{ "cells": [ { "cell_type": "markdown", "id": "f10c8f26", "metadata": {}, "source": [ "# 8-channel mode and polarization (de)multiplexer" ] }, { "cell_type": "markdown", "id": "106c2164", "metadata": {}, "source": [ "Note: the cost of running the entire notebook is larger than 1 FlexUnit.\n", "\n", "Mode-division multiplexing and polarization-division multiplexing on integrated photonic circuits are critical for large-bandwidth and high-speed optical communication networks. Here we introduce an 8-channel mode and polarization (de)multiplexer that is based on asymmetric directional couplers that operate on TE0 to TE3 as well as TM0 to TM3 modes. The design is based on [Wang, J., He, S. and Dai, D. (2014), On-chip silicon 8-channel hybrid (de)multiplexer enabling simultaneous mode- and polarization-division-multiplexing. Laser & Photonics Reviews, 8: L18-L22](https://onlinelibrary.wiley.com/doi/full/10.1002/lpor.201300157).\n", "\n", "The notebook is organized as the following: \n", "\n", "First, we use Tidy3D's [ModeSolver](https://docs.flexcompute.com/projects/tidy3d/en/v1.9.0rc1/_autosummary/tidy3d.plugins.ModeSolver.html?highlight=modesolver) to simulate the effective indices of the eight modes as a function of waveguide width. From the result, we can obtain the width of the bus waveguide in each directional coupler section to satisfy the phase match condition. \n", "\n", "Then, we model each directional coupler section individually to ensure good mode conversion efficiency. \n", "\n", "Lastly, once we confirm that good performance is achieved on each section, we build the whole 8-channel (de)multiplexer and simulate the whole device, which is about 200 $\\mu m$ in length. Thanks to the fast speed of Tidy3D solver, large simulations like these can be handled easily. \n", "\n", "The models in this notebook contain many waveguide bends. These bends can be defined natively in Tidy3D as demonstrated in the [Euler waveguide bend](https://docs.flexcompute.com/projects/tidy3d/en/v1.9.0rc1/notebooks/EulerWaveguideBend.html) example or the [waveguide Y junction](https://docs.flexcompute.com/projects/tidy3d/en/v1.9.0rc1/notebooks/YJunction.html) example. Alternatively, it is often easier to make use of `gdstk` as shown in the [GDSII import tutorial](https://docs.flexcompute.com/projects/tidy3d/en/v1.9.0rc1/notebooks/GDS_import.html). Here we will also demonstrate how to use `gdstk` to define the structures used in the simulation.\n", "\n", "" ] }, { "cell_type": "code", "execution_count": 1, "id": "f1046476", "metadata": { "execution": { "iopub.execute_input": "2023-02-03T02:34:08.431113Z", "iopub.status.busy": "2023-02-03T02:34:08.430662Z", "iopub.status.idle": "2023-02-03T02:34:10.095793Z", "shell.execute_reply": "2023-02-03T02:34:10.095345Z" } }, "outputs": [ { "data": { "text/html": [ "
[20:34:09] WARNING This version of Tidy3D was pip installed from the 'tidy3d-beta' repository on __init__.py:103\n", " PyPI. Future releases will be uploaded to the 'tidy3d' repository. From now on, \n", " please use 'pip install tidy3d' instead. \n", "\n" ], "text/plain": [ "\u001b[2;36m[20:34:09]\u001b[0m\u001b[2;36m \u001b[0m\u001b[31mWARNING \u001b[0m This version of Tidy3D was pip installed from the \u001b[32m'tidy3d-beta'\u001b[0m repository on \u001b]8;id=594279;file:///Users/twhughes/Documents/Flexcompute/tidy3d-docs/tidy3d/tidy3d/__init__.py\u001b\\\u001b[2m__init__.py\u001b[0m\u001b]8;;\u001b\\\u001b[2m:\u001b[0m\u001b]8;id=895082;file:///Users/twhughes/Documents/Flexcompute/tidy3d-docs/tidy3d/tidy3d/__init__.py#103\u001b\\\u001b[2m103\u001b[0m\u001b]8;;\u001b\\\n", "\u001b[2;36m \u001b[0m PyPI. Future releases will be uploaded to the \u001b[32m'tidy3d'\u001b[0m repository. From now on, \u001b[2m \u001b[0m\n", "\u001b[2;36m \u001b[0m please use \u001b[32m'pip install tidy3d'\u001b[0m instead. \u001b[2m \u001b[0m\n" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "
INFO Using client version: 1.9.0rc1 __init__.py:121\n", "\n" ], "text/plain": [ "\u001b[2;36m \u001b[0m\u001b[2;36m \u001b[0m\u001b[34mINFO \u001b[0m Using client version: \u001b[1;36m1.9\u001b[0m.0rc1 \u001b]8;id=337653;file:///Users/twhughes/Documents/Flexcompute/tidy3d-docs/tidy3d/tidy3d/__init__.py\u001b\\\u001b[2m__init__.py\u001b[0m\u001b]8;;\u001b\\\u001b[2m:\u001b[0m\u001b]8;id=340613;file:///Users/twhughes/Documents/Flexcompute/tidy3d-docs/tidy3d/tidy3d/__init__.py#121\u001b\\\u001b[2m121\u001b[0m\u001b]8;;\u001b\\\n" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "import numpy as np\n", "import matplotlib.pyplot as plt\n", "from matplotlib.gridspec import GridSpec\n", "import gdstk\n", "\n", "import tidy3d as td\n", "import tidy3d.web as web\n", "from tidy3d.plugins import ModeSolver" ] }, { "cell_type": "markdown", "id": "7bb676ae", "metadata": {}, "source": [ "The [ModeSolver](https://docs.flexcompute.com/projects/tidy3d/en/v1.9.0rc1/_autosummary/tidy3d.plugins.ModeSolver.html?highlight=modesolver) will check if the solved mode fields decay at the boundaries. When the field does not decay, a warning will be thrown. When we solve for more modes than the waveguide can support, spurious modes will appear and their fields most likely won't decay at the boundaries. We set the logging level to `error` mainly to avoid these warnings. \n", "\n", "In general, we do not recommend setting the logging level to `\"error\"` since most warnings are informative and can help troubleshoot your simulations." ] }, { "cell_type": "code", "execution_count": 2, "id": "c5c1d71d", "metadata": { "execution": { "iopub.execute_input": "2023-02-03T02:34:10.098289Z", "iopub.status.busy": "2023-02-03T02:34:10.098011Z", "iopub.status.idle": "2023-02-03T02:34:10.100188Z", "shell.execute_reply": "2023-02-03T02:34:10.099817Z" } }, "outputs": [], "source": [ "td.config.logging_level = \"error\"" ] }, { "cell_type": "markdown", "id": "a7d335b5", "metadata": {}, "source": [ "## Mode Indices Calculation" ] }, { "cell_type": "markdown", "id": "5e4cae7f", "metadata": {}, "source": [ "To obtain the width of the bus waveguide in each asymmetric directional coupler, we need to first calculate the relationship between the effective indices of each mode and the waveguide width. This can be achieved by using the [ModeSolver](https://docs.flexcompute.com/projects/tidy3d/en/v1.9.0rc1/_autosummary/tidy3d.plugins.ModeSolver.html?highlight=modesolver) from Tidy3D's plugins. This computation will be done on a local computer so it won't cost any FlexUnits.\n", "\n", "For the entire notebook, we will focus on the central wavelength of 1550 nm and a wavelength range from 1500 nm to 1600 nm.\n", "\n", "" ] }, { "cell_type": "code", "execution_count": 3, "id": "d91ebe00", "metadata": { "execution": { "iopub.execute_input": "2023-02-03T02:34:10.102279Z", "iopub.status.busy": "2023-02-03T02:34:10.102121Z", "iopub.status.idle": "2023-02-03T02:34:10.104789Z", "shell.execute_reply": "2023-02-03T02:34:10.104452Z" } }, "outputs": [], "source": [ "lda0 = 1.55 # central wavelength\n", "ldas = np.linspace(1.5, 1.6, 101) # wavelength range of interest\n", "\n", "freq0 = td.C_0 / lda0 # corresponding central frequency\n", "freqs = td.C_0 / ldas # corresponding frequency range\n", "\n", "fwidth = 0.5 * (np.max(freqs) - np.min(freqs)) # width of the excitation spectrum" ] }, { "cell_type": "markdown", "id": "2b036b2a", "metadata": {}, "source": [ "The structure is Si waveguide on silica substrate and top cladding. Therefore, we only need to define two materials. Within the wavelength range of interest, they can be considered lossless and dispersionless." ] }, { "cell_type": "code", "execution_count": 4, "id": "5b23e8e9", "metadata": { "execution": { "iopub.execute_input": "2023-02-03T02:34:10.106823Z", "iopub.status.busy": "2023-02-03T02:34:10.106665Z", "iopub.status.idle": "2023-02-03T02:34:10.108987Z", "shell.execute_reply": "2023-02-03T02:34:10.108630Z" } }, "outputs": [], "source": [ "n_si = 3.48 # silicon refractive index\n", "si = td.Medium(permittivity=n_si**2)\n", "\n", "n_sio2 = 1.44 # silicon oxide refractive index\n", "sio2 = td.Medium(permittivity=n_sio2**2)" ] }, { "cell_type": "markdown", "id": "31f7f875", "metadata": {}, "source": [ "The thickness of the waveguide is the standard 220 nm, which we will use throughout the notebook.\n", "\n", "Here we calculate the effective indices for the four TE modes (TE0-TE3) and the four TM modes (TM0-TM3) for waveguide width from 300 nm to 2500 nm." ] }, { "cell_type": "code", "execution_count": 5, "id": "472af715", "metadata": { "execution": { "iopub.execute_input": "2023-02-03T02:34:10.110987Z", "iopub.status.busy": "2023-02-03T02:34:10.110833Z", "iopub.status.idle": "2023-02-03T02:34:10.112943Z", "shell.execute_reply": "2023-02-03T02:34:10.112605Z" } }, "outputs": [], "source": [ "h = 0.22 # waveguide thickness\n", "ws = np.linspace(0.3, 2.5, 30) # range of waveguide width" ] }, { "cell_type": "markdown", "id": "55b3bd07", "metadata": {}, "source": [ "Define [ModeSpec](https://docs.flexcompute.com/projects/tidy3d/en/v1.9.0rc1/_autosummary/tidy3d.ModeSpec.html?highlight=modespec), [GridSpec](https://docs.flexcompute.com/projects/tidy3d/en/v1.9.0rc1/_autosummary/tidy3d.GridSpec.html), and [BoudnarySpec](https://docs.flexcompute.com/projects/tidy3d/en/v1.9.0rc1/_autosummary/tidy3d.BoundarySpec.html?highlight=boundaryspec) for the simulations. The number of modes is set to 4 to make sure TE0-TE3 (TM0-TM3) modes are always included, even though when the waveguide width is small, not all modes are supported. " ] }, { "cell_type": "code", "execution_count": 6, "id": "3fbb79f9", "metadata": { "execution": { "iopub.execute_input": "2023-02-03T02:34:10.114890Z", "iopub.status.busy": "2023-02-03T02:34:10.114740Z", "iopub.status.idle": "2023-02-03T02:34:10.117647Z", "shell.execute_reply": "2023-02-03T02:34:10.117276Z" } }, "outputs": [], "source": [ "N_mode = 4 # number of modes\n", "\n", "# define mode spec\n", "mode_spec = td.ModeSpec(num_modes=N_mode, target_neff=n_si)\n", "\n", "# define grid spec\n", "grid_spec = td.GridSpec.auto(min_steps_per_wvl=30, wavelength=lda0)\n", "\n", "# define boundary spec\n", "bound_spec = td.BoundarySpec.all_sides(boundary=td.PML())" ] }, { "cell_type": "markdown", "id": "faee33d5", "metadata": {}, "source": [ "The waveguide structure has a mirror symmetry with respect to the $xy$ plane. In this case, the TE and TM modes share different symmetries. Therefore, we can solve for the TE and TM separately by imposing the corresponding symmetry in the simulation. This way, the result looks cleaner.\n", "\n", "First, we use the `(0,0,1)` symmetry to get the effective indices of the TE modes. A for loop will be used to iterate over different waveguide widths. At each iteration, the effective indices of the first four TE modes will be calculated." ] }, { "cell_type": "code", "execution_count": 7, "id": "a8765bc5", "metadata": { "execution": { "iopub.execute_input": "2023-02-03T02:34:10.119558Z", "iopub.status.busy": "2023-02-03T02:34:10.119408Z", "iopub.status.idle": "2023-02-03T02:34:37.296002Z", "shell.execute_reply": "2023-02-03T02:34:37.295498Z" } }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/Users/twhughes/.pyenv/versions/3.10.9/lib/python3.10/site-packages/numpy/linalg/linalg.py:2139: RuntimeWarning: divide by zero encountered in det\n", " r = _umath_linalg.det(a, signature=signature)\n", "/Users/twhughes/.pyenv/versions/3.10.9/lib/python3.10/site-packages/numpy/linalg/linalg.py:2139: RuntimeWarning: invalid value encountered in det\n", " r = _umath_linalg.det(a, signature=signature)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/Users/twhughes/.pyenv/versions/3.10.9/lib/python3.10/site-packages/numpy/linalg/linalg.py:2139: RuntimeWarning: divide by zero encountered in det\n", " r = _umath_linalg.det(a, signature=signature)\n", "/Users/twhughes/.pyenv/versions/3.10.9/lib/python3.10/site-packages/numpy/linalg/linalg.py:2139: RuntimeWarning: invalid value encountered in det\n", " r = _umath_linalg.det(a, signature=signature)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/Users/twhughes/.pyenv/versions/3.10.9/lib/python3.10/site-packages/numpy/linalg/linalg.py:2139: RuntimeWarning: divide by zero encountered in det\n", " r = _umath_linalg.det(a, signature=signature)\n", "/Users/twhughes/.pyenv/versions/3.10.9/lib/python3.10/site-packages/numpy/linalg/linalg.py:2139: RuntimeWarning: invalid value encountered in det\n", " r = _umath_linalg.det(a, signature=signature)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/Users/twhughes/.pyenv/versions/3.10.9/lib/python3.10/site-packages/numpy/linalg/linalg.py:2139: RuntimeWarning: divide by zero encountered in det\n", " r = _umath_linalg.det(a, signature=signature)\n", "/Users/twhughes/.pyenv/versions/3.10.9/lib/python3.10/site-packages/numpy/linalg/linalg.py:2139: RuntimeWarning: invalid value encountered in det\n", " r = _umath_linalg.det(a, signature=signature)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/Users/twhughes/.pyenv/versions/3.10.9/lib/python3.10/site-packages/numpy/linalg/linalg.py:2139: RuntimeWarning: divide by zero encountered in det\n", " r = _umath_linalg.det(a, signature=signature)\n", "/Users/twhughes/.pyenv/versions/3.10.9/lib/python3.10/site-packages/numpy/linalg/linalg.py:2139: RuntimeWarning: invalid value encountered in det\n", " r = _umath_linalg.det(a, signature=signature)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/Users/twhughes/.pyenv/versions/3.10.9/lib/python3.10/site-packages/numpy/linalg/linalg.py:2139: RuntimeWarning: divide by zero encountered in det\n", " r = _umath_linalg.det(a, signature=signature)\n", "/Users/twhughes/.pyenv/versions/3.10.9/lib/python3.10/site-packages/numpy/linalg/linalg.py:2139: RuntimeWarning: invalid value encountered in det\n", " r = _umath_linalg.det(a, signature=signature)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/Users/twhughes/.pyenv/versions/3.10.9/lib/python3.10/site-packages/numpy/linalg/linalg.py:2139: RuntimeWarning: divide by zero encountered in det\n", " r = _umath_linalg.det(a, signature=signature)\n", "/Users/twhughes/.pyenv/versions/3.10.9/lib/python3.10/site-packages/numpy/linalg/linalg.py:2139: RuntimeWarning: invalid value encountered in det\n", " r = _umath_linalg.det(a, signature=signature)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/Users/twhughes/.pyenv/versions/3.10.9/lib/python3.10/site-packages/numpy/linalg/linalg.py:2139: RuntimeWarning: divide by zero encountered in det\n", " r = _umath_linalg.det(a, signature=signature)\n", "/Users/twhughes/.pyenv/versions/3.10.9/lib/python3.10/site-packages/numpy/linalg/linalg.py:2139: RuntimeWarning: invalid value encountered in det\n", " r = _umath_linalg.det(a, signature=signature)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/Users/twhughes/.pyenv/versions/3.10.9/lib/python3.10/site-packages/numpy/linalg/linalg.py:2139: RuntimeWarning: divide by zero encountered in det\n", " r = _umath_linalg.det(a, signature=signature)\n", "/Users/twhughes/.pyenv/versions/3.10.9/lib/python3.10/site-packages/numpy/linalg/linalg.py:2139: RuntimeWarning: invalid value encountered in det\n", " r = _umath_linalg.det(a, signature=signature)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/Users/twhughes/.pyenv/versions/3.10.9/lib/python3.10/site-packages/numpy/linalg/linalg.py:2139: RuntimeWarning: divide by zero encountered in det\n", " r = _umath_linalg.det(a, signature=signature)\n", "/Users/twhughes/.pyenv/versions/3.10.9/lib/python3.10/site-packages/numpy/linalg/linalg.py:2139: RuntimeWarning: invalid value encountered in det\n", " r = _umath_linalg.det(a, signature=signature)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/Users/twhughes/.pyenv/versions/3.10.9/lib/python3.10/site-packages/numpy/linalg/linalg.py:2139: RuntimeWarning: divide by zero encountered in det\n", " r = _umath_linalg.det(a, signature=signature)\n", "/Users/twhughes/.pyenv/versions/3.10.9/lib/python3.10/site-packages/numpy/linalg/linalg.py:2139: RuntimeWarning: invalid value encountered in det\n", " r = _umath_linalg.det(a, signature=signature)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/Users/twhughes/.pyenv/versions/3.10.9/lib/python3.10/site-packages/numpy/linalg/linalg.py:2139: RuntimeWarning: divide by zero encountered in det\n", " r = _umath_linalg.det(a, signature=signature)\n", "/Users/twhughes/.pyenv/versions/3.10.9/lib/python3.10/site-packages/numpy/linalg/linalg.py:2139: RuntimeWarning: invalid value encountered in det\n", " r = _umath_linalg.det(a, signature=signature)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/Users/twhughes/.pyenv/versions/3.10.9/lib/python3.10/site-packages/numpy/linalg/linalg.py:2139: RuntimeWarning: divide by zero encountered in det\n", " r = _umath_linalg.det(a, signature=signature)\n", "/Users/twhughes/.pyenv/versions/3.10.9/lib/python3.10/site-packages/numpy/linalg/linalg.py:2139: RuntimeWarning: invalid value encountered in det\n", " r = _umath_linalg.det(a, signature=signature)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/Users/twhughes/.pyenv/versions/3.10.9/lib/python3.10/site-packages/numpy/linalg/linalg.py:2139: RuntimeWarning: divide by zero encountered in det\n", " r = _umath_linalg.det(a, signature=signature)\n", "/Users/twhughes/.pyenv/versions/3.10.9/lib/python3.10/site-packages/numpy/linalg/linalg.py:2139: RuntimeWarning: invalid value encountered in det\n", " r = _umath_linalg.det(a, signature=signature)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/Users/twhughes/.pyenv/versions/3.10.9/lib/python3.10/site-packages/numpy/linalg/linalg.py:2139: RuntimeWarning: divide by zero encountered in det\n", " r = _umath_linalg.det(a, signature=signature)\n", "/Users/twhughes/.pyenv/versions/3.10.9/lib/python3.10/site-packages/numpy/linalg/linalg.py:2139: RuntimeWarning: invalid value encountered in det\n", " r = _umath_linalg.det(a, signature=signature)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/Users/twhughes/.pyenv/versions/3.10.9/lib/python3.10/site-packages/numpy/linalg/linalg.py:2139: RuntimeWarning: divide by zero encountered in det\n", " r = _umath_linalg.det(a, signature=signature)\n", "/Users/twhughes/.pyenv/versions/3.10.9/lib/python3.10/site-packages/numpy/linalg/linalg.py:2139: RuntimeWarning: invalid value encountered in det\n", " r = _umath_linalg.det(a, signature=signature)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/Users/twhughes/.pyenv/versions/3.10.9/lib/python3.10/site-packages/numpy/linalg/linalg.py:2139: RuntimeWarning: divide by zero encountered in det\n", " r = _umath_linalg.det(a, signature=signature)\n", "/Users/twhughes/.pyenv/versions/3.10.9/lib/python3.10/site-packages/numpy/linalg/linalg.py:2139: RuntimeWarning: invalid value encountered in det\n", " r = _umath_linalg.det(a, signature=signature)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/Users/twhughes/.pyenv/versions/3.10.9/lib/python3.10/site-packages/numpy/linalg/linalg.py:2139: RuntimeWarning: divide by zero encountered in det\n", " r = _umath_linalg.det(a, signature=signature)\n", "/Users/twhughes/.pyenv/versions/3.10.9/lib/python3.10/site-packages/numpy/linalg/linalg.py:2139: RuntimeWarning: invalid value encountered in det\n", " r = _umath_linalg.det(a, signature=signature)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/Users/twhughes/.pyenv/versions/3.10.9/lib/python3.10/site-packages/numpy/linalg/linalg.py:2139: RuntimeWarning: divide by zero encountered in det\n", " r = _umath_linalg.det(a, signature=signature)\n", "/Users/twhughes/.pyenv/versions/3.10.9/lib/python3.10/site-packages/numpy/linalg/linalg.py:2139: RuntimeWarning: invalid value encountered in det\n", " r = _umath_linalg.det(a, signature=signature)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/Users/twhughes/.pyenv/versions/3.10.9/lib/python3.10/site-packages/numpy/linalg/linalg.py:2139: RuntimeWarning: divide by zero encountered in det\n", " r = _umath_linalg.det(a, signature=signature)\n", "/Users/twhughes/.pyenv/versions/3.10.9/lib/python3.10/site-packages/numpy/linalg/linalg.py:2139: RuntimeWarning: invalid value encountered in det\n", " r = _umath_linalg.det(a, signature=signature)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/Users/twhughes/.pyenv/versions/3.10.9/lib/python3.10/site-packages/numpy/linalg/linalg.py:2139: RuntimeWarning: divide by zero encountered in det\n", " r = _umath_linalg.det(a, signature=signature)\n", "/Users/twhughes/.pyenv/versions/3.10.9/lib/python3.10/site-packages/numpy/linalg/linalg.py:2139: RuntimeWarning: invalid value encountered in det\n", " r = _umath_linalg.det(a, signature=signature)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/Users/twhughes/.pyenv/versions/3.10.9/lib/python3.10/site-packages/numpy/linalg/linalg.py:2139: RuntimeWarning: divide by zero encountered in det\n", " r = _umath_linalg.det(a, signature=signature)\n", "/Users/twhughes/.pyenv/versions/3.10.9/lib/python3.10/site-packages/numpy/linalg/linalg.py:2139: RuntimeWarning: invalid value encountered in det\n", " r = _umath_linalg.det(a, signature=signature)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/Users/twhughes/.pyenv/versions/3.10.9/lib/python3.10/site-packages/numpy/linalg/linalg.py:2139: RuntimeWarning: divide by zero encountered in det\n", " r = _umath_linalg.det(a, signature=signature)\n", "/Users/twhughes/.pyenv/versions/3.10.9/lib/python3.10/site-packages/numpy/linalg/linalg.py:2139: RuntimeWarning: invalid value encountered in det\n", " r = _umath_linalg.det(a, signature=signature)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/Users/twhughes/.pyenv/versions/3.10.9/lib/python3.10/site-packages/numpy/linalg/linalg.py:2139: RuntimeWarning: divide by zero encountered in det\n", " r = _umath_linalg.det(a, signature=signature)\n", "/Users/twhughes/.pyenv/versions/3.10.9/lib/python3.10/site-packages/numpy/linalg/linalg.py:2139: RuntimeWarning: invalid value encountered in det\n", " r = _umath_linalg.det(a, signature=signature)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/Users/twhughes/.pyenv/versions/3.10.9/lib/python3.10/site-packages/numpy/linalg/linalg.py:2139: RuntimeWarning: divide by zero encountered in det\n", " r = _umath_linalg.det(a, signature=signature)\n", "/Users/twhughes/.pyenv/versions/3.10.9/lib/python3.10/site-packages/numpy/linalg/linalg.py:2139: RuntimeWarning: invalid value encountered in det\n", " r = _umath_linalg.det(a, signature=signature)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/Users/twhughes/.pyenv/versions/3.10.9/lib/python3.10/site-packages/numpy/linalg/linalg.py:2139: RuntimeWarning: divide by zero encountered in det\n", " r = _umath_linalg.det(a, signature=signature)\n", "/Users/twhughes/.pyenv/versions/3.10.9/lib/python3.10/site-packages/numpy/linalg/linalg.py:2139: RuntimeWarning: invalid value encountered in det\n", " r = _umath_linalg.det(a, signature=signature)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/Users/twhughes/.pyenv/versions/3.10.9/lib/python3.10/site-packages/numpy/linalg/linalg.py:2139: RuntimeWarning: divide by zero encountered in det\n", " r = _umath_linalg.det(a, signature=signature)\n", "/Users/twhughes/.pyenv/versions/3.10.9/lib/python3.10/site-packages/numpy/linalg/linalg.py:2139: RuntimeWarning: invalid value encountered in det\n", " r = _umath_linalg.det(a, signature=signature)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/Users/twhughes/.pyenv/versions/3.10.9/lib/python3.10/site-packages/numpy/linalg/linalg.py:2139: RuntimeWarning: divide by zero encountered in det\n", " r = _umath_linalg.det(a, signature=signature)\n", "/Users/twhughes/.pyenv/versions/3.10.9/lib/python3.10/site-packages/numpy/linalg/linalg.py:2139: RuntimeWarning: invalid value encountered in det\n", " r = _umath_linalg.det(a, signature=signature)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/Users/twhughes/.pyenv/versions/3.10.9/lib/python3.10/site-packages/numpy/linalg/linalg.py:2139: RuntimeWarning: divide by zero encountered in det\n", " r = _umath_linalg.det(a, signature=signature)\n", "/Users/twhughes/.pyenv/versions/3.10.9/lib/python3.10/site-packages/numpy/linalg/linalg.py:2139: RuntimeWarning: invalid value encountered in det\n", " r = _umath_linalg.det(a, signature=signature)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/Users/twhughes/.pyenv/versions/3.10.9/lib/python3.10/site-packages/numpy/linalg/linalg.py:2139: RuntimeWarning: divide by zero encountered in det\n", " r = _umath_linalg.det(a, signature=signature)\n", "/Users/twhughes/.pyenv/versions/3.10.9/lib/python3.10/site-packages/numpy/linalg/linalg.py:2139: RuntimeWarning: invalid value encountered in det\n", " r = _umath_linalg.det(a, signature=signature)\n" ] } ], "source": [ "n_eff = np.zeros((len(ws), N_mode)) # placeholder for the effective indices\n", "\n", "# loop over the waveguide width and compute the effective indices at each iteration\n", "for i, w in enumerate(ws):\n", "\n", " # define the waveguide structure\n", " waveguide = td.Structure(geometry=td.Box(center=(0, 0, 0), size=(w, td.inf, h)), medium=si)\n", "\n", " sim_size = (6 * w, 0, 8 * h) # simulation domain size\n", "\n", " # define simulation\n", " sim = td.Simulation(\n", " size=sim_size,\n", " grid_spec=grid_spec,\n", " structures=[waveguide],\n", " sources=[],\n", " monitors=[],\n", " run_time=1e-11,\n", " boundary_spec=bound_spec,\n", " medium=sio2,\n", " symmetry=(0, 0, 1),\n", " )\n", "\n", " # define mode solver\n", " mode_solver = ModeSolver(\n", " simulation=sim,\n", " plane=td.Box(center=(0, 0, 0), size=sim_size),\n", " mode_spec=mode_spec,\n", " freqs=[freq0],\n", " )\n", "\n", " # solve for the modes\n", " mode_data = mode_solver.solve()\n", "\n", " # obtain the effective indices\n", " n_eff[i] = mode_data.n_eff.values" ] }, { "cell_type": "markdown", "id": "1a2ffc2d", "metadata": {}, "source": [ "After the indices are solved, we can plot them for visualization." ] }, { "cell_type": "code", "execution_count": 8, "id": "87edbe05", "metadata": { "execution": { "iopub.execute_input": "2023-02-03T02:34:37.298396Z", "iopub.status.busy": "2023-02-03T02:34:37.298225Z", "iopub.status.idle": "2023-02-03T02:34:37.509922Z", "shell.execute_reply": "2023-02-03T02:34:37.509499Z" } }, "outputs": [ { "data": { "text/plain": [ "Text(0, 0.5, 'Effective index')" ] }, "execution_count": 1, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjcAAAG6CAYAAAD07mc1AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8o6BhiAAAACXBIWXMAAA9hAAAPYQGoP6dpAACQ+0lEQVR4nOzdd3hUddrG8e+UZNJ7DwFCQu8I0psiKIhiQVEUWLsLKmLFAlYidl1dWHWV14IgnQVEkQ7Sey+hhwRSSG9TzvvHSQYCARJIciYzz+e65pozJ2eSOwzJPPlVnaIoCkIIIYQQTkKvdQAhhBBCiKokxY0QQgghnIoUN0IIIYRwKlLcCCGEEMKpSHEjhBBCCKcixY0QQgghnIoUN0IIIYRwKlLcCCGEEMKpSHEjhBBCCKcixY0QQgghnIqmxc2kSZNo1aoVfn5++Pn50blzZ37//fcrPmfGjBk0adIEDw8PWrZsyaJFi2oorRBCCCFqA02Lmzp16vDBBx+wZcsWNm/ezE033cSdd97Jnj17yr3+77//5oEHHuDRRx9l27ZtDBo0iEGDBrF79+4aTi6EEEIIR6VztI0zg4KC+Oijj3j00Ucv+dj9999PXl4eCxYssJ/r1KkTbdq0YfLkyTUZUwghhBAOyqh1gFJWq5UZM2aQl5dH586dy71m3bp1jBkzpsy5fv36MXfu3Mt+3qKiIoqKiuyPbTYbGRkZBAcHo9PpqiS7EEIIIaqXoijk5OQQFRWFXn/ljifNi5tdu3bRuXNnCgsL8fHxYc6cOTRr1qzca1NSUggPDy9zLjw8nJSUlMt+/oSEBN5+++0qzSyEEEIIbZw8eZI6depc8RrNi5vGjRuzfft2srKymDlzJsOHD2flypWXLXAqa+zYsWVae7Kysqhbty4nT57Ez8+vSr6GEEIIIapXdnY2MTEx+Pr6XvVazYsbd3d34uPjAbjhhhvYtGkTX3zxBf/5z38uuTYiIoIzZ86UOXfmzBkiIiIu+/lNJhMmk+mS86UztIQQQghRe1RkSInDrXNjs9nKjJG5UOfOnVm6dGmZc0uWLLnsGB0hhBBCuB5NW27Gjh3LbbfdRt26dcnJyWHq1KmsWLGCP/74A4Bhw4YRHR1NQkICAM899xw9e/bkk08+YcCAAUybNo3NmzfzzTffaPltCCGEEMKBaFrcnD17lmHDhpGcnIy/vz+tWrXijz/+4JZbbgHgxIkTZUZEd+nShalTp/LGG2/w2muv0bBhQ+bOnUuLFi20+haEEEII4WAcbp2b6padnY2/vz9ZWVlXHHNjtVoxm801mKz2cXd3v+p0PCGEEKIqVPT9GxxgQLGjURSFlJQUMjMztY7i8PR6PbGxsbi7u2sdRQghhLCT4uYipYVNWFgYXl5estDfZdhsNk6fPk1ycjJ169aVfychhBAOQ4qbC1itVnthExwcrHUchxcaGsrp06exWCy4ublpHUcIIYQAHHAquJZKx9h4eXlpnKR2KO2OslqtGicRQgghzpPiphzSxVIx8u8khBDCEUlxI4QQQginIsWNEEIIIZyKFDdOQKfTXfH21ltvcezYsct+fP369fbPtWLFCtq1a4fJZCI+Pp4pU6Zo940JIYQQ10BmSzmB5ORk+/H06dMZN24cBw4csJ/z8fEhLS0NgL/++ovmzZuXeX7pzLCjR48yYMAAnnrqKX755ReWLl3KY489RmRkJP369auB70QIIYS4flLcOIELd0X39/dHp9NdslN6aXETHBx82V3UJ0+eTGxsLJ988gkATZs2Zc2aNXz22WdS3AghhKg1pLi5CkVRKDBrM9XZ081QozOS1q1bR58+fcqc69evH6NHj66xDEIIIcT1kuLmKgrMVpqN+0OTr733nX54uVftS9SlS5dL9oPKzc0F1NWZw8PDy3wsPDyc7OxsCgoK8PT0rNIsQgghRHWQ4sbFTJ8+naZNm2odQwghhKg2Utxchaebgb3vaDPexNPNUOWfMyYmhvj4+HI/FhERwZkzZ8qcO3PmDH5+ftJqI4QQotaQ4uYqdDpdlXcNOarOnTuzaNGiMueWLFlC586dNUokhBBCVJ5rvGsLu/T0dFJSUsqcCwgIwMPDg6eeeoqvvvqKl19+mUceeYRly5bx22+/sXDhQo3SCiGEEJUni/i5mD59+hAZGVnmNnfuXABiY2NZuHAhS5YsoXXr1nzyySd89913Mg1cCCFEraJTFEXROkRNys7Oxt/fn6ysLPz8/Mp8rLCwkKNHjxIbG4uHh4dGCWsP+fcSQghRU670/n0xabkRQgghhFOR4kYIIYQQTkWKGyGEEEI4FSluhBBCCOFUpLgRQgghhFORdW6EEEKIWspqUzBbbZitNixWBbOt5N5qw2pT1JuiYLGeP7afv+hmsSnYFPXearNhLvk8pZ/PYlMwW2yYbQqWkq9ptipYbDbMlrJf28/DjYn3ttLs30WKGyGEEOIylJI3e/sbufWCN/2LC4sL3+xLjossNorMVoosNgpL7i88V2SxUmS2UVhyf+F1xZaSz2O76PNb1QLDbLXhqIu5hPqaNP36UtwIIYRwWBbr+Tf8wpKioPCCYkC9P188FJrVgqHQfGExYaW4pFgotqr3pUXGxedLj4vMVopLionaRKcDN70eo0GHUa/DoNdh0Osx6MGo15c8LrnpdGUfX3C+9PluBj1uBvXzqcc6jCWf391Q+nX0uBv1GPU6jAY97gYd3iZtywspboQQQlyR1aZQYLaWFA8XFg7qcUGxlcILCorCMsXG+YLjfOFw/r7IXmxY7UVHaZFRZLFic8DaQn0T1+Gm1+NW8qZuf+M3qI9L3+xNRgMmNz0eJfcmox4PNwMmo179WOnjcj7mbrygsNDrcTOqhUTp13ErOX++8FCLFyHFjRBCOB1FUSi22sgvspJXbCG/2EpekYXcIgt5RRZyCi32x7lFVnKLzOQVWcuczyuykFNyn19s1fpbAsDdoFcLBbfzRYHHBYWDh9Fwvjgo+VhpAeFu1Nvv3Q0l9xcUEaXnyrvm4sJCp5MCwtFJceMErvaDNn78eEaMGEFsbGy5H1+3bh2dOnUiOTmZF154gc2bN3P48GGeffZZPv/882pILIS4nEKzlXP5xWTmm8nMN5NVUMy5kuO8IotarFxUtOQXq48LLnhsqaYmD3ejHg+jHk93tZBQC4rSYsKAR0nR4VlaeFxQbFxcZJiMhkuKitJiw3TROZNRj15aJUQFSXHjBJKTk+3H06dPZ9y4cRw4cMB+zsfHh7S0NAD++usvmjdvXub5wcHBABQVFREaGsobb7zBZ599VgPJhXBOVptCdoGZ7EIz2QUWskqOswrMJUVLSfFScL6IKT0ustiqNIvJqMfbZMTTzYCvhxFvkxGfC27eJiM+HkZ8TAZ8TG54m0qucy89r17j7W6UAkPUGlLcOIGIiAj7sb+/Pzqdrsw5wF7cBAcHX/KxUvXr1+eLL74A4Pvvv6+mtELUDlabUlKMqC0nWQXFnMsz2wuVi4uW7AIzOYXqudwiy3V9baNeR4CXGwFe7gR4uhHg5Ya/p3tJcWLAy92Il7sBb3cjXqaSe/eS86bz573cDBgNspyZcD1S3FyNooA5X5uv7ealDn0XQly3nEIzp84VkJJdSFa++YKun2IyC8xqAVN6nFdMduH1FSgAXu4G/D3d8PNww8/TiL+nWqQEepUULF4lx57uJQWMG4He7ni7G2RchxDXQYqbqzHnw4Qobb72a6fB3btKP2WXLl3Q68v+JZebm1ulX0MILZQWL+ot/6L7ArIKzNf0eX1NRgK8yxYgfp5ulxQtfh7nP+bnYcTP0w03aTURQhNS3LiY6dOn07RpU61jCFEphWYrablFpOUWcza7kKTMi4uYihUvQd7uhPt5EHRBsRLg5Uagl7vaauLlfr47qKSQkQJFiNpHipurcfNSW1C0+tpVLCYmhvj4+Cr/vEJUlsVqIyOvmLM5RaTmFpFWcp+ac/6WVvK4ol1EQd7u1An0LLl5lTmODvDUfGExIUTNkJ/0q9HpqrxrSAhXUGyxkZRZwMmMfE5k5HMyI5+T59TjlKxC0vOKK7V0vLtBT6iviRAfd6KleBFCXIH8JnAx6enppKSklDkXEBCAh4cHANu3bwfUcTipqals374dd3d3mjVrVtNRhYNTFIW03OLzhUtJEXMiQ+0qSs4quOrqsnodBPuYCPUxEeprKilezh+r590J9fHAz9Mog2yFcAQ2GxRlQX6Geiso597oCbdO0CyiFDcupk+fPpec+/XXXxkyZAgAbdu2tZ/fsmULU6dOpV69ehw7dqymIgoHU2i2kpiay+GzuSSezeXQ2VyOpOZxIiOfAvOVV671cNNTN8iLukFe1An0sh9HBXgS5mci0MtdlosXQiuWIijMuuCWCQWZ54/zM6Dg3KWFS8E5UK6yHpN3mBQ3ouqMGDGCESNGXHK+fv36KBXoA6jINcI5ZRWY7QXM4ZJi5tDZHE6dK7hs95FOB5F+HsQEnS9cYkpudYO8CPFxl9YWIaqboqgFR+4ZyEmB3LPqccG5i4qXC4qYwiywFF7f13X3Ac8g8AosuQ86f+8dWiXf2rWS4kYIF1NotrIrKYv9ydkcOqsWMYfP5nI2p+iyzwnwciM+1If4MPUWF+ZD/WBvogI8MBkNNZheCBdiLoS8s2qxkpOiFiy5ZyE35YJzJYWM7dqWOgAdePiBh3/JLeD8sWfgBQVLcNnixTMQjKaq/G6rlBQ3Qji5lKxCtp44x5bj6m3P6SzM1vKbYsL9TDQM87UXMPGhPjQM9yHYW1pghKhSNptalGSdguxT6r39dlK9z0+v3Of0DASf8JJbmFqQlFe0XHgz+YHe+ZY7kOJGCCdittrYn5zDluMZbDmRydbj50jKLLjkuhAfE63r+BMf7mNvkYkL88HPw02D1EI4GZtNHZuSexayk0qKlaSyxUv26Yq1thjcLyhYSooW3wj13ifi/DmfMIduSalpmhY3CQkJzJ49m/379+Pp6UmXLl2YOHEijRs3vuLzPv/8cyZNmsSJEycICQnh3nvvJSEhwT7jRwhXcS6vmG0nz7fK7DiZdckgX70Omkb60a5uIDfUU291Aj2lJUaIyrCaIS9VLVjyUi9/nHsW8tOuPuAWQGcAvyjwr6Pe/KJLjmNKHkeprTHys1ppmhY3K1euZOTIkXTo0AGLxcJrr71G37592bt3L97e5a8tM3XqVF599VW+//57unTpwsGDBxkxYgQ6nY5PP/20hr8DIWpOkcXKvuQcdpzMZMepTHaczCQxNe+S6/w8jLSrF8gNJcVMq5gAfGT9FyEurzj/ghaW0taVksc5yWrBUphZ+c/rGXRBwVLOzScCDPKzWR00/VddvHhxmcdTpkwhLCyMLVu20KNHj3Kf8/fff9O1a1cefPBBQJ0F9MADD7Bhw4ZqzytETbHaFA6fzbUXMTtPZbE/JbvcsTINQr3thcwN9QKJC/VBL9OrhVBV5dgWnUGdBeQTqk51vvDYJwy8Q84fewWDQbp5teJQJWNWVhYAQUFBl72mS5cu/Pzzz2zcuJEbb7yRI0eOsGjRIh5++OFyry8qKqKo6PwskOzs7KoNLcR1UhSFkxkF7DiVyc5Tmew4lcXupCzyiy9dQybI251WdfxpXSeA1jH+tIkJJMjbXYPUQjgQRYG8NEg/DOmH1Pu0w+r9uaNgLb7653D3Lad1JQb8Is8XLB4BTjn41hk5THFjs9kYPXo0Xbt2pUWLFpe97sEHHyQtLY1u3bqhKAoWi4WnnnqK1157rdzrExISePvtt6srthDX5GRGPvN3nGbj0Qx2nsrkXP6lAwu93A20jPandUyAvaCRsTLCpRXnQ0Zi2eKltJgpzLr88y4e23Jh8VJ67OFfc9+HqHYOU9yMHDmS3bt3s2bNmitet2LFCiZMmMC///1vOnbsyOHDh3nuued49913efPNNy+5fuzYsYwZM8b+ODs7m5iYmCrPL8TVZOYXs3BXMnO2JrH5+LkyH3Mz6Gga6XdBq0wAcaE+snqvcB2lC9HlJEN2MuScPn9/7phazGSfusIn0EFADATHQ3BD9T4kHoLi1HEvMrbFpTjEqz1q1CgWLFjAqlWrqFOnzhWvffPNN3n44Yd57LHHAGjZsiV5eXk88cQTvP766+gvajI0mUyYTDI9TmijyGJl+f5U5mw7xfL9qRRb1RkUOh10jQvhlmbhtI4JoGmkryyGJ5yX1awuOJeTrE6BLnOfrA7mzUkBy6XLFlzCM7Bs8VJazATFgptn9X8volbQtLhRFIVnnnmGOXPmsGLFCmJjY6/6nPz8/EsKGIPBYP98ruhq3RTjx49nxIgRl/33XbduHZ06dWL27NlMmjSJ7du3U1RURPPmzXnrrbfo169fdcR2WoqisPn4OeZsS2LhzmSyCs53OTWJ8OXudtHc0TqaCH9ZukA4mYJMSDsEaQcg9QCkHVTvM49XbGo0lMwwigLfSHW8i29USYtMQwhpqK6OK8RVaFrcjBw5kqlTpzJv3jx8fX3tu1X7+/vj6alW4MOGDSM6OpqEhAQABg4cyKeffkrbtm3t3VJvvvkmAwcOtBc5riY5Odl+PH36dMaNG8eBAwfs53x8fEhLSwPgr7/+onnz5mWeHxwcDMCqVau45ZZbmDBhAgEBAfzwww8MHDiQDRs2lNlQU5TvSGouc7clMWd7Eiczzv8FGu5nYlCbaAa1jaZppJ+GCYWoAoqitrKkHYDUg2ULmdwzl3+e3qgWKn6RJYVLVPn3blL0i+unaXEzadIkAHr16lXm/A8//GDf/PHEiRNlWmreeOMNdDodb7zxBklJSYSGhjJw4EDef//9mortcCIiIuzH/v7+6HS6MucAe3ETHBx8ycdKff7552UeT5gwgXnz5vG///1PipvLSM8t4n87TjNn+2l2nMy0n/d2N3Bri0jubhdNpwbBMnZG1E7mAkjeAac2wZm9aiGTdgiKrjDr1DdKbWEJbQwhjdT74IbqSroy00jUEM27pa5mxYoVZR4bjUbGjx/P+PHjqylVWYqiUFCRfuBq4GnUdmaMzWYjJyfnilPzXZHNprA2MY2f1x9n6b6zWGzq/2ODXkf3hiHc1Taavs0i8HR3zZZEUUspCmQcgVOb1WLm1CY4sxtslkuv1ekhMLZsARPSWC1qPKR1UmjPIQYUO7ICSwEdp3bU5GtveHADXm5eVfo5u3TpcsmYpdzc3HKv/fjjj8nNzeW+++6r0gy11bm8YmZuOcUvG45zLD3ffr5ltD93tY1mYOsoQn1l8LqoJQoyIWmLWswkbVbvCzIuvc4nHOp0gMjW5wuZoAayj5FwaFLcuJjp06fTtGnTq143depU3n77bebNm0dYWFgNJHNMiqKw7WQmP68/zoKdyRRb1EGRPiYjd7eLZmjHejSO8NU4pRBXYTVD6v6SFpmSQibtwKXXGUwQ1Qai20Od9mpR419H9jYStY4UN1fhafRkw4PabO3gaaz6aY0xMTHEx8df8Zpp06bx2GOPMWPGDPr06VPlGWqDvCILc7cn8cv6E+xNPj++oFmkHw91qsedbaLwlv2ahCPKz1C7k1J2QcpuOLNLHfBb3iq9gbFqAVOnpJgJbwlGWfFa1H7y2/kqdDpdlXcNObJff/2VRx55hGnTpjFgwACt49S4Ayk5/Lz+OHO2JZFbpI41MBn13N4qioc61aVNTICsECwcg82qjpFJ2VVSzOxW77OTyr/e5AfR7dRiprRlxjukZjMLUUOkuHEx6enp9in3pQICAvDw8GDq1KkMHz6cL774go4dO9qv8/T0xN/feZcmL7JYWbw7hZ/XH2fTsfMrBzcI8ebBjnW594Y6BHjJX7NCQzYrnN6m3kqLmbP7wJxf/vUB9SCiJYS3gIgW6n1APZmtJFyGFDcuprxupl9//ZUhQ4bwzTffYLFYGDlyJCNHjrR/fPjw4UyZMqUGU9aMpMwCfl5/nN82nSQ9T22yN+h19G0WzkOd6tElLlhaaYR28tLg8FI49CckLlW3JriY0RPCm5UUMSXFTHhzmbEkNGG1WUnKTeJw5mGKrEXcFnubZlmkuHEyI0aMsK8RdKH69etfder9xdPunZGiKGw6do4f1h7ljz0plMziJsLPgwdurMuQG2MI95NFxIQGbDa1ZebwErWgSdoKXPAz6+EPMR0vaJFpqc5a0suSA6Jm2RQbSblJJGYmcjjzMImZiSRmJnIk6whF1iIAIr0jpbgRoroVmq3M33GaKWuPlRkg3DU+mGGd63NzkzCMBmmyFzUsPwMSl8GhJXD4L8hPK/vxiJbQsC/E36KOlZHNH0UNsik2kvOSyxQxhzMPczTr6GXXf3PXu9MgoAHxAfFYbVYMGhXf8pMinFpKViE/rz/O1I0nyCjpevJw03N3uzqM6FKfRuEyjVvUIJsNUnaWFDNL1KnZF+655O4Lcb1LCpo+6lYFQlSzfHM+J3NOciz7GMeyjnE8+zhHs46SmJV42SLGTe9GrH8scQFxxAfE2+/r+NTRrKC5kBQ3wukoisLWE+f4Ye0xFu9Osa8gHB3gybDO9bi/Q4wMEBY1Jz8DjixXx88c/uvS/ZfCmkHDW9SCJqYjGNy0ySmcmsVmITk3maPZRzmefZzj2cftxcyZ/MvvCWbUG6nvV79MARMXEEeMbwxGveOWEI6bTIhKKrJYWbgzmSl/H2PnqSz7+Y6xQfyja336NA2XridR/Ww2SN4Gh/5Si5mkzWVbZ9y81daZ+D5qUeNfR7uswunYFBvHso6xI3UHR7OO2ouZkzknsZS3lUaJAFMA9fzqUc+vHvX96lPPrx7xAfHE+MXgpq99BbcUN6LWO5tTyC/rT/DLhhOk5aqD2dyNega1iWJEl1iaRcnMEVHNSmc2Hf5LndmUn17246FNoWEftaCp21m2LhBVJt+cz660XWw/u50dqTvYkbqD7OLyNzY1GUzU9atLfb/69gKmtJgJ8Aio2eDVTIobUWtZrDY+/OMAP6w9itmqdj1F+HnwcOd6PHBjXYK8petJVBObVd3C4PBf6tiZ09spM7PJ3RfieqnFTHwfaZ0RVUJRFJJyk9ieup0dZ9VC5sC5A9gubBkEPAweNA9pTpOgJvYipr5ffcK9w9HrXKP1WoobUStlF5oZNXUbqw6mAnBDvUD+0bU+/ZpH4CZdT6I65Jw5X8wkLofCzLIfj2hZUszcAjE3ytgZcd2KrcXsTd/LjtQdbD+7ne2p20krSLvkukjvSNqEtqF1WGvahLWhUWCjWtmVVJWkuBG1zvH0PB79v80cPpuLh5ueT+9rQ/+WMqtEVDGrRZ3NdHiJOrspZWfZj3v4Q9xNajETfzP4RmiTUzgNs83MnrQ9rEtex4bkDexM3YnZZi5zjVFvpFlQM1qHtaZ1qHqL8Jb/exeT4kbUKuuPpPPUz1vIzDcT4efBd8Pb0yLaebeGEDUsJ0VtnTm0RJ3hVJhV9uNRbc+3zkTfIOvOiOuiKAqJmYmsT17P+uT1bD6zmTxzXplrgjyCaB2qtsi0CW1Ds+BmeBhlodGrkZ9MUWtM33SC1+fsxmJTaF3Hn2+HtSdMVhMW1+NqrTOegWrrTMO+EHcz+IRqk1M4jZS8FHsxsyF5wyXdTP4mfzpGdKRjpHqr61tXtoG5BlLcOIGr/ccfP348I0aMIDY2ttyPr1u3jk6dOrFmzRpeeeUV9u/fT35+PvXq1ePJJ5/k+eefr47YFWa1KSQs2sd3a44CcHurSD4e3BoPN+0XihK1UIVaZ25Rp2lH3yDbG4jrklWUxaaUTfZi5lj2sTIf9zB40C68HZ0iO9ExsiNNgpq4zKDf6iTFjRNITk62H0+fPp1x48Zx4MAB+zkfHx/S0tS/Dv766y+aN29e5vnBwcEAeHt7M2rUKFq1aoW3tzdr1qzhySefxNvbmyeeeKIGvpNL5RSaefbXbSw/oA4cHt2nIc/d3FD+khGVd3ITLH8Pjqwoe94zUG2VaXiLtM6I61K6xszu9N3sSt3FrrRd7MvYV2Y2k16np0VwCzpGdqRzVGdah7bG3SAzO6uaFDdOICLi/GAyf39/dDpdmXOAvbgJDg6+5GOl2rZtS9u2be2P69evz+zZs1m9erUmxc3JjHwe/b9NHDyTi8mo55P7WnN7q6gazyFquZRdsOx9OPj7+XP21pm+EN1OWmdEpSmKQkpeCrvTd7M7Tb3tTd9Lrjn3kmsb+DegY2RHOkV2on1Ee/zcZe2t6ibFzVUoioJSUP7eGtVN5+mpaQvFtm3b+Pvvv3nvvfdq/GtvOpbBkz9tISOvmDBfE98Oa0/rmIAazyFqsbTDsPx92DNbfazTQ5sHocfLEFhP22yi1skszCxTyOxO2016Yfol13kYPGgW3IzmIc1pEdyCG8JvINw7XIPErk2Km6tQCgo40O4GTb52461b0Hl5Venn7NKlC3p92f7c3Nyyf2nUqVOH1NRULBYLb731Fo899liVZriaGZtP8tqcXZitCi2i/fhuWAci/GXgsKigzBOwciJs/xUUq3quxT3Q6zUIidc2m6gVFEXhRM4J/j79N9vObGNX2i5O5Z665DqDzkCjwEb2QqZFSAviAuIces8lVyGvgIuZPn06TZs2veI1q1evJjc3l/Xr1/Pqq68SHx/PAw88UO3ZrDaFDxfv5z+rjgDQv2UEnwxug6e7dBmICsg5A6s/gS0/gFXdAZ5Gt8FNr6sL7AlxBdnF2WxM3sja02tZd3odSblJl1xTz68eLUJa2AuZJkFNZFq2g5Li5ip0np403rpFs69d1WJiYoiPv/Jfr6Wzqlq2bMmZM2d46623qr24yS2yMHradv7ap+5O++xN8Yzu0wi9XgYOi6vIz4C1X8DGb8Ccr56L7QE3jYOYDtpmEw7LYrOwO203606vY+3ptexK21Vm4K9Rb6RdWDtujLiRlqEtaR7cHH+TrKlVW0hxcxU6na7Ku4ZqE5vNRlFRUbV+jVPn8nns/zazPyUHd6Oej+5txZ1toqv1awonUJQD6yfB3/+CopKNAut0gJvehAY9tc0mHNLp3NP2lpn1yevJKc4p8/FY/1i6RHWhS1QX2oe3x8vNdX/313ZS3LiY9PR0UlJSypwLCAjAw8ODr7/+mrp169KkSRMAVq1axccff8yzzz5bbXmW7T/DyzN3kpZbTKiviW8evoG2dQOr7esJJ2AugE3/hTWfnt99O7wF3PQGNLoVZJkAUaLYWmxvmVl3et0la8z4ufvRKbITXaK60DmqM1E+MhvTWUhx42L69Olzyblff/2VIUOGYLPZGDt2LEePHsVoNBIXF8fEiRN58sknqzxHZn4x7/xvL7O3qf3azSL9+G54e6ICqr4rTjiJ7NOw7WfY/D3klKztFBSnjqlpdhfoZeEzoa41s+XMFhYeWcifx/8s0zpj0BloFdrK3jrTPLg5BlkGwCnpFEVRtA5Rk7Kzs/H39ycrKws/v7JrDRQWFnL06FFiY2Px8JBBYldzrf9ef+5J4fW5u0nNKUKvg8e6N2DMLY1kxWFxKZsVDi+FLVPg4OLzs5/8Y6DnK9D6AdnfSQBw6NwhFhxZwKKji0jJO986HeYVRq86vegS1YUbI2/E191Xw5Tielzp/fti8ltB1JhzecW89b89zNt+GoC4UG8+GtyadtINJS6WlaS20mz9EbIvmIJbryvcMAKa3QlGk2bxhGNIyUvh96O/s+DIAg6eO2g/7+PmQ9/6fRkQO4Abwm+Q1hkXJMWNqBGLdyfzxtzdpOUWo9fBEz3iGN2nobTWiPNsVnXPp80/wKE/oHTmimcgtH4QbhgOoY21zSg0l12czV/H/2LhkYVsStmEgtr5YNQb6RHdg9vjbqdHnR6YDFL8ujIpbkS1Ss8tYtz8PSzcqY6RaBjmw0eDW9NGVhsWpbKSYNtPsPWnclpp/gFNB4KbdBO7smJrMauTVrPwyEJWnlxJsa3Y/rF2Ye24Pe52+tbrK1O1hZ0UN6LaLNyZzJvzdpORV4xBr+PpnnE8c3M8JqO01rg8m1XdlXvLlEtbadoMhXbDIbSRphGFdhRF4VTuKbac2cKmlE2sOLmC7OJs+8fj/OO4Pe52+sf2lxlOolxS3JTDxcZYX7PL/Tul5hQxbt5uft+tDuprEuHLR/e2pmUd+avK5ZkLYMNk2PgtZF+wAmy9btD+H9DkdmmlcUGKonAs+xibz2xmy5ktbE7ZzJn8M2WuCfMMo3+D/gxoMIDGgY013XdPOD4pbi7g5uYGQH5+Pp7VsDqwsykuVpuGDQa1JUZRFObvOM1b8/dwLt+MUa/jn73jGdU7HnejTNN1aTYb7J4Jf719vuvJM0jdyPKGERDSUNN4ombZFBuJmYn2YmbLmS2kFaSVucaoM9I8pDntw9vTJaqLDAwWlSLFzQUMBgMBAQGcPXsWAC8vL/nr4DJsNhupqal4eXlhNBo5m13I63N3s2Sv+tdW00g/Ph7ciuZR0lrj8o6vgz9eg9Nb1cd+ddS1aZrfLa00LsJqs3Lw3EE2n9nM5pTNbD27lcyizDLXuOvdaRXaihvCb6B9RHtah7bG0yh/ZIprI8XNRSIiIgDsBY64PL1eT926dfljzxlembWTrAIzbgYdo3o35J+943AzSGuNS8s4Cn+Nh73z1MfuPtDteeg8EtzkTcvZKYrCjtQdzDk8hyXHl1yy1YGn0ZPWoa1pH96eG8JvoGVoS5nhJKqMFDcX0el0REZGEhYWhtls1jqOQ3N3d+dYej7PTttGscVGi2g/Prq3NU0jr7y4knByBZmw+mPY8B91d26dHto+DL1fB99wrdOJapZWkMb8xPnMOTSnzHYH3m7etA1rS/vw9rSPaE+zoGa4Gdy0CyqcmhQ3l2EwGOxjSUT5FEXh9Tm7KbbY6N4whO9HdJDWGldmNauzn5ZPgIIM9VyD3tDvfQhvrmk0Ub3MNjOrTq1i7qG5rE5ajbVkJWlPoyd96/Xlzvg7aRvWFqNe3nJcgTUnB0tKCqaG2o2lk/9p4prN3HKKdUfS8XDT8/6gllLYuCpFgYN/wJ9vQPoh9VxIY7Woie8jG1k6scTMROYcmsP/jvyPjMIM+/k2oW24q+Fd9KvfD283bw0TippiTk4mZ9kycpcuI2/TJkxxcTSYO0ezPFLciGuSnlvE+4v2AfDczY2oG+ylcSKhiZRd8MfrcHSl+tgrGHq/Bu1GyJ5PTiq3OJfFxxYz5/AcdqbutJ8P9gjmjrg7GNRwEA38G2iYUNQERVEoOnCAnKVLyV26jMK9e8t+3GLGlpeH3lub4lZ++4hr8v7CfWTmm2kS4ctj3WO1jiNqWk4KLHtP3f8JBQzu0Olp6P4CeMgMOWejKAqbz2xm7uG5/HnsTwqthYC6y3aPOj24K/4uutXphptextA4M8VsJn/LFnKWLiN36VLMp0+f/6BOh2e7dvjedBO+N9+Ee/36muUEKW7ENVh9KJXZ25LQ6eCDe1pJd5Qrsdlg03fw11tgzlPPNb8L+rwFgfU1DCaqg02x8cexP5i0YxJHs47az8f6x3J3/N3cHnc7IZ4hGiYU1c2am0vemjVqQbNyJbbs8ytF6zw88O7aFd+bbsKndy+MQUHaBb2IpsVNQkICs2fPZv/+/Xh6etKlSxcmTpxI48ZX3hwvMzOT119/ndmzZ5ORkUG9evX4/PPP6d+/fw0ld12FZitvzN0NwLBO9WSPKFeSdQrm/vN8F1T0DdAvAep21DaXqHKKorDs5DK+2vYVhzMPA+psp1vr38pdDe+iVUgrWQPMiZmTk8lduZKcpcvIX78e5YKZw4agIHx698L35pvx7twZvYMueKtpcbNy5UpGjhxJhw4dsFgsvPbaa/Tt25e9e/fifZl+uuLiYm655RbCwsKYOXMm0dHRHD9+nICAgJoN76K+XHqI4+n5RPh58GI/2aHZJSgK7JgGv78MRdlg9IRb3oEOj4FeWu2ciaIorD29lq+2fcWe9D0A+Lr5MqLFCIY2HSqDg52UraiI/E2byVu9mty1ayg+nFjm4+716uFz88343nwTnm3aoKsFM4k1LW4WL15c5vGUKVMICwtjy5Yt9OjRo9znfP/992RkZPD333/bt0uor3HfnqvYn5LNN6uOAPD2nc3x9ZD+daeXmwoLRsP+BerjOh1g0GQIidc0lqh6m1I28dW2r9h6Vl1J2tPoyUNNH2J48+Gy27aTURSF4qPHyFuzmtzVa8jftAmlsPD8BXo9nq1a4VM6fqZBg1rXUudQY26ysrIACLpCv938+fPp3LkzI0eOZN68eYSGhvLggw/yyiuvlLsuTVFREUVFRfbH2Rf0F4qKs9kUxs7ehcWm0LdZOP2aR2gdSVS3fQvgf89Bfhro3aDXq9B1tMyCcjI7Unfw1bavWJ+8HgCTwcSQxkN4pOUjBHk4zhgKcX2subnkr19P7uo15K1eXXYwMGAMD8e7W1d8unfHu3NnDP61u6B1mN9SNpuN0aNH07VrV1q0aHHZ644cOcKyZcsYOnQoixYt4vDhw/zzn//EbDYzfvz4S65PSEjg7bffrs7oLuGXDcfZdiITH5ORt++UBdmcWmEW/P4q7JiqPg5rBnf9ByJbaZtLVKn9Gfv5attXrDyljqEy6o3c0/AeHm/5OOHespJ0bafYbBTu20fe6jXkrVlD/vbtYLHYP65zc8OrQ3u8u3bDu3s3TA0b1rrWmSvRKYqiaB0C4Omnn+b3339nzZo11KlT57LXNWrUiMLCQo4ePWpvqfn000/56KOPSE5OvuT68lpuYmJiyMrKws9PtgmoiJSsQm75dCU5RRbevqM5w7vU1zqSqC5HVsDckSU7d+ug63PqujVG2fPHWRzJPMLX27/mz+N/AqDX6bkj7g6eav0U0T7RGqcT18t85iyZ06eTOWMGltTUMh9zr1cP7+7d8eneDa8OHdB71a71ybKzs/H396/Q+7dDtNyMGjWKBQsWsGrVqisWNgCRkZG4ubmV6YJq2rQpKSkpFBcX4+7uXuZ6k8mEySS/mK/HW/P3kFNkoU1MAA91qqd1HFEdivPV6d0b/6M+DoyFuyZD3U6axhJV52T2SSbtmMTCowuxKTZ06Lg19laebv00sf6yVlVtpigKBVu3cu6XX8j+c4m9hUbv5YVXp074dO+Gd7duuMfEaJy05mha3CiKwjPPPMOcOXNYsWIFsbFX/wHr2rUrU6dOxWazoS+ZqXHw4EEiIyMvKWzE9Vuy9wyL96Rg0OtIuLslBr3zNFuKEqc2w5wnIV2d8kv7R+CWd8Hko20uUSX2pO/hl72/8PvR37Eo6pveTTE3MbLtSBoFNtI4nbgetsJCshcsIOOXqRTt22c/73nDDQQ9NBTfm29G56Lvi5oWNyNHjmTq1KnMmzcPX19fUlJSAPD398ezZO78sGHDiI6OJiEhAVC7r7766iuee+45nnnmGQ4dOsSECRN49tlnNfs+nFVukYVx89Q1bR7v3kB2+3Y2lmJYORHWfAqKDXwj4Y6voGEfrZOJ62SxWVh+cjk/7/3ZPvsJoGt0V0a1GUWLkMuPaxSOr/hUEud+nUrWzFlYSybi6Ewm/AbeTtDQoXg0bapxQu1pWtxMmjQJgF69epU5/8MPPzBixAgATpw4YW+hAYiJieGPP/7g+eefp1WrVkRHR/Pcc8/xyiuv1FRsl/HxHwdIziokJsiT527WbndXUQ3O7IU5T6h7QwG0HAz9PwLPQG1zieuSXZzN7IOz+XX/r5zOU2fDGHVG+tbvy0NNH6JlaEuNE4prpSgK+evWkfHzL+QuX66uPwW4RUcT+OADBNxzDwZZ783OYQYU15TKDEhyZTtOZjLo32tRFPjxkRvp0ShU60iiqhxdBVPvB3M+eAbB7Z+qWyiIWuto1lF+2fcL8xPnU2ApACDQFMi9je5lSJMhhHmFaZxQXCtrbh5Z8+Zy7pepFB85Yj/v3aUzgQ89hE/PnrViUb2qUOsGFAvHYrbaeHX2LhQF7mwTJYWNM0lcDr8+AJYCiO0Bd38LvrJmUW2kKArrTq/j530/szpptf18fEA8Dzd7mP6x/fEwemiYUFyP4uPHyfjpZ7LmzMGWp+7jpvfywn/QIAKHPogpLk7jhI5Nihtxie/XHGVfcjb+nm68eXszreOIqnL4L5g2FCyF0LAv3PcTuMmbX21TYClgwZEF/LL3FxKz1GXydejoWacnDzV7iBsjbnSq9UpcTVFiImmT/0P2woXqRrWAe/36BA4div9dgzD4yED/ipDiRpRxMiOfz/46CMDr/ZsS4iPT6J3CwT9h+kNgLYJGt8F9/ydr19QyKXkpTNs/jZmHZpJVpA4i9TJ6cVfDu3iwyYPU9aurcUJxPQoPHCRt8iRyFv9hH0/j3aM7QcOG492lMzrZx61SpLgRdoqi8Mbc3RSabXSMDWJw+yuvOSRqiQO/w2/DwFoMTW6He38Ao2tOD62NrDYrP+39iX9t+xfFtmIAon2iGdp0KIPiB+Hr7qtxQnE9CvfuJW3SJHKW/GU/53PzzYQ8/TSeLWQ1+GslxY2w+9/OZFYeTMXdoGfC3S2ladsZ7FsAM0aAzQxN74B7vweDbHhaW5zMOckba96wT+duF9aO4c2H07NOTwx61xhE6qwKdu4k7d+TyF2xQj2h0+Hbrx8hTz+FR+PGmmZzBlLcCAAy84t55397ABjZO564UOnXrfX2zoOZj4DNAs3vhru/kcKmllAUhZmHZvLRpo8osBTgZfTilRtf4a74u+SPjlouf+tW0v49ibw1a9QTej1+/fsT8tSTmOLjtQ3nRKS4EQB88Pt+0nKLiQv15qleDbSOI67X7tkw6zFQrOoaNoMmy27etURqfirj/h7HmiT1ze+G8Bt4r+t71PGVbuLaLG/jRtL+PYn89eru6xgM+A8cSPCTT2CqwOr8onLkt51g87EMpm06CUDC3a0wGaW5u1bbOUNdoE+xQashMOjfIF0YtcLiY4t5b/17ZBVl4a5359l2z/Jws4fR62QwaW2kKAp5f/9N2qRJFGzeop40Ggm4axDBTzzhUns91TQpbgRfLlP3FLqvfR1ujA3SOI24Ljumwdyn1cKmzUNwx5dS2NQCWUVZvL/+fX4/9jsATYOaMqHbBOIDpZuiNrIVFpLz559k/PILhTt2AqBzc8P/3nsIeewx3KJl9/XqJsWNi9uXnM2qg6nodTCqt2yxUKtt+wXmjQQUaDcMbv8CZPqow1uTtIZxa8eRWpCKQWfg8VaP80SrJ3DTy/io2qbwwAEyf5tB1v/+hy07G1D3fAq47z6CH3sUt/BwjRO6DiluXNw3q9TlvPu3jKRusJfGacQ12/ojzH8WUNRdvft/IoWNg8s35/Px5o+ZcXAGAPX96pPQPUE2taxlbHl5ZC1aROaMmRTu3Gk/b4yKJOCeewi87z6MobLKe02T4saFnTqXz/wd6uZ6T/aQpbxrrc0/wILR6vGNT8BtH4LMqHFoW89s5fU1r3Mq9xQADzV9iOfaPSfbJdQSiqJQuHs3mb/NIHvhQmz5+eoHjEZ8b7qJgMGD1YX3XGTPJ0ckxY0L+37NMaw2ha7xwbSs4691HHEtNn4Li15Ujzs+DbcmSGHjwIqtxXy1/Sum7J6CgkKkdyTvdn2XjpEdtY4mKsCanU3W/P+ROXMmRfv328+716tHwH2D8R80CGNwsIYJRSkpblxUZn4x0zadAKTVptZaPxkWv6Iedx4Ffd+TwsaB7c/Yz9jVYzmcqQ7gHxQ/iJc7vCwrDDs4RVEo2LKFzBkzyF78B0pREQA6d3d8+/UjYPC9eHXoIOsPORgpblzUz+uPk19spWmkH90bhmgdR1TWms/hr/HqcdfR0OctKWwclNVm5Yc9P/D19q+x2CwEeQQxvvN4bqp7k9bRxBXYiovJnDGDc79MpfjIEft5U6NGBAwejP/A2zEEBGgXUFyRFDcuqNBsZcrfxwB4skcD+YujNrHZYMmbsO4r9XH3F+GmN6SwcVAns0/y2prX2J66HYCb697MuM7jCPKQJRcclWKxkDlnDmn/noQlORkAnZcXfv1vI3DwYDxatZLfmbWAFDcuaNbWU6TlFhMd4MmAVpFaxxEVZSlWp3rv+k19fMu70PVZbTOJcl28fYK3mzdjbxzLHXF3yBujg1JsNrIX/U7qv77EfFztsjeGhxP8xOP43zkIg4+3xglFZUhx42KsNoVvS6Z/P9otFjeDTBeuFYpy1Z29E5eC3gh3fg2th2idSpQjrSCN8X+PZ9WpVQB0iOjAe13fI8onSuNkojyKopC7bBmpX3xJ0cGDABiCggh+4nEChwxB7yEz2GojKW5czJK9KRxLz8ff0437O8jS37VCXjpMHQxJW8DNC+77ERreonUqUY4lx5fwzrp3yCzKlO0THJyiKOSt/ZvUL76gcNcuAPS+vgQ/+ghBDz+M3ltaamozKW5ciKIoTFqpttoM61wPb5O8/A4v8wT8dDekHwLPQHhwBsR00DqVuEhOcQ4fbPyA+YnzAWgS1IQJ3SbQMFBW/XZE+Vu3kvrZ5+Rv2gSoY2qCHn6Y4Ef+gcFflsVwBvLu5kI2Hs1gx8lM3I16hnepr3UccTVn9sLPd0NOMvjVgYdnQ2hjrVOJi2xM3sgba98gOS8ZvU7Poy0e5enWT+NmkO0THE3Bnj2kfvEFeatWA+p07sAHhhD8xBOyPo2TkeLGhfynZKzN4BvqEOJj0jiNuKLj6+DX+6EwC0KbwEOzwV8223MkhZZCvtz2JT/t/QmAOj51SOieQJuwNtoGE5coOnyY1C//Rc6ff6onDAYC7rmHkKefwi1SJlU4o0p3BE+ZMqXc8xaLhbFjx15vHlFNDqTksGz/WXQ6eLx7A63jiCvZvwh+GqQWNjEd4R+/S2HjYPam72XIgiH2wubeRvcy645ZUtg4GPPZs5x+5RWODLxDLWx0OvwGDiRu0UIi33lbChsnVuni5tlnn2Xw4MGcO3fOfu7AgQN07NiRX3/9tUrDiapTukHmrc0jqB8iA+Uc1tYfYfpQsBRCo1vh4bngJWuiOAqLzcI3O79h6MKhJGYlEuwRzNc3f834zuPxcpONZx2FoihkLVzIkYF3kDVvPigKvrf0IXbeXKI/+hD3evW0jiiqWaWLm23btnHq1ClatmzJkiVL+Prrr2nXrh1NmjRhx44d1ZFRXKfkrALmbU8C4Ike0mrjkBQFVn8C858BxQZthsL9v4C7vGE6iuPZxxmxeAT/2vYvLIqFW+rdwpw759CjTg+to4kLWM6dI+n5MZx+4UVsWVl4NG9O/Rm/Uedf/8KjUSOt44kaUukxN3Fxcaxdu5bRo0dz6623YjAY+L//+z8eeOCB6sgnqsD3a45isSl0jA2ibd1AreOIi9ls8MdY2DBZfSzbKTgURVH47cBvfLLlEwosBfi4+fBax9e4vcHtsiCfg8lZtozkN8dhTU8Ho5GQp58i5Ikn0LnJ4G5Xc00DihcuXMi0adPo3LkzBw8e5L///S89e/YkKkoWqXI0WQVmpm5QV9t8qqdskOlwLMUw9ynYPUt93G8CdB6pbSZhdzb/LOPWjmPt6bUAdIzoyLtd3yXSR8ZqOBJrdjZnJiSQNXcuAKaG8UR+8AGezZtrG0xoptLdUk8++SSDBw/mlVdeYfXq1ezcuRN3d3datmzJb7/9Vh0ZxXWYuuEEecVWGof70qtxqNZxxIWKctTF+XbPUlcdvvtbKWwcyOKji7lr3l2sPb0Wk8HEKx1e4Zu+30hh42By167lyB13qoWNXk/w449Rf9YsKWxcXKVbbtauXcuGDRto3bo1ABERESxatIivv/6aRx55hPvuu6/KQ4prU2Sx8v3ao4A61kaa0B2IuQD+7w44vRXcvOH+HyG+j9apBJBVlMX7G97n96O/A9AsuBkJ3RJoECDj1RyJLS+PMx9/TOav0wBwq1eXqIQP8GrXVuNkwhFUurjZsmULJtOla6SMHDmSPn3kl7MjmbstidScIiL9PRjYWroMHcrKiWph4xkIQ2dBnRu0TiSAv5P+5s21b3K24CwGnYHHWz3OE62ewE0vYzYcSf7mzZwe+xrmkycBCHzoIcLGPI/eSwbgC1WlixuTyURiYiI//PADiYmJfPHFF4SFhfH7779Tt27d6sgoroHNptgX7Xu0WyzuRtnbxmGk7Ia1X6rHd34thY0DyDfn8+mWT5l+YDoA9f3qM6HbBFqGttQ4mbiQraiI1M+/IGPKFFAUjFGRRE2YgHenTlpHEw6m0u94K1eupGXLlmzYsIHZs2eTm5sLwI4dOxg/fnyVBxTX5q99ZziSmoevh5EhN0rR6TBsVvjfs6BYoelAaDJA60Qub0fqDu5bcJ+9sHmwyYP8NvA3KWwcTMGuXRy9+x4yfvgBFAX/e++hwfz5UtiIclW65ebVV1/lvffeY8yYMfj6+trP33TTTXz11VdVGk5cu9JWm4c61cNHNsh0HJu+U3f3NvnBbR9qncalma1mJu+czHe7vsOm2AjzCuPdru/SJaqL1tHEBZTiYtImTybtP9+A1YohNITId97Bt3dvraMJB1bpd71du3YxderUS86HhYWRlpZWJaHE9dl8LIMtx8/hbtDzD9kg03FknYKl76jHfcaDn4yD0kpiZiJjV49lX8Y+AAY0GMDYG8fib5IdoR2FYjaTvWgRad9+S/HhRAD8+vcn/M03MAbKel3iyipd3AQEBJCcnExsbGyZ89u2bSM6Wva/cQSTV6qtNne3iybMz0PjNAJQVyBe+CIU56r7Rd3wiNaJXJJNsfHz3p/5YusXFNuK8Tf582anN+lXv5/W0UQJW34+mTNnkT7lByynkwEwBAQQ8dZ4/G69VeN0oraodHEzZMgQXnnlFWbMmIFOp8Nms7F27VpefPFFhg0bVh0ZRSUcPpvDX/vOqBtkylYLjmPffDj4O+jdYOAXoJcB3jXNarMyZsUYlp1cBkC36G680+UdQr1k/SdHYDl3jnO/TOXczz9jzcwEwBAcTNCwYQQ+MASDn5+2AUWtUuniZsKECYwcOZKYmBisVivNmjXDarXy4IMP8sYbb1RHRlEJ365S17W5pWk4caE+GqcRABRkwqKX1eNuz0NYU03juKpJOyax7OQyTAYTL3d4mcGNBsvaTw7AfPo06VOmkDljJkpBAQBuMTEEP/oI/oMGofeQ1mdReZUubtzd3fn2229588032b17N7m5ubRt25aGDRtWRz5RCWeyC5mzTd0g80nZasFxLH0bclMgOB66v6B1Gpe0/MRy/rPzPwCM7zyegXEDNU4kCg8eJOO//yVr4SKwWAAwNWtKyGOP4du3LzqjTIQQ1+6a//fUrVtX1rVxMD+sPUax1UaH+oHcUE8G3DmE4+tg8/fq8cAvwE3+Cq1px7OP89qa1wB1mrcUNtrK37KF9G+/I3fFCvs5r06dCH78Mby7dJHWNFElKlTcjBkzpsKf8NNPP73mMOLa5RSa+WX9cQCe6CGtNg7BUgT/e049bvsw1O+mbR4XlG/OZ/Ty0eSac2kb1pYX27+odSSXpNhs5K5YSfp331Gwdat6UqfDt29fgh97FM+WsqaQqFoVKm62bdtW5vHWrVuxWCw0btwYgIMHD2IwGLjhBllpVSu/bjxBTpGFuFBvbm4SpnUcAbD2C0g7AN6hcMs7WqdxOYqiMP7v8RzOPEyIZwif9PwEN4Nso1DT8tZv4Mz771F06DAAOjc3/AcNIuiRf2C6aNatEFWlQlM2li9fbr8NHDiQnj17curUKbZu3crWrVs5efIkvXv3ZsCAyq22mpCQQIcOHfD19SUsLIxBgwZx4MCBCj9/2rRp6HQ6Bg0aVKmv62ysNoXv1xwD4Mkecej10qyrudSDsOoj9fjWD8ArSNs8LujHvT+y+NhijDojn/b6VGZF1TDFYuHsF19w4h//oOjQYfTe3gQ/9ihxS/8i8t13pLAR1arS81E/+eQTEhISCLxgEaXAwEDee+89Pvnkk0p9rpUrVzJy5EjWr1/PkiVLMJvN9O3bl7y8vKs+99ixY7z44ot07969st+C01mXmE5KdiEBXm7c2VYWhtOczaZ2R1mLIf4WaHGP1olczqaUTXy25TMAXurwEm3DZKfommROSeH4iBGkT5oMikLA4HuJX76MsBdfxC1MWpZF9av0gOLs7GxSU1MvOZ+amkpOTk6lPtfixYvLPJ4yZQphYWFs2bKFHj16XPZ5VquVoUOH8vbbb7N69WoyS9ZEcFXzd6gzpPq3jMRkNGicRrDtJzjxN7h5wYBPQAZI1qiUvBReXPkiVsXKwAYDeaDJA1pHcik5y5eTPPY1rJmZ6L29iXjnbfwr2aovxPWqdMvNXXfdxT/+8Q9mz57NqVOnOHXqFLNmzeLRRx/l7rvvvq4wWVlZAAQFXbkJ/5133iEsLIxHH330ur6eMyiyWPl9dwoAd7SWVhvN5ZyBJW+qx71fh8B62uZxMcXWYsasGENGYQaNAxvzZuc3ZfZNDVGKizmT8AGnnv4n1sxMPJo3J3b2LClshCYq3XIzefJkXnzxRR588EHMZrP6SYxGHn30UT766KNrDmKz2Rg9ejRdu3alRYsWl71uzZo1/Pe//2X79u0V+rxFRUUUFRXZH2dnZ19zRke04kAqOYUWIvw8uLG+jOvQ3OJXoTALIttAx6e0TuNyEjYmsCttF37ufnzW+zM8jZ5aR3IJxSdOkDTmBQp37wYgaPgwQl94Ab27u8bJhKuqdHHj5eXFv//9bz766CMSE9XNzOLi4vD29r6uICNHjmT37t2sWbPmstfk5OTw8MMP8+233xISElKhz5uQkMDbb799Xdkc2fwdpwEY2DpSBhJr7eAfsGc26Axwx5dgkEXIatLsQ7OZeXAmOnRM7DGRGN8YrSO5hOxFi0h+cxy2vDwM/v5EJkzA96abtI4lXJxOURRF6xCjRo1i3rx5rFq16pINOS+0fft22rZti8FwflyJzWYDQK/Xc+DAAeLiyq7xUl7LTUxMDFlZWfjV8r1KcosstH9vCYVmG/8b1Y2WdWRHY80U5cK/O0HWSejyDPR9T+tELmVP2h6G/T6MYlsxo9qM4snWT2odyenZCgo4MyGBzBkzAPBs147oTz7GLTJS42TCWWVnZ+Pv71+h9+9K/2mZl5fHBx98wNKlSzl79qy9uCh15MiRCn8uRVF45plnmDNnDitWrLhiYQPQpEkTdu3aVebcG2+8QU5ODl988QUxMZf+pWYymTCZTBXOVJss2ZtCodlGbIg3LaJrd6FW6y2foBY2AXWh11it07iUjMIMRq8YTbGtmF4xvXi81eNaR3J6RYcPk/T88+raNTodwU8+QeioUbJlgnAYlf6f+Nhjj7Fy5UoefvhhIiMjr2uw3siRI5k6dSrz5s3D19eXlBR1YKy/vz+enmpf+bBhw4iOjiYhIQEPD49LxuMEBAQAXHGcjrOav13tkrqjdZQMmtRS0lbYMEk9HvAZuF9fF62oOIvNwsurXiYlL4V6fvWY0G0Cep3suF5dFEUha/ZsUt59D6WwEENICNEfTsS7SxetowlRRqWLm99//52FCxfStWvX6/7ikyapbwi9evUqc/6HH35gxIgRAJw4cQK9Xn5ZXSwjr5jVh9IAuKONzJLSjNUC/3sWFBu0HAwN+2idyKV8ue1LNiRvwNPoyee9PsfX3VfrSE7LmptHyltvkb1gAQDeXboQ9eFEjBUc/yhETap0cRMYGHjVqdoVVZHhPisu2FytPFOmTKmSLLXNol3JWGwKLaL9iAv10TqO61r/b0jZBR4B0C9B6zQuZcnxJfyw+wcA3un6DvGB8Roncl4Fe/aQNGYM5uMnwGAg9LnnCH7sUXTyh6dwUJX+n/nuu+8ybtw48vPzqyOPqKDSWVKyto2Gzh1Tx9oA9HsffGR5/5qSmJnIG2veAGB4s+HcWv9WjRM5r9w1azn+4FDMx09gjIyk3k8/EvLE41LYCIdW6ZabTz75hMTERMLDw6lfvz5ubmU3ottauuOrqDanMwvYeDQDgNtbSXGjmd9fBUsB1O8ObYZqncZl5BbnMnr5aPIt+XSI6MDoG0ZrHclp5a5ew6mRI1GKi/Hu3p3ojz7EUDLOUQhHVunixtU3qXQEC3aqrTY3xgYRFSCLlGni6Go4+DvojXD7Z7LFQg2xKTZeX/M6x7KPEe4Vzkc9PsKolxk61SF39WpOjRyFUlyMz803U+ezT9HJonyilqj0b4Xx48dXRw5RCfO2S5eUpmw2+FPtEuGGf0BIQ23zuAhFUfho00csO7kMN70bn/X6jGDPYK1jOaXcVavUwsZsxveWPkR/8okUNqJWkU7TWiYxNZc9p7Mx6nX0bymLZWli9yxI3g7uvtDrVa3TuARFUfhw04f8vO9nAMZ1HkfL0JYap3JOuStXXlDY3EL0p9JiI2qfCrXcBAUFcfDgQUJCQggMDLzimioZGRlVFk5cqnRtm+4NQwjyll84Nc5cCEvfUY+7jQZvmQZb3RRFYeKmifyy7xdALWwGxQ/SNpSTylm+nKRnn1MLm759if7kY3QXjasUojaoUHHz2Wef4eurrh/x+eefV2cecQWKopyfJSVr22hj4zeQdQJ8o6DTP7VO4/QURSFhYwK/7v8VgLc6v8U9je7ROJVzylm2nFPPPQdmM779+hH98UdS2Ihaq0LFzfDhw8s9FjVrd1I2R9PyMBn13NIsQus4ric/A1Z/rB7f9Aa4e2mbx8kpisKEDROYdmAaOnS81eUt7m54t9axnFLOsmWcem60WtjceivRH30ohY2o1WSaQS0yf0cSAH2aheNjkpeuxq36GAqzILwFtB6idRqnpigK7294n+kHpqNDx9td3uauhndpHcsp5SxdyqnRz4PZjF//24j68EPZI0rUevI/uJaw2RT+tyMZkFlSmsg4onZJAdzyDugNV75eXDObYmPChglS2NSAnL/+UgsbiwW//v2J+nCiFDbCKcj/4lpi47EMUrIL8fUw0quxrIRb45a+AzYzxN0E8TdrncZp2RQb769/n98O/oYOHe92fZc74+/UOpZTyl6yhKTnx6iFzYABRE38QAob4TRkKngtUbq2zW0tIjAZpdWgRp3aDHvmADq45V2t0zgtm2Lj3fXvSmFTA7L/+PN8YXP77VLYCKdzzcXN4cOH+eOPPygoKAAqtgmmuDbFFhu/7y7tkorWOI2LUZTzC/a1eRAiWmibx0nZFBvvrHuHmQdnokPHe93ek8KmmmQv/oOkMSWFzcCBUtgIp1Tp4iY9PZ0+ffrQqFEj+vfvT3Ky+qb76KOP8sILL1R5QAFrDqeSmW8mxMdE5zhZkbVG7V8IJ9aB0RN6v651GqdUWtjMOjQLvU7P+93e5464O7SO5ZSyFy8m6YUXwGrF/847iPogAZ1BWoKF86l0cfP8889jNBo5ceIEXl7np8Lef//9LF68uErDCVVpl9TtrSIx6GUPoxpjNcNfJduNdP4n+EurWVWzKTbeXvd2mcJmYNxArWM5pezffyfphRdLCps7iZwwQQob4bQq3Rb5559/8scff1CnTp0y5xs2bMjx48erLJhQFRRbWbL3DCAL99W4LVMg/TB4hUDX0VqncTo2xcZbf7/FnMNz0Ov0TOg2gQENBmgdyyllzZ/P6bGvqYXNoEFEvv+eFDbCqVW6uMnLyyvTYlMqIyMDk8lUJaHEeX/tO0N+sZWYIE/axgRoHcd1FGbDig/U416vgoeftnmcjNVmZfzf45mXOA+9Tk9CtwT6N+ivdSynoygKaf/6irR//xsA/7vvJvLdd6SwEU6v0t1S3bt358cff7Q/1ul02Gw2PvzwQ3r37l2l4UTZHcCvtKeXqGJrv4D8NAiOhxtGaJ3GqVhtVsb9Pc5e2HzQ/QMpbKqBraiI0y++ZC9sgh97lMj33pXCRriESrfcfPjhh9x8881s3ryZ4uJiXn75Zfbs2UNGRgZr166tjowuKyvfzMqDZwGZJVWjsk/Duq/V4z5vgUGWoa8qiqLwzvp3mJ84H4POwAfdP+DW2Fu1juV0LOnpnBo5ioLt28FoJPKt8QTce6/WsYSoMZVuuWnRogUHDx6kW7du3HnnneTl5XH33Xezbds24uLiqiOjy/p9dzJmq0KTCF8aR/hqHcd1LHsfLAUQ0wma3K51GqcyP3E+sw/NVgubHlLYVIeiQ4c4dt/9FGzfjt7Pj7rffSeFjXA517S4gb+/P6+/LtNiq1vpDuADZbuFmpOyG7b/oh73fQ+kK7DKnMw+yYQNEwAY2WYkt9aXwqaq5a5eQ9Lzz2PLzcWtbl1iJk/G1CBW61hC1LhKt9zEx8fz1ltvcejQoerII0qczS5k3ZF0QPaSqlFLxgEKNBsEMR20TuM0zDYzr65+lXxLPu3C2vFIi0e0juR0zv36Kyefegpbbi5e7dtTf/o0KWyEy6p0cTNy5EgWLlxI48aN6dChA1988QUpKSnVkc2l/W9nMooC7eoGEBN06ew0UQ0Sl0HiUtC7QZ/xWqdxKv/Z8R92pu3E182XD7p/gEE2Hq0yitVKyoQJpLz9jn2qd8z3/8UYGKh1NCE0c02L+G3atIn9+/fTv39/vv76a2JiYujbt2+ZWVTi+pR2SUmrTQ2xWeHPcepxh8cgqIG2eZzI1jNb+XbXtwCM6zyOSJ9IjRM5D2tuHqf+OZJzP/4EQOjo0UQmTEDv7q5xMiG0dc17SzVq1Ii3336bgwcPsnr1alJTU/nHP/5Rldlc1rG0PHaczESvgwGtpLipETunw5ldYPKHni9rncZp5BTnMHb1WGyKjTvi7pABxFXIfPo0x4cOJXflSnQmE9Gff0bIU0/KkhFCcI0Diktt3LiRqVOnMn36dLKzsxk8eHBV5XJp/ytptekaH0KoryyMWO3MBbDsPfW4+xjwCtI2jxN5f8P7nM47TR2fOoy9cazWcZxGwa5dnPznP7GmpmEICSHm66/wbN1a61hCOIxKt9wcPHiQ8ePH06hRI7p27cq+ffuYOHEiZ86cYdq0adWR0aUoisI8mSVVs9b/G7KTwD8GOj6ldRqnseDIAhYeWYhBZyChewI+7j5aR3IK2Yv/4PjDw7CmpmFq1IjY6dOksBHiIpVuuWnSpAkdOnRg5MiRDBkyhPDw8OrI5bL2Jedw+Gwu7kY9t7aI0DqO88tLg9Wfqcc3vQluHtrmcRKnck7x/vr3AXiy9ZO0CWujbSAnoCgK6d98S+pn6v9X7x7dif70Uww+UjQKcbFKFzcHDhygYcOG1ZFFcH4gce/Gofh5yMq41W7lRCjOgcjW0FK6VauCxWbhtTWvkWvOpU1oGx5v+bjWkWo9xWol+c1xZM2eDUDgQw8R/uor6IzXNbJACKdV6Z8MKWyqj82m2Mfb3NlGtluodumJsPl79fiWd0F/zePrxQW+2/Ud285uw8fNh4TuCRj18gZ8vdL+PUktbPR6wl9/jaChQ7WOJIRDq9BvnaCgIA4ePEhISAiBgYFXHI2fkZFRZeFczdYT50jKLMDHZOSmJmFax3F+Kz8EmwXi+0CDnlqncQrbz25n8o7JALze6XXq+NbROFHtl7dunX3zy8gJ7xMwaJC2gYSoBSpU3Hz22Wf4+vraj2WqYfUo7ZLq2ywcDzdZ5KxapR2CXb+px71lK5GqkFucy6urX8WqWOkf25/bG8i+XNfLkppK0ksvg6Lgf+89UtgIUUEVKm6GDx9uPx4xYkR1ZXFpFquNhTuTAbijjcySqnYrJ4Jig8b9Ibqd1mmcQsLGBJJyk4jyjuKNTm9oHafWU6xWkl56GWtaGqaGDYmQ/fyEqLBKDzIwGAycPXv2kvPp6ekYDNLacK3WJqaTnldMkLc7XeNDtI7j3M7uh10z1eNer2qbxUksPrqY+Ynz0ev0JHRPwNdddrG/XmmTJpO/fj06Ly+iv/gcvaen1pGEqDUqXdwoilLu+aKiItxlye9rtuKAWjDe2iICN4MMbK1WKycCCjS5XZ0lJa5Lcm4y76x7B4DHWz5Ou3BpCbteeevXk/b11wBEvjUeUwPZDkSIyqjwNIYvv/wSAJ1Ox3fffYfPBWsrWK1WVq1aRZMmTao+oYs4fDYXgNZ1/DVO4uTO7IE9c9TjXrJi7vWy2qyMXTOWHHMOrUJa8WTrJ7WOVOtZUlNJevEldZzNPXfjf8cdWkcSotapcHHzWcnCUYqiMHny5DJdUO7u7tSvX5/JkydXfUIXkVhS3MSHyYJc1WrFB4ACze6EiBZap6n1ftjzA1vObMHL6MUH3T/ATS9rM10PxWol6eXScTbxRLwhY5eEuBYVLm6OHj0KQO/evZk9ezaBgYHVFsrV5BVZOJ1VCEBcqBQ31SZlF+ybD+igp4y1uV6703bz9Ta16+S1jq8R4xejcaLaL23yZPLXrUfn6Un05zLORohrVenVtZYvX14dOVxaYqraahPi406Al4xbqjYrPlDvm98F4c20zVLL5ZvzeWXVK1gUC/3q9+OOOOk6uV556zeQ9rW6nk3E+HGY4uI0TiRE7VXpkav33HMPEydOvOT8hx9+KLuCX6PS4kZabarR6e2wfwGgkxlSVWDipomcyDlBuFc4b3Z6U9a+uk6WtDSSXnoRbDb8775b1rMR4jpVurhZtWoV/fv3v+T8bbfdxqpVq6oklKspHUwcJ+Ntqk9pq03LeyG0sbZZarllJ5Yx+9BsdOhI6J6Av0kGwV8PxWrl9Msvq7t8N4wn4k0ZZyPE9ap0cZObm1vulG83Nzeys7OrJJSrSTybB0C8tNxUj6QtcPB30Omh5ytap6nVCi2FTNyottyOaDGCDhEdNE5U+6V/8w15f69Tx9l89pmMsxGiClS6uGnZsiXTp0+/5Py0adNo1qxy4xgSEhLo0KEDvr6+hIWFMWjQIA4cOHDF53z77bd0796dwMBAAgMD6dOnDxs3bqzU13U0h1Ol5aZalbbatLofQmTj1+vxw54fOJ13mgjvCJ5u/bTWcWq9vA0bSf3XVwBEjBuHKT5e40RCOIdKDyh+8803ufvuu0lMTOSmm24CYOnSpfz666/MmDGjUp9r5cqVjBw5kg4dOmCxWHjttdfo27cve/fuxdvbu9znrFixggceeIAuXbrg4eHBxIkT6du3L3v27CE6uvbtpG222jiWVtJyI8VN1Tu5CQ79CToD9HhJ6zS1WnJuMt/vUndRf+GGF/A0SgvD9bCkpZH04gvqOJu77iLgrkFaRxLCaVS6uBk4cCBz585lwoQJzJw5E09PT1q1asVff/1Fz56V21l58eLFZR5PmTKFsLAwtmzZQo8ePcp9zi+//FLm8XfffcesWbNYunQpw4YNq9w34wBOZORjsSl4uRuI9PPQOo7zWTFBvW/9AATL7JPr8emWTym0FnJD+A30q99P6zi1mmKzcfrlV7CmpuEeHyfjbISoYpUubgAGDBjAgAEDqjoLWVlZAAQFBVX4Ofn5+ZjN5ss+p6ioiKKiIvtjRxsXVDqYuEGoN3q9zDipUifWQ+Iy0Buhx4tap6nVNqdsZvGxxejQ8eqNr8rsqOukjrP5G52nJ3U+/xy9l5fWkYRwKte0iVFmZibfffcdr732GhkZGQBs3bqVpKSkaw5is9kYPXo0Xbt2pUWLiq8c+8orrxAVFUWfPn3K/XhCQgL+/v72W0yMYy00VjoNXAYTV4PlJa02bR6EoFhts9RiVpuViZvUQcT3NLqHJkGyzcr1yNu4kdQv/wVAxJtvyjgbIapBpVtudu7cSZ8+ffD39+fYsWM89thjBAUFMXv2bE6cOMGPP/54TUFGjhzJ7t27WbNmTYWf88EHHzBt2jRWrFiBh0f5XTpjx45lzJgx9sfZ2dkOVeDYp4FLcVO1jq2FoytB7wbdpdXmesw+PJv9GfvxdfPlmbbPaB2nVrOkp3P6hZL1bAYNIuDuu7SOJIRTqnTLzZgxYxgxYgSHDh0qU1D079//mte5GTVqFAsWLGD58uXUqVOnQs/5+OOP+eCDD/jzzz9p1arVZa8zmUz4+fmVuTkS2VOqmqxIUO/bPgSB9bTNUotlFWXxr61qK8M/2/yTII+KdxmLskrH2VhSU3GPiyNi3JtaRxLCaVW65WbTpk385z//ueR8dHQ0KSkplfpciqLwzDPPMGfOHFasWEFsbMW6Dj788EPef/99/vjjD9q3b1+pr+lIFEUhMVVmSlW5o6vg2GowuEP3F7ROU6tN3jGZc0XniPOP4/4m92sdp1ZL/+Zb8tauRefhQZ3PP5NxNkJUo0oXNyaTqdxBuQcPHiQ0NLRSn2vkyJFMnTqVefPm4evray+O/P398SxZyGrYsGFER0eTkKD+JT5x4kTGjRvH1KlTqV+/vv05Pj4++PjUrgLhTHYRuUUWDHod9YLLn/ouKklRYHlJq0274RDgOF2QtU1iZiK/7v8VgJdvfFl2/L4O+Vu3kvqv0nE2b2BqKOstCVGdKt0tdccdd/DOO+9gNpsB0Ol0nDhxgldeeYV77rmnUp9r0qRJZGVl0atXLyIjI+23CxcJPHHiBMnJyWWeU1xczL333lvmOR9//HFlvxXNlQ4mrhfkhbvxmsZ2i4sdWQEn/gaDCbqPuerlonyKojBx40SsipXeMb3pEtVF60i1ljUri6QXXwSrFb+BA/G/+26tIwnh9CrdcvPJJ59w7733EhYWRkFBAT179iQlJYXOnTvz/vvvV+pzKYpy1WtWrFhR5vGxY8cq9TUc2flp4LWrxclhKcr5GVLt/wF+UdrmqcVWnFzBuuR1uOndeKm9LH54rRRFIfmNN7GcTsatbl0ixo+XafRC1IBKFzf+/v4sWbKEtWvXsmPHDnJzc2nXrt1lp2KLy7NPA5fxNlUjcSmc2ghGD+j2vNZpaq1iazEfbf4IgOHNhxPjJ1171ypz2jRyliwBNzeiP/kEg490PwtREypU3AQFBXHw4EFCQkJ45JFH+OKLL+jatStdu3at7nxO7bDMlKo6ZVptHgXfCG3z1GI/7v2RkzknCfUM5bGWj2kdp9YqPHCQMwnqvmZhY8bg2bLi63cJIa5PhQZ6FBcX2wcR/9///R+FhYXVGspVnF/jRv6au26Hlqi7fxs9odtordPUWmfzz/LNzm8AeP6G5/F2k/+b18KWn0/SmDEoxcV49+xB0PDatzWMELVZhVpuOnfuzKBBg7jhhhtQFIVnn33WPpvpYt9//32VBnRW2YVmzuao20LIbuDXSVFgecl4rxsfA58wbfPUYp9v+ZwCSwGtQlsxoEHVb7HiKs4kJFCcmIgxNJSohAR0epkwIERNqlBx8/PPP/PZZ5+RmJgIqHtASevN9SldvC/M14Sfh0yxvS4Hfofk7eDmDV1Ha52m1tqRuoP/HfkfAGNvHIteJ2/I1yJ70SIyZ8wEnY6ojz7EWIm98oQQVaNCxU14eDgffKD2HcfGxvLTTz8RHBxcrcGcnSzeV0UU5fzO3x2fAO8QbfPUUjbFxgcb1J/xQfGDaBEi40OuRfGpUySPGw9A8JNP4N2pk8aJhHBNFfrTLCgoiLS0NAB69+6Nu7t7tYZyBTKYuIrsXwApu8DdB7o8q3WaWmt+4nx2p+/G282b59o9p3WcWkkxm0l64QVsubl4tm1L6KhRWkcSwmXJgGKNyIaZVeRvddVXOj4FXtL8fy1yi3P5fMvnADzV6ilCPKX161qkfvklhTt2ovfzI/rjj9AZK73ShhCiisiAYo0ckTVurl9eOpzcqB53eFTbLLXYNzu/Ib0wnXp+9RjadKjWcWql3DVrSf/2OwAi33sXt+hojRMJ4doqPaBYp9PJgOLrVGyxcTwjH5CWm+tyZDmgQHgLWY34Gh3LOsZP+34C4OUOL+NmkMHtlWVJTeX0K68AEDDkfvz69tU4kRBCBhRr4Hh6Hlabgo/JSLifSes4tdfhv9T7+Ju1zVGLfbT5Iyw2C92iu9GjTg+t49Q6is3G6VdexZqejqlhQ8JffVXrSEIIrmH7haNHj1ZHDpdiH28T5iP7zFwrmw0OL1WP42Xrj2ux+tRqVp1ahVFn5OUOL2sdp1bK+P578v7+G52HB9GffYrew0PrSEIIKrEreP/+/cnKyrI//uCDD8jMzLQ/Tk9Pp1mzZlUazlnJysRVIGUn5J1VZ0nFyHTbyjJbzXy46UMAhjYdSqx/rMaJap+CHTs4+/kXAIS//hqm+HiNEwkhSlW4uPnjjz8oKiqyP54wYQIZGRn2xxaLhQMHDlRtOiclG2ZWgdIuqdieYJSlCSpr6v6pHMs+RpBHEE+2flLrOLWONSeHpDEvgMWC7223EnDvvVpHEkJcoMLFjaIoV3wsKu5wqkwDv272LikZb1NZucW5TN4xGYDR7Ubj6+6rcaLaRVEUkseNw5yUhFt0NJHvvCPdy0I4GFlfvYbZbAqJZ2V14utSmAUnN6jHUtxU2oIjC8g159LAvwF3xt+pdZxaJ3PmTHJ+XwxGI9GffIzBV4pDIRxNhYsbnU53yV8n8tdK5SVnF1JgtuJm0FE3yEvrOLXTkRWgWCG4IQTW1zpNraIoCtMPTAfgvsb3yf5RlVR0+DBn3le3+wh97lk827TRNpAQolwVni2lKAojRozAZFKnLhcWFvLUU0/h7a0Oir1wPI64vNLBxPWCvXEzyBvLNSkdb9PwFm1z1ELbzm7jcOZhPI2eDIwbqHWcWsVWWEjS82NQCgvx7tKF4Edl4UghHFWFi5vhw4eXefzQQw9dcs2wYcOuP5GTK90NPF7G21wbRZHxNtfht4O/AXBb7G34uftpnKZ2OTNxIkWHDmEIDiZq4gfo9PLHiRCOqsLFzQ8//FCdOVyGfTBxmEwDvyap+yE7CYweUK+r1mlqlYzCDP489iegdkmJisv+808yf50GQNQHH2AMDdU4kRDiSuRPjxqWKLuBX5/SLqn63cCt/P3NRPnmHp6L2WamRXALmgc31zpOrWE+fZrkN94EIOjRR/Dp3k3jREKIq5HipobZ17gJlRkW1+TQEvVeViWuFJtiY8aBGYC02lSGYrGQ9NLL2LKz8WjZkrDnntM6khCiAqS4qUGZ+cWk5RYD0EBWJ668olw4sU49jpfBxJWx7vQ6TuWewtfdl1tjb9U6Tq2R9u9JFGzZgt7bm+hPPkbnLgtGClEbSHFTg0pbbaL8PfA2VXpbL3FsDViLIaAeBMdpnaZWKZ3+fWfcnXgapTuvIvI2biRtsrrYYcRbb+Fet67GiYQQFSXFTQ26cMNMcQ3su4D3AVljqcJS8lJYeWolAIMbDdY4Te1gOXeO0y+9DDYb/nfdhf/A27WOJISoBClualBiqroysWy7cA0UBQ7LeJtrMevQLGyKjQ4RHWgQ0EDrOA5PURSSX38Dy5kzuNevT8Qbr2sdSQhRSVLc1KDDMlPq2mUcgXPHQO8GsT20TlNrmG1mZh2cBchA4oo698tUcpctQ+fmRvSnn6D3lvFxQtQ2UtzUIHu3lLTcVF5pl1S9zmCSf7+KWnFyBakFqQR7BHNzjCx6eDWF+/dz9sMPAQh76UU8mjXTOJEQ4lpIcVNDCs1WTp7LB6Tl5ppcON5GVFjpQOK7G96Nm8FN4zSOzZafT9KYF1CKi/Hp1YvAhx/WOpIQ4hpJcVNDjqbloSjg52EkxEemk1aKuRCOrlaPpbipsGNZx9iQvAEdOu5tdK/WcRxeyoQJFB85gjEsjMiECbIxsBC1mBQ3NcS+eF+Yj/zSrKzja8FSAL5RECbdBBU146C6aF+POj2I8onSOI1jy160iKyZs0CnI+rDDzEGBmodSQhxHaS4qSEymPg6XLhRphSGFVJoKWTu4bmADCS+muJTp0geNx6A4CefwLtTR40TCSGulxQ3NUQGE18HGW9TaX8e/5Ps4myivKPoGiUbjF6OYjaT9MIL2HJz8WzbltBRo7SOJISoAlLc1JDSNW6k5aaSMk9A2gHQGaBBL63T1BqlA4kHNx6MQW/QOI3jSv3yXxTu2Inez4/ojz9CZ5SVw4VwBlLc1ACrTeFIqrTcXJPSVps6HcAzQNMotcX+jP3sTN2JUW9kUPwgreM4rLy//yb9u+8AiHznHdyiozVOJISoKlLc1IDTmQUUWWy4G/XEBHlpHad2KR1v01C6pCqqtNWmT90+hHiGaJzGMVnS00l65RVQFALuuw+/W/tpHUkIUYWkuKkBpeNtGoR4Y9DLgNgKsxTDEXVPJBlvUzG5xbksPLIQkIHEl6PYbJweOxZrahqmhvGEj31V60hCiComxU0NSJQuqWtzaiMU54BXCES01jpNrbDgyAIKLAU08G9A+/D2WsdxSBn/9yN5q1ajM5mI+uQT9J6yS7oQzkaKmxogu4Ffo0OlG2XeDHr5r3o1iqLYu6Tua3yfrKdUjoLdezj76acAhI99FY9GjTROJISoDvKOUQPOTwOXDfgqxb6+zS3a5qgltqdu53DmYTyNngyMG6h1HIej7vb9OpjN+N5yCwH33691JCFENZHipgZcuDqxqKDsZDizC9BBXG+t09QKpa02t8Xehp+7n8ZpHE/B5s0UHTiAztOTiHfelpYtIZyYFDfVLD23iHP5ZnQ6aBAixU2FJS5T76PagrfM+LmajMIM/jz2JwD3NZKBxOU59+s0APxvv122VxDCyWla3CQkJNChQwd8fX0JCwtj0KBBHDhw4KrPmzFjBk2aNMHDw4OWLVuyaNGiGkh7bUoX74sO8MTTXRZTq7DDpeNtZJZURcw7PA+zzUzz4OY0D2mudRyHY0lLI3uJ+n8q8IEhGqcRQlQ3TYublStXMnLkSNavX8+SJUswm8307duXvLy8yz7n77//5oEHHuDRRx9l27ZtDBo0iEGDBrF79+4aTF5xsqfUNbBaIHG5eizFzVXZFJt9k8z7G8s4kvJkzp4DZjMerVvh0Uw2XxXC2Wm61vjixYvLPJ4yZQphYWFs2bKFHj16lPucL774gltvvZWXXnoJgHfffZclS5bw1VdfMXny5GrPXFmyp9Q1OL0VCjPBIwCib9A6jcNbd3odJ3NO4uvmS7/6shjdxRSrlczp6nikwPul1UYIV+BQY26ysrIACAoKuuw169ato0+fsn/N9+vXj3Xr1pV7fVFREdnZ2WVuNUkGE1+D0i0X4nqDQfb6uZrSgcR3xN+Bl5usgH2xvDVrMCcloff3x6//bVrHEULUAIcpbmw2G6NHj6Zr1660aNHistelpKQQHh5e5lx4eDgpKSnlXp+QkIC/v7/9FhMTU6W5r0a6pa7BIRlvU1EpeSmsPKWu4iwDictXOpA4YNAg9B4eGqcRQtQEhyluRo4cye7du5k2bVqVft6xY8eSlZVlv508ebJKP/+VFBRbScosAKRbqsLy0uD0NvU47mZts9QCsw7NwqbYaB/engYBDbSO43DMSUnkrlSLv4AhMh5JCFfhEG3+o0aNYsGCBaxatYo6depc8dqIiAjOnDlT5tyZM2eIiIgo93qTyYTJZKqyrJVR2iUV5O1OkLe7JhlqncTlgALhLcEvUus0Ds1sMzPr4CxABhJfzrnfZoCi4NW5E6bYWK3jCCFqiKYtN4qiMGrUKObMmcOyZcuIrcAvn86dO7N06dIy55YsWULnzp2rK+Y1O7+nlKxMXGGl423ipdXmalaeXElqQSrBHsHcXFf+vS6mFBeTOXMmAIFDHtA4jRCiJmnacjNy5EimTp3KvHnz8PX1tY+b8ff3x7NkM7thw4YRHR1NQkICAM899xw9e/bkk08+YcCAAUybNo3NmzfzzTffaPZ9XE6ijLepHJvtguJGxttcTelA4rsb3o2bwU3jNI4n56+/sKanYwwNxfcmWeVaCFeiacvNpEmTyMrKolevXkRGRtpv00umbQKcOHGC5ORk++MuXbowdepUvvnmG1q3bs3MmTOZO3fuFQcha+Ww7AZeOSk7ID8N3H0gpqPWaRza8ezjrE9ejw4d9zS6R+s4DuncNPX3SMDge9G5SfEnhCvRtOVGUZSrXrNixYpLzg0ePJjBgwdXQ6KqlXhWXYxQdgOvoNJWmwa9wChjlK6ktNWme53uRPtEa5zG8RQlJpK/cSPo9QTUgt8VQoiq5TCzpZyNxWrjaJpa3MRLy03F2HcBl/EjV5JTnMPsQ7MBGNJYFqUrT2mrjU/v3rhFysB0IVyNFDfV5OS5AoqtNjzc9EQHeGodx/EVZMLJjeqxTAG/otmHZpNnziPOP45u0d20juNwbPn5ZM2dC0DgECn+hHBFUtxUk9LBxA1CfNDrdRqnqQWOrADFCiGNILCe1mkclsVm4ed9PwMwrPkwdDr5v3Wx7EWLsOXk4Fa3Lt5du2gdRwihASluqslh2XahcmSWVIUsOb6ElLwUgjyCGNBggNZxHFLpisSB99+HTi+/4oRwRfKTX00SZcPMilOUC8bbSHFzOYqi8H97/g+AIU2GYDJoszilIyvYtYvCPXvQubnhf9ddWscRQmhEiptqIi03lXB2H+ScBqMn1OuqdRqHteXMFvak78FkMMmKxJdR2mrje+utGK+wAa8QwrlJcVMNFEWxb5gZFyarE1/V4ZKNMut3AzfZ2PBy/m+v2mpzR9wdBHnIG/fFrFlZZC9aBEDgAzKQWAhXJsVNNUjNLSKn0IJeB7EhUtxclYy3uapjWcdYeVLdAPKhZg9pnMYxZc2bh1JYiKlRIzzbttU6jhBCQ1LcVIPSVpu6QV6YjAaN0zi4olw4vk49bniLtlkc2M/7fkZBoWednjTwl92/L6Yoin1tm8AHhsgsMiFcnBQ31SAxtWRlYhlMfHVHVoDNDIH1IUjetMuTWZjJvMPzABjefLjGaRxT/oaNFB85gt7LC7+Bd2gdRwihMSluqoFsmFkJu35T7xsPAPlru1zTD0yn0FpI06CmtA9vr3Uch3RumjqQ2O+OgRh8pCtYCFcnxU01OCzTwCsmPwMO/K4et3lA2ywOqthazK/7fwVk0b7LMZ89S85f6rgtWZFYCAFS3FSLxNLdwKXl5sr2zAFrMYS3gIiWWqdxSAuPLCS9MJ1wr3D61e+ndRyHlDVrFlgseLZpg0eTJlrHEUI4ACluqlhukYXkrEJANsy8qh1qVwKtpdWmPIqi8OPeHwEY2nQobno3jRM5HsVq5dxvMwCZ/i2EOE+Kmyp2pKTVJsTHhL+XvBldVnoinNoIOj20HKx1Gof09+m/OZx5GC+jF/c0ukfrOA4pd+UqLMnJGAIC8L31Vq3jCCEchBQ3VeywfTCxDGq8otJWm7ibwTdc2ywOqnSrhbsb3o2fu5/GaRzTuWnqeCT/u+9Gb5LtKIQQKiluqliibLtwdTbbBV1S0pVQnoPnDrIueR16nZ6hTYdqHcchFZ86Rd7qNYC6SaYQQpSS4qaKyUypCjjxN2SdAJMfNJGdrcvz4x51rE2fun2o41tH4zSOKXP6dFAUvLt2xb1ePa3jCCEciBQ3VeywrHFzdTvUrgSaDwI3T02jOKLU/FQWHl0IyKJ9l2MrLiZz5iwAAobIJqJCiLKkuKlCZquN4+n5gLTcXFZxPuxRV9uVWVLl+3X/r1hsFtqEtqFVaCut4ziknD/+xHruHMbwcHx799Y6jhDCwUhxU4WOp+djsSl4uxuI9Jfdrcu1fyEU50BAPYjppHUah5Nvzue3g+qqzdJqc3mlKxIHDB6MzmjUOI0QwtFIcVOFLly8T1aSvYzSLqnWQ0Av//0uNj9xPllFWcT4xtA7RlokylN48CAFW7aAwUDA4Hu1jiOEcEDy7lKFZDDxVWQnw5Hl6nErGSdxMavNyk97fwLgoaYPYdDLjvLlySzZ/dv3pptwC5dlBIQQl5LipgrJhplXsWsGKDa1Oyo4Tus0DmfFqRWcyDmBr7svg+IHaR3HIdny8siap47ZkhWJhRCXI8VNFbJ3S4XKAn6XUJSyXVLiEqXTv+9rdB9ebl4ap3FMmbPnYMvLw61eXbw6yZgtIUT5pLipIoqikJiaB0jLTblSdsLZvWAwqVPARRm7Unex9exWjHojDzZ9UOs4DsmWn0/af/4DQPCIEehkzJYQ4jLkt0MVOZNdRG6RBaNeR71gabm5ROmKxI1vA89AbbM4oNINMvvH9ifMK0zjNI4p46efsaal4RYTQ8A9steWEOLyZA5lFTEadIy5pRFZBWbcDFIzlmE1q+NtQNa2Kcfp3NMsOb4EgGHNhmmcxjFZs7JI/+9/AQh9ZhQ6d3eNEwkhHJkUN1UkxMfEszc31DqGY0pcBnmp4B0K8Tdrncbh/LzvZ6yKlY6RHWkc1FjrOA4p/b/fY8vOxtSwIX4DZMsOIcSVSRODqH6lA4lbDgaDm7ZZHExOcQ6zD80GYHgzWbSvPJbUVDJ+UqfIh45+Dp1BpsgLIa5MihtRvQrOwf5F6rHMkrrE7EOzyTPnEecfR7foblrHcUhpkyajFBTg2bo1PjfdpHUcIUQtIMWNqF575oK1CMKaQYTsk3Qhs83Mz/t+BuDhZg/LqtblKD51inMz1PFaoc8/L/9GQogKkeJGVK/SWVKtHwB5YypjybElpOSlEOQRxO1xt2sdxyGl/esrMJvx7tIZ704dtY4jhKglpLgR1SfjCJxcDzq9Ot5G2CmKYp/+PaTJEEwGk8aJHE/RoUNkzZ8PqK02QghRUVLciOqzQ90DiAa9wS9S2ywOZn/Gfvak78FkMHF/Y9lnqzypX34JioLvLbfg2bKl1nGEELWIFDeiethsF2y3IGvbXGz5SXUD0W7R3QjyCNI4jeMp2LmTnCV/gV5P6HPPah1HCFHLSHEjqsfJ9ZB5HNx9oYmsS3KxFSdXANArppeWMRzW2c8+A8D/jjswxcdrnEYIUdtIcSOqR2mrTfM7wV02gbxQSl4K+zL2odfp6VGnh9ZxHE7eunXkr1sPbm6EjBqldRwhRC0kxY2oeuYCdQo4SJdUOUq7pNqEtpEuqYsoisLZzz4HIPC++3CvE61tICFErSTFjah6BxZBUTb414W6XbRO43CkS+rycpcupXDnTnSenoQ8/ZTWcYQQtZQUN6LqbS8dSHw/6OW/2IVyi3PZmLIRkOLmYorVSuoXXwAQNGwYxpAQjRMJIWoreecRVSvnDCQuVY9byXYLF1t7ei0Wm4X6fvWJ9Y/VOo5DyV6wgKJDh9H7+RH8yD+0jiOEqMU0LW5WrVrFwIEDiYqKQqfTMXfu3Ks+55dffqF169Z4eXkRGRnJI488Qnp6evWHFRWzawYoNqhzI4TILJeLlY636R3TW+MkjkUpLib1X18BEPzYYxj8/TVOJISozTQtbvLy8mjdujVff/11ha5fu3Ytw4YN49FHH2XPnj3MmDGDjRs38vjjj1dzUlFh9u0WpNXmYmabmVWnVgHSJXWxczNnYj51CkNICEEPDdU6jhCiljNq+cVvu+02brvttgpfv27dOurXr8+zz6qLesXGxvLkk08yceLE6oooKiNlF5zZBQZ3aH6X1mkczvaz28kpziHQFEjr0NZax3EYtvx80iZNAiDk6afQe8nSAUKI61Orxtx07tyZkydPsmjRIhRF4cyZM8ycOZP+/ftf9jlFRUVkZ2eXuYlqUtpq0+hW8JIpzhdbdmIZAD3q9MCgN2icxnFk/PwL1tQ03KKjCRwse5AJIa5frSpuunbtyi+//ML999+Pu7s7ERER+Pv7X7FbKyEhAX9/f/stJiamBhO7EKsFdv6mHsvaNpdQFEXG25TDmp1N+nffARDyzCh07u4aJxJCOINaVdzs3buX5557jnHjxrFlyxYWL17MsWPHeOqpy6+HMXbsWLKysuy3kydP1mBiF3JkOeSdBa9gaHiL1mkcTmJmIkm5Sbjr3ekc1VnrOA4j/b/fY8vOxtQwHv+BA7WOI4RwEpqOuamshIQEunbtyksvvQRAq1at8Pb2pnv37rz33ntERl6687TJZMJkMtV0VNdTut1Cy8FgcNM2iwNacWoFAJ2iOuHlJmNKACypqWT8+CMAoc89h84gXXVCiKpRq1pu8vPz0V+0KJyh5BeioihaRBIAhVmwf6F6LLOkyrX8hNolJbOkzkv7zzcoBQV4tGqFz803ax1HCOFENC1ucnNz2b59O9u3bwfg6NGjbN++nRMnTgBql9KwYcPs1w8cOJDZs2czadIkjhw5wtq1a3n22We58cYbiYqK0uJbEKDuI2UphNAmENlG6zQOJ60gjZ1pOwHoWaenxmkcQ/GpJM5Nnw5A2POj0el0GicSQjgTTbulNm/eTO/e5wdXjhkzBoDhw4czZcoUkpOT7YUOwIgRI8jJyeGrr77ihRdeICAggJtuukmmgmttp/omReshIG9Sl1h5ciUALYJbEOYVpnEax5D21VdgNuPVuRPenWUMkhCiamla3PTq1euK3UlTpky55NwzzzzDM888U42pRKUUZMKJdepxi3s1jeKoSjfK7F1XZkkBFB0+TNb8+QCEjR6tbRghhFOqVWNuhAM6tkbdbiG4IQTINPuL5ZvzWZesFn8y3kaV+uW/wGbDp8/NeLaWxQyFEFVPihtxfY6sUO8b9NIyhcNan7yeImsR0T7RNAxoqHUczRUfO0bOn3+CTkdoyUrjQghR1aS4EdfnqDqeRIqb8tm7pGJ6y6BZIGPqVAC8e3THo1EjjdMIIZyVFDfi2mUlQdpB0Omhfjet0zgcq83KylNq8SddUmDLyyNr9hwAgh56SOM0QghnJsWNuHalrTZRbcEzQNMojmhX2i4yCjPwdfOlXXg7reNoLnPePGy5ubjXq4d3165axxFCODEpbsS1OyJdUldSupdUtzrdcNO79qrNiqJw7he1Sypw6IPo9PKrRwhRfeQ3jLg2inJ+MHGsLExXntLxNjfF3KRpDkeQv349xYmJ6Ly88L/rLq3jCCGcnBQ34tqkHoDcFDB6QExHrdM4nOPZxzmSdQSjzkjXaOmCyfj5FwACBt2JwddX4zRCCGcnxY24NqXjbep2BjcPbbM4oNJWm/YR7fF1d+038+JTSeQuV7voAocO1TiNEMIVSHEjro19fRvpkipP6XgbmSUF536dCjYb3l06Y4qL0zqOEMIFSHEjKs9qUVcmBhlMXI5zhefYdnYboK5v48psBQVkzpwFQKBM/xZC1BApbkTlnd4GRdngGQgRrbRO43BWJ63GpthoHNiYKB/X3q0+e+FCbFlZuEVH49NTWvmEEDVDihtReaVdUvW7g96gaRRHVDrextW7pBRFsQ8kDnzwAXQG+b8ihKgZUtyIypP9pC6ryFrEmiS1y87VdwEv2LKFov370Xl4EHDPPVrHEUK4ECluROUU58GpjeqxFDeX2Ji8kQJLAWGeYTQLaqZ1HE2Vttr4D7wdQ0CAtmGEEC5FihtROSfWgbUY/GMgqIHWaRzOhV1SrrxRpvnMGXKWLAFkILEQouZJcSMq58Ip4C785l0eRVFkvE2Jc9OmgdWKV/v2eDRurHUcIYSLkeJGVI59PynXHk9Snr3pezlbcBYvoxcdI1131WZbcTGZv80ApNVGCKENKW5ExeWlQ8pO9Ti2h7ZZHFDpwn1do7vibnDXOI12cn7/HWt6OsaICHz73Kx1HCGEC5LiRlRc6ZYLYc3BJ0zbLA5IuqRU9unfQ+5HZzRqnEYI4YqkuBEVV1rcyCypS5zOPc2BcwfQ6/T0iHbdVq2CnTsp3LULnZsbAYMHax1HCOGipLgRFSf7SV1WaZdU27C2BHgEaBtGQxk//wyAX//+GIODNU4jhHBVUtyIijl3TL3pjVCvi9ZpHE5pl5Qr7yVlSUsj+/fFgAwkFkJoS4obUTGls6TqdACTr7ZZHExOcQ6bUzYDrj3e5txvv4HZjGfr1ni2bKF1HCGEC5PiRlRMaZdUrHRJXWxt0losioUG/g2o51dP6ziaUMxmMqdNB6TVRgihPSluxNXZbDKY+AqWnVwGuHarTc5ff2E5exZDSAh+/fpqHUcI4eKkuBFXd3YP5KeDuw/Uaa91GoditplZc6pko0wXHm9jn/59333o3F13jR8hhGOQ4kZcXWmXVL0uYHDTNIqj2XpmKznmHII8gmgZ0lLrOJoo3LePgi1bwGgk4P77tY4jhBBS3IgKsE8B76VlCodUOgW8Z52eGPQGjdNowz79u29f3MJlcUchhPakuBFXZimG43+rx1LclCEbZYLl3DmyFywEZCCxEMJxSHEjruzUJjDng3cohDXTOo1DOZR5iKTcJEwGE50iO2kdRxNZs2ahFBXh0awZnm3baB1HCCEAKW7E1Vw4BVyn0zSKoylttekc2RkvNy9Ns2hBsVo5N/VXQG210cn/DyGEg5DiRlyZTAEvl6IoLDqyCHDdLqnc5csxnz6NISAAvwH9tY4jhBB2UtyIyyvMhlPqyruyn1RZ285uIzErEU+jJ33ru+a6LqXTvwMGD0ZvMmmcRgghzpPiRlze8bWgWCGoAQTU1TqNQ5lxcAYAt8Xehq+7621HUXToEPnr14NeT+ADQ7SOI4QQZUhxIy7viHRJlSezMJM/j/0JwOBGgzVOo42MqVMB8L35ZtyiojROI4QQZUlxIy5P9pMq1/zE+RTbimka1JTmwc21jlPjrDk5ZM2bD8j0byGEY5LiRpQvJwVS9wE6iO2hdRqHoSiKvUvq3kb3uuQMocwZM1Hy8zE1bIjXjR20jiOEEJeQ4kaU7+gq9T6yNXgFaZvFgWw5s4Vj2cfwNHrSP9b1ZgjZCgtJ/+F7AIJGDHfJ4k4I4fikuBHls2+5IF1SFypttekf2x8fdx+N09S8zN9mYE1Nwy0qCv877tA6jhBClEuKG3EpRZH9pMpxrvAcS44vAWBwY9cbSGwrKiL9u+8ACH7ySXRusomqEMIxSXEjLpWeCNlJYDBB3c5ap3EY8xPnY7aZaRbczCUHEmfOmInl7FmMkZEE3DVI6zhCCHFZmhY3q1atYuDAgURFRaHT6Zg7d+5Vn1NUVMTrr79OvXr1MJlM1K9fn++//776w7qSI+pO18TcCG6e2mZxEIqiMPPgTMA1p3/biotJ//ZbAEKeeBydu7vGiYQQ4vKMWn7xvLw8WrduzSOPPMLdd99doefcd999nDlzhv/+97/Ex8eTnJyMzWar5qQuRrqkLrEpZRPHso/h7ebtkgOJs2bNwnLmDMbwcPzvuUfrOEIIcUWaFje33XYbt912W4WvX7x4MStXruTIkSMEBakzeOrXr19N6VyUzQrHVqvHDXprm8WBlA4kHhA7wOU2ybQVF5P2jdpqE/z44+il1UYI4eA0LW4qa/78+bRv354PP/yQn376CW9vb+644w7effddPD3L7z4pKiqiqKjI/jgrKwuA7OzsGslc65zeBlmZ4O4HPg1A/p3IKMzgjwN/YLVZuS3yNpf7v3Nu1mwyT53CGBKCvl9fl/v+hRCOofR3j6IoV722VhU3R44cYc2aNXh4eDBnzhzS0tL45z//SXp6Oj/88EO5z0lISODtt9++5HxMTEx1x63lcuAdWd/mYh1w4UXrDh+CsDCtUwghXFxOTg7+/v5XvEanVKQEqgE6nY45c+YwaNCgy17Tt29fVq9eTUpKiv0bmz17Nvfeey95eXnltt5c3HJjs9nIyMggODjYJRcgy87OJiYmhpMnT+Ln56d1HFFCXhfHJa+NY5LXxXFV12ujKAo5OTlERUWh1195PlStarmJjIwkOjq6TMXWtGlTFEXh1KlTNGzY8JLnmEwmTCZTmXMBAQHVHdXh+fn5yS8EBySvi+OS18YxyeviuKrjtblai02pWrXOTdeuXTl9+jS5ubn2cwcPHkSv11OnTh0NkwkhhBDCUWha3OTm5rJ9+3a2b98OwNGjR9m+fTsnTpwAYOzYsQwbNsx+/YMPPkhwcDD/+Mc/2Lt3L6tWreKll17ikUceueyAYiGEEEK4Fk2Lm82bN9O2bVvatm0LwJgxY2jbti3jxo0DIDk52V7oAPj4+LBkyRIyMzNp3749Q4cOZeDAgXz55Zea5K+NTCYT48ePv6SrTmhLXhfHJa+NY5LXxXE5wmvjMAOKhRBCCCGqQq0acyOEEEIIcTVS3AghhBDCqUhxI4QQQginIsWNEEIIIZyKFDdO6Ouvv6Z+/fp4eHjQsWNHNm7ceNlrp0yZgk6nK3Pz8PCowbSuYdWqVQwcOJCoqCh0Oh1z58696nNWrFhBu3btMJlMxMfHM2XKlGrP6Woq+7qsWLHikp8XnU5HSkpKzQR2EQkJCXTo0AFfX1/CwsIYNGgQBw4cuOrzZsyYQZMmTfDw8KBly5YsWrSoBtK6lmt5bbR4n5HixslMnz6dMWPGMH78eLZu3Urr1q3p168fZ8+evexz/Pz8SE5Ott+OHz9eg4ldQ15eHq1bt+brr7+u0PVHjx5lwIAB9O7dm+3btzN69Ggee+wx/vjjj2pO6loq+7qUOnDgQJmfmTDZc6tKrVy5kpEjR7J+/XqWLFmC2Wymb9++5OXlXfY5f//9Nw888ACPPvoo27ZtY9CgQQwaNIjdu3fXYHLndy2vDWjwPqMIp3LjjTcqI0eOtD+2Wq1KVFSUkpCQUO71P/zwg+Lv719D6YSiKAqgzJkz54rXvPzyy0rz5s3LnLv//vuVfv36VWMy11aR12X58uUKoJw7d65GMgnV2bNnFUBZuXLlZa+57777lAEDBpQ517FjR+XJJ5+s7ngurSKvjRbvM9Jy40SKi4vZsmULffr0sZ/T6/X06dOHdevWXfZ5ubm51KtXj5iYGO6880727NlTE3HFFaxbt67M6wjQr1+/K76Ooua0adOGyMhIbrnlFtauXat1HKeXlZUFQFBQ0GWvkZ8ZbVTktYGaf5+R4saJpKWlYbVaCQ8PL3M+PDz8smMCGjduzPfff8+8efP4+eefsdlsdOnShVOnTtVEZHEZKSkp5b6O2dnZFBQUaJRKREZGMnnyZGbNmsWsWbOIiYmhV69ebN26VetoTstmszF69Gi6du1KixYtLnvd5X5mZDxU9anoa6PF+0yt2hVcVL3OnTvTuXNn++MuXbrQtGlT/vOf//Duu+9qmEwIx9O4cWMaN25sf9ylSxcSExP57LPP+OmnnzRM5rxGjhzJ7t27WbNmjdZRxEUq+tpo8T4jLTdOJCQkBIPBwJkzZ8qcP3PmDBERERX6HG5ubrRt25bDhw9XR0RRQREREeW+jn5+frJJrIO58cYb5eelmowaNYoFCxawfPly6tSpc8VrL/czU9HffaJyKvPaXKwm3mekuHEi7u7u3HDDDSxdutR+zmazsXTp0jJV85VYrVZ27dpFZGRkdcUUFdC5c+cyryPAkiVLKvw6ipqzfft2+XmpYoqiMGrUKObMmcOyZcuIjY296nPkZ6ZmXMtrc7EaeZ+p0eHLotpNmzZNMZlMypQpU5S9e/cqTzzxhBIQEKCkpKQoiqIoDz/8sPLqq6/ar3/77beVP/74Q0lMTFS2bNmiDBkyRPHw8FD27Nmj1bfglHJycpRt27Yp27ZtUwDl008/VbZt26YcP35cURRFefXVV5WHH37Yfv2RI0cULy8v5aWXXlL27dunfP3114rBYFAWL16s1bfglCr7unz22WfK3LlzlUOHDim7du1SnnvuOUWv1yt//fWXVt+CU3r66acVf39/ZcWKFUpycrL9lp+fb7/m4t9la9euVYxGo/Lxxx8r+/btU8aPH6+4ubkpu3bt0uJbcFrX8tpo8T4jxY0T+te//qXUrVtXcXd3V2688UZl/fr19o/17NlTGT58uP3x6NGj7deGh4cr/fv3V7Zu3apBaudWOoX44lvpazF8+HClZ8+elzynTZs2iru7u9KgQQPlhx9+qPHczq6yr8vEiROVuLg4xcPDQwkKClJ69eqlLFu2TJvwTqy81wQo8zNw8e8yRVGU3377TWnUqJHi7u6uNG/eXFm4cGHNBncB1/LaaPE+oysJK4QQQgjhFGTMjRBCCCGcihQ3QgghhHAqUtwIIYQQwqlIcSOEEEIIpyLFjRBCCCGcihQ3QgghhHAqUtwIIYQQwqlIcSOEEEIIpyLFjRBCCCGcihQ3QgjN9OrVi9GjR1/3NVWpqjJda+709HTCwsI4duxYpZ9bWUOGDOGTTz6p9q8jRE2T4kYIBzV58mR8fX2xWCz2c7m5ubi5udGrV68y165YsQKdTkdiYmINp7w+s2fP5t1339U6RhnXkqkqC7D333+fO++8k/r161fJ57uSN954g/fff5+srKxq/1pC1CQpboRwUL179yY3N5fNmzfbz61evZqIiAg2bNhAYWGh/fzy5cupW7cucXFxWkS9ZkFBQfj6+modowwtM+Xn5/Pf//6XRx99tEa+XosWLYiLi+Pnn3+uka8nRE2R4kYIB9W4cWMiIyNZsWKF/dyKFSu48847iY2NZf369WXO9+7dG4DFixfTrVs3AgICCA4O5vbbby/TovPNN98QFRWFzWYr8/XuvPNOHnnkEQBsNhsJCQnExsbi6elJ69atmTlzpv3anJwchg4dire3N5GRkXz22WeXtF7Ur1+fzz//vMzXaNOmDW+99Zb98cXPycvLY9iwYfj4+BAZGVlul8nVsl1swYIFBAQEYLVaAdi+fTs6nY5XX33Vfs1jjz3GQw89dE2ZRowYwcqVK/niiy/Q6XTodDp7l5LNZuPll18mKCiIiIiIMt97eRYtWoTJZKJTp05lzq9ZswY3N7cyBe2xY8fQ6XQcP368zONZs2bRo0cPPD096dChAydOnGD16tV06tQJLy8vbr75ZjIzM+2fZ+DAgUybNu2KuYSobaS4EcKB9e7dm+XLl9sfL1++nF69etGzZ0/7+YKCAjZs2GAvbvLy8hgzZgybN29m6dKl6PV67rrrLnsxM3jwYNLT08t83oyMDBYvXszQoUMBSEhI4Mcff2Ty5Mns2bOH559/noceeoiVK1cC8P/t3GlsTO8XwPFvx29qq9ZMO2i1P1FLddIWpRUJplOhEe0LJPakLxCENIpKihBLEIKgiS2WorYQS9IQSzrNFCmJmRutGKqlIi0JzVC6Yf4vGvfvqirq/1eT80nmxT2d+8x5nnnRM+c+9y5evJgbN25w8eJFrl69it1u5+7du62eb0ZGBvn5+Vy4cIErV65gs9majNtSbl8bOXIkb9++xeFwAJCfn09QUJCmaMzPz29yqe9Hc9qxYwfDhw9nzpw5VFRUUFFRQVhYGADZ2dl07tyZwsJCNm/ezNq1a7l69Wqz87fb7QwZMqRJ3Ol0EhkZSYcOHdSYw+HAYDDQq1cvABRFAWD37t1s2LCBmzdv8uLFC2bOnMmmTZvIysoiLy8PRVE4dOiQOk58fDy3b9+mrq6u2byE+Nv886cTEEI0z2q1smjRIj58+EBNTQ0OhwOLxUJDQwN79uwB4NatW9TV1anFzaRJkzRjHDx4EJPJxP3794mKisJgMDBu3DiOHz/O6NGjAThz5gxBQUFYrVbq6urYsGED165dY/jw4QCEh4dTUFDA3r17iY2NJTs7W3P+oUOHCAkJadVcq6urOXDgAMeOHVPHzc7OJjQ0VH1PS7lZLJYm4wYEBDBo0CBsNhtDhw7FZrORnp7OmjVrqK6uxu12U1JS8s1zfySngIAAfH196dSpEz169NCcHxMTw+rVqwHo168fWVlZXL9+nTFjxnxzDZ4+ffrNdVQUhcGDB2tiTqeTgQMHao6NRiOnTp0iMDAQAIvFQkFBAcXFxXTq1AmAuLg4Kisr1fNCQkKor6+nsrJSLZSE+NtJ50aINiwhIYF3795x584d7HY7/fv3x2QyYbFY1H03NpuN8PBw/v33XwAePXrEtGnTCA8Px9/fX92YWl5ero47Y8YMzp49q/5az8nJYerUqeh0OkpKSnj//j1jxozBz89PfR05coTHjx9TWlpKQ0MD8fHx6ngBAQFERES0aq6PHz+mvr6eYcOGqTGj0agZt6XcmmOxWLDZbHg8Hux2OxMnTiQyMpKCggLy8/MJCQmhX79+v5TT98TExGiOg4ODefnyZbPvr6mp0XRnPnM6nQwaNEgTczgcmpiiKEyYMEEtbKDxO58yZYpa2HyO9e7dWz3u2LEj0LjfRwhvIZ0bIdqwvn37EhoaSl5eHlVVVWp3ISQkhLCwMG7evEleXh6JiYnqOSkpKfTq1Yv9+/ere2uioqKor6/XvMfj8ZCbm0tcXBx2u53t27cDjd0KgNzcXHr27KnJp3379rx+/fqHctfpdHg8Hk2soaHh5xfhCy3l1pyEhAQOHjyIoijo9XoGDBhAQkICNptNs66/m16v1xz7+Pg02ev0paCgIKqqqjSxjx8/UlRU1KRzc/fuXU2Xzul0kpmZqXmPoiikp6erx7W1tbhcLk3H5/P3aTKZfnBWQrR90rkRoo2zWq3YbDZsNptmX8ioUaO4dOkSt2/fVi9JvXr1CpfLxcqVKxk9ejSRkZFN/lkCdOjQgYkTJ5KTk8OJEyeIiIggNjYWALPZTPv27SkvL6dv376aV1hYGOHh4ej1eu7cuaOO53a7efjwoeYzTCYTFRUV6vGbN28oKytrdp59+vRBr9dTWFioxqqqqjTjtpRbcz7vu9m+fbtayHwubr5e15/NCcDX11fdsNwagwcP5v79+5qYy+WitrZWc7nq1q1bPH/+XO3cvHnzhidPnmgKoLKyMtxutyZ27949PB4P0dHRaqyoqIjQ0FCCgoJanb8QbYV0boRo46xWKwsWLKChoUHTYbBYLCxcuJD6+nq1uDEYDAQGBrJv3z6Cg4MpLy/X3BX0pRkzZpCcnExxcbF6pxBAly5dWLp0Kenp6Xz69IkRI0bgdru5ceMG/v7+pKamkpqaSkZGBkajkW7durF69Wp0Oh0+Pj7qOImJiRw+fJiUlBS6du3KqlWraNeuXbPz9PPzY9asWWRkZBAYGEi3bt1YsWIFOt1/f4P9SG7fYjAYiImJIScnh6ysLKCxOJw8eXKTdf3ZnKDxzrDCwkKePHmCn58fRqOx2Xl+T1JSEpmZmVRVVWEwGIDGjgzArl27SEtLo6SkhLS0NAC1G6coCu3atSMqKkod6/MenC/30TidTvr06YOfn58as9vtjB079pfyFaKtkuJGiDbOarVSU1PDgAED6N69uxq3WCy8fftWvWUcGi8FnTx5krS0NKKiooiIiGDnzp3f7EwkJiZiNBpxuVxMnz5d87d169ZhMpnYuHEjpaWldO3aldjYWJYvXw7Atm3bmDdvHsnJyfj7+7Ns2TKePXum2S+SmZlJWVkZycnJBAQEsG7duu92bgC2bNlCdXU1KSkpdOnShSVLljR5wFxLuTXHYrHgdDrVtTAajZjNZl68ePHdPTQ/ktPSpUtJTU3FbDZTU1PT4jybEx0dTWxsLKdPn2bu3LlAY0GSlJREaWkp0dHRmM1m1qxZw/z589m5cydHjx5FURQiIiI06/+tTciKomguSdXW1nL+/HkuX778S/kK0Vb5eL6+KC6EED/p3bt39OzZk61bt/7fHkDnrXJzc8nIyKCoqAidTkdSUhJxcXGsX7/+t3/W7t27OXfuHFeuXPntYwvxJ0nnRgjx0xwOBw8ePCA+Ph63283atWuBxgcBitYZP348jx494vnz54SFhaEoivpwxd9Nr9eza9eu/8nYQvxJ0rkRQvw0h8PB7Nmzcblc+Pr6MmTIELZt26bZqCpar7KykuDgYIqLizGbzX86HSH+GlLcCCGEEMKryK3gQgghhPAqUtwIIYQQwqtIcSOEEEIIryLFjRBCCCG8ihQ3QgghhPAqUtwIIYQQwqtIcSOEEEIIryLFjRBCCCG8ihQ3QgghhPAqUtwIIYQQwqtIcSOEEEIIr/Ifnr/9IHAkNfQAAAAASUVORK5CYII=\n", "text/plain": [ "