diff --git a/Autograd25WaveguideCrossing.ipynb b/Autograd25WaveguideCrossing.ipynb new file mode 100644 index 00000000..cacd64d5 --- /dev/null +++ b/Autograd25WaveguideCrossing.ipynb @@ -0,0 +1,2106 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "18c8ebd2-739f-4821-ad99-864c433014df", + "metadata": {}, + "source": [ + "# Topology optimization of a waveguide crossing\n", + "\n", + "In this example, we will walk you through performing a simple inverse design optimization of a 3D waveguide bend.\n", + "\n", + "In this example, we'll be using a pixelated material grid to define the design region. However, one could also use shape parameterization to solve the same problem. You can see how this is done for a waveguide bend [here](https://www.flexcompute.com/tidy3d/examples/notebooks/Autograd8WaveguideBend/).\n", + "\n", + "If you are unfamiliar with inverse design, we also recommend our [intro to inverse design tutorials](https://www.flexcompute.com/tidy3d/learning-center/inverse-design/) and our [primer on automatic differentiation with tidy3d](https://www.flexcompute.com/tidy3d/examples/notebooks/AdjointPlugin1Intro/).\n", + "\n", + "Before using Tidy3D, you must first [sign up](https://tidy3d.simulation.cloud/signup) for a user account. See [this link](https://docs.flexcompute.com/projects/tidy3d/en/latest/install.html) for installation instructions.\n", + "\n", + "\n", + "## Setup\n", + "\n", + "First we import the packages we need and also define some of the global parameters that define our problem.\n", + "\n", + "> Important note: we use `autograd.numpy` instead of regular `numpy`, this allows `numpy` functions to be differentiable. If one forgets this step, the error may be a bit opaque, just a heads up." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "8e90922d-93e9-4f35-bf11-167a891a6a19", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
07:53:25 CET WARNING: Using canonical configuration directory at                \n",
+       "             '/home/mahlau/.config/tidy3d'. Found legacy directory at           \n",
+       "             '~/.tidy3d', which will be ignored. Remove it manually or run      \n",
+       "             'tidy3d config migrate --delete-legacy' to clean up.               \n",
+       "
\n" + ], + "text/plain": [ + "\u001b[2;36m07:53:25 CET\u001b[0m\u001b[2;36m \u001b[0m\u001b[31mWARNING: Using canonical configuration directory at \u001b[0m\n", + "\u001b[2;36m \u001b[0m\u001b[32m'/home/mahlau/.config/tidy3d'\u001b[0m\u001b[31m. Found legacy directory at \u001b[0m\n", + "\u001b[2;36m \u001b[0m\u001b[32m'~/.tidy3d'\u001b[0m\u001b[31m, which will be ignored. Remove it manually or run \u001b[0m\n", + "\u001b[2;36m \u001b[0m\u001b[32m'tidy3d config migrate --delete-legacy'\u001b[0m\u001b[31m to clean up. \u001b[0m\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import autograd\n", + "import autograd.numpy as np\n", + "import matplotlib.pylab as plt\n", + "import tidy3d as td\n", + "import tidy3d.web as web\n", + "import autograd.numpy as np\n", + "import math\n", + "import optax\n", + "\n", + "from tidy3d.plugins.autograd.invdes.filters import ConicFilter\n", + "from tidy3d.plugins.autograd.invdes.projections import smoothed_projection" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "76bbc17e-4589-4285-acf3-f2ad2847cfd6", + "metadata": {}, + "outputs": [], + "source": [ + "# spectral parameters\n", + "wvl0 = 1.0\n", + "freq0 = td.C_0 / wvl0\n", + "\n", + "# geometric parameters\n", + "eps_mat = 4.0\n", + "wg_width = 0.5 * wvl0\n", + "wg_length = 1.0 * wvl0\n", + "design_size = 3 * wvl0\n", + "thick = 0.2 * wvl0\n", + "\n", + "# resolution\n", + "pixel_size = wvl0 / 50\n", + "min_steps_per_wvl = wvl0 / (pixel_size * np.sqrt(eps_mat))\n", + "\n", + "radius = 0.150\n", + "floor_radius = math.floor(radius / pixel_size)\n", + "discrete_radius = floor_radius if floor_radius % 2 == 1 else floor_radius + 1" + ] + }, + { + "cell_type": "markdown", + "id": "4b0d462a-e017-41b1-b8a0-8d97f2d49259", + "metadata": {}, + "source": [ + "Next, we will define all the components that make up our \"base\" simulation. This simulation defines the static portion of our optimization, which doesn't change over the iterations.\n", + "\n", + "For now, we'll include a definition of the design region geometry, just to have that on hand later, but will not include a design region in the base simulation as we'll add it later." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "5c441d22-05b9-4e34-8717-fbda75eb0ca5", + "metadata": {}, + "outputs": [], + "source": [ + "waveguide_in_horizontal = td.Structure(\n", + " geometry=td.Box(\n", + " center=(-wg_length - design_size / 2, 0, 0),\n", + " size=(2 * wg_length, wg_width, thick),\n", + " ),\n", + " medium=td.Medium(permittivity=eps_mat),\n", + ")\n", + "\n", + "waveguide_out_horizontal = td.Structure(\n", + " geometry=td.Box(\n", + " center=(wg_length + design_size / 2, 0, 0),\n", + " size=(2 * wg_length, wg_width, thick),\n", + " ),\n", + " medium=td.Medium(permittivity=eps_mat),\n", + ")\n", + "\n", + "waveguide_out_vertical = td.Structure(\n", + " geometry=td.Box(\n", + " center=(0, -waveguide_in_horizontal.geometry.center[0], 0),\n", + " size=(wg_width, waveguide_in_horizontal.geometry.size[0], thick),\n", + " ),\n", + " medium=td.Medium(permittivity=eps_mat),\n", + ")\n", + "\n", + "waveguide_in_vertical = td.Structure(\n", + " geometry=td.Box(\n", + " center=(0, waveguide_in_horizontal.geometry.center[0], 0),\n", + " size=(wg_width, waveguide_in_horizontal.geometry.size[0], thick),\n", + " ),\n", + " medium=td.Medium(permittivity=eps_mat),\n", + ")\n", + "\n", + "design_region_geometry = td.Box(\n", + " center=(0, 0, 0),\n", + " size=(design_size, design_size, thick),\n", + ")\n", + "\n", + "mode_source_horizontal = td.ModeSource(\n", + " center=(-design_size / 2.0 - wg_length + wvl0 / 3, 0, 0),\n", + " size=(0, wg_width * 3, td.inf),\n", + " source_time=td.GaussianPulse(\n", + " freq0=freq0,\n", + " fwidth=freq0 / 20,\n", + " ),\n", + " mode_index=0,\n", + " direction=\"+\",\n", + ")\n", + "\n", + "mode_monitor = td.ModeMonitor(\n", + " center=(-mode_source_horizontal.center[0] + 0.2, 0, 0),\n", + " size=(0, mode_source_horizontal.size[1], td.inf),\n", + " freqs=[freq0],\n", + " mode_spec=td.ModeSpec(num_modes=1),\n", + " name=\"mode\",\n", + ")\n", + "\n", + "field_monitor = td.FieldMonitor(\n", + " center=(0, 0, 0),\n", + " size=(td.inf, td.inf, 0),\n", + " freqs=[freq0],\n", + " name=\"field\",\n", + ")\n", + "\n", + "sim_base = td.Simulation(\n", + " size=(2 * wg_length + design_size, 2 * wg_length + design_size, thick + 2 * wvl0),\n", + " run_time=100 / mode_source_horizontal.source_time.fwidth,\n", + " structures=[waveguide_in_horizontal, waveguide_out_vertical, waveguide_out_horizontal, waveguide_in_vertical],\n", + " sources=[mode_source_horizontal],\n", + " monitors=[mode_monitor],\n", + " boundary_spec=td.BoundarySpec.pml(x=True, y=True, z=True),\n", + " grid_spec=td.GridSpec.auto(\n", + " min_steps_per_wvl=min_steps_per_wvl,\n", + " override_structures=[\n", + " td.MeshOverrideStructure(geometry=design_region_geometry, dl=3 * [pixel_size])\n", + " ],\n", + " ),\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "2b3ce430-dfc0-44d0-8bc4-eb28b2411aea", + "metadata": {}, + "source": [ + "Let's visualize the base simulations to verify that they look correct." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "b91cc9ba-f9bc-41bc-beff-613834915229", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ax = sim_base.plot(z=0.01)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "b8ee69e3-843c-4f61-9f44-6a84a29f5aec", + "metadata": {}, + "source": [ + "## Define Parameterization\n", + "\n", + "Next, we will define how our design region is constructed as a function of our optimization parameters.\n", + "\n", + "We will define a structure containing a grid of permittivity values defined by an array. Since we have a symmetric waveguide crossing, we only need to optimize 1/8 of the design volume. The function below constructs the full permittivity array from the design parameters through translation and rotation. \n", + "\n", + "We will convolve our optimization parameters with a conic filter to smooth the features over a given `radius`. Then we will add a smoothed projection function (see the paper [here](https://arxiv.org/pdf/2503.20189) for full details). The advantage of this projection is that we can work with fully binarized structures in our simulation. Since we assume that our topology should not change during optimization, we can use a value of $\\beta = \\infty$ during the whole simulation process, which completely binarizes the design except for a small boundary at the interface change. If we want to change the topology during optimization, we could also add a scheduling for the beta parameter, increasing it step-wise towards $\\beta = \\infty$.\n", + "\n", + "For more details on the parameterization process, we highly recommend [our short tutorial](https://www.flexcompute.com/tidy3d/learning-center/inverse-design/Inverse-Design-in-Photonics-Lecture-4-Fabrication-Constraints/), which explains the process in more detail." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "3c319b9a", + "metadata": {}, + "outputs": [], + "source": [ + "def save_one_eighth(array):\n", + " assert array.shape[0] == array.shape[1], ValueError(\"Array must be square\")\n", + " \n", + " size = array.shape[0]\n", + " center = size // 2\n", + " \n", + " # Extract the top-left triangular region (above main diagonal in top-left quadrant)\n", + " compressed_data = []\n", + " indices = []\n", + " \n", + " for i in range(center):\n", + " for j in range(i, center):\n", + " compressed_data.append(array[i, j])\n", + " indices.append((i, j))\n", + " \n", + " metadata = {\n", + " 'original_shape': array.shape,\n", + " 'indices': indices,\n", + " 'compression_ratio': array.size / len(compressed_data)\n", + " }\n", + " \n", + " return np.array(compressed_data), metadata\n", + "\n", + "# 1. Pre-compute the index mapping matrix\n", + "# This creates a grid (size x size) where each cell holds the integer index \n", + "# of the parameter in 'params' that controls that pixel.\n", + "def compute_index_map(metadata):\n", + " shape = metadata['original_shape']\n", + " indices = metadata['indices']\n", + " size = shape[0]\n", + " center = size // 2\n", + " \n", + " # Create the top-left quadrant map\n", + " tl_map = np.zeros((center, center), dtype=int)\n", + " \n", + " # Fill the upper triangle with parameter indices (0, 1, 2...)\n", + " # The 'indices' list connects the k-th parameter to coordinate (i, j)\n", + " for k, (i, j) in enumerate(indices):\n", + " tl_map[i, j] = k\n", + " \n", + " # Symmetrize the quadrant (copy upper triangle to lower triangle)\n", + " # Get indices of the upper triangle (excluding diagonal)\n", + " rows, cols = np.triu_indices(center, 1)\n", + " # Assign lower triangle indices to match upper triangle\n", + " tl_map[cols, rows] = tl_map[rows, cols]\n", + " \n", + " # Construct the full map using geometric mirrors\n", + " full_map = np.zeros(shape, dtype=int)\n", + " \n", + " # Top-Left\n", + " full_map[:center, :center] = tl_map\n", + " # Top-Right (Horizontal flip of TL)\n", + " full_map[:center, center:] = np.fliplr(tl_map)\n", + " # Bottom Half (Vertical flip of Top Half)\n", + " full_map[center:, :] = np.flipud(full_map[:center, :])\n", + " \n", + " return full_map\n", + "\n", + "num_pixels = int(design_size / pixel_size)\n", + "example_array = np.zeros((num_pixels, num_pixels))\n", + "_, metadata = save_one_eighth(example_array)\n", + "\n", + "# Calculate the map once using the metadata you created earlier\n", + "INDEX_MAP = compute_index_map(metadata)\n", + "\n", + "# 2. Define reconstruct to use vectorized indexing\n", + "def reconstruct(params):\n", + " # Uses the integer map to look up values from 'params' all at once.\n", + " # This is fast and autograd-safe.\n", + " return params[INDEX_MAP]" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "08d19383", + "metadata": {}, + "outputs": [], + "source": [ + "def get_density(params: np.ndarray) -> np.ndarray:\n", + " \"\"\"Get the density of the material in the design region as function of optimization parameters.\"\"\"\n", + " full_arr = reconstruct(params)\n", + " \n", + " filter = ConicFilter(kernel_size=discrete_radius)\n", + " arr_filtered = filter(full_arr)\n", + " \n", + " arr_projected = smoothed_projection(arr_filtered, beta=np.inf, eta=0.5)\n", + " return arr_projected\n", + "\n", + "def get_design_region(params: np.ndarray) -> td.Structure:\n", + " \"\"\"Get design region structure as a function of optimization parameters.\"\"\"\n", + " density = get_density(params)\n", + " eps_data = 1 + (eps_mat - 1) * density[:, :, None]\n", + " return td.Structure.from_permittivity_array(eps_data=eps_data, geometry=design_region_geometry)" + ] + }, + { + "cell_type": "markdown", + "id": "90110e4f-9ea4-48fc-b311-c5b568540333", + "metadata": {}, + "source": [ + "Next, it is very convenient to wrap this in a function that returns an updated copy of the base simulation with the design region added. We'll be calling this in our objective function. We'll also add some logic to exclude field monitors if they aren't needed, for example during the optimization." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "c4598fe8-b992-48de-9876-b28a557291df", + "metadata": {}, + "outputs": [], + "source": [ + "def get_sim(params: np.ndarray, with_fld_mnt: bool = False) -> td.Simulation:\n", + " \"\"\"Get simulation as a function of optimization parameters.\"\"\"\n", + " design_region = get_design_region(params)\n", + " sim = sim_base.updated_copy(structures=sim_base.structures + (design_region,))\n", + " if with_fld_mnt:\n", + " sim = sim.updated_copy(monitors=sim_base.monitors + (field_monitor,))\n", + " return sim" + ] + }, + { + "cell_type": "markdown", + "id": "6193eeca-2b7e-4aec-8c2a-774559341369", + "metadata": {}, + "source": [ + "At the beginning, we will initialize our parameters such that we start with a naive crossing, which is just a continuation of the waveguides. Note that this crossing is not a perfect continuation of the waveguides, but for the purpose of initialization it is good enough." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "8d78a6f5", + "metadata": {}, + "outputs": [], + "source": [ + "def fill_cross_antialiased(num_pixels, wg_width, pixel_size):\n", + " \"\"\"\n", + " Fill array with a cross pattern with anti-aliased edges (vectorized).\n", + " \"\"\"\n", + " center_pos = (num_pixels / 2.0) * pixel_size\n", + " half_width = wg_width / 2.0\n", + " \n", + " # Create index grids\n", + " i_indices, j_indices = np.meshgrid(np.arange(num_pixels), \n", + " np.arange(num_pixels), \n", + " indexing='ij')\n", + " \n", + " # Pixel boundaries in physical coordinates\n", + " y_min = i_indices * pixel_size\n", + " y_max = (i_indices + 1) * pixel_size\n", + " x_min = j_indices * pixel_size\n", + " x_max = (j_indices + 1) * pixel_size\n", + " \n", + " # Horizontal bar boundaries\n", + " horiz_y_min = center_pos - half_width\n", + " horiz_y_max = center_pos + half_width\n", + " \n", + " # Vertical bar boundaries\n", + " vert_x_min = center_pos - half_width\n", + " vert_x_max = center_pos + half_width\n", + " \n", + " # Calculate overlap with horizontal bar (in y-direction)\n", + " horiz_overlap_y = np.maximum(0, np.minimum(y_max, horiz_y_max) - np.maximum(y_min, horiz_y_min))\n", + " horiz_fill = horiz_overlap_y / pixel_size\n", + " \n", + " # Calculate overlap with vertical bar (in x-direction)\n", + " vert_overlap_x = np.maximum(0, np.minimum(x_max, vert_x_max) - np.maximum(x_min, vert_x_min))\n", + " vert_fill = vert_overlap_x / pixel_size\n", + " \n", + " # Union of horizontal and vertical bars (cross shape)\n", + " result = np.maximum(horiz_fill, vert_fill)\n", + " \n", + " return result" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "76cff654", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# get initial parameters by converting full cross into 1/8th flat array\n", + "cross_array = fill_cross_antialiased(num_pixels, wg_width, pixel_size)\n", + "params0, metadata = save_one_eighth(cross_array)\n", + "sim0 = get_sim(params0, metadata)\n", + "\n", + "_, (ax1, ax2) = plt.subplots(1, 2, tight_layout=True, figsize=(10, 4))\n", + "sim0.plot_eps(z=0.01, ax=ax1)\n", + "sim0.plot_eps(x=0.01, ax=ax2)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "9c0c4498-1ff0-4902-bc61-7bacd0791c1b", + "metadata": {}, + "source": [ + "We can also run a quick simulation with a field monitor added to verify how poorly the initial device is coupling. This gives us lots of room to improve things through optimization!" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "367a6e58-645b-40e1-b868-3f297725f226", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
07:53:32 CET Created task 'initial_waveguide_crossing' with resource_id         \n",
+       "             'fdve-e15d4636-5d30-43f6-b676-9c8e99fb1261' and task_type 'FDTD'.  \n",
+       "
\n" + ], + "text/plain": [ + "\u001b[2;36m07:53:32 CET\u001b[0m\u001b[2;36m \u001b[0mCreated task \u001b[32m'initial_waveguide_crossing'\u001b[0m with resource_id \n", + "\u001b[2;36m \u001b[0m\u001b[32m'fdve-e15d4636-5d30-43f6-b676-9c8e99fb1261'\u001b[0m and task_type \u001b[32m'FDTD'\u001b[0m. \n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
             View task using web UI at                                          \n",
+       "             'https://tidy3d.simulation.cloud/workbench?taskId=fdve-e15d4636-5d3\n",
+       "             0-43f6-b676-9c8e99fb1261'.                                         \n",
+       "
\n" + ], + "text/plain": [ + "\u001b[2;36m \u001b[0m\u001b[2;36m \u001b[0mView task using web UI at \n", + "\u001b[2;36m \u001b[0m\u001b]8;id=115851;https://tidy3d.simulation.cloud/workbench?taskId=fdve-e15d4636-5d30-43f6-b676-9c8e99fb1261\u001b\\\u001b[32m'https://tidy3d.simulation.cloud/workbench?\u001b[0m\u001b]8;;\u001b\\\u001b]8;id=198091;https://tidy3d.simulation.cloud/workbench?taskId=fdve-e15d4636-5d30-43f6-b676-9c8e99fb1261\u001b\\\u001b[32mtaskId\u001b[0m\u001b]8;;\u001b\\\u001b]8;id=115851;https://tidy3d.simulation.cloud/workbench?taskId=fdve-e15d4636-5d30-43f6-b676-9c8e99fb1261\u001b\\\u001b[32m=\u001b[0m\u001b]8;;\u001b\\\u001b]8;id=663235;https://tidy3d.simulation.cloud/workbench?taskId=fdve-e15d4636-5d30-43f6-b676-9c8e99fb1261\u001b\\\u001b[32mfdve\u001b[0m\u001b]8;;\u001b\\\u001b]8;id=115851;https://tidy3d.simulation.cloud/workbench?taskId=fdve-e15d4636-5d30-43f6-b676-9c8e99fb1261\u001b\\\u001b[32m-e15d4636-5d3\u001b[0m\u001b]8;;\u001b\\\n", + "\u001b[2;36m \u001b[0m\u001b]8;id=115851;https://tidy3d.simulation.cloud/workbench?taskId=fdve-e15d4636-5d30-43f6-b676-9c8e99fb1261\u001b\\\u001b[32m0-43f6-b676-9c8e99fb1261'\u001b[0m\u001b]8;;\u001b\\. \n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
             Task folder: 'default'.                                            \n",
+       "
\n" + ], + "text/plain": [ + "\u001b[2;36m \u001b[0m\u001b[2;36m \u001b[0mTask folder: \u001b]8;id=839249;https://tidy3d.simulation.cloud/folders/folder-b09a5d67-f90e-4deb-9d9b-a702c3884aec\u001b\\\u001b[32m'default'\u001b[0m\u001b]8;;\u001b\\. \n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "68079475457e4e86a264407ae0f30aa5", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Output()" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
\n"
+      ],
+      "text/plain": []
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "
07:53:35 CET Estimated FlexCredit cost: 0.363. Minimum cost depends on task     \n",
+       "             execution details. Use 'web.real_cost(task_id)' to get the billed  \n",
+       "             FlexCredit cost after a simulation run.                            \n",
+       "
\n" + ], + "text/plain": [ + "\u001b[2;36m07:53:35 CET\u001b[0m\u001b[2;36m \u001b[0mEstimated FlexCredit cost: \u001b[1;36m0.363\u001b[0m. Minimum cost depends on task \n", + "\u001b[2;36m \u001b[0mexecution details. Use \u001b[32m'web.real_cost\u001b[0m\u001b[32m(\u001b[0m\u001b[32mtask_id\u001b[0m\u001b[32m)\u001b[0m\u001b[32m'\u001b[0m to get the billed \n", + "\u001b[2;36m \u001b[0mFlexCredit cost after a simulation run. \n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
07:53:37 CET status = success                                                   \n",
+       "
\n" + ], + "text/plain": [ + "\u001b[2;36m07:53:37 CET\u001b[0m\u001b[2;36m \u001b[0mstatus = success \n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "296309103dfa4698982e0536d8d54dfa", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Output()" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
\n"
+      ],
+      "text/plain": []
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "
07:53:41 CET Loading simulation from simulation_data.hdf5                       \n",
+       "
\n" + ], + "text/plain": [ + "\u001b[2;36m07:53:41 CET\u001b[0m\u001b[2;36m \u001b[0mLoading simulation from simulation_data.hdf5 \n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sim0 = get_sim(params0, with_fld_mnt=True)\n", + "sim_data_init = web.run(sim0, task_name=\"initial_waveguide_crossing\")" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "2a181857-8388-43bb-ab7e-eb38587242b9", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ((ax0, ax1), (ax2, ax3)) = plt.subplots(2, 2, figsize=(10, 7), tight_layout=True)\n", + "sim0.plot_eps(z=0.01, ax=ax0)\n", + "ax1 = sim_data_init.plot_field(\"field\", \"E\", \"abs^2\", z=0, ax=ax1)\n", + "ax2 = sim_data_init.plot_field(\"field\", \"Ex\", z=0, ax=ax2)\n", + "ax3 = sim_data_init.plot_field(\"field\", \"Ey\", z=0, ax=ax3)" + ] + }, + { + "cell_type": "markdown", + "id": "90d90143-d5aa-4406-81ee-68119d5cb85b", + "metadata": {}, + "source": [ + "## Define Objective Function\n", + "\n", + "The next step is to define the metric that we want to optimize, or our \"figure of merit\". We will first write a function to compute the transmission (between 0-1) of the output mode given the simulation data. " + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "16c24074-d66f-4e62-83d8-4e12aa069981", + "metadata": {}, + "outputs": [], + "source": [ + "def get_transmission_from_data(data):\n", + " mode_amps = data[\"mode\"].amps.sel(direction=\"+\").values\n", + " energy = np.sum(np.abs(mode_amps) ** 2)\n", + " return energy" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "4b84d373", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Transmission: 0.790709113221821\n" + ] + } + ], + "source": [ + "print(f\"Transmission: {get_transmission_from_data(sim_data_init).item()}\")" + ] + }, + { + "cell_type": "markdown", + "id": "e0869f1f-a34d-457f-9ca9-4e855774c929", + "metadata": {}, + "source": [ + "Next we can put everything together into a single objective function." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "0f39f538-7c6c-46b6-9bb9-f25c6713431f", + "metadata": {}, + "outputs": [], + "source": [ + "def objective(params: np.ndarray) -> float:\n", + " \"\"\"Objective function.\"\"\"\n", + " sim = get_sim(params, metadata)\n", + " data = web.run(sim, task_name=\"crossing\", verbose=False)\n", + " transmission = get_transmission_from_data(data)\n", + " return transmission" + ] + }, + { + "cell_type": "markdown", + "id": "fcd0837e-57b7-438e-82d4-1ec72b571493", + "metadata": {}, + "source": [ + "## Optimization\n", + "\n", + "Getting the gradient of the `objective` function is easy using `autograd`. Calling `g = autograd.value_and_grad(f)` returns a function `g` that when evaluated returns the objective function value and its gradient.\n", + "\n", + "We use this as it's more efficient and we don't have to re-compute the objective during the gradient calculation step if we want to store the value too.\n", + "\n", + "Let's construct this function now and have it ready to use in the main optimization loop." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "42bbb42d-2ec3-49fd-a91c-6b4e64009dc9", + "metadata": {}, + "outputs": [], + "source": [ + "val_grad_fn = autograd.value_and_grad(objective)" + ] + }, + { + "cell_type": "markdown", + "id": "c4dea036-cb09-47e3-ad9e-156a47bbfffe", + "metadata": {}, + "source": [ + "Next we will run the optimizer, we first make a cell to define the parameters and some convenience functions and objects to store our history." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "20a041a9-cd33-4310-889b-8da46dc630b3", + "metadata": {}, + "outputs": [], + "source": [ + "# hyperparameters\n", + "num_steps = 40\n", + "learning_rate = 1\n", + "\n", + "# initialize adam optimizer with starting parameters\n", + "params = np.copy(params0)\n", + "\n", + "optimizer = optax.adam(learning_rate=learning_rate)\n", + "opt_state = optimizer.init(params)\n", + "\n", + "\n", + "# store history\n", + "objective_history = []\n", + "param_history = [params]" + ] + }, + { + "cell_type": "markdown", + "id": "edf7c795-8343-4a3a-8c0d-a2e521c66131", + "metadata": {}, + "source": [ + "And then we can iteratively update our optimizer and parameters using the gradient calculated in each step.\n", + "\n", + "We'll throw in a quick visualization of our device material density just to keep an eye on things as the optimization progresses.\n", + "\n", + "> Note: the following optimization loop will take about half an hour. To run fewer iterations, just change `num_steps` to something smaller above." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "921419b7-dea0-4c86-a706-968650b1e292", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "step = 1\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\tJ = 7.9071e-01\n", + "\tgrad_norm = 1.1751e-02\n", + "step = 2\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\tJ = 8.0941e-01\n", + "\tgrad_norm = 4.0858e-03\n", + "step = 3\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\tJ = 8.1575e-01\n", + "\tgrad_norm = 2.5668e-02\n", + "step = 4\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\tJ = 8.0011e-01\n", + "\tgrad_norm = 2.5134e-02\n", + "step = 5\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\tJ = 8.2831e-01\n", + "\tgrad_norm = 1.2441e-02\n", + "step = 6\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\tJ = 8.3549e-01\n", + "\tgrad_norm = 4.4742e-03\n", + "step = 7\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\tJ = 8.3518e-01\n", + "\tgrad_norm = 2.1592e-02\n", + "step = 8\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\tJ = 8.3212e-01\n", + "\tgrad_norm = 1.9747e-02\n", + "step = 9\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\tJ = 8.4477e-01\n", + "\tgrad_norm = 1.4037e-02\n", + "step = 10\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\tJ = 8.5550e-01\n", + "\tgrad_norm = 1.0773e-02\n", + "step = 11\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\tJ = 8.5905e-01\n", + "\tgrad_norm = 1.2394e-02\n", + "step = 12\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\tJ = 8.6618e-01\n", + "\tgrad_norm = 1.4078e-02\n", + "step = 13\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\tJ = 8.7737e-01\n", + "\tgrad_norm = 8.0084e-03\n", + "step = 14\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\tJ = 8.8001e-01\n", + "\tgrad_norm = 7.3118e-03\n", + "step = 15\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\tJ = 8.7676e-01\n", + "\tgrad_norm = 4.7928e-02\n", + "step = 16\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAQ8AAADaCAYAAAC4q8cWAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjMsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvZiW1igAAAAlwSFlzAAAPYQAAD2EBqD+naQAAN+xJREFUeJztnXlYVdXex7/ncCY4cA4ziCM5hBiGISIOWckrvZFIg5qvs+asZd5uigMmGZaWWjnlLfXmdaQSu2qWIo4hhnpL08wUNQdA4HAO85nW+4fP2ZfNGTgjsA/r8zz7Udb+rbV/e++zv3uttdf6LR4hhIBCoVBshN/cDlAoFG5CxYNCodgFFQ8KhWIXVDwoFIpdUPGgUCh2QcWDQqHYBRUPCoViF1Q8KBSKXVDxoFAodkHFgyMcP34cPB4Px48fb25XKE5m79698Pf3R2VlZZMf+8qVKxAIBLh8+bLNeal4tDA2bNiAbdu2NbcbdrFz506sXbu2ud0AAOj1eqxcuRLh4eGQSCTo2bMndu3aZXX+8vJyTJ06FUFBQZBKpXj22Wdx4cIFk7bfffcdnnrqKUgkEnTo0AFLly6FVqu16jg6nQ5Lly7FnDlz4O3tbbV/ziIyMhJJSUlIS0uzPTOhtCh69OhBBg0aZJSu0+lITU0N0el0Te+UlSQlJZGOHTs2txuEEEIWLFhAAJApU6aQzZs3k6SkJAKA7Nq1q9G8Op2O9OvXj0ilUvLuu++SdevWkcjISOLj40P++OMPlu2hQ4cIj8cjzz77LNm8eTOZM2cO4fP5ZPr06Vb5uW/fPsLj8cjdu3ftOk9ncOjQIQKA/Pnnnzbla5HiUVlZ2dwuNBvmxIMLtBTxuHv3LhEKhWTWrFlMml6vJwMHDiTt2rUjWq3WYv49e/YQACQzM5NJKy4uJr6+vmTUqFEs28jISPLkk08SjUbDpC1atIjweDxy9erVRn1NTk4mAwYMsPbUXIJarSZ+fn5kyZIlNuVzuXjcvXuXTJo0ibRp04aIRCLSqVMnMn36dFJXV0cIIWTr1q0EADl+/DiZMWMGCQoKIr6+vkz+9evXk8jISCISiUibNm3IzJkziUKhYB3jjz/+IC+//DIJCQkhYrGYtG3blowcOZKUl5czNj/++CPp378/kcvlRCqVkm7dupHU1NRG/bcmX21tLUlLSyOdO3cmIpGItGvXjvz9738ntbW1RuVt376dxMbGEk9PT+Lr60sGDhxIfvjhB0IIIR07diQAWJtBSHJycggAkpOTwypv79695KmnniISiYQEBASQ0aNHG73Fxo8fT6RSKbl79y4ZNmwYkUqlJDAwkPztb39r9EEihJCsrCzywgsvMPfwscceI+np6ay8gwYNMvLdkpCMHz/eyN6wLV26tFGfLLF+/XoCgPz222+s9J07dxIA5NSpUxbzDx8+nISEhBjV8qZOnUq8vLyY+/rbb78RAGT9+vUsu3v37hEA5L333rN4nJqaGiISici7777LSi8oKCAAyNatW43yNLw+S5cuJQDItWvXyOjRo4lMJiOBgYFk8eLFRK/Xkzt37pDk5GTi4+NDQkJCyEcffWTSl5deeon07NnTor8NEdjZVLKK+/fvo0+fPkz7MSIiAvfu3cPXX3+N6upqiEQixnbmzJkICgpCWloaqqqqAADvvvsuli1bhoSEBMyYMQPXrl3Dxo0b8fPPP+PMmTMQCoVQq9VITExEXV0d5syZg9DQUNy7dw8HDhxAeXk55HI5fvvtN7z44ovo2bMn0tPTIRaL8eeff+LMmTMW/bcmn16vR3JyMk6fPo2pU6eie/fuuHTpEtasWYM//vgDWVlZjO2yZcvw7rvvol+/fkhPT4dIJEJeXh6OHTuGIUOGYO3atUzbd9GiRQCAkJAQs/5t27YNEydORGxsLFasWIGioiJ88sknOHPmDC5evAhfX1/GVqfTITExEXFxcfjoo49w9OhRfPzxx+jcuTNmzJhh8Tps27YN3t7emDdvHry9vXHs2DGkpaVBpVJh1apVAIBFixZBqVTi7t27WLNmDQBYbMNPmzYNCQkJrLTDhw9jx44dCA4OZtJKSkos+mbAx8cHYrEYAHDx4kVIpVJ0796dZdOnTx9m/4ABA8yWdfHiRTz11FPg89ldgn369MHmzZvxxx9/ICoqChcvXgQA9O7dm2UXFhaGdu3aMfvNcf78eajVajz11FNWnaMlRo4cie7du+ODDz7AwYMHsXz5cvj7++Pzzz/Hc889hw8//BA7duzA22+/jdjYWDz99NOs/DExMdi/fz9UKhVkMpl1B7VJamxk3LhxhM/nk59//tlon16vJ4T8t+YxYMAA1pusuLiYiEQiMmTIENYbYN26dQQA2bJlCyGEkIsXLxpVMRuyZs0aAoA8fPjQJv+tybd9+3bC5/ON3mabNm0iAMiZM2cIIYRcv36d8Pl88tJLLxm90QzXghDzzZaGNQ+1Wk2Cg4PJE088QWpqahi7AwcOEAAkLS2NSTO85dPT01ll9urVi8TExFi+CISQ6upqo7Rp06ax3sKEONZsuX79OpHL5eR//ud/WL8DmKmdNNzqv6WTkpLIY489ZnSMqqoqAoAsWLDAoi9SqZRMmjTJKP3gwYMEADl8+DAhhJBVq1YRAOTOnTtGtrGxsaRv374Wj/PFF18QAOTSpUusdHtqHlOnTmXStFotadeuHeHxeOSDDz5g0hUKBfH09CTjx483KtdQK8vLy7Poc31c9rVFr9cjKysLQ4cONVJmAODxeKy/p0yZAg8PD+bvo0ePQq1WY+7cuaw3wJQpUyCTyXDw4EEAgFwuBwD88MMPqK6uNumL4Q28f/9+6PV6q8/BmnyZmZno3r07IiIiUFJSwmzPPfccACAnJwcAkJWVBb1ej7S0NKM3WsNrYQ35+fkoLi7GzJkzIZFImPSkpCREREQw16c+06dPZ/09cOBA3Lx5s9FjeXp6Mv+vqKhASUkJBg4ciOrqavz+++82+96QqqoqvPTSS/Dz88OuXbtYv4MjR45YtSUmJjJ5ampqmFpIfQzXqaamxqI/1uY3/GvOtrHjlJaWAgD8/Pws2lnD66+/zvzfw8MDvXv3BiEEkydPZtJ9fX3x+OOPm7znBh+srekBgMuaLQ8fPoRKpcITTzxhlX14eDjr79u3bwMAHn/8cVa6SCTCY489xuwPDw/HvHnzsHr1auzYsQMDBw5EcnIyxowZwwjLyJEj8cUXX+D111/HggULMHjwYLz88st49dVXjR7k+liT7/r167h69SqCgoJMllFcXAwAuHHjBvh8PiIjI626Ho1h7voAQEREBE6fPs1Kk0gkRj76+flBoVA0eqzffvsNixcvxrFjx6BSqVj7lEqlra4bMWXKFNy4cQM//fQTAgICWPsaNm2swdPTE3V1dUbptbW1zH5n5Df8a862seMYIE4I5tehQwfW33K5HBKJBIGBgUbpBtEy5YMtLzKX9nnYgrUX2hQff/wxJkyYgP379+PHH3/EG2+8gRUrVuDs2bNo164dPD09cfLkSeTk5ODgwYM4fPgw9uzZg+eeew4//vgj603X0KfG8un1ekRFRWH16tUmy2jfvr3d5+VMzJ1jY5SXl2PQoEGQyWRIT09H586dIZFIcOHCBcyfP9+mmpwpPvnkE+zatQv/+te/EB0dbbS/sLDQqnLkcjnzG2rTpg1ycnJACGE9DA8ePADwqE/CEm3atGFs69Mwf5s2bZj0hvf5wYMHTB+LOQxCqVAo0K5dO4u2gGWRMXV/zd1zU+UYXiINxcYSLmu2BAUFQSaT2TVyDQA6duwIALh27RorXa1Wo6CggNlvICoqCosXL8bJkydx6tQp3Lt3D5s2bWL28/l8DB48GKtXr8aVK1fw/vvv49ixY0yzwhyN5evcuTPKysowePBgJCQkGG2GmkHnzp2h1+tx5coVi8ezVvnNXR9DWsPrYy/Hjx9HaWkptm3bhjfffBMvvvgiEhISTFa1bW1+nTp1Cm+//Tbmzp2L0aNHm7Rp06aNVduePXuYPNHR0aiursbVq1dZZeXl5TH7LREdHY0LFy4YCWNeXh68vLzQrVs3Vjn5+fksu/v37+Pu3buNHiciIgIAUFBQYHJ/RUUF6++ioiKL5TlCQUEB+Hw+c27W4DLx4PP5SElJwb///W+jiws0XlVLSEiASCTCp59+yrL98ssvoVQqkZSUBABQqVRGo/mioqLA5/OZ6mRZWZlR+YYba6rKacCafCNGjMC9e/fwj3/8w8i2pqaG+XKUkpICPp+P9PR0ox9l/fOTSqUoLy8365OB3r17Izg4GJs2bWKdw/fff4+rV68y18dRDG+v+j6q1Wps2LDByFYqlVrdjHnw4AFGjBiBAQMGMF9sTGFPn8ewYcMgFApZPhJCsGnTJrRt2xb9+vVj+fH7779Do9Ewaa+++iqKiorw7bffMmklJSXIzMzE0KFDmT6OHj16ICIiAps3b4ZOp2NsN27cCB6Ph1dffdXiNYiJiYFIJDL5fAAwerHt27ePORdnc/78efTo0YNp6luDS5stGRkZ+PHHHzFo0CDmM+aDBw+QmZmJ06dPsz4lNiQoKAipqalYtmwZnn/+eSQnJ+PatWvYsGEDYmNjMWbMGADAsWPHMHv2bAwfPhzdunWDVqvF9u3b4eHhgVdeeQUAkJ6ejpMnTyIpKQkdO3ZEcXExNmzYgHbt2ln8ZGdNvrFjx2Lv3r2YPn06cnJy0L9/f+h0Ovz+++/Yu3cvfvjhB/Tu3RtdunTBokWL8N5772HgwIF4+eWXIRaL8fPPPyMsLAwrVqwA8OgHtXHjRixfvhxdunRBcHAw0/laH6FQiA8//BATJ07EoEGDMGrUKOZTbadOnfDWW2/Ze9tY9OvXD35+fhg/fjzeeOMN8Hg8bN++3eQPOCYmBnv27MG8efMQGxsLb29vDB061GS5b7zxBh4+fIh33nkHu3fvZu3r2bMnevbsCcC+Po927dph7ty5WLVqFTQaDWJjY5GVlYVTp05hx44drOp8amoq/vnPf6KgoACdOnUC8Eg8+vbti4kTJ+LKlSsIDAzEhg0boNPpsGzZMtaxVq1aheTkZAwZMgSvvfYaLl++jHXr1uH11183+lTcEIlEgiFDhuDo0aNIT0832n/48GGMHj0aTz/9NP744w9s3rwZXl5e+PHHHxEbG4sXX3zR5mtjCo1GgxMnTmDmzJm2ZbT6u4yd3L59m4wbN44EBQURsVhMHnvsMTJr1iyjQWKmPucS8ujTbEREBBEKhSQkJITMmDGDNUjs5s2bZNKkSaRz585EIpEQf39/8uyzz5KjR48yNtnZ2WTYsGEkLCyMiEQiEhYWRkaNGmU01Lgh1uZTq9Xkww8/JD169CBisZj4+fmRmJgYsmzZMqJUKlm2W7ZsIb169WLsBg0aRI4cOcLsLywsJElJScTHx8eqQWJ79uxhyvP397c4SKwhhs98jXHmzBnSt29f4unpScLCwsg777xDfvjhByN/Kisryf/93/8RX1/fRgeJmRpUZtgcHSRGyKMh5hkZGaRjx45EJBKRHj16kH/9619GdobP2AUFBaz0srIyMnnyZBIQEEC8vLzIoEGDzP5G9+3bR6Kjo4lYLCbt2rUjixcvJmq12io/v/32W8Lj8Vifew2fajMyMkhCQgIRi8UkPDycfP3112ThwoXEy8uLLFu2jBDy33vYcDiBuXs+aNAg0qNHD1ba999/TwCQ69evW+WzAR4hdN0WCqW50Ol0iIyMxIgRI/Dee+8BAG7duoXw8HBs3boVEyZMcLkPKSkp4PF4TLPIWuisWgqlGfHw8EB6ejrWr1/fLFPyr169igMHDjDCZQtUPCiUZmbkyJEoKytrlin53bt3h1artXo8Vn2oeFAoFLugfR4UCsUuaM2DQqHYRYsZnt7S0ev1uH//Pnx8fOyayEZxPwghqKioQFhYmMU5Uu4KFQ8ruX//Pj777DMIBMaXjBAChUJh98g/kUjEGhErFouh1+uhVqsd8tkWBAIBBAIBtFottFoty6ematnyeDzWuTf0qaloeD8kEgmkUqnJ65CRkYG//vrLqrkpDbH0EuJCbwIVDyvx8fGBQCCAl5eX0VuGEIJOnTrZPflMr9dDpVIxQ6SFQiFkMlmTv82qq6uZ4fR8Ph/Xrl2z+aFtGGTGVrRaLZRKJTOEXyqVwsvLy6EybaXh/RAIBKirqzO6HwYffXx87DoO12srVDysxPCW4PP5EAqFTLper4der4dYLGZFRrMVoVDIxFIICAgwGSPC1UgkEtbbtrF4FKZwxoOu0WiY6e/+/v7N8pDVvx+Gaex8Pp/li0Fc7G3Gcl08uO29m6BWq1FaWgqhUAihUIjS0tImbbIAj0SwtLQUPB4PEokEtbW1dr9RHaGiogK1tbWQSCTg8XgoLS11eNq/rTS8H+Xl5S7xgcfjmd24ABWPZkatVqOkpARCoRCBgYEIDAxk3npNJSAG4dBoNAgMDERAQABkMhlkMlmTCkhFRQUTQzMgIACBgYHQaDRNKiCm7oeh36X+zFlnYKjJmNq4AG222AghhPVD1uv1IISwpnRbi0ajgUKhgEAggEwmY/oXZDIZFAoFiouL4efnx2omORtDZ69Wq2VidKjVaojFYlRVVUEul8PDw4PpC2kMewWvqqoKlZWV8Pb2hlgsZsqRy+Wsa+HKt7K5+yGVSlFRUcH4ZCpMgT1wRSTMQcXDBgw/FlPiUVdXZ9ObyfBFwdBX0jCuiKenJ9RqNaqqqpjef2dDCIFarQafz4e3tzd0Oh3rHPR6PRPlns/nW9V5auirsAWtVguNRgOpVAoPDw+jMry9vaFWq6FSqSASiVwiIJbuh1arBZ/Ph16vh0ajASHEKfeDikcrory8HB07dmQFHNZoNKirq8MLL7xgUyAVLpCammpznoyMDBd40rwolUocOnQIIpEIlZWVTC3N0WYMFY9WhF6vh0AgMPqqotPpIJfL4e/v30yeuQZrgiM3xN2ugQHDfQ8ODkZpaSmUSqXDE9m4Lh7c9p5CaWL4fD4CAgIgFAodjhzP9Q5TbnjZQhCJRE3+2ZDS8jAIiL2DAuuXw2XxoM0WG+Dz+VCpVCZHmVJaF3w+3/plGS2UwWW47X0TY/ii0hwDlygtD0cffq7XPLjhZQuBEAK5XN7kA5co7gkVj1aGQCBgjXzkwuxHSsuEiocTWbFiBWJjY+Hj44Pg4GCkpKSYXBGtIZmZmYiIiIBEIkFUVBQOHTrE2k8IQVpaGtq0aQNPT08kJCTg+vXrdvspEokYAXFkKj6ldUPFw4mcOHECs2bNwtmzZ3HkyBFoNBoMGTLE4tDon376CaNGjcLkyZNx8eJFpKSkICUlhbXM5cqVK/Hpp59i06ZNyMvLg1QqRWJiol2jIQ0YBESr1Tb5JDaKe8D1iXEt6mvL4cOHWX9v27YNwcHBOH/+vNk4EZ988gmef/55/P3vfwcAvPfeezhy5AjWrVuHTZs2gRCCtWvXYvHixRg2bBgA4KuvvkJISAiysrLw2muvmSy3rq6ONUS54erwwCMB8fPzs3reB4VSH67UMMzRor03DMKxNGoxNzfXaEnCxMRE5ObmAni0gG9hYSHLRi6XIy4ujrExxYoVKyCXy5nN3Gr3QqHQoTgelNYLbba4CL1ej7lz56J///4W15QoLCxESEgIKy0kJASFhYXMfkOaORtTpKamQqlUMttff/1l76lQKCbhuni0qGZLfWbNmoXLly/j9OnTzXJ8sVhsVTQvjUZD+zwodsEVkTBHi/R+9uzZOHDgAHJychoNLBsaGoqioiJWWlFREUJDQ5n9hjRzNvaiVquhUCg408FFaVlwvebRorwkhGD27NnYt28fjh07hvDw8EbzxMfHIzs7m5V25MgRxMfHAwDCw8MRGhrKslGpVMjLy2Ns7MEQccrULFsKxRq4Lh4tqtkya9Ys7Ny5E/v374ePjw/TJyGXy+Hp6QkAGDduHNq2bYsVK1YAAN58800MGjQIH3/8MZKSkrB7927k5+dj8+bNAB59Dps7dy6WL1+Orl27Ijw8HEuWLEFYWBhSUlLs8rN+qDqZTGYUyIdCsQauiIQ5WpR4bNy4EQDwzDPPsNK3bt2KCRMmAADu3LnDuuj9+vXDzp07sXjxYixcuBBdu3ZFVlYWq5P1nXfeQVVVFaZOnYry8nIMGDAAhw8fZgX1sRatVovy8nIIhUIEBAQ06XoiFPeCiocTsWak5vHjx43Shg8fjuHDh5vNw+PxkJ6ejvT0dEfcA4/Hg1KphEQiQUBAAOdvPqV54frvp0WJR0tHLBbDw8ODCgcFAByeGMn13xAVDxvQ6/XNspIbpeVhWFXOEbj+O6LiYQOGSOOU1o1hnRtHAyBz/RM/FQ8KxQbqL5DlaLR8rr+IqHhQKFZCCGGtrOfolzauiwe3vae4FEKI1QPgRCKRW8c1MaysZxAOZwwMpIPEKG6NtfN23H1+j1qthlarRXBwsNNGFHNFJMxBxYNCsQJCCPz8/Jw6FYHr4sFt7yku55133nGqHVcRiUROX3Cc680WbnhJaTY+/PBDp9pxFVc80FwXD9psoVCswBWdwVwRCXNw23uKy4mLi3OqHVdRq9VOFxCu1zy44SWl2cjPz3eqHVcxfKp15kJfVDwobo21D4u7r54nEomg1WqdulIgFQ+K21JeXu5Sey7B5/Ph5+fn1KVGqXhQ3BZfX1+X2nMNoVDIWmrUUQGhiz5RKK0Iw0qBJSUl0Gg0DpXFlRqGObjtfRMjELQ+rb1586ZT7dwBg4A4OiWf682W1vc0OIBAIEB1dTW8vLya25UmIzw8HHV1dRbXsKmrq2t1EeRFIhGdkt/cDnAJrVaLqqoqiMVi+Pj4NLc7TUZjwtDahMOAozVRrosHt71vYrRaLaRSKVQqFSoqKprbHZeyYsUKqzvw6tsZlsSgNE6ra7YUFBTg1KlTuH37NqqrqxEUFIRevXohPj7erqUMuIaXlxfEYjETv9KaJSm5hiO9/QsXLsTChQvdOraHs+CKSJjDavHYsWMHPvnkE+Tn5yMkJARhYWHw9PREWVkZbty4AYlEgtGjR2P+/Pno2LGjK31udgxNFpVKBS8vL3h4eDSzR85j27ZtTivHsNYOxTStQjx69eoFkUiECRMm4JtvvkH79u1Z++vq6pCbm4vdu3ejd+/e2LBhg8V1VNwBg4CUl5dDKpU2szfOY8KECcxDb+t6voWFhQgJCXGRZ+5HqxCPDz74AImJiWb3i8ViPPPMM3jmmWfw/vvv49atW87yr0Xj4+MDrVbrtlG0bBUCKhy2wXXxsMp7S8LRkICAAMTExNjtENeQSqVODxLTkhg8eLBT7Sj/pdV1mBooLi5GcXGx0RDdnj17OuwU13CnPo+GHD161KoO1KNHjzaBN+4FV0TCHDaLx/nz5zF+/HhcvXqV6VHn8XgghIDH4zk86o5rEELcttkCADU1NVbbeXp6utgb94Irc1jMYbN4TJo0Cd26dcOXX36JkJAQzl8AR9Dr9VAoFJx/g5iiZ8+euHTpktX2hlG3UVFR+PXXX13lllvB9d+NzeJx8+ZNfPPNN+jSpYsr/OEMhpXDtFotvL29m9sdp5KRkWGTcNTn0qVLyMjIwMKFC53slfvBdfGw2fvBgwfjl19+cYUvnKH+koN+fn6c/xHU5/PPP8eiRYscKmPRokX4/PPPneSR+9LqOky/+OILjB8/HpcvX8YTTzxh9KUhOTnZac61ROoLR2BgIAC4TT+PQCBw2rlMnz4ds2bNcnhJRneGKyJhDpvFIzc3F2fOnMH3339vtK81dJgahqUblhzkSmcpj8fD2bNnzQYq/vXXX51+73Q6HX799VezX+Dy8vLQt2/fVjuUneviYbP3c+bMwZgxY/DgwQPo9XrW5u7CIRKJoNPpnLZWaVNh8NXcIK4uXbrgySefdMmxn3zySbP9YwZ/uHQtnQnXmy02e1laWoq33nqrVY4m5PP5kMvlnPuxGyJemYo/kZ+fjxs3brj0+Ddu3DAZXd3gj6MRuZqL6upqh/JzXTxsbra8/PLLyMnJQefOnV3hT4umrq4OP/30E+vHLhQK4enpidTUVCgUCpcclxACpVKJyMhIXLp0Cf7+/qz9CoWCSduwYQNmzJjB7Ks/iM/f3x8TJ07Eli1bmLSmWm8lLi6OqZmqVCoEBwejrq6O5Wf9h2bjxo2YOXMmANMLLpWVlSEqKgpXrlyBXC536ZABPz8/jBgxAjU1Ncy99/HxocGAbM3QrVs3pKam4vTp04iKijLqMH3jjTec5lxLo7na5vUfjICAAIu2M2fOxMyZM6FQKODr62vk89atW7F161Zcv34dXbp0abIlEwzHEQqFJjtRDX6Wl5fDz8+Pta/++bdt2xb37t1j/m6OoMs+Pj6QyWSorKx0qJxWJx5ffPEFvL29ceLECZw4cYK1j8fjubV4cAk/Pz9MnDgRW7duNbm/a9euTeyR5RGVAoHAor8G6gtHc2AQDpVKhdraWofK4rp42Ox9QUGB2c1ZQXDXr1+PTp06QSKRIC4uDufOnbNon5mZiYiICEgkEkRFReHQoUOs/YQQpKWloU2bNvD09ERCQgKuX7/uFF9bMo09iC2Nlu6vVCplhMMZkeS43ufhNC8fPHiAlStXOlzOnj17MG/ePCxduhQXLlzAk08+icTERBQXF5u0/+mnnzBq1ChMnjwZFy9eREpKClJSUnD58mXGZuXKlfj000+xadMm5OXlQSqVIjEx0eE3B6X1IBAI4O3t7dQQlFwXDx6xsSE/adIkk+m3b9/GuXPnHL6wcXFxiI2Nxbp16wA8aiu3b98ec+bMwYIFC4zsR44ciaqqKhw4cIBJ69u3L6Kjo7Fp0yYQQhAWFoa//e1vePvttwEASqUSISEh2LZtG1577TWTftTV1bE69FQqFZYvX87qNAP+22G6d+9el3WYUpoXPz8/jBs3Dmq1mrUqnlAoxFdffQWlUgmZTGZzuUuXLjW7b9myZfa42qTYLHEKhYK1lZSU4Ny5czh+/Dg++ugjh5xRq9U4f/48EhIS/usgn4+EhATk5uaazJObm8uyBx7FHzHYFxQUoLCwkGUjl8sRFxdntkzgUQBguVzObA2jp1FaF4bI+c6E6zUPmztM9+3bZzL9/fffR1ZWFqZNm2a3MyUlJdDpdEZjSEJCQvD777+bzGMq9F1ISAgKCwuZ/YY0czamSE1Nxbx585i/DTUPSuvEFcPsuSIS5nDaui2jRo1yq4dLLBa7ZWR0SsuB6+LhNO9/+eUX9OrVy6EyAgMD4eHhgaKiIla6pUC8oaGhFu0N/9pSprswceLE5nbBJlqyv65YarTVNVvqV+UNFBUVYf/+/UhKSmLtX716tU1li0QixMTEIDs7GykpKQAedZhmZ2dj9uzZJvPEx8cjOzsbc+fOZdKOHDmC+Ph4AI+WSwwNDUV2djaio6MBPGqC5OXlsUZiuhuGQWL/+Mc/TP7wDYPEmjKYEyHE7CAxrVYLDw8PrF692miQWH0aDhJrKgQCAaRSKavD1FG4IhLmsFk8Ll68aDI9NjaWiWsK2B9ibd68eRg/fjx69+6NPn36YO3ataiqqmLeSuPGjUPbtm2ZlcnefPNNDBo0CB9//DGSkpKwe/du5OfnY/PmzYwfc+fOxfLly9G1a1eEh4djyZIlCAsLYwSqpePI8PSG96Hh8HQ+n98ko0wND4pGozE5PN3gp2FUbEsang6ACfqk0+mc+qmWy9gsHjk5Oa7wg2HkyJF4+PAh0tLSUFhYiOjoaBw+fJjp8Lxz5w7rovfr1w87d+7E4sWLsXDhQnTt2hVZWVl44oknGJt33nkHVVVVmDp1KsrLyzFgwAAcPnzYrhXunn76adZC12q1GrW1tcjIyDB6qJ2JXC43+8b18/MzO3S+/rUqKyszeqvn5eUhNjbWeY6aIS8vj/m/TCZDbW0tS/QaPkgzZsywWDP09/dnXQ9XTh0oKytDZmYmdDodqqurIZPJ4OPjg+rqanz11Vd2l9vqxKMpmD17ttlmyvHjx43Shg8fbnGRKR6Ph/T0dKSnpzvLRU4hFAqh0WigVCqNxKN3797o3LmzS2fWdu7cGb179zZKVyqVjH9cQCqVQiAQMDFdHI2az3XxsMr7559/HmfPnm3UrqKiAh9++CHWr1/vsGMU52EIWNSw09jAn3/+6bLQkr/88gv+/PNPk/sM/nAloBLAnttCp+RbwfDhw/HKK69ALpdj6NCh6N27N8LCwiCRSKBQKHDlyhWcPn0ahw4dQlJSElatWuVqv5sFLkeKb6xa37NnT3h4eDg1oJOHh4fFdXzi4uI4GUXMsNRoWVmZQ+VwRSTMYZV4TJ48GWPGjEFmZib27NmDzZs3M1VOHo+HyMhIJCYm4ueff0b37t1d6nBzIhaL3Tomp1arxeeff47p06c7XNamTZscGjDY0vHx8WF1+NpDqxAP4NGDM2bMGIwZMwbAo/ZqTU0NAgICONNmdRS9Xg+lUgmJRMK5aGLWMm3aNJSWljoUQf399993a+EwUL/j3B64XJMFHBgkJpfLERoa2mqEA3jUNvfw8EBJSQmn2um2snDhQkRFRdmVNyoqiq7ZYiWtos+D8l9kMhlqampQUlLCLL3gjhhWfaupqbHqDVtdXU2Xm7QRroiEObjtfTPA5/OZplpJSQlng/dai6enZ6OiYI0NxRiu1zy44WULo76AKBSKJosD2lw0tti1tYthU9hQ8WilGAREIBC4df+HtZ16XO/8aw5anXiMHz8eJ0+edIUvnIPP58PPz89tHxxzg8qcZd/aaXXioVQqkZCQgK5duyIjI6PZo1k3Nzwez60+227btg08Hg88Hs/mkAWhoaFM3m3btrnGQTei1YlHVlYW7t27hxkzZmDPnj3o1KkT/vd//xdff/2123cemsOdltmcMGFCiyrHnWl14gEAQUFBmDdvHn755Rfk5eWhS5cuGDt2LMLCwvDWW2+1imUNDFRVVbmdaBJCkJGRYVfejIwMTg45bw5apXgYePDgAY4cOYIjR47Aw8MDL7zwAi5duoTIyEisWbPGWT62WCoqKlBZWemWA+VSU1NBCGE2S9S3S01NbSIPuU+rEw+NRoNvvvkGL774Ijp27IjMzEzMnTsX9+/fxz//+U8cPXoUe/fudfvp7xUVFVCpVPD29nZJiLqWRGNfk9z5a5Mr4bp42Pyrb9OmDfR6PUaNGoVz584xof3q8+yzzzbLGqJNhUE4ZDIZxGKxWy8eVVBQgMcee8yijVgsxs2bNxEeHt5EXrkHXBEJc9gsHmvWrMHw4cMtRuHy9fVFQUGBQ461VKqrq1FXV8dEk3L3t25jwlHfjvZ12AbXP/HbLB5jx451hR+cQCAQoKqqCv7+/kxMBwrFXrhe8+C2902MIYJ2axEOWyOFOzOyOBdwNLZLq+vzaM1otVqHYzhwCVv7rdy5n6sharWaCYhlL1wRCXNQ8bABd44iRrEetVqNkpKSVh8AmYoHxSIikciqTmF3GqJvCYNwCIVCh8MQcF08uO09xeVYG1XdVdHXWxIajYYRjoCAAIcfftrnQXFrIiIinGrHVfR6PVQqFcRisVOEA6A1D4qbM3/+fKfacRW1Wg2BQOA04QC4X/PghpeUZmPlypVOteMqPB4Pfn5+Tn2wuS4etNlCoViBSCRy+ohQroiEOah4UCxCv7Y8whVDybkuHtz2nuJywsLCnGrHVVwR5NoQdc3UxgVozYNiFlt+xLdu3QKPx3PbyXFqtRpCodCpNSyu1zyoeFAoVsDj8aBQKJwqIFwXD257T6E0ESKRCAKBwKlLjXL9aws3vKRQmhnDp1rDSoHOEBAqHhRKK4HH47GWGm3tU/K54SWF0kKov9SoM6bkU/FoJYhEIrdfl5bSOAYBccaUfC6LB/3aYgN8Ph8qlQpeXl6cucEU18Dn8yGTyRwug8u0GO81Gg3mz5+PqKgoSKVShIWFYdy4cbh//36jedevX49OnTpBIpEgLi4O586dY+2vra3FrFmzEBAQAG9vb7zyyit2rataV1cHnU6H0tJSWgOhtPop+S3Gy+rqaly4cAFLlizBhQsX8O233+LatWtITk62mG/Pnj2YN28eli5digsXLuDJJ59EYmIiiouLGZu33noL//73v5GZmYkTJ07g/v37ePnll232kRACuVwOjUZDBYTiMFwXjxbTbJHL5Thy5Agrbd26dejTpw/u3LmDDh06mMy3evVqTJkyBRMnTgQAbNq0CQcPHsSWLVuwYMECKJVKfPnll9i5cyeee+45AMDWrVvRvXt3nD17Fn379rXJT4FAgMDAQJSUlKC0tNThqiul9cIVkTBHi/ZeqVSCx+OZDayrVqtx/vx5JCQkMGl8Ph8JCQnIzc0FAJw/fx4ajYZlExERgQ4dOjA2pqirq4NKpWJtBkQiEQIDA6HRaKBQKNx2SDbFtXC95tFivaytrcX8+fMxatQos2/3kpIS6HQ6hISEsNJDQkJQWFgIACgsLIRIJDISoPo2plixYgXkcjmztW/fnrXfICBardbtF36iuAauT4xrNvHYsWMHvL29me3UqVPMPo1GgxEjRoAQgo0bNzaLf6mpqVAqlcz2119/GdmIRCL4+fnRmgfFLrhe82i2Po/k5GTExcUxf7dt2xbAf4Xj9u3bOHbsmMU+hcDAQHh4eBh9OSkqKkJoaCgAIDQ0FGq1GuXl5azaR30bU4jFYojF4kbPw9kzLSmtB66IhDmazXsfHx906dKF2Tw9PRnhuH79Oo4ePYqAgACLZYhEIsTExCA7O5tJ0+v1yM7ORnx8PAAgJiYGQqGQZXPt2jXcuXOHsaFQmgNa83ASGo0Gr776Ki5cuIADBw5Ap9MxfRL+/v7M233w4MF46aWXMHv2bADAvHnzMH78ePTu3Rt9+vTB2rVrUVVVxXx9kcvlmDx5MubNmwd/f3/IZDLMmTMH8fHxNn9pMec37fOg2ANXRMIcLUY87t27h++++w4AEB0dzdqXk5ODZ555BgBw48YNlJSUMPtGjhyJhw8fIi0tDYWFhYiOjsbhw4dZnahr1qwBn8/HK6+8grq6OiQmJmLDhg0O+6xWq6FQKKxq3lAoDaHi4SQ6depkVcfjrVu3jNJmz57N1ERMIZFIsH79eqxfv94RF1kYVg4TCAS0z4NiF1Q8WiH1lxyUyWSoq6trbpcoHISKRytDq9WivLycWXKQLn5NsRcqHq0IHo8HpVIJiUTi1JXDKK0Trv9+qHjYgFgshoeHBxUOCgDHl2Pg+m+IiocNEELg5eXFaqpoNBpotVqHo0q1RPz8/GzOU1ZW5gJPmhelUgmtVguNRsOkEUJQXl7uULlUPFoRUqkUCoWCJRR6vR6EEBw6dAgCgeXLqdfroVarwePxbFq+kBACtVoNQghEIpFDPzpbyhoxYgTrb4FAAIFAAK1Wa7avJzMz0yo/DA+jUChs9LrVx95r6EhZhn4uHo8HPp8PQgi0Wq3DNQ+uzGExBxUPGzDc7IYPHCEEYrEYQqGw0TKEQiEUCgV0Oh38/Pwa/QERQqBQKKDVapno3Y4ikUigUChQWVlpscyamhrm/1KpFF5eXqisrERVVZXFsq2lqqoKlZWV8Pb2hlQqbdReo9FApVJBIBBYde2swZr7odFowOfzmX0ajQaEEKeEIeQyVDxsxPD2qY9er7d6jotIJGKib6tUKov9J3q9ngk6FBwc7NTxJMHBwSgtLYVSqURgYKDJsg3VdB8fH0ilUiiVSlRUVFgs1xYfDWuhGATBx8fHrK1arYZSqYRYLHZqn5O198Mw29UwmlgsFjs8IZLr4sFt7zlK/Xgg5iKSGYRDo9GYfbgdoX4UcEvrkPj4+EAmk0GlUjUqHPZgTfn1x9W4orPa2vtRV1fHNPdsaWqZg+tzW7jhpRti6QfrauEw0JiAuFo4rDmOq4XDQGP3Q6fTOVU4AO6LB222WImhiqrX64163YFHkcfsGTDm7e0NpVKJwsJCJvyASqWCTqeDXC632DnpLAwzmouKiiCXyyEQCFBdXQ25XI7KykrU1tZa3ddSXV1tlw8eHh4Qi8UoKytDXV0d81VLqVTCw8MDnp6eqK2ttatsWzB1P5RKJfR6PTw8PEAIYe6/QWDsbb5wRSTMwSM0ko1V3L171yiaGIUCAH/99RfatWvX3G40OVQ8rESv1+P+/fvw8fFxqJdfpVKhffv2+OuvvzgZPJnr/gPOOwdCCCoqKhAWFsb5WoQ90GaLlfD5fKe+XWQyGWcfPoD7/gPOOQe5XO4kb7hH65NLCoXiFKh4UCgUu6Di0cSIxWIsXbqUs9HHuO4/4B7n0BKgHaYUCsUuaM2DQqHYBRUPCoViF1Q8KBSKXVDxoFAodkHFw0E0Gg3mz5+PqKgoSKVShIWFYdy4cbh//36jedevX49OnTpBIpEgLi4O586dY+2vra3FrFmzEBAQAG9vb7zyyitGS2s6g8b8aEhmZiYiIiIgkUgQFRWFQ4cOsfYTQpCWloY2bdrA09MTCQkJuH79utP9Bh4tSB4bGwsfHx8EBwcjJSUF165dazRfSzoHzkIoDlFeXk4SEhLInj17yO+//05yc3NJnz59SExMjMV8u3fvJiKRiGzZsoX89ttvZMqUKcTX15cUFRUxNtOnTyft27cn2dnZJD8/n/Tt25f069fPqf5b40d9zpw5Qzw8PMjKlSvJlStXyOLFi4lQKCSXLl1ibD744AMil8tJVlYW+eWXX0hycjIJDw8nNTU1TvWdEEISExPJ1q1byeXLl8l//vMf8sILL5AOHTqQyspKs3la2jlwFSoeLuDcuXMEALl9+7ZZmz59+pBZs2Yxf+t0OhIWFkZWrFhBCHkkSkKhkGRmZjI2V69eJQBIbm6u03xtzI+GjBgxgiQlJbHS4uLiyLRp0wghhOj1ehIaGkpWrVrF7C8vLydisZjs2rXLaX6bo7i4mAAgJ06cMGvT0s+BK9BmiwtQKpXg8Xjw9fU1uV+tVuP8+fNISEhg0vh8PhISEpCbmwsAOH/+PDQaDcsmIiICHTp0YGwcxRo/GpKbm8uyB4DExETGvqCgAIWFhSwbuVyOuLg4p/ltCUN8WX9/f7M2Lf0cuAIVDydTW1uL+fPnY9SoUWYnXZWUlECn07HW0wWAkJAQZnHvwsJCiEQiIwGqb+Mo1vjRkMLCwkb9NqS5ym9z6PV6zJ07F/3798cTTzxh1q4lnwOXoOJhIzt27IC3tzeznTp1itmn0WgwYsQIEEKwcePGZvSydTJr1ixcvnwZu3fvbm5XWgV0Sr6NJCcnIy4ujvm7bdu2AP4rHLdv38axY8csTvUODAyEh4eH0ZeToqIihIaGAgBCQ0OhVqtRXl7Oqn3Ut3EUa/xoSGhoaKN+G9LatGnDsomOjnaK36aYPXs2Dhw4gJMnTzYaOqGlngPXoDUPG/Hx8UGXLl2YzRDCb8SIEbh+/TqOHj2KgIAAi2WIRCLExMQgOzubSdPr9cjOzkZ8fDwAICYmBkKhkGVz7do13Llzh7FxFGv8aEh8fDzLHgCOHDnC2IeHhyM0NJRlo1KpkJeX5zS/60MIwezZs7Fv3z4cO3YM4eHhjeZpaefAWZq7x5brqNVqkpycTNq1a0f+85//kAcPHjBbXV0dY/fcc8+Rzz77jPl79+7dRCwWk23btpErV66QqVOnEl9fX1JYWMjYTJ8+nXTo0IEcO3aM5Ofnk/j4eBIfH+9U/xvzY+zYsWTBggWM/ZkzZ4hAICAfffQRuXr1Klm6dKnJz5y+vr5k//795NdffyXDhg1z2WfOGTNmELlcTo4fP8669tXV1YxNSz8HrkLFw0EKCgoIAJNbTk4OY9exY0eydOlSVt7PPvuMdOjQgYhEItKnTx9y9uxZ1v6amhoyc+ZM4ufnR7y8vMhLL71EHjx44PRzsOTHoEGDyPjx41n2e/fuJd26dSMikYj06NGDHDx4kLVfr9eTJUuWkJCQECIWi8ngwYPJtWvXnO43IcTstd+6dStnzoGr0Cn5FArFLmifB4VCsQsqHhQKxS6oeFAoFLug4kGhUOyCigeFQrELKh4UCsUuqHhQKBS7oOJBoVDsgooHxSRffvklhgwZ4vLjHD58GNHR0dDr9S4/FsW5UPGgGFFbW4slS5Zg6dKlLj/W888/D6FQiB07drj8WBTnQsWDYsTXX38NmUyG/v37N8nxJkyYgE8//bRJjkVxHlQ83JiHDx8iNDQUGRkZTNpPP/0EkUhkNCW9Prt378bQoUNZac888wzmzp3LSktJScGECROYvzt16oTly5dj3Lhx8Pb2RseOHfHdd9/h4cOHGDZsGLy9vdGzZ0/k5+ezyhk6dCjy8/Nx48YN+0+W0uRQ8XBjgoKCsGXLFrz77rvIz89HRUUFxo4di9mzZ2Pw4MFm850+fRq9e/e265hr1qxB//79cfHiRSQlJWHs2LEYN24cxowZgwsXLqBz584YN24c6s/H7NChA0JCQlhR2SgtHyoebs4LL7yAKVOmYPTo0Zg+fTqkUilWrFhh1r68vBxKpRJhYWF2H2/atGno2rUr0tLSoFKpEBsbi+HDh6Nbt26YP38+rl69ahTJKywsDLdv37brmJTmgYpHK+Cjjz6CVqtFZmYmduzYAbFYbNa2pqYGACCRSOw6Vs+ePZn/GwIIR0VFGaUVFxez8nl6eqK6utquY1KaByoerYAbN27g/v370Ov1uHXrlkXbgIAA8Hg8KBSKRsvV6XRGaUKhkPk/j8czm9bw02xZWRmCgoIaPSal5UDFw81Rq9UYM2YMRo4ciffeew+vv/660Vu/PiKRCJGRkbhy5YrRvoZNjZs3bzrFx9raWty4cQO9evVySnmUpoGKh5uzaNEiKJVKfPrpp5g/fz66deuGSZMmWcyTmJiI06dPG6Xv378f3377LW7cuIH3338fV65cwe3bt3Hv3j2HfDx79izEYjENLswxqHi4McePH8fatWuxfft2yGQy8Pl8bN++HadOnbK4rszkyZNx6NAhZvU1A0lJSVi5ciUiIyNx8uRJbNiwAefOncP27dsd8nPXrl0YPXo0vLy8HCqH0rTQGKYUkwwfPhxPPfUUUlNTATwa5xEdHY21a9c69TglJSV4/PHHkZ+fb9WyCZSWA615UEyyatUqeHt7u/w4t27dwoYNG6hwcBBa86BYhatqHhTuQsWDQqHYBW22UCgUu6DiQaFQ7IKKB4VCsQsqHhQKxS6oeFAoFLug4kGhUOyCigeFQrELKh4UCsUu/h/VX1/DyqCRmwAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\tJ = 8.8168e-01\n", + "\tgrad_norm = 1.0029e-02\n", + "step = 17\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\tJ = 8.8646e-01\n", + "\tgrad_norm = 7.1024e-03\n", + "step = 18\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\tJ = 8.9084e-01\n", + "\tgrad_norm = 6.2544e-03\n", + "step = 19\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\tJ = 8.9662e-01\n", + "\tgrad_norm = 7.1711e-03\n", + "step = 20\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\tJ = 9.0646e-01\n", + "\tgrad_norm = 8.4122e-03\n", + "step = 21\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\tJ = 9.1950e-01\n", + "\tgrad_norm = 8.2430e-03\n", + "step = 22\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\tJ = 9.2206e-01\n", + "\tgrad_norm = 2.3775e-02\n", + "step = 23\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAQ8AAADaCAYAAAC4q8cWAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjMsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvZiW1igAAAAlwSFlzAAAPYQAAD2EBqD+naQAAOl5JREFUeJztnXlYVdX+/9/7cCY453BAQBBJJYdwwFREHK+WJH0lkTI1r7OmORZ5K7UUE01LM82cvn5L/eV1pJvYVVNxnlHBLIfUjBxAQBTOYT7T+v3hc3ZszsAZgQ3r9Tz7gb32Wmt/9nDee42fxRBCCCgUCsVOBLVtAIVC4SdUPCgUikNQ8aBQKA5BxYNCoTgEFQ8KheIQVDwoFIpDUPGgUCgOQcWDQqE4BBUPCoXiEFQ8eMKJEyfAMAxOnDhR26ZQXMzu3bvRqFEjFBcX1/i5b9y4AaFQiGvXrtmdlopHHWPdunXYsmVLbZvhENu3b8eqVatq2wwAgMFgwLJlyxAaGgqpVIqOHTtix44dNqcvLCzE5MmTERAQAJlMhpdeegkZGRlm4/7000/o0qULpFIpmjVrhgULFkCn09l0Hr1ejwULFmDmzJmQy+U22+cq2rVrh9jYWCQmJtqfmFDqFO3btyd9+/Y1Cdfr9aSsrIzo9fqaN8pGYmNjSfPmzWvbDEIIIXPmzCEAyKRJk8jGjRtJbGwsAUB27NhRbVq9Xk969uxJZDIZ+fTTT8maNWtIu3btiEKhILdv3+bEPXDgAGEYhrz00ktk48aNZObMmUQgEJApU6bYZOeePXsIwzDk4cOHDl2nKzhw4AABQP744w+70tVJ8SguLq5tE2oNS+LBB+qKeDx8+JCIRCIyffp0NsxgMJA+ffqQkJAQotPprKbftWsXAUCSk5PZsLy8POLj40NGjBjBiduuXTvy4osvEq1Wy4Z98sknhGEYcvPmzWptjYuLI71797b10tyCRqMhvr6+ZP78+Xalc7t4PHz4kEyYMIE0adKEiMVi0qJFCzJlyhRSUVFBCCFk8+bNBAA5ceIEmTp1KgkICCA+Pj5s+rVr15J27doRsVhMmjRpQqZNm0YKCgo457h9+zZ54403SGBgIJFIJKRp06Zk+PDhpLCwkI1z+PBh0qtXL6JUKolMJiNt2rQhc+fOrdZ+W9KVl5eTxMRE0rJlSyIWi0lISAj58MMPSXl5uUl+W7duJZGRkcTT05P4+PiQPn36kEOHDhFCCGnevDkBwNmMQnL8+HECgBw/fpyT3+7du0mXLl2IVColfn5+ZOTIkSZfsbFjxxKZTEYePnxIBg8eTGQyGfH39yf/+te/qv0hEUJISkoKGThwIPsMn3/+eZKUlMRJ27dvXxPbrQnJ2LFjTeIbtwULFlRrkzXWrl1LAJDr169zwrdv304AkNOnT1tNP3ToUBIYGGhSyps8eTLx8vJin+v169cJALJ27VpOvKysLAKALFq0yOp5ysrKiFgsJp9++iknPDMzkwAgmzdvNklT9f4sWLCAACC3bt0iI0eOJN7e3sTf35/MmzePGAwGcv/+fRIXF0cUCgUJDAwkX375pVlbXn/9ddKxY0er9lZF6GBVySays7PRrVs3tv4YFhaGrKws/PDDDygtLYVYLGbjTps2DQEBAUhMTERJSQkA4NNPP8XChQsRHR2NqVOn4tatW1i/fj0uXbqEs2fPQiQSQaPRICYmBhUVFZg5cyaCgoKQlZWFffv2obCwEEqlEtevX8drr72Gjh07IikpCRKJBH/88QfOnj1r1X5b0hkMBsTFxeHMmTOYPHky2rZti99++w0rV67E7du3kZKSwsZduHAhPv30U/Ts2RNJSUkQi8VIS0vDsWPHMGDAAKxatYqt+37yyScAgMDAQIv2bdmyBePHj0dkZCSWLl2K3NxcfP311zh79iyuXLkCHx8fNq5er0dMTAyioqLw5Zdf4siRI1ixYgVatmyJqVOnWr0PW7ZsgVwux6xZsyCXy3Hs2DEkJiZCrVZj+fLlAIBPPvkEKpUKDx8+xMqVKwHAah3+nXfeQXR0NCfs4MGD2LZtGxo3bsyG5efnW7XNiEKhgEQiAQBcuXIFMpkMbdu25cTp1q0be7x3794W87py5Qq6dOkCgYDbJNitWzds3LgRt2/fRnh4OK5cuQIA6Nq1KydecHAwQkJC2OOWSE9Ph0ajQZcuXWy6RmsMHz4cbdu2xeeff479+/dj8eLFaNSoEf73f/8XL7/8Mr744gts27YNH3zwASIjI/GPf/yDkz4iIgJ79+6FWq2Gt7e3bSe1S2rsZMyYMUQgEJBLly6ZHDMYDISQv0sevXv35nzJ8vLyiFgsJgMGDOB8AdasWUMAkE2bNhFCCLly5YpJEbMqK1euJADI48eP7bLflnRbt24lAoHA5Gu2YcMGAoCcPXuWEELInTt3iEAgIK+//rrJF814LwixXG2pWvLQaDSkcePGpEOHDqSsrIyNt2/fPgKAJCYmsmHGr3xSUhInz86dO5OIiAjrN4EQUlpaahL2zjvvcL7ChDhXbblz5w5RKpXklVde4bwHsFA6qbpV/krHxsaS559/3uQcJSUlBACZM2eOVVtkMhmZMGGCSfj+/fsJAHLw4EFCCCHLly8nAMj9+/dN4kZGRpLu3btbPc+3335LAJDffvuNE+5IyWPy5MlsmE6nIyEhIYRhGPL555+z4QUFBcTT05OMHTvWJF9jqSwtLc2qzZVxW2+LwWBASkoKBg0aZKLMAMAwDGd/0qRJ8PDwYPePHDkCjUaDhIQEzhdg0qRJ8Pb2xv79+wEASqUSAHDo0CGUlpaatcX4Bd67dy8MBoPN12BLuuTkZLRt2xZhYWHIz89nt5dffhkAcPz4cQBASkoKDAYDEhMTTb5oVe+FLVy+fBl5eXmYNm0apFIpGx4bG4uwsDD2/lRmypQpnP0+ffrgzz//rPZcnp6e7P9FRUXIz89Hnz59UFpait9//91u26tSUlKC119/Hb6+vtixYwfnPUhNTbVpi4mJYdOUlZWxpZDKGO9TWVmZVXtsTW/8ayluded58uQJAMDX19dqPFt4++232f89PDzQtWtXEEIwceJENtzHxwcvvPCC2WdutMHWkh4AuK3a8vjxY6jVanTo0MGm+KGhoZz9e/fuAQBeeOEFTrhYLMbzzz/PHg8NDcWsWbPw1VdfYdu2bejTpw/i4uIwatQoVliGDx+Ob7/9Fm+//TbmzJmD/v3744033sCbb75p8kOujC3p7ty5g5s3byIgIMBsHnl5eQCAu3fvQiAQoF27djbdj+qwdH8AICwsDGfOnOGESaVSExt9fX1RUFBQ7bmuX7+OefPm4dixY1Cr1ZxjKpXKXtNNmDRpEu7evYtz587Bz8+Pc6xq1cYWPD09UVFRYRJeXl7OHndFeuNfS3GrO48R4gJnfs2aNePsK5VKSKVS+Pv7m4QbRcucDfZ8yNza5mEPtt5oc6xYsQLjxo3D3r17cfjwYbz77rtYunQpLly4gJCQEHh6euLUqVM4fvw49u/fj4MHD2LXrl14+eWXcfjwYc6XrqpN1aUzGAwIDw/HV199ZTaP5557zuHrciWWrrE6CgsL0bdvX3h7eyMpKQktW7aEVCpFRkYGZs+ebVdJzhxff/01duzYgX//+9/o1KmTyfGcnByb8lEqlew71KRJExw/fhyEEM6P4dGjRwCetUlYo0mTJmzcylRN36RJEza86nN+9OgR28ZiCaNQFhQUICQkxGpcwLrImHu+lp65uXyMH5GqYmMNt1VbAgIC4O3t7dDINQBo3rw5AODWrVuccI1Gg8zMTPa4kfDwcMybNw+nTp3C6dOnkZWVhQ0bNrDHBQIB+vfvj6+++go3btzAZ599hmPHjrHVCktUl65ly5Z4+vQp+vfvj+joaJPNWDJo2bIlDAYDbty4YfV8tiq/pftjDKt6fxzlxIkTePLkCbZs2YL33nsPr732GqKjo80Wte2tfp0+fRoffPABEhISMHLkSLNxmjRpYtO2a9cuNk2nTp1QWlqKmzdvcvJKS0tjj1ujU6dOyMjIMBHGtLQ0eHl5oU2bNpx8Ll++zImXnZ2Nhw8fVnuesLAwAEBmZqbZ40VFRZz93Nxcq/k5Q2ZmJgQCAXtttuA28RAIBIiPj8d///tfk5sLVF9Ui46OhlgsxurVqzlxv/vuO6hUKsTGxgIA1Gq1yWi+8PBwCAQCtjj59OlTk/yND9ZckdOILemGDRuGrKws/N///Z9J3LKyMrbnKD4+HgKBAElJSSYvZeXrk8lkKCwstGiTka5du6Jx48bYsGED5xp+/vln3Lx5k70/zmL8elW2UaPRYN26dSZxZTKZzdWYR48eYdiwYejduzfbY2MOR9o8Bg8eDJFIxLGREIINGzagadOm6NmzJ8eO33//HVqtlg178803kZubix9//JENy8/PR3JyMgYNGsS2cbRv3x5hYWHYuHEj9Ho9G3f9+vVgGAZvvvmm1XsQEREBsVhs9vcBwOTDtmfPHvZaXE16ejrat2/PVvVtwa3VliVLluDw4cPo27cv24356NEjJCcn48yZM5yuxKoEBARg7ty5WLhwIV599VXExcXh1q1bWLduHSIjIzFq1CgAwLFjxzBjxgwMHToUbdq0gU6nw9atW+Hh4YEhQ4YAAJKSknDq1CnExsaiefPmyMvLw7p16xASEmK1y86WdKNHj8bu3bsxZcoUHD9+HL169YJer8fvv/+O3bt349ChQ+jatStatWqFTz75BIsWLUKfPn3wxhtvQCKR4NKlSwgODsbSpUsBPHuh1q9fj8WLF6NVq1Zo3Lgx2/haGZFIhC+++ALjx49H3759MWLECLartkWLFnj//fcdfWwcevbsCV9fX4wdOxbvvvsuGIbB1q1bzb7AERER2LVrF2bNmoXIyEjI5XIMGjTIbL7vvvsuHj9+jI8++gg7d+7kHOvYsSM6duwIwLE2j5CQECQkJGD58uXQarWIjIxESkoKTp8+jW3btnGK83PnzsX/+3//D5mZmWjRogWAZ+LRvXt3jB8/Hjdu3IC/vz/WrVsHvV6PhQsXcs61fPlyxMXFYcCAAXjrrbdw7do1rFmzBm+//bZJV3FVpFIpBgwYgCNHjiApKcnk+MGDBzFy5Ej84x//wO3bt7Fx40Z4eXnh8OHDiIyMxGuvvWb3vTGHVqvFyZMnMW3aNPsS2twv4yD37t0jY8aMIQEBAUQikZDnn3+eTJ8+3WSQmLnuXEKedc2GhYURkUhEAgMDydSpUzmDxP78808yYcIE0rJlSyKVSkmjRo3ISy+9RI4cOcLGOXr0KBk8eDAJDg4mYrGYBAcHkxEjRpgMNa6Krek0Gg354osvSPv27YlEIiG+vr4kIiKCLFy4kKhUKk7cTZs2kc6dO7Px+vbtS1JTU9njOTk5JDY2ligUCpsGie3atYvNr1GjRlYHiVXF2M1XHWfPniXdu3cnnp6eJDg4mHz00Ufk0KFDJvYUFxeTf/7zn8THx6faQWLmBpUZN2cHiRHybIj5kiVLSPPmzYlYLCbt27cn//73v03iGbuxMzMzOeFPnz4lEydOJH5+fsTLy4v07dvX4ju6Z88e0qlTJyKRSEhISAiZN28e0Wg0Ntn5448/EoZhON29xq7aJUuWkOjoaCKRSEhoaCj54YcfyMcff0y8vLzIwoULCSF/P8OqwwksPfO+ffuS9u3bc8J+/vlnAoDcuXPHJpuNMITQdVsolNpCr9ejXbt2GDZsGBYtWgQA+OuvvxAaGorNmzdj3LhxbrchPj4eDMOw1SJbobNqKZRaxMPDA0lJSVi7dm2tTMm/efMm9u3bxwqXPVDxoFBqmeHDh+Pp06e1MiW/bdu20Ol0No/HqgwVDwqF4hC0zYNCoTgELXlQKBSHqDPD0+s6BoMB2dnZUCgUDk1ko9Q/CCEoKipCcHCw1TlS9RUqHjaSnZ2Nb775BkKh6S0jhKCgoMDhkX9isZgzIlYikcBgMECj0Thlsz0IhUIIhULodDrodDqOTTVVs2UYhnPtVW2qKao+D6lUCplMZvY+LFmyBA8ePLBpbkpVrH2E+NCaQMXDRhQKBYRCIby8vEy+MoQQtGjRwuHJZwaDAWq1mh0iLRKJ4O3tXeNfs9LSUnY4vUAgwK1bt+z+0VZ1MmMvOp0OKpWKHcIvk8ng5eXlVJ72UvV5CIVCVFRUmDwPo40KhcKh8/C9tELFw0aMXwmBQACRSMSGGwwGGAwGSCQSjmc0exGJRKwvBT8/P7M+ItyNVCrlfG2r80dhDlf80LVaLTv9vVGjRrXyI6v8PIzT2AUCAccWo7g4Wo3lu3jw2/p6gkajwZMnTyASiSASifDkyZMarbIAz0TwyZMnYBgGUqkU5eXlDn9RnaGoqAjl5eWQSqVgGAZPnjxxetq/vVR9HoWFhW6xgWEYixsfoOJRy2g0GuTn50MkEsHf3x/+/v7sV6+mBMQoHFqtFv7+/vDz84O3tze8vb1rVECKiopYH5p+fn7w9/eHVqutUQEx9zyM7S6VZ866AmNJxtzGB2i1xU4IIZwX2WAwgBDCmdJtK1qtFgUFBRAKhfD29mbbF7y9vVFQUIC8vDz4+vpyqkmuxtjYq9PpWB8dGo0GEokEJSUlUCqV8PDwYNtCqsNRwSspKUFxcTHkcjkkEgmbj1Kp5NwLd36VLT0PmUyGoqIi1iZzbgocgS8iYQkqHnZgfFnMiUdFRYVdXyZjj4KxraSqXxFPT09oNBqUlJSwrf+uhhACjUYDgUAAuVwOvV7PuQaDwcB6uRcIBDY1nhrbKuxBp9NBq9VCJpPBw8PDJA+5XA6NRgO1Wg2xWOwWAbH2PHQ6HQQCAQwGA7RaLQghLnkeVDwaEIWFhWjevDnH4bBWq0VFRQUGDhxolyMVPjB37ly70yxZssQNltQuKpUKBw4cgFgsRnFxMVtKc7YaQ8WjAWEwGCAUCk16VfR6PZRKJRo1alRLlrkHW5wjV6W+3QMjxufeuHFjPHnyBCqVyumJbHwXD35bT6HUMAKBAH5+fhCJRE57jud7gyk/rKwjiMXiGu82pNQ9jALi6KDAyvnwWTxotcUOBAIB1Gq12VGmlIaFQCCwfVlGK3nwGX5bX8MYe1RqY+ASpe7h7I+f7yUPflhZRyCEQKlU1vjAJUr9hIpHA0MoFHJGPvJh9iOlbkLFw4UsXboUkZGRUCgUaNy4MeLj482uiFaV5ORkhIWFQSqVIjw8HAcOHOAcJ4QgMTERTZo0gaenJ6Kjo3Hnzh2H7RSLxayAODMVn9KwoeLhQk6ePInp06fjwoULSE1NhVarxYABA6wOjT537hxGjBiBiRMn4sqVK4iPj0d8fDxnmctly5Zh9erV2LBhA9LS0iCTyRATE+PQaEgjRgHR6XQ1PomNUj/g+8S4OtXbcvDgQc7+li1b0LhxY6Snp1v0E/H111/j1VdfxYcffggAWLRoEVJTU7FmzRps2LABhBCsWrUK8+bNw+DBgwEA33//PQIDA5GSkoK33nrLbL4VFRWcIcpVV4cHngmIr6+vzfM+KJTK8KWEYYk6bb1xEI61UYvnz583WZIwJiYG58+fB/BsAd+cnBxOHKVSiaioKDaOOZYuXQqlUslulla7F4lETvnxoDRcaLXFTRgMBiQkJKBXr15W15TIyclBYGAgJywwMBA5OTnscWOYpTjmmDt3LlQqFbs9ePDA0UuhUMzCd/GoU9WWykyfPh3Xrl3DmTNnauX8EonEJm9eWq2WtnlQHIIvImGJOmn9jBkzsG/fPhw/frxax7JBQUHIzc3lhOXm5iIoKIg9bgyzFMdRNBoNCgoKeNPARalb8L3kUaesJIRgxowZ2LNnD44dO4bQ0NBq0/To0QNHjx7lhKWmpqJHjx4AgNDQUAQFBXHiqNVqpKWlsXEcwehxytwsWwrFFvguHnWq2jJ9+nRs374de/fuhUKhYNsklEolPD09AQBjxoxB06ZNsXTpUgDAe++9h759+2LFihWIjY3Fzp07cfnyZWzcuBHAs+6whIQELF68GK1bt0ZoaCjmz5+P4OBgxMfHO2RnZVd13t7eJo58KBRb4ItIWKJOicf69esBAP369eOEb968GePGjQMA3L9/n3PTe/bsie3bt2PevHn4+OOP0bp1a6SkpHAaWT/66COUlJRg8uTJKCwsRO/evXHw4EGOUx9b0el0KCwshEgkgp+fX42uJ0KpX1DxcCG2jNQ8ceKESdjQoUMxdOhQi2kYhkFSUhKSkpKcMQ8Mw0ClUkEqlcLPz4/3D59Su/D9/alT4lHXkUgk8PDwoMJBAQCnJ0by/R2i4mEHBoOhVlZyo9Q9jKvKOQPf3yMqHnZg9DROadgY17lx1gEy37v4qXhQKHZQeYEsZ73l8/1DRMWDQrERQghnZT1ne9qoeFDqLYQQu4rW9dmviXFlPYPBAH9/f4jF4gYvHvy2nuJW5s+f79b4fEKj0UCn07HC4Qr4PsKUH1ZSaoXFixe7NT6fIITA19fXpVMRqHhQ6i2//PKLW+PzCbFY7PIFx/kuHrTNg2KRF198ETqdDkJh9a+JTqdzehGkuow7ftB8EQlL8Nt6itvx8PBATEyM1TgxMTH1WjgA9zQG873kwQ8rKbXGli1bcOjQIatxDh06hC1bttSMQbWERqNxuYBQ8aDUa8aPH+/SeHylcletq6DiQam3WHL67Kr4fMI4rsOVKwVS8aDUS7RaLR4+fGhXmocPH0Kr1brJotpFIBDA19fXpUuNUvGg1Esc7ZZ0dXdmXUIkEnGWGnVWQPi+6BMVD4pFKq+65474fKTyUqOumJLP55IHHedhB7aMd6hPtG/fno7zMINRQKp65LcXvoiEJRrWr8FJhEIhSktL4eXlVdum1BgeHh7VTpCrzxPiLCEWi+mU/No2gE/odDqUlJRAIpFAoVDUtjmUWsbZkijfxYPf1tcwOp0OMpkMarUaRUVFtW2OWyktLUXr1q3xyiuvVNuAxzAMXnnlFbRu3RqlpaU1ZCH/aXBtHpmZmTh9+jTu3buH0tJSBAQEoHPnzujRo4dDSxnwDS8vL0gkEraxzJYlKfmEQqFAcXExu//HH3/YlO7IkSMAAJlMBgCQy+X1XmCdhS8iYQmbrd+2bRu6deuGli1bYvbs2UhJScHp06fx7bff4tVXX0VgYCCmTZuGe/fuudPeOoFCoYC3tzfUajVKSkpq2xyHGDJkCKdE0aFDBzAMwwoHwzDw8fGxK08fHx82z+LiYjAMw1k/hy9dkDUF30seNlnZuXNnrF69GuPGjcO9e/fw6NEjpKen48yZM7hx4wbUajX27t0Lg8GArl27Ijk52d121zpGASkuLublwk8//vgjgL/HGly/fp09tmbNGhgMBhQUFNiVp3H49po1a9iw69ev82rsQk3Cd/Gwqdry+eefW51ZKZFI0K9fP/Tr1w+fffYZ/vrrL1fZV6dRKBTQ6XTQaDS1bYrdyGQys6Wm06dPo2fPnk7lPXXqVLz44ovo06ePU/nUd/giEpawSTyqm5JdGT8/P/j5+TlsEN+QyWS87Kpcv349xowZYxJe+QfvyHXREobt8F08HLY+Ly8P165dw6+//srZGiJ8GRzl4eEBuVyOrVu3YvPmzSbHb9++zb7Qy5cvB2C7gBjjGdMJBALcvn3bJN6lS5cwcOBAMAzDm/vmLhpEtaUy6enpGDt2LG7evMm+MAzDsAOJnF0Ih28QQnhTbZHJZCgqKjIpcQQGBiInJwcAOM+voqLC5h6T/Px8KBQKfPDBB/jggw/YcEIIgoKC2NGY3bp149jTkOF7Kc1uiZswYQLatGmDc+fO4c8//0RmZibnb0PC2KjIl2qLsVRQmYyMDFY4jKSmpoJhGEilUgQEBNiUd0BAAKRSKRiGQWpqKudYTk4OMjIybLKnIdHgSh5//vkn/vOf/6BVq1busIc3GFcO0+l0kMvltW2OTUyZMoWzHxwcjM6dO3PCGjdujMePHzt1ngEDBiAgIAB5eXlsWNXzGO155513nDoXn+GLSFjCbuv79++Pq1evusMW3lB5yUFfX19evASZmZmc/VWrViErK4sTxjCM08Jh5PHjxybFcnMltKp2NSQaXMnj22+/xdixY3Ht2jV06NDBxH9DXFycy4yri1QWDn9/fwDgRTvP888/z9kvKyvj7Lur/m1sD7NmF1+qfa6GLyJhCbvF4/z58zh79ix+/vlnk2MNocHUOCzduHIYHxpLK/udMDZsz507F3PmzAEAbNq0ya3n37RpEyZMmMAZTFd5pq5arYa3t7dbbaiL8F087LZ+5syZGDVqFB49egSDwcDZ6rtwiMVi6PV6ly45WBMEBwcDALp06WLi/So/Px8TJ0506/knTpyI/Px8k1moXbp04djX0OB7tcVuK588eYL3338fgYGB7rCnTiMQCKBUKuukcBjnpmRnZ5scM44kTU9Ph0AggFarZasKtvamOIvxPHq9nj13eno6x77KZGdnm8yNqWs4O4OY7+Jhd7XljTfewPHjx9GyZUt32FOnqaiowLlz5zhOfkUiETw9PTF37ly754LYSr9+/XDixAl2Py0tjR0vodfr0bx5c7bxs2nTprhz547Z3jCBQACFQoGkpCS89957brG1OgQCAYKCguDt7W1xxu4ff/yB1q1bA3g2N+a3335DeHg4e/zixYuIiopi96veH1fj6+uLYcOGoaysjH32CoWCOgOyN0GbNm0wd+5cnDlzBuHh4SYNpu+++67LjKtr1FbDXtUfRlRUlFXvXq1btzZrKyEEarUaCQkJWL58Oe7fv+8Ocy1SWFgIX19fALDqws8oHEY6duwIALh58ybCwsI4wgGY3h93U3lSpDM0OPH49ttvIZfLcfLkSZw8eZJzjGGYei0edYnqekeUSiVUKpXFeFlZWTU+PNwoHOYw9spY+5q3bdvWHWbZRWV3DOXl5U7lxXfxsNv6zMxMi5urRpiuXbsWLVq0gFQqRVRUFC5evGg1fnJyMsLCwiCVShEeHo4DBw5wjhNCkJiYiCZNmsDT0xPR0dG4c+eOS2ytq6jVat4Nf2YYxmmP5O5EJpOxwuEKR0d8b/NwmZWPHj3CsmXLnM5n165dmDVrFhYsWICMjAy8+OKLiImJ4YxWrMy5c+cwYsQITJw4EVeuXEF8fDzi4+M5ywAsW7YMq1evxoYNG5CWlgaZTIaYmBinvxyUhoNQKIRcLnepC0q+iwdD7KzIT5gwwWz4vXv3cPHiRadvbFRUFCIjI1mHMgaDAc899xxmzpzJjkuozPDhw1FSUoJ9+/axYd27d0enTp2wYcMGEEIQHByMf/3rX+yELZVKhcDAQGzZsgVvvfWWWTsqKipQUVHB7qvVaixevJjTaAb83WC6e/dutzWYUmoXX19fjBkzBhqNBoWFhWy4SCTC999/D5VK5dA4lQULFlg8tnDhQkdMrVHslriCggLOlp+fj4sXL+LEiRP48ssvnTJGo9EgPT0d0dHRfxsoECA6Ohrnz583m+b8+fOc+MAz/yPG+JmZmcjJyeHEUSqViIqKspgnACxduhRKpZLd6vM6rJTqMXrOdyV8L3nY3WC6Z88es+GfffYZUlJSnJrolJ+fD71ebzKGJDAwEL///rvZNDk5OWbjG2eKGv9ai2OOuXPnYtasWey+seRBaZi4w9UkX0TCEi5bt2XEiBH16sclkUjqnWd0St2C7+LhMuuvXr1qdtq1Pfj7+8PDw8NkDEBubi6CgoLMpqnsaMZcfONfe/KsD3h7e/NuwhkhpM7OcXHHUqMNrtpSuShvJDc3F3v37kVsbCzn+FdffWVX3mKxGBERETh69Cji4+MBPGswPXr0KGbMmGE2TY8ePXD06FEkJCSwYampqejRowcAIDQ0FEFBQTh69Cg6deoE4FkVJC0tDVOnTrXLvrpEdUtAqlQqq/GaNm2K+/fv1+hYj4KCAotjPYxCZ21sinGQWG10QQuFQshkMk6DqbPwRSQsYbd4XLlyxWx4ZGQk8vLy2C5VRx/wrFmzMHbsWHTt2hXdunXDqlWrUFJSgvHjxwMAxowZg6ZNm2Lp0qUAgPfeew99+/bFihUrEBsbi507d+Ly5cvYuHEja0dCQgIWL16M1q1bIzQ0FPPnz0dwcDArUHUdc8PTgWc/uKrD0wFYHMPCMEytDk/38fFh3RIah6ebKx3duXOHM8r0119/5QxPT0tLq9Hh6QBYp096vd6lXbV8xm7xOH78uDvsYBk+fDgeP36MxMRE5OTkoFOnTjh48CDb4Hn//n3OTe/Zsye2b9+OefPm4eOPP0br1q2RkpLCmVD10UcfoaSkBJMnT0ZhYSF69+6NgwcPOrTC3T/+8Q/OQtcajQbl5eVYsmQJGjVq5MSVO4aHhwcePnyIDh064Pr168jKyrI4S9U4o7Y215kxGAychmpzH5lWrVohKysLTZs2Rfv27TnCATzzg1qTVbKnT58iOTkZer0epaWl8Pb2hkKhQGlpKb7//nuH821w4lETzJgxw2I1xdwXZujQoRg6dKjF/BiGQVJSEpKSklxlYp2j8qC4qhjXaImIiMClS5fY+UiEEDx+/LhGZtYaPZQZq0mEEERERLD2VSU4OLjOtdnIZDIIhUJ2FKyzVT6+i4dN1r/66qu4cOFCtfGKiorwxRdfYO3atU4bRnEdxmn6GRkZJi+sv78/vvvuO7ee/7vvvoO/v79JicfoFNmcG4G6SuW5LXRKvg0MHToUQ4YMgVKpxKBBg9C1a1cEBwdDKpWioKAAN27cwJkzZ3DgwAHExsbWW6/YfJsrYqRyD4bxGoxtRsCzUcPudAhkHJVcucei8r2sqz0sllAoFACeVWecgS8iYQmbxGPixIkYNWoUkpOTsWvXLmzcuJFtzWcYBu3atUNMTAwuXbpUJ2Y+uguJRMLLdWmBZ17vK/sx9fT05ByvrvfGUaqrevB1uQ6FQsGZvuAIDUI8gGc/nFGjRmHUqFEAnnWplZWVwc/Pz8SnR33FYDBApVJBKpXWSW9i1ggNDeXsJyQkYNmyZZxeGkKIS5ZeAGCy9AJgvuRW1S4+Ubnh3BH4WpI14rD0KZVKBAUFNRjhAJ71rHh4eCA/P58Xjo+rsmHDBs5+dna2Sdd7Xl4eDh8+7NR5Dh8+bCIc5rr4q9rT0OB7mwc/rKxDeHt7QyQS8VJAPvzwQ5OwLl26mIy0feWVV0AIQXl5uc2lkMePH6O8vByEELzyyiucY0FBQayz4+rsaUhQ8WhgCAQCtqqWn5/PmZ5fl1m8eLHFwU25ubkcB0rG2aMSiYRdm6Y6/P392blAlWefHjhwwKLLwaKiono1H8peqHg0QCoLSEFBgclyBnWRefPmgRDCblW9s8XGxoJhGDAMA7lcztbHzZUYzGGMVzk9wzCIjY3lxKtsAyEE8+bNc8HV8RMqHg0Uo4AIhULeVV8A645ogL/nMFmajlAVYzxzc58o5mlw4jF27FicOnXKHbbwDoFAAF9fX162mptb8c/ImjVrsGLFCofyXbFiBesFjmKdBiceKpUK0dHRaN26NZYsWWKyWHJDg2EY3nXbAs/W3wH+rka0b9+ePTZjxgxWGO3BuOh35akF7du3Z89B4dLgxCMlJQVZWVmYOnUqdu3ahRYtWuB//ud/8MMPP/Cm8dDV8HGZzf/85z+cH/S1a9dACIFcLgfwTFTsnX5eWFjI5imXy0EI4cy5oQLCpcGJB/BsANCsWbNw9epVpKWloVWrVhg9ejSCg4Px/vvv1/tlDSpTUlJSr0SzqKgIhBCUlJSgVatWJv5hLREdHY1WrVqhpKQEhBCXTVuvz/BdPJyaVfvo0SOkpqYiNTUVHh4eGDhwIH777Te0a9cOy5Ytw/vvv+8qO+skRUVFKC4uNjsrlO94eXlxPgLW2nVoicIx+CISlrBbPLRaLX766Sds3rwZhw8fRseOHZGQkIB//vOf7ASnPXv2YMKECfVaPIqKiqBWqyGXy2t85TVK/aDBiUeTJk1gMBgwYsQIXLx4kXXtV5mXXnoJPj4+LjCvbmIUDm9vb0gkknq9eJRer6/WfyfDMNDpdFRE7aTBicfKlSsxdOhQq164fHx8kJmZ6ZRhdZXS0lJUVFSw3qT4OMbDVq5fv87xyGYNoVCIa9eucXptKNbhYxd/ZewWj9GjR7vDDl4gFApRUlKCRo0asT4d6jO2Ckfl+LT9w3YaXMmjIWP0oN0QhMPRHiStVttgZlo769uF7+LBb+trGJ1O57QPB74gEokQEhJiV5qQkJAGIxwajYZ1iOUoDbqrtqHBVy9ijvLgwQO76uUPHjxwozV1B41Gg/z8/AbvAJmKB8UqAoHAplnDfP8h2IpROEQikYkrR3vh+z2j4kGxil6vt6n0wcch+vai1WqhUqkgEong5+fndBc9FQ9KvcZWUdDr9fV6nIfBYIBarYZEIoGfn59Lfvh8Fw9+W09xK1evXrV5gWehUIirV6+62aLaQ6PRQCgUukw4ANpgSqnHmBs9XF38+jrOg2EY1uWAq+CLSFiC39ZT3Iq9LgLrs0tBsVjs8hGhfC958MNKSq2waNEit8bnE+4YSs538aDVFgrFBtzh5LrBzW2hNBzsfbkZhqm3bR4ajQYikcilLif5UsKwBBUPCsUGGIZBQUGBSwWE7+LBb+splBpCLBZDKBS6dKVAvrd58MNKCqWWMXbVunKpUSoeFEoDgWEYzlKjrpiST8WDQmkgVF5qtKFPyeeHlXUEsVjMi3VpKe7FKCCumJLPZ/GgvS12IBAIoFar4eXlxZsHTHEPAoGAXS3AmTz4TJ2xXqvVYvbs2QgPD4dMJkNwcDDGjBmD7OzsatOuXbsWLVq0gFQqRVRUlMkK8OXl5Zg+fTr8/Pwgl8sxZMgQ5Obm2m1jRUUF9Ho9njx5QksgFKd//HwvedQZK0tLS5GRkYH58+cjIyMDP/74I27duoW4uDir6Xbt2oVZs2ZhwYIFyMjIwIsvvoiYmBjk5eWxcd5//33897//RXJyMk6ePIns7Gx2rVZ7IIRAqVRCq9VSAaE4Dd/Fo85UW5RKJVJTUzlha9asQbdu3XD//n00a9bMbLqvvvoKkyZNwvjx4wEAGzZswP79+7Fp0ybMmTMHKpUK3333HbZv346XX34ZALB582a0bdsWFy5cQPfu3e2yUygUwt/fH/n5+Xjy5InTRVdKw4UvImGJOm29SqUCwzAWF5DSaDRIT0/nrKcqEAgQHR2N8+fPAwDS09Oh1Wo5ccLCwtCsWTM2jjkqKiqgVqs5mxGxWAx/f39otVoUFBTU2yHZFPfC95JHnbWyvLwcs2fPxogRIyx+3fPz86HX6xEYGMgJDwwMRE5ODgAgJycHYrHYRIAqxzHH0qVLoVQq2e25557jHDcKiE6nq9cLP1HcB8MwFjc+UGvisW3bNsjlcnY7ffo0e0yr1WLYsGEghGD9+vW1Yt/cuXOhUqnYzZxncLFYDF9fX1ryoDgE30setdbmERcXh6ioKHa/adOmAP4Wjnv37uHYsWNW2xT8/f3h4eFh0nOSm5uLoKAgAEBQUBA0Gg0KCws5pY/KccwhkUggkUiqvQ5Xz7SkNBz4IhKWqDXrFQoFWrVqxW6enp6scNy5cwdHjhyBn5+f1TzEYjEiIiJw9OhRNsxgMODo0aPo0aMHACAiIgIikYgT59atW7h//z4bh0KpDWjJw0VotVq8+eabyMjIwL59+6DX69k2iUaNGrFf9/79++P111/HjBkzAACzZs3C2LFj0bVrV3Tr1g2rVq1CSUkJ2/uiVCoxceJEzJo1C40aNYK3tzdmzpyJHj162N3TYslu2uZBcQS+iIQl6ox4ZGVl4aeffgJg6nj3+PHj6NevHwDg7t27yM/PZ48NHz4cjx8/RmJiInJyctCpUyccPHiQ04i6cuVKCAQCDBkyBBUVFYiJicG6deuctlmj0aCgoMCm6g2FUhUqHi6iRYsWNjU8/vXXXyZhM2bMYEsi5pBKpVi7di3Wrl3rjIkcjCuHCYVC2uZBcQgqHg2QyksOent7o6KiorZNovAQKh4NDJ1Oh8LCQnbJwYa2+DXFdVDxaEAwDAOVSgWpVOrSlcMoDRO+vz9UPOxAIpHAw8ODCgcFgPPLMfD9HaLiYQeEEHh5eXGqKlqtFjqdzmmvUnURX19fu9M8ffrUDZbULiqVCjqdDlqtlg0jhKCwsNCpfKl4NCBkMhkKCgo4QmEwGEAIwYEDB6pdFNpgMECj0YBhGLuWLySEQKPRgBACsVjs1EtnT17Dhg3j7AuFQgiFQuh0OottPcnJyTbZYfwxikQimxfTBhy/h87kZWznYhgGAoEAhBDodDqnSx58mcNiCSoedmB82FV/cIQQSCQSiESiavMQiUQoKCiAXq+Hr69vtS8QIQQFBQXQ6XSs925nkUqlKCgoQHFxsdU8y8rK2P9lMhm8vLxQXFyMkpISq3nbSklJCYqLiyGXyyGTyaqNr9VqoVarIRQKbbp3tmDL89BqtRAIBOwxrVYLQohL3BDyGSoedmL8+lTGYDDYPMdFLBaz3rfVarXV9hODwcA6HWrcuLFLx5M0btwYT548gUqlgr+/v9m8jcV0hUIBmUwGlUqFoqIiq/naY6NxLRSjICgUCotxNRoNVCoVJBKJS9ucbH0extmuxtHEEonE6QmRfBcPflvPUyr7A7HkkcwoHFqt1uKP2xkqewG3tg6JQqGAt7c31Gp1tcLhCLbkX3lcjTsaq219HhUVFWx1z56qliX4PreFH1bWQ6y9sO4WDiPVCYi7hcOW87hbOIxU9zz0er1LhQPgv3jQaouNGIuoBoPBpNUdeOZ5zJEBY3K5HCqVCjk5Oaz7AbVaDb1eD6VSabVx0lUYZzTn5uZCqVRCKBSitLQUSqUSxcXFKC8vt7mtpbS01CEbPDw8IJFI8PTpU1RUVLC9WiqVCh4eHvD09ER5eblDeduDueehUqlgMBjg4eEBQgj7/I0C42j1hS8iYQmGUE82NvHw4UMTb2IUCgA8ePAAISEhtW1GjUPFw0YMBgOys7OhUCicauVXq9V47rnn8ODBA146T+a7/YDrroEQgqKiIgQHB/O+FOEItNpiIwKBwKVfF29vb97++AD+2w+45hqUSqWLrOEfDU8uKRSKS6DiQaFQHIKKRw0jkUiwYMEC3nof47v9QP24hroAbTClUCgOQUseFArFIah4UCgUh6DiQaFQHIKKB4VCcQgqHk6i1Woxe/ZshIeHQyaTITg4GGPGjEF2dna1adeuXYsWLVpAKpUiKioKFy9e5BwvLy/H9OnT4efnB7lcjiFDhpgsrekKqrOjKsnJyQgLC4NUKkV4eDgOHDjAOU4IQWJiIpo0aQJPT09ER0fjzp07LrcbeLYgeWRkJBQKBRo3boz4+HjcunWr2nR16Rp4C6E4RWFhIYmOjia7du0iv//+Ozl//jzp1q0biYiIsJpu586dRCwWk02bNpHr16+TSZMmER8fH5Kbm8vGmTJlCnnuuefI0aNHyeXLl0n37t1Jz549XWq/LXZU5uzZs8TDw4MsW7aM3Lhxg8ybN4+IRCLy22+/sXE+//xzolQqSUpKCrl69SqJi4sjoaGhpKyszKW2E0JITEwM2bx5M7l27Rr55ZdfyMCBA0mzZs1IcXGxxTR17Rr4ChUPN3Dx4kUCgNy7d89inG7dupHp06ez+3q9ngQHB5OlS5cSQp6JkkgkIsnJyWycmzdvEgDk/PnzLrO1OjuqMmzYMBIbG8sJi4qKIu+88w4hhBCDwUCCgoLI8uXL2eOFhYVEIpGQHTt2uMxuS+Tl5REA5OTJkxbj1PVr4Au02uIGVCoVGIaBj4+P2eMajQbp6emIjo5mwwQCAaKjo3H+/HkAQHp6OrRaLSdOWFgYmjVrxsZxFlvsqMr58+c58QEgJiaGjZ+ZmYmcnBxOHKVSiaioKJfZbQ2jf9lGjRpZjFPXr4EvUPFwMeXl5Zg9ezZGjBhhcdJVfn4+9Ho9Zz1dAAgMDGQX987JyYFYLDYRoMpxnMUWO6qSk5NTrd3GMHfZbQmDwYCEhAT06tULHTp0sBivLl8Dn6DiYSfbtm2DXC5nt9OnT7PHtFothg0bBkII1q9fX4tWNkymT5+Oa9euYefOnbVtSoOATsm3k7i4OERFRbH7TZs2BfC3cNy7dw/Hjh2zOtXb398fHh4eJj0nubm5CAoKAgAEBQVBo9GgsLCQU/qoHMdZbLGjKkFBQdXabQxr0qQJJ06nTp1cYrc5ZsyYgX379uHUqVPVuk6oq9fAN2jJw04UCgVatWrFbkYXfsOGDcOdO3dw5MgR+Pn5Wc1DLBYjIiICR48eZcMMBgOOHj2KHj16AAAiIiIgEok4cW7duoX79++zcZzFFjuq0qNHD058AEhNTWXjh4aGIigoiBNHrVYjLS3NZXZXhhCCGTNmYM+ePTh27BhCQ0OrTVPXroG31HaLLd/RaDQkLi6OhISEkF9++YU8evSI3SoqKth4L7/8Mvnmm2/Y/Z07dxKJREK2bNlCbty4QSZPnkx8fHxITk4OG2fKlCmkWbNm5NixY+Ty5cukR48epEePHi61vzo7Ro8eTebMmcPGP3v2LBEKheTLL78kN2/eJAsWLDDbzenj40P27t1Lfv31VzJ48GC3dXNOnTqVKJVKcuLECc69Ly0tZePU9WvgK1Q8nCQzM5MAMLsdP36cjde8eXOyYMECTtpvvvmGNGvWjIjFYtKtWzdy4cIFzvGysjIybdo04uvrS7y8vMjrr79OHj165PJrsGZH3759ydixYznxd+/eTdq0aUPEYjFp37492b9/P+e4wWAg8+fPJ4GBgUQikZD+/fuTW7duudxuQojFe79582beXANfoVPyKRSKQ9A2DwqF4hBUPCgUikNQ8aBQKA5BxYNCoTgEFQ8KheIQVDwoFIpDUPGgUCgOQcWDQqE4BBUPilm+++47DBgwwO3nOXjwIDp16gSDweD2c1FcCxUPignl5eWYP38+FixY4PZzvfrqqxCJRNi2bZvbz0VxLVQ8KCb88MMP8Pb2Rq9evWrkfOPGjcPq1atr5FwU10HFox7z+PFjBAUFYcmSJWzYuXPnIBaLTaakV2bnzp0YNGgQJ6xfv35ISEjghMXHx2PcuHHsfosWLbB48WKMGTMGcrkczZs3x08//YTHjx9j8ODBkMvl6NixIy5fvszJZ9CgQbh8+TLu3r3r+MVSahwqHvWYgIAAbNq0CZ9++ikuX76MoqIijB49GjNmzED//v0tpjtz5gy6du3q0DlXrlyJXr164cqVK4iNjcXo0aMxZswYjBo1ChkZGWjZsiXGjBmDyvMxmzVrhsDAQI5XNkrdh4pHPWfgwIGYNGkSRo4ciSlTpkAmk2Hp0qUW4xcWFkKlUiE4ONjh873zzjto3bo1EhMToVarERkZiaFDh6JNmzaYPXs2bt68aeLJKzg4GPfu3XPonJTagYpHA+DLL7+ETqdDcnIytm3bBolEYjFuWVkZAEAqlTp0ro4dO7L/Gx0Ih4eHm4Tl5eVx0nl6eqK0tNShc1JqByoeDYC7d+8iOzsbBoMBf/31l9W4fn5+YBgGBQUF1ear1+tNwkQiEfs/wzAWw6p2zT59+hQBAQHVnpNSd6DiUc/RaDQYNWoUhg8fjkWLFuHtt982+epXRiwWo127drhx44bJsapVjT///NMlNpaXl+Pu3bvo3LmzS/Kj1AxUPOo5n3zyCVQqFVavXo3Zs2ejTZs2mDBhgtU0MTExOHPmjEn43r178eOPP+Lu3bv47LPPcOPGDdy7dw9ZWVlO2XjhwgVIJBLqXJhnUPGox5w4cQKrVq3C1q1b4e3tDYFAgK1bt+L06dNW15WZOHEiDhw4wK6+ZiQ2NhbLli1Du3btcOrUKaxbtw4XL17E1q1bnbJzx44dGDlyJLy8vJzKh1KzUB+mFLMMHToUXbp0wdy5cwE8G+fRqVMnrFq1yqXnyc/PxwsvvIDLly/btGwCpe5ASx4Usyxfvhxyudzt5/nrr7+wbt06Khw8hJY8KDbhrpIHhb9Q8aBQKA5Bqy0UCsUhqHhQKBSHoOJBoVAcgooHhUJxCCoeFArFIah4UCgUh6DiQaFQHIKKB4VCcYj/Dy/kucqvNhDmAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\tJ = 9.3359e-01\n", + "\tgrad_norm = 1.9402e-02\n", + "step = 24\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\tJ = 9.4594e-01\n", + "\tgrad_norm = 9.0214e-03\n", + "step = 25\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\tJ = 9.4385e-01\n", + "\tgrad_norm = 1.5572e-02\n", + "step = 26\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\tJ = 9.5159e-01\n", + "\tgrad_norm = 8.1870e-03\n", + "step = 27\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\tJ = 9.5354e-01\n", + "\tgrad_norm = 1.7442e-02\n", + "step = 28\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\tJ = 9.4670e-01\n", + "\tgrad_norm = 1.9657e-02\n", + "step = 29\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\tJ = 9.5474e-01\n", + "\tgrad_norm = 1.1618e-02\n", + "step = 30\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAQ8AAADaCAYAAAC4q8cWAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjMsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvZiW1igAAAAlwSFlzAAAPYQAAD2EBqD+naQAAOjZJREFUeJztnXd4FNXex7+72ZZsspuQQAqBJDRDCQZC6IhKJGokRKXISxWkCShyvUIQEgkICiqItJerwpVLjQp4AVG6dKRcXylSQyhpJCS76dvO+wfPzN3JlmxLsrM5n+eZJ9kzv3PmN+07px8BIYSAQqFQ7ETY0A5QKBR+QsWDQqE4BBUPCoXiEFQ8KBSKQ1DxoFAoDkHFg0KhOAQVDwqF4hBUPCgUikNQ8aBQKA5BxYMnHD16FAKBAEePHm1oVyguZseOHWjSpAnKysrq/dhXr16FSCTC5cuX7Y5LxcPNWLNmDTZu3NjQbjjEli1bsGLFioZ2AwBgMBiwdOlSREVFQSaToXPnzti6davN8UtKSjBp0iQ0bdoUcrkczz33HC5evGjW9qeffkLXrl0hk8nQsmVLpKenQ6fT2XQcvV6P9PR0zJgxA76+vjb75yo6dOiApKQkpKWl2R+ZUNyKjh07kv79+5uE6/V6UllZSfR6ff07ZSNJSUkkIiKiod0ghBAyZ84cAoBMnDiRrF+/niQlJREAZOvWrbXG1ev1pHfv3kQul5OPPvqIrFq1inTo0IH4+fmRGzducGz37dtHBAIBee6558j69evJjBkziFAoJFOmTLHJz507dxKBQEAePHjg0Hm6gn379hEA5NatW3bFc0vxKCsra2gXGgxL4sEH3EU8Hjx4QMRiMZk2bRobZjAYSL9+/Uh4eDjR6XRW42/fvp0AIJmZmWxYQUEB8ff3JyNGjODYdujQgTz99NNEq9WyYR9++CERCATk2rVrtfqanJxM+vbta+up1QkajYYEBASQ+fPn2xWvzsXjwYMHZPz48SQ0NJRIJBISGRlJpkyZQqqrqwkhhGzYsIEAIEePHiVTp04lTZs2Jf7+/mz81atXkw4dOhCJREJCQ0PJ22+/TYqLiznHuHHjBnnttddIcHAwkUqlpHnz5mT48OGkpKSEtfn1119Jnz59iFKpJHK5nLRr146kpqbW6r8t8aqqqkhaWhpp3bo1kUgkJDw8nPz9738nVVVVJult2rSJxMfHE29vb+Lv70/69etHfvnlF0IIIREREQQAZ2OE5MiRIwQAOXLkCCe9HTt2kK5duxKZTEYCAwPJyJEjTb5iY8eOJXK5nDx48IAMHjyYyOVyEhQURP72t7/V+iIRQsiuXbvIyy+/zN7DVq1akYyMDE7c/v37m/huTUjGjh1rYs9s6enptfpkjdWrVxMA5MqVK5zwLVu2EADk+PHjVuMPHTqUBAcHm+TyJk2aRHx8fNj7euXKFQKArF69mmP38OFDAoAsXLjQ6nEqKyuJRCIhH330ESc8KyuLACAbNmwwiVPz+qSnpxMA5Pr162TkyJFEoVCQoKAgMm/ePGIwGMi9e/dIcnIy8fPzI8HBweSzzz4z68urr75KOnfubNXfmogcLCrZRE5ODrp3786WH6Ojo/Hw4UN8//33qKiogEQiYW3ffvttNG3aFGlpaSgvLwcAfPTRR1iwYAESEhIwdepUXL9+HWvXrsXvv/+OkydPQiwWQ6PRIDExEdXV1ZgxYwZCQkLw8OFD7NmzByUlJVAqlbhy5QpeeeUVdO7cGRkZGZBKpbh16xZOnjxp1X9b4hkMBiQnJ+PEiROYNGkS2rdvjz///BPLly/HjRs3sGvXLtZ2wYIF+Oijj9C7d29kZGRAIpHg7NmzOHz4MAYOHIgVK1awZd8PP/wQABAcHGzRv40bN+LNN99EfHw8lixZgvz8fHz55Zc4efIkLl26BH9/f9ZWr9cjMTERPXr0wGeffYaDBw/i888/R+vWrTF16lSr12Hjxo3w9fXFrFmz4Ovri8OHDyMtLQ1qtRrLli0DAHz44YdQqVR48OABli9fDgBWy/CTJ09GQkICJ2z//v3YvHkzmjVrxoYVFhZa9Y3Bz88PUqkUAHDp0iXI5XK0b9+eY9O9e3d2f9++fS2mdenSJXTt2hVCIbdKsHv37li/fj1u3LiBmJgYXLp0CQDQrVs3jl1YWBjCw8PZ/Za4cOECNBoNunbtatM5WmP48OFo3749PvnkE+zduxeLFi1CkyZN8L//+794/vnn8emnn2Lz5s14//33ER8fj2eeeYYTPy4uDrt374ZarYZCobDtoHZJjZ2MGTOGCIVC8vvvv5vsMxgMhJD/5jz69u3L+ZIVFBQQiURCBg4cyPkCrFq1igAg3377LSGEkEuXLplkMWuyfPlyAoA8evTILv9tibdp0yYiFApNvmbr1q0jAMjJkycJIYTcvHmTCIVC8uqrr5p80ZhrQYjlYkvNnIdGoyHNmjUjnTp1IpWVlazdnj17CACSlpbGhjFf+YyMDE6aXbp0IXFxcdYvAiGkoqLCJGzy5MmcrzAhzhVbbt68SZRKJXnhhRc4zwEs5E5qbsZf6aSkJNKqVSuTY5SXlxMAZM6cOVZ9kcvlZPz48Sbhe/fuJQDI/v37CSGELFu2jAAg9+7dM7GNj48nPXv2tHqcr7/+mgAgf/75JyfckZzHpEmT2DCdTkfCw8OJQCAgn3zyCRteXFxMvL29ydixY03SZXJlZ8+eteqzMXXW2mIwGLBr1y4MGjTIRJkBQCAQcH5PnDgRXl5e7O+DBw9Co9Fg5syZnC/AxIkToVAosHfvXgCAUqkEAPzyyy+oqKgw6wvzBd69ezcMBoPN52BLvMzMTLRv3x7R0dEoLCxkt+effx4AcOTIEQDArl27YDAYkJaWZvJFq3ktbOH8+fMoKCjA22+/DZlMxoYnJSUhOjqavT7GTJkyhfO7X79+uHPnTq3H8vb2Zv8vLS1FYWEh+vXrh4qKCvz11192+16T8vJyvPrqqwgICMDWrVs5z8GBAwds2hITE9k4lZWVbC7EGOY6VVZWWvXH1vjMX0u2tR2nqKgIABAQEGDVzhbeeust9n8vLy9069YNhBBMmDCBDff398dTTz1l9p4zPtia0wOAOiu2PHr0CGq1Gp06dbLJPioqivM7OzsbAPDUU09xwiUSCVq1asXuj4qKwqxZs/DFF19g8+bN6NevH5KTkzFq1ChWWIYPH46vv/4ab731FubMmYMBAwbgtddew5AhQ0xeZGNsiXfz5k1cu3YNTZs2NZtGQUEBAOD27dsQCoXo0KGDTdejNixdHwCIjo7GiRMnOGEymczEx4CAABQXF9d6rCtXrmDevHk4fPgw1Go1Z59KpbLXdRMmTpyI27dv49SpUwgMDOTsq1m0sQVvb29UV1ebhFdVVbH7XRGf+WvJtrbjMBAXTObXsmVLzm+lUgmZTIagoCCTcEa0zPlgz4esTus87MHWC22Ozz//HOPGjcPu3bvx66+/4p133sGSJUtw5swZhIeHw9vbG7/99huOHDmCvXv3Yv/+/di+fTuef/55/Prrr5wvXU2faotnMBgQExODL774wmwaLVq0cPi8XImlc6yNkpIS9O/fHwqFAhkZGWjdujVkMhkuXryI2bNn25WTM8eXX36JrVu34l//+hdiY2NN9ufl5dmUjlKpZJ+h0NBQHDlyBIQQzsuQm5sL4EmdhDVCQ0NZW2Nqxg8NDWXDa97n3Nxcto7FEoxQFhcXIzw83KotYF1kzN1fS/fcXDrMR6Sm2FijzootTZs2hUKhcKjnGgBEREQAAK5fv84J12g0yMrKYvczxMTEYN68efjtt99w/PhxPHz4EOvWrWP3C4VCDBgwAF988QWuXr2Kjz/+GIcPH2aLFZaoLV7r1q3x+PFjDBgwAAkJCSYbkzNo3bo1DAYDrl69avV4tiq/pevDhNW8Po5y9OhRFBUVYePGjXj33XfxyiuvICEhwWxW297i1/Hjx/H+++9j5syZGDlypFmb0NBQm7bt27ezcWJjY1FRUYFr165x0jp79iy73xqxsbG4ePGiiTCePXsWPj4+aNeuHSed8+fPc+xycnLw4MGDWo8THR0NAMjKyjK7v7S0lPM7Pz/fanrOkJWVBaFQyJ6bLdSZeAiFQqSkpODf//63ycUFas+qJSQkQCKRYOXKlRzbb775BiqVCklJSQAAtVpt0psvJiYGQqGQzU4+fvzYJH3mxprLcjLYEm/YsGF4+PAh/vGPf5jYVlZWsi1HKSkpEAqFyMjIMHkojc9PLpejpKTEok8M3bp1Q7NmzbBu3TrOOfz888+4du0ae32chfl6Gfuo0WiwZs0aE1u5XG5zMSY3NxfDhg1D37592RYbczhS5zF48GCIxWKOj4QQrFu3Ds2bN0fv3r05fvz111/QarVs2JAhQ5Cfn48ff/yRDSssLERmZiYGDRrE1nF07NgR0dHRWL9+PfR6PWu7du1aCAQCDBkyxOo1iIuLg0QiMft+ADD5sO3cuZM9F1dz4cIFdOzYkS3q20KdFlsWL16MX3/9Ff3792ebMXNzc5GZmYkTJ05wmhJr0rRpU6SmpmLBggV48cUXkZycjOvXr2PNmjWIj4/HqFGjAACHDx/G9OnTMXToULRr1w46nQ6bNm2Cl5cXXn/9dQBARkYGfvvtNyQlJSEiIgIFBQVYs2YNwsPDrTbZ2RJv9OjR2LFjB6ZMmYIjR46gT58+0Ov1+Ouvv7Bjxw788ssv6NatG9q0aYMPP/wQCxcuRL9+/fDaa69BKpXi999/R1hYGJYsWQLgyQO1du1aLFq0CG3atEGzZs3YyldjxGIxPv30U7z55pvo378/RowYwTbVRkZG4r333nP0tnHo3bs3AgICMHbsWLzzzjsQCATYtGmT2Qc4Li4O27dvx6xZsxAfHw9fX18MGjTIbLrvvPMOHj16hA8++ADbtm3j7OvcuTM6d+4MwLE6j/DwcMycORPLli2DVqtFfHw8du3ahePHj2Pz5s2c7Hxqair++c9/IisrC5GRkQCeiEfPnj3x5ptv4urVqwgKCsKaNWug1+uxYMECzrGWLVuG5ORkDBw4EG+88QYuX76MVatW4a233jJpKq6JTCbDwIEDcfDgQWRkZJjs379/P0aOHIlnnnkGN27cwPr16+Hj44Nff/0V8fHxeOWVV+y+NubQarU4duwY3n77bfsi2twu4yDZ2dlkzJgxpGnTpkQqlZJWrVqRadOmmXQSM9ecS8iTptno6GgiFotJcHAwmTp1KqeT2J07d8j48eNJ69atiUwmI02aNCHPPfccOXjwIGtz6NAhMnjwYBIWFkYkEgkJCwsjI0aMMOlqXBNb42k0GvLpp5+Sjh07EqlUSgICAkhcXBxZsGABUalUHNtvv/2WdOnShbXr378/OXDgALs/Ly+PJCUlET8/P5s6iW3fvp1Nr0mTJlY7idWEaearjZMnT5KePXsSb29vEhYWRj744APyyy+/mPhTVlZG/ud//of4+/vX2knMXKcyZnO2kxghT7qYL168mERERBCJREI6duxI/vWvf5nYMc3YWVlZnPDHjx+TCRMmkMDAQOLj40P69+9v8RnduXMniY2NJVKplISHh5N58+YRjUZjk58//vgjEQgEnOZepql28eLFJCEhgUilUhIVFUW+//57MnfuXOLj40MWLFhACPnvPazZncDSPe/fvz/p2LEjJ+znn38mAMjNmzdt8plBQAhdt4VCaSj0ej06dOiAYcOGYeHChQCAu3fvIioqChs2bMC4cePq3IeUlBQIBAK2WGQrdFQthdKAeHl5ISMjA6tXr26QIfnXrl3Dnj17WOGyByoeFEoDM3z4cDx+/LhBhuS3b98eOp3O5v5YxlDxoFAoDkHrPCgUikPQnAeFQnEIt+me7u4YDAbk5OTAz8/PoYFsFM+DEILS0lKEhYVZHSPlqVDxsJGcnBx89dVXEIlMLxkhBMXFxQ73/JNIJJwesVKpFAaDARqNximf7UEkEkEkEkGn00Gn03F8qq+SrUAg4Jx7TZ/qi5r3QyaTQS6Xm70Oixcvxv37920am1ITax8hPtQmUPGwET8/P4hEIvj4+Jh8ZQghiIyMdHjwmcFggFqtZrtIi8ViKBSKev+aVVRUsN3phUIhrl+/bvdLW3OSGXvR6XRQqVRsF365XA4fHx+n0rSXmvdDJBKhurra5H4wPvr5+Tl0HL7nVqh42AjzlRAKhRCLxWy4wWCAwWCAVCrlzIxmL2KxmJ1LITAw0OwcEXWNTCbjfG1rm4/CHK540bVaLTv8vUmTJg3ykhnfD2YYu1Ao5PjCiIujxVi+iwe/vfcQNBoNioqKIBaLIRaLUVRUVK9FFuCJCBYVFUEgEEAmk6GqqsrhL6ozlJaWoqqqCjKZDAKBAEVFRU4P+7eXmvejpKSkTnwQCAQWNz5AxaOB0Wg0KCwshFgsRlBQEIKCgtivXn0JCCMcWq0WQUFBCAwMhEKhgEKhqFcBKS0tZefQDAwMRFBQELRabb0KiLn7wdS7GI+cdQVMTsbcxgdoscVOCCGcB9lgMIAQwhnSbStarRbFxcUQiURQKBRs/YJCoUBxcTEKCgoQEBDAKSa5GqayV6fTsXN0aDQaSKVSlJeXQ6lUwsvLi60LqQ1HBa+8vBxlZWXw9fWFVCpl01EqlZxrUZdfZUv3Qy6Xo7S0lPXJ3DQFjsAXkbAEFQ87YB4Wc+JRXV1t15eJaVFg6kpqzivi7e0NjUaD8vJytvbf1RBCoNFoIBQK4evrC71ezzkHg8HAznIvFAptqjxl6irsQafTQavVQi6Xw8vLyyQNX19faDQaqNVqSCSSOhEQa/dDp9NBKBTCYDBAq9WCEOKS+0HFoxFRUlKCiIgIzoTDWq0W1dXVePnll+2aSIUPpKam2h1n8eLFdeBJw6JSqbBv3z5IJBKUlZWxuTRnizFUPBoRBoMBIpHIpFVFr9dDqVSiSZMmDeRZ3WDL5Mg18bRrwMDc92bNmqGoqAgqlcrpgWx8Fw9+e0+h1DNCoRCBgYEQi8VOzxzP9wpTfnjpJkgkknpvNqS4H4yAONop0DgdPosHLbbYgVAohFqtNtvLlNK4EAqFti/LaCUNPsNv7+sZpkWlITouUdwPZ19+vuc8+OGlm0AIgVKprPeOSxTPhIpHI0MkEnF6PvJh9CPFPaHi4UKWLFmC+Ph4+Pn5oVmzZkhJSTG7IlpNMjMzER0dDZlMhpiYGOzbt4+znxCCtLQ0hIaGwtvbGwkJCbh586bDfkokElZAnBmKT2ncUPFwIceOHcO0adNw5swZHDhwAFqtFgMHDrTaNfrUqVMYMWIEJkyYgEuXLiElJQUpKSmcZS6XLl2KlStXYt26dTh79izkcjkSExMd6g3JwAiITqer90FsFM+A7wPj3Kq1Zf/+/ZzfGzduRLNmzXDhwgWL80R8+eWXePHFF/H3v/8dALBw4UIcOHAAq1atwrp160AIwYoVKzBv3jwMHjwYAPDdd98hODgYu3btwhtvvGE23erqak4X5ZqrwwNPBCQgIMDmcR8UijF8yWFYwq29ZzrhWOu1ePr0aZMlCRMTE3H69GkATxbwzcvL49golUr06NGDtTHHkiVLoFQq2c3SavdisdipeTwojRdabKkjDAYDZs6ciT59+lhdUyIvLw/BwcGcsODgYOTl5bH7mTBLNuZITU2FSqVit/v37zt6KhSKWfguHm5VbDFm2rRpuHz5Mk6cONEgx5dKpTbN5qXVammdB8Uh+CISlnBL76dPn449e/bgyJEjtU4sGxISgvz8fE5Yfn4+QkJC2P1MmCUbR9FoNCguLuZNBRfFveB7zsOtvCSEYPr06di5cycOHz6MqKioWuP06tULhw4d4oQdOHAAvXr1AgBERUUhJCSEY6NWq3H27FnWxhGYGafMjbKlUGyB7+LhVsWWadOmYcuWLdi9ezf8/PzYOgmlUglvb28AwJgxY9C8eXMsWbIEAPDuu++if//++Pzzz5GUlIRt27bh/PnzWL9+PYAnzWEzZ87EokWL0LZtW0RFRWH+/PkICwtDSkqKQ34aT1WnUChMJvKhUGyBLyJhCbcSj7Vr1wIAnn32WU74hg0bMG7cOADAvXv3OBe9d+/e2LJlC+bNm4e5c+eibdu22LVrF6eS9YMPPkB5eTkmTZqEkpIS9O3bF/v37+dM6mMrOp0OJSUlEIvFCAwMrNf1RCieBRUPF2JLT82jR4+ahA0dOhRDhw61GEcgECAjIwMZGRnOuAeBQACVSgWZTIbAwEDe33xKw8L358etxMPdkUql8PLyosJBAQCnB0by/Rmi4mEHBoOhQVZyo7gfzKpyzsD354iKhx0wM41TGjfMOjfOToDM9yZ+Kh4Uih0YL5Dl7Gz5fP8QUfGgUGyEEMJZWc/Zlja+iwe/vafUKYQQLFy40CbbhQsXevS8JszKeoxwuKJjIN87ifHDS0qDcPnyZcyfP98m2/nz53PmUPE0NBoNdDqdy4QD4L940GILxSIxMTF223tq7oMQgoCAAJcOReCLSFiCigfFIsz6rPbYeyoSicTlC47z/XpR8aBYRK/X29Wc6GzTpTtTFy86FQ+KR0MIsUlAPLW4wlAX58d38eC395Q659atWy614ysajcblAsL3ClN+eElpMNq2betSO77CNNW6cqEvKh4Uj8Xe7tN8725tDYlEAp1O59KVAql4UDyOF154wWEhEAgEeOGFF1zsUcMjFAoREBDg0qVG+S4etMKUwkEkEjndanLw4EGIRCKPmyhJLBYjKCgIhYWFKCoqYme3cxS+59T4IXGUesNYOOzt12Bs76nNtsZLjbpiSD6fcx788NJNEIk8P6NGCIFCoQAhhG1hsLboFvBkUS5jeya+p8IIiLMCScWjESESiVBRUdHQbtQ5zEp9DEVFRWjTpo1Z2zZt2qCoqMhqfE9EIpG4ZEg+FY9Ggk6nQ3l5OUpLSxvalXrBuM7CUj8O43BPq+OoDWdzonwXD8/Ph7sQnU4HuVzOlnX9/Pwa2KO6wRVNtJ5cbHEVfBEJS9gtHllZWTh+/Diys7NRUVGBpk2bokuXLujVq5dDSxnwDR8fH0ilUlZAbFmSki/cunXLZZ29BAIBbt68abG4Q2lE4rF582Z8+eWXOH/+PIKDgxEWFgZvb288fvwYt2/fhkwmw8iRIzF79mxERETUpc8NDpPjUKvV8PHxgZeXVwN75DxhYWHIzc11aZpt27ZFaGgocnJyXJqup9AoxKNLly6QSCQYN24cfvjhB7Ro0YKzv7q6GqdPn8a2bdvQrVs3rFmzxuo6Kp4AIyAlJSWQy+UN7I3j6PV6k7K7VquFSCRCdnY2IiMjbU7r7t27iIiIgE6nY5ttc3NzIRAIoNPpPEJkXUmjEI9PPvkEiYmJFvdLpVI8++yzePbZZ/Hxxx/j7t27rvLPrfHz84NOp4NGo2loVxxi8uTJ7LKcDMZ1FfbmIBl7kUhkMhqXCaP8l0YhHtaEoyaBgYEIDAx02CG+IZfLeflSdOvWDRcuXOCEMTkogUDg1Dkx8eVyOcrLy03CKU9oFOJhjoKCAhQUFJj08e/cubPTTvENvmXHzQkHAJSVlQHg5j7u3LmDVq1a1ZrmnTt32P+Z+GVlZSYtMVRA/kujE48LFy5g7NixuHbtGvsQMA+EQCDw2G7JlmB6VvIFS82wNV9olUqFsLAwmzvFtWrVCj4+PsjJyeF0njI3mZBAIEBmZiaGDBlip/eeRaMb2zJ+/Hi0a9cOp06dwp07d5CVlcX525gwGAwoLi7m/ZfU2P9hw4ZBIBDA39/f7t60FRUV8Pf3h0AgwLBhw8ymz+DpFeq20Og6id25cwc//PBDo2+/Z1YO0+l08PX1bWh3bKK2zlyu/BJmZmZyiiiWciB8F15n4ItIWMJu7wcMGIA//vijLnzhDcZLDgYEBPDiIViyZAnnd9euXTkvbp8+ferkuMbpVlVV1epXY6LR5Ty+/vprjB07FpcvX0anTp1Mhm0nJye7zDl3xFg4goKCALjX8PPc3FyEhoZywrRaLebOnQsAZusa6rLsferUKTaHIZVKOfVkADB37ly8//77Js+RufPwNPgiEpawWzxOnz6NkydP4ueffzbZ1xgqTJlu6czKYe5UWWosAsa5CuOFioYMGQKVSuX0iFBnMS7GSCQSi8UnTy7W8F087PZ+xowZGDVqFHJzc2EwGDibpwuHRCKBXq936ZKDruLBgwdmw9999132f2bskb+/Pxv21FNP1alfNY+zceNGLFiwgOMPwPXTGEvn5Qnwvdhit5dFRUV47733EBwcXBf+uDVCoRBKpbJBhSMrK8tsuPGQAa1Wy/6/cuVK9n+mGGD8Nb9x44arXTQLc5xx48YhPT2d4w/A9dPY/5pDIRgsXYf6xNm5XfguHnYXW1577TUcOXIErVu3rgt/3Jrq6mqcOnWK83CLxWJ4e3sjNTUVxcXFdXJcQgju3LnDuebGAmCckwC4ndZkMhlbUZmVlYVmzZrh448/xsSJE126jIA9hIeHo6ysjDNpkHEupGanu6tXr6JDhw7sb+Nize3bt9GqVas6rbcJCAjAsGHDUFlZyd57Pz8/l0wGxGfsFo927dohNTUVJ06cQExMjElF1zvvvOMy59yNhip/W3oxLIULhULW12vXriEqKord9+jRI0yaNAmTJk1yvaO1YO0Fv3btGvt/zZeqY8eOAJ5MGfDhhx9y9jXER8zPzw8KhYLtkesojU48vv76a/j6+uLYsWM4duwYZ59AIPBo8XAnavvSpqenY8GCBRzhcGeioqJACGGLNOZwh75FjHCo1WqzTc/2wHfxsNv7rKwsi5urepiuXr0akZGRkMlk6NGjB86dO2fVPjMzE9HR0ZDJZIiJicG+ffs4+wkhSEtLQ2hoKLy9vZGQkICbN2+6xFd3JSMjg3fdnwUCATIyMhraDYvI5XJWOFwxFSXf6zxc5mVubi6WLl3qdDrbt2/HrFmzkJ6ejosXL+Lpp59GYmIiCgoKzNqfOnUKI0aMwIQJE3Dp0iWkpKQgJSUFly9fZm2WLl2KlStXYt26dTh79izkcjkSExOd/nJQGg8ikQi+vr4uEw6A/+IhIHYW5MePH282PDs7G+fOnXP6wvbo0QPx8fFYtWoVgCedslq0aIEZM2Zgzpw5JvbDhw9HeXk59uzZw4b17NkTsbGxWLduHQghCAsLw9/+9je8//77AJ4M+goODsbGjRvxxhtvmPWjuroa1dXV7G+1Wo1FixZxKs2A/1aY7tixo84qTCkNS0BAAMaMGQONRoOSkhI2XCwW47vvvoNKpYJCobA7XWtFNKY5252xW+KKi4s5W2FhIc6dO4ejR4/is88+c8oZjUaDCxcuICEh4b8OCoVISEjA6dOnzcY5ffo0xx54Mv8IY5+VlYW8vDyOjVKpRI8ePSymCTzpNq1UKtnNUpMhpXHAzJzvSvie87C7wnTnzp1mwz/++GPs2rULkydPdtiZwsJC6PV6kz4kwcHB+Ouvv8zGycvLM2ufl5fH7mfCLNmYIzU1FbNmzWJ/MzkPSuOkLpaV4ItIWMJlSy+MGDHCo14uqVTqUTOjU9wPvouHy7z/448/0KVLF6fSCAoKgpeXF/Lz8znh+fn5CAkJMRsnJCTEqj3z1540PYG0tDTejQthWsXckbpYapTvxRa7vZw1a5bJNnLkSIwePRotWrTghNuLRCJBXFwcDh06xIYZDAYcOnQIvXr1MhunV69eHHsAOHDgAGsfFRWFkJAQjo1arcbZs2ctpskHahMGpsLNHbpx2wLjp7WKwlu3bmH48OH15RIHkUjk8lny+S4edsvppUuXzIbHx8ez85oCjg/znjVrFsaOHYtu3bqhe/fuWLFiBcrLy/Hmm28CAMaMGYPmzZuz80C8++676N+/Pz7//HMkJSVh27ZtOH/+PDsruEAgwMyZM7Fo0SK0bdsWUVFRmD9/PsLCwpCSkuKQj/WNue7pTDjwpHu6cVdv427n7du358Rp2rQpp3t6fc6/yvhrrnt6+/btUVlZCeCJ/8Yv0JUrV9ju6du2bcP27dvZffXRPR0AO+mTXq93aVMtn7FbPI4cOVIXfrAMHz4cjx49QlpaGvLy8hAbG4v9+/ezFZ737t3jXPTevXtjy5YtmDdvHubOnYu2bdti165d6NSpE2vzwQcfoLy8HJMmTUJJSQn69u2L/fv3O7TC3TPPPAMfHx/2t0ajQVVVFRYvXlzravLO0KpVKxBCkJWVZdJrtKSkhPPyGK/FYtyXJSoqitORr6EeXmakbKtWrdgch7GfNUdnG49rAWD2OtRlEe3x48fIzMyEXq9HRUUFFAoF/Pz8UFFRge+++87hdBudeNQH06dPx/Tp083uO3r0qEnY0KFDrc6JyfRcdOfei7Ziqbv5/fv32eZksVjMvkzvvPMOO2KVWRHOePq/du3a1cvI2nbt2gF4MiQ/Ozsb6enpnBXqjIc1GI+Xun//vtn0GqLbvVwuh0gkYud0cTbXxnfxsMn7F198EWfOnKnVrrS0FJ9++ilWr17ttGMU+wgPDzcb/uWXX7L/M193445O169fr1O/ah7HeEi+cW7D2E9jLJ1XQ2E8toUOybeBoUOH4vXXX4dSqcSgQYPQrVs3hIWFQSaTobi4GFevXsWJEyewb98+JCUlYdmyZXXtd4Pg7mNFCCFmp+/TaDTsHCTff/+9Wyx5YHwta87GZuk83AVmqdHHjx87lQ5fRMISNnk/YcIE3LlzB3PnzsXVq1cxadIk9OvXD/Hx8UhMTMQ//vEPtGzZEr///ju2b9+Oli1b1rXfDYJUKq2TzkKuxNwLJxaLsXjxYgBPPgQCgQBxcXHsfkIIevfuXSf+9O7dmy0iVVdXQyAQcIRj8eLFJtM6AObPw53w8/NzuvWlUeQ8gCcvzqhRozBq1CgAT8aHVFZWIjAw0OzN90QMBgNUKhVkMpnbTUNYG6mpqewkyABw8eJFTt3HyZMn6yRndfLkSfZ/cxXUqampLj9mfWFcce4I7p6TrQ2HJU6pVCIkJKTRCAfwJHvt5eWFwsJCt5r42FbMtUjUnGzYVYsxDR06tNY1YfjWic3VNJqcB+UJCoUClZWVKCwsZJde4DvGOZAdO3YAsH+5SQBml5tk0q9JZmamEx57BnwRCUtQ8bAToVCIwMBAFBUVobCwsMGXMLAXcyu3AaartymVSpSXl9vckUyv15t9Gcwd66WXXnKLStuGhu/iwW/vGwhGQMRiMYqLixtsImFHsVRcYOZEGTduHBtmqzga2zHxjedYYejQoYPJTG+NFb4XW/jhpRvCCIhIJPKY+o9BgwYBACIiItgwWyf5NbZj4jPpMbz00ku4cuWK3b56KnwXD7uLLWPHjsWECRPwzDPP1IU/vEIoFCIgIIDtccg3CCGcruzAk2IGM1Nadna2XellZ2cjIiIC8+fPNymu6HS6eh1Hwwf4IhKWsNt7lUqFhIQEtG3bFosXL8bDhw/rwi/eIBAIeNdsa4yXlxcIIZx+FWKxGAKBAJGRkXalFRkZCYFAwGmBCw0NBSGECocZ+J7zsNvLXbt24eHDh5g6dSq2b9+OyMhIvPTSS/j+++85c3s2Jjxhmc2cnByXzyh/8+ZN5OTkuDRNT6LRiQfwZFj3rFmz8Mcff+Ds2bNo06YNRo8ejbCwMLz33nsev6yBMeXl5R4jmm3atHFZ3wtCiFuss+LONErxYMjNzcWBAwdw4MABeHl54eWXX8aff/6JDh06YPny5a7y0W0pLS1FWVmZx3WUI4SAEAKtVsv+70p7yhManXhotVr88MMPeOWVVxAREYHMzEzMnDkTOTk5+Oc//4mDBw9ix44dHjH83RqlpaVQq9Xw9fWtkynq3AHj87KUizAO99TrUFfwXTzsvtuhoaEwGAwYMWIEzp07h9jYWBOb5557zmTxZU+CEQ6FQgGpVOpxi0cplUrOLF+BgYEWR5DeunWL7TRnKT7FPHwRCUvYLR7Lly/H0KFDrc7C5e/vz5u5M+2loqIC1dXV7GxSfOzjYQ2miZVpNbGlPufx48cm9jV7rFJM4fvAOLvFY/To0XXhBy8QiUQoLy9HkyZN2DkdPA0vLy+29cjeimBje9o0Wzt8z3nw2/t6hplB21OFA3jSmavmCnz2kpCQ4PbznrgCZ8+x0dV5NGZ0Op3TczjwgQMHDgBwLFvdWIoqGo3G6XodvoiEJah42EFj+JoaY2kErjX7xoBGo0FhYWGjnwCZigfFKv7+/pwJk63ZNQYY4RCLxfD29nYqLSoeFI+muLjYptxHcXFxPXjTsGi1WqhUKojFYgQGBjrdRE/Fg+LR2Fps8fSmWYPBALVaDalUisDAQJe8+FQ8KB6LvWV642ZeT0Oj0UAkErlMOAAqHhQPxt4Z0vg2o5o9CAQCBAQEuPSF57t48Nt7Sp3y559/1qk9n5BIJC7vEcr3fh788JLSIHTq1AkLFy60yXbhwoWcxcU9jbroSk7Fg+LRDB8+3KV2fKUuimTM6nnmNj5A6zwoFrHnIW7Xrh0Az+0optFoIBaLXTrlJF9yGJag4kGh2IBAIEBxcbFLBYTv4sFv7ymUekIikUAkErl0qVFa50GhNAKYplqxWOwyAaHiQaE0EgQCAbtSYGFhYaMfks8PLykUN8F4qVFXDMmn4tFIkEgkHt2LkmIbjIC4Ykg+n8WDtrbYgVAohFqtho+PD29uMKVuEAqFUCgUTqfBZ9zGe61Wi9mzZyMmJgZyuRxhYWEYM2aMTSuOrV69GpGRkZDJZOjRowfOnTvH2V9VVYVp06YhMDAQvr6+eP3115Gfn2+3j9XV1dDr9SgqKqI5EIrTLz/fcx5u42VFRQUuXryI+fPn4+LFi/jxxx9x/fp1JCcnW423fft2zJo1C+np6bh48SKefvppJCYmoqCggLV577338O9//xuZmZk4duwYcnJy8Nprr9ntIyEESqUSWq2WCgjFafguHm5TbFEqlezcmQyrVq1C9+7dce/ePbRs2dJsvC+++AITJ07Em2++CQBYt24d9u7di2+//RZz5syBSqXCN998gy1btuD5558HAGzYsAHt27fHmTNn0LNnT7v8FIlECAoKQmFhIYqKipzOulIaL3wRCUu4tfcqlQoCgcDiFHcajQYXLlzgzPYtFAqRkJCA06dPAwAuXLgArVbLsYmOjkbLli1ZG3NUV1dDrVZzNgaJRIKgoCBotVoUFxd7bJdsSt3C95yH23pZVVWF2bNnY8SIERa/7oWFhdDr9QgODuaEBwcHIy8vDwCQl5cHiURiIkDGNuZYsmQJlEolu7Vo0YKznxEQnU7ncQs/UeoHvg+MazDx2Lx5M3x9fdnt+PHj7D6tVothw4aBEIK1a9c2iH+pqalQqVTsdv/+fRMbiUSCgIAAmvOgOATfcx4NVueRnJyMHj16sL+bN28O4L/CkZ2djcOHD1utUwgKCoKXl5dJy0l+fj5CQkIAACEhIdBoNCgpKeHkPoxtzCGVSiGVSms9D1ePtKQ0HvgiEpZoMO/9/PzQpk0bdvP29maF4+bNmzh48CACAwOtpiGRSBAXF4dDhw6xYQaDAYcOHUKvXr0AAHFxcRCLxRyb69ev4969e6wNhdIQ0JyHi9BqtRgyZAguXryIPXv2QK/Xs3USTZo0Yb/uAwYMwKuvvorp06cDAGbNmoWxY8eiW7du6N69O1asWIHy8nK29UWpVGLChAmYNWsWmjRpAoVCgRkzZqBXr152t7RY8pvWeVAcgS8iYQm3EY+HDx/ip59+AgDExsZy9h05cgTPPvssAOD27dsoLCxk9w0fPhyPHj1CWloa8vLyEBsbi/3793MqUZcvXw6hUIjXX38d1dXVSExMxJo1a5z2WaPRoLi42KbiDYVSEyoeLiIyMtKmise7d++ahE2fPp3NiZhDJpNh9erVWL16tTMucmBWDhOJRLTOg+IQVDwaIcZLDioUClRXVze0SxQeQsWjkaHT6VBSUsIuOdjYFr+muA4qHo0IgUAAlUoFmUzm0pXDKI0Tvj8/VDzsQCqVwsvLiwoHBYDzyzHw/Rmi4mEHhBD4+PhwiiparRY6nc7pWaXckYCAALvjPH78uA48aVhUKhV0Oh20Wi0bRghBSUmJU+lS8WhEyOVyFBcXc4TCYDCAEIJ9+/ZBJLJ+OQ0GAzQaDQQCgV3LFxJCoNFoQAiBRCJx6qGzJ61hw4ZxfotEIohEIuh0Oot1PZmZmTb5wbyMYrG41utmjKPX0Jm0mHougUAAoVAIQgh0Op3TOQ++jGGxBBUPO2Buds0XjhACqVQKsVhcaxpisRjFxcXQ6/UICAio9QEihKC4uBg6nY6dvdtZZDIZiouLUVZWZjXNyspK9n+5XA4fHx+UlZWhvLzcatq2Ul5ejrKyMvj6+kIul9dqr9VqoVarIRKJbLp2tmDL/dBqtRAKhew+rVYLQohLpiHkM1Q87IT5+hhjMBhsHuMikUjY2bfVarXV+hODwcBOOtSsWTOX9idp1qwZioqKoFKpEBQUZDZtJpvu5+cHuVwOlUqF0tJSq+na4yOzFgojCH5+fhZtNRoNVCoVpFKpS+ucbL0fzGhXpjexVCp1ekAk38WD397zFOP5QCzNSMYIh1artfhyO4PxLODW1iHx8/ODQqGAWq2uVTgcwZb0jfvV1EVlta33o7q6mi3u2VPUsgTfx7bww0sPxNoDW9fCwVCbgNS1cNhynLoWDoba7oder3epcAD8Fw9abLERJotqMBhMat2BJzOPOdJhzNfXFyqVCnl5eez0A2q1Gnq9Hkql0mrlpKtgRjTn5+dDqVRCJBKhoqICSqUSZWVlqKqqsrmupaKiwiEfvLy8IJVK8fjxY1RXV7OtWiqVCl5eXvD29kZVVZVDaduDufuhUqlgMBjg5eUFQgh7/xmBcbT4wheRsISA0JlsbOLBgwcms4lRKABw//59hIeHN7Qb9Q4VDxsxGAzIycmBn5+fU7X8arUaLVq0wP3793k5eTLf/Qdcdw6EEJSWliIsLIz3uQhHoMUWGxEKhS79uigUCt6+fAD//Qdccw5KpdJF3vCPxieXFArFJVDxoFAoDkHFo56RSqVIT0/n7exjfPcf8IxzcAdohSmFQnEImvOgUCgOQcWDQqE4BBUPCoXiEFQ8KBSKQ1DxcBKtVovZs2cjJiYGcrkcYWFhGDNmDHJycmqNu3r1akRGRkImk6FHjx44d+4cZ39VVRWmTZuGwMBA+Pr64vXXXzdZWtMV1OZHTTIzMxEdHQ2ZTIaYmBjs27ePs58QgrS0NISGhsLb2xsJCQm4efOmy/0GnixIHh8fDz8/PzRr1gwpKSm4fv16rfHc6Rx4C6E4RUlJCUlISCDbt28nf/31Fzl9+jTp3r07iYuLsxpv27ZtRCKRkG+//ZZcuXKFTJw4kfj7+5P8/HzWZsqUKaRFixbk0KFD5Pz586Rnz56kd+/eLvXfFj+MOXnyJPHy8iJLly4lV69eJfPmzSNisZj8+eefrM0nn3xClEol2bVrF/njjz9IcnIyiYqKIpWVlS71nRBCEhMTyYYNG8jly5fJf/7zH/Lyyy+Tli1bkrKyMotx3O0c+AoVjzrg3LlzBADJzs62aNO9e3cybdo09rderydhYWFkyZIlhJAnoiQWi0lmZiZrc+3aNQKAnD592mW+1uZHTYYNG0aSkpI4YT169CCTJ08mhBBiMBhISEgIWbZsGbu/pKSESKVSsnXrVpf5bYmCggICgBw7dsyijbufA1+gxZY6QKVSQSAQwN/f3+x+jUaDCxcuICEhgQ0TCoVISEjA6dOnAQAXLlyAVqvl2ERHR6Nly5asjbPY4kdNTp8+zbEHgMTERNY+KysLeXl5HBulUokePXq4zG9rMPPLNmnSxKKNu58DX6Di4WKqqqowe/ZsjBgxwuKgq8LCQuj1es56ugAQHBzMLu6dl5cHiURiIkDGNs5iix81ycvLq9VvJqyu/LaEwWDAzJkz0adPH3Tq1MminTufA5+g4mEnmzdvhq+vL7sdP36c3afVajFs2DAQQrB27doG9LJxMm3aNFy+fBnbtm1raFcaBXRIvp0kJyejR48e7O/mzZsD+K9wZGdn4/Dhw1aHegcFBcHLy8uk5SQ/Px8hISEAgJCQEGg0GpSUlHByH8Y2zmKLHzUJCQmp1W8mLDQ0lGMTGxvrEr/NMX36dOzZswe//fZbrVMnuOs58A2a87ATPz8/tGnTht2YKfyGDRuGmzdv4uDBgwgMDLSahkQiQVxcHA4dOsSGGQwGHDp0CL169QIAxMXFQSwWc2yuX7+Oe/fusTbOYosfNenVqxfHHgAOHDjA2kdFRSEkJIRjo1arcfbsWZf5bQwhBNOnT8fOnTtx+PBhREVF1RrH3c6BtzR0jS3f0Wg0JDk5mYSHh5P//Oc/JDc3l92qq6tZu+eff5589dVX7O9t27YRqVRKNm7cSK5evUomTZpE/P39SV5eHmszZcoU0rJlS3L48GFy/vx50qtXL9KrVy+X+l+bH6NHjyZz5sxh7U+ePElEIhH57LPPyLVr10h6errZZk5/f3+ye/du8n//939k8ODBddbMOXXqVKJUKsnRo0c5176iooK1cfdz4CtUPJwkKyuLADC7HTlyhLWLiIgg6enpnLhfffUVadmyJZFIJKR79+7kzJkznP2VlZXk7bffJgEBAcTHx4e8+uqrJDc31+XnYM2P/v37k7Fjx3Lsd+zYQdq1a0ckEgnp2LEj2bt3L2e/wWAg8+fPJ8HBwUQqlZIBAwaQ69evu9xvQojFa79hwwbenANfoUPyKRSKQ9A6DwqF4hBUPCgUikNQ8aBQKA5BxYNCoTgEFQ8KheIQVDwoFIpDUPGgUCgOQcWDQqE4BBUPilm++eYbDBw4sM6Ps3//fsTGxsJgMNT5sSiuhYoHxYSqqirMnz8f6enpdX6sF198EWKxGJs3b67zY1FcCxUPignff/89FAoF+vTpUy/HGzduHFauXFkvx6K4DioeHsyjR48QEhKCxYsXs2GnTp2CRCIxGZJuzLZt2zBo0CBO2LPPPouZM2dywlJSUjBu3Dj2d2RkJBYtWoQxY8bA19cXERER+Omnn/Do0SMMHjwYvr6+6Ny5M86fP89JZ9CgQTh//jxu377t+MlS6h0qHh5M06ZN8e233+Kjjz7C+fPnUVpaitGjR2P69OkYMGCAxXgnTpxAt27dHDrm8uXL0adPH1y6dAlJSUkYPXo0xowZg1GjRuHixYto3bo1xowZA+PxmC1btkRwcDBnVjaK+0PFw8N5+eWXMXHiRIwcORJTpkyBXC7HkiVLLNqXlJRApVIhLCzM4eNNnjwZbdu2RVpaGtRqNeLj4zF06FC0a9cOs2fPxrVr10xm8goLC0N2drZDx6Q0DFQ8GgGfffYZdDodMjMzsXnzZkilUou2lZWVAACZTObQsTp37sz+z0wgHBMTYxJWUFDAieft7Y2KigqHjklpGKh4NAJu376NnJwcGAwG3L1716ptYGAgBAIBiouLa01Xr9ebhInFYvZ/gUBgMaxm0+zjx4/RtGnTWo9JcR+oeHg4Go0Go0aNwvDhw7Fw4UK89dZbJl99YyQSCTp06ICrV6+a7KtZ1Lhz545LfKyqqsLt27fRpUsXl6RHqR+oeHg4H374IVQqFVauXInZs2ejXbt2GD9+vNU4iYmJOHHihEn47t278eOPP+L27dv4+OOPcfXqVWRnZ+Phw4dO+XjmzBlIpVI6uTDPoOLhwRw9ehQrVqzApk2boFAoIBQKsWnTJhw/ftzqujITJkzAvn372NXXGJKSkrB06VJ06NABv/32G9asWYNz585h06ZNTvm5detWjBw5Ej4+Pk6lQ6lf6BymFLMMHToUXbt2RWpqKoAn/TxiY2OxYsUKlx6nsLAQTz31FM6fP2/TsgkU94HmPChmWbZsGXx9fev8OHfv3sWaNWuocPAQmvOg2ERd5Two/IWKB4VCcQhabKFQKA5BxYNCoTgEFQ8KheIQVDwoFIpDUPGgUCgOQcWDQqE4BBUPCoXiEFQ8KBSKQ/w/jtq+C7NBoVcAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\tJ = 9.5823e-01\n", + "\tgrad_norm = 7.8635e-03\n", + "step = 31\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\tJ = 9.6085e-01\n", + "\tgrad_norm = 5.3692e-03\n", + "step = 32\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\tJ = 9.6281e-01\n", + "\tgrad_norm = 6.8166e-03\n", + "step = 33\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAQ8AAADaCAYAAAC4q8cWAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjMsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvZiW1igAAAAlwSFlzAAAPYQAAD2EBqD+naQAAOtlJREFUeJztnXlcVOX+xz8zzAYDDMgqKoKaIaahiLuXUq70k0TM1Lzuu6aWeSs1DZNcUivN3DJTb15XKrGrhCLue6i3m7nkVdwFRGEG2WZ7fn/wOufOYRZmA+bA8369zgvmOc/znO/ZPudZv4+AEEJAoVAoNiKsawMoFAo/oeJBoVDsgooHhUKxCyoeFArFLqh4UCgUu6DiQaFQ7IKKB4VCsQsqHhQKxS6oeFAoFLug4sETjh07BoFAgGPHjtW1KRQns2fPHjRq1AjPnz+v9WNfvXoVIpEIV65csTktFQ8XY926ddi6dWtdm2EXO3bswKpVq+raDACAXq/H8uXLER4eDplMhvbt22Pnzp1Wpy8qKsKkSZMQEBAAuVyOV199FZcuXTIZ9+eff0bHjh0hk8kQGhqKBQsWQKvVWnUcnU6HBQsWYMaMGfD09LTaPmcRGRmJhIQEJCcn256YUFyKtm3bktjYWKNwnU5HysrKiE6nq32jrCQhIYE0b968rs0ghBAyZ84cAoBMnDiRbNy4kSQkJBAAZOfOndWm1el0pHv37kQul5NPPvmErFmzhkRGRhIvLy/y559/cuKmp6cTgUBAXn31VbJx40YyY8YMIhQKyZQpU6yyc+/evUQgEJAHDx7YdZ7OID09nQAg//3vf21K55Li8fz587o2oc4wJx58wFXE48GDB0QsFpNp06axYXq9nvTq1Ys0bdqUaLVai+l3795NAJDU1FQ2LD8/n/j4+JBhw4Zx4kZGRpKXX36ZaDQaNmzevHlEIBCQa9euVWtrYmIi6dmzp7WnViOo1Wri6+tLPv74Y5vS1bh4PHjwgIwbN440btyYSCQSEhYWRqZMmUIqKioIIYRs2bKFACDHjh0jU6dOJQEBAcTHx4dNv3btWhIZGUkkEglp3Lgxefvtt0lhYSHnGH/++Sd54403SFBQEJFKpaRJkyZk6NChpKioiI1z6NAh0qNHD6JQKIhcLietW7cmc+fOrdZ+a9KVl5eT5ORk0rJlSyKRSEjTpk3JBx98QMrLy43y27ZtG4mJiSHu7u7Ex8eH9OrVixw8eJAQQkjz5s0JAM7GCMnRo0cJAHL06FFOfnv27CEdO3YkMpmM+Pn5keHDhxt9xUaPHk3kcjl58OABGTBgAJHL5cTf35/8/e9/r/ZFIoSQtLQ00q9fP/YetmjRgqSkpHDSxsbGGtluSUhGjx5tFJ/ZFixYUK1Nlli7di0BQP744w9O+I4dOwgAcvLkSYvpBw8eTIKCgoxKeZMmTSIeHh7sff3jjz8IALJ27VpOvIcPHxIA5NNPP7V4nLKyMiKRSMgnn3zCCc/JySEAyJYtW4zSVL0+CxYsIADIjRs3yPDhw4m3tzfx9/cn8+fPJ3q9nty7d48kJiYSLy8vEhQURD7//HOTtgwcOJC0b9/eor1VEdlZVbKKR48eoXPnzmz9MSIiAg8fPsQPP/yA0tJSSCQSNu7bb7+NgIAAJCcno6SkBADwySefYOHChYiLi8PUqVNx48YNrF+/Hr/++itOnz4NsVgMtVqN+Ph4VFRUYMaMGQgODsbDhw+xf/9+FBUVQaFQ4I8//sDrr7+O9u3bIyUlBVKpFP/9739x+vRpi/Zbk06v1yMxMRGnTp3CpEmT0KZNG/z+++9YuXIl/vzzT6SlpbFxFy5ciE8++QTdu3dHSkoKJBIJzp8/jyNHjqBv375YtWoVW/edN28eACAoKMisfVu3bsXYsWMRExODpUuXIi8vD1999RVOnz6Ny5cvw8fHh42r0+kQHx+PLl264PPPP8fhw4fxxRdfoGXLlpg6darF67B161Z4enpi1qxZ8PT0xJEjR5CcnAyVSoUVK1YAAObNmwelUokHDx5g5cqVAGCxDj958mTExcVxwjIyMrB9+3YEBgayYQUFBRZtY/Dy8oJUKgUAXL58GXK5HG3atOHE6dy5M7u/Z8+eZvO6fPkyOnbsCKGQ2yTYuXNnbNy4EX/++SfatWuHy5cvAwA6derEiRcSEoKmTZuy+81x8eJFqNVqdOzY0apztMTQoUPRpk0bfPbZZzhw4AAWLVqERo0a4ZtvvkHv3r2xbNkybN++He+//z5iYmLwl7/8hZM+Ojoa+/btg0qlgre3t3UHtUlqbGTUqFFEKBSSX3/91WifXq8nhPyv5NGzZ0/Olyw/P59IJBLSt29fzhdgzZo1BADZvHkzIYSQy5cvGxUxq7Jy5UoCgDx58sQm+61Jt23bNiIUCo2+Zhs2bCAAyOnTpwkhhNy8eZMIhUIycOBAoy8acy0IMV9tqVryUKvVJDAwkLz00kukrKyMjbd//34CgCQnJ7NhzFc+JSWFk2eHDh1IdHS05YtACCktLTUKmzx5MucrTIhj1ZabN28ShUJB/vrXv3KeA5gpnVTdDL/SCQkJpEWLFkbHKCkpIQDInDlzLNoil8vJuHHjjMIPHDhAAJCMjAxCCCErVqwgAMi9e/eM4sbExJCuXbtaPM6mTZsIAPL7779zwu0peUyaNIkN02q1pGnTpkQgEJDPPvuMDS8sLCTu7u5k9OjRRvkypbLz589btNmQGutt0ev1SEtLQ//+/Y2UGQAEAgHn98SJE+Hm5sb+Pnz4MNRqNWbOnMn5AkycOBHe3t44cOAAAEChUAAADh48iNLSUpO2MF/gffv2Qa/XW30O1qRLTU1FmzZtEBERgYKCAnbr3bs3AODo0aMAgLS0NOj1eiQnJxt90apeC2vIzs5Gfn4+3n77bchkMjY8ISEBERER7PUxZMqUKZzfvXr1wu3bt6s9lru7O/t/cXExCgoK0KtXL5SWluL69es2216VkpISDBw4EL6+vti5cyfnOcjMzLRqi4+PZ9OUlZWxpRBDmOtUVlZm0R5r0zN/zcWt7jhPnz4FAPj6+lqMZw0TJkxg/3dzc0OnTp1ACMH48ePZcB8fH7z44osm7zljg7UlPQCosWrLkydPoFKp8NJLL1kVPzw8nPP77t27AIAXX3yREy6RSNCiRQt2f3h4OGbNmoUvv/wS27dvR69evZCYmIgRI0awwjJ06FBs2rQJEyZMwJw5c9CnTx+88cYbePPNN41eZEOsSXfz5k1cu3YNAQEBJvPIz88HANy6dQtCoRCRkZFWXY/qMHd9ACAiIgKnTp3ihMlkMiMbfX19UVhYWO2x/vjjD8yfPx9HjhyBSqXi7FMqlbaabsTEiRNx69YtnDlzBn5+fpx9Vas21uDu7o6Kigqj8PLycna/M9Izf83Fre44DMQJzvxCQ0M5vxUKBWQyGfz9/Y3CGdEyZYMtH7IabfOwBWsvtCm++OILjBkzBvv27cOhQ4fwzjvvYOnSpTh37hyaNm0Kd3d3nDhxAkePHsWBAweQkZGB3bt3o3fv3jh06BDnS1fVpurS6fV6tGvXDl9++aXJPJo1a2b3eTkTc+dYHUVFRYiNjYW3tzdSUlLQsmVLyGQyXLp0CbNnz7apJGeKr776Cjt37sQ///lPREVFGe3Pzc21Kh+FQsE+Q40bN8bRo0dBCOG8DI8fPwZQ2SZhicaNG7NxDamavnHjxmx41fv8+PFjto3FHIxQFhYWomnTphbjApZFxtT9NXfPTeXDfESqio0laqzaEhAQAG9vb7tGrgFA8+bNAQA3btzghKvVauTk5LD7Gdq1a4f58+fjxIkTOHnyJB4+fIgNGzaw+4VCIfr06YMvv/wSV69exeLFi3HkyBG2WmGO6tK1bNkSz549Q58+fRAXF2e0MSWDli1bQq/X4+rVqxaPZ63ym7s+TFjV62Mvx44dw9OnT7F161a8++67eP311xEXF2eyqG1r9evkyZN4//33MXPmTAwfPtxknMaNG1u17d69m00TFRWF0tJSXLt2jZPX+fPn2f2WiIqKwqVLl4yE8fz58/Dw8EDr1q05+WRnZ3PiPXr0CA8ePKj2OBEREQCAnJwck/uLi4s5v/Py8izm5wg5OTkQCoXsuVlDjYmHUChEUlIS/vWvfxldXKD6olpcXBwkEglWr17Nifvdd99BqVQiISEBAKBSqYxG87Vr1w5CoZAtTj579swof+bGmipyMliTbsiQIXj48CG+/fZbo7hlZWVsz1FSUhKEQiFSUlKMHkrD85PL5SgqKjJrE0OnTp0QGBiIDRs2cM7hl19+wbVr19jr4yjM18vQRrVajXXr1hnFlcvlVldjHj9+jCFDhqBnz55sj40p7GnzGDBgAMRiMcdGQgg2bNiAJk2aoHv37hw7rl+/Do1Gw4a9+eabyMvLw08//cSGFRQUIDU1Ff3792fbONq2bYuIiAhs3LgROp2Ojbt+/XoIBAK8+eabFq9BdHQ0JBKJyfcDgNGHbe/evey5OJuLFy+ibdu2bFXfGmq02rJkyRIcOnQIsbGxbDfm48ePkZqailOnTnG6EqsSEBCAuXPnYuHChXjttdeQmJiIGzduYN26dYiJicGIESMAAEeOHMH06dMxePBgtG7dGlqtFtu2bYObmxsGDRoEAEhJScGJEyeQkJCA5s2bIz8/H+vWrUPTpk0tdtlZk27kyJHYs2cPpkyZgqNHj6JHjx7Q6XS4fv069uzZg4MHD6JTp05o1aoV5s2bh08//RS9evXCG2+8AalUil9//RUhISFYunQpgMoHav369Vi0aBFatWqFwMBAtvHVELFYjGXLlmHs2LGIjY3FsGHD2K7asLAwvPfee/beNg7du3eHr68vRo8ejXfeeQcCgQDbtm0z+QBHR0dj9+7dmDVrFmJiYuDp6Yn+/fubzPedd97BkydP8OGHH2LXrl2cfe3bt0f79u0B2Nfm0bRpU8ycORMrVqyARqNBTEwM0tLScPLkSWzfvp1TnJ87dy7+8Y9/ICcnB2FhYQAqxaNr164YO3Ysrl69Cn9/f6xbtw46nQ4LFy7kHGvFihVITExE37598dZbb+HKlStYs2YNJkyYYNRVXBWZTIa+ffvi8OHDSElJMdqfkZGB4cOH4y9/+Qv+/PNPbNy4ER4eHjh06BBiYmLw+uuv23xtTKHRaHD8+HG8/fbbtiW0ul/GTu7evUtGjRpFAgICiFQqJS1atCDTpk0zGiRmqjuXkMqu2YiICCIWi0lQUBCZOnUqZ5DY7du3ybhx40jLli2JTCYjjRo1Iq+++io5fPgwGycrK4sMGDCAhISEEIlEQkJCQsiwYcOMhhpXxdp0arWaLFu2jLRt25ZIpVLi6+tLoqOjycKFC4lSqeTE3bx5M+nQoQMbLzY2lmRmZrL7c3NzSUJCAvHy8rJqkNju3bvZ/Bo1amRxkFhVmG6+6jh9+jTp2rUrcXd3JyEhIeTDDz8kBw8eNLLn+fPn5G9/+xvx8fGpdpCYqUFlzOboIDFCKoeYL1myhDRv3pxIJBLStm1b8s9//tMoHtONnZOTwwl/9uwZGT9+PPHz8yMeHh4kNjbW7DO6d+9eEhUVRaRSKWnatCmZP38+UavVVtn5008/EYFAwOnuZbpqlyxZQuLi4ohUKiXh4eHkhx9+IB999BHx8PAgCxcuJIT87x5WHU5g7p7HxsaStm3bcsJ++eUXAoDcvHnTKpsZBITQdVsolLpCp9MhMjISQ4YMwaeffgoAuHPnDsLDw7FlyxaMGTOmxm1ISkqCQCBgq0XWQmfVUih1iJubG1JSUrB27do6mZJ/7do17N+/nxUuW6DiQaHUMUOHDsWzZ8/qZEp+mzZtoNVqrR6PZQgVDwqFYhe0zYNCodgFLXlQKBS7cJnh6a6OXq/Ho0eP4OXlZddENkr9gxCC4uJihISEWJwjVV+h4mEljx49wtdffw2RyPiSEUJQWFho98g/iUTCGRErlUqh1+uhVqsdstkWRCIRRCIRtFottFotx6baqtkKBALOuVe1qbaoej9kMhnkcrnJ67BkyRLcv3/fqrkpVbH0EeJDawIVDyvx8vKCSCSCh4eH0VeGEIKwsDC7J5/p9XqoVCp2iLRYLIa3t3etf81KS0vZ4fRCoRA3btyw+aWt6mTGVrRaLZRKJTuEXy6Xw8PDw6E8baXq/RCJRKioqDC6H4yNXl5edh2H76UVKh5WwnwlhEIhxGIxG67X66HX6yGVSjme0WxFLBazvhT8/PxM+oioaWQyGedrW50/ClM440XXaDTs9PdGjRrVyUtmeD+YaexCoZBjCyMu9lZj+S4e/La+nqBWq/H06VOIxWKIxWI8ffq0VqssQKUIPn36FAKBADKZDOXl5XZ/UR2huLgY5eXlkMlkEAgEePr0qcPT/m2l6v0oKiqqERsEAoHZjQ9Q8ahj1Go1CgoKIBaL4e/vD39/f/arV1sCwgiHRqOBv78//Pz84O3tDW9v71oVkOLiYtaHpp+fH/z9/aHRaGpVQEzdD6bdxXDmrDNgSjKmNj5Aqy02QgjhPMh6vR6EEM6UbmvRaDQoLCyESCSCt7c3277g7e2NwsJC5Ofnw9fXl1NNcjZMY69Wq2V9dKjVakilUpSUlEChUMDNzY1tC6kOewWvpKQEz58/h6enJ6RSKZuPQqHgXIua/Cqbux9yuRzFxcWsTabcFNgDX0TCHFQ8bIB5WEyJR0VFhU1fJqZHgWkrqepXxN3dHWq1GiUlJWzrv7MhhECtVkMoFMLT0xM6nY5zDnq9nvVyLxQKrWo8ZdoqbEGr1UKj0UAul8PNzc0oD09PT6jVaqhUKkgkkhoREEv3Q6vVQigUQq/XQ6PRgBDilPtBxaMBUVRUhObNm3McDms0GlRUVKBfv342OVLhA3PnzrU5zZIlS2rAkrpFqVQiPT0dEokEz58/Z0tpjlZjqHg0IPR6PUQikVGvik6ng0KhQKNGjerIsprBGufIValv14CBue+BgYF4+vQplEqlwxPZ+C4e/LaeQqllhEIh/Pz8IBaLHfYcz/cGU35Y6SJIJJJa7zakuB6MgNg7KNAwHz6LB6222IBQKIRKpTI5ypTSsBAKhdYvy2ghDz7Db+trGaZHpS4GLlFcD0dffr6XPPhhpYtACIFCoaj1gUuU+gkVjwaGSCTijHzkw+xHimtCxcOJLF26FDExMfDy8kJgYCCSkpJMrohWldTUVEREREAmk6Fdu3ZIT0/n7CeEIDk5GY0bN4a7uzvi4uJw8+ZNu+2USCSsgDgyFZ/SsKHi4USOHz+OadOm4dy5c8jMzIRGo0Hfvn0tDo0+c+YMhg0bhvHjx+Py5ctISkpCUlISZ5nL5cuXY/Xq1diwYQPOnz8PuVyO+Ph4u0ZDMjACotVqa30SG6V+wPeJcS7V25KRkcH5vXXrVgQGBuLixYtm/UR89dVXeO211/DBBx8AAD799FNkZmZizZo12LBhAwghWLVqFebPn48BAwYAAL7//nsEBQUhLS0Nb731lsl8KyoqOEOUq64OD1QKiK+vr9XzPigUQ/hSwjCHS1vPDMKxNGrx7NmzRksSxsfH4+zZswAqF/DNzc3lxFEoFOjSpQsbxxRLly6FQqFgN3Or3YvFYof8eFAaLrTaUkPo9XrMnDkTPXr0sLimRG5uLoKCgjhhQUFByM3NZfczYebimGLu3LlQKpXsdv/+fXtPhUIxCd/Fw6WqLYZMmzYNV65cwalTp+rk+FKp1CpvXhqNhrZ5UOyCLyJhDpe0fvr06di/fz+OHj1arWPZ4OBg5OXlccLy8vIQHBzM7mfCzMWxF7VajcLCQt40cFFcC76XPFzKSkIIpk+fjr179+LIkSMIDw+vNk23bt2QlZXFCcvMzES3bt0AAOHh4QgODubEUalUOH/+PBvHHhiPU6Zm2VIo1sB38XCpasu0adOwY8cO7Nu3D15eXmybhEKhgLu7OwBg1KhRaNKkCZYuXQoAePfddxEbG4svvvgCCQkJ2LVrF7Kzs7Fx40YAld1hM2fOxKJFi/DCCy8gPDwcH3/8MUJCQpCUlGSXnYau6ry9vY0c+VAo1sAXkTCHS4nH+vXrAQCvvPIKJ3zLli0YM2YMAODevXuci969e3fs2LED8+fPx0cffYQXXngBaWlpnEbWDz/8ECUlJZg0aRKKiorQs2dPZGRkcJz6WItWq0VRURHEYjH8/PxqdT0RSv2CiocTsWak5rFjx4zCBg8ejMGDB5tNIxAIkJKSgpSUFEfMg0AggFKphEwmg5+fH+9vPqVu4fvz41Li4epIpVK4ublR4aAAgMMTI/n+DFHxsAG9Xl8nK7lRXA9mVTlH4PtzRMXDBhhP45SGDbPOjaMOkPnexU/Fg0KxAcMFshz1ls/3DxEVDwrFSgghnJX1HO1p47t48Nt6So1CCDHyjWKO9PT0eu3XhFlZjxEOZwwMpIPEKPUWtVqNfv36WRW3X79+qKioqLejbdVqNbRaLQIDA512jnwRCXNQ8aCYxZqJgVXj19fSByEEvr6+ThVHKh6UeguzPqst8esrEonE6QuO8/16UfGgmEWn09nUneho16UrUxMvOhUPSr2GEGKVgNTX6gpDTZwfFQ8KpQGgVqvtmkhpCb6LB7+tp9Q41lZb+D5asjqYrlpnLvTF965aflhJqRNsFYT6LCASiQRardapKwVS8aDUO8aNG2e3EAgEAowbN87JFtU9QqEQvr6+Tl1qlIoHpV4hEAiwZcsWh/LYsmVLvSyFiMVizlKjjgoI3xd9ouJBAVDZIFj1oc3MzMTs2bOtSj979mxkZmZywgQCQb3zLG+41KgzpuTzueRBe1tsQCSqv5fLcDSph4cHuwpeXFwcPvvsM4tfQ8NuTEII5HI5SktL2XzrWzcuIyBVPfLbCl9Ewhz8tr6WEYlE7EtR39i7dy+Aypff1PKZ5gTAVHhJSQkbzuRb35BIJE6Zkk9LHg0ErVaLkpISSKVSeHl51bU5TiUpKcliCcHX19dseGFhocl99a3EURVHS6J8EQlz8Nv6Wkar1UIul0OlUqG4uLiuzakR0tPTTTbgFRUVmYxfVFRkMr61U/kbMg2u5JGTk4OTJ0/i7t27KC0tRUBAADp06IBu3bo5fQSeK+Lh4QGpVMo2ltk689SVGTZsGHbt2uWUvBISEvDWW29h586dTsmvPsIXkTCH1eKxfft2fPXVV8jOzkZQUBBCQkLg7u6OZ8+e4datW5DJZBg+fDhmz56N5s2b16TNdQ5TZVGpVPDw8ICbm1sdW+Q4QqHQ6dWMXbt2Yffu3U4dlVmf4Lt4WGV9hw4dsHr1aowZMwZ3797F48ePcfHiRZw6dQpXr16FSqXCvn37oNfr0alTJ6Smpta03XWOl5cXvL298fz5c14v/MRMfDMUjqysLBBCbBYTJo3h0p6m8qdU0iCqLZ999hni4+PN7pdKpXjllVfwyiuvYPHixbhz546z7HNpvLy8oNVqeTuW4cyZM+jRowcn7Pr163jxxRcdyrd37964fv06IiIi2LCaKNnwHb6IhDmsEg9LwlEVPz8/+Pn52W0Q35DL5bx8KVq0aIGcnByj8BdffNHhkoK59LQEwqVBiIcp8vPzkZ+fb1Sfbd++vcNG8Q2+tXmYE44dO3YA4Hax5ufnIzAwsNo88/Pz2f+Z9Dt27MDf/vY3TjwqIP+jwYnHxYsXMXr0aFy7do19CJgHQiAQ1GtvUqYghPCq2mJupGjVF3rTpk2YOHGi1fkyAvPtt99iwoQJACp7b4YNG2Z0TIFAgLy8PKtEqT7Dlzks5rBZ+saNG4fWrVvjzJkzuH37NnJycjh/GxJ6vR6FhYW8/5Ia2j9+/HgIBAKbhMOQiRMnQiAQYPz48SbzZwgKCrIr//pEg2gwNeT27dv48ccf0apVq5qwhzcwK4dptVp4enrWtTlWYepLZ1jtjI+Px6FDh5xyrM2bN+PBgwc4ePAge5yqL0VDr8LwRSTMYbP1ffr0wW+//VYTtvAGwyUHfX19Xe4hYEZ5nj59mg0LCAgwimfonzQrK8tpwsFw6NAhtttWIBDgzTffNIpjaNfp06d5NSXdURpcyWPTpk0YPXo0rly5gpdeesnIHX1iYqLTjHNFDIXD398fgGt5DTd88Zhu2I0bN6KgoIANj46ORnZ2Nvs7PDy8xrrX4+LiEBYWhpycHKSmpqK4uBg+Pj5siaegoAAbN27EpEmTON3GDaFUwheRMIfN4nH27FmcPn0av/zyi9G+htBgygxLZ5YcdKXGUsNen3PnzgGoLF1MnjyZDSeE4OrVq+xvpVJZ4+Ny7ty5A6VSCYVCAS8vL+h0Ouj1etbeyZMns20l586dQ9euXdnzqc/PE9/Fw2brZ8yYgREjRuDx48fQ6/WcrT7faKByGrZOp3PaWqXOpKCggNN+0aVLFwDgTBVgHtapU6eyYT4+PrViH3McQgju379vVDxn7GTsBipLeYYlpvoG36stNlv59OlTvPfeew2ytVwoFEKhULiccADctgPD4v79+/fZ/+fOnQsAOH78eO0ZVgWBQIBmzZpx7AG4dhrab6qtxlVw1LcL38XD5mrLG2+8gaNHj6Jly5Y1YY9LU1FRgTNnzkCj0bBhYrEY7u7umDt3rlm/Fo5CCIFSqeSUEgxfMEulB8Oi/+LFi9GnTx9ERkYiKCgI//nPf2rE3urYtGkToqOjsXjxYo6d5sjJyUF4eDj727Bdp6ioCAqFokYbWX19fTFkyBCUlZWx997Ly8spzoD4jM3i0bp1a8ydOxenTp1Cu3btjBpM33nnHacZ52rUVQOeuRejcePGyM3NtZj2xx9/RFJSEvu7d+/ezjTNJiy94D/++KPZfS1atABQ6We16ryb2qp2GWI4KdIRGpx4bNq0CZ6enjh+/LhR8VcgENRr8XAlLL2Ihj0VhsLhyhh6MjN3bq5QXWSEQ6VSoby83KG8+C4eNlufk5NjdnPWCNO1a9ciLCwMMpkMXbp0wYULFyzGT01NRUREBGQyGdq1a2fkxYoQguTkZDRu3Bju7u6Ii4vDzZs3nWKrq8LH8RKubrNcLmeFwxme5Pje5uE0Kx8/fozly5c7nM/u3bsxa9YsLFiwAJcuXcLLL7+M+Ph4zsQrQ86cOYNhw4Zh/PjxuHz5MpKSkpCUlIQrV66wcZYvX47Vq1djw4YNOH/+PORyOeLj4x3+clAaDiKRCJ6enk51Qcl38RAQGyvy5lYDu3v3Li5cuODwhe3SpQtiYmKwZs0aAJXddc2aNcOMGTMwZ84co/hDhw5FSUkJ9u/fz4Z17doVUVFR2LBhAwghCAkJwd///ne8//77ACrHNgQFBWHr1q146623TNpRUVGBiooK9rdKpcKiRYs4jWbA/xpM9+zZU2MNppS6xdfXF6NGjYJareb4chWLxfj++++hVCrh7e1tc74LFiwwu2/hwoX2mFqr2CxxhYWFnK2goAAXLlzAsWPH8PnnnztkjFqtxsWLFxEXF/c/A4VCxMXF4ezZsybTnD17lhMfqJyjwcTPyclBbm4uJ45CoUCXLl3M5gkAS5cuhUKhYDeme5HSMGE85zsTvpc8bG4wNbcOx+LFi5GWlsYZzWgrBQUF0Ol0RmNIgoKCcP36dZNpcnNzTcZneiGYv5bimGLu3LmYNWsW+5speVAaJjXhapIvImEOp63bMmzYsHr1ckml0nrlGZ3ievBdPJxm/W+//YYOHTo4lIe/vz/c3NyMlvHLy8tDcHCwyTTBwcEW4zN/bcmzPmCPA+O6xpVtromlRhtctcWwKM+Ql5eHffv2ISEhgbP/yy+/tClviUSC6OhoZGVlseMT9Ho9srKyMH36dJNpunXrhqysLMycOZMNy8zMRLdu3QBUzhgNDg5GVlYWoqKiAFRWQc6fP8+Z48E3CCFmB4kZvoBpaWm8GOuRlpbG/m/oKsAQZpCYKReKNY1IJIJcLje7+JU98EUkzGGzeFy+fNlkeExMDOvXFLDfxdqsWbMwevRodOrUCZ07d8aqVatQUlKCsWPHAgBGjRqFJk2aYOnSpQCAd999F7Gxsfjiiy+QkJCAXbt2ITs7Gxs3bmTtmDlzJhYtWoQXXngB4eHh+PjjjxESEsKLlwowPTwdqOweBypHWSqVSpNpBw0axPl95MgRzvD0l19+uUZsNgUjaszw9I4dO3LsNNeucPv2bXZ4+u3bt2t9eDoA1umTTqdzalctn7FZPI4ePVoTdrAMHToUT548QXJyMnJzcxEVFYWMjAy2wfPevXuci969e3fs2LED8+fPx0cffYQXXngBaWlpeOmll9g4H374IUpKSjBp0iQUFRWhZ8+eyMjIsGuFu7/85S/w8PBgf6vVapSXl2PJkiVo1KiRA2duGYVCYbZIzyz5aArDmc7z5s3Dq6++yv6uK2fVjI/TefPmsfNbLM3INpzXApieJlCT1Z1nz54hNTUVOp0OpaWl8Pb2hpeXF0pLS/H999/bnS/fxcPmcR4NFZVKhQ8//BAxMTEmxWPw4ME1Kh7VUVBQYHJmbWhoKDtjVSgUQqfTITY2lp1aUJsjOpk2jQcPHqBZs2Zwc3Nj3Qg0a9YM9+7dM7LpyZMnrNOluoIRD5lMhoqKCqhUKnh7e8PNzQ0TJkywe5zHypUrze577733HDG5VrBK+l577TXWuYwliouLsWzZMqxdu9Zhwyi24e/vz/mSnT9/HkDl4D0G5kVdv349G+bMOrwlmOMwU/IZHzAMjJ2M3UCl2NW1cFTFcG4LnZJvBYMHD8agQYOgUCjQv39/dOrUCSEhIZDJZCgsLMTVq1dx6tQppKenIyEhAStWrKhpu+sEV553AVQW/Rkbu3btyjY8fvPNN+z4G4FAwHFDqFAoEBYWVqPexMLCwtjp61XdEALAN998w7Hb8HxcEWat4mfPnjmUD19EwhxWWT9+/Hjcvn0bH330Ea5evYpJkyahV69eiImJQXx8PL799luEhobi119/xe7duxEaGlrTdtcJUqnU5delNayFMg6QJ02axPmCX7x4kSOEOTk5OHz4cI3Yc/jwYbZ3ZPDgwfD29uYIh7+/PyZNmsSxt+p5uCJeXl6Qy+UO5dEgSh5A5YszYsQIjBgxAkDl/JCysjL4+fkZ+fSor+j1eiiVSshkMpeYHm4OUy/ekydPTC6+pNfrIRAI0KdPH/Tt29epHtT79u2LPn36sDb98MMPJu1i6NGjh8uLhiGGbV/24Ool2eqwW+IUCgWCg4MbjHAAlY2jbm5uKCgocCnHx9Zi6sU0/ModPHjQ7MRHWxk3bhy7ZkvV41iypyHB95IHP6x0Iby9vSEWi3krIKYw/AJ+9913IITg22+/tSuvb7/9FoQQfPfddybzZ6g64rchQsWjgSEUCtmqWkFBAWd6Ph8w97Wv+oJPmDABhBCUlZVZlW9ZWRkIIewYDnP5AsAHH3zQ4NepBah4NEgMBaSwsJDTAMgHqhOQhw8fsmHMkP7qMIzHpDclHJ6enk5xGlUfoOLRQGEERCQS8bL6Yqm9wdDtwo0bN6zKzzCeObcNH3zwgdOGdtcHGpx4jB49GidOnKgJW3iHUCiEr68vb1vNCSFGpSaBQIDIyEiH8o2MjDS6Jnq9npY4qsB38bB5botSqURcXByaN2+OsWPHYvTo0WjSpElN2MYLBAKBS3fbVgfjaV0oFLKlEaZ71Z68TIXxrVpXW/BFJMxhs/VpaWl4+PAhpk6dit27dyMsLAz/93//hx9++IF3jYfOwlVHQtqCXq8368/VXt566y0qHBbge8nDLisDAgIwa9Ys/Pbbbzh//jxatWqFkSNHIiQkBO+99169X9bAkJKSknojmjt37sSBAweckteBAwewc+dOp+RVX2mQ4sHw+PFjZGZmIjMzE25ubujXrx9+//13REZGWpwxWF8oLi7G8+fP69VAuX79+rGzXw03cyuz+fj4mIzfr1+/2jWchzQ48dBoNPjxxx/x+uuvo3nz5khNTcXMmTPx6NEj/OMf/8Dhw4exZ88epKSk1IS9LkNxcTFUKhU8PT1rxEVdbZOWlmax4dfcshKWlpsQCAQcD2EULnwXD5uf+saNG0Ov12PYsGG4cOGCyXEAr776ap2sIVpbMMLh7e0NqVRaLxaPGjhwIIDKF97Dw8NomQFzwmK4tCWDXC5np6sPHDiwwQ9DNwdfRMIcNlu/cuVKPHr0CGvXrjU7gMjHx6dO/EzWBqWlpaxwMFOz6wOGC1yVlpZCIBDg8OHDmDNnTrVd0QKBAHPmzMHhw4chEAg4fi4M86VwYZbXNLXxAZtLHiNHjqwJO3iBSCRCSUkJGjVqVK+EA6h0Pl3V8fBf//pXq9MvW7YMy5Yt44TREodlGlzJoyHDeNCub8JhCCGEdTZtL2PHjm0QwuGob5cG1+bRkNFqtQ77cOADmzdvxubNm+0qPjcE0QAq3TOY81hvLXwRCXNQ8bABV/ci5mzMrZ9iKX5DQK1Wo6CgAG5ubg7lw3fx4Lf1lBonPj7eqfH4DiMcYrHYLo/phtBqC6Vek5GRYVXpIyMjoxasqVs0Gg2USiXEYjH8/Pwc7qLni0iYg4oHxSLWVltMjfeoT+j1eqhUKkilUvj5+TnlxafiQam32Fqnd3NzqxeTBE2hVqshEomcJhwAFQ9KPcbWGbH1eQatQCCAr6+vU194Kh6UektFRQWkUqlN8esrEonE6SM/+S4e/LaeUqNIJBKkp6dbFTc9PZ3XTpGqoyaGjNPeFkq9JjY21qnx+EpNVMn4MofFHFQ8KGax5eFmll6srz0uarUaYrHYqaUrvpQwzEHFg0KxAoFAgMLCQqcKCN/Fg9/WUyi1hEQigUgkcupKgXxv8+CHlRRKHcN01TpzqVEqHhRKA0EgEHCWGm3oU/L5YSWF4iIYLjXqjCn5VDwaCBKJpF6PoqRYByMgzpiSz2fxoL0tNiAUCqFSqeDh4cGbG0ypGYRCoVOm5PMZl7Feo9Fg9uzZaNeuHeRyOUJCQjBq1Cg8evSo2rRr165FWFgYZDIZunTpggsXLnD2l5eXY9q0afDz84OnpycGDRqEvLw8m22sqKiATqfD06dPaQmE4vDLz/eSh8tYWVpaikuXLuHjjz/GpUuX8NNPP+HGjRtITEy0mG737t2YNWsWFixYgEuXLuHll19GfHw88vPz2Tjvvfce/vWvfyE1NRXHjx/Ho0eP8MYbb9hsIyEECoUCGo2GCgjFYfguHi5TbVEoFMjMzOSErVmzBp07d8a9e/cQGhpqMt2XX36JiRMnsk57N2zYgAMHDmDz5s2YM2cOlEolvvvuO+zYsQO9e/cGAGzZsgVt2rTBuXPn0LVrV5vsFIlE8Pf3R0FBAZ4+fepw0ZXScOGLSJjDpa1XKpUQCARmF5BSq9W4ePEi4uLi2DChUIi4uDicPXsWAHDx4kVoNBpOnIiICISGhrJxTFFRUQGVSsXZGCQSCfz9/aHRaFBYWFhvh2RTaha+lzxc1sry8nLMnj0bw4YNM/t1LygogE6nQ1BQECc8KCgIubm5AIDc3FxIJBIjATKMY4qlS5dCoVCwW7NmzTj7GQHRarVOG3FIaVjwfdGnOhOP7du3w9PTk91OnjzJ7tNoNBgyZAgIIVi/fn2d2Dd37lwolUp2u3//vlEciUQCX19fWvKg2AXfSx511uaRmJiILl26sL+bNGkC4H/CcffuXRw5csRim4K/vz/c3NyMek7y8vIQHBwMAAgODoZarUZRURGn9GEYxxRSqdQqRzjOnmlJaTjwRSTMUWfWe3l5oVWrVuzm7u7OCsfNmzdx+PBh+Pn5WcxDIpEgOjoaWVlZbJher0dWVha6desGAIiOjoZYLObEuXHjBu7du8fGoVDqAlrycBIajQZvvvkmLl26hP3790On07FtEo0aNWK/7n369MHAgQMxffp0AMCsWbMwevRodOrUCZ07d8aqVatQUlLC9r4oFAqMHz8es2bNQqNGjeDt7Y0ZM2agW7duNve0mLObtnlQ7IEvImEOlxGPhw8f4ueffwYAREVFcfYdPXoUr7zyCgDg1q1bKCgoYPcNHToUT548QXJyMnJzcxEVFYWMjAxOI+rKlSshFAoxaNAgVFRUID4+HuvWrXPYZrVajcLCQpv8fFIoDFQ8nERYWJhVDY937twxCps+fTpbEjGFTCbD2rVrsXbtWkdM5MCsHCYSiWibB8UuqHg0QKouOVifvYZTag4qHg0MrVaLoqIidsnBhrb4NcV5UPFoQAgEAiiVSshkMqeuHEZpmPD9+aHiYQNSqRRubm5UOCgAHF+Oge/PEBUPGyCEwMPDg1NV0Wg00Gq1DnuVckV8fX1tTvPs2bMasKRuUSqV0Gq10Gg0bBghBEVFRQ7lS8WjASGXy1FYWMgRCr1eD0II0tPTIRJZvpx6vR5qtRoCgcCm5QsJIVCr1SCEQCKROPTQ2ZLXkCFDOL9FIhFEIhG0Wq3Ztp7U1FSr7GBeRrFYXO11M8Tea+hIXkw7l0AggFAoBCEEWq3W4ZIHX+awmIOKhw0wN7vqC0cIgVQqhVgsrjYPsViMwsJC6HQ6+Pr6VvsAEUJQWFgIrVbLeu92FJlMhsLCQjx//txinmVlZez/crkcHh4eeP78OUpKSizmbS0lJSV4/vw5PD092UWjLKHRaKBSqSASiay6dtZgzf3QaDQQCoXsPo1GA0KIU9wQ8hkqHjbCfH0M0ev1Vs9xkUgkrPdtlUplsf1Er9ezTocCAwOdOp4kMDAQT58+hVKphL+/v8m8mWK6l5cX5HI5lEoliouLLeZri43MWiiMIHh5eZmNq1aroVQqIZVKndrmZO39YGa7MqOJpVKpwxMi+S4e/Laepxj6AzHnkYwRDo1GY/bldgRDL+CW1iHx8vKCt7c3VCpVtcJhD9bkbziupiYaq629HxUVFWx1z5aqljn4PreFH1bWQyw9sDUtHAzVCUhNC4c1x6lp4WCo7n7odDqnCgfAf/Gg1RYrYYqoer3eqNUdqPQ8Zs+AMU9PTyiVSuTm5rLuB1QqFXQ6HRQKhcXGSWfBzGjOy8uDQqGASCRCaWkpFAoFnj9/jvLycqvbWkpLS+2ywc3NDVKpFM+ePUNFRQXbq6VUKuHm5gZ3d3eUl5fblbctmLofSqUSer0ebm5uIISw958RGHurL3wRCXMICPVkYxUPHjww8iZGoQDA/fv30bRp07o2o9ah4mEler0ejx49gpeXl0Ot/CqVCs2aNcP9+/d56TyZ7/YDzjsHQgiKi4sREhLC+1KEPdBqi5UIhUKnfl28vb15+/IB/LcfcM45KBQKJ1nDPxqeXFIoFKdAxYNCodgFFY9aRiqVYsGCBbz1PsZ3+4H6cQ6uAG0wpVAodkFLHhQKxS6oeFAoFLug4kGhUOyCigeFQrELKh4OotFoMHv2bLRr1w5yuRwhISEYNWoUHj16VG3atWvXIiwsDDKZDF26dMGFCxc4+8vLyzFt2jT4+fnB09MTgwYNMlpa0xlUZ0dVUlNTERERAZlMhnbt2iE9PZ2znxCC5ORkNG7cGO7u7oiLi8PNmzedbjdQuSB5TEwMvLy8EBgYiKSkJNy4caPadK50DryFUByiqKiIxMXFkd27d5Pr16+Ts2fPks6dO5Po6GiL6Xbt2kUkEgnZvHkz+eOPP8jEiROJj48PycvLY+NMmTKFNGvWjGRlZZHs7GzStWtX0r17d6fab40dhpw+fZq4ubmR5cuXk6tXr5L58+cTsVhMfv/9dzbOZ599RhQKBUlLSyO//fYbSUxMJOHh4aSsrMypthNCSHx8PNmyZQu5cuUK+fe//0369etHQkNDyfPnz82mcbVz4CtUPGqACxcuEADk7t27ZuN07tyZTJs2jf2t0+lISEgIWbp0KSGkUpTEYjFJTU1l41y7do0AIGfPnnWardXZUZUhQ4aQhIQETliXLl3I5MmTCSGE6PV6EhwcTFasWMHuLyoqIlKplOzcudNpdpsjPz+fACDHjx83G8fVz4Ev0GpLDaBUKiEQCODj42Nyv1qtxsWLFxEXF8eGCYVCxMXF4ezZswCAixcvQqPRcOJEREQgNDSUjeMo1thRlbNnz3LiA0B8fDwbPycnB7m5uZw4CoUCXbp0cZrdlmD8yzZq1MhsHFc/B75AxcPJlJeXY/bs2Rg2bJjZSVcFBQXQ6XSc9XQBICgoiF3cOzc3FxKJxEiADOM4ijV2VCU3N7dau5mwmrLbHHq9HjNnzkSPHj3w0ksvmY3nyufAJ6h42Mj27dvh6enJbidPnmT3aTQaDBkyBIQQrF+/vg6tbJhMmzYNV65cwa5du+ralAYBnZJvI4mJiejSpQv7u0mTJgD+Jxx3797FkSNHLE719vf3h5ubm1HPSV5eHoKDgwEAwcHBUKvVKCoq4pQ+DOM4ijV2VCU4OLhau5mwxo0bc+JERUU5xW5TTJ8+Hfv378eJEyeqdZ3gqufAN2jJw0a8vLzQqlUrdmNc+A0ZMgQ3b97E4cOH4efnZzEPiUSC6OhoZGVlsWF6vR5ZWVno1q0bACA6OhpisZgT58aNG7h37x4bx1GssaMq3bp148QHgMzMTDZ+eHg4goODOXFUKhXOnz/vNLsNIYRg+vTp2Lt3L44cOYLw8PBq07jaOfCWum6x5TtqtZokJiaSpk2bkn//+9/k8ePH7FZRUcHG6927N/n666/Z37t27SJSqZRs3bqVXL16lUyaNIn4+PiQ3NxcNs6UKVNIaGgoOXLkCMnOzibdunUj3bp1c6r91dkxcuRIMmfOHDb+6dOniUgkIp9//jm5du0aWbBggcluTh8fH7Jv3z7yn//8hwwYMKDGujmnTp1KFAoFOXbsGOfal5aWsnFc/Rz4ChUPB8nJySEATG5Hjx5l4zVv3pwsWLCAk/brr78moaGhRCKRkM6dO5Nz585x9peVlZG3336b+Pr6Eg8PDzJw4EDy+PFjp5+DJTtiY2PJ6NGjOfH37NlDWrduTSQSCWnbti05cOAAZ79erycff/wxCQoKIlKplPTp04fcuHHD6XYTQsxe+y1btvDmHPgKnZJPoVDsgrZ5UCgUu6DiQaFQ7IKKB4VCsQsqHhQKxS6oeFAoFLug4kGhUOyCigeFQrELKh4UCsUuqHhQTPLdd9+hb9++NX6cjIwMREVFQa/X1/ixKM6FigfFiPLycnz88cdYsGBBjR/rtddeg1gsxvbt22v8WBTnQsWDYsQPP/wAb29v9OjRo1aON2bMGKxevbpWjkVxHlQ86jFPnjxBcHAwlixZwoadOXMGEonEaEq6Ibt27UL//v05Ya+88gpmzpzJCUtKSsKYMWPY32FhYVi0aBFGjRoFT09PNG/eHD///DOePHmCAQMGwNPTE+3bt0d2djYnn/79+yM7Oxu3bt2y/2QptQ4Vj3pMQEAANm/ejE8++QTZ2dkoLi7GyJEjMX36dPTp08dsulOnTqFTp052HXPlypXo0aMHLl++jISEBIwcORKjRo3CiBEjcOnSJbRs2RKjRo2C4XzM0NBQBAUFcbyyUVwfKh71nH79+mHixIkYPnw4pkyZArlcjqVLl5qNX1RUBKVSiZCQELuPN3nyZLzwwgtITk6GSqVCTEwMBg8ejNatW2P27Nm4du2akSevkJAQ3L17165jUuoGKh4NgM8//xxarRapqanYvn07pFKp2bhlZWUAAJlMZtex2rdvz/7POBBu166dUVh+fj4nnbu7O0pLS+06JqVuoOLRALh16xYePXoEvV6PO3fuWIzr5+cHgUCAwsLCavPV6XRGYWKxmP1fIBCYDavaNfvs2TMEBARUe0yK60DFo56jVqsxYsQIDB06FJ9++ikmTJhg9NU3RCKRIDIyElevXjXaV7Wqcfv2bafYWF5ejlu3bqFDhw5OyY9SO1DxqOfMmzcPSqUSq1evxuzZs9G6dWuMGzfOYpr4+HicOnXKKHzfvn346aefcOvWLSxevBhXr17F3bt38fDhQ4dsPHfuHKRSKXUuzDOoeNRjjh07hlWrVmHbtm3w9vaGUCjEtm3bcPLkSYvryowfPx7p6ens6msMCQkJWL58OSIjI3HixAmsW7cOFy5cwLZt2xyyc+fOnRg+fDg8PDwcyodSu1AfphSTDB48GB07dsTcuXMBVI7ziIqKwqpVq5x6nIKCArz44ovIzs62atkEiutASx4Uk6xYsQKenp41fpw7d+5g3bp1VDh4CC15UKyipkoeFP5CxYNCodgFrbZQKBS7oOJBoVDsgooHhUKxCyoeFArFLqh4UCgUu6DiQaFQ7IKKB4VCsQsqHhQKxS7+H4orKvhziSZyAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\tJ = 9.6592e-01\n", + "\tgrad_norm = 1.0452e-02\n", + "step = 34\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\tJ = 9.6938e-01\n", + "\tgrad_norm = 4.6641e-03\n", + "step = 35\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\tJ = 9.7234e-01\n", + "\tgrad_norm = 3.5643e-03\n", + "step = 36\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\tJ = 9.7384e-01\n", + "\tgrad_norm = 5.4688e-03\n", + "step = 37\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\tJ = 9.7460e-01\n", + "\tgrad_norm = 4.5780e-03\n", + "step = 38\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\tJ = 9.7571e-01\n", + "\tgrad_norm = 3.6787e-03\n", + "step = 39\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAQ8AAADaCAYAAAC4q8cWAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjMsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvZiW1igAAAAlwSFlzAAAPYQAAD2EBqD+naQAAO8FJREFUeJztnXd4FNX+/9+72ZZsspuQHiCFZqgGIYQAGoV8CRIpooB8qYJ0UOAqRSmCCAoIiDT5KqBIjZfihYBC6L1ef2IAuRCClBACm930bef3R56Zm8mWbE12kvN6nnmSPW0+095zzplzPkdACCGgUCgUOxHWtAEUCoWfUPGgUCgOQcWDQqE4BBUPCoXiEFQ8KBSKQ1DxoFAoDkHFg0KhOAQVDwqF4hBUPCgUikNQ8eAJx48fh0AgwPHjx2vaFIqL2bVrF+rVq4fCwsJq33dmZiZEIhGuX79ud14qHh7G2rVrsXnz5po2wyG2bduGlStX1rQZAACj0YglS5YgJiYGMpkMbdq0wfbt223On5+fjzFjxiA4OBhyuRyvvfYarl69ajbtL7/8gpdeegkymQyRkZGYN28e9Hq9TfsxGAyYN28eJk+eDF9fX5vtcxUtWrRAamoq5s6da39mQvEoWrZsSZKSkkzCDQYDKSkpIQaDofqNspHU1FQSFRVV02YQQgiZOXMmAUBGjx5NNmzYQFJTUwkAsn379irzGgwG0qlTJyKXy8mnn35KVq9eTVq0aEH8/PzIX3/9xUmbnp5OBAIBee2118iGDRvI5MmTiVAoJOPGjbPJzj179hCBQEAePHjg0HG6gvT0dAKA/Oc//7Ern0eKR2FhYU2bUGNYEg8+4Cni8eDBAyIWi8nEiRPZMKPRSF5++WXSoEEDotfrrebfuXMnAUDS0tLYsNzcXOLv708GDRrESduiRQvy4osvEp1Ox4Z98sknRCAQkBs3blRpa+/evUmXLl1sPTS3oNVqSUBAAJkzZ45d+dwuHg8ePCAjR44k4eHhRCKRkOjoaDJu3DhSVlZGCCFk06ZNBAA5fvw4GT9+PAkODib+/v5s/jVr1pAWLVoQiURCwsPDyYQJE4hKpeLs46+//iL9+vUjoaGhRCqVkvr165OBAweS/Px8Ns1vv/1GOnfuTJRKJZHL5aRZs2Zk1qxZVdpvS77S0lIyd+5c0rhxYyKRSEiDBg3IRx99REpLS03K27JlC4mPjyfe3t7E39+fvPzyy+TXX38lhBASFRVFAHA2RkiOHTtGAJBjx45xytu1axd56aWXiEwmI4GBgWTw4MEmb7Hhw4cTuVxOHjx4QPr06UPkcjkJCgoi//jHP6p8kAghZO/evaRnz57sNWzUqBFZsGABJ29SUpKJ7daEZPjw4SbpmW3evHlV2mSNNWvWEADkzz//5IRv27aNACCnTp2ymr9///4kNDTUpJY3ZswY4uPjw17XP//8kwAga9as4aR7+PAhAUA+++wzq/spKSkhEomEfPrpp5zwrKwsAoBs2rTJJE/l8zNv3jwCgNy6dYsMHjyYKBQKEhQURGbPnk2MRiO5f/8+6d27N/Hz8yOhoaFk2bJlZm158803SZs2bazaWxmRg00lm3j06BE6dOjAth9jY2Px8OFD/PzzzyguLoZEImHTTpgwAcHBwZg7dy6KiooAAJ9++inmz5+P5ORkjB8/Hrdu3cK6detw6dIlnDlzBmKxGFqtFikpKSgrK8PkyZMRFhaGhw8fYv/+/cjPz4dSqcSff/6JN954A23atMGCBQsglUrxn//8B2fOnLFqvy35jEYjevfujdOnT2PMmDFo3rw5/vjjD6xYsQJ//fUX9u7dy6adP38+Pv30U3Tq1AkLFiyARCLBhQsXcPToUXTv3h0rV65k276ffPIJACA0NNSifZs3b8a7776L+Ph4LF68GE+ePMHXX3+NM2fO4Nq1a/D392fTGgwGpKSkICEhAcuWLcORI0fw1VdfoXHjxhg/frzV87B582b4+vpi2rRp8PX1xdGjRzF37lxoNBosXboUAPDJJ59ArVbjwYMHWLFiBQBYbcOPHTsWycnJnLBDhw5h69atCAkJYcPy8vKs2sbg5+cHqVQKALh27RrkcjmaN2/OSdOhQwc2vkuXLhbLunbtGl566SUIhdwuwQ4dOmDDhg3466+/0Lp1a1y7dg0A0L59e066iIgINGjQgI23xJUrV6DVavHSSy/ZdIzWGDhwIJo3b44vvvgCBw4cwMKFC1GvXj18++236Nq1K7788kts3boVH374IeLj4/HKK69w8rdr1w779u2DRqOBQqGwbad2SY2dDBs2jAiFQnLp0iWTOKPRSAj5b82jS5cunDdZbm4ukUgkpHv37pw3wOrVqwkAsnHjRkIIIdeuXTOpYlZmxYoVBAB5+vSpXfbbkm/Lli1EKBSavM3Wr19PAJAzZ84QQgi5ffs2EQqF5M033zR5ozHnghDLzZbKNQ+tVktCQkJIq1atSElJCZtu//79BACZO3cuG8a85RcsWMAps23btqRdu3bWTwIhpLi42CRs7NixnLcwIc41W27fvk2USiX5n//5H859AAu1k8pbxbd0amoqadSokck+ioqKCAAyc+ZMq7bI5XIycuRIk/ADBw4QAOTQoUOEEEKWLl1KAJD79++bpI2PjycdO3a0up/vvvuOACB//PEHJ9yRmseYMWPYML1eTxo0aEAEAgH54osv2HCVSkW8vb3J8OHDTcplamUXLlywanNF3Pa1xWg0Yu/evejVq5eJMgOAQCDg/B49ejS8vLzY30eOHIFWq8WUKVM4b4DRo0dDoVDgwIEDAAClUgkA+PXXX1FcXGzWFuYNvG/fPhiNRpuPwZZ8aWlpaN68OWJjY5GXl8duXbt2BQAcO3YMALB3714YjUbMnTvX5I1W+VzYwuXLl5Gbm4sJEyZAJpOx4ampqYiNjWXPT0XGjRvH+f3yyy/j7t27Ve7L29ub/b+goAB5eXl4+eWXUVxcjJs3b9pte2WKiorw5ptvIiAgANu3b+fcB4cPH7ZpS0lJYfOUlJSwtZCKMOeppKTEqj225mf+Wkpb1X6ePXsGAAgICLCazhbee+899n8vLy+0b98ehBCMGjWKDff398cLL7xg9pozNtha0wMAtzVbnj59Co1Gg1atWtmUPiYmhvM7OzsbAPDCCy9wwiUSCRo1asTGx8TEYNq0aVi+fDm2bt2Kl19+Gb1798aQIUNYYRk4cCC+++47vPfee5g5cya6deuGfv364e233zZ5kCtiS77bt2/jxo0bCA4ONltGbm4uAODOnTsQCoVo0aKFTeejKiydHwCIjY3F6dOnOWEymczExoCAAKhUqir39eeff2L27Nk4evQoNBoNJ06tVttrugmjR4/GnTt3cPbsWQQGBnLiKjdtbMHb2xtlZWUm4aWlpWy8K/Izfy2lrWo/DMQFzvwiIyM5v5VKJWQyGYKCgkzCGdEyZ4M9LzK39nnYg60n2hxfffUVRowYgX379uG3337D+++/j8WLF+P8+fNo0KABvL29cfLkSRw7dgwHDhzAoUOHsHPnTnTt2hW//fYb501X2aaq8hmNRrRu3RrLly83W0bDhg0dPi5XYukYqyI/Px9JSUlQKBRYsGABGjduDJlMhqtXr2LGjBl21eTM8fXXX2P79u346aefEBcXZxKfk5NjUzlKpZK9h8LDw3Hs2DEQQjgPw+PHjwGU90lYIzw8nE1bkcr5w8PD2fDK1/nx48dsH4slGKFUqVRo0KCB1bSAdZExd30tXXNz5TAvkcpiYw23NVuCg4OhUCgcGrkGAFFRUQCAW7duccK1Wi2ysrLYeIbWrVtj9uzZOHnyJE6dOoWHDx9i/fr1bLxQKES3bt2wfPlyZGZm4vPPP8fRo0fZZoUlqsrXuHFjPH/+HN26dUNycrLJxtQMGjduDKPRiMzMTKv7s1X5LZ0fJqzy+XGU48eP49mzZ9i8eTM++OADvPHGG0hOTjZb1ba3+XXq1Cl8+OGHmDJlCgYPHmw2TXh4uE3bzp072TxxcXEoLi7GjRs3OGVduHCBjbdGXFwcrl69aiKMFy5cgI+PD5o1a8Yp5/Lly5x0jx49woMHD6rcT2xsLAAgKyvLbHxBQQHn95MnT6yW5wxZWVkQCoXssdmC28RDKBSib9+++Ne//mVycoGqq2rJycmQSCRYtWoVJ+33338PtVqN1NRUAIBGozEZzde6dWsIhUK2Ovn8+XOT8pkLa67KyWBLvgEDBuDhw4f4v//7P5O0JSUl7Jejvn37QigUYsGCBSY3ZcXjk8vlyM/Pt2gTQ/v27RESEoL169dzjuHgwYO4ceMGe36chXl7VbRRq9Vi7dq1JmnlcrnNzZjHjx9jwIAB6NKlC/vFxhyO9Hn06dMHYrGYYyMhBOvXr0f9+vXRqVMnjh03b96ETqdjw95++208efIEu3fvZsPy8vKQlpaGXr16sX0cLVu2RGxsLDZs2ACDwcCmXbduHQQCAd5++22r56Bdu3aQSCRmnw8AJi+2PXv2sMfiaq5cuYKWLVuyTX1bcGuzZdGiRfjtt9+QlJTEfsZ8/Pgx0tLScPr0ac6nxMoEBwdj1qxZmD9/Pnr06IHevXvj1q1bWLt2LeLj4zFkyBAAwNGjRzFp0iT0798fzZo1g16vx5YtW+Dl5YW33noLALBgwQKcPHkSqampiIqKQm5uLtauXYsGDRpY/WRnS76hQ4di165dGDduHI4dO4bOnTvDYDDg5s2b2LVrF3799Ve0b98eTZo0wSeffILPPvsML7/8Mvr16wepVIpLly4hIiICixcvBlB+Q61btw4LFy5EkyZNEBISwna+VkQsFuPLL7/Eu+++i6SkJAwaNIj9VBsdHY2pU6c6etk4dOrUCQEBARg+fDjef/99CAQCbNmyxewN3K5dO+zcuRPTpk1DfHw8fH190atXL7Plvv/++3j69CmmT5+OHTt2cOLatGmDNm3aAHCsz6NBgwaYMmUKli5dCp1Oh/j4eOzduxenTp3C1q1bOdX5WbNm4YcffkBWVhaio6MBlItHx44d8e677yIzMxNBQUFYu3YtDAYD5s+fz9nX0qVL0bt3b3Tv3h3vvPMOrl+/jtWrV+O9994z+VRcGZlMhu7du+PIkSNYsGCBSfyhQ4cwePBgvPLKK/jrr7+wYcMG+Pj44LfffkN8fDzeeOMNu8+NOXQ6HU6cOIEJEybYl9Hm7zIOkp2dTYYNG0aCg4OJVColjRo1IhMnTjQZJGbucy4h5Z9mY2NjiVgsJqGhoWT8+PGcQWJ3794lI0eOJI0bNyYymYzUq1ePvPbaa+TIkSNsmoyMDNKnTx8SERFBJBIJiYiIIIMGDTIZalwZW/NptVry5ZdfkpYtWxKpVEoCAgJIu3btyPz584lareak3bhxI2nbti2bLikpiRw+fJiNz8nJIampqcTPz8+mQWI7d+5ky6tXr57VQWKVYT7zVcWZM2dIx44dibe3N4mIiCDTp08nv/76q4k9hYWF5H//93+Jv79/lYPEzA0qYzZnB4kRUj7EfNGiRSQqKopIJBLSsmVL8tNPP5mkYz5jZ2VlccKfP39ORo0aRQIDA4mPjw9JSkqyeI/u2bOHxMXFEalUSho0aEBmz55NtFqtTXbu3r2bCAQCzude5lPtokWLSHJyMpFKpSQmJob8/PPP5OOPPyY+Pj5k/vz5hJD/XsPKwwksXfOkpCTSsmVLTtjBgwcJAHL79m2bbGYQEELXbaFQagqDwYAWLVpgwIAB+OyzzwAA9+7dQ0xMDDZt2oQRI0a43Ya+fftCIBCwzSJbobNqKZQaxMvLCwsWLMCaNWtqZEr+jRs3sH//fla47IGKB4VSwwwcOBDPnz+vkSn5zZs3h16vt3k8VkWoeFAoFIegfR4UCsUhaM2DQqE4hMcMT/d0jEYjHj16BD8/P4cmslFqH4QQFBQUICIiwuocqdoKFQ8befToEb755huIRKanjBAClUrl8Mg/iUTCGRErlUphNBqh1WqdstkeRCIRRCIR9Ho99Ho9x6bqatkKBALOsVe2qbqofD1kMhnkcrnZ87Bo0SL8/fffNs1NqYy1lxAfehOoeNiIn58fRCIRfHx8TN4yhBBER0c7PPnMaDRCo9GwQ6TFYjEUCkW1v82Ki4vZ4fRCoRC3bt2y+6Gt7GTGXvR6PdRqNTuEXy6Xw8fHx6ky7aXy9RCJRCgrKzO5HoyNfn5+Du2H77UVKh42wrwlhEIhxGIxG240GmE0GiGVSjme0exFLBazvhQCAwPN+ohwNzKZjPO2rcofhTlc8aDrdDp2+nu9evVq5CGreD2YaexCoZBjCyMujjZj+S4e/La+lqDVavHs2TOIxWKIxWI8e/asWpssQLkIPnv2DAKBADKZDKWlpQ6/UZ2hoKAApaWlkMlkEAgEePbsmdPT/u2l8vXIz893iw0CgcDixgeoeNQwWq0WeXl5EIvFCAoKQlBQEPvWqy4BYYRDp9MhKCgIgYGBUCgUUCgU1SogBQUFrA/NwMBABAUFQafTVauAmLseTL9LxZmzroCpyZjb+ABtttgJIYRzIxuNRhBCOFO6bUWn00GlUkEkEkGhULD9CwqFAiqVCrm5uQgICOA0k1wN09mr1+tZHx1arRZSqRRFRUVQKpXw8vJi+0KqwlHBKyoqQmFhIXx9fSGVStlylEol51y4861s6XrI5XIUFBSwNplzU+AIfBEJS1DxsAPmZjEnHmVlZXa9mZgvCkxfSWW/It7e3tBqtSgqKmJ7/10NIQRarRZCoRC+vr4wGAycYzAajayXe6FQaFPnKdNXYQ96vR46nQ5yuRxeXl4mZfj6+kKr1UKj0UAikbhFQKxdD71eD6FQCKPRCJ1OB0KIS64HFY86RH5+PqKiojgOh3U6HcrKytCzZ0+7HKnwgVmzZtmdZ9GiRW6wpGZRq9VIT0+HRCJBYWEhW0tzthlDxaMOYTQaIRKJTL6qGAwGKJVK1KtXr4Yscw+2OEeuTG07BwzMdQ8JCcGzZ8+gVqudnsjGd/Hgt/UUSjUjFAoRGBgIsVjstOd4vneY8sNKD0EikVT7Z0OK58EIiKODAiuWw2fxoM0WOxAKhdBoNGZHmVLqFkKh0PZlGa2UwWf4bX01w3xRqYmBSxTPw9mHn+81D35Y6SEQQqBUKqt94BKldkLFo44hEok4Ix/5MPuR4plQ8XAhixcvRnx8PPz8/BASEoK+ffuaXRGtMmlpaYiNjYVMJkPr1q2Rnp7OiSeEYO7cuQgPD4e3tzeSk5Nx+/Zth+2USCSsgDgzFZ9St6Hi4UJOnDiBiRMn4vz58zh8+DB0Oh26d+9udWj02bNnMWjQIIwaNQrXrl1D37590bdvX84yl0uWLMGqVauwfv16XLhwAXK5HCkpKQ6NhmRgBESv11f7JDZK7YDvE+M86mvLoUOHOL83b96MkJAQXLlyxaKfiK+//ho9evTARx99BAD47LPPcPjwYaxevRrr168HIQQrV67E7Nmz0adPHwDAjz/+iNDQUOzduxfvvPOO2XLLyso4Q5Qrrw4PlAtIQECAzfM+KJSK8KWGYQmPtp4ZhGNt1OK5c+dMliRMSUnBuXPnAJQv4JuTk8NJo1QqkZCQwKYxx+LFi6FUKtnN0mr3YrHYKT8elLoLbba4CaPRiClTpqBz585W15TIyclBaGgoJyw0NBQ5OTlsPBNmKY05Zs2aBbVazW5///23o4dCoZiF7+LhUc2WikycOBHXr1/H6dOna2T/UqnUJm9eOp2O9nlQHIIvImEJj7R+0qRJ2L9/P44dO1alY9mwsDA8efKEE/bkyROEhYWx8UyYpTSOotVqoVKpeNPBRfEs+F7z8CgrCSGYNGkS9uzZg6NHjyImJqbKPImJicjIyOCEHT58GImJiQCAmJgYhIWFcdJoNBpcuHCBTeMIjMcpc7NsKRRb4Lt4eFSzZeLEidi2bRv27dsHPz8/tk9CqVTC29sbADBs2DDUr18fixcvBgB88MEHSEpKwldffYXU1FTs2LEDly9fxoYNGwCUfw6bMmUKFi5ciKZNmyImJgZz5sxBREQE+vbt65CdFV3VKRQKE0c+FIot8EUkLOFR4rFu3ToAwKuvvsoJ37RpE0aMGAEAuH//Puekd+rUCdu2bcPs2bPx8ccfo2nTpti7dy+nk3X69OkoKirCmDFjkJ+fjy5duuDQoUMcpz62otfrkZ+fD7FYjMDAwGpdT4RSu6Di4UJsGal5/Phxk7D+/fujf//+FvMIBAIsWLAACxYscMY8CAQCqNVqyGQyBAYG8v7iU2oWvt8/HiUeno5UKoWXlxcVDgoAOD0xku/3EBUPOzAajTWykhvF82BWlXMGvt9HVDzsgPE0TqnbMOvcOOsAme+f+Kl4UCh2UHGBLGe95fP9RUTFg0KxEUIIZ2U9Z7+0UfGg1FqYr1+2VK9ru08TZmU9o9GIoKAgSCSSOi8e/Lae4la+/fZbm9vlAoEA3377rZstqjm0Wi30ej0rHK6A7yNM+WElpUYYN26cW9PzCUIIAgICXDoVge/iQZstFIoNSCQSly84zheRsAQVD4pFxGIxdDqdXelrK+540PkuHvy2nuJWtFotCCEICgqymi4oKAiEkFrt18QdHcK02UKp9eTl5TkVXxvQarUOTaS0Bl9EwhL8tp7idubMmePSdHyl4qdaV8H3mgc/rKTUCFOnTsXChQttSrtw4UJMnTrVzRbVHMy4DleuFEjFg1Lr2LFjBwQCAVauXGlXvpUrV0IgEGDHjh3uMawGEQqFCAgIcOlSo1Q8KLWCnj17QiKRQCAQYNCgQU6VNWjQIAgEAkgkEvTs2dNFFtY8YrGYs9SoswJCF32i8B5LN2u/fv2gVqtNfMSao1u3blAqldi9ezcbptPpcPDgQQgEglozfJ1ZKTAvL8+uz9jm4EsNwxJUPOxAJKp9p8uScOTm5iI4OBgAkJ+fj4CAAItlqFQq+Pv7AwCePn2KkJAQs/upbQJS2SO/vfBdPPhtfTUjEolQXFxc02a4jMrC0a1bNxBCQAhhhQMA/P39LT74hBBWOAAgODiYLaNbt26ctE+fPnWd8TWMRCJxyZR82udRR9Dr9SgqKkJBQUFNm+JSli9fDkIIjhw5AqBcEIxGI7KyslBSUgIASE1NNZuXCS8pKUFWVhaMRiMrNEeOHAEhBMuXLwcAvPbaa+4+lGrF2Zoo38Wj9tXD3Yher4dcLmfdz/n5+dWwRc5hMBhMbtSQkBC7agjp6elmmz7BwcHIzc0FUP7Jd+rUqU73EdQ2+CISlrBbPLKysnDq1ClkZ2ejuLgYwcHBaNu2LRITE10+As8T8fHxgVQqZQXEliUpPZXKN69QKHRZv8TTp08hFAo5XyRq89wXR6gz4rF161Z8/fXXuHz5MkJDQxEREQFvb288f/4cd+7cgUwmw+DBgzFjxgxERUW50+Yah6lxaDQa+Pj4wMvLq4Ytch53fB4khNSqjlJXw3fxsMn6tm3bYtWqVRgxYgSys7Px+PFjXLlyBadPn0ZmZiY0Gg327dsHo9GI9u3bIy0tzd121zh+fn5QKBQoLCzk9cJPubm5ZoUjMjISFy9etKusixcvIjIy0iRcIBCwTRjKf+F7n4dNVn7xxRe4cOECJkyYgIYNG5rES6VSvPrqq1i/fj1u3ryJRo0audxQT8TPzw++vr68bcuHhoYiNDTUbFz37t0RHx9vV3nx8fHo3r27xX0VFhbabWNtpk6IR0pKis0FBgYGol27dg4bxDfkcjkv2/JV1QZOnjzpULnW8vn5+bFrDFP4Lx4Of23Jzc1Fbm6uyRDdNm3aOG0U3+Bbn4e1/o3K/RMGg8Gm42PWMLl165bV/Xz88cfo2rUrEhISbDW31sIXkbCE3dZfuXIFrVq1Qnh4ONq0aYO4uDi0bduW/VvX8FQnOMwcicq1RkvC8frrr7PCUVBQwOa3VRi9vLzYPMw4GEIIXn/9dZO0HTt2xJdffskJS0lJ4dW8DlfA97ktdovHyJEj0axZM5w9exZ3795FVlYW529dwmg0QqVSedzXhIo336+//lpl+tdffx3p6elsXoVC4dT+FQoFa0N6erpZAZk5cybnd0U7+fLwOEuda7bcvXsX//znP9GkSRN32MMbmJXD9Ho9fH19a9ocFmsPnrm4Tp06cYTD1bYQQpCeno7OnTvj7NmzZuOt5a3N8EUkLGG39d26dcPvv//uDlt4Q8UlBwMCAjz2Jqi4lqo5YVi3bh3OnDljMd4VMOUy+7EUD8DptV/5Rp2reXz33XcYPnw4rl+/jlatWpl8aejdu7fLjPNEKgoH4xjYU276/Px8zm/mJjQ3I7Zic8LdzQSmFsEMGqtMQEAAVCqVyUOTn5/PmXRX2+CLSFjCbvE4d+4czpw5g4MHD5rECQQCj3mQ3AUzLJ1ZOcyTOksrisShQ4cAAImJiSaiAoAVjuoak9OoUSPcvXvXbHMkPz8fiYmJOHfuHA4dOoQePXoAKD+e2tx04bt42G395MmTMWTIEDx+/BhGo5Gz1XbhkEgkMBgMLl1y0F0wX1nOnz9vNV1WVlZ1mMPuZ/DgwWbjGTvtGVPEd/jebLHbymfPnmHq1KkWRybWZoRCIZRKZY0Jx/Xr15GZmYldu3aZxNWvX5/9Pzs722IZTPMBADZu3Oh6I6tgy5YtHBvMUdH+isfFsGvXLmRmZuL69etusdFWnPXtwnfxsLvZ0q9fPxw7dgyNGzd2hz0eTVlZGc6ePcsZji4Wi+Ht7Y1Zs2ZBpVK5Zb/Mg9a6dWs2bMCAAez/K1aswKNHj9jf5uaXMAQHB2P69On46KOPMGbMGDdYWzVCoRCdOnWyGF/R/orHBZS7RRg4cCD7mzk37uy3CQgIwIABA1BSUsJeez8/P5c4A+IzdotHs2bNMGvWLJw+fRqtW7c26TB9//33XWacp1GT7W9zM5Vv3ryJ5s2bm4RnZ2ez6SsvGZmXl4fp06dj+vTp7jPWAhUf8MpfXyreR5VrTgKBAEKhEAaDwcQ7WVRUlNWaljuoOCnSGeqceHz33Xfw9fXFiRMncOLECU6cQCCo1eJRU5h7q1p700ZHR7NCx5dJexXtjI6ONok3Go1mj/n+/fvVOqiMEQ6NRoPS0lKnyuK7eNhtfVZWlsXNVSNM16xZg+joaMhkMiQkJFQ5NTwtLQ2xsbGQyWRo3bo1O+iJgRCCuXPnIjw8HN7e3khOTsbt27ddYqunYs/Qck+BGeLuqcjlclY4XOGKku99Hi6z8vHjx1iyZInT5ezcuRPTpk3DvHnzcPXqVbz44otISUmxOAP07NmzGDRoEEaNGoVr166hb9++6Nu3L6czbcmSJVi1ahXWr1+PCxcuQC6XIyUlxek3h6fjyqURqwNPtlckEsHX19dlwgHwXzwExM6G/MiRI82GZ2dn4+LFi06f2ISEBMTHx2P16tUAym+ohg0bYvLkySbzIQBg4MCBKCoqwv79+9mwjh07Ii4uDuvXrwchBBEREfjHP/6BDz/8EACgVqsRGhqKzZs345133jFrR1lZGcrKytjfGo0GCxcu5HSaAf/tMN21a5fbOkwpNUtAQACGDRsGrVbLGTMjFovx448/Qq1WOzQfaN68eRbj5s+f74ip1YrdEqdSqThbXl4eLl68iOPHj2PZsmVOGaPVanHlyhUkJyf/10ChEMnJyTh37pzZPOfOneOkB8rHCjDps7KykJOTw0mjVCqRkJBgsUwAWLx4MZRKJbuZc4JEqTswnvNdCd9rHnZ3mO7Zs8ds+Oeff469e/di7NixDhuTl5cHg8FgMoYkNDQUN2/eNJsnJyfHbPqcnBw2ngmzlMYcs2bNwrRp09jfTM2DUjdxh6tJvoiEJVxm/aBBg3D8+HFXFVfjSKVSKBQKzsY3+HZz8s1eZ+F7zcNlVv7+++9OOwMKCgqCl5eXyTJ+T548QVhYmNk8YWFhVtMzf+0pszZACOHddAGDweCxc1ncsdQo38XD7jNSsSrP8OTJE+zbtw+pqamceGalMFuRSCRo164dMjIy0LdvXwDlHaYZGRmYNGmS2TyJiYnIyMjAlClT2LDDhw8jMTERABATE4OwsDBkZGQgLi4OQHkT5MKFCxg/frxd9tUUhBBERUXh/v37nDBLg8Tu3bvH/l95kJinUnGQ2L1790zGejCDxJKSkjh+UiMjI5Gdne32T7wikQhyudzsJENH4YtIWMJu8bh27ZrZ8Pj4eNavKeD4cOFp06Zh+PDhaN++PTp06ICVK1eiqKgI7777LgBg2LBhqF+/PutI94MPPkBSUhK++uorpKamYseOHbh8+TI2bNjA2jFlyhQsXLgQTZs2RUxMDObMmYOIiAhWoPiAuQckNjYWhBCsWLGCI9oVR6NWFo6goCB2eLpIJKrW2glTq2CGp1ccZVrRzsqjaSvWRjIyMqyORnUXjNMng8Hg0k+1fMZu8Th27Jg77GAZOHAgnj59irlz5yInJwdxcXE4dOgQ2+F5//59zknv1KkTtm3bhtmzZ+Pjjz9G06ZNsXfvXrRq1YpNM336dBQVFWHMmDHIz89Hly5dcOjQIYdWuHvllVfg4+PD/tZqtSgtLcWiRYtQr149J468av744w8IhUKTCWFTp07FsmXL2Hkg9+/ftzi/peJSkhs2bMCoUaPcZ7AFmPEcll4wFWtYERERnDiRSISdO3eiVatWnHEh7mzuPH/+HGlpaTAYDCguLoZCoYCfnx+Ki4vx448/Olwu38XD7nEedRWNRoPp06cjPj7erHj079/f7eJRFRUfxqomjFXHhDJz+xw6dCh++uknm23yhNuTEQ+ZTIaysjJoNBooFAp4eXnhvffec3icx4oVKyzGTZ061RmTqwWbpK9Hjx5V+oUAyr1uf/nll1izZo3ThlGcg3Eo3LFjR6vpYmJiqsMcdj9bt241G8/YaYvD5pqk4twWOiXfBvr374+33noLSqUSvXr1Qvv27REREQGZTAaVSoXMzEycPn0a6enpSE1NxdKlS91td43gyfMugPIBfIw3sR49eoAQgnPnziEgIMCko+/gwYN4/fXXWe9e7oaZ92SuJuHv788O2GO8iAHw2BG7zFrFz58/d6ocvoiEJWwSj1GjRmHIkCFIS0vDzp07sWHDBqjVagDlD1SLFi2QkpKCS5cume39ry1IpVKPXpe2sr9Po9EIoVAIlUplIhA9e/bEunXrMG7cOIu+RV1FVU0kRiQqz23xZP+lfn5+nOkLjlAnxAMof3CGDBmCIUOGACifH1JSUoLAwEBeLrfoCEajEWq1GjKZzOPdEALls1SZB9ecQIwfPx5btmzBmTNn3CYgzP47d+5sNZ6xl09U7PtyBE+vyVaFw9KnVCoRFhZWZ4QDKO8c9fLyQl5enkc5Pq6ItQ5Gc3Fnz55Fz549q8zrjC09e/Y0WbOlqv15Qkepu+F7nwc/rPQgFAoFxGIxbwTEFofCBw8e5AgI4yHeUTQaDUc4zHna/+KLLzi/K9pZF4QDoOJR5xAKhWxTLS8vz2NHbxJCsG7dOhNvb5YGOB08eJAdcOXn58c6KTb34FvKz+RhOhSzs7Mt5p8xYwbn94kTJ7Bu3bo6IxwAFY86SUUBUalUHuvEZty4cSYOj3x9fbFo0SKz6aOjoyEQCDht+R07dti0r4rpfHx8IBAIzLoTBMzXLEpLSzFu3Dib9lVboOJRR2EERCQSeWzzxRKzZs2yOm6npKSE7cz74YcfbCqTSScQCFBSUmIxXV2qWVRFnROP4cOHcyYm1WWEQiECAgJ42WuekJAAQojJbGOGyMhIXLp0ya4yL126ZHFY/JMnT6hwVKLOiYdarUZycjKaNm2KRYsW4eHDh+6wizcIBAJefLa1REhIiNmH+v79++jQoYNdZXXo0IEzL4WBEIKQkBCHbayt1Dnx2Lt3Lx4+fIjx48dj586diI6Oxuuvv46ff/7ZYzsP3Q3f/GaYwx3jPMytS0v5L3VOPIDyVcemTZuG33//HRcuXECTJk0wdOhQREREYOrUqbV+WYOKFBUV8VY0K3f0Go1GBAcHu6Ts4OBgk/L5ep7cRZ0UD4bHjx/j8OHDOHz4MLy8vNCzZ0/88ccfaNGihdUZg7WFgoICFBYW8nagHLNOSsVrlZubyy5afvfuXRQXF4MQwo4DqUzPnj1BCEFxcTHu3r0Lg8EAo9HIWSpjxYoVEAgETnuaq23UOfHQ6XT45z//iTfeeANRUVFIS0vDlClT8OjRI/zwww84cuQIdu3ahQULFrjDXo+hoKAAGo0Gvr6+bnFRV51MmzYNAoGA9TDPLO8YExMDb29vAMCBAwfM5mXCvb29ERMTA6FQyDZ/kpOTIRAIWEdF7vYFwzf4Lh523/Xh4eEwGo0YNGgQLl68yLr2q8hrr73m0ZOanIURDoVCAalUytvFoyr3c2RkZLC/c3Nz2SZMfn4+O1u3MgKBACqVir3eT58+tdg56qomUW2BLyJhCbvFY8WKFejfv79VL1z+/v7IyspyyjBPpbi4GGVlZaw3Kb6N8aiMpY7SkJAQ9OvXD2q1GhkZGVbLCAgIQLdu3aBUKrF7926L+6Fw4eMn/orYLR5Dhw51hx28QCQSoaioCPXq1WOHYNcGmD6NI0eOcDo1LQmBOcwJjFgsRnJyssnawZRy+F7z4Lf11QzjQbs2CQdDeno6tFotCCHYvn27U2Vt374dhBBotdpaLRzO+nbhe58HP6z0EPR6vdM+HPjAO++8A0IIZzkLW5gyZQoIIRbX/61NaLVa1iGWo1DxqEN4shcxd7BixQqbR89KJJI68XkeKBeOvLw8p50X8V08+P2NkeJ2SkpKbHpIrE2Gq00wwiEWi9nP2I7CF5GwBL+tp7gdoVCIxo0bW03TuHFj3j8ItqDT6VjhCAwMdPqYac2DUmuRSCQ2DSm/c+cOBAIBxGIx7z9dW8JoNEKj0UAqlbpEOAD+1zyoeFAsYu9clNo8d0Wr1UIkErlMOAAqHhRKnUAgECAgIMClDzzfxYPf1lPcyvr1692ank9IJBKXjwilfR6UWsvYsWMxduxYmx6a2j783B1DyfkiEpbgt/WUaqFdu3ZOxdcG3OHkWiAQWNz4AK15UCxi60185coVNm1trYFotVqIxWKXupzke82DigeFYgOM6wFXCgjfxYPf1lMo1YREIoFIJHLpSoF87zDlh5UUSg3DfKp15VKjVDwolDqCQCDgLDVKp+RTKBSbYVYKFIvFdEp+TRvAJyQSiceuS0upPhgBoVPyKTYjFAqh0Wjg4+PDmwtMcQ9CoRAKhcLpMviMx1iv0+kwY8YMtG7dGnK5HBERERg2bBgePXpUZd41a9YgOjoaMpkMCQkJuHjxIie+tLQUEydORGBgIHx9ffHWW29ZXKPVGmVlZTAYDHj27BmtgVDq/JR8j7GyuLgYV69exZw5c3D16lXs3r0bt27dQu/eva3m27lzJ6ZNm4Z58+bh6tWrePHFF5GSksJZdGjq1Kn417/+hbS0NJw4cQKPHj1Cv3797LaREAKlUgmdTkcFhOI0fBcPj2m2KJVKHD58mBO2evVqdvFkS6uvL1++HKNHj8a7774LoHxy1oEDB7Bx40bMnDkTarUa33//PbZt24auXbsCADZt2oTmzZvj/Pnz6Nixo112ikQiBAUFIS8vD8+ePXO66kqpu/BFJCzh0dar1WoIBAKLC0hptVpcuXKFXekMKL8gycnJOHfuHIDyodM6nY6TJjY2FpGRkWwac5SVlUGj0XA2BolEgqCgIOh0OqhUqlo7JJviXvhe8/BYK0tLSzFjxgwMGjTI4ts9Ly8PBoMBoaGhnPDQ0FDk5OQAAHJyciCRSEwEqGIacyxevBhKpZLdGjZsyIlnBESv19da71kU98L3iXE1Jh5bt26Fr68vu506dYqN0+l0GDBgAAghWLduXY3YN2vWLKjVanb7+++/TdJIJBIEBATQmgfFIfhe86ixPo/evXsjISGB/V2/fn0A/xWO7OxsHD161GqfQlBQELy8vEy+nDx58gRhYWEAgLCwMGi1WuTn53NqHxXTmEMqlUIqlVZ5HK6eaUmpO/BFJCxRY9b7+fmhSZMm7Obt7c0Kx+3bt3HkyBEEBgZaLUMikaBdu3acpQ6NRiMyMjKQmJgIoNzXhFgs5qS5desW7t+/z6ahUGoCWvNwETqdDm+//TauXr2K/fv3w2AwsH0S9erVY9/u3bp1w5tvvolJkyYBAKZNm4bhw4ejffv26NChA1auXImioiL264tSqcSoUaMwbdo01KtXDwqFApMnT0ZiYqLdX1os2U37PCiOwBeRsITHiMfDhw/xyy+/AADi4uI4cceOHcOrr74KoNzNf15eHhs3cOBAPH36FHPnzkVOTg7i4uJw6NAhTifqihUrIBQK8dZbb6GsrAwpKSlYu3at0zZrtVqoVCqbmjcUSmWoeLiI6Ohomzoe7927ZxI2adIktiZiDplMhjVr1mDNmjXOmMiBWTlMJBLRPg+KQ1DxqINUXHJQoVCgrKyspk2i8BAqHnUMvV6P/Px8dsnBurb4NcV1UPGoQwgEAqjVashkMpeuHEapm/D9/qHiYQdSqRReXl5UOCgAnF+Oge/3EBUPOyCEwMfHh9NU0el00Ov1TnuV8kQCAgLszvP8+XM3WFKzqNVq6PV6zlq8hBDk5+c7VS4VjzqEXC6HSqXiCIXRaAQhBOnp6RCJrJ9Oo9EIrVYLgUBg1/KFhBBotVoQQiCRSJy66ewpa8CAAZzfIpEIIpEIer3eYl9PWlqaTXYwD6NYLK7yvFXE0XPoTFlMP5dAIIBQKAQhBHq93umaB1/msFiCiocdMBe78gNHCIFUKoVYLK6yDLFYDJVKBYPBgICAgCpvIEIIVCoV9Ho9673bWWQyGVQqFQoLC62WWVJSwv4vl8vh4+ODwsJCFBUVWS3bVoqKilBYWAhfX1/I5fIq0+t0Omg0GohEIpvOnS3Ycj10Oh2EQiEbp9PpQAhxiRtCPkPFw06Yt09FjEajzXNcJBIJ631bo9FY7T8xGo2s06GQkBCXjicJCQnBs2fPoFarERQUZLZsppru5+cHuVwOtVqNgoICq+XaYyOzFgojCH5+fhbTarVaqNVqSKVSl/Y52Xo9mNmuzGhiqVTq9IRIvosHv63nKRX9gVjySMYIh06ns/hwO0NFL+DW1iHx8/ODQqGARqOpUjgcwZbyK46rcUdnta3Xo6ysjG3u2dPUsgTf57bww8paiLUb1t3CwVCVgLhbOGzZj7uFg6Gq62EwGFwqHAD/xYM2W2yEqaIajUaTXneg3POYIwPGfH19oVarkZOTw7of0Gg0MBgMUCqVVjsnXQUzo/nJkydQKpUQiUQoLi6GUqlEYWEhSktLbe5rKS4udsgGLy8vSKVSPH/+HGVlZexXLbVaDS8vL3h7e6O0tNShsu3B3PVQq9UwGo3w8vICIYS9/ozAONp84YtIWEJAqCcbm3jw4IGJNzEKBQD+/vtvNGjQoKbNqHaoeNiI0WjEo0eP4Ofn51Qvv0ajQcOGDfH333/z0nky3+0HXHcMhBAUFBQgIiKC97UIR6DNFhsRCoUufbsoFArePnwA/+0HXHMMSqXSRdbwj7onlxQKxSVQ8aBQKA5BxaOakUqlmDdvHm+9j/HdfqB2HIMnQDtMKRSKQ9CaB4VCcQgqHhQKxSGoeFAoFIeg4kGhUByCioeT6HQ6zJgxA61bt4ZcLkdERASGDRuGR48eVZl3zZo1iI6OhkwmQ0JCAi5evMiJLy0txcSJExEYGAhfX1+89dZbJktruoKq7KhMWloaYmNjIZPJ0Lp1a6Snp3PiCSGYO3cuwsPD4e3tjeTkZNy+fdvldgPlC5LHx8fDz88PISEh6Nu3L27dulVlPk86Bt5CKE6Rn59PkpOTyc6dO8nNmzfJuXPnSIcOHUi7du2s5tuxYweRSCRk48aN5M8//ySjR48m/v7+5MmTJ2yacePGkYYNG5KMjAxy+fJl0rFjR9KpUyeX2m+LHRU5c+YM8fLyIkuWLCGZmZlk9uzZRCwWkz/++INN88UXXxClUkn27t1Lfv/9d9K7d28SExNDSkpKXGo7IYSkpKSQTZs2kevXr5N///vfpGfPniQyMpIUFhZazONpx8BXqHi4gYsXLxIAJDs722KaDh06kIkTJ7K/DQYDiYiIIIsXLyaElIuSWCwmaWlpbJobN24QAOTcuXMus7UqOyozYMAAkpqayglLSEggY8eOJYQQYjQaSVhYGFm6dCkbn5+fT6RSKdm+fbvL7LZEbm4uAUBOnDhhMY2nHwNfoM0WN6BWqyEQCODv7282XqvV4sqVK0hOTmbDhEIhkpOTce7cOQDAlStXoNPpOGliY2MRGRnJpnEWW+yozLlz5zjpASAlJYVNn5WVhZycHE4apVKJhIQEl9ltDca/bL169Sym8fRj4AtUPFxMaWkpZsyYgUGDBlmcdJWXlweDwcBZTxcAQkND2cW9c3JyIJFITASoYhpnscWOyuTk5FRpNxPmLrstYTQaMWXKFHTu3BmtWrWymM6Tj4FPUPGwk61bt8LX15fdTp06xcbpdDoMGDAAhBCsW7euBq2sm0ycOBHXr1/Hjh07atqUOgGdkm8nvXv3RkJCAvu7fv36AP4rHNnZ2Th69KjVqd5BQUHw8vIy+XLy5MkThIWFAQDCwsKg1WqRn5/PqX1UTOMstthRmbCwsCrtZsLCw8M5aeLi4lxitzkmTZqE/fv34+TJk1W6TvDUY+AbtOZhJ35+fmjSpAm7MS78BgwYgNu3b+PIkSMIDAy0WoZEIkG7du2QkZHBhhmNRmRkZCAxMREA0K5dO4jFYk6aW7du4f79+2waZ7HFjsokJiZy0gPA4cOH2fQxMTEICwvjpNFoNLhw4YLL7K4IIQSTJk3Cnj17cPToUcTExFSZx9OOgbfUdI8t39FqtaR3796kQYMG5N///jd5/Pgxu5WVlbHpunbtSr755hv2944dO4hUKiWbN28mmZmZZMyYMcTf35/k5OSwacaNG0ciIyPJ0aNHyeXLl0liYiJJTEx0qf1V2TF06FAyc+ZMNv2ZM2eISCQiy5YtIzdu3CDz5s0z+5nT39+f7Nu3j/y///f/SJ8+fdz2mXP8+PFEqVSS48ePc859cXExm8bTj4GvUPFwkqysLALA7Hbs2DE2XVRUFJk3bx4n7zfffEMiIyOJRCIhHTp0IOfPn+fEl5SUkAkTJpCAgADi4+ND3nzzTfL48WOXH4M1O5KSksjw4cM56Xft2kWaNWtGJBIJadmyJTlw4AAn3mg0kjlz5pDQ0FAilUpJt27dyK1bt1xuNyHE4rnftGkTb46Br9Ap+RQKxSFonweFQnEIKh4UCsUhqHhQKBSHoOJBoVAcgooHhUJxCCoeFArFIah4UCgUh6DiQaFQHIKKB8Us33//Pbp37+72/Rw6dAhxcXEwGo1u3xfFtVDxoJhQWlqKOXPmYN68eW7fV48ePSAWi7F161a374viWqh4UEz4+eefoVAo0Llz52rZ34gRI7Bq1apq2RfFdVDxqMU8ffoUYWFhWLRoERt29uxZSCQSkynpFdmxYwd69erFCXv11VcxZcoUTljfvn0xYsQI9nd0dDQWLlyIYcOGwdfXF1FRUfjll1/w9OlT9OnTB76+vmjTpg0uX77MKadXr164fPky7ty54/jBUqodKh61mODgYGzcuBGffvopLl++jIKCAgwdOhSTJk1Ct27dLOY7ffo02rdv79A+V6xYgc6dO+PatWtITU3F0KFDMWzYMAwZMgRXr15F48aNMWzYMFScjxkZGYnQ0FCOVzaK50PFo5bTs2dPjB49GoMHD8a4ceMgl8uxePFii+nz8/OhVqsRERHh8P7Gjh2Lpk2bYu7cudBoNIiPj0f//v3RrFkzzJgxAzdu3DDx5BUREYHs7GyH9kmpGah41AGWLVsGvV6PtLQ0bN26FVKp1GLakpISAIBMJnNoX23atGH/ZxwIt27d2iQsNzeXk8/b2xvFxcUO7ZNSM1DxqAPcuXMHjx49gtFoxL1796ymDQwMhEAggEqlqrJcg8FgEiYWi9n/BQKBxbDKn2afP3+O4ODgKvdJ8RyoeNRytFothgwZgoEDB+Kzzz7De++9Z/LWr4hEIkGLFi2QmZlpEle5qXH37l2X2FhaWoo7d+6gbdu2LimPUj1Q8ajlfPLJJ1Cr1Vi1ahVmzJiBZs2aYeTIkVbzpKSk4PTp0ybh+/btw+7du3Hnzh18/vnnyMzMRHZ2Nh4+fOiUjefPn4dUKqXOhXkGFY9azPHjx7Fy5Ups2bIFCoUCQqEQW7ZswalTp6yuKzNq1Cikp6ezq68xpKamYsmSJWjRogVOnjyJtWvX4uLFi9iyZYtTdm7fvh2DBw+Gj4+PU+VQqhfqw5Rilv79++Oll17CrFmzAJSP84iLi8PKlStdup+8vDy88MILuHz5sk3LJlA8B1rzoJhl6dKl8PX1dft+7t27h7Vr11Lh4CG05kGxCXfVPCj8hYoHhUJxCNpsoVAoDkHFg0KhOAQVDwqF4hBUPCgUikNQ8aBQKA5BxYNCoTgEFQ8KheIQVDwoFIpD/H+VkXcThFT9RAAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\tJ = 9.7691e-01\n", + "\tgrad_norm = 4.4190e-03\n", + "step = 40\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\tJ = 9.7744e-01\n", + "\tgrad_norm = 4.1116e-03\n", + "CPU times: user 46.2 s, sys: 1.73 s, total: 48 s\n", + "Wall time: 13min 6s\n" + ] + } + ], + "source": [ + "%%time\n", + "for i in range(num_steps):\n", + " print(f\"step = {i + 1}\")\n", + "\n", + " sim_i = get_sim(params, metadata)\n", + " _, ax = plt.subplots(figsize=(2, 2))\n", + " sim_i.plot_eps(z=0, ax=ax, monitor_alpha=0.0, source_alpha=0.0)\n", + " plt.axis(\"off\")\n", + " plt.show()\n", + "\n", + " # re-compute gradient and current objective function value\n", + " value, gradient = val_grad_fn(params)\n", + "\n", + " # outputs\n", + " print(f\"\\tJ = {value:.4e}\")\n", + " print(f\"\\tgrad_norm = {np.linalg.norm(gradient):.4e}\")\n", + "\n", + " # compute and apply updates to the parameters using the gradient (-1 sign to maximize)\n", + " updates, opt_state = optimizer.update(-gradient, opt_state, params)\n", + " params[:] = optax.apply_updates(params, updates)\n", + "\n", + " # we need to constrain the values between (0,1)\n", + " np.clip(params, 0, 1, out=params)\n", + "\n", + " # save history\n", + " objective_history.append(value)\n", + " param_history.append(params)" + ] + }, + { + "cell_type": "markdown", + "id": "e068f2a8-0522-49e6-a8e2-c06a0201d702", + "metadata": {}, + "source": [ + "## Analysis\n", + "\n", + "Now is the fun part! We get to take a look at our optimization results.\n", + "\n", + "We first plot the objective function values over the course of optimization, which should show a (more or less) steady increase. Since the curve does not yet level off we could continue the optimization to improve the design even further." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "799483e1-448f-4a20-b4e9-fbbea5955424", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(objective_history)\n", + "plt.xlabel(\"iterations\")\n", + "plt.ylabel(\"objective function\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "1ec30ee7-ccf4-463b-8dbb-43eed33fc3ff", + "metadata": {}, + "source": [ + "Next, we can look at the performance of our optimized device, we first construct it using the final parameter values and then take a look at the design." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "857429ef-e2a5-4b67-8489-b4e22b38b026", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "params_final = param_history[-1]\n", + "sim_final = get_sim(params_final)\n", + "sim_final.plot_eps(z=0)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "2f0f78ae-7e1a-4abc-82bd-107fa69c05e6", + "metadata": {}, + "source": [ + "It seems to exhibit large feature sizes, which is promising! There are some discontinuities with the waveguide, which could be rectified with a more advanced approach but it is beyond the scope of this notebook.\n", + "\n", + "Let's add a multi-frequency mode monitor and a field monitor to inspect the performance." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "9f5416aa-8307-4948-833c-92a4cee6c90e", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
08:23:13 CET Created task 'inv_des_final' with resource_id                      \n",
+       "             'fdve-95ca1eea-3ac1-43dd-b4e7-b839586eaaaf' and task_type 'FDTD'.  \n",
+       "
\n" + ], + "text/plain": [ + "\u001b[2;36m08:23:13 CET\u001b[0m\u001b[2;36m \u001b[0mCreated task \u001b[32m'inv_des_final'\u001b[0m with resource_id \n", + "\u001b[2;36m \u001b[0m\u001b[32m'fdve-95ca1eea-3ac1-43dd-b4e7-b839586eaaaf'\u001b[0m and task_type \u001b[32m'FDTD'\u001b[0m. \n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
             View task using web UI at                                          \n",
+       "             'https://tidy3d.simulation.cloud/workbench?taskId=fdve-95ca1eea-3ac\n",
+       "             1-43dd-b4e7-b839586eaaaf'.                                         \n",
+       "
\n" + ], + "text/plain": [ + "\u001b[2;36m \u001b[0m\u001b[2;36m \u001b[0mView task using web UI at \n", + "\u001b[2;36m \u001b[0m\u001b]8;id=31039;https://tidy3d.simulation.cloud/workbench?taskId=fdve-95ca1eea-3ac1-43dd-b4e7-b839586eaaaf\u001b\\\u001b[32m'https://tidy3d.simulation.cloud/workbench?\u001b[0m\u001b]8;;\u001b\\\u001b]8;id=574400;https://tidy3d.simulation.cloud/workbench?taskId=fdve-95ca1eea-3ac1-43dd-b4e7-b839586eaaaf\u001b\\\u001b[32mtaskId\u001b[0m\u001b]8;;\u001b\\\u001b]8;id=31039;https://tidy3d.simulation.cloud/workbench?taskId=fdve-95ca1eea-3ac1-43dd-b4e7-b839586eaaaf\u001b\\\u001b[32m=\u001b[0m\u001b]8;;\u001b\\\u001b]8;id=522139;https://tidy3d.simulation.cloud/workbench?taskId=fdve-95ca1eea-3ac1-43dd-b4e7-b839586eaaaf\u001b\\\u001b[32mfdve\u001b[0m\u001b]8;;\u001b\\\u001b]8;id=31039;https://tidy3d.simulation.cloud/workbench?taskId=fdve-95ca1eea-3ac1-43dd-b4e7-b839586eaaaf\u001b\\\u001b[32m-95ca1eea-3ac\u001b[0m\u001b]8;;\u001b\\\n", + "\u001b[2;36m \u001b[0m\u001b]8;id=31039;https://tidy3d.simulation.cloud/workbench?taskId=fdve-95ca1eea-3ac1-43dd-b4e7-b839586eaaaf\u001b\\\u001b[32m1-43dd-b4e7-b839586eaaaf'\u001b[0m\u001b]8;;\u001b\\. \n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
             Task folder: 'default'.                                            \n",
+       "
\n" + ], + "text/plain": [ + "\u001b[2;36m \u001b[0m\u001b[2;36m \u001b[0mTask folder: \u001b]8;id=289145;https://tidy3d.simulation.cloud/folders/folder-b09a5d67-f90e-4deb-9d9b-a702c3884aec\u001b\\\u001b[32m'default'\u001b[0m\u001b]8;;\u001b\\. \n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "dcc59aca29a24c2e95d50ee1dcc36fab", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Output()" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
\n"
+      ],
+      "text/plain": []
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "
08:23:16 CET Estimated FlexCredit cost: 0.387. Minimum cost depends on task     \n",
+       "             execution details. Use 'web.real_cost(task_id)' to get the billed  \n",
+       "             FlexCredit cost after a simulation run.                            \n",
+       "
\n" + ], + "text/plain": [ + "\u001b[2;36m08:23:16 CET\u001b[0m\u001b[2;36m \u001b[0mEstimated FlexCredit cost: \u001b[1;36m0.387\u001b[0m. Minimum cost depends on task \n", + "\u001b[2;36m \u001b[0mexecution details. Use \u001b[32m'web.real_cost\u001b[0m\u001b[32m(\u001b[0m\u001b[32mtask_id\u001b[0m\u001b[32m)\u001b[0m\u001b[32m'\u001b[0m to get the billed \n", + "\u001b[2;36m \u001b[0mFlexCredit cost after a simulation run. \n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
08:23:17 CET status = queued                                                    \n",
+       "
\n" + ], + "text/plain": [ + "\u001b[2;36m08:23:17 CET\u001b[0m\u001b[2;36m \u001b[0mstatus = queued \n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
             To cancel the simulation, use 'web.abort(task_id)' or              \n",
+       "             'web.delete(task_id)' or abort/delete the task in the web UI.      \n",
+       "             Terminating the Python script will not stop the job running on the \n",
+       "             cloud.                                                             \n",
+       "
\n" + ], + "text/plain": [ + "\u001b[2;36m \u001b[0m\u001b[2;36m \u001b[0mTo cancel the simulation, use \u001b[32m'web.abort\u001b[0m\u001b[32m(\u001b[0m\u001b[32mtask_id\u001b[0m\u001b[32m)\u001b[0m\u001b[32m'\u001b[0m or \n", + "\u001b[2;36m \u001b[0m\u001b[32m'web.delete\u001b[0m\u001b[32m(\u001b[0m\u001b[32mtask_id\u001b[0m\u001b[32m)\u001b[0m\u001b[32m'\u001b[0m or abort/delete the task in the web UI. \n", + "\u001b[2;36m \u001b[0mTerminating the Python script will not stop the job running on the \n", + "\u001b[2;36m \u001b[0mcloud. \n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "b99de3c8195345129e5e25e55751eaff", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Output()" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
08:23:24 CET status = preprocess                                                \n",
+       "
\n" + ], + "text/plain": [ + "\u001b[2;36m08:23:24 CET\u001b[0m\u001b[2;36m \u001b[0mstatus = preprocess \n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
\n"
+      ],
+      "text/plain": []
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "
08:23:29 CET starting up solver                                                 \n",
+       "
\n" + ], + "text/plain": [ + "\u001b[2;36m08:23:29 CET\u001b[0m\u001b[2;36m \u001b[0mstarting up solver \n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
             running solver                                                     \n",
+       "
\n" + ], + "text/plain": [ + "\u001b[2;36m \u001b[0m\u001b[2;36m \u001b[0mrunning solver \n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "66f91a9a48d94238851a8238368d2fe6", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Output()" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
08:23:37 CET early shutoff detected at 4%, exiting.                             \n",
+       "
\n" + ], + "text/plain": [ + "\u001b[2;36m08:23:37 CET\u001b[0m\u001b[2;36m \u001b[0mearly shutoff detected at \u001b[1;36m4\u001b[0m%, exiting. \n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
\n"
+      ],
+      "text/plain": []
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "
             status = postprocess                                               \n",
+       "
\n" + ], + "text/plain": [ + "\u001b[2;36m \u001b[0m\u001b[2;36m \u001b[0mstatus = postprocess \n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "4d7618d5497344bf97b9a2a3ff257be8", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Output()" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
08:23:38 CET status = success                                                   \n",
+       "
\n" + ], + "text/plain": [ + "\u001b[2;36m08:23:38 CET\u001b[0m\u001b[2;36m \u001b[0mstatus = success \n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
\n"
+      ],
+      "text/plain": []
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "
08:23:40 CET View simulation result at                                          \n",
+       "             'https://tidy3d.simulation.cloud/workbench?taskId=fdve-95ca1eea-3ac\n",
+       "             1-43dd-b4e7-b839586eaaaf'.                                         \n",
+       "
\n" + ], + "text/plain": [ + "\u001b[2;36m08:23:40 CET\u001b[0m\u001b[2;36m \u001b[0mView simulation result at \n", + "\u001b[2;36m \u001b[0m\u001b]8;id=305773;https://tidy3d.simulation.cloud/workbench?taskId=fdve-95ca1eea-3ac1-43dd-b4e7-b839586eaaaf\u001b\\\u001b[4;34m'https://tidy3d.simulation.cloud/workbench?\u001b[0m\u001b]8;;\u001b\\\u001b]8;id=458872;https://tidy3d.simulation.cloud/workbench?taskId=fdve-95ca1eea-3ac1-43dd-b4e7-b839586eaaaf\u001b\\\u001b[4;34mtaskId\u001b[0m\u001b]8;;\u001b\\\u001b]8;id=305773;https://tidy3d.simulation.cloud/workbench?taskId=fdve-95ca1eea-3ac1-43dd-b4e7-b839586eaaaf\u001b\\\u001b[4;34m=\u001b[0m\u001b]8;;\u001b\\\u001b]8;id=291622;https://tidy3d.simulation.cloud/workbench?taskId=fdve-95ca1eea-3ac1-43dd-b4e7-b839586eaaaf\u001b\\\u001b[4;34mfdve\u001b[0m\u001b]8;;\u001b\\\u001b]8;id=305773;https://tidy3d.simulation.cloud/workbench?taskId=fdve-95ca1eea-3ac1-43dd-b4e7-b839586eaaaf\u001b\\\u001b[4;34m-95ca1eea-3ac\u001b[0m\u001b]8;;\u001b\\\n", + "\u001b[2;36m \u001b[0m\u001b]8;id=305773;https://tidy3d.simulation.cloud/workbench?taskId=fdve-95ca1eea-3ac1-43dd-b4e7-b839586eaaaf\u001b\\\u001b[4;34m1-43dd-b4e7-b839586eaaaf'\u001b[0m\u001b]8;;\u001b\\\u001b[4;34m.\u001b[0m \n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "5357ab51156b4fbe9205a9946a6f27f8", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Output()" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
\n"
+      ],
+      "text/plain": []
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "
08:23:44 CET Loading simulation from simulation_data.hdf5                       \n",
+       "
\n" + ], + "text/plain": [ + "\u001b[2;36m08:23:44 CET\u001b[0m\u001b[2;36m \u001b[0mLoading simulation from simulation_data.hdf5 \n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "mode_monitor_final = mode_monitor.updated_copy(\n", + " freqs=td.C_0 / np.linspace(wvl0 * 1.2, wvl0 / 1.2, 101)\n", + ")\n", + "sim_final = sim_final.updated_copy(monitors=(field_monitor, mode_monitor_final))\n", + "sim_data_final = web.run(sim_final, task_name=\"inv_des_final\")" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "3bf3d162-f158-4970-aac6-0a526ec9c319", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "f, ((ax0, ax1), (ax2, ax3)) = plt.subplots(2, 2, figsize=(10, 7), tight_layout=True)\n", + "sim_final.plot_eps(z=0.01, ax=ax0)\n", + "ax1 = sim_data_final.plot_field(\"field\", \"E\", \"abs^2\", z=0, ax=ax1)\n", + "ax2 = sim_data_final.plot_field(\"field\", \"Ex\", z=0, ax=ax2)\n", + "ax3 = sim_data_final.plot_field(\"field\", \"Ey\", z=0, ax=ax3)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "a8f930a9-4416-49f0-95bb-e8335eef56e3", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAj4AAAG2CAYAAAB/OYyEAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjMsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvZiW1igAAAAlwSFlzAAAPYQAAD2EBqD+naQAARXxJREFUeJzt3Xd8VFX+//H3JJk0IBBIqIYSUHoHEVYFFaSJoC6osBQLltVFAWHBRSEoKoqgX2Vd1BUsIOCC4gJSBaSKSxMEQXoNvYUSQnJ/f5xfBoYkkExmMpPc1/PxuI8wd+7c+ZwMIW/OPfcch2VZlgAAAGwgyN8FAAAA5BWCDwAAsA2CDwAAsA2CDwAAsA2CDwAAsA2CDwAAsA2CDwAAsA2CDwAAsA2CDwAAsA2CDwAAsI0CGXzGjh2rihUrKjw8XE2aNNHq1av9XRIAAAgABS74TJkyRf369dPQoUO1du1a1a1bV61bt9aRI0f8XRoAAPAzR0FbpLRJkyZq3LixPvzwQ0lSWlqa4uLi9Le//U2DBg3yc3UAAMCfQvxdgDddunRJa9as0eDBg137goKC1LJlS61cuTLT1yQnJys5Odn1OC0tTSdOnFCJEiXkcDh8XjMAAMg9y7J09uxZlS1bVkFBWV/QKlDB59ixY0pNTVWpUqXc9pcqVUq///57pq958803lZCQkBflAQAAH9u3b59uuummLJ8vUMHHE4MHD1a/fv1cj0+fPq3y5ctr165dKlKkiB8ru7GUlBQtWrRId911l5xOp7/LyRN2bLNko3ZblnTihJSUpMvnz2v18uW6tX59OSVZ4eFSkSJSoUJmCwuTCmCvrG0+66vQZnu0WfJtu8+ePatKlSrd8Hd3gQo+MTExCg4O1uHDh932Hz58WKVLl870NWFhYQoLC8uwv3jx4oqKivJJnd6SkpKiyMhIlShRwjY/OHZss1TA2p2WJm3fLm3YIK1fL/3+u3TwoNkOHZJSUlyHdrjeeSIipHLlpJtuurJVqSJVqyZVry4VL+7rlvhEgfqss4k226PNkm/bnX6+Gw1TKVDBJzQ0VA0bNtTChQvVqVMnSWbMzsKFC/X888/7tzjArlJSpNWrpXnzpIULTdg5dy73571wwQSo7dszfz42VqpRQ2rQ4MpWtaoUHJz79waQbxWo4CNJ/fr1U8+ePdWoUSPdeuuteu+993Tu3Dk99thj/i4NsI/Tp6Vp06Tvv5d+/FE6ezbvazh6VFqyxGzpIiOlhg2lpk2lZs3M15Il8742AH5T4ILPww8/rKNHj+rVV19VYmKi6tWrpzlz5mQY8AzAyy5dkubOlb780gSeq+6W9JTlcEihoXIEBZkentw6f15autRs6SpXlm6/XbrzTumOO8zlsgI4dgiAUeCCjyQ9//zzXNoC8srBg9KHH0qffCIdO5b915UuLdWtK9WpI1WqJJUte2WLjlaKw6HZc+eqXfv25tp9WpoJP0lJpgfpyBFp/37pwAHzddcuaetW6Y8/3MYJ3dCOHWb7/PMrdd1xh9S8udlq1JCuc2ssgPylQAYfAHlg/Xpp9Ghp8uTsBY06daR775XuvtuMt7lRL2xKinvPS1DQlTu6SpUyPTNZvW7XLmnzZjOAeu1as+3fn712JSZK33xjNkkqUcL0BjVvbr7WqcM4ISAfI/gAyJlVq6RXXpEWLLj+cU6n1K6d9NBDUqtWpiclLzid0i23mO3/3+QgyfQQ/fKLtHKl2VavNr1HN3L8uPTtt2aTpKJFTY9Q+tawoRQa6pOmAPA+gg+A7Nm4URoyxIzfuZ5mzaTu3aXOnU1vSaAoWVJq395skpSaatq0bJkZ8/PTT6a350ZOn5ZmzjSbJIWHS02amHFCTZuaP8fE+K4dAHKF4APg+nbvNoFn0iQzwWBmwsOlnj2lF1808+jkB8HBUr16Znv+edO2HTtMAEq/G2zPnhuf5+LFjHeP3XzzlRDUqJG5PBYe7quWAMgBgg+AzF24IL3zjvTmm+aXe2ZKljSh4dln838vh8Nhxg1VqSI9/rjZt2fPlVCzZIkJRtnxxx9m++IL8zgkRKpVy1wWq1vXbLVrS9HRvmkLgCwRfAC4syzpv/81vTe7dmV+TIkS0ssvm8ATEZGn5eWpChWkHj3MJpk7yH76yWzLlkmbNmXvPJcvm8Hg69e774+Lk2rWNL1k6Vt8fNY9awByjeAD4Iq9e6W//lWaNSvz54sUkfr3l/r2lQJ8SRefKFdOevRRs0lmXbEVK8wYoVWrzODpnMw3tG+f2ebMce1ySmofFqbgypXNHEPx8VL58ua905foKFPGrFUGIMcIPgDMHDkffywNGJD5nU5BQaZ3Z9iw/H9Jy5uKF5fuu89skrmV/tdfTQhatUpas8asRZbDHpyQ5GRzO/7mzVkfVLSoWZajZEnzNTpaKlbsyhYVZWaqLlToytewMHMHWvrmdJrPNjjYfE2fr8iyrtSclmYGgl+9Xb5stpSUnG9Xv/byZSk1VUGXLqna1q0KWrHCXHK0LPO+6TWkT2vgcFypNyTEfA0Odm9TaKhpZ0SEaXf610KFTHAvXNh8tdH6WHBH8AHsbvt26ckn3QfnXu32280EhXXr5m1d+ZHTacbxNGwoPfec2Xf2rLRunfS//5l5hX791QSaS5dy916nT5stq7XK8pFgSVXz+k3DwtyDYrFiJsjGxJhLuTExZitZ0swbVaqUCZdMZpnvEXwAu0pLM4Fm0KDML8+ULm0GN3frxhIOuVGkiJn48M47r+xLSTGzTG/caHqE0retW72y1AeyITlZOnzYbNkVEmICUNmy5rJj+tfy5c14rfRLkszrFNAIPoAdHTwo9eolzZ+f+fNPPCGNGmX+FwzvczrNXV61arnvT01Vyp49+vnrr3Vb6dIK2bPHDDC/emkOb6xZBs9cvmw+hwMHzHiuzDgcJhBVrGiWYknf0u8YLF2a/0j4GcEHsJv//Ed6+mkzMPdaFSqYNbdatcr7umDGq8TF6XitWrLatcs4DsWypFOnzESLR4+a2aiPHjXbqVPm0tepU2Y7c8Ysynru3JWvly6ZX97e5HSanhCn88q4oau3a/eFhFwZn+N0SsHBSnM4dPDoUZUtV05BISHmcpLDcSUgpI/1SR/7c+1Yo8uXTdvSt4sXTUC8cMG0/fz5vAuMlnUlHC1fnvH5QoWkKlUUHB+vaiEhcpw4Ye7sq1rVjNuCzxF8ALs4e1bq00eaMCHz5597TnrrLTP4E4HJ4TDjTKKjperVPTtHWtqVgJCSYh6nb6mp7gOJ07f0QcTpW3qA8dKaZakpKVoze7ZKtWunIF8NOk5NNeHv7FkzgD99jFR6UDx50vxn4Ngxsx0/bgLl4cPmeW85d07asEFBGzaYcU3pa8JJ5jJZjRpXtpo1Ta8ggcirCD6AHaxdKz3yiJlU71rlypmVye+5J+/rQt4LCjKzSNttJungYHOnmyfTMCQnmxCUmCgdOmR6cw4evHL5cd8+MxXEuXO5qzG9p+jaS9Dly5sJL2vXNrOA16tnZgcP4Ve4J/iuIWfS0ty7oBHYLEv64ANzm3pmdxF16SJ99JG5mwVA5sLCzPxJN92U9TGWZXqN9u41y7zs2mW23bvNjN87d2Y9A/qN7N1rtqvn1woPN71B9epJDRqYrU6dgj2hqJcQfHB9qanSzz9Ls2ebbf16cynk6q7Y+vXNHSv87yOwHD8uPfaYmYX5WkWKSGPHSn/5CyEW8AaHw/wHonhxE0aulZZmeon+/3Imqb//rqNLl6rUqVNy7Npl/q3NiYsXzRQJ//vflX3BweYSaKNG0q23mq12be4yuwa/qZC5vXvNZHUzZmQcBHv2rAlDP/98ZV/VqtJ770lt2uRllcjKihXSww+bbvhr3XqrNHmyudMEQN4ICrrSa3TXXUpLSdHPs2erXbt2clqWCURbtlyZuPK338wUBzkZjJ6aapZR2bTpyli+sDATxNKDUOPG5jKZjecjIvjAnWVJX34p/e1v5q6Q7Nq6VWrbVmrfXho9WrrlFt/ViKxZlvTuu9LgwZn/gzlggPT66/wPEAgkoaGm97xmTff9ly6Zf1t//dXM+fTrr2YSzIMHs3/u5OSM/1EtWtSEoKZNzdakia0WzCX44IqjR6VnnpGmT/f8HLNmSfPmmQUuhw+33wBKfzpxwszNk9mlrdhYs1I4PXJA/hEaemVQ89WOHjUBaMMGMyv42rU5Wxrl9GkzgPrqQdTVqknNmpmtaVPzuID2ChF8YMyeLT3+eNazmNaqJbVrJ7VubW6B/e03s61cabpnr5aSYmb8/fln6bvvbPU/Cb9ZvdoMVN6zJ+NzLVpIkyaZhS0B5H+xsVLLlmZL9/9vk9eaNebfg9WrpW3bsn/O9NnDP/vMPC5WzISgO+4wy9Y0blxgFsYl+MDcyvzYY5n/b6FHD9NzU6GC+/7Wrc3XtDTTkzBoUMbQ9NNP5gfmhx/M7ZjwvvS7tl56yQTOqzkc0pAh0tChXptvBUCAKlToSo9NupMnzeDnX365EoYOHcre+U6dunJTi2RCT+PG0p/+ZP5db9Ys394NSvCxu/HjzfIE14aeEiWkceOkhx66/uuDgszllQcflEaMkMaMcf8FvHmz6TadPZtFLr3t9Gnz2U2blvG52Fjpq6+ke+/N+7oABIboaDML+9Uzse/fbwLQypVm+9//src+XHKytGyZ2UaONPuqVzc9Qs2bm61cOd+0w8sIPnb2739LvXtnDD333WeWLShdOvvniooyPwyPPmouiV39v4qDB80Px7ffMkmet6xbJ3XubOYHudYdd5i7tsqWzfu6AAS29DvLHnzQPL50yUxTsnKluRt05UozIWN2bNlito8/No8rVzYB6O67zRagl9cL5sgl3Ngnn0hPPpkx9AwYIH3/fc5Cz9Xq1ZNWrco4nf7Zs+aOrwULPDsvDMuS/vlP6bbbMg89gwdLP/5I6AGQPaGh5g6vF16Qpky5Mlni5MnS88+bnvrszvW1Y4cZI/SXv5h/g2rWNMvkzJhheqgDBD0+djR+vPTUUxn3DxokvfFG7ie0K1/eLM7XsaO0dOmV/cnJ0v33S3PmmAkPkSMh584p+NFHM7/rrnhxMw1Bu3Z5XxiAgiUuzswD9vDD5vHp06Y3aPlys/38c/YWfU2fk+iDD8w4w8aNFXTXXSpRuLAZmO2rddlugOBjN/Pnm8tb13r5ZTO/i7dm8Y2ONre19+jhvgjfhQum52fePDP2B9mzdq1a9OunoMzuumvSRJo6lQHkAHyjaFEzT1vbtuZxSoq53L50qbRkifl6o4VcU1OlVasUvGqVbpdkjRghffqpGR6Rx7jUZSe//Sb9+c8Zp0YfMsS7oSddeLj09ddmccyrJSWZH6A1a7z7fgVRWpo0ZoxC7rxThTILPf36mbvnCD0A8orTaS6P9e9vhkYcO2aC0JgxUocOZkmcG3CcP2/GBPkBPT52cfiw6Wm5djbmAQPM7eq+Wq8pONjc7p6cbAY3pzt92txxtGiRWVgPGSUmmjvm5s5Vhk8nOtpMQ9Chgx8KA4CrBAeb8Z316pnJay9fNneLLVxotuXLMyySbBUtKkfDhv6olh4fWzh/3oytuXZyuz//WXrrLd8vUul0moFy144/OXHCXOfdvNm3758f/fCDGVQ4d27G55o2NXdhEHoABKKQEHMDxj/+YW62OHnS/Fs2cKCs+vVlORyyWrTw2/xiBJ+CLi3NjLNZvdp9f5Mmpicmr6YkDw01881cPdOoZKZev+eenM0wWpCdP2/ugmjXTjpyxO0py+FQ6ksvmWvqXNoCkF9ERpoe/pEjdfnnnzXn88+V+tZbfiuH4FPQvf56xgnuKlY0txdGRORtLeHhZgmLa+/oSkw0cz5kdnu2naxaJdWvb+6AuIZVpoxWDBumtDfe8NudEADgDZeiovw2vkci+BRss2ZJw4a57yta1OwvVcovJalQIWnmzIx3dB04YMJPZmtNFXTJyeauuj/9KfOerw4ddHnNGh1j5msAyDWCT0G1fbvUrZv7BIVBQdJ//iPVqOG/uiQz4v+HH8y6L1fbu9csqPnHH34pyy9WrzbfhzffNJclrxYeLn34oemdi4nxT30AUMAQfAqic+ekBx7IOFPm229nHGPjL0WLmsFu9eq579+92/R8FPRb3c+ckf72NzMAcOPGjM83aWIGMD/3nO8HnwOAjRB8ChrLMgtXbtrkvv/hh82cL4EkOtpMqFirlvv+o0dNz09BXN7CsszMy9Wrm96ca5cMcTrNYq/LlklVq/qnRgAowAg+Bc3o0Wa9lavVqmUWJA3EnoOYGDPPQ4MG7vuTksydTVOn+qcuX9i82cyl9NBDZuHWa9WtK/3yixnvE8IUWwDgCwSfgmTBAmngQPd9RYuaiQMLFfJPTdlRsqSZyPDaldtTUsysz8OGZZxtOj85etRcsqpTx4xtulZEhFnZ/pdfTPgBAPgMwaeg2LnTXM66doDsxIlSlSr+qSknoqLM3WZdurjvtywpIcHc8bV/v39q89S5c2ZcVZUqZkX1zMJb69bmsuTAgdymDgB5gOBTEJw7J3XqZGZCvlpCgrm0kl+EhUmTJpnekWv99JNUt64c//1v3teVU2fOmLu0KlaU/v73jMuESFLp0qatP/wgxcfneYkAYFcMJMjvLEvBTz6Z8c6gBx4wi4/mN8HBZgK/ChWkwYPde0lOnFDIQw+pXsuWZqK/QJu9+PhxaexY6b33zBTtmYmIkF56yfTwFC6cp+UBAOjxyfdunj5dQdfOzFyjhlnAMq+Wo/A2h8MsnvrTTyYAXaPCggUKqV5deuWVzHtT8pJlmQX4uneXypWThg7NOvR07y5t3WoWhSX0AIBf5NPfjJAkx9y5qv7VV+47ixUzE94VKeKXmryqWTMzl82f/5zhKcf582Y5jipVTA/LqVN5W9u+fdL775sBy7ffLn31lZmBOTP33WcGLn/xhRQXl7d1AgDcEHzyqx07FNy9uxxXzwPjcEhff50/BjNnV7Fi5pb2cePMQnfXOnpU6tvXjJl55BEzZubyZe/XYVnS77+bsTuNG5vLbC++mHG+pKs9+KC0dq303/9KjRp5vyYAQI4xxic/SkqSOnWS49pejjfekNq08UtJPuVwSE89Jd13n9JefVWO8ePluPbuteRkM3/RlCkmBN1zj1kP7LbbTK9MTu+YOntW2rBBWrlSWrHCfD18+MavCw2VOnc2g5pr187ZewIAfI7gk99kNTNz+i/bgqxsWaV+9JGW1qunFnPnKmjmzMyPS0w0t/FPnGgeR0RIt9xiFmYtXdp8LV7c9AxdumTmC7p40SyUumuX2Y4fz1ltlStLzzwj9erFuloAEMAIPvnNqFEZZjO2ataU47PPAnNmZh84Gxen1OnTFfTzz2Z8z3//awJMVi5cML033hYdLXXoIP3lL6aHKb8OJgcAGyH45Cfz5kmDBrntulSokBzffCOnHe8Suv12sx0/Lk2ebO5k++UX375nmTJmzqQHH5SaN2fSQQDIZwg++cX//mfWeLpqbIvlcGhN375qVJAGM3uiRAkz6eFzz5kByIsXmzE5q1ZJ27Z5fl6Hw4zTadrU3GHWrJm5pGWTnjUAKIgIPvnB5s1m0HJSktvutGHDdIS1ndxVq2a2Z54xj48fN3dWHThgBicnJpqvp0+bgcjpm9MpxcZKlSqZGZcrVTJ3bkVE+LU5AADvIvgEut27pXvvzTjYtnNnpf3979KcOX4pK98oUUJq1crfVQAAAgSjMQNZYqLUsqXprbhaq1bSl18ymBYAgBziN2egOnnSrNy9Y4f7/ttuk6ZPNwt6AgCAHCH4BKJz58yq6r/+6r6/dm1p9mzWeQIAwEMEn0CTnGxulV650n1/5crS3Llm7hgAAOARgk8gSU01K3jPm+e+v2xZaf58M4cMAADwGMEnUFiW9Oyz0jffuO8vXtwEoUqV/FMXAAAFCMEnEKSlmZW+P/nEfX+hQma18Zo1/VIWAAAFDfP4+FtKivT449JXX7nvDw2VZsyQbr3VP3UBAFAAEXz86fx5s6r67Nnu+4OCzNpT99zjn7oAACigCD7+cuKEWdl7xQr3/SEhZrHNBx7wT10AABRgBB9/OH5catFC2rTJfX9EhDRtmtS2rV/KAgCgoCP45LWLF6VOnTKGnuhoadYssxI4AADwCYJPXkpLkx57TFq2zH1/2bLmlnXu3gIAwKcKzO3su3fv1hNPPKFKlSopIiJClStX1tChQ3Xp0iV/l3bFkCFm0PLVypWTli8n9AAAkAcKTI/P77//rrS0NI0bN05VqlTRpk2b1Lt3b507d06jRo3yd3lmjp4333TfV6SIuaOrYkW/lAQAgN0UmODTpk0btWnTxvU4Pj5eW7du1UcffeT/4DN3rpmV+WrBwWaW5jp1/FMTAAA2VGCCT2ZOnz6t4sWLX/eY5ORkJScnux6fOXNGkpSSkqKUlJTcF7Fhg0I6d5YjNdVt9+UPP5R1991mAkMPpdfnlTrzCTu2WbJnu+3YZsme7abN9uHLdmf3nA7Lsiyvv3sA2L59uxo2bKhRo0apd+/eWR43bNgwJSQkZNg/adIkRUZG5rqO2h9/rPhrJijc9tBD2tK9e67PDQAAjPPnz6tr1646ffq0oqKisjwu4IPPoEGDNHLkyOses2XLFlWrVs31+MCBA2revLlatGihTz/99LqvzazHJy4uTseOHbvuNy7b0tIU9PLLCh492jzs3FmpX35pZmfOpZSUFM2fP1+tWrWS0+nM9fnyAzu2WbJnu+3YZsme7abN9miz5Nt2nzlzRjExMTcMPgF/qat///7q1avXdY+Jj493/fngwYO666671KxZM3388cc3PH9YWJjCwsIy7Hc6nd77UN59V6pcWZo6VUFffKGgTN4vN7xaaz5hxzZL9my3Hdss2bPdtNk+fNHu7J4v4INPbGysYmNjs3XsgQMHdNddd6lhw4YaP368grzQq+I1f/2r9PTTZlAzAADwi4APPtl14MABtWjRQhUqVNCoUaN09OhR13OlS5f2Y2VXIfQAAOBXBSb4zJ8/X9u3b9f27dt10003uT0X4MOYAABAHgmga0G506tXL1mWlekGAAAgFaDgAwAAcCMEHwAAYBsEHwAAYBsEHwAAYBsEHwAAYBsEHwAAYBsEHwAAYBsEHwAAYBsEHwAAYBsEHwAAYBsEHwAAYBsEHwAAYBsEHwAAYBsEHwAAYBsEHwAAYBsEHwAAYBsEHwAAYBsEHwAAYBsEHwAAYBsEHwAAYBsEHwAAYBsEHwAAYBsEHwAAYBsEHwAAYBsEHwAAYBsEHwAAYBsEHwAAYBsEHwAAYBsEHwAAYBsEHwAAYBsEHwAAYBsEHwAAYBsEHwAAYBsEHwAAYBsEHwAAYBsEHwAAYBsEHwAAYBsEHwAAYBsEHwAAYBsEHwAAYBsEHwAAYBsEHwAAYBsEHwAAYBsEHwAAYBu5Dj7JycneqAMAAMDnchx8fvjhB/Xs2VPx8fFyOp2KjIxUVFSUmjdvrhEjRujgwYO+qBMAACDXsh18vv32W91yyy16/PHHFRISor///e+aPn265s6dq08//VTNmzfXggULFB8fr2eeeUZHjx71Zd0AAAA5FpLdA99++22NGTNGbdu2VVBQxrzUpUsXSdKBAwf0wQcf6KuvvlLfvn29VykAAEAuZTv4rFy5MlvHlStXTm+99ZbHBQEAAPgKd3UBAADbyHHw+eOPPzRt2jTt2rVLkjRr1izdeeedaty4sUaMGCHLsrxeJAAAgDdk+1KXZAY4d+nSRUFBQXI4HPr444/19NNPq0WLFoqKitKwYcNcA58BAAACTY56fEaMGKGBAwfq4sWL+uijj/TMM8/ozTff1A8//KCZM2dq7NixmjBhgo9KBQAAyJ0cBZ+tW7fq8ccfl8PhUM+ePXXp0iW1bNnS9fy9996rPXv2eL1IAAAAb8hR8Dl37pyKFCliXhgUpIiICEVGRrqej4iIYCZnAAAQsHIUfBwOhxwOR5aPAQAAAlmOBjdblqVbbrnFFXaSkpJUv35914SG3NEFAAACWY6Cz/jx431VBwAAgM/lKPj07NnTV3UAAAD4HDM3AwAA28h2j090dHS2BzKfOHHC44IAAAB8JdvB57333nP9+fjx43r99dfVunVrNW3aVJJZxHTu3Ll65ZVXvF4kAACAN2Q7+Fw9vuehhx7S8OHD9fzzz7v29enTRx9++KEWLFigvn37erdKAAAAL/BojM/cuXPVpk2bDPvbtGmjBQsW5Lqo3EpOTla9evXkcDi0fv16f5cDAAAChEfBp0SJEpoxY0aG/TNmzFCJEiVyXVRuDRw4UGXLlvV3GQAAIMDk6Hb2dAkJCXryySe1ePFiNWnSRJL0888/a86cOfrkk0+8WmBO/fDDD5o3b56mTZumH374wa+1AACAwOJR8OnVq5eqV6+u//u//9P06dMlSdWrV9eyZctcQcgfDh8+rN69e+u7775zW0PsepKTk93WFztz5owkKSUlRSkpKT6p01vS6wv0Or3Jjm2W7NluO7ZZsme7abN9+LLd2T2nwyog60xYlqV27drpT3/6k4YMGaLdu3erUqVKWrdunerVq5fl64YNG6aEhIQM+ydNmpTt8AQAAPzr/Pnz6tq1q06fPq2oqKgsj8t28Dl37pwKFSqU7QJyenxWBg0apJEjR173mC1btmjevHmaOnWqlixZouDg4GwHn8x6fOLi4nTs2LHrfuMCQUpKiubPn69WrVrJ6XT6u5w8Ycc2S/Zstx3bLNmz3bTZHm2WfNvuM2fOKCYm5obBJ9uXuqpUqaIXXnhBPXv2VJkyZTI9xrIsLViwQKNHj9add96pwYMH57zya/Tv31+9evW67jHx8fH68ccftXLlSoWFhbk916hRI3Xr1k2ff/55pq8NCwvL8BpJcjqd+eYvY36q1Vvs2GbJnu22Y5sle7abNtuHL9qd3fNlO/gsXrxYL7/8soYNG6a6deuqUaNGKlu2rMLDw3Xy5Elt3rxZK1euVEhIiAYPHqynn37a4+KvFhsbq9jY2Bse93//9396/fXXXY8PHjyo1q1ba8qUKX4ddwQAAAJHtoNP1apVNW3aNO3du1fffPONli5dqhUrVujChQuKiYlR/fr19cknn6ht27YKDg72Zc2ZKl++vNvjwoULS5IqV66sm266Kc/rAQAAgSfHd3WVL19e/fv3V//+/X1RDwAAgM94dDt7flCxYkUVkBvWAACAl3g0czMAAEB+RPABAAC2QfABAAC2QfABAAC24fHg5lOnTmn16tU6cuSI0tLS3J7r0aNHrgsDAADwNo+Cz3//+19169ZNSUlJioqKksPhcD3ncDgIPgAAICB5dKmrf//+evzxx5WUlKRTp07p5MmTru3EiRPerhEAAMArPAo+Bw4cUJ8+fVi9HAAA5CseBZ/WrVvrf//7n7drAQAA8CmPxvi0b99eAwYM0ObNm1W7du0MK6Lef//9XikOAADAmzwKPr1795YkDR8+PMNzDodDqampuasKAADABzwKPtfevg4AAJAfMIEhAACwDY+Dz5IlS9ShQwdVqVJFVapU0f3336+lS5d6szYAAACv8ij4fPXVV2rZsqUiIyPVp08f9enTRxEREbrnnns0adIkb9cIAADgFR6N8RkxYoTefvtt9e3b17WvT58+Gj16tF577TV17drVawUCAAB4i0c9Pjt37lSHDh0y7L///vu1a9euXBcFAADgCx4Fn7i4OC1cuDDD/gULFiguLi7XRQEAAPiCR5e6+vfvrz59+mj9+vVq1qyZJGn58uWaMGGC3n//fa8WCAAA4C0eBZ9nn31WpUuX1rvvvqupU6dKkqpXr64pU6aoY8eOXi0QAADAWzwKPpL0wAMP6IEHHvBmLQAAAD7FBIYAAMA2st3jU7x4cW3btk0xMTGKjo6Ww+HI8tgTJ054pTgAAABvynbwGTNmjIoUKeL68/WCDwAAQCDKdvDp2bOn68+9evXyRS0AAAA+5dEYn7Vr12rjxo2uxzNmzFCnTp308ssv69KlS14rDgAAwJs8Cj5PP/20tm3bJsnM4vzwww8rMjJS33zzjQYOHOjVAgEAALzFo+Czbds21atXT5L0zTffqHnz5po0aZImTJigadOmebM+AAAAr/Eo+FiWpbS0NElmmYp27dpJMktZHDt2zHvVAQAAeJFHwadRo0Z6/fXX9eWXX2rJkiVq3769JGnXrl0qVaqUVwsEAADwFo+Cz3vvvae1a9fq+eef1z/+8Q9VqVJFkvSf//zHtXYXAABAoPFoyYo6deq43dWV7p133lFwcHCuiwIAAPAFj3p89u3bp/3797ser169Wi+++KK++OILOZ1OrxUHAADgTR4Fn65du2rRokWSpMTERLVq1UqrV6/WP/7xDw0fPtyrBQIAAHiLR8Fn06ZNuvXWWyVJU6dOVa1atbRixQpNnDhREyZM8GZ9AAAAXuNR8ElJSVFYWJgkczv7/fffL0mqVq2aDh065L3qAAAAvMij4FOzZk3961//0tKlSzV//ny1adNGknTw4EGVKFHCqwUCAAB4i0fBZ+TIkRo3bpxatGihRx99VHXr1pUkff/9965LYAAAAIHGo9vZW7RooWPHjunMmTOKjo527X/qqacUGRnpteIAAAC8yaPgI0nBwcFuoUeSKlasmNt6AAAAfCbbwadBgwZauHChoqOjVb9+fTkcjiyPXbt2rVeKAwAA8KZsB5+OHTu67uTq1KmTr+oBAADwmWwHn6FDh2b6ZwAAgPzC4zE+6ZKSkpSWlua2LyoqKrenBQAA8DqPbmfftWuX2rdvr0KFCqlo0aKKjo5WdHS0ihUrlmHAMwAAQKDwqMfnL3/5iyzL0meffaZSpUpdd6AzAABAoPAo+GzYsEFr1qxR1apVvV0PAACAz3h0qatx48bat2+ft2sBAADwKY96fD799FM988wzOnDggGrVqiWn0+n2fJ06dbxSHAAAgDd5FHyOHj2qHTt26LHHHnPtczgcsixLDodDqampXisQAADAWzwKPo8//rjq16+vr7/+msHNAAAg3/Ao+OzZs0fff/+9qlSp4u16AAAAfMajwc133323NmzY4O1aAAAAfMqjHp8OHTqob9++2rhxo2rXrp1hcPP999/vleIAAAC8yaPg88wzz0iShg8fnuE5BjcDAIBA5VHwuXZtLgAAgPzAozE+mTl16pS3TgUAAOATHgWfkSNHasqUKa7HnTt3VvHixVWuXDkGPQMAgIDlUfD517/+pbi4OEnS/PnztWDBAs2ZM0dt27bVgAEDvFogAACAt3g0xicxMdEVfGbOnKkuXbro3nvvVcWKFdWkSROvFggAAOAtHvX4REdHuxYpnTNnjlq2bClJsiyLO7oAAEDA8qjH58EHH1TXrl1188036/jx42rbtq0kad26dczmDAAAApZHwWfMmDGqWLGi9u3bp7fffluFCxeWJB06dEh//etfvVogAACAt3gUfJxOp1566aUM+/v27ZvrgnJr1qxZGj58uH799VeFh4erefPm+u677/xdFgAACAAeBR9J+uOPP7Ro0SIdOXIkw4SGr776aq4L88S0adPUu3dvvfHGG7r77rt1+fJlbdq0yS+1AACAwONR8Pnkk0/07LPPKiYmRqVLl5bD4XA953A4/BJ8Ll++rBdeeEHvvPOOnnjiCdf+GjVq5HktAAAgMHkUfF5//XWNGDFCf//7371dj8fWrl2rAwcOKCgoSPXr11diYqLq1aund955R7Vq1crydcnJyUpOTnY9PnPmjCQpJSVFKSkpPq87N9LrC/Q6vcmObZbs2W47tlmyZ7tps334st3ZPafDsiwrpyePiorS+vXrFR8fn+PCfGXy5Ml69NFHVb58eY0ePVoVK1bUu+++q3nz5mnbtm0qXrx4pq8bNmyYEhISMuyfNGmSIiMjfV02AADwgvPnz6tr1646ffq0oqKisjzOo+DzxBNPqHHjxq5V2n1p0KBBGjly5HWP2bJli9auXatu3bpp3LhxeuqppySZ3pybbrpJr7/+up5++ulMX5tZj09cXJyOHTt23W9cIEhJSdH8+fPVqlUrOZ1Of5eTJ+zYZsme7bZjmyV7tps226PNkm/bfebMGcXExNww+Hh0qatKlSp65ZVXtGrVKtWuXTtD8X369PHktJnq37+/evXqdd1j4uPjdejQIUnuY3rCwsIUHx+vvXv3ZvnasLAwhYWFZdjvdDrzzV/G/FSrt9ixzZI9223HNkv2bDdttg9ftDu75/Mo+Hz88ccqXLiwlixZoiVLlrg953A4vBp8YmNjFRsbe8PjGjZsqLCwMG3dulW33367JJMsd+/erQoVKnitHgAAkH95FHx27drl7TpyLSoqSs8884yGDh2quLg4VahQQe+8844ks3o8AACAx/P4BKJ33nlHISEh6t69uy5cuKAmTZroxx9/VHR0tL9LAwAAAcDj4LN//359//332rt3ry5duuT23OjRo3NdmCecTqdGjRqlUaNG+eX9AQBAYPMo+CxcuFD333+/4uPj9fvvv6tWrVravXu3LMtSgwYNvF0jAACAVwR58qLBgwfrpZde0saNGxUeHq5p06Zp3759at68OeNpAABAwPIo+GzZskU9evSQJIWEhOjChQsqXLiwhg8ffsM5dwAAAPzFo+BTqFAh17ieMmXKaMeOHa7njh075p3KAAAAvMyjMT633Xabli1bpurVq6tdu3bq37+/Nm7cqOnTp+u2227zdo0AAABe4VHwGT16tJKSkiRJCQkJSkpK0pQpU3TzzTf77Y4uAACAG8lx8ElNTdX+/ftVp04dSeay17/+9S+vFwYAAOBtOR7jExwcrHvvvVcnT570RT0AAAA+49Hg5lq1amnnzp3ergUAAMCnPAo+r7/+ul566SXNnDlThw4d0pkzZ9w2AACAQOTR4OZ27dpJku6//345HA7Xfsuy5HA4lJqa6p3qAAAAvMij4LNo0SJv1wEAAOBzHgWfSpUqKS4uzq23RzI9Pvv27fNKYQAAAN7m0RifSpUq6ejRoxn2nzhxQpUqVcp1UQAAAL7gUfBJH8tzraSkJIWHh+e6KAAAAF/I0aWufv36SZIcDodeeeUVRUZGup5LTU3Vzz//rHr16nm1QAAAAG/JUfBZt26dJNPjs3HjRoWGhrqeCw0NVd26dfXSSy95t0IAAAAvyVHwSb+b67HHHtP777+vqKgonxQFAADgCx7d1TV+/Hhv1wEAAOBzHg1uBgAAyI8IPgAAwDYIPgAAwDYIPgAAwDYIPgAAwDYIPgAAwDYIPgAAwDYIPgAAwDYIPgAAwDYIPgAAwDYIPgAAwDYIPgAAwDYIPgAAwDYIPgAAwDYIPgAAwDYIPgAAwDYIPgAAwDYIPgAAwDYIPgAAwDYIPgAAwDYIPgAAwDYIPgAAwDYIPgAAwDYIPgAAwDYIPgAAwDYIPgAAwDYIPgAAwDYIPgAAwDYIPgAAwDYIPgAAwDYIPgAAwDYIPgAAwDYIPgAAwDYIPgAAwDYIPgAAwDYIPgAAwDYIPgAAwDYIPgAAwDYIPgAAwDYIPgAAwDYIPgAAwDYIPgAAwDYIPgAAwDYIPgAAwDYKVPDZtm2bOnbsqJiYGEVFRen222/XokWL/F0WAAAIEAUq+Nx33326fPmyfvzxR61Zs0Z169bVfffdp8TERH+XBgAAAkCBCT7Hjh3TH3/8oUGDBqlOnTq6+eab9dZbb+n8+fPatGmTv8sDAAABIMTfBXhLiRIlVLVqVX3xxRdq0KCBwsLCNG7cOJUsWVINGzbM8nXJyclKTk52PT5z5owkKSUlRSkpKT6vOzfS6wv0Or3Jjm2W7NluO7ZZsme7abN9+LLd2T2nw7Isy+vv7if79+9Xp06dtHbtWgUFBalkyZKaNWuW6tevn+Vrhg0bpoSEhAz7J02apMjISF+WCwAAvOT8+fPq2rWrTp8+raioqCyPC/jgM2jQII0cOfK6x2zZskVVq1ZVp06dlJKSon/84x+KiIjQp59+qu+//16//PKLypQpk+lrM+vxiYuL07Fjx677jQsEKSkpmj9/vlq1aiWn0+nvcvKEHdss2bPddmyzZM9202Z7tFnybbvPnDmjmJiYGwafgL/U1b9/f/Xq1eu6x8THx+vHH3/UzJkzdfLkSVeD//nPf2r+/Pn6/PPPNWjQoExfGxYWprCwsAz7nU5nvvnLmJ9q9RY7tlmyZ7vt2GbJnu2mzfbhi3Zn93wBH3xiY2MVGxt7w+POnz8vSQoKch+vHRQUpLS0NJ/UBgAA8pcCc1dX06ZNFR0drZ49e2rDhg3atm2bBgwYoF27dql9+/b+Lg8AAASAAhN8YmJiNGfOHCUlJenuu+9Wo0aNtGzZMs2YMUN169b1d3kAACAABPylrpxo1KiR5s6d6+8yAABAgCowPT4AAAA3QvABAAC2QfABAAC2QfABAAC2QfABAAC2QfABAAC2QfABAAC2QfABAAC2QfABAAC2QfABAAC2QfABAAC2QfABAAC2QfABAAC2QfABAAC2QfABAAC2QfABAAC2QfABAAC2QfABAAC2QfABAAC2QfABAAC2QfABAAC2QfABAAC2QfABAAC2QfABAAC2QfABAAC2QfABAAC2QfABAAC2QfABAAC2QfABAAC2QfABAAC2QfABAAC2QfABAAC2QfABAAC2QfABAAC2QfABAAC2QfABAAC2QfABAAC2QfABAAC2QfABAAC2QfABAAC2QfABAAC2QfABAAC2QfABAAC2QfABAAC2QfABAAC2QfABAAC2QfABAAC2QfABAAC2QfABAAC2QfABAAC2QfABAAC2QfABAAC2QfABAAC2QfABAAC2QfABAAC2QfABAAC2QfABAAC2QfABAAC2QfABAAC2QfABAAC2QfABAAC2QfABAAC2QfABAAC2kW+Cz4gRI9SsWTNFRkaqWLFimR6zd+9etW/fXpGRkSpZsqQGDBigy5cv522hAAAgYIX4u4DsunTpkjp37qymTZvq3//+d4bnU1NT1b59e5UuXVorVqzQoUOH1KNHDzmdTr3xxht+qBgAAASafNPjk5CQoL59+6p27dqZPj9v3jxt3rxZX331lerVq6e2bdvqtdde09ixY3Xp0qU8rhYAAASifNPjcyMrV65U7dq1VapUKde+1q1b69lnn9Vvv/2m+vXrZ/q65ORkJScnux6fPn1aknTixAmlpKT4tuhcSklJ0fnz53X8+HE5nU5/l5Mn7NhmyZ7ttmObJXu2mzbbo82Sb9t99uxZSZJlWdc9rsAEn8TERLfQI8n1ODExMcvXvfnmm0pISMiwv1KlSt4tEAAA+NzZs2dVtGjRLJ/3a/AZNGiQRo4ced1jtmzZomrVqvmshsGDB6tfv36ux2lpaTpx4oRKlCghh8Phs/f1hjNnziguLk779u1TVFSUv8vJE3Zss2TPdtuxzZI9202b7dFmybfttixLZ8+eVdmyZa97nF+DT//+/dWrV6/rHhMfH5+tc5UuXVqrV69223f48GHXc1kJCwtTWFiY276s7hoLVFFRUbb6wZHs2WbJnu22Y5sle7abNtuHr9p9vZ6edH4NPrGxsYqNjfXKuZo2baoRI0boyJEjKlmypCRp/vz5ioqKUo0aNbzyHgAAIH/LN2N89u7dqxMnTmjv3r1KTU3V+vXrJUlVqlRR4cKFde+996pGjRrq3r273n77bSUmJmrIkCF67rnnMvToAAAAe8o3wefVV1/V559/7nqcfpfWokWL1KJFCwUHB2vmzJl69tln1bRpUxUqVEg9e/bU8OHD/VWyz4WFhWno0KG2CnZ2bLNkz3bbsc2SPdtNm+0jENrtsG503xcAAEABkW8mMAQAAMgtgg8AALANgg8AALANgg8AALANgk8AGTt2rCpWrKjw8HA1adIkw4SM13rvvfdUtWpVRUREKC4uTn379tXFixddzw8bNkwOh8Nt8+Us2J7KSbtTUlI0fPhwVa5cWeHh4apbt67mzJmTq3P6g7fbHOif9U8//aQOHTqobNmycjgc+u677274msWLF6tBgwYKCwtTlSpVNGHChAzHBPrn7It2F7TP+tChQ+ratatuueUWBQUF6cUXX8z0uG+++UbVqlVTeHi4ateurdmzZ3u/+FzwRbsnTJiQ4bMODw/3TQM8kNM2T58+Xa1atVJsbKyioqLUtGlTzZ07N8Nxvv65JvgEiClTpqhfv34aOnSo1q5dq7p166p169Y6cuRIpsdPmjRJgwYN0tChQ7Vlyxb9+9//1pQpU/Tyyy+7HVezZk0dOnTItS1btiwvmpNtOW33kCFDNG7cOH3wwQfavHmznnnmGT3wwANat26dx+fMa75osxTYn/W5c+dUt25djR07NlvH79q1S+3bt9ddd92l9evX68UXX9STTz7p9o9koH/Okm/aLRWszzo5OVmxsbEaMmSI6tatm+kxK1as0KOPPqonnnhC69atU6dOndSpUydt2rTJm6Xnii/aLZkZjq/+rPfs2eOtknMtp23+6aef1KpVK82ePVtr1qzRXXfdpQ4dOuT9v98WAsKtt95qPffcc67HqampVtmyZa0333wz0+Ofe+456+6773bb169fP+tPf/qT6/HQoUOtunXr+qReb8lpu8uUKWN9+OGHbvsefPBBq1u3bh6fM6/5os354bNOJ8n69ttvr3vMwIEDrZo1a7rte/jhh63WrVu7Hgf653wtb7W7oH3WV2vevLn1wgsvZNjfpUsXq3379m77mjRpYj399NO5rNA3vNXu8ePHW0WLFvVaXb6U0zanq1GjhpWQkOB6nBc/1/T4BIBLly5pzZo1atmypWtfUFCQWrZsqZUrV2b6mmbNmmnNmjWuLsCdO3dq9uzZateundtxf/zxh8qWLav4+Hh169ZNe/fu9V1DcsiTdicnJ2fo6o2IiHD9j9eTc+YlX7Q5XSB/1jm1cuVKt++RJLVu3dr1PQr0z9lTN2p3uoL0WWdHdr8vBVFSUpIqVKiguLg4dezYUb/99pu/S/KatLQ0nT17VsWLF5eUdz/XBJ8AcOzYMaWmpqpUqVJu+0uVKqXExMRMX9O1a1cNHz5ct99+u5xOpypXrqwWLVq4Xepq0qSJJkyYoDlz5uijjz7Srl27dMcdd+js2bM+bU92edLu1q1ba/To0frjjz+Ulpam+fPna/r06Tp06JDH58xLvmizFPifdU4lJiZm+j06c+aMLly4EPCfs6du1G6p4H3W2ZHV9yU/f9bZUbVqVX322WeaMWOGvvrqK6WlpalZs2bav3+/v0vzilGjRikpKUldunSRlHf/fhN88qnFixfrjTfe0D//+U+tXbtW06dP16xZs/Taa6+5jmnbtq06d+6sOnXqqHXr1po9e7ZOnTqlqVOn+rHy3Hn//fd18803q1q1agoNDdXzzz+vxx57TEFBBfevcnbaXBA/a2SOz9o+mjZtqh49eqhevXpq3ry5pk+frtjYWI0bN87fpeXapEmTlJCQoKlTp7oWFs8rBfe3RT4SExOj4OBgHT582G3/4cOHVbp06Uxf88orr6h79+568sknVbt2bT3wwAN644039OabbyotLS3T1xQrVky33HKLtm/f7vU2eMKTdsfGxuq7777TuXPntGfPHv3+++8qXLiw4uPjPT5nXvJFmzMTaJ91TpUuXTrT71FUVJQiIiIC/nP21I3anZn8/llnR1bfl/z8WXvC6XSqfv36+f6znjx5sp588klNnTrV7bJWXv1cE3wCQGhoqBo2bKiFCxe69qWlpWnhwoVq2rRppq85f/58hl6O4OBgSZKVxfJrSUlJ2rFjh8qUKeOlynPHk3anCw8PV7ly5XT58mVNmzZNHTt2zPU584Iv2pyZQPusc6pp06Zu3yNJmj9/vut7FOifs6du1O7M5PfPOjs8+b4URKmpqdq4cWO+/qy//vprPfbYY/r666/Vvn17t+fy7Ofaa8OkkSuTJ0+2wsLCrAkTJlibN2+2nnrqKatYsWJWYmKiZVmW1b17d2vQoEGu44cOHWoVKVLE+vrrr62dO3da8+bNsypXrmx16dLFdUz//v2txYsXW7t27bKWL19utWzZ0oqJibGOHDmS5+3LSk7bvWrVKmvatGnWjh07rJ9++sm6++67rUqVKlknT57M9jn9zRdtDvTP+uzZs9a6deusdevWWZKs0aNHW+vWrbP27NljWZZlDRo0yOrevbvr+J07d1qRkZHWgAEDrC1btlhjx461goODrTlz5riOCfTP2bJ80+6C9llbluU6vmHDhlbXrl2tdevWWb/99pvr+eXLl1shISHWqFGjrC1btlhDhw61nE6ntXHjxjxt2/X4ot0JCQnW3LlzrR07dlhr1qyxHnnkESs8PNztGH/KaZsnTpxohYSEWGPHjrUOHTrk2k6dOuU6Ji9+rgk+AeSDDz6wypcvb4WGhlq33nqrtWrVKtdzzZs3t3r27Ol6nJKSYg0bNsyqXLmyFR4ebsXFxVl//etf3X4ZPvzww1aZMmWs0NBQq1y5ctbDDz9sbd++PQ9blD05affixYut6tWrW2FhYVaJEiWs7t27WwcOHMjROQOBt9sc6J/1okWLLEkZtvR29uzZ02revHmG19SrV88KDQ214uPjrfHjx2c4b6B/zr5od0H8rDM7vkKFCm7HTJ061brlllus0NBQq2bNmtasWbPypkHZ5It2v/jii66/36VKlbLatWtnrV27Nu8adQM5bXPz5s2ve3w6X/9cOywri+siAAAABQxjfAAAgG0QfAAAgG0QfAAAgG0QfAAAgG0QfAAAgG0QfAAAgG0QfAAAgG0QfAAEJIfDoe+++87fZUiShg0bpnr16nn02u7du+uNN97wbkGZGDRokP72t7/5/H2A/I7gAwBX8Wbg2rBhg2bPnq0+ffp45XzX89JLL+nzzz/Xzp07ff5eQH5G8AEAH/nggw/UuXNnFS5c2OfvFRMTo9atW+ujjz7y+XsB+RnBB7C5mTNnqlixYkpNTZUkrV+/Xg6HQ4MGDXId8+STT+ovf/mLJOn48eN69NFHVa5cOUVGRqp27dr6+uuvXcd+/PHHKlu2rNLS0tzep2PHjnr88cddj2fMmKEGDRooPDxc8fHxSkhI0OXLl7Osc9++ferSpYuKFSum4sWLq2PHjtq9e7fr+V69eqlTp04aNWqUypQpoxIlSui5555TSkqK65hDhw6pffv2ioiIUKVKlTRp0iRVrFhR7733niSpYsWKkqQHHnhADofD9Tjdl19+qYoVK6po0aJ65JFHdPbs2SzrTU1N1X/+8x916NDBbX9mPUrFihXThAkTJEm7d++Ww+HQ1KlTdccddygiIkKNGzfWtm3b9Msvv6hRo0YqXLiw2rZtq6NHj7qdp0OHDpo8eXKWNQEg+AC2d8cdd+js2bNat26dJGnJkiWKiYnR4sWLXccsWbJELVq0kCRdvHhRDRs21KxZs7Rp0yY99dRT6t69u1avXi1J6ty5s44fP65Fixa5Xn/ixAnNmTNH3bp1kyQtXbpUPXr00AsvvKDNmzdr3LhxmjBhgkaMGJFpjSkpKWrdurWKFCmipUuXavny5SpcuLDatGmjS5cuuY5btGiRduzYoUWLFunzzz/XhAkTXIFCknr06KGDBw9q8eLFmjZtmj7++GMdOXLE9fwvv/wiSRo/frwOHTrkeixJO3bs0HfffaeZM2dq5syZWrJkid56660sv6+//vqrTp8+rUaNGl3v25+loUOHasiQIVq7dq1CQkLUtWtXDRw4UO+//76WLl2q7du369VXX3V7za233qr9+/e7BUIA1/DqkqcA8qUGDRpY77zzjmVZltWpUydrxIgRVmhoqHX27Flr//79liRr27ZtWb6+ffv2Vv/+/V2PO3bsaD3++OOux+PGjbPKli1rpaamWpZlWffcc4/1xhtvuJ3jyy+/tMqUKeN6LMn69ttvXc9VrVrVSktLcz2fnJxsRUREWHPnzrUsy6wEXaFCBevy5cuuYzp37mw9/PDDlmVZ1pYtWyxJ1i+//OJ6/o8//rAkWWPGjMn0fdMNHTrUioyMtM6cOePaN2DAAKtJkyZZfk++/fZbKzg42K3mrM5ftGhR1yrsu3btsiRZn376qev5r7/+2pJkLVy40LXvzTfftKpWrep2ntOnT1uSrMWLF2dZF2B39PgAUPPmzbV48WJZlqWlS5fqwQcfVPXq1bVs2TItWbJEZcuW1c033yzJXMJ57bXXVLt2bRUvXlyFCxfW3LlztXfvXtf5unXrpmnTpik5OVmSNHHiRD3yyCMKCjL/5GzYsEHDhw9X4cKFXVvv3r116NAhnT9/PkN9GzZs0Pbt21WkSBHX8cWLF9fFixe1Y8cO13E1a9ZUcHCw63GZMmVcPTpbt25VSEiIGjRo4Hq+SpUqio6Oztb3qGLFiipSpEim587MhQsXFBYWJofDka3zX6tOnTquP5cqVUqSVLt2bbd9175/RESEJGX6PQRghPi7AAD+16JFC3322WfasGGDnE6nqlWrphYtWmjx4sU6efKkmjdv7jr2nXfe0fvvv6/33ntPtWvXVqFChfTiiy+6XXLq0KGDLMvSrFmz1LhxYy1dulRjxoxxPZ+UlKSEhAQ9+OCDGWoJDw/PsC8pKUkNGzbUxIkTMzwXGxvr+rPT6XR7zuFwZBhr5KmcnjsmJkbnz5/XpUuXFBoaet1zp4+vyur90sPTtfuuff8TJ05Icv+eAHBH8AHgGuczZswYV8hp0aKF3nrrLZ08eVL9+/d3Hbt8+XJ17NjRNdg5LS1N27ZtU40aNVzHhIeH68EHH9TEiRO1fft2Va1a1a2npUGDBtq6dauqVKmSrfoaNGigKVOmqGTJkoqKivKojVWrVtXly5e1bt06NWzYUJK0fft2nTx50u04p9OZaRDJqfR5fzZv3pxhDqDDhw+7/nz06FElJSXl+v0kadOmTXI6napZs6ZXzgcURFzqAqDo6GjVqVNHEydOdA1ivvPOO7V27Vpt27bNrcfn5ptv1vz587VixQpt2bJFTz/9tNsv8nTdunXTrFmz9Nlnn7kGNad79dVX9cUXXyghIUG//fabtmzZosmTJ2vIkCGZ1tetWzfFxMSoY8eOWrp0qXbt2qXFixerT58+2r9/f7baWK1aNbVs2VJPPfWUVq9erXXr1umpp55SRESE2+WoihUrauHChUpMTMwQinIiNjZWDRo00LJlyzI8N2bMGK1atUpbtmzRs88+K8lcijt+/LjH7yeZQePpd4IByBzBB4AkM84nNTXVFXyKFy+uGjVqqHTp0qpatarruCFDhqhBgwZq3bq1WrRoodKlS6tTp04Zznf33XerePHi2rp1q7p27er2XOvWrTVz5kzNmzdPjRs31m233aYxY8aoQoUKmdYWGRmpn376SeXLl3eNP3riiSd08eLFHPUAffHFFypVqpTuvPNOPfDAA+rdu7eKFCnidnnt3Xff1fz58xUXF6f69etn+9yZefLJJzO9PNemTRs98sgjatSokW666SY999xzGjt2rDZt2pSr95s8ebJ69+6dq3MABZ3DsizL30UAgD/s379fcXFxWrBgge655x6vn//ChQuqWrWqpkyZoqZNm0oyY3O+/fbbTMNibvzwww/q37+/fv31V4WEMIoByAo/HQBs48cff1RSUpJq166tQ4cOaeDAgapYsaLuvPNOn7xfRESEvvjiCx07dswn57/auXPnNH78eEIPcAP8hACwjZSUFL388svauXOnihQpombNmmnixIkZ7tjypvRLh7725z//OU/eB8jvuNQFAABsg8HNAADANgg+AADANgg+AADANgg+AADANgg+AADANgg+AADANgg+AADANgg+AADANgg+AADANv4fV4VP2lp2qD4AAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "transmission = abs(sim_data_final[\"mode\"].amps.sel(direction=\"+\")) ** 2\n", + "transmission_db = 10 * np.log10(transmission)\n", + "wavelength = td.C_0 / transmission.f\n", + "\n", + "plt.plot(wavelength, transmission_db, c=\"red\", linewidth=3)\n", + "plt.xlabel(\"wavelength (μm)\")\n", + "plt.ylabel(\"transmission (dB)\")\n", + "plt.ylim(-10, 0)\n", + "plt.grid()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "269a485f-cfec-42a3-88f7-97a24ebef5a1", + "metadata": {}, + "source": [ + "It seems to perform quite well! Let's export the simulation to a GDS file for fabrication!" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "58734838-82a9-434f-804e-632df1276407", + "metadata": {}, + "outputs": [], + "source": [ + "# uncomment below to export\n", + "\n", + "# sim_final.to_gds_file(\n", + "# fname=\"./misc/invdes_crossing.gds\",\n", + "# z=0,\n", + "# frequency=freq0,\n", + "# permittivity_threshold=(eps_mat + 1) / 2.0\n", + "# )" + ] + }, + { + "cell_type": "markdown", + "id": "defd1181-7b47-4f52-971d-1be05c4170aa", + "metadata": {}, + "source": [ + "## Other Examples\n", + "\n", + "Here are some other selected inverse design examples if you want to explore more!\n", + "\n", + "- [Mode converter](https://docs.flexcompute.com/projects/tidy3d/en/latest/notebooks/Autograd3InverseDesign.html)\n", + "- [Shape optimized taper](https://docs.flexcompute.com/projects/tidy3d/en/latest/notebooks/Autograd5BoundaryGradients.html)\n", + "- [Metalens optimization](https://docs.flexcompute.com/projects/tidy3d/en/latest/notebooks/Autograd7Metalens.html)\n", + "- [Wavelength division de-multiplexer](https://docs.flexcompute.com/projects/tidy3d/en/latest/notebooks/Autograd9WDM.html)" + ] + } + ], + "metadata": { + "applications": [ + "Passive photonic integrated circuit components" + ], + "description": "This notebook demonstrates the inverse design of a compact waveguide bend with permittivity binarization and minimum feature size control.", + "feature_image": "./img/adjoint_18.png", + "features": [ + "Adjoint inverse design" + ], + "kernelspec": { + "display_name": "tidy3d-env", + "language": "python", + "name": "python3" + }, + "keywords": "inverse design, silicon photonics, waveguide bend, photonic integrated circuits, design optimization, topology optimization, adjoint, Tidy3D, FDTD", + "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.12.8" + }, + "title": "Topology Optimization of a Waveguide Bend in Tidy3D | Flexcompute" + }, + "nbformat": 4, + "nbformat_minor": 5 +}