kaolin/examples/tutorial/interactive_visualizer.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "43840b4a-f9dc-4076-b1bf-5276da05f4ea",
   "metadata": {
    "tags": []
   },
   "source": [
    "# Interactive visualizer\n",
    "Using [Interactive visualizers](https://kaolin.readthedocs.io/en/latest/modules/kaolin.visualize.html) you can bring your own renderer and connect it to the visualizer with live mouse camera control right in the notebook, for example to debug your custom rendering function. The main condition is that the renderer has to take a [Camera](https://kaolin.readthedocs.io/en/latest/modules/kaolin.render.camera.camera.html#kaolin-render-camera-camera) as input.\n",
    "\n",
    "In this notebook, we show how to visualize differentiable rendering of a multi-material mesh from ShapeNet using spherical gaussians lighting. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "69114969",
   "metadata": {
    "scrolled": true,
    "tags": []
   },
   "outputs": [],
   "source": [
    "import copy\n",
    "import glob\n",
    "import math\n",
    "import logging\n",
    "import numpy as np\n",
    "import os\n",
    "import sys\n",
    "import torch\n",
    "\n",
    "from tutorial_common import COMMON_DATA_DIR\n",
    "import kaolin as kal\n",
    "\n",
    "import nvdiffrast\n",
    "glctx = nvdiffrast.torch.RasterizeGLContext(False, device='cuda')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dd8f9d9e",
   "metadata": {},
   "source": [
    "## Load Mesh information"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "4963d2ce",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SurfaceMesh object with batching strategy FIXED\n",
      "            vertices: [1, 5002, 3] (torch.float32)[cuda:0]  \n",
      "               faces: [10000, 3] (torch.int64)[cuda:0]  \n",
      "             normals: [1, 5002, 3] (torch.float32)[cuda:0]  \n",
      "    face_normals_idx: [1, 10000, 3] (torch.int64)[cuda:0]  \n",
      "                 uvs: [1, 5505, 2] (torch.float32)[cuda:0]  \n",
      "        face_uvs_idx: [1, 10000, 3] (torch.int64)[cuda:0]  \n",
      "material_assignments: [1, 10000] (torch.int16)[cuda:0]  \n",
      "           materials: [\n",
      "                      0: list of length 1\n",
      "                      ]\n",
      "       face_vertices: if possible, computed on access from: (faces, vertices)\n",
      "        face_normals: if possible, computed on access from: (normals, face_normals_idx) or (vertices, faces)\n",
      "            face_uvs: if possible, computed on access from: (uvs, face_uvs_idx)\n",
      "      vertex_normals: if possible, computed on access from: (faces, face_normals)\n",
      "     vertex_tangents: if possible, computed on access from: (faces, vertices, face_uvs)\n"
     ]
    }
   ],
   "source": [
    "# Set KAOLIN_TEST_SHAPENETV2_PATH env variable, or replace by your shapenet path\n",
    "SHAPENETV2_PATH = os.getenv('KAOLIN_TEST_SHAPENETV2_PATH')\n",
    "\n",
    "if SHAPENETV2_PATH is not None:\n",
    "    ds = kal.io.shapenet.ShapeNetV2(root=SHAPENETV2_PATH,\n",
    "                                    categories=['car'],\n",
    "                                    train=True, split=1.,\n",
    "                                    with_materials=True,\n",
    "                                    output_dict=True)\n",
    "    mesh = ds[0]['mesh']\n",
    "else:\n",
    "    # Load a specific obj instead\n",
    "    OBJ_PATH = os.path.join(COMMON_DATA_DIR, 'meshes', 'fox.obj')\n",
    "    mesh = kal.io.obj.import_mesh(OBJ_PATH, with_materials=True, with_normals=True, triangulate=True)\n",
    "\n",
    "def process_mesh(mesh):\n",
    "    # Batch, move to GPU and center and normalize vertices in the range [-0.5, 0.5]\n",
    "    mesh = mesh.to_batched().cuda()\n",
    "    mesh.vertices = kal.ops.pointcloud.center_points(mesh.vertices, normalize=True)\n",
    "    print(mesh)\n",
    "\n",
    "    diffuse_maps = [m['map_Kd'].unsqueeze(0).cuda().float() / 255. if 'map_Kd' in m else\n",
    "                    m['Kd'].reshape(1, 1, 1, 3).cuda()\n",
    "                    for m in mesh.materials[0]]\n",
    "    specular_maps = [m['map_Ks'].unsqueeze(0).cuda().float() / 255. if 'map_Ks' in m else\n",
    "                     m['Ks'].reshape(1, 1, 1, 3).cuda()\n",
    "                     for m in mesh.materials[0]]\n",
    "\n",
    "    # Use a single diffuse color as backup when map doesn't exist (and face_uvs_idx == -1)\n",
    "    mesh.uvs = torch.nn.functional.pad(mesh.uvs, (0, 0, 0, 1))\n",
    "    mesh.face_uvs_idx[mesh.face_uvs_idx == -1] = mesh.uvs.shape[1] - 1\n",
    "    return mesh, diffuse_maps, specular_maps\n",
    "\n",
    "mesh, diffuse_maps, specular_maps = process_mesh(mesh)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "03e898f4",
   "metadata": {},
   "source": [
    "## Instantiate a camera\n",
    "\n",
    "With the general constructor `Camera.from_args()` the underlying constructors are `CameraExtrinsics.from_lookat()` and `PinholeIntrinsics.from_fov` we will use this camera as a starting point for the visualizers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "c6eee7ab",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "camera = kal.render.camera.Camera.from_args(eye=torch.tensor([2., 1., 1.], device='cuda'),\n",
    "                                            at=torch.tensor([0., 0., 0.]),\n",
    "                                            up=torch.tensor([1., 1., 1.]),\n",
    "                                            fov=math.pi * 45 / 180,\n",
    "                                            width=512, height=512, device='cuda')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4fff8eb1",
   "metadata": {},
   "source": [
    "## Rendering a mesh\n",
    "\n",
    "Here we are rendering the loaded mesh with [nvdiffrast](https://github.com/NVlabs/nvdiffrast) using the camera object created above and use both diffuse and specular reflectance for lighting.\n",
    "\n",
    "For more information on lighting in Kaolin see [diffuse](./diffuse_lighting.ipynb) and [specular](./sg_specular_lighting.ipynb) tutorials and the [documentation](https://kaolin.readthedocs.io/en/latest/modules/kaolin.render.lighting.html)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "5e4b8a49",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Those are the parameters used to define the Spherical gaussian\n",
    "azimuth = torch.zeros((1,), device='cuda')\n",
    "elevation = torch.full((1,), math.pi / 3., device='cuda')\n",
    "amplitude = torch.full((1, 3), 3., device='cuda')\n",
    "sharpness = torch.full((1,), 5., device='cuda')\n",
    "# We will use this variable to enable / disable specular reflectance\n",
    "global apply_specular\n",
    "apply_specular = True\n",
    "\n",
    "def generate_pinhole_rays_dir(camera, height, width, device='cuda'):\n",
    "    \"\"\"Generate centered grid.\n",
    "    \n",
    "    This is a utility function for specular reflectance with spherical gaussian.\n",
    "    \"\"\"\n",
    "    pixel_y, pixel_x = torch.meshgrid(\n",
    "        torch.arange(height, device=device),\n",
    "        torch.arange(width, device=device),\n",
    "        indexing='ij'\n",
    "    )\n",
    "    pixel_x = pixel_x + 0.5  # scale and add bias to pixel center\n",
    "    pixel_y = pixel_y + 0.5  # scale and add bias to pixel center\n",
    "\n",
    "    # Account for principal point (offsets from the center)\n",
    "    pixel_x = pixel_x - camera.x0\n",
    "    pixel_y = pixel_y + camera.y0\n",
    "\n",
    "    # pixel values are now in range [-1, 1], both tensors are of shape res_y x res_x\n",
    "    # Convert to NDC\n",
    "    pixel_x = 2 * (pixel_x / width) - 1.0\n",
    "    pixel_y = 2 * (pixel_y / height) - 1.0\n",
    "\n",
    "    ray_dir = torch.stack((pixel_x * camera.tan_half_fov(kal.render.camera.intrinsics.CameraFOV.HORIZONTAL),\n",
    "                           -pixel_y * camera.tan_half_fov(kal.render.camera.intrinsics.CameraFOV.VERTICAL),\n",
    "                           -torch.ones_like(pixel_x)), dim=-1)\n",
    "\n",
    "    ray_dir = ray_dir.reshape(-1, 3)    # Flatten grid rays to 1D array\n",
    "    ray_orig = torch.zeros_like(ray_dir)\n",
    "\n",
    "    # Transform from camera to world coordinates\n",
    "    ray_orig, ray_dir = camera.extrinsics.inv_transform_rays(ray_orig, ray_dir)\n",
    "    ray_dir /= torch.linalg.norm(ray_dir, dim=-1, keepdim=True)\n",
    "\n",
    "    return ray_dir[0].reshape(1, height, width, 3)\n",
    "\n",
    "\n",
    "def base_render(mesh, diffuse_maps, specular_maps, camera, height, width, clear=False):\n",
    "    \"\"\"Base function for rendering using separate height and width, assuming batch_size=1\"\"\"\n",
    "    vertices_camera = camera.extrinsics.transform(mesh.vertices)\n",
    "    face_vertices_camera = kal.ops.mesh.index_vertices_by_faces(\n",
    "        vertices_camera, mesh.faces)\n",
    "    face_normals_z = kal.ops.mesh.face_normals(\n",
    "        face_vertices_camera,\n",
    "        unit=True\n",
    "    )[..., -1:].contiguous()\n",
    "\n",
    "    # Projection: nvdiffrast take clip coordinates as input to apply barycentric perspective correction.\n",
    "    # Using `camera.intrinsics.transform(vertices_camera) would return the normalized device coordinates.\n",
    "    proj = camera.projection_matrix()[None]\n",
    "    homogeneous_vecs = kal.render.camera.up_to_homogeneous(\n",
    "        vertices_camera\n",
    "    )[..., None]\n",
    "    vertices_clip = (proj @ homogeneous_vecs).squeeze(-1)\n",
    "\n",
    "    rast = nvdiffrast.torch.rasterize(\n",
    "        glctx, vertices_clip, mesh.faces.int(),\n",
    "        (height, width), grad_db=False\n",
    "    )\n",
    "    # nvdiffrast rasteriztion output is y-up, we need to flip as our display is y-down\n",
    "    rast0 = torch.flip(rast[0], dims=(1,))\n",
    "    hard_mask = rast0[:, :, :, -1:] != 0\n",
    "    face_idx = (rast0[..., -1].long() - 1).contiguous()\n",
    "\n",
    "    uv_map = nvdiffrast.torch.interpolate(\n",
    "        mesh.uvs, rast0, mesh.face_uvs_idx[0, ...].int()\n",
    "    )[0] % 1.\n",
    "    \n",
    "    if mesh.has_attribute('normals') and mesh.has_attribute('face_normals_idx'):\n",
    "        im_world_normals = nvdiffrast.torch.interpolate(\n",
    "            mesh.normals, rast0, mesh.face_normals_idx[0, ...].int())[0]\n",
    "    else:\n",
    "        im_world_normals = nvdiffrast.torch.interpolate(\n",
    "            mesh.face_normals.reshape(len(mesh), -1, 3), rast0,\n",
    "            torch.arange(mesh.faces.shape[0] * 3, device='cuda', dtype=torch.int).reshape(-1, 3)\n",
    "        )[0]\n",
    "    \n",
    "    batch_idx = torch.arange(len(mesh), device='cuda', dtype=torch.long).reshape(\n",
    "        len(mesh), 1, 1).expand(len(mesh), height, width)\n",
    "    \n",
    "    im_cam_normals = face_normals_z[batch_idx, face_idx] * (face_idx.unsqueeze(-1) != -1)\n",
    "    im_world_normals = im_world_normals * torch.sign(im_cam_normals)\n",
    "    albedo = torch.zeros(\n",
    "        (1, height, width, 3),\n",
    "        dtype=torch.float, device='cuda'\n",
    "    )\n",
    "    spec_albedo = torch.zeros(\n",
    "        (1, height, width, 3),\n",
    "        dtype=torch.float, device='cuda'\n",
    "    )\n",
    "    # Obj meshes can be composed of multiple materials\n",
    "    # so at rendering we need to interpolate from corresponding materials\n",
    "    im_material_idx = mesh.material_assignments[0, ...][face_idx]\n",
    "    im_material_idx[face_idx == -1] = -1\n",
    "\n",
    "    for i, material in enumerate(diffuse_maps):\n",
    "        mask = im_material_idx == i\n",
    "        mask_idx = torch.nonzero(mask, as_tuple=False)\n",
    "        _texcoords = uv_map[mask]\n",
    "        _texcoords[:, 1] = -_texcoords[:, 1]\n",
    "        if _texcoords.shape[0] > 0:\n",
    "            pixel_val = nvdiffrast.torch.texture(\n",
    "                diffuse_maps[i].contiguous(),\n",
    "                _texcoords.reshape(1, 1, -1, 2).contiguous(),\n",
    "                filter_mode='linear'\n",
    "            )\n",
    "            albedo[mask] = pixel_val[0, 0]\n",
    "            pixel_val = nvdiffrast.torch.texture(\n",
    "                specular_maps[i].contiguous(),\n",
    "                _texcoords.reshape(1, 1, -1, 2).contiguous(),\n",
    "                filter_mode='linear'\n",
    "            )\n",
    "            spec_albedo[mask] = pixel_val[0, 0] #.permute(1, 0)\n",
    "    img = torch.zeros((1, height, width, 3),\n",
    "                      dtype=torch.float, device='cuda')\n",
    "    sg_x, sg_y, sg_z = kal.ops.coords.spherical2cartesian(azimuth, elevation)\n",
    "    directions = torch.stack(\n",
    "        [sg_x, sg_z, sg_y],\n",
    "        dim=-1\n",
    "    )\n",
    "    im_world_normals = im_world_normals[hard_mask.squeeze(-1)]\n",
    "    diffuse_effect = kal.render.lighting.sg_diffuse_inner_product(\n",
    "        amplitude, directions, sharpness,\n",
    "        im_world_normals,\n",
    "        albedo[hard_mask.squeeze(-1)]\n",
    "    )\n",
    "    img[hard_mask.squeeze(-1)] = diffuse_effect\n",
    "    global apply_specular\n",
    "    if apply_specular:\n",
    "        rays_d = generate_pinhole_rays_dir(camera, height, width)\n",
    "        specular_effect = kal.render.lighting.sg_warp_specular_term(\n",
    "            amplitude, directions, sharpness,\n",
    "            im_world_normals,\n",
    "            torch.full((im_world_normals.shape[0],), 0.5, device='cuda'),\n",
    "            -rays_d[hard_mask.squeeze(-1)],\n",
    "            spec_albedo[hard_mask.squeeze(-1)]\n",
    "        )\n",
    "        img[hard_mask.squeeze(-1)] += specular_effect\n",
    "\n",
    "    if clear:\n",
    "        img = torch.cat([img, hard_mask], dim=-1)  # Add Alpha channel\n",
    "    final = (torch.clamp(img * hard_mask, 0., 1.)[0] * 255.).to(torch.uint8)\n",
    "    \n",
    "    # 'img' is the displayed image, while the other value `face_idx` is only printed on query\n",
    "    return {\n",
    "        'img': final,\n",
    "        'face_idx': face_idx[0]\n",
    "    }\n",
    "\n",
    "def render(camera):\n",
    "    \"\"\"Render using camera dimension.\n",
    "    \n",
    "    This is the main function provided to the interactive visualizer\n",
    "    \"\"\"\n",
    "    return base_render(mesh, diffuse_maps, specular_maps, camera, camera.height, camera.width)\n",
    "\n",
    "def lowres_render(camera):\n",
    "    \"\"\"Render with lower dimension.\n",
    "    \n",
    "    This function will be used as a \"fast\" rendering used when the mouse is moving to avoid slow down.\n",
    "    \"\"\"\n",
    "    return base_render(mesh, diffuse_maps, specular_maps, camera, int(camera.height / 4), int(camera.width / 4))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "383f1ffa-936c-416f-8779-d20fe28e7230",
   "metadata": {},
   "source": [
    "## Turntable visualizer\n",
    "This is a simple visualizer useful to inspect a small object.\n",
    "\n",
    "You can move around with the mouse (left button) and zoom with the mouse wheel.\n",
    "See the [documentation](https://kaolin.readthedocs.io/en/latest/modules/kaolin.visualize.html#kaolin.visualize.IpyTurntableVisualizer) to customize the sensitivity."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "f10f6ab7-662c-4cf6-8af4-5f28ae79d795",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "944583172c5b471d9898fa8c0ff37840",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Canvas(height=512, width=512)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "ae8a29f78a334533b4c81ccd3e716cf5",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Output()"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "visualizer = kal.visualize.IpyTurntableVisualizer(\n",
    "    512, 512, copy.deepcopy(camera), render,\n",
    "    fast_render=lowres_render, max_fps=24, world_up_axis=1)\n",
    "visualizer.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d8ff3945-66a4-47af-a3c0-4428c2adf6cf",
   "metadata": {},
   "source": [
    "## First person visualizer\n",
    "This is a visualizer useful to inspect details on an object, or a big scene.\n",
    "\n",
    "You can move the orientation of the camera with the mouse left button, move the camera around with the mouse right button or\n",
    "the keys 'i' (up), 'k' (down), 'j' (left), 'l' (right), 'o' (forward), 'u' (backward)\n",
    "\n",
    "See the [documentation](https://kaolin.readthedocs.io/en/latest/modules/kaolin.visualize.html#kaolin.visualize.IpyFirstPersonVisualizer) to customize the sensitivity and keys.\n",
    "\n",
    "--------------------\n",
    "*Note: camera are mutable in the visualizer. If you want to keep track of the camera position you can remove the `copy.deepcopy` on camera argument or you can check `visualizer.camera`*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "03b01bb2-bd76-4e7a-8599-855544febb53",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "8e0d056954494663ad27d16030c5ca2b",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Canvas(height=512, width=512)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "87f7e8eb9f1d4e1f8f763fb26649196f",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Output()"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "visualizer = kal.visualize.IpyFirstPersonVisualizer(\n",
    "    512, 512, copy.deepcopy(camera), render, fast_render=lowres_render,\n",
    "    max_fps=24, world_up=torch.tensor([0., 1., 0.], device='cuda'))\n",
    "visualizer.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0c6a9142",
   "metadata": {},
   "source": [
    "## Adding events and other widgets\n",
    "\n",
    "The visualizer is modular.\n",
    "Here we will add:\n",
    "* sliders to control the spherical gaussian parameters (see [ipywidgets tutorial](https://ipywidgets.readthedocs.io/en/stable/examples/Using%20Interact.html) for more info).\n",
    "* A key event to 'space' to enable / disable specular reflectance (see [ipyevents documentation](https://github.com/mwcraig/ipyevents/blob/main/docs/events.ipynb)) to see all the events that can be caught.\n",
    "\n",
    "In general if you want to modify the rendering function you can use global variables or make a class (with the rendering function being a method)\n",
    "\n",
    "-------------\n",
    "More info on spherical gaussians parameters in our [sg_specular_lighting.ipynb](./sg_specular_lighting.ipynb) tutorial\n",
    "and [documentation](https://kaolin.readthedocs.io/en/latest/modules/kaolin.render.lighting.html)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "0a9fd84e",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "62ae43bc91274e14a843fd377d5c061f",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(Canvas(height=512, width=512), interactive(children=(FloatSlider(value=1.0471975803375244, desc…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "fc0ada76a2bf4380880d81c5a302b90b",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Output()"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from ipywidgets import interactive, HBox, FloatSlider\n",
    "\n",
    "def additional_event_handler(visualizer, event):\n",
    "    \"\"\"Event handler to be provided to Kaolin's visualizer\"\"\"\n",
    "    with visualizer.out: # This is for catching print and errors\n",
    "        if event['type'] == 'keydown' and event['key'] == ' ':\n",
    "            global apply_specular\n",
    "            apply_specular = not apply_specular\n",
    "            visualizer.render_update()\n",
    "            return False\n",
    "        return True\n",
    "\n",
    "visualizer = kal.visualize.IpyTurntableVisualizer(\n",
    "    512, 512, copy.deepcopy(camera), render,\n",
    "    fast_render=lowres_render, max_fps=24,\n",
    "    additional_event_handler=additional_event_handler,\n",
    "    additional_watched_events=['keydown'] # We need to now watch for key press event\n",
    ")\n",
    "# we don't call visualizer.show() here\n",
    "\n",
    "def sliders_callback(new_elevation, new_azimuth, new_amplitude, new_sharpness):\n",
    "    \"\"\"ipywidgets sliders callback\"\"\"\n",
    "    with visualizer.out: # This is in case of bug\n",
    "        elevation[:] = new_elevation\n",
    "        azimuth[:] = new_azimuth\n",
    "        amplitude[:] = new_amplitude\n",
    "        sharpness[:] = new_sharpness\n",
    "        # this is how we request a new update\n",
    "        visualizer.render_update()\n",
    "        \n",
    "elevation_slider = FloatSlider(\n",
    "    value=elevation.item(),\n",
    "    min=-math.pi / 2.,\n",
    "    max=math.pi / 2.,\n",
    "    step=0.1,\n",
    "    description='Elevation:',\n",
    "    continuous_update=True,\n",
    "    readout=True,\n",
    "    readout_format='.1f',\n",
    ")\n",
    "\n",
    "azimuth_slider = FloatSlider(\n",
    "    value=azimuth.item(),\n",
    "    min=-math.pi,\n",
    "    max=math.pi,\n",
    "    step=0.1,\n",
    "    description='Azimuth:',\n",
    "    continuous_update=True,\n",
    "    readout=True,\n",
    "    readout_format='.1f',\n",
    ")\n",
    "\n",
    "amplitude_slider = FloatSlider(\n",
    "    value=amplitude[0,0].item(),\n",
    "    min=0.1,\n",
    "    max=20.,\n",
    "    step=0.1,\n",
    "    description='Amplitude:\\n',\n",
    "    continuous_update=True,\n",
    "    readout=True,\n",
    "    readout_format='.1f',\n",
    ")\n",
    "\n",
    "sharpness_slider = FloatSlider(\n",
    "    value=sharpness.item(),\n",
    "    min=0.1,\n",
    "    max=20.,\n",
    "    step=0.1,\n",
    "    description='Sharpness:\\n',\n",
    "    continuous_update=True,\n",
    "    readout=True,\n",
    "    readout_format='.1f',\n",
    ")\n",
    "\n",
    "interactive_slider = interactive(\n",
    "    sliders_callback,\n",
    "    new_elevation=elevation_slider,\n",
    "    new_azimuth=azimuth_slider,\n",
    "    new_amplitude=amplitude_slider,\n",
    "    new_sharpness=sharpness_slider\n",
    ")\n",
    "\n",
    "# We combine all the widgets and the visualizer canvas and output in a single display\n",
    "full_output = HBox([visualizer.canvas, interactive_slider])\n",
    "display(full_output, visualizer.out)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c6a6c886-2a4a-40d1-acaf-3bf45a4bc346",
   "metadata": {},
   "source": [
    "## Customizing Drawing and Event Canvases\n",
    "\n",
    "In some cases, it may be desirable to receive events on a different canvas from the one used for drawing, or you may want to create the drawing canvas manually. \n",
    "\n",
    "You can mix and match any number of drawing canvasses and event canvasses by passing `canvas` and `event_canvas` variables to the visualizer constructor. \n",
    "\n",
    "In this example, we show:\n",
    "\n",
    "1. How to use Kaolin visualizers with MultiCanvas, where you may draw something else on one of the stacked sub-canvasses (in this case, background color)\n",
    "2. How to control visualizer using events from another canvas (in this case, mouse motion in the first canvas controls both cameras)\n",
    "\n",
    "There are many ways you may want to build debug interfaces around your rendering function, and our visualizers allow for flexibility."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "606c21ce-7dba-4dca-99c7-93dfc6907342",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SurfaceMesh object with batching strategy FIXED\n",
      "            vertices: [1, 482, 3] (torch.float32)[cuda:0]  \n",
      "               faces: [960, 3] (torch.int64)[cuda:0]  \n",
      "             normals: [1, 482, 3] (torch.float32)[cuda:0]  \n",
      "    face_normals_idx: [1, 960, 3] (torch.int64)[cuda:0]  \n",
      "                 uvs: [1, 514, 2] (torch.float32)[cuda:0]  \n",
      "        face_uvs_idx: [1, 960, 3] (torch.int64)[cuda:0]  \n",
      "material_assignments: [1, 960] (torch.int16)[cuda:0]  \n",
      "           materials: [\n",
      "                      0: list of length 2\n",
      "                      ]\n",
      "       face_vertices: if possible, computed on access from: (faces, vertices)\n",
      "        face_normals: if possible, computed on access from: (normals, face_normals_idx) or (vertices, faces)\n",
      "            face_uvs: if possible, computed on access from: (uvs, face_uvs_idx)\n",
      "      vertex_normals: if possible, computed on access from: (faces, face_normals)\n",
      "     vertex_tangents: if possible, computed on access from: (faces, vertices, face_uvs)\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "33f50439d62940ee9307d0f02717a895",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(HBox(children=(MultiCanvas(height=512, layout=Layout(height='500px', width='500px'), width=512)…"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from ipycanvas import MultiCanvas, Canvas, hold_canvas\n",
    "from ipywidgets import Layout, VBox, Dropdown\n",
    "from functools import partial\n",
    "\n",
    "# Create two multi-layer canvasses, containing 2 aligned images each with opacity enabled\n",
    "# (e.g. useful for various overlays)\n",
    "# multi_canvas[0] - background canvas\n",
    "# multi_canvas[1] - foreground canvas\n",
    "cwidth = 512\n",
    "multi_canvas = MultiCanvas(2, width=cwidth, height=cwidth, layout=Layout(width=\"500px\", height=\"500px\"))\n",
    "multi_canvas2 = MultiCanvas(2, width=cwidth, height=cwidth, layout=Layout(width=\"500px\", height=\"500px\"))\n",
    "colors = [\"red\", \"blue\", \"green\", \"purple\", \"#cc3333\"]\n",
    "\n",
    "# Function to set background canvas of both canvasses\n",
    "def set_background(val): \n",
    "    with hold_canvas():\n",
    "        multi_canvas[0].fill_style = val\n",
    "        multi_canvas[0].fill_rect(0, 0, cwidth, cwidth)\n",
    "        multi_canvas2[0].fill_style = val\n",
    "        multi_canvas2[0].fill_rect(0, 0, cwidth, cwidth)\n",
    "        \n",
    "# Actually set background and clear front canvasses\n",
    "set_background(colors[0])\n",
    "with hold_canvas():\n",
    "    multi_canvas[1].clear_rect(0, 0, cwidth, cwidth)\n",
    "    multi_canvas2[1].clear_rect(0, 0, cwidth, cwidth)\n",
    "    \n",
    "# Create background color picker\n",
    "def handle_dropdown(change):\n",
    "    global background_color\n",
    "    with visualizer.out:\n",
    "        set_background(change['new'])\n",
    "color_dropdown = Dropdown(options=colors, value='red', description='Background:')\n",
    "color_dropdown.observe(handle_dropdown, names='value')\n",
    "\n",
    "\n",
    "# Read in an additional mesh\n",
    "mesh2 = kal.io.obj.import_mesh(os.path.join(COMMON_DATA_DIR, 'meshes', 'pizza.obj'), with_materials=True, with_normals=True, triangulate=True)\n",
    "mesh2, diffuse_maps2, specular_maps2 = process_mesh(mesh2)\n",
    "    \n",
    "# Create render closures that only requires a camera to render; ensure we render with Alpha channel\n",
    "render1 = partial(base_render, mesh, diffuse_maps, specular_maps, width=cwidth, height=cwidth,  clear=True)\n",
    "lowres_render1 = partial(base_render, mesh, diffuse_maps, specular_maps, width=cwidth//4, height=cwidth//4, clear=True)\n",
    "render2 = partial(base_render, mesh2, diffuse_maps2, specular_maps2, width=cwidth, height=cwidth,  clear=True)\n",
    "lowres_render2 = partial(base_render, mesh2, diffuse_maps2, specular_maps2, width=cwidth//4, height=cwidth//4, clear=True)\n",
    "\n",
    "# Create first visualizer\n",
    "visualizer = kal.visualize.IpyTurntableVisualizer(\n",
    "    512, 512, copy.deepcopy(camera), render1,\n",
    "    fast_render=lowres_render1, max_fps=24, world_up_axis=1,\n",
    "    canvas=multi_canvas[1], event_canvas=multi_canvas)\n",
    "\n",
    "# Create second visualizer, still controlled by mouse within the first canvas\n",
    "visualizer2 = kal.visualize.IpyTurntableVisualizer(\n",
    "    512, 512, copy.deepcopy(camera), render2,\n",
    "    fast_render=lowres_render2, max_fps=24, world_up_axis=1,\n",
    "    canvas=multi_canvas2[1], event_canvas=multi_canvas)\n",
    "\n",
    "# Show all the canvasses and outputs\n",
    "visualizer.render_update()\n",
    "visualizer2.render_update()\n",
    "VBox((HBox((multi_canvas,multi_canvas2)), color_dropdown, HBox((visualizer.out, visualizer2.out))))"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.16"
  },
  "widgets": {
   "application/vnd.jupyter.widget-state+json": {
    "state": {
     "028ab2f05e1e4e5281586fb97f4df6b2": {
      "buffers": [
       {
        "data": "iVBORw0KGgoAAAANSUhEUgAAAgAAAAIACAYAAAD0eNT6AABwRElEQVR4nOz9eZhvW37X973XsPf+DTWd6Z479KTuRlNL6lZrQgLNMgYHCAnYDyTBJI/NpAjkKOBgY+wYjJPHCYmDMQFsHh47j+ckhAgEtkFiEIOxAtaApm71pO6+4xmr6vfbe68pf6y1q+pe3Vaf232H7ns/r36qq05N93eq6tT6ru/6fr8LRERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERN7Ujm+/p7zRj0FERF7MvtEPQN78QtjxxMlxuX2wUiAgIvIFQgGAvOZONp7f9lt/G4fHR9x+YqsgQETkC4ACAHnNnfQd3/1NX8u3fMe3crDevNEPR0REAP9GPwB583vHu97Lylu+6j3v4eF0j5z+cfnox++ZN/pxiYi8lSkAkNfcraee4OjG2/n2xx7jmfgCZprZzT9enn36VEGAiMgbREcA8pr7VnuXr/91/zTz4ZYPfu03cvCuL+Xd7/lSrl3bqB5ARETkzeo3f9mtUtJPlFJ+rpTyj0r5W3+i/JM/9D8tf+Lb3qEAQETkDaIMgLzmfuYs8xf+jf8EcLCLsL3Nkzev87XveYo/8bVPKggQEXkDKACQ19xPf+qO+fmf+Emgg9LDl76Lk3c+xTvf/gRPvf2Yf+uDtxUEiIi8zlQEKK+Ln/nIzwEeTu9BnOCJp7j57DPcOvkkLzw4f6MfnrzK/u1vf6qsOkNnwTuDN+CswQG8KNwrlFI4mzPf99c/raJQkdeR/sHJ6+ZP/pZvL7/v3/3XYTyDt9+Ev/SX+PA//Gl+/KOf5KPPP88f/Nuf0s/jF6F/49seL0eDY9t7BgfeGjpr8c7S9x7vDIaCw2KtxbVFv+RMzoVSIJcMuZALzCRiLJxPid/xV35RPxMirxFlAOR185Mf+hh86CNwOMALn4Z+y+O3b7I7e4FVXPEf/zNfUv75H/qofuF/Efg/fc+TZfCO3hlWnWfVGzargaFzdMbQeUfXdXTG0nce5wq99XXLUcBgINc/xhwJcyDGRAyBEBNjCpwMhR/6Z99dUimMqbCLkd/xg5/Uz4fIq0T/mOR18+vffb389l/9VXzH130l6fyUMk/M957l6YcPOT8942yKpAx3Y+aP/IPAsw+e0c/nF4g/+M2PlccOOnpn6bxl0zmODwZODjasVz29c3XR957e2Lr4O0vnO/qhY9X3pBQoqe70Y8pYLJZCzpkQAzllxmlinGbGeWYOkRAj0xyJMTLnzBwTU8rsUua3/6VP6OdD5POgf0Dyuvnyd9wov+ltG37Dr/wqwj4Q7j9LiDN+6HBT3QX+gf/+lHeakTEWTp444sP9O3j+J/9/fHo/62f1DfBHv+OJcrTybZfv2HSew4OBa0eHHB9uGLxn1a8Yhp5V5xlcB97gCtB1QAbrYFjVT5gzmOVbmS7rAWKC/R6mmTDPzCEQ5pnz/ch+mpnmQIixvhwiISSmkpgTnOfCP/8XlTkSeaX0j0ZeN7/hS2+XD7xtwzu3HWsststcW2/xc2RYbfmjP/LTTHMmHXScrk5YTSNf+aVfwoOjr+Hv/uCf57ld0M/r6+APf+vjZdtbDlc9m95xuO7ZrgcO1yvWq4HOOa4fHXJyfIhzjr7r8H0P6wF6D96Dbc8N4GwNBpyFlOpibw2ME5QWARQgBBjH+jTNsB+hFE7PzpnmGgSM88w0zYQYGefAbhoJIbPPhV1M/M/+4sf0MyLyiFQDIK+b4w62zrDbR7recLLe4rotnR3xJrEzhunJpxinmTRNnMfCz/7CR7nx3ps89o538e89OZepOPZp5nf/bZ0Fv9r+99/+RNn2noPBcbhZceN4y8FmxdF2w7WjQw62GwbnWK0G7HoN6xX0PfQdeAddD9bWxb33dedvTd39ewelfctShBxhnOuiT4Hcnua5Bgb7fX1KicPtlsNpIs2hHRFM7PYj+3FiPQ/EmBjnmfNx5i/9lneXXcz8tv+PAgGRz0b/SOR18/1f/2R5/GjFta5w8+SIo37NerDYOPP7/pufx187YU6ZlOoZcUqJbCxfsvG875t/I/+v//wv8O9/22Mk4xlTZj8ldjnxfeoe+Jz9gW+5XY56y9GqZ7vynBysuX58xNF2w8nxIbdOjjm+dlQX96FvC30Hq1Vd3L2vQUDnwTkYBrAFjK0ZAetrUOD7VgDYKv+MqTv8XV3kyblmA3KuGYDdHsZ6JHDx5znAOBGniWmamOfANM/Mc2COgfP9yG4c2U0z57uZ/Zz4rX9ZdQIin4n+ccjr4nd+05PlS4423Ng4bp1c53CwrKxlu+4JyfC7/tO/T7l+TO87Us7MMRNCZHe25/Z64PaXf5Cz+3f52X/yj/mPv+ftlAyRQsywnyIPC8SY+L6/87R+ph/BD3zz7XJ97ThedRyseo4ONtw43nByuOXa4TE3r5+wuXYNelcX71UH6zUMG9h0dfdvTF3gu649+fpkbQ0GfEf9FWOBBKza81yfx1B3/CG0AICaHRindgwwtUCgHQvsWzAwB9jvidNMSIEwB6ZpYppmpjBztttxvh85HyfO95Hz/cz/4q8qYyTyUvpHIa+53/Ernyrv2m641cGNk0NONj03rp2w3W658/x9fupjH+c/+h+eZTo+wRqDc44Ycy32SpGzaeI92zX30oZrvecPvndk6z3GmJo5thBzYbef2M9wbgu/94eVFXg5/+q3PlGOVo7joeNg1XH9cMvJ0QEHB1tuHB9y48Z1Vtevw2Zdz+z7tsAPK9hsYNueVgM4XzMC1gE9daFfhosawLU/u/aUqat8CwCY259j/XNJEHINCuaxHgHcf1ADgZAvg4JxgjDBHNvzQJgC8xzY7c7Z7XfM88w0ztw9PWN3PnI6Bf65/+/H9TMhcoVqAOQ19wSFY5t48h1v56RfsV07jraH3H1wzk898xx38ax7j8sZu13jvCVncLNlngwpFh48POPwZM1H7j/kf/nf3uE/+jVPse18HTrjHdY6Ns4QXcecE//Fdz9ZHibYYfn+v6nd3x/5tifKzU3HweA5XPVcOz5ku1lxvN3WVP/NG3Q3rsHhIRxsW2q/q7v5vq+p/fUKDg5gOKAu8B11gfdcLv5Xf6XY9j7Ll38JAlJ7AhiBUP9sMvShZg+cqYFHKXB6Bl2pf7auxRAFvLmIJ0wCkwubgwP80DPuRnw3YvuO0+4Md7bjL/6md5WzMfHb/5qGC4mAAgB5jf3B998stw+3PHFyzGHJbHrHyck1zh+cEjOsD4/oxgccXj9mbwe6zYDzHlMy/ZzY+5mYC8/tznnvdJ8pe46OjnjOwWM2c2g7nPN471n1PZRMdpaN7ziYZmII/Ke/5m3l/hQZU+EHfvTZt8wv/3/5Vz1eDnrHkS9c36453Ky5cbhivVlzdFCr+G/cuI67fg1OjuD4GI4Oa+q+61oAYOqiux6gWwMH1FT+srtfdvyeurgDDFfevvT5Lbt/w2UAEIAtNQMwt+cGXIGhQLGwPaopnjDCLteMRBogtaLBApSCzxByJkdwfsXB0Qo/7fH7Cec9wzDQPzzDuR3/2a97e/ltf1VBgIj+Echr5gc+cLM8fuuEpx67xeOHGx473HB46wZ+s+bsfMeDs3OeeVD4xd2On7hzxr3THZuDLc53lJI5PZ94eHrOg93Eh37hE9zowPktd+aJX39k+MavucbbvOf6ZoNzlu16xdZ75gJDP3B6dsZZmDg/3zOmyBgzYR45nwvnc+Ff+rtvzmDgj37n28rWFw47x3bwXDvacnyw5WB7wPFmy9G1A65dO6k7/YMDOD6CaydwdFR3/hfn+a11z/TABjiiLv7LmX7f/otLut9QA4Floc/tfZfntI+L7elqNqBQA4IRmIC5Hgmcn9ejgHEPuwnOd/XPu30tIkyh1hLEDDEx7vfklMi5kFOs9STTxIP7D9hPI2E/8sKd+5ztJ+7vEr9TR0XyFqYMgLwmvv+rr5frN4+5eXzM7ZMDHlut2B4dcnTjOjkl7JCZjeck75mON3zp4QmffOYFjm9cZ7Vace/BA1y3p3MeUx7ghzVnaeZL7EyIE0N/nWfvTaxvWHyMnNgejCVYx8FqwPuO9dBxsN9x3g3sp4mUM7u0Yg6ROUb+q//RO8vZ/XOmaLgXAv/KP7r/RbsY/LHvfqIcOMvB4Nh0HcergRvXjlj1nusnxzzxxG26a9dqMZ9vqf3NARwewPVrcHJcU+99X4v+cNT0/UDd9XftCeqvjYHLRX0544fLPcWy6Nsrb4vtY3sud/zLwr8EAX17bsHs62P1S4bA1LqDYYCQWttggSkQzkdiToSYMc7hvYPSkWPEY1gdZopzdL7ntrO4Ow8xZsd/+F1Pln/xh3UJkbw1KQCQV90PfOCxsll3PHZ4xO3rRxz5FYdHB1w7ucbgO7pjT7Ybhts9wy/ewW6us9lF+vWamzevcT4mVquOYb3jjj8lTjPvPtrw3Fnmuf2Od2x77jJx7xcD149WHK8Nu1zo5ki3WoG1DKseZxyb7ZrDaWacAtM8Ms2BKQRSysxzZN5umaaJd6TMf7IZypwK5ynybIQ/9o/ufsEuDP/2d9wuW2856C29tWw6z8F2xdAPHB1sOTjccv3oiONrR/jDQzg5qVX8q6Hu/F0H3tbF//CwTe3ruFygh/Znd+X5Ehgsi7q58nLicvFP7WPaQr5cAIBrzwuXdQOBy6yBay8vgcEaugijrccQ3tZ32ccawBhTjwlSZoqJmBP7/UQwsOp6VkNPP6wJWA6cx1jPvNthjOMkO3Ip5Ax//rueLP+CggB5C1IAIK+q73v/jTKYwu3jYx6/ecQ1MjcPVmyHFf2qY9hY6FbYkxOuHx5z/fEvZ3M+cv+5e/TXnyJN9+j3kdWqY7PZ4n0HOeGtx//CJ/m5s5HBRTZzx9Z4PvrCjgNn6Q42HHtPComydvi+Z+g6HJaDg8J+HBnDmhgjKSVCCMzTRIyZlDIpBq4dbMkpcf/BOdf2D/kvvuPJUifMzYwx8wP/8N7rvkj8kW+5VW6sHM4UemcYrGXdOTarns3Q03W+XsLT92wPNqzXGw4PN2wPD2rl/mqAx29DP8BBS98fHsH2oFbzd2suF/6rz69W9S+vWwKBq7v6xbK4w+WvlatfrqUGoLzkdfDizgHaf6cdFVjbZgyYOlvAdrX1MIfWNlhIMRFzDQJOp5kYEnMXmVJm1fdYPFjYHhzinAe346hzYCDGF8g58x985xPld/6IWkjlrUUBgLxqftcHbpahwI3rR9w4XNPHxMHJCf1qxWq1qbfBHd6A7RYOj+GJE4ietz2cWIfAzt/C7B3rh+ec9Z6hn/D9itXQ40NmfuyE5AOffDBxN83gDHfunPPgxob+bGLleuzGknIhxMxmcNjNGkpms1mzmWfGaSLHSEyRGBM51xvoSJnz7YQphRvHB3xivoZLCTMFwjQz58T/87uGUkzGDh1pCtyJhX2GsRT+1R994XNePL7/626ULznucBScgb5zDMaw8p7V4OhtHbe7Xg8cHmzYrHr6vmO1XtF3ns1qjR36WqVvbR3ac3INDjZwdACm9fB3ri76wwDrQy4X+b49LYt8z+UOfan0X17+5fxyX4KrWYLAZd3A0ga4dAgcAPcu325cXfj7vvb/M9dsQMoQIqREKoVUDOe7id04EVJmipkpF/LG4LzD5MzQOYbVGuc90zhSShtk9PRz5LJTJkDechQAyKvif/61j5V1SZwcb7l5eMiN4wOubzastxuGvmezXWNXA2y2dRG6cb1WnvdbWN3lRnyKsTtkv++4vr3P3YenzFPgwdkZN46POF73HPmI3Q48TM9z596nObm2ZoyR+2Pg+skG1w0U60gYfNdj+/5ySA0F1mtWYYYYIUZKCKScW9FYJo+GEkbseubtaaZkRyJy9vAh265nd7oj+kIOE9Z5TvYTkQIl84O/cVuwtS0ttQtvYs6kXLAYvDNYa2rSvLMYLKaAcRZvDH3X4RxYa+n7vm52raVvqezjwwNW656hW+GHNonvIqW/aef3HXRD7c33vvbyr9d1wVz1sNpAv+ZygV8Wfcdlyn/Fi3f6S5r/1bAs8ssO/+rrl+Bgx4vmBJRSRwjHVvWPbeODgVzvFYi5MM6R/X7kfJqJIeOGQsSQzciqH1h1nlRsnVTc9aydYx5nvOs5Oj4ixIx1M//hdz5Z/sUfURAgbw0KAORVsc2FkxuH3FivuX7zmMP1hq7v6YaeftVh1xu4cVh3n0/cgvU16I+ADq4P4F7gKftO7p7fgVXPycEBu/OZ/fWR07OJo36NOd9hHwvsQ+KnHz7kmd2OzbZnjoWAZSaTrAXrKdZejqwd2hhaa+riP8+QMyYEfGrFZyHyxHZiX67hTWT34CHjfod1a655T8iZw4MNfj2QQ2AOmRBG5jjT244xBqY4s+o6eu8Bw+A9ua2f3tZF3q96TCy4zrMeBtarVRuAN2OsxztbC906X3e+UB9f33b4w1AX9XUbzLOchfdtl78ZYPD1bNx6WG9rcHCx2FMfECsuC/mWM//lfQyXC//nuxYug3+u/jm2l/OVPy+PY3zxxyyTAlOqlf4h1K9LyZCh5MwcMmOY2KdImOuNgTYlZp+IGTIW33V01pGLqZcROcv64LB+H2Niexjh7JyUCn/mO54sv+dvKgiQNz8FAPJ5++e+4lo52PQcOM+NW9dY+R5nDXbd4XuPG3pYu5qW3h7A0XXoV9Rf9AOQ4PgmcJveJlL25OGcI3+H4bSwPezoTab7mq+kfPJTxO234M/OuXfnaTIW6z3JGMYAcWsJpZCdbfPqWyCw3Ey3MpfjZle5LiylppNN2bKhQFnhNh0n5Trzwx358JApzbj1wHh+jt2s8TnhNo/BFAlponSOHOqO0tm6cDtnWfU9puvaOmrqjtb7OvTG97BaYXyHLfnyqlxr6/sMfV28c6kL/LZlTw62bcxuadl5U9v1jo/b6zdcnt0vu3va13sZx+u5bOlbAoCrhX2vhmXhXyr8l9ctr48ved+JyzbBVIO1MdTU/xxay18L4BKQCyFlzqeJcQ6EmJhiZD8HSsh0XSYVC67D+0Df9XSuI6WMxVGMZX24JZXEPM/kUscLxFz4U7/68fJ9P/qMggB5U1MAIJ+3k83A8dBxuF2xHtb0nSVQGKwlW8PmYFPT1CdbuHUb5qkOlmGgngf3MJ3Cw3/MwfBOgjfYlHEHG5LvOLvzHHnT0ffXeeJ8ZD5acf6ud/FYP/L40HN0OGAMJOuJGZI1xJjrOfEyj37o6s6aAqZNtZvnlkZui1JowUCKOHsA00j/nifg/gNWptRixOMNK9NRUsQkA9dcba1bFu8Y6+e0tTq9ZiGG1s7m6vu5lqI35nKh923CnfWXQYJvZ99LSv/qy10LDnrf/l7L0zJ8Z92+vi+d0rcEXbm9z/Ir4Gor3+fq6qCfZWe/vA5eHBDkK6+L7efA8qLHmlomILenufb612xApMTEnBIpZULInJ7veXC2Y5pTnVIwFLL1mHHCWsPgO8xqwPqOlCLZWjAd3bCiX2+YYmJYZ4x1FM74k9/6ePn9f0dBgLx5KQCQz8tv/rJr5WTjuHaw5ujGdZyzBAx+07Parjm4cYQ5Pmi710Og1GlzpoNyDmYD+wfgtnC8hYefouvXEB6CSzgPx0eH+HGg2408dfuEuw9W/Lpf9X4efGQgnj1gP830Q6Hra4V4wZGLJc6h/oB3vi7AQ+sxN9TnfdeuoW230YXUrqpti9PBNTjf14XXJNhsWKVDwGJsyyQsC7c3dXANLSWfc/38zrVOuqGm7+tBf7tGd7hc6K27DBxcK3xz7WrdpRDOt4p462ob34uq9ped9dVz/aspf0Nd+AuXhX3uyts/38UfLlP6y8vLWf4yOChwed5frrx/O9Nnunx93tcrg0NsMcUSnKX6fQqREFO9MTIXcikUYLefmVNiToWN9Zg54HxkWBWSMUwx1WJLaynFkkyiYPH9imEVmULC5kzfd6zD1ToFkTcfBQDyeTleD5ys1gyHB3S2XgyTO4cbelLfEYehDpu5dgjbVU1fWwAP+/swJLB9XTzntmPuLOyG+jzt4fiELQ+YV0dsT97F2z/6Q/yKTeHwm7+Oj/zch7jz4B5n+3OG9VAT2Nbi+x7r2i6yX9VdsnP1uWk3z7naYlgLzUrbWYa6y6RAKDVzMc31Y4wFxvr3mSfYHNYFetVdDr4rpQYFQw9hrm12zrSRuqa+frked1i33by7DCRKvhzUQ27PzZVz/GWnPlx5eVmolsX36tuXFL+58rTmcue9vO3ztezqC3UhXxb7q2f+hjrQ52pwsHzMMhGwZRCKren/BIxz/T7Ocz0KiBFSJObMnAq5QMwJ4xy5ZO6f7phS4XSKHG4Tw2rTLht0hJTJpRCpxZm5GIrzON/huh7XdfTGEENiXSx/9jufLL9bRYHyJqUAQD4vR65gnMUZS8YQDHhn2Rc48J7VsKrn1kdHdScbc10Uw66e0YdYd8ZjrhPfogVm6BLsxroon92F3Y5ru8A2d9w66LjxxNuY9w948h1P0N1fcfe5F0hhxnmH7zqcc1jbFv0Q2t30rVLet91uLnXBT21BSqkuyKmlmV2pBXXjUNfJEMFu6tuWuoLtpgUDB2BbIDG0HfbR8eWO3prLlL9vH3uRzm+97dTiwctU/ZImX87yl+dXi/Sujt41V15e2vmWM/XlOIArb+94cYr+lVoW94voh7rwB168s4dfuuhfHQNsXvy60sb7GlO/5nlJ/ZeL9H+IiZgyuWRSSVAMOYGxljklzqeICQnne852IwfrNefTyMr3ZAs21+6NnEt9Aqzr6P3AnAv9akVOhVXf83//tsfL7/3bOgqQNx8FAPI5+83vPSwmGywdJkMKcz3JdY4UC7uQOY2Fw2F9uRB2ts51zwn2uS6wpw/rL/YpwfoIylAX7RihzHVxdT34U/rTc2687XEwln67YRVGrpdDLJm7z93BO0uxtu6JvWmLfHta+7rQuhYALD/9HXWBsRlcrouPTeBLGz1rWiahvf/xBubWpz5YWHet3qDt9termr7P+bII0bZd/vJ1GFr6/2JhXtLzSyCwLP7L65YFfnnd1Wt2lz9Di1R48dn/S87WX1Tk97msa8tAn1ash20vT+3ty5n+8vmvTglc7gBYdv1LIND+XGLNnMxTC7jMRdsmc7yY+R9jqQN/5sgcElMIzCEyhUAMkZgSJRt208z5OHM+Bw5jpuRA7yy9NeSYySmTMsSUSQW6YaiPzlhiTLgU6HPmT337E+X7/pYGBcmbiwIA+ZytAN9ZhsM1c0j0XY/xYOZM3hj2uXCaIJ3vcQdbOIht/Sl1fYgR9nM9Cx+nmiE4uw/9SX3d8QE8c6e+n3Nw0EOX66Uwmw1MnpN5rtfNlEQJiTCOWN9hrKtpducv76O5OJ+n9sV7D4z1LL9vBXqppdOdb8VngBtgbWr62RmIHg6GGlx0rt5Wt7aXaf5lfexaoZ9pZ/fe18DAt3n8vPTp6o5+Sc2/XCve8h9YAgDzkqfuyseWKy93L/O5Phcv3d0vrXsv3dG/XPV/4cW7/3z5mGKAOLaq/7me9e+n+rTbwTTCFBhDYjdOnI8jMUb2ITDnmg3IGZIxpAJjCHRzZJwD5/uJs93Eqvck78jO4jCkXNojshQMxnmcT4QY8H1Pl2qw4UPkT/yq2+V/+ya9QEremhQAyOesd5Z+vWLaT/iDA5K1FDwzhj5myvnI6nzHMw/OeGq7qTvh2BbNztVxrqFV6zt/ucCeP1N3zGEDvYF1D9nVM/nVGrrzupgeHmDmwEGJ7M7P6FcDpETXeXzfFn/fgV+1XbgF0xbYBJhSjyFyalPl2ll1aQtYae9XEoyxtjImDysLU6zHCRjo2ppgfP2c66HVFbQv1BIEOHt5BHAxjGdJ619doJfd+tVU/7LQL4t/5sUX8Lx0V391rO7y8Z8t3f/LvX15W2j/7cBllf9ST3D1hr/lfZZgAF50619qlf1L4WSK9XXzfNn7v9/Vn4kxwJxgCszTyDRNzKku0uM4E+bENEViLu2UIDHPgX0EsxvZTjOr/UzfnXPr+JhSMqaAKxmDqRMBjcU4S8kF23X4GGuOIyWGlEg5sMpXxxiLfPFTACCfk9/0nsNyfHyAX60ozhMKnM4Fm2ZWxZC7iPGBOw/OWN1/yGq75Ybraqp96GoWILXFzLaUf46t3W1oPeCnrV1uKYQbatuboS4enYftCveww3lPypmu7/Ftkh5weeZfSs0wONOyArYeEYTWAdD37cI5W9P/IV4WzCcDJ5v6GPvWy+9iDVKWBXPoa3BjDUyhBjiY+ty2/z6mfczVfvt2lAC8ePTushBfDQCuWlLvXHnfcuX91lym5Je3f7b+/l9u8V9S/svCv+zgr6b7r97udzUD0BbO0lL47Ryfdg7PMgMhtbdPSwAw1qt/9xPMc83whFhvc5wCIdYJgHMMxFIH+hQypcCcC/tY6LHMsWYGphA5GycOVh0hFjKX//1iato/lxoEWu8pKeK7jpwifVphrNdRgLypKACQz8nxqqPrPJlCt+qYc2GaI57CnDJpDBwb8MPAvWfv0vuekjI3jw/rxDpvaz1AaMcCZVkILaQZSDUtH+d63l7a79xprM+trbvtljXw1tJ7X2vprKUf1rU637X2ufWmPs9tF+1bv33f151noXYLhImLXf0yS8C1boTtQV2c1quaAdj29W3O1vqFrgcb2wa+7eJLO/e37TlweVve1XP65c9Lsd+y21/efpFOaM+X15UrL18NLq721cOLMwaPaknZX93lLxX+S0CQr/x5eZ/5Mpuy9PAvT2kp5ltel9pTadX9rRVzP9bq/6kOAcrjzDRPTHOs0/tSYpoDc051EuQUmENijrnNdUpMEcaYmGMiUZhC4nw/4iyYzpMoF22gtsV1qVwMGaxZAWNxXUeXMiknhqHn3/3Wx8u/pPkA8iagAEBesd/2lSflxtGWG9cO2R5ucd2KO/fPMHj2ZLad5/TOQ3Y5kULBtcE2IWamOXH9hmG96mpa35lWfd/VdHBsv4G9r7vpvk3CK20hMrku4r6H3WkNAjpbT75XPT7DYA3F2/pbfMkomPY58pW2w2UCrbF1bQyxZR9CzQZYU4sUc4Fo6nEF1KBkNcDZvrYJxlDT/6VA8XUBW69a73oLXpYVJpea/bhYXK8O77la7Hc1vX/1+dWXX5qyX2btX32/RD1uWP6bny0LsHzOq0V6mfoFWfr0l7a+Je2/vG+ANLWpfe31ifp1WAYu5VK/9jlfBl4XwUEr9su57f5HmCbSNLPbjYQws5sj4zwzzrXoL0yB/TzWosAUyam2+IUE98dItjOr1Yi/95Anrh1jMVhj8AcWb8C0FtCcC+XK84LBtSmMOWd8X3AhEGxi3Xf8H77l8fKv/D0FAfLFTQGAvGK31x3XD1c8efsE2w2U4tnvZnZTYug9//VPPc37bxxiH+zwqe6ukrF453HeYq0hHx6yOljjTGuDWzLdKdWgYGnLc7YtmOVyk1tsHcxjysWG1/UdbprrnBxrMZn2eW1deENr6/NtQYtXivNCS0cbU2cRpKX4r709zzBsYRdqlsDaWg/gqMcKpQUp674uYsNhu7mOdtzR/luZy0DEXD0rh8vK/6utei+3WF9d9JdFfXn/ZYFfsgLL58h85s939fNcLdhbZgu0Hf2LCvdSe1168evDlbG9S4rfUCv6l69pauf+pbSFv1y+vNQBhFCLQueJeT8yhcAYZsb9yBQj4zhxPs2EGJhCIieYc2I/B6YUSTGTSmY3Z+Y8sl2vWfUjR5s1nXeElBhDpPe2BqelYHJ9DKUNFCptRgDWYp3HloxfDXQ5M6XMQae1X774KQCQV+QPfuNj5anHrvPudz2B6dZ0/YqYDPM+sZ/PeXoXOHrnO/nIRz7G7cMBUqDrOrq+Z1ivMENPsR7jOug8a2OxObaz+VIX11VXF07T+r9NqYv+0NWUcMptXQqt1c7Qb1b4ecIYQ+9sa/dru/LcFkFDLSQ0uWYWKPXzLQt0LPWYgNjqBdrZ+5Tqmb+3LT9s4GyGTdeGF/n63wihHmuw1Bu0hc22nf3SfliowcbF7npZxK8W/13dsb90x19e8uerr7saBFztDFjO45d/8vHK+y3X8S4L+kt3+MuZ//K8Xcu7TE3MVwv4Qg2oQrrc+S+p/9KyIMuZ/5IRuQgG2pHANMM0E6fIHBPjOBHamf++BQQhBqaWCZhCTfPHDGHOhJyJGR7MiWNnCSkzhsj5OLFZ9cTc6gVKxplaClJrAeru3yynHsZQjMU6h6PDp0zq6p0DHYX/27c+Xr5fRwHyRUwBgDyy7/3gzfKOx2/wvi97B5vNMf1qTZwKD3cTJwcHPNwl8t0HdKczn54Tj5WZs11h9fCU1drjho7iHKVVxRtr2J+PGBKH6xX9YV+L5qa2CPmupfuHuvgaC5sepqkW6i0LUEmkHPF9R4eh74e6Di+LSgg1sDgb6yK8LDjOtSE97S/YZhARWzYgzK0WIEGyrRavHUvYVvRHqWfV6zV1vPEyRKhNAyy0c+Zc6wCurtXA5c57GahzNQBYFu6X272/NP2/fA7Pi8fvLoFGz2fuwae93/SS1y8Ffcui344CSqiLdAyXi3vMtU8/tRa+MXA5Zjm9eLFfRiVDywjky/ctwDQRxondOBFCYJ4C0xyZwsQ8J/ZTJITEHOplQHPOLSioZ/2xwHks9SDFOqaYmEJkN82c7UYOh4EpRlK29QTK1m+ryS3LtAQB7etbMLUWwDl8N+BiwlAINvJ/+dWPlx/QpUHyRUoBgDyS3/d1t8r7v+xtvP+97+Jd73g7xvXsd4mz8x05W3I0XDsIXD84JN99QL8yxCnhVpaHZzuSs8zZEuZACIl9G96yGbp62n0SuOG2tT8/ljr4Z1jXtLpt/fO0KnuAsq9T+Fq62FrPZmUxOWO8a3MAXN2hlwnorixCtB7+0gYAtYJC244LltS+62r7WTF1SFA/1KBgHOvLmVbg19cK97IEFF39fCG0Rd9cBh52OdtPXKb9r0YEy5n61XqAly70V99/WeCvZgWu1hcsL09c7vRnLtsCufL2ZbHv2p+X903AWBf+EGvWJLbFPuaW7qd+bUILDsbpMtAqV4r+Lv4ay3/bXMkG1M81TzP7eWIcR+a5Lv7zHBmnmTnl2gUQ6q1/y/CfObadf0yknPm5OyO9s/X9psC5d2yHmfXQ83A/cshANLDqPbaAtaaGVAUohloFwOXPhKlHAV0PPoQ6F2pImP2EyBcrBQDyWX3/198q3/ArnuKbPvDVvPdL302YErkYeptwxhGjZQqZ7arn2uGas2lHGgshJVJITKVgdjvuWygpEFIhOEMogcP1mtV2Rdl3BBe5ZtZ0mwEbbF17uq4dYS9n7r4W5oVcMwTbLRjLuusID8+Z54A1hZILJuVWcd6K/Jxti1aCYGoHgLNtg23aYm5hH1raPtbWw0Kb5FdqMGD6+jm8rzv+3rf2Rt8217FV/LvLc3/TghdjXhIEWC775a8+vTT9f/Ws/8ri+aIrdZc0/XLuH7i8cXGZMbB0Byzp/KWwonU/MHPZ6rerf44t3R9aABDT5aTGnNsMhZb5GOfLo4DUqvspkBI5piuP3FBaNqCeu5d6sU9MTPPMNM2M08w0z+yniRQT4xQZp6nWBExz7QKIsU3+g7kNCZpTvrjeoab/A3Ps2IfI+X5i3Xd4Z+mswbXhTaWYWnpSCqYUDEvdxnI74GWCwnddLQxsz//ktz1efr9GBcsXIQUA8sv6Q99yu3zDl76LD37Fr+BdH/xqKJbOzZAdg8+kZDk6sZyGiOvP6VcD3XaFK4kpFIiBlAvMgTKOJG+ZHZzbmeN8nV065jBumOeZcZwZp8B6v2a7WbENAZNSrai3qbUO0i706cFv6vn74MghY+ZEF6DEjPGm7d6pKWZMbSEsbRF2to3v9S3/uyzO7ZzatYLAdUthuw7OYz33j1zOEojtiABTU+Bd10YQ58u2P9P+W8ZeThq0tmYVeOlTfMl34OqxwNXd/tXF/2q9wFKgB/Wf9zmXO/xMnd94Tmt74MUtfXB5FDFDWc70l8l8S7q/BVExXbbuLbcpjuPlx7Tb+lLOpFKr6ZeNf17O241pJYqFnDIxRkKINQiYA+MYCG33v59rQBDmyDTN7MNMaPcCzHGuIU2rMTTUz59yYY6Z3Rw4aHUAq96z6TuKq0cAtvcXnRqmHQFY014GbHuM1vqaxLEJ5zwtXqAU+Pe/66nyv/7hTykIkC8qCgDkM/rXv/WJ8h0f+DI+8L4v49oHvxZyG1LTh7rYnY/YbqLkiF1b8mDpjwbWU8eUe/ZngfOY6z0Bc2a2mTlH9mFiCBO7OPPwzilHB4ccbzZcOzpmv5u4du2YnOs1r4cUTGm7befa3IA2ptd7cJHiPNmtSC5gj3rm+6cYDHk/Yo3FWVt3ojtasaGpHxtiDSB6d9ktUNpOPSTYrOuFRK4t3Ou+dgIsu/Le18zEskAvxfe0TEHKLaho/91lOmBqZ96dvdINsDxx+fkvXn7pwCCuvO/Vtr9l8V7efvU4YAkQ7nNZAxCvvG97HGmuf/85tnbIWGsuQpvamOPl7j4sBZlXAoG5HgHURTm2AKAuxrHUa3u52PnXr5VpWYCcUj3Hj7Ht/EMNDKeRaQqEEBhDfV6DgUjMiRAzIWRiiDUjUOpNf0u0EXNmbnUAQ+fYjzO71cy69/VHwVmKNdCyALZ9DY0xrRugfj9z+3zWObquI5SCc45+6AnjyJ/89ifK79eQIPkiogBAXta/9e3vLL/x27+Br/6ub4KDExgOwK3aGfopzJEcJxKRYTD4Vc921fFwt+dos2KeJ6a+JwMP9xNhDvgMY7aMaWaTLFOA0yHy8Czy8GBmFww3SmHKiUxdLFLOrKZ6dotzNW3vW8o9JUi57vJKIYSMpxBKYD4N+FgwsQYBpi3EvfEYCqb3bTDQAKktrKldPuN8yw7Yep6fc13A91OdLLgUD4ZUWxRzu2bYmsvF3bnL7DrUo4hlS0m5bHn0V3f37soHLCl8y4sHA11VrjzlK6+7Ws1/tdXw6vOrFf60qv22wJclrZ/hfFf/2/tQL3EKc8sCtEU/tgK/GKGdzdcq+/pyaot6Xtrr2vNcCtbYi2MA077XL84AzOz2IyHWAr9xbCOA55k5l4sAYwqRWHKbL5SZYg2OlmOGnAsxZcY5sO49U4jsx4C3po6eMrDq/MURzdKscDGBsh0RWeMp2ZFTwlqL8x5KJuWI9Y4uZ/6db3ui/Mt/W0GAfHFQACC/xL/5LY+X3/gtH+Crv/EbYLgONx6DqcDd03opSwwQ9yQivrOMybK6fpP+6CY3b+8oz91lv73D2d2HlIfnZHPKNAVMTnRTYcywK5khzHQDbINhCoUpFsYQuH4SyLmQUmaaApv1wLwa6LzDe0fnO4oxpJjIORNjJu1CnRB3+hByJO525LnWKHSmLp7WWiYT6JylywXvDSa1RdUsqX9XiwMTdfpf34b69F1dJEtrV3TLjIKli6At4CHXzoGc69uLqa+zpu72jeNi/n00tbCuWxb/l1bxL216V0fqXq0JuNoeeDWNv7y8LPRLJGK5KAaMyxl+e/9lYc+mTkOclxa/UgOjaapP49QW/va4ppmUEjHE2sKfwsXZfMqFmBIp1SMAgJRaO+by2Nv3hgIp188TYmSaA/txrIV/c2ip/hpUhPY+MWbmOdRRwCnXQCBDaDP7C6V199XgIsRUpwX6WkC4GToCCYPBFAOdrd9eazGlUGyu2aMCxlpKSJScMKZ2hPQeZjIueUrOuC5zHF56hCPyhUsBgLzIv/F1t8v/5Ff9Sr76g99Uq9u31+D+DPfOai+8idCNzO96igfumHh2xnw+ks72cPc+2UXMZks/zfS7gDsfscZhTGTOMKeMLxEfM1PX089tlxgCMSXmMDPO9Zf+PAeODjasVgOHmw0H2zXOmXrZj+vqIhMzJhXOn79D3k3k+QF5mshTPbs36TKl23lH33m8c3Q+YYOh7PeQwTrLuu/xzkHJdVZBbpcXzbGN6O/a2rp0BrSjgWJrF8DVdj13pd3NUt/HLMcEy6yA0tboNmPgohcfLlP2V8cAXy3+u5rev/q2ZeFvBX95rI+bsb2ub1ft5vo8xlq1n1vr4r6NWo6XVfmEub58cb5fF/4pTKRcCG2xDzGSYiKkTKYwzYGU6tjelDOUF+cpoC62UC6DhZiIMbAfJ8YpME4TIQViyIQUKIV65W9MxBiJqab39/NMDImQM3O8PGYALoLJ/RzoncNQ8NZxtFlhjMXm+hi9NbVFFfC2DgIy7QGbVF8wxmKtu5hx5Jyn73sM9YjDGsOf+a4nyu/5YWUB5AufAgC58FufOirf+hXv46u//Gtqe9fBNXjuFOwOugAHh3D4JDx2k3R/xJ7uoHiS9Re90skYQqwjWb13uM7hvCfPcxv3Xlu3nHd0MTI7R8qpfkzJzGFuAUHb7aXIaufrDXBhpu88ztX0aymQYsFOM+HhjjlM7Pd7zDyT58C0H+v0QWwdGuhMXfydxVpLSXWRzSVyfHjQzog7+uwJ3QryzNp5XI4wWThY18W772uaPKZWl2dby2GscwwSdXtIuiwsXIYcYS4zALbVNOCpdwgsWQB48ZAeuCwAXFwNAJbl9OryurTqxbqjd60dMZy3/2apF+1Mc13sl6p+EhfD8GPr77cZdq26PyfibiTMkZAScwjMMRFyouTCnFJdnEMklDqXP5Zaz5Fzrfav6XXTEgE1mIm5kFoAMbcAYJqmurOfAjHXgsLYiv4uAoC2q8+xLvK0a4EvvkKtqC+XQkyF/RzwzjKGwIOzHcfbNd5Yiq2PwVlqK2lL/Vtj2mWONRNgiyFRcLHUERXeU1Ki+K4djzmMsfzp73yifO+PKAiQL2wKAOTCr/ryd5KuvYdP3HnAk/YE/9GPwrYDm3nwVd/D6h09w2lgvrdjf7bn/GxHjImcEvMcSSkynu8Yx7EVbo31jJc6WCW1CW0pRUxMTM7Qe1cLuVIi5kRMqX0MUAopRY6264sisM16jTUG6xzee3KKuJCJ4ykPz86IKcA0UWJi2o+UXFP7pRR67/DW4n39JV1SwvqOVefw48SUElNK+OgJNnM0dEwx41KiHwbM2dhu/Us1bd9TF/Uu19S55fJ5aHMBDFeO8FtKfTlbzm0KYaB+zo2pbY4XbXzw4h3+8vqr5/5X3i+1o4LlzSHWRdvQblukFelNdccfUs0CQN351yvzuJjWF5bWv/a67NiNO2IIREpdpOe2G8+5LuLte5liIpXaClpyLYbMubQTh4KxpqbViyGlTCaTQiS2S36mObSU/UwMmZhiyxBkYlp2//W/m1sdSEiZlOFDd0Nt7Ghfl1QMLhdSyZcFgXPkbKwBJRSs6Wvq39g62wgwtpByvTuA9i2spws1U2AwUOp8ANeW+hwCnSuYruPPffeT5Xf9jU8rCJAvWAoABIB3Xt+Wjx2/lxuPH3KaJ56+e4d1l1l3x7zwgW/l+sFMfzdxdrbj4cOHhDlwvh/ZnY/EGNnvz9ntzmrKNsaawh1npvbnlJfz+pouLrlgornYwc2hFYul2i5WW6xqGrqkxDzPhDAzbueaWbC2XtQXC4M1jNPE+W7PPE/k3Y4pJMocSNlArufQzhpWXc8wdJhcCDmz6joOVgOpwGbdE1Ji1WdiydyPM946fOdZhcDBZlXnEHXtimITattfjJfzBJbBQj7XscPeUS8IutK+144ZLuYOLB0Cc4RhuXBnGdSzfNwyCbCdvV8dnlO4nHiYW/o/p1p4WEo771/S+a2yv7QAIMbaHhlTzQjEdqQxRxKZnFqBXcpM+/q9DKUwhbkW67VFuy7iEEKd85BzZk71PoC8fC8vzv7r4l+r7JcivdrPH1ImzDNTCKSYL7IMpRRCWNoKa6C4tA3GVGf/h5SYYqIsn7fVWubWDphiJrrSbgpM7MeZsfd4a5hMLQosxWE73z7O4KytP49LAedFLWadE1AoOFeDiDonol4tTE44HH/mu54sv+eHFQTIFyYFAALAx++em//sv/0r5cPPfQl/zzi+4u23uHW8YvUdv4bbzz7D/k7HYC3Pv3AHcGQMOex57vk7nJ/vSTmznyL37t3j6WeeYzcFxnHk7HzP+fmO3b6m9lOsbWG5tcTFaAi2va5dxkKBnHKtCwixZhg2A9M0MU4zm/UKgDBH8hToSmb38JRxd05KgTjNxKW2YIq1AyAmnLWs+46uq0NxvDWEIZEKzDkzhpnNMLTpcpntdkPfd/S0UTlhZm3bjXvFt5sLzeWAoKWIcEnxO9OO9MuVIUCm3Xpn2lXCvg4nsrYO0cHUWgvrL+cIABc36BUuMwlL/30uNcBIrUWvpb0vqvWX2fvLJT20l+fWtjfOMI2EecJgGKe5DuYppQ5yCjMpFeZQU/EhF+Z5rkHB3IK7Us/wQ6iZnFQKMdTvq12mOF4JAJz3Fx+X2/d+DpGY6jFASvnyrD8vi307BmiLf2qT/3LOTGMglVw/XykX1RjFLEcBNQgIIRGcYwqR3jvGEFkPPbFlEKyxzDFi8Fi3dAMUYgZnSp0vgMW40uoDLMWU1hFQ6rwIY0k5Y0oNHP6D73my/M6/riBAvvAoAJALnz6dzcdf2Jc7245PfexjvO3LP8CNv/9jHB9uuXnjBtcO1jVlmzOWwhxm/s6P/Qxh2hHnmWIK81THsu52O873YyvkCoQUSW1nCBct2pfDYAqUktumtjDHUOsA5kCYZ46mNUPfsV6NNQBobX8mJdJ+z/7sjPF8T861jzyGSJwD1nsICQf4zrGfAt45vIG+71vfeSbEjlXomUK9892bHsaJYAqxzFi3hV1tXRtsu7Og9Y7Xfv8Mcaojgq2piy5tUmAM0PX19XmZz09bmcLlJUGhVd4vbYZLa+FFX1pL76d8me5f2g7DS4fzxJoBWG7ZC21C4PK2uU33Ox9Jc+2rD63CvrQdvus69mPN8NQz/7ro1qK8WM/eqdX7BluzAilTcmac5svDiUC9oRHTNs8G5hljLTnlelqxBIepVflfWehDqyvIrZiw5FwfS3t7Xgr+WqFlbj9TptBeXro6Sz0CCJHOWkLM9edzqMFAiAlvLc46Us44Ywkl0i0BTFkGO17+DBtqYSCA9R5jDTlCb3pKTlhrcCnyZ7/zifK7VRMgX2AUAMiL/A8/+wnzzieulYeHa85+9sPcvnHMelhh+AWGVc/hwZZsHE8/c8bg9uzGPQ/P9pzvJh6enbd2rdqat6SGw3LvuwFn69mpd7YWV2EwplBKnUhXA4B8UQg4zfUymHEcWQ09q6GrNQDWYHDkEJj2E9P5WU3/x0KJkRwT1hlMnqhZe48P9WpiZy29c3Qh0U0Tc1xzVOri0LeU8rC2MNdBL8Z09TZhV5hDwnURP5taB7DM+SddHgfYdhzg7GVRP6kGCZ2/nImfW2FgasV+hrrou+VooN1IuJQBYNuCni8v0SmlLvrTfNGLf3lBT7p8eckCtKmMzIE8BcapztufW2vdOEdSDDWdf3ZODIHiHfvdRMm17S6Vwhzr2X5hafWrgVvMiTnVr2FuGQvnHQVLCIFiSmuKaKn1FhTMc6hHROlylx9jDRpjujw+ykDJuU0SvNzdl1IfyxIf1ROTjGu1B9ZCzPVIZY4Rbw2jrxmh3X5k5W2b11TP/J0xJFNX+GzLZS9GuXx+EZy1wU/We3KqfyNrDCZbjPPMYaSj8Ke/+23le//GJxUEyBcMBQDyS3z86XuGp+/x1IPz8qFPvsDR4cA8Zo42PZ2Foe/YTxP7cWYKkZwL5/s6ue3Og90j/YK7dbIpnXd0vk7qc6WebS8T4WJKhOiJbShMiIGh83Wyn6sdB9YYUkjEOJP2EylGwhzIKdaq7ZQxpWALOGPp2y/8zjpS54k5U0rHzs0YA6s8EHwilEI2Frvq6cqK8xApbsZ1jugN82zb7XAJ5gLDiouV3rna3mfbRURdKwSMrUNgTi033RbupQ9+qQcwrTbAt86Ai2yBuTz3j/FK4X9L48d0OYJ3yQwstyUm2gz/UO8rONvX2/XGwH6eCDlepPrnUHfbhUwuhmnKjGd7LKYW5LVLd0KsZ/TG2lpcl3LNvBTaUUBsCz/EKVHKXKftLZP1TN05l5zaZYmtjTBFUmqFfkttQcqthqSQS6bkNkyIclkw2gKJ1LoNDNRCw3aRT8r1W5JbcBBzYQqJ3TThLJztpxpYUup5f+mgWIz3hJjovSeXXIdItYMAU6AYgzWuBSW12NG4esGQsbbOvmAAwJrEv/ddbyu/74cVBMgXBgUA8hl96tkHBh4AcON4U372ERf3R/H8/fq5Hrt2UDpf6L0ll3YmfOV8N/XpYhhM5x3OmosgIKXa+hVjIsdAmWu1ujG1latuAusoYm8NvfeMITJ4zxAcnfeYraGLluAcxka886RiazV6TnTTHtcPpDmQnSFbS6KeM7uc64VEsd36txTjJQOm9dUnVxf+kmvaveuBfJkFsPbFrf6+u5x02KrP626/XC7+wEVgEOPlzn9qw3yW/rfcAoChg2kkxcT04JRiqMHbVNP+KdcFfBmzm0smjIE5F0rKlJI5jbUOIIU6fncM6XIaQcvY1AmAubYEFrC5XIw+KBTilC/+TtYtA3ZMrV+c5xqQtcU+pHyR8s8XO/5aPJrbcUhK6eKCx6XTIxt4bkzmsbUvZjkayKVOes61FmOpNwkxsp8t3rbdvzWY1YCxBmstNtVAYnCunemXi1KONmcQgyGVXG8TLAZTbJ0a2FlcSRQsJRocBWzkAPi/fvtT5X/zt3RvgLzxFADII3nUnf0r9dy9MwPw5M2j0nlzUeOWciY6S4wZZ2E/zTVTYE1b/Gu19ZLZJtczYlvqGa0tpQUB9cY3bwwh5bbYJ2bvWfeZ9aqe+zuXwEeG6OhWNUUNlmmu58MUX+sLppliLfM847sOM+/rAt91l7cADqu6M1/a6VKoqX1MnaS3ZACWFbRQF24DdFfuPSi0XXy5XNiX78LSRRBzXfjnuQ30aV0DMdedb5oZHzyAkOs1QTG1q3XH1ilYL9uZ41KBPxFCve9gDrGm4aH13dcWvdDS8TUdXpa+hDadr850cK0/PqWlMC+32TwGYwyrvgdTu0BKq+qPbbd/cRSQayCYUm5TEMrF7IAaBNSdeMl1oU/Af/2R+vP03D6a2xtfoNUDZIim7u5tqRMJozHMMTKG+jOyn2MdBEWpRwH4i/rNFFIdy7TMBrC0WwPbKU6mHReV9m3N5ALeuDZe2JADdBgONxdnOiJvKAUA8gXh0y88NABP3TwszrVz2JQJ1lz80mU5W20XySwp2dJ+EZcYMW3Bd6XUAiwKNpU6Dri0X+gY+g6sNcxToDeeySd8sJy7TNmPlBiweYXp14RYmNcJXywJwxQCgx/YjxOdczAlutBaAq2rw3bqf6AeEThfRwfb5by4rfp5KdJr5/TOXwYA8OK+fnhxIeBSGJjSxXje3HrnLwbh5EyI5aKHPuZEioUpjMS4TO4LtQJ+rovw3Ir9lql+pZTLuf45M12M/c0XZ+G51U+EtoiDYYrTxQjgi6K8NvzHOttmANS/2BI0LIt9LuXKOX++CB4whpLbnH9nL2OnUtrcxBcvrCm3eQOm7tZTLhgyBos19bpoFxOztXgb2U1zC/ZKzQoYg+0Nc2y1I6ZdFmRNO6lZjhja508F21o6jXUYTP1eOIc1Bm8g2UBnCn/21769/O6/9ovKAsgbSgGAfEH51Aun5rFr2+JtK/Rri4YxXDwH6hlyqRe3LK+3pgMKsdR0rssJT6npV8DmOguA9svcm7oQ5RIp2RGCxXf15Ww6Qsz0Xb18JoyA75hiJBfHnPas+57RFHrvidaywmBsrgv4vLT0uTZVL1/eDUBLzy8Lf6HVCHR1F+/sRer6oq8/xlbpnutfeOnxL4UY6sKf2m14SyFlbot3iLGl1jOxlDquN8baV19ybdeLbapfaH31LQiIKRPifBEUxPa8lNpnX7PvtdAzLIN58uVFTheLv60DmevkvMI8B4y1F3MhQqy1JKnt/mmft367S83I5EIphkyBEC+OH3IrAHzJ+s8LYzI3N76Q84uuUDDki5T/1eBluTHQ2potcjFhjanXBrfHUCy4Un8uU8k4AznVotY6Gbq0o4H6bbPOQ3GUMmNdDQpTKaxWhT/9a99evldBgLyB9MMnX9BunWzKxTjW9tNaOwcuF37TKrfNxfvVrIEDbEn01GFBa+cYOs/aOw5XA9uho+86hs6xHXq6bs3qsMNnON5uWXWOzcGalXccbDb0fc9m5fHOMgxrSIXVytcLilYrXEys1gMlJNzQ1UW6a/38pVxW95c2Yje18/zc0vh1xQDfCv5MbdsrmLbxN20ITsY4S04JYwxzS+EvN+/FNn0vtcU+5kw2pe7cQya3uf/jfrxo24spE+ZAmEOd6pdS3fXHxLQM3Ml1Il/NMgCtFiIskwDbmXzKubUH1hW5nqm7eq5OuZjEmIEUa/fDHGubYmrBRWmBzlLpbyl1wE/L9uRlUW+dB7l1RMzjzH/54Ycv+r12a+OLbzcOelt38Z019N6y6Tzr3rPqPOvBc7gaOFwPHAwdQ+dZed8mSIJfgpgWnFoKztma0SDXmpIWGFlb6wWsrQ8ll1RHBuf6FKaJOI+MIfC9P/QJ/R6WN4QyAPIFbSkWBLhxtG7BQLlY6JfZOtmUi/ZAZ2q1OSVj2+AeY03bfLdT62IIqeBdoiTLNBWwCXsOq4MNZ7sz3OEh8xSwGKYp1Km93rWWs5mh7zjfT6zWPeHhGV273tYZi8n19sF6GVAtDCO2qCWly5kAc6jzC1pPvGv3FFhniO2suuS6yNZsRW6Jgdza8LgomAsxkaiFesv5uesHxnGui3IKxFIbDabdHmMd8zQztnG+pRXxzSFc7PZj68FPKTOX1C77SRdzHEKqBXuxjfPNF9mH+vaaua/dDdYYnLeEltVYEhkpxYugocSI7/sa5LQAwBpDXI4/DCzT9gxQlp8FDL01dZLyS3+GdtHcWrvi2u4bWuo+ZeolTjWQrHcExFpr4izOOaZY700o7c4Kb03tDmjZpELGtY8n1O6Jrqs1HKWNR7bWYGxXv39zqVmEYSCR6Rz8qd/w7vJ9P/gRBQHyulMAIF807jzcG4Db1zblpckra+rZv7WtfqDWX+OtpWstg3Wcax3mE3LERYjWkG0i2cQYJgwdZ6enbFcD0zhdXKLrncEFC2ZicBYGiGFmNayYxoDDkJ3FTDXNnQo4Z/HG4K1rI4GXRczCFJn2O8ZpYmyLrSk1aPBdV4va2mTElAuZpfodYqxp7zo5EbIxdefe7lEIIbZbAjKp9fIb0zHniC1QYqJYwxymi7n7tfWPVvjXdvTxshXv4jrdGOvZPFxU6y9vX6bwXRboGZaGvboIupr1aEcwlMs7AkrJ9TIpIE/T1XQPmHrOXxdcwNjaa29NzQRYy4AjxRlneVnP75O5tWnRQl6qKetjY45XphS2Hf6+/kytO9fqEOrPEsVSbKZrwYRznpQSXefrkYBzpFK7J2qtSiYXS4mxloKsV+Q5UnKgd1vIXb2sSeQNoABAvug8e29nHr9+UKwpF+n/pVDQWVuLtUob6tIWFkO+SEPX1jJDsrkVeHlWNjPEVmfeDcRUuwhyiATvGXdTnVhIJtmOOdZFLaZM5x3eOlZDxziBCQnvLF1xzLm09jFLKqmNqK2V6/txYjfW++xrC1sbPDRNbS2yLQgAKBe7+ile3pWwLE4htvT7smBT2s14dXhRSlO9kImaojal7vTnObXhPpdn/MuCvrQHLs+X3vzcCjDDknXIbYBTW/zTS3rzrTEYZzApt958Q7Q1NHAt0LHGUEoLLnKbnGyhHhoYfElYU2sjXC44Xy8SMr5e3mNMIcVfWgdw1fO7aG5tfE0AXQkCDIUxpMub/1iaNAxmM5Bbq+LQ15n/udVxWAx5nPDOU2Ksj88WSqqDg4x19eez1JkA2dj6eTtXu1Qo+GIorvDnf+uXl3/hP/9ZZQHkdaUAQL4oPXP3zDx+/bC4tqnj4pd3HdBiSy3+89bgyDjrW1V5rcxOyZBMpusHQkkMxhMTbA96YkwMzhKiw3ronSVbwzgHcLZODMwDztYUfMyRznlCywjUOQS1IrzEGgC0qkVsKYR2jp9zZprnOhag1L52510biwzO24v7EQoQQmJqFyuBaQFAbcVbZt2T6+Q8zDJSOV70+i+jcVO67NtPKde3twU+tbfnnC/fftHOV2/dS1cq/kMLUErrw4/5agagrccGbLItO9OOBFI9P4+5nq0vlfx1B13P873zdKk+btM5SqlDqHJKmFLoVx0x1OJIbzL9Zs14Fj/TjwxwJQhgqVEwNThMMMV05WjJtLsFMkfrAWttm2hp6kAjQz3yyRlrMyWB94YYEt651rGZ6jHQkq9qA4qsM+C6OhXRWDpvmH3Pn/ntX1V+z//jpxQEyOtGAYB80Xrm7ql54sZhMaUO36sLzuUNc4lSr4V1deKc823GOwa8q4vZ1Cb8hRnXr9jvJobB1Z0ulpQy+90O7zs658nF1COArt4dj8mE0Ha0JhPniOs9Jrf77ku5vPQmJgzmYqGt6fqZ3G4QzKUOwrHO1fR2MbV2ISfmNvBoTrHOzzemtbXRDsottkBIkdJa3nIuF2N+a0CQSfFyEU8lt6mLtXL/6s5/uaAntDP/i49ZKvVbVmC5dW859784AjDmRZkAY+q5vTUw+JqJiS1LUUrBda7NJajje3uTcTnXgIGMc54cM3kOrLZr4jyTyXS9x+R6rOG8o3SO7/uqk/Knfur+Z1xIn99Fc3NdgwBKwWSDtbQFfnl1IZWuTh3M9VrjzdCTe09tJqyr+jKN0ntLCqldc9zaD0sNwhz54s8WW2tIrGnXF1jAYy6ugRZ5/SgAkC9qT985NbdPtnWjObh6pS01JeyHvt5GR11455Dq/e/W11G164FowBY4nyLeRowD71ZkY5mmiVI6Unb4HpKNZBLZeeYQ6DtPngqlK3hTi+jiqsPNGWcS1tTCsdxurCu5pvlrwV25WHxTm35HqUELxmAx+JbmDrnu0mOMxJYNYNl151KLG2nZD1tvs0sXu/vlpsXLm/diaz1csg71Qh1Ird8+tQU/XCkAjEtXwXIc8JIFv5TSxgDXGQS5pfZNK8xccuvOWDIFaxLetmFOFlyo9Q+rUos5C3WWg+ltvSYhJqyvFwrN81zbPFuw5w2YzoOBfr0i7/af9efmhX00Nze+lAzYOhOglFrHkad2FJILOdfMUaJmN9Yp0nUeWwqrzjP41u9PzUR57yAbTOvi8M5cTGY0xrTLIltLqAfrBwqlziVwHf/n3/Ud5Q/8ub+pLIC8LvSDJm8Kj18/KK6AK4nOgG/jWa2B1dDhcqazhq7zdM4wOEfnHN5ZVr2nd7UdcDN0HG63dMbQeUdnbR1B3PlaUDh4rDWsutpC6K1r0wktJReMqztxY0wdZpPrqMLUdpI5p1ot3wKAud3mF1MkY5lCxJm6GNZrbU07469p+7L8r5jLkQKtJc6YNkExZox1jHO9gtkaWpBBqym4LCAsS+Fe2/HXXvxykeKvRwWXu/6wBAPLPP5yOQioFiteDudJrSPCOduq9e1lG5539M7T+Xop1LqdvS+X8dj2fr6zWFe/5uR6pXOdKdDS7r3FU+sFnLOQEmkcyfuJf+fH737W32831r64VmDY2doe2DlH72qb4KpzrPuOwbvaFjp0bIaO3jmcMaz62kbobD3i6L2rbY8GnHG4bhl5XIMD4229D8qC6eoFQqY4ovFMCaaUOJ0C/9qf++v63SyvOWUA5E3hmbtn5va1g2KcJ+UMOdUfbgPTFOhtLSYrOWGKrYXg1lAy+ASGiHMwR8vZ+Y7NaqhpeudqBTiZ7DpSyfSdZx8Sacj0Xbud0BisM+Qx0uYTYtog/BzixRl5vT3vctpdipEp1Qr8MId6Lt22+MsCW+Di5r3S6gUuJyKVi7HIMbWugJJaSr9cDMtZFvqULl+uWYRa+JhLIcbIHK8U/i2LeilXXrdU+tfRvGnp+y+1y/EiMMh1Lr8z9epoawze1QK54mu7pCmZEjOH3pNyYeh9rZ2gfi1rzcJylBLr1c4FTMp0645cCjYnrKtdHuRcK/hdT3bhkX5u7uyjub5yrTBwGW28ZEQuhx3FdmRSv+KQu9aV0IZVeVfqbt8UXHEX6f0ccs0KWMucMz4baJdj2mJqNsCuiP2GHGacMQw5/3IPWeRVowBA3jSevXdmHr9+UIqzlNLVMrRS7weIqV1EEwCX6Y1lFzODN9iUSMXUc3giBQtzoPORmDy98/TtfLaUetVv7z1TSoSQcHBROm67en/BRRFcHcvXptjVM+aYykXhXgyRcZ7rLrsFAjHGmtovdeu4LPj10pt0MRgot1qH5Ra6FCPW+daTX1vRcuuCyO3zp4sFPF8EE+Ulqf2lfiBdFP3V3fxl2r8dH1Bv1Vs6CxLtZmMuBx6aNhPB2TqJsbOGnDLHpY7GdaaevXe2VciXQjEFiiO3bg5SwPQd2YINGW89JWSss3jv6q28MeO8wTpH1/XMYeQPv/+k/PEf/8y1AIu7YzIAt1a2sJzRF0Md4bhMmTTMbbDPcuTSe4uNlsnV71GmHtl0vuBdrSPxxjGFiCmmDm/KCV9qDUQptbugtlRmsL62N36mXkaRV5kCAHlTqZmAbcFb8hzoXRsha4CU6664OCDSlbors6VQvKPMXLTqFTJz9HQuEV0iU/u9+84zhUjwHcYaOmuw1KXCdgNlnqHUVP8y7z7nuttf5gDEi9v9YI6BaQp1nG8xl+fv7Ua9nHObJtcmyi1/l1b1X5Z589AW9ZnYJgRi6g6a0vr4W7FfuQgclizD5Z8vshMFYsktdqk7/eXPy3l4pn7+1IoOU7uQx2LAUgfuti20L4UugR16bM7sS8a4mn0wOWO7emeS7ZYBQXXSHgZSspQELlKDtA7A0JkaTFhvsc7hfU23p5xw3UCYHi0LsHh+zOb6YEqxl92ExpSL7gDwYFJbsAuboaeYeHm3QTtqycYQYt35z3nGOoszFlsyqViyrXMlrGuXTJVanGlaZ0fMmT/8v/qO8sf/gmoB5LWlAEDedJ69d25uXz8ovvPMbcJcVwol1TNkmzJTTtDXlH5N8RYGX0jFk+JEiIntBkqsv4PLlMldTTs764lpwnvP3M628xzxLmJ8PYxf2hFDCPX8PdbWvJLaFbmtPiDMkSmFOlfAOaZ5JmYY53DR4tfW03pkkZbUdGsPbLPxL4bwZIi59sx3rl2a1IKOZYd/9ex/SdcvnQOhbeHbdH1Kqe1wIWUytSCxGFMX/5yZiyECz52Fz7hYPX68LqWA7XtiKVjrmQ2YEFl7R+9dPRpwtXe+OHvx9cvG4DvPMs+/FMih3uqXHZBTG8hTj3VcZ7DB0B8ekOaJP/RVR+X/+FMPH3khvTst2QBXcgt6+sRFJmTNkrGI7XUdKWdWXceQPc4YQpzpOndZhwJAwllHZwFcbXnMYEumGE8qtV3UmBrUeae1X157CgDkTenZVhPgjCWbOlZ3SOFi0fMGyhzpWpV2buN0fUyUNtUt5czgPcFbJmuZU6b3HmcizhiMC3jn6vjeAilMmNxqDYCS2ll8ThcFdiyp/gw5p3q7Xju7Pzs7bzvYTEy1W8C26XexXAzFu+j5T20nv0htxHBKreK8TUXMpbRpg8uiXi52uAXarr9mMVKqAVGd5V8X+5gvi/oKMObM87v4yCvUMw/25rGTdbE50VlXByG1v0ufEsnY2kOfMzkm+lJqh0Wp1zmnUG9FLK2IM1GPDmow5vC+o5gIGEyrtsfA4bVjztrtga/U82My1wdXapZjyXpE5lRYd47OWwrzReHlHDJ9F1n5rhaFpohzlqFz2GIwxdINtgUxBRcTKbXKx1aL4liOY+oxkchrTQGAvGk9e6/eDf/EtYOSXIeNI2AosfZh52LaYCDIrv7iHTAUAl12Nf2dS20DXIbVGEPXkv4uGaKtzWjG1NvgXHaUtoguV+bGlOpZbyvGiyFg2q48pMI8z/VYIddUex23Wwv0EobcLgS6vFXvSkEf7RzfLF0Dy7FB3XcuwULMyx0IrXagneODaQt7uRhAVC8vLMRSn1KBZ1/Bgv9ynru/N7dO1uVwVc/2rTGw3WKmc4pNJLp6QpIzM6Xuon1fC+VybO11hRACg/cY2m2RnWeOkX7wGG/xxmFdDbaMdVwc2H8OlmzAjZUrqWSS5aKToo/2YqHeDB2dS3TBsfeR3jl8Z1kPnhJrkOKWos1SpxAuPxvZG0xMuAKxHR3NKTGHzy1wEXklFADIm97T987Mk9e2JRtLKBm/DHthOYqvO3TfBgUNvW879kxOjphcvfI3pXqtrvcs9w0556FkfNfXim+X6531rUf/sk/eQl6m7yVSisQM0zQzpcQ4hpZSb7t02s6zZQRg2Syai0UfrlSq59R27q14EHPxOeCymj1TF6DcPta0gUK1iK0GAwl45vzzW/BfzvP394YTysGqB+8Ic2BnPa5EcknYOTNYQ+o8ztT5+ZZ6PW8KNQXinYMcKN6TXCFHWLl6syC5kGzBeY8jU0rCdB1/+P03yh//8Tuf89/nzlIkuHYlU8ixLvwhZULnGGOqtwl2DhctXWfpsyWRWQ8dQxsBnHMhhBo4Oucpth60+JIwrmBKau2XkbOd7geQ154CAHlL+PS9c/P49cPiYwDyZXGeM5RUyLZOk8M5pimQvbu42jbkzJwSg69ntVOrJagrSqx3wceEw5DcMkZ2mTdfi/NMyWAKcwhka5kz7M5H5pKZpsAUUz1fby15JRciXDxODNQysVpfkHK9Hnep4l+uyq0uCwMLNYi43P23IGBpc2utfK8kpf/5eP7+3qTDUo63Qw1ErCGuDxgIrEwg43CxHs3YlLHeQaQOR3K1Aj8XSyozQ/H1DgBbCwvrdyAz51qcWWLhcHvAvfDKigE/42PfJwOJx9audNaQSr3foc+1LmBKjoPBk7AkbG13TJYwR/oCPhesLeAM1mWMB1fqXQbEiDGFEBIxBc7246vymEV+OQoA5C3jmbun5tbJQXE505FxJdZWOdNGCLcUrHftWCDXy3lszPTOElNmihZvLc6aOgzGWWrcUKfUuVRTA20TfjlpqxRCiuRUiHNgioFQ6l0A+5QZQ6rV46keBZRlx94q8qENF7qSwoea4c65Xa/briOuPQzl8u/Ecu5fq/Rfr8X+M7l7Opq7pyNvu3VYcu9J447sHMX2WOvIJbEKCU/G55pCt6ZgsyGlTOcsZvBkayim9thjau1DMWBKDYyMNUzesur7V/XxP7evGYHHNq502TLnQu9M7ZIoie26ozhPSZkw1ba/LhZ8B66rcwyMCThr6buMNRbnTT0aKJkYA+fKAMjrQKWm8pZ0++SgWAvdPGENFz3pzpp6ha8zeFsn13lrsc7SWYN39bZB7yzeOTrX7o63rmYFWpEXxlBSvWEOUye+xRCZY2QOkZAT8xjYpcx+CpyH1KrsWyseLd1/UbBnLnrvTXv9EgRcdqxzseC/0BapL3Q3j9dlO3Sse89gLdbaWk9hDC4FHImuFLwpDM4yDB2dBdMm8fWdZzN4Nn1H72qNxND39JbakpkjU4g896kX+NM//+jdAK/ErY0v3tW5AKu+PUbf0Q0DQ9+xXg1Ya+oUROfqk7V0XSsgXaY4psw4z5ztRv7K3/vwF8X3T764KQMgb0nP3j8zt062JWHolyl71rZJcG3Yjc1kZ4i54HMht8yAdzX1u5yre2pxmDX5YkCfrZEA2VIvvMmJeY7Mc7iotp8LnE+Bh3NijJnQzvyXVP6y9C81AXf2b+zO/bXwwoO9eYE9t47XZT14tn13cYWucxZTakAwpFCr8NtgI2cCfec4tJZ5rt0PxXh6CqFN1+mdJ4Y6Mjib1264zpJRubFxJWAZS8H5jJ8nOh8Z9oFVX8cZO2voe892PVwOcEqJlOtQqd04sR9fnSMLkc9GAYC8ZT1//9wAXN/2pV/6yTN4C64VxWUMrk3hq+19prWftW1bu33WmHoHfJ0BcHH3DeTaBx5aLUFpxW9zLtzfjaRc+Ln785tuYX+lnn+wv/gaPHF9U7ZDh831a+9MwfQDcZ5gCvTU71FKvhZWDgN9joTOs1r39GNm1Vl812MdTLtwURPxWrqzS4Zdrd6/dbIuQ9fhYmIMkd1Y75Tw3tLNkfP93K4NrkOi6ijmxH4M/ORHX3jL/zzI60MBgLzl3T2vC/DNtSu+Fcc5A6lYoi101uJLrlPvCmRn8cUCieLqLt22O+ShjY61pt39XgfUxFKIsbbnpVxIMbHuHX/nU+f6ZX/F1pkyW8tv+fK38aW3b/HH/uo/qJfvpEjnHaZbE6eJLmcoqX4/mPHDARHLPGVsb8jFMhuPLRPF1JsVX0/P398buLyV8LFrm9L7Oj+gHhnV46LcjnxKKXz06Qf6WZDXlQIAkWY5N7+1cqWzNU3vS62oT8XgiyWVulujow39qSlp7wymtKtsS73y1XaejMVcGbWblmtngb3ufPmlSgHn6HqPt4Z/7Z/+Rnb7kZ/5hQ/zgx95SG9hsLB1htJbBmMwwZAenNN3jnXvKXnN4Aem3Z5tm6tvhle3EPCVeu7eTou7fMFRACDyEs+3vu/HVrbkUojF4IthoN1OZxwlJIoHXyyF2t/fdw6wWG9IMRNixNnaqpYLOO/IKVO8wcyJH3tau/+XMtYweMfh9Zt4CyYn7s4T5/vA3fGyBuL22pWxQBcmnCkcrXoOBo/LcJ522JK4cbjFUOhXPdPp+Rv51xL5gqQAQOQzeG7MBupiU9vxMvW+mULnHMa0Ebqm0FlPmiOdL1jjsW0+fSmte9/Wyn0bIiUlStKkt5djrWXlez4xR95+uMb5Ov1vjPFF7/fsPhn2iSfWrqydwZSZkgq9c2x7T2ctKUYYOqyxGM3WF/kldO+kyGfx7D6ZWyvPmApzhjFm5pwZY2JMqQ6BCYlYYEqZGCI4Q2yp/mzAzAE7BZyzhJhZvc5n0l8stp3HecPHzzKHNzac7/aYAn/5F/cvu4I/vU/m7pwvbisMIdYODAyWegXvDITd/Pr+RUS+CCgDIPIIQip85c0tt68d8KO/8ByERHYWaNX/vcXkhLWeTB0T6+YZYw2mGLAF13nyPDF0VpH3yxgsxVnLer2iFMf9nPAp40P8ZT/u/pzNYE1ZOYv1npSpdwV0rnZtxMiYVHAh8lL6PSTyCH76wWxsm7zzz37Tr2BMtd88pHp/ewyxXaKTKfuA2wccDjJYCjYV0jzjh47tqntd2tK+2Gy8ZdN5NqsVx2vH8+6Asun55N37n/Vjnx2TeTAnTnczBkspBmd8vXSn1CmBIvJiCgBEHtFD0+GN5eBgy/f+M1/PHCDGOgc+5EyYI2ZM9UrfVOf/lxQogBu6OjUw1xbD9dDzP373gValKwZXx/ZutxsONvATn3iBT9w/ZW8e7ctk2vhmrCGVjDOWfQg4A//Vx1RwKfJSCgBEHtGnYiTmzOA7Omv53/36r+csJkKot9IRMqkkUo5g6x3yxvk6ECjVa3isdThbU9ReS9KLDH3Heui4frilhMJu2vEPXthxb/dok/EcBpMghkKudz6xNp79XnP1RV6OAgCRR7SfAj//cObhvVM643Fdzx/9jd/Mw5iZQmBKmURd+K11WOpIYWPrjPp+taa3Boxj4x2DVwnO4kbvymboOFituN6vObQdaY48G+GHPnr/kUKlwcFcLJ3pMLnOaXDGsgsqABR5OQoARB5RSpmHw4oxTVholeeFP/BdX8VZgpk67Q9rSTlhrGHlLd53DL2jd45+6Nl0jq53DEatgIt171j3Pdvtmk0umO2KeT/ShUf/FfXQdOwSdMax6Td0xjKGgCk6aRF5OQoARB5RyYX9+Tn38ayOVxAzsRSyc/zeX/3ljLEwtsLARL2xblh3bFeeVedYuxoQ9H1PZ+3FbX4C26Hj+GjL0dERwTt8gKHref7es4/8OZ6fZ0LveBjhyDtWzmKmyF1drSvyshQAiDyinDMxZX7+QeDZ3FH62tpHS/H/2l9xkynDlDPFGOaUCBi6YaAfVqw3aw42K3rnWPeOYbV+o/9KXxDes+3K0eEh69WKx2/fYrXecC/M3HvuLt/wntuP/Hl67/DdwPnQYc3Aqh/Ivl67KyK/lAIAkUdUcsEU2BvLz5xNRH8AprabUSCEwhQTcyzMMdX7300dZ9t7j/eOvutYdZ51P6AawOpw1XHz+gkn20Mef/w2dtiyezCSdond088/0ucYeluG3nM49GTj+bEp8SAkxmnmdK9Ui8jLUQAg8ohMLmAMviucjYG/fxox1oGzGOexDn7xPBlDbQ00ztZiQAsO8NbhncN7V7sBHrG97c3sq66ty9ueepL3vuMJvvy972YOiYc5U6bAs7HwIx+980hxkrUGM2V83xO8xawHts4wz5Ef/MijFRGKvNWoDFnkEflcKCkSxpF9mFgdnlDshGGm5MvBPiEVTM6UXMgpg/UMm3pRTd97HIngDJjuDfzbvPG+58ueKidHRzx28zZf+zXvx3U9H7t/jj+7y537Z3zjUwMf/+ijfS5vYPBdDcSSYes6RjcRsgotRT4TBQAij6oUSi4UPGUX2YUHhKd6jHFY41iKzUspWGMhZwbvKTlju4GBgrMG4x3jfsa9RS+oeefRUL76ve/iXbce493veRdf8fW/kluHa/67n/pZplL42C9+kl88e8DwCm7wW2VwzuKHFbMFNwyUlDgPCgBEPhMFACKP6EHC3Cy5xJDwK8eMx/crJhKFeisgwIdOgznpXCnZsh06nLfkKdBtNzhbyCngrKOURxtw82Zy6/ikfOs3vZ8PfNX7+Iav+wA2BoobeP585mPP3eeZT32ap+885Pam494zjx4AdM7h+p7tMEDfs58n9tOeXdQMAJHPRAGAyCuwjJq1eHJKGD8wuIdMxlKu9JvHXEjjjImGg+2KzeAZOovDkF2tC7D2rffP7+jGLcbhBl/2FR/g+OQGzz/3DJ96+lP85Mc+xc986CO88OmP8/TDc77ipuVvPPto43uvd6b0neeg7+lWPdZ33H9wyg/ff44DXQIk8hm99X4DiXw+SiGGQIyZnBPJZM6jJedISJfp5vPomLNltxt5/PiIle8hZ4x3OONxzuHdW68G4MGd59k9fI6/9Q//IWMMjLtzPv3Ms7zw8Jz97pw7D85ZmYmPfeLRd/+9tfTesxp6nLWsV2sevPACW1/4yx968NY8ZxF5BAoARF4BG2GOmeIKxXQMYc+9MuBLIV7JAPxiCpyeG546DHTGQYRiDF3vsGQenEVyeOsdAZzvTvnxn/wZ7rxwh+31W9y//4Cz83POz095/v4DvvypI37iI49W+b/ovcUPHcNqhbee3bhnnmZ80AAgkV+OAgCRV8CUArkwz5Ey7yjzwLYznKZEsVe7agvRgMHRjQnbWUxnKKGQc6ZzBrq3XhfuPiRz7+H9cn5+ylw+QqYQUiKlZAB+4iPjK/6c/apnM6zYrNeYzpH2Iw9DYKW9v8gvSwGAyCuQUyKWzPm9ife++xpp3BPGwm6a4UoroKG2pv2Th4FP+JlfF+HoiS3OOCKWYhyme2v+89vFZHbx1anOf2Ltyrrz3Dg55MaNGyRqncaR97gQX5X/hsib1VtvCyLyeSq5YLuOb3n3LbrjHlP2pBKxV+73zaVgSua0ZDwTP4fHGkdOEKeCt56YlKL+fA3ecrBZc3hwwLBZYQyEGPAlEfevPJsg8laiAEDkFTCl1EuAQuR+SMxdYTuAXw94f/nPqZRCLgVKYiy5pgQiEDPWWUIKdGZ4w/4ebwa3Vq7cvHWdk+MTtgcHdM5xfHREnGae3U388Kd3OgQQ+WUoABB5hYwxJAL/zY99nIkNc9fTW0Msl/+cpikbW+qtgNkUXpgnfvCZ83pVcMqsVmumnXaon4/rhxturze8/bHHuHb9GteuXeN8P+FiIsa3XoGlyCulAEDkFTBAThFSYjt4fujnTznqV4ybnp99SVV/oRbZ5GyYrOE6mZQjJSTCPuBXqzfir/Cm8K7jdTkeVty+doN3PvUk737XlzDuduzGkYc58tW3dM+CyGfz1qxCEvk8lFIwgOsKx6s9/+XHRm4UR8gvXnRySjjAmULOhTNn8f6AwkixhhxVpPa5+Kobm/LkrRv8U9/8DfTrAzY3bvLMvYfMKdHlwtl+x/3d6Rv9MEW+4CkAEHmFfCo4Y7DOYH3HwXbmNJzX+f9XlFIIOZNLrXi3Fp5/eMaBgQDEoCl1r8T13peveOo673r72/hV3/QNDNayPjrh6dNz9vMMxjI+eABn9/mRZ/Y6/xf5LBQAiLwiBm8Nnbc4C84W9jkwzhHMSxb0AhjD1jq8gfOS+eizZ7zvdofJhph0Uc2jOjCmfPB9X8p7nnqC7/6OX02hsFqteOzxJ+k/9Qyf+Pgn+fAvfJRnn34G9yq1GIq82SkAEHkFrIXB1MXfGgPW0Hcdd+7sf0kGIFNIOTPmgsewspYXPGA7xt35LzkykM/s6Im3cfPdX8O7v/oreds73s7x4SHHJ8f83X/w3/Ejf/NH+cgvfpLn7txjHifWaq4QeSQKAEReAWcNxhrIBVsKMSZ85+icfdEgIIBSIKZEomAM9RIhAw+fOycOiektOAr4cxXGHXfvPM3KfwU/83Mf5fT0Hs8//wK/8LGP88xzz3H3wSnTfuaFceLO82r/E3kUCgBEXoGu8/hVT993OAwlF5xzDNZhXjJ5rlCIKZFz/YdmKMy58E8ifOkaOqsmnEd1fvqAT/7ix/l//5W/xlPXjynTOXdfeIH7Z2c8PK+XCJ3NgV3MWvxFHpECAJFHdL0zZTX0rA5W3Lhxgu0sySTyHDEpkeMvzQBQIISAN4aUCtHClsyUCoPTP79HtQvRfOyTnyyffuZ5ftpZTI7kkhnnQEyFMRct/CKvkH4DiTyiw95xeLTl2s1jVqsO33c8OL1HnwIWiPHFZ/qGuuvPKTGmxMp5ojH8QoLb1hOt1qxXYjdFs5vUOinyalEOUuQRPDHYst2sObl5wpNPPMbhwYaZAilTUubu3YeUl9QAZFoQUAolF0IppFxwZSQVIKkNUETeOMoAiHwW7z7oyq3r13jb25/EHq+4df0a9x88oJRISIUVhjAFVi9T02eoWQHrDNYYYkn0CaYciGpXE5E3kAIAkV/GB5+8Vm694wm+4X1fzb3dGZsbW/rNivzgASUbQincuf8QP8N//+z0kpx+AerCb3BkA9Y67qZSLwSKygCIyBtHAYDIZ/BPve895YMffD/f+mu+G+thHHdsjzZ86EMf5tnn7rB7cMqDh6c8uPeAYfdyLX0GSsFSyCXjjcEVgzEGnz0xKAMgIm8cBQAiL+PatcNy7W3v42u/5quxc8IdHWBN5h/+2I/zsx/+BZ6+/4AHD+4zjhOn+8D99PJDfYwBay05JXIuJDLrbLHTxJ27u9f5byUickkBgMjLWGP48Md+jr/zjw/5kiee53zl+dTdF3j+mWf49LPPMp2fczaNnN45I55P3NnFX1LSb4BcamCQS6GUjKFw3xge3B+xaBKgiLxxFACIvIy752fkT3+Cf7Te8uFfKEwxkL1nnCfOx5Gnn71DON0TcmZMn2H4jKFeGkQdG+yMI5fELRf5e8/d5+R1/RuJiLyYAgCRlzHO2ZyWqXzkF36aXAwJQzaQUmKaI3NMn7WJ32AoxmCsxRjIJdFTmHKmM9CjOQAi8sZRACDyGZyHbM7D+Ll/AtP+zxiKAW8tlvqP7tB45rx/dR6oiMjnQIOARF4j1oB1FmttHQhkDKmd+697T1IGQETeQAoARF4jzoCzFmMNznswBpsKKUW8MTAoABCRN44CAJHXSGcsnff0qxWD97hSyBRKKZzFwO6zlxGIiLxmFACIvAaOt74Mfc96s+Ho4ADvO/rO4ygkCrsQcZvVG/0wReQtTAGAyGvgCDhYD7zt9m2unZxw/fAQcsY7BximUvixZ0+VAhCRN4wCAJFX2XuPV+XW8TE3rl3n/e/7Cg43W1LJOCCmjHEO90Y/SBF5y1MboMir5GDjys2DgS996p2846mnePe73ol1jgcP7lMKJAqFQpoCOesiIBF5YykAEHkVvOvAl+vXT/i13/5t3Lh+iykEDg4OwRg26w37cIqxjtNx5N75OQ9jfKMfsoi8xSkAEHkVvOPLPsBv+Z5fydHBAQbLarXi+o0b/NzPf4h9jDx8+ICnn32OB/cfcLYf2esmQBF5gykAEPk8XV8Ppbt+iH1wzpe8731cv3GDn/npn+VH/vaP8vFPfpJnn3+BB6dnnJ6esttPzPPMM7GoAFBE3lD6JSTyeTrobLn93qf44GNPcfzYNQZrSfuJTz9/h7sPHvLw/im7aWK327GbI/eTFn8ReePpF5HIq2B71JenHr/NTdcxTzPJZEwxvHDnPg93e1LOnGr2r4h8AdEvJJFXQdfbsuoccS5YEsYYSqkXCr3Rj01ERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERE/v/twQEJAAAAgKD/r/sRKgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB8BdnlLkVAMeQgAAAAAElFTkSuQmCC",
        "encoding": "base64",
        "path": [
         "value"
        ]
       }
      ],
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "2.0.0",
      "model_name": "ImageModel",
      "state": {
       "layout": "IPY_MODEL_c497736e857b4e588f512c1b93ded194"
      }
     },
     "057995c02bb54f4683e087d9517cd518": {
      "model_module": "ipycanvas",
      "model_module_version": "^0.13",
      "model_name": "CanvasManagerModel",
      "state": {
       "_model_module_version": "^0.13",
       "_view_module": null,
       "_view_module_version": ""
      }
     },
     "06ecd236087d49bc8046c46556fcba36": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "2.0.0",
      "model_name": "LayoutModel",
      "state": {
       "height": "500px",
       "width": "500px"
      }
     },
     "07815ff4d97a4917b4a920c0fa1ded35": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "2.0.0",
      "model_name": "LayoutModel",
      "state": {}
     },
     "0cc4c53b69774ad49fa33d9258d56135": {
      "buffers": [
       {
        "data": "iVBORw0KGgoAAAANSUhEUgAAAgAAAAIACAYAAAD0eNT6AAC5SklEQVR4nOz9eZxmWV7Q+X/OcrdnjT1yX2rNqq6u3nehpbEbsIFBYXBABUEUUMcdZ1RGfr9RR8RxxhkGhXEbxV0UBKGnWXpfaHqr6qquLSsrK/fMWJ/9ruec+eNGZmVVV/WCyPp9v15ZEc8TEU9F3Ofee77nnO/5HhBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBC/LalfqN/ASHEr62//W0PhJuff84F/hJX/Bd9I1Dwff/Po3LfEOK3AbmQhfhN5gf/8Muea8DV8y9R9YJPXqyBV7zEz7zkE1/Sl39V/vw/fUTuNUL8JiMXpRC/zl6sgb+9Yb/9onxhAHDre9ULHj/v5z9PAPBFXvFf6o0hfOFv+bw/ePPn/9w/+Yzck4T4dSIXmxC/xv7WH35ZuHlh3d6A395wf76vPz8Y+PwjADc/XVRPMOue4Wc//AS7rmJ1TTEvA0UJxoKNwIf2n1Jw76biUKb44DOeSoHRYKxCq4AyYAz4BkIAow0REVkRs7jhyBeBEODPff3dX1rDHz7vQyA899wLvvhn/rEEBkL8WpOLSohfpRdr6D+nEX+Rr932AXXbk7f/bPWznyFb1fRf+xpU2qf81Psxdz8IZ96Iiiwahyt3ubL7LD/5iY9hOjDoa67teEY77Wt3BqAT8L59fNem5o6NDh98fEbhgIhbv4wG8GBUGzDkMyjmEBxYBdqAReFyCEHjTMD7gHcQ/MHvHtqAQSlY7QXe/uAam3lGeu0q9sGXv8RRfPFG/yUDi/C5X//T/+hhuY8J8asgF44QX4R+ZsNf/aZ7gRdv7D9/I39bL/+2r3U/8xnwL3he0bZunQT7wJ3QsZTz83jvCSGhWIzJeusoXTK+MaIuoX/nMT7yzHUe225YPwyLBnZ3A6GBo2uKr3hZxMceqzm3FVBGYRMwGdgYohgSQNeAASzkpWI6DVQFeNpGXjmFUgEVFNTQNIHIKgaJ4czRHvdvHME/vMPuw3u43GNRBGB1tcuJr/sa7PIKeusxQnGWaDmmGVd4f4PxMw5e/8pbx+dzGv7wUsFAeP73vyB4+O//oQQFQnwhcpEI8SLaeXr1vIb5C/X2bz1/WyOf/MojdF/1JhhsEFQJSxuQLYGv0MaggiP4Bm1TaEbUux+kKfdQyuDqMU0VWEwC1iq0aXvzdQF1BctrkHQUcZqgjULZhhuV4z99xnP3KTi9pnjXxwMlcM+y4mVHDUc278GuvoMQLxNbDcpgoz7GZiil0SYjFBPU6EPo/NMQIqr8KWw2RPffCp1XQPc0ysQEpXD5Avfpd+E/8BP4uiIo8LVjdiNQ7EGewwLI0XigARQBhSJTgSQOmBgaB0kPlAZXQTGBaNmw9I0PHhzd8PxA4KVGCz4nYGgf/cn/WwICIV5ILgrxO97tjf1LNuov9fztPfrReS7WFYOVo2TDIxiTorUn6qyhox6qcwyVLqMV+O1PoPInUL4gNBNcuUOVF1gLkYUkCUQx2LSdmzdRjE7OQHQnQXVARShtILiDUYOKS9sfYOp38MGznN7L8ZX7Mcqi/A2UuwphSsDjzWlcdB8uuwefbqK0BTzBNygTg7EobVHKALqdB3A1uBoVJShXQpSBighatccigAqAVngXcGVOKKeYa4+R/8zfx01mBNu+DDWgA95DCArvoSkDdaloKkP0yjeSfs030PiGcvsR6tlFTNzBpn3edfYnefvKg58zKhBuGwoI7YfnvvYi7/mf+LGH5N4nfseTi0D8jnRzrfznG8b/fI399Bee5Ohf+H5CtcA5g1/sQz3HT58imJQ466OaHXy1R1PuUs93iNMeNjmEiVeJuuso1WDdRYaDc5joFCF+FSFaQwWPokHRgI5BG4KOUNEKys1QzTZ+/mGqxVP4oJgG2GliotiQMODE8usxpkvQXZSOCTpBKYNCo3BQbeHiEwQVE+aP4H2EG74WsnV01GlHJlSbDKCUPpjX1yilCMEDAaUOGl3nCcFBNcbvfwqiZczSy9pjt/0x1OxRXLkFvgAsKj6BV11c524CEcGXsHwHUX8dHaU4H2iqknIxxzuPn22jmgnuyo+STy5js0O4JifpHEXphA88+2lOn3oH/e3t9s15kRyB8CLzCi82mvC9EhSI32HkhBe/I/zgH35ZUEo9v3E/ePyiQcDt8/hKsfm7v4+gAvV8RlCgnIOmAA4amODB1ygCGo+mRvscmgnNfItmcZ3F7gW0aTh5F0TJ3WBPgI6ABhUmKPcJgtsm+EDwCjAou4btvw6dnoF4HYonqEfvoyxuMA2GmRmgtcU0C/r5Nsq1jZsyihACShuy7hGSzml0tEHQy7DxdnS2BErhyhxf5QSlccUUN7tOMDEqXcWkPZSN0dqglH7+MdIHR64pCaNzhJ1foJmfxbuKKLIof6Edzzen8N7h6xlKJ6j0PnAzgp/imvxgFMDgsSg9oM53cb5sj6LzNFWNq2cYm2JthHcz7PABqM5hOvcACd7P8W4frbbY9duM/VeyvLf/vASBF+YKvNiowO2jCN/zoxIMiN/+5CQXv23d6uW/oDf/okHAbQ3+3/nEI/y3r76b133FX6aZT6gf+3HSw69Er7yMePZJVHYKs/9h9NL9NEuvIpgUCGgToY2GEAjllGrrEUZP/kNcVXHHg69Fd18DOkY1E8DRlPsU4yuYaEGcemyUosICHZ3ApEdQySb4mmCGYHqgI4KOGe+8m1FxBZQmYsDa8HXo8jrN5OOUsydROsPYAa7eo24KPBBFiqR7HJPcg47vQq+9GdNbR9uIEELb2/aO4B3eBYKr0VGCjiwKdRDYBIJSEFQbBN08uD7gg8c3DSHfxW79NLg9nCvwzgEa32wT3BRom2OtTBsgKIVSGehlyO4imGVIDlFsP8x061OU821CCISgUBgCDVUxI0m7dFcfwNc7xCuvJfgK3+zTFDvoaJW6Vjz+K+/jZW/5GvZ+6l2kb371886N508TPD9AeGFw8N3/4NNynxS/LcmJLX5b+dvf9kB4XoN+W4/+pYIApRT/avIZXt45xju++gfJ92+gdIwypu3Nq4AxBm3a3HZtIpSxKJO0LxgCbvdh2P7n4PawkSPqbhDFR9p58fgMBEMIvm1Kw4TLj/5n4sxhszsoJs8SZw39JUXS6ZEMvxqV3gt2uf1dlSaYjDK/xI3dd+FwRPRZP/z7iKMlfD0H1xCUxS8u46ePoEJJU+U0VUm1eBrn5kTdVxKt/i6SQ2/G9pYxNkYbA1ofLOELeN8QnKOpG3ANGI3WhoBHhXadn8KhaacFsDEcZPwDhMl11LV/R1AOn5/DuzbHwfsFdZXTVJDPwQVFFAeSTo8oPUK12KVpKqLeScr500z22sCl288oFjnFIlDmiqZpW2hjYDEDPAyWO3QH0D32e8FNyccP4X1Nb/3V6P7L2D3/aUajG9z11j/Ls//6e3nlV/0Q58/964Nf+AXTBc//z+eMHPxxCQbEbyNyMovf0m42+J9vHv9zggAFCsXVk8c4c/iriKsps6f+JlqnoDfAB2yygiuu0DhH0JqmmbBwFbt5hdM9QpTiVYOxBh8qBoMjLGnHPb2niKwlOIfJjkL2NoLugltAc5189BGKBTTVAhN7qhyyjqHbP4WxGbazTrTyFnS8hsKhTMRi/DjX9j5ETUEvXmd982uIO0chNPgmxzc13oFrPKgIHfcAT3X9F2mmZwnNPq5e4OqG7NR3kR15IwbXBjFRhrIJ3JzfD7QBAYrgHcF7gm9/j3buXx/M//s2QDjIDQCF0poQPGF8HrPzblzxGM7VBO/xzT6L0R6uUexcD2xdh9pDb0lhLVQ5aBPYHynKJhAvK64ExYV5YGbB63DrbhU82GCJjEVXhsLVqERhbUNiIVLQ85ohgc3MsTHQZMkK2NNULDM88UYO3fkarvyLb2H9mSlbr3tN+7q3zQ98/imC9pv+2N+XYED81iYnsPgt6Ye+7YFwewP/hYb1bwYBjwyucX99jJUz38rep/8iu8mdzFWFsgatO2gdUbucJFlCKcUi3yX4HG0zfDHHBsOR429mNHsa5/ZZtRl3RlOMbjBaoZjjqynJYA3d+TKC6aPqfQIli/2PEpwjqC5lvosybcZ/1jtO1juDjnuo9CSqdxpsl5s96/b3DyitDxpiD6EiuBpPF1cuaIoRrlrgyxGhmVIvtvBNTnAHxXlCRbJyH+nm67DpAGUs2ibPvT4NKu6DaasDBQLBtz3+NvGPdtWBd+0yPkXbEhPaKYHgCT6gtELj0MUW7vp/xldb+OoqjQsE79m6cIHZJDAZK+bzdhagM1TM88BeDjtWcT4EZh5MFDBG4avAbBfKoi2boLTCN21rrIIidhAqqJuDBQYW3M3kDhXQBpQJ7ftjPEYruim8bKh46wNv4K5XfQP7j36EZOkQO5c+cfD3P/efz7/MsPVdP/IpuZeK33LkpBW/pfzQt98c4n9+r/5ze/nPBQHbdxwhfvTdHH3TD6Gu/AifyqF2NUFFzBdzup0hjYeAp64bfChwzZwunntOv4OFmzBbXCO4HK0161HEyXAWoyw2WkfbBNwOoZkRxV26y2cIbkpjjrZtpK/bAGD0KQJtgZ26iQghJusfxsYxWWeFdOUMZnAGlCVgQcXouNMuu/NtTV8dZSgTETB457mZfxhCoBxfapP4yi18NcY1Nbp7mmhwJ7a7io5SzM0GWoEyMd5moMzBXLwCbVDaHGT8B9oWz4P3hHqBakpClBHa2oGog+mQgD4oOdh+r9ZtnmDId3E3PoyP1vHjj1LsvwfnHJO9hqsXA6ORwiew29U8NQ9M8rbBLcvAfNGWLsYovG+f10ahAV8qcBC8agMPDt53x0G+gEfpm2dNwHOQFNn+1u1zB1ULD/5K/vo3dDj1sj/E/PLPcfmpayTLD37OCoKXzB247fk/KsGA+C1CTlTxm97f+Nb7QxLpz9vIv/Bx/eQ2J975Dkz+KxRsMJpc4BdunGc0U7gAgQjXgPcO8PgC1pdj7jx1gnF+g729KQZNlkQsDQakVnPSjVjRFZ0+eAdaa4ztQZgTnMNag9EeozU2SQnxCaCPa3K0DeTjJykWDd63pXXb9rZPcDkET9K9A5MMCWEEzIk7q8TpEeKlNwEJQUcQD1FJStAJzhuqxZRqPiLUOb4pCU2N7qyRLB/D2hhtbTvUr1Tb6zc3a/Qd9P2VAufapD6l2rX/WhOaioMDhIqS9jnnbvX0Q5u+TwgOFdqGMLjmuaDhoPXV2rSBi9b48SXU7ofw848ynz7F3kTx0WfgoSuBUQ7ECmcDnnYfAq3aBt43bQVCVx0kIIaAtgGdBoyBYKFRoS0vpNt9CkKgHSXQYJTCVYAD5yDUGhUC6mAAA267EYZAbzXww9/yWorJecpyl97GO7n69PXnN/cvmTvQfhKAP/p/SSAgfnOTE1T8pvV3vv2B8PkaffjcKYCN1QVq6c1UN/41auXr+flzP8H5q6CVoiwDjWurznU7ik4P5jltcptXtxqESMOwq+hlcM+S5lDjGawqTNTBVzlag7EJxi4RZydwxdP4eorp3I/ZeDth8suY+jGUchBt4r3G1TN8UHi3T1POqfKAcxpllsBDlKakw+MYXaO0B9XFqyWwQ1ApQVtUcNjOOvHgKCaJaaqcxc4FyullaErs4C6yI68jyvrYKEIbg9a6HbpXuv3jDvIfwq1jqG6uY2yf9x7vGvxsC67+Es30KnQP4zp3422f4Bxqch6992mYXKbZrfGXb6CLEq0U2rWNslKB4NseO7ZtpF0vpV7pMD12gktuzqX5NXJXsXejpqlTCmp05NC6rSpUFYbpnsIVMYvS4bMGHztUotC2bW2NgcaDMQobWVaGHTpph8UsZz4pmI0LyiLQ1O37jofQ0BYrahTKtUGFCu2Ei7o5J0LAW/jhP/Yd2NmPsxhV9I69lUEKTz8xv2054RfIGwC+84c/KfdZ8ZuSnJjiN52/80deHp7Xs+fFM/e57XuG/T2qZkgx+iz9N/493v3LfxbVjkZTNVBW7XByUbW9S+fa14oj6HZh0IHNTLE6g2QMx+6HpLMEahkfGlw1RinbZs2HMa6swQEBnMqw/bspZ5eo8xHJ0j24ckRkDWm0hU5TCArXlFSlI2hQoU2kUwq8UxjbR+k+2vbQdgA6QtslTNQD01b903GGjrroKCO4Kb4ao7LjqPQQUf9E28NXCqXbY6PrBXp2sZ2CGN6J7iwdBAPtygIOjifuYNu/m8P+TUE1u8L4xr/GUbYNmwMqh68qKNvVDG0Vwjb5TwWLigxKR6AMQTUoV+O1IgSHIcZpTwgxJhoStCXoDioa0hCxaGZMyhFbe88yyycsFjUhB2pP2u1iQhtQWGvJi5yiKLFxTLSUUQ0MZTFjf3Sd3BfEcUScdNqyRz5QuwYVIC9KKldSloGiCDR1YFEEqMEV4GuggdCodoMj345CuFrxnV+2yoOHdrBRh6R3lG4/45nHLPD83n94YRhwW2Dw2KUJf+enzso9V/ymISej+E3hL33D3WFjKf0C2fvPH/JfSp6i8hX/6y94OpuB3/eGb2Lz0Ek+8Nm/SzdR2Ki9HTeNIm8AAlYruhYOp4bTq30yHaPIUGoJDbh6AiRtjzkEQmgIbg448CXeTXFVQNdQBMMs97i6nUafzw3BHKXTUWj2MNEGdV2Rj3ep5gvWNyEbtn+v96Gdz9agdYRNNlAqarun1PimQamEEEq08USmwEYp2q4Teg9ill+P6R3DpF2C95iD4X0dWVQImChBaQ2+OUja0213OQBKE7xHGdP+ja4GV6GanKAMKMut7MHg0UC49gT+F36AZp6jE41JEsDj6xKVaVTWQekI1T2OXroPgm/LCZfbBBQh34L5LjMDjy+2+anHS8oENlYVu5PAfAp1CXiFJtCPNWvDiKX+gLWlZVZWVxj0lzDxMiZZosZQB8fcT1hUI0o3o2raBt4Fj7ERkY7bBjkAaBpXUdU1RZUTFORljqOmKnIuX99nNvM0FVQL8BWEWqEa1R4KD5EB3Vf8zd/lGBx6E71DD6LyG1x4/NLzcgVeuHSw/fS5B2evzvibP/Gk3HvFbzg5CcVvqL/6TfeG5V78Rc3rtw8VRzaW+V9/5n2MAxw+qci3AidXNW98/dfQXX0lUbZECBWhvEFqIW3OYuKT6GgN7UuMG9Nmiymox1DfQAUPySFCvcDVY0IzJYQSFaZ4t8A3M7T3lCVc3dJsbcHScsL+qGJrD+6+I6MqFsxngRv7MC8htWBUm3gWG0ViA9ZojAporSjrdrg8NmCjgLWaqgwYDVUFKNg8ZMmGG3Q2XkWycoZk7S60jQnllKi3jLERwVXYJMPGGTZOD3ILTNsz1walVTtPf7CSTmlzkAXQZveH0BbmaZcBhjZZ7mZSYF0RbjyO+vg/wj37GZQK6DRqu8bGQKgJNNA/gjvxVbhjvwt6awSlYbGL2j+HufEr6HwbXUNz40m0d4TIcDUx/NLOjEvaoQ0cWolJOquMpjXb22N2RjVVdZCDCCijaGqPaxTe0QYoRqEMxAfxzXI3ptPPWBl0OTrMWFo/Rpr1aYxCa4tTEbWH0fQSTVPjUERmQF7n5OWUebFoiw35Bfmi5MIz++QjRTU9mCrw7bHUUeBHv+MkxSJm/a6vxu19kItP38w6DC9SfvjmV5775NmtOT/wbx6Xe7D4DSMnn/gN8ad+7x3h9Eb3JXv7L/b4yPINdj9+jb+3peiuwc5OQA0VaPgLX/cn6Q7vIu0ut/PfvkJPPoqe/dzBLnc9lF5G2WOQnUabDmr+OLreurWcTSmFK/ep69lzvWAcTb7F/t6Cea6YLeDyFbg+0hgT6MWwqAJLXdiewbhQdG2ga6EJ0EmhCJDHmg6gc49VgcgoEgM2giTWRCYQRxrnAsF5lDLYOCMAk2neJhcaQxSngOLMG95JunEfWht0lKJsgrUJ2rZz/ybJMHGCNhYTJZgobi9271DGtJn7oV1S17ZKBwc6BHA1oanb41+XMLpO+MQ/pzn7IbQJmG4HFScEV6Fs1E6D3PF1NC/7fajesH39W6kFHl/XuHxO2H4G/dn/hHYeppegGlG4OU92ezyTGOrU0Ek3mC8WKBRxt8siTLi6e5m9UcV8FvBNe/7UB9M4nnb4XjWwcSyiahpGO6ENHGi3UjApGBtIIkXTtFNBxsGZYxucPn6SleUjNEpR4bEhpijn5NWCopwzLSZM8yk39reYjBtmE0+z0KipJlQBFSv+yjug6xzH77Do+LVcPFffNiVw022fvSA4uLqX8z/++GflXix+3clJJ35d/ZG3nQx3HeqSJeZF1/A/v+Fvd+g7cthQXb3E3/3kNpVtE/d8F0IChw8H3rrxGl7xmj+OjTsYazHaElyFvvjXUL7Adt6AVhNI7iakd6CmDx3U7S9RzahdA68ghArXlLh61C69cw03dkrKsuDiRbi+0968I9v2NkdO8Uxu2S0djQ1EXUUSad50xNPpBN73BMxCANcOJZugyLRi1cCdvYDLoWkCjW9HAaoGKqexWlF7xc7c0Y8CDx43GBxJHOgkitAEDIqmUfR7PQbDFWxvmai7hkq7mKSL7qxj1+7G9tcwcUaUZCjTtspKqTZXoJ5ixo+iRp8BV1ItcszL/iR0VgDwVdlOFWw9g/7gX6e5dhmdxagkQxvbvmfGEJRH3/HV1Ge+ATVYa6Oag5EPpTS+ce1+A4sRfrZPuPAp9N4zNNc+hV+MMUmffeV42Dr2uwO63Q02jr0FX+dErqIorrJtblAYg/cR4/ke4+kO83zRLn8sA7Oi3Sa5nEKvE3HnmWWmkzmXLs+pinYXQg2oCDiYCYnSQHDQsQkn7znCfLZPPp8zn9asZX1OHFtjdeUocbZCwFJXNdd3zvLE1afZ2qooZ6BuGNBtaeR/+idPM9nZZf3ofXTqD/PY068FXpAc+LzA4PmRwPa45M//00fknix+3cjJJn5dfPNbjoYTax2OrKQvOqz/Yo9RsLF8lR//6A7n60DQ4GM4srlCqff4is0lHnzl9xOnm+jgIO60w97VGHX5R1DmECrk2KhHPXt/mxFYlujsOMquoSlROsZEh6HZIYQRdXGVajJhrl+L6R2nnD7LbP8Jtq8XPLuneGRbs5UH4sRDAjprd7f33uOdYklrTh3xXM4Do6mimim8V5gogA9EXhFHCl0pVrRi3dp23tkpisoRXCDDcTxWrATPZhJIaYe4kwSiFLRv17lbq7AGtLXEaYI2BbpjaPrr1L1lWLkbtf4AdFaxnWWiwSpRkrbHyDcQGnRTot0c6jmqd4SQDtvtgbUB1+Drsp2cf9//QfPoL2L6y6hEo7Ru9xGgbjP+h8fx930L4dD9qDh9bsOg4Lm53NCVJc1kF3f+fZhgCeffT3X5UXyjiYdHUDpir9zhoaTkbF0SDw9zz5mvw8QrECp8uc+8Pse0voayqwQiqsUOppkyq3O2pjPy2uE9jCeOYhQ4fbrPcHWJC5evMh411Dk0ZZt4iQ7oqD2mRrUbFr7pza+kbkqa2uGdQ9l2mmNRjpkXBVYpmqpgkPRZGRzi9Pr9/MiP/Sccnk4EUTfww9/97XTNJYL7BbI7/wiP/cyjL1gm+FJ5AjAranYnFd//rx6Te7P4r05OMvFf3Xd/1elw75HeFzW/f/PxsaPXqfKc//1TE/prmtjAfh0Y9ANfvXaKkysxZvhm1PCNhPRQ+1rBo6oJTM6ii/OExQcx6Rnc/D1o5VE6oEIX7ZchXkLrBG2XCO4G5eJZZjsL1Oo7KWtQ2pLn2/y/H/s0j1wu0FGgCIpGtwl/3rWZ4j60baW2kJjA4QGMmkBeq7YXbMBXGl+CihTBBoyDyAOlJuSwvFDcPQ8sh8AwDnRjSKKDpDMF1gSGmxoF1AuwSUo1WqCVwlgwOhDFCpPodojeKkLlUZEiPtGlXL8Pt/FaosP3Y2yM7a0Q9ZbaNfoqtKMBioPqgG0Wv2prAbbb/e5dgQ//HzRnfxmVLKP7Q6Bq9wjwFUo7VBQRhkfxay/HL99PyFbagkEKmskWxdZZytEO9f5F+mqfLApUO4/T7HnqGRht0b5B6fZYTrsZjy9nnA85cwUrGycZ9I+TxctEUcK0uUZZbVPVU2y0TCc9Aa5mMrvM9vgai6ZgUZaUZc1s0lDO4GUPHqepCm5c32Ux98ynAedpl4CaQJwFklRRL+Dee0/S6/XI8xlWRyRJSjcZoJUmoNq/PRiUtjhX84vv/0X25wo9stjg+YNfvsrXvfWNuOl59vK3Mbrw4duuiPA5AcHtD0MI3BiVjOY1f+PfPyH3aPFfjZxc4r+aP/zW4+HkRpfVfgx8cQ0/wOlT5/nw41MuLmX0spMQNDr2DPNnef3d34POP4lSCZg1lErQboSyGaH4LKq5CGFya6hbqQgT3YWKVjDRAKUMwU3QStOUlylml8gnGrPyBioGFLOzvP/h8zx8pSJKAnUXmo6mGAeKOcQd0DbQ1AplFFpBU0MoAmsdcAYWvk0hUOFmsZ12eLrJVZvlHoHWgY5XuJliPoONWnGqggGgAyRBkdnAyqrn7i9fI1vZZPLMRS59Ysqgv8Ty0SNkR+/k2kc+wfTqNXrdwNIqJFm7gMHYg+AhgpAprjUJvTOvITv2AGbjHrLNO4mz7CBJUGOig6JBAIR2vT+A9/jdK7j3/l3cuU8SbILqr2DShFCP2kz/gwBCJzHEMdPxNtv7C/b3G7KeJoojvHdUeSBJ+8RRStRM8HmJn3tUA6GC4ANpDzQKYyPqmaPsxjx795DHmjE7TcXy6jJxkhGnA2yataMYkcViqKoRIUAarxKbZZqmpKynLMopo/mInfGI8W5Jr5tx5q4zNIuGa1sX2JtPWMwdVXlzdQZ0++B9m/z3hjc/gK9L8rLNTUijlE7SQZsEj8ZoSxz1CAF+8l3vInfANcXGkuLPf+1b2Xj5dwAlWx/+Bxwc3he0/bdNCNz2hfGiZnda8T/JaID4r0ROLPFr7pvedDQcXU05tdEFXjqx74WBwOnf+/9HWcOnH/2XnNt+H8u9UzRuzB2dU5xYO4OaPwXNPsrvo3yFMgNUfBeqehQV5iidoXTW9mhpAI82HbTpo0yK0hG+eZZqcZbFJEYf+06CXeLKZ/4VZTXlY5d22SpqfAfqQcx02xGcJ1uGfl8TxYZetoJRlkVZkVc100nObLemE2DY0YwaT608RoG2Cn+QfV+XbRDgCkVo2gYzstB3UMwVs7kiahQbBayhWLIwiGAYG1aWO6i6oi4qjGlYPhTI+gaXG/bPl4S8XcMex7C+CVFqSIYZ5ThH4+gOFDrTzGwXf8/vxhy6D0VJcf2XqabX6R59Pdnmy8jW7yIeHELHEdratgog4PM54cn3UP7Sj9KMJ6ilZVSSgnI01fxgfwDaZYCRwcYxJo1BObYu73L+6ZKyAaugl4ChLbYUGcC1NREi224saK0mOENwbZEeqyxBV2xpz/j4Ua4NFc/Ot+gtL0E3QkWWKEoJBLQ1oBypTanrMXhHPztBGq2Sxks0vqFqKsaLHS7vnmNv+xobm5usLx8nz3N2R9fY3t0iXzRUNVgLUWRJsi6jG1NWlpa4+64jjCd7OOfQyhBFUfteRhGRTeh11vnMMw9ToslMzqO/WHDX4ZQ//21/ic76GapLP8P+M49/nryA53+hbgJb44Jp3vA//zsZDRC/tuSEEr+mvuv3nAon1jv0M/u8RD54LrHvuYS/5x6ffucPoKzlP7//O8jSE/im4YE7/zhLaoaqdtHFlYNNbUq0n6OVhVCj402Un6Gi5bbqXf4ZtB1grEOFMUopmnoH/D5q9b8hrP+3ONfQVDnF7AajCz/Pp57+JFfKPSZaMfMRo92S3qri0Gqfld6w7UrTLiMDTV3X1FVgXpYs8hK7qDhkAxcv1HDUEg0S0tiCcjhXUTcVTeOZTQOLvUA11fimXdZmdaDroJwr5rlCBzhuFGcSRTH1hFqxbA2ZVfRTxdJyysqpTazKUTRYP0WZBd2NHuhNxleGjM8+hXFTOoknihSDu+5CN3PcaBt/z8txRx+kLq9TLy6wd/08072Co3cEOstHSVdeT7L+GpSbg8vRyQo66qNmc8rH/jP1Zz9Gk0PTgOlYdNRWzKkKcFX7vmpr2tUJBqJORtTt4kPFeHfOjfMl1A7lFfYgCEoz6K13MMmAZjIBZXHzpq21MFpwPcAlwESauJ9x6BWnmKw4zi6us10sGK6voawmKI0xlshGaK3QVhFpTVNNyYsd1nvH6CQbmGQTZQaEAEW1x874HFs75+l3l1gZHmd3ssVoMmI0npLnFb7xpJ2ELEtpSs/OlTmvfv29WKtY5Dl5VRHp9v22GnpZj4vjHVCWfLHL+Ucca1HKn/9vvoFeukHv5O/i+vv+VntR3LYk4CVWDkKA3Vk7JfD9/1JGA8SvHTmZxK+Jb/3y42F9ELM2SNrGH77AUH8bGNx7eJXi/m8hVDPe+ys/RLx6lFfe+b0kWZ9o6yfx9ZwQUpTP0ToGN0H7XRR12+AbgzEJKumhPKhoHTp3Q3oU1T0KJgHane2cq6nyKa4pKPbP8tEP/Ag3jGdh5mznMfOqZnXNsDZYJY0yYhuhUJR1ySRfsCgKirKm2+nSy4b44CnLOXEzod9JqeOU6aJmbzQBILYRUaRJU01kNSjNYtawc7VkvNvgyrYkr9WBrFaUC0VetmVp14CjjcIVgRTFoX7gvrs7rB8f0F3rUk1y9p7YYeXwMmR9ds/uMN9uyx3211ZYOrxMWEwotq+j6gVZT9Nd0nitmC0lqPXDRCt3kS6fROkcpZr2vUk30VEH5aaAg6aAusHNbtCMd2h2r6HnNcX5bVwe2h58pPEq4FVodwhW7XA+TqENZMtLxIMlmvkck/WIOhmgCPkYnEMbSyhz/LwmOXY/oa6YfPYRirzmch041yiWuobaBxZVW/N/6gJBKY7eN8Tc0+NZP4fEYpJ2dQLGgm8ISmGMRhlF0GCCRrkC76f0OkukySpJNCQ1yzQBKl8ymV/FqgilM/ZnO+yNtynKHOUDWZKSpn2SuMvOaIed6yM2llc4duIUZbNge3SDxjWUZYlTgbib4qo5N24UDMcJ6/2Y7/7Gv0rc26S88VH2nvz4rWvoeSsDXiQayCvH7rTiL/4/slJA/NqQE0n8F/sjbzsZlroRa/2YfmZfsuG/famfAu755ofgodczPf6nCF5TuYY4Sgi+LU1risttj7J3DG0TvHOgDdpE7Wvc3MhFt9XjMG3PzzuPtfa5pKqD+vZVMWZx42PcuPBzfOpajlmZM9eaWVGwurpGYrtEJgX0wWu3xXCapsYrhTERRltGsyk39q4TxxFZrBloUHFEERQuBAyQVzVl7WjqmijSJHFEbNv58kWZs31jwd6lhmrRBkIdHYgrxXimqRyYoOg7GBZwKPEc6sLh9UAnial2aiIVsBpyD7sLzf5eYDWGYao4cpclzCN8Ds284tB9x/DFiFDMiLIItZHB3W8mWhqgdYnqniZES6ho0L5prkDZuE1kwBBcia+mqHIPNX8av7hGKKZU185BVdGMI2YXKuqpwhcQvKKaeJK+wpVtUp+N1EEBJM1gY0hy6AjxxiHiQ6cJ8wn+2pMU184x35vSBFCJgrjNoYh1u6RQm3Yp381diOsK8hxGMzi/UGwNDOFUj/nA0mSekDqwHqL2nAuANjFpkhHFXWpf4poC7+YondNPI/rRgDhewcZroFLmxQ5lNSFOV6nqgqpa4JqaomnQwRDHHbRuaypMZvvs7Y9o5o7VjQEXd7ZQODwGEztsY4knmtGo4G98+/czPHwvTne4+kvtaMBLFQ+C5yoJBg97s4rxvOav/EupHSD+y8gJJP6LfMfNxn+Q0LvZ84cvOPz/vT/2ED/zR0F/3U/iqjleGQC8azA2bivZKY2rFm19eWPQSh/UnQ+o23az07eNKCiln6tPT1tv3zcN1WKPcnaV80//FE/sX0IPG2aVBlWysXYHRifodqU43jftxj1o6qYtCmR0zKVrF5lXMzqdLoPuMp0ooSn2KfJ9dvKa5dXVtphQ4w42wmkL4njfVtyzRhFZi9GG4D07ezMuPT1hvh8wB+2dKjR5CR6F8dCtFYerwL1LirtOBSbbcH0nMMw8Visan+AqRVHUzOtAquHEimJ9rcP46hzjPYOhZenMy1n6fX8KlWbUFz+Gsx7FFtrGmKUHUL1jbUvtaoKr8fk2qh6jmwmmuYbx+ygqVKghVG3yHwalY9Axiqj93PTAzw+KDFl8M8U3BcVon3Lu8GVEuVeiVUaYLUiW+8TDAUYHaKY0lx7BFznR8jrxkVdADYsnPkSzKLCdHjruoqOUEEpcVRBlKXrQJ14bYlYMVx99nMsfmbC/G/jlYLjW0YS+IltWRMueqGuIs7T9Od1OwxhriaO2/HPtCupmgtUFSeLI4h6RWcL7hKYx7F3dQyUBlTrSyGBMROMqQqgpm5yqDm0uRGiDp3OXt0mSdtrI1ZDWCfXVitecVLzjNe9gcMfXotJ1tt73d15yCuCFgUHjPbO8YVY0/AWpGyD+C8jJI37VvvMrb2v803ZjlBeb57/VOLef8id+7GHe/Yeh+Nofb0vu6/bm68p5OyQeZ7h8hEmHmCghENpSveNn4fp729792pfD4ATKRqjgD0YF2vTq4N3NtHv07BxlSNm98EucG1/iYnmD/lpCXpUknTXSZB2tIhSasiko6gVlnROCJzIJTQicvXgBj2dtpc+wu4Y1CYmNwJWUi21mrmCcV5S5ZzhYYmVp0CbPOd+WG1ZtMBCbCKMNkWlHJ3wIjPMFZ5+4xOhKg3GQekVZKIqm/XoaFP1C0ysCpzJFWQUsikQrSgfjOtAET98oVqJAQiADlvuGQapYOn6CpfsepNm9RHXtIiu//0+Am8HSYczwCCpU4HNUugy+xk8uE+oSsjVUPYLRR/Czz6BwBF8RQg4KbLSENtnBMsIYpVOUidEmPig0FEBblM7AdFHREOVmgCfoIXXVZt2XYY3QxOgqx1z4AGFyHTztss2sA24XRYpbLAj1CJcHfKmIsgzTO4SvAibzxF0P9YSwvIQb7VNemzLfhcUEtrYDFwvNJ3uaaqhIVyzdjQQGETbTWKuxsUVp3b5dxtCJu3TTIYSGndl5GtWQmLZccqRjwFC5gHea2SKnaUoiCy40OMCaBKUDZeU4d65kfS2jdiMmNyCtNb9707H/mOIb/8SfIVp7OSYZcP09P/jcxXXbkoAXCwyqpg0C8spRVI6//C9kNEB86eSkEb8qf/T3nAzDTsT6IKGb2i+q4W97/g/znvfA6Im/SLz2AI6EcrpNsnQYjcf7gE0y1OQCvn8CrXXboBcz9M5naPbPYw69ErN0EtNdITiHq9qqfdQFIR/ht59Gza7gZtdZ1DXXr5/lnHVcVo7jd6Y0WLx3JNlmuwEPmmkxI69KPJBGKVbHXLx6CWUbNtc3GXSWiUyCQtE4j/ceV82YzK+wX+ZMi0DjFL6GLI7YWFtBodBKk8YpVhvMwXCI1hZjNAEoXMneeMLlp0c0i0BaepqFZ5orKtrM+SMWXp4GOh6ahWK2UMxKcKGtLlhUnlRBAmQEVuLAsc2Ywy+/n+z+r8CsHUcpMPOr6PnThP4y5uiDmGwJlQ4J9QK/+wSYlNDMabZ+mmp2Dl/n7UaB0PaWD2ogaE07r67bIXWta7QdYJNDmOgQ2i6joiXQEcpk7ehNswdujFIGTAcVFgTdJUSb1NFp6jDE7e/hPvsemmc+Q7KxSbn3aeLNQP/+d6LTQ1TPvheTJJhowOLJX8FN5lhryU6/hmjjFCrp4OfnqSeXqbbOU88amkW7rr8aw3gHdgo4n8DcQhk0emDprWdsnFqiiDRzC42CRZNTeI/ShjiO0Sq0I0RaESc9tDYHI0UeQ0TwClfXuCYwqwqKPMdNA0mnQ1nWzF3JzvYe+bzkkEr47970cs5+8uO8+t4l1t78A1S1YnjsDJd/7vufd519TuN/23BAUXvmRc2icpS15y9LOWHxJZITRnzJvuvtp8JSJ2J1EB/0/D+3oX+xYOB7f+wh3vOet/DR//3DvPa7/xMezc6jHyI+dA9Jp0ucZrimbDe7CRwM4wf05Fm0rwjDu9pqfk2FG++grn4a/9T7cdcuE8qmLTzn2oaqcQZXeuZVxCPLlic3Av2lkpWNHnlREHWXICTU3lHVFRhNGg9J4wFbO5cIqubw6jHiuIc9yP4PIVA1VbuKoCnYH11iWs8ISmGjGB8gzz2LRcUgXubU0VPUYUblKqw2pFGM0YbYpu1GPCpQe0dRNxR5wdblfVxRstipmOxD6dt57zUFvbliyRhSFXCNZr5oUEEREegb2LBAGRikgfteEbN69yqu+3rCkS/DZH20z9GzZ1Bpijn8ynYnwMUFmH6WUOzi3T7F3qcoFzneKarC09Q3G/1218KbM9FKPRcQEJ7LubORwsRgk4g4PQVUmGQZ23kZKj7cLsVUDtWMwFcok6D9iGC6eLNOEx2j9kPqR97D+EP/BvSC9FAgsilx9xBRf4A2KSYaoHVFM5qB6hINUqIj94BfQHODZucS1e4VfDmlnFb4sm03mzlUE5jvw24JT2eaxkK3E8jSg2JOiSFNLcPNu0jXHyA99eXsX3uI/b3PsjO7zLSZEjoZXkdom1JUcwwZy+kqWhlMVYF3VPk+cRShtaauHFc+fI13Jo6PfnjOJFF8xQ/+aVSYYCnonXwbKEuwPaprH2T81Aefu9i+wKZCedkwL9qRgKrxsqeA+JLIySK+JH/s7afCUjdidZDQTcxza/t5qV5/+/h7fvQh3vsP/grnn/hhVPwm1t/8x2kWZbtErKnRcdLuL681evuT+LVXt0P7N/eun+3QzGb4T/x7zO5DhKLGxEN8A8FpiBQ+eLwLqKgdNSinBZNRzUOnMp6Nc4ZrDdZA0Ipg0rZIkElJ4h5ZNmQ02aFyC9aGR0njPtYk7Z7yocH5QAiesspxvmaRj9gZXyYYjTYGaxNAURQNReGpS8eRzU2WlgYUVYF3nkgbIhMRWYM2BlD44HDBsSgL3ERT5RU3ru2yf70kL8FEgbtXE972ytexuX4/NlnDpP12gyNt25yH4GGyy86HfpokPMnKoXYb3+J6h6Wjp9vNe/oDwrE3EB99Dba3hA6O6tLPUF35Z1TTEeUC8rRPWDtF5UucB5ssEfWOEZQC00OFGt+MCPk2Zjai2tnFjcZY5Yiidt28sQfngQJtNXHkSQdrpL270L0HUaaL8nO07bS1d5tddAiEaA2f3IHTPcJ8j+lH/hXTxx8nHgQ6m4pseZUoG4LvEvdPYNIByvZR83OwtImK0luRSHPpM5RXL+CrGhVnhGZC8A7vSpq8ohkH8h1YLOB8qdjuJXQGCStrPZJugo00ZT4jSVN6q4cY3PX16O4hqmsPMb/wM5juKepZSWRTVKWZfeQXWSKwfGKFam8Xay27H2vY/Ia3oSaPo7OI6GVfy+M/+CP4AVy8plgYxWv+zx8glM/SO/pmrK9xOsGZiNFH/s+Dq+3FW/8XlhGeHwQBZe2omsD/8M8flfu6+KLIiSK+aN/9jtNh2I1YG8R0YvsFhvufSwD8nh99iJ/863+AcnaFy+enbHYKDp34PdSRxb72a/CuwbkGFRzaRIRqhs4GhMbh8zk88R6aj/xzjOljBj183RCcAzdGR902Yz3qEeyQejGmHl/G146yiqlWlvlwZ8z1uELrBh0g7cHy2imWBqeJcCzKMbvja/R7y2TpAGsyIhOjUNSupmpKpvkOTVOAD8RRh8lsm0kxZdAfEEcZSinqJuB8wBMYz2fUpePYxhGyLKNuKlzd4EIgiQ1GtwfOKMO0nBICLOY1rlbMdxbMdwsmY0dkA689vcHb3vj7WRocRweP1hEq6oAyzy25Uxo/3mb6yz9Fr59QbD9MfqNk6d5TxPd9LXppBdVsEW++lmh4nHz3szz58b9F128xC4EqU9QAJsID3mhq71E6I4mXQEckyTpJuoaNum3yoLJtOWUXsA786Bxh+xH8aBdfNygVMEaRZYGsq4hSRdS5m2j4VhT6IKEvQzUzQlMSVNYGM+kRmG9RPPGTxL2IZHCEUBUoAvX+DWxnk7i7jLYKlfUJdY5SllDOCPkIVIZvAq5soHM3wQ4IxX5bLclq3LX3Uu9fo57C9Grgah0zWlklWVuhf+QU3bUTuHJG8CX16FnSTkIUJTT5DYrZs/Q3HiA0BpoptnMY7QdUH/l39EtFEnuyI4eYXrhOsx3I7r6PzokjFBfPU+6e58kPe7JVOLerSU9lvPx/+bv48ZPodIN04z6q0VU+8Av/P16xeuLWdffiqwOe/+Qsb1iUDUXt+XP/5DNyXxdfFDlRxBfle77qdFjqRvQyy7AToW+r6vf5Gn+lYPzZR9g43mWRvoJlf5GlqWNx+QbRN/5N/Mf/Pekf/KvtXGoUgdYo53HOER5/P9XP/19Eg3UCGnyJW0yJl08S0goowY1Jjw7It/aophYTDdG2hzn+u9j/xE9zxec8eTJhHAfm0wVp4lleVaSdFTrd01RVSVmNWRkex5iEEDxGR4QQWFRT9qZb5NWUyFhik5DFfaaLPfYm1+n2MtJ4AAflYCOTtsl9vsEFx2QxJXhYXzlECOAbT+VKrFEkcbsbog+OvK4o6pp5XhNHCTo0bJ+bsH2jpqcCX/fau3jtg19L3DmGjVJMNkTZBKUNQRnQEUFpgvM0dY0vF+RPfYji2mdJ1zdIVlZRJtCUz7A/fYzt+ZhFmGOtIS+hrhxxBF7d3NtAk9eK3EF/uEGvf4Qk6RFFMcYYjLGUxYiy2MFGA7LuEeJkgNFRWx2PlGj3HIsnfgm/KDAW1o6s0l/eIO4dQZkBTm2iTVu1EV+BKwnlPjgPOkH5Cje7RLn9EMt3vRE7uK/dfGi2Q33lYUyUYnuHUZ3j4GeEegZlAU1B6J3BF1NCPoN4GXQP5yCojLD/FH7/s0CFn2wxv1wwrzTTpcM0d96H7i6h4w7p8lHQFpt0caMLVDufpZ5faas7+naTpCSxFIsRda255x1/md1/89cxN6asnThGdvgexg+/DzdxNBPN8N4+i/05finhyi/NCV04v6d45Q//WdTSMfIL/4HOiW9gOjvHhx/+l6QbU169eO0XfX2GEJjmNXnZ5gP8WQkCxBdBThLxef2htx4PvdTSSQy91DLoRGSx+dyGHl6k1C+cijosHvskZq1Pfex19HLD/gfeRYgjTKdD563fCUmNfcXb0Magjabevk7zb/8cuBQ16FOPtvFVSX69Jk4U6fEuwy97J356Ht1YPE1bI4CIpO+p7IN4eswvPskT5z/C48cNu2VFXS/Y3FCsrm7Q799FUUzBGHrpEXxo8L5Ga0PlaopyzKzYZ1HM6aZD+ukKl2+cpdPttzXnqcm66xgdEesEo2NAEUKg8SUueBZ1xe54RJrEHF0/gqsrqibH+4ZO0iGylsY35HXJpJgzmuakSUIniSmmJTsX5mxg+aZ3/lFOHX2QTnUelR7GZccgWwZt8aEd7g8BXFXhmhrva0LT4Os5Pt8ilLssFmfZnr6PQu8zHXl2Ru37po1ldXUJowz7uyNm85LatfkHXoFTCqxBGU0cx/Q6Q7pZn153mSzrEccZxhq8qwkhYE0Ha/toExPpjE5IcRc+yOzcr2CpSTuBznBAb/N3E8VdTMgJ9QydHAHdJVQTcB4VGih3oB7hJpeJ+3egWCY0ljB/GqP2yJZPYrqHDnr2GaoqCE0J0ZAQYvxkl5C3K0uwGb4qqHdv4JsxJk3RSlFcu8J8FKjWT1Cd+XIKn+PKMSbtgslIh6uoakIzfZZi/xJt1cMF+WSfsqqoK+hkcGNbsby8xOmTr2D/3e/j1GHD2v0PMn3i04QqUO4GNr7lu6hVwrn/+e+jDweuXILiENzz1/8HZuf/DXpwHzu9mO7Ky/i5d/9t1jYcX+4PgoAXGQV44VPeB2ZFQ141bRDwjyUIEJ+fnCDi8/qut58KndjQTS291DLsRs9fd99++jm9/oM0QDaeeZim0KgNR1qssPvkHkEpQgpNqVg9egQ1u4b5s/+UbHkdP9li9iPfQ9ApylpcM2sTuVzAZrQbx3jon9Q0U4+vFU0DAU201KF3IkXFFZOrc1x1kuYVr+D91z/Adjkj7dYcXt9kODzNZHqdOOkSx0sHKwEOGu+mYVpssyjGOF+x2jvJ5WtP0+ia5cEmg846k/0nUVFEki5hbYc46uCcbzf/0YrGNdS+wYdAExom0z2W+8ukSYeymuF8jVKKJElxrmFezRnlE3b3C9aW+qSxJdSwXvd5zYm3cPcDX0fSXWt3zDNRWw2HNjci3AwAaIeKvWsIwbdTJMHjfY2r5rh8l8X0UWbuM+zXD7OzO2Nvp11qaCKoa+hlEZlN2N0uGI8dJtOYNCHr9kmzPv1OO/zf1AVRnDJfTLDGUpU53hWsLB+mkw2x6RCcQ6mYKOphdEw0n1A88W7c9kWiGLIMuoMuaecQNu4SpSdRdhlfjAmuxkR9qEYYXWHcRUK9R3zomwh5TrPzYXx+mXhwHKsHaFehiAnVApWuo3QKZYXLc1Apbj4mhBqddql2LuPyLWxngLId/GyPxaiiOPIq8uUTmHu+HB88zew61WwPYy3JcBNXTqi2HmJ85SGqYsZ07klSi7XQiT3KaeZ7JdMJpMpy/PSr0A9/nM31gMsDvWN9dLRBvXuJzuv+AE/+bz8O65Zt13D0+74VOmtcc7vEg0PM55eJ4iUuXnw3949Wb12LX0TRYKraU1SOvHKUtePPSBAgPg85OcRL+o63nQxpbOgmbQAw6Fiy2L5kr//mx4O6fygFS489hq0bph2wNwLFPNAETW01mXP0uxAlkJxKsH/oX9K853+hPHeRYm8frcGFgF0KRKtdip0SN2mwSrVzy0NDU3nqIlDlgbpWmMTQ+AAGQjxk3xacuzPhajNlbbXHobVTeGeomglp0kWbhKAsdeMoyymTxS6Nb0jiHnXl2BvdoDvo0c36pFGP2MSMx+fIeut0sxUi28f5QONyoG2EQwgHS+faJL+8mlGUM5aH6wTfUNU5Do9SntqXTMsZk0VJWSgOLS+RWMWq7vCqE1/H6dO/hyTptfkR3rW1DqIOyiYH/79AW3nxZhKkawMA79slEb6BULbV/FxJvrjBuYv/kRvuY4QQGG9DkcM0h9m8TeI7vKHpJDCdwtWrgek0EFS7IiFKLGhNGltMZEnTBGXapZOdNGLQH5JEEUmyRK+/CaEhNAV4iF3AX36E8plnSEyg14Xh2jKd/glstolRCQoPTY6KVzCDOzBUmOIs+YVfZPZ0idLQPdGjd+qN6GgTvfcYynSgidG+JjQLcBCKOW4xwedzXFHi8QRV43LQkSJeXkPpDL+YUJaexdoZZt1N8tLTdNcp5tu4aoaNLNX0Oq6eE2cJw0P3EHfXwCTYzgpKW6LuGsYo6t0LMLqK2z0Hky2qnTnKDcl2n2KwHEj6A8pZgPGE7svfxCxZ4vp738WFr/gyrg5HHD10mrpaUKNJkwHHD72FYnEJ/Yn3PXdRfp5qgQDOtwFA1XiqxlPWnj/9jx6W+7x4UXJiiBf1TW8+GlZ67XB/N7HPzf3r24f5b1vqd/Dk7UsBh59+HGsaGueIopTtcwWTQpEM2/XyPRPIjKKzDNk3fSv6gW+m/Mffzmxnjg4NQSvMMNA0iqAgWetTPTsnTX27kU7UThn7BvIJBKPoHDfsXnCs3bNOd6PDtaeusXv8KE/EFb1BD2tjpos9up0eSdwBoHY183LGopiiVUy3s8rW1rOkWUyv2wcCSlmG3cNs7z7DaLbPnSdeQSdZJ6hA42vyYkTAo3WMNRGE0E4r4HChYjLbI7FdBt01Zos9FvUEr6qDpYANdQVGaZaShOPpPbzizB9g/dB9RDZutzYODup5e2BtB2WiW+vw2oBDQWhXKnjv2+e8a4OA0AYFBI93NU1Tcv36Jzl7418wqm9w7WpgZwuaqq1WuLoMcQrdHvQ7mrJQXLni2N1tax1oA57Qbrhj9MFHhdFt3f2bpY8jE7OyNGRpuMKgv0IIjnx0jXhvl/j6DQ6vBeIIjO5hoy5xmpJmy9j0ONoutTUGuoeIwi77H/lx9j8zI04gXYV0BeLEYDsdjMowehNVl/hiD+qmzfqvynb+vxiDcSirCC5gkiE6HqKw0FmjXDpDceRVhMEmIc5omppytktx7THIemSrp9BJhtIxSiuUidoqk74BwNgYk6To4PDjG5RXHsXNx5jhccx8G3/+V7C9owym58nPfYp6Bs5BXQVcx7DyP/1brjz1H3h49FHWN17JOB9zYecRTLPL3UcOcejZI1/UNXuzdlBRt73/uvHUjadxgf9eggDxIuxv9C8gfnMadiyR0cRWE0eaNDZorZ7X0L/YkP/t9f/LRU28qom+6X+j/NG/SFMp8kW7650FrIZ4I1AWis69XwdNRTGa4+qGkClCDxhq+qdO46sJ9TO7dAYBFdryv75U+CZgoghrHEEF0t46ne4W47PblBcVF87D9jM3SH53h/Gi3TLW+0AWAkU5xgdH42vqumLYWyPSMTe2nmZpuESWddt5bZ3Q7RwiuAqjK04cvf9geDtFa82iHGNsRNOUeF/iDW2DyMESPW/pZEvt/Lyq20ZERVgLgQalNIN+zHq0zN3Lb+GOe99Jp7cKAYxpe9xKKci6bR0E36CmF1HVFNc71QYECtqCwwqjTbsNMYrgFQGNUm2goFSMIWFz43X04gHXdt5HTz1GXWyxuxsoSlgU0HgoK0WeazY31nng5REauHFjyrMXxlSVJ+i21LLybQhYlUBwFMC4qVB6wfa1KUl6nU4/pt/PGPQ62NRglzPCKKdXB/qDGYNVizFDXLCEckwUAlp1YLpFaJ4mGZQkkcIYIAdmQKbR/VWiI1+Bn16kufgIwZt2hiQ4lFGgG6L+EDM8DN4TygV4RSg99Ndp7vhK1Ok3kGa9dojDtP+8P0pz8gzh5nugFBAITYUr55DvEPIdnPN4lWJWTmGyPrY/JLrz1RSjXerRFpx6A9Edb4btc8x3AsV8Rvn4WbI1iJZjul/zQ8wuPcrhnmW9+43sXPh3FKvHuWf1FOeu7eJY54X9tPZR+JzBgJvBt9WKRiucVm1wFuCvffOZINsJixeSAEB8jj/ytpPheY1/ZEgj8znD++1Hdev2dPtznY8+3BbkefUDqIs/j441delRlaIBFAG/DKarsa9+LftPvo/dR97Fhgt01/v4zgKzPGjr8e+MoF6gS0WoFOhAVal257mgKGYNZQHKwuRj18kLRVUq6kaxXWqqec3hGwnNqYYai9KGvFrQiWNSG4NKWOotc/n6s+TNPivDFfppn8bXRFGXOGqH/yu/xaH1lxOnh6jqEdPFZbrZJkncJYQapdzBKEDbEw+4g0YXajendCVxiDFxQ8eCDwrnILWaI/FpHrj7W9g48iDWtCsElNZoo9uiSO2RBQJBGXzvRNugacXNIkU335+D8QDQCoVug4CD36d9fzTaJHT7d3AqNGxEGb3603wwv86NncB4CnHc9lCjqKGs9lkadBn0epw+dQf33pVSLCY8e+EyO3tThstLrCyv0u0M6HZWiOJlIqVpyhzTzCkXFeeeeZbt8zdYJCPirqETawqbMpjl6Lki6Ywx1pDYITrqQtQh6HbTpybvMr2SonRObAy9w4cJ9Qg1U/hyj3r/F7Frd5Pc+7WE608S5jmhKVFRjI5Tgi9RXuPH1yCfQW1hcIRw5isxZ95KNFw7qHjUHuM2sTIQsqzdx6Hd0KGdVjFArLH9DoQjuKDxAVxVtHkG3TW89ySddbyO8NUUu3IMDt1Nce6nGS3OcjlTPPCyQ3QOHebKp/4eTXqc9bvfTrRyig1yOtf/If/hRgNO8ZEPfYYHXvFy7t9LXnCVKl6qNTdGYV0bADit0CGwMXzhzwshUwDiRfyxt58KaWzoJO3wfz+zZIm91cN4qSH/26cEBp94CPfG1xMdeyuLJ/8N9Xsv471i+3qgqRW9fqAzBAqF/trjTHb2SXTO0nnPyr13UE0vQvBEh4+SbmwQZTA//xjzqwUha7PUQwNhHxZXoXdYceMyVA0UjYKgiToWszbg/m/7LrKjxzh38Rf4xM4HcEYx6PTpRG0meAiGvFhQVnv0e6vENjko7NMO/WfpYSLTpS6vEaebKJPgvaOqJ4xm1+h0lgBomgU+uLZvpgA83jvyOmdezIhMTCdNUaFpO5oqsMQ69x/7Bo6efBNx0kHdmmLRt5ZT3LpIyzlUU4JOCNqCtoSDhsAH144Bh4PG3rtbUwPt0HDAB982bN7hmhJfzWiKEc3sCvPpJ3jq+if56NMjrt0IrK6AVorpzBOUYrAE/aHl0No6a0sbDLorxJGizmdcOn+NCxd3wChsYun0MnqDPlmWgdfEUUIcJ6Rxj0Qbxtef4dLFp3GuJlOB48CpZUV3uEkU9dvCSlHSVtILC/KFonAr2HSZSMfYnWuEsw+RJA5fVESdFNPpYbtddJq056JN2n0ijMVPd6EoCEWF1zHhwa+HV349ZrCKitqplHCwyRTquekUws2T++bjNoDyTVvtTxHa/QMC+KbGB09oNxOgcQ1NUZBfexIVxSSrpwmzLfbe823U9Sqz6Ra2m+BUh6S3ztmHHqc/hON3QbaUECWv4WevPcn23h57Y8e3HvnilwTCc9MAVe1pnKfxgY89tcc/e+9FueeLW2QEQDzPd37lyRDZtvef2HboPz1Ys357Dx94fuP/gudGnWWWV+6knl/HxUfY2bxC/wasbSiCUQd7rweGX73JoqzYOH4MX9cU02fIb5xHuXZOmvoybucSnTOHCYMAC7D9DEXD9PGavfOKpWPtdMHGg4FyDuOLgc1X3knvNW+le2SdONlD91/JmTNfj3tin6fypzDGUjQFSjl6ySZpUtPvHCGNuiit28ZSaYztoLTGuVFbpEgbUAqvwNiMpcEJ5vkWcdQhiQZU9RTMwVx8CDg8TVDEUY80Mu20h4noqh73rH09J+95K0mUHRy453Y4RKnnJVgG71FRSjARytUHUwt1O7evLYabBWMCQQW8bucEgmue21fGO7wrCNUcmjnK1Wi3QGlLEt/LnasOHz7NL4cxW1uBYT+QxoqigDKHJHXsjyc0dc18MaKXpfS6G7z8dV/Pq9+Qsdg+z6c/9VEuPLPNbjIm6UV0BxlJGmFNhNIKo9tA8di99xKVc3a3rrBT1AwLRdbTeN2gqFGmopqPmM0SZsUGyjo6nTXqKEId6qPWj1NQY8Z7dCbbhNku4coloixBKYPyRZss6QO+ewz1xm9Dn3kL5mCoXxtzawhdadVWO9RAUGgUymjwjnAryDWE0FZvtEmblxGaBpqifY2oQ1POAIXSCqsNIe5j4/sodq+hdUAtbTKaNNTVDSbzQOpKOv0YX8+59xWHeerR62jt0aHBqTW++vAm/6//KfYX3BYFfnFuTgMYo/BBYYA33LPCP3vvxS/thcRvaxINiuf57q86HbLY0IkNndSSHYwEmFs90+ca+s8XEOh8go4zxvv7nD27i3OKhIoI6NyAjcQS37sEh0sGx78MdMze+V/GYIg+dY3+Rkw5qVDBYhOFUw12qUO0skHQGspAmNSobpfRuYsMj/fJZznJsVN03/LN2MNnsJHB6IBVoEMNOFw14pmrH+Tx0cM0RmN1TGQH5PkO3SRDK1A0aBNhTA8dLaF1hq/H+FBik/W2xxcaQnAoFHk1pqxndNJlvC8gOIyJqF1FXi1wwbXHT3kipTic3M+dR97B2uYp4qR78P8MqIPgot0A6WAUwftbvc2DrQ4Pkv/aXQ+D83gOeqsBMLrdcAcOVgIcfCl4vKsIB7skhmaBr0a4fBtXFVTzPfL9p5i7y1wot/nk+ZKLFwJppghOE2WK3nJgOIwZ9HoMewM6qUFrh1ED0niZXu8I/f4pqEqunH0/zzz7JLaXYvs9lNbENsbaCOdrgvcYpYmLBYvdG3QXBS/fXCHLEgwF5aJkZ9cyX1jiLCPqDNDGEpqS3upR+ofvJVm/h/zyx8hHV0i669jeCmGxR//er6R39EF0kqGjqN1TQr1gyDw41MEuR4FAaBxa+fYEjrP2OHuHLidtwBcPUMYSQsC7m8l/9qAiZdUmBCpzsASzQSnVVlRsHOViQlU1FFuP88hPfB9FCbvTQBbD2gpsnn45Rpfo+hqOMUkHku5bqHWEm22z0znKdlAcu77zRV/HPoSD1QBtMmDjA84Ffubj1/jZT16X+74AJAAQt/mut58KaWTIEkN6MPefJYZOYttG6iXq/sNtwcBBBLC49iy1N1y9OmM0rTm9GkgjqCp4dhcOrcccOblEZ2mJqHcUlGZy7SzFLMd6z+DRffqHM5TWNEWgKSqCUsT9IcmZV6F7Q6p8QXTHqzGbJ9FxiukN0EYRpRlG3wxaHLqaQbNob87a4JucC1c/zOPjhyhQbSU95zGqIdKeEEqSaAlrBmjdA51RLK5iY02abLYjAaHB+YoQAs43LMox1sQHnXff1uhXEFxF40tik7CU3sXm8BUMOpskSYcobofGjTFto61Aa3Nrbf/NY40/yOKHWw0TQaGs5dYWfbQjAFpr/M3vP4gh2tHrhtBU+HJGqBYwPk+YXYR8C6oRrtynmV6jno9Z4BgdUvzyBc/VOcz3DPVCMVjTrB3tMhz26Hd79DsdCCVNo7G23ybLhUASd1ldeSX93kmunn0fZ598N8mwRzxcPfj9GiBQFzkqBAbKEK5fY3MyJTKKvbFhdxoRRZYs1e10CIFuV9NfWUWpCOdqbNJDa+hu3INNMmbXPg3KUEznnPiK76Z3/FXE/WVM1G71e+t2dzCkr/AHHwHfoItx+6UoAxOBTSG072XQBzkw6rlB0xDaqEsF3x7bpjwIztpqgQRP8A11uWA6HvOj//fv58krMJ0FVBGonOKrj8K9RwJH734N2l1h//o1euua/uFvRukGd/mT/L0fPsdPT+Envu+5aYAv5sbd7g3QrgSonce5wNPXZ/zt//iU3PcFIFMA4jaR0Rj9/KS+m/P9t3pQt+akX7rxV8D16yNcA4dXNGdOB9JuO6Qfxwr9NEzqmkvP7nDnKw7jx0+TLN1Ld/00vXWYXfsM6h0PkA3vIf+Vd6NNQbpk6N1zF2rjFXDqzWAt2XAdZS1Rtw8HS9C00bcaTRNZaBxG19j6PChDbY/jkx7Hj7yRLO7y2OgJpq6kVhXKxLhQEpkuRqXttr/1DjbqknUGEMqDfLAK5w9q07sFddOuT/ehweiDWvquJDIJadxnJX05h1ffSK+3jjUW5yqCa/C+oa7BubYBJwQCDnVzCZ/3KF+ifA06AZMcFBsyKBMTigKaui3+4xtCeO69C8ET6pLgA6rYw175ZezORZKlkxANUP0jhInCPfIZ3PWL2ABJgKBgEBTrz8as35PxcG/OU52KqojYueLYrwqG9y/RWV0my5bRuqYoFkBGHHUBj/M1N7Y/yXj6DL1DR/myO36Aevws587+AqUviHsDjIlI+xlNlVNWJdFwhet7nupqjfeKxrVLH2dVjbWKfheKWaCYLfAO0ixi/fhJCIbdcx8nBEg6Ed3V4/RWT7HziX9Ode2jrL7yWwjDY5gobndABLS9mdVv25wLFVBEhChpgyXvDoIxDehbSYDeeZRyoFQ7QkNA24PXVQkmisE1uLpEedfWgggNkZ+hcawctYzLGr8K9ZYiyuE9u/DZPXin+xTHT22S9iwERZpmuMnjfPLJZ/iZmeI/fN9rvuTr2RqN9+10kA+KEODOQ90v+XXEb18SCQoAvv0rToRuam/N/SdxOwqQJZZuYtqa7S9o/F8YENyesHbp0Ye5+x4wSTtNaiJFXYKNIB/DM88oVAq9Psz2I+5582toqpxqMSLtdFi+/w+Sdvp03Dahcww6S2ibtoldhHZo17TDu9ram79Bu0TOVe3N18QEX7c3dEBHCUpbXFMTXI0H6qZgOtvmsUs/z0ztE3yNUQGNgaCp6lnbE42HEByOBpRth7HxB3X/AyGodmMcE6NRpDoj29/mg+/+JHed7DIYLJMNj3Hivt9Dd/nEwTB9ILgK3+QQ6oPtbHNCqAiuBB2hdYyioS31Y1FoCKYdvnbtev92316DMhlg210UAbPYRj36LsJjZ9F5QCtFNOyglSO48tYMQwih/ejbugoE2pr3ASoC2/caLmSey3PF1thS5ZpTp45w8t4z9IaHsDamqXI8Cm0y6nqOwhFcDq5Am4ysc5Th8E6q/Wd49ulfJPc1JJYQGnzTEDeeeO7wn72BGVfQQGRp6wSkCm90uwexBrQmTi39wRJJd0Dc6WDSIZiEcrrH6PpT3LjeLlU8fOoI973tW+icfAt2uIlJu2jdljZWun0P8L7dV8HVByWl21yM9lwO7QYJeEy1j9YVREt4neJdWw8BFNpG2OQgQFMQXE0oF/jFNdx8i/2F5z9+8HsolxWPPOm58lS7JqOagakDmYPvejBw7NgQG3cYbtzDzgc+wDf+x/Y9/g/f96UlAQI41/b8a/dcPQDnPO99dJt/8f5Lcu8XEgCI1nd+5cmQxeb5S/9ic5ADYNv9329r5J9r/J9LVOO255eShw+y09s1+41rR669g24fdi4r3v8pOLSqOHQ4o7d2FBOlhODYu/oEKtrk/q/5S6TGo7MlVDZE2xRto4NiLLa9kas2lcsoUNq0w7oHE9/atFULfVVg8ivoagffOYWLlwg6atfKe49zFcX0Cte3P8YzkycpDtZYe1fhfI7Rqp2/VgpjUlARVVPgcWgdk0ZLWJ3gfU3SeGZXtvj0x85y8coYgEMblje84TBJHLG8epxO/wg26kKoCaEB5WmbkqbNRlce5ws0gRDAeodyFa4aQ92gidAkaDIMXYwdoFWMdg26nKD3zhEeexZ9Y0ZEW28BgIM2VKmDnMCm/ecasGmEimNU0gHbLpWs51Ma76mnC5yCYgjjM4qzXnNtqqhrxZ2n7+HUva8lG2xQLHbI8z1M1CFOBoQmpyi2QBusiQmuIYmX6A/vJFaaS8+8i0mxh0NhUJh5TvHoHuFTY9bTwOG7YOUOUAFCEwi1YfdRT+M1/WVDZ9Ogl/o0yRouQFF6nnriIqNFhcbTTduA5speYLCyytv/wB9g+e63EK+exGYdbBS1UzX4g3n9NvFSaY0y9iDrX6GVQs+vYEYfQqkCpWqgXT1ScIwmpDizjNcpKuoQxTHatFdGqArq8Xn2ty/w8JN/m7NZiTPL7MzGnL/guXw+UI8CaQNZDd92V+DwccOdp7+K9LM/yyv+cfvW/cRffP4IwBdz42582+i3jb8/qFjZVgr83h97SO79QqYABLzp3pVg9MHN7/ZGnVsJ6bxw45+XbvzbZ5NUYSwEDb5qs5Cb6uB7NGycgDeWiqu7sJgXdFY9vhqDSkh7K7SjqTWNiYlQ+LoGbcEbtDLgGnzwaAU6eIJpe3DaRu2w7EEiXQhtJnejMlS0SXCBgMY3Fa6YokxEqHNsM2Ho59yJYiuf8/D+FXbnnnlTY1UgjSKyJCKJEzqdFENEFnfpZhmJ6aGmF7n69MMUecGVK4oLVwN4qGrNZOrZHY1YO7zEXnWdnd1LdHuHiHvHCNYeLB8raUv53Jy7VxgVo43GaI0i4DtLbY+6WRDXAVurttvezAnFDdzus3DuCupSQVwFtGmrIzZNaDPdD5ZOEtpAzHnwTuHqgOlY7FKKiTOoPU2+oClq7HBI5757sIMBwTl6jz9Kfz6mOq4ZH8m4Or/GEw//Aiurh1k7dBfDwWnKYotqdqXdEMhmNL6kWOzjfUNZzRiPnyXrHmb1xFfSn1zi+pWPUxMgirAbGQszx00bFs8oevEGUVSzuLqHqgNpqcAHwtWG/GpDHJck/V0Mnl7PsjqAeTfw9A6Mc8XCQe0Ue7v7/Lu//6O87J5/wau//G0kx16PXbuPqDvARgGbDrFpp80JMAc5A163J+3Wx7H7P9fmXET9g4qAFlRDr/k0we3j9HEKfZK6WqYputjYYntH8EkfPzzD6Ge/h3Opo9Pt8OTWmKV+RJqU6Khdt9+UUEfw42fhe1Ydkzzm0F+7gPonp9oaD7cusC9McbNicFsVQh3k7yjVVm9MY8Pvfc2h8HOSDPg7ngQAAq3bMq7P3SgOGvWbDT+8YL7/hfkAn/t80m1fKwCNhlgHmki166R1gAYGy/D4s7C83seVC1CBKHZ4N2Vp47VQjfCqi9NgjCE0Gq8UwWs0rt2UyFqwSft7Rymg8K5BhzYZKzQVEKCz3k4L2LgNUrzHB0c5uoK78UHqZopPDmNtxVo24P6Z4+eefIILI0dVtY2nse2NdXk1Zmk15dChAStLM/bsFeJIo47dAXXO2pGa01/eJU079GyCsQlBNYwnOxR1TpKkjBfbsNgjiTtYm7XlgxUoPFopFAZjFNp7VKhRKhDZLhpL0B2KLKBtiSmuEVUV+uo29ce2iXcCsQYbKeqmDQKoFRxsonSQf4dONbbbBhChA7UvaOYlqthvG6W+QmUBFwpCOcVPDL3730Ky+XqWZyV7Dz1M9uSYZTdjkQfU3TOy15WEzkV66RLpyhJOZbi0T93MKZOCopxS1VNq35CPzjGdXSYyKcONO6im2+zvXiOksHZmhSP7jrXXvYnOa99BmE9pPvZ+rvzSe4gJDNZjlKswkcNbqFzA1wo3dcQJWBd4GYqo40nXFNcXiif3IR5o7j6xgvKBUBaEfBc9WMH2VjDWttMCKEJdUI+vEUZPovY/hjVzfBJhdRdFDMq210UAdIZWHu2vE9VPUds7yc2rCPYQysQYnRBmY2w3obu0YHs/p2d7PHxuypFDhjMPeKZjuPppT10qkizwnx5S/PETI5T6+YNrS926AL/4FvtgkeNtjb+6FRAo7jvW5+c+ef1XcbcQv51IAPA73F2Hu0G/oOHXqh32VDfn/Z+34c8XbvwVEHXaW9DoPCQroBPFQQcL7wxN6Vk+BFmsmOzOqIoSlMMGj4nB2ICfP4OfjvDZCn5+FLN6BtUUKBuDsagoAROD0igToW8WzwmB0JToOEMlGTQN3lX4ckxQQDRo1+gXU7zSFKZLUU+p5leYLbYYLya4WPHGLzvN66IUbWM62bDNRg8KHxq0ghCKg4I+FqtjlAptIaAQ8N6jUDjvyOsFtXOYqEc3HoCC2Ga3pjCUgqpp2N3fZn+8x+rSKv1Ov115ofXB++GJ1D5We1w9Q4WGTrJKHHdxcUp0h8HnBXxySpTTjn6gqMYKqoCODsb9DagYfBxwccAMFOkG2H47UpNfDaRrMYNXvh7d7dOML9Hs7ZEeeRBsil4a4kOXw3c9yPzTP8/Or5xFjzyLj4658fgj7KaaKkAvgsMdy9YzDWUwJEsGbwJH33AX/fuWqDtrFLFlWoy4PtkiMRmrG3ezVzzD7nyX/KmSq8+8l/hnPkw+r/EarM6YLyqYOGqn8MGShECiAj0F3U6g14fB4ZgQVcymmryA2AdeE2t6KuCevYrWEDrLhCjC9VbwUYTp9PFNgGJE/dS/pR59HK0WxKtvRMd9VPMs6BJFH6V6KNs5WIHRIfgYpXsolZCEbWqrcVEfX08JaUrsZpgTX05UvJt4AE89WvG2V7ySSXGeJycTRnNgWeH3AkErdgNYvY/68E4bRN8cATi4vm73UgHB7dUj23Psto8h0EnMf/nNQ/yWJwHA73BKPdf7f67hb5/XiraXfXsQcPAfddvPv9jz5595JaeOPUxvtcN8R9O/P8E3ewA418E3M4KGw+uKjzwOJ1Zq+gM4embA3o05+d4j9JY6aDPGo9GzXYIOmOEJjG578dQpKt7ExO2yP1RbhEUFDTYG2g1blLVoG9HgcXVJqHPqYky1/RH+v/b+O1ry5DrsPL8R8XNpn6tXr3y170YDDaDhQQIE6ERShprRaoYaaSmNNHtW4siMVucsl6s1MzvnjNmz0tkds6PlcDXiypAiqRlBokbkECRBAxIkQRBAdwPtu6vLVz2b/uciYv+IzPcyn6kqgBRd3885Vel+mc/9Mu+NiBsRw9E1tvO79L2jjFJMNyVee5hEJ7R0hHU1ebELhHHfqhpj6wmVd1RViUeHOe06IY1b4A2NRjt8AGuFUg5jPJXNw+pwrmKU59Ruj2ja4nTOEZmIVtqhe65LGsU4W7Db32Sn1yNNmyx3OjSSiNQotDIYYDC6RV0NpssRd8necYlCXyH70ohkoqh2wRegaoUrQWeKeEXReNigl31YK7+oSFbXaDx8GdNQuEkPOy5JGjm2TnETSxJVxOxBuYd3Q+ykpNh1qMmQZtfjehBlimTHM+rCOFXUuWfrpsXWigYOtRmGa17/Fy8z+VQ4T1qp4fylFmdP1TTXNcPaUV6ruHPdUnhwhcVNSoxX+8V1sYaVxNOIYDSBfq1IvWbXe5KRpzWBc1mDlYcfpbkeM3j5FbJWhUqgt+sxOxZz9xrJ3i+h/8jjqKpA1RW+mKBcjd18GT+5SpIYTHIBVd6EuggVibYEeoBFUaB0AqaJNxmoLiQbODtCpWGXQD3tdSqyswySFVShKC10ztX8jz/zPB9+9hyXzyWoaJurNcQdRTSCpnf8vz/zPP/JmXfw0z/90wx/9m8fvMdOfB8fuuOgA2Ch5T9LOK3z/NmPX/A/8svXZRjgbUwSgLc5zSzwz4/5Kw56BdTclrM8QPBXB70ArVWSTkHR0/hJQrT0JNRXoRjiYqjGijPn4cbnNTdHmr/4XYqVy59g7eIOxegaz715g+euv0oeK8alwunP0EkVJlYsLcMnnvzTvPND3zetT/D7RYDKmLAIzn7PANPFYDqgDePeFXZufprd/ouM0g60ltFK09DT2gGvQDnqeoD1Fq8s1tV477DKh5p8nZE1OlhnqSqLA2oMaZzgvaa2lr2dHYajEa1mi24n7CrosBitqaoSSyhAxDuq0pLnmygcRnuMcUQ64sKZJTQ1vf5b7G5bTq10aMQZyhO6sl3GXv82Rt+lYTLSUx7zhKHzliXWiuIO2Aqq2pN4Tet0m8aFVZLHH8d0utS7z1PdvcL45eeIWpp4uYNSMdq0GL78PHHcofW+P4NKwvfp6yHFjc8SJz1c5GitK0wN1R5ke5ozY8i1pz2BrPZhnYVp71DpZ+cb1Cg2S8fma0P8mx4XKXI8WkMn9TQyxaiYrm0ArCWejgnDMMZ5lFUsx57aKIalZ8+D85qG9phyRNJ/jesvewZ3oeEV6yvQ6oJyisiAGVekJiNqncI7R12MUZtfpL7+z1HV6+jGKsZpTLSETjfQyQrK3ga3R9hSoYaog1KT6VCXwfoEXedgmkTNVRyOYjSi99ovY6//NH4JJiWUTtFe9/zS525yYa3BBz70BDevvcJo2+NKz9qSwseeKlnlne+4wG/87Pw7Vi28B08S3pMH2wUt9ABMEwB3n62FxR9+kgC8zR0O9vO3AZzzWDetJJ8L8kcLAg+uzD6cXn/lIk9/5AmWzr9KevoixKdwwzvgJ7gqbCurNXzsEc+XJpYf+hKYF/4VkYEkVmQp0FWkkeL0Eix3FVt9aLbgYX2Gd334L4exW0Arg9cKjUYRCv+8m67I5h3j3k1uvP6v2Ok/zzia4ExK1O2GneGo0DSoqkGoWbAVlavDB6SOqGxJaYtQGV/X0y7+Cu8gLytqGwr+8CGZ8k7RiBOyKOXyuYeI4pTBYJc3r1ylNxyTNGOWVxpo7zFYtLbTGQEV3pfUlcXVIWDWxS7tVHG628a2K+5u9dmzfboNMy0OhFYjY2Ntg07SxidvEW/mqIaimUHWhqoPxa6i6Dt2vtgne3NA640B6cV1lLpNdvEy8ePn8cWE6vYu3k/w68ssfeiPM/7qv2b30/8fTLJCsnoKs9QlbX+IaPkOJn+FyXgbmqCL8O+MUhjtcRaMUjRnGxMRNoHKw2rOFHhGSjHyMHKKsgarFB3rWUax3nR0V2BpKUxfBI8rp2sgeUIxp4O69kxKxVJf06sVUQLbfc2Vu4BXbCjPRtehYhgNQ/CPFWS9EpzHDnv4NEMNr2Dv/DrKVdjJNkZ7bHUD6i4u15g4wasJOmphsvMQrYEtAIu3OVYDvsDZgmq8Q5wu41SD0a1XKK7+K1bMOeqyz/lVxerSMg+dHnHjQsmt22N+6tOv8d4PtHnOD7A9xU7tebSleOvVf8IjH/pj++/FE9/DR64sPqimPXlOHRQFhgRAMoC3O0kA3ua0CkWAsw8JrWbD6H4a/Kf/vCeaVgaeFPznP6dm133zkyQdBX4VP/oyJnkEX38x9DTocOD1JvQsFCgwoWWi6vC6UQ+Wu5A2w+fttz/6Lh564jtYOf/NxHEjfO8evPIoZ8PCOViUCuv2l+MtXvny3+Hq5EVIGpgkIkmWwnNcgSOirCdUdR+HoXaOSZFTe43WESYqGY167I5y4rRJHCWY6c9mCN3xWlmccrPyA6y3DPOaQT3iztZ2aIh5aLcyNs60Uarm1o0dticFnaWIRiMijhUaj3UOA1Q5RAas9QwrmIwHNBLFSkcznHj6Y8dK17GxFoYHskaTZvsJls7+EdL2y7D7M5hBTrwESRfiLmRhLyG8hdHVHSY7O6x8oIO3O0xe3MPZCc3HLmEHFaPnPo1RTepJQeehdxCtrqNPPQL1HXy5CcNXiNoJkc5wTGgvQ6EUmYJkqBj1oFJhOmWcgbOOulKsxeBixW4JexYaytMhLFKTas9K27PS8jQyjyHs/lgTZpW0lkPPdtwCV8HWVVARNBPFYAR1qejlmkorWsbzaMPTijzWKkYjRaTAKY8zsHN3j91P/Re0H34np971Cdzdz2LrCX7yMnEWgV8FnWCLWyifo1uXqaqrRGmOr8eY4hYqXkbFG7h4AxdtAI4qzxnc+CoN1cBnpxi/+k9Q1Us0T38bl/eu8KbxPLryHby0+fM8dXaVSf4io8Lz3AtDljuKrZZi3HfY2vOPPjOkXf3HB++p/f9ONp8MzLr+5x9TSlFVDuc8Ev+FJABvc0pPx/2ZdfdPl5/XYT1x50MvgHM+rDM/e95+EnC0S1LNfQq99PM/xDs/8V0Ut/4O6eqHwA/xFmwdEoa3enC9AtsCa0OVup5uzmI0xCksp4pnuit87JN/k/X2BMUe2gxxNEE3wx4urkIrh4uTsLBLNYB6wt61n+GrW5+nMI4WE7yy+PwWWdLGeUvtFFUdU1vFuHQUVlPWhso6SmspyxrlDUvtBmUxotcb0G61Ud7vt8C999jaU9tp89R5jAWFxtUeb6GuHKN+QW8HGo2I06srQM5uf5ftOzlGQ7utSJIQ+OPk4G/hCdsGTwpoNzxrXWAp/L72RmPGRUkWjVlrVqT6VfRXrpDaAgzTnhBP1lWoJcj3PNUIiCC9aIhWE6ybUFcTGBncMCLe+ADR0m2Kt76EHjpGz38FhcI0v0y0tIqbbOMmfXzhURVkTYW3kK4YajzVm5409eg8nBjagUoVTodfT1F52igaxmO9osLjYk+cQdLwZFl4zSgLtQReaZJOxngvB+uoBmGf+2bDYxqKxhKsb0B/y1N4T7sbzqGiD26iqEYKWyhU5CFW1Ab6OdibY+7e+jz9t75Aa1WRtpYwHkzUpX/jDZIM4liB9lTjVzGxwpVDonSILfth50E7wukmvpyg/Zjd8VmilccYX38O072A0QbdWIfyGu88/7/i1e1/yc3eL3Nx9aPsjl9nfTliUtf0jGL7jufsabhbw1Apvu/j7517Xy1G/iN5wNwdfiGyT5MANUvy/f6aAF4ygLc9SQDe5uZ7ANx0RbsQ+D3OqYVeAOf8fsEg3Cv4L9YG6Mn/i8b6x3Hll/BuSF2GhGN7G359B6omOK2ICCsG5hNFHIex34aFf+8DZ3n8m/4xJorBFaidT+Ff+wuY9b+C3/jTeO/RJgE8WIvOd+DqP6f3/D/DrJ+hpWPGvmRQVKQpoUVYDqjrsH1wVcNw4qlqRVFAbRVl5dHGYyKF1nB70ifSEd12C1sMGefFdN1+g3ahJyAsD6vCojW1phhbqlxRFo6iqLHW0WpAIyvpb01opppOs8updc+gGjCaWIZDyDJFloRV8FqpIkkUSTwdjqkUvZ6nqsIvtxkrljuKy03HheYmrShDPWOxRPhNi0kNnoSqN8bV0DqtsYWnHICegNpzxKsreOvwVUnxla9QvvYyJsuo9jw+D1MgbeVx+R5+PEApF2oVDGAUrlCQAacgOXOaVrWL3ypRJURdUClUE/BRGINuaEgAH4NqeKIVjck0zlqUVSinqSsXdn7UCmeh2plgvKKuNWUVzsE4USQo9MQTK8XaKdBhNiV1DsorxoXCFwo0xEvhhL89gFJDPIHlJbADxbU74KMenWWIbpQ0Gop2J5yHJlIkWagrNTGUkUcnBcbuEnUfB5tAfpvB5hfY2zJka4+hDVS9l9CMMZ3H0MkS8ZnvonPtX7DbcAzzV4lMC4em1YBhDkWqGFz3rJ+DfDKrnLh3F/9xHQJutjHU3JtS+YP1AGoXVn6UGgAhCcDb3GzMf1JY2o1oGvzVdA3x0PVv/EESEJmDoq6F4K8OPrDC6+7fzQuff5J3ffhXUR7q0mG04nOvK3Y87DZCV28G1HUo8mpd8iy1Ffk2/NsXNKfULfIv/imWLvw7cO57UUvfjBru4Uc5uuqjki5hn1mNmRU7tR5j7ek/DsuP88H+FX7t1R/njvX0euFTT2tFPf0QNEAjVTRSsA1opZBGhqqGSBvy0uC8YjRxTEZDtIbYOyajirIEV2lcrcAr6lIREVEXiuEQrAsL8RRlTVk4vPU0GorVFc/aGpRY2tqTZrC2rFhqMy3eUlQlFAWUpcc7RVUq4gSaHU28Ak0FTyQZT2xcpNs4hzGNsLJd2+GiO/g3trHbm+AnxE2NHYdxdJMq8FCPHaMXeqh4L/QWMJsBUmGiGjS4yqONIsk0UVOjjMEVYXdDX4fzJD6viZ/5KPryd0F5k3TpN+iceoX+FweMN8O4vWl6HAoMpG0FKQz3wvDE8kOa5PwlfNRg99U3GF4piLzGFqBcWEUSrXBKUdezqaSK0QDYCd9zkkCUhoTWTreSdoUCq/AGkrbHtjR3C8VmokkU+MITTTyj3LObK8ZesTGGjaYn7ijyAaiGRjcsrqFwHc+kDyb16ASaRqMzC/YmrrhKMcmxtaEeXSPrnAZf4aImqJio/RAmbvHe05/k1/KXqOu7dBsPU9YVm7vTWREdaCnIbyr+9gffeyS6H9v7P30jzh5z06h+XGxX0/dlbcNW1RL/hSQAb3NaQVk7hkVNK5vf6YyF7n/nmCYBhwsCWQj+8+OUB48rfF3hrYK6QW+Yc9uHxYIafcVoGHoATl1WLC9n5OOcIod3rcAz55dJs3W0apLvXSOt/xnKKNS5fxtTXAdfhz3btUHVE5SJcJ2zMOlhN7+K7t/hoSe+l6Vz38LnP/d3eT5/g7GxeBd6GLKEsF2wIiQE0033cjudR29rrKopag+RIlFgdEQnbaAstBqrZCZFqwzvwZgEVIxWYZnZoqzxviQvi/0dBItyD2cLOs0m1uXU9YSqrigrz50t8E4RRWASRdKCOFOYFDINtYekUjyRdnnq4nfQaVzATHedq6Mu2sSo4hr6VBt1+t2Y/pj6yvNU167j6xEmBZ14ouUwvu6nyzMf/NFCwHd1uO0qcLVCxyGxqkcVyiuIITmX4M6fRz/6J2DpYbyOUFkbsheZ7A3QjRDg6zIsCW1SsCrcjlJFcwPGBbzxvKP8tbeock1Ze6yLqBxUXpFoTxpBnHqiRBHFHleHLv2q0gxsSFxS5dHKT9dqCMmGIxT8dSNPVcCohlu1prkEpQvDI1HluZwoTi1pOkaFqYcjR1QrogaooSdKDF45kk4b1Yrx0Yg6KxlXtxjcvImPwGfLWODUqUdxeolo4+O4uEM9eBM3fg3jdmH7K1w++01cu/4Su9FpXD2hKkLyifJoB3qo+Nsfes/++3C+uHbhPXUMP/dvdjuMUbG//LMibLQUevskBXi7u09JifjD7tlHlny3EbPWSTi7ktHMIiKtiIwmMorYaOJIhz0CIk0SG9J4vhbg0CjlwgfV4hDBpXc/ArbgU7/200zailYNv3Id4nXF6TMZd94sKGsPXcVGG/7y4+9lNT2FMTE6XsMXb6GVotVaJ+48Dp0nYfkxfF1gjENFTVTaPejyLIeom5+D0++B1gZea6ytefW5H+VzL/wQW2pM2IXXgw9d3c6B0X5/Y5y6hsqGoZGqhroOLfq6hqqEqvDUlcJWYYVCfIQm9AaY6Ra/SkNsHFEcWl51BXFiaWSWZupIU0jTEOyjJtSRw0YhIalsWMEvq+ESmieWz3Kue452soGK18NmQdNdClXUQTcfDj+7r6HeRZXXUXYS5qyPR1RXXqd47U3UJEfp0Ao00bTuo56u++ABzTRhgzr3WAuoMI6vuoro3AbRhQuQgHdDfHKJ5Py3EnXPwngT+9pn6P3sp/G9AtcHOwl1H1ZB7Ty1VZgm1FrRn0BZAF4Rt6B1KcV6x63rlkFPsdzxXH6sSV1Z9m7X7PXC0I1zoYfAOUXpFG56olmmw0ehw4HYgdKe3ViRtzRxojinHU9nmmblqEch241iMI2wgZWOCcnXiqIeO6KWRscZJm6GJMSN8I8V3PnlCvXOjKqzRm0iKteivf4wjZXH8K1HwkZPO58myVaheYqo/xyjrM1mr8dbrQ265r384C/8AMM98An8wPpB8L9X0D9uYoCbTu1zcwW8s+ve+2lS77lyZ8irt4bc3s35F79xS2LA25j88d/mnrnU9e1GxHIr5vRSxumlFGMOJQBGzSUBIQEwWh9b9Q+zRGBx/HL+8f+5+AoJnr2RIjod09+qaSxpTq0oVlceZZzf5v3RWR7NEiIN3o6x5U2SuIOiJooczc47SbOzqHgVTn0TKmliRj+F63wHeuXJ/RX0Zt/L/nKq01L9usrJh1vcuPpLfPXVn+D66C0GZjo1atrF7OoQ+MoqbLhXVaFeABc20JldL4tpK9eGhX30dMVAbzVxTAj8zlHlCq0NSyuKjfMRy2sK3ahwUYIyjbBToa+pbEFmDF3l2ah7bGhYiU7RitZJ0zV0vIKKlvEqQyWrUO6h3Ahl94AJOr2IilZRURuiDFNcQ9W7QAT1IHzT+RC7e43i6hXqmxWMw7QL5aeryMVhZmOtoF8q6gxa59donbtM3D6D8w5nLbYaUE/uYpgQJylR4wyu2kT5Mexp8q/cwo88tge+0GgT6hdGPej1IC+ny0Wj6HnNHQNbWqE0NPXBMtRJFLr/CwWlCq17pSDzhJkHDtJpQaHyYe+JaDo103goDQxjxVJH8YxWLI89rnTES2GWQrqsiJseE4dtgHWkKfsVqJC0KcAYj44UKlIkZzXZw6vs/sIt8ofXyM+uoLIGcXsNpTLilaeJV55GqYrJG/+ArNujk0Vk5QqoNXx8g9ffeIHNtxwXP/B+drdf4V9/9TofXXrPwvtm/k2ljnlkv+t/VrfjwyqQs8B/cBmKAweTihvbY67cHfHf/8wV+fx/m5MhgLe556/21QceXfZF5ZiUNWUd0zBmOtk6VKLP/s1aF6EW4OA1FoP/SYWB4VGAP56+i5+zL1DHnrZJeOS9j1P7MctRzF7/FZ7IHuFMeZ2qrtjZrml2Etqnv4X4/B/DZMvY3mvc/dJ/zvqph0hajvrKj5Kc+QaU2sYUO9TR96Fba2HzFqXReJR3KBWhvMLZnFh5okjz2MVv4GJzg2J4jTxb5sqtF3ju6i9yu9plYsNuat4qKgtFWAtnmiCEWom6hqqabQccWppaWZSGqlSMJ5qkMmxcTjjzsKa93CBJukSmiddJCLK+IlaOCEtS9Vm1PU7XOS3riR0kukFCiklWsNZQF7fAf5k4iXE27GRnsoeITn072pcwegPcXZTtoUqDcnt4u43SLcCidQypQW+cJVrVlE9tMx5mjPcqnDU4DK4oGG1t0r9r2d2DsoTGjR3OnNll7bwh6xq8VygsWmtM1qbOa6rxK9RVRdJcIlnuEL3D4W9sEy85ql1FvecxCWSt0NEQjaEoFdYqmga6SuOnCYBTYU8DH3m8IWwKVSu0C1MwIwU4iD0YE4ZOYheq3rUDVAjcI6UYaGh7xZldKIF+BN1TGpWERM71oSg9WQOSRo21EK94RncVydolVj72XegzjzH+uR+m/9pzmJamer1Gx5C+4xOgBlT5HpqEKEuIsxZRq0NtUsh/hY2Jx/+v4e//fXj6ac973wuPPr3MI9cegsmf5+wbf4+9pbX5N9JCTc3CO+jQ3dOcNUzrO3bw/2A64N6oZJjXUgAoAOkBEMB7HlrynUbESjvh9FLKqW5KdKQX4GAoII5Cr0BkDnoB9j+sjg3+R+sDAH6y9QJPnfsGLBNWdcyp5XfhxxUr138M5WsUcOuKorME3ZWUODZ4m4cFd4DOymmy9rvI7C5R8xzV3nOoTodY7VA/9F8SrTxClLXQUYQm7ITmdYSqS3y+hfcalS7hlKYa7uGjBGctxXCL2k64duNX+cr1n+Ha4A7bg5pJ7hmNQ1W6tWGWhJoWynkfqs6rPPQGxJHizDnDQ483ObVxmijtEEamI5zPp4PrOa7eRpcWPQS7V6FGFadrON2BrBHmv6eZwhiFsw6lQevGtJUaE0UNvM+x5R5KNUmXP0zceTd+/BbKTTCRhuoaSlUo00brFuDBFyhqtLIUw6sMtqEsEzyaMrdEcQttYnAlyk5wZZ+8P8ZXEMWQNDskjRa27GOrCeVIoWJFPnagI9Ye+wC+2mOwfYeVcx+heepdRLbC3XmR6sbrlDtjhrdHXHt9TH8cxuRHXlFoRalhogi7GTbBdGC14zmVhsBua8W1O5qdkUb7cELp2SqDHqJpwlq5sIBzpaGlFWcqSFE0lKdlQhLbTD3dNci6jsaKohxq1p99gs47H4f8DW7/3FepBmWYQqehnljqUhGnHhN7XGTge74fN34N23oMHafEw1/FqQbN8x9n6/qP88TOZ/F/4RZnzpzZP/fnx9+99/zE3zqh5Q9HuvsPH7NfqzPXzT+7nHX/O+/Z7hfc3Bmz1S/pjUt++Oevyuf/25ycAIJ3Xuz4VhaGAdY6KedWG2RJ6OafBfr5oD9LCsL9ar/VD/efFbBwDOA+8ed5+fo/5kyyTtn7LR4t+kTKo4E40bz0W2E6XBRBq6toNML1tY3TmLiDideImo+hVIrRMcZV+CTFjP8BEONYJnnvPyRqLqMIiwWZ8W2saVDbEjfZxOmUerRFlfdx2Tr14Aqu3MMWW0wGr+G1pY6hnw65XWzhTcWwVOwVcGcb+n1FmYcx5FYWiiQ3NjztjqJyEbaGySBBDUvUOCGlSW97zN7uhFNrLTQeo8HbnPU1QzoquJh5Ws2wDkIcQxz2PGLWOaN8mNONCtvJRnHo+rWzKXJpRtI4i1YWo2q0SdFRgzC4X4G7jWKE1ppy5BlPHqH26ygstuyjTAsdd4g6l9BRCz+5BpOruHqEUQ6TxLi6h622SBJLWa0SNc9iXYZuXMIsP4turKNcDXGTaOkcOkmoyxHF7Zcpdt8iXj1DVe+x+eqvMnjjBtfe3ONmP6c2nn4FlXEMEuhbRWXDksOqUDRqRTKBqFLEqP3zxbvp0sH+IOE0ESwlivZYkdUe4yFTioxQ/3B6XfPwR2NOvecS1//lV0kaMbpRkmTgrWXpXWfY+9Ituu/eQBnH3f/lDr6ApBkyDvst3465+Axky6TLFyn3buKLLaL0LFub/xmP3dzkb7/l+ZEfCef7kcD/v3v3kffjceP76sgbLFwNQZ79or7DCcAs+Oel5drmiLu9nN1hxWBS8aOyD8DbnpwAAoBnH1n23WkvwMZyylon3Q/20bQOwMwVBx5OBNTCrICD0H+41T9/zOz2iw8XPJNq4tvXaagxSQo60VjriWPFYFtRlhlr5x9BuQlpqvBeE2cbKDTaNDDJCtQjVOMRlCuJDETFz1CV13ElRO2nSZ76T9Faobd/Add5P755Dh9nuCpHRSnVeJfRrc8x2XyJ7kPfinMlo5ufoexdJemcJ159BqcN/Z3fZFTeoW52qfyIV2+8SuljnIrwyjDK69C9jcbomt27BS+9UFHkIXDHGpqxCiv7dWPWVhKUr1npGtotYDhmvXasdaHZZlpHEFqgKFDKh62CtUdN6xW888RJWLjGT1uEetqKjhOF1ilRvAreh02KjEb5bYzOUc6Qu49RVBvYqoRoDWstmAQVdzBZF+0rXDVBG42mRuVvoNwudTkK60VUE0znSdqP/zuY5UvotBn+1tN451zJ9vVf5uadX6KnHLvDOxi7w/mly/QKw41ej91Jj63eHbYHI5RWJGlE7cArmIws+cTjSoXNwRSKLFeYsSIaKeKJIq6nY/9AJ4GlOJxmRa5IxpBYRTQdwsqdp6nhoTPwxAdixjdLip7jzHsj1p99kts/9xztC2tQThjezFl99gxbn71GvuUwqcdk0PyWD1Ccfy+6dRZlWtBo4rZ+Bb/9U7zU2uLb3w9nPjydlnco8AP8+N98Zv6tMEctJNLHXAXF/t95MdhPf9/e79cCeA83t0fc2p2wPSjpjSr+4S9I619IAiCmnrnc9e0sYqkVs95NOb/WII40kQ6B3uiDBCBczhKDaSIQzZKAe7X6j+kpmJqceZXmVsnykqaTeZJOF6/6uFJjfQZotM5QZDibY0wDE3fATvC2h7MDIg1KxWTtx1DRBZS3JHpIVf0WbsJ0XF7TeuL7iS99G15pPODqHFeN0Y1VbJnj8j7p0hnyvTtYO6Eab+LrMeXey+isy87gK+TGUhtNaYfc3nkZjKE3shQ+RkcRk4ll2C84tZyxu1ly9a2aYT/UC0RRaKV7GxKCpabiw+9e5uFL69i6Zvf2LaLehMdOQbtFWJEuCsFc6fB8rUMgd7XH1mFfhSiGJG0TmSXQEVrFeNfHu22iKAJfoaMlvB+jdYSiQKsaLPS2l8jrR4lPfwdm6WxYGGpwE1/tgS9ROmY2nyxZeQSjwe19lXJ8h0n/Ntn6e+g89icwjVVU3MDEKSaZdlsoxWT3Cm985Ye4PXqRvk3o5yU+Maw0l1lJuuwOKkoVsTm+xc3t22xu9RiOLMU4TFN0Vdj5WUcKHUHaUiSZwsQeXWlcz9OZwIqF0ySskqHGjv5Oyc1rjsiGxMB7T+Wh4T1PPerQhSfzkBhPI4H2Uk3aVkx2NL6s6T4Vkqyd33I0m2GmhMkg+bYPUKw/BPSoxzdx1RvkdZ9xCz6sPZ/K4Pu+bzH4zycBP/4333XkXXDc+P7hRGD2/poF9lkL/+A6+19rdv/esODG9pjNXsHuqGQ4qfmnn5XWv5AiQDH1/Ft99YHHln1ZOcaFZTCpWW0nYZlbNzsqzAWHaUE9fjrbWqOUW6wJOKYw8OA2CzcU0LzzOElrk/5gk87yEtge3eXHyCev4yixlSaK1/A08TbF2RpX76AxDHt9smZGb7ckjmqIu6TNc7itz0DrIaLok2TdLzAaDdDaY7d+CbpPES1fQpmEKE1xcRNnK7TS6GwJZWKirEucnKGz8RTFYIeye5n+7hcZoyitx0QxabJMUWWUlcFEMZkPuxK2uxmnOo5GrBje3Wbcc9R1GB7QOnRXKx3GrZeWDK2WYbe3QxRpltaXGKua1oqnk2mMqfc3TjIGtFFh/D9u4J3ClgO0iTDxCiZaI0pOo3Q6/Rs4FBW+vg1ugImXUaoGewNvJ2itqaoLeJWiXR8/fB6VaKK1JyFrU22/gk47kN+Ceow2KX7r1yjL25T5NqV5itaZT7Lyju9EZ12UiUEblI5QJgrjNd5TDK+zuf0im+wSt89SFZb+cMigHmE7ORfX3oFz66ykp+g2mqyu3mR3sMe4riidw7tQxmZQYUZG4ZmMoe6FNQEaXQVrUDQ0d1RN1h+Q3YF6TxGlmqQI0zmr6Uz5EnjldU3ccHz8447ipmWwCZMxtFccqxccSSdj70sT7CRM0zSZJ9uIGX7gWym1w49vQXmF8dZVerueb3pEwZ/1nD+vFoL9bEdNpRQ/9h+9a/F9cGLAP67mP/BzAX9+Kr8nFPv5g3cd1jv2RiWDSc24qCkqJ8Ff7JMEQOyrraesHXllGeU1jcTQTKPQ8HOh63mWDKhZ/64iVFvbcDs2oRoeHizwzz9SjU6DOk2pNtje+nk6rddpZ11K28dqjbXbwF20WUerEk9EPtgkTqG/U2AUlIVCbX+ecvcLpM2zqGIbklVscZqG91QqJ7/9OTLVhYf+HJgMlTTQSUYUZag4FNc570i7a9iyRGuDiRLS1jpmlGGTkiRqYEyDNF2m03yTfg6rKxvEcbo/DTDPh9hqQDkGozRZHLqz/fQnXuoqLlwwXNroEEUKW5eURc0Yhatj6ljRWnknhhGaIagcrSegUrRKwWuU9iTNFgDadDDJKYwxoCqUSdEqwle7EGuUT0HnYO/g3RiNwdp3YZsfp7O8QjV4nar3CvXd/wW785vobAOlDcXWb6G0JsqWqMeb5LtXMJGicilV/mXWLjxMlESoZieslzubNjKbdomlHN+kjkqa3cso06RrEqKqicWxV/Rp6Fe4uAyDnds0SXh840mK0yOsKsP5pWIKa6ltHbZRdjVFPSYv+xRFxTi3FM5jC0898VzdAxd7Vt7lyE5Z3C1N665GF6HvvAnEmacBTHYcpx5LqM9atr5Us3xZ88YvOignrJ+GtUcbuLrEP3mW2ypH77xItnwJrxXDratMbsG7/8/w+Edg/J/MneLqIBEIwf+dR95z9+sZOzw8MFvCd7/yn4PrinB+zRb+AdgZFPTHFeOiJq8cZe0QYkYSALHvS2/21IcfX/FF5RjlNZEJ8+ebqcGr6cIrhH8WYLrVq8Kh0ITWJkTTJXmP/VBTcx96zD0+d9DdN+6geCc7Oy/RXcmJDcSZpnYpti7xfgimhDonWwWtWqytuxCk4nXqQqGjZbSPKCdDsAXWe2qWUfld2o0zKH0afur/Bnmf5MwautHArDyKuvzN6Ic+BibCVgVFVWCrCa4aUAxuYssBSdxhXI1omJjxZJOLZ99HkqR8/vmfo9lcp9NaIk0z1lbPU/Y30f4ucapBwVqmOLduMO0Wp8512Nsa0G616GQNlHfk+YS6rtnp9XjphZrHvvtpmpe+Gz98C+oRprGM8iW29+sw+Sra6Glru4VWSbgeNfD1Ht72MEZDbHHl1bDtsFIQR3h7msHgNEV9Gm9ukXQNvvboaAljt3H1JtXuDmVpcR6itEHev0VZ7DHq7eKspnPqPBtPfSfNMx9FGcCPQl99lIJKCcvwAMpTl1tE7RWWumcpqzFZskSztuxO+lTecWu4hfeWRx5+H3vliH7dp5G0MNNVFp13OF9S2Zza1di6oKzHlHaFsi4Y5YOwyJKt2BsP8UlN7w7cuauwE0+z5cjOOVbvGrqDsFDUaOzRGsabmq98pWbcg8xrdq45MgMXHlLEmUP5CeXTjzJqd2hEEVHaYDwaEpdfIjoF3/ge+PufUkwmfqG1P385C/4nFfPd8/2hDrr3/bSF7/H7gX9mv+WvwgPjwtKbTvublJaisvyYtP7FHDkZxIL3PbLs242IdhrRbkQsNWNWOgmtNEJrhVFhJzajw9Q0oxWRVhijwwqC09kCsdFhk6HZCx+qD4CjrZvF8c5wa+XdXZ6sKmh8Ade8RD26Su0b1K5G+ZoqD9Pyku434OtdlBuilEV7TZj0lWCrcZg6Z69CvyZ61dBwMeBCUSBhJkOUxOAt0dp53Lf+AIxu45/5dmh1GG3dYPuVT7HLiKi7zKD/MpV1RFGKUzFKGXCORmuDKEq5u/kc27u3aESKX//Nt9jc9Vw43eVD736SxlKH0pXk+R6+mFDmE1xtaaYNoqhBUSraRLxntcdSPCRpXUInq+h4FaUisHvoeAmyM5AuQ/4W5K+FMYXmuyBZg8GvgdsGvwd+GyjBJZCfZTg+xyRPqcoirLKoPd4W1ONNytEd6mqEcxp0m9op+js7TMY11kecf+xhVi+9h+b6EyQrj5J0T6OaGaRxKLn3VShWYJkwwAH4IW/82n/Gm/UVkvYFJuMdau+ITBvrDeNqwKjcoyqGrCQZj519FqsT+lUPS+iZqsO2iNi6wrqKylZUNqc32SOvJpR1hSGsnlhWls3dXXoDx2RPUd31MPRQKVa14sIVRXcMqfO0vKepPC3tWFtynN6ArOGpK49OFVw+hX7vhyBO0dka8Zl3UY33UNd+hdp+mSq6ziN/Hy68dLTIz3vPj/2Ndx46uY8L+Pd+X8xX9u93/88SgOn1cOBiQnB9c8it3Qlb/YLeqOR/+Lm35PNeLJAeALHgt97YUx95YtWPVb3fgzsr7mtlEW469h8+fNT+AkHKeZwKC+TUhGMixf6WuQvU0czzpOGCvef6/DrwkfVHMRdeJzrVBfcfgv3/Ugz7aF9TAxSfw5gWzuUo05x+CBtMfAFUjanfgIGhMXgHdfkSVpe4wmPHYbEZpRRx2xClGWqUo//F/xGVaPTd56me+dOkaZPTq+/l+d/4Lzjzzu/i3JlvJR++ymbvdYibmKiB1jFVNcDWY7qdM6wtPUQSebJoQH/SoN05RxRl1JQUZR9nw/4AoYDSgS2YFJ7dOznnl3osbWQ0mmcwzXNh3n75EhgVquHUGKpdsDpMlE+aQA72VRg/D0xANUB3of1ncMUS47tvMd65QVUWKBS2cpjEYqsevhrgih6UDl9o6kpR2x5pq8W5hx9n6dJHSZYfRqdddNpGRymm0QkbOiTNUIFIclxJO5R7WD9EtVYZTG5RuxKtE6IYMp0SKU0zzajaBXk15K3eqzy88Q0sRS1yOwY1/ZiabmBjbYnzFojY8AXD8S6DyR79UZ/dUQ/vNYmOD3p+jEfFoL0nMbCWwdnac67laTUczaYjihSNLmQrCck7nqY6/wS1HeGiFrYqMJ1zRCtP4vqblOM7mG7K0ps36H4vXPz+oz/yP/0bTx85l2eJ7f26+effC/PL+Hp/cut/9vqzkbnNXk5vXDHKa/LSSte/OJYkAOKIonbTwG8PWijT/cRbWRS2DFZM15xn+k+FDYNUWIrVeo+arspm9EG35+G658Pd/4dbR7OLX99KYetpPvrvvwg/+X9HPfMUjY0foJH3UX6MHf4PjAZ9mkmK6Zylzt/E1xZ4jbi1hqvb1M8PqPqvouMGTkXke33qXFNtgrKe1qkaTYXWe0QNRRQrkr1/RXr9NRKT4PI+61+5y429X6J49yYbD32QC+kq/b0vsjV8iyjuEsctTNwiiTq4aohzmvXVi+R3XmM4iUjTBjiP0VH4ANeKOEqJXESdj7h9rc/ltOSZSx5dDdm58TpZ4yqtdgPTDYkA9QR8HYZB4o2w0P7kOhQ12BjPEqr1Xlj9KLTPgC1wTLD+LlHUwY0G2MEOxk6wg13caIBKQmFhZ2mJxsVnwli+LVBJG9M5h0pWUA5wFmUrTNKEuDGdn2iA9OQTSiu874OH0m6jTRcdZ1TUoCqSLCNyDapyi9paxj7h6vZXWWluEMUNal9Nz4II72xY78BBZcdMJnv0JlvkxQTlHOdXz7LUXmcw3uXNm6/x2hs97AhU5anKsGtgU3u6HcfKeTj10Ydwy2vQaEF1nTI9i2628ZTUtibprBJ32+AdVX4TVY1IWoZzo38Ofx0uXlz8UX/0r7/jvoV86tBJftx7wDPX6mdxvH92xMHzDr5OWTu2ejm7w4LhpJoW/ln+8S9ek9a/OEISAHHEF9/YU+97ZHn/o0ah9uf5K6DdiBeWCJ6fgqRmWwkrsLiQLPjpkIGavcL9uv+PaycFn/vhp1EKyt6LfPLZ7we+hPrv3k/09LewfPZ9qJULsDcma/wW47v/jDqr8e4OWfujjC59gcnnHFlXM9ruo5RBb0AxcsRGYRPP5suWznqHU89+K3E9oN58GT3R2M0XqPoF3SzjTqvmKz/9eeI/mpOtPkRz+X08gmcweoOb26+SZetEJqLZXCdOV2gkDU7nA24PLEZrnLN4V2GMoZmGpZedrbhyY8Byw/PMk5oosSQJtNYAU9K/W1HsDFBakTbWieIUZTxK74UFkaKnUcbiKXBVAZNdjJ6GjboiylosbTyGL7cZ969Rbt6lf7NgtOPBQhIrEl2g1F10fJfYADVgwp4A6VpGtJzAqTNw7jE4dRlWL4TlCjsbsHwRTOv4E6ocQNzC2S3iZBmtW6SmjVZRWG2QOJQmKM3a0kUm5YBRvcfe1k3WGqdYXnoU0DjvsM5Se4dXEJmUZmuNNF2iqism5ZDKlmzt3WJvsMXW3pCkqdl4NGLzrQmxUbz/yRYf/WPPkGWnUD6i1BFRnJG1OiTqUXy+Ca6EOEGtvIska7D32k9Cex3lHOPiCo/1v4HtPwnPXjr4Ef/pX3/6xEK+k8b1jz//1bTFv9jVv/+uUNNVJw9vwgWMi5qtfs7esKA3qhjmFXnpKKT1L04gWaE40fsfXfZprPdnA3QaEd1mzEo7pdOIMXquHkDPrxWgjtYLzP3T+uiH10ndo8cNF8z7D37wJQA+8QnFD/3Q9CmfVVBCLweXKXQRQXKBMvp2ot/8KfyNTVxpqQtD551Pkjzk2Hn+JbxVDF4DXSYMXrV0Mjj9DU/SffajTF74LH77KvbiKX7m/F0Gg5jLjz/J8pmLaG1Y6TyG9jU66eCUZ3v7NxkNt2m0TtHKWijb49bWW9QYvHc0kjar3Ytkpgv5LivjX2ajXaKnH/bzSyhroyAGEg3FOqPtHJO9g6j7bkz7Yph6N7kNNod4Dco+5D2oa+zmVXovvoLqjUmrgixW6MSEhfbjFHDQSEC5g2UG7RhsBbmC3ENBWEAfICE09nVIHOh04B3Pwru+Dc6+AzorkHbZLwAEsLe485X/htd7v0TZfDgUaKoklKyrFKUyKjvC4bHO4pzF+prRpMdO/zZL2RIX199BFHUZl0PKekJVl+BD7YbWmtqGugDrwwyBcd6jn/e5tXubGzdzBnfCwkjf88QGH3/nn8Ikp1DpCnGzG5Kd7a8y2b5K1mmiWxdg+AaVahOvvoPxrc/xg3/nn/C3/reXaHXex995Ycx//V//NAA/8teeOqHX6gHqXY4J4t6D4/B4P/vDH4fH+WfP7Y1Ltvs5e8OS/jgU/o2LUPz3D2TsX5xATgxxTx94dNmnsQlJQGZoZ/F+YWC3ER8K8Hoa4EHPBX+tFoP/PROB6Y2TTszD3aszs0QA4NFHFT/1U/8l6p+9yZtZRTW+TWQgO/MBdPsc6S/+XcqXrhC3V+lf26EYenSsufAX/y32Pv8z3P3shHxL4QgLBSk1XY3PwdKjbb78nSXbVUWLBhcee4J2d5mqGrO69v5QCBm3QGegDVHcYDJ4Hje6yng8YVJHpHGDrppwRr/CcjwKcdg0wBVhqoVX0z1tp78IN/3JEyDTUDZhcoravRPdfTfK1/jBVbzzmIufgFd+luo3Po0ZFOgkms4NU3DubHixqgwBXNnwNYwBbUMRX9yA5QtQDmF0N1T1V4OwFaJyISEYAbmbJgUqvJZRsLIC7/tOeOpb4dQlaC6Hx+0OfvMnefHl/46+tlTpKphVougMzmlUcjr0iJBQ2pzCjrGuZlIO6U126Q1vkWrHIxvvp916hMpBWfSp6pxxsbO/g6P3lkGxR1UXbA932R30GU5q9nZhtOdItOI/+sZv4umn/yxKNdFpF2Ui4ijF59v40R1GX/0nvPFrX2DtoTXWP/qXiSeK7ulluP5p+CP/nMuXQ2D+0b/21NwJ+bWN6y+ex9MOfX/QxT9f4Mfh8f5jov92P2enn7M3KumPQ8t/UlgmpeWHf16CvziZnBzivj7w2IrP5noC9mcHtFO6rXihpR8C/0ECMAv+oUeAowmDWRwDPS4lOK6u7OhRwV/6wZf2u0dfeQUGP9Thxtp76JiHGOshjcZDaDuA/k0aX30Ts/wI+Ru/hasqykHB9pWS8Z7CeoXXCrzCKcXyBcup9ylufl5T3VHof3eFz/tdLlxa4tT6OtpMGI3HXDz/YVqts2TZKbwx09kBHjW5zuadX2brxg0+fN5zepVp8UT4GmEz+ioEe08IqBC64T3T1jIQqbCVXnUWqg2YnCe/+wpap6iqRL32Cv5KjlIKlYJZy6AZwTjHVzXOemwObhJ+sdnlFrz7UajHMHKwB5gunH4E1i9Cow0v/RiMb4JKwvdXjsJ+yIVjP4KNgXr68zTX4GN/Dp78BDQb4WfRE7Ze/2G2d3+eMmmyV0d43cF6TZScQZs2ytV4neC9onaOcTVkkG8xGm9iXcVk0uf86hOsdB6mqCeM8h0G4y0mRY7RCY3GMnGSMcl3qG3J3niH7d4ew37FoOd5WDf5G3/xH2BcimksT9d3iFF46nyEfePT/OpP/CDGx7zne/4Sp00KZ2K4/H/g8cehLD0/Mg38X8+4/uzK4XThoGU/3+Jf7P4/UvBHSETu7k3YGeT0hiX9SSj6mxSWvLJ85Wqfz7+2K5/x4kRycogH8sFZEpBOk4AsotuKWW2nLLWSEPAVqFkSMA32+z0Bs9v6oB7AaIWem0r4IEH/uO7Wg6uLT/pLP/gSr76quPGfw90YVOsx4s4GuthFeUPcXCeyBvdzXyBKG8QtQ9ErKXb2KPsOrGa3pxjWUCpYiTW18+w5RQy0FaRN6H1jRPzsMo31GK9TWukafjzm9KVvJGqeQpkmzXKPzujLVGXJytppGP9saG3rJaivQeNDMPpc+BmUC/czCEsGahUigGWaLESg1qFYwvZOYbnI5NoXca+9xkqqKa5bkvUEdbYD/RImBfW4nv5MhCCuFFkH9Pr011YShhkgJB2F2j/WjTz1SBFlHv1sJxQfFmUo/ksaUNtQlEgFt6ah6sxp+K7/K5x7CtJk2svQABST4Wu8+sp/S8WQylXUTqGSdXAVJl4GFePROFImxRbOVkRxh9Fkm97gOsrD5bMfRekGebFNf7LJsNhlkvco65zKFhR1xd5wj/HI4QrPSqz4c9/4/Tz53u9FxQm+rKgmQ5yrwSh8f4wtb2Juf55G9H740IgrVwyf/ORfAuBH/uqTCyfb4UT1+C7+8N9xvVuHA/v+7dkUwkP3H1bWls29CTuDMMVvMAv+ZU1eOn7ztR2+cm0gn+/inuQEEQ/sQ4+vHAwHpGZaE5Cw0k7oNhOMVtNtU0PgV2q+J4C5HoLjhwRm/+apk68cWy9w7P3Ax7sv86vxx4jUTaLRKUyrpB55Elsz7OVsvXqT/HVLqwcaHaaNOY22nolXlIRhcxRU0/ntsSJsM4zCKc/ysufshwyn3+dJW9BoqlBctvQR4CZMXoTEhLF3lYJOgTTMzz//v4edfwjVa9D8dqCC/AtQ3YQ6D3P7GYOqIH44BOxBxmS3i2leYvLcz5K+uU2mYmh7WAF8O+yHq1wI0HUdZgoAdKY/gCLUFjTa8NAHw9ftvQZlAXEG+R5cG+NvOAavKaih+x5gA9gC2oTdjZguURdWhg7DCN/6A/Dw+0OScIw7b/44r975CbJ0DbzB6RWcG6HjLh6DUhmemLrapZFdAhVhbcE4v8Gg9wrGNGi2L6J0xGB8g63RLe72blLkBbWtmOQeXcH5pMn3fPv/k/VHPjn31T1YRzUeU9x6k/LVvwsXzrH6nkeB/w2/+v/4joXz6nCCea8x/ZOHs9TsK+9/C/uBfnrjuMcOf51RXrHZm7A7DMF/OKkYFQct/195cZvXb4/ks13cl5wk4mvy4cdXfJocJAHtLKbdiGhnMZ1GTLsRTwN/qFSeDQnMX98fFthPBtivHziuPmDmawn4i4cdGn/1L2OHmtQ8zMTeZXhthH0ZmCi2xxEj5ckxVIQGt1HQVIrIKyocGkU7gW7L08k8+ZYGG3rnO4lDO8XFj2nOfztEzbAbX5RoVOshqN6CC/8nwEB2CfI3wY9D8EgfC4v33PpHUC7B8hOQZTD4EcCF+f7RZXAtKLpQr+Paz6KjFuy9Ds/9ONy5DXVG+IYcRAbGI6imPQlNBUtRqNGbDT94D1kaxvBdHe53VQjo1kExgRtj6tdh+CbYclqyMAwN+6WPEBIKBfQ9rLfhfd8DH/nz0Fq+7zlVD97gpVd+lAk38SjqOsfrsPmTIwIVdhZUSlO7EuvBeUdpx+R5j7IaYF1FHKdAxWiySb+/x1q+zHd9599j5ewzHJ3wlDO++wajz/8tlk91iM0z/OpnfuXYLvrjK/bV8effoWRh9tx7d+UfeuykyA/0hgVbvQm7s2K/WfAvLUVp+fnnN7m+PZHPdfFA5EQRX7MPP7G6UBOQJYZGamilEe1GSAQaabTfA7DfEzA/LHB4iGC/TmCuN8DMfRQfN556nw/qk8wftvXWK9x6S/FBA41KYR1EFYyHiuFEsVUpdr0iVrCSeWylSadF83kFS0rRVGFaWjPVYVp8BN2nVznzH/wV9Oh/RlXPkySKuL00XSbXwOm/ApOvwvLHoHhzOr//JrgemI3p7VuAg/RJMBegimDvdWw5RnXeDd0nIGqjsxbsvAkv/wz81k+FjEVlYfcgVxB2z7FhjD5V0GRaUAhhcj7gNSy3YWUt9BRUJcRtsD4kD7duwWYJE6Cr4FIK/Rx6THsZCLMDsjY8/SfgW/9DaHYf8Izy+38Vl9/kzSs/yc29z4KKiHQLbz21txjVxOPwtcXZgpiEyDRIfEqUdmhlp1ldfyedlcvobOPQ1yjB2/CzlSW913+B6ur/hVdfurR4mDpyVt1zPP9wunDcOej3/wvHH47v/tgDjyYYW70J2/0wx39W7DeeLvSz2cv51G/cks9z8TWRE0Z8XT7yZEgC0tiQRpqDXoGIVhYSgW4zJjbmoDdgvydgsUhQaxYLCecLCuefe8yn8HEn8HFJw73MXvczv3iVJ1pneXb5Nh2d0+gomhpIwlS8tNmlLsdQg0WhCgfOkKw9xODa69OthSFqNKjf/W0kH/szqPYKqi6Itz+N2vr/EcU5URxB4zRkG1C/Ac1PQnIKfA4qgmQd2u+D7GFQKba/SX3n17B7X0BjIdkgWnmWaOkyfu91VNwGW+MnA9T1X4HP/nT42TWhcA8P2oV1chWh6z8GUg3NBFqt0DtQTGArh6ENzdJYwVkVmvm9KiQKI4XbApd7ohVCw1oBxsNyDE99N3zXD4SvRxlmQxCzMC2QMdCYPtFO/0XsLx3827JfLBEu7RCqCUQdsJrP/Tf/7vwf/rcV7I99/qEW/+w7Omp+OGCuC2DuG5i99jCv6I8K9obFkWl+eWl59eaAX/zKlnyWi6+ZnDTi6/bRJ1d9HGkSo0mmyUCWaBpJtF8o2G7ELLWS/cCv7tMTMF8wOJ8sHK4nWKQerGjwAQ6Yv1nfrdC6ZPfWiPN+xErXsbYUFs1BAzUUYxgNFYMayiTGrp0iXj+LaXZorJylefZpsvVHiKKwq2LkayJGxOVXSfwtMAPIToHeALNBFT+MNw0Gr/xDrn7xU6ydf5TOo3+BqPswCofJb+DGN0LC1NzALD+JSZr48SYM3kCZDN9+FPfipzCv/E+w5cI8/tiHMYpUQxxBFk2DtApFfM6GLn+tQou/IgT8nHCd2VDBNHmoXGjulsByBGffDR/89+Hpj03juGYhoLvN0CPB2v3+Ig/IE+oOhlBtAwaSpZBA+elUCg9Mtvjc3/urx47Fw73H8heP5IFqAWbf2WLUP7b7isOHqUOvO5yEwD+YVIwmocU/uz4uLJOy5ktv7vGF1/fkc1x8XeTEEb8t735oyXcaUUgCopAIZLEhm/YGNFNDqxHTbSS0GtGhIQGF0gfXF6YPcrTXYDEhODh+3v1a/yef8A/Wu/D4B/8MfncTXexRLD+OufNlyv7LaB8x3NtBJYpBkWNrIEqpnGMyGnL28iVWHv8kjZXLJGuPoJsrxFmLOEkxUUw52KLq3yLtnqEe3mX81r/muc/8j2gNSyvQbIEhotl4iOUn/hzl8A5+50tUgz3itI+OG6RLZ8gu/glUtsrklR+k+cj3Ut19kerGF4kbl0nrAZgJ1D2oPNy8AXU/JAdxFBIECGMY3oehirqGvIDSh3qB2oehg7GChx6HJ/8UvOePQXv50G/KQ70N5TYkp0ML/Mg4/HSlwv1E4WAo4Cg3d8z81WmBY5mDiSFO+Nzf/e7p3+/eQ0T3mpt/cHGvZOHg+Q/a4j8+UV38GqO8ojcqGIwrRnnFOA8BPy9Dq3/W8v/Vl7Z58bpU+ouvn5w84rftkY2WP9VNyGJDHGnSePbPTHsDDM0sotOI6TYTsuSY+gA9F9inwX6+mPBoPcHxz505ppPgWA/yBrjXa/XOf4w/+dA3s5llDOx1Wr0X2H7hF2ifXmdSx5gsRZcFRV2g6gKrLFHcQDfWaJ99D+nyZZLuWWw1CT973ArbGict3Og6ey/9MNYpxtvX2bp5B28rbA0vXInI65gib/LNH3wf5x57mHrnFYqd5+iuD9BxTbr2LKc+/B9Pi/lKfJSh0ga0lsL4/oOYFQN6N93wh5AYnGR0C1QK5Rj6b2F3vojvPIlubuCTLiiNMfF0WmAULqkJ6xF3w0JIIesLX9Pbac9Bc/oFpsdaD17zuf/qTx75+xwXZO8f7BcfPKlr/yTHtvoPdR8cfY3FIYfxfuAv98f3Z8E+ryxlZfevf+b5u7x5Zyyf3+K3RU4g8Tvi7Erml5oRa92UxOi5RCD0BszXB3SaCUvNhCjSCy37WaBXzG4fDf6HewMWagrmehTU/gf7A1An7TxwzKEPcEx183XOf/Q7WU0z0laD3bqNchHloEe8uk619SrYPZQvwyqDy4+SLD9E++L7aaw/FL5IOcZXI3zZx/VfJLnwbaATylGPyZ0XcGWfujZsPfdD5P0tqhLGQ09soNVWXPrwv8fSY38U5R3J6nn8zldQ/S+D3cT2voTlMrr1DqKzH4PT75hOTTxua5DZvL7j+ND6dqGwLgwhxOH24Bb26v+E7f1LdFRR1xG0vwXfeIq4tYJK16CxHnYUVISkQk/XC6jHUO5CeTe8Xnqaz/3gX7tPoJ9rr580rDN98Phu/bnXOOH5/j5//aOL9B28+Cw53f9/7vwcFxW9YUF/XDLKZ4v5zOb0W4oq7OZX1Y6iktX9xO8cOZHE75i1TuKbqWG1nbDUjImjMCyQxposMWSxoZFO6wOmRYLdZnoowE/jwX4yMHf9AROB+eEBPX2Rr6ml/wAHf61vnIc/+G/RWnqU0e6b1LsvkjZXUevvIS5HFMMrRDrBt7p0Ln2UbPVySGRsjrclHkM92caObmG6j1KN+4yu/gpp1sF5hS0nZKceR1W79F/973F1n9WHvhsVrWOrAVmnRWRy8Bqb36YevEk9GWBtjatLnPXErUdonPkIhgpvK3SyhPc5OmqCSqlqi0lX8SoNLXJb4ewIu/s8+a2fwlORNk6hogzlejg3AT9Bp8sYHYO/ibM15RBM5wn06h/Fp2v49BRx6yxEGeiYKI749R/6Cwu/6OP6de4d6E/oCVJzAfjooXOve6+/7uJjJ6zTs/A6apZgzicBCiZ5zd4oDy3+Sejun0yn9B0Efks1Df5X7o74uec25TNb/I6Rk0n8jju9lPp2FrG+lNBIov3agDQ2ZLEmmw4LtLKwbsBSM6GZxfsBn2kvwEECcDQhOGlo4OhQwWJB4cFn+8mn/oMOH9znoQc2H28ef/83EJ//MK3lR8EVqGwt1OVtv4Atx0Tr78PmQ8rdK/hygB3dxuV3SVaeAh1jlh8haa2QLZ3GT7ZRvRdQe/+aUe9XqJ3FxOukyWMo3cH7Elfv4t0euH5Yj4ASfISrm9hKg4tROiVubGDLHvngDWwVuum9dSgd9lHQxqBMPR0M98RJCx13QTm0G4AbA1DVhjp6Ny+/sHvkF3k4OB/+3RwcerR755jOgK+rBsAfOuLozQc4bxYC/UGv1uzLTYqavWEI/IPJbIx/Npe/pqhCS7+qHaV1XL074m6v4MtXevJ5LX5HyQkl/o0JwwIxp5dTYnPQG5DG5si0wWw6c6CZxWRxGGPeD/yz6yz2BuwnCSfUDRyeRqjnPoz3hwhOeAec0IY89h3z9b6JvpZEY95H/+pPoAATRRAl4YfIh9OxcxO2s917Gbb/ERS/DNaGWQaqxX51vo8JUwTDaoTe5th6jLN9XH0daytwGu9jwnJ/Fm3aeO+xeY61E/A53ntefnNxLv3xP9dx4X3ukGOedO9W/gmveaS3Z9YKP/FbOvJFDmbiH37S0e/+2KA/vT2fvIIiLyv2hgX9UbHf4g9j/Add/UXlqOrQ5X9ta8zdvZzeuOaNO7Kyn/idJyeV+DdqrZP4VmpYaSestpOFYYFZfUAam/3rWRJN9xuIaWYRsdH7gX/24b4Y/KcBnsXkYLE34ISaAph7zaOB4mt6cxwJPCccdOKtex762zvshKB439e8b3LEwi/sxFe9x9c/qVF9YmA99jXnrp0Y6O/3mzr+iYe/j8Xv7egxav/Qg2Qzr0KLfyHw54tj/Pst/tpxY3vM7d2c3riSJX3Fv1FyconfFaeXUt9pRJzqprSz6bBAFJKAOJoWDUaaZJYIxLNkIKKZRbSyeH/K35EegP371LEJgT702Oz4hWLBwwnB/vX7V4DPfK0t+uMffrAM5EHfuA/+vX+dPR2z399JP809k4ijWdPh1vxJ39vhlz3cnT//Wv7IPUdvHl1kar4H4vCKlAe354P9ftBXiqq20/n6IeAPpwV+4yIU+IVq/pqycpTTFv/N7Qm39ybsjSpeuyWBX/ybJyeZ+F11biXzS62YM8vZfuCPjCI2Ovyb1QtEZn+oIIsNWXowRNBIo7megMWgfuT6cffNXdeHgvz85SxILdYmHHzoH+deQfK+x51ELVzc+6DDt76uJISDH/hexx0TiOdC+/1/7kPf5OHHjvuJjm3h3/sbOvHo+W90/ls5qDE4Jgk4dF7MB/2yqveD/mQW6KuaorRzgb/eb/GX0xb/7Z0Jt3Yn7I4qXr05lM9k8btGTjbxu25+WGCtkxKZsO5/pDVxpA4SgUiTTBOBZDaTIInC2gLTXoEkNgs9AQdB+qD1Px/Ej51dcOj6fBDYTwjmr88eV4fuP/Envk9L9x7ukWvc+zn3yBru+3LHPvWYW/d6bXWvZx/3NQ4df9zv677dGff8ho4ecSSwLwZ+NfeHXUwGp397pSjKmtGkZFzMj+eHoF9WlqIOY/rFdP7+wZQ+y53dnJs7YWOflyXwi98DctKJ3zOzYYF2Fv41UkNkNJFWRNMkIDaKODL7vQLJXO3AfOFgK4uJpvUCh5OA+Vb7Sb0GzF0/EtTn4reaCxpHewsOnn9sEH2AwHrsIw/4Lj2plX5s8Dvh2PuH2OMTi5MD/PFB+aSvc1xX/n2+0sk/46EsRR26f/5vdvhyfmho/75whbyYX6GvOijiK2vKerGQr6odlXXUtaOoLVXl2Ozn3NgaszOseOmGrOQnfu/IySd+z51bzXwa6enywYZOIyaNNZEOwwNRpA/1CoRagfniwdArENOcTi2cfVgrjvYMTB9aSARCi46D3oT5FiH3SwiOf+39LmQWnzt3sfAaLBz74F0GJz70gAnHSa35E591v6TiSAw/+nv8Gr7akS9+NNk4HOTV0Z/9cDGhWmz5H+7OD4cc9ASM84pRXjLOKyZFtbhIz34R36Ggbx219dTWYa1ne5BzfWvM9iBs5nNtS7btFb+35AQUv2+cWU79rBhwtr1wtxkfDA/MJQNJNKsXMNN6AU2aRDQSQ2M6gyBLwr/DPQP7H/pz952YCEzvm7uYu2+xGGwxOTg6LLHv60gMDrdeDx97nPsF26OFb4cfP/ZJcxdfS9Zw9I7jHz7hlY+twj903zFBfv5lF4d1DheATm/v9xopRnkZuvf3F+g5GMMvFyr3w2VtZ4H/IOgXlWVnULDVL9geFAzymqubEvjF7w9yIorfd9a7iY/3dxjUNNOIThbG/eeHB8KlIjGGOD6YVZBOZxAk8XwNwayoMArrDKjjgvfimgNHbs8cun1c4F943UP3LTxv4TWPCZAP2GOweMziN3ivHoLjHztc9X7S1zl0z30/TRYD8rFf9cj3ffi+Q637hSD/IAH/6MyPgymmiuGkmCvkC4G/2K/Yt/tV+7NW/nxr31pH7Tx5GYJ+2LbXMsprBpOatzZl7X7x+4uckOL3tY2laa/AdJfBVmboNmPS2IRkYNojEB0aIoij6fTCWS3BtKBwNnxwMIQQegmMUfvBZRb0Ya534J6Be+7+I4Hn0P3zx98vuM4lEEce/7oC/MkJxrFHHZOUHI31985GTuopUId+kKNFf/OB/oSg/zUE/IPCvYProYVeT1vz9X5Lf76Qb7Yc7/ySvLPWfj0N+LV1+0G/Ny6na/lb8ipU+V+5K4Ff/P4kJ6b4A+PsSuaTSE13GTS0GxFLzQQznUYYmWnvwDQhmN1euH9/CMHsJwxxfNBLkMURaRKRxmYugD9oC352zGLYU4cCmTp0/OHXPfb1D732cb6mVvtxXeoc/vkOBd4Tnv+1vP6R4Y+5b/rkrz3/eztatb+4iNPx4/iVddNldqct+dpSzVXkV9ZRzrX0H6R7f1LWbPdnm/hM1/CXoC/+AJGTVPyBc3op9bFRYWpgbGilhk5zNhMg1AsYozB69m+WBMyuz5IBRWwO9xQczDRI5noIsiTC6Lkegv23znSZmUOt5cOtfzgUyOYeO3z/cY4G2Hs8dviwE568+L0dfOP3TAiOeb39Vzvu/iPj8sf9nhZ7Ae4Z8A9dHu7OR4X5+KH1Phfs51rxde2orJ1ehmA+C/Bltdi9P7t/1r0/zmt2Bjn9ccVwGvQLCfriDyg5YcUfaPuFg7GmkRhaWegVSGKNUQqt5xMBhTEaoxXR9PpBL8HiUMLhhGCWDOzXEUx7CWYWA9zBjSM9Bic8flyvwLx7JQAn33Xw4urwvfMt78VD555zNKE57jkL9y68zqHEZqHVftxz5gP/cYF+sXUP7LfqZ4V5ZXU42Nu5ivyDFnxtHdZ57OzShcdmU/Zm3fvWOkYS9MUfUnLyij80zq1mPplLBmZFgY3pmgFGM5cQ6LmkYL6XYG764dyQwX5SEJtQSzA3DdEsDDtM/0VmugjRCV3ph4Oy2j9y7vb9PVjPgDryegtd73MHP3ACcLhn4KSehGOC/kLic6iIT8FCsJ8d41wYry/mqvBn3fizLvzZZV0vBvxZcLcutPatmwV9j5tder+fENTOM5pU7AzCevwjCfriDyk5kcUfOhvLqQ9LC6v9QH6w90BYb6CRhumBRoUkQO8nAgdDCPuXx9QXzHoHYqP3EwgznaFgposZmbmEYP56fEySAIdaxeHKA71B1aEr84H/+ERj7qt8DYH/ni18dfj7ng/6xwf8+ZZ8CM4HrfEQnEM3fDkf8Pcr8A+68Pdb9LPx+f2AH15rFuQPB3w3ve18+DfKq2n1vgR98fYgJ7X4Q21jOfVGzQX3WUJgVNiAaH8hoWlrfpYMzHoIzHS4YD8pmA/sIUmY9Srowz0Lc0MORp+QKMzVJRz0OJiF6+pIYF+8MR+MDx+3MMZ+3POOHaOfe85JLXvmgvl878X0wYPu9YNgbq0/uD4Lxt7tB2K7H5DdfmCurT+mG38a4Oe66ecTB3v49ZzH+rlg7zzDyWzp3rBEb1lZJqWVoC/eVuQEF287Z1cyPwvQYSMitd/FP9umuDHdfOggsC8WFc6SAa0VWi1emsPXDycIar7HQR953VlCMOuFmO9BiCO9v8Xx4rj40THz4++bX/DoYB68mjtmYf2DuWOcXwy2zh10q88H81mQPyn4zi79kfsJ9+0/zjQJOH7MfpZQ2LnWvD30dWrrpvP654N9CPBh2MBTT3sMJOiLtxs52cXb3tmVzGtN6PLXcwnBdNggm/YSNKfbGO8nBEqjdQiOWk13FpwFf6XQmiPJgZ4bctBa7ScD84nDLBnQZi4xmEsQ9FzAnrXYF5ch/hrvf8Dner8YbA8H9IXAPnffLJAfPHYQ6P2x18Pl7HmzcfvD4/WHv3ZVO4aTg2V68/Jgx72DBXvCc2eXsjiPeDuTk1+IQ84spws9BLPu/oM6gmlCkEYk02EDpdhvmWvFocvjkoNw33E9CPfrSTi6YNHhdQpOKqY7WpC32I0/1wvA4QSAg0A+C877AX4+aB8f4GfPnb/tvcezeNt58ITbTB8/LtgXlZ0uuDNduKea1grUjmq/0t/P1QJIsBfiMHlDCPEAzq2GYYPZUsTR/rDBwVh/tJAwzO1ZEJsHSAqm9x/Tg6AOJQazgAyLRXXz4/fHJQSHW/YHjy+2/BeeN1cDMB+sTwzu3CfIL1wPdyw8D/YDv58usZCXNaP9VfrCIj3F3Kp8lfWHagGQYC/EA5A3iRBfh1lCYOYC+EGQZn9cf9ZqnxUSzvcoxNMivyQOyYI6KSmYvubs+nyx3ZFFhOaTgIXbHCrgm13eO4E4eEzNBeZZcD8U8GHhOscF9un12h5aUvdwQd+sq965hTH7Wau+niv4k811hPj6yBtHiN9B51Yyvz8cMKsBUIdrATi6SJFZXJzo6P4GYWbA/Dg9HA78au76gYVegIXHjy5EtH/kkd6A4HDgD/eFQHyvgF7PCgXnivaOdu3PagUOhhpmQX6WEFyVLXSF+B0jbyYhfpedX838wnDAfqJwcP242QfRNFHQh6ffHTckoA5a7gf1AAdV/ScV+t3red77gwV15oLy8YV5B0F8/vrh4QPnWRgycEiLXojfLfJGE+L3mVmCMOtJOBheOKgJAI7ppp+7frgVf7/HF17r+GEFf6iFPgvg9wvo3sM1abkL8fuOvCmF+EPk/Frmj2zhy2ICcOjqYtf//N3HfDrMgrwEdCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBC/MH0/wdeRomSb4SlSwAAAABJRU5ErkJggg==",
        "encoding": "base64",
        "path": [
         "value"
        ]
       }
      ],
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "2.0.0",
      "model_name": "ImageModel",
      "state": {
       "layout": "IPY_MODEL_cbaa210c38594d61a81277598525f1db"
      }
     },
     "0d849e8d200f438390e608e291b9eda1": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "2.0.0",
      "model_name": "LayoutModel",
      "state": {}
     },
     "148040a250554e5a81f69c431f5e7213": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "2.0.0",
      "model_name": "LayoutModel",
      "state": {}
     },
     "14f38f2c3e8e45d892c2e16374a327ea": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "2.0.0",
      "model_name": "DescriptionStyleModel",
      "state": {
       "description_width": ""
      }
     },
     "18f37e7ff18a4102b1cb532e491d6c77": {
      "model_module": "@jupyter-widgets/output",
      "model_module_version": "1.0.0",
      "model_name": "OutputModel",
      "state": {
       "layout": "IPY_MODEL_ff5f438dc17b4b169823824e86917a78"
      }
     },
     "1b867460a1444ee6b0f34b4c65d8a86f": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "2.0.0",
      "model_name": "LayoutModel",
      "state": {}
     },
     "1c2b457935114bb7985c03a94b723533": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "2.0.0",
      "model_name": "LayoutModel",
      "state": {}
     },
     "29c1abdcc17448039092b667c074f5fe": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "2.0.0",
      "model_name": "LayoutModel",
      "state": {}
     },
     "2a70f25cc3f345c4be89a35511826665": {
      "model_module": "ipycanvas",
      "model_module_version": "^0.13",
      "model_name": "CanvasModel",
      "state": {
       "_canvas_manager": "IPY_MODEL_057995c02bb54f4683e087d9517cd518",
       "_model_module_version": "^0.13",
       "_view_module_version": "^0.13",
       "height": 512,
       "layout": "IPY_MODEL_9d8fa33f71334c3da7d6a3be92b69832",
       "width": 512
      }
     },
     "2d57bf5226ac47f59990dc3b9cc7fe85": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "2.0.0",
      "model_name": "LayoutModel",
      "state": {}
     },
     "2def9608e0804dcfaebe5e7f1f34ac79": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "2.0.0",
      "model_name": "LayoutModel",
      "state": {}
     },
     "33f50439d62940ee9307d0f02717a895": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "2.0.0",
      "model_name": "VBoxModel",
      "state": {
       "children": [
        "IPY_MODEL_f8784f5b7b934c1dbaec1fe139fc7882",
        "IPY_MODEL_644d30351a154bb6b18bcd551ee92628",
        "IPY_MODEL_77a7239a42bc4747a26da8cfc264e5b7"
       ],
       "layout": "IPY_MODEL_148040a250554e5a81f69c431f5e7213"
      }
     },
     "36d1226e7bc840ee9218e9251d7c0c16": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "2.0.0",
      "model_name": "LayoutModel",
      "state": {}
     },
     "3998cbe5b8f34ca0aa514d7021f99636": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "2.0.0",
      "model_name": "LayoutModel",
      "state": {
       "height": "500px",
       "width": "500px"
      }
     },
     "3a27767c2af8456a931afd3ead798de2": {
      "model_module": "ipycanvas",
      "model_module_version": "^0.13",
      "model_name": "CanvasModel",
      "state": {
       "_canvas_manager": "IPY_MODEL_057995c02bb54f4683e087d9517cd518",
       "_model_module_version": "^0.13",
       "_view_count": 1,
       "_view_module_version": "^0.13",
       "height": 512,
       "layout": "IPY_MODEL_45dcb73d20dc468cb6cb1782a37bbe23",
       "width": 512
      }
     },
     "3bc97411abdc47aaaba7d3efa8db2dec": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "2.0.0",
      "model_name": "LayoutModel",
      "state": {}
     },
     "45dcb73d20dc468cb6cb1782a37bbe23": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "2.0.0",
      "model_name": "LayoutModel",
      "state": {}
     },
     "49d478905050439daa1cb56b1f19c41f": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "2.0.0",
      "model_name": "LayoutModel",
      "state": {}
     },
     "4f6467a481fd462ca57850bc3170e6fc": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "2.0.0",
      "model_name": "LayoutModel",
      "state": {}
     },
     "52845bdda1a94054960ce138fb139966": {
      "buffers": [
       {
        "data": "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",
        "encoding": "base64",
        "path": [
         "value"
        ]
       }
      ],
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "2.0.0",
      "model_name": "ImageModel",
      "state": {
       "layout": "IPY_MODEL_adc9877c1cf243509c714321bf0f26a1"
      }
     },
     "57ae78b546bf472fa9bbc04526753cd9": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "2.0.0",
      "model_name": "LayoutModel",
      "state": {}
     },
     "585bf0d982c54678ae87579ebcae75a6": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "2.0.0",
      "model_name": "LayoutModel",
      "state": {}
     },
     "588ce5762fc142b6a77aae2fb1bc3109": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "2.0.0",
      "model_name": "LayoutModel",
      "state": {}
     },
     "62ae43bc91274e14a843fd377d5c061f": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "2.0.0",
      "model_name": "HBoxModel",
      "state": {
       "children": [
        "IPY_MODEL_3a27767c2af8456a931afd3ead798de2",
        "IPY_MODEL_79dac9073cbb42759310dac7e77931c2"
       ],
       "layout": "IPY_MODEL_57ae78b546bf472fa9bbc04526753cd9"
      }
     },
     "644d30351a154bb6b18bcd551ee92628": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "2.0.0",
      "model_name": "DropdownModel",
      "state": {
       "_options_labels": [
        "red",
        "blue",
        "green",
        "purple",
        "#cc3333"
       ],
       "description": "Background:",
       "index": 0,
       "layout": "IPY_MODEL_3bc97411abdc47aaaba7d3efa8db2dec",
       "style": "IPY_MODEL_14f38f2c3e8e45d892c2e16374a327ea"
      }
     },
     "6d641eb2dc2243bd96695ed6a6959797": {
      "model_module": "@jupyter-widgets/output",
      "model_module_version": "1.0.0",
      "model_name": "OutputModel",
      "state": {
       "layout": "IPY_MODEL_b19b56873f43476f8c7697d405df4f47"
      }
     },
     "7088a20bf7314ff4b4da7e56d5a94f09": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "2.0.0",
      "model_name": "LayoutModel",
      "state": {}
     },
     "72d33316592b40a89d3623e8bc09a09b": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "2.0.0",
      "model_name": "SliderStyleModel",
      "state": {
       "description_width": ""
      }
     },
     "77a7239a42bc4747a26da8cfc264e5b7": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "2.0.0",
      "model_name": "HBoxModel",
      "state": {
       "children": [
        "IPY_MODEL_18f37e7ff18a4102b1cb532e491d6c77",
        "IPY_MODEL_6d641eb2dc2243bd96695ed6a6959797"
       ],
       "layout": "IPY_MODEL_7088a20bf7314ff4b4da7e56d5a94f09"
      }
     },
     "79dac9073cbb42759310dac7e77931c2": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "2.0.0",
      "model_name": "VBoxModel",
      "state": {
       "_dom_classes": [
        "widget-interact"
       ],
       "children": [
        "IPY_MODEL_7df0d4a8db1f40e99f268dcd2c8e4d8a",
        "IPY_MODEL_cc4529d0cd0b4626996a671e0827e909",
        "IPY_MODEL_7d61884c6a204feeb28f8bd57a886e08",
        "IPY_MODEL_7ab00525f23f4b558a7d72461f3a61a7",
        "IPY_MODEL_ac9925e8cdd14183a81ed60ae9a6f96b"
       ],
       "layout": "IPY_MODEL_1c2b457935114bb7985c03a94b723533"
      }
     },
     "7ab00525f23f4b558a7d72461f3a61a7": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "2.0.0",
      "model_name": "FloatSliderModel",
      "state": {
       "behavior": "drag-tap",
       "description": "Sharpness:\n",
       "layout": "IPY_MODEL_c4ec426ac77949db8bb3b1e1c47fef91",
       "max": 20,
       "min": 0.1,
       "readout_format": ".1f",
       "step": 0.1,
       "style": "IPY_MODEL_72d33316592b40a89d3623e8bc09a09b",
       "value": 5
      }
     },
     "7c469b8c6d474299ad7889ceb1721535": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "2.0.0",
      "model_name": "LayoutModel",
      "state": {}
     },
     "7d61884c6a204feeb28f8bd57a886e08": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "2.0.0",
      "model_name": "FloatSliderModel",
      "state": {
       "behavior": "drag-tap",
       "description": "Amplitude:\n",
       "layout": "IPY_MODEL_49d478905050439daa1cb56b1f19c41f",
       "max": 20,
       "min": 0.1,
       "readout_format": ".1f",
       "step": 0.1,
       "style": "IPY_MODEL_db12a40b37af4f6da437a309f96ad290",
       "value": 3
      }
     },
     "7df0d4a8db1f40e99f268dcd2c8e4d8a": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "2.0.0",
      "model_name": "FloatSliderModel",
      "state": {
       "behavior": "drag-tap",
       "description": "Elevation:",
       "layout": "IPY_MODEL_2def9608e0804dcfaebe5e7f1f34ac79",
       "max": 1.5707963267948966,
       "min": -1.5707963267948966,
       "readout_format": ".1f",
       "step": 0.1,
       "style": "IPY_MODEL_c09c20c5e8b94626aaf3a71b8be82bf1",
       "value": 1.0292036732051035
      }
     },
     "80d8616ee0dd48ceb5a80ce2fefa4d7b": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "2.0.0",
      "model_name": "LayoutModel",
      "state": {}
     },
     "85674eb8dca343f3b282dd578098090c": {
      "model_module": "ipyevents",
      "model_module_version": "2.0.2",
      "model_name": "EventModel",
      "state": {
       "_supported_key_events": [
        "keydown",
        "keyup"
       ],
       "_supported_mouse_events": [
        "click",
        "auxclick",
        "dblclick",
        "mouseenter",
        "mouseleave",
        "mousedown",
        "mouseup",
        "mousemove",
        "wheel",
        "contextmenu",
        "dragstart",
        "drag",
        "dragend",
        "dragenter",
        "dragover",
        "dragleave",
        "drop"
       ],
       "_supported_touch_events": [
        "touchstart",
        "touchend",
        "touchmove",
        "touchcancel"
       ],
       "_view_module": "@jupyter-widgets/controls",
       "prevent_default_action": true,
       "source": "IPY_MODEL_c132d3e57fe7413b9f500b46a5b86751",
       "throttle_or_debounce": "throttle",
       "wait": 41,
       "watched_events": [
        "wheel",
        "mousedown",
        "mouseup",
        "mousemove",
        "mouseleave",
        "mouseenter",
        "contextmenu"
       ],
       "xy_coordinate_system": ""
      }
     },
     "874275ca2f98410d94f8b55848894e69": {
      "model_module": "ipyevents",
      "model_module_version": "2.0.2",
      "model_name": "EventModel",
      "state": {
       "_supported_key_events": [
        "keydown",
        "keyup"
       ],
       "_supported_mouse_events": [
        "click",
        "auxclick",
        "dblclick",
        "mouseenter",
        "mouseleave",
        "mousedown",
        "mouseup",
        "mousemove",
        "wheel",
        "contextmenu",
        "dragstart",
        "drag",
        "dragend",
        "dragenter",
        "dragover",
        "dragleave",
        "drop"
       ],
       "_supported_touch_events": [
        "touchstart",
        "touchend",
        "touchmove",
        "touchcancel"
       ],
       "_view_module": "@jupyter-widgets/controls",
       "prevent_default_action": true,
       "source": "IPY_MODEL_c132d3e57fe7413b9f500b46a5b86751",
       "throttle_or_debounce": "throttle",
       "wait": 41,
       "watched_events": [
        "wheel",
        "mousedown",
        "mouseup",
        "mousemove",
        "mouseleave",
        "mouseenter",
        "contextmenu"
       ],
       "xy_coordinate_system": ""
      }
     },
     "87d07716578948c3a1980843d83eb0a5": {
      "buffers": [
       {
        "data": "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",
        "encoding": "base64",
        "path": [
         "value"
        ]
       }
      ],
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "2.0.0",
      "model_name": "ImageModel",
      "state": {
       "layout": "IPY_MODEL_e77ebcb6119b4713b7fb144772769bff"
      }
     },
     "87f7e8eb9f1d4e1f8f763fb26649196f": {
      "model_module": "@jupyter-widgets/output",
      "model_module_version": "1.0.0",
      "model_name": "OutputModel",
      "state": {
       "layout": "IPY_MODEL_ee03169c8e3a4d4589dd2f830fb67a49"
      }
     },
     "88372a643a7d477ca08bc3fede268b2b": {
      "model_module": "ipyevents",
      "model_module_version": "2.0.2",
      "model_name": "EventModel",
      "state": {
       "_supported_key_events": [
        "keydown",
        "keyup"
       ],
       "_supported_mouse_events": [
        "click",
        "auxclick",
        "dblclick",
        "mouseenter",
        "mouseleave",
        "mousedown",
        "mouseup",
        "mousemove",
        "wheel",
        "contextmenu",
        "dragstart",
        "drag",
        "dragend",
        "dragenter",
        "dragover",
        "dragleave",
        "drop"
       ],
       "_supported_touch_events": [
        "touchstart",
        "touchend",
        "touchmove",
        "touchcancel"
       ],
       "_view_module": "@jupyter-widgets/controls",
       "prevent_default_action": true,
       "source": "IPY_MODEL_8e0d056954494663ad27d16030c5ca2b",
       "throttle_or_debounce": "throttle",
       "wait": 41,
       "watched_events": [
        "wheel",
        "mousedown",
        "mouseup",
        "mousemove",
        "mouseleave",
        "mouseenter",
        "contextmenu",
        "keydown",
        "keyup"
       ],
       "xy_coordinate_system": ""
      }
     },
     "8cd00d0d59e84b11a66e8a7381f4284d": {
      "model_module": "ipyevents",
      "model_module_version": "2.0.2",
      "model_name": "EventModel",
      "state": {
       "_supported_key_events": [
        "keydown",
        "keyup"
       ],
       "_supported_mouse_events": [
        "click",
        "auxclick",
        "dblclick",
        "mouseenter",
        "mouseleave",
        "mousedown",
        "mouseup",
        "mousemove",
        "wheel",
        "contextmenu",
        "dragstart",
        "drag",
        "dragend",
        "dragenter",
        "dragover",
        "dragleave",
        "drop"
       ],
       "_supported_touch_events": [
        "touchstart",
        "touchend",
        "touchmove",
        "touchcancel"
       ],
       "_view_module": "@jupyter-widgets/controls",
       "prevent_default_action": true,
       "source": "IPY_MODEL_3a27767c2af8456a931afd3ead798de2",
       "throttle_or_debounce": "throttle",
       "wait": 41,
       "watched_events": [
        "wheel",
        "mousedown",
        "mouseup",
        "mousemove",
        "mouseleave",
        "mouseenter",
        "contextmenu",
        "keydown"
       ],
       "xy_coordinate_system": ""
      }
     },
     "8e0d056954494663ad27d16030c5ca2b": {
      "model_module": "ipycanvas",
      "model_module_version": "^0.13",
      "model_name": "CanvasModel",
      "state": {
       "_canvas_manager": "IPY_MODEL_057995c02bb54f4683e087d9517cd518",
       "_model_module_version": "^0.13",
       "_view_count": 1,
       "_view_module_version": "^0.13",
       "height": 512,
       "layout": "IPY_MODEL_29c1abdcc17448039092b667c074f5fe",
       "width": 512
      }
     },
     "8e836f5d2fe04969a258c16249da98a9": {
      "buffers": [
       {
        "data": "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",
        "encoding": "base64",
        "path": [
         "value"
        ]
       }
      ],
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "2.0.0",
      "model_name": "ImageModel",
      "state": {
       "layout": "IPY_MODEL_585bf0d982c54678ae87579ebcae75a6"
      }
     },
     "944583172c5b471d9898fa8c0ff37840": {
      "model_module": "ipycanvas",
      "model_module_version": "^0.13",
      "model_name": "CanvasModel",
      "state": {
       "_canvas_manager": "IPY_MODEL_057995c02bb54f4683e087d9517cd518",
       "_model_module_version": "^0.13",
       "_view_count": 1,
       "_view_module_version": "^0.13",
       "height": 512,
       "layout": "IPY_MODEL_4f6467a481fd462ca57850bc3170e6fc",
       "width": 512
      }
     },
     "983296ba520d485c8bed23006b6c3cae": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "2.0.0",
      "model_name": "LayoutModel",
      "state": {}
     },
     "9c237c2155aa4bdd9b0caa8d5e9c7cb2": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "2.0.0",
      "model_name": "LayoutModel",
      "state": {}
     },
     "9d8fa33f71334c3da7d6a3be92b69832": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "2.0.0",
      "model_name": "LayoutModel",
      "state": {}
     },
     "a51d5b82bebc47b2a531ea0a46225215": {
      "buffers": [
       {
        "data": "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",
        "encoding": "base64",
        "path": [
         "value"
        ]
       }
      ],
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "2.0.0",
      "model_name": "ImageModel",
      "state": {
       "layout": "IPY_MODEL_0d849e8d200f438390e608e291b9eda1"
      }
     },
     "ac9925e8cdd14183a81ed60ae9a6f96b": {
      "model_module": "@jupyter-widgets/output",
      "model_module_version": "1.0.0",
      "model_name": "OutputModel",
      "state": {
       "layout": "IPY_MODEL_7c469b8c6d474299ad7889ceb1721535"
      }
     },
     "adc9877c1cf243509c714321bf0f26a1": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "2.0.0",
      "model_name": "LayoutModel",
      "state": {}
     },
     "ae8a29f78a334533b4c81ccd3e716cf5": {
      "model_module": "@jupyter-widgets/output",
      "model_module_version": "1.0.0",
      "model_name": "OutputModel",
      "state": {
       "layout": "IPY_MODEL_07815ff4d97a4917b4a920c0fa1ded35"
      }
     },
     "aec9730790134651828b789e27299380": {
      "model_module": "ipycanvas",
      "model_module_version": "^0.13",
      "model_name": "MultiCanvasModel",
      "state": {
       "_canvas_manager": "IPY_MODEL_057995c02bb54f4683e087d9517cd518",
       "_canvases": [
        "IPY_MODEL_ee9605ae57b74dcc8279099f5f8019dd",
        "IPY_MODEL_bb45660e3f4b4a96983acd4d374279e4"
       ],
       "_model_module_version": "^0.13",
       "_view_module_version": "^0.13",
       "height": 512,
       "layout": "IPY_MODEL_3998cbe5b8f34ca0aa514d7021f99636",
       "width": 512
      }
     },
     "b19b56873f43476f8c7697d405df4f47": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "2.0.0",
      "model_name": "LayoutModel",
      "state": {}
     },
     "bb45660e3f4b4a96983acd4d374279e4": {
      "model_module": "ipycanvas",
      "model_module_version": "^0.13",
      "model_name": "CanvasModel",
      "state": {
       "_canvas_manager": "IPY_MODEL_057995c02bb54f4683e087d9517cd518",
       "_model_module_version": "^0.13",
       "_view_module_version": "^0.13",
       "height": 512,
       "layout": "IPY_MODEL_36d1226e7bc840ee9218e9251d7c0c16",
       "width": 512
      }
     },
     "c09c20c5e8b94626aaf3a71b8be82bf1": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "2.0.0",
      "model_name": "SliderStyleModel",
      "state": {
       "description_width": ""
      }
     },
     "c132d3e57fe7413b9f500b46a5b86751": {
      "model_module": "ipycanvas",
      "model_module_version": "^0.13",
      "model_name": "MultiCanvasModel",
      "state": {
       "_canvas_manager": "IPY_MODEL_057995c02bb54f4683e087d9517cd518",
       "_canvases": [
        "IPY_MODEL_2a70f25cc3f345c4be89a35511826665",
        "IPY_MODEL_ebb8945ba8854dc9adf1184167b17ec5"
       ],
       "_model_module_version": "^0.13",
       "_view_count": 1,
       "_view_module_version": "^0.13",
       "height": 512,
       "layout": "IPY_MODEL_06ecd236087d49bc8046c46556fcba36",
       "width": 512
      }
     },
     "c497736e857b4e588f512c1b93ded194": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "2.0.0",
      "model_name": "LayoutModel",
      "state": {}
     },
     "c4ec426ac77949db8bb3b1e1c47fef91": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "2.0.0",
      "model_name": "LayoutModel",
      "state": {}
     },
     "cbaa210c38594d61a81277598525f1db": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "2.0.0",
      "model_name": "LayoutModel",
      "state": {}
     },
     "cc4529d0cd0b4626996a671e0827e909": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "2.0.0",
      "model_name": "FloatSliderModel",
      "state": {
       "behavior": "drag-tap",
       "description": "Azimuth:",
       "layout": "IPY_MODEL_9c237c2155aa4bdd9b0caa8d5e9c7cb2",
       "max": 3.141592653589793,
       "min": -3.141592653589793,
       "readout_format": ".1f",
       "step": 0.1,
       "style": "IPY_MODEL_f94db071097947ddab0e000c1dfb3d60",
       "value": -0.04159265358979303
      }
     },
     "d4114cbb2bb7460ea91ae276acb25e42": {
      "buffers": [
       {
        "data": "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",
        "encoding": "base64",
        "path": [
         "value"
        ]
       }
      ],
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "2.0.0",
      "model_name": "ImageModel",
      "state": {
       "layout": "IPY_MODEL_80d8616ee0dd48ceb5a80ce2fefa4d7b"
      }
     },
     "db12a40b37af4f6da437a309f96ad290": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "2.0.0",
      "model_name": "SliderStyleModel",
      "state": {
       "description_width": ""
      }
     },
     "e409675c46b34e119b9bfa46c50f364b": {
      "model_module": "ipyevents",
      "model_module_version": "2.0.2",
      "model_name": "EventModel",
      "state": {
       "_supported_key_events": [
        "keydown",
        "keyup"
       ],
       "_supported_mouse_events": [
        "click",
        "auxclick",
        "dblclick",
        "mouseenter",
        "mouseleave",
        "mousedown",
        "mouseup",
        "mousemove",
        "wheel",
        "contextmenu",
        "dragstart",
        "drag",
        "dragend",
        "dragenter",
        "dragover",
        "dragleave",
        "drop"
       ],
       "_supported_touch_events": [
        "touchstart",
        "touchend",
        "touchmove",
        "touchcancel"
       ],
       "_view_module": "@jupyter-widgets/controls",
       "prevent_default_action": true,
       "source": "IPY_MODEL_944583172c5b471d9898fa8c0ff37840",
       "throttle_or_debounce": "throttle",
       "wait": 41,
       "watched_events": [
        "wheel",
        "mousedown",
        "mouseup",
        "mousemove",
        "mouseleave",
        "mouseenter",
        "contextmenu"
       ],
       "xy_coordinate_system": ""
      }
     },
     "e77ebcb6119b4713b7fb144772769bff": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "2.0.0",
      "model_name": "LayoutModel",
      "state": {}
     },
     "ebb8945ba8854dc9adf1184167b17ec5": {
      "model_module": "ipycanvas",
      "model_module_version": "^0.13",
      "model_name": "CanvasModel",
      "state": {
       "_canvas_manager": "IPY_MODEL_057995c02bb54f4683e087d9517cd518",
       "_model_module_version": "^0.13",
       "_view_module_version": "^0.13",
       "height": 512,
       "layout": "IPY_MODEL_2d57bf5226ac47f59990dc3b9cc7fe85",
       "width": 512
      }
     },
     "ee03169c8e3a4d4589dd2f830fb67a49": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "2.0.0",
      "model_name": "LayoutModel",
      "state": {}
     },
     "ee9605ae57b74dcc8279099f5f8019dd": {
      "model_module": "ipycanvas",
      "model_module_version": "^0.13",
      "model_name": "CanvasModel",
      "state": {
       "_canvas_manager": "IPY_MODEL_057995c02bb54f4683e087d9517cd518",
       "_model_module_version": "^0.13",
       "_view_module_version": "^0.13",
       "height": 512,
       "layout": "IPY_MODEL_588ce5762fc142b6a77aae2fb1bc3109",
       "width": 512
      }
     },
     "f8784f5b7b934c1dbaec1fe139fc7882": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "2.0.0",
      "model_name": "HBoxModel",
      "state": {
       "children": [
        "IPY_MODEL_c132d3e57fe7413b9f500b46a5b86751",
        "IPY_MODEL_aec9730790134651828b789e27299380"
       ],
       "layout": "IPY_MODEL_983296ba520d485c8bed23006b6c3cae"
      }
     },
     "f94db071097947ddab0e000c1dfb3d60": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "2.0.0",
      "model_name": "SliderStyleModel",
      "state": {
       "description_width": ""
      }
     },
     "fc0ada76a2bf4380880d81c5a302b90b": {
      "model_module": "@jupyter-widgets/output",
      "model_module_version": "1.0.0",
      "model_name": "OutputModel",
      "state": {
       "layout": "IPY_MODEL_1b867460a1444ee6b0f34b4c65d8a86f"
      }
     },
     "ff5f438dc17b4b169823824e86917a78": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "2.0.0",
      "model_name": "LayoutModel",
      "state": {}
     }
    },
    "version_major": 2,
    "version_minor": 0
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}