{"cells": [{"cell_type": "markdown", "metadata": {}, "source": ["# Light extraction efficiency calculation of a square-shaped \u00b5-LED\n", "\n", "**Note: The FC cost of running this notebook is larger than 100 FCs.**\n", "\n", "Micro-light-emitting diodes (\u00b5-LEDs) based on InGaN have attracted significant attention as next-generation display technologies, with potential applications ranging from high-resolution panels to augmented and virtual reality systems. As \u00b5-LED dimensions shrink, ensuring high internal quantum efficiency (IQE) and, critically, light extraction efficiency (LEE) becomes increasingly challenging. LEE, in particular, is strongly influenced by structural parameters such as chip cross-sectional geometry, lateral size, and p-GaN thickness.\n", "\n", "The finite-difference time-domain (FDTD) method is a powerful tool for predicting and optimizing LEE, allowing systematic evaluation of design variations. These simulations, however, can be very computationally expensive and time-consuming, especially when sweeping a large number of parameters.\n", "\n", "Hence, Tidy3D GPU-accelerated solver is the perfect tool to tackle these problems, where large simulations can be handled extremely fast, and in parallel. This makes it possible to complete in just a few hours a workload that would take weeks using other solvers on traditional HPC systems.\n", "\n", "In this notebook, we will reproduce some results from the paper by `Han-Youl Ryu, Jeongsang Pyo, and Hyun Yeol Ryu, *\"Light Extraction Efficiency of GaN-Based Micro-Scale Light-Emitting Diodes Investigated Using Finite-Difference Time-Domain Simulation,\"* IEEE Photonics Journal (2020)`. [DOI:10.1109/JPHOT.2020.2977401](https://ieeexplore.ieee.org/document/9019847). \n", "\n", "First, we will calculate the LEE of a square LED as a function of its cross-sectional size and reflector absorption. Next, we will investigate the relation between LEE and p-GaN layer thickness. Finally, we will verify that, for larger LED sizes, the LEE is well represented by just a single dipole at the center, and that simulating and averaging multiple dipoles at different positions has little effect, greatly reducing computational cost.\n", "\n", "<img src=\"img/squareLED.png\" width=\"500\" alt=\"Schematic of the experiment\">\n", "\n", "For more information, please refer to our [learning center](https://www.flexcompute.com/tidy3d/examples/), where you can find more examples involving [LEDs](https://www.flexcompute.com/tidy3d/examples/notebooks/BlueMicroLED/) among many other structures."]}, {"cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": ["import matplotlib.pyplot as plt\n", "import numpy as np\n", "import tidy3d as td\n", "import tidy3d.web as web"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Since the notebook explores many parameter spaces, the cost of running it in full is quite high. For this reason, the global `RUN` parameter is set to `False` by default, to prevent unintentional execution."]}, {"cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": ["RUN = False"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## Simulation Setup\n", "\n", "First we will define global parameters that will be used in the simulation"]}, {"cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": ["# Set logging level to ERROR to avoid too many messages related to long runtimes\n", "td.config.logging.level = \"ERROR\"\n", "\n", "# Operation wavelength and frequency\n", "wl1 = 0.440\n", "wl2 = 0.480\n", "\n", "f1 = td.C_0 / wl2\n", "f2 = td.C_0 / wl1\n", "\n", "fwidth = (f2 - f1) / 2\n", "freq0 = f1 + fwidth\n", "wl0 = td.C_0 / freq0\n", "\n", "source_time = td.GaussianPulse(freq0=freq0, fwidth=fwidth)\n", "\n", "# Define heights\n", "nGanHeight = 3\n", "MQWHeight = 0.05\n", "reflectorThickness = 0.5\n", "\n", "# Wavelength to monitor LEE\n", "wvl_analysis = np.linspace(0.469, 0.472, 11)\n", "freq_analysis = td.C_0 / wvl_analysis"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Next we will define an auxiliary function to create the LED structure. The structure is defined by a stack of p-GaN, InGaN MQW and n-GaN on top of a silver reflector."]}, {"cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [], "source": ["def createStructure(pGanHeight=0.1, size=3, GANExtinctionCoef=30):\n", "    \"\"\"\n", "    Create a layered \u00b5-LED structure.\n", "\n", "    Parameters\n", "    ----------\n", "    pGanHeight : float\n", "        Thickness of the p-GaN layer (in \u00b5m).\n", "    size : float\n", "        Lateral size of the LED (in \u00b5m).\n", "    GANExtinctionCoef : float\n", "        Extinction coefficient of GaN (in cm\u207b\u00b9).\n", "\n", "    Returns\n", "    -------\n", "    structure : list\n", "        List of Tidy3D Structure objects representing the LED layers.\n", "    z_MQW_center : float\n", "        z-coordinate of the MQW layer center.\n", "    MQWHeight : float\n", "        Thickness of the MQW region (in \u00b5m).\n", "    dimensions : tuple\n", "        Overall dimensions of the LED (Lx, Ly, total height).\n", "    \"\"\"\n", "\n", "    L = size\n", "\n", "    # Define materials\n", "    reflectorThickness = 0.5\n", "    kGan = GANExtinctionCoef * (wl0 * 10**-4) / (4 * np.pi)\n", "    nGanMedium = td.Medium.from_nk(n=2.45, k=kGan, freq=freq0)\n", "    MQWMedium = td.Medium.from_nk(n=2.49, k=0, freq=freq0)\n", "    pGanMedium = td.Medium.from_nk(n=2.45, k=kGan, freq=freq0)\n", "    reflectorMedium = td.Lorentz.from_nk(n=0.14, k=2.47, freq=freq0)\n", "\n", "    # Compute z centers\n", "    z_reflector_center = reflectorThickness / 2\n", "    z_pGan_center = reflectorThickness + pGanHeight / 2\n", "    z_MQW_center = reflectorThickness + pGanHeight + MQWHeight / 2\n", "    z_nGan_center = reflectorThickness + pGanHeight + MQWHeight + nGanHeight / 2\n", "\n", "    reflector_box = td.Box(\n", "        center=(0, 0, z_reflector_center - 50), size=(10 * L, 10 * L, reflectorThickness + 100)\n", "    )\n", "    pGan_box = td.Box(center=(0, 0, z_pGan_center), size=(L, L, pGanHeight))\n", "    MQW_box = td.Box(center=(0, 0, z_MQW_center), size=(L, L, MQWHeight))\n", "    nGan_box = td.Box(center=(0, 0, z_nGan_center), size=(L, L, nGanHeight))\n", "\n", "    # Create structure list with materials\n", "    structure = [\n", "        td.Structure(geometry=reflector_box, medium=reflectorMedium, name=\"reflector\"),\n", "        td.Structure(geometry=pGan_box, medium=pGanMedium, name=\"pGan\"),\n", "        td.Structure(geometry=MQW_box, medium=MQWMedium, name=\"MQW\"),\n", "        td.Structure(geometry=nGan_box, medium=nGanMedium, name=\"nGan\"),\n", "    ]\n", "\n", "    total_height = reflectorThickness + pGanHeight + MQWHeight + nGanHeight\n", "\n", "    return structure, z_MQW_center, MQWHeight, (L, L, total_height)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Next, we will define a function to return the [Simulation](https://docs.flexcompute.com/projects/tidy3d/en/latest/api/_autosummary/tidy3d.Simulation.html) object. The source is a [PointDipole](https://docs.flexcompute.com/projects/tidy3d/en/latest/api/_autosummary/tidy3d.PointDipole.html). We will add a normalization monitor at the MQW to record the emitted power, along with two other [FluxMonitor](https://docs.flexcompute.com/projects/tidy3d/en/latest/api/_autosummary/tidy3d.FluxMonitor.html)s to record the total extracted power and the extracted power in the z+ direction.\n", "\n", "We will also define an auxiliary function to automatically set the appropriate symmetry when applicable, based on the source position.\n", "\n", "Since some \u00b5-LEDs can be relatively large, and the fields can remain confined inside the structure for a long time, we will increase the [shutoff](https://www.flexcompute.com/tidy3d/learning-center/tidy3d-gui/Lecture-8-Run-Time-and-Shutoff/) parameter from the default value of 1e-5 to 1e-4.\n"]}, {"cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [], "source": ["def parseSymmetry(geometrySymmetry, polarization, posx, posy=0):\n", "    \"\"\"Parse geometry symmetry and polarization to set Tidy3D symmetry flags.\n", "\n", "    Parameters\n", "    ----------\n", "    geometrySymmetry : tuple of bool\n", "        Symmetry along (x, y, z) axes.\n", "    polarization : str\n", "        Dipole polarization (\"Ex\", \"Ey\", or \"Ez\").\n", "    posx : float\n", "        x-position of the source (\u00b5m).\n", "    posy : float, optional\n", "        y-position of the source (\u00b5m), default is 0.\n", "\n", "    Returns\n", "    -------\n", "    list of int\n", "        Symmetry settings for (x, y, z), with 0 for none, \u00b11 for symmetry/antisymmetry.\n", "    \"\"\"\n", "\n", "    if polarization == \"Ex\":\n", "        sym = (-1 if geometrySymmetry[0] else 0, 1 if geometrySymmetry[1] else 0, 0)\n", "    elif polarization == \"Ey\":\n", "        sym = (1 if geometrySymmetry[0] else 0, -1 if geometrySymmetry[1] else 0, 0)\n", "    elif polarization == \"Ez\":\n", "        sym = (1 if geometrySymmetry[0] else 0, 1 if geometrySymmetry[1] else 0, 0)\n", "\n", "    return [sym[0] if posx == 0 else 0, sym[1] if posy == 0 else 0, 0]"]}, {"cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [], "source": ["def getSim(\n", "    pGanHeight=0.1,\n", "    size=20,\n", "    pad=1,\n", "    padz=1,\n", "    min_steps_per_wvl=12,\n", "    GANExtinctionCoef=30,\n", "    background_medium=td.Medium.from_nk(n=1.5, k=0, freq=freq0),\n", "    source_position=(0, 0),\n", "    polarization=\"Ex\",\n", "    symmetry=(1, 1, 0),\n", "):\n", "    \"\"\"Build a Tidy3D simulation of a square \u00b5-LED with dipole excitation.\n", "\n", "    Parameters\n", "    ----------\n", "    pGanHeight : float\n", "        Thickness of the p-GaN layer (\u00b5m).\n", "    size : float\n", "        Lateral size of the LED (\u00b5m).\n", "    pad : float\n", "        Padding in x and y directions (\u00b5m).\n", "    padz : float\n", "        Padding in z direction (\u00b5m).\n", "    min_steps_per_wvl : int\n", "        Minimum grid steps per wavelength.\n", "    GANExtinctionCoef : float\n", "        Extinction coefficient of GaN (cm\u207b\u00b9).\n", "    background_medium : td.Medium\n", "        Background medium of the simulation.\n", "    source_position : tuple\n", "        (x, y) position of the dipole source (\u00b5m).\n", "    polarization : str\n", "        Dipole polarization (\"Ex\", \"Ey\", or \"Ez\").\n", "    symmetry : tuple\n", "        Symmetry settings for the simulation.\n", "\n", "    Returns\n", "    -------\n", "    td.Simulation\n", "        Configured Tidy3D simulation with structures, source, and monitors.\n", "    \"\"\"\n", "\n", "    structures, QWCenter, QWHeight, structure_size = createStructure(\n", "        pGanHeight=pGanHeight, size=size, GANExtinctionCoef=GANExtinctionCoef\n", "    )\n", "\n", "    x, y = source_position\n", "    zPosition = QWCenter\n", "    dipole = td.PointDipole(\n", "        center=(x, y, zPosition),\n", "        polarization=polarization,\n", "        source_time=source_time,\n", "        name=f\"dipole_{x}_{y}_{polarization}\",\n", "    )\n", "\n", "    symmetry = parseSymmetry(symmetry, polarization, x, y)\n", "\n", "    grid_spec = td.GridSpec.auto(min_steps_per_wvl=min_steps_per_wvl, wavelength=wl1)\n", "\n", "    boundary_spec = td.BoundarySpec(\n", "        x=td.Boundary(minus=td.PML(), plus=td.PML()),\n", "        y=td.Boundary(minus=td.PML(), plus=td.PML()),\n", "        z=td.Boundary(minus=td.Absorber(), plus=td.PML()),\n", "    )\n", "\n", "    sim_size = [i + 2 * pad for i in structure_size[:2]] + [2 * padz + structure_size[2]]\n", "    sim_center = [0, 0, structure_size[2] / 2 + padz]\n", "\n", "    # Monitors\n", "\n", "    norm_flux_monitor = td.FluxMonitor(\n", "        center=structures[2].geometry.center,\n", "        size=structures[2].geometry.size,\n", "        name=\"norm_flux_monitor\",\n", "        freqs=freq_analysis,\n", "    )\n", "\n", "    outside_flux_monitor = td.FluxMonitor(\n", "        center=(sim_center[0], sim_center[1], sim_center[2] - pad / 2),\n", "        size=[sim_size[0] - pad, sim_size[1] - pad, sim_size[2] - pad / 2],\n", "        freqs=norm_flux_monitor.freqs,\n", "        name=\"outside_flux_monitor\",\n", "        exclude_surfaces=[\"z-\"],\n", "    )\n", "\n", "    lateral_flux_monitor = td.FluxMonitor(\n", "        center=(sim_center[0], sim_center[1], sim_center[2] - pad / 2),\n", "        size=[sim_size[0] - pad, sim_size[1] - pad, sim_size[2] - pad / 2],\n", "        freqs=norm_flux_monitor.freqs,\n", "        name=\"lateral_flux_monitor\",\n", "        exclude_surfaces=[\"z-\", \"z+\"],\n", "    )\n", "\n", "    sim = td.Simulation(\n", "        size=sim_size,\n", "        center=sim_center,\n", "        grid_spec=grid_spec,\n", "        structures=structures,\n", "        sources=[dipole],\n", "        monitors=[norm_flux_monitor, outside_flux_monitor, lateral_flux_monitor],\n", "        run_time=20e-12,\n", "        boundary_spec=boundary_spec,\n", "        medium=background_medium,\n", "        symmetry=symmetry,\n", "        shutoff=1e-4,\n", "    )\n", "\n", "    return sim"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Now we can plot and inspect the geometry."]}, {"cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [{"data": {"text/html": ["\n", "    <div class=\"simulation-viewer\" data-width=\"800\" data-height=\"800\" data-simulation=\"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\" ></div>\n", "    <script>\n", "        \n", "        /**\n", "        * Simulation Viewer Injector\n", "        *\n", "        * Monitors the document for elements being added in the form:\n", "        *\n", "        *    <div class=\"simulation-viewer\" data-width=\"800\" data-height=\"800\" data-simulation=\"{...}\" />\n", "        *\n", "        * This script will then inject an iframe to the viewer application, and pass it the simulation data\n", "        * via the postMessage API on request. The script may be safely included multiple times, with only the\n", "        * configuration of the first started script (e.g. viewer URL) applying.\n", "        *\n", "        */\n", "        (function() {\n", "            const TARGET_CLASS = \"simulation-viewer\";\n", "            const ACTIVE_CLASS = \"simulation-viewer-active\";\n", "            const VIEWER_URL = \"https://tidy3d.simulation.cloud/simulation-viewer\";\n", "\n", "            class SimulationViewerInjector {\n", "                constructor() {\n", "                    for (var node of document.getElementsByClassName(TARGET_CLASS)) {\n", "                        this.injectViewer(node);\n", "                    }\n", "\n", "                    // Monitor for newly added nodes to the DOM\n", "                    this.observer = new MutationObserver(this.onMutations.bind(this));\n", "                    this.observer.observe(document.body, {childList: true, subtree: true});\n", "                }\n", "\n", "                onMutations(mutations) {\n", "                    for (var mutation of mutations) {\n", "                        if (mutation.type === 'childList') {\n", "                            /**\n", "                            * Have found that adding the element does not reliably trigger the mutation observer.\n", "                            * It may be the case that setting content with innerHTML does not trigger.\n", "                            *\n", "                            * It seems to be sufficient to re-scan the document for un-activated viewers\n", "                            * whenever an event occurs, as Jupyter triggers multiple events on cell evaluation.\n", "                            */\n", "                            var viewers = document.getElementsByClassName(TARGET_CLASS);\n", "                            for (var node of viewers) {\n", "                                this.injectViewer(node);\n", "                            }\n", "                        }\n", "                    }\n", "                }\n", "\n", "                injectViewer(node) {\n", "                    // (re-)check that this is a valid simulation container and has not already been injected\n", "                    if (node.classList.contains(TARGET_CLASS) && !node.classList.contains(ACTIVE_CLASS)) {\n", "                        // Mark node as injected, to prevent re-runs\n", "                        node.classList.add(ACTIVE_CLASS);\n", "\n", "                        var uuid;\n", "                        if (window.crypto && window.crypto.randomUUID) {\n", "                            uuid = window.crypto.randomUUID();\n", "                        } else {\n", "                            uuid = \"\" + Math.random();\n", "                        }\n", "\n", "                        var frame = document.createElement(\"iframe\");\n", "                        frame.width = node.dataset.width || 800;\n", "                        frame.height = node.dataset.height || 800;\n", "                        frame.style.cssText = `width:${frame.width}px;height:${frame.height}px;max-width:none;border:0;display:block`\n", "                        frame.src = VIEWER_URL + \"?uuid=\" + uuid;\n", "\n", "                        var postMessageToViewer;\n", "                        postMessageToViewer = event => {\n", "                            if(event.data.type === 'viewer' && event.data.uuid===uuid){\n", "                                frame.contentWindow.postMessage({ type: 'jupyter', uuid, value: node.dataset.simulation, fileType: 'hdf5'}, '*');\n", "\n", "                                // Run once only\n", "                                window.removeEventListener('message', postMessageToViewer);\n", "                            }\n", "                        };\n", "                        window.addEventListener(\n", "                            'message',\n", "                            postMessageToViewer,\n", "                            false\n", "                        );\n", "\n", "                        node.appendChild(frame);\n", "                    }\n", "                }\n", "            }\n", "\n", "            if (!window.simulationViewerInjector) {\n", "                window.simulationViewerInjector = new SimulationViewerInjector();\n", "            }\n", "        })();\n", "    \n", "    </script>\n", "    "], "text/plain": ["<IPython.core.display.HTML object>"]}, "metadata": {}, "output_type": "display_data"}], "source": ["sim = getSim()\n", "sim.plot_3d()"]}, {"cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [{"data": {"image/png": "iVBORw0KGgoAAAANSUhEUgAAA2QAAAG1CAYAAACWFTdrAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjYsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvq6yFwwAAAAlwSFlzAAAPYQAAD2EBqD+naQAAyzxJREFUeJzs3XmYFNW5+PHvqaquXmaYRXbEICqKERXjghiNiWAwcSMao1yNS1DjvnCNSlQUNJJo3BKiXONCNJoQcm/wRg0RcUXRRGPuL65BgxqRARmZfbqrq875/VHdzfRM9ywwC8O8n+fpZ3qqTtU5vcx0vX3OeY8yxhiEEEIIIYQQQvQ6q68bIIQQQgghhBADlQRkQgghhBBCCNFHJCATQgghhBBCiD4iAZkQQgghhBBC9BEJyIQQQgghhBCij0hAJoQQQgghhBB9RAIyIYQQQgghhOgjEpAJIYQQQgghRB+RgEwIIYQQQggh+ogEZEL0oeeeew6lFM8991xfN0V0s7/85S+4rstHH33U63VXV1dTUlLCk08+2et1CyGEEKJrJCATohfcfffdLFq0qK+bsUUeffRR7rzzzr5uBgBaa2655RbGjh1LLBZjn3324Te/+U2XzvH0009zxBFHUF5ezqBBg9h///1ZvHhxbn91dTW33norX/nKVxg6dCgVFRUcfPDBeWU645prrmHGjBmMGTOmS8d1h8GDB3P22Wdz3XXX9XrdQgghhOgaZYwxfd0IIbZ3EyZMYMiQIW16wrTWeJ6H67pY1rb5/cgxxxzDm2++yYcfftjXTWH27Nn8+Mc/5pxzzuHAAw/kscce44knnuA3v/kNp5xySofHP/jgg8ycOZMjjzyS4447Dtu2ee+999hxxx254oorAHj88cc54YQT+OY3v8nXvvY1HMfhv//7v3n22WeZM2cOc+fO7bCev//97+y33368/PLLTJ48easf95Z45513+OIXv8iKFSs44ogj+qQNQgghhOiYBGSi1zQ2NlJSUtLXzegTxQKy/mBbCcjWrl3L2LFjOffcc1mwYAEAxhgOP/xw1qxZw4cffoht20WP//DDD/niF7/IOeecw1133VW03Jo1a7AsK69nyxjD1KlTeemll3LDAdtz6aWXsnTpUj788EOUUl18pN1n7733Zr/99uOhhx7qszYIIYQQon3b5lfyYpu3du1aZs6cyahRo4hGo4wdO5bzzz8fz/MAWLRoEUopnn/+eS644AKGDRvG6NGjc8fffffd7LXXXkSjUUaNGsWFF15ITU1NXh2rV6/mxBNPZMSIEcRiMUaPHs0pp5xCbW1trszy5cs59NBDqaiooLS0lD322IMf/vCHHba/M8elUimuv/56dtttN6LRKDvttBNXXnklqVSqzfl+/etfc9BBB5FIJKisrOQrX/kKTz31FAA777wzb731Fs8//zxKKZRSfPWrXwWKzyFbsmQJ+++/P/F4nCFDhnDaaaexdu3avDJnnnkmpaWlrF27lunTp1NaWsrQoUO54oorCIKgw+fgscce4+ijj869hrvuuis33nhj3rFf/epXeeKJJ/joo49ybd95552LnvPMM8/MlWt9u+GGGzpsU0ftTafTXHDBBbltSinOP/98PvnkE1atWtXu8QsXLiQIAubNmwdAQ0MDhb6PGjt2bJthhkoppk+fTiqV4l//+leHbV26dClHHHFEm2Cs2POw8847c+aZZ+Z+z/79rFy5kksuuSQ3dPL73/8+nudRU1PD6aefTmVlJZWVlVx55ZUFH8uRRx7JH//4x4L7hBBCCLFtcPq6AaL/+fTTTznooIOoqanh3HPPZfz48axdu5bf//73NDU14bpuruwFF1zA0KFDmTNnDo2NjQDccMMNzJ07l6lTp3L++efz3nvvcc899/DXv/6Vl156iUgkgud5TJs2jVQqxcUXX8yIESNYu3Ytjz/+ODU1NZSXl/PWW29xzDHHsM8++zBv3jyi0Sjvv/8+L730Urvt78xxWmuOO+44Vq5cybnnnsuee+7JP/7xD+644w7++c9/snTp0lzZuXPncsMNN3DIIYcwb948XNfl1Vdf5ZlnnuHrX/86d955JxdffDGlpaVcc801AAwfPrxo+xYtWsRZZ53FgQceyPz581m/fj133XUXL730Em+88QYVFRW5skEQMG3aNCZNmsRPf/pTnn76aW677TZ23XVXzj///Hafh0WLFlFaWsqsWbMoLS3lmWeeYc6cOdTV1XHrrbcC4Tyo2tpaPvnkE+644w4ASktLi57z+9//PlOnTs3btmzZMh555BGGDRuW27Zx48Z225Y1aNAgotEoAG+88QYlJSXsueeeeWUOOuig3P5DDz206Lmefvppxo8fz5NPPskPfvAD1q5dS2VlJRdeeCFz587tcMhoVVUVAEOGDGm33Nq1a/n444/50pe+1OHj60j2vT937lxeeeUV7r33XioqKnj55Zf5whe+wM0338yTTz7JrbfeyoQJEzj99NPzjt9///254447eOutt5gwYcJWt0cIIYQQPcAI0UWnn366sSzL/PWvf22zT2ttjDHmwQcfNIA59NBDje/7uf0bNmwwruuar3/96yYIgtz2BQsWGMA88MADxhhj3njjDQOYJUuWFG3HHXfcYQDz2Wefdan9nTnu4YcfNpZlmRdffDFv+8KFCw1gXnrpJWOMMatXrzaWZZlvfetbeY/HmM3PhTHG7LXXXubwww9vU8+zzz5rAPPss88aY4zxPM8MGzbMTJgwwTQ3N+fKPf744wYwc+bMyW0744wzDGDmzZuXd8799tvP7L///u0/CcaYpqamNtu+//3vm0QiYZLJZG7b0UcfbcaMGdPh+QpZvXq1KS8vN0ceeWTe+wDo1O3BBx/Ma8cuu+zSpo7GxkYDmKuvvrrdtpSVlZnKykoTjUbNddddZ37/+9+b//iP/+jUsdXV1WbYsGHmsMMO6/AxP/300wYwf/zjH9vsA8z111/fZvuYMWPMGWeckfs9+/czbdq0vPfR5MmTjVLKnHfeebltvu+b0aNHF3x/vfzyywYwixcv7rDdQgghhOgbMmRRdInWmqVLl3LsscdywAEHtNnfeojWOeeckzev5+mnn8bzPC677LK8HolzzjmHsrIynnjiCQDKy8sB+POf/0xTU1PBtmR7ih577DG01p1+DJ05bsmSJey5556MHz+ejRs35m7Z5AjPPvssEA5N01ozZ86cNj0sWzJ36LXXXmPDhg1ccMEFxGKx3Pajjz6a8ePH556fls4777y83w877LBODauLx+O5+/X19WzcuJHDDjuMpqYm3n333S63vbXGxka+9a1vUVlZyW9+85u898Hy5cs7dZs2bVrumObm5lxvWUvZ56m5ubnd9jQ0NLBp0ybmzp3LvHnzOPHEE3nkkUc46qijuOuuu6ivry94nNaaU089lZqaGn7+8593+Lirq6sBqKys7LBsR2bOnJn3Ppo0aRLGGGbOnJnbZts2BxxwQMHXPNuGzvZICiGEEKL3yZBF0SWfffYZdXV1nR7+NHbs2Lzfs2sy7bHHHnnbXddll112ye0fO3Yss2bN4vbbb+eRRx7hsMMO47jjjuO0007LBWsnn3wy9913H2effTZXX301U6ZM4YQTTuDb3/52u8PPOnPc6tWreeeddxg6dGjBc2zYsAGADz74AMuy+OIXv9ip56MjxZ4fgPHjx7Ny5cq8bbFYrE0bKysr2bRpU4d1vfXWW1x77bU888wz1NXV5e1rOU9vS51zzjl88MEHvPzyywwePDhvX+thjZ0Rj8cLzt9LJpO5/R0d39jYyIwZM/K2z5gxg2XLlvHGG2/wla98pc1xF198McuWLeOhhx5i33337XR7TTfM2/rCF76Q93v2vb/TTju12V7oNc+2oS8TiwghhBCifRKQiR7V0UVye2677TbOPPNMHnvsMZ566ikuueQS5s+fzyuvvMLo0aOJx+O88MILPPvsszzxxBMsW7aMxYsXc8QRR/DUU08VzbjXmeO01uy9997cfvvtBc/R+oK4r7SXVbA9NTU1HH744ZSVlTFv3jx23XVXYrEYf/vb37jqqqu61ONYyF133cVvfvMbfv3rXzNx4sQ2+7PzsTpSXl6eew+NHDmSZ599FmNMXoCxbt06AEaNGtXuuUaNGsXq1avbzN/Lzm0rFNDMnTuXu+++mx//+Md897vf7VSbs8FnZ4LirGLBW7HXt9D2QufItqGjeW9CCCGE6DsyZFF0ydChQykrK+PNN9/couOz2evee++9vO2e57FmzZo22e323ntvrr32Wl544QVefPFF1q5dy8KFC3P7LctiypQp3H777bz99tv86Ec/4plnnskNKSymo+N23XVXPv/8c6ZMmcLUqVPb3LI9WLvuuitaa95+++126+tsD0Wx5ye7rbsWGX7uueeorq5m0aJFXHrppRxzzDFMnTq14DC7rvauvPjii1xxxRVcdtllnHrqqQXLjBw5slO3losxT5w4kaamJt555528c7366qu5/e3Zf//9Adpkq/z0008B2vQ0/uIXv+CGG27gsssu46qrrur4gWeMHz8eCNPnF1JoaGS2x7W7ZdvQOhGKEEIIIbYdEpCJLrEsi+nTp/PHP/6R1157rc3+joZpTZ06Fdd1+dnPfpZX9v7776e2tpajjz4agLq6Onzfzzt27733xrKs3LC1zz//vM35sxflhYa2ZXXmuO985zusXbuWX/7yl23KNjc35zJGTp8+HcuymDdvXptepZaPr6SkpE1a/0IOOOAAhg0bxsKFC/Mew5/+9Cfeeeed3POztbI9LC3b6Hked999d5uyJSUlnR7CuG7dOr7zne9w6KGH5jI1FrIlc8iOP/54IpFIXhuNMSxcuJAdd9yRQw45JK8d7777Lul0Orft5JNPBsL3WpbWmgcffJAddtghF7ABLF68mEsuuYRTTz21aC9pMTvuuCM77bRTwb8PoM0SB3/6059IJpM9kpr+9ddfp7y8nL322qvbzy2EEEKI7iFDFkWX3XzzzTz11FMcfvjhuZTw69atY8mSJaxcuTIvLXtrQ4cOZfbs2cydO5ejjjqK4447jvfee4+7776bAw88kNNOOw2AZ555hosuuoiTTjqJ3XffHd/3efjhh7FtmxNPPBGAefPm8cILL3D00UczZswYNmzYwN13383o0aPbTX/emeO++93v8rvf/Y7zzjuPZ599li9/+csEQcC7777L7373O/785z9zwAEHsNtuu3HNNddw4403cthhh3HCCScQjUb561//yqhRo5g/fz4Q9s7cc8893HTTTey2224MGzYslyCkpUgkwk9+8hPOOussDj/8cGbMmJFLe7/zzjtz+eWXb+nLlueQQw6hsrKSM844g0suuQSlFA8//HDBoGD//fdn8eLFzJo1iwMPPJDS0lKOPfbYgue95JJL+Oyzz7jyyiv57W9/m7dvn332YZ999gG2bA7Z6NGjueyyy7j11ltJp9MceOCBLF26lBdffJFHHnkkbxjf7Nmz+dWvfsWaNWty66Ydf/zxTJkyhfnz57Nx40b23Xdfli5dysqVK/mv//qvXMKQv/zlL5x++ukMHjyYKVOm8Mgjj7R57nbZZZd223r88cfzhz/8oc3wSoB33nmHb37zmxx33HF8+umn3HXXXZSXl/Pyyy/zm9/8ps0ct62xfPlyjj32WJlDJoQQQmzL+iK1o+j/PvroI3P66aeboUOHmmg0anbZZRdz4YUXmlQqZYzZnLa7UGp8Y8I09+PHjzeRSMQMHz7cnH/++WbTpk25/f/617/M9773PbPrrruaWCxmdthhB/O1r33NPP3007kyK1asMMcff7wZNWqUcV3XjBo1ysyYMcP885//bLftnT3O8zzzk5/8xOy1114mGo2ayspKs//++5u5c+ea2travLIPPPCA2W+//XLlDj/8cLN8+fLc/qqqKnP00UebQYMGGSCXorx12vusxYsX5863ww47mFNPPdV88skneWXOOOMMU1JS0ubxXX/99aYzf9ovvfSSOfjgg008HjejRo0yV155pfnzn//cpj0NDQ3mP/7jP0xFRYUB2k2Bf/jhhxdNYV8o3XtXBUFgbr75ZjNmzBjjuq7Za6+9zK9//es25bJLAqxZsyZve319vbn00kvNiBEjjOu6Zu+9925zfPa9W+zWMhV/MX/7298M0GbZBMDMmjXLnHTSSSYej5uRI0eaBQsWmIULF5pEImHOPvvsvDa0/vvJvratl2wo9F545513DJD3NyOEEEKIbY8ypgfGyQghxAA3ZcoURo0axcMPP5zbppTi+uuv54Ybbujx+i+77DJeeOEFXn/9dekhE0IIIbZhModMCCF6wM0338zixYtzSxn0purqau677z5uuukmCcaEEEKIbZzMIRNCiB4wadIkPM/rk7oHDx5MQ0NDn9QthBBCiK6RHjIhhBBCCCGE6CPSQyaEEL1EpuwKIYQQojXpIRNCCCGEEEKIPiI9ZN1Ia82nn37KoEGDZCK9EEL0ImMM9fX1jBo1CsuS7xqFEEL0HxKQdaNPP/2U+3+5ANTmp1VhsHUdiuJDlbSKAApl0gAYFQEMVub33mCUjcFB4aNMkNem9trerW1A5T321m3qLQP59fA1VH3uo3WYoj0ajaK1xvM8HMfBcRx838f3/R5rQ2uu62JZFqlUCiCvTb2l9WNv2abeGoYor8dmjuPgui7xeBwgtyj4jTfeyL///W9Gjx7da20RQgghtpYEZN1o0KBBoBxs28JWYEx46VxRVkbEaicgM9CQtEnrsFctYhlKYwGWivdSy0PNnkVTOvxm2VEwKBoQsWO92oZ0oKhP2RgDCkhENHFX92obBuzrYTQGzagxY1GWC4Dv+9TW1qJ1+BqUlJSQSCR6rg0FaK2pq6sjnQ4D4kgkQllZWa/3gjQ1NdHY2AiAZVmUl5fjOL37L1Rej80aGhqoqanJ/Z6tf9CgQb3aDiGEEGJrSUDWjbLDFG0Ftm2hTXhx70ZsInb7x1o21DSGFxRlJRq3ly/0AJwIpOrCNriOoSTeQaN7gAuktcLzw+dyUAlYqveHHw3E18OYAKM10VgUy9kcfKbTaZLJJAA77LBDnwwHi0QibNy4EQhTukej0V5vQywWy/UKxWIxysrKer0NIK9HlmVZ1NbWYozBsqxccCzDxYUQQvQ3MtB+G5D2obZJ4VgGxzLUNinSvTcCCQgDx9pGhVIG1zF4vqIx2fsXNo3JMBhzHYNShtpGhe7lxHTyemxWX19PMpkkFouhlKK6ujrXO9NbPM+jurqaSCRCJBKhurq619f30lpTXV2NUopYLEYymaS+vr5X2wDyemRprXO9Y5ZlobXu1WGbQgghRHeSHrIeYDI9YyZz89uZ/uT7UJdUOApK42HkUd+k+LxRURYz9EbHjDFhnb4hV6eVgvqkItAQj/ZORNScUjR5ioRriEdN7rnZVK8YlDD0xhffA/n1MAbQCivto7RHY2MjDQ0NlJaWUlJSQiwWY9OmTWzYsIHKyspe6YlIp9Ns2rQJx3EoLy8HyGtDJBLp8TYYY9i0aRO+7+fqtCyLmpoafN+npKSkx9sAyOuRkX09PM/Dtm1s28b3fYKg9+aZCiGEEN1JArJupjAYFFobDOE8Ms83BAW+xDY6nDPl2oaIbfAyX/BGIwYrUDR7EAkMPTpiz4RtUMqQcAyBgSANlmWIRxTpAEwSbLtng7IgUPjaEI8YLMuQyuTPSEQM6UDRmISInZlY1kMG/OthAGOhUx6BTpNOpykpKcG27dwQudLSUjzPo66uDtd1ezQIyCaKiEajuK6bGy4Yj8fxvDBgzCaY6CnGGDzPw7IsSktLCYKAIAiwbZuSkhI8z8MY0+NzyXzfl9eD/NejpKQkN5/OcRxZ400IIUS/JQFZN3NVHaUxm4gFvrZIBw4HjvqA0miqr5smRPu0j3JKGH7Q6Tjx4X3dGiHaVVtby5NPPkk0GiUSieSCVCGEEKK/kYCsm2ltiDgxXNdGBWB8i8FDv0BZonfneQjRVdpvwvhNVFaUESnZoa+bI0SHHMchEonguq7MIRNCCNFvSUDW3QwoZaGUjVJhxi/lxLF6fmqFEFtNB72bnEEIIYQQYqCTLItCCCGEEEII0Uekh6wvGAM63detECKfToNJQ7oOvN7JHChEpzhl0AfrrQkhhBC9QQKyvqDT8NnKvm6FEPl0ANqH/zcHnN5f6FeIog5YAG5FX7dCCCGE6BHylWMP6+U1W4UQQgghhBD9iPSQ9SDfh3RHa5Um1/dKW4TokMncql+Tr2rEtmHol/u6BUIIIUSPk4Csm9k26KCJZNKmtjmGa2tSNf8kmWyxDpkOINUQ3u8oYBOilxgj03SEEEIIIXqbBGTdzBjwTYQmL4ZjaSIO2G4ZdrTFGjnah9S68H42IIuUgpKrYdF3tNEoA1TuInPIRN/RHmz6v75uhRBCCNFrJCDrZoFWNHhxoo6iJKZIBw5OYiSRlknrAg+a1oT3/drwZySOjBMTfUnrAK19sNzwJoQQQgghetw2FwG88MILHHvssYwaNQqlFEuXLs3bb4xhzpw5jBw5kng8ztSpU1m9enWH5/3FL37BzjvvTCwWY9KkSfzlL3/J259MJrnwwgsZPHgwpaWlnHjiiaxf3/X5XUZFcJShvMSgVJcPb3kmucmtb24mkJvcevmGEEIIMWBtcz1kjY2N7Lvvvnzve9/jhBNOaLP/lltu4Wc/+xm/+tWvGDt2LNdddx3Tpk3j7bffJhaLFTzn4sWLmTVrFgsXLmTSpEnceeedTJs2jffee49hw4YBcPnll/PEE0+wZMkSysvLueiiizjhhBN46aWXuvwYSmMBlnK2YnqYCdeCEqI3GRPeGj8OJ0MK0VtKdwHkPSeEEGJg2uYCsm984xt84xvfKLjPGMOdd97Jtddey/HHHw/AQw89xPDhw1m6dCmnnHJKweNuv/12zjnnHM466ywAFi5cyBNPPMEDDzzA1VdfTW1tLffffz+PPvooRxxxBAAPPvgge+65J6+88goHH3xwwfOmUilSqc3JOurqJIgSQgghhBBCdN42F5C1Z82aNVRVVTF16tTctvLyciZNmsSqVasKBmSe5/H6668ze/bs3DbLspg6dSqrVq0C4PXXXyedTuedd/z48XzhC19g1apVRQOy+fPnM3fu3LxtN865nIakjdtNU3CSjfXdcyIhOmAAoxTV9TVYMoZM9IJhO47t6yYIIYQQfW6bm0PWnqqqKgCGDx+et3348OG5fa1t3LiRIAjaPaaqqgrXdamoqOj0eQFmz55NbW1t7vbvf/8bZdL4RlHbqDByTSuEEEIIIYRoR7/qIdvWRKNRotH89OC2ZSh1m2lKx6hr1EQjGr+pirRplfbeT2buZ7b5KaBFFpAgnIGmM5lBfC0vlegdDb6LMluVkUaIohSG0oj0/AshhBBZ/eoqf8SIEQCsX7+ekSNH5ravX7+eiRMnFjxmyJAh2LbdJmPi+vXrc+cbMWIEnudRU1OT10vWskxnKQWOSlMW1dQ0x7B8CLw6AqvVwtBBJkDL9qIFPpsDMgMmjNSyAVn/6ssU/ZYBgyLvywEhhBBCCNFj+lVANnbsWEaMGMGKFStyAVhdXR2vvvoq559/fsFjXNdl//33Z8WKFUyfPh0ArTUrVqzgoosuAmD//fcnEomwYsUKTjzxRADee+89Pv74YyZPntylNgYBWHYC13UoV9CcdohW7EGs9TpkwabwvmkMf0ZL2Bx1GUiHAVkyFfakedJDJnqckThMCCGEEKKXbXNX+Q0NDbz//vu539esWcPf//53dthhB77whS9w2WWXcdNNNzFu3Lhc2vtRo0blgi2AKVOm8K1vfSsXcM2aNYszzjiDAw44gIMOOog777yTxsbGXNbF8vJyZs6cyaxZs9hhhx0oKyvj4osvZvLkyUUTenSG40BEd1xOCCGEEEIIMTBtcwHZa6+9xte+9rXc77NmzQLgjDPOYNGiRVx55ZU0NjZy7rnnUlNTw6GHHsqyZcvy1iD74IMP2LhxY+73k08+mc8++4w5c+ZQVVXFxIkTWbZsWV6ijzvuuAPLsjjxxBNJpVJMmzaNu+++e6sfjyVDDYUQQgghhBBFKGMkF2B3qaurY8FPf8iQHcpwXYd0AJ6vOHJimvLWQxY/WxneT2bmtsWGkj9kMVzTLJv23tPdlEdfiKIyQxZTtiT1ED1GYRgUCf+/5dLel+4CKrMwtPag+q/h/aFfDn8esADcirzzfP755yxZsoRYLIbrujQ1NXH22WdTW1tLWVlZLzwSIYQQontI/40QQgghhBBC9BEJyIQQQgghhBCij2xzc8j6PQXGaIwJMAaMsTB+MzrdIruHToep72Fz2nsdtPjFkF1VevN4UhlZKoQQQgghxPZGArJuZltgdBM6DSawMEGEVN1qUpn09UC4xpiXSXefjdO8JvLWIdPhOmVBNiuITOkRQgghhBBiuyMBWTcLNCgrgRWxURYoZREtG0c00aqHLAiTdZBqDn+6CfKSevgN4W4vDOS0tnvnAYiBTQJ/0U81NTX1dROEEEKILSIBWXczYRCmlI1SoJRCOXGsSIsygQdWJsDKXgBbNnkBmVJ5u+VKWfQ8GRYr+hetwy+66uvraWxs7OPWCCGEEFtGAjIhhBD9kud5eJ5HOp2mpKSk4wOEEEKIbZBkWRRCCNEvGWNIpVLEYjESiURfN0cIIYTYIhKQCSGE6NdSqRS+7/d1M4QQQogtIgGZEEKIfikSiTBs2DAikQi1tbV93RwhhBBii0hAJoQQol9yHAelFIMHD8a2JROtEEKI/kmSenQz2wYdNBGkFTqw0IFNquYDksnU5kI6gFSY1p7M+tCkGslfhywNgJ9bh0wy4IleIG8z0Q9ZlkVZWVlfN0MIIYTYIhKQdTNjQCkHZVkoo1DawnbLsKMt5jdoH1LrwvvZgMx2yEttb8KATJvwClm3WMZMiB4jqyuIfsqyZMCHEEKI/kkCsm6mNSjLxbIdFKCMwkmMJNIyI3PgQdOa8L6fmffgRMlbh8yEPWpBJiDDyJWy6GnSPSaEEEII0dvkK0UhhBBCCCGE6CMSkAkhhBBCCCFEH5GATAghhBBCCCH6iARkPczItBwhhBBCCCFEERKQ9SBjIB10XE4IIYQQQggxMEmWxW5mWWC0h+/71DVGUAr8pnWkTau0934ycz+zzU+Rl3M8CCM5rTLbZB0y0RskmacQQgghRK+SgKybKQVa+zQ0xfE1JCI+gVdHYLVaGDrIBGjZOCvwyVsY2oSRWi4gk75M0Rsk7hdCCCGE6FUSkHWzIIDG9CCMsihPGDQO0Yo9iLVehyzYFN43jeHPaAl565Clw4AsmQp70jwtL5XoaUZ6yIQQQgghepn0u3QzrSL4RlGRMDgSQwkhhBBCCCHaIQFZt1MMigZEJBgTQgghhBBCdEACsm5niNgyEUcIIYQQQgjRMQnIup1FsydPqxBCCCGEEKJjEjl0M4VPU9qiMSnZEYQQQgghhBDtk5lO3UwREI/4NCQjxLTBtgzGb0an9eZCOh2mvofNacZ10OIXE64qTcss5DIMUgghhBBCiO2NBGTdzLYgZjdg49KQjBKLpEnVrSaVSV8PhGuMeZl099k4zWsibx0yHa5TFliZTkzpcBNCCCGEEGK7IwFZNws0KCtBacxGWxZ+ECNaNo5oolUPWVAf3k81hz/dBHnrkPkN4W4vDOS0tnvnAYiBTQJ/IYQQQoheJQFZdzOglIVSNokoNKUUyoljRVqUCTywMgFW9gLYsskLyJTK2y1XyqLnybBYIYQQQojeJkk9epgjHVtCCCGEEEKIIiQgE0IIIYQQQog+IgGZEEIIIYQQQvQRCciEEEIIIYQQoo9IQCaEEEIIIYQQfUSyLHYz2wYdNBGkFTqw0IFNquYDksnU5kI6gFSY1p7M+tCkGslfhywNgJ9bh0wy4IleIG8zIYQQQoheJQFZNzMGlHJQloUyCqUtbLcMO+pvLqR9SK0L72cDMtshL7W9CQMybcIrZN1iGTMheoysriD6Kd/3Oy4khBBCbIMkIOtmWoOyXCzbQQHKKJzESCIlLQoFHjStCe/7teFPJ0reOmQm7FELMgEZRq6URU+T7jHRv5jM/0fP86itre3j1gghhBBbRgIyIYQQ/ZLnedi2TV1dHbYtiz4KIYTonyQgE0II0S9prdm0aRPRaJREItHXzRFCCCG2iGRZFEIIIYQQQog+IgGZEEKIfsmyLCorK/F9n7q6ur5ujhBCCLFFJCATQgjRL7mui+u6DBkyhCAIOj5ACCGE2AbJHLJuZllgtIcOfEygMIGF31RF2rRKe+8nM/cz2/wUeTnHMxcXWmW2yTpkojdIMk/Rj6jM/0fXdSkvL+/j1gghhBBbRgKybqYUGONjtMJoC2NsAq+OwGq1MHSQCdCycVbgk7cwtAkjtVxAJn2ZojdI3C/6KceRjzMhhBD9k3yCdbMgAMtOYEcctAWWUkQr9iDWeh2yYFN43zSGP6Ml5K1Dlg4DsmQq7EnztLxUoqcZ6SETQgghhOhl0u8ihBBCCCGEEH1EAjIhhBBCCCGE6CMSkAkhhBBCCCFEH5GATAghhBBCCCH6iARkPcyXpXGEEEIIIYQQRUjqvu6mwBiNMQFNKQs/AOM3o9N6cxmdDlPfw+Y04zpo8YsBY/J2Sz5yIYQQQgghtj8SkHUz2wKjm2hodGnyosQiaVJ1q0ll0tcD4RpjXibdfTZO85rIW4dMh+uUBVamE1PSkQshhBBCCLHdkYCsmwUakkEpKT9CIqaxrSjRsnFEE616yIL68H6qOfzpJshbh8xvCHd7YSCntd07D0AMbBL4CyGEEEL0KgnIupnBpjntUBYHN6LwfIVy4liRFoUCD6xMgJW9ALZs8gIypfJ2y5Wy6HkyLFYIIYQQordJUo9uZnBIRDQlMbm4FUIIIYQQQrRPArJup4m7uuNiQgghhBBCiAFPArJup0gHMrxQCCGEEEII0TEJyLqdoT5lk/b7uh1CCCGEEEKIbZ0EZN3MMmkcZahpUvgSlAkhhBBCCCHaIVkWu5ltQ0mkniY/Tm2TRSLik6p5n2QytbmQDiAVprUnsz40qUby1yFLA+Dn1iGTJCGiF8jbTAghhBCiV0lA1s2MActyKE8E1DRapLWD7ZZhR1t0l2kfUuvC+9mAzHbIS21vwoBMm/AKWUueENEbZPqjEEIIIUSvkoCsm2kNynJxHIeyEmhMKZzESCIlLQoFHjStCe/7teFPJ0reOmQm7FELMgEZRq6URU+T7jEhhBBCiN4mc8h6kFIQsfu6FUIIIYQQQohtlQRkPUxJx5YQQgghhBCiCAnIhBBCCCGEEKKP9LuA7IYbbkAplXcbP358u8csWbKE8ePHE4vF2HvvvXnyySfz9htjmDNnDiNHjiQejzN16lRWr17dkw9DCCGEEEIIIfpfQAaw1157sW7dutxt5cqVRcu+/PLLzJgxg5kzZ/LGG28wffp0pk+fzptvvpkrc8stt/Czn/2MhQsX8uqrr1JSUsK0adNIJpO98XCEEEIIIYQQA1S/zLLoOA4jRozoVNm77rqLo446ih/84AcA3HjjjSxfvpwFCxawcOFCjDHceeedXHvttRx//PEAPPTQQwwfPpylS5dyyimnFD13KpUildq8vlhdXR2WBUZ76MDHBAoTWPhNVaRNq7T3fibYy6az91Pk5RwPwnz4OjsJTdYhE71B5jwKIYQQQvSqftlDtnr1akaNGsUuu+zCqaeeyscff1y07KpVq5g6dWretmnTprFq1SoA1qxZQ1VVVV6Z8vJyJk2alCtTzPz58ykvL8/ddtppJ5QCY3yMTmO0jzEBgVdHkNrU4lZDEPjhzRDesr8HPkGQJjCawGi0UmFQZiE3ufX8TYh+SstijUIIIfqpftdDNmnSJBYtWsQee+zBunXrmDt3LocddhhvvvkmgwYNalO+qqqK4cOH520bPnw4VVVVuf3ZbcXKFDN79mxmzZqV+72uro6H7v0xlp3AjjhoCyyliFbsQaz1OmTBpvC+aQx/RkvYfEVsIB1eXCRTYU+ap/vdSyX6HSM9ZKJf0lpTV1fX180QQgghtki/u8r/xje+kbu/zz77MGnSJMaMGcPvfvc7Zs6c2attiUajRKPRXq1TCCFEyPd9jDFUV1cTZIZ5CyGEEP1Nvx+kVFFRwe677877779fcP+IESNYv3593rb169fn5qBlf7ZXRgghxLYnnU6zYcMG0uk05eXlfd0cIYQQYov0+4CsoaGBDz74gJEjRxbcP3nyZFasWJG3bfny5UyePBmAsWPHMmLEiLwydXV1vPrqq7kyQgghtl3RaBTH6XcDPoTYJj333HMopXjuuef6uimiB/zlL3/BdV0++uijXq+7urqakpKSNstPiX4YkF1xxRU8//zzfPjhh7z88st861vfwrZtZsyYAcDpp5/O7Nmzc+UvvfRSli1bxm233ca7777LDTfcwGuvvcZFF10EgFKKyy67jJtuuon//d//5R//+Aenn346o0aNYvr06X3xEIUQQnSCUopoNEoymaSpqamvmyNEv3L33XezaNGivm7GFnn00Ue58847+7oZee6//3723HNPYrEY48aN4+c//3mnj02lUlx11VWMGjWKeDzOpEmTWL58ecGyL7/8MoceeiiJRIIRI0ZwySWX0NDQ0Om6rrnmGmbMmMGYMWM6fUx3GTx4MGeffTbXXXddr9e9ret3Adknn3zCjBkz2GOPPfjOd77D4MGDeeWVVxg6dCgAH3/8MevWrcuVP+SQQ3j00Ue599572Xffffn973/P0qVLmTBhQq7MlVdeycUXX8y5557LgQceSENDA8uWLSMWi/X64xNCCNE5rutSUVFBWVkZjY2Nfd0cIfqVYgHZV77yFZqbm/nKV77S+43qpG0tIPuv//ovzj77bPbaay9+/vOfM3nyZC655BJ+8pOfdOr4M888k9tvv51TTz2Vu+66C9u2+eY3v9lmnd2///3vTJkyhaamJm6//XbOPvts7r33Xk466aRO1fP3v/+dp59+mvPOO6/Lj7G7nHfeefztb3/jmWee6bM2bIuUMUYWuOomdXV1LLjthwyuKMV1bdIBeL7FkXs3UJZokZJZp6H6r+H91MbwZ3QH8rIs+uG3Hamm8GdaR3rnQYiBTQEpG2Uk3aLoGQrDoEiYEXHYjmPDjaW7gLLD+9rb/P9x6JfDnwcsALci7zyff/45S5YsIRaL4bouGzdu5JJLLqG2tpaysrJeeCRie9DY2EhJSUnHBbdDEyZMYMiQIf1yaOIxxxzDm2++yYcfftjXTaG5uZmddtqJgw8+mMcffzy3/bTTTmPp0qX8+9//prKysujxf/nLX5g0aRK33norV1xxBQDJZJIJEyYwbNgwXn755VzZb37zm/z973/n3Xffzf2fu++++zjnnHP485//zNe//vV223rppZeydOlSPvzwQ5Tqu8/5vffem/3224+HHnqoz9qwrel3PWTbOtsCo5vQ6XpMuhHjJ0nVrSa16a3Nt5p3SXmN4U0T3rymzdu8RlK+T8r3CSyLwLLARm5y6/mb/EcQ/VQikejrJog+tnbtWmbOnMmoUaOIRqOMHTuW888/H8/zAFi0aBFKKZ5//nkuuOAChg0bxujRo3PH33333ey1115Eo1FGjRrFhRdeSE1NTV4dq1ev5sQTT2TEiBHEYjFGjx7NKaecQm1tba7M8uXLOfTQQ6moqKC0tJQ99tiDH/7whx22vzPHpVIprr/+enbbbTei0Sg77bQTV155JalUqs35fv3rX3PQQQeRSCSorKzkK1/5Ck899RQAO++8M2+99RbPP/88SimUUnz1q18FKDqHbMmSJey///7E43GGDBnCaaedxtq1a/PKnHnmmZSWlrJ27VqmT59OaWkpQ4cO5YorruhUJtTHHnuMo48+Ovca7rrrrtx44415x371q1/liSee4KOPPsq1feeddy56zgcffBClFA888EDe9ptvvhml1FbPZ3r22Weprq7mggsuyNt+4YUX0tjYyBNPPNHu8b///e+xbZtzzz03ty0WizFz5kxWrVrFv//9byD80n/58uWcdtppeV86nX766ZSWlvK73/2uw7YuXbqUI444ok0wppTihhtuaFN+55135swzz8z9nv0bWrlyJZdccglDhw6loqKC73//+3ieR01NDaeffjqVlZVUVlZy5ZVXUqjf58gjj+SPf/xjwX0DlcyC7maBBmUlsCI2ygKlLKJl44i27iEL6sP7qebwp5ugYA+ZF65DprXdOw9ADGzSMSaE6Ic+/fRTDjroIGpqajj33HMZP348a9eu5fe//z1NTU24rpsre8EFFzB06FDmzJmTG+p6ww03MHfuXKZOncr555/Pe++9xz333MNf//pXXnrpJSKRCJ7nMW3aNFKpFBdffDEjRoxg7dq1PP7449TU1FBeXs5bb73FMcccwz777MO8efOIRqO8//77vPTSS+22vzPHaa057rjjWLlyJeeeey577rkn//jHP7jjjjv45z//ydKlS3Nl586dyw033MAhhxzCvHnzcF2XV199lWeeeYavf/3r3HnnnVx88cWUlpZyzTXXAG3XY21p0aJFnHXWWRx44IHMnz+f9evXc9ddd/HSSy/xxhtvUFFRkSsbBAHTpk1j0qRJ/PSnP+Xpp5/mtttuY9ddd+X8889v93lYtGgRpaWlzJo1i9LSUp555hnmzJlDXV0dt956KxDOgaqtreWTTz7hjjvuAKC0tLToOc866yz+53/+h1mzZnHkkUey00478Y9//IO5c+cyc+ZMvvnNb+bKbtq0qVOBYyKRyH0J9MYbbwBwwAEH5JXZf//9sSyLN954g9NOO63oud544w123333Nj37Bx10EBAOM8y22ff9NvW4rsvEiRNz7Shm7dq1fPzxx3zpS1/q8PF1JPv+nzt3Lq+88gr33nsvFRUVvPzyy3zhC1/g5ptv5sknn+TWW29lwoQJnH766XnH77///txxxx289dZbeVOIBjIJyLqbCYMwpWyUCr91UE4cq+WIw8ADKxNgZS+ArZbdEwYy315svj6WK2XR0+SbKiFE/zR79myqqqp49dVX8y5Y582b1+Zb+B122IEVK1Zg2+Hn8Geffcb8+fP5+te/zp/+9CcsK/wsHj9+PBdddBG//vWvOeuss3j77bdZs2YNS5Ys4dvf/nbufHPmzMndX758OZ7n8ac//YkhQ4Z0uv2dOe7RRx/l6aef5vnnn+fQQw/NbZ8wYQLnnXceL7/8Mocccgjvv/8+8+bN41vf+ha///3vc48HyD0X06dP59prr831dLUnnU5z1VVXMWHCBF544YXc/PpDDz2UY445hjvuuIO5c+fmyieTSU4++eRc4obzzjuPL33pS9x///0dBmSPPvoo8Xg89/t5553Heeedx913381NN91ENBrlyCOPZMcdd2TTpk0dtj3rl7/8JXvttRczZ87k8ccf54wzzmDEiBHcfvvteeX222+/TmUfvP7663M9SuvWrcO2bYYNG5ZXxnVdBg8ezKefftruudatW1cwU3h2W/b4bH6EYmVffPHFdut59913gTC7+NYaPnw4Tz75JEopLrjgAt5//31uvfVWvv/973PPPfcAcO6557LzzjvzwAMPtAnIdtllFwDefvttCcgyZICSEEIIIfotrTVLly7l2GOPbdN7ALQZnnXOOefkgjGAp59+Gs/zuOyyy/KCl3POOYeysrLckLPsWnd//vOfi2b1zPYUPfbYY2itC5bZ0uOWLFnCnnvuyfjx49m4cWPudsQRRwDh0DkIh6VprZkzZ07e44G2z0VnvPbaa2zYsIELLrggL9nZ0Ucfzfjx4wsOyWudNOKwww7jX//6V4d1tQzG6uvr2bhxI4cddhhNTU25gGJLjBgxgl/84hcsX76cww47jL///e888MADbXqlHnnkEZYvX97hrWWA0dzcnNcD21IsFqO5ubndtjU3NxONRgsem93f8mexsh3VU11dDdDufLbOmjlzZt57adKkSRhjmDlzZm6bbdsccMABBV/3bBs2bty41W3ZXkgPmRBCCCH6rc8++4y6urpOf9Peuocg2yOyxx575G13XZdddtklt3/s2LHMmjWL22+/nUceeYTDDjuM4447jtNOOy0XrJ188sncd999nH322Vx99dVMmTKFE044gW9/+9ttgqOWOnPc6tWreeedd3JZpVvbsGEDAB988AGWZfHFL36xU89HR4o9PxD2IrbOBBiLxdq0sbKykk2bNnVY11tvvcW1117LM888Q11dXd6+lvP0tsQpp5zCr3/9a5544gnOPfdcpkyZ0qbMl7/85S6fNx6P5+YptpZMJvOCzGLHF5oDmEwmc/tb/ixWtqN6srpj3tYXvvCFvN+z7/+ddtqpzfZCr3u2DX2ZWGRbIwGZEEIIIQaMzl64FnLbbbdx5pln8thjj/HUU09xySWXMH/+fF555RVGjx5NPB7nhRde4Nlnn+WJJ55g2bJlLF68mCOOOIKnnnoqr2eudZs6Ok5rzd57791mmF1W64vhvlLsMXakpqaGww8/nLKyMubNm8euu+5KLBbjb3/7G1dddVWXehwLqa6u5rXXXgPCoXJa6zZB8meffdapOWSlpaW5eWsjR44kCAI2bNiQN2zR8zyqq6sZNWpUu+caOXJkm+QosHmIYvb47FDFlks7tSzbUT2DBw8G6FRgnFUseCv2GhfaXugc2TZ0ZVjv9k6GLPawrfz/IYQQQoh2DB06lLKyMt58880tOj67QO57772Xt93zPNasWdNmAd29996ba6+9lhdeeIEXX3yRtWvXsnDhwtx+y7KYMmUKt99+O2+//TY/+tGPeOaZZ3JDCovp6Lhdd92Vzz//nClTpjB16tQ2t2wP1q677orWmrfffrvd+jrbO1Hs+clu664Fhp977jmqq6tZtGgRl156KccccwxTp04tOMRuS3pWLrzwQurr65k/fz4rV64suI7ZgQceyMiRIzu8/fSnP80dM3HiRIBcsJf12muvobXO7S9m4sSJ/POf/2zTI/jqq6/mnX/ChAk4jtOmHs/z+Pvf/95hPePHjwdgzZo1BffX19e32Zbtde1u2TbsueeePXL+/kgCsh7k+5Du+IsWIYQQQmwhy7KYPn06f/zjH9tcrELHQ7SmTp2K67r87Gc/yyt7//33U1tby9FHHw2Eacd93887du+998ayrNwwss8//7zN+bMXyoWGmmV15rjvfOc7rF27ll/+8pdtyjY3N+cyRk6fPh3Lspg3b16bXqWWj6+kpKRNWv9CDjjgAIYNG8bChQvzHsOf/vQn3nnnndzzs7WyvSst2+h5HnfffXebsiUlJV0awvj73/+exYsX8+Mf/5irr76aU045hWuvvZZ//vOfeeW2ZA7ZEUccwQ477JBLZpF1zz33kEgk8p6fjRs38u677+bNQfz2t79NEATce++9uW2pVIoHH3yQSZMm5Xo+y8vLmTp1Kr/+9a/zgqeHH36YhoaGDheH3nHHHdlpp50K/o0AbZY5+NOf/kQymeyR1PSvv/465eXl7LXXXt1+7v5Khix2M9sGHTSRTNrUNsdwbU2q5p8kky3+EesAUmFae7IBW6qRzZkUTZgaH/Cz3elKMuCJXiBvMyFEP3TzzTfz1FNPcfjhh+dSwq9bt44lS5awcuXKvLTsrQ0dOpTZs2czd+5cjjrqKI477jjee+897r77bg488MBcJr9nnnmGiy66iJNOOondd98d3/d5+OGHsW2bE088EQizOr7wwgscffTRjBkzhg0bNnD33XczevTovMyIrXXmuO9+97v87ne/47zzzuPZZ5/ly1/+MkEQ8O677/K73/2OP//5zxxwwAHstttuXHPNNdx4440cdthhnHDCCUSjUf76178yatQo5s+fD4Spx++55x5uuukmdtttN4YNG5ZLENJSJBLhJz/5CWeddRaHH344M2bMyKW933nnnbn88su39GXLc8ghh1BZWckZZ5zBJZdcglKKhx9+uGBAsP/++7N48WJmzZrFgQceSGlpKccee2zB827YsIHzzz+fr33ta1x00UUALFiwgGeffZYzzzyTlStX5oYubukcshtvvJELL7yQk046iWnTpvHiiy/y61//mh/96EfssMMOubILFixg7ty5PPvss7l13yZNmsRJJ53E7Nmz2bBhA7vtthu/+tWv+PDDD7n//vvz6vrRj37EIYccknuff/LJJ9x22218/etf56ijjuqwrccffzx/+MMfMMa06WV85513+OY3v8lxxx3Hp59+yl133UV5eTkvv/wyv/nNb5gxY0aXn5tili9fzrHHHitzyFqQgKybGQO+idDkxXAsTcQB2y3Djrb4Vk37kMqMAc4GZLZDXmp7EwZkOvOPSIY+il4h/xuFEP3QjjvuyKuvvsp1113HI488Ql1dHTvuuCPf+MY3OrVo+A033MDQoUNZsGABl19+OTvssAPnnnsuN998M5FIuG7Nvvvuy7Rp0/jjH//I2rVrSSQS7LvvvvzpT3/i4IMPBuC4447jww8/5IEHHmDjxo0MGTKEww8/nLlz5+YSHxTSmeMsy2Lp0qXccccdPPTQQ/zhD38gkUiwyy67cOmll7L77rvnzjdv3jzGjh3Lz3/+c6655hoSiQT77LMP3/3ud3Nl5syZw0cffcQtt9xCfX09hx9+eMGADMIFnxOJBD/+8Y+56qqrKCkp4Vvf+hY/+clP2g12u2Lw4ME8/vjj/Od//ifXXnstlZWVnHbaaUyZMoVp06bllb3gggv4+9//zoMPPsgdd9zBmDFjigZk559/fq7HKRsADB48mHvvvZfjjz+en/70p1x55ZVb1fYLLriASCTCbbfdxv/+7/+y0047cccdd3DppZd26viHHnqI6667jocffphNmzaxzz778Pjjj/OVr3wlr9yXvvQlnn76aa666iouv/xyBg0axMyZM3NBdke+973vsWDBAl566aU2XxCcf/75/Pvf/2bWrFlUVFRw88034zgOs2bN4plnnum2gOzdd9/lzTffLDhkdCBTRpbJ7jZ1dXX8/KfXYMcqiTqKkpghHSiOnJimvKRFwcCDzzJZiZLrw5+xoeStQ5YOxxInG8NuaU8XTqkqRPcxYUCWslFGIjPRMxSGQZHw/9uwHTPZ7kp3AZWZDK49qP5reH9o5tvqAxaAW5F3ns8//5wlS5YQi8VwXZempibOPvtsamtr26SyFkIIEZoyZQqjRo3i4Ycfzm1TSuWtrdaTLrvsMl544QVef/116SFrQeaQdTOjIjjKUF5ikPeZEEIIIYTYVtx8880sXry4Uwtgd7fq6mruu+8+brrpJgnGWpEhiz2gNBZgKQfJ5yGEEEIIIbYVkyZNKrpuWk8bPHgwDQ0NfVL3tk56yIQQQgghhBCij0gPWQ9oSNq4MuVLCCGEEEJs4ySdRN+THrJupkwa3yhqGxXy/hZCCCGEEEK0R3rIupltGUrdZprSMeoaNdGIxm+qIm1apb33k5n7mW1+iryc40E4A01nJz3KOmSiN8gcWyG2K1prPv30UwYNGiST6IUQopcZY6ivr2fUqFG59e4KkYCsmykFjkpTFtXUNMewfAi8OgKr1cLQQSZAy8ZZgU/ewtAmjNRyAZn0ZYreIHG/ENuVTz/9lPvuf6Dgdy3KclCWXfCLGGPIfQ6hrCJZg1t8ZhXU8qC2ZYzJfNYpq2iw2HGZ9uvoqJ2depwGTLc9F+23QSlLXo8Cj9NP+3y2fi1aa5RSRKNRtNY9lpzCdV0syyKVShUdzteZMlvDcRwcx8H3fXzf3+IyW6Mzz7W8HptFIpHcuny6xQLCN998M//+978ZPXp08fN3a2sFQQCWncB1HcoVNKcdohV7EGu9DlmwKbxvGsOf0RLy1yELX8hkKuxJ87S8VKKnGekhE2I7M2jQIMBg2TaWstFGozNfCMYSpcRisaLH+lqTamrAaJ94ySBsO5K3X5vwAt22iv/j8LXBKbDfSzaT8pqIuAncaIJip9AGvFQTaa+ZqBvHjcU7XUdWoA1KqTZ1BEGa5sZ6lBUhmijFaefbay/t4TU3YNk28URpGDh1oo6Wj6PQc2WMprmpAR0Y3HgpbqT4BPSB/HoYA6N3HI6VidB836e2thbbtikrK2u356ErtNbU1dURBAHl5eU4TvFrr66U7aqmpiYaGxspKSnpcGHzrpTtiq48x/J6hIIgYP369WitsSwLx3FygVn4v7g4ucrvQY4DEd1xOSGEEKInZHsxLGWjLIVOh8PhLdvBjcaIuG7R3hDlB7jllTQ31pFKNlE6qBInsjkICAKNNoaIYxc83hgDgSZi5/emJJsaSfspSkrKsd0YllLYduELuCDQ2E4ZbsSlubkBJ4gQS2z+hrNYHS2l/aBNHX46TVNjExE3SrykDINq/3HYDtFolMb6GrxUM6VlFXlBWaE6Wj+O1s+VMZqGuhrAMKhiMEbZ7T6Ogfp6GGPQxhCPuXnHxGIxNm7cSHNzM4MHD97qIEBrTXV1NQDDhw/H7UR2tkQiQXV1NQ0NDQwZMqRTx3Skvr6eVCrFDjvs0OFFfLYN0WiUuro6otFop47piOd51NTUEIvFOv3cyusRPm+RSATf9wmCIBeYAR0OGZeBcD2sm74kEEIIIbaYNpp02gNjsJ1IrqehI0pZlJZVYNsODfWb8NPprWpHsqmR5uYG4vHSvAv5jsQSJcTjpTQ3N5BsatyqNvjpNA31m7Btp01g1R7HiVA6qJIg8Gmoq9k8jHELZIOxIPDDwMqJdHwQ8nq05LouQ4YMIZ1OU11dnTdErKuyF//pdLpLF/KWZTF48GAikQgbN27c6iF79fX11NXVUVZW1qXAatCgQZSVlVFXV0d9ff1WtcHzPDZu3EgkEulSYCWvx2au63Z5KKn0kAkhhBDbuewwRduJoJTCaE0Q+Pi+KvrNbeBrjAJjW8QSJTQ11FNfW02ipBw74qADjTagKHzhZYwhCAzKhHWkmptJJRuJxkpwXBffT2+uwxS+6GtZh+O6uEGcpsZwWFI0Hm9TR7uPw1gEaZ+mxlos2yGWKAm/xe7i44jHB9HUWEtdzeckSgehlNWlx2GMpqmhHh34JErKQRE+F519HAPs9TDGYIwhnVYEQdtzlpeXs2nTJjZs2EBlZWWXk9cYY9i0aRO+71NZWQnQ5Qv5srKyvDZEIp0LsFtqbGykoaGB0tJSotFol9sQjUZJJBLU1NTg+z4lJZ0PsLPS6TSbNm3CcRzKysq2aF7aQH490ul02KOrNZFIJPP3EHSqPgnIhBBCiAHAth2U2nyBG/hpfEyRBBHhXCALsDIXwa4bI/A9vFQTThDBZC+ZdbEEEOF8IQKF1gFB4BONJbBtC99LFayjNa1NXh22bRGNJQiCNKlmg2XZuTo6ehwqbfD9NJGIi+24BJnepdZ1tPc4snXEYgl8P02qqTE8l+nc4zCBIvA9LKVwYwmMCfC9oGAdxR7HQHs9jAGDIWnpoj27paWleJ5HXV0dbjvDcNs+JwbP87Asi9LSUoIg6PQFdGvxeBzP82hsbMwlmOgs3/dJp9OUlJRg2zbJZHKL2mDbNiUlJXiehzGmS/Ooskk5otEoruuSSqU6PqiIgfp6+L6fSzwDYSKQziYYkYBMCCGE2K5ZlJaVE42Hk9ED38f3PHbe62CGDK7EKTJfqLbJw7Ut4tHClwrNKR8v0JQnCg8n8gNNfXOaQfGI1CF1bHEdfqDxA834MTsQdwvPjxNiW1BbW8uTTz5JNBrN9cp1NpiTgKy7qXBsuDHhN17GWBi/GZ1uMYRAp8PU97A566sOWvxiyK4qvTmulnzkQgghuk5ZNhE3hm2HH/nGGJRtEU2UEk0MKnrhHDUeEcciWuTCObB9lK+JFrk4twONb/lEY47UIXVscR12oHG0obKykkSRY4TYVjiOQyQSyc17kzlkfcS2wOgmdBpMYGGCCKm61aRSLSJko8HLTILNxmleE3lrc+jwBQyyXaySjlwIIcQWsGwHX4fZ7wCCwJCdb9+YbP9iIe1rav32507UNra/X+qQOramDq0NEUcypIntmwRk3SzQoKwEVsRGWWFGpGjZOKKJVj1kQSYLTqo5/OkmyFuHzG8Id3thIKe1dNOLXiCBv+inmpqa+roJ2ywdBDiWIpLpsVBGYTKDNEra6cmobQx7Mor1SjSlfNK+pryk+PC1xqQvdUgdW1WHH+hwXpoQ2zEJyLqbCYMwpWyUCtcdUE4cq2WCl8ADKxNgZS+ALZu8gCwzIXDz9bFcKYueJh94on/JplWur6+nsXHrUm9vz0zmbzs70Vwphcp8pji2VfTC2bIUjqWK7ncsRdDO/lw5qUPq2Mo6tmaJASH6A+kDFkII0S9lFy+tq6vbohTP3emGG24IA50Wt/Hjx7d7zJIlSxg/fjyxWIy9996bJ598Mm+/MYY5c+YwcuRI4vE4U6dOZfXq1T35MIQQQvQBCciEEEL0S8YYUqkUsViMRCLR181hr732Yt26dbnbypUri5Z9+eWXmTFjBjNnzuSNN95g+vTpTJ8+nTfffDNX5pZbbuFnP/sZCxcu5NVXX6WkpIRp06ZtcUpsIYQQ2yYZsiiEEKJfS6VSW7TwZ3dzHIcRI0Z0quxdd93FUUcdxQ9+8AMAbrzxRpYvX86CBQtYuHAhxhjuvPNOrr32Wo4//ngAHnroIYYPH87SpUs55ZRTurfxxoBplWTB+GAschlA2hyjw1ux0WTagAlAexRdlErqkDo6qkOb8ObVgZJ+BLENccqgC+ubtXuqbjmLEEII0csikQgVFRXU1dVRW1vb181h9erVjBo1ilgsxuTJk5k/fz5f+MIXCpZdtWoVs2bNyts2bdo0li5dCsCaNWuoqqpi6tSpuf3l5eVMmjSJVatWFQ3IUqlU3oKudXV1nWu88eCzl1pt3BFoBGqKHFQBlEDT2iL7XWAkJNcBxTLqSR1SR0d1uEAC/t9joPr+71yInAMWgFvRLaeSrxqEEEL0S47joJRi8ODB2HbfZqKdNGkSixYtYtmyZdxzzz2sWbOGww47jPr6+oLlq6qqGD58eN624cOHU1VVlduf3VasTCHz58+nvLw8d9tpp5225mEJIYToBdJD1s1sG3TQRJBW6MBCBzapmg9IJjd/Y4kOIBWmtSeTephUI/nrkKUB8HPrkEkGPNEL5G0m+iHLsigrK+vTNnzjG9/I3d9nn32YNGkSY8aM4Xe/+x0zZ87stXbMnj07r+etrq6OBx96hEAb0n74gRP4m9OI1zZ6WJYKh5GxY3hQOvx80ipNMy4pU16wLq1cIM2movujQDO1VGCZVJEyUofU0X4dGgcHD+pfA72h4DFC9KqhX+72U0pA1s2MAaUclGWhjEJpC9stw462WCRR+5BaF97PBmS2Q15qexMGZNqEH5rFhloL0a1kdQXRT1ndNI6/u1RUVLD77rvz/vvvF9w/YsQI1q9fn7dt/fr1uTlo2Z/r169n5MiReWUmTpxYtN5oNEo0Gs3bprVBKYWVmdNj1ObpPRHHwrFUOKeHzNIBOhwW1mwPC8+pCw8T62i/r+KkrUFEdD2Oad6ic0gdUkeA223zdITYVklA1s20BmW5WLaDIlyA00mMJNIyI3PgQdOa8L6f+YfkRMlbhyzzzVKQCcgwcqUsepp0jwnRXRoaGvjggw/47ne/W3D/5MmTWbFiBZdddllu2/Lly5k8eTIAY8eOZcSIEaxYsSIXgNXV1fHqq69y/vnnd6ktRgcoNHZmXSdjLCw//ExJRDML+GpNbk6PDodEptwRRGkmYRf7RjBFipKi+33S1BIjYX+OUyQLRAqHKI1Sh9RRtA4fTZoYVO5L8XlnQvQw7cGm/+ux00tAJoQQQmylK664gmOPPZYxY8bw6aefcv3112PbNjNmzADg9NNPZ8cdd2T+/PkAXHrppRx++OHcdtttHH300fz2t7/ltdde49577wXCxZsvu+wybrrpJsaNG8fYsWO57rrrGDVqFNOnT+9i6wzNTQ240SiqS1nqrExXWrFjVOZWbL/VYv+WnkPqkDqy54qAcoscI8S2yff9jgshAZkQQgix1T755BNmzJhBdXU1Q4cO5dBDD+WVV15h6NChAHz88cd5wyoPOeQQHn30Ua699lp++MMfMm7cOJYuXcqECRNyZa688koaGxs599xzqamp4dBDD2XZsmXEYrGuNU5Z6MCnoa6G0rKK7ni4QgghOuB5XqczAEtAJoQQQmyl3/72t+3uf+6559psO+mkkzjppJOKHqOUYt68ecybN29rm0e8ZBCpZBMNdTXEEiUdHyCEEGKLeZ7Hxo0bO50BWGZJ9jAj03KEEEL0MduOUDqokiDwaWqoR+aMCiFEz0in02zcuJFIJNLpDMASkPUgYyAddFxOCCGE6GlOJAzKdODjp9N93RwhhNjuaK3ZtGkTkUiEwYMHdzoDsAxZ7GaWBUZ7+L5PXWMEpcBvWkfatEp77ycz9zPb/BR5OceDMJLT2dzEsg6Z6A2SzFOI7Y5SFtpAEGiUZRNLDMJLhSnJm1J+Ju29BirCAzLXDxqHZgqvFQXk9jVlj2vFJ5rZX4lDkTWppA6po4M6AlotCyTENszzPBzH6VIwBhKQdTulQGufhqY4voZExCfw6gisVgtDB5kALRtnBT55C0ObMFLLBWTSlyl6g8T9Qmx3LEthjMmta6ksB8uOAJD2NUEuIMvMLbPy/xGkaH/OWbH9OnOJkSaWuaju+jmkDqlDY+MgPbqif1BKUVlZ2eW1MSUg62ZBAI3pQRhlUZ4waByiFXsQa70OWbApvG8yC3FGS8hbhywdBmTJVNiT5ml5qURPM/IlpBDboSAIsC1FxAknlys0Jgjvl5e4mXXIgKa14QF+uA7ZJudLRGkiUWTtpyYqSFFCJWsL7vdxqWUk5azDwStYZhM7hmtSSR1SR5E6fFzSJAqWFWJb47ouSnX9Ykr6XbqZVhF8o6hIGByJoYQQQgghhBgQtiQYAwnIeoBiUDQgIsGYEEIIIYQQogMSkHU7Q8SWiThCCCGEEEKIjklA1u0smj15WoUQQgghhBAdk8ihmyl8mtIWjUnJjiCEEEIIIYRon8x06maKgHjEpyEZIaYNtmUwfjM6rTcX0ukw9T1sTjOugxa/mHBVaVpmIZdhkEIIIbpOZdKnmuznijGYzGeKH2Q+m7QB3MwB8XATDj5R/Oz2VnyimTLF9rt5PwuROqSOjurwiaCl/0D0E1rrjgsV0OWAbM2aNbz44ot89NFHNDU1MXToUPbbbz8mT55MLBbbokZsT2wLYnYDNi4NySixSJpU3WpSmfT1QLjei5dJd5993bwm8tYh0+E6ZUF2HQPpcBNCCLEFLNvG1wYywVcQGPx0+BnTmMyuiRkAI8P7TkXu2DQxarPbi+hofyOD290vdUgd7dWhsYgUWWRaiG2N53lEIhFct/iXEoV0OiB75JFHuOuuu3jttdcYPnw4o0aNIh6P8/nnn/PBBx8Qi8U49dRTueqqqxgzZkyXH8D2ItCgrASlMRttWfhBjGjZOKKJVj1kQX14P9Uc/nQT5K1D5jeEu70wkNPa7p0HIAY2CfzFAKG15vnnny/4BePUqVPZaaed+rqJ3UYHAY6liNjhZ0y6OYkx4SiNkpiTWYfMg+S68AD/MwBq7b2JkCTBpoLnbaKSNDHKWVdwv49LI4MpobromlS1jJQ6pI526/CJEBAtWFaIbY1Sik2bNnU5KOtUQLbffvvhui5nnnkm//3f/93mgyqVSrFq1Sp++9vfcsABB3D33Xdz0kknde0RbC8MKGWhlE0iCk0phXLiWJEWZQIPrEyAlb0AtmzyArLMOgabr4/lSln0NBkWK7Z/zc3N3Hbbbdxzzz18/vnnTJw4MfcF4/vvv8/SpUs555xz+PrXv86cOXM4+OCD+7rJWy07PFEpRbKpkVSyCTcaDkt0bCsMyJSC7AW0Cb8otPBxSBW9sHZIEeAU3b+5nFe0jNQhdXSmDkOkYFkhtjWu6xIEARs3bmTIkCGdPq5TAdmPf/xjpk2bVnR/NBrlq1/9Kl/96lf50Y9+xIcfftjpBmzvHOnYEkKIbcbuu+/O5MmT+eUvf8mRRx5JJNL2Qu+jjz7i0Ucf5ZRTTuGaa67hnHPO6YOWdr9kUyPNzQ1EYyVY1pbPyUltqAEg7UYIIjapxpqC5QIrRlAyGK+xjkAnC5cpGUw63UjKK3wOqUPqCKwYaUdT8+EHJL2NBY8RojvtMGn8Fh+rlKKyspK6ujo2btxIaWlpp47rVEDWXjDW2uDBgxk8uP2xw0IIIURfeOqpp9hzzz3bLTNmzBhmz57NFVdcwccff9xLLetZXrKZtJ8iHi/FcV3SKZmTI4QQPUEpxeDBg6murqa2trZTx2xxlsUNGzawYcOGNtlE9tlnny09pRBCCNGjOgrGWopEIuy666492JpeYgwpr4mSknJiiRJ8P93XLRJCiO2aZVkMHjyYqqqqTpXvckD2+uuvc8YZZ/DOO+/kUugqpTDGoJQiCIKunlIIIYToE8lkkv/3//5fwS8YjzvuuD5qVXczRN0EsURJXzdECCEGDMuyKCsr61TZLgdk3/ve99h99925//77GT58OEpJsgkhhBD9z7Jlyzj99NPZuLHtvJTt6wtGhRuL93UjhBBiwOnsfN0uB2T/+te/+O///m922223LjdqILBt0EETQVqhAwsd2KRqPiCZbDFeXweQCtPak/28TzWSvw5ZOKTEz61DJhnwRC+Qt5kYQC6++GJOOukk5syZw/Dhw/u6OT3GdhwCbUj74QdO4GsCHf6x1zZ6WJYC4wM7hgc45UC4gG8z5aTI71kLSsJ54toKUzrXlxQe1pnd31AyFksXzqinLZdUdAjpSOFvkaUOqUMrG1vLMFuxfetyQDZlyhT+7//+TwKyIowBpRyUZaGMQmkL2y3DjvqbC2kfUpk1PLIBme2Ql9rehP98dGZY6BYu/C1E10iHt+infN/vuFAr69evZ9asWdt1MAagdTilwMqMaDEqt7IKEcfCsRQYC2jMHBBOQm8mDMyi2e0Z6XT4eyoapnSOpOsK1hvYMXynFMdvwA4KZ9zr6BxSh9ShVQS2IiuoEP1BlwOy++67jzPOOIM333yTCRMmtEkZvP2Mud8yWoOyXCzbQQHKKJzESCItv2AMPGhaE973M9lXnCh565CZsEctyARkGLlSFj1NusdE/5Kdx+x5XqczWbX07W9/m+eee277SNzRDmM0lgI7szC0MRaWH36mJKLZhaE1UBMeoMNJ6ClGEaWJRHZ7Rst05elIGTHvs4L1BlaMBqeUWOoz7CIp0NORMiLpuqLnkDqkjjDtfedShwvRX3U5IFu1ahUvvfQSf/rTn9rs277G3AshhNiWeZ6HbdvU1dVh211f9HHBggWcdNJJvPjii+y9995tvmC85JJLuqupQgghRFFdDsguvvhiTjvtNK677rrtfpiHEEKIbZfWmk2bNhGNRkkkEl0+/je/+Q1PPfUUsViM5557Li9JlVJKAjIhhBC9ossBWXV1NZdffrkEY0IMcJ6qwDIpHJr7uilCbJFrrrmGuXPncvXVV3c6E5YQQgjR3br8CXTCCSfw7LPP9kRbhBD9yIbI4XwaPY7PIofQbA2XGWii11mWRWVlJb7vU1dXOEFAezzP4+STT5ZgTAghRJ/qcg/Z7rvvzuzZs1m5cqWMuRdiADPKQSuXRmtXGq2xuKaG0mA1JcFH2KQ6PoEQW8l1XVzXZciQIaxfv77Lx59xxhksXryYH/7whz3QOiGEEKJztijLYmlpKc8//zzPP/983j4Zcx9mZjXaQwc+JlCYwMJvqiJtWqW99zPZh7Lp7P0UeTnHM8lRdHZOg6xDJnqYsQwGg3I0Ku126hhlfCxSGGw8q5LPrUnUOPtSEnxEafAvXLNRMumLHpOd8+W6LuXl5V0+PggCbrnlFv785z+zzz77tPmC8fbbb++WdvY1pSy0gSAIP3B0oHNLqjSl/Ezaew1UhAdkOgyz65C1lnbD5ymbnjzpDi1Yb2DHwv3RoUVToGfXpCpG6pA6JO29GAi6HJCtWbOmJ9rRZb/4xS+49dZbqaqqYt999+XnP/85Bx10UNHyS5Ys4brrruPDDz9k3Lhx/OQnP+Gb3/xmbr8xhuuvv55f/vKX1NTU8OUvf5l77rmHcePGdaldSoExPkYrjLYwxibw6gisVgtDB5kALRtnBT55C0ObzAdnNiCT/0WihxhlMFYAGIyCVLyRTakTMP4glC7+xtOEF2UKUARYpgmDQuNS7+xBg70brq5mkH6fRPARFl1fJ0qIznKcLn+c8Y9//IP99tsPgDfffHOr6p8/fz7/8z//w7vvvks8HueQQw7hJz/5CXvssUfRYxYtWsRZZ52Vty0ajZJMbr6Q7Y7PJstSGGM2r2tpwjUzAdK+JsgFZJn1Waz8LwDbLAwdyc9o2dECv75TmrtfTLFzSB1ShywMLQaCrn+CFbFu3Toefvhhrrzyyu46ZVGLFy9m1qxZLFy4kEmTJnHnnXcybdo03nvvPYYNG9am/Msvv8yMGTOYP38+xxxzDI8++ijTp0/nb3/7GxMmTADglltu4Wc/+xm/+tWvGDt2LNdddx3Tpk3j7bffJhaLdbptQQCWncCOOGgLLKWIVuxBrPU6ZMGm8L7JLLgZLSFvHbJ0GJAlU+EHs6e77aUSIsfYAYGT/bJAoVBoEyOth2OUg7LCtfSKsVoNTVQYbFIYk8LgkLKHkrKGYjsTKQn+RWmwBtfU9NwDEqILunM+9PPPP8+FF17IgQceiO/7/PCHP+TrX/86b7/9NiUlJUWPKysr47333sv93jLTI3TPZ1Pg+9iWIuKEgZRCY4KwnvISN7MOGdC0NjzAD9ch2+R8qfA6ZI3h70l3KOlIGYMaPyhcrxWjoWQspY1riq5JVV+ya7trUkkdUoesQyYGgi5f5X/ve98ruP2jjz7iL3/5S68EZLfffjvnnHNO7pvFhQsX8sQTT/DAAw9w9dVXtyl/1113cdRRR/GDH/wAgBtvvJHly5ezYMECFi5ciDGGO++8k2uvvZbjjz8egIceeojhw4ezdOlSTjnllB5/TEL0BR3xwjuKNutCK5XEsnwsP9LmuI6EvWY+lvEzvWZR6pwJ1NvjiekNlAbvk9D/RuXG7Aqx7fjoo4+49dZbWbBgQaePWbZsWd7vixYtYtiwYbz++ut85StfKXqcUooRI0YU3Nd9n00GL9mMG412srwQQojuoHXnrnO6HJBt2rQp7/cgCPjXv/7FO++8w913393V03WZ53m8/vrrzJ49O7fNsiymTp3KqlWrCh6zatUqZs2albdt2rRpLF26FAiHYVZVVTF16tTc/vLyciZNmsSqVauKfuilUilSqc09BHV1daBsNA4aB4NBG/BIkGrZy2BcsAaH9+3MVbC1A3k9ZFb4wek5cQDSunNzeoToLGPpFr1jgAl7yHzboO0SIACVDnvKzNaNmc2++zUl1KvxNJmxlAYfUB5s3TAx0f8oDKnM/7Umlfk/SDmY7DC4NFiZkQ4mM38ppcHkD3lt9gK0MWhtCFrMieqKr33ta216pCAc8bFu3bouBWSt1dbWArDDDju0W66hoYExY8agteZLX/oSN998M3vttRewZZ9NBT+XUKS8JpymCLFE8d46IYQQ3Udr3ekMwF0OyP7whz8U3P6jH/2IpUuX8v3vf7+rp+ySjRs3EgRBm3XQhg8fzrvvvlvwmKqqqoLlq6qqcvuz24qVKWT+/PnMnTu31bYbSapS0iaCbzQBHv8OJhAP4psLGQ0lE/FVKSrRhG2awXLJn0PmExAjKLNxgjp0gUlkBgttD8IK6ov2NATWIBRprCJDB7QVwxDB1vUF90sd228dlqktmCwmUDZexc6oIBnWYcLBjPnniKLQqCLj+o0VwWBh6VSm401hMu9hCx9jUtTaX6LRn4YiKHgO3y7DMl67j0MrFyco/M/OYBM4g7D9eqljG6vDUWHA8Ek0+38xASg84likcUqnZLZXhj8+bATLw88EXq5j09RQS3PKJ6097LTB97re2zpx4sS837NfML7//vssWrSoy+fL0lpz2WWX8eUvfzk3LL6QPfbYgwceeIB99tmH2tpafvrTn3LIIYfw1ltvMXr06C36bCr0uXT9vB8RdRM0NzcA4LjyBZ8QQvQkrTXV1dUEQeHP1Na6bWLSjBkzuOmmm7rrdP3C7Nmz83re6urqeOSRhyEzSMugcnNqnLwLWgO6jpRTScRoHF0HtBpKYtJoy0UTxw5qUQUCMq2ipJ3hOHo9limcZjxtD8HSHnZQW3B/oKJoK4obfFJwv9SxHdeRrsfYbf9RaCuGsSIo3QAmDSYcgNiSsUtBpzJBW1tGORjLwQQNZMdDRkwztqnHoRmjXJLOzli6qvjjiAzB+CnsIhf4gYpibBfbK7xfqyieGkakvedK6uiDOqpwCOfORvJ6vRRNlOHiEdHZc2T+LzoKLAs/0PiBoSRm4dhWOOtRKSylKNDR1aE77rij4Pb77ruPBQsWcOqpp3b9pMCFF17Im2++ycqVK9stN3nyZCZPnpz7/ZBDDmHPPffkv/7rv7jxxhu3qO5Cn0v3PfgQbiyOE0Robm7ADeKy9poQQvQQYwzV1dWk0+lOZwDutoDs//7v/3LZqnrSkCFDsG27zZoz69evLzoOf8SIEe2Wz/5cv349I0eOzCvT+hvUlqLRKNECY/IVGoUJ7wUBtvKxVYsLD6OBFBYBFl7YQ9aa8bBIY+Fn9ttty5DNbpfCMoW/tQ7n8XhF91vGw+AX3S91bN91GNM286FlNIoAZXyUCTIBWWs6fB8bnddTl+sNy47ENSkiuh7H1GHjbT7aMpsfR5EeF2X8dntkLONhjF90PxZSxzZah034P8/JfQRFAYVFgI2Pk/ufmHnP2GFAZlsKy1I4diYgU+EcrELDDrfGlClTuPjii7fo2IsuuojHH3+cF154gdGjR3fp2Egkwn777cf7778PbNlnU7HPJSA3XLGpsQ43Gi9YRgghxJYzxrBp0ya01gwZMgTf71yG6S4HZK3nYkH44fDYY49x9NFH5+3viTVcXNdl//33Z8WKFUyfPh0IuwVXrFjBRRddVPCYyZMns2LFCi677LLctuXLl+e+mRw7diwjRoxgxYoVuQ+5uro6Xn31Vc4///wutjAMxQyQ9lIYbfC1wtct55ApIIomgq/i2MSBlkMWIRzYFUerKL6K54Z7taSt+OafRUbrGOVirBhaFc7GZawYRrlF90sd23kdxmCUbrU/gq1qiThrcTy/4PyxJAl8y8WoCIYg8563yfaGKWWwlEfcVKGUAWWh2dyevMdRhFYuyoqjreLPhVZuu/uljm2zjiDzRYCfGxkQ/v/TOPi4+CreYjsQhEuB+DqcMxb2lGmMCT/8zBbMH2vPM888w9e+9rUuHWOM4eKLL+YPf/gDzz33HGPHju1yvUEQ8I9//CO3JEt3fTZlhxwbY4jGEwSBj++Hw439zNpkaEPu+c48/+HrEcUnf4hjkHmNAzuGttzc720ejx3L+1mItlwCO9buOaSOgV1HYEUxqvCX0kJsazzPw/d9hg0bhuu6PReQvfHGGwW3H3jggWzYsIENGzYAbVP3dqdZs2ZxxhlncMABB3DQQQdx55130tjYmMu6ePrpp7Pjjjsyf/58AC699FIOP/xwbrvtNo4++mh++9vf8tprr3Hvvffm2nrZZZdx0003MW7cuFxq4VGjRuWCvk6zbAIipJM+6VSSiOvSrEsxQWJzGQPYpeEFhhqEHxlEm/E2mWQfxhiaY7vTeshYS57b/rewgT2IwB7UbplkrP01baSO7b2OzRe0RgUoILB2JogWe9+FiWd0NJaLCxUmnLtmPBQ+GEjGdm23DSl3xw4eRynN9m7tlmmOtb9f6tjW6hhNOvMlQMrKZvDcfMGfJk6tk31vZgKzpgDU5h7W2kaP5uY0gTYQhF8q+LrrQdkJJ5zQZtv69et59dVX+drXvpa3/3/+53/aPdeFF17Io48+ymOPPcagQYNyc7zKy8uJx8PH0fqzad68eRx88MHstttu1NTUcOutt/LRRx9x9tlnA9332WTZdvj8ZIIvKxJDZe43JrNrYgZAphfOqcgdmyZGbXZ7RlAyOO/3hpL2g8/m2Mh29/tOKQ0dpDWXOgZuHVrZOEGBkURCbIOMMVRWVuJ2ca5ulwOy7ly3ZUudfPLJfPbZZ8yZM4eqqiomTpzIsmXLchOfP/7447zx8YcccgiPPvoo1157LT/84Q8ZN24cS5cuzZtsfeWVV9LY2Mi5555LTU0Nhx56KMuWLevSGmQA6IDAa8JPayLRGI5liFsNJOxWQxZT1TQ5Y7F1DVG/CuxWPWQ6TcoegU+CWOqfRXvIvMho3PQnWLrwP6tkdBy2rieSLjwBPB0ZQWANIpZaXfjhSB0Dqw5l0MTxIjsR9dYWraM5thvoFFa6EcukiZh6HBpywxe9yAgCu5R48v2ijyPl7thhHXbQgFvkcUgd/bWOT3BNmLQml/HPHgQoahlJhGYSfuYcztDwZ2JHsFyaUj5pX4drZ+kItqVw7HAII0HXvwQsNLa/vLyc3XffvcvnuueeewD46le/mrf9wQcf5MwzzwTafjZt2rSJc845h6qqKiorK9l///15+eWX+eIXv5gr0x2fTToIcCxFxA7rVkZhIuHHf0nMyaxD5kFyXXiAH64PVWvvTYQkCfKzK3uN4Ry/ZHQovlNKaeOagvUGdozm2EjiyXXYQeGhrA0lY3H8BmKpImtSSR0Dvo7Airbb4ybEtsR1XSKRri8X1G9XG77ooouKDlF87rnn2mw76aSTOOmkk4qeTynFvHnzmDdv3la1S2uN9jXxeAycKMZvxrEMjtXi21ttCOeQpXFMMw6FLoA8AprRxsYxzQSF5pBluiYs3Vx8PpHxUDpZfL9OolS0+JwlqWMA1WHCjjKjIJKpo535Qm5QjxtswDLNbfpvLd2Msdzi84lalGuvjnb3Sx39to7ic8h8HLyic8gcSxF04xyyBx98cIuOK6QzwyZbfzbdcccdRROLZHXHZ5PJzu7MPE9KqdwwxuxzGY7SyDzfmec/fD1SOC3mfwIEmdfYDpJoyy26AHCWHSSLlgkTEBXfL3VIHQDa6voFrhB9YUsTJnXqqKOOOopXXnmlw3L19fX85Cc/4Re/+MUWNWZ7YIzBdR2iUUkrLLZvtkliFwjGhNiWdfd8MyGEEGJrdaqH7KSTTuLEE0+kvLycY489lgMOOIBRo0YRi8XYtGkTb7/9NitXruTJJ5/k6KOP5tZbb+3pdm+7lMJ15ZscIYTYFu21117MmTOHE044od0x/qtXr+b2229nzJgxXH311b3YQiGEEANNpwKymTNnctppp7FkyRIWL17MvffeS21tuMaRUoovfvGLTJs2jb/+9a/sueeePdrgbZ4xBIHG6beDQYUQYvv185//nKuuuooLLriAI488sugXjG+99RYXXXTRFmTaFUIIIbqm02FDNBrltNNO47TTTgOgtraW5uZmBg8evEWT17ZbCpJJD8dx6OSIUCGEEL1kypQpvPbaa6xcuZLFixfzyCOP8NFHH9Hc3MyQIUPYb7/9OP300zn11FOprKzs6+YKIYQYALa4H6e8vLzTq08PJJZlYbShsbGZSMyS+TVCCLENOvTQQzn00EP7uhlCCCG2I1s6T1kG1nUzZdlEoi7plEequZGI69LoJwjSLRZcNYAVQxuHwBqGp8pBWWxOe2/AMmjlYoyhMbYnhV5eo8JFVZOxcSiTKtgeo1x8ayiBU1Zkf3iOcK0zqWPA12HAkN2/G5bx2pYhXCRYR4YSOIW/lNEqnJvTHC/8OHL7pY4BWMc40pksi0mr7cLQzZSTcvbIbM+sU9TogwKdWWtsU0OK5iYvXFvL1xiCcE0yUZBt2wTakPYDAAJf4wfh/dpGD8tSYHwgsw5d5jXOvR6U5J0vuw6ZtsLXtL6k8HqD2f0NJWOxdJH3leWSig4hHSn8/0rqkDq0srF1umBZIbY1nud1fcksJCDrfsZgYYgn4jQ1NKKDABsPp+XwRQWYBtJqCChwglqwWr0UJiBth2vwOEEN2rTtazNWnMAahK3rUUXWDvKdYQDYfu0W7Zc6BmAdJAjsUuygoeiaVDoytN1zdLRfWXGpYwDXESFch8x1sl9UJQBoJgwEojp7jsz/PccCZdHshUFE1LEIbAsLsBRYW5H6fiDQ2qCUwso8R7720UF4gRtxwuUEMBbQmDkgfP5zr0d2e0Y6Hf6eig4Jz5GuK1hvYMfwnVIcv6HomlQdnUPqkDq0isAWphIXorcZY9i0aRPDhg3rUgp8Cci6m9FYSuNYBjdRQpBqJOb4xCMtFobWGtLVBKqCiL+RqK4CFc8/j/awlMIzpUTT6wquQ6ZVjCA6iEi6quiaU4FdgR3U4vrrizRYEdjlRfdLHQOpjrCHQZs4gT0ON11VdE2pwCnH9mtx08XqCMsU26+tGM32blLHgKxjHdFMQBZ3B2X2lgGKFCVEaSChWy0+HbUgsw5RytckYhFM2sGyFJZtYdsWgY8owhiNpcC2Lfx0mmRTPY4T9kIkotmFoTVQEx6Qef5TjCJKE4ns9oyUt/n3dKSMmFd4gd/AitHglBJLfVZ0zal0pIxIuq7oOaQOqSOwYqSd0qJlhdiWuK5LQ0MD1dXVDB48uNPHyVcOPUgphW0XWNBZCCGE6GV+Ok1D/SYs28GRZFxCCNHtLMuisrKSdDpNdXU1WuvOHdfVis444wxeeOGFLjdwwJJRNEIIIfpYEITBmG07JEoHIR9OQgjRMyKRCEOGDCGdTlNXV3hobmtdDshqa2uZOnUq48aN4+abb2bt2rVdbqgQQgjR14444gjmzp3bZvumTZs44ogj+qBFPae5sR7bdigtq0ApGRwjhBA9yXVdhgwZQpBJoNSRLv9XXrp0KWvXruX8889n8eLF7LzzznzjG9/g97//Pem0ZMERQgjRPzz33HMsWLCA6dOn09i4OXGF53k8//zzfdiybmY0lgRjQgjRq1zX7fQSYVv0n3no0KHMmjWL//u//+PVV19lt91247vf/S6jRo3i8ssvZ/Xq1VtyWiGEEKJXPf3001RVVXHwwQfz4Ycf9nVzeoginiiVYEwIIXqZ43Quf+JWZVlct24dy5cvZ/ny5di2zTe/+U3+8Y9/8MUvfpFbbrmFyy+/fGtO3z8pC20sAmOBMRhjkfQdVLrVU60Go41Dyh6GNoBqtd8KSFtDMMaQiowsmvYeIB0ZUTQFulEuvjMUCq5kRmYfeM7wwsdLHQOvjkwKci8yongK9MyaVMWkM/u8SOE6dOZxSB0DsY6RZNcXM7nssuF7LrvuFdaIzPaK8EdKg0rn0t43JdM0p3y0NuhAEyjNli5DNnLkSJ5//nnOOussDjzwQJYsWcKee+65ZSfbRinLxmARBOHkch1odGbx0qaUn0l7r8k935m4Lfd6tJJ2MxkvM+nJk27h90Vgh2vxJKNDi6ZAz65JVYzUIXVI2nsxEHQ5IEun0/zv//4vDz74IE899RT77LMPl112Gf/xH/9BWVm4yN8f/vAHvve97w3QgExhlIVBARqDIsDFJ7q5jAGUFV4uG/CtAgtDK4PJFPXtinYXhg7sQajMQopt2xP+KLaYa0f7pY4BVkeLhaEDuxRTrA46qKOD/dlFgqWOgVlHOrOMR/b9nF0YOitlZc+RWZDY16A2Z6pK+Rov0GhAG1DGoE3nMlm1lF27LBqN8uijj3LTTTdx1FFHcdVVV3X5XNsyy1IYY3JBmDaQuUva1wS5gCzzfFv5nzhtFoaO5GcP7miBX98pzd0vptg5pA6pQxaGFgNBlwOykSNHorVmxowZ/OUvf2HixIltynzta1+joqKiG5rXD+kAGx9HKQJlYamAEqeJRKTFxYLWkFxHg7MrkWAj0aAK7LbrkKXs4XimlETq3aLrkCWj44ilVhddk6o5ukdmTaqqgvs9ZwSBXU489c/CD0fqGEB1bF6HLBkbRzz5ftE1qZrju7e7JpUXGU7glBNvLvI4rBjNsd2kjgFZx+rN65DZmXXI7HAdsk3sGK5D5r8Xbo9kespKdgYrSlMyTcrXVJZGcY2LYykcx8K2FY11DQXrbY8x+YHHtddey5577skZZ5zR5XNty4IgwLYUESf8HFFoTBAGo+UlbmYdMqApk6Qr879jk/OlwuuQNYa/J92hpCNlDGr8oHC9VoyGkrGUNq4puiZVfcmu7a5JJXVIHbIOmRgIuhyQ3XHHHZx00knEYrGiZSoqKlizZs1WNUwIIYRoTxAE2EbTUFeP3oKVodesWcPQoflDr0488UTGjx/Pa6+91l3NFEIIIdrV5YDsu9/9bk+0QwghhOiSIPCpr/kcy7aJlwzq8vFjxowpuH2vvfZir7322trmCSG2msGzfXwnoCGWJJo2qAJz6oXo77YqqYcQQgjR1xzHxbYjfd0MIUQ3SkXS1MdS+FYMrCj/HLGB2A4b2XnjYHZoKOn4BEL0IxKQCSGE6JcU4ERc0ulUsaSioluZVj9bby9UvuWtM+fu6n6pY3usI7A0tfEw46syBgxYGNJOmtUjqti9ahg7NEpQJnqIyS7mbLfMN9WjJCATQgjRLzlOhEgsju95NDbW9nVztnMG0nUA2HaYrMGyPSzl535vc4SlUCrAslPYqnAZS/lYtlf0HFLHwKtD2R7G9ijxw4tirTTaaIakPRztgQGv4lMiwQ69da0sBpqGf4U/S3eBAkn1eoIEZN1OtfheyAAKX4e3HKOAKJoIvopjE6d12mew8ImjVRRfxTEF1vDOruujrXiYIasAo1yMFUOrwklYjBXDKLfofqljANahWtRRhFYuyoqjreLt1Mptd7/UMXDrCEyYgGPzciDh/z+Ng4+Ln1ufLJM2OzBgNL42aG3wA40f6HD5EGOIxhP4aUmLXYzKfLZks0oaYzCZTyk/szZZuJBb5vnO/g/AwSeKj0v4eRa+Xn4mLX5gxQksF7/I+ybIbA/aeV8Flotl4u2eQ+oYWHX4dgytomiVWZ9QxTAtL4oVpG1NMpImnpahymL7oEzrvL9ii9XV1XHPf/0XjhvFsW2CICDwfcZN2JtYPLG5oAEyFyS5xWBU6+95Nn9wZgr0ZNOF2KzryzkJ0SVWZk0xx8lcTNkt1isyBrILyjqZC7bYCFD531I2N9bx7mvPYEdcbMfBT6f5z0vOo7a2Nrcmpgg/l+5asJCSQeU4kfD5DnyfIO0x/oAjiJdknisTQDKzVIafWRzcjuV/NgVeuNuX4Ff0JJO3Fp7BwTIN7Pb5RbjButx2O5nA9iUgE91v2I5jwzulu2z+7NEeVP81vD/0y+HPAxaAW5E77vPPP2fJkiXEYjFcN/xca2pq4uyzz+7ws0l6yLqbDrBJYysIlMJSmrjVQMJukZLZaEhV0+SMxdY1RP2qzAVJiw8+nSZlj8AnQSz1z6I9ZF5kNG76EyzdXLA5yeg4bF1PJF14Tap0ZASBNYhYanXhhyN1DLw6iOO5o4l6a4vW0RzbDTtowC1ShxcZQWCXEk++X/RxpNwdpY4BWccnuCZchyyWyMwBsQcBilpGEqGZhJ85h5NJSZ/YESyXppRP2tfh2lk6gm0pHFuF62gF8qVVMTrwcSxFxA4/R5RRuSkSJTEnsw6ZB8nMxa4frg9Va+9NhCQJNgEGdPi6+U1hwJx0R5C2BzGoufD/ksCK0xQdTSL1CXaR91V9fByRoJ6YV/h9JXUMvDqaosNJWiW4/jtApodMlVBj2zhq82XrqHRceshEzxg0rterlICs2xkU2dBKAQbHCm852gApLNI4phmHQv+0PAKa0cbGMc0FF4bO9mRYurnoIsHKeCidLL5fJ1EqWnS/1DGQ6jB5PyzdXHSRYMt47e/XzRjLLbq/ZTmpY+DVYWf+5zm5j6AooLDwcfBwTPZ/Ytgjg63AsnAsRWCFAZhjWygFSilUmxEGoiVjNHWNzVjp8B+ICXzQPhvrmvh3vU9gDDZpdlU1AJSpcJHtJM14QQNJvwaFIaaawhNmPo4C5aGVT9ou3GMWKJvAskhbHloVLqOVT6C8ds4hdQy0OgxpFB6WaWpxTKxlASxs6twy6lz52xfd77P3235ZYOGxsxV+vv2rNtz/23efJ8nmRcttv5mK6nq0asJYmX+UnRxRIAGZEEIIsV1TBF4TyrZR9pZ97BsUSZPI2+abKNpE2mzP0kQJjEPKxLFM21Ee4TkiaBNFFzmH1DEw6wh0lMbMBa3BAmVRFXFROhwGNqhhLE2mouDxQmxLLC0BmRBCCCGUQlkWQaoBO1racfkiTJG5zO1tN7mf7fdkbOl+qWP7rEMZG9svw3caMUqBAo3CNlFKmkYTSVfIShdim2cFHrb2Oy6IBGRCCCHEds9yE5h0kiDVgBWJS5oosc2zAxc7cAlsC23HKWncmVhyZC5rqBDbMivwsAOPwOpcqFW4P1l0G6PlOxwhhBgofvGLX7DzzjsTi8WYNGkSf/nLX9otv2TJEsaPH08sFmPvvffmySefzNtvjGHOnDmMHDmSeDzO1KlTWb26cEKF9iilsGKlKGUTeE1IgmXRXygdwdIRXL9UgjHRLyidDoMx20VbnUs8IwFZD9JBQBBIDnEhhBgIFi9ezKxZs7j++uv529/+xr777su0adPYsGFDwfIvv/wyM2bMYObMmbzxxhtMnz6d6dOn8+abb+bK3HLLLfzsZz9j4cKFvPrqq5SUlDBt2jSSyfaTpxSyOSizwsQeQgghupfR2EE6DMZaLunSAVmHrBuF65AtJOKGGcOaGxuwbYcvTtyHWLzFAogG0Gm0csFoLJMCZbE57X04AlsrF2MMlvEKjpU2Kpq7r0yqYJuyZbZ2v9QxQOowYNhch2W8gufQyu2W/VLHwKwjm1nWiWTea/bmhaExBsuvDbdHMvOdEqNBOejMiAPLUjQ31vH2X1fgOJvXIZvVx+uQTZo0iQMPPJAFCxYAoLVmp5124uKLL+bqq69uU/7kk0+msbGRxx9/PLft4IMPZuLEiSxcuBBjDKNGjeI///M/ueKKKwCora1l+PDhLFq0iFNOOaXDNoXrkN1DJD4Iy86uQ5ZGp5vYccJXicQHERiDRUAlYbr7qAqDvRSlGBTKFMmGp8LzdbS/M2WkDqmj2H6DjSJN5fqF2P7nBY8RoqeFWRbD0Qn/0nsB8Fv/4jZZFis3vIlWFtrJZAb10/z42itkHbJeZwzG90l5HpaycBwLGw+nZWekAkwDaTUEFDhBLbQeY2oC0na4Bo8T1KBN2256Y8UJrEHYuh5VZL0P3xkGgJ29wOnifqljANZBgsAuxQ4aiq5JpSND2z1HR/uVFZc6BnAdEcL1rNzsws+E2daaKQcgqrPnyPzfc8Isa81euHhW1LEIbAsLsBRY20Dqe8/zeP3115k9e3Zum2VZTJ06lVWrVhU8ZtWqVcyaNStv27Rp01i6dCkAa9asoaqqiqlTp+b2l5eXM2nSJFatWlUwIEulUqRSm79sqaurQwcaHfi5L/aMCQBFOtlIWhu00SgCStgYtjuT3j5phV8UWkGR19wOX69i+42KYqxYuNRGkS+IOjqH1CF1GOUAFk1eBDuIFTxGiJ6msKm1woCqSYfvQytIYbdYlsryU2GXirJROrPYo+ncSDkJyLqZ0ZqUn8RxbOxoCQRJYo5PPNJieIjWkK4mUBVE/I1EdRWoeP6JtIelFJ4pJZpeV3AdMq1iBNFBRNJVRdecCuwK7KAW119fpMWKwC4vul/qGEh1hJdr2sQJ7HG46aqia0oFTjm2X4ubLlZHWKbYfm3FaLZ3kzoGZB3riGYCsrg7KLO3DFCkKCFKAwndag2YqAWZcfgpX5OIRTBpB8tSWLaFbVv09Qi8jRs3EgQBw4cPz9s+fPhw3n333YLHVFVVFSxfVVWV25/dVqxMa/Pnz2fu3Ll5266/YS7p5jryRmEYw2cf/I1AB2AMyrKptZLhLu1jDOBswEIDxZ5cB6MsVJFeUbAwys3sL3xRYpSLCXy09sPX0wrbqLVBa4NlOSjb2eo6lGn/cWgsjJ8EpbCtMKufMaADDcrCcqKZHpstr6Pj5yqC9lPhyJnMOnsYCHT4eiknNkBfDwuUjfK/QKDD3IyOCujx6WQGfGNjMvVlX48223qYNopA29hWgKVM0W09yWQed8vnvtC2nm1E374eCs1bjMM3NkmdwLYCEnxIHAuMzrynFVaQxg7S5BrTyYGIEpB1M601SikSiTieVpKWVQghRK+ZPXt2Xq9bXV0d991/f/hL7gIh/GHZDsaOEKQaMb6PchVpPwzQYlELbTsogs3f9LZiLBuDXXSdHaMUxnJQOo0qMMoDQFsOylb4qYB0OiDihF8++n5433Ej3VNHB4/DwgYskp6P0YpIxMZL+1hK4boW2BGU9reqjo4fRwRbpfFSAem0T9R1SPsB2hhirgPOAH09jAlfD9/CVgFxu6nnL/4BFEQMNAUJPB0h5jTj6SjaWMSdZmxVuP090Q7PuKR8l6gdBsJeECFqe7hWscC4+9tgG5tmP45R4NopUkEcS+kB83oowFUpXCBtXDzfBVtjIDNnLBK+dwMvs6RDy2lIHZOArAfE49E+Hz4jhBCi9wwZMgTbtlm/Pr+HcP369YwYMaLgMSNGjGi3fPbn+vXrGTlyZF6ZiRMnFjxnNBolGo0W2NN2WKdlO+Giu/EydLIezwuHmJXGbRxb4VsKZQy2VbinI1AGoxSOLtITAgSWwlYaVaS3JFtHLA5JT5HKDEuNRxUxt3vr6PBxWIaIbdHYrEl7Po4FpXEFynRfHR0+DkPMVjQ0G9Je2IM0KG7h2GbAvh4NzRrP84haaSojG3ulR6ilEruBmnQlad9FYRjifkbE6uUueRsa/QSNfjhfqTxSS4nT1LttAEqsBjZ5O5D2XaJWiorIpgH5eiQiKSxlSAUJFJrAiaLtTM+vygRjrb4A64hkWRRCCCG2kuu67L///qxYsSK3TWvNihUrmDx5csFjJk+enFceYPny5bnyY8eOZcSIEXll6urqePXVV4ueUwghRP8jPWQ9oLk5hePIUyuEEAPJrFmzOOOMMzjggAM46KCDuPPOO2lsbOSss84C4PTTT2fHHXdk/vz5AFx66aUcfvjh3HbbbRx99NH89re/5bXXXuPee+8FwjT1l112GTfddBPjxo1j7NixXHfddYwaNYrp06d3S5uNMehkAxhNLBbB8wIakoZ41EZFLBQ2xhReR8coG2Ms/KL7LQwWhkhmfkVb2oR1pFIKLw1uJPzsTHoB2igise6ro6PHkfJtmlM+lmXjujbJlE99syIWD5NKdEcdHT0ObRySzRptLGIxR16PlI9lO7iuS6opycb0MEqcpl6ZuwXh9J9GP4E2FolIM8kgSnV6KAmnCadID19PSPouqSBK1A57sev8ClImTszppSGLgK8tmvwElqWJ2Sma/PiAfT3W+l/IrTMGYAfh62A6uQh0IRI1dDPLstBa09TUHCb1EEIIMSCcfPLJfPbZZ8yZM4eqqiomTpzIsmXLckk5Pv74Yyxr88CUQw45hEcffZRrr72WH/7wh4wbN46lS5cyYcKEXJkrr7ySxsZGzj33XGpqajj00ENZtmwZsdjWZ5szxhAkGzEmwImW4NjN2DFFc9KnOeUTtQKctvmkup3npUmnA9yIjetuvizx0gHGShNxe/5SJQgCUqlwzlg85qCUIh51aE75JJNpognT8zkLjCGVTKONIR51sG1LXg+liMUiKMumxE3R5EVo9BO9EgTkXfxnLvhLVBONfoImP9FrQUDLYKxlAJYKwqHJvRGU5YIxpXPPfcJposlPDMjXI7foc4t1xuzAQ3cyo2Ihsg5ZN6qrq+Oehffg2A4pz0OhiLgOe07YnXi81Yen30DaGgJoIv6GomnvjTFE/A1bnfbe8QsvTNrRfqljANbRibT36UyK80j6sy3arzuRZl3q2H7rcLNp76OZ7LJOi7T3xhD3Pg63RyvCn2V7gnJyae/jrk1TQx3/75XlOBEX24mQTqe5/OLv9+k6ZNuiuro67rjjTrBsLDu8mjfGYIIAJxLFGI0dH5Tbl93vNzeACXDjgzBW4SjAzlyBBUUuIxThkgTamKLTKIyXxPeasdwYtpufbTjwmtFeEseNo9zCAWhn6uiwnTrAa64HZePES/Pm2unAJ2huwLJt7Fgpxa46O6qjo/0YQ5BsQAcBdrwUy3Za7BrYr4eVKd+QbEYHPrafwigL7USLvh5bzRgsP4Uy4fwgWj7n7e3rZipIYwVptB3B2JFO7+tWOij+nLe3rzttY6+Hb0fbLPpsBR52kELpAKPszc+FDrjxhjmyDlmvUwrlOMScCM2NDfi+JsDFb7HYLgZQVvjPyoBvlbddGFqZzPLQ4NsV7S4MHdiDUFaR1cAzpwyc8i3aL3UMsDpaLAwd2KWYYnXQQR0d7M8uEix1DMw60pllPDYvdB4uDJ2VsrLnyIwy8DWozd88pnyNF2g0oA0oY5DvFtvXMsgw2oDRGBMQSZSjWn0hqBRE4mX4yTq85nqcWFlegJA7T7Z8kb4jpTIfd9k7rfheM4HXjOMm2lz8AzhuCQEWaa8JG4VToExHdXTUTh34pJP1KMvGiZW1SXxi2y5Woox0cx0m2VCwTEd1dLTfGIOfrMfogEiiTF6PVq9HmN3coLEJLAvt2Dh+M8r38J149wcBxuD4zWAMaSfRNgBWEGTaYGXaUCxI3hpW4GEF/7+9u4+Tq6rzPP455966VdXd6W4IIZ0EgSgBRHkSNJMRdxzJiwRZIMg6wGRAMAPKijMIjq6zA8GXzCDoKIvy4LoOiIug8cX6BJNdNgwCGpAgvGZHIEKGB3lokIT0Yz3de87+UdXVT1XdTac6naa+79erX919z7n3d++p6ur7q3vr/OKaJ/8ABAEWW74yg63dZxcZlxDGRZwJao+1DfR4VAxN6hG6GHxSqZ83dUrIGs0lBMSEYQqXbSUp5mgNB2lJjbiM6RzkX6E/fAep5HXSSTcE4+uQFYKFFH0bLYWn6tYhy6eXkSk8XbcmVS59SKUmVe2aNcWwiyToIFv4Xe3DUYwmijFchyyfWUY2/0zdmlS57MET1qQqphaShB1kc3WOw2bIZQ5SjKaM8fRwHbKgUocsKNche4Ml5Tpk8dby8lRldsLWA8GmGcyXKMSOvdrSRD4itIYwtIRhgJ/tQmR7MF+pO8ZQ4lqZsjxMt5brPdWZfjzMlBORYq6HIN2GGZMEBNZiMMR11jcYwsASJ46x10tcMY8r5QjTrdgoU3cbQZQhAOLCAM457JgrMxPFqB6HDfB4kjEzA/okJin0Y21ImGkn8a5mEmGwpLLtFAd7KQ72YDNt45KyejGqx1FnrEZ+hi9qadfjUePxMJjqVTIoT4sfh1nCOEcY5xqbBFRO/o13E5/YGzNuHxqZBJSvtoy/LW4sN+YzTI1MysrJWA5v7IRjrMdjmAsifJzH4MHFb+ozZZplcQbZICAINMQiIjL7vPeQVOpHmaDmVZaRjDGE2XkYE5AU+huW9A6d/NtUtuZVlrHCKItNZXGl8i1zjTB08m9MUDnGiU8gbRASpNvwPsHl+xtyRXYoGfM+IUi36fF4E4/HUBJgvKtePdn1nZjiyf+QShLgjS2vVyeJfbOmevI/xAURSVD+XJNNGvN5sqkmY0P0eIzcD4vHYPAYN/W/UWULM8xY1SMTEZFZNiYZm2qtTGNM5YpQY5KAkSf/Y6+uTMRGmYYlASNP/mtd7arHNDApG5uMjb3aVXcf9HgMr9fIJODNnvwPaXAS8KZP/isamZS92WRsiB6PYd4Ew0lZnXp842JNdydFRERkjvCVExMbYuyb+9ffqCRguif/QxqRBEz35H9II5Ky6SZj1X3Q4zG8fiOSgOme/A9pUBIw3ZP/IY1IyqabjA3R4zHM27CSlE0x3puOICIiInPPNJKxIbuaBOzqyf+QXUkCdvXkf8iuJGW7moxV90GPx/B2diUJ2NWT/yG7mATs6sn/kF1JynY1GRuix2NYOSmbGk3qISIi8hY1nCyUT668c9UTJJfE+PLHz2ty3pWnyB9xQmVSGXxxkDjXh/Gt2CAsb7PuNixxIYeLC9gwjQnCUclDrRij1ncGY8yoGCYIMS4iKQ7iXYJNZ/HOTXgcLomJ8wMYazGpDLik2r9WjFrHMTaGDbPlfcj1YjNtABMeB0CS78c7RxCVSz2MHovxMcYeR7M+Hs4YXFIqT6tagwdiExIkRQI3QGKjyRMK7wlcEbwjDqJyvAnGbipiQgJfJCgOkARRefrzSVhXInAxiQ3LJY7i0i7tgysXHyAo5SGJcXbyKfGNT8qzNRpLYkLYxVthm/fxcDBUi6xSrmqoguFkb9woIWs4U52uvjL5K7Erf1V5A6RxpIhNloAsY6d9BktMFmfSxCaLr3Ex09ns8Pc6z1lvIrzN4Eztd8C8zeBNVLddMZowhhkRow5nIozN4mz9/XQmmrBdMZo3RuLL/+yHy4GUX/8cITERscmOWA4k5WnaY+dxzhMnrjyLm2fCk0eBvr4+vnjFFbO9GyIiTa2vr4+OjvplY1QYuoF6e3u58VvfIozShEFAkiQkccyydx9OJtsy3NEDlROS6qXcce8cVFK6Me9uisy4mS90L03OVmqKhWHlnduRt4R4D0nl1qewkphlumDMO5u5gV6e2nIvQSoiCEPiUolL/+qTKgw9hnOOl19+mXnzJp+5bip6e3t529vexu9//3uN85ugcZs+jd30aNymp9Hj5r2nr6+PxYsXYye4ZVxXyBrNJQSUCAwkxmCNI2v7aQlGXP71DgrbGQyXEridpOPuygnJyOrnJQpBFzEtZAq/q3uFrJjaj6j0Itblau5OPr2MwPWRKtWuSVVKdZHYeWQKT9c+HMVovhhkKUb7kS6+VDdGLnMQQdJPVCdGMdVFErSRzT9T9zgK0RLFaMoYLxL5ch2yTEul8HMwDzD0sIgUOVriyjbCBeXvLUvARgwWYkqxo6M1InQpAmsIg3Ldo+JAY6bffqux1rLffvs1fLvt7e06yZsGjdv0aeymR+M2PY0ct4mujA1RQtZw5btFy6lVub58aMtfVc4DBSwlQp8jpNYJUJGEHM4HhD5XszD00JUM63J1iwQbX8S4fP12l8eYdN12xWimGH7UN+tydYsEW1+cuN3l8Daq2z6yn2I0X4yg8poXVv8FpSmX340JKRL6odfEyofSAwPWElpDYssJWBhY8A5jDIXcIIXi4IRxRURE9lRKyEREZE6K4xKl/hJJEpOOWiZfQUREZA+kae9FRGRO8kBcKpJKpYky9SckkcZJp9OsX7+edDo9eWep0rhNn8ZuejRu0zNb46YrZCIiMqfFcZEg1L+z3SGdTnOFZm180zRu06exmx6N2/TM1rjpCpmIiMxJQRAyr3NvgiAkN9A327sjIiIyLUrIRERkTgqCAGMsbe2d2EBXyEREZG5SHbIGKtchu4lUlCYIwmodskPefRiZ7IjPN3jAlXAmAu+wvgDGMjztfbm0tDMR3nusL9aseO/N8P2txhdq7tNQn11tV4wmieHBMxzD+mLNbTgTNaRdMZozxtDMsmGq8lwLhgtD4z027ikvT7WVv7fsBybEufIrobWG3EAvTzyyiTAs1yErlYpc+lcXqg6ZiIjMOXpLsdG8x3iHwQMGgyegSDjyYqQBfD8lsw8YCJMesGMeCp9QCso1eMJkJ86PL+jpbZbEziNwfZg6tYPicF8AgqETnDfZrhhNGIMWkqCNIOmvW5PKpRZMuI3J2o3NKkYTx0hRvr0wGir8THmGxBzlWi1pN7SNyuteaMFYcsWk3B5aksBiAWvAGoM1uuFDRETmJiVkjeYd1jgC44iNxRhHJozJpkYUhnYOSttJTCep+HXSrhvMmBnCXBFrDEXfRrr0Ss06ZM5kSNLzSJW669acSoJOgqSHKH61zg4bkqCjbrtiNFOM8tUH57MkwTKiUnfdmlJJ2EEQ9xCV6sUo96nX7myGXHCQYjRljFdIVxKybDSv0toOGAq0kqafFjem+HTagk0BUIgdLZkUvhRircEGliCwJDEiIiJzkt5SFBERaSJ33nknJ5xwAvPnz8cYw+OPPz6uTz6f51Of+hTz58+nra2N008/nVdfrZ+MA3jvufzyy1m0aBHZbJaVK1fy9NNPj+qzY8cO1q5dS3t7O52dnaxbt47+/v5GHt5uc+6552KMGfW1evXqSde7/vrrOfDAA8lkMixfvpxf//rXo9qnM/ZzyWTHP9aGDRs49NBDyWQyHH744dx9992j2qfyvJvLrrjiinHPs0MPPXTCdZp1zO6//35OPvlkFi9ejDGGH//4x6Pap3vcu+NvVgmZiIhIExkYGOC4447j6quvrtvnM5/5DD/72c/YsGEDv/jFL3j55Zf5yEc+MuF2r7nmGq677jpuuukmHn74YVpbW1m1ahX5/PBV17Vr1/Lb3/6We+65h5///Ofcf//9XHDBBQ07tt1t9erVvPLKK9Wv22+/fcL+P/jBD7jkkktYv349v/nNbzjyyCNZtWoVr732WrXPdMZ+rpjK8Y/0q1/9irPOOot169bx2GOPsWbNGtasWcO//du/VftM5Xk3173rXe8a9Tx78MEH6/Zt5jEbGBjgyCOP5Prrr6/ZPp3j3l1/s0rIREREmsjZZ5/N5ZdfzsqVK2u29/T08J3vfIevfe1rfOhDH+KYY47h5ptv5le/+hUPPfRQzXW891x77bX83d/9HaeeeipHHHEEt956Ky+//HL1Xeonn3ySjRs38j/+x/9g+fLlHHfccXzjG9/gjjvu4OWXX56pw51R6XSarq6u6tdee+01Yf+vfe1rnH/++Zx33nkcdthh3HTTTbS0tPBP//RPwPTGfi6Z7PjH+m//7b+xevVq/uZv/oZ3vvOdfOlLX+I973kP3/zmN4GpPe/eCsIwHPU822effer2beYxO/HEE7nyyis57bTTxrVN97h319+sErKZpjksRURkDnn00UcplUqjErZDDz2U/fffn82bN9dc59lnn6W7u3vUOh0dHSxfvry6zubNm+ns7OTYY4+t9lm5ciXWWh5++OEZOpqZdd9997HvvvtyyCGHcOGFF7J9+/a6fYvFIo8++uioMbLWsnLlyuoYTWfs54qpHP9YmzdvHvfGwapVq6r9p/K8eyt4+umnWbx4MW9/+9tZu3YtL7zwQt2+GrPapnPcu/NvVgnZDPLekyTJbO+GiIjIlHV3dxNFEZ2dnaOWL1y4kO7u7rrrDPWpt053dzf77rvvqPYwDNl7773rbndPtnr1am699VY2bdrE1VdfzS9+8QtOPPHEuv/3X3/9dZIkmXSM3uzYzxVTOf6xuru7Jx2voWVT3eZcs3z5cm655RY2btzIjTfeyLPPPssHPvAB+vr6avbXmNU2nePenX+zmmWx0YzFeUvsDMXBAYw15OMQUxoz1GY+zocUgn1xHjBj2m1Cye6D955CalHdae8BSqmuulOgexMRhwuod6mu3AbFcGHNdsVowhiVKciLqa76U6CbqDrNeS2lSlsxVTuGqxyHYjRjjEVAub6Yr84uW37OOcLy1Pe2q7K8s/yt4MCUqtPeD+ZL5Aoxznlc4kiMw+luhJpuu+02PvGJT1R//+d//mc+8IEPzOIezU21xvHMM8+s/n744YdzxBFH8I53vIP77ruP448/fjZ2U96CTjzxxOrPRxxxBMuXL+eAAw7ghz/8IevWrZvFPZNGUkLWaMbgMBQGczjvSAURCRHxiGK75RJltny67CG2HeMLQxtfKQ8NcdA5YWHoJJiHsVGNHsObTMKOabUrRpPFGFEYOgna8PViMEmMSdqHigQrRnPGKFXKeAwXOi8Xhh5SsEPbaC1/ix0YN9weO4qJwwHOg/Ee75WR1XLKKaewfPny6u9LliyZdJ2uri6KxSI7d+4c9a7vq6++SldXV911hvosWrRo1DpHHXVUtc/YyRviOGbHjh11t7unmMo4vv3tb2efffbhmWeeqZmQ7bPPPgRBMG72tZHjOp2xnyumcvxjdXV1TTpeQ8vqPe/eajo7Ozn44IN55plnarZrzGqbznHvzr9ZJWQN5l1CMTcIQDrbivFFWsNBWlLDJxM4B/lX6A/fQSp5nXTSDcH4OmSFYCFF30ZL4am6dcjy6WVkCk/XrUmVSx9SqUlV+7JpMewiCTrIFn5Xs10xminGcB2yfGYZ2fwzdWtS5bIHT1iTqphaSBJ2kM3VOQ6bIZc5SDGaMsbTw3XIgkodsqBch+wNlpTrkMVby8tTlX9mrQeCTTOYL1GIHXu1pYl8RGgNYWgJwwCvQmQ1zZs3j3nz5k3ecYRjjjmGVCrFpk2bOP300wHYunUrL7zwAitWrKi5ztKlS+nq6mLTpk3Vk5ve3l4efvhhLrzwQgBWrFjBzp07efTRRznmmGMAuPfee3HOjUp29kRTGccXX3yR7du3jzrZGymKIo455hg2bdrEmjVrAHDOsWnTJi666CJgemM/V0zl+MdasWIFmzZt4uKLL64uu+eee6pjMZXn3VtNf38/27Zt4+yzz67ZrjGrbTrHvTv/ZpWQNZhzDjy0tbUQE+B1jiAiInuQHTt28MILL1RnNty6tZwAD83g1tHRwbp167jkkkvYe++9aW9v59Of/jQrVqzgj/7oj6rbOfTQQ7nqqqs47bTTMMZw8cUXc+WVV7Js2TKWLl3KZZddxuLFi6snMu985ztZvXo1559/PjfddBOlUomLLrqIM888k8WLF+/2cdgV/f39fPGLX+T000+nq6uLbdu28bnPfY6DDjqIVatWVfsdf/zxnHbaadWTt0suuYSPfexjHHvssbzvfe/j2muvZWBggPPOOw9gymM/V012/Oeccw5LlizhqquuAuCv//qv+ZM/+RP+8R//kZNOOok77riDLVu28N//+38HmNLzbq777Gc/y8knn8wBBxzAyy+/zPr16wmCgLPOOgvQmI3U398/6srhs88+y+OPP87ee+/N/vvvP6Xjnq2/2TmXkJ177rl897vfHbVs1apVbNy4ccL1rr/+er7yla/Q3d3NkUceyTe+8Q3e9773Vdvz+TyXXnopd9xxB4VCgVWrVnHDDTeM+yDfpDxkMhFBEBBrPg8REdnD/PSnP62eTADVz0KtX7+eK664AoCvf/3rWGs5/fTTR/1PHGnr1q309PRUf//c5z7HwMAAF1xwATt37uS4445j48aNZDKZap/bbruNiy66iOOPP766/euuu24Gj3ZmBEHAv/7rv/Ld736XnTt3snjxYk444QS+9KUvkU4Pf0Rh27ZtvP7669XfzzjjDP7whz9w+eWX093dzVFHHcXGjRtHnWtMZeznqsmO/4UXXsDa4fnm/viP/5jvf//7/N3f/R1/+7d/y7Jly/jxj3/Mu9/97mqfqTzv5rIXX3yRs846i+3bt7NgwQKOO+44HnroIRYsKH9uV2M2bMuWLfzpn/5p9fdLLrkEgI997GPccsstUzru2fqbNX6O3Xh/7rnn8uqrr3LzzTdXl6XT6Qlrf/zgBz/gnHPO4aabbmL58uVce+21bNiwga1bt1ZnfLrwwgu56667uOWWW+jo6OCiiy7CWssvf/nLKe9bb28v37z+m7S2pAnDFIXE4uMcRx35DlpaRjzJR96yGO8ptyxurdmuGM0UQ7csKsZuvmWxtXILWGrELYu+n5Z85bmZrdyyuOD9425ZHOjr4ZEHNhJG5dfbYqHAX1/0CXp6emhvb6+5DyIiInuiOTnt/R5diNF7isXSdA9NRERERESayJxMyPaUQoyFQoHe3t5RX8YYisWYQqHYgCMVEREREZG3sjn3GbLVq1fzkY98hKVLl7Jt2zb+9m//lhNPPJHNmzcTBONv65uoqNtTTz0FTL+o21VXXcUXv/jFUcu+/OWrCEJLPl8kiAyhNcSu/FXlDZDGkSI2WQKyjJ32GSwxWZxJE5ssvkbuPFTXx9ksuHHNlVAR3mZwpvZ9wd5m8Caq264YTRjDjIhRhzMRxmZxtv5+OhNN2K4YzRsjqcx2NFwOpPz65wiJiYir9ckqU/AnHrwjdh7nPHHiiBOH9+A15b2IiMxxe3RCtqcXYvzCF75Q/cAglD9DdtvttxNEaYyNKeRzEEXkXBs+aRle0QNBW/kEw8wjTs0DM6bwc1A+wfDek8sczOhkbbRitN+E+5kE80iCiafrzWeWTdiuGE0Uo5LoFaKJ6xUlQRu54KAJ++QyE7crRjPG2I9SpaZYwaYqS4drn5XI0hMOPTcridlgAmb4roOegSK5XInEeUg83pSTNRERkbloj07I9vRCjOl0etRsSgC4hIAS6UwK5zP4pETW9tMSjJj/3jsobGcwXErgdpKOuyEYc4XMlSgEXcS0kCn8ru4VsmJqP6LSi1iXq7mP+fQyAtdHqlT7Sl8p1UVi55EpPF2zXTGaMAZZitF+pIsv1Y2RyxxEkPQT1YlRTHWRBG1k87ULVzqbpRAtUYymjPEikS9P6pFpqRR+DuYBhh4WkSJHS1zZRlieRYyWJWAjBgsxpdjR0RoRuhSBNYSBIQwsJPXftBIREdmT7dEJ2dwsxOgxlFOrVJQmKcSE1hPaEe/eOg8UsJQIfY6QWidARRJyOB8Q+lzNWRaHrmRYl6s7457xRYzL1293eYxJ121XjGaK4Ud9sy5Xd8Y964sTt7sc3kZ120f2U4zmixFUXvPC6r+gNGCwxIQUCf3Qa2LlqlhgwFpCa0hsOQELA4sx5Zo6ZuwdBiIiInPInJrUo7+/n7/5m7/hoYce4rnnnmPTpk2ceuqpNQsxfvOb36z+fskll/Dtb3+b7373uzz55JNceOGFdYu6/cu//AuPPvoo5513XkMKMdpgTg2xiIiIiIjsRnMqWxgqxHjKKadw8MEHs27dOo455hgeeOCBSQsxfvWrX+Xyyy/nqKOO4vHHH69Z1O0//sf/yOmnn85/+A//ga6uLu68887denwiIiIizeY73/kOJ5xwwozH2bhxI0cddRTO1ZkVS2SW7NG3LI6VzWb53//7f0/a77nnnhu37KKLLqreolhLJpPh+uuv5/rrr9+VXRQRERGRKcrn81x22WVs2LBhxmOtXr2ayy67jNtuu42zzz57xuOJTNWcukImIiIiIm8dP/rRj2hvb+f973//bol37rnnct111+2WWCJTpYRMRERERHbJrbfeyvz58ykUCqOWr1mzZsKrUXfccQcnn3zyqGUf/OAHufjii8dt59xzz63+fuCBB3LllVdyzjnn0NbWxgEHHMBPf/pT/vCHP3DqqafS1tbGEUccwZYtW0Zt5+STT2bLli1s27ZtegcqMgOMV0XNhunt7eXGb91EKkoTBCFJkpDEMYe8+zAy2REFVz3gSjgTgXdYXwBjGZ723gMeZyK891hfpNaD5M3w5+aML9ToMdxnV9sVo0liePAMx7C+OL4P5SLBjWhXjOaMMTSzbJiqPNeC4cLQeI+Ne8rLU23l7y37gQlxlVpj1hpyA7088cgmwjAiCEPiUolL/uqT9PT00N7eXnMfRGTm5HI5Fi1axLe//W0++tGPAvDaa6+xZMkS/s//+T/86Z/+ac31Ojs7+da3vsUZZ5xRXfbBD36Qo446imuvvba6bM2aNXR2dnLLLbcA5YSsr6+Pf/iHf+BDH/oQX//617ntttv44z/+Yz7+8Y9z5JFH8vnPf56tW7fy29/+dtRsrF1dXXz5y18eleCJzKY59RmyOcF7jHcYPGAweAKKhCMvRhrA91My+4CBMOkBO+ah8AmloFyDJ0x24vz4aZ29zZLYeQSuD1OndlAc7gtAMHSC8ybbFaMJY9BCErQRJP11a1K51IIJtzFZu7FZxWjiGCnKdciicOiNqhYAcnQAkHZD26i87oUWjCVXTMrtoSUJLBawBqwxODei1qOI7HbZbJY///M/5+abb64mZP/zf/5P9t9/fz74wQ/WXGfnzp309PSwePHiacX88Ic/zCc+8QkALr/8cm688Ube+973VuN//vOfZ8WKFePqyi5evJjnn39+WjFFZoISskbzDmscgXHExmKMIxPGZFMjThacg9J2EtNJKn6dtOsGkx29HVfEGkPRt5EuvVKzDpkzGZL0PFKl7ro1p5KgkyDpIYpfrdkOhiToqNuuGM0Uo3z1wfksSbCMqNRdt6ZUEnYQxD1EpXoxyn3qtTubIRccpBhNGeMV0pWELBsN1ZlsBwwFWknTT4sbU3w6bcGmACjEjpZMCl8KMcZgA4t3CYXBvrr7JSK7x/nnn8973/teXnrpJZYsWcItt9zCueeeW7dWYC5XfgMok8lMK94RRxxR/Xlo5uzDDz983LLXXnttVEKWzWYZHBycVkyRmaCETERE5qQkLmKsJZ/rxwb6dyYy244++miOPPJIbr31Vk444QR++9vfctddd9XtP3/+fIwxvPHGG5NuO0mScctSqVT156Gkr9aysdPc79ixgwULFkwaU2R30aQeIiIyJznvGezvwdqAbEvbbO+OiAB/+Zd/yS233MLNN9/MypUredvb3la3bxRFHHbYYTzxxBPj2l59dfTV9n//939vyP7l83m2bdvG0Ucf3ZDtiTSCEjIRERERaYg///M/58UXX+Tb3/42H//4xyftv2rVKh588MFxy3/yk59w5513sm3bNv7+7/+eJ554gueff56XXnppl/bvoYceIp1Os2LFil3ajkgjKSETEZE5yRpDS1sHziXkBvtne3dEBOjo6OD000+nra2NNWvWTNp/3bp13H333fT0jJ4Q6KSTTuKaa67hsMMO4/777+eGG27g17/+Nd/73vd2af9uv/121q5dS0tLyy5tR6SRdNO9iIjMSUEYEaZStIV70bvz9dneHRGpeOmll1i7di3pdHrSvocddhgnnXQSN9xwA1/4wheqy5csWcKGDRtG9b3wwgurPz/33HPjtjW2ktOBBx44atnrr7/Oj370o3G1yURmmxKyRjMW5y2Jt+A93lvycYgpjRlqMx/nQwrBvjgPmDHtNqFk98F7TyG1qO609wClVFfdKdC9iYjDBVCzkhmVNiiGC2uvrxjNF6MyBXkx1VV/CnQTVac5r6VUaSumasdwleNQjGaMsQgof97LV2eXLT/nHGF56ns7NBtaZ/lbwYEpVae9H8yXyBVivPe4xBGEKdItQzM2ishseeONN7jvvvu47777uOGGG6a83le+8hV+9rOfzeCelT333HPccMMNLF26dMZjibwZSsgazRi8sXgM4PAYEiLiEcV2yyXKbPl02UNsO8YXhja+Uh4a4qBzwsLQSTAPY6MaPYY3mYQd02pXjCaLMaIwdBK04evFYJIYk7QPFQlWjOaMUaqU8RgudF4uDD2kYIe20Vr+Fjsww7OkFWJHMXE4wHkw3mPH1nIUkd3u6KOP5o033uDqq6/mkEMOmfJ6Bx54IJ/+9KdncM/Kjj32WI499tgZjyPyZuk/WKO5hICY0BgSY7EmoTUcpCU1YspV5yD/Cv3hO0glr5NOuiEYX4esECyk6NtoKTxVtw5ZPr2MTOHpujWpculDKjWpumu2F8MukqCDbOF3tQ9HMZooxnAdsnxmGdn8M3VrUuWyB09Yk6qYWkgSdpDN1TkOmyGXOUgxmjLG08N1yILKVa2gXIfsDZaU65DFW8vLU5UrZa0Hgk0zmC9RiB17taWJfERoDWFoCcMAn6gwtMhsq3Ub4XTcd999DdmOyFyhST1ERERERERmiRIyERERERGRWaKETEREREREZJYoIRMREREREZklSshmmEvc5J1ERERERKQpaZbFhjPV6epLxQLeeWJniN2IOmLeAGkcKWKTJSDL2GmfwRKTxZk0scnia+TOQ3V9nM1CnbzPmwhvMziTqd1uM3gT1W1XjCaMYUbEqMOZCGOzOFt/P52JJmxXjOaNkfjyjIjD5UDKr3+OkJiIuFqfrDIFf+LBO2Lncc4TJ444cXhfLgQ7thisiIjIXGK8/pM1TG9vLzd+61uEURoXxxTyOVJRxCFHHEUm2zLc0QOVExKGht+MLfzsK81DD8/4wtAiM0IXdWWG2UpNsTBMlRcEI2qfeQ9JZer9sJKYZbrAjC79kRvo5akt9xKkIoIwJC6VuPSvPklPTw/t7e0zfQgiIiINoytkjeYSkuIgccmRSmcIrSdr+2kJRtTI8Q4K2xkMlxK4naTj7soJyYiky5UoBF3EtJAp/K7uFbJiaj+i0otYl6u5O/n0MgLXR6pUuyZVKdVFYueRKTxd+3AUo/likKUY7Ue6+FLdGLnMQQRJP1GdGMVUF0nQRjb/TN3jKERLFKMpY7xI5Mt1yDItlcLPwTzA0MMiUuRoiSvbCBeUv7csARsxWIgpxY6O1ojQpQisIQwMYWAh0ZtWIiIyNykhazDnHC52ZLMZCNP4OEdoPaEdcSHSeaCApUToc4TUOgEqkpDD+YDQ52oWhh66kmFdrm6RYOOLGJev3+7yGJOu264YzRTDj/pmXa5ukWDrixO3uxzeRnXbR/ZTjOaLEVRe88Lqv6A0YLDEhBQJ/dBrYrH8LTBgLaE1JLacgIWBxRgwxmDG3WEgIiIyd2hSjwbz3hNFIel0NHlnERERERFpakrIGs0Yoig123shIiIiIiJzgBKyRvOeRFPdi4iIiIjIFCghazQD+XyRJElme09ERERERGQPp4Ssway1GGMYGMjhlJSJiIiIiMgEVIesgcp1yG4iTEWUCkWSJCYVRRx6+LvJZEcUXPWAK+FMBN5hfQGMZXja+3JpaWcivPdYX6TWg+RNuvqz8YWa+zTUZ1fbFaNJYnjwDMewvlhzG85EDWlXjOaMMTSzbJiqPNeC4cLQeI+Ne8rLU23l7y37gQlxrvxKaK0hN9DLE49sIgyH65BdojpkIiIyB2na+0bzHosn25JlsH8AlyQEFAlHXow0gO+nZPYBA2HSA3bMQ+ETSkG5Bk+Y7MT58dM6e5slsfMIXB+mTu2gONwXgGDoBOdNtitGE8aghSRoI0j669akcqkFE25jsnZjs4rRxDFSlOuQRUOFn2kBIEcHAGk3tI3K615owVhyxfJdB+nQkgQWC1gDVlPfi4jIHKaErNG8wxpHaD1RSytJYYBMGJNNjSgM7RyUtpOYTlLx66RdN5js6O24ItYYir6NdOmVmnXInMmQpOeRKnXXrTmVBJ0ESQ9R/GqdHTYkQUfddsVophjlqw/OZ0mCZUSl7ro1pZKwgyDuISrVi1HuU6/d2Qy54CDFaMoYr5CuJGTZaF6ltR0wFGglTT8tbkzx6bQFW569thA7WjIpfCnEWoMNLEFgSWJERETmJH2GbAYZYwiCGgWdRUREREREUEI283QXjYiIiIiI1KGETEREREREZJYoIRMREREREZklSshERERERERmiWZZbDRjcd6SeAve470lH4eY0pihNvNxPqQQ7IvzgBnTbhNKdh+89xRSi+pOew9QSnXVnQLdm4g4XAA1K5lRaYNiuLD2+orRfDEqU5AXU131p0A3UXWa81pKlbZiqnYMVzkOxWjGGIuAcn0xX51dtvycc4Tlqe9tV2V5Z/lbwYEpVae9H8yXyBVinPO4xJEYh1NFTRERmaOUkDWaMXhj8RjA4TEkRMQjiu3iAWPLp8seYtsxvjC08ZXy0BAHnRMWhk6CeRgb1egxvMkk7JhWu2I0WYwRhaGToA1fLwaTxJikfahIsGI0Z4xSpYzHcKHzcmHoIQU7tI3W8rfYgXHD7bGjmDgc4DwY73F+uF1ERGQuUULWaC4hICY0hsRYrEloDQdpSY04WXAO8q/QH76DVPI66aQbgvF1yArBQoq+jZbCU3XrkOXTy8gUnq5bkyqXPqRSk6q7Znsx7CIJOsgWflf7cBSjiWIM1yHLZ5aRzT9TtyZVLnvwhDWpiqmFJGEH2Vyd47AZcpmDFKMpYzw9XIcsqNQhC8p1yN5gSbkOWby1vDxVuVLWeiDYNIP5EoXYsVdbmshHhNYQhpYgMAz09teMKyIisqdTQiYiInNSkiQE3tHf24dTZWgREZmjlJCJiMiclCQxfTt3YIOAbOu82d4dERGRadEsiyIiMqeFYUQQpGZ7N0RERKZFV8hERGROMkCYiiiVCvUmFRUREdnjKSETEZE5KQxTpDJZ4mKRgYGe2d4dERGRaVFC1nCmOl19ZX57Ylf+qvIGSONIEZssAVnGTvsMlpgszqSJTRZf4+7Sobo+zmahzozP3kR4m8GZTO12m8GbqG67YjRhDDMiRh3ORBibxdn6++lMNGG7YjRvjMSXJ+AYLgdSfv1zhMRExNX6ZJUp+BMP3hE7j3OeOHHEiSuXD/GedLaFuFSqu+8iIiJ7MuO9140eDdLb28uN3/oWYZQmDAKSJCGJY5a9+3Ay2Zbhjh6onJAwNPxmbOHnSkpXfXjGF4YWmREq5yQzzFZqioVh5XNfwYjaZ95DUpl6P6wkZpkuMKNLf+QGenlqy70EqYggDIlLJS79q0/S09NDe3v7TB+CiIhIw+gKWaO5hIASgYHEGKxxZG0/LcGIKZm9g8J2BsOlBG4n6bi7ckIyIulyJQpBFzEtZAq/q3uFrJjaj6j0Itblau5OPr2MwPWRKtWuSVVKdZHYeWQKT9c+HMVovhhkKUb7kS6+VDdGLnMQQdJPVCdGMdVFErSRzT9T9zgK0RLFaMoYLxL5ch2yTEul8HMwDzD0sIgUOVriyjbCBeXvLUvARgwWYkqxo6M1InQpAmsIA0MYWEj0ppWIiMxNSsgazmMYSq0M4Alt+avKeaCApUToc4TUOgEqkpDD+YDQ52oWhh66kmFdrm6RYOOLGJev3+7yGJOu264YzRTDj/pmXa5ukWDrixO3uxzeRnXbR/ZTjOaLEVRe88Lqv6A0YLDEhBQJ/dBrYrH8LTBgLaE1JLacgIWBxRgwxmDG3WEgIiIyd2jaexERERERkVmihExERERERGSWKCETERERERGZJUrIZph3msRSRERERERqU0I2g1ySkCSaQ1xERERERGpTHbIGKtchu4lUVJ4xLDfQTxCEHHbUEWSyIwquesCVcCYC77C+AMYyPO19ubS0MxHee6wvUutB8iZd/dn4Qs19Guqzq+2K0SQxPHiGY1hfrLkNZ6KGtCtGc8YYmlk2TFWea8FwYWi8x8Y95eWptvL3lv3AhLjKHQfWGnIDvTzxyCbCcLgO2SWqQyYiInOQpr1vNO/xcUyhWMQaSxhaAoqEIy9GGsD3UzL7gIEw6QE75qHwCaWgXIMnTHbi/Phpnb3Nkth5BK4PU6d2UBzuC0AwdILzJtsVowlj0EIStBEk/XVrUrnUggm3MVm7sVnFaOIYKcp1yKKhws+0AJCjA4C0G9pG5XUvtGAsuWJSbg8tSWCxgDVgNfW9iIjMYUrIGsw7RyHOE4YBQboVkjyZMCabGlEY2jkobScxnaTi10m7bjDZ0RtyRawxFH0b6dIrNeuQOZMhSc8jVequW3MqCToJkh6i+NU6e2xIgo667YrRTDHKVx+cz5IEy4hK3XVrSiVhB0HcQ1SqF6Pcp167sxlywUGK0ZQxXiFdSciy0bxKaztgKNBKmn5a3Jji02kLNgVAIXa0ZFL4Uoi1BhtYgsCSxIiIiMxJ+gxZgznnMMbQ0pLVO7YiIiIiIjIhJWQzIJtNKxkTEREREZFJKSETERERERGZJUrIZkAuV0CTV4qIiIiIyGSUkDWYtRbvPYODOSVlIiIiIiIyIc2y2GDGWtKpiEKxSDI4QCoKycchpjRmqM18nA8pBPviPGDGtNuEkt0H7z2F1KK6094DlFJddadA9yYiDhdAzUpmVNqgGC6svb5iNF+MyhTkxVRX/SnQTVSd5ryWUqWtmKodw1WOQzGaMcYioFxfzFdnly0/5xxheep721VZ3ln+VnBgStVp7wfzJXKFGOc8LnEkxuH0/peIiMxRSsgazRhMGJIJU+QG+oljR0JEPKLYLh4wtny67CG2HeMLQxtfKQ8NcdA5YWHoJJiHsVGNHsObTMKOabUrRpPFGFEYOgna8PViMEmMSdqHigQrRnPGKFXKeAwXOi8Xhh5SsEPbaC1/ix0YN9weO4qJwwHOg/FedySIiMicpYSs0VxCQEwYpnDZVpJijtZwkJaUG9HHQf4V+sN3kEpeJ510QzC+DlkhWEjRt9FSeKpuHbJ8ehmZwtN1a1Ll0odUalJ112wvhl0kQQfZwu9qH45iNFGM4Tpk+cwysvln6takymUPnrAmVTG1kCTsIJurcxw2Qy5zkGI0ZYynh+uQBZU6ZEG5DtkbLCnXIYu3lpenKlfKWg8Em2YwX6IQO/ZqSxP5iNAawtAShgFehchERGSOUkI2g2wQQKCP6YmIiIiISG3KFmaYsapHJiIiIiIitSkhExERERERmSVKyERERERERGbJHpWQ3XnnnZxwwgnMnz8fYwyPP/74uD75fJ5PfepTzJ8/n7a2Nk4//XRefbX2h8yHeO+5/PLLWbRoEdlslpUrV/L000+P6rNjxw7Wrl1Le3s7nZ2drFu3jv7+/kYenoiIiIiIyCh71KQeAwMDHHfccfzZn/0Z559/fs0+n/nMZ7jrrrvYsGEDHR0dXHTRRXzkIx/hl7/8Zd3tXnPNNVx33XV897vfZenSpVx22WWsWrWKJ554gkwmA8DatWt55ZVXuOeeeyiVSpx33nlccMEFfP/733+TR2Gq09VX5rcnduWvKm+ANI4UsckSkGXstM9gicniTJrYZPE1cuehuj7OZsGNa66EivA2gzOZ2u02gzdR3XbFaL4YQ7WhnM1Qr5aZMxHGZnE2XbvdZst1q+q2ZxSjaWNkSXx5RsThciDl1z9HSExEXK1PVpmCP/HgHbHzOOeJE0ecOLwvv+GmKe9FRGQuM34P/E/23HPPsXTpUh577DGOOuqo6vKenh4WLFjA97//ff7Tf/pPADz11FO8853vZPPmzfzRH/3RuG1571m8eDGXXnopn/3sZ6vbWbhwIbfccgtnnnkmTz75JIcddhiPPPIIxx57LAAbN27kwx/+MC+++CKLFy+e0n739vZy47e+RRilCYOAJElI4phl7z6cTLZlxE4BlRMShobfjJ38w1f3X2R3snrOyW4ShqnyD8GI2mfeQ1KZej+sJGaZLjCjS3/kBnp5asu9BKmIIAyJSyUu/atP0tPTQ3t7+27YexERkcbYo66QTebRRx+lVCqxcuXK6rJDDz2U/fffv25C9uyzz9Ld3T1qnY6ODpYvX87mzZs588wz2bx5M52dndVkDGDlypVYa3n44Yc57bTTau5PoVCgUChUf+/t7a3UISsRGEiMwRpH1vbTEoyokeMdFLYzGC4lcDtJx92VE5IRSZkrUQi6iGkhU68mlc1STL2NqPR7rMvV7JNPH0zg+kiVXqnZXkotIrHzFEMxyozBkCYfvY1M8fcEbrDmNgYyhxAmfaRLL9dsL6QWEwfzaM1vrdme2BbFUAwyLZXCz8E8wNDDIlLkaImfKS8PF5S/tywBGzFYiCnFjo7WiNClCKwhDAxhYCkO1K6fJiIisqebUwlZd3c3URTR2dk5avnChQvp7q5dBHdo+cKFC+uu093dzb777juqPQxD9t5777rbBbjqqqv44he/OGrZl7/8DxiGUisDeEJb/qpyHihgKRH6HCG1TqyLJOTwNiId1i54mpgSJWuJghKBrd2nZGNSFOtuA1sEGyuGYpRv/wJSYYY4TNFqDWGdl4iShXTgaUnVbrfGUzDQ1lK7PcYQW8Vo+hipodtmS+VtEBNSJPRDr4nF8rfAgLWE1pDYcgIWBha8wxhDITdIoVg7kRQREdnTzdqkHrfddhttbW3VrwceeGC2dmXavvCFL9DT01P9+v3vfz/buyQi0jTiuMRgfy+5XD/pqGXyFURERPZAs3aF7JRTTmH58uXV35csWTLpOl1dXRSLRXbu3DnqKtmrr75KV1dX3XWG+ixatGjUOkOfT+vq6uK1114btV4cx+zYsaPudgHS6TTpdO0PsO8yG4EJy5+bsFGdTikwFkwKTJ0ZHkxQ3k69bSiGYgzx5YkTSLWU24J5QL3ndwS0APU+q9NS7hPUa48q7YqhGNPngbhUJEpnidLZSfuLiIjsiWbtCtm8efM46KCDql/Z7OT/TI855hhSqRSbNm2qLtu6dSsvvPACK1asqLnO0qVL6erqGrVOb28vDz/8cHWdFStWsHPnTh599NFqn3vvvRfn3KikUeStb/iG2+Gf631N1GdX11eM5ojRGHFcJElKDdueiIjI7rRHfYZsx44dvPDCC7z8cvlD41u3lj8c3tXVRVdXFx0dHaxbt45LLrmEvffem/b2dj796U+zYsWKURN6HHrooVx11VWcdtppGGO4+OKLufLKK1m2bFl12vvFixezZs0aAN75zneyevVqzj//fG666SZKpRIXXXQRZ5555pRnWBQRkd0rCEKyrW3kBwfIDfTN9u6IiIhMyx6VkP30pz/lvPPOq/5+5plnArB+/XquuOIKAL7+9a9jreX000+nUCiwatUqbrjhhlHb2bp1Kz09PdXfP/e5zzEwMMAFF1zAzp07Oe6449i4cWO1BhmUP9N20UUXcfzxx1e3f911183g0Y7hHZg9qk63NJ1KBT3vKuUYHHWLnVWr7U233Y1oVwzFGLENX69tvCAIMMbS1t5Jzxvbp7yeiIjInmSPrEM2V5XrkN1EKkoTBGG1Dtkh7z6MzMhbMj3gSjgTgXdYX6i5PWfKn7OYrH0qfRRDMSZr94AxYG26ejPZXDwOxXgLxUi1lb+37AcmxLnyvytrDbmBXp54ZBNhWK5DVioVufSvLlQdMhERmXP2qCtkbwneY7zDlE9vMXgCioQjP65nAN9PyewDBsKkp+amSmF5Kv567c5mSew8AtdXtybVZNtQDMUYUn7GQkCW2M4j5fpGTD8+Wi4obyPtaseYrD02WUqKoRiTbqPy1kBowVhyxaTcHlqSwGIBa8Aag9UdBiIiMkcpIWs077DGERhHbCzGODJhTDY1ouaTc1DaTmI6Sble0qb2CYz1ESXbTrZOe+LzDJhOMv4NAlP7HefE7KMYijGlGN57vPekwoA+m6WFnXVfIAqkSDNAnZJTQJECrXXbYxJ6UAzFmCTGwveM7xM7WjIpfCnEWoMNLEFgSeqU3RMREdnT6S1FERERERGRWaIrZLPBWMgsAtqAgPoPwzwgC+GiOu0poAXChUC9KZ8VQzGmGMPHkBRgryOgEEHLEgjqTE0+EJdvI0vXeU+n4CB20Hpg7fbEw2CiGIrx5mKIiIi8BSkhmw2GclLmTPl7vc8+eAvegK3XbspfxtTfhmIoxlRjuMo6JkW1cHS9/Rh6DttUnfYSGAe2TgFg78AUFUMx3lwMERGRtyC9DTnTNIeliIiIiIjUoYRsBnnvSZJktndDRERERET2ULplscE8hjiGxDsKgzmMgZ39Cfl4/BRgMf0AhNSeHiwmBvop1ml3WBw9FHHYuttQDMWYWgzvHYYUge0l9iFx3hLY2p/1yZcSBoDBVFC3HSDJ125PnKeUOMVQjGnHyA32EZdiPAaXOEo1XmNFRETmAiVkDVYsligWS3jnADDGsO13z2FqfmZi6KSk3n2NE7cPXYEzGILQjuhf5lyCcx5rLbbeZzamvA/1+niS2OHxBEGAMaP3YbJ9nFqMyffTOYdzrjwNth17MjfxPk41RrM8Hsa+QPXieb2hGgpdp93FMc4l2CDABmNeZrwniUt47wnCVJ2/jcljTNbunSOJSxhjCMJU+XN3I/cxiXFJgrUBNqzzUjjVfajXZ8SxhqnU+M/1eUdcqr+PU4oxhf18Kz4e3iXkB/vAGIwxeK/7w0VEZG5SQtZg3rvqSYOxFoMnFRqCGm/4JqQwE1zpcAR4LAHFOtECikmKYq4fvCGbTVfPcYrFEnExJpXOEkXhLsQwxKQIKVE7ATDEYZZCrp+4GJPNRgRB+YQuSRy5XBFjLVG2jdBMN8ZUxiqiWIwpFXKk0yFRVJ4UwHvI5Yo454mybUSBA9w0YzTB4+EdJpUmdoYwMHWT1zh25YK8Qe2Td5c48vkccTFHOtNKOpstb947Bvv7cHFM1NJGFEW7FMN5CMPa7d57isWA4mA/4Glpm4epJESFXI64mCeMsmQy2V2KESd+wrEqlVIUcv2UCjlaWjsIUuWX3aQUMzjQg7EBUaaVVKr2y/FUYjTj4+HimEKuH2MsxpSvkomIiMxFSsgarXKOHIYB3lhwCUGlcOl4IYYEWycJMQR4AgLqfQ7NkgoiosAxMJCjUCjS0pKpXKVLyGYjwnTLLsfwhAQ46r81HhK2tZEf7CefL9HaWp5lLZ8vEYaWTEsbmHCXY0x2HJlsRGgT8vkS1lqiKMXgYB7voa2tBR+kK4nO9GO8tR8PDx5MGOKdIQxs3ZNzT4I1ps7zGhLjyLaGJKkUuVw/QRCQzmbp7+3De0db5954E+xyDOM9YVj79jbvPd4ERFHEQN9O8oMDtLV3UsjlKBZztLS2E0SZBsRwkxyHJZXai9xAL7lcH23hXgDkcn2EqYhsazses4sxmu/xSCjfgWCMxViDcbpCJiIic5MSshlgDBhT75S78YIgoLU1zcBAgd7eQQAymRTpdFT3tL7RjDG0tGQYHMzT358Hyu9it7Rk8MbstrFIpyOgnHzk8+Xbo1pb0wRBUOeaVOPp8RiWaWkFIJfrJ5frxxhD27y9CMKQ0m66ohGGKdrm7UV/3xvs3PEHALLZNjItrZTi3fOIGGNpa++kv3cnfb07hvervRPn2G232+nxEBER2fMoIWugoZMqYyzOJXhvAE8cu5onXAlx5Ra52ichDoPH4+u0exwOiycul+8xBlf57Jq1AXGcNDhGvdsJh2I4giCkVCoAEAQhSeJwJA2MMflxWBvgfbEyDhbvoRTHDY0x+XHM0cfDA5RIvIGk3hW48gQNxhiSOlmu85UrIkmMseW/B4AwjMqf9ysWiZ1vWIx6RsYwxpIk5eeFsZZiodDwGBMdhzUQhCmKxXKCHIQtlIqlhsZopscjcTHOeYxJMM5Uj0mfJRMRkbnGeP33apgXX3yRt73tbbO9GyIiTev3v/89++2332zvhoiIyJQpIWsg5xwvv/wy8+bNm2Amv6nr7e3lbW97G7///e9pb29vwB42B43b9GjcpkfjNj2NHjfvPX19fSxevHiCWUxFRET2PLplsYGstTPyzmx7e7tO9KZB4zY9Grfp0bhNTyPHraOjoyHbERER2Z30NqKIiIiIiMgsUUImIiIiIiIyS5SQ7cHS6TTr168nnU7P9q7MKRq36dG4TY/GbXo0biIiImWa1ENERERERGSW6AqZiIiIiIjILFFCJiIiIiIiMkuUkImIiIiIiMwSJWQiIiIiIiKzRAnZDLrzzjs54YQTmD9/PsYYHn/88XF98vk8n/rUp5g/fz5tbW2cfvrpvPrqqxNu13vP5ZdfzqJFi8hms6xcuZKnn356VJ8dO3awdu1a2tvb6ezsZN26dfT39zfy8Harc889F2PMqK/Vq1dPut7111/PgQceSCaTYfny5fz6178e1T6d8Z8rJjv2sTZs2MChhx5KJpPh8MMP5+677x7VPpXn3Vx3xRVXjHueHXrooROu04zjdv/993PyySezePFijDH8+Mc/HtU+3WNu5r9XERFpXkrIZtDAwADHHXccV199dd0+n/nMZ/jZz37Ghg0b+MUvfsHLL7/MRz7ykQm3e80113Dddddx00038fDDD9Pa2sqqVavI5/PVPmvXruW3v/0t99xzDz//+c+5//77ueCCCxp2bLNh9erVvPLKK9Wv22+/fcL+P/jBD7jkkktYv349v/nNbzjyyCNZtWoVr732WrXPdMZ/LpjKsY/0q1/9irPOOot169bx2GOPsWbNGtasWcO//du/VftM5Xn3VvCud71r1PPswQcfrNu3WcdtYGCAI488kuuvv75m+3SOuZn/XkVEpMl5mXHPPvusB/xjjz02avnOnTt9KpXyGzZsqC578sknPeA3b95cc1vOOd/V1eW/8pWvjNpOOp32t99+u/fe+yeeeMID/pFHHqn2+ed//mdvjPEvvfRSA49s9/nYxz7mTz311De1zvve9z7/qU99qvp7kiR+8eLF/qqrrvLeT2/854rJjn2sP/uzP/MnnXTSqGXLly/3n/jEJ7z3U3vevRWsX7/eH3nkkVPur3HzHvD/63/9r+rv0z3mZv57FRGR5qYrZLPo0UcfpVQqsXLlyuqyQw89lP3335/NmzfXXOfZZ5+lu7t71DodHR0sX768us7mzZvp7Ozk2GOPrfZZuXIl1loefvjhGTqamXffffex7777csghh3DhhReyffv2un2LxSKPPvroqHGy1rJy5crqOE1n/OeCqRz7WJs3bx7VH2DVqlXV/lN53r1VPP300yxevJi3v/3trF27lhdeeKFuX43beNM55mb+exUREVFCNou6u7uJoojOzs5RyxcuXEh3d3fddYb61Funu7ubfffdd1R7GIbsvffedbe7p1u9ejW33normzZt4uqrr+YXv/gFJ554IkmS1Oz/+uuvkyTJpOP0Zsd/LpjKsY/V3d096VgNLZvqNuei5cuXc8stt7Bx40ZuvPFGnn32WT7wgQ/Q19dXs7/GbbzpHHMz/72KiIgoIWuQ2267jba2turXAw88MNu7NGfVGsszzzyTU045hcMPP5w1a9bw85//nEceeYT77rtvtndX3kJOPPFEPvrRj3LEEUewatUq7r77bnbu3MkPf/jD2d41EREReYtSQtYgp5xyCo8//nj1a+TtgvV0dXVRLBbZuXPnqOWvvvoqXV1dddcZ6lNvna6urnGTN8RxzI4dO+pud08ylbF8+9vfzj777MMzzzxTcxv77LMPQRBMOk5vdvzngqkc+1hdXV2TjtXQsqlu862gs7OTgw8+uO7zTOM23nSOuZn/XkVERJSQNci8efM46KCDql/ZbHbSdY455hhSqRSbNm2qLtu6dSsvvPACK1asqLnO0qVL6erqGrVOb28vDz/8cHWdFStWsHPnTh599NFqn3vvvRfnHMuXL5/uIe42UxnLF198ke3bt7No0aKa24iiiGOOOWbUODnn2LRpU3WcpjP+c8FUjn2sFStWjOoPcM8991T7T+V591bU39/Ptm3b6j7PNG7jTeeYm/nvVURERLMszqDt27f7xx57zN91110e8HfccYd/7LHH/CuvvFLt88lPftLvv//+/t577/VbtmzxK1as8CtWrBi1nUMOOcTfeeed1d+//OUv+87OTv+Tn/zE/+u//qs/9dRT/dKlS30ul6v2Wb16tT/66KP9ww8/7B988EG/bNkyf9ZZZ838Qc+Avr4+/9nPftZv3rzZP/vss/7//t//69/znvf4ZcuW+Xw+X+33oQ99yH/jG9+o/n7HHXf4dDrtb7nlFv/EE0/4Cy64wHd2dvru7u5qn6mM/1w02bGfffbZ/r/8l/9S7f/LX/7Sh2Hov/rVr/onn3zSr1+/3qdSKf///t//q/aZyvNurrv00kv9fffd55999ln/y1/+0q9cudLvs88+/rXXXvPea9yG9PX1+ccee8w/9thjHvBf+9rX/GOPPeaff/557/3Ujll/ryIiImVKyGbQzTff7IFxX+vXr6/2yeVy/j//5//s99prL9/S0uJPO+20UQmb9+VppW+++ebq7845f9lll/mFCxf6dDrtjz/+eL9169ZR62zfvt2fddZZvq2tzbe3t/vzzjvP9/X1zeThzpjBwUF/wgkn+AULFvhUKuUPOOAAf/755486UfPe+wMOOGDU2Hrv/Te+8Q2///77+yiK/Pve9z7/0EMPjWqfyvjPVRMd+5/8yZ/4j33sY6P6//CHP/QHH3ywj6LIv+td7/J33XXXqPapPO/mujPOOMMvWrTIR1HklyxZ4s844wz/zDPPVNs1bmX/8i//UvO1bWhspnLM+nsVEREpM957PyuX5kRERERERJqcPkMmIiIiIiIyS5SQiYiIiIiIzBIlZCIiIiIiIrNECZmIiIiIiMgsUUImIiIiIiIyS5SQiYiIiIiIzBIlZCIiIiIiIrNECZmIiIiIiMgsUUIm0kS+853vcMIJJ8x4nI0bN3LUUUfhnJvxWCIiIiJzmRIykSaRz+e57LLLWL9+/YzHWr16NalUittuu23GY4mIiIjMZUrIRJrEj370I9rb23n/+9+/W+Kde+65XHfddbslloiIiMhcpYRMZI75wx/+QFdXF//wD/9QXfarX/2KKIrYtGlT3fXuuOMOTj755FHLPvjBD3LxxRePWrZmzRrOPffc6u8HHnggV155Jeeccw5tbW0ccMAB/PSnP+UPf/gDp556Km1tbRxxxBFs2bJl1HZOPvlktmzZwrZt26Z/sCIiIiJvcUrIROaYBQsW8E//9E9cccUVbNmyhb6+Ps4++2wuuugijj/++LrrPfjggxx77LHTivn1r3+d97///Tz22GOcdNJJnH322Zxzzjn8xV/8Bb/5zW94xzvewTnnnIP3vrrO/vvvz8KFC3nggQemFVNERESkGSghE5mDPvzhD3P++eezdu1aPvnJT9La2spVV11Vt//OnTvp6elh8eLF0473iU98gmXLlnH55ZfT29vLe9/7Xj760Y9y8MEH8/nPf54nn3ySV199ddR6ixcv5vnnn59WTBEREZFmoIRMZI766le/ShzHbNiwgdtuu410Ol23by6XAyCTyUwr1hFHHFH9eeHChQAcfvjh45a99tpro9bLZrMMDg5OK6aIiIhIM1BCJjJHbdu2jZdffhnnHM8999yEfefPn48xhjfeeGPS7SZJMm5ZKpWq/myMqbts7DT3O3bsYMGCBZPGFBEREWlWSshE5qBischf/MVfcMYZZ/ClL32Jv/zLvxx3dWqkKIo47LDDeOKJJ8a1jb3N8N///d8bso/5fJ5t27Zx9NFHN2R7IiIiIm9FSshE5qD/+l//Kz09PVx33XV8/vOf5+CDD+bjH//4hOusWrWKBx98cNzyn/zkJ9x5551s27aNv//7v+eJJ57g+eef56WXXtqlfXzooYdIp9OsWLFil7YjIiIi8lamhExkjrnvvvu49tpr+d73vkd7ezvWWr73ve/xwAMPcOONN9Zdb926ddx999309PSMWn7SSSdxzTXXcNhhh3H//fdzww038Otf/5rvfe97u7Sft99+O2vXrqWlpWWXtiMiIiLyVmb8yHmqReQt7aMf/Sjvec97+MIXvgCU65AdddRRXHvttQ2N8/rrr3PIIYewZcsWli5d2tBti4iIiLyV6AqZSBP5yle+Qltb24zHee6557jhhhuUjImIiIhMQlfIRJrYTF0hExEREZGpUUImIiIiIiIyS3TLooiIiIiIyCxRQiYiIiIiIjJLlJCJiIiIiIjMEiVkIiIiIiIis0QJmYiIiIiIyCxRQiYiIiIiIjJLlJCJiIiIiIjMEiVkIiIiIiIis+T/AxfL+XXlMosiAAAAAElFTkSuQmCC", "text/plain": ["<Figure size 1000x500 with 2 Axes>"]}, "metadata": {}, "output_type": "display_data"}], "source": ["fig, ax = plt.subplots(1, 2, figsize=(10, 5))\n", "sim.plot(z=sim.structures[2].geometry.center[2], ax=ax[0])\n", "sim.plot(x=0, ax=ax[1])\n", "plt.show()"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Finally, we will define a function for calculating the LEE"]}, {"cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [], "source": ["def calculateLEE(sim_data, monitor_name=\"outside_flux_monitor\"):\n", "    fluxDipole = sim_data[\"norm_flux_monitor\"].flux\n", "    fluxOutside = sim_data[monitor_name].flux\n", "\n", "    return np.mean(fluxOutside / fluxDipole)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## LEE as a Function of Length and Reflector Absorption\n", "\n", "First, we will investigate the relation between the LEE, the device size, and the reflector absorption coefficient. We will create a [Batch](https://docs.flexcompute.com/projects/tidy3d/en/latest/api/_autosummary/tidy3d.web.api.container.Batch.html) object to run the simulations in parallel. Before running, we can also estimate the maximum cost of the batch."]}, {"cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [{"data": {"text/html": ["<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"color: #7fbfbf; text-decoration-color: #7fbfbf\">16:53:31 -03 </span>Maximum FlexCredit cost: <span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">354.029</span> for the whole batch.              \n", "</pre>\n"], "text/plain": ["\u001b[2;36m16:53:31 -03\u001b[0m\u001b[2;36m \u001b[0mMaximum FlexCredit cost: \u001b[1;36m354.029\u001b[0m for the whole batch.              \n"]}, "metadata": {}, "output_type": "display_data"}], "source": ["sizes = [1, 5, 15, 30]\n", "abs = [0, 10, 30, 50]\n", "sims_varying_abs = {}\n", "for l in sizes:\n", "    for a in abs:\n", "        sims_varying_abs[str((l, a))] = getSim(size=l, GANExtinctionCoef=a)\n", "\n", "\n", "batch_varying_abs = web.Batch(simulations=sims_varying_abs, folder_name=\"LedLEECalculation\")\n", "batch_varying_abs.estimate_cost();"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Next, we run the batch."]}, {"cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [{"data": {"application/vnd.jupyter.widget-view+json": {"model_id": "d929b748f3414665bcd4199adc15f2cf", "version_major": 2, "version_minor": 0}, "text/plain": ["Output()"]}, "metadata": {}, "output_type": "display_data"}, {"data": {"text/html": ["<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"></pre>\n"], "text/plain": []}, "metadata": {}, "output_type": "display_data"}], "source": ["if RUN:\n", "    batch_data_varying_abs = batch_varying_abs.run(path_dir=\"varying_abs\")"]}, {"cell_type": "markdown", "metadata": {}, "source": ["We can now verify the effective cost of the batch. Since some simulations ended before the stipulated runtime, the actual cost is smaller than the estimated maximum."]}, {"cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [{"data": {"text/html": ["<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"color: #7fbfbf; text-decoration-color: #7fbfbf\">16:53:44 -03 </span>Total billed flex credit cost: <span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">232.624</span>.                            \n", "</pre>\n"], "text/plain": ["\u001b[2;36m16:53:44 -03\u001b[0m\u001b[2;36m \u001b[0mTotal billed flex credit cost: \u001b[1;36m232.624\u001b[0m.                            \n"]}, "metadata": {}, "output_type": "display_data"}], "source": ["batch_varying_abs.real_cost();"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Post-processing the data."]}, {"cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [], "source": ["import pandas as pd\n", "\n", "df = pd.DataFrame()\n", "\n", "for k in batch_data_varying_abs.keys():\n", "    tup = eval(k)\n", "    abs = float(tup[1])\n", "    l = float(tup[0])\n", "\n", "    sim_data = batch_data_varying_abs[k]\n", "    lee = calculateLEE(sim_data)\n", "    df.loc[abs, l] = lee.values"]}, {"cell_type": "markdown", "metadata": {}, "source": ["As we can see, the LEE decreases with both the LED cross-section size and the reflector absorption."]}, {"cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [{"data": {"image/png": "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", "text/plain": ["<Figure size 640x480 with 1 Axes>"]}, "metadata": {}, "output_type": "display_data"}], "source": ["fig, ax = plt.subplots()\n", "\n", "ax.set_xlabel(\"Reflector absorption (cm$^{-1}$)\")\n", "ax.set_ylabel(\"LEE\")\n", "\n", "df.T.plot(ax=ax, marker=\"o\")\n", "ax.set_ylim(0.7, 1)\n", "plt.show()"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## LEE as a Function of p-GaN Thickness"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Next, we will investigate the influence of the p-GaN layer thickness for LEDs of sizes 5, 10 and 20 \u00b5m"]}, {"cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [], "source": ["pGanHeights = np.linspace(0.060, 0.140, 9)\n", "\n", "sims_varyingpGan_L5 = {}\n", "sims_varyingpGan_L10 = {}\n", "sims_varyingpGan_L20 = {}\n", "\n", "for p in pGanHeights:\n", "    sim_L5 = getSim(pGanHeight=p, size=5)\n", "    sims_varyingpGan_L5[str(p)] = sim_L5\n", "\n", "    sim_L10 = getSim(pGanHeight=p, size=10)\n", "    sims_varyingpGan_L10[str(p)] = sim_L10\n", "\n", "    sim_L20 = getSim(pGanHeight=p, size=20)\n", "    sims_varyingpGan_L20[str(p)] = sim_L20\n", "\n", "\n", "batch_varyingpGan_L5 = web.Batch(simulations=sims_varyingpGan_L5, folder_name=\"LEECalculation\")\n", "batch_varyingpGan_L10 = web.Batch(simulations=sims_varyingpGan_L10, folder_name=\"LEECalculation\")\n", "batch_varyingpGan_L20 = web.Batch(simulations=sims_varyingpGan_L20, folder_name=\"LEECalculation\")"]}, {"cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [{"data": {"application/vnd.jupyter.widget-view+json": {"model_id": "d66a6650aa264eb9a4ae4248bf06ee25", "version_major": 2, "version_minor": 0}, "text/plain": ["Output()"]}, "metadata": {}, "output_type": "display_data"}, {"data": {"text/html": ["<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"></pre>\n"], "text/plain": []}, "metadata": {}, "output_type": "display_data"}, {"data": {"application/vnd.jupyter.widget-view+json": {"model_id": "023d148978494342a58b7d27a836fa67", "version_major": 2, "version_minor": 0}, "text/plain": ["Output()"]}, "metadata": {}, "output_type": "display_data"}, {"data": {"text/html": ["<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"></pre>\n"], "text/plain": []}, "metadata": {}, "output_type": "display_data"}, {"data": {"application/vnd.jupyter.widget-view+json": {"model_id": "c676d5e5575340c0926a36fc672cfe62", "version_major": 2, "version_minor": 0}, "text/plain": ["Output()"]}, "metadata": {}, "output_type": "display_data"}, {"data": {"text/html": ["<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"></pre>\n"], "text/plain": []}, "metadata": {}, "output_type": "display_data"}], "source": ["if RUN:\n", "    batch_data_varyingpGan_L5 = batch_varyingpGan_L5.run(path_dir=\"varyingpGan_L5\")\n", "    batch_data_varyingpGan_L10 = batch_varyingpGan_L10.run(path_dir=\"varyingpGan_L10\")\n", "    batch_data_varyingpGan_L20 = batch_varyingpGan_L20.run(path_dir=\"varyingpGan_L20\")"]}, {"cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [], "source": ["Lee_varyingpGan_L5 = []\n", "Lee_varyingpGan_L10 = []\n", "Lee_varyingpGan_L20 = []\n", "\n", "for p in pGanHeights:\n", "    sim_data_L5 = batch_data_varyingpGan_L5[str(p)]\n", "    Lee_varyingpGan_L5.append(calculateLEE(sim_data_L5))\n", "\n", "    sim_data_l10 = batch_data_varyingpGan_L10[str(p)]\n", "    Lee_varyingpGan_L10.append(calculateLEE(sim_data_l10))\n", "\n", "    sim_data_l20 = batch_data_varyingpGan_L20[str(p)]\n", "    Lee_varyingpGan_L20.append(calculateLEE(sim_data_l20))"]}, {"cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [{"data": {"image/png": "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", "text/plain": ["<Figure size 640x480 with 1 Axes>"]}, "metadata": {}, "output_type": "display_data"}], "source": ["fig, ax = plt.subplots()\n", "ax.plot(pGanHeights, Lee_varyingpGan_L5, \"o-\", label=\"L= 5 \u00b5m\")\n", "ax.plot(pGanHeights, Lee_varyingpGan_L10, \"o-\", label=\"L= 10 \u00b5m\")\n", "ax.plot(pGanHeights, Lee_varyingpGan_L20, \"o-\", label=\"L= 20 \u00b5m\")\n", "ax.set_xlabel(\"pGan Heights\")\n", "ax.set_ylabel(\"LEE\")\n", "ax.legend()\n", "\n", "\n", "ax.set_ylim(0.5, 1)\n", "\n", "ax.set_xlabel(\"p-GaN Thickness (\u00b5m)\")\n", "ax.set_ylabel(\"LEE\")\n", "plt.show()"]}, {"cell_type": "markdown", "metadata": {}, "source": ["We can also decompose the total LEE into its lateral and vertical components. The results match well the ones presented on the Fig. 6 of the reference [paper](https://ieeexplore.ieee.org/document/9019847)"]}, {"cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [], "source": ["Lee_varyingpGan_L20_lateral = []\n", "Lee_varyingpGan_L20 = []\n", "for p in pGanHeights:\n", "    sim_data_l20 = batch_data_varyingpGan_L20[str(p)]\n", "    Lee_varyingpGan_L20.append(calculateLEE(sim_data_l20))\n", "    Lee_varyingpGan_L20_lateral.append(\n", "        calculateLEE(sim_data_l20, monitor_name=\"lateral_flux_monitor\")\n", "    )\n", "\n", "Lee_varyingpGan_L20_top = np.array(Lee_varyingpGan_L20) - np.array(Lee_varyingpGan_L20_lateral)"]}, {"cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [{"data": {"image/png": "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", "text/plain": ["<Figure size 640x480 with 1 Axes>"]}, "metadata": {}, "output_type": "display_data"}], "source": ["fig, ax = plt.subplots()\n", "\n", "ax.plot(pGanHeights, Lee_varyingpGan_L20, \"o-\", label=\"Total LEE\")\n", "ax.plot(pGanHeights, Lee_varyingpGan_L20_top, \"o-\", label=\"Top LEE\")\n", "ax.plot(pGanHeights, Lee_varyingpGan_L20_lateral, \"o-\", label=\"Lateral LEE\")\n", "\n", "ax.set_xlabel(\"p-GaN Thickness (\u00b5m)\")\n", "ax.set_ylabel(\"LEE\")\n", "\n", "ax.legend()\n", "plt.title(\"LEE vs p-GaN Thickness\")\n", "ax.set_ylim(0, 0.9)\n", "plt.show()"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## Relative Error for Single Dipole LEE Calculation"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Now, we will run batch simulations with distributed dipoles to calculate the average LEE value and compare the results with those from a single dipole at the center, to estimate how accurate the single dipole approximation is."]}, {"cell_type": "markdown", "metadata": {}, "source": ["We will define a function to calculate the mean LEE by exploiting the rotational and mirror symmetries of the structure. The `lee_dict` is a dictionary mapping each dipole position to its corresponding LEE. The function ensures the correct contributions are included (e.g., a dipole at (1,1) has the same LEE contribution as (-1,1), (-1,-1), and (1,-1))."]}, {"cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [], "source": ["def averageLee(lee_dict):\n", "    \"\"\"Compute the average LEE using rotational and mirror symmetries.\n", "\n", "    Parameters\n", "    ----------\n", "    lee_dict : dict\n", "        Dictionary mapping dipole position keys (e.g., 'dipole_x_y')\n", "        to their corresponding LEE values.\n", "\n", "    Returns\n", "    -------\n", "    np.ndarray\n", "        Symmetry-averaged LEE.\n", "    \"\"\"\n", "\n", "    avg_lee = 0\n", "    count = 0\n", "\n", "    for key, values in lee_dict.items():\n", "        posX, posY = key.split(\"_\")[1:3]\n", "        posX, posY = float(posX), float(posY)\n", "\n", "        # Case 1: source at center -> counts once\n", "        if (posX == 0) and (posY == 0):\n", "            avg_lee += np.array(values)\n", "            count += 1\n", "\n", "        # Case 2: source on x- or y-axis -> symmetric copy doubles contribution\n", "        elif posY == 0:\n", "            avg_lee += 2 * np.array(values)\n", "            count += 2\n", "\n", "        elif posX == 0:\n", "            avg_lee += 2 * np.array(values)\n", "            count += 2\n", "\n", "        # Case 3: source off axes -> four symmetric positions\n", "        else:\n", "            avg_lee += 4 * np.array(values)\n", "            count += 4\n", "\n", "    return avg_lee / count\n", "\n", "\n", "def calculateLees(Total_lee, batch_data):\n", "    \"\"\"Calculate the center LEE and the symmetry-averaged LEE.\n", "\n", "    Parameters\n", "    ----------\n", "    Total_lee : list\n", "        List of LEE values for all dipole positions.\n", "    batch_data : dict\n", "        Dictionary mapping position keys to dipole metadata.\n", "\n", "    Returns\n", "    -------\n", "    tuple\n", "        - center_lee : float\n", "            Mean LEE at the center dipole.\n", "        - avgLee : np.ndarray\n", "            Symmetry-averaged LEE across all dipoles.\n", "    \"\"\"\n", "\n", "    center_lee = Total_lee[0]\n", "\n", "    lee_dict = {key: Total_lee[i] for i, key in enumerate(batch_data.keys())}\n", "    avgLee = averageLee(lee_dict)\n", "\n", "    return float(np.mean(center_lee)), avgLee"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Next, we define a function to create a batch by placing the dipoles in a grid around the LED. Since we can use mirror and rotational symmetries, the dipoles only need to be placed in a quarter of the MQW area."]}, {"cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [], "source": ["def createSingleDipoleBatch(\n", "    simBase,\n", "    source_time,\n", "    dipoles_per_dimension=5,\n", "    xSpan=(0, 1),\n", "    polarization=\"inplane\",  # inplane or outofplane\n", "    symmetry=(1, 1, 0),\n", "):\n", "    \"\"\"Create a batch of simulations with dipoles placed across the LED structure.\n", "\n", "    Parameters\n", "    ----------\n", "    simBase : td.Simulation\n", "        Base LED simulation.\n", "    source_time : td.SourceTime\n", "        Time profile of the dipole source.\n", "    dipoles_per_dimension : int, optional\n", "        Number of dipole positions sampled per dimension (default=5).\n", "    xSpan : tuple of float, optional\n", "        Range of x positions for dipoles (\u00b5m), default is (0, 1).\n", "    polarization : str, optional\n", "        Polarization of dipoles: \"inplane\" (Ex) or \"outofplane\" (Ez).\n", "    symmetry : tuple, optional\n", "        Symmetry settings for the simulation (default=(1,1,0)).\n", "\n", "    Returns\n", "    -------\n", "    dict\n", "        Dictionary mapping keys (format: 'pol_x_y_index') to Tidy3D Simulation objects.\n", "    \"\"\"\n", "\n", "    sims = {}\n", "\n", "    x = np.linspace(xSpan[0], xSpan[1], dipoles_per_dimension)\n", "    for i in range(dipoles_per_dimension):\n", "        y = x[i]\n", "\n", "        if polarization == \"outofplane\":\n", "            pol = \"Ez\"\n", "            xList = x[i:]\n", "        elif polarization == \"inplane\":\n", "            pol = \"Ex\"\n", "            xList = x\n", "        else:\n", "            pol = polarization\n", "            xList = x[i:] if polarization == \"Ez\" else x\n", "\n", "        for pos in xList:\n", "            zPosition = simBase.sources[0].center[2]\n", "            dipole = td.PointDipole(\n", "                center=(pos, y, zPosition),\n", "                polarization=pol,\n", "                source_time=source_time,\n", "                name=f\"dipole_{x}_{y}_{polarization}\",\n", "            )\n", "\n", "            sim = simBase.updated_copy(\n", "                sources=[dipole], symmetry=parseSymmetry(symmetry, pol, pos, y)\n", "            )\n", "\n", "            sims[f\"{pol}_{pos}_{y}_{i}\"] = sim\n", "\n", "    print(\"Number of Simulations:\", len(sims))\n", "\n", "    return sims"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Now we can create the batch simulation for different LED sizes."]}, {"cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [{"name": "stdout", "output_type": "stream", "text": ["Number of Simulations: 16\n", "Number of Simulations: 16\n", "Number of Simulations: 16\n", "Number of Simulations: 9\n", "Number of Simulations: 9\n", "Number of Simulations: 9\n"]}], "source": ["simBase = getSim(size=1)\n", "sims_l1 = createSingleDipoleBatch(\n", "    simBase,\n", "    source_time=source_time,\n", "    dipoles_per_dimension=4,\n", "    xSpan=(0, 0.4),\n", "    polarization=\"inplane\",\n", "    symmetry=(1, 1, 0),\n", ")\n", "batch_l1 = web.Batch(simulations=sims_l1, folder_name=\"LED\")\n", "\n", "simBase = getSim(size=2.5)\n", "sims_l2d5 = createSingleDipoleBatch(\n", "    simBase,\n", "    source_time=source_time,\n", "    dipoles_per_dimension=4,\n", "    xSpan=(0, 0.9 * 2.5 / 2),\n", "    polarization=\"inplane\",\n", "    symmetry=(1, 1, 0),\n", ")\n", "batch_l2d5 = web.Batch(simulations=sims_l2d5, folder_name=\"LED\")\n", "\n", "simBase = getSim(size=3)\n", "sims_l3 = createSingleDipoleBatch(\n", "    simBase,\n", "    source_time=source_time,\n", "    dipoles_per_dimension=4,\n", "    xSpan=(0, 0.9 * 3 / 2),\n", "    polarization=\"inplane\",\n", "    symmetry=(1, 1, 0),\n", ")\n", "batch_l3 = web.Batch(simulations=sims_l3, folder_name=\"LED\")\n", "\n", "\n", "simBase = getSim(size=5)\n", "sims_l5 = createSingleDipoleBatch(\n", "    simBase,\n", "    source_time=source_time,\n", "    dipoles_per_dimension=3,\n", "    xSpan=(0, 2),\n", "    polarization=\"inplane\",\n", "    symmetry=(1, 1, 0),\n", ")\n", "\n", "batch_l5 = web.Batch(simulations=sims_l5, folder_name=\"LED\")\n", "\n", "\n", "simBase = getSim(size=10)\n", "sims_l10 = createSingleDipoleBatch(\n", "    simBase,\n", "    source_time=source_time,\n", "    dipoles_per_dimension=3,\n", "    xSpan=(0, 0.9 * 10 / 2),\n", "    polarization=\"inplane\",\n", "    symmetry=(1, 1, 0),\n", ")\n", "batch_l10 = web.Batch(simulations=sims_l10, folder_name=\"LED\")\n", "\n", "simBase = getSim(size=20)\n", "sims_l20 = createSingleDipoleBatch(\n", "    simBase,\n", "    source_time=source_time,\n", "    dipoles_per_dimension=3,\n", "    xSpan=(0, 0.9 * 20 / 2),\n", "    polarization=\"inplane\",\n", "    symmetry=(1, 1, 0),\n", ")\n", "batch_l20 = web.Batch(simulations=sims_l20, folder_name=\"LED\")"]}, {"cell_type": "markdown", "metadata": {}, "source": ["We can define a function to plot all the sources of a given batch together for inspection."]}, {"cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [{"data": {"image/png": "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", "text/plain": ["<Figure size 640x480 with 1 Axes>"]}, "metadata": {}, "output_type": "display_data"}], "source": ["def plot_batch(batch, **args):\n", "    \"\"\"Function for visualize all sources for a given batch\"\"\"\n", "    fig, ax = plt.subplots()\n", "    sims = list(batch.simulations.values())\n", "    z = sims[0].sources[0].center[2]\n", "    sims[0].updated_copy(symmetry=[0, 0, 0]).plot(z=z, ax=ax, monitor_alpha=0)\n", "    for sim in sims[1:]:\n", "        sim.updated_copy(symmetry=[0, 0, 0]).plot(\n", "            z=z, ax=ax, monitor_alpha=0, fill_structures=False\n", "        )\n", "    plt.show()\n", "\n", "\n", "plot_batch(batch_l1)"]}, {"cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [{"data": {"application/vnd.jupyter.widget-view+json": {"model_id": "eb338d70210a4ca5a26e2f6a399fdba1", "version_major": 2, "version_minor": 0}, "text/plain": ["Output()"]}, "metadata": {}, "output_type": "display_data"}, {"data": {"text/html": ["<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"></pre>\n"], "text/plain": []}, "metadata": {}, "output_type": "display_data"}, {"data": {"application/vnd.jupyter.widget-view+json": {"model_id": "5fe903e87fc14d33a8f95093c6e66660", "version_major": 2, "version_minor": 0}, "text/plain": ["Output()"]}, "metadata": {}, "output_type": "display_data"}, {"data": {"text/html": ["<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"></pre>\n"], "text/plain": []}, "metadata": {}, "output_type": "display_data"}, {"data": {"application/vnd.jupyter.widget-view+json": {"model_id": "a91232a8e2724aff824ef3124a05c83c", "version_major": 2, "version_minor": 0}, "text/plain": ["Output()"]}, "metadata": {}, "output_type": "display_data"}, {"data": {"text/html": ["<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"></pre>\n"], "text/plain": []}, "metadata": {}, "output_type": "display_data"}, {"data": {"application/vnd.jupyter.widget-view+json": {"model_id": "ebf68baa3bcc433dbb2d6c57cb62860a", "version_major": 2, "version_minor": 0}, "text/plain": ["Output()"]}, "metadata": {}, "output_type": "display_data"}, {"data": {"text/html": ["<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"></pre>\n"], "text/plain": []}, "metadata": {}, "output_type": "display_data"}, {"data": {"application/vnd.jupyter.widget-view+json": {"model_id": "313142e975cb4e2083570a7ff0ff9a2b", "version_major": 2, "version_minor": 0}, "text/plain": ["Output()"]}, "metadata": {}, "output_type": "display_data"}, {"data": {"text/html": ["<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"></pre>\n"], "text/plain": []}, "metadata": {}, "output_type": "display_data"}, {"data": {"application/vnd.jupyter.widget-view+json": {"model_id": "e70e1bba4e474850aa4cf4ea67f20f65", "version_major": 2, "version_minor": 0}, "text/plain": ["Output()"]}, "metadata": {}, "output_type": "display_data"}, {"data": {"text/html": ["<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"></pre>\n"], "text/plain": []}, "metadata": {}, "output_type": "display_data"}], "source": ["if RUN:\n", "    batch_l1_data = batch_l1.run(path_dir=\"MultipleDipolesL1Ex\")\n", "    batch_l2d5_data = batch_l2d5.run(path_dir=\"MultipleDipolesL2d5Ex\")\n", "    batch_l5_data = batch_l5.run(path_dir=\"MultipleDipolesL5Ex\")\n", "    batch_l10_data = batch_l10.run(path_dir=\"MultipleDipolesL10Ex\")\n", "    batch_l20_data = batch_l20.run(path_dir=\"MultipleDipolesL20Ex\")"]}, {"cell_type": "code", "execution_count": 26, "metadata": {}, "outputs": [], "source": ["Total_lee1 = [calculateLEE(sim_data) for sim_data in batch_l1_data.values()]\n", "Total_lee2d5 = [calculateLEE(sim_data) for sim_data in batch_l2d5_data.values()]\n", "Total_lee5 = [calculateLEE(sim_data) for sim_data in batch_l5_data.values()]\n", "Total_lee10 = [calculateLEE(sim_data) for sim_data in batch_l10_data.values()]\n", "Total_lee20 = [calculateLEE(sim_data) for sim_data in batch_l20_data.values()]"]}, {"cell_type": "markdown", "metadata": {}, "source": ["As we can see, the error in the single dipole approximation tends to decrease with size. Hence, using only a dipole at the center can greatly reduce computational cost while still providing accurate results."]}, {"cell_type": "code", "execution_count": 27, "metadata": {}, "outputs": [{"data": {"image/png": "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", "text/plain": ["<Figure size 640x480 with 1 Axes>"]}, "metadata": {}, "output_type": "display_data"}], "source": ["fig, ax = plt.subplots()\n", "\n", "size = [1, 2.5, 5, 10, 20]\n", "lee0 = []\n", "avgLee = []\n", "\n", "center, avg = calculateLees(Total_lee1, batch_l1_data)\n", "lee0.append(center)\n", "avgLee.append(avg)\n", "\n", "center, avg = calculateLees(Total_lee2d5, batch_l2d5_data)\n", "lee0.append(center)\n", "avgLee.append(avg)\n", "\n", "\n", "center, avg = calculateLees(Total_lee5, batch_l5_data)\n", "lee0.append(center)\n", "avgLee.append(avg)\n", "\n", "center, avg = calculateLees(Total_lee10, batch_l10_data)\n", "lee0.append(center)\n", "avgLee.append(avg)\n", "\n", "center, avg = calculateLees(Total_lee20, batch_l20_data)\n", "lee0.append(center)\n", "avgLee.append(avg)\n", "\n", "ax.plot(size, lee0, \"o-\", color=\"blue\", label=\"Single Dipole\")\n", "ax.plot(size, avgLee, \"o-\", color=\"red\", label=\"Average Lee\")\n", "\n", "ax.set_ylim(0.7, 1)\n", "ax.set_xlabel(\"LED Size (\u00b5m)\")\n", "ax.set_ylabel(\"LEE\")\n", "plt.legend()\n", "plt.show()"]}], "metadata": {"applications": ["Nanophotonics"], "description": "This notebook demonstrates how to model light extraction efficiency in micro-LEDs using Tidy3D.", "feature_image": "./img/squareLED.png", "features": ["Parameter sweep"], "kernelspec": {"display_name": "td210rc1", "language": "python", "name": "python3"}, "keywords": "micro-LEDs, light extraction efficiency, LED, LEE, 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.11.13"}, "title": "How to model led lee calculation using Tidy3D | Flexcompute"}, "nbformat": 4, "nbformat_minor": 2}