mesh_surface_patch.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "f5df3fc0",
   "metadata": {},
   "outputs": [],
   "source": [
    "import trimesh"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "c8f80426",
   "metadata": {},
   "outputs": [],
   "source": [
    "from meshplot import plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "a5c1c774",
   "metadata": {},
   "outputs": [],
   "source": [
    "mesh = trimesh.load_mesh('./model_manifold.obj')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "7d10de4a",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/thor/anaconda3/envs/iglenv/lib/python3.6/site-packages/traittypes/traittypes.py:101: UserWarning: Given trait value dtype \"float32\" does not match required type \"float64\". A coerced copy has been created.\n",
      "  np.dtype(self.dtype).name))\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "d0d7a4e425fc4e45b9953172e532b077",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Renderer(camera=PerspectiveCamera(children=(DirectionalLight(color='white', intensity=0.6, position=(1.5497207…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<meshplot.Viewer.Viewer at 0x7f40912363c8>"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plot(mesh.vertices)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "011c3d84",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(32900, 3)"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mesh.vertices.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "67bf2c0e",
   "metadata": {},
   "outputs": [],
   "source": [
    "import igl"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "ff677b90",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(728, 3)\n"
     ]
    }
   ],
   "source": [
    "_,v_,f_,_,_ = igl.decimate(mesh.vertices,mesh.faces, 1500)\n",
    "print(v_.shape)\n",
    "# v_[:,0] = (v_[:,0] - v_[:,0].min()) / (v_[:,0].max() - v_[:,0].min())\n",
    "# v_[:,1] = (v_[:,1] - v_[:,1].min()) / (v_[:,1].max() - v_[:,1].min())\n",
    "# v_[:,2] = (v_[:,2] - v_[:,2].min()) / (v_[:,2].max() - v_[:,2].min())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "eefa9c7a",
   "metadata": {},
   "outputs": [],
   "source": [
    "mesh = trimesh.Trimesh(v_,f_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "c9990ac8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "a9a2e014319b442cb97b82cdd4077181",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Renderer(camera=PerspectiveCamera(children=(DirectionalLight(color='white', intensity=0.6, position=(0.0028013…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<meshplot.Viewer.Viewer at 0x7f407de78710>"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plot(mesh.vertices)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "5648d0cb",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "6e264903",
   "metadata": {},
   "outputs": [],
   "source": [
    "normal = np.random.randn(3)\n",
    "normal /= np.linalg.norm(normal)\n",
    "point = np.random.randn(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "3e2eda2d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Requirement already satisfied: triangle in /home/thor/anaconda3/envs/iglenv/lib/python3.6/site-packages (20200424)\r\n",
      "Requirement already satisfied: numpy in /home/thor/anaconda3/envs/iglenv/lib/python3.6/site-packages (from triangle) (1.19.4)\r\n"
     ]
    }
   ],
   "source": [
    "!pip install triangle"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "9d367f4d",
   "metadata": {},
   "outputs": [],
   "source": [
    "bbox_mesh = trimesh.Trimesh()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "1bf094ed",
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_box_mesh(v):\n",
    "    v1 = 0\n",
    "    v2 = 1\n",
    "    v3 = 2\n",
    "    v4 = 3\n",
    "    v5 = 4\n",
    "    v6 = 5\n",
    "    v7 = 6\n",
    "    v8 = 7\n",
    "\n",
    "    bbox_tri = np.array([[v1, v2, v5], [v2, v5, v6], [v2, v3, v6], \\\n",
    "                    [v6, v7, v3], [v3, v7, v8], [v8, v4, v3], [v4, v8, v5],\\\n",
    "                   [v5, v4, v1], [v5, v6, v8], [v8, v6, v7], [v2, v4, v1], [v2, v4, v3]\n",
    "                   ])\n",
    "\n",
    "    zmin = v[:,-1].min() + 0.1 * v[:,-1].min()\n",
    "    zmax = v[:,-1].max() + 0.1 * v[:,-1].max()\n",
    "    ymin = v[:,-2].min() + 0.1 * v[:,-2].min() \n",
    "    ymax = v[:, -2].max() + 0.1 * v[:, -2].max() \n",
    "    xmin = v[:, -3].min() + 0.1 * v[:, -3].min() \n",
    "    xmax = v[:, -3].max() + v[:, -3].max()\n",
    "\n",
    "    bbox_verts = np.array([[xmin, ymin, zmax],[xmax,ymin,zmax],[xmax, ymin, zmin],\\\n",
    "                  [xmin, ymin, zmin], [xmin, ymax, zmax], [xmax, ymax, zmax],\\\n",
    "                  [xmax, ymax, zmin], [xmin, ymax, zmin]])\n",
    "    \n",
    "    return bbox_verts, bbox_tri"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "68abd641",
   "metadata": {},
   "outputs": [],
   "source": [
    "bbox_verts, bbox_tri = generate_box_mesh(mesh.vertices)\n",
    "\n",
    "bbox_mesh = trimesh.Trimesh(bbox_verts, bbox_tri)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "7d3705f4",
   "metadata": {},
   "outputs": [],
   "source": [
    "from meshplot import plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "4755e982",
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(48, 2, 3)\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "6d2a0451c57448ae945e51df3ed844f6",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Renderer(camera=PerspectiveCamera(children=(DirectionalLight(color='white', intensity=0.6, position=(0.0028013…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "normal = np.random.randn(3)\n",
    "normal /= np.linalg.norm(normal)\n",
    "point = np.random.randn(3)\n",
    "\n",
    "point = np.array([-0.54905429,  0.14446151, -0.16177154])\n",
    "normal = np.array([-0.19714132, -0.87347182,  0.44517669])\n",
    "polyline, triangles_edge = trimesh.intersections.mesh_plane(mesh, \n",
    "                                                           plane_origin= point, \n",
    "                                                           plane_normal= normal, \n",
    "                                                           return_faces=True)\n",
    "\n",
    "print(polyline.shape)\n",
    "m = plot(mesh.vertices)\n",
    "# m.add_mesh(bbox_verts, bbox_tri)\n",
    "m.add_points(polyline.reshape(-1,3), c='blue')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "5890415b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([-0.54905429,  0.14446151, -0.16177154]),\n",
       " array([-0.19714132, -0.87347182,  0.44517669]))"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "point,normal\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "208ad1b5",
   "metadata": {},
   "outputs": [],
   "source": [
    "bbox_mesh = trimesh.Trimesh()\n",
    "bbox_mesh.vertices = bbox_verts\n",
    "bbox_mesh.faces  = bbox_tri"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "e897714b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# def unordered_to_triangles(points):\n",
    "#     triangles = [[points[0], points[1], points[2]], [points[1], points[2],points[3]]]\n",
    "#     return np.array(triangles)\n",
    "\n",
    "def unordered_to_triangles(points):\n",
    "    triangles = [[points[0], points[1], points[2]], [points[0], points[1],points[3]],[points[0], points[1], points[2]], [points[1], points[2],points[3]]]\n",
    "    return np.array(triangles)\n",
    "def unordered_to_triangles(points):\n",
    "    triangles = [[points[0], points[2], points[3]], [points[1], points[2], points[3]]]\n",
    "    return np.array(triangles)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "3cd279f7",
   "metadata": {},
   "outputs": [],
   "source": [
    "import random"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "id": "f1670a9d",
   "metadata": {},
   "outputs": [],
   "source": [
    "def split_mesh(mesh, plane_normal=None, plane_origin=None):\n",
    "    \"\"\"\n",
    "    Splits mesh by intersection with a plane, \n",
    "    returns closed mesh for positive and negative side of plane \n",
    "    \"\"\"\n",
    "#     plane_normal = (plane_normal)\n",
    "#     plane_normal = plane_normal\n",
    "#     plane_origin = plane_origin\n",
    "    done = False\n",
    "    while not done:\n",
    "        if plane_normal is  None and plane_origin is  None:\n",
    "            plane_normal_ = np.random.randn(3)\n",
    "            plane_normal_ /= np.linalg.norm(plane_normal_)\n",
    "#             plane_origin_ = np.random.randn(3)\n",
    "            plane_origin_ = np.mean(mesh.vertices, 0)\n",
    "#             plane_origin_ = mesh.vertices[random.randint(0, len(mesh.vertices)-1)]\n",
    "        else:\n",
    "            plane_normal_ = plane_normal\n",
    "            plane_origin_ = plane_origin\n",
    "        polyline, triangles_edge = trimesh.intersections.mesh_plane(mesh, \n",
    "                                                           plane_origin= plane_origin_, \n",
    "                                                           plane_normal= plane_normal_, \n",
    "                                                           return_faces=True)\n",
    "        \n",
    "#         print(polyline.shape)\n",
    "        if polyline.shape[0]>0:\n",
    "            print(plane_normal_, plane_origin_)\n",
    "            print(polyline.shape)\n",
    "            done = True\n",
    "            break\n",
    "        elif plane_normal is not None and plane_origin is not None and len(polyline)==0:\n",
    "            print('Plane does not pass')\n",
    "            print(plane_normal_, plane_origin_)\n",
    "         \n",
    "                                                                        \n",
    "            return None, None\n",
    "        \n",
    "    print('found')\n",
    "    plane_normal = plane_normal_\n",
    "    plane_origin = plane_origin_\n",
    "    \n",
    "    vertices_negative = []\n",
    "    vertices_positive = []\n",
    "    for vertex_id, vertex in enumerate(mesh.vertices):\n",
    "        # TODO: add threshold\n",
    "        signed_distance = np.dot(plane_normal, np.subtract(vertex, plane_origin))\n",
    "        if signed_distance < 0:\n",
    "            vertices_negative.append(vertex_id)\n",
    "        else:\n",
    "            vertices_positive.append(vertex_id)\n",
    "    \n",
    "    triangles_negative = []\n",
    "    triangles_positive = []\n",
    "    # For each triangle check how many points on either side of the plane\n",
    "    for triangle in mesh.faces:\n",
    "        triangle_negative_check = [vertex_id in vertices_negative for vertex_id in triangle]\n",
    "        # If all points on the negative side this triangle is not affected\n",
    "        if all(triangle_negative_check):\n",
    "            triangles_negative.append(np.array(mesh.vertices[triangle]))\n",
    "        elif any(triangle_negative_check):\n",
    "            # Get section line for this triangle on edge\n",
    "            section = polyline[np.all(np.isin(mesh.faces[triangles_edge], np.array(triangle)), axis=1)][0]\n",
    "            assert section.shape == (2,3)\n",
    "            # If two points on negative side\n",
    "            if sum(triangle_negative_check) == 2:\n",
    "                vertex_1, vertex_2 = mesh.vertices[triangle[triangle_negative_check]]\n",
    "                \n",
    "                triangles_negative.extend(unordered_to_triangles([section[0], section[1], vertex_1, vertex_2]))\n",
    "                vertex_3 = mesh.vertices[triangle[np.logical_not(triangle_negative_check)]]\n",
    "                triangles_positive.append(np.vstack([section[0], section[1], vertex_3]))\n",
    "            elif sum(triangle_negative_check) == 1:\n",
    "                vertex_3 = mesh.vertices[triangle[triangle_negative_check]]\n",
    "                triangles_negative.append(np.vstack([section[0], section[1], vertex_3]))\n",
    "                vertex_1, vertex_2 = mesh.vertices[triangle[np.logical_not(triangle_negative_check)]]\n",
    "#                 print(section[0], section[1], vertex_1, vertex_2)\n",
    "                triangles_positive.extend(unordered_to_triangles([section[0], section[1], vertex_1, vertex_2]))\n",
    "        # If all points on the positive side this triangle is not affected\n",
    "        else:\n",
    "            triangles_positive.append(np.array(mesh.vertices[triangle]))\n",
    "            \n",
    "    # Get triangulation of the split surface\n",
    "    vertices_splitsurface = []\n",
    "    for a, b in polyline:\n",
    "        for vertex in [a,b]:\n",
    "            if tuple(vertex) not in vertices_splitsurface:\n",
    "                vertices_splitsurface.append(tuple(vertex))\n",
    "\n",
    "    triangles_splitsurface = unordered_to_triangles(vertices_splitsurface)\n",
    "    \n",
    "    # Add triangles of split surface to both the positive and negative side\n",
    "    triangles_negative.extend(triangles_splitsurface)\n",
    "    triangles_positive.extend(triangles_splitsurface)\n",
    "    \n",
    "    print(plane_normal_, plane_origin_)\n",
    "    \n",
    "    return np.array(triangles_positive), np.array(triangles_negative)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "39089067",
   "metadata": {},
   "source": [
    "### Slice mesh with heuristics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "id": "763dc10d",
   "metadata": {},
   "outputs": [],
   "source": [
    "def split_mesh(mesh, plane_normal=None, plane_origin=None):\n",
    "    \"\"\"\n",
    "    Splits mesh by intersection with a plane, \n",
    "    returns closed mesh for positive and negative side of plane \n",
    "    \"\"\"\n",
    "#     plane_normal = (plane_normal)\n",
    "#     plane_normal = plane_normal\n",
    "#     plane_origin = plane_origin\n",
    "    done = False\n",
    "    while not done:\n",
    "        if plane_normal is  None and plane_origin is  None:\n",
    "#             plane_normal_ = np.random.randn(3)\n",
    "#             plane_normal_ /= np.linalg.norm(plane_normal_)\n",
    "# #             plane_origin_ = np.random.randn(3)\n",
    "            plane_origin_ = np.mean(mesh.vertices, 0)\n",
    "            idx1 = random.randint(0, pos_mesh.vertices.shape[0]-1)\n",
    "            idx2 = random.randint(0, pos_mesh.vertices.shape[0]-1)\n",
    "            v1 = pos_mesh.vertices[idx1]\n",
    "            v2 = pos_mesh.vertices[idx2]\n",
    "            v_1 = (v1 - v2)/ np.linalg.norm(v1 - v2)\n",
    "            idx1 = random.randint(0, pos_mesh.vertices.shape[0]-1)\n",
    "            idx2 = random.randint(0, pos_mesh.vertices.shape[0]-1)\n",
    "            v1 = pos_mesh.vertices[idx1]\n",
    "            v2 = pos_mesh.vertices[idx2]\n",
    "            v_2 = (v1- v2 )/ np.linalg.norm(v1 - v2)\n",
    "            plane_normal_ = np.cross(v_1, v_2)\n",
    "#             plane_origin_ = mesh.vertices[random.randint(0, len(mesh.vertices)-1)]\n",
    "        else:\n",
    "            plane_normal_ = plane_normal\n",
    "            plane_origin_ = plane_origin\n",
    "        polyline, triangles_edge = trimesh.intersections.mesh_plane(mesh, \n",
    "                                                           plane_origin= plane_origin_, \n",
    "                                                           plane_normal= plane_normal_, \n",
    "                                                           return_faces=True)\n",
    "        \n",
    "#         print(polyline.shape)\n",
    "        if polyline.shape[0]>0:\n",
    "            print(plane_normal_, plane_origin_)\n",
    "            print(polyline.shape)\n",
    "            done = True\n",
    "            break\n",
    "        elif plane_normal is not None and plane_origin is not None and len(polyline)==0:\n",
    "            print('Plane does not pass')\n",
    "            print(plane_normal_, plane_origin_)\n",
    "         \n",
    "                                                                        \n",
    "            return None, None\n",
    "        \n",
    "    print('found')\n",
    "    plane_normal = plane_normal_\n",
    "    plane_origin = plane_origin_\n",
    "    \n",
    "    vertices_negative = []\n",
    "    vertices_positive = []\n",
    "    for vertex_id, vertex in enumerate(mesh.vertices):\n",
    "        # TODO: add threshold\n",
    "        signed_distance = np.dot(plane_normal, np.subtract(vertex, plane_origin))\n",
    "        if signed_distance < 0:\n",
    "            vertices_negative.append(vertex_id)\n",
    "        else:\n",
    "            vertices_positive.append(vertex_id)\n",
    "    \n",
    "    triangles_negative = []\n",
    "    triangles_positive = []\n",
    "    # For each triangle check how many points on either side of the plane\n",
    "    for triangle in mesh.faces:\n",
    "        triangle_negative_check = [vertex_id in vertices_negative for vertex_id in triangle]\n",
    "        # If all points on the negative side this triangle is not affected\n",
    "        if all(triangle_negative_check):\n",
    "            triangles_negative.append(np.array(mesh.vertices[triangle]))\n",
    "        elif any(triangle_negative_check):\n",
    "            # Get section line for this triangle on edge\n",
    "            section = polyline[np.all(np.isin(mesh.faces[triangles_edge], np.array(triangle)), axis=1)][0]\n",
    "            assert section.shape == (2,3)\n",
    "            # If two points on negative side\n",
    "            if sum(triangle_negative_check) == 2:\n",
    "                vertex_1, vertex_2 = mesh.vertices[triangle[triangle_negative_check]]\n",
    "                \n",
    "                triangles_negative.extend(unordered_to_triangles([section[0], section[1], vertex_1, vertex_2]))\n",
    "                vertex_3 = mesh.vertices[triangle[np.logical_not(triangle_negative_check)]]\n",
    "                triangles_positive.append(np.vstack([section[0], section[1], vertex_3]))\n",
    "            elif sum(triangle_negative_check) == 1:\n",
    "                vertex_3 = mesh.vertices[triangle[triangle_negative_check]]\n",
    "                triangles_negative.append(np.vstack([section[0], section[1], vertex_3]))\n",
    "                vertex_1, vertex_2 = mesh.vertices[triangle[np.logical_not(triangle_negative_check)]]\n",
    "#                 print(section[0], section[1], vertex_1, vertex_2)\n",
    "                triangles_positive.extend(unordered_to_triangles([section[0], section[1], vertex_1, vertex_2]))\n",
    "        # If all points on the positive side this triangle is not affected\n",
    "        else:\n",
    "            triangles_positive.append(np.array(mesh.vertices[triangle]))\n",
    "            \n",
    "    # Get triangulation of the split surface\n",
    "    vertices_splitsurface = []\n",
    "    for a, b in polyline:\n",
    "        for vertex in [a,b]:\n",
    "            if tuple(vertex) not in vertices_splitsurface:\n",
    "                vertices_splitsurface.append(tuple(vertex))\n",
    "\n",
    "    triangles_splitsurface = unordered_to_triangles(vertices_splitsurface)\n",
    "    \n",
    "    # Add triangles of split surface to both the positive and negative side\n",
    "    triangles_negative.extend(triangles_splitsurface)\n",
    "    triangles_positive.extend(triangles_splitsurface)\n",
    "    \n",
    "    print(plane_normal_, plane_origin_)\n",
    "    \n",
    "    return np.array(triangles_positive), np.array(triangles_negative)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "id": "5df3c229",
   "metadata": {},
   "outputs": [],
   "source": [
    "np.random.seed(123)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "id": "163c0e15",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 0.7270126   0.29988907 -0.61767242] [ 0.00364515 -1.25566869 -0.55193688]\n",
      "(79, 2, 3)\n",
      "found\n",
      "[ 0.7270126   0.29988907 -0.61767242] [ 0.00364515 -1.25566869 -0.55193688]\n"
     ]
    }
   ],
   "source": [
    "pos_mesh, neg_mesh = split_mesh(mesh, normal, point)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "id": "a7147fad",
   "metadata": {},
   "outputs": [],
   "source": [
    "normal = np.array([ 0.7270126   , 0.29988907,  -0.61767242] )\n",
    "point = np.array([ 0.00364515, -1.25566869 , -0.55193688])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "id": "d6dd7f23",
   "metadata": {},
   "outputs": [],
   "source": [
    "pos_mesh = np.array(pos_mesh)\n",
    "neg_mesh = np.array(neg_mesh)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "id": "f10aaef0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "ef1d3b0899b34ec99d0b755044899ccd",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Renderer(camera=PerspectiveCamera(children=(DirectionalLight(color='white', intensity=0.6, position=(0.0820813…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 143,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m = plot(pos_mesh.reshape(-1, 3),c='blue')\n",
    "m.add_points(neg_mesh.reshape(-1,3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "efbfdc30",
   "metadata": {},
   "outputs": [],
   "source": [
    "import math"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "c08c43c4",
   "metadata": {},
   "outputs": [],
   "source": [
    "# mesh_pos = trimesh.Trimesh(pos_mesh.reshape(-1,3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "id": "a7611f01",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_verts_faces(triangles):\n",
    "    v = np.unique(triangles.reshape(-1,3),axis=0)\n",
    "    faces = []\n",
    "    for triangle in triangles:\n",
    "        tri_indices = []\n",
    "        for vertex in triangle:\n",
    "            for index, v_ in enumerate(v):\n",
    "                if (v_ == vertex).all():\n",
    "            \n",
    "                    tri_indices.append(index)\n",
    "        faces.append(tri_indices)\n",
    "    return v, np.array(faces)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "id": "0b978d54",
   "metadata": {},
   "outputs": [],
   "source": [
    "v, faces = get_verts_faces(pos_mesh)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "id": "88407092",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[189, 157, 204],\n",
       "       [157, 189, 188],\n",
       "       [188, 139, 157],\n",
       "       ...,\n",
       "       [498, 505, 500],\n",
       "       [  9,   1,   8],\n",
       "       [  7,   1,   8]])"
      ]
     },
     "execution_count": 146,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "faces"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "id": "0c20a135",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/thor/anaconda3/envs/iglenv/lib/python3.6/site-packages/traittypes/traittypes.py:101: UserWarning: Given trait value dtype \"float32\" does not match required type \"float64\". A coerced copy has been created.\n",
      "  np.dtype(self.dtype).name))\n",
      "/home/thor/anaconda3/envs/iglenv/lib/python3.6/site-packages/traittypes/traittypes.py:101: UserWarning: Given trait value dtype \"uint32\" does not match required type \"float64\". A coerced copy has been created.\n",
      "  np.dtype(self.dtype).name))\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "1306ee8afa5a4d5b81293a60d16d47a8",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Renderer(camera=PerspectiveCamera(children=(DirectionalLight(color='white', intensity=0.6, position=(0.0028013…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<meshplot.Viewer.Viewer at 0x7f402dd73400>"
      ]
     },
     "execution_count": 147,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plot(mesh.vertices, mesh.faces)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "id": "999c1608",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "063c8c9c6b8c4706902a95666d918535",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Renderer(camera=PerspectiveCamera(children=(DirectionalLight(color='white', intensity=0.6, position=(0.0820813…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "p = plot(v,faces)\n",
    "p.add_lines(v[faces[:,0]], v[faces[:,1]], shading={\"line_color\": \"red\"});"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "id": "fa506182",
   "metadata": {},
   "outputs": [],
   "source": [
    "patches = []\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "id": "fd2e4700",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-0.70913009  0.65381653 -0.26392891] [-0.00260612  0.011225   -0.00451322]\n",
      "(100, 2, 3)\n",
      "found\n",
      "[-0.70913009  0.65381653 -0.26392891] [-0.00260612  0.011225   -0.00451322]\n",
      "[-0.05565712  0.01538727 -0.06430389]\n",
      "(67, 2, 3)\n"
     ]
    }
   ],
   "source": [
    "pos_mesh, neg_mesh = split_mesh(mesh)\n",
    "verts, faces  = get_verts_faces(pos_mesh)\n",
    "pos_mesh = trimesh.Trimesh(verts, faces)\n",
    "# pos_mesh = trimesh.Trimesh((pos_mesh.reshape(-1,3)))\n",
    "# neg_mesh = trimesh.Trimesh(neg_mesh.reshape(-1,3))\n",
    "# patches.append(pos_mesh)\n",
    "# patches.append(neg_mesh)\n",
    "plane_origin_ = pos_mesh.vertices.mean(0)\n",
    "print(plane_origin_)\n",
    "idx1 = random.randint(0, pos_mesh.vertices.shape[0]-1)\n",
    "idx2 = random.randint(0, pos_mesh.vertices.shape[0]-1)\n",
    "v1 = pos_mesh.vertices[idx1]\n",
    "v2 = pos_mesh.vertices[idx2]\n",
    "v_1 = (v1 - v2)/ np.linalg.norm(v1 - v2)\n",
    "idx1 = random.randint(0, pos_mesh.vertices.shape[0]-1)\n",
    "idx2 = random.randint(0, pos_mesh.vertices.shape[0]-1)\n",
    "v1 = pos_mesh.vertices[idx1]\n",
    "v2 = pos_mesh.vertices[idx2]\n",
    "v_2 = (v1- v2 )/ np.linalg.norm(v1 - v2)\n",
    "\n",
    "cross_ = np.cross(v_1, v_2)\n",
    "# plane_normal_ = np.random.randn(3)\n",
    "plane_normal_ = cross_\n",
    "polyline, triangles_edge = trimesh.intersections.mesh_plane(pos_mesh,\\\n",
    "                    plane_origin=plane_origin_,  plane_normal= cross_, return_faces=True)\n",
    "\n",
    "print(polyline.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "id": "089db8fb",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(463, 3)"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pos_mesh.vertices.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "id": "f19e682a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "df5d8779c13d47d092c3e9b6fbdf2026",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Renderer(camera=PerspectiveCamera(children=(DirectionalLight(color='white', intensity=0.6, position=(-0.094889…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<meshplot.Viewer.Viewer at 0x7f4037dff048>"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plot(pos_mesh.vertices)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "id": "05d35ef6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0, 3)"
      ]
     },
     "execution_count": 123,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pos_mesh.faces.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "id": "90ad6e41",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0, 2, 3)"
      ]
     },
     "execution_count": 121,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "polyline.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "id": "bc8fd8d0",
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "id": "6684664d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 0.92, 'simple 3D scatter plot')"
      ]
     },
     "execution_count": 113,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjwAAAGKCAYAAAAIdJtvAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOy9d3hc9Z3v/zrTZzTqsiyrWLIkd2ObYmzDElqoSWjZu0DCJrlZEpJAliz5bUiy7AY2zxLIJjdl2QAJEBIWlnKTUBLMLgklwBrTjHG3iq3ey2iKppzy+0P3HGakGdUjzbH8fT1PnuDRme98ZzQ6530+7S1pmoZAIBAIBALBYsaW7Q0IBAKBQCAQzDdC8AgEAoFAIFj0CMEjEAgEAoFg0SMEj0AgEAgEgkWPEDwCgUAgEAgWPY4pfi5auAQCgUAgEBwvSJl+ICI8AoFAIBAIFj1C8AgEAoFAIFj0CMEjEAgEAoFg0SMEj0AgEAgEgkWPEDwCgUAgEAgWPULwCAQCgUAgWPQIwSMQCAQCgWDRIwSPQCAQCASCRY8QPAKBQCAQCBY9QvAIBAKBQCBY9AjBIxAIBAKBYNEjBI9AIBAIBIJFjxA8AoFAIBAIFj1C8AgEAoFAIFj0CMEjEAgEAoFg0SMEj0BgAe68806uv/76eVn7nHPO4YEHHpiXtQVjfO5zn+O2227L9jYEAsEkCMEjEFiAb3/725YTJf39/Zx55pkUFxdTUFDA9u3beeONN4yf33777TidTnJzc8nNzWXVqlXcdNNNdHV1Leg+JUmisbHR+Pcrr7xCZWXlgu5hJozfr0AgWBiE4BEIBGnx+/089NBD9PX1MTQ0xK233sonPvEJZFk2jrn66qsJBoMMDg7yu9/9ju7ubk499dQFFz1mkvz+BALB4kEIHoFgAbn77rupqKggNzeX1atX86c//QkYi5Zcd911ABw7dgxJkvjlL39JVVUVhYWF3Hfffbz99tts3LiRgoICbrrpJmPNhx9+mDPPPJOvfvWr5Ofns2bNGmPddDz00EOsXbuWwsJCLrroIlpaWtIe5/F4WL16NTabDU3TsNvtDA0NMTg4OOFYp9PJ+vXreeKJJ1iyZAk//OEP067Z2NjI2WefTX5+PiUlJVx99dXGz/bv388FF1xAUVERS5cu5c477wTgrbfeYvv27RQUFLBs2TJuuukm4vE4AB/5yEcA2LRpE36/n1/96ldccskldHZ24vf78fv9dHZ2oqoqd911F3V1dRQXF/NXf/VXxvvQP+8HH3yQ5cuXc955503Ytx41uvPOOykpKaGmpoZHH30042f8i1/8gvr6eoqKirjsssvo7OxMu98nnngi4xoCgcBchOARCBaIw4cPc8899/D2228TDAb5r//6L2pqajIev2vXLhoaGnjiiSf42te+xr/8y7/wxz/+kf379/Pkk0/y6quvphxbW1tLf38/d9xxB1dddVVaYfL0009z55138tvf/pa+vj7OOussrr322kn3vXHjRjweD5dddhnXX389paWlGY+12+1cfvnlvPbaa2l//o//+I9ceOGFDA0N0d7ezle/+lUAgsEgH/3oR7n44ovp7OyksbGR888/31jzRz/6Ef39/ezcuZM//elP/OxnPwPgz3/+MwB79uwhFArx2c9+lh07dlBeXk4oFCIUClFeXs5Pf/pTnn76aV599VU6OzspLCzkxhtvTNnbq6++ysGDB/mv//qvtHvv7u6mv7+fjo4OfvWrX/HFL36Rw4cPTzjupZde4lvf+hZPPvkkXV1dVFdXc80116Tdb7LgEwgE84sQPALBAmG324nFYhw4cIBEIkFNTQ11dXUZj//Hf/xHPB4PF154ITk5OVx77bWUlpZSUVHBWWedxe7du41jS0tL+drXvobT6eTqq69m9erV/OEPf5iw5v3338+3vvUt1q5di8Ph4Nvf/jbvv/9+xigPwAcffMDIyAiPPfYYf/EXfzHl+ywvL08rtmAsEtTS0kJnZycej8dY7/e//z1lZWV8/etfx+PxkJuby9atWwE49dRT2bZtGw6Hg5qaGm644YYUsTcd7r//fv7lX/6FyspK3G43t99+O//3//7flPTV7bffTk5ODl6vN+M63/3ud3G73Zx99tl87GMf48knn5xwzKOPPsrnP/95TjnlFNxuN9/73vfYuXMnx44dm9GeBQKBuQjBIxAsEPX19fz4xz/m9ttvp7S0lGuuucZIdaRj6dKlxn97vd4J/w6FQsa/KyoqkCTJ+Hd1dXXatVtaWrj55pspKCigoKCAoqIiNE2jo6Nj0r17PB6uvfZa7rrrLvbs2TPpsR0dHRQVFaX92fe//300TeP0009n/fr1PPTQQwC0tbVlFH9Hjhzh4x//OGVlZeTl5fHtb3+b/v7+SfcwnpaWFq688krjfa9duxa73U5PT49xTFVV1aRrFBYWkpOTY/w702fc2dlJdXW18W+/309xcfGUn7FAIJhfhOARCBaQT33qU7z++uu0tLQgSRK33nqrKet2dHSgaZrx79bWVsrLyyccV1VVxf3338/w8LDxv9HRUc4444xpvU4ikaC5uTnjz1VV5bnnnuOss85K+/OysjJ+8Ytf0NnZyf33389XvvIVGhsbqaqqoqmpKe1zvvzlL7NmzRoaGhoYGRnhzjvvTHmv40kWfjpVVVXs2LEj5X1Ho1EqKiomfV4yQ0NDhMNh49+ZPuPy8vKUiFk4HGZgYCDltQQCwcIjBI9AsEAcPnyYl156iVgshsfjwev1YrfbZ7yOpmmoqoqmacaFv7e3l5/+9KckEgmeeuopDh48yKWXXjrhuV/60pf43ve+x/79+wEIBAI89dRTaV/nzTff5PXXXycejzM6Osrdd99NT0+PkWpKJpFIcPDgQa699lq6u7u55ZZb0q751FNP0d7eDoxFTCRJwm638/GPf5zu7m5+/OMfE4vFCAaD7Nq1Cxir78nLy8Pv93Po0CHuvffelDWXLl2aIsKWLl3KwMAAgUAg5X3/wz/8gyFE+vr6eOaZZ9J/wJPwne98h3g8zmuvvcbvf/97/tf/+l8TjvnUpz7FL3/5S95//31isRjf/va32bp1q1GvNX6/AoFgYRCCRyBYIGKxGN/85jcpKSmhrKyM3t5eoxNpOmiaRiKRIBqNIssysViMQCBANBply5YtHDp0iJKSEv7hH/6Bp556iuLi4glrXHnlldx6661cc8015OXlsWHDBnbs2JFxvzfeeCPFxcVUVFTw/PPP84c//CElqvHEE0/g9/spKCjgsssuo7i4mHfffTdt5APg7bffZuvWrfj9fi677DJ+8pOfsGLFCnJzc3nxxRd57rnnKCsrY+XKlbz88ssA/OAHP+Cxxx4jNzeXL3zhCxMKfW+//XY++9nPUlBQwJNPPsmaNWu49tprqa2tpaCggM7OTm6++WYuu+wyLrzwQnJzc9m2bZshqKZLWVkZhYWFlJeX8+lPf5r77ruPNWvWTDju/PPP57vf/S6f/OQnWbZsGU1NTTz++OMZ9ysQCBYGabLQMDDpDwUCwfyjaRqyLKcU2CYSCSRJQtM0/uM//oNf//rXvPDCC8bPJUnCZrPhcDiw2+3YbDbsdvuUaRtBel555RWuu+46IzolEAgsS8aTnGMhdyEQCKaPHtFRFAUYEzG6yNHRhY2eGkp+rqqqxGKxlMd04ZMshPTnCwQCwWJGCB6BwGIkR3R27tzJGWecMWNBoouj8esCKIqCLMtommYcowsh/X9CCAkEgsWGSGkJBBZhfOpKkiRD8Iw/Lh6PmyZG9HNAchG0znghpKfFhBASCAQWRaS0BAKrkk7oLKSg0F8rXURIT6vpAqurq4uioiJ8Pt+EiJAQQgKBwMoIwSMQZIlsC52pSLefkZERCgoKUFXVqC1KPj65Rig5LWal9yUQCE5MhOARCBYYqwud6WCzTZxooRdKK4pimHsCRkG1LoKSI0ICgUCwUAjBIxAsEItB6Ey2X1EoLRAIrIwQPALBPLMYhE4yUzQ6pDBZfRCALMskEomUnwkhJBAI5gMheASCecIsoZMcFVksTCWEkguldZIHKYpCaYFAMFOE4BEITEYXOg0NDaxYsWJOF2V90KBVLurjBx/Ox/rABI8xvWMsHo/z3nvvccoppxg/0wWQKJQWCASTIQSPQGAS4yM6PT091NXVzWnN+RYYMyVbImK8gNEF0WSF0sJaQyAQJCMEj0AwR+azRieT4MnmhdtqAizdZyGsNQQCwXiE4BEIZokeWcgkdMxIR9lsNksJjOMF0TEmEAjGIwSPQDBDphI6OpIkoarqhHqUmSBSWuZhRseYsNYQCI5fhOARCKbJdIWOjhnRGV00jSebhcxWEmBmMBNrDZ2RkRFKSkpEx5hAcBwhBI9AMAUzFTo6mcTKTBARnuwxWX1QQ0MDeXl5E44X1hoCgXURgkcgyMBshY6OzWZbdIIHFl+EZ6bo34N0rfPCWkMgsC5C8AgE41AUhUQiYVzYZ3uHboZYmWyNbKS1xEU6M6JQWiCwNkLwCAT/D1VVkWWZWCzG7t27Of300+fcYTXXCE+6OiD9wpqtSMuJHuGZCcJaQyCwDkLwCE54dKGjKAowNtROVdU5X2DMivDMVTQJzMUMwSesNQSChUcIHsEJy3ihkxw5MeOithhreKy2n8XGdKw19LRYX18ffr8fv98vCqUFgmkgBI/ghCOT0NGZ7ynJc11D0zSGhoZwOp34fD5sNtucXkMwM7JVOzX+NQOBAB6PR1hrCATTRAgewQnDVELHbMyO8GiaRm9vL83Nzfh8PhRFYXR0FICcnBxycnKMO36XyzUv701EeKzjXq9bZaQTvMJaQyCYiBA8gkXPQgsdHbMiPIqi0NvbS1NTE/n5+Zx88slGMbNe4xOJRAiFQgwNDdHe3k4sFsPhcKSIoJycHBwO8Sc/V6wi+CarMxMdYwLBRMTZT7BoyZbQ0ZlrhEfTNKLRKIcOHaKgoIDNmzfj9XoBUtIXNpvNEDXJJBIJwuEwoVCI7u5uQqEQiqLgdrsNAeT3+2eUFsv2BdAqYiPbnwN8GLGZLsJaQ3CiIwSPYNGRbaGjM9sIj6ZpDA4O0tjYSCKRoKamhsrKyhmv43Q6KSgooKCgIGXtWCxGKBQiHA4zMDBAJBIBwOfzpUSE3G53xknDJzJWSmmZsY/ZWGuMF0GiUFpwPCAEj2DRoKoqg4ODOBwO42KdzRPwbCI8utDxeDxs2LCBzs5OXC7XhONmK6YkScLj8eDxeCgpKTEeT06LBQIBOjo6iMVi2O32lGiQLiJPZKwi+OZbeE1mraEXSgMcPnyYVatWGWkw0TEmsCpC8AiOe1RVJZFIoKoqHR0dlJSUGKmfbDITUTI0NERjYyNOp5N169YZ6amFKhLOlBaTZdlIi/X09DAwMEBvby+dnZ2GCNILpk+kbjErXMBVVc3KZz5ewITDYRwOh7DWEFgeIXgExy3JQgc+PLGaNahvrnfQ04nwDA8P09jYiN1uZ82aNeTm5qb8PNtdUQ6Hg/z8fPLz8wE4duwYXq+XgoICQqEQoVCIwcFBwuEwAF6vN6VI2uPxLLoL22JLaZmFKJQWWB0heATHHemETvJJ1AzBo68zfgDcTJhMrAQCARobG5EkiVWrVk1w3h6/D6ugf85utxu3201xcbHxM1VVGR0dJRQKMTIyQmdnJ9FoFLvdnhIN8vv9OJ3OWb2+FdJJVhEaVtnHZAhrDYGVEIJHcNwwmdDRMSvCY4bgSSdWgsEgDQ0NaJpGfX29ETnJRLYjPDPBZrMZ6a1k9LRYOBymr6+Po0ePIssyLpdrQrfYdD7vbF/4rCI0spXSMgNhrSHIBkLwCCzPdISOjtkRnrmQLFaCwSBNTU3Iskx9fX1K59R017ACs9nP+LQYYNgk6PVBbW1tRCIRNE3D6/WmRIS8Xq+4qKXBKsLLTGZiraGjCyBRKC2YCiF4BJYkuSV2OkJHx2azmdJJZJbTeSgUYs+ePcTjcerq6igqKprRGlYTPGYhSZKRFkv+TDRNM9JiwWCQ7u5uRkdHU6JHsiwTj8fTdq8tBFYRGlbZx0IwnY6xvXv3UlNTY3RoCmsNwXiE4BFYitkKHR2bzTahJmA26JOMZ0s4HKa9vZ1oNMqGDRtSal1mgtUEz3xfMCRJwufz4fP5KC0tNR5XFIVwOEwwGESWZfbv308ikcDpdKakxXJycuaUhpwOVhIa2d5HtuvLks8N8XjcEDjCWkOQDiF4BJZgrkJHx6waHt2yYaZEIhGampqIRCIUFRUhSdKsxQ6YJ+DMJBsCzG63k5eXh9/vp6uri5NPPhkYu8jpQxQ7OjoIh8OoqpqSFvP7/aamxawkQLPNTKc9zyeKohhiV3SMCdIhBI8gq+hCZ2hoiHg8TkFBwZzy79mq4RkdHaW5uZlgMEhdXR0lJSX09fURCATmtI9MEZ5snYitdgFwuVwUFRWlTYslzw/S02I+ny+lbX62JqtW+xyyhZUKp6fai7DWEAjBI8gK4yM6+kyXmda4jGeha3ii0SjNzc0EAgHq6upYt25dyonVDPNQq0UUrLaf8SSnxZYsWWI8riiKMU16YGCA1tZWIw2SLIKmMlm1Ukor21hJ8MDshKiw1jhxEIJHsKBkSl2Z3U4+3+vEYjGam5sZHh5mxYoVrF27dsLJbq51QGBNwZNN5vJZ2O12cnNzJwx3TCQShuDu6uoiHA6jKAoejyelPsjr9ZryO11MWEnwmP17ma61RvLxwlrD2gjBI1gQpqrRsdvtlumummydeDxOc3Mzg4ODrFixgjVr1mQ8mc22Dmj8GplO5NmINFhBgJn9np1OJ4WFhRQWFhqP6U71en1QX18fo6OjwFgaLZFIMDAwgN/vn3VabDFgJcGzUEwlhEZGRmhvb2f16tXG8cJawxoIwSOYV6ZbjGxWhGe+IkXxeJxjx47R399PTU0Nq1evnvKEZYY4EBGF7CBJEl6vF6/Xm5IWU1WVnp4euru7GRoaor29nVgsZqTFkrvFJkuLLRZORMGTCf28pmmakeoShdLWYvH/RQqywniho58MJhsYaLUIj77/Y8eO0dvbS3V1Ndu2bZv2Cd6s4YXZbv1Nxmr7WWhsNpvRAVZfX288nkgkjCLp7u5uQqGQkRZLFkE+n29RCQSrCB4r1VWN7xZL/n8dYa2RHYTgEZjKTIWOjpmRGTOEk6qqdHV10djYyPLly9m+ffuMT+xmT2sWWIN0F1en00lBQUHKBG1N04jFYkZ9UH9/P5FIBMDoFtPFkD4s73hDCJ6JJAueTAhrjewgBI/AFPT8tSzLMxI6OlaJ8MiyTEtLC+3t7RQXF89K6Ogsxi4tcXKdPpIk4fF48Hg8lJSUGI+rqmp0iwUCATo6OojFYtjt9hQR5Pf7M6bFrPKdsIrgmY7IWChkWZ51OlNYa8wvQvAI5sRchY5OtouWFUWhtbWVjo4OKisrWbFihXEXtdB7ScZqc3jAOhfbbDHXaILNZjMETTKyLBtF0j09PTQ3NyPLMm63O0UE+Xw+wBriU/+bzzZzNfo1k/kQX9PpGIvH4ynHC2uNiQjBI5gV+h/awMAAmqaRn59/XA4MVBSFtrY22tvbqaioYPv27djtdtrb2+cswETRsvlY4bOYr/SJw+HImBbT64MGBgYMk9VYLMaxY8eMqJDH41nwC5pVJi0rimKJfcDYXpxO54K81lRCKJ21hs1m4/HHH+cLX/jCguzRSgjBI5gR4yM6+iTh6bp/Z8LsYuOpUFXVEDrLli1j27ZtKWFoMywdFuMcHivsJ9t3qQv5/pPTYskWJfF4nD179uD1egkEAnR2dhKNRrHb7SlF0n6/f14vvlYRGlbZB1gjvTaZtUYwGOTBBx8UgkcgyESm1JXD4UgJpc6WhbqIqapKR0cHra2tlJWVsXXr1rT5dqt0WJ3oXVFWJduiC8YKpZcuXcrSpUuNx2RZNqJBfX19HD16FFmWcblcE9rmzRAIVonwLPaUlhno39lgMEheXl6Wd5MdhOARTMpUNTpm1d7MN6qq0tnZSUtLC0uXLuX000+f9M7XDMGzGLu0rLafbGCFjqBMe3A4HOTn55Ofn59ybLLJaltbm5EWG2+yOtO0mChanogsy5bZSzpGRkZSvh8nEkLwCNIy3WJks7qr5gtN0wyhU1JSwpYtW3C5XFM+zyodVunWCIVCNDQ0EI1GjQvViTTsLttYQfDNpFhYkiTcbjdutzslLaZpGpFIhHA4TDAYpLu72zBZTRZBuslqpn1Y4TtnFeEFY+LLCp9JJoTgEQj+HzPtunI4HJYUPJqm0dXVxbFjxyguLua0006bltDRsWKEZ3R0lMbGRiKRCLW1tXi9XqO9OdkDavxdu9frNS0iISI8Y1ghwjPXC7wkSYZZamlpqfG4oigpabFjx46RSCRwOp0TTFatIjSsFOGx0l7SEQgEhOARnNjMtr3cahEefejhzp07KSoq4tRTT8Xtds94HbPEylyx2WzIssyBAwcIBALU19dTUlKCqqokEom0XT26B1QoFKKnp8e4ax8fDVqoTpLFhpVTWmZgt9vJy8ubUOehp8VCoRAdHR2Ew2Gi0Sher5dwOJxisrrQn49VhBdYX/CMjIzMucnkeEUInhOcuc7RMbOGRy/Qnc2JS9M0ent7aW5uRlEUtm7disfjmfVezOoamwu6Uenw8DBVVVUpjuyTGZam84BKLmbt7e0lFAoZM16ShZDuCJ6JbF/orcBiFzyZcLlcFBUVUVRUZDzW0NCA3+/Hbrcb84OS02LJkcaZRFhnipVEhpX2ko6RkRFRtCw4sbDawEB9rZkKHk3T6Ovro6mpiby8PE4++WTef//9OUcvsil4ZFnm2LFj9PT0UFlZSX5+PmVlZXNaM1Mxa7L1ge4Irqc6koVQ8ueZzZSWFdJpVtiDVSIaeuHz+IiBnhYLh8MMDAzQ0tJipMXG1weZIQ6sUkukk21BPBkjIyNUVVVlextZwTrfEMGCoAudrq4uiouLZy10dMwUPHp6bDonLk3T6O/vp6mpCb/fz6ZNm4wJtLpYmcuJNBvt4Pq0587OTiorK9m+fTuKotDT0zMvr5fJ+iC5hqO/v9+o4XC5XMbY+lAolDUjTCtcTLK9h85QJ8dCx8gL5lGeW561fWQSXpOlxfTvlp4WU1UVj8eTIoKmijSOx0pRFSsI4skIBAJs2LAh29vICkLwnCBomoaiKMiyjKZpNDQ0UFJSMucTt9kRnqnW0jSNwcFBGhsb8fl8bNy40RA6yeuYUXC8UCcuVVVpb2+nra3NGIKon7xVVV3wE2i6i5Xe2tzZ2cnw8DAtLS2GEWbybJfc3Nx5TV1YgWymtGJyjEf2P8KLjS+SiCfYENnApXWXsq1iW1b2M9NIk8vlwuVyUVhYaDw2vu6st7eX0dFRgAlDFF0uV9rP3ioRr+MB0aUlWLSMFzq6x4ouLuYaBjYz9TPVWrrQcbvdbNiwgZycnHnb00KktPROsqNHj1JaWpp2NpAVaongw9bm3NxcNE2jtrYW+NAIMxgMMjQ0RFtbG/F4PKWjR/d/ssod+FzJpuD5n47/4bXW16j0VxKNRumP9PNq66usLl5Noadw6gVMxgyhkanuTFEUowsx+bvlcDgmDFG0SoTH6tEdEIJHsAjJJHR09HbyuQoeM0/8mSI8Q0NDNDY24nQ6Wbdu3QTTxfGY0Tk2n0JDL7BuamqiqKho0tlAVmsDH7+fTEaYyR09bW1thMNhAHw+X0oNh9vtznp66HiidaSVHGcOdsmOw+ZAs2tElSgJZW42KLNlPs1D7XY7ubm55ObmpjyeSCSMIYr6OAY9TZafnz/tAvz5wEoTnzMhurQEi4aphI6O3W43unSswniRMTw8TGNjI3a7nTVr1kw48U13HTP2YgaapjEwMEBjYyO5ubmccsopU3aSHa9iIF1Hj6qqjI6OEgqFCAQCdHR0EIvFjDt2swtZ54ts2iks8Y5FQNpD7XjxokoqKwpWkO/Ozh17Ni7wTqeTwsLClLTYvn37KC8vR1XVlAJ8GBPZyd+t+RTZVok0TYaI8AiOe6YrdHSsaAmh72lkZISGhgYkSWLVqlUzbqG0ouAZGhqioaEBj8eTtu5oNmRDDM0l4pTcqpzs/6TfsY8vZPV6vSlCaC5jBswkmymtcn85MSVGd6ibUCLElsotfGbDZ3A7snPjMp8RnpnuQ0+LJRfg6ylXPS3W3t5uiOzx9UFmdHkdD4InFAqJtnTB8clMhY6OFQWPLMs0NDTgcrmor6+f9V2IlTysFEXh3XffxWazsXbt2mlHqU4k0t2xa5pmRIOCwSBdXV1Eo1FsNhuxWIyOjo6s2WlkK8UoqzK7e3dzSe0l9BX1IcdlPHkebFL2inWtbh6aKeWaSCSMNFhPTw9NTU0oimLMpdJF0Ew7EY8HwWO1Fv6F5MR814uA2QodHYfDgSzLpuxFFwezvdMLhUI0NjYyMjJCeXk59fX1c9qPGV1ac71r1d9TLBZjw4YNKRdzwdRIkoTP58Pn86XYHkQiEfbv34+maXR3dxMKhVAUJaWteSGm/WYjqiGrMoqmkOPKIe6MI0syCVsia/U7YJ3uqJkKDafTmXZKuT6XSp8fpHciJtee5eTkZDRZtbqPlpXqAbOBdX8zgrTMVejoZGt+TjKhUIimpiZisRj19fUEg0FT7o6y2dmU7He1cuVKYrHYvEV1spFayXYRtcPhwOl0UllZaTw2HTsN/WJlhp1GtlJabrubspwyeiI92FQbQTlIgaMga/U7OlZJaZnRLZZuLpWeFguHwwQCATo7O4lGo9jt9glpMas7pevfXSv8zrKBEDzHCbpHlCzLxhd2Ln/gZgqemXZ8RSIRGhsbGR0dpb6+3nBw1ms35ko2/L1isRhNTU0pflf672g+BMKJfNIaz2RtzclTpI8ePTorO43xLLTg0TSN4dgwAGcvP5udHTvZ3b+bHGcOF9RckLX6HasxX7+TZOGcXHuWbNeif7+i0ahxU5AshqwQBYOxGzKv15vtbWQNIXgsTnJE58iRIxQWFqaE+GeLmS7n0xUYkUiE5uZmQqGQIXSST1J2u51YLGbKfhYqwhOPxzl69CgDAwPU1tam+NmfsI0AACAASURBVF1BdiY2zyfZjvDMBLvdPis7jeQhd+lYyPcvqzJ/PPZHmoebkZCoyq1ied5yRuVRIkqE3x35HZ9c/UlKfCVTLyYwlXR2LZ2dncRiMfLy8giHw7S1tRGJRFBVdcJIhkxpsfkkEAicsAXLIASPZUmXunI4HKZdPO12O4mEObn/qaJFo6OjNDc3EwwGqaurY/369Wn/0M0SKgsheJL9rqqrq1m5cmXau7jjSSCcCExmp6F38+jeT/F4fEI0SO+uW6gL1YG+AzQONVKVW4UkSRwePMyfWv7EcudyvC4vqqbyTMMz/M2mv1mQ/QgmR1VV3G43xcXFRuRaf3x0dJRwODyhCH+8t9h8TioPBAInbEs6CMFjOSar0TGz0Fifw2PWWukETzQapbm5mUAgQG1tLevWrZv0QmFWms3M9zYeRVFoa2ujo6PD8LuaLFxtlUnJZrFYBVy6IXe6nYYeDdKLWGOxGD6fj9HR0SktD+bKQHQAv9NvrG232YkkIjjdTmw2G3mePNqD7cSVOC774rb0OB6QZTltyih5JENyhF5Pi4XDYSMtpvvWzcek8hPZKR2E4LEM0ylGdjgcCxaVmctasViM5uZmhoaG0qZ5MmHlCI+qqnR0dNDa2jrB72oyFltKywosVHRFt9PQ79h1Ghsb8Xg8OByOOdlpqJpKJBHB6/Bit6U/bolvCfv791PgKUBCIqEk8Dv9JJQELqeL4egw+e78E1rsWEmAz7RbLF1aTBfaen1QcloseTaVbrI6k78HEeERZJWZdF3Z7Xai0agpr2tmDY8ueJLrWVasWMGaNWtm9Mdolggzq2hZkiTDrXwyv6up9mKlE/JcyXahtBU+S71IOlkEwUQ7jUgkgqZpEwYout1u+iJ9/Mf+/2AoOoTP4ePqdVdTW1A74bXWFq+lN9LL4YHDAGxeupmSFSX8ZvdvCGkhStwlXL7y8gV53+Oxwu8CsjsIcjxm2fXoQjt5Uvn42VTd3d1GN+J0689OZFsJEIIna8ymvdyqKS2Ajo4OGhsbqampYdWqVbM6AZkpeOYaVdG74nbt2jWl39V878VqWOVCly0yXWCna6fRF+rj6a6ncbvdlOWVISsyj+x9hFu23kKuK3WEgd1m57zq89havnWs88eZM1bPt8KB2++mpqwma9Gd43UGz3wyn3vJNJtKURQjGqTXnyUSCSPimJOTQyAQoLKyUqS0sr2BE425zNExW/DMVVwkEgmOHTtGe3s7JSUlbNu2bU4nQCuktJL9rhRF4eSTT57THB2zal6schdrhT1km5n8LpJrN5aULuH5pufZObyT/bH9LHcup0guQkkodIx08Mqbr1BTWDPBTkOSJHKcOSnreu1eirxFWU1lWUXwWMmwMxviy263k5eXN0HI6BHHcDjMr3/9a15++WXC4TAlJSUMDQ1x0kkncdJJJ1FXVzflnl944QVuvvlmFEXh+uuv55vf/GbKzx999FHuvvtuAPx+P/feey+bNm0y942agBA8C4QZAwPnY3bObJBlmZaWFrq7u1m+fDl1dXUAcz75mVm0PBvBM97v6sCBA3PumDAjpTXXSdZmIyI8s3v/H/R+wFudb1GdV80h7yH64/2UUELtkloSvgRnbDkDr+adYKdht9snmKtawcPKKoJHURRL7AOsFW1Kjjh+73vfA+COO+6grq6OsrIy9u7dy+OPP04sFuPZZ5/NuI6iKNx44428+OKLVFZWsmXLFi677DLWrVtnHLNixQpeffVVCgsL2bFjB1/84hfZtWvXvL/HmSIEzzxj1mRkyH5KS5ZlWltb6erqoqqqyuhQ0k/McyVbER7drHS835VZnlxmGJme6CLDasxGbHSHu8lx5uC0Ozl92en8ue3PNA8343P6uLDmwrFCZJeL0tLStJ08oVDIsNPQ25sLCwsXzE5jPFYSPFYRGdPZi6ZpvNn5Jjs7duJxeLhoxUXUFdYtyP6CwSBr167lnHPO4corr5zWc9566y3q6+uprR2rMbvmmmt45plnUgTPGWecYfz3tm3baG9vN3fjJiEEzzyhC5329nZyc3NNmbZppuCZyUVUURRaW1uNVuzxHUpmRmYWsmhZ97uSZZmVK1dO6F6wiuu6lVrBrbSXbDHbaFupr5SIPFbIXJpTyubSzawpWcPmpZt58eiLvNHxBgCX1l3KxtKNxvPSdfIcPHjQmCM03k4jea6LWXYa6bBClEnfhxWEF0xP8LzZ+SaPHXiMEk8JQ6ND/Oy9n3HL6bdQkVsx7/sbGRmZcZdWR0cHVVVVxr8rKysnjd48+OCDXHLJJbPe43wiBI/JjI/ojIyMGMVjc2WhHc71mTPt7e1UVFSwffv2jI7EVik2ns464/2ukotMzd6PGQJBtLanku2L7GwFz8bSjRwdPsq+/n1ISKwsXslVq67igT0P4HV4KfWVElfi/KHpD+S58ggnwrjsLlYUrMBhSz1Va5qGx+MhNzd3gp3GeLsDM+w0Mn0OVhAaVorwTOe7sbNjJyWeEvLcYzU3kWCE/X37F0zwzLRLK935K9N7fPnll3nwwQd5/fXXZ7W/+UYIHpPIlLrKVlRmLqiqaggdfebMZK2WZgkxsy5kmYRKJr+rma5jxl5mwnjRpGkanZ2ddHZ24vP5Umo75vsCJCI8s6/hcdgcXLX6Ks6pPgdVUynyFBFTYozKo/icPt7vfZ/RxChROco9796D1+lFURVWFq3kuvXX4bR/GKnJJDbSFbBOZqeR/P2ZrJ05HVaJrFhlHzC9c5jL7kJWP7wmKKqyYH5osxE8lZWVtLW1Gf9ub2+nvLx8wnEffPAB119/PTt27JgwssEqCMEzRzRNQ5ZlFEVJW6NjpuCZb5KH65WVlbF169ZpzZRY6MjTVIwvWp7K7yoTZhYcm7GGpmn09/fT2NhIQUEB9fX1xoWsra2NcDgMMCGlMZ+j6hcaq4it2YpzSZIo9n54MfBIHrwOL883PY+iKdiwcWToCKeXnc4ZVWN1EQ2DDRwaPMRJS04ynjeTKNNM7DQyTflNJyisIjSyHeHpDfcSiAVSfq+TcXHtxfzsvZ8RCUaQFZlcd25KCnM+CQaDM+463bJlCw0NDRw9epSKigoef/xxHnvssZRjWltbueqqq3jkkUdYtWqVmVs2FSF4ZslUQkfH6XSaYog5HyRfSDs7O2lpaZnVcD2rCR49qjJdv6tMmFVwbMYaw8PDtLa24vV62bx5Mx6Ph3g8Tk5OzoS5L+lmcqTzhJrNRVtEeMwdEWCTbJxadirPNz2P1+nFLtmpzKmkO9INGiCN/f4jiYjpe5iJnQYwIRpkle6obAqvV1tf5TeHfoMkSUhIbHNsYwtbJn1OfWE9t5x+C2+0v8ErLa8QjAf58ds/5roN17GycOW87lfTtBmLQ4fDwT333MNFF12Eoih8/vOfZ/369dx3330AfOlLX+Kf//mfGRgY4Ctf+YrxnHfeecf0/c8VIXhmyHSFjo7D4TDuvM3cgxknXEmSaG9vp7W1lSVLlsx6uJ7VBI+maUQiEXbt2jUtv6tMWKGGJxQKMTw8jCzLKR1kmda02WxpL2LjUxqRSASbzZZyAfP7/XOeEnsiYPaIgCJvEeuXrKcspwynzcmhgUMcGDiAoirE1Biapk2o75ivi3wmOw1VVY1okG6noQshTdNM93yaCdmK8AyMDvCbw7+hzF+G0+4kFAuxo3MHVylXTTkfqcJfQetIKyW+Ekp9pYTiIX6555fcuv1W8t3zY/0wl/PQpZdeyqWXXpry2Je+9CXjvx944AEeeOCBWa+/UIiz2zSZqdDRMXuisS4u5nJh0jTNaG8dGRmZtdAZv6dsk5ySA6btd5WJbNbw6IXVo6Oj+P1+1q5dO6Hw3YyUhi6Cenp6aGpqQlGUCVYI+vA7wdREEhECsQD57nx8Tt+kx3aFumgPtiMhUeItoX+0H5/Dh9vh5qKai+iN9OJxevjUuk9RmVuZ8tyFnsuULI51ent7jdb4cDic4vk0Phrkdrvnbb+qqs6bUI8rcfb27SWuxKkrqKM058NxASOxESQko7bK6/AiIxNJRKYUPOFEmN5wL8vzlgPgd/kZig3RF+mbd8FzIv8tC8EzBbrQ0UXLTOfoOJ1OywgeTdPo6emhubmZwsJCCgsLqampmXONh5mCR08jzeQz1jSNrq6uFL+rt99+e853fdmYwxOPxw3j1bq6OpYsWcLevXvnJY1kt9vTGhcm+/XoM5YcDodRDxSPx7NeN5FNMomNA30HuHf3vSTUBE6bky+d/CXWL1mfdo2GwQYe3f8okiQhqzLLcpaxrngdoUSI1cWrOa3stEkvTFZoCVdVFafTOS07jVgsZnyHcnJyjFEdZnyH5uu7GFfi/HDXDzk0eAibZMNpc/L32/7eSDsVe4tx2p0E40FyXbn0h/spcBdMsAdJh9fhxePwEE6EyXHmIKtjzS55rvmzfYhEIvh8k4vwxY4QPBlIJ3Rmc4Ixu2hZX8/tnn5Vv6Zp9Pb20tzcTH5+Pqeccgoej4e9e/ea1k5u1gVZFxnTETzJ76uwsHDOkapMe5nrGtNxuE+eXl1TU8Pq1auN79tC1s1k8utJJBJGOiMajbJ79240TUt7Jz+fWKF+KJ3giSQi3Lv7XnxOH36Xn1A8xH277+Ouc++aYAsB8Hzz8xR5i/C7xiImLcMtnFdzHmuK10x7D9mun8n0d5psp7F06VLjcf07FA6H6ezsJBQKTXAAn01Ecb5qiXb37ObgwEFq8muQJImh6BCP7nuU28+6HYA8dx43bL6Bf3/v32kNtFLiKuGvav4Ku21q8WW32blu/XU8vPdhBqODqJrKx+o+lhJBMptAIHBC+2iBEDxpkWXZuEjNVujozJfgmQ6aptHX10dzczO5ubls3rwZr9ebspYVUlHJTCeClex3lZuby8knn4zH4zF9L2YULU8lVlRVNeqoMtUbZVpjIdMaTqeTwsJCvN4x64ONGzemreuIx+PT7vKZLdmObKT7XQxHh0moCUPA+F1+ArEAw9HhtIInJsdSUheSJJFQpxbGyXvI9ucw00is/h0qLCw0HssUUdTtNJI7DjOdE+bLSyscD2O32Y3P2efwEYgFUo7pDnUzEhsBxmp6gnIQgKahJj7o/QCPw8PW8q0UeSfO+lpdvJpvbPsGA6MD5LpyWZqzdMIxZjKboYOLDSF4MjBXoaNjtuCZTvooWRD4/X42btyYNpRpdn2RGUwVVRnvdzWfIVozIleZ3o9eR9Xc3Expaemks46sai2Rrq4DSCmQ1rt8JElasAnAC8H4c0OBpwCnzWmkKMKJMA6bgwJP+pknm5du5rW211jmX8aoPIrT5qTCP/3Bc1YRPHOtnckUUUy200iuL/N4PBMGKM5XSqu2sBYJiVA8hMfhoSvcxYU1Fxo/Hxgd4Ff7fsVS31LcDjcDIwM80fIEVcureOiDh4x5Ozs7dnLL6bek/S4Uegop9BROeHw+EIJHCJ602Gw2U4fgmXmxmkpA6ULH6/VOKQisUmycTKY9ZfK7mk/MmCCdbmjgwMAADQ0N5Ofnc9ppp02ZBrLSpOXppNfSdflkmgCc7gKW7Qv5VGiaRjAe5N2+d1E0BUVTCMaDnFlxJq+1v8ZwdBiHzcEXN38xbXQH4Lzq83BIDvb176PIU8SFay9MGwWYjGx/TvPZDp7OTkPTNKLRaEqh/ejoKLFYDFmWKSgoMEVMD0eHaQu24XF4uPGUG3nswGMMjA5wbvW5/OWavzSOG4oOjXW1/b+hgR6Hh4SW4PeNvyffnW8InGOBY+zt28tZVWfNek9mEAgEhODJ9gYEMyOT4BkcHKSxsRG3282GDRvIyUl/ok3GioJnfERkKr+rTJjhMD7d+pup1tDfTyAQ4MiRI7hcLjZt2pQiRnvCPTyy9xEGIgOctfwsLqm7ZFo1PFa4058OmSYAp7uAjXcH9/v9liqQDsQDPPLWIwTiAdqCbfRF+jht2WnYJTubSjdxad2lFHmL0oodWZUJxAL4nX7OqzmP82rOy8I7MIeFnn8jSRJerxev15tip7Fnzx7KyspIJBJzttNoCbTwo7d/REyOoWgKW5Zt4fvnfj9tXc4S3xJsks2I6g1Fh/A7/dhsNuzah8fbJFvKZOVsISI8QvAcd4wXKUNDQzQ2NuJ0Olm3bt2MPLvMrOGZTXdVOvT3N12/q0zoQiPbbemSJBGPx9m9ezeqqrJ69eoJhYND0SH+5rm/oX+0H5fdxUvHXmJwdJDrTrrOWGO84NFTrgud6jJTXGW6gMmybIigrq4uo7jV5/PhdruJxWJEo9F5bXWejLcH3yYgB1iWt4xDg4fwOX2MxEY4Zekp7O/fz+UrL08rdtqD7fzs3Z8xFB3CaXNy5eor2de/j/aRdqrzqrl63dXTntZrBazQKQZjwjk/Pz+lYSGTnQZMPon8kX2PjA1/zKtE0zTe6nyLreVb005Cznfnc9MpN3Hv7nvHoj2axBfWfwHFp/Do/kdRVIW4Esdlc7GuZN2E5y80IsIjBE9a5uOP2Kw7cYfDQSwWIxAI0NjYiM1mY82aNbNK8djtduLx+Jz3pK9lRreEpmkcPXqUWCw2Lb+rTOjpqGwKnmg0yrFjxxgZGWHTpk0ZRdvrra/TNNyE3+XHbrNT5C3i4T0PTyp4poOmaXSFulBRKfeXY5PMuRufb5HlcDgoKChI8fzRh0kODg7S39/P4cOHicVihjHvQvqJjSqjuB1uVE012omHo8PGtF1Z+/BuvjvUTVuwDbfdzWMHHiOuxKnMqyQYC3Lbn29jS9kWKnIraBlp4efv/5y/3/r3E4xCrYoVOsUgfVv6+NlTUTlKS6AFSZModZYyGhlNa6fROtBKib8kZdZaKB7K+NonlZ7Ej87/EaFEiMGuQfL9+ZSWluKQHLzV9RZeh5cLVlww7wXJ0yEYDFJdXZ3tbWSV4+Mv6zhHT0OZUaQZj8dpa2tjcHCQ+vr6OSl2M1Na+lqzfY+631VPTw8VFRWcfPLJc05HZWtoYCKRoLm5mYGBAcrKynC73RnFjqIq3PfefXQGO3HYHEhIVOdXG07KMDvBE1fi/NNr/8Qb7W8gIbGpdFPGFumZkK07er3oWbfZOOmkMV+pZBuE+fAT6w51czRwFL/Lz/qS9dgkG6tyVnE0dJRoKMrA6ADheJhoIsob7W+wrWIbS31jF7fDA4d58IMHUTWVqBzlQP8Bzq0+13g/MTmGz+nDYXNQllNGe7CdoegQS3xLJtuSZbCKl9ZU+xgYHeDO/7mT7nA3Ghobl2zkltNvYdmyZUCqnUZ9bj3v9bxHkb2IuBYnqAbp7Ork7/b9HcPyMBtLN/L5TZ9P6bBzO9y4HW6GtWFDeG0p38KW8sktJhYaEeERgmdBMEPwBINBGhsbiUaj5Ofns2nTJlP2ZbbgmSnJ82eqq6uprq4mJydnzhfWbAwNVBSFlpYWurq6DO+uUChES0tLxue80/UO7cF23PaxiAGMtbTedd5dxjGzeS9PHXyK19peMy6+u3t289Ceh/jqaV+d0TrpyGbH2PhIqcvlSjv4zgw/sQ96P+DuN+9GVVVUVLZXbOdvT/tb6vx1fK7mc3zrz99iWc4yfAU+bJKNqBLlipVXGJN3f3v4txS6C/G7/Kiayjtd79A20kZ1fjWapqFqKk7b2LGyKqOh4bYvjGu2GVhF8MDkQvyJg0/QG+mlMncsTbW7ZzevtLzChbUXGs/VC+2/cuZXeHjvw+zt24vX5uWKyit48vCTqLKKGzcvHXqJlvYWbjzpRkNU6wMUrT6MU9TwCMGTFrPvYufSmq4X7SYSCerr67HZbLS1tZmyLzPb0mcqeBRFoa2tjY6ODhJ5CQIlAeJynFK1FI8y95k64x3TZ8N0O+ySLS3Ky8tTLC2mis6EEiGcNidrS9bSFeoirsSxSTY+s/EzxjGzifDs799vpLAkScLr8HJo4NCM1jheMctP7L7d9+F3+sl156JpGjs7dnJe9ViR8aalmzi17FSq8qqM12gPttMZ6mRUHqUit4JQIkSJd8zKwybZ2FCygXAiTEewA03TuHbdtbQH2xmJj6BqKpfVX5YS2bM6VhI8k9ER7DCmH0uShMfuGTNnTYPf5eemU28irsRx2Bzs7duLvdnO8qIxC4gyrYyWQAs5+TkoMYWOjg7C4bBhVqwPrJ1vO43ZIASPEDwZMbMgdDaCJxwO09jYaNSy6HewoVAoayJlrmvJqkzzYDOd3Z2ogyo1lTU4q508deApvA4vcSWOW3bzudWfm/N+FiKllWzVUVJSktZlfqo1TlpyEm67m5HYCIqmEFWinFx6Ml7HhwMiZ/pdfLnlZX535Hf0j/bT6mhlbfFaRuVRVhbN3Yn5eHVLn6mfmMfjoX2wnYrcCmRZxuFwYJNsBONB3JqbHGcO5bnldIW6WOZfRjAW5OjwUf7t3X/DbXdjk2xsKt1EW7CNCn8FkUSEJTlLuGHzDWho5LnzKPYW0zTUxGB0kGJvMbUFtVn8hGbO8SJ41hav5Q9Nf8DvHIu0RZUo9QX1kz5H98LyOX0o2of+iVElitfppWxJWUpNnKqq7NmzB5/Pl9FOI9sdhyMjIyl1cSciQvAsADMRPJFIxDCN1IVO8l2CmWmohUxpRRNR7n7lbvZ07MHn9VFTWsMty27hsXceY2nOUqO2ZF/HPpoCTaxi1Zz2Y8YMncnEij5LJzc317DqSMdUAqE0p5TvnvNdPv30p4nKUfwuP93hbh4/8DjXrr92Wmsk0xHs4FuvfosSXwmyKjMcG+aDvg+4tO5SPr/x89NaIxlFVXjswGP88dgfKfIUccOmG2a8hpWZzE9sQ88GXu94nVxbLnbsyJqMNjBW7xEOh/nfG/43v97/a1pHxsxqFU2hJrcGh81BOBFmb99eLl95OXv79pLnyuO6DddRU1CT8vp1hXXUUbeQb9k0jhfB85dr/pLeSC/vdr8LwBWrrmB7xfZpPbe+oJ4zK8/k9fbXsUk2NDS+vPnLExoA9NltS5cuTakXSyQSRno1ueMwGwa9QvAIwZORhY7wjI6O0tTURCgUoq6uLmN3kpmTm82O8GSaKNzb28tv3v0NB4cPclrdadjtdjqDnTzb8CwJNZFSt2CTbCSUuc2+gfmL8IyMjHDkyBEcDgcnnXTSlPOOprOPnnAP5f5yyvxlAIwmRvn1B7+eleBpHm4GbezOtLaglqgSZTg6zF3n3DWrdMnP3/85D+99mBxnDo1Djezp2cM3VnxjxuscT0iSBE4IqAGG5CHaEm147B7u/sjdrF+6ngMHDtDe3k4kEuFs29k4y5x0q938YvgX2Bi7EOpzWS6uvThlWJ0ZWCXClg3Bs7dvL88ceQZFU7i09lJOW3balM/xODz83Za/I5wII0kSr7S8ws1/vBmbZOOKlVdw9vKzM4oNSZL4wuYvsL1iOyOxESrzKqnJr0l7bLoaHqfTmbbjMNlOo7u725g/Nb7Y3kwX+FAotCADW62MEDwLwGQiJRqN0tTUxMjICHV1daxfv35SpW+2SJkv8TTe76qwspAyR5lxQvC7/PSF+zhr+Vk81/AcJd4SRhOj5LhyqPBOf8R+X6SPzmAnPqePusI6487LbMETDodpaGiY8QDE6dQBSUx+Z5epeDrdFOdSX+nY9F9VwW6zo6GR68rNaHEwFb898lsKPYW47C78jEWf9gX2cTEXz2o9q6NpGvv69/GHxj9wYOAAZ1aeiYZGf6Sft3vf5rI1l+FyuVi3bmyuiu4n5up3ocgKHX0duCU3ATnAkpwlBAeCkIupfmJWGTa50ILn0MAhvvv6d/E4PUhI3P3m3fz96dNr45ckCb/Lzystr/DEwSdY5l+Gpmk89MFD5LnzOKXslIzPtUm2tHN4xjPdz8MMO43Z/P41TbN0UfVCIATPAqDPzkkmGo3S3NxMIBCgtraWdevWTetLbOaJzkzbi2TBk87vKtGd4OW2l0moCeySnYHRAbZVbuO8mvPw2D3s6d1DbkEupxecDuHpvWbDYAM/f+/nqKgoqsJp5afxqfWfwibZ5lS0nDyDQ5ZlDhw4wMjICPX19dj99hn9DqbT6XV29dn8fPfP6Y304rQ5iStxvnHqh1GUqdJz3aFu/um1f2J//37Kcsq4cMWFvHj0RUPw3H3O3TOe7aJpGk8eepKGwQYAqnKrKPQWIiFhl6Y+aSqqQnuwHZfdRVlOWdYu0G91vsW+vn0s8S3hotqLjNqMdOgXwB1NO+gIdtAV7jJMHRVN4Vjg2IS/F73oeZ1/HXd47+An7/yEcCJMra+WCysu5LHDj6HEFTb4NlDqKTXFT+xEFTyvtL6Cw+5IGc744rEX+VjOx6a9xjvd71DgKcDjGEtB+5w+3u95f1LBM13m+nuZjp1Gb2+vUWw/k++SVaKC2UYIngyYeUJxOBzGfJBYLEZzczNDQ0PU1taydu1aS5y85orNZiMcDvPuu++m9bvaXLaZ82rO45nDz2C32blgxQWU5ZTx5IEnyXPn8dcn/TV57jyGhoboCnZN+XqyKvPYvsco8BTgd/nRNI13Ot9hW/k26ovqZxXhiStxnjr4FLs6duGUnGz1b6UwXMjy5cupqa/hF+//gr29ewE4t+Zcrl1/7ZTD/KYjKpf5l/HLT/ySX33wK4aiQ1yw4gIuqbvE+PlU1hJff+nrtARaKPYWMxQd4q3Ot/j3i/6dmByjtqCW8tzyGX0OAL85/Bt+/PaPKfGW0Bps5fDgYcr8ZVTnVbM5f/OE4xVVoSfcQ647F0VV+NsX/5Yjg0dQNZWP1nyUf/7IP5syUG8mJ+4nDjzBv+76VxRNQZIknm18lnsvujfjPlpHWnmh+QUq8irwOD30R/s50HeAD3o+ICJHyHfn853XvsPHPOkvsJuWbuKBSx9gVB6leaiZH7z1A1w2F4qmcDR0lNs23kYuuXP2E7PKhGMw7zyZUBK83v46gViANcVrWFO8ZsIx/ZW3QAAAIABJREFUDsmBon0o/BVNwSE5ZhS1UFSFhsEGSrwllOeWE1fiKTN1rEamaeSZvOn00Qu6GNIji7oYs8r3JlsIwbMA6BGew4cPMzAwQE1NDWvWrFk0X75QKER7ezvxeJxNmzalTffs693Hro5dLMlZgqIptIy08Frba4Zg2Nu7l69u+eqUKbuR2Aj3vHMP/9P2PzQONXJe9XmsLlmNJI1FHkblsfHxyVGRpqEm/nP/fzIcHea0Zadx1Zqr0t7pP3fkOf7c8mcKtAL6h/t5bvg5rlhyBWVlY8Lsg94PWJ63HFVT+WPzH6ktqGV7Zfrix75IH+F4mFJf6bSEV3V+Nf901j+l/dlkgmcwOkhLoIUS31jnUZ47j6HoEJqm8RdVf8HhgcO83PIytQW1VOdPf8qq3tXiz/Hjd/lpD7azumg1/37Bv9N6qDXl2NaRVm7YcQPd4bFW39qC2rE9eUvQ0Pjvo/899rmvvmrarz8Z0/m7UTWV//P2/yHXlYvT7kTTNN7veZ+3u97OWLAaToSxS3YCsQCNg41ISPSO9iIx1tavairPNT5HSXkJW9madg2bZCPHmcPzTc/jd/oNQ9D2kXbe7HyTT6755Jz9xKwy4dgsZFXmtj/fxnvd74E09hneuvXWCT5jF9ZeyKttr9IR7DDOGxfXXIxtaHqfxeGBw+zq2kVLoIXGoUbcDjfnLj/XND+zhTyfZ/Km0wcoBoNBBgYG2LlzJ/fffz+1tbXIssyf/vQnNm7cmCKepuKFF17g5ptvRlEUrr/+er75zW+m/FzTNG6++Waef/55fD4fDz/8MKecMveI2XwgBE8GzPryxuNxOjs76enpYc2aNaxcudKUk5UVOiSS/a6WLFmCqqppxY6maTy671GKfcX4nD5UTeXh9x/G4/TgdXpBG0vLfHzlx6n2Vk8qeH72zs949vCzuO1uNE3j6SNPc7Xjaoq8RdhsNpb5x6an6hGevkgfP9j5A5x2JznOHF5oeoGEkuCvN/51yrqDo4P8bu/viIaj5JXksXLFStpG2ugaHYs2NQ42UugpNISVx+nh2PCxCYJH0zSePvw0Tx9+GkmSyHPncb7r/Dl9zpMJnhxnDjbJNubZY3cZdgf57nzu230f9+++H7vNjqqp3PEXd/CJlZ+Y1mv6HD4S6ljxeKGnkJgS4/ya81mSs4QWLXWQ4tf/9HXag+3kuHKQkHij/Q2qcqsMqwWbZOPgwMFZvXdVU+kOdeOyuwxRNx3iSpyEksDhGjvF6Xe34UTmfGllbiVIsKtjFx6nxxgEmePIId+bT0JJMBwbpis6dQRSjyrpSJKUEp1IfnymfmIej4dEIkEsFsPlch33N07vdb/H+73vU55bjiRJjMqj/PTdn3Ju9bkp72153nLuPPtOXmp5CVVT+UjVRyh1lNI+0j6t13n84OPkunI5t/pchqJD9EZ6ObPyTAo9hXN+D1ZIGSUPUCwuHkv7rV+/nk9/+tO8/PLLfP/732fHjh3cdddd9Pb2UlZWxj333MPKlZnHVSiKwo033siLL75IZWUlW7Zs4bLLLjNq2AB27NhBQ0MDDQ0N7Nq1iy9/+cvs2rVr3t/vbBCCZ55IJBIcO3aM3t5eli1bRmFhIRUV0y/GnQy9ndwMwTMbV/FYLEZTUxOBQMDwuxocHKSvry/t8Qk1QUQem0MCYxexoegQdd46ijxFaJpGW7CN3nAvtf7ajBERVVN5s+NNXHYXBd4C/G4/RwaO8GbHm3ys/mPccPINxkVRdzpvGmoirsaNDqiqvCp2duw0BI+maew5uocfvPEDjkSOINtl4qNxtrENRVPw2sbm4VTmVXI0cJQ8d97YXXkimjZV9N/N/82db9yJz+ljef5yonKUp/ue5nIun9Znq2ka73W/R+tIK0t9S9lasXVSwaN3oHx/1/eN6NYnV30Sl93F/bvvx+8c8+eKK3HueP0Ozq85H5/Tl3atZK7ffD1f++PXjKhNgaeAK1ZeMeE4VVN5t/tdQvEQUmRM3NgkGyPxEaPWQtXUKeeepCMQC/DV//4q+/v3o6HxifpP8P+d/P+l3YPEh+H6rlAXvZFeNi/dzPu975PnymNUHsVtd7OpNPOE8jx3HleuupJ9ffuQFRm/y08kESGqRMknH5s0FjXMd+Zzw44b2Nu3F4fNwfaK7ZxWdhofr//4mIAHLlhxAf/2zr+NDaJTZZBgW8W2ab/3qfzEZFnm0KFDWfMTM5OIHDF+f+F4mCODRxiODvOd177DzVtuTqnZqcqr4rMnfZaecA/hRJhIPDLt9xqOh3HZXbgdbsr8ZaiaioY5QsXKU5a9Xi81NTXU19fzgx/8wHi8p6dngpHxeN566y3q6+uprR2bEXXNNdfwzDPPpAieZ555hs985jNIksS2bdsYHh6mq6vLsO6wEkLwmEyyVcLy5cvZvn07siwzMDBg2mvo3VVmeHPpKaTptD/qflcDAwMT6o8mS0W57C5WFq6keaiZ8rxyBkcH8bv8yJpMRI4gKzJeh5clviWTrmOTbHidXuTwWGeZXbJT7C3mo7Uf5bazbpvwvmKx2Jhlg6p+ODhMjhoX/MHBQRoaGni251mWli5lhXsFr7e9TstwCzbJxqllp1KpVgJwxeorOBY4RttIG6qmclr5aZxReUbKa7YGWrnv3fsYlUdxOVzs69vH+pL1DMWHjNcPxoJ0BDvwOr0sz1s+QWg+eeBJnm14FqfNSUJNsKd3D1dVXpWx5R/GLqQOyUFUjmKX7Ozp3cNHRj6Cw+bAbrMbv4OoEmUoOjQtwXPy0pP5xSW/4OWWl3Hb3Vxce7EhGpNpGm4ikhi7YDlsDmRlzCJhed5yAvEAqqZyVtVZGdNZCSXBsw3P0jrSyrqSdVyw4gIjXfHDXT9kb99eCj2FaGg80/AMa/LXsNE+1jETiof4xsvf4OWWl/E4PHxz2zdRNIWfvPMTY40NxRtoD7VTV1DHbWfeNqVPVV1BHRtKNoztPxbgpZaXiCtxhqPDAJxZcSa/avkVvfHesa4Xm52jgaPs7d3L+73vc8dZd+CwOdiybAs3n3Yzr7a9isvm4pK6S1iet3zKz30ydD8xSZIIBAJs2LABmJ6fWG5urinni6lQ1LHhmT7H5LYdyawtXovL7mIgMkDDUAOjibFJ1QcHDnLn/9zJv573r8bvU9M0frn3l/zu8O+wSTb8dj9fqf8Kq1k95eucU30OD+55EJtkQ1ZlVFROLTt1Tu9Xx8qCB8bGaYwXN0uXTm1o2tHRQVXVh9PEKysrJ0Rv0h3T0dEhBM/xxEzDxLIs09raSmdnJ1VVVWzfvt248zBzdo6+ntmt6ZMJnmQRV1NTkzYtN1XtzWc2fob/3PefHBw4SIG7gMtXXT7W9YJGQk2wPG85tYW1/z977xkYR31ucf9mZmf7rnbVu2RJtmzLvdsYMN34XlqAJBBIQoALCYQbagIBAoEbTCDgvJQQehJwuEAuoRkDBoNtsCV3Czf13suutpeZeT8MGixXDIb4zevzyWV29r+zszNnnuc85yAKBxcbXzP9Gn7x/i/oDHYiIJBmT+PssrP32W64pVWRUUF5ejm7+nYhCiICApeNv8wQV1dUVPBe/D0sWLDLdk4uPpl17evoC/XxWe9nfDr4KZnlmUzNnsqt826lI9iBJEjkuvZNH6/uqcYm2zBLZkyCCYfsoGaghsnWyQiCQJOviXvX3EsoEUJRFU4vOZ3Lp1xunGuBWIBl9csodBcSU2LElThrWtZwXNpxWLUvjA1VVaWtrc3I6Hqy5UkGw4Nk2bIQRZG6wToq2ysRBZFIMoLNZCMQD5BiSTmsYMoxqWMYk3pwA8i2Id2NuCPYgaIqIIBTdvLyuS/TG+nFJJooTiner7hb1VRu+PAGPmn9RK9iobG1Zyu3zNEn1Kp7q7GZbCNaYzv6dxgjwr9d81tWtqzEZdaF0neuvhOzZCbTnoksyYQTYZqGmvjgog+MfKthaJqmi173EjBPzpxMRUYF2/u2E4gF9MoVAjFFJ88aGu3RdkREfTpQUZBFGYfZwfa+7TT5myjz6tWs6TnTmZ5zZG6oqqaOuOkfbp5YU1PTCFHrl80TOxysaFzBQ+sfIq7EGZs2lrvm34XT7MQiHTxiIcuRxf0L7ueuNXcRV+IUpxRTkVGBLMo0DTXhi/oMLdSWni28uutV3GY3CDAQGuD5uuc5buJxh1zfwpKFKKrCiqYVWCwWrpl2zSHP7y+Lo53wfNXg0P1Vlvf+Lr/MNkcLjhGerwlFUWhpaaG9vZ38/Hzmzp27z4l/JMe/4dszH9wz72r4sx2ofHwowuO2uLlq+lWGP4wv6uOF6heoGagh15XLpRMvxS7b9VDFgxCe+YXzefo/nubN2jcB/SI2M2/fVOJh0bJZMnPD7BvY1LWJgcAAgk/AMmChdHSp0S4wi2b+Uv0XVE3Fa/XSF+5jRs4Mcl25NPgb+EPlH/jTwj/hsrgOKvw1m8zYZTuTsyZT3VNNLBkj3Z7OObl6O+vxjY+jqAr5rnxUTeW9hveYlTuLSVn6DTyuxtE0jfqBeup8dYBeAekMdVJsKh4RZZGZmcmMGTMQBIElnUuwm+2oqko8HieRSFDTWsONY27kgZ0PMJAYIN2ezuNnPH7QsewDYUPnBt6sexNZlLlo/EUj/i/flY/FZGFi+kTiapxYMkaaLQ2P1YPXdnBtxK7+XVS2V5Ju1002FVXh5V0v819T/guP1UOZt4wmfxM22WaEbY5KGWW8fnXbauySHtwpSiLxaBwV1SA3dtnOQHQAX8w3guh90PQB96+7n3AizKzcWfxm/m+MSR1ZkvnlnF+yqWsTD1Y+SKYjk/5IPwICcTXOB80fAJ9rgjSdpEWTUZ2QcGR/5wBbe7Zy84c30xnsZEzqGB465SFSxdRD3lC+ap6Yy+XC4XAcsuK79+esHazl95W/x2PxYLFaqO6t5oz/PYN0ezoplhRum3sbU7L2ne4bxrj0cfz+pN9z/QfXk+fMM3RpEtKIimRnsJOOQAeNSqP+HajCCKPSlqEWdvXvwm6yMzNnJhbTSFPTs0af9aV1bIeDo53wfNUcrfz8/BHZjW1tbeTm5h72NkcLjhGeA+BQF5RhMtDW1kZeXh5z5sw5oq6YB8ORNAzcX7VozzDMnJycEWGYB1vTwQhPJBHh5Z0vs6VrC06zk++N/x7Xzrx2xDZbu7eyq28XHf0dTIpPwmHe18U4EAvQGeykLLWMsWljmZo9db/vN1zhSapJ+gJ92AZteANeQ3M0/P3u6N3B2va1RBIR4kqcvkgfMrLxRGmTbCTVJP2RflyWfV1KByID1A/WYzVZmZY1jbdr32ZDxwaiySgWycIdx9+BtUOvznQEOsi060ZjoqBb0Q9EB4x9uc1u0u3pvFX7Fmm2NOJqHItk4YPWD7g4+2KqqqpwOp1Mnz4di8VCMplEURTm5M1hR/8OwmqYQDxAUk1SklfC6eNOZ3bebLp8XQgxgUBDgB3dO3Sdh9OB2+VGlmVCiRBPb32a2oFaJmVO4scTf2wQo0/aPuGn7/4URVVIqkme2foMk12Tuch5EReOvZDRqaO5dtq1PLbpMURBxG1x88DJDxz091PdW82dq+6kwdfAQFRvb8qSrBMX9BsdwM2zb2ZX/y66Ql2omsqc3DmcV3YeHa0dAGTYM2jwNRhTWLIkIwkSsWQMi8lCIB7AZXaNEKXu7t/N3Z/cjVN2kmnPpKqjisVrF3PfgvuMbcySmTl5c/BavUSSEURB1N8jqenhrowk/YqmsLp1NfPy5x3WJNzeeK/hPd5peAeP1cMVk6/AZrJx9fKriStxvFYv9b56rlp+FUvPWPqVNDpfJk+sq6uLYDCIoigHjT/Yu8rUMNiAhobVZNXd1UM9BOIBJmVMIpQI8ZvVv+HZ/3iWNFsamqa3J/9Z809kSeZHE37E/IL5FLoLWThqIcsbljPsxXnl5CsNzxyAweggvpgPr9WLKIgMhAcM7dq2nm3c+8m9hti+PK2cu+ffPYL0fFNIJpNHNeH5qhWemTNnUltbS2NjI3l5ebz00kssXbp0xDZnn302jz76KN///veprKwkJSXlqGxnwTHCc9gYbie0trYaZODbIjrD+CZaWqBfxDo7O2lqaiIjI2O/YZgH28/B1vR/u/+PTZ2bKEwpJJKI8OyWZ7lp7k2G8Hdl00qWbl+K3WSnpbeFYGWQm+fePOJiF0lEeHTDo/SGe7GZbHza+innlZ/H+IzxmETdkGz4IiyKIm2BNu5/9X56Aj14XB5umH/DPuOYNQM1tAfaKUgpwCyaCSfD1A3U0RZoo8xbRlSJYtbMdAQ6CMQDjEkdY1xA6wfruXvV3USSEVRNZWrWVNwWnbSUeEuwyTaW1S1joVl3JR6XPo7tvdvJc+URS8bQ0ChwF9AV7OLJzU/S7G8mlozhtXiRRZk0expl7jJqumrwWX3MmDEDp9O5z7G9eurVrGhawYbODUiixJjUMewc2Emf1kdZYRlFhfpNWFVVmnqbuGX1LXzW/xkuycUVRVfwWtdr1IfqkSWZj5o/orqnmj+c/AeCiSCPbXwMAQGX2UXzkL6+LcoWOqs66Q51c92M67i44mJOH3U6A9EB8lx5Ri7a/tAf6efn7/0cRVXIsmfRHepmZ/9OxnjHEEwEmZAxwRCeZzoyefncl6kdrMUsmRmTOoauwS5aw60UJ4r57fG/5bK3LyOYCAJ6EOsPK37I4srFRJIR7LKdP576xxFtq539O9FUzQhnTbelU9VRtd+1LipdxIrmFfrElaqfV5n2THpCukFkVIkCkGJOwSbbaPQ10hfu+0q+R3/f8XfuWn0XGnol6626t7jn+HtIKAmcZv07T7Gk0B3qpifcc0RbBgfLExsece7s7CQajRphmHa7XlEcrmyk2lKNKlxSTRJKhHCZXYbDcTgcNryiltUvY8n6JbjNblRN5c7Vd/KHU/7A1KypXDnlSmblzqI/0k+Bu2CflpNLdpHnzKM/qlfdHCYH+U5dZ/f01qexy3ajWrerfxdVnVUcX3D8ETtWB8LRXuEJBAIUFxcf9utMJhOPPvooZ5xxBoqi8JOf/ISKigqeeOIJAK6++moWLVrEsmXLKCsrw26389xzzx3h1R85HCM8XxJ7Vj2ysrKYPXv2YRGdYcfdIzE9caRbWslk0miVeL1eZsyYMSIA78vu52CtqOqeavJceqnaYXbQF+mjI9hh3Bxer3mdPGceFpOFuDVOe6Cdmv4ao90DOsHoDnUbWTZWyco9a+6h1FuKpmnMK5jHjyf9GAGBzq5O/lz9Z6xuK1NLphJJRnhsw2M8cOoDI8abUywpJLWkEe+gaRo5zhzC8TDtgXb8ST+ZZPJQ1UOgQUFKAXefcDdui5unNj8F6JMjmqaxvmM9kigxJ/+LaZxWfyv96IL1n07/KQ+se4DGwUYkQeLKKVfq/jsf34k/5qfQXUiTv4lwMsz8/PlEg1Fau1spzygnMzNzv2QHwGKy6CGUnlJssg1JkGgZaqHB10CqNZW/VP+FJn8To1NH83HLxzQEGsh2ZxNOhnmk9RESSgKPxaNPFCWTvL37bRq7GpFMEjv8OzCJJmPaSBIlnYzZ0nhp50tcO/1aREEk3Z7+pcbGd/fv1t/v86iLivQKagZrsMk25hfM5+bZN4/Q+9hkm6HZWVa/jLtW30UinsBd4+ahUx7izQvfZEPnBuyynRMLTsRisnDyqJMZjA6Sac8cQZhBnzbT0IwKRTgZHjEFtCfOHXMuDb4G/rjhjwgI5Dnz8Fg9nJVxFjsSO9jcs5lcZ65B8IZiQ6zrXMfpltMNkjKMcCJMQk3QEeigPdhOcUqxofUBeGTjI8iSbFTWfFEfW3u2ktSShn5nuHLhNDkJC+FDHuuvgwPFHyQSCYLBID6fj3g8zubNm9E0DZvNxgzPDCr7Ko0bf6lHD0VVVD3qZPg7H/YoGj5GUSXKyuaVTM2aiiAIB219FXuKyXPlMSlzEqqm0jHYwcS0iYB+/Pf8vgUEwolv9jgN48sOfvyr8FVbWgCLFi1i0aJFI/7t6quvNv4sCAKPPfbY11rft4Wj9xv6F2P4CUpVVTo6OmhubiYzM/Owqh57YpikHC6R2B+OVEtr2PRs9+7dpKamMnXq1AOmfh8Khwq49Fq9hBIhPJLHeBK0m+zGOoa1PXtib9+SvUdId/btxBf1ke/KR0NjVfMq0rV00sPpmF1mYlKMsRm6Y6tdtjMQGaAn1DPixjw7bzYzsmewunU1ZsmMgIDH6qHIU4Tb4iYlkkKf2mdM2LT6W3m95nUunXgpveFeo80lCAKSKNEd6mZV8yp8MR+xpB4nMiFXn6ZJtaXyuwW/wx/zYzPZsJgs9IX76A33UuDWpxyK3EU09TaxuXkzXpeX0vxSrqy4kmh/dL/HdfjG7bV66Qp2Ga7TqqZiES3c88k9tAfb8Vg8fNj8Ies71jMmdYw+8SM7CMaDJFV94k8QBCSTRCQWQbbLKIqC0+SkPdSOXbTrT7GiRIophUQiwf4mentCPTy77VkGIgOcNuo0Tht12oj/d1vcKJpi3MRFQSTflc8bF7xxUH1RZ7CT3675LVbJanjk3PjBjbz7vXc5q+wsXq99nfvX3U+BuwBZlOkMdjIhYwILSxaOaMNMyZzCrNxZrO9cj4iIJErcOu/W/b6nIAjcOPtGFpYs5M26NxEQOGfMOTTsbECJKmzu2WycT4PRQYbiQyz+dDGPb3ych055yLgpL1m/hKU7luKL+ogkI2Q79Gm3W+feagSLJtUvSDfo57rX6uXCsRfyyq5XjH+/efbN2E12omKUhJJAQ/tKuqzDRetQK//Y/Q8iyQhnjDqD8TnjCQQCTJo0ycgT+++0/2Zr51Z6h3rp9fTyetfrhCNhEOGC8gsodhcD+m9xmLyBLsg+WFVwT0zMmMj3x3+fV3a9goZGiauEi8svBmBe3jyWNSwjx5FDNBnFJJooTzv09NaRwNFe4TmWlK7jGOE5ADRNo6Ojg6amJtLT05k5c+bXIitHkvCYTCYikcjX2sfg4CB1dXUkk0ny8vIMn4VvCt8d/10e3/A4Q7EhFE1hatZU42IkCAInF5/MsrplpNnS6I/3U2ItodRbOmIfJZ4S0mxp+li3yaZPxKSW6WZl4QiBgQB1tjrOXHAm8UQc21YbQ7Eh3BY3cSWui5L3EtLaZTuPnPGIri/q3kJXqItALIBZMjMQGaBqoMogLKBXld5veJ+Pmj+ibqAOURCZkjWFmBKjI9CBxWShuqeaYDyI1WSl1FvKax2vcV7wPLKdeqbUnkGedtmOiEg0ESUeiTPgG8AkmpBdMmHCdAY7iSiR/ZKLPXHphEtZvHYxrQF9bL4io4IcVw7twXa8Fi+BeACbSdcjhRNhnBYnqqYiizKZbr1NY5bMBBNB7CY7Df4GvSopqrgsLsq8ZdQO1mI32dEUjZ5gD6dlnMaG9Ruw2+04nU4SpgQ/+vBH9Ef7ERF5q/4tfj3v1/yg4gfGOivSKzh91Oksb1yuT3UBv57760PetNsCbbqxmmQhlozhkB34oj76I/08V/0cb9W9hSzKNPoaiatx3WFZlNnYtZHbj7udzmAnv1n9G+oG9e/s4nEXU5Zaxvj08eS5Du6PVZFRQUVGBaAbGt7WdBs+0UeWPYtmfzOBeAANDYfsIJQIYZft3LzyZt6+8G3ebXiXF7e/iF220xzTp+pC8RAZ9gwWr13M6aNOx21x84PxP+DxTY+jaLpWyi7bOW3UaRSnFHNq8am6bs1bxoSMCfT29fLk7idZsWoFGhrHFxzP8QXHk2XPYn7B/EPGnRwu2gPtXPb2ZQTiAURB5I3aN7hn7j1kizpx21P0vKd249y+c6npqcGiWMgQMti4cSOCIHCC8wSqWqtojbciiPrv4ayys1BUhV39u4gkI4xOHb3fyAdBEPhO+XdYWLKQmBKjr7UPj03/Pf1o4o/Q0Pik7RNcZhfXzbjugMnmRxr/zhWefyccvd/QvxjDLaiv0t7ZH45kG+rr7GtoaIja2lpEUWTs2LH4/f4jpgc6GEZ5RnHrcbfSHmg3iMCeF+azx5yN0+ykuqcak9PEdbOvw20Z6RvhMDu4dua1fNj4IYPRQU4vOZ36vnra29uRTBL2FDtlRWXsGNiBU3JyQf4FvB96n6HYEKqmcunESw0n5j1hla38cNIP+SE/5Edv/IhST6nhzGyVrHQGOo2n8npfPQATMiZQmFLI1u6tbO/djtfmJZwIE0qECCVDWE1WUqwplHhLaOluYVffrv362NhMNhblL+KZTc9gs9gQrALheJgMKYNmfzP1g/X8ZPlPeHjKwwc9viWeEn534u+o99VjkSxUpFfQE+4hEAtQ018D6E/SKZYUoskoCVWvDpxafCq/nPNLHtv4GLW+WkZ7RvO/u/4Xk2gyCFIsGeOWObcwKXMST295mte3v86QMsQK3wpSs1O5tuhaIuEIr+98nZ5AD3ZJH3VOakmWVC7h3OJzjfFnQRC4fd7tVPdWs75zPSbRxCu7X+GM0jMO+pSf58xD1VRD0BxOhDFLZkRBZFn9MjLsGbpJYDIKgu4ULUsyz257FlmU+aDpAzqCHQzFhwB4sOpBXj3v1UOSnb3RE+6hPlhPZ6wTVVNRUQ2Nk9vsJpzUWyjBeBB/zM+Wni2Igj69NWyLEEwEyZVyiSgRBqIDuC1ufj7j5zhkB2/Xv43H6uGmWTcxyqNPpM3OHRlj8Vr9ayxrW0aGK4Oh2BAvfPYCr+1+DbtsZ27eXJ5e9PQRyS0bxpt1bzIUGzIE94F4gOe3P89tY27bZ1tFVRiIDuCQHZSkl1CSXoKiKrzb+C41kRqKnEWcmH0i6SnpfNzyMUpcYVrKNLrqu7iv5T62+7djNplxWV08ePKDBxSB22U7dtlOr9ZryAQsJgtXTb2Kq6ZedcQ++5eFoihYLN+8OPqr4liFR8cxwnMQFBYWfuXE7b2cVrRxAAAgAElEQVTxTehuDgfBYNCo6IwePdpg+8FgkHg8fkTWdSik2lKN6ae9IYkSp5Wcxmklp1FZWUmqZf/bea1ezh93PsFgkC07ttCv9jNkHcJkMpHvyOefNf9ERCQYDzJZnsyDpz9IX6QPt8W9Xw+aWDLG6zWvs7t/N/mufGP8OKEliCtxXCYXRd4iqnuqcZqdeK1eMuwZ2GQbNtlGeVo5p486nUx7Jjd+cCNZjiz6In0oqkIkEUHTNDQ0LNK+F0Ofz0dNTQ2pUiq3nnwrJtlEb6iXRzc8Sr1Pn/xKk9PoDnTzctPLzJ8x/6DHd28dTa4zF1VTDQ8ZVVPJcGRw86yb0dBIt6czN28uoiByx/w7jNdt6t5E3WCdLtZFoMRTgiRKZNgzKE8rZyA+QJpT1728uP1FMuwZXDnlStJ60zDJJmwWG4qqoCZVookolTsrIa7rpZxOJ//X/n9s7d6K2+xGEAQqOyp5YN0D3HX8XQf8bDnOHP5r8n/xyIZHEBRdrPrgyQ8aI+gCenSDIArGMfdH/QxEB3hk4yME4gFAtyAQBIGYEGPJhiX85T//ctBjujccsoPWSCtJ7Yvfn4ZGKBHSK3VKlN39u/FYPQgI5LvyUVRFj4BAIKEmMEtmOoIdpNnSyHF8HoUiiFwx5QqumHLFPu+paiptgTZUTaXQXcjGno26qeTnWi2AiBIhmAjyeu3rNP+9mVe/8+oBtUkAzf5mmv3NZDuzD+lFE0vG8Mf8dAT16TiX2UW6NX0fPWJ7oJ07V99Jd6gbURD52dSfcUbJGfy+8ve8U/+ObkypJtlYsJF7TriHueV6LIumaSyvXU61v5p0OR1FUege6OaOd+7g11N/PWJcfu+20dHSSjpa1nEgHCM8Oo4Rnm8JR7rC82WrMnvmXY0ePXqEOdnh7uvL4HBjKvaHgyWd7/l5KsZUsGTGEnrDvcSVOPesuYd0Wzrb+7bTE+xhfXA91i1Wrpt1HZIgsaN3B0PxIUq9pWTYM9A0jSc2PcHatrV4rV529e9CQGBz92Za/a1oaMQTcTI8GZSnl+uGgqKJjkCHsZ6EksBr89IebCfXlYs/5sdr9dIZ7ERSJXwxH8WOYiZlfCG+DoVC1NbWkkgm2CZsY2PPRoQegUJ3IWePOZtwMoyqqphEE7FkDJfZRXu4nWgySk1/DYqmUJ5Wjlk4eOVREASKUorIcmQRToaxSlbdBVoys7B04QFfd9H4i3hpx0s4zA5ERERRpDxVbz++UfsGwWQQJaLglJ2YJTMftXzElVOu5ITCE7BWWmkfaieUDKFqKmbJzAP1D+C2uLlo7EUsyFrAtuptKKqi64DQb+ifNn/KQMUATqdzn4pqUk1yzbvXsLxxOZqmkS6n88JZL1Ds0b2JxqWN46OWjxARDZ0RGvRF+zAJJpxmp9F2EkQBCYmYEqMt8OUymIahabrYeU+yMwyrZMUX9yGiu4E7ZAd3rr6T35/0e1Y2r2RH3w4yHXruUygeIqbEcJvdbOvdxsycfX2khhFNRrnhgxvY0LUBND2RPcOSgaIqaOjmiRoaCSWBLMqomkqTv4k7Vt3B42c8vt99vlP/Dv/z6f8YJPHyyZdz+eTLD7gGj9WDL+ZDFmQQ9Em7YZPLPXHf2vvoD/eT48whlozxyMZHSLOn8V7je2Q7s41K16ftn9I81Gy0mwRBwJ/06xEZLl3IbElaiGtxsrKyCAaDdHR0jMgTG26hJRKJo8Lk7lDmrf9qBIPBAw49/P8JR+839G+Gb7ultb+8q/1dGI6kp88wUfm6Tzr7G3GPx+M0NDQwODhIaWkpGRkZxufJdmbTE9Kt/tuG2ugN9eKxeYiEI1R1VPFx08ds7N7IisYVSII+ZfS7k35HYUohVR1VFKcUG9qanX07SSaTlHpLiSVjtPnaaPA3MDN/Jv2RfsP5t9mv6zGyHdmcOupU1rWvw2v1ku3Ixh/VRcmzc2dzwfgLMHeZkUWZeDxOfX09g75B+px9VPmq2NC5gePyj0OWZFr9rWzs2sj3xn+PB9Y+gBAV0AQNWZDZNLiJ+X+ZT4olBbtsJ8OewX0L7iNFPnhffkbODEPTsKV7Cwk1wQvbXyDdns6MnBn7fc355ecjizJrO9biMru4aPxF5DhzaAu0saNvBwktgazK9Ef6DWdj0MMdr595Pbd8dItOfD+vaGzt2crpo07nxZ0vUpFVweS8yVT2VmI2mY3JsNKU0n0cgV0uF06nk9daXmN5w3L9holGV7SLxesW88TCJ+gIdtDobzRiQ1wWF8UpxcSVOKawiTSrXuWQBImkliSpJEHUvXa+bL5XQklw68e38squVxAQkJFJkBixjYpO0AV0IzyLpJvvRZNRnjrzKbb2bKWqs4rntz1Pmi2NQCJAOB7mzlV38s733jngez9f/TyVHZWk2/TK3aauTSzMW0iOI4eB2ABm0ay38dArTYIgkGJJYWvP1v3uL5wIc9/a+3DKTiwmC0k1ybPbnuXU4lMP2D7qDnVT5inDF/OhaPq0VUyJjSA8iqpQP1hvtAgtJt1dudXfqudkfS7IHnbNTigJ+iP9WE1WHLKD0amjjX83iSYGIgOcXHTyAfPEgsEgfr8fv9/PZ599NsJB2uVyYbfbv9U8saO9wqNp2lG9vm8LxwjPQXAknxy+rZbWwfKuDrSvI+npcyR++HtWePaOtSgvL9/v5/FavaTaUqnpr8EsmYkkI5hEE6m2VNa0rWFN6xojDsIf9XP/2vt54swnQNMrDJIgEUlE8MV82M12SrwldAQ66JP6CMaDKJqC1WTFYrLwh1P/wLbubZgkE7NyZ+G2uDl11Kns6t/FqpZVOC1O5uTP4Za5t+AwO9jQt4HGxkb6+vooKSnh0+invL7jdQajg3QGO9E0jROLTsRr89Lsb+b2+Xou2AeNH7CzfydD8SHcJjedgU4CsQDHFR5Hb6iXFz57gWumXnPQY3lJxSVEE1Ge2voULrOLeVnzcJldPL31acaljzN0M+s71vPIpkfwRX3MzZvLdTOu47zy80bsa2v3VgpcBXQHukmqSWMa7Bczf2FsE0wEkUUZq8VKMBE0jAR7w704zU66g91cO/1aVreupnaw1qhC3XvqvUYLZtgReGhoiF5/L6vqVhFLxox2FMDmrs2oqsr7je8TioeoSNdFxcF4kGxHNi+c/QLf/ed3qeqowizqWh8JCafZqWeymWxcP+t6uoJdxNU4uc7cA+peHqh8gFd2vWLEnigoWESL7oyNTuyGJ/KGDSV3DeyizFuGxWRBlmRm5MwwhNc7+ncQiut5V81DzWzp3sJgdJD3Gt/DITu4aPxFhmB/Z99OfXrw889tNVlpCbbw2PzH6JK6GIgMcN+6+9jVvwuAHEcOgXgAp9lJ/WD9PsJ/f0zPNxv2kjKJJt3ALzpwQMKTac/ELJmNcfGeUM8+LS1JlMh2ZuOP+fFYPcb5MRxPsr5zvW7eqGqUeEu44YMbaBlqwWqycu30a/nB+B9w5eQreXbbs4an1c+m/WyftQzniTkcDrKysggEAkaQ5bB5YktLy7eeJ3Y0E56jIcn9aMExwvMt4UhMVu25r71JypfJu9ofvgnCcyT2k0gkaGlpoaWl5ZCxFqBHAvxi1i/4he8XVPdWk2nPZIJ7AnEljkN2GCPQAC6Li65gF7UDtRSmFLKtexuBeIBGfyNWyUpSS5LpyNSnu9Q4HpOHuBKnO9TNBWMvINeVu4+53NburfSF+ihyF3HaqNNYWLYQAYG2tjZ8Ph9ut5s5c+YQUSK8teYtCtwFOMz6pFFHsIPB6CDheJh5BXog6aUTL2V3/24+bfsUj8VDJB7RPYrUOA0DDfhiPt5teJcLxlxAjmv/rqaaprGpexNdoS48Vg/Ts6cbrsP9kX6GYkM4ZAfN/mbu+fQenLKTDFsGq1tXIyDwq7m/2ucYmyUz89Pmk7AnCMVDlKeWj7hRDh8XTdP0qoqaNHx8VE0lnAizsnkld82/Sx8M0FQmZU7CarLyccvH/GP3PwA4u+xsPm3/lC09W2iN6NM8kiQZbaVccy4bN26kvqOeWCxG1BTFJOmXs2E7gycXPslNH97Euo51jEsfR5G7CF/Uh12286u5v+K9xvf4uOVjBEGgwFVgBFaO9o7m2unXGj4x7ze9r4uORT3CwiJasJltiAlRb01Z3PhiPuO9h8NqSz2lI4TY49PHE4gHCMT0aScVnWj/1zv/hV22YzPZSCgJPm3/lD8v/LOu/9EUuoJdRBNR0uxpRJNRytxl2GU7x+cdzys7X8EpO/FavGiaRl+kj4SaIJKMsGDpAm6edTMLihaQac8k25lNui0dr9WLL+rDY/UQiocwiaaDBpt+p/w7fNTyEa1DrQiCoLcnR180Yowe9DH72z++ne5QN4qm8N1x32V8+niyHdkE40HdffzzKcb+aD9mUa/w3b/ufsaljePCcRdyzphzjN/sl3ngHCYakiR9pTwxl8uFzWb72g+3/18gPEdD6+9fjWOE5yA4Wis8e1ZADifv6kDrOpoIz7A30LZt2w7byTrXlctfz/krj254lJr+Gnp6ejgh9wROKjqJFU0riCQjWCUrXcEuBEHgwXUPGvEOvaFexqePJ9+Vz7aebVT3VDPKM4piZzGTciaRVJJ8p/w7nDLqlH3et7qnmnvX3IvT7EQQBJ7c/CRyXMY55MTr9VIZreShDQ8hbZY4s/RMY2In3Z5OgbuA2sFa2ofamZYzjXPG6LlbD617iB19OxAEgfZAuyEgNpvMtAXbQNOjFR5a/xC3H3f7fkd417St4dltz+KUnYQTYda0rGFB8QLdA0m2G+Rn98BuVFU1bvDZjuz9ug/PzJnJG7VvUO+rJ8OdgUk0ccmES4z/TygJjss7jlk5s/ikXQ8ERdCrCA2+BnKdufz0vZ9iEkwktSRlnjLcFjclnhKOzz+eB6seNMImr//getJt6brzsi2d3sZekloSWZDJsmXx+NmPk+PMwdvv5eNlH+v6GU0knAizMGUh1dXVOJ1OFs9ajNPpxGLRWyyxZAyzZObjlo9Z0bRCT6xHYFn9MobiQ9gkGyubV7KmbQ3/PP+fmEQTmfZMagZqkJFB06s4l026jEgiwsbOjdjNdta1rzOy0DRNA0E3ytzQucFoHY5JHcNJhSexdMdSVHR9k1N20hpoZWb2TH0KjTg9oR5e2/0aVZ1VrOtYR1yJ0xpspTfSy6nFp3JR2UUIgsAbtW9w28e36dEXokwwETR0X2E1jIrK7atvx7vei0k0ccvsW7hq6lU8fOrD3PThTXSHunGZXSw+cTFJNcnyhuXYTDbm5M4ZEcfgtrh5/IzH2dS1iYSaYHLmZOL+OK3+Vl6tfBVf1MdJRSdxStEpPL3oaTZ1bWLpjqX8Y/c/eLfhXao6qxAQSLWlkm5LZ0PXBtJsaciiHgkyEBlge992ZuTMwCyZD8tX6GBmrt90ntieOJoJTygUwuH4cj5H/+44Rni+JRxJwjNs8tfa2npYeVf7w5HU8HwdwqNpGv39/dTW1qKqKmPGjCE7e98x7kPBarJyw+wb6A33snH9Rs6ceiaCIHDLnFt4uOphBhQ9/iASj1DkKUIURIaiQ3QGOylwFyAKImPTx5JQEtx/yv0MtAxQnF+M13vgIMwPmz7EYrKQakslHovTF+zj7d1vc9+Z97GqYxVvtr9JYWohJtnEq7teJc+ZR+tQK16rF5tsY0HRAu48/k7DiTqhJKjsqKTAVcD2nu16rpCmV1iiySiCJjA6bTSzcmbR4m+hfrCeadnT9lnXyuaVpNvScVlcHJd/HKtaV7G9bztjU8dy3YzrDFdal9mFimoIziPJCCnWLwjUUGyId+rfoSfcwylFp1CUKCK3OJeZOTONCZ9tPdt4dOOjRJIRcl253D7vduoG62j0NVLdW01SS7KpexOSKJFpzyQYDVLVWUWZt4z6wXpe3P4iJtGERbIYGVYRJaLnP5msTM2ayokFJzI9fTqusMuwFyhLK+PPZ/6Z56ufJ5QIsah0EQtHLSQajRo6j/b2dmKxGLIs00svzzU8R91QHZIoUeQuIpqMMhAdQBIkI6i0ZqCGLd1bmJEzg7vm38W5/ziXqBJFQMBr9nLNtGv0VPrOSpJqkrLUMrb3bkdDwySayHZkk+HI4Jltz4zQSl047kKWNyxHEiREQZ/qSrOl0RPuoSvUpbsDJ8Ms2bCEUEKvvoiiyGj3aOJqnGunX4s1YUUURV7e9bI+Afg5OQklQ4QTYRRG/gaD8SBp1jQeqHyAEwpOYFz6OF77zmtG66tmoIYLXruAaDKKpmmUp5Xz9JlPY5Ntxj76I/38767/pcXfwpSsKSzKWsRtVbcRJYosyqxsXolvlo+zR5/N89XP0xfuI82WxqpW3YQzzZbGYHQQf8yPgEBSSeqE53ODqT3zzg4Xh/NgeqA8sWQyaVSDDpQn5nK5DOK8NxRF+VY1Q4cDv9+P2+0+9Ib/P8AxwvMt4UgRnuG8q1AoRDQa/crOz8M40i2trzLG7/P5qK2txWKxMHnyZN1X52s8LYmCSJYjC4/ZY1ycTh51MicWnUhMidHka+KBtQ8YLS6P1WNkAJklM/6on6nZUylKKSJsCh/yM1kkC/G4HjyqqioWhwVXqguf4mNt+1pskg1ZlJElGZfZRa4rl1JvKdt6tjEpaxI/mvSjEeP6kijpJoDxIBaTBavJylB0iEnZk2j0NXJS0UkUegrRVL2aIIm6/uivn/2VLd1byHHlcMWkK5Al2ZgoSrenMzVrKmeVncXZo89GEiTD7XhmzkymZU9jc9dm3W1ZkLhlzi2APiW0eN1iOoIdOEwOqjqrGCeMG2EmOBgdZMn6JThkB2m2NAYiA9QM1vDgSQ8y5dkpuMwu+qP9qKioqkowESShJZAECUmUjBbMcCbVQHRADytVvsh4UzWVqdlTmeKdQlvbyOmqcenjuP+k+wF9NHpZwzJkUWZ27mxKM7/QsNT11XH+y+cTToaNMFQlplDkKtInykSzcQMW0Nttw/tfefFKPmz+EAmJ3FCuYQFw1/y7uGv1XbT4W5BEvYWnodEV6iLbkU00GaU71K1PNjmyWFC4gFvm3ML96+5HURVm5c7i/DHnc8MHN+jWBQKIiEQSemipRbKQVJL44/r0n6IpX8RixMP4Y36G4kPGevd2J4fPNWqfT641+huNFqQsyviiPu5bex/RpE5cgvEgVR1VvLr7VS6dcCmg++5cvfxqBqODOGQHyxuWs7pptR6H4i1EURXqBuu49v1ruemDmwgkAjhkB+m2dCNFPq7oQbihRAiv1UtCSRhxG2XeMhaVLNpn3d8mTCbTYeeJ7SmQHvaYOhpxzHTwCxwjPAfB0dTS0jSNnp4eI+/KbrczevTor70uURSPmKjtcKtFwWDQqOiUl5cbTyGiKH4jZoiSKGEX7eS787Gb7fSF+0ixpCAIAhMyJrC9dzvBeJBUWyrfHf9dYy0HIzzxeJwxwhheC7xG3B5HlEXqBuuIa3F+/u7P9fRuLWZsH01GUTWV6p5qYkqMde3raBhsoDilmMumXEaqLRVREPnp9J/yUOVD+jSMIJJhydDHfZUYoWRId2BORCh0F1KeWs7D6x9mTesaUm2pbO7azK2Dt/KzqT/j6a1PE01GSSpJUq2pLChcwIbODSzdsZRYMsas3Fn8oOIH3DX/LjZ2bSQYD1KeVk6+Sw9krBusozPYSaFL13h4LB4qWyqpG6yjfrCeFEsKKZYUFFUxWmKptlTaA+2Gq7Yv4iOa+CIaIxjXwz4RwBfx0R3qRkUlqSUJx8PG6Lzb4tZHxzWYlTuL4/KPIxLSdXCBeIDB6CBZ9iyjwlE3WMcdq+4gktT9j17Z9Qr3n3S/IYZe3rycqBI1KlvhRJjmSDM5KTlkWjMJJoIEo0E9T82egyfqob+/H5dLJ6mXTLiERCLBZ599ZnyWbT3bqPfVE1WiRlxCUtV/A+u71lPkLuKq5VchICAKIrfOvZWrpl7F5ZMvJ6EksMk2+iP9lHhKiMR10bwkSnr2lMVjGCWGE2FKPaWMTx9Pf0c/jUONDMWH9BaN8sX5tT+omqrbJIgSf63+K7esvIVATB/TT7Wl4ov69HDYcDNo+vof3fgoF469EKvJyq7+XfhjfuM4WiQLtf21OEx6m6RpqIm+SB9xJU5MiKFoCsG4fhyH9Th22W78+cmFT/J+0/vs6NtBeVo5t8691dBfHU04VJ5YMBiktbWVcDhMKBRi+/btI4jQkTCsPRI4Rni+wNF3lv2b4qsSnuFWT11dHS6Xy8i7Wrt27RELIz1S+LIVnmg0Sl1dHaFQaL/eQF+1UrQ3DhTY6ra4+eXcX/LMlmfoDnUzNXsqdpOdV3e9SmGKfmP/Y9UfefDUBw9ICBVFoaWlhY6ODsaOGstTFz7FqpZVvFv/LqM8oyhPK0fVVGoGahAQ6Ah2YDKZcJld9IZ7yXZk0zrUyurW1aiais1kY+n2pbx38Xuk2dNIs6WRac+k1FOKP+bHqeheMv+z4H9Is6Wxs28nbrObmVm6h8unbZ9+Ec4qO+gMdmKSTPxy7i/Z3L0Zq2RlXv48BqIDPLX1KTIdmaTaUvmk/RNsJhsXV1y8j6PvgeBL+Ljm3WuMEM6JGRNRNIW4EscsmQklQpglMynWFBaOWshft/8VQRAQNdFonVlNVkyiia5QlzHSHYwH8bg8BBNBspxZuC1u8px5XDX1Ksanjzcqch93fcyLG19EQ8NtdvPwKQ9TnlbOSzteAvgi92yolRWNK/je+O/p58NeIluLZMFlcfGnRX/CaXbyUNVDbOzayGjvaK6fcj3mpJnBwUFaWlpIJBJYLBZsNhuxWIz3a9+nLlDHnzb/iYQyckR9T7xZ/yaLShdhl+2EE2HuX3c/L5z1AhaTxZgKS7WmkuvIZXnv8hGvTRVSybBlMBAdYG7eXB465SH9/FF7qfHr59VwPMfeGK7gGRUrQcAkmHi/6X3yXfmEEiE0TcNldqGoCq2BVqyS1TBuDMQDfNTyEQtLFmI1WUdUlgLxgJ4UL+iRH33hPn0U//Mxd9BH5IerXSnWFHKcOaiayqnFp7KgaAEnFZ/0pc61oxGyLOP1eke0uauqqigqKiIYDI44Z8xm8z4C6W/7mu33+48Rns9xjPAcBP/qCs9w3pXFYmHSpEnY7fZ99ne0PEXAodtjiUSChoYG+vv7KS0tpaKiYr/H+EhVeIarM/u7wGTYM6jIqCDFmsKY1DE8v+15RqeORhb19mDLUAvbe7eTKWYa5EvVVIZiQ/h6fbS3tJObmztCO3XJxEt0Eausf0+iIOqj4Pnz8KR48Kt+sh3ZVHZUYpNtbOzcCOg3J4/FQ2ewk0fWP8IF4y7gphU36TdkswtVUznJdRI3/seNRg7XhMwJqKpKPB5HRW9NKaqCKIlGC8gsmSnzlo1I5d7ctVk3xzPp+oxsRzZbe7ZyccXF+z2GZd4ycpw5tARacJgcDMWH8Cf8ZFgycMgONE2jureac0afQ2VnpRGfcN2M6zBLZu458R5e3vUy0WQUURSxCHqLbunZS/nJsp/o1RzBrLcUtSTd4W7Gp4/Xk7MRDHPAYbLTMtTC0/VPk+5KxyJZ8Mf83Pjhjbx5wZsE4gEsSaCvF5wuQ8g7jLNGn6VrYz4fCZclmWumXWN4x9x9/N2A/pDRFeoiqSUZlTkKSZQMsavP5+PvO//ORzs/QkKiP9xPXI3v1wRyz5R5TdNDPn1RH0PxITJMX7h+BxNBVrSs2Of1rYFWLqm4hHNHn8tpo04bEYLqNDup99Xvo9cZxjCJVjSFXGcusiTTFewikdSn6zT0qbNwMkxhSiE7+nbo548oku/ORxREIkm9mjY+bTyzcmaxtn0tMSVGV6iLNHMaXpuXwfggTrNT/6yfkxwBAbNkJs2eppPHmdfT6G+kwF3AiQUnHrHr6tEybj1MBIeJzZ7/Ho/HjWpQf38/4XDYGK3fkwh9k6aFxyo8X+AY4fmWcDg/8r3zrvacMhjG0Uh4DkRUFEWhubmZzs5OioqKGDNmzCG9gYZdeL/uevZXKUqqSX6z6jds69mGVbLybv27DEYGDXM34/WCaOyjK9jF3R/eTW13LQ6rg5uPv5lRxaP22ffo1NGsbF6JXbajomc/+WI+lu9ajmgSSSpJEmqCdFu6cXOQRAlRFJEEibZAGysaVyAIgqHr0dDYFdw1InR0T5hEExePv5i/fPYXZFEmoSaYlDmJcWnj9tl2MDbIpu5N7OjfQVFKEanWVCOpfX+wmqz8as6vDNHyuLRx3N51u0GYBEFv1YxL18eKB6ODZNozjbXbTDZKPCU0+hv1AFRBN6XLdeXqvi1xvyFejSfjZDmymJo51SA4oiAa+VkAbcE2BAQjqiPFkkJPuIeh+BAntUj8P1uWUWeGmKRhzSlkxnG/Nl5b6C5k2XeX8YfKPzAQHeDc0edy0fiLSKpJFq9bzFu1b5FqS2Vc2jia/E0ICIxOHc1t827DZXZhtVpxuB2sGlzFmOwxmEQTdqed1W2rUTQFCckgIJIgYZfsRJQIvqiPVS2rjCmqde3rOGv0Wca66gfrDb3Q3nj09Ef3CQPVNI052XMO+htyyA48Vo8RCWESTUjoxM1sMiPE9OqnWdQ9qwpcBUiiRIolhZgSQ0NjWpYuhJdEiQdPfpC369/mma3P4JAd5JhzkGUZV9LFuLRxVHZU0uhrNG7+ZslMnjOP357wWyZmTOQETjjgWr8qjpYK94EmtARBwGKxYLFYSEtLG7H9sEC6t7eXxsZGkskkVqt1BAmyWq1HhBweq/B8gWOE5yjCgfKu9ocjKTY+UOvncLE3UVFVlfb2dlpaWvaphhwMh9LNHM569ref+sF6tvdup8BVgCDobYGByADNQ826583nk0YTMibQ19lHMBjk3pX3MpgcpKKggoSW4NFNj1KaXrpPGOklEy+hNdBK/UC9Ec65dMtSUu2puOwuNE1jZ6TJDPMAACAASURBVP9OagZrSLWl0jrUSqqcSjgRRhIl5ubPJZaM6SPKapxYMkYkGcEjHDwH57vjvkuxp5idfTvJdGRyStEp+xjptQ61snT7UkCfuukKdjE2dawhUB6Gqqmsa19Hk7+JHGcO8/PnG20hgL+7/05zsJlsRzbhpD7SW55WTpYjiyxH1oh9RZIRSjwlFKcU0xvuxWV2YZftxJQYv573a65YdoXhFCxLMnlO3QunxFNCMB4koSb42bs/o9HXiE22MStrFklVJ43DIluX2YV7KMbxv3mKJedoDFpAVsDd1EJN00YmZ0421jPaO5onFj5Be6Cd/kg/4WSYu1bfxd+2/41oIoqGxtr2tZxddjYplhR2D+zmpR0vceWUKwGMNs0wCSlwFzAlawpF7iKKUooQEHiu+jlkQUZRFS4edTHP1j1LXNVJm6qo/PjtH7P6+6sZl6WbgmbaMxERjdbeMIZ1P3tDVVU9xy21nP5w/z6vEwURWZKJKTEcJgcJJUFCSRAnTpotDbNoNtpPDtmBQ3bw2H88xj9r/smq1lVk2DP41dxfjfBXkiWZc8ecy/rO9Wzr2YaW1Ayym+3M5sWzX+SdhneoG6jDLtuZlj2NOblz9vGrOpI42gnPgSBJEm63e8Tk1LAdx3A1qLu7m0gkgiRJ+4zLH+5Ax9DQECUlJYf1mn9XHCM8B8G3pbo/VN7V/nCknZuPxFilJElEo/poa3d3Nw0NDaSnpx/2JNmRInMHrDipyoipClEQyXRkcs30a6gZqCHdls5/jv5PREWko6ODcDxMQAowJlOvTMnIDEQGaA+070N43BY39554Lz3hHt1xWLLyt81/M8iHIAik2dL4yeSfUOAq4J4197CtZ5uRb/WDCT+gJ9TDS9tforK90ijbT8vZd+x8TwiCwOzc2QfV4Wzu3kxciTM9ezr+mJ9IIoLD7NjHdO7v2//O+03vYzfpFYrPej/jmunXGDffSwov4cPEh6zvXE+qNZVfz/u1IXLeG13BLiLJCM3+ZvwxP3ElTpG7iGx7NmPTxvLqea/yfPXzLG9YjkWy0DrUSlSJ4rV5KXIX8fcdf8cX9aGiElEivNf8HlnWLHxRHybRhCzKLF6wGKmllepcCU8UJvfo7x21mnhn9xtcOOsnI9Z095q7eWLzE8iibEzDRZPRES2jtkAbHquHFHMKdYN1xmutkpXpqdPZFdyF1+IlGA9S6inlj6f90TAZPG/MedQN1jE1ayp22c6fa/6shyt8vn9VU3m+8nkuyLlAz49yOvn5xJ+zZNsSQ3MD8Nyi5/Z7TIdNEAvcBaRYUvDFfCNeN9xScpgcFKcUE4gHCCf1JPnb5t5GtiObdR3r+KT9E6ySlZ/P+DmTMicxKXPSft9vT5xVdhZVHVVE4hFkZBRBYVHpIkZ5Ru3XGfmbxNHifZNMJr/2OgRBwGazYbPZyMj4ot2ZTCYNEtTe3k4oFBqRJzYcv2I2mw94vzrW0voCxwjPITDseXOk9rXnU8mXzbvaH74J/5yva7suSRLBYJDKykpcLhfTpk3DarUe9n6OVIXnQPsp9ZaS58qjbagNp9mJP+Znfv58FpYu5MyyMw2t0cDAAF6vlyxzFunBdALxAG6LG0VVUDTlgN4hkigZREjTNMo95dQGaskz5xGMB7GarIxPH09VRxULihbw40k/ZnrOdDIdmSTUhJ6y7c43hK357nx2de2iI9DxtZ6Yh8euh3PDJFHCJY9slw7FhljZspIid5GhXdnSs4WOYIdBapwmJ/fMveeQ77e5azMPr3+YcCJM3WCdUYkY7B3knP87h7cvfJtZubNY3rAcp9mJ3WTHF/WRUBIoqsKJhSfyt8/+NqKCoaLiT/hZPHsxZallFLgK8Fg9aKY+pESSPXXJiqZico280K9uXc1TW57S09w/d34ertoMt9wQvvjd++N+5uXPG7EPRdXdj4PxIP9Z+p/8cOIPDbLzRu0bvLj9RQQEPmj+gBtn3mjsS0AwiMnYUWOZNWmWofG43HI5k+yTWNu5FkEU+H7Z98lyZuH3+/cxwRtuG+W78smwZejREwj0R/pBALts5/KJl7OuYx0xJUaqLRWv5qU73E2GI4Od/TtZsmGJTvwR2Nm/k1fPe5XRqYee+pyTN4ffHv9bnq18lhR3ChdPvJiJGRMP+bpvAkdTheeb0uCYTKaD5on5fD7a2toMn6m9W2Imk+kY4dkDxwjPt4g9qzKHk3d1oH0dTQ7Jfr+furo6EokE06dP/1rOnkeywrM/wmMxWVh88mL+Vv03Wv2tVGRUcFHFRWiaRnNzM+3t7YbWqLOzk1gsxvWzrue+T+8jEA+gaArnjz2fEs+hy8SCIHD95Ot5puYZ6oJ1ZDuz+e+Z/82SqiW0+luxmCy81/Ael6mXMSZtDHd8dAf+mJ/agVpOLj6ZPLcuqO0UOvFFfYckPAdLq5+TN4eXd73Mzr6ddIY6UVSFH074oeHHA1/EMgz/fbhtcaBpIGCEFmlP/LP2n7gtbmoGavZpu2zp3sKfN/+ZG2ffSCQZIakkaQ41G149a9vXMjt3NuFEeN9jih5vsOeNVktPZ8LND5P19nU0pwqYkyqRyRVcNeXSEa+tGahB1dQRx2iYhKioSJqExWTBZrLREexgbNpYLhp/kbHtvKXzqPfXG3/vCfVw4+wbAagdrOVvn/2NLEcWsiTTG+rlya1P8p0x3+G1mtf090Ug1Z7KhWMvBMBsNhuRCIWFhZzP+YbGIxAIjDDBG36qj0QiJJNJLpt0GWta19AV7iKWjGESTbpuLBnnld2vUOguxBf1MRDVQ0anZU/DbrJzx+o7iCkxJEH3e+oKdvHctuf43YLfHfA73hNz8+fi9rspLi7+lzr4Hi0Vnm97HXvniQ1jT4F0c3Mzv/jFL/D5fNjtdlJSUlAUhcmT/1/2zjxOjrrO+++qvo+57yPXTGYmB7nILQiBACJIAnKtgLIo6q7rIy4exFXXRREDCI8s3o/KsqIiCBo5BAwYjnCEhIQASWYmc2buu++ruur5o62ie7p7pmemZ7rV+fjilZc9Xb/6VXVV/T71PT6fNTH1RKlgZGSEq6++mvb2dhYvXszDDz8cJ8R66tQpPvaxj9HX14coinzqU5/ipptuSsvxphPzhGcOodPpaGlpYWRkZEp+V4kw1+7ryeDxeGhubkaSJBYuXMjo6OiMH4KzHeGBiLLr5zZ+DnhPzLGtrS1OtVodY0XJCv77A/9Nt7ObXFOu1r6eCvJN+dyy7haqqyMRkgM9BzjlPKWNEQgH+M27v0GSJWRFpiqnim5XN/s69vHhZR/WxNvK7GVxY4flMM+0PcPzHc9zuO8wRr2R5UXL+cKmL8SRo3xzPp9d/1mue/w6fKGI1s3vm35PTX4NH1v1MW2uq0pWcXTgKAXmAhxBB9U51VTa44lWKBxxXt/XuQ+DYOCyhsu4qPYijUwEw0H0gl7TpxmPN/vfBGBH3Q5+/e6vkZSI7xYiFFmK+EPjH8gx5jAaGNW20Qt6CowFbCiPd3q3XPVRvnnmGTx75BHGco2cXnsWK0tW8utjv2bEN8IZ1WewtGBpJOIiR4ihWseyqXITzSPN6EU9v935W/LN+YSVMOW2co3I7evYF0N2INJJtadpDzvrd0YsSxAw6CKR0iJrEa1jrfx2529ZV7aOve17WZS3iP8687/IMcY3IqhIVuOhvtX39fVpha5fqfkKPxF/wmuDr+GX/RhFY0SgUA7TNNIUET8M+8kz53H9adfzrVe+RVgOoxN0EdPTcAC9oGfEP5J0PomQDdGVbJgDZA/xiibPAH/+85/x+Xxcc801lJeX8/jjj3PbbbcxMjLCRz/6Ub7whS+kNO7u3bvZvn07u3btYvfu3ezevZs77rgj5jt6vZ67776b008/HZfLxfr16zn//PM1Y9dswTzhmQTpSGmpflcqGZiq31UiZNoSIhAIcPLkSVwuF3V1dRQVFeF2uxkaGsrIfJKNMxlxUu0s8vLy2LhxY1zXWzRpKjAXTEsCf7yWz/hoiU7Q4ZN8BKSAZgS6qnQVh3oP0TLSQqm9lMurLteE3+CvdSZdXfz6nV+zb3AfLa4WJEXCZrRh1pm59eVb+f4F39cWXxXPdzyPw+/AbDAjEnHJvv/t+zXCIwgCn173aR4/+TgnR0+yunQ1l9ZfGjcOwC/f+SV3H7ibkBzCrDcz6IvoC62vWA/A9kXbuf/t+1mUu4jm0eaYbRUUFuVGimI3V25mffl6Xul+BaNoZEHuAow6I8eGjmnmo2E5jEEwsCRvCbevuT3G+iIaeZU1XFl5CxARebz44YtpHm3WipzvPe9eblh9Az9/6+fauBcsuYAiSxG1+bWRjiadngJzAX2ePoLhIBYx0pF2qP9Qwn2+2f8mO+t3Umot1RS79aKeEe8IAgLff/P7lNnK+NWOX2nijFNF9Fv94OAgNTU1WCwWgsEgY+YxgnKQd0feBSL3ZlgJE1JC9Mg9eCUv7WPtXP/k9Zj0EeuOId8QoiBqvl/nLJqaLk42kI1sIRrZMo9EsFgs+Hw+brzxRi0tpipIp4o9e/awb98+AK6//nq2bdsWR3gqKiqoqIg8u3Jycli+fDnd3d3zhOcfCdFdSuoFUVxcnJYHhV6vJxCYWGE1VUyFYIRCIdra2hgaGqKmpoYVK1Zob/TpEgxM1zgT6fm4XC6amprQ6XRxGkfjx5jpXMaPsaJ4BYWWQnrdvVj1VkYCI1yy9BIeP/k4nqAHm9GGTtCxtGApu7fvpia/hjdef0PbfmhoiObmZvLz8znsPkyeMRKuNgtm3F43fr2fU/5TtPS1UFtaG1Ob1enoREHBKEaInU7RMeKLfbs3681ayiUZZEXmx4d/TDAcJMeYQ1AOcmzoGIf6Dr1HeBZvx6Az8NKplxj1j8YQBgGBl0+9TCgc4msvfo0TwycIK+FIekuWGPYNR6wflEg0AiHicv+Dc39AXiC1eoTHTz5O82gzsiKjF/VIssQt+26h6dNNfHLNJ+lx93DvwXu1FntfyEe/p5/r/ngdx4aPARH7hV9e8ksuqr2IS5deyq0v3xq3n8vqLwOgoaiBf1rxTzx84mFEQWTIO4RZZ+Zw32F8ko/D/Ye59cxbY4w5VSiKwv6u/bza8ypWvZVL6i5J6mAuyzID3gHcHjdFliLOW3YeB0YO0Bfqo9vVjUlnwiJY8Pl9dHu6te3cITcFpgKq7FURawfJi4DAjrodXNFwRUrnNHoOmSY82TAHyG7CA5EofLQ+kKognSr6+/s1MlNRUcHAwMCE329vb+fw4cNs3pyakOlcYp7wTILpdGqpKZL29nZKSkq0LiW15TwdSHdKazLCE60svHDhQrZs2RL3sElX1CndwoPRUFWevV4v9fX1McWAqY4xVajF6iryzHkRQb5jD9M43MjavLWsLlvNqtJV3Lb/NtyhiCz/5zZ9joaiBm27aJK2Zs0aTCYT5kZzxHBUCEUKbvVgNBkjC9qYl7f730aSJM0EsdZai0E0aLUxITlEQ3nD+ClPijH/mGYBIQgRXRxP0KMp7arHffbCszl74dnsrN/JhQ9dGLF9QEFE5PjIcR545wGebXuWUlspdpOdPncfg95BtlRu4Zm2ZyJRmL/WFelFPQ0FDfT19QGR2iFJljSriPFwBByElXCMpo8qRLgoL9JGbhANfO+N7+EIOBjwDkTqp6KiUSE5xEcf/ygnPnWC2sJa/mXVv/Djt3+s/f2Taz7J2rK12v+/YtkVbFu4jVH/KF99IdK9pqbEOhwdnBw9ycqSlXFzfaHzBX529Gfkm/IJhoMcHTzKN9//zbg2f4DDI4fZ37U/UlSOwkdWfISvnvFVzu85P+JmPxqJ9vX19MVsp6AwFhhjRd4KQsYQYX2YKxZewZX1VzIyPILdbk9Z+0WW5Wk9G9OJbCEas1m0nA4oijLpeTrvvPO0+yoa3/72t6e0L7fbzeWXX873vve9rDQszd5f6W8Q4/2uNmzYEJMiSXcr+VyMpSgK3d3ddHR0TOrKns4IT7oJjyRJtLa2MjQ0xNKlSykpKUnpgZ2uCM/4tGi5vZyaghqePPkkJ0dPsr9rPxcvvZgHdjxAv6c/Yi1hi/j3BAIBfD4fx44do6GhQSNpsixzce3FkSJUKcCYNIZO0DESHOFLm7/E6XWRVvZoE8StBVtZZlvGSddJ3GE3BtGAx+fh1Y5X2bJwYjG7aFj1VspsZfS5+/CGvChKxLV728JtCb+vF/SEiZAPtfsrrIQ50H1As3wQiGjSeCQP3a5uJEVCkSPu40a9ka1VW7Xxnml9hl+9+yskWWJd2To+s/4zWqeUijOqzkAnRMxJRUFEQeGsBbECeBsqNnDfBfcx4Bng/qP3s6d5T9zcw3KYowNH2bZwG1/b/DWuq7gOSmF50fKEqb5iazE5xpwI0Yk6ndFdWuPxdNvTlFhKtJRXp7OTI/1H+EDNB2K+5w66+VPvn6itqMVqjPhTPXT8IdaUruGcRedoqSlJlii5tyRuPzIy3f5u/nnNP3PJ0kuoslQlNcdUW55tNlvcy43aGp9JyLKcFYRHFQ3MRkzUxBCNvXvjlb5VlJWV0dvbS0VFBb29vTG+YtEIhUJcfvnlXHvttXz4wx+e9pxnE/OEJw1I5nc1HnMdlUkViQiGSt5aWlooKipKSUtnNiMz0x1HkiQ6Ojro6upKGpmabIyZ1nCNj/BApL7kR4d+RLGlGJPehKzIPN3yNJfUX8Ly4ohCcjgcpr29nb6+PvR6PRs3boyZu9peXmItodJeiSRLGEQDxdbiGCVfQRDY17uP7x/6PgOeSDg6LIZZnLOYFfkrEGSB7778XT5f83lsJhs5OTnaf6oT9HiY9CZu2XILu1/bjV+KaC99ZMVHtLmPR31hveYfpnZ1FVoKKTAXoCgKnc5OvCEvYSXSKi3LMpFOcYWQHKLCXsE92++BEJx0nuSXPb+kwlaBQTTwZv+bPPjOg3x63adj9rm8eDk/u+hnfOG5L+AIOHj/gvfzww/8EIhEWz72xMc4NnSMcls5P7voZ5TaSjVrkWjIyHz/0Pd55MQjfHL5J7HpbSwrXTbhb27Sm9i+eDvPtj5LrikXT8hDVU5VjM1HNFTvKxWKosR1vUGE8CiyokW1jDojKOAJecg35+OX/PzuxO841HcIg2hIeD+2Odv4xsvf4J4D93DfBfdxaf2lMdovoVAIl8ulmWN6PBErjuiW52xIJ6VDOyxd88gG4pUI6rNrJtG4HTt28MADD7Br1y4eeOABdu7cmXA/n/jEJ1i+fDk333zztPc125gnPJNgsgtlIr+r8Uhn3U26yVMw+J58/8jICM3Nzdhstilp6aQrxJ0OkqEoiibdXl1dzebNm6cVdk5EVqaKRATOJ/kIK+HIggVa5EN1mVa7xiorK9m6dSuvvfZawvMbDAfJN+Vr9hCBcEBTLlZxqO8Qd7x2B4qiMOgdjGj9CAKOoANZH+kKk5wSDasbKDAW4HK5cLlcDA0N4fV6NbVX9Y1fxflLzmdpwVI6nB0UW4pZWZzYGw0i2kR3bruTr734NfySXyvS/kvnXyi3l3Oq9xSiIJJrysUX8tHn6YtYe/zVcNQv+Sm2FuNwOOj2diMiaueu1FrK0YGjHOg5QL+nn1Wlq1ictxiAC5ZcwNs3vh0zF1mR2fnoTrqcXSgodLu7ueL3V/DHy//Ia92v0eHsiInE1ObXUl9YjzPg5L+P/DefX/r5VH52/nnVP1NmLePY0DHK7GVcVn9Z0vTbpfWXct/B+/BJPkJyiDxznmbtEI1CSyFWvZVR3yhFtiJG/aPYjDYKzZHOnMcaH+O1nteozqnmA0s+wJ6T8RErFY6gg6/85StsrtisFctDxBwzutsHYu0QVBXgAwcOaKlSlSBPJICXbsiynBWppGwmPB6PZ8Zds7t27eKqq67i5z//OQsXLuSRRx4BoKenhxtvvJGnnnqK/fv388tf/pJVq1axdm0kxXv77bdz0UUXzfgY0onMXy1/o0jF72o8sjmlFQ6HtRoRURRZuXJlzOL2twSVsImiSFVVFUuXJn6rTgXpquEZT+DyTfkRj6mxNkqtpTgCDsx6M3lKHq+//npc15hKAscvJsuLI2mVUf8oFr2Ffm8/O+p2aH9XFIVfvfMret29SLKEKIhYDBbcAbdmzmkz2Mgx5pBvzsegiyx2efl57Gnew7vBd6nOqebCogsJ+8Oa2uvBgwexWq3orXpW5a0iLzdv0oXu/CXnE5SDfO+N79Ey2kJdQR2ltghZ0Qk69Do9Fr0FWZZxh9zvqWHLEUFEV9Clnbto925HwEHrWCtX/uFKLVLyow/8iA/WfjDmPPz2+G95vfd1Siwl9Ln7IgKDUf8b8A5w3wX38Vz7c/yh6Q/4JT/uoJuNlRFH+lxTLqPeUUaDowmPD+CN3jf4c9ufEQWRHXU7uKTukphoWzJsrNjIl7d8mTd638BmsHHuonM1P7JoGHVGrqy6klfCr3DKeYoiSxGfXvdpLIZI4fWRgSNU2ivRiTpWl62mx9XDG/1vxI2jotvTza+P/ZqbN908qb9ddKu80+lkw4YN+Hw+XC5XhIh2d2sCeCo5nihKOFNkC9HIlnkkgsPhmHEtTVFREc8991zc55WVlTz11FMAnHnmmVlj5joR5gnPJBh/o07F72o8sjWlJUkSfX19jI2NUVdXN2khb7bC7XbT1NSEIAisXLkSt9utheOni9no0oLIdfXNs7/JHa/ewbHBY5RaSrms6DJGekZYtWpV3FtZMr+z6pxqvnHmN/jF0V/gCri4rP4yrlnxnvP5Q8cfYn/3fk1RWJIl7EY7hZZCJFnCG/IiCiL/vvHftYgJwF2v36XZPQTCAQ71H+J7532ParEaj8fDomWLuPu1u2kcbkSQBT5U+iFOyzkNq9Wqve2rkvfRx+AOuulwdmjaPGE5TL+nn6AcRCdH2vONojHiLfXXwlidqMOit2DVW3Hj5rT80+gUOjnUd0hr6W9ztCEgECaMJEt8+ulPs/uc3Tj8Dh5vepwjg0fwSb6I8ajehE/yoRN0GpEMK2EKLYWU2cq4ZuU1XLPyGjwhD//69L/il/yY9WaC4SCyIifV0DnYe5B7DtxDrikXWZG5/ZXb+c8z/5P6wvqUrpPTSk7jtJLTJv1eiamEb67/JkE5iElninlG5ZnyIuktXeQerimoocvdxYBnIKmz+r6OfXy44cMsyY83w50IareP1WqNEcALBAJaXZAaJRRFMSZKaLfbZ0wSsoVoZMs8EmHeODQW84QnRUzH72o80kl40pH2CQQCtLa2Mjw8jMViYf369RnvvJgOVE0gt9tNfX29pgLq9XpnhaxMFcm0nIqtxXz7/d/W7EXq6+uTXlcT6UGtKF7Bd8/9btzniqLw+6bfc1rxafgkHw5/xMvKL/lZkr+EYksx/3nGf7K8eHmM0eiYf4xn256l3FauabUcHz5O80gzy4sjquD3HrqX57ueJygHseqtPDH2BOeuP5cSQwkul4vh4WHa29u1gs6cnBxeGHqBbx78Jt6Ql0A4wJv9b1JuKyeshDHpTITlMIqsECLEhTUXsr97f+TYEbhn+z1asbNe1HPzpptpHmkmEA7wzuA7vNn3pqbmLMsy3rCXX73zK17qeinuvOjCughRQEARFAw6A+cuOlcTMwyGg3Q4OkCAT679JD898lNQIrU8H6n/CPnGxC8Ez3U8R44xR9Nq6gv38fKpl6kvrEdWZN7oeYOWsRYq7ZWcUX1GwoLnQe8gbw9EUnBrytbEaC9FQxRFzGJ8euzq5Vfzg0M/wBlwIisyK4tXcnHtxdz1+l0cGzoWR3pEREx6E86gM+F+poNEDuGSJGnq0b29vbjdbmRZxmazxXlCpYpsqCOCyLFlQ2otEZxOZ1Z2S2UK2fkrZRFCoRDHjh2blt/VeKST8MwEkiTR1tbGwMAANTU1VFdX09ramjayk2pnwEwhSRLt7e0MDAxQW1sbowkE6ekam60IjyzLdHZ20t3dzeLFi1m2bNmE52y6ApiKomAQDZxRdQYD3gG6Xd2ct/g81pevZ2vVVsrt5XHbqMWzWvdUlOmlOvc9zXsISAFMehPD/mGGfEO0jLVodgPl5eXa/v1+Py6Xi4f2P0QoFMKMGZ8SaU/vcfegoGATbRiMBmRZRlIkfnbRzzjYd5A+dx9rStfEFUOLgqi17FsNVmTkiIKwqMMf9mM32Dk+fDzhOQkrYXKMOdy88Wb0Oj0LchbwoaUfQhAEXEEX33n1O3Q6O1EUhfrCem476zZcQRfFlmKMQSMjI4lViQ2iQWuhV8+XXhd5xD58/GGeOPkEZr0Zf9jPkYEjfG7D52Lc0HtcPdz5+p34JB8o8FTLU9yy9RZKrPHdVsmwtGApX33fV+lwdiDJEo81PsY7Q+9Qbi+nz93HkH8opj7JIBqwG+1U2ComGHXm0Ov15OXlxUQbZFnW1KOHh4fp6OggFAphMpliSJDFYkl4b2RLZCVb5pEI8xGeWMwTnkkgiiKFhYXT8rsaj0wTHnWRVTuWVMVnv9+f9nqgdLzxJCNOsizT1dXFqVOnWLBgQdLOq9kiK1NFNFmJdpIvKyubsM0/2RhT2e/7qt/Hw8cfJteYi81gY1XpKm7Zegs5xhwUReHRE4+yp3kPOlHHNSuu4fwl51NgLmBr1Vb2d+3HbrDjlbwsylukdRi55Yi7uFFnRC/q0Yk6xvxjuIPuhHOwWCxIOok2TxtOKRJJUBddtX7GE/JglI0YRAOXLrkUgnBW9VmTvsGrEasvbf4Sd712F1JYwmqwcv7i83m06dGE2ygomHQmrl91Pfnm2GjNH5r+QKejk+rcahRFoXG4kUN9h/hwQ6TNdnh4OOlz4ENLP8SR/ojRqqIoGHVGti/ajjvo5unWp1mYu/A9Q9b+I5xynmJR3iJt+2fbnkWSJU1wsMPRwa0v34pe1JNnyuPaldcmTI+dHD3JRWvi4gAAIABJREFUC50vICsy71/wfpYVLaPYWsyepj2M+kdZlLcIq8HK/q79Ec8zQYekRO53q8HKTRtu0iQQUkG6ajXUNJfdbo8hyNEpMbVAWqfTxdQF2Wy2rInwZIMmUTLMG4fGYp7wTAK9Xq/djDNFuvRlopFKNCW666e8vJwtW7bEEJJ0zitdhEclGtFkILpVvqSkZNLOq3S0yaeTNDkcDhobG7Faraxfvx6TKV5xd6IxprrQvND5Anua9uAL+Rj2DVOTX8NPzvqJVoPydOvT/PTITym2FBMKh7j7wN3kGnPZXLWZr5/xdX75zi956dRLeF2R+p9fHfsV1628DoNgoMJewYB3AJ/kQ1Zk8kx5LC+KRGEGPAOcHD1JrilX69z64nNfZMg3FKdDoxBxETfqjOxYuoPTi07ngxUfpKOjA6/XiyAIMV1A0b/FsG+YSx+9lA5HB+6gW+t6W1a0jLHgWFLdm3Vl6/jpB38aR3YAul3d2IyR+ilBELAarPS4e1I63/WF9fzX+/+L/V370Yt6zl5wNpU5lYz5x4BYQ1bVxysaqpCjig5HBwDbFm7DE/Lwwzd/yFff99WYbdrG2vjBoR9gN9oREPjJ4Z/wL+v+hUJLId2ubnSijn5PP66AC6POqAkxGjBg1pvZUrElRjgxFcxmBFcQBMxmM2azmeLiYu3zUCikGWOqrfI+nw9ZlsnPz9eI02TSGbOFecLzt4F5wjMJ0nkhp/umUBf0ZIu+oigMDg7S0tJCQUFBQq8omB3Ck65xVMIzNjZGU1MTVqs15Vb5dEVnZopAIMDIyAjBYJDly5en1NGXaB5TPZa7Xr+LHGMOZbaySGTJ28/JsZOU2CIpkhc6XyDHmKN1+HglLy93vczmqs2Y9WYuqr2Ip1ufpthSjCiI/O7E7whKQTYbNnPN8mv47YnfIskSCgrnLjqXpYVLOTpwlK+/+HVCcghZkTln4Tl8acuXeLLlyUiXGGKMc7raVZVjyuHaVdfGCReGw2Htbb+7u5vRsVEGvAP0e/r5aetPOTlyEq/k1YhNIBzgxNAJCqoLWFa0jKaRJi2aoRN0PHzpw5y/5Pyk52x50XKO9B8hz5SHgoI75Ka+4L2oymSLfU1+DTX5NTGf5ZnyWFWyircG36LQXIgz4KTcVk51TnXM9zZVbOLNvjcx6owRcu8ZYNuibehEHbmmXBwBB53OzphtDvQcwKw3a7U+kiLx3de/i9VgZcgzxOHBw+QYc9ALemRFxqq3sjhvcaTLDYV1ZeumfI1nIrJiMBgoKCiIcek+fPgwVVVV+P1+BgcHaW1tJRwOa63yKlE2mUyzSkiylexAhPDU1NRM/sV/EMwTnhSQDgPR2YDaqZWI8IyOjtLc3IzFYmHt2rVYLJak46SjAFpFulWSPR4PTU1NKIrCihUrptQqny4Bw+lCVXceGBjAbDazYUO8w3eqmOo1qCgK7qBbq/8QBAFRELXWboi0WQfC7+lCheQQuab3ChzfHXqXYDhIVU4VABW2Cv7S+Rc2L9rMx1d9nNNKT6NptIlqezXnLDoHURC56/W7MIgGiixFKIrCXzr/wnlLzoto//DXNvOow5AVGavBSqW9UrO7iIZOp9NqP7whL//7wv/yWtdrhLpDdLm6NMIVjYAcoNPZyRvXv8Gdr9/J3va9lFnL+OZZ35y0Y+qDtR+ky9XFK92vAHDeovPYvnh7zHkVBIF2Rzt/avkTwXCQsxacxbrydUnHFASBz5z+GR5rfIzGkUZWFK/gymVXxnlqnV5+OjesvoG97XsRBIENFRs05WW1k0ztVFOhRm1kRUZA4JTzFIPeQTaUb6DH1YMv5MMkmsi15XL2grN5s/9Nutxd5Bpy2bZoG59Y+4kJz0ciZEsKR5Zl8vLyYgr9o1XFnU4nPT09Wqt8dF2Q1WrNinTYbGM+whOLecKTAaQrJKzWBEWnRtTWbGDa0YSZIF32EgCNjY34fL4Ju5fmai5TgVpj1NnZyaJFizj99NM5ceLEjMacKuERBIEtVVt4tetVSqwleCUvelHPiuL33IuvWXkNh/oO0eXqAgWKrEXsrHtPRdWkM8Wo/wbDQawGqzb+mQvO5MwFZ2p/VxSFIe+Q5v+kkpth3zArilZwuP9wxJLgr1Eek2iiwFLAgpwFiKI4YUu2LMt8a/+3eOzkYwz5htCJOgLhgFZYPR655HL40GE+ZPsQH9nykchCZ7FPeu8ZdUY+c/pnuH7V9RGH8nF2FYqi0Ovt5f+9+/9AiFhmvN7zOjdvupkNFckJrcVg4drTrk36d/V8va/6fbyv+n0AnBg+wY/e/BFj/jHCSpjTy0+noaiBQ20RE9ZgOMiof5Rn257FF/JRYC7AqIu4zT/Z8iTOgBNPyIMoilxWfRlvD7xNma2MC2suZNg3zMrilRRbiieaUkKk4s00F0gUaYpulY+2QAgGg1qkcHh4GI/HE1NDpNYFTTUVn8kXqlTgdDr/ZmVGZgPzhGeOkag2ZbqIFh9U2+Z9Ph91dXUxod+5xEwjPKqdwtjYGDU1NaxevXra5HCuIzyKomhO5sXFxVqtVCAQmLXW9onwH1v/gztfu5PXe1+n0FzILVtuiUmjLM5bzA8u+AFv9L6BKIhsqdoS0wa9qWITNfk1tIy1IAoiAgK3bLkFYTjxXARBYHXpao4OHKXUWsqxoWP0enu5bf9tjPhGIpYRyJh1ZpYXLWd9xXpeOvUS/d5+NpZvZNQ3ik7QkWfK0yIbEHExX/8/6yPETIUSSVFFd0WpMOqM3PmBO9lYuZFAIKApR6teUZMJ4wmCELP/8TgyfARJkai2R86l3q/nT61/mpDwpIpQOMTx4eMEwgEW5S7iP973H5xynsJqsLKsaFlMV9djTY/xp5Y/YTfYMQrGSD2LLZ93B9/FJ/nIM+URkAL4Q35e6X4Fb9DL0sKllFhLKLGW0O5oxxPyTHisiRAOh7MiwgOpp5OMRmNC9Wi1Lii6Vd5qtcZEgyaqtcvmDi2Yj/CMxzzhSQHpTGmpUZl03CR6vR6/309vby+jo6PU1tambIo5W5gu4Yk2Ka2urqasrIyCgoIZHUu6vL1SgcvlorGxEaPRyLp162JSiOm4fqaTdsw15XLb2bdN+J1ye3lSJWCLwcId59zBi50v4gq5WFWyimVFy3hr5K2k4315y5e5/ZXbeb7jeYa8Q6wpXUObo40BzwDl9nIUFILhIF/e8mW8kpcDvQcotBTSNNrEJb+7hNqCWqx6K/++6d85b/F5AHx+7+fpdnXH7CckhzCIBnINuXx2/Wf5Q9Mf6HZ1o9fpWV2ymh+++UNMOhPryiO+dtFeUcFgMKF9hlvnptnXjM1q45yacyjPiW9WUBQFQYy9JhUUFEWhdawVb8hLVU6VpsUzFYTCIX58+Mc0jjRqViOfPf2zCYmUrMgc6DmAjIzdaMditeAJeqi0V9Ll6kJWZIJykHJ7OX7JjyfooSKngvXl6wG0gulo/aVUkQ3GoelAdLpUhaIoeL1eXC4Xo6OjdHZ2EgwGMZlMMSRZbZXPdqf0+QhPLLL3l/o7hV6v17QmZgJJknC5XAwMDFBXV0dDQ8OMyEEyJd+pYqokQy2sPnnyJMXFxZpJ6fHjx7OipXwyBAIBmpub8Xq9NDQ0JHybmk3xwtmG1WDlwtoL4z5PNpciSxF3b7+bzzzzGQa9g+Sacnlr8C10YqQVuthSzIhvhHZHOy93vUyuMZdgOEino5OgHCQcDmO32Ln79btZXrScqpwq3hl8R+vmiq7XEQQBo97IjWtv5Ma1N/K5P3+OInMRJr0JT8jDvQfv5ccX/jjOv8poNFJUVBQjjNc41Mg9L91DIBQgGAry6NuP8qmaT7GgYEGMcrSiKGwo2cBB50F63D3oRT2+kI9KeyW3vnwrOkGHUWfki5u/mNQoNBneGXqHEyMnWJIXUTwe84/xyIlH2LV1V9x5FxA0gURPyINRZ9RMaC9cciHPtT+nFZs7gg7+7fR/w6gzcqj/EEbRSDAc5IIlFyT19poI2dIOPhsQBAGbzRajdK4oikaS3W43AwMDWqu8yWQiEAjgdDqx2WxZF+2ZJzyxmCc8KSCdEZOZWkJE14dYLBZqa2uprKyc8bzUyMxMH2RTifA4HA6ampowm81xnVfpKH6eTZIQDoc18cba2lpKS0uTXiez5biezajOqabD2UGuKRe7wc6QNIRejHQK6UU9C/MWouvW0eXqYtQ/iivoQkbmyOARjgwewW6w0z7WTlVOFStLVvL20NtxxcnFlmJ+cdEvKLIU0TzaDKAVAtsMNhwBB86AM6VF/anWp7CarSwqjOjidDm7GModYkvVlhh14GAwiF6v51M1n+LA6AFEg0h1bjWPNj7KgtwFiILImH+Mnxz+CXede9eUzllACqDjvQXTarDGKSCrNUiCIKAX9ZpNhlfyEpAC1OTV8G/r/w2b0cZr3a+hE3RcsvQSdtbvxKgz0lDUwKh/lFJbKXUFdVOan4q/Z8KTCIIgaOrR0a3ykiTR39+P3+/XPOYURdHsVdRoUKZa5SFS0/m36ok4G5gnPHMMg8EwLZE/RVHo6+ujtbWV0tJStmzZQk9PT9q7q2Z6c6ZCVLxeL01NTYTD4aTGq+kiPOmCutAoikJPTw/t7e1UVVUlFT0cP4+/1QhPIqQyl4+v/jjHho/R5+6jyFzEoHeQfk8/w95hLqy5kItqL8Ib8vJcR8SUMLpVHcAdcrP71d08vuBxvrf9e+zv2q/V8BhEA49f8ThbqrZov3GptRS9qMcT8mhkx2awJdTaSYRAOBCT3tGLekJKKMYwEyIO0V6vF5vNRqGuEJfLxZHOI7icLobDw/QH+wkqQS2ql+zaCMsRzy+T3sSof5SToycZC4whKRKugAuz3ky3u5tzFp4Ts516HYblMHaDnYtqL2LAM6ClqD5U9yFyTDl8ZetXGPJGdI+KLcXoxAiRii5any6ygfBkw72g1+uxWq3k5eVRVxchj2pnqaoeHW2vEl0XZDab56z0INO/VTZhnvDMMdSUVqpQFIXh4WGam5vJz89nw4YNWjpMLYhN17zSobas0+mSzikYDGq+UXV1dTEphfHIdEt5NNQFfmRkhKamJgoKCrTUW6rbp2sOfysot5fzwwt+yG/e/Q1fffGrmlmohMS+zn00DjdSZCliQe4CmkeaE47xZv+bkTdmo5WjnzjK/q79tA200TjQyMPHH+Zg30E+vvrjyMiccp7iqmVX8cjxRxjzj2E32vnS5i/FCPlNhLMXns1/H/xvREFEVmRC4RBbq7Ym/K7ZbKai4j0rhmJHMX9+7s8cHj2ML+SLWG4IJn7w3A+4qOYiLSWmLnI/OPQDHnj7AcJKmNUlqym2FhMMB4FIwbUkS4wFxjhrwVnsqNsRs2+VbOhEHdW51Qx6B1lZshK/5GfQO6h1yImCOCX15KkgGwhPNswB4ouWRVHUfm8Vqr2K2iWmFs/r9fq44vl0HtPf0vNirjBPeFJAOpl4dGfVZBgbG6O5uRmTycSaNWuwWq3THiuVeaVTMDAa4XCYjo4Oent7WbJkyaS+UemcTzqgKAqHDx9GFMWEv8NcIBnhyUSBeqrky2aw8dO3fqqRHbUGxxFwcNmjlxEIB3CH3Jow4Hj4JB9n/+ps/vX0f+UjKz7C1qqtPPjWg7w18BYOyYFX8vKzt37G4rzFQKSQ9+yFZ3PdyusotBRqAn5HBo7Q4+qhzFbG6eWnx3Q6qdhSuYXw6WH2tu9FJ+rYsXZHQs2eRG3tC/MWcnH9xXzn1e9gMVgoyymLCA0G3uKfcv8Jt9tNX18ffr+fA2MH+GHrDymzlmEymHjh1AtU2iq5fNnlAHQ6Ozl74dlcUHNBwnMSvf+rll3Fg+8+SJerC1EQuXLZlVPy3ZousoFsZMMcIDXjUNVexWKxxBTPh0IhrS4oWll8vKHqdIuitXqvLOmoywbME545hsFgmDTC43a7aW5uRpblpCkfmHk9UDRmg/BEp38qKys1765UMJcdVskQDAY5efIkXq+XpUuXxuh6zDWyKeKVKlxBF+6AW6u9if63x9MTaUE35sWIH0bDbrRj1Bm5+8DdVNmrqM6tpsXRwlhwDJ1eR6G5kB53D+6gm22LtiEKIn/p+AvvX/B+zRT1oeMP8YemP2iKzhfUXMANq26IWwQS6QpNBStLVrKpYhOVOZXoRT1hOYw75KaouChmkfvTi3/CZDChF/QEA0HEsEivs5fBocGICnoYnIHkzuXRhKfQUshn138Wd9CNWW9OOZo1U2QD2ciWdvCZzMNgMCRslVdd5fv7+2lpadHUo6OjQUajcVIiM1+/E495wpMC0l207PP5Ev7N7/dz8uRJPB4PdXV1k4rtpdOMNF3kSSU8audVYWHhlNI/0eMEg8EZz2c6kGWZjo4Oenp6WLJkCV6vN6aOIxNIFlWZK2f68XNJBUPeIUYCiZ3FIRKRcYfc5BhzcAVdMV1YAgLOoJMDvQcAuOL3V2DWmfGEPJh0JkqNEfKptkj7Jb/mJzXsGwYiXU5PnHyCBTkL0IkRzZ69bXu5uPZi7EY7/Z5+8kx5MdpDyaC2nbeMtFBhq6CKqpi/1xXUUWItod/bj01vY9Q/yiV1l8RFkypyKlAERSvQt0gWFEVBb9bjDXgZdg/DALzhfgObzRbTIabX6+PIhiiIMerYc4FsIDzZMAeIEJREdj3ThU6ni6sbU9WjXS4XDoeDrq4uAoGA5iqfTE/K4XBk/LmVbZgnPHOMRCQlFArR2trK8PAwtbW1rFy5MqVFJRtTWj6fj/7+fiRJmtTSYiKkM6KRKimILgyvqKjQnMz7+/szHl3JthqeVOZy/9v3YzVYIwW6CdJWCgohOYRdtLOudB1No01IYYmgHNS0bVT4w34tEhSSQog+EYveQq4pFyksYRANhMIhEGBB7gIATYlZLdjVCTp0oo7G4UZ+fezX+CQfiqJwzYprErbeRx/rb479hidbnqR3rBcFhS/KX+TipRdr37Eb7dyy9RaePPkkQ74hLqm7hHMXnRs31jUrr+HP7X+mZbQFgHxTPjesuoEOVwd2o53Prf0cGyo2aMWv49/0TSYTfr+fkZER7HZ7WhfbVJENZOPvIcKTKqLVo8vKyrTPo13lVT0pURTp7Oyko6ODsrKyGSvtj4yMcPXVV9Pe3s7ixYt5+OGHk4rahsNhNmzYQFVVFU888cSM9jtbmCc8c4xowhNd27Jo0SLq6+un9Lae7pTWTMiTz+fT9GjsdjurV6+e8XzS5cmVCuEZHR2lqakJu90eUxgO2dESnojwuFwu2tvbMZvNWiQgEwtgMnhDXi2VlAwKCovzFvPohx/l1pdu5TfHfpPQ4VyFVW/FJ/kIySGW5iylwFyAKIiM+CNKzp9Y/QlWlawCIm3rRdYi3hp4C5NoimxTsJSHjj+EgEClvZJgOMiD7z7IypKVGlEajzZHG0+1PEWnoxNXwIWCwlf2fYXqnGrWlK3RvldkKeJjqz424TmxG+3874f+lxdOvUAgHGBTxSYq7BVx30tW/Kp2/gwPD9PR0UEoFNJ+/7kyy5RlOeNie9lAuiCzxEttlY9u/pAkCaPRSEtLC4899hhHjx5l/fr1LFu2jLVr17J27VrOPffclOe8e/dutm/fzq5du9i9eze7d+/mjjvuSPjde++9l+XLl+N0Jk/JZhrzhCcFpDulFQqFOHXqFJ2dnVRWVmqRhOmMlekIjxqdGhkZYenSpdjtdo4fPz7j+aQrwjNZe3B0i/zKlSsT5rzTaa46XUQTnmAwSHNzM263m4ULFxIKhTRV2OgFMCcnh9zc3LSToETk66VTL/HDN39IMBzkqmVXcdXyq7i84XL+ePKPcS3n0TCIBv7v9v9L+1g7e5r3EJAn7zrUCTrWla3j9rNvJ9+Uj81oQxRE7Aa75vwO8HTr0zzT8gx9nj5kZEREOp2dlNvLKTQX0u3upsxahiiIDPuGkxIed9DNWGAMv+QnxxAhIK6wi8eaHoshPKnCYrBwYU3yiFIyqHowNptNa4NWO4BU5WjVLNNoNGoEKFoZOB3IBrLxjxThmQr0ej2rV69m9erVPP3007zxxhvcfvvtNDY2cvjwYfbu3cv27dsnH+iv2LNnD/v27QPg+uuvZ9u2bQkJT1dXF08++SRf/epXueeee9J1OGnHPOGZQ6itzUNDQ9hstmnVtkQjnZ1Mer1+SjUz0XUuixcv1qJToVBo1rq9pgO1+Hn8G2k0Uaurq4sRFEs0RjZEeCRJoq2tjZ6eHmpqalixYgWhUAhFUSgvjxTpRrtFj42NcerUKY0E2e12cnNzUy56TBWH+g7xmWc+ozmxv97zOl98/ovodXryjHkMMph027Ac5u4Dd7Ovcx/uoDtOTTkaCgoeyYNBMFCTX0PbWBv3v30/ITlEobmQ2866jdqCWiBS+PvF57/IkG9I215GpsvVRZe7CxERg2hAJ+pYlLeILlcXJdYSzRk+GpX2iLCnpESc2X2yj3xzfkZI8PhoZXQHUHRRfXS6I1oZWCVAM2mDzgbCkw1zgNS6tDIF1UdLr9ezcuVKVq5cOeUx+vv7NQmGiooKBgYGEn7v85//PHfeeScul2tGc55tZOcvlWVIx8KgaunY7XZsNhv19fEtr5mYl4pUU1qKotDb20tbW1tMnUv0OOkiPOmM8KiQZZlTp07R1dWVchox04RHURQ8Hg+Dg4MsWLBgwohgIrfo6ChAdNFjdCRoKqmQ8RGe/337f+l2R7yuZFmOieioBcTJYNFb2Nu+F0mOkIlEZMeAgSJbEY6Ag4AUwKa38c7gOzx+8nHWla6j3FbOqH+Ur734NR685EF0oo6W0RY8IQ+yIsfZUYSViPmlKESKnVtHW3nkxCM82vgoN224ibVla2P2X2wt5gubvsDNz93MSGCEfHM+5fZyzl549qTnKt1ItR4tUbojFAppJCi6DTo6EpSKPUI2kI1siaxkyzwSIVXj0PPOO4++vr64z7/97W+ntJ8nnniC0tJS1q9fr0WDshXzhGeW4XA4aG5uRq/Xs2rVKqxWK6+++mqmpxWHVIiKStry8vLYuHFjwlRJuupd0tWWrpKVaM+ukpISNm/enPKbWboIz3Q6qlwuFydOnCAcDrNgwQJqa2unvN9EUQBFUWKcxKNTIdEkKBVF2HcG30FWZAyiAYmppVjDShi70Y4n5NFIz3jIyKwtXcvh/sOExBAhJWIcKskSnpCHAksBBeYC+tx9OAIOCi2F5Bhz8Et+wko4ZkxFURCFSMFzjjFHawFfkLMAbyii63Pf+ffFHfM5i87hkUsf4RcHfoGgEzi//vyMEJ6ZkA2DwUBBQUFM0anqGO5yuWLsEaK1YHJycmLulUx0Bo5HthCNbJlHIjgcDpYundzPbe/evUn/VlZWRm9vLxUVFfT29iaU5ti/fz9//OMfeeqpp/D7/TidTq677joefPDBGc1/NjBPeFLEVLtkPB4Pzc3NSJJEXV1dSkw7k5iI8LhcLpqamtDpdKxevXpC4b10PQjTGSlyOp0cO3YsoWdXKkin+Weq5ye6TmfZsmW4XK606hIJgoDZbI5zEo8mQapYnsFgiCFBENultShvEYf7DxOWpza/AnMBBtFAqbUUR8DBoGcQv+x/b45qemvcKRMQMOgMoKB1f3lCHsx6MznGyPz6Pf2U28rpdHbGEB6jaCRMGBkZnRBpVS+yFEUiYwYrI64Rzah0PJYWLuWTDZ/EbrfHnLO5RLrJRiLH8Gh7hMHBQVpbW2O0YLxeb8afZ9kQZYLsJjypRngmwo4dO3jggQfYtWsXDzzwADt37oz7zne+8x2+853vALBv3z6++93vZiXZgXnCk3YEAgFOnjyJy+Wa1D4hXUjHQzBRAbTf76e5uRmfz5fUCXy2kA6S4ff7GR0dxe12s3LlymlrUqRjLpMVT6uIro1S63QEQcDtds9KzYgkS+xt38uIf4SN5RupK6yLM0lUnaLVepDR0VE8Hg/5+fnk5ORwTf01vHjqRXwhH8FwcNLC4yW5S/j4mo9zwZIL6HB28PUXv47dYEewC/S6ezVlZpWo1OXX0efpI9+cT6ejE4vegiRLLMxbiIjIgGcAnajjG2d8I0KEiBChcls5fsmveU/5JB9Wg5WqnCqGvcPIiozVYGVjxUbCcpgedw9rS9cmVGJWkenoxlzsP7pDTK3fiNaCGRgYoKOjg7a2NkwmU4xW0Fx5RMmynFFTThWqDlQ2Ih2EZ9euXVx11VX8/Oc/Z+HChTzyyCNAxFPuxhtv5KmnnkrHVOcM84QnRUwW4QmFQrS1tTE0NBSzUCVDuh5cau1NOk0/o49l6dKllJSUzPlDfiYRHrW4d3BwEJvNxuLFi2ckwJUODZzJSFN0yq2srCyuTmc2dHgkWeLaP17Lwb6DWqrnRx/4EecvOT/me0ajkaKiIo28Hz9+nPLychRFweVyUR4o59+X/DuP9TyGIApU51ZzdOQoQ76hSMRGibin37zpZq5cdqXmaA6wvHg5OYYc/tT2J2x6Gzvrd/KZZz7DWwNvIQoiVy+/mrvOvYtfHP0FJ4ZOsLZwLWJYpKa8ho+s/IjWYVWdUx0jILiieAVWQ6QoN9eYi1/yU1dYR11BHfeefy/tjna8IS8+ycdvjv2GPk8fp5efzg2rb5jwnGWa8MiynDE7EbU2bHh4mIULF2Kz2WIigqpHlBoRTCaIlw6Ew+GsJRrZgnQQnqKiIp577rm4zysrKxOSnW3btrFt27YZ7XM2MU94ZohwOExnZyc9PT0sXLgwJfdsdTFPR3W/qsWTDsIjSRLt7e10d3ezaNGilI5ltjCdBV5RFLq7u+no6KC6upotW7bQ3Nw862QlFUx0PC6Xi8bGRkwmU9KU22wUTj/b9iwH+w6iF/QIokAwHOQLz3+Bo584OuF2giBoirCqGvhpp53Gp0Kf0upBXC4XHo8nJlqQk5ODQYy/Ts9YcAZnLDhOaBTiAAAgAElEQVRD+//7rt0X953/s/7/AJE6srGxsZhapuqc6rjvl1hLuPOcO/m3Z/+Nfm8/RZYi8s35fGzVxxAEgSX5S7TvbqjYkHEikyqyIaKgRiqTpUXViKDb7dYE8XQ6XVxx9EyOI5tTSdkCp9NJfn5+pqeRVZgnPNNE9OKaqFtpIqjpo3QRnplq8ajRBYfDQXFx8ZQKehNBLVyeyQNtqovP0NAQzc3NcVYW6UxHzXSM8YRnfJ3ORG9jM4nweEIenm9/nhH/CM+0PsPBvoPkmfI4b/F5kYVejJxrg2jAEXBMuvgn+1uiolhJkjQSdOrUKTweT1xnkN1un5VFvL6onsevfJwDPQdwh9w0FDZobeupHtN4ZJoYZXr/MHn9zPiIICS/DsbbZ6T6DM2WGp5sxjzhicc84UkR6kNGURQGBgZoaWmhqKhoWlo66RYMnMlYIyMjNDU1kZubi9VqnVYXUKI5zVXI2e1209jYiE6nS+oonw2EJ7p7TZZlOjs76e7uTin9qW6fzC19/Ofdzm6u/eO1tIy1RDRkhEh7uCPgIBQOUWwpZsw/xkPHH0JRFELhEHpRjz/sZ1PlppRtOFKBXq8nPz8/5sEb3RnU1dUVs/ipOkGptEenArPezFkLz5rxOCoyTTiyYaGfzhySXQeqfUZfXx8ulwtZljUSpJLiRM/XbIjwZCq9mCo8Hs+8eeg4zBOeKWBkZITm5mZsNtu0un1UZIPpp0oURFFk1apV2Gw2XnnllbTMSSU8s1lUqBaHu91uGhoakr7JpCs6M5nDfSpjhMNhBgYGktbpTIRUIzztY+2svX+tZufgGHEAUGYr04qBHUEHpdZSJEni8vrLeab9GZwBJ5sqNvGjC340zSNMHYk6g9TFz+l0xrRHj48EZZpwZFpxO9PHD+kjXYmMMmVZxuv14nK5NBsNSZKwWCwx10I21PBkA+maDJk+R9mGecKTIrq6uujr60tqPzAVpJvwTGWsaEf2+vr6pEZwM0G6RAMTIdp/rLa2dtLoSDr0fNJBmiRJ4t1338VqtU6LLKdKeL74/BcTele5Ai5ExEhLthLRJdIJOs5YcAZ3n3c3siJP2J00nblMBckWPzUS1Nvbi9vtJhQKIYpiTGHsXCvdZppw/b0QnkQQRVFzAFcRrR6uCmc6HA6CwSB5eXlT0oxKJ7KZ8KjXSaavlWzDPOFJEdXV1VqL5kyRCcIT3bk0FUf26SCdlhfqjRut8FxZWcnWrVtTeuhmmvCodToOh4OGhgaqquKtC1JBqoKOA97E0u+yIpNrzGU0MIpO0BGUgywrWsbFtRHH71TJzlxCFMU4EjQ4OMjw8LDmYq+6iEfXgowXyksnMk04sqFoea7PQSL18MOHD1NXV6cpiKuaUXq9Pq5DbLbOV7YTnnnEY57wpIh0G4jOlemnLMt0dXVx6tQpzZYg2QMgHcXGqcwpVahEZ2xsjMbGRnJzc5MqPCdDutJRU32AjK/TUdVrZ3sOH6j5AEcGjsR9btabQYALay7knEXnUGot5eLai2NaxFPFbER4prJvo9FIZWWl9ll0GiRaKM9qtcZ2iKUhxZppwpMNTuWQ2SgXRM6DmuaK1owKhUJah1hHR0dMp6BKgtJVH5auTtvZgNvtnq/fSYDs/LWyEOm8wQ0Gw5SMOieCXq/H5/PFfR5dXJ2qlUK6io3TGeE5fPgwgiBw2mmnTesGTkd6bSp2Gcn0dMbGxmY0j1RJxle2foV3B9/liZYnABARuXv73Xx89ceRFRmdmJ1vpDNBdBokWigvWS1INAmaqpN8pt+cM024sgXJXswMBgOFhYWaXAJEottqcXR3dzdutxsgrkNsquRFkqSsjfA4HI4ZaY/9vWKe8GQAer0ej8eTtrHGR4tGR0dpamrCbrdPqV4kXZo+M00jhUIhrc5o8eLFM0olzmVKS9XTMRqNced9plGRVLcXBZFf7/w1wXCQsBzGYrBof9MJ6Xk4/y0suGrXl81mi3OSd7lcjI6O0tnZqTnJjzdRnWzsTCEburSyBan+Dnq9Pql9hsvlikmNqlFBNRo0ESHO5pSWw+HIuP1HNmKe8KSITDiTpzqWuqB7PB6amppQFGVaxdXpmtd0IzzRaaDFixfj8/lmfNPOhQ5PMBjU7ESS6enMdB5TJUxGnRFm8Vmc6UjHdBBdC1JWVgYkdpIPBoMxlgm5ubkYjcYp+6HNBjK9/78XRAtiqoiOCo6MjMQQ4ugOMZPJFLEryWLC43Q65yM8CTBPeDIAg8GQtpSPXq8nEAhw7Ngxzb8rOpw7FaTTsHMq40Sn30pLS7U00PDwcFZ0WCUbY3ydzvLly5MuRjON8EynjujvFelc8KfiJG8ymTR/Np1ON+ddQerc5gnP7CBZVNDv92vdguq1YDAYEAQBk8mE1+vFYrFk1e8yH+FJjHnCkwHo9foZF9JCJIfc3d3N0NAQp5122oQLbirIBOFxOBw0NjYmbNfOJpXk6DEm872ajXkkqyPKlK9SpsjXXOw3kWWCoigEg0HeffddvF4vzc3Nmm+UKpY4F63R84RnbhFNiKPtMwKBAK2trUiSREtLCz6fD51OF5Manc0OscmQDh+tv0fME54UkU1dWrIs093dTWdnJ+Xl5eTl5WlvJDOdV7oIz2RF2T6fj+bmZoLBIMuXL48JLUePM9P5pFtpeaI6nYkwVzU885gdqG/zRqORBQsWaIre0ZEgtTVa1QhS/0vn23+ma3iy4RrMhjmYTCZMJhMlJSVal1goFNIiQR0dHXi93hgbFbWwfi7SYPOEJzHmCc8UkK5FZ7qEJzqyoHpeCYLA4ODgjOcEc1PDI0kSra2tDA0NUVdXR3FxcdLFIF0Fx+kYQ5IkLW04me9VsjHmsoZnNpFNc5lrjI+wqAtfdGu0ap7pcrkYGBjA5/Np+jDRb//TIUGZjvBkmnBlyxwgvmg5kZdctI2KKp6pKEqMZILdbk+7Kr3T6WTp0qVpHfPvAfOEJwOYTj3G2NgYTU1NcakfRVHSpmo8myktNSrV0dExJVf5TKe0VB2jsbExqqurp502nM0IT6YXwX8kpPIbJjLPVPVhXC5XjIP4VFMgmf6ts4FsZMMcILUurUQ2Ksl0o2YqmRCN+QhPYswTnikgE2+2Xq+XpqYmwuFwwtRPurvH0kV4oknG4OAgzc3NFBcXs2XLlpT1LtIxn+kSnvHRtNzc3Bm3x8+EeGVT0fI/coQHpnfPJdOHUUnQeJE89T+bzRazuGd6sc/0/iF72sGnO49kulGJJBOiuwXtdnvKNWLzTumJMU94shTBYJCWlhYcDgd1dXUxb4uzBbXja6ZQU2NqvYvBYGDdunVYLJbJN45CpoqWx9fpGAwG3njjjRnNYyrihcm2/0cmGdmCdEZY9Hp9XApEkiQtBXLq1CnNSV6tAwkGgxm9DrKB8GTDHCC9xCuZZEJ0jVhvb29MjVi0fcb4a3I+wpMY84Qng0j08AyHw7S3t9PX10dNTQ3Lli2bsxB2uiI84XCY0dFR/H4/DQ0N077x5jrCk0xPJx1pw5laXCQjTLIsZ80C8I+A2U4p6fV68vPzY97Oo+tAvF4vx44dQ6fTxSkFz0XUIxuutb/1CE+qSNQtCO/ViLnd7pj0qN1u56WXXmLFihU4HI75CE8CzBOeKWA2OrXUYjVFUbQal6qqqpTNMdV5ZYMHlkrWent7MRgMbNy4cUbnbK58sCbT00nH7z7TlNT4CI9KwtR/1fMkCIJ2HczWwpTpaFOmhf/mGtF1ICMjI9TX12MwGDSl4OhiWJUE5ebmzgoJygbCI8tyVhCeTFlLJKoRUyPqQ0ND3HfffRw9epTLLruMtWvXsm7dOtatW8fatWtT9vMbGRnh6quvpr29ncWLF/Pwww/HRCJVjI2NceONN/LOO+8gCAK/+MUv2Lp1a9qONd2YJzwZgkp49Ho9Q0NDnDx5ksLCQjZt2jTlin11rJkUuanjTIfwKIpCT08P7e3tVFVVsWnTJo4cOTLjhSmdnlyJMB09nekinSktRVEIh8MoioJOp9PIlEqA1HOm/jsXJGiukA1pvUwTLkEQ0Ol0cU7y0XYJfX19uFwurSNIJUAzdZLPBsKTDr+/dCFb5qGmR3ft2gXAmWeeyYsvvsjx48c5fPgwDz74IIODg1x66aUpjbd79262b9/Orl272L17N7t37+aOO+6I+95NN93EhRdeyO9+9zuCwSBerzetx5VuzBOeKSDdEZ6xsTG6urowmUysXbt2yjUu0WOlg/BMpy19ZGSEpqYm8vLyNCdzWZbTQlTSUcOTDNPV05ku0tWlFQ6HtXMiCIL2HxBD1qKjP9G/RzpIUKYjPJlEprukJtp/IrsEtSPI6XTGdASNT4el+pKVDYQnG+aQzVDvTavVyoYNG9iwYcOUx9izZw/79u0D4Prrr2fbtm1xhMfpdPLiiy/yP//zP0Ak8jTTNWi2MU94MgCv18vY2Bgej4eVK1fO2PMkEwrJHo+HxsZGBEFg1apVMaHSdHUUzUaEJ7pOp6GhYc7y3DMhbypxCQaDHDt2jLy8PHJzc7HZbBMufpA6CVIUBVEU/24iQbOFTBOeqS720R1B0WMkaouO1obJyclJSIKygWxkSw1PtmMm12l/f7/WQVZRUcHAwEDcd1pbWykpKeGGG27grbfeYv369dx7770pp80ygXnCM4cIBoO0trYyOjpKbm4uVVVVaTF4m6lyc/Q4kxGM6O6x+vr6aft2pYJ0Ep6p+F7NBqab0oqO6mzduhW3243T6aSjowO3261puajpjemQoGgiNJ4E6XQ6bTx1+3/kCE+mkQ7ClawtWiVBw8PDtLe3I0lSnDaMLMsZ13zKBsKTzdd/qr/ReeedR19fX9zn3/72t1PajyRJvPnmm9x3331s3ryZm266id27d/Otb31rynOeK8wTnilgujd6OByms7OTnp4eFi9eTENDA21tbWl1TJ9thWRZluno6KCnp4clS5bMSfdYOlJaiqIQCoV47bXXYoxJ5xpTjXpFR2LU7QVBiOvgkSQJp9OJy+Wira0Nj8cTU9+Rm5s7oapvdFRHhbrfaCIE75Gg6M8z/bY/18h0hGe29p/MOHO8NozP59OuxWj38LlENlx3mb4OJoLb7Y6J6CXD3r17k/6trKyM3t5eKioq6O3t1Yx1o1FdXU11dTWbN28G4IorrmD37t3Tn/gcYJ7wzCIURaG3t5e2tjYqKytjFtt0RWXUsdIRCUn05q4oCv39/bS0tFBeXj6nhGGmER61TkeSJDZt2jTtGql0IFXCM57oRNfoJIJer48TtFNVfZ1OJy0tLXi9XvR6vUaAJrM2SEaCwuEwg4OD9Pf3U1dXRzgcnjAS9PeITC90c7n/RNowPT09+Hw+bDYbDoeDrq4uAoEAZrM5JhJkMplmbZ6yLKfdimGqyIYoUzI4HI4ZZw527NjBAw88wK5du3jggQfYuXNn3HfKy8tZsGABjY2NNDQ08Nxzz7FixYoZ7Xe2MU94poCp3MBDQ0M0NzdTUFCgFfNGI10if+pY6SJP0RgbG6OxsRG73c6GDRum/CY304fzdCM84+t0Tpw4kZZiupkcz2QpLUVRYqInkxGdiZBI1TcUCuF0OnE6nfT39+P1ejEajTEkaCKTS5/PR1NTEwaDgfXr12sLzkSRIJUEpZsAZeub9Vwh08dvMpkoLS3V3vrHC+T19PQQCAQwGo0xJChdTvLZ0KWldthmI9IhOrhr1y6uuuoqfv7zn7Nw4UIeeeQRIEJ4b7zxRp566ikA7rvvPq699lqCwSA1NTXcf//9M57/bCI7f7G/YTidTm1hWLNmjeaqPB56vR6Px5OWfaYrpaUi2s5ixYoVCZ3MJ4Ma0ZjJA26qEZ7oOp0lS5ZodTqq1cVM3sjU6Nd0j2eiCE90VGc2CAJESNB47Y5gMKiRoN7eXnw+XwwJys3NxWAw0NbWxujoKPX19XFF3uNtD9R/E9UFpYMEZUPtRKYJRyaRKJ2UTCBvtpzksyG6kg1zSIZ0EJ6ioiKee+65uM8rKys1sgOwdu1aDh48OKN9zSXmCU+a4PP5aG5uJhD4/+y9eZRcZZ0+/lRX9VK97+lO71tVdceQ0OnuBAUGZxRHRTmignPkADIckEVQJzIQjl+DuAQYgRFmRA3gdhxcjhh/GvWIMyiaEILZTLqrqtfq6uqq3mvfb93fH5z38lb1rfXeW3Wb3Oec/EHoVL9169Z9n/fzeT7PE4JOp0t7w4nd0hKjWhSJRBAMBnH27FkuyTxXEBImpLKSaYWHZVmuosan0xEzoiLXjZqvwpNt+0pslJSUoLGxMe5zDoVCHAkimiCtVovm5maEw2EEg8Gk7Qq+Ca90JIj8vFRET4G4iMViGVc2UiXJu93unJPk5aDhkTPhcblcSqxEEiiEJwvwfQkjkQhmZmawvr6O/v5+NDY2ZrRpFRcXi0p4hLwWSQS3Wq1Qq9UYGxsT/GXOV9K51+vlWlbJ/HSKiooKFkJK/3vaOLCQRCcVSktLodVqMT8/j+rqagwPDyMWi3HCaJvNhmAwiLKysrhKULJ2ZyoSRFpfCgnaOhBKNvhcggkJImPyNAmqrKzcJLyXA9mQwxqSQcnRSg6F8GQJ0tqg2yddXV3Q6XRZbVpitqFyFffSTsNNTU3Yu3cvTp8+LYp1uxgkI9X1zMZPp1AhpDRIhYd2SZYT0QHe1CXMzMxwlgP0Q7OsrGyTZsPtdsPlcsFqtSIUCkGr1caRoGTVvWxIUDQajRNDy6GldTFDiuoKHwkiwnsyfUjyoqqqquDz+RAMBjclyecTCuHZmlAIT5Ygk1czMzOCppbEbmll+1putxsmkwmlpaVxlRFCnoROQYg1OZaIZDqdVJAL4QkGg3A6ndyDWi5kh2VZOBwOzM3NobOzEwMDAynXRms2aBIUDAbhdruxsbEBi8WCcDjMxRoQYbQQEhSJRLCysoKamhouO0ypBOUX+Won8QnvSV7UxsYG7HY75ubm4sbjq6qq8kaC5CxaJgcWBZshz09Mxjh79ixKSkp4J6+yQaEITzAYxOTkJILBIK/WSKzKkxgVHhrpdDqpkK/2Gh9IpUKlUqG1tRVzc3PcmDgxDKypqclJvCkGyOg+mcTLleiqVCpotVpotVpuhJn4uLjdbqytrWF2dhaRSCSOBBFhNB9oo0OakLW0tPBOhtH/TiFB0qCQ+hmSF1VaWorBwUFOFkCS5K1WK3w+H1QqFZcbRkiQ2NUYpcKzNaEQnixxySWXyCI9m0YmLa1oNIrZ2VmsrKygv78fTU1NvO+jEDEV6ZCJTicVClHhSRwzLyoqQldXF/f/6THx5eXlTWPi1dXVoo3x8iESiWB6ehperxd6vT6nSbx0oH1caDM7ku20urrKGXAmVoIICfJ6vTCZTKioqIgjZMkiM/hIEJ05ppAgYZCLYJisQaPRbDLjZBiGI0E2mw1erxcA4kiQ0CR5MargUkEhPMmhEJ4sIUa1QGykqvCwLAubzQaLxYL29nbs27cv5QMrH67NmSIcDiMQCODChQuCcq/EEi1nSlAzGTNPNibucrngdruxuLjITUSRKlAqcXCmIMn28/Pz6Orqgl6vz3vEBnH0pWMNSMr3ysoKpqenEY1GOb1TT08PWlpakrYQ0uWGKSRIPMiB8KRbg1qtRk1NTdymzzAMd4/Z7XZ4vV6wLLspRDXTNpVS4dmaUAhPlpCL7oJGss14bW0NZrMZdXV1GBsby+hEIpb2RgjhoXU6Go0GIyMjgh4uYlR4MsnCEjp9VVJSgqamJs7LRKg4OBFEt1VdXS2ofSU2SAuisrISLS0tWF5exvT0NJqbm6HVauHxeHDq1CnEYjFuaodUgpLdF29HEiQHwbYcCA+Q/XOYjlshiMViHAlaWlrC1NQUYrFYHAmqqqriJUFyJzz5CkXealAITwFBNlGxHyCkDaBWq1OaH/Kh0C2tlZWVOJ3O3/72N8FTY1K3tKQaM89WHEyqQIlJ1yTw1e/3Y3BwMKOcnULA7/fDZDKhpKQEIyMjm4gc2aCIUaLZbEYsFuO0UGSDEosEkVakXEhQoWMtAPkQHjFQVFTE3TMEmSbJK4Rna0IhPAUEaUWJEXsAxI9q63Q61NXVZf0aYhIeMkmTCZLpdOQwYZXqNfI9Zp5MHEx0MaQlxDAMKioqEIvF4PF40Nvbm5fA11zAMAzm5uawurqasnVJb1BtbW0A3tygSIL84uIiPB4PAGyqBCXbpLMhQcFgEAzDcKPy+SZBciA8hAS+XZEqSZ6I7+fm5uD1ehEMBlFbW8sRbrlUTP1+PyoqKgq9DFlCITxZQswHjliEh2EYhEIhnDx5Er29vRmNaqdaUzZEJRnUajWCwWDan0vnpyMGAZNiSktO5oF8upiNjQ0YjUaUlpaivr4eCwsLmJ+f5x7O1dXVgoWbYmB1dRVTU1NobW3F6Oho1ptpUVHRplYFEa263W4sLCxwotXE954pCSJWFBaLBT09PQBQkHaYHKorDMMUnHTlG/T3i+DMmTPo6upCKBTC+vo6LBYLotEotFotR7ZT2TBIBdL2LPR9IlcohKeAEDqaTqexq1QqwaPyQOZEJZPXSUVUMvXTEas6I5TEkXXIiejwIRwOcxEnl1xySdxDmq6G2Gw2rhqSKREQE8FgECaTCSqVCrt378568i4VkolWiZGd1WqFx+PhKkbkvfN5uPh8PhiNRpSXl2/SPSXeD1KTIKXCIw8dEwCulVpXVxc3gRgIBDivoPn5eUQiEd4keSkht2eSnKAQniwhRYUnF2xsbMBsNqOqqgqjo6M4d+6cKA+DfGh4EnU6qaoMYqxHTNGyXF2SSTyIzWZDX18fr+1AsmoIyTaan5+H1+uN+zlCBMR6r4ToOhwODAwMxE2pSQm1Ws07vkzeu8ViiXvvlZWV3P9L1mZL1w4TmwQVmmwAha8yFfr3E/BpeGgbBrrdHAwG4fF44HK5sLCwgFAoxEuCxPiOkclQBfxQCE8BkQvhIcJOlmWxY8cOToBKXkvo6UHMKa1EkpGLn44cNDwsy6K0tJSLXSDi4EKZBSaCkN+Ghoasc9D4iABxtKUDROkpl8Rso0yxvr7OEd2xsbGCb1zJ3rvNZsPMzAxXLZ2cnIzTA6UigFJOh8llMyvkGuRCeIDMrgOtuUuMZiEVx8XFRYRCIZSUlMSRoFx8uLxer2yHEuQAhfAUENkQHmIUt7GxAZ1Ot+lkLGZlRmwfnmxyr1K9Tq4Q6pIci8XQ1NSEuro67qTmcDgQCAQ4nxzaLDBfCIVCmJycRCQSwc6dO7OaxksF4mhLi96FGCXS67zkkkug1WpFWafYCIfDMJvNiEajGB0d5dZJcp2IKJzkOmVKAMUiQXJoaRUacp6OyhT09CWxoAAQR4IcDgeCwSCKi4vjSFC6Q5bL5Yqr4CqIh0J4skS+W1qJIaXJjOLEiqoQizgVFRUhGo1ibm4uq9wrvtcRWuHJ9j0l0+nwhRySEXEikKV9ckglSOzpjVgsBqvVCrvdzrWvpEYyo0Ty3u12Oy8BXFlZgc1mQ29vL3fClRuIOafVakVfX9+mdfLlOvERwOLi4rj3nmpzyoUERSIRyawstgrezu+9tLQUpaWlaGxs5P6OTpJfXl6OS5Inf2iyTSrQCvihEJ4CQqPRIBAI8P4/lmXjDNj27t2b0gVUboTH6XRifX0d1dXVOQesirWebF2Ss9Hp8PnkJOZHkegE2icn1+BB0hZqamrC6OhoQU+7JSUlaGxsjHtAEwK4srKCCxcucJoYWh+T78mVVCBtVqKFy/RzSUUAiZFdtnEhqUiQz+fDzMwM6uvrwTBMXCWIL3j17Qo5VHjyKZxOlyS/uroKv9+PEydO4Pz582hpaeGeYblcp/X1ddxwww2Ym5tDd3c3fvrTn/Lamzz55JM4fPgwVCoVdu7ciRdeeCGv1e1coRCeLJGPCo/L5YLJZEJ5eXnGWhexiIpQ4kQ2EI1Gg4qKCvT39wtaj1ixEOleQ6zpq2T5UcQwz+FwYHJyMs4wL51XDPAmkTCbzWBZVtZtIbVajdXVVQSDQYyNjaG8vDxtinohPEwYhsHMzAycTicMBoMoWWJ8BJA4ZZNIA74qWDrBqtVqxdLSEtcOTqwEkXv7YiBBQk1IxVpDIa8rX8Wxr68Px48fx29/+1ucPXsWo6OjKC8vx6WXXoq9e/fixhtvzOi1Dx06hH/6p3/CAw88gEOHDuHQoUN49NFH437GZrPhm9/8JsbHx6HVanH99dfjxRdfxC233CLm25QECuHJASqVShSWn0guAoEAN1JsMBiy6sUWusKTqNOpqanB8ePHRVnPVnRJpkFHJ2zfvh3AWyPiZHLD6/VCpVLFJahXVFSAZVlYLBYsLS3ldaopW9AZXT09Pdi2bRt3HVMZJa6urnJuthUVFXEEMNcqWDoQc8a2tjaMjIxIqospLS2NiwsB3iJBxB4gGAyirKyMe9+kEkQOPo2NjXEeRZlMh9FVSuDtQ4Lo4NBCrqHQpCsRDQ0NuOaaa+D1emEwGHDgwAG43W6cOXMGFosl49c5cuQIXnnlFQDAzTffjKuuumoT4QHeFPcHAgEUFxfD7/dzzzW5QyE8BQQhKdFoFDMzM1hdXcXAwAAaGxuzfghrNBqEQiHBa8r29xI9ycLCQs46nVRQq9WC3xcf4SGEtVBj5slGxMlGODs7C5fLhXA4jKqqKnR2dkKr1cpSuOrxeGA0GlFdXZ1RWyhVgKjb7cbS0hJXBcs0OysT0N4/l156qeR+KMmQSILozDS32835BAFAS0sLqqqqEIlEUq43UxIExMdmZEOC5OCBI4cKjxwJDwEdHFpdXY0rr7wyq3+/tLTEfSdbW1uxvLy86Wfa2tqwf/9+7pl09dVX4+qrrxa++DxAITwFhFqthsfjwYkTJ9DR0ZE2yTzda4nR0soGtJ9OOo1RrhBLtJzMJVkOGUkEarUadXV1KE8xH9IAACAASURBVCsrw8bGBqqrq9HT08NpQyYnJzldCNED5XsyjEY0GsX09DTcbrfgtlCqKlhibES2Roksy8JqtWJxcRH9/f1xLSc5gJ7aUalUWF1dRV9fHxoaGuDxeOB0OjE/P49wOJxVcGwyEkQToUQSpFarOUKdeF0L3coBlApPOrjdbq6Vngzvec974HA4Nv39V7/61Yx+x8bGBo4cOYLZ2VnU1tbi4x//OH70ox9l3DYrJBTCkwPEaGkRshCJRHD55ZcLJgtitbQyAQkn1Wg0GWuMcoWYY+lyd0mmM6UGBgbievR0K4uuBtBGZjQJklIYzLIslpaWMDs7i87OTuh0OkmuY7rYCD7HZNIKJOtxu90wGo2or68vuMg7FUKhEEwmEwDEVZ8STeyIID5XPRRd1SFIJEGJAaqEBEWjUYVsyGQNyUBXeJLh5ZdfTvr/tm3bBrvdjtbWVtjtdt7Jypdffhk9PT1chfK6667DsWPHFMKjYDM8Hg9MJhOKi4uxe/dunDlzRpTKSD4IjxA/nVwhhmiZPKzJ9ZEb0WFZlktmziRTiq8lQoTB6+vrmJubQyQSidPEVFdXi3Kf+Xw+mEwmlJWVbYpayAf4YiP4jBIJyWUYBjqdLqc2cT5AtE9kJD6VxUAyQTwdbDk7O7vps6+qqsqZBNFEyO12Q6VSIRwOp6wESQk5VJmi0ahk+jKhEJqU/uEPfxjf//738cADD+D73/8+rr322k0/09nZiddeew1+vx9arRZ//OMfMTIyImTZeYM8PzWZI5cHJzFf8/l8kpAFMVtaiV4fQnQ6QjUnQkXLLMuCZVlotVqcOHEibkKmpqamYDoOAuKcXVxcnLOuJFmCOtHEEHsDhmE4TUxNTU1W4aEMw2B2dhbr6+ucKF0uoI0SaTuHxsZGFBcXY3FxEVNTU5xPDqmE5eJkKyZITldlZSVGRkZy2kST6aEICSICbSIKp9uBqX4fTYIYhuEOOjqdDmq1epNPEF0JkpKQMAxT8FTyrV7hSYUHHngA119/PZ577jl0dnbiZz/7GQBgcXERt912G44ePYq9e/fiYx/7GIaHh6HRaHDppZfi9ttvF+stSAqF8EgM0qZwOBzo6+vDjh07JHnIilnhoVPcSeutqakpa50OIStCHg65ErnE8vw73vEOqFQqhEIhuFyuuHZQIUakaQIxMDDA63UhBOk0MSQ8lPwcIQF8AZr0VNPo6KgsKyXAm1OOJLpkZGRkU1svE6NEsTKNUiEWi3GtSynIYzpROB8BJkQo8bu6vr4Os9mM9vb2Ta1L8t1KpguSggTJocIjd8Ij5DDd0NCAP/7xj5v+fvv27Th69Cj33w8//DAefvjhnH9PoaAQHolAJ5m3tbXhsssuk/SLKibhUavVXKAiYfC5+L4QsiLk4ZCtaDmdTqe0tBTNzc2bjAJdLlfciHSulZBM1re8vIyZmRm0t7djZGQkbw/wdOGhJECTxCaUlZVhZWUFpaWlBZ1qSgc6kFSn08Vpn2gkM0rkC3akq4Bi6qGcTidMJhOam5vz+tknI8B8/lCVlZWoqKiA0+kEy7JJ0+z5JrzSkSDy87mSIDmQDTmsIRmEEp63OxTCkwPSnQDJqaimpgajo6MpH5hiWcWL1dIKh8Pwer0wm80YGhoS9OURY02ZvkauY+a0LoKchslG4HK54iohyYSxmYJc19LSUuzZs0cWjsN8AZrhcBiTk5OwWCzQarXwer04f/78plagHCo9hEA0NTXlFEiamGlE66Ho6SihVcBoNIqpqSn4/X5Rc8+EgIi9q6qq0NbWBuAt8jg/P4/y8nIwDIOzZ8/G2QOkOgCkIkHkuymEBMllLL3QbbVk8Pv9sri35AqF8IgIIugkdtsVFRVp/w3dPhICoZsPrdMpKyuDTqcTfFIQyyU5XYVH7DFzeiMgIJUQl8vFCWM1Gk0cCUimCSE+S06nU3b6l0Ssra1hcnISLS0tGBwc5K5lOBzmWoGLi4txZnlSVELSIRKJYHJyEsFgUFQCkUwPxVcFJCSopqYmpVEiaSGlysKTA8ikmEqlwr59+7jPMxaLcVEG5AAAZG4PkA0JikajcWLoxO+zMpaeHOTQV+jrI2cohCcHJD6wwuEwpqen4XK5UpbU+VBcXCwK4RGCRJ3O1NSUaMnrUlZ48jlmzlcJIQGSienp9Hg4mZrq6OjAwMCAbDc7OrqCr4VRUlKSdDIssRJCZ4aJfRJmWRYOhwNzc3ObHJ2lAl8VMBOjxOLiYkxNTUGtVsumoscH0n63WCzo7+/fNClWVFS0aTIu0R6AdgqvqqriqqBikCD6+88wTMG/Q9FoVJaEh6DQ10fOUAiPAMRiMVgsFiwuLqKnpwcGgyEnh+RIJCLRClOD9tOhdTpitcfE9NChQecIFcIlmSAxQJI45rpcLiwvL+P8+fNQqVSora1FNBrlzATlNNJKJ69nY8qXrBLCNx0kllsymWoqLy8vyEg8jVSaGJfLhcnJSbjdbpSVlaG2thbLy8sZGyXmE4FAABMTE9BqtVmFp/LZA/DpwYhujFSDciVB0WgUDocDPp8ParU67pkpRBOUCxiGkdV3mIBUuBUkh/w+tS0Acsqcnp5GS0uLoDRwsf1zMhkDpytSBoNhU+tKToQn8b0kppnLafNQqVRQq9VwOp3w+/3Ys2cPqqqq4Pf7ORI0NTWVdXCoVCD6F5LVJPTUyjcdRJMAPrfkdJUA8hqzs7NYW1uTdUuQbLx2ux01NTUYHh4GgKSVEPL5p3v/UoBlWSwsLMBms2VdlU4Gvioo7ZE0NzfHEZbE958qQT4YDGJiYgJlZWWcTos+9NCVIeCtSq9Uzwe5trQ8Ho8oIbhvZyiEJweEQiGsra1hZGRE8OSKRqMRzT+HEIxkp49EP51kFSmx1iSmN5DcXZLptkBXV1fcCC8hAcmCQ4lbMC2KzUUUnSmIKDkcDksuoE2lh+KrBBASVF5eDpVKxQ0AtLS05HWqKVvQNgOJwb/JKiEulyuOBNCfP3n/UsDn82FiYoIbqpBy86Y9kggikQj3+c/MzMDv9/O+fwCcKSMfKUuWGyY1CZIr4XG5XFkFTl+MUAhPDtBqtdixY4coryVmS4tUi/gITzZ+Ookl41whBuEhDy+v18uJguVEdIA3R0FNJhOqq6szarXwjYeTk7DL5eI2AY1Gw+lhxJiMYlkWNpsNVqsVvb29aG5uLsi1TFYJIB4509PT8Hq9iEQiUKvV6Orqkq1TMvBmtpDJZEJra2tGpCyZHoyQgOnpafh8Ps4okfzRarWCrgFpwa+srGwiZflEcXEx6uvr4wgM0cN5PB7u8w+FQtBqtejo6EBZWVnK6nW68FQ+o0RSkcuWBMmV8Ag1HbwYoBCeHCDmg1cKw0AayXQ6qaBWqxEMBgWvRyjhIe2rtrY2GI1G7gFIi4ILqeOIRCLcqLHQ8Ey+kzAxyiPtIDIZlUtmFiFltbW1WWk18gWNRoP6+nrU1dXBZrPB5/NhYGAAJSUlXB5WMBjcJAovpDcQmRQLhULYtWtXTl5VBHwkgDZKpEXxuRglkmvY1NQky0oZ0cPV19fDZrPB7/djx44dnCcYHZxLv/9UbtlSkSC5Eh6Xy6UQnjSQ11PvIoRGo0EoFBLltWiCQet09Hp9Vk6+Ymp4cnlviWPmnZ2d6OzsTGkSSE8GSf0wpysl3d3dOYnVM0GiUV6qzCyaBNAP40gkwlUMBgcHUVlZKfo6xYLX64XRaERVVVUcKaPfPwlOFdMjJ1vQ4alSTorxGSXSwbE2m22TPUAiCWQYhrNEGBoakvXnHwgEMD4+jsrKyrhWGx2cm8wtm9YE5YMEybHaqFR40kMhPDlCjMR0QPwKTzgchsViSavTyceass3BSqfTSWYSSEShiXoYQgLE1EO4XK6CVUrSZWYRt1yWZbmNbWNjA729vbL2f6E35VSVMpVKxRkF0k7ZZDKMJsEkPJN45Ih1Ik+Mr8h3hTFVcGwiCSwuLsb6+jra2towMjIi28+fFlCnO5ylI4GkEppNJSwdCaKfSaFQCAzDcH5BchqcUAhPeqjSbNrCd/S3KcLhsCiEx+l0wmaziaIJOnv2LFwuF1pbW9HT05PzZkzEpDt37hS0ntXVVW6yJhXEHjOn9SAul4srhSfqYbIBSYoPBoPQ6/UZmUoWCm63GxMTEygqKkJpaWlSUagcNkA6p6u9vV2UNdGRCUQXQkgguQeyHQ9nWRZWqxWLi4uiTTVJhUgkAqPRCK/Xi5qaGvj9fkSj0U2VMDm0Nf1+PyYmJlBZWYn+/n5RiCldCSR/EiNDcmmHrq2twWw2o6OjA01NTZue/1JPh6XDd77zHWi1Wtx11115/90yQ9KHSOHv+C0KOVV4iE4nGAyis7MT3d3dgl5PzJZWJi7JYo+ZEz0IvSmRByCdmUSb5CXbAMjpc2FhoaBC30xAHJ1dLhcGBwc3iaLJ+19eXt5EAkkrIF8IBoOcq6/YOV3JIhOIKNhqtWY1GefxeGA0GlFXVyf5VJNQrKysYGpqCl1dXVxgLpA+PFSoR1K2oAkknzWGECSrBJJKmMvlgtVq5TSB9D3Ap4kjafE+nw+7d++O02olqwTla0SeBjnsKkgOhfAUGEIIT6JOx+v1ikbCxCA8qaIl8j1mztcKIK0QPn+cmpoaLv+ovr4eY2Njst3o6EDSZI7OmZJAqUXh9EaXjdGhUPC5BSebjKPjEhYXFzkCKWf9SzgchslkAsuyGB4e3kQg04WHLi4ucs+PRBIk9kbt9/sxPj6O6urqvBHIZO1gQoI2NjZgsVg2acJYlsXU1BTa2to2pcUD2WuCyFqkIEFKSys9FMJTYORCeJL56QSDQQQCAcFrUqvVoml4EgmPXPx0kpnkeTwerK+v49y5c9zDj2EYLC8vo6amRvBosNjw+/0wGo05BZLykcBAIMCrh6FF4bluUGRSqL6+XhaVkmSTcR6PB3a7HRMTE1Cr1aisrITD4ci5HSol6KiNvr4+rqKRCdJVwhYWFkQ1SqTJ7uDgYME351S5aU6nk5vALC0txcbGBqLRaEYHgUKRIIXwpIdCeHKEWJtetu2jVH46UhIVMV4nsX0lJ+JA4HQ6sbS0BL1ej8bGxrgqAGkF0aPR+Q7NJGAYBnNzc1hdXYVerxelJUCLwltaWgBsrgLQTsnkGqTbAEmlzOv1yn5SCADsdjui0Sguu+wylJWVcVUAQgLkYo9AHIjFFFAny81KNIrMxi0ZyK/ZoRCoVCpEo1FYrVa0tLSgs7MTAHiF8dloonIlQXxxG8mgEJ70UAhPgZHppp+Jn45YrSixyZzYaeZSYH19HZOTk5tiFvj8UfimYuipoMTRcLGxurqKqakptLa2YnR0VNLryVcFoDfARKdg8v7J/UlabZ2dnbKeFEtVKeHTg5BK2NraGmZnZzlRcDJ7ALHXarPZsLCwgIGBgbixbSmQzihyZmYmqVEiAMzPz8PhcMBgMMh6Q47FYpibm8Pa2hp27NgRR8wTq8HJNFHkOUCqoUJJEHmeZ0KC3G63qFqotyMUwpMj8vXgzsZPR+xcLqEoKipCKBRCIBBAcXGxLKs6dEr4JZdckpF5XLLRaJfLxSVnsyybVV5UpmslQl++RPN8IVVyPBmP9/l8iEQiKC0tRVdXFxoaGmT32ROQtqBWq82oUsJXCeOzB5AiM42eaipkpYRPE0bagSRB3uv1coeBrq4ulJaWZpT1Vwh4vV6Mj4+jqakJe/bsSfs5pdNEkedALBbLShguhAQphCc9FMIjEyQ+CGidTqbmdmK1tISC/nI2NTXh3LlzcRMhxBulkJUeYrO/tLQkWDxL64Hohx9phdFtAPL+a2pqUhqkJa6VnJLzcaLPBcQpt66uDvPz8wgGg+jr6+MexHa7PU4QSiohhRyNJteVtDCFbBbJNkA6My1RD0OIcDb3wNLSkmwrJSUlJZxbssVi4SwcWJbl7oF0Ron5BsuysFgsWF5exuDgoCC3dL7cODo81263w2w2byLClZWVgkhQLBbDmTNnuPamguRQfHhyRCwWEy0D67XXXos7rdE6nWz8dEKhEP7+979jZGRE8JqOHTuGyy67LOvTWDKdDv3Fd7lckhsEpsLa2homJyexbds2dHV15Y14kSqIy+WC2+1GIBDgHv7kGiQ+sEirrbm5Oa9rzQUkfb2pqQnd3d2b1kpPxpE/hXDKBt4ykGxsbORdq1RgGCbu/SdrB9LfA4/Hg4mJCTQ0NKCnp0fW94DX68XExATq6+t510p75JDvQTgc5sbDyWEoHxu33+/HhQsXUFdXh97e3rxdV9oslfhEAchpOi4ajeKpp57Cb3/7W3znO98R7J32NkHSTUQhPDlCTMLzxhtvYOfOnYhEIpxOR6fTZZ3NwzAMTp48iX379gle0/Hjx7F3796MHwK5TF/R3jBut1tyQXAgEIDZbIZKpYJOpytYS4iAPPzJ+3e5XIhGo6ioqEB5eTlcLhdUKhUMBoOgnCapQTKlgsEgDAZDVunr9MPf5XLFVUFoUbRYRDgajWJ6ehoejweDg4OyMJCk24Hke0Ayo/x+P4LB4CZNidwgJJiU1kSRPyQyRQqjRNrZWQ7TYsCbz26aBJHvAU2CEs0y5+bm8OlPfxrvete78PDDDyvVnbegEB6xISbhOXXqFDQaDfx+f9a5VzRYlsXx48fxzne+U/CaTp48iV27dqX9Eok9Zk6bg7lcLkQikU2tsGx1CwzDcA/jgYEBWbvkxmIxTE9Pw+FwoKKigrvHCAHIpg0iNWihr5iZUnQVhDhlE38cQoIybQfSIK7O7e3taGtrk8U1TIaVlRWYTCau2pOpSV4hQPQvYlagaF0cqYKIYZFA8rqqqqrQ19cn22kxIH44gFyD+++/H729vaisrMSxY8fw7LPP4t3vfnehlyo3KIRHbLAsi3A4LOg1iE6HOKP29fUJfggfO3ZMFMJz6tQpDA4Opqws5GPMnIhB6VYYXQGoqalJ2Qojm1xrays6Ojpk3Q4gbRbSDiAPY/rB53K54PP5RCEAQuDz+WA0GlFeXo7+/n7Jx7Lp0EiXyxWnBUnWDiQIhUIwmUwAAL1eLysfnUSQEX4S9kqqZYlOwVJXQTIBmWpaXV0VrH/J9PclRoZkKgxnWRaLi4uwWq2CDpWFxvT0NB566CF4PB5s27YNk5OT0Gq1GB4exl133QWDwVDoJcoBCuERG0IJz+rqKsxmM5qamhCJRLBt2zZRxKhiEZ6zZ8+ir6+Pt4yeOGYO5Dc9mFQAyIPf5/NxMQlk82MYBiaTCcXFxRgYGJD1JpdLThchAOQaEAJAXwMpSEgsFsPs7CyXkVaodkBiO5BoQWh7gMrKSiwvL2N+fh79/f2cwaJcQbRlHR0d2L59e9rvFD0ZRv6QqSA6M0yKKgbRFeVbA5UI2iiRtIIAxAnD1Wo1TCYTysrKMDAwIIsMsWzBsix+97vf4eDBg3j44YfxkY98hLs/PB4PTp8+jb6+Ps464iKHQnjERq6Eh/bTITqd6elpVFZWcm6fQiAW4blw4QLa29vjNjS5uCTzgWx+xDgwHA6jpqYGjY2NefHGyQXk1Dk/Py+4JUQqALQeKHEyTujmt76+DrPZzBmyya1aRrdB1tbWsLq6iqKiItTX16O2tpa7BnJbdyQSgdlsRiQSgcFgEKQtSyaIzcYoMt3rE8IrVxNJUhElZqFutxtarRb19fUZGyXKCV6vFwcOHIDD4cDhw4c5KwQFSaGEh4qNbL8skUgEU1NTvH46arVaND2QSqVCLBYT/FCnR9xJijkZhZQT0SEoKSkBy7JYW1tDV1cX2traOCEk8UUh3jhy0MKQQEqSJyT01Enb5Ce6JLtcLthstk3twEwf/OFwGGazGdFoFLt27ZKtgJpcg6WlJQQCAQwPD6OqqiplaGi6lqjUWFpawszMjGjBtPR7I0hlFEn+ZHINSFWnqakJIyMjsiOOBGq1GuXl5bBYLCgvL8fu3buhUqnijBL9fn/cNZBjbAwAvP766/jc5z6HO+64A7fffrtsr/lWgVLhEYBwOJw2rDPRT4evVG2z2RCJRASnnAOZi43TYXJyEjU1NWhqapJ9HITP54PJZEJpaSkGBgaSvnf65Ee0MMXFxXFtIKknt+gpIb1eL7nuIRGJgmDSDkzUAwFvOfpardasc5oKATIWn26En3YJplui9OZXWloq6b0eCoVgNBqhVquh0+nyLkCORCLcdyFxMizxGpCqzvr6uuxDVAFwzsfp2pippuPIn3xr4+i1Pfroo3j11Vfx3HPPQafT5X0NWxhKS0sKpCM8tE4nlZ8OcSXt6+sTvKZTp05lPRrMh5mZGZSUlHBtNjmSnWg0itnZWWxsbECn0+VkHBcOhzkC5Ha7EQqFNkUEiNHzZ1kWS0tLmJ2dRVdXF1pbW2VzPck1ICQoFAqhuLgYgUAA1dXV0Ov1BR/hT4VoNIrJyUn4/f44oW82oK8B0UTR3jBiaaLoNubAwEDe0uIzAd810Gg0CAQCaGhoQF9fn6zvA2LrEYvFYDAYciKRxCOIvga0VUY+jBJNJhPuvvtuvO9978OBAwcKktO2xaEQHikQiUQ4PQsNotNRq9XQ6/VpWwBra2ucf4VQnDt3Dj09PTlXDkjrihjeAYhzBy5k+Z9eIyEPHR0doo4Y0+Z45OGfGBNRWVmZ1e8jE01arRYDAwOyfoAxDIPp6Wmsr69j27ZtnDi6UAaB6UBO82KTyERNlNvt5jyScrVIIBEWZLJNzuJZYo+wvr6O1tZWjggQt2yxDwRCsbq6isnJSfT29oqihSSgjRLJH6ksAmKxGA4fPowf/OAHePbZZzE2NibCO7gooRAeKZBIeFLpdFLB5XLBarXiHe94h+A1jY+Po7W1NaexSzJmTjRAKpUqbiKKeKKUlpbGkaB8luMJmdRqtejv78/L76ZjIvjGwpO1QBiG4VoBhZxoyhRkhL+trQ3t7e2bok5og8BCOmUDb+WK5bMlRFskEEFwJplpLMtifn4edrsdBoNB9nlHLpcLRqORE6fTn2nigYD442STFyUmotEozGYzwuEwBgcH8zKNmYlRYlVVVVYHG4fDgbvuugu9vb14/PHHZWGIuYWhEB4pQAhPLBbDwsICrFZrUp1OKvh8PkxOTmL37t2C10R8XLIZwc12+iqZOSDZ/KU4/UciEczMzMDtdkOv12fl5CoF+MbCtVott/mHw2HMzc2hvb19E3mQG+hQ0mx8amgtDCHDxB6A1oGICdolVw65YsQhl9wHdGYaqX7Mzs5u8laSIxiGwczMDFwuV1Yu1LQ4PnEyTMzw3ESsr6/DZDLJokWcLDYl0Scp8fNnWRZHjhzBoUOHcOjQIbz//e+X9bNii0AhPFIgGo1iaWkpI51OKoiZgTU9PY2KioqMRhfFGjNnWZZ76POd/oVMQLAsC7vdDovFgs7OzqzJZL5ATn2rq6uwWCxgGIarhNGtMDm0gQhYloXVasXi4qLgAFWCxJwkMTVRJKeppqZG1i65kUiEC411u90oKSmJa4FIQQSFIlVVJxckugQTIkhPCOZaEWQYhtNsDQ0NyVZXlMwo8U9/+hMAYOfOnfjFL36BUCiEb3/727LSc21xKIRHCpjNZmxsbGSk00kFMTOw5ubmoNFo0N7envRn8jFmTudkuVwuLigzG2M8MrpNbODlrH0hrrN0fAVtikZyonJNTBcbbrcbRqNR8soDnyaKdsfNhAjSrcFsc5oKAUIetm3bxvkVJZokEiJIn/4LcX8TzZbb7cbQ0JDgYYdU4JuOI1OSmU5FOZ1OGI3GLREPwodYLIa//e1v+NnPfoY///nP8Hq9aGpqwu7duzE6OorLL79ccUsWDoXwSIFkouVsIWYG1sLCAqLRaNIR90SX5Hw9MGgRKHnw00JYeuOLRCKYnp6G1+styOh2tiAOuZkY8tGJ6XREgtQOyQQkusDr9cJgMBRkxJjogegWSDJPFGJ2uBWiQWjykK4lRCqCNAnKtxaGkIft27ejo6OjIOQhmWM4fS+UlJRwImqXyyU5MZMSoVAIX/nKV3Dq1Cm88MIL6O7uht/vx9mzZ/HGG2+goqICt956a6GXudWhEB4pwDAMZ84nFGI5JDscDvh8vk0j7nJ0SaY3PlIBYRgGkUgELS0t6OrqKlgFJBMEg0GYzWawLJvz6HY6IijWRBTLslheXsbMzIwsW4OJvjA+nw/RaBRFRUXo6elBU1OTbMIy+UCIGZ/gO1PwaWGIUSSthRGj3URIb65j/FKBnoqiSVA4HEZtbS06OzsLVg0TigsXLuDuu+/GRz/6Uezfv180Mvu73/0O9913HxiGwW233YYHHngg7v8bjUZ86lOfwqlTp/DVr34V+/fvBwBYrVbcdNNNcDgcKCoqwu2334777rtPlDUVGArhkQJyJDwrKyvcVBAgT6LDB5fLBbPZjMrKStTX13NEiC79EwJQ6DFYYiZpt9tF074kvn6qiahsNVGBQABGoxElJSUpjRnlANpyoL29HSUlJUmzsuQQFxKJRDA5OYlQKITBwUHR9SSpgmPJdcjmULCxsQGTySSImOULdIxFb29vnFGgGMnp+QLDMPjv//5v/PznP8d3v/tdUYZT6NfW6XT4wx/+gPb2doyOjuJ//ud/MDQ0xP3M8vIyLBYLfvnLX6Kuro4jPHa7HXa7HcPDw/B4PNizZw9++ctfxv3bLQolWkIKiP2wIHoaIdBoNGAYhns9ubskk+DMQCAQ5+JKvDTo0v/y8jKmpqYKGhFB3HwbGxsxOjoqyUOWjgcgWixaE0WiE4ghWrK08Fgshvn5eTgcDuh0OtTX14u+VjFBE7ORkRHuFE/fCyQra2lpKS4uRMppoGQgHkDd3d1oaWmR5B5Uq9Wora2NG2Wn26IOhyPuXqDbQDToqo6c40EIvF4vxsfHN8VYtLa2AogXBNvtdq7SmhicWugW6MLCAj796U9j9+7dSde2DgAAIABJREFUePXVV0UnxK+//jr6+/vR29sLAPjEJz6BI0eOxJGW5uZmNDc34ze/+U3cv21tbeWuZ1VVFQYHB2Gz2d4OhCcpFMIjE6jVajAMI7h6odFoEI1GOT8dQJ5VHTJevLCwkDJHSKVSoby8HOXl5dyXk46IILk4xcXFm3xxxEQ4HMbk5CTC4TB27tyZ9zaARqNBfX09R1rotPD19XXMzc1xxng1NTUoKirCwsICmpubMTY2VvAHfyrQ02KpiJlKpUJFRQUqKiqwfft2APEeSRaLJS/C8HA4DKPRCJVKhT179uS9YlZcXIyGhoa4kXxiFeF0OjE/Px9nEKhSqbC4uIiOjg7odDrZPQtosCzLif8HBweT6veKiopQVVWFqqoqLiGcHhKwWq3wer1QqVRxwvB8HY5YlsVPfvITPPXUU3jyySfxj//4j5L8XpvNho6ODu6/29vbceLEiaxfZ25uDqdPn8bevXvFXJ7soBAeARDzBiZERQjhYVkWarWa0xPU1NSgtrZWdiOwTqcTZrMZdXV1GBsby7pKwnfqpSMirFYr1/6gvYFyqcYk5kk1NTXJYsNQqVQoKytDWVkZVwGJxWJwuVxcxay4uBirq6sIh8OyCMrkAwmkrK+vz6liVlRUxH3GBHwVECKETVYNywS0RUK6nKZ8g9wLJO+MZVl4PB5ufLukpAQLCwtwuVxxomg5EWGfz4fx8XHU19fnFE7Kdy9Eo9FNhyMhLcFMsL6+js997nMoLS3Fn/70p5xMYDMFnyQl2/fi9Xrx0Y9+FE899ZTsJyCFQiE8MgEhPLmAHjMvLi7G2NgY98BfWFjYtPlXV1cX5EEXCoW4KsmOHTtEdRMtKSlBU1MTtwnRrriLi4ubksIz2fzdbjdMJhNqa2tzImb5BNG+zM3NoaenB9u2bYNKpYobBZ6amiq4UzYBMblzOp0YGhoSdVossQJCV8M2NjbiqmGZxkSQdltZWVlcu02u2NjYgNlsjhvfprVhCwsLBa2A0CAVPuJELaYjuUajQV1dXRzpIJNhbrc7riVIE+JcDoksy+L//u//cODAARw4cAA33HCD5Neyvb0dVquV+++FhQWu+pkJIpEIPvrRj+KTn/wkrrvuOimWKCsoomUBYFkW4XBYlNe6cOEC2trasradz2TMnN78iQhWpVJxX+7a2lpJp6GIE/Xi4iJ6e3sLViVJFpORqIMhY/E+nw96vV726dAkq4tkNKXbjGmnbFoMLLQalinIGH8hhbOJMRFutxsANmnDAHDOzltBB0WCVAOBQEamfHQFJFdvHCEIBAIYHx/nvLYKdagg34nEvCz6OqT6Xvn9fnzpS1/C1NQUnnvuuZQ+aGIiGo1Cp9Phj3/8I9ra2jA6Ooof//jH2LFjx6afPXjwICorKznRMsuyuPnmm1FfX4+nnnoqL+vNE5QpLakQCoVEeR2TyYSGhoaMJ36ETl/RIlin0xkXjSDmNBQJIW1sbER3d7fsqiR0QCS5DtFoFE1NTWhvby9YNSwTMAyDubk5rK2tCcrq4iPEAOJOvGKc/MPhMMxmM6LRKAwGg+wcchMnojweDzcl2NnZKfnBQCgIkezo6BBkO5DMG4fe/IVWBUmreGFhQZb5Ynx5WXRV0Ofzcc+H06dP495778VNN92Ez3zmM3l/Xhw9ehSf/exnwTAMbr31Vjz00EN49tlnAQCf/vSn4XA4MDIyArfbjaKiIlRWVmJ8fBznzp3DFVdcgZ07d3Jr/trXvoYPfOADeV2/BFAIj1QIh8O8fdRskWkkhFRj5sQPxul0xjni0q2PbDa9YDCIyclJbmxSTl4ffCChpOXl5WhpaeEIABkJJ9egkO7INIhOKxOzw1xAqmH0OHRJSUlOwnCWZeFwODA3N4e+vj5OZyJXxGIxWCwWLC8vc35W5Drk2ygyE5AATalG48mzgb4fotHopsiQTA8zwWAQ4+PjKC8vx8DAgOwOQclADgZutxvf//738Ytf/AKBQABerxd33HEHrr32WuzcuVN2msmLEArhkQpiER6LxQK1Wp02EiKfY+b0NBS96dGbf6pRaCLylTOi0SgXmJgslDQajW6qAhVq06OrJEIjTbIFbQjncrniJoGS+eL4/X4YjUYu3b7Q5CAdSOQGqUjyJZ8ntgTp6TjiGJ6vTXxtbQ1msznvAZr05k8OBunGwmniq9PpCh78KgSzs7O48847sW/fPnzkIx/BmTNncPLkSZw7dw67d+/G4cOHC73EixkK4ZEKYsVL2Gw2RCIR3kgIOZkHEvEnnZROdA/Am3oH4pIs11YQEO883NHRkVUuTzJ35ET9h5jvP3FaTA5VEtoXh970iC+Oz+fDxsaGLFsWiaBF1LQfVCZI5ZAsZkuQBjE8DIfDsmkPJsuOq6qqQkVFBZaXl1FaWgqDwVBw89BcEYvF8MMf/hDf/va38cwzz+Dyyy/f9DMMw+REeHN1TM7k315kUAiPVBCL8CwvL8PtdqO/v5/7OzkRnWSIxWJYW1vD9PQ0IpEI1Go1J3qkW0ByAqk6lJaWiuY8zPewJ+OvQq+D1+uNC1GV82bBMAzsdjtmZ2e5ddIiWDneD8R9WMxMqXQtQSIGzgWrq6uYnJyU1PBQLESjUVgsFiwsLECr1YJhGNGuQ76xvLyMe++9F01NTXjqqadEzfgT4picyb+9yKA4LcsdarUakUgEwFveCnJ3SSYJ4cvLyxgYGOBK1MQHxel0wmazccLPVK2PfICIfFdXV6HX60WtOtA6H2IEFolEuOpH4nUgD/xU14GuOhgMBtmHqEajUUxPT8Pj8WB4eJibciIeSW63O+46FDouhJ5oEtt9WK1W845Dk+uwsLCQ9SRQJBKB2WxGJBLB8PCw7LUikUgERqMRAPDOd76Te2+kNZrrdcg3WJbFb3/7Wzz88MN45JFHcO2114r+PBbimJzJv1XwJhTCIxBi3fjFxcUcwaHHzOXaFlpZWcH09DRaWlo2Ofny+aCQ1ofD4YDZbAaAuOqH1IZ4q6urmJqawvbt2zE6OpqX61pcXIzGxkZu8o6+DuliMsj1bWtrw8jIiCwJL42VlRVMTU3xuvnyeSQlxoXEYjFJW4LJ1tvV1QWDwZCX65vsOrjdbqyurmJmZiZpcCxZL+2xJGeQ9fb29nLGmASlpaWbrgNpEa+trXHXQQ5ZWV6vFwcOHMDS0hL+8Ic/pB0qyRVCHJPFclu+GKAQHplArVYjEAggFApBrVbLtqrj9/thNpuhVquxe/fujMrRfJEAtCcOMcQjbri1tbWinfICgQDMZjOKiooyXq9USHYdaCdYr9eLcDiMkpISdHd3o7GxUZb3AUEoFILJZAKAjKsOfHEhySIi6KqgGNNx4XAYJpMJLMsWvEpCXweykdJ6oIWFBc4TRqPRoLOzc0tU+UwmE6LRaMaxGyqVClqtFlqtdtN1cLvdWFxchNfrzXtu2okTJ/D5z38ed955J2677TZJf5cQx2Qx3JYvFiiEp8AgFR2NRoPy8nKcOnUKALiNP9tkbKlAt4N0Op1gu/TEkj/thkuf8nI99ZPR4qWlpbh2m9xAYjJqampgtVrh9/uh1+uhVqvhdrvx97//Pe/GgJmAZVksLi5ifn5elJiFZBERpAW0uLjIeUXRrbBMSTGdwi4X0Tcf6IwokhSv0+lQVlYW55ZNpiXJtZBDe4tMjImhLeLLyqJ9kvhy06qrq0V5VobDYTz66KP4y1/+gp/+9KcYGBgQ9HqZQIhjslC35YsJimhZIBiGERQJwafTIdUP4olDsoDIxphPzQPLslhZWcHMzAy2b9+O9vb2vLXZ6FM/EX5qNJo4QTTfg56YHTY3N8t+Wgx4axS6vr4ePT09m8hMMqds+kGfz4ws4uxcWVmZVxF1suk40gIiI+GJn3cwGITRaERxcTF0Op2s9CF8oKtQBoOBt0pCWwSQKlCiL06+PheGYTgtlBQ+QKlA9ILkT2J0SrYxESaTCXfddRfe//7348CBA3m7hkIck7P5txcJlCktqZAL4cl2+orPFJCUdwkJkmLD8/l8MJlMKC0tRX9/vyxOkXRIKPGCIdWP8vJy2O12xGKxvHvU5IJoNIqpqSl4vV4YDIasRqHpjCy+mIyamhrRN3YiUl9ZWRE980jImrxeL3c/0Kf+6upqBAIBLC0tbRnfl+XlZUxPT/NqX1KB6MNoEkR0UWTz5yODQuF0OmE0GuMyuwqNRJNE4heVSiQfi8Vw+PBh/PCHP8Szzz6L0dHRvK87V8fk6upq3n97EUMhPFIhFotx01XpIOaYOSnvEhJEb3hCNTBkOmhjYwM6nU7WHiosy8Lr9XIRCxqNZpM5ohyckWnQHkCdnZ2CYgBoJFY/otEorwA2GdZ9YdicQbTVlqG+Ir6q4HQ6YTKZtkTVLBKJcFVJ4M32CN0Kk4IMCkU4HIbRaIRKpYJerxfNKoGQQeIPRJNBIe1yhmG4ibyhoSFZHy5oMkj+MAyDn//852hoaMDg4CCef/556PV6PP7447J3hVeQFgrhkQqZEJ58jZmTDc/pdMaZ4ZEqUDrzM1rn0N7eXrBgx2zgdDphNpvj2kH5ygnLBSR1u6SkRDQPoGSgBbCkFUZrHmgy+Ju/L+GL/58RGrUKUYbFIx824IPv2IZIJIKpqSkEAgEYDAbZbwbE6XtpaYmrQiW6I7tcLq4VRqelF4rELS0tYWZmJi/aIvq7QbeAaD1QunvS5XJhYmJCVN+ifCMWi+HkyZP48Y9/jL/+9a+IRqOor6/H8PAwRkdHceWVV3KxIgq2HBTCIxXSEZ5M0sylXBtdBSLmZ4QA0SddkiVFIgCk3IjFQDgcxtTUFILBIPR6Pef5wodULcFccsJyAS2iLmTqNtE8kI0/GAwiUlSKe192I8y89XUv0xThxU8OYG3RkvfYglzh8XgwMTGBhoYG9PT0pCQwfGSwqKgor7ooUtUpKiqCXq8vWNUpMSqDtInpa6FWqxGLxbjK79DQUMrvnNzhcrmwf/9+hEIhPPvss2hsbITP58Pp06dx8uRJNDU14cYbbyz0MhXkBoXwSAWWZREOh3n/Xo4uyXTbg4QAkrX29fXJ3rmVng4S4kmSS05YriDtoKamJt58pkKCZVn8bXYVd/5kHL7IW47hZWrg/rEyXL3nTYNGOa05EfRGnG0sBA0xqh+ZgK6kijHhJjZovyg6KTwcDqOurg49PT2S6IHyhVdffRX3338//u3f/g033nijqO8jXcQDy7K47777cPToUZSXl+N73/sehoeHAQBPPvkkDh8+DJVKhZ07d+KFF17YMi7UMoNCeKRCIuEh5IFlWVm7JJMgv9nZWTQ3N6OkpIQTfUq18QuFx+OB0WhEdXW1JNNBiTlhtAYmF9EnyTsKBoOybget+8J4z38eRzD6FuEpVavw/Y93QRXyxk3HyS0egpBJkhov9neNHBAIEYpEIoIsAkKhEIxGI9RqdUGrOpmCTo7v7OzkKoSJI+Fy1MolIhgM4itf+QrOnDmD559/nje3UAgyiXg4evQonn76aRw9ehQnTpzAfffdhxMnTsBms+Hyyy/H+Pg4tFotrr/+enzgAx/ALbfcIuoaLxIo0RJSgf6CJ46Zy/UE5PF4YDKZUFlZidHR0U0PXbLxO51OWCyWuIBQqaY9UoGOLJAyYqG0tJSzbwfi2x5Wq5XTwKTLCaNTobeCM259RQkeurobj/xuBhq1CjFWhUc+bMAluremhMLhMLfpyyEuhNwTXq8XO3fulIxMlpWVoaysjJuYoi0CFhcXNwWFJpuYpO8JOVZ1+ODz+TA+Po76+nped3J6JNzhcHD2GXQrTC6HpfPnz+Puu+/G9ddfj8cff1ySezWTiIcjR47gpptugkqlwr59++B0OmG32wG8eU8HAgEUFxfD7/crXjoSQCE8IoFhGNm1rxIRiUS4TUKv1yclDsk2fqfTifn5eS4YM50fjlDQm0RXV9emyAKpQZuftbe3A0idj0WysSYnJ1FeXo6RkRHZn+AZhsHs7Cw6Yus4ctslcDPFvFNaJSUlSWMyHA4HJicn46wSpEgIJ1hbW8Pk5CRvjIXUUKlUqKysRGVlZZwhHiGD09PTm9qjZWVlmJ6eRnFx8Za4J1iWxfz8PBwOBwYHB1FdXc37c3wRMuSwtLGxgbm5OUSj0Tg9UL5NMxmGwX/913/hF7/4BQ4fPoxdu3ZJ9rsyiXjg+xmbzYaRkRHs378fnZ2d0Gq1uPrqq3H11VdLttaLFQrhEYgLFy7g61//OkZHR7Fv3z4MDQ3JrrJD6166urqg1+uz2iTojZ98WWk/HKvVinA4HNf+ETr1Qszt5EYckuVjbWxswGw2w+fzoaysDOXl5VhZWclLTliuWF9fh9lsRmtrK0ZGRrL6vDKJyRBbF0WHZxY6JoQGX1Ao2fhtNhvW19e5xHibzVbQAN108Pv9GB8fR01NTdaZcyqVKmVFzG63czEk+RgYsFqtuPPOO3HppZfiz3/+s+T3SyYRD8l+ZmNjA0eOHMHs7Cxqa2vx8Y9/HD/60Y8U4bTIUAiPQOh0Otxzzz04fvw4vvGNb8BkMqGhoQFjY2PYu3cvxsbGUFtbW7ANz+VywWw2o7q6GqOjo6LpXviCEEkVaGFhIeP2TyJoDyC9Xi8Lc7tUUKlUCIVCWFhYQGtrKzo6OsCyLG9OGN3+KSSBI9qiUCgkako4icmgfZvo9uj8/Dw3AUSqQNXV1RltqmR0u7e3F83NzbIkkDTIIaOkpARXXHEFNBoNlw2VWBHL16RguvUuLCzAZrPBYDCI5r2VrCJGIiJmZ2c5jRjdChOiB2JZFi+++CK++c1v4sknn8S73/3uvFzXTCIekv3Myy+/jJ6eHu55et111+HYsWMK4REZimhZZJAH3V//+lccP34cr7/+Ovx+Py655BKOBJGsJClBxrYDgQD0en3OkytCQLd/XC4XQqFQSsEncZndKh5A4XAYZrMZ0Wg0pbMzXeqnfWASdVFSv196OqhQ2qJ0MRmJZni0yFen08lGE5IMLMvCbrfDYrGkdXfmmxQklSB645cawWAQ4+PjKC8vx8DAQEEqT0QjRg4KwWAwp0PC2toaPve5z0Gr1eKb3/ym4My/bJBJxMNvfvMbPPPMM5xo+d5778Xrr7+OEydO4NZbb8XJkyeh1Wpxyy23YGRkBJ/5zGfytv63EZQprUIiFArh1KlTOHbsGF577TUYjUa0tLRgdHQUe/fuxejoKGpqakTZfMhJbWFhQXaC2WSbXUVFBTweD8rKymAwGGTTqkgGlmVhs9lgtVpzNovLNScsV9CGh3LLk0o2Dl5UVASPx4OBgQEuRVvOCAaDmJiYQFlZGQYGBnKqptKtYqkzsgg5m5+fL6g3FB8SzSLJaDx9YKqsrOTIGcuy+N///V889NBDeOihh3D99dcX5LmXLh6CZVncc889+N3vfofy8nK88MILGBkZAQB86Utfwk9+8hNoNBpceumlOHz4sCzifLYgFMIjJ7AsC6vVimPHjuH48eM4efIkgsEgdu3ahbGxMYyNjUGn02V90iKuw8Qro1BuwpmC+KcsLS2htrYW4XAYwWCwoNM/6eD1emE0GlFVVSX6aHyynLBs2z80yL22uLgou00tGfx+Py5cuAC1Wo3y8nJ4PJ6MQkILBVojJ3ZmV6qMLLoVlu21CIVCmJiY4Aiw3J8VwFvDE+RanD59Gk888QSGhoY4Y9EXX3wxThSs4KKEQnjkjmAwiDfeeIOrAk1OTmL79u1cG2xkZARVVVW8p5ZwOMxpMtK5DssFZNKG+KeQBzY9/UMe8KlaHvkC0RY5nU5JR+NpJKuIZZoTRpyHk6Wwyw00OUvUkaTKhSqkDwzdDurv788LcUhWHaSvRWlpadJrQfy3BgYGOPH9VsVf/vIXPPLII2huboZGo+FiZsbGxnDvvfeitbW10EtUkH8ohGergWVZWCwWrgr0xhtvIBwOY/fu3VwrrKurC08++SRUKhVuvfVWNDU1yaZ9lQzBYBBmsxksy0Kv12fUvqJbHi6XC4FAIK/ZWCsrK5iampKFtiiTnDCVSsWRMyHOw/mE1+vFxMQEV53MhJzxxWTk674gbc2FhQVZVM5onyS32x13LQgRisVisoiyEAPRaBRPPPEEfv/73+O5556L87pZWVnByZMncdlll+Wk4RHilux0OnHbbbfh/PnzUKlUeP7553HZZZcJe7MKsoVCeN4O8Pv9OHnyJI4fP47f/OY3uHDhAnbs2IErr7wS73rXu7Bnz568iF9zQSwWg9Vqhd1uR39/v6CTJcuyCAQCcVUglmXjTrhijIIHg0GYTCYuwVqO/fTEnLD19XUEAgFUV1dj+/btBZ/+SYdYLIbZ2Vmsra1hcHBQUOWM775IbP+I8f0IBAKYmJgoqMg3Hehr4Xa7sba2hkAggJqaGmzbtk12bcFsMDMzgzvvvBNXXnklvvSlL4kqZBfilgwAN998M6644grcdtttCIfD8Pv9ok28KcgYCuF5u8But+MLX/gC3G43vvGNb0CtVsdVgRiGwaWXXspVgfr6+gr+UCMeNY2Njeju7pZkg6DN31wu16ZR8JqamoxP+3RrRSg5yxfoiTGdThenB5IyJ0wIXC4XjEYjtm3bFtfWFBNiisPp0W29Xp/XCaBcQbyLyCRhKBTividbLR4iFovhBz/4Ab773e/i6aefxuWXXy767zh+/DgOHjyI3//+9wCAr3/96wCABx98kPuZO+64A1dddRX+5V/+BQCg1+vxyiuvoKKiArt27cLMzIxsr+FFAiVa4u2C8+fP4xOf+ASuueYa7u96e3tx4403cvqXkydP4tixY/jiF7+ImZkZdHV1cVqg4eHhvJ34ibYoHA5Lav8PbDZ/I5UPl8uF1dVVTE9PIxaLxT3c+a6D2+2G0Wjk7PTleHqnQY9B0xNj5eXlSf1wLBaL4JwwIWAYBtPT03C73XjHO94hqeasqKiIe48ENBlcWFjIKCYjEAhgfHyci2OR+30BvKmTM5vN6O7u5kKBySGACHvptqDdbs95HFxqLC8v4zOf+Qy2bduGV199VbI2rRC3ZI1Gg6amJnzqU5/C2bNnsWfPHvznf/7nltBUXixQCM8Ww3vf+96k/4+MeF911VW46qqrALw1CXXs2DEcOXIE/+///T+wLIvh4WGuCtTT0yPqZkePxvf19RVEW6RSqaDVaqHVarmRZj4nYJKGXVlZibW1Nfj9fgwNDW0J3Yvf74fRaIRWq03rRi1WTphQEHfntrY2DAwMFOQkzGeayReTQSbjAoEAVlZWMDg4uCXaE9FolAutvfTSS1N+jnzxEPRBYWZmJm5Crrq6WrCLejZgWRZHjx7FI488gkceeQQf/vCHJb1nhLglR6NRnDp1Ck8//TT27t2L++67D4cOHcIjjzwi2XoVZAeF8LzNUVRUhP7+fvT39+Omm24Cy7Lwer1cFejBBx+ExWJBd3c3NxK/Z8+enCehSIWkrq4OY2NjsjoJ8zkBBwIBWK1WTExMoLi4GGq1GhaLJa+GgNkiFothfn4eS0tL0Ov1OW3CueSECbEIoN2d5RQLASSPySBidRIEPD09Lbu2YCI2NjZgMpnQ0dEBg8GQ9b3Ld1AgE3Jut5tzUS8qKpJ8ctLj8eDBBx/E2toa/vCHP3BxFVJCiFuySqVCe3s79u7dCwD42Mc+hkOHDkm+ZgWZQ9HwKEAsFsPU1BT++te/4rXXXsOpU6egUqkwPDyMvXv3Yu/evWk1FpFIhItRKJSzc7agzfgGBgZQUlKySfPh9XplpX9xuVwwmUycHkrKk3YqiwCy2WUiDicO2nRrRc5INh6f6JYdiUREzY8TAoZhMDU1Ba/Xi6GhIdHiQpKBb3KSVEvFSEp/7bXX8PnPfx533303/vVf/zVv11WIWzIAXHHFFTh8+DD0ej0OHjwIn8+Hxx9/PC9rV8BBES0ryBwsy8Lj8eD111/nfIHm5+fR19fHVYGGh4eh1WoRi8XwwgsvQKfTob+/f0tsaLFYDBaLBUtLSxmNFCdudLT+pba2Nifjt2wRjUYxPT0Nj8eDwcHBgukC0onDac1HOByG0WjkptzkWBFJhM/nw8TEBGpqatDb25uyokWqpbQ3UCE8o1wuFyYmJtDW1lYw24TE+BS32x1HCEkrLF2FMBwO49ChQzh27Biee+45DAwM5OkdvAUhbslnzpzhJrR6e3vxwgsvbAlx+9sMCuFRIAyxWAwmk4kjQKdPn0YoFEIoFEJfXx8eeeQRDA4Oyp7sOJ1OmEwmNDU15VwhoU3wSBWInvypra0VdXMnrZWOjg60tbXJ6hrTG53T6YTb7QbDMFCr1QgEAuju7kZHR4es1swHlmUxPz8Ph8MBg8GQc2gtX+VDKhEw0ec5nU4MDQ1JOhSQC2idWCIhJKRQq9Vy30Gj0Yi77roL11xzDR544IEt4f6sQJZQCI8C8eDxeHDw4EEcP34cn/zkJ7GysoLjx4/DZrNhYGCAqwKlE0zmE0RDEgwGYTAYRN8c+GIhhLY7QqEQTCYTAMjWBygRxKOGjDt7vV7Jc8KEwufzYXx8HLW1tWmrOtkiMROKBMcKnZDzeDwYHx/Htm3b0NXVJXtCSUAIodvthtPpxB133AGtVovm5mYYjUZ861vfSjmYoUBBBlAIjwLxQMy1br311rgHNcMwMBqNXBXozJkzKCkpwcjICKcFIuK+fIFlWTgcDszNzeU1TJVud5BYiEynoOhspv7+fm6aSM6gPWr42oSpcsIKpX8hbuZLS0uCqjrZgq9CmHhvJIuGiMVimJubw+rq6paZJkyFxcVF3H333aioqEBfXx9OnTqFtbU1GAwG3HLLLfjnf/7nQi9RwdaDQngUiAeWZTMiDSzLwul04rXXXuNIkMPhgE6nw+joKPbt24ddu3ZJdtr3+XwwGo1czlGh/UToKSiXy4VQKBSX/kxGoI1GIyorK0UPJ5WIKqgVAAAeYUlEQVQK2eheCITmhImx5vHxcdTV1aG3t7fg5pyZxGSQ3K58CNalBsuyeOmll/DYY4/hsccew/ve9z7usyYRGCqVCoODg1m/tpBoCODNg9vIyAja2trw61//WtgbVVAIKIRHgTzAMAzGx8c5d+hz585xPjJjY2PYt2+fYOEzwzCYm5vD2toa9Hp93k7u2YLe9J1OJ9bW1hCNRtHY2Ijm5mbU1tamDIEsNIj4e2VlRZTrnElOmFACSNa8vLyMwcFBVFdXC3o9qZAYk7GysoJwOIzGxkY0NDRwYnm53hup4HQ6sX//fkSjUXzrW98SNV1eaDQEADzxxBN444034Ha7FcKzNaEQHgXyBMuyWF9fj6sCLS8vQ6/Xc22wSy65JGMRMDG2a21tRUdHx5Y4BRMhdXNzM9ra2uLG4oPBIOeFU1tbm9GkSz5A/JakrDYky0yjs7Gy2fRJQClJj98K94bf7+f0Rd3d3XFVMZ/Ph+Li4k0p6XIFy7J49dVX8e///u/Yv38/brzxRtEJm5BoiNbWViwsLODmm2/GQw89hCeeeEIhPFsTSrSEAnlCpVKhoaEBH/zgB/HBD34QwJsn/QsXLuDYsWM4fPgwzp07x1n6k4iMRC3O+vo6FhcXEY1GsWvXLsl9SMQA8S4KBAJx0RuJzrfEC8dut3NhpmSTq62tzWv+EcMwcZNBUmpIVCoVysvLUV5ejtbWVu73J7plp/NJoitRQgNK8wVaEzU4OMhVz1LFZFitVk4bRYvl5UCQg8EgvvzlL+PcuXP41a9+ha6uLkl+j5BoiNbWVnz2s5/FY489Bo/HI8n6FBQWCuFRIDtoNBrs2rULu3btwp133gmWZbG2tobjx4/j2LFj+M53vsOla4+MjMBut+PIkSN46aWX0N/fX+jlZwRixtfV1ZXSEZfPBZhu/RiNxk2tn5qaGkk2OeLiu337doyMjBSkncLnlp0qJ0yj0WB+fh5NTU0YGRnZElUdMulWUVGRNrcrVUwGTZDpqlgmZpFi4u9//zvuuece3HDDDVzgsVQQEg3x61//Gs3NzdizZw9eeeUVqZaooIBQCI8MsL6+jhtuuAFzc3Po7u7GT3/6001mVVarFTfddBMcDgeKiopw++2347777gMAHDx4EN/97ne5h97XvvY1fOADH8j7+5AKKpUKjY2N+NCHPoQPfehDAN7c9F966SUcOHCAq3bcc889cVWgQmR4pUMwGITJZIJarcaePXty8uvRaDSor6/nJqHo1s/y8jKmpqa4LChSBRJigEeymQKBgCyrZ3w5YR6PBzMzM3C5XCguLub0UVLmhAkFmc6zWq05p7Eni8kgBJm4oRNXZHKPSGEKyTAMnnnmGbz00ks4fPgwdu3aJfrvSISQaIif//zn+NWvfoWjR49yVgI33ngjfvSjH0m+bgX5gaLhkQHuv/9+1NfX44EHHsChQ4ewsbGBRx99NO5n7HY77HY7hoeH4fF4sGfPHvzyl7/E0NAQDh48iMrKSuzfv79A7yD/+NrXvoajR4/imWeewe7du8GyLOcHdOzYMZw4cQIbGxsYGhriCNCOHTsKNqlFtygGBgZEFWryIZUjcm1tbcYCYGJ62NXVhdbWVtkRSD54PB5MTEygqakJXV1dKCoq4p2QEysnTAyEQiGMj4+jrKwMAwMDkk/nJXoDiR2TMT8/jzvvvBN79uzBV77ylbwRTKHREASvvPIK/uM//kPR8GxNKKJlOYMWzdntdlx11VWc4VwyXHvttbjnnnvw3ve+96IkPBcuXIDBYEi5SUUiEZw9e5YTQ1+4cAF1dXVcSvzY2BgaGhok38SJWFYKY7tMQadgkz9EAEy8cOhWRzgchtlsBsMwMBgMshbDEsRiMczOzmJtbS2tvihVThghQPlo/bAsi6WlJczOzkKn00lOhFOtI9E3qqioKK4KlEmVMBaL4cUXX8TTTz+Np556Cu9+97vz9A7egpBoCAKF8GxpKIRHzqitrYXT6eT+u66uDhsbG0l/fm5uDldeeSXOnz+P6upqHDx4EN/73vdQXV2NkZERfOMb31DyW3hANhe6CuR2u7Fjxw6uCjQ0NCTa6ZphGMzOzmJ9fR0Gg0F2I9C0ANjpdHKtDrVaDbfbjf7+fk4sLHeQqTG6qpMtsskJEwPhcJhzpdbr9QX3iUpEtjEZa2tr+OxnP4vy8nI8/fTTcTorBQryCIXwFBrvec974HA4Nv39V7/6Vdx8880ZEx6v14t/+Id/wEMPPYTrrrsOALC0tITGxkaoVCp88YtfhN1ux/PPPy/NG3mbIRwO48yZM5wv0MTEBBoaGjgCNDY2hrq6uqxP+ltxPD4YDOLChQtgWRYVFRXwer1gGIYTvMrR+4XkSW1sbGBwcFDUqbFkOWG0ALiysjKn60FE6319fZz2SO5IrBK63W7cf//9aGpqQkdHB15++WV8+ctfxic+8QlZ3SMKLjoohEfOyLSlFYlEcM011+B973sfPv/5z/O+1tzcHK655hqcP39e6mW/LcGyLOx2O0eATpw4Aa/Xi507d3IkaHBwMGlbKhKJwGw2IxwOw2AwyE7gyweWZWGz2bCwsLBJX0QEwGTTTxwDr62tLVhlwu12Y2JiIq95UvT1IF442eSERSIRmEwmxGIxGAyGLZEgnwobGxt48MEHMT09jdbWVszMzKCqqgpjY2P40Ic+hCuvvLLQS1Rw8UEhPHLGF77wBTQ0NHCi5fX1dTz22GNxP8OyLG6++WbU19fjqaeeivt/drudaz08+eSTOHHiBF588cW8rf/tjlAohNOnT3MkiJgEEi3Q6Ogoqqur8cILL+D/b+/Og6Ks/ziAvx9ZwRCCRIWFFRBRWERFQVgtf1LmMQziVKOW5+RVeGTlAdY4o0OeZZfaZCmGHdrUlKSiqeTJLiAqmim6KCshCOK6nMGy7PP7g3meIK6HXfZg+bxmmmbg+S7PgsPz4Xt83uXl5Zg1a5bZMruMVV1djVu3bsHJyQn+/v6C9hdxsx5cEdQ4DJObBTLljFbjWZ2goCD07t3bZF9LCKE5YaWlpVAqlRg4cCA8PDwses+d4cqVK3jrrbewYMECLF26lP+Zq9VqXLp0CSKRCBMmTDDotQ2Nh2jrNCvpNqjgsWaPHz/GjBkzkJ+fD29vb/z000/o06cPCgsLsWjRIqSkpODixYsYN24chg0bxv9i4Y6fz507F9nZ2WAYBr6+vtizZ0+H9l4YeyxeyHhbws2IpKWlQaFQ4MKFCygsLISvry9efvllPP/88wgICLCKhm+t0ev1yM/PR3FxMQICAozab9FSGCY368E99DtrJoPrPeTh4QFvb2+rLCr/mxNWXl6O2tpa2NnZwcfHB3379jVrs8jOVldXh48//hinTp3Cvn37DMq7aosx8RBtnWYl3QYVPKR1xh6LFzLeFnF9Rg4cOIAtW7agd+/eUCgUSE9Px+3btyEWixEeHo7w8HB+FsgaHnIVFRXIyckxacRCS7MeTk5OfAHk5OTUoa/LdXguKyuDVCq1+KyOUGq1Grdv34ZEIoGjoyPKy8tNlhNmDrm5uVi6dCmef/55rF+/3iRLcsbGQzTW+DQr6TYoWoK0Ljk5me8sOn/+fERGRjYrWMRiMf/LxNnZGVKpFA8ePEBQUJCg8bbo4sWLePToEdLS0vg+I88++yyAhr/y8/PzIZfLcfr0aWzduhU1NTUYMWIEvxl6yJAhZt3M3HgpKDAw0KQRCy11AOZmgfLz81FZWcl3TW5v74tGo0FOTg48PT0RGhpqFUVje+rr65Gbm4uqqiqMHDmS//fRODKkpWaRhuaEmZper0dSUhL27t2LXbt28f/OTcHYeAiOSqXC1atXERERYbJ7JV0LFTwExcXF/C8KsViMkpKSNq//7y+Sjo63FePHj8f48eNb/BzDMPDx8YGPjw//V+g///yDrKwsKBQKJCQkQKlUwsvLiy+AwsLC4OzsbJKHHBdQ6uHhYZFYCC7ewNnZGRKJBEDDLBA349E4B6pxX6C8vDyUl5dj+PDhfNaYteMKNC8vLwwZMqTF77XQnDCuIzI3C2SJTc7FxcVYsWIFPD09ceHCBZPmpwHGxUNwKisr8corr+DTTz+1unYQxHKo4Okm2joW3xH0i8RwTz31FMaNG4dx48YB+DfUUi6X48SJE/jggw+g0+kQEhLCb4j29/c3ahZIp9Ph7t27/Ekzayoa7O3t0bdvX/Tt2xfAv3tfNBoN7t27B7VaDQcHB/Tr149vhGeNkRAcvV6Pu3fvoqyszKACra2csCdPnkClUjXJCTNkabAjWJbFsWPHkJCQgE2bNmHq1KlmKZSNiYcAGvYYvfLKK5g9ezbfuoMQgPbwEBh/LN6QTtGkZVVVVcjKyuK7Q9+9excDBgzgj8SHhoYK7v3y+PFjKJVKDBgwAJ6enlazPNIWbimosrISUqkUPXv25GeBGkdCND4BZQ2bw7kj8qbeTK3X65tsiK6oqICdnV2TY/GdURRWVFQgPj4eT548wZ49e+Du7t4Jdy+MMfEQbZ1mJd0GbVomrTP2WLyQ8cQwXFwCdyT+8uXL0Ov1GDlyJD8L5Ofn1+Sv/EePHqG4uBg6nQ6BgYFWPSvSGJfG7uXlBYlE0mLR0DgSQqPRoKKiAgzDNHvgm6u4434+arXaYkfk28oJc3V17XBRqFAosGrVKixfvhwLFiywSNNMQ+Mh2jrNSroNKnhI64w9Ft/a+I4QerR9wYIFOHr0KPr379+kuaKtJ8ZzuGWfS5cu8bNAeXl58PHxQXh4OGpra/Hjjz8iMTHRInt1DFFfXw+lUomqqioEBQV1uFlj4wgE7gSUOYJBKysrcfPmTaPiLEyhvZyw1nKxtFotNm/ejIyMDOzbtw/+/v4WegeEGIUKHmLdhB5tP3/+PJycnDBv3rxmBU93C1Dl6PV6KBQKrFy5EjU1NXj66adRV1eH0NBQfhbI19fXah7IjXERHBKJBF5eXp1SoDU+AcXNAgFo94Hfkde/f/8+SkpKIJVKTXrarbO0lBOm1WqRkpKCMWPGQCwWY926dZg6dSri4uK6xBF5QlpBBQ+xbh3ZB9RSfEZ3LngOHz6MDRs2YOvWrZgyZQp/BDwzM5OfBbp//z4GDhzInwgbNWqURTcw63Q65Obmorq6GlKp1OQRHNwDn9sLxAVhcnuBhPbBqaqqws2bN/HMM880W0rsSliWhVqtxuHDh3Hs2DFcvXoVffr0wdixYyGTySCTyRAUFGQV+6MI6SAqeIh160hifGsFT3dNjOdCStuaadDr9VAqlfxeoCtXrqBHjx4IDQ3lN0R7e3ub5QHOzepYcjM1F4TJFUDl5eVgWbbJLJCjoyN/byzL4u+//0ZhYSGkUilcXFzMfs+drbCwELGxsZBKpdi2bRvs7Oxw7do1pKenIyMjA9OmTcP06dMNem1DoyGEjCWkHVTwEMvrrMT4lgoeSozvGJZlUV5e3mQWqKCgAIMGDeK7Q48cObJTZ150Oh2USiVqamoglUqtbjM11weHK4Kqq6vRq1cvODo64smTJ3B1dcXgwYO7/KwHy7L45Zdf8OGHH+LDDz/EpEmTOrXoNCYaQshYQtpBnZaJ5Z0+fbrVz7m7u/MhqEVFRejfv3+HXrvxsdnFixcjOjra4PvsDriTTRMnTuTb7uv1euTk5EAul+PQoUOIi4tDz549ERoaioiICMhkMoP32Tx+/Bh37tyBj48PAgMDrXIz9X/74LAsC5VKhYKCAri4uKCiogKXLl1qMgtkTd2QhdBoNFi1ahX0ej3OnDnDd37uTJmZmfD394efnx8A4NVXX0VycnKToiU5ORnz5s0DwzCQyWTQaDQoKiqCSqVqdywhhqKCh1iFmJgYJCUlIT4+HklJSZg2bVqHxjdOjP/1118RHBxsitu0aT169EBQUBCCgoKwaNEisCyLsrIyZGRkQC6X4/vvv0dhYSEGDx7Mb4YOCQlpc6ZGp9Phzp07qK2tbRKxYO1qampw69Yt9OrVC2PGjOH39+j1en4WqKVuyC4uLujZs6eF7745lmVx4cIFxMXFYfXq1ZgzZ47JCjVjoiGEjCXEUFTwEKsQHx+PGTNmYN++ffzRdgBNjsYDwGuvvYazZ8+itLQUEokEGzduxMKFC7F27dpmifHEOAzDwNXVFZMnT8bkyZMBNCxX3Lp1C3K5HN9++y1Wr14NBwcHhIWFQSaTISIiAmKxGAzD4JdffkFdXR3GjRvHf8zasSyLhw8fQqVSYciQIc1mQHr06MEXNpyamhqUlZVBrVYjLy8P9fX1TTKxhDaKNJWamhps3LgRN27cwJEjR+Dt7W3Sr2dMNISQsYQYigoeYhXc3NyQmpra7OOenp58sQMABw8ebHH8t99+2yn3YWw/IKHjuyo7OzsEBwcjODgYS5YsAcuy0Gg0SE9Ph1wux/79+1FYWAg7OzvY29sjPj4ebm5uXeKhpdVqcevWLYhEIoSFhQmeqenVqxd69erFL6tys0BlZWVQqVSorKyEvb19k1kgc2ViXb9+HcuXL8drr72Gjz/+2Cz7j4yJhtBqte2OJcRQtGmZkEaM7QckdLytSklJwbp16/Dqq6/C1dUV6enpuH79OhwdHTF69GiEh4dDJpPB3d3dqoqg4uJi3Lt3D/7+/nzzys7EZWJx/5k6E6u+vh6ff/45kpOTsXfvXgwfPrzTXrs9xkRDCBlLSDvolBYhQhjbD6g754odP34ce/fuxe7du+Hh4cF/nOv5kp6ejrS0NKSnp6O0tBQBAQH8kfjhw4dbJAm8rq4OOTk5ABp+dua6By4TizsRVllZCZFI1GQWyMHBwaDXvn//PmJjYxEeHo6EhASDX8cYhkZDtDaWkA6ggocQIYztB9SR8bZGr9eDYRhBMzc6nQ43btzg+wL9+eefcHZ25meBIiIi0L9/f5POAj169Ai5ubnw8/Mzazhma7RabZNZIK1W22QWyNnZuc1ZIL1ej4MHD2LXrl347LPPEBkZab6bJ8R60LF0Qjht9QMihuvIkoxIJEJISAhCQkKwdOlSsCyL0tJSKBQKyOVyfPnll1Cr1ZBKpfwyWHBwcKecgOJOjmm1WowaNcoiMyAtsbe3R79+/fglNS43TaPRoKCgoFkyuoODA3+EvrS0FG+//TacnZ1x7tw5/uOEkH9RwUO6HVP3AzJmfHfFMAz69euHmJgYxMTEAGgoTK5fvw65XI4vvvgCN27cgKura5NZIK7ZpFBqtRq3b9+Gj4+P1Z8cYxgGTk5OcHJygkQiAdA0GT0hIQHnzp2DWCxGXl4eli5dilWrVnWZo/+EmBstaRHSyJo1a+Dm5sZvOlar1di+fXuL17a0pNWR8aRjWJZFSUkJPwuUkZEBjUaDoUOH8gXQ0KFDW8zE4hLZq6urERQUZBNFQVVVFd5//30UFBTgxRdfRE5ODq5evQp7e3uMHTsW27dvt+qCjhAToT08hAjx+PFjzJgxA/n5+Xw/oD59+rTZD8jd3Z3vB9TaeGIadXV1uHbtGr8Z+q+//kKfPn34xojh4eG4evUqdu/ejZ07d0IikdhEEXD58mWsXLkSCxcuRGxsbJPlxPLycty4cQNjx441+usIbbPQWv7VmjVrcOTIEdjb22PQoEHYv38/LbcRU6OCh5CuxNgHzYYNG/D111/z+0E2b96MqKgos74HS+AaByoUCpw/fx4///wzRCIRZDIZxo4di4iICEilUkHJ6Naorq4OH330EVJTU7Fv3z5IpVKTfj0hbRbayr86efIkXnjhBYhEIsTFxQFAt2rTQCyi1YLH9NHIhJAO27p1KyZMmAClUokJEyZg69atza6pr6/HsmXLcPz4cdy8eRMHDx7EzZs3+c+/8847yM7ORnZ2drcodoCGfS9isRg+Pj5IS0vDmjVrkJOTg3fffRf19fXYsWMHnnvuOURHR2Pjxo04ceIE1Gp1ix1+rU1ubi6ioqLAMAzOnTtn8mIHaMi8mj9/PgBg/vz5OHz4cLNrGmdn2dvb8/lXADBp0iS+uJTJZCgoKDD5PRPSmq75Zw4hNi45ORlnz54F0PCgiYyMbPaXsZCQxu7q8OHD+O677xAQEAAAfAL8O++8A5ZlUVRUhLS0NFy8eBE7duxAdXU1hg0bxu8FCgwMtJpUdL1ej/379yMxMRG7d+/ulKUqoYqLi/mMOrFYjJKSkmbXCM2/SkxMxMyZM013s4S0gwoeQqxQZzxodu3ahQMHDiAsLAw7duywqYiL9iQkJLT6OYZh4OnpienTp2P69OkAGjohX7lyBXK5HNu3b0dOTg7c3d35Amj06NFwcXEx+/6fhw8fYsWKFRgwYAAuXLgAJyenTv8axrZpEJJ/tWnTJohEIsyePduwmySkE1DBQ4iFmPJBExsbi/Xr14NhGKxfvx6rVq1CYmKicTdswxwcHDBmzBiMGTMGQMP3tqCgAHK5HH/88Qe2bduGmpoaDB8+nJ8tCggIMNksEMuyOHr0KD744ANs3rwZ0dHRJiu2jG3T0F52VlJSEo4ePYrU1FSb2DBOui4qeAixEFM+aBp3Dl68eDGio6M78c5tH8MwGDBgAGbOnMkvw9TU1CArKwsKhQJbtmzBnTt34OnpyRdAYWFhePrpp41+qFdUVCAuLg4ajQapqakW7eUUExODpKQkxMfHIykpCdOmTWt2zejRo6FUKpGXlwcvLy8cOnQIP/zwA4CGTfXbtm3DuXPn4OjoaO7bJ6QJOqVFiBUS0s+nraBFrlgCgE8++QQZGRk4dOiQJd6KzWJZFvfv3+fjMbKyslBbW4uQkBC+CBoyZEiHOlDL5XKsXr0aK1aswOuvv96pgaKGENqmobX8K39/f9TW1sLNzQ1Aw8ZlLlOLEBOhY+mEdCXGPmjmzp2L7OxsMAwDX19f7Nmzhy+A2tPaUXcOy7JYuXIlUlJS4OjoiG+++QajRo0SNNbWVVdX87NA6enpUCqVkEgkfE+gsLAwODk5NZsF0mq12LRpEzIzM5GYmIhBgwZZ6B0Q0uVRwUMIaV9bPVU4KSkp2LlzJ1JSUpCRkYGVK1ciIyND0NjuRq/XQ6VS8bNAly9fhk6nQ0hICEaPHg2ZTIa6ujosW7YM06ZNw9q1a7tsjyBCrASFhxJC2ifkqHtycjLmzZsHhmEgk8mg0WhQVFQElUpFx+T/o0ePHvDz84Ofnx/mzJkDlmVRXV2NS5cuQaFQ4L333sPly5eRkpLCz5IRQkyDGg8SQngtHXV/8OCBoGuEjO3uGIZB7969ERkZiXXr1uHYsWMoKioyWbGjVqsxceJEDB48GBMnTsSTJ09avO7EiRMICAiAv79/i00uP/roIzAMg9LSUpPcJyHmQAUPIYQnpKdKa9cIGUuaM+X3qDM6dv/99984deoUvL29TXafhJgDFTyEEF57PVXaukbIWGJexkZDAA0RJZS8TmwBFTyEEF7jniparRaHDh1CTExMk2tiYmJw4MABsCyL9PR0uLi4QCwWCxpLzMvQjt3cUuRvv/0GLy8vjBgxwjw3TIgJ0aZlQghPJBJh165dmDx5Mn/UfejQoXzvlDfffBNRUVFISUmBv78/HB0dsX///jbHEtMyVcfu6upqbNq0CSdPnjT6HgmxBnQsnRBitYzpCeTr6wtnZ2fY2dlBJBIhKyvLEm/BogICAnD27Fm+Y3dkZCRu377d5BqFQoENGzbg999/BwBs2bIFABAdHY0JEybwHZK5JcrMzEx4eHiY940QIlyra6+0pEUIsUrtbaYFgOPHj0OpVEKpVOKrr75CbGxsk8+fOXMG2dnZ3bLYAf6NhgAgKBqi8VLksGHDUFJSApVKBZVKBYlEgitXrlCxQ7osKngIIVapvc20QOs9gUiD+Ph4nDp1CoMHD8apU6f4GbLCwkJERUUBaLoUKZVKMWPGDFqKJDaJ9vAQQqxSS5tpMzIy2r3mwYMHEIvFYBgGkyZNAsMweOONN7BkyRKz3bu1cHNzQ2pqarOPe3p68vEkABAVFcUXQK1RqVSdfXuEmBUVPIQQq2RMTyAASEtLg6enJ0pKSjBx4kQEBgbif//7n2lulhBi9WhJixBilYzpCQSA/3///v3x0ksvITMz0wx3TQixVlTwEEKskjE9gaqqqlBRUQEAqKqqwsmTJxEcHGyJt0EIsRK0pEUIsUrG9AQqLi7GSy+9BADQ6XSYNWsWpkyZYrH3QgixPOrDQwghhBBbQX14CCGEENJ9UcFDCCGEEJtHBQ8hhBBCbB4VPIQQQgixeVTwEEIIIcTmUcFDCCGEEJtHBQ8hhBBCbB4VPIQQQgixeVTwEEIIIcTmtRct0WrHQkIIIYSQroJmeAghhBBi86jgIYQQQojNo4KHEEIIITaPCh5CCCGE2DwqeAghhBBi86jgIYQQQojN+z+8uRqy9Dun8wAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 720x504 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.figure(figsize = (10, 7))\n",
    "ax = plt.axes(projection =\"3d\")\n",
    "\n",
    "# Creating plot\n",
    "ax.scatter3D(pos_mesh.vertices[:,0], pos_mesh.vertices[:,1], pos_mesh.vertices[:,2], color = \"green\")\n",
    "ax.scatter3D(plane_origin_[0], plane_origin_[1], plane_origin_[2] ,color='r')\n",
    "ax.scatter3D(v_1[0], v_1[1], v_1[2] )\n",
    "\n",
    "plt.title(\"simple 3D scatter plot\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "id": "980dcc63",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0, 2, 3)"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "polyline.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "id": "dfab6cc4",
   "metadata": {},
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "'numpy.ndarray' object has no attribute 'vertices'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-151-4fa5c4c93e96>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mp_\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mn\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0msplit_mesh\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mpos_mesh\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m<ipython-input-138-a3c4e2e08745>\u001b[0m in \u001b[0;36msplit_mesh\u001b[0;34m(mesh, plane_normal, plane_origin)\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;31m#             plane_normal_ /= np.linalg.norm(plane_normal_)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     14\u001b[0m \u001b[0;31m# #             plane_origin_ = np.random.randn(3)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 15\u001b[0;31m             \u001b[0mplane_origin_\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmean\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmesh\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvertices\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     16\u001b[0m             \u001b[0midx1\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mrandom\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrandint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mpos_mesh\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvertices\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     17\u001b[0m             \u001b[0midx2\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mrandom\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrandint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mpos_mesh\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvertices\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mAttributeError\u001b[0m: 'numpy.ndarray' object has no attribute 'vertices'"
     ]
    }
   ],
   "source": [
    "p_,n = split_mesh(pos_mesh)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "id": "54048987",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<trimesh.Trimesh(vertices.shape=(728, 3), faces.shape=(1500, 3))>"
      ]
     },
     "execution_count": 154,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mesh "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "id": "cfc29350",
   "metadata": {},
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "'numpy.ndarray' object has no attribute 'vertices'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-155-c2c794684972>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      8\u001b[0m \u001b[0;32mwhile\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mdone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      9\u001b[0m     \u001b[0mmesh\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpatches\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpop\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 10\u001b[0;31m     \u001b[0mp_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mn_\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0msplit_mesh\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmesh\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     11\u001b[0m     \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'split done'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     12\u001b[0m     \u001b[0mverts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfaces\u001b[0m  \u001b[0;34m=\u001b[0m \u001b[0mget_verts_faces\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mp_\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m<ipython-input-138-a3c4e2e08745>\u001b[0m in \u001b[0;36msplit_mesh\u001b[0;34m(mesh, plane_normal, plane_origin)\u001b[0m\n\u001b[1;32m     14\u001b[0m \u001b[0;31m# #             plane_origin_ = np.random.randn(3)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     15\u001b[0m             \u001b[0mplane_origin_\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmean\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmesh\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvertices\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 16\u001b[0;31m             \u001b[0midx1\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mrandom\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrandint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mpos_mesh\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvertices\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     17\u001b[0m             \u001b[0midx2\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mrandom\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrandint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mpos_mesh\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvertices\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     18\u001b[0m             \u001b[0mv1\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpos_mesh\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvertices\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0midx1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mAttributeError\u001b[0m: 'numpy.ndarray' object has no attribute 'vertices'"
     ]
    }
   ],
   "source": [
    "\n",
    "num_patches = 10\n",
    "   \n",
    "\n",
    "patches = [mesh]\n",
    "\n",
    "done = False\n",
    "counter = 2\n",
    "while not done:\n",
    "    mesh = patches.pop()\n",
    "    p_, n_ = split_mesh(mesh)\n",
    "    print('split done')\n",
    "    verts, faces  = get_verts_faces(p_)\n",
    "    p_ = trimesh.Trimesh(verts, faces)\n",
    "    verts, faces = get_verts_faces(n_)\n",
    "    n_ = trimesh.Trimesh(verts, faces)\n",
    "\n",
    "    patches.insert(0, p_)\n",
    "    patches.insert(0, n_)\n",
    "\n",
    "    counter+=2\n",
    "    print(counter)\n",
    "    if counter >= num_patches:\n",
    "        break\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "be7d9c49",
   "metadata": {},
   "outputs": [],
   "source": [
    "def linestrings_to_polygon(poly):\n",
    "    polygon = []\n",
    "    \n",
    "    for index, pieces in enumerate(poly):\n",
    "        polygon.append(pieces[0])\n",
    "        polygon.append(pieces[1])\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "id": "fecce0ca",
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "id": "b4ec915f",
   "metadata": {},
   "outputs": [],
   "source": [
    "import trimesh.intersections\n",
    "\n",
    "def slice_mesh_plane_bidirectional(mesh, plane_normal, plane_origin):\n",
    "    # Compute positive side of plane\n",
    "    dots_cache = np.dot(plane_normal, (mesh.vertices - plane_origin).T)[mesh.faces]\n",
    "    positive = trimesh.intersections.slice_mesh_plane(mesh,\n",
    "                                                     plane_normal=plane_normal,\n",
    "                                                     plane_origin=plane_origin,\n",
    "                                                     )\n",
    "    \n",
    "    # Compute negative side of plane\n",
    "    dots_cache *= -1\n",
    "    negative = trimesh.intersections.slice_mesh_plane(mesh,\n",
    "                                                     plane_normal=-plane_normal,\n",
    "                                                     plane_origin=plane_origin,\n",
    "                                                     )\n",
    "    \n",
    "    # Compute the cap\n",
    "    cap = trimesh.intersections.mesh_plane(mesh,\n",
    "                                       plane_normal=-plane_normal, \n",
    "                                       plane_origin=plane_origin, \n",
    "                                       return_faces=False, \n",
    "                                       )\n",
    "    print(cap.shape)\n",
    "    for piece in cap:\n",
    "        plt.plot(piece)\n",
    "    plt.show()\n",
    "    polygon = linestrings_to_polygon(cap)\n",
    "    # Triangulate the cap and add to both sides\n",
    "    cap_vertices, cap_faces = trimesh.creation.triangulate_polygon(polygon)\n",
    "    print(cap_vertices.shape, cap_faces.shape)\n",
    "    \n",
    "    # Append cap to positive mesh\n",
    "    positive_vertices, n_positive_vertices = positive.vertices, len(positive.vertices)\n",
    "    np.append(positive_vertices, cap_vertices, axis=0)\n",
    "    positive_faces = positive.faces\n",
    "    np.append(positive_faces, cap_faces+n_positive_vertices, axis=0)\n",
    "    # Construct negative mesh\n",
    "    positive_mesh = trimesh.base.Trimesh(vertices=positive_vertices, faces=positive_faces)\n",
    "    \n",
    "    # Append cap to negative mesh\n",
    "    negative_vertices, n_negative_vertices = negative.vertices, len(negative.vertices)\n",
    "    np.append(negative_vertices, cap_vertices, axis=0)\n",
    "    negative_faces = negative.faces\n",
    "    np.append(negative_faces, cap_faces+n_negative_vertices, axis=0)\n",
    "    # Construct negative mesh\n",
    "    negative_mesh = trimesh.base.Trimesh(vertices=negative_vertices, faces=negative_faces)\n",
    "\n",
    "    return [positive_mesh, negative_mesh]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "id": "f5eb92b7",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(141, 2, 3)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "ename": "NameError",
     "evalue": "name 'linestrings_to_polygon' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-124-e8bbd4488c5a>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mslice_mesh_plane_bidirectional\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmesh\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mpoint\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnormal\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m<ipython-input-123-f183a4d105f7>\u001b[0m in \u001b[0;36mslice_mesh_plane_bidirectional\u001b[0;34m(mesh, plane_normal, plane_origin)\u001b[0m\n\u001b[1;32m     26\u001b[0m         \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mplot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mpiece\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     27\u001b[0m     \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshow\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 28\u001b[0;31m     \u001b[0mpolygon\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mlinestrings_to_polygon\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcap\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     29\u001b[0m     \u001b[0;31m# Triangulate the cap and add to both sides\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     30\u001b[0m     \u001b[0mcap_vertices\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcap_faces\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrimesh\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcreation\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtriangulate_polygon\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mpolygon\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mNameError\u001b[0m: name 'linestrings_to_polygon' is not defined"
     ]
    }
   ],
   "source": [
    "slice_mesh_plane_bidirectional(mesh, point, normal)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "41feb73e",
   "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.6.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}