{"cells": [{"cell_type": "markdown", "metadata": {}, "source": ["# Wideband beam-steerable reflectarray with polarization-rotating unit cells\n", "\n", "This example demonstrates how to design and optimize a wideband reflectarray based on polarization-rotating unit cells (PRUCs) using Tidy3D. The design is based on the work by [Luyen *et al*.](https://ieeexplore.ieee.org/document/8664570), where a reflectarray design is demonstrated with wide bandwidth and beam-steering capabilities using minimum-switch topology.\n", "\n", "The design consists of:\n", "\n", "* A polarization-rotating unit cell (PRUC) with two configurations (0\u00b0 and 180\u00b0 rotation)\n", "* Arrow-shaped metallic patches on the top layer\n", "* Ground plane with circular holes in the middle layer  \n", "* Bottom layer with diagonal connecting strips, which enable the switching behavior\n", "* Rogers RO4003C substrate layers bonded by Rogers RO4450B prepregs\n", "\n", "<img src=\"img/reflectarray.png\" width=\"400\" alt=\"Rendering of a reflectarray constructed with the polarization-rotating unit cells\">\n", "\n", "Key features:\n", "\n", "* Full-wave electromagnetic simulation of the unit cell using periodic boundary conditions\n", "* Optimization of geometric parameters using Bayesian optimization\n", "* Analysis of reflection coefficients and fractional bandwidth\n", "* Cell designs achieving over 58% fractional bandwidth for cross-polarized reflection\n", "\n", "This notebook shows how to:\n", "\n", "1. Create parametric geometry for the PRUC design\n", "2. Set up periodic boundary conditions and plane wave excitation\n", "3. Configure optimization of key geometric parameters\n", "4. Analyze reflection coefficients and bandwidth performance\n", "\n", "Let's start by importing the required packages and defining some basic parameters."]}, {"cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": ["# standard python imports\n", "from copy import copy\n", "from typing import Union\n", "\n", "import matplotlib.pyplot as plt\n", "\n", "# additional imports to aid in geometry processing and post-processing of results\n", "import numpy as np\n", "import pandas as pd\n", "import shapely as shapely\n", "\n", "# tidy3d imports\n", "import tidy3d as td\n", "\n", "# design plugin for performing the Bayesian optimization of the PRUC\n", "import tidy3d.plugins.design as tdd\n", "import xarray as xr\n", "\n", "# dispersion plugin for fitting loss tangent to complex-conjugate pole-residue pair model\n", "from tidy3d.plugins.dispersion import FastDispersionFitter"]}, {"cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [{"data": {"application/vnd.jupyter.widget-view+json": {"model_id": "71fb6a43f4844ac8bb98dce080afaa91", "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": "d58596ea84b74e148ef986d9cfca8f13", "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": ["# Frequency range of interest is 8 to 12 GHz\n", "freq_start = 4e9\n", "freq_stop = 16e9\n", "# Center frequency of 10 GHz\n", "freq0 = (freq_start + freq_stop) / 2\n", "fwidth = 9e9\n", "# Center wavelength\n", "wavelength0 = td.C_0 / freq0\n", "# Longest wavelength\n", "wavelength_start = td.C_0 / freq_start\n", "freqs = np.linspace(freq_start, freq_stop, 101)\n", "wvl_um = td.C_0 / freqs\n", "run_time = 20e-9  # 20 ns run time\n", "\n", "# Tidy3D uses microns by default\n", "mm = 1e3\n", "# Default unit cell parameters\n", "S = 6 * mm  # size of the unit cell\n", "s = 0.15 * mm  # spacing between arrow and unit cell boundary\n", "l_stem = 2.7 * mm  # length of arrow from via center to tip\n", "l_head = 2.75 * mm  # length of arrow head\n", "w_stem = 0.25 * mm  # width of arrow stem\n", "w_head = 0.7 * mm  # width of arrow head\n", "d_via = 0.46 * mm  # Via diameter\n", "w_cnx = 0.5 * mm  # Width of connector on bottom layer\n", "# Custom parameters not given in [1]\n", "w_via_pad = 0.5 * mm  # Width of via pad on the top layer\n", "d_hole = 0.9 * mm  # Hole diameter in ground plane\n", "\n", "# Substrate is three layers of Rogers RO4003C bonded by two layers of 0.1 mm\n", "# thick Rogers RO4450B prepregs with total thickness 3.35 mm\n", "prepreg_t = 0.102 * mm\n", "l1_t = 0.813 * mm\n", "l2_t = 1.524 * mm\n", "l3_t = 0.813 * mm\n", "structure_t = 2 * prepreg_t + l1_t + l2_t + l3_t\n", "# Used to define grid discretization\n", "dl_xy = 0.1 * mm  # resolution in the xy plane\n", "dl_hole = 0.05 * mm  # grid resolution around ground plane holes\n", "dl_z = 0.05 * mm  # resolution along the z axis\n", "# Metals modeled as 35 microns thick\n", "metal_t = 0.035 * mm\n", "\n", "# Substrate material properties\n", "RO4003C_er = 3.4\n", "RO4003C_losstan = 0.0027\n", "RO4450B_er = 3.54\n", "RO4450B_losstan = 0.004\n", "\n", "RO4003C = FastDispersionFitter.constant_loss_tangent_model(\n", "    eps_real=RO4003C_er,\n", "    loss_tangent=RO4003C_losstan,\n", "    frequency_range=(freq_start, freq_stop),\n", "    max_num_poles=3,\n", "    tolerance_rms=1e-3,\n", ")\n", "RO4450B = FastDispersionFitter.constant_loss_tangent_model(\n", "    eps_real=RO4450B_er,\n", "    loss_tangent=RO4450B_losstan,\n", "    frequency_range=(freq_start, freq_stop),\n", "    max_num_poles=3,\n", "    tolerance_rms=1e-3,\n", ")\n", "\n", "# All metals are modeled as perfect electric conductors\n", "patch_metal = td.PEC\n", "\n", "# Simulation domain definition with sufficient padding around the structure for PMLs\n", "sim_size = (S, S, structure_t + wavelength_start / 2)\n", "sim_center = [0, 0, 0]"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## Helper Class Definitions\n", "In this section, we define two helper classes which simplify the process of constructing the unit cell and reflectarray structure. Since the cells in this section are only needed for defining the Tidy3D structures, mesh overrides, and snapping points, feel free to skip to following section describing the [structure setup](#structure-setup).\n", "\n", "### PRUC Geometry\n", "We define a PRUC (Polarization-Rotating Unit Cell) helper class which creates the fundamental building block of the reflectarray.\n", "\n", "The class is initialized by parameters describing the unit cell dimensions (cell size, arrow dimensions, via sizes, etc.)\n", "\n", "- `calc_via_offset()` - Calculates where to place the vias in the unit cell\n", "- `make_single_arrow()` - Creates coordinates for one arrow-shaped patch\n", "- `make_all_arrows()` - Creates four rotated copies of the arrow for the unit cell\n", "- `make_bottom_layer()` - Creates the bottom connecting strips\n", "- `make_ground_layer()` - Creates the ground plane with holes\n", "- `make_vias()` - Creates the connecting vias between layers\n", "- `make_unit_cell_geometry()` - Assembles all components into complete unit cell\n", "\n", "The class handles both 0\u00b0 and 180\u00b0 rotated versions of the unit cell through the `bit_version` parameter, which controls the orientation of the bottom layer connections."]}, {"cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": ["class PRUC:\n", "    \"\"\"Class representing a Polarization-Rotating Unit Cell (PRUC) for reflectarray antennas.\n", "\n", "    This class defines the geometry of a unit cell containing four arrow-shaped patches\n", "    connected by vias through a ground plane. The cell can be rotated 0\u00b0 or 180\u00b0 to\n", "    encode binary phase information.\n", "\n", "    Attributes\n", "    ----------\n", "    S : float\n", "        Size of the square unit cell aperture in microns.\n", "    s : float\n", "        Spacing between arrow patches and unit cell boundary in microns.\n", "    l_head : float\n", "        Length of the arrow head in microns.\n", "    l_stem : float\n", "        Length from via center to arrow tip in microns.\n", "    w_stem : float\n", "        Width of the arrow stem in microns.\n", "    w_head : float\n", "        Width of the arrow head in microns.\n", "    w_via_pad : float\n", "        Width of the square via pad on top layer in microns.\n", "    w_cnx : float\n", "        Width of the bottom layer connections between vias in microns.\n", "    d_via : float\n", "        Diameter of the metal vias in microns.\n", "    d_hole : float\n", "        Diameter of the holes in the ground plane in microns.\n", "    metal_t : float\n", "        Thickness of all metal layers in microns.\n", "    z_top : float\n", "        Z-coordinate of top substrate surface (excluding metal) in microns.\n", "    z_ground : float\n", "        Z-coordinate of ground plane substrate surface in microns.\n", "    z_bottom : float\n", "        Z-coordinate of bottom substrate surface (excluding metal) in microns.\n", "    bit_version : bool\n", "        If True, rotates bottom connections 180\u00b0 to encode binary '1' state.\n", "        If False, keeps 0\u00b0 rotation for binary '0' state.\n", "    \"\"\"\n", "\n", "    def __init__(\n", "        self,\n", "        S: float,\n", "        s: float,\n", "        l_head: float,\n", "        l_stem: float,\n", "        w_stem: float,\n", "        w_head: float,\n", "        w_via_pad: float,\n", "        w_cnx: float,\n", "        d_via: float,\n", "        d_hole: float,\n", "        metal_t: float,\n", "        z_top: float,\n", "        z_ground: float,\n", "        z_bottom: float,\n", "        bit_version: bool,\n", "    ):\n", "        self.S = S\n", "        self.s = s\n", "        self.l_head = l_head\n", "        self.l_stem = l_stem\n", "        self.w_stem = w_stem\n", "        self.w_head = w_head\n", "        self.w_via_pad = w_via_pad\n", "        self.w_cnx = w_cnx\n", "        self.d_via = d_via\n", "        self.d_hole = d_hole\n", "        self.metal_t = metal_t\n", "        self.z_top = z_top\n", "        self.z_ground = z_ground\n", "        self.z_bottom = z_bottom\n", "        self.bit_version = bit_version\n", "\n", "    def calc_via_offset(self):\n", "        \"\"\"Calculates the offset of the via in the unit cell\"\"\"\n", "        return self.S / 2 - self.s - self.l_stem / np.sqrt(2)\n", "\n", "    def make_single_arrow(self) -> list[tuple[float, float]]:\n", "        \"\"\"Returns the 2D coordinates of a single arrow in the unit cell corresponding with the first quadrant.\"\"\"\n", "\n", "        def swap_xy(xy: tuple[float, float]):\n", "            \"\"\"Applies a reflection along the y = x line.\"\"\"\n", "            return (xy[1], xy[0])\n", "\n", "        via_offset = self.l_stem / np.sqrt(2)\n", "\n", "        # Create points along half of an arrow\n", "        tr = (0, 0)\n", "        br = (0, -self.l_head)\n", "        br2 = (-self.w_head, -self.l_head)\n", "        in_corner = (-self.w_head, -self.w_head - self.w_stem / np.sqrt(2))\n", "        bl = (\n", "            -via_offset + self.w_stem / np.sqrt(8),\n", "            -via_offset - self.w_stem / np.sqrt(8),\n", "        )\n", "        # Complete arrow is created by reflecting points across y = x line\n", "        arrow_points = [\n", "            tr,\n", "            br,\n", "            br2,\n", "            in_corner,\n", "            bl,\n", "            swap_xy(bl),\n", "            swap_xy(in_corner),\n", "            swap_xy(br2),\n", "            swap_xy(br),\n", "            swap_xy(tr),\n", "        ]\n", "        # Use shapely polygon operations to create the union of the arrow and via pad.\n", "        arrow = shapely.Polygon(arrow_points)\n", "        via_pad = shapely.box(\n", "            -via_offset - 0.5 * self.w_via_pad,\n", "            -via_offset - 0.5 * self.w_via_pad,\n", "            -via_offset + 0.5 * self.w_via_pad,\n", "            -via_offset + 0.5 * self.w_via_pad,\n", "        )\n", "        arrow_shapely = shapely.union(arrow, via_pad)\n", "        return arrow_shapely.exterior.coords\n", "\n", "    def make_all_arrows(self) -> list[td.PolySlab]:\n", "        \"\"\"Returns a list of all arrows in the unit cell by using rotations and translations.\"\"\"\n", "        slab_bounds = (self.z_top, self.z_top + self.metal_t)\n", "        arrow_tr_verts = np.array(self.make_single_arrow())\n", "        arrow_tl_verts = np.copy(arrow_tr_verts)\n", "        arrow_tl_verts[:, 0] *= -1\n", "        arrow_bl_verts = np.copy(arrow_tl_verts)\n", "        arrow_bl_verts[:, 1] *= -1\n", "        arrow_br_verts = np.copy(arrow_tr_verts)\n", "        arrow_br_verts[:, 1] *= -1\n", "\n", "        corner_offset = self.S / 2 - self.s\n", "\n", "        arrow_tr_verts += np.array([corner_offset, corner_offset])\n", "        arrow_tr = td.PolySlab(vertices=arrow_tr_verts, axis=2, slab_bounds=slab_bounds)\n", "        arrow_tl_verts += np.array([-corner_offset, corner_offset])\n", "        arrow_tl = td.PolySlab(vertices=arrow_tl_verts, axis=2, slab_bounds=slab_bounds)\n", "        arrow_bl_verts += np.array([-corner_offset, -corner_offset])\n", "        arrow_bl = td.PolySlab(vertices=arrow_bl_verts, axis=2, slab_bounds=slab_bounds)\n", "        arrow_br_verts += np.array([corner_offset, -corner_offset])\n", "        arrow_br = td.PolySlab(vertices=arrow_br_verts, axis=2, slab_bounds=slab_bounds)\n", "        return [arrow_tr, arrow_tl, arrow_bl, arrow_br]\n", "\n", "    def make_bottom_layer(self) -> td.Geometry:\n", "        \"\"\"Returns the bottom layer of the unit cell\"\"\"\n", "        via_center = self.calc_via_offset()\n", "\n", "        # Horizontal connections\n", "        zcenter = self.z_bottom - self.metal_t / 2\n", "        thickness = self.metal_t\n", "        strip = td.Box(\n", "            center=(0, 0, zcenter),\n", "            size=(\n", "                2 * np.sqrt(2) * (via_center) + self.d_via + (self.w_cnx - self.d_via),\n", "                self.w_cnx,\n", "                thickness,\n", "            ),\n", "        )\n", "        angle = -np.pi / 4\n", "        if self.bit_version:\n", "            angle = np.pi / 4\n", "\n", "        rotate_45 = td.Transformed.rotation(axis=2, angle=angle)\n", "        strip = td.Transformed(geometry=strip, transform=rotate_45)\n", "\n", "        geo_tuple = (strip,)\n", "\n", "        metal_regions = td.GeometryGroup(geometries=geo_tuple)\n", "        return metal_regions\n", "\n", "    def make_ground_layer(self, ground_width: float = None) -> td.Geometry:\n", "        \"\"\"Returns the ground layer of the unit cell\"\"\"\n", "        zcenter = self.z_ground + self.metal_t / 2\n", "        thickness = self.metal_t\n", "        via_center = self.calc_via_offset()\n", "\n", "        ground_size = (self.S, self.S, thickness)\n", "        if ground_width is not None:\n", "            ground_size = (ground_width, ground_width, thickness)\n", "\n", "        ground = td.Box(center=(0, 0, zcenter), size=ground_size)\n", "        hole_size = (self.d_hole, self.d_hole, thickness)\n", "        hole_tr = td.Box(center=(via_center, via_center, zcenter), size=hole_size)\n", "        hole_tl = td.Box(center=(-via_center, via_center, zcenter), size=hole_size)\n", "        hole_bl = td.Box(center=(-via_center, -via_center, zcenter), size=hole_size)\n", "        hole_br = td.Box(center=(via_center, -via_center, zcenter), size=hole_size)\n", "        holes = td.GeometryGroup(geometries=(hole_tr, hole_tl, hole_bl, hole_br))\n", "        ground_with_holes = td.ClipOperation(\n", "            operation=\"difference\", geometry_a=ground, geometry_b=holes\n", "        )\n", "        return ground_with_holes\n", "\n", "    def make_vias(self) -> tuple[td.Cylinder, td.Cylinder, td.Cylinder, td.Cylinder]:\n", "        \"\"\"Returns the vias in the unit cell\"\"\"\n", "        via_center = self.calc_via_offset()\n", "        center_z = (self.z_top + self.z_bottom) / 2\n", "        length = self.z_top - self.z_bottom\n", "        radius = self.d_via / 2\n", "        tr = td.Cylinder(\n", "            center=(via_center, via_center, center_z),\n", "            length=length,\n", "            radius=radius,\n", "            axis=2,\n", "        )\n", "        tl = td.Cylinder(\n", "            center=(-via_center, via_center, center_z),\n", "            length=length,\n", "            radius=radius,\n", "            axis=2,\n", "        )\n", "        bl = td.Cylinder(\n", "            center=(-via_center, -via_center, center_z),\n", "            length=length,\n", "            radius=radius,\n", "            axis=2,\n", "        )\n", "        br = td.Cylinder(\n", "            center=(via_center, -via_center, center_z),\n", "            length=length,\n", "            radius=radius,\n", "            axis=2,\n", "        )\n", "        return tr, tl, bl, br\n", "\n", "    def make_unit_cell_geometry(\n", "        self, dl_hole: float, ground_width: float = None\n", "    ) -> tuple[\n", "        td.GeometryGroup,\n", "        list[td.MeshOverrideStructure],\n", "        list[tuple[float, float, float]],\n", "    ]:\n", "        \"\"\"Returns the geometry of the metallic portion of the unit cell,\n", "        mesh overrides around the holes, and the vertices of the arrows.\"\"\"\n", "        arrows = self.make_all_arrows()\n", "        bottom_geometry = self.make_bottom_layer()\n", "        ground_with_holes = self.make_ground_layer(ground_width)\n", "        via_geometry = self.make_vias()\n", "        all_geometries = tuple(\n", "            arrows + [bottom_geometry] + [ground_with_holes] + list(via_geometry)\n", "        )\n", "        geometry_group = td.GeometryGroup(geometries=all_geometries)\n", "\n", "        # Make regions of mesh refinement\n", "        mesh_overrides = [\n", "            td.MeshOverrideStructure(geometry=hole, dl=[dl_hole, dl_hole, self.metal_t])\n", "            for hole in ground_with_holes.geometry_b.geometries\n", "        ]\n", "\n", "        # Get arrow vertices for snapping points\n", "        arrow_verts = [\n", "            (vert[0], vert[1], self.z_top) for arrow in arrows for vert in arrow.vertices\n", "        ]\n", "        return geometry_group, mesh_overrides, arrow_verts"]}, {"cell_type": "markdown", "metadata": {}, "source": ["### PRUC Array Structure Construction\n", "\n", "The `PRUCArray` class handles the construction of a complete reflectarray antenna by arranging multiple Polarization-Rotating Unit Cells (PRUCs) in a regular grid. It manages:\n", "\n", "- Assembly of unit cells in an Nx \u00d7 Ny array configuration\n", "- Creation of substrate and prepreg layers\n", "- Specification of material properties\n", "- Definition of mesh refinement regions\n", "\n", "Key methods:\n", "\n", "- `make_substrates()`: Creates the layered dielectric structure\n", "- `make_array()`: Constructs the full reflectarray using a binary mask to determine cell rotations\n", "\n", "The array construction supports:\n", "\n", "- Arbitrary array dimensions through `Nx` and `Ny` parameters\n", "- Extended substrate areas beyond the unit cell boundaries\n", "- Custom mesh refinement around critical features\n", "- Material specifications for substrates, prepregs, and metals"]}, {"cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [], "source": ["class PRUCArray:\n", "    \"\"\"Class representing an array of Polarization-Rotating Unit Cells (PRUCs).\n", "\n", "    This class handles the construction of a reflectarray consisting of multiple PRUCs,\n", "    including substrate layers and mesh refinement specifications.\n", "\n", "    Attributes\n", "    ----------\n", "    unit_cell_0 : PRUC\n", "        Unit cell representing binary '0' state with 0\u00b0 rotation.\n", "    unit_cell_1 : PRUC\n", "        Unit cell representing binary '1' state with 180\u00b0 rotation.\n", "    Nx : int\n", "        Number of unit cells along x-axis.\n", "    Ny : int\n", "        Number of unit cells along y-axis.\n", "    array_sx : float\n", "        Size of array in x-direction in microns. Allows for substrates that extend farther than the unit cells.\n", "    array_sy : float\n", "        Size of array in y-direction in microns. Allows for substrates that extend farther than the unit cells.\n", "    prepreg_t : float\n", "        Thickness of prepreg layers in microns.\n", "    l1_t : float\n", "        Thickness of top substrate layer in microns.\n", "    l2_t : float\n", "        Thickness of middle substrate layer in microns.\n", "    l3_t : float\n", "        Thickness of bottom substrate layer in microns.\n", "    substrate_medium : Medium\n", "        Material properties of the substrate layers.\n", "    prepreg_medium : Medium\n", "        Material properties of the prepreg layers.\n", "    metal_medium : Medium\n", "        Material properties of the metal layers.\n", "    dl_hole : float\n", "        Mesh cell size for refinement around holes in microns.\n", "    dl_xy : float\n", "        Mesh cell size in xy-plane in microns.\n", "    dl_z : float\n", "        Mesh cell size in z-direction in microns.\n", "    \"\"\"\n", "\n", "    def __init__(\n", "        self,\n", "        unit_cell_0: PRUC,\n", "        unit_cell_1: PRUC,\n", "        Nx,\n", "        Ny,\n", "        array_sx,\n", "        array_sy,\n", "        prepreg_t,\n", "        l1_t,\n", "        l2_t,\n", "        l3_t,\n", "        substrate_medium,\n", "        prepreg_medium,\n", "        metal_medium,\n", "        dl_hole: float,\n", "        dl_xy: float,\n", "        dl_z: float,\n", "    ):\n", "        self.unit_cell_0 = unit_cell_0\n", "        self.unit_cell_1 = unit_cell_1\n", "        self.Nx = Nx\n", "        self.Ny = Ny\n", "        self.array_sx = array_sx\n", "        self.array_sy = array_sy\n", "        self.prepreg_t = prepreg_t\n", "        self.l1_t = l1_t\n", "        self.l2_t = l2_t\n", "        self.l3_t = l3_t\n", "        self.substrate_medium = substrate_medium\n", "        self.prepreg_medium = prepreg_medium\n", "        self.metal_medium = metal_medium\n", "        self.dl_hole = dl_hole\n", "        self.dl_xy = dl_xy\n", "        self.dl_z = dl_z\n", "\n", "    def make_substrates(\n", "        self,\n", "    ) -> tuple[list[td.Structure], list[td.MeshOverrideStructure]]:\n", "        \"\"\"Create the layered substrate structure for the reflectarray along\n", "        with mesh overrides that refine the mesh along the normal axis of the layers.\"\"\"\n", "        top_l1 = 0\n", "        top_l2 = top_l1 - self.l1_t - self.prepreg_t\n", "        top_l3 = top_l2 - self.l2_t - self.prepreg_t\n", "        bottom = top_l3 - self.l3_t\n", "\n", "        metal_t = self.unit_cell_0.metal_t\n", "\n", "        array_sx = self.array_sx\n", "        array_sy = self.array_sy\n", "\n", "        sub1 = td.Structure(\n", "            geometry=td.Box(\n", "                center=(0, 0, top_l1 - self.l1_t / 2),\n", "                size=(array_sx, array_sy, self.l1_t),\n", "            ),\n", "            medium=self.substrate_medium,\n", "        )\n", "        prepreg1 = td.Structure(\n", "            geometry=td.Box(\n", "                center=(0, 0, top_l1 - self.l1_t - self.prepreg_t / 2),\n", "                size=(array_sx, array_sy, self.prepreg_t),\n", "            ),\n", "            medium=self.prepreg_medium,\n", "        )\n", "        sub2 = td.Structure(\n", "            geometry=td.Box(\n", "                center=(0, 0, top_l2 - self.l2_t / 2),\n", "                size=(array_sx, array_sy, self.l2_t),\n", "            ),\n", "            medium=self.substrate_medium,\n", "        )\n", "        prepreg2 = td.Structure(\n", "            geometry=td.Box(\n", "                center=(0, 0, top_l2 - self.l2_t - self.prepreg_t / 2),\n", "                size=(array_sx, array_sy, self.prepreg_t),\n", "            ),\n", "            medium=self.prepreg_medium,\n", "        )\n", "        sub3 = td.Structure(\n", "            geometry=td.Box(\n", "                center=(0, 0, top_l3 - self.l3_t / 2),\n", "                size=(array_sx, array_sy, self.l3_t),\n", "            ),\n", "            medium=self.substrate_medium,\n", "        )\n", "\n", "        substrates = [sub1, prepreg1, sub2, prepreg2, sub3]\n", "\n", "        patch_box = td.Box(center=(0, 0, top_l1 + metal_t / 2), size=(array_sx, array_sy, metal_t))\n", "        ground_box = td.Box(\n", "            center=(0, 0, top_l3 + metal_t / 2),\n", "            size=(array_sx, array_sy, metal_t),\n", "        )\n", "        bottom_box = td.Box(\n", "            center=(0, 0, bottom - metal_t / 2),\n", "            size=(array_sx, array_sy, metal_t),\n", "        )\n", "\n", "        dl_metals = (self.dl_xy, self.dl_xy, metal_t)\n", "        dl_subs = (self.dl_xy, self.dl_xy, self.dl_z)\n", "\n", "        substrate_overrides = [\n", "            td.MeshOverrideStructure(geometry=patch_box, dl=dl_metals),\n", "            td.MeshOverrideStructure(geometry=ground_box, dl=dl_metals),\n", "            td.MeshOverrideStructure(geometry=bottom_box, dl=dl_metals),\n", "            td.MeshOverrideStructure(geometry=prepreg1.geometry, dl=dl_subs),\n", "            td.MeshOverrideStructure(geometry=prepreg2.geometry, dl=dl_subs),\n", "            td.MeshOverrideStructure(geometry=sub1.geometry, dl=dl_subs),\n", "            td.MeshOverrideStructure(geometry=sub2.geometry, dl=dl_subs),\n", "            td.MeshOverrideStructure(geometry=sub3.geometry, dl=dl_subs),\n", "        ]\n", "        return substrates, substrate_overrides\n", "\n", "    def make_array(\n", "        self, bit_mask: Union[xr.DataArray, bool], ground_width: float = None\n", "    ) -> tuple[\n", "        td.GeometryGroup,\n", "        list[td.MeshOverrideStructure],\n", "        list[tuple[float, float, float]],\n", "    ]:\n", "        \"\"\"Returns all Tidy3D structures, mesh overrides and snapping points for the array.\"\"\"\n", "        S = self.unit_cell_0.S\n", "        xstart = -self.Nx / 2.0 * S + 0.5 * S\n", "        ystart = -self.Ny / 2.0 * S + 0.5 * S\n", "\n", "        substrate_structures, substrate_overrides = self.make_substrates()\n", "\n", "        geo_unit_cell_0, cell_overrides, cell_snapping_points = (\n", "            self.unit_cell_0.make_unit_cell_geometry(\n", "                dl_hole=self.dl_hole, ground_width=ground_width\n", "            )\n", "        )\n", "        geo_unit_cell_1, _, _ = self.unit_cell_1.make_unit_cell_geometry(\n", "            dl_hole=self.dl_hole, ground_width=ground_width\n", "        )\n", "\n", "        def get_cell_variant(i, j):\n", "            if type(bit_mask) is bool:\n", "                return bit_mask\n", "            return bit_mask[i, j].item()\n", "\n", "        unit_cell_geos = []\n", "        mesh_overrides = []\n", "        arrow_snapping_points = []\n", "        for i in range(0, self.Nx):\n", "            dx = xstart + i * S\n", "            for j in range(0, self.Ny):\n", "                dy = ystart + j * S\n", "                # Add translated geometries\n", "                translate = td.Transformed.translation(dx, dy, 0)\n", "                if get_cell_variant(i, j):\n", "                    transformed_cell = td.Transformed(geometry=geo_unit_cell_1, transform=translate)\n", "                else:\n", "                    transformed_cell = td.Transformed(geometry=geo_unit_cell_0, transform=translate)\n", "                unit_cell_geos.append(transformed_cell)\n", "\n", "                # Add mesh overrides\n", "                mesh_overrides += [\n", "                    override_hole.updated_copy(\n", "                        path=\"geometry\",\n", "                        center=(\n", "                            dx + override_hole.geometry.center[0],\n", "                            dy + override_hole.geometry.center[1],\n", "                            override_hole.geometry.center[2],\n", "                        ),\n", "                    )\n", "                    for override_hole in cell_overrides\n", "                ]\n", "\n", "                # Add snapping points\n", "                arrow_snapping_points += [\n", "                    (v[0] + dx, v[1] + dy, v[2]) for v in cell_snapping_points\n", "                ]\n", "\n", "        all_cells = td.GeometryGroup(geometries=unit_cell_geos)\n", "        all_cells_structure = td.Structure(geometry=all_cells, medium=self.metal_medium)\n", "\n", "        all_structures = substrate_structures + [all_cells_structure]\n", "        all_mesh_overrides = substrate_overrides + mesh_overrides\n", "\n", "        return all_structures, all_mesh_overrides, arrow_snapping_points"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## Setup\n", "### Structure Setup\n", "\n", "Using the helper classes defined earlier, we create an array consisting of a single unit cell, since in this notebook we are interested in optimizing the unit cell design [1].\n", "\n", "We plot a candidate unit cell in the figures below."]}, {"cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [{"data": {"image/png": "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", "text/plain": ["<Figure size 1000x500 with 2 Axes>"]}, "metadata": {}, "output_type": "display_data"}, {"data": {"image/png": "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", "text/plain": ["<Figure size 1000x500 with 1 Axes>"]}, "metadata": {}, "output_type": "display_data"}], "source": ["# Positions of the substrate interfaces\n", "top_l1 = 0\n", "top_l2 = top_l1 - l1_t - prepreg_t\n", "top_l3 = top_l2 - l2_t - prepreg_t\n", "bottom = top_l3 - l3_t\n", "substrate_width = 2 * S\n", "\n", "unit_cell_1 = PRUC(\n", "    S=S,\n", "    s=s,\n", "    l_head=2.5 * mm,  # l1,\n", "    l_stem=3 * mm,  # l2,\n", "    w_stem=w_stem,\n", "    w_head=w_head,\n", "    w_via_pad=w_via_pad,\n", "    w_cnx=w_cnx,\n", "    d_via=d_via,\n", "    d_hole=d_hole,\n", "    metal_t=metal_t,\n", "    z_top=0.0,\n", "    z_ground=top_l3,\n", "    z_bottom=bottom,\n", "    bit_version=True,\n", ")\n", "\n", "unit_cell_0 = copy(unit_cell_1)\n", "unit_cell_0.bit_version = False\n", "\n", "array = PRUCArray(\n", "    unit_cell_0=unit_cell_0,\n", "    unit_cell_1=unit_cell_1,\n", "    Nx=1,\n", "    Ny=1,\n", "    array_sx=substrate_width,  # Make array large enough that the substrates extend passed the simulation boundaries\n", "    array_sy=substrate_width,\n", "    prepreg_t=prepreg_t,\n", "    l1_t=l1_t,\n", "    l2_t=l2_t,\n", "    l3_t=l3_t,\n", "    substrate_medium=RO4003C,\n", "    prepreg_medium=RO4450B,\n", "    metal_medium=patch_metal,\n", "    dl_hole=dl_hole,\n", "    dl_xy=dl_xy,\n", "    dl_z=dl_z,\n", ")\n", "\n", "mask = np.ones((array.Nx, array.Ny), dtype=bool)\n", "mask[0, 0] = False\n", "bool_array = xr.DataArray(\n", "    mask,  # The value (can be False too)\n", "    dims=[\"x\", \"y\"],  # Names of the dimensions\n", ")\n", "\n", "all_structures, all_mesh_overrides, arrow_snapping_points = array.make_array(\n", "    bit_mask=bool_array, ground_width=substrate_width\n", ")\n", "\n", "via_center = unit_cell_1.calc_via_offset()\n", "scene = td.Scene(structures=all_structures, plot_length_units=\"mm\")\n", "fig, axs = plt.subplots(1, 2, figsize=(10, 5), tight_layout=True)\n", "scene.plot(ax=axs[0], z=top_l1, hlim=[-3 * mm, 3 * mm], vlim=[-3 * mm, 3 * mm])\n", "scene.plot(ax=axs[1], z=bottom, hlim=[-3 * mm, 3 * mm], vlim=[-3 * mm, 3 * mm])\n", "plt.show()\n", "fig, axs = plt.subplots(1, 1, figsize=(10, 5), tight_layout=True)\n", "scene.plot(ax=axs, x=via_center)\n", "plt.show()"]}, {"cell_type": "markdown", "metadata": {}, "source": ["### Simulation Setup\n", "\n", "Now we set up the electromagnetic simulation to characterize the PRUC. We use periodic boundary conditions in x and y to model an infinite array. A ``FieldMonitor`` is added just above the source to capture the reflected waves."]}, {"cell_type": "code", "execution_count": 6, "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\">10:15:24 CEST </span><span style=\"color: #800000; text-decoration-color: #800000\">WARNING:  \u2139\ufe0f \u26a0\ufe0f RF simulations are subject to new license           </span>\n", "<span style=\"color: #7fbfbf; text-decoration-color: #7fbfbf\">              </span><span style=\"color: #800000; text-decoration-color: #800000\">requirements in the future. You are using RF-specific components  </span>\n", "<span style=\"color: #7fbfbf; text-decoration-color: #7fbfbf\">              </span><span style=\"color: #800000; text-decoration-color: #800000\">in this simulation.                                               </span>\n", "<span style=\"color: #7fbfbf; text-decoration-color: #7fbfbf\">              </span><span style=\"color: #800000; text-decoration-color: #800000\"> - Contains monitors defined for RF wavelengths.                  </span>\n", "</pre>\n"], "text/plain": ["\u001b[2;36m10:15:24 CEST\u001b[0m\u001b[2;36m \u001b[0m\u001b[31mWARNING:  \u2139\ufe0f \u26a0\ufe0f RF simulations are subject to new license           \u001b[0m\n", "\u001b[2;36m              \u001b[0m\u001b[31mrequirements in the future. You are using RF-specific components  \u001b[0m\n", "\u001b[2;36m              \u001b[0m\u001b[31min this simulation.                                               \u001b[0m\n", "\u001b[2;36m              \u001b[0m\u001b[31m - Contains monitors defined for RF wavelengths.                  \u001b[0m\n"]}, "metadata": {}, "output_type": "display_data"}, {"name": "stdout", "output_type": "stream", "text": ["Number of cells: [88, 88, 137]\n", "Smallest cell size (\u03bcm): (35.66, 35.66, 33.50)\n"]}, {"data": {"image/png": "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", "text/plain": ["<Figure size 640x480 with 1 Axes>"]}, "metadata": {}, "output_type": "display_data"}], "source": ["boundary_spec = td.BoundarySpec(\n", "    x=td.Boundary.periodic(),\n", "    y=td.Boundary.periodic(),\n", "    z=td.Boundary.pml(),\n", ")\n", "\n", "time = td.GaussianPulse(freq0=freq0, fwidth=fwidth)\n", "planewave = td.PlaneWave(\n", "    size=(td.inf, td.inf, 0),\n", "    center=(0, 0, 5 * mm),\n", "    source_time=time,\n", "    direction=\"-\",\n", "    pol_angle=np.pi / 2,\n", "    num_freqs=1,\n", ")\n", "\n", "R_mon = td.FieldMonitor(\n", "    size=(td.inf, td.inf, 0), center=(0, 0, 15 * mm), name=\"reflection\", freqs=freqs\n", ")\n", "\n", "sim = td.Simulation(\n", "    center=sim_center,\n", "    size=sim_size,\n", "    grid_spec=td.GridSpec.auto(\n", "        min_steps_per_wvl=10,\n", "        wavelength=td.C_0 / freq_stop,\n", "        override_structures=all_mesh_overrides,\n", "        snapping_points=arrow_snapping_points,\n", "        dl_min=0.018 * mm,\n", "    ),\n", "    structures=all_structures,\n", "    sources=[planewave],\n", "    monitors=[R_mon],\n", "    run_time=run_time,\n", "    boundary_spec=boundary_spec,\n", ")\n", "\n", "print(f\"Number of cells: {sim.grid.num_cells}\")\n", "print(\n", "    f\"Smallest cell size (\u03bcm): ({np.min(sim.grid.sizes.x):.2f}, {np.min(sim.grid.sizes.y):.2f}, {np.min(sim.grid.sizes.z):.2f})\"\n", ")\n", "\n", "ax = sim.plot(z=top_l1)\n", "ax = sim.plot_grid(ax=ax, z=top_l1)\n", "plt.show()"]}, {"cell_type": "markdown", "metadata": {}, "source": ["### Bayesian Optimization Setup\n", "\n", "This section defines the key functions and parameters for optimizing the reflectarray unit cell design. To use the ``design`` plugin, we must provide a function that parameterizes the ``Simulation``, as well as a function that calculates a metric which evaluates the fitness of the design.\n", "\n", "In this notebook, we wish to optimize the fractional bandwidth of the unit cell by modifying the arrow stem length and the arrow head length of the PRUC. In the next section, we introduce a few helper functions with these tasks in mind.\n", "\n", "Using these helper functions we setup a Bayesian optimization using the ``design`` plugin. The optimization is configured to run 50 initial iterations followed by 10 refinement iterations using an Upper Confidence Bound (UCB) acquisition function."]}, {"cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [], "source": ["def compute_flux_polarization_components(mon_data) -> tuple[float, float]:\n", "    \"\"\"Compute flux in the +z axis direction, but decomposed\n", "    into x and y electric field polarizations\"\"\"\n", "    Ex = mon_data.Ex\n", "    Ey = mon_data.Ey\n", "    Hx = mon_data.Hx\n", "    Hy = mon_data.Hy\n", "\n", "    Px = 0.5 * np.real(Ex * Hy.conj())\n", "    Py = 0.5 * np.real(-Ey * Hx.conj())\n", "\n", "    flux_x = Px.integrate([\"x\", \"y\"])\n", "    flux_y = Py.integrate([\"x\", \"y\"])\n", "    return flux_x, flux_y\n", "\n", "\n", "def find_frequency_bounds(value_dB: xr.DataArray, threshold=-1) -> tuple[float, float]:\n", "    \"\"\"Find the frequency bounds where value_dB is above the threshold.\"\"\"\n", "    value_dB = value_dB.squeeze()\n", "    peak_amp = value_dB.max().item()\n", "    peak_frequency = value_dB.idxmax(dim=\"f\").item()\n", "    if peak_amp < threshold:\n", "        return np.nan, np.nan\n", "\n", "    below_threshold = (value_dB < threshold).values\n", "    low_freq = value_dB.f[below_threshold].where(value_dB.f < peak_frequency).max().item()\n", "    high_freq = value_dB.f[below_threshold].where(value_dB.f > peak_frequency).min().item()\n", "\n", "    return low_freq, high_freq\n", "\n", "\n", "def calculate_fractional_bandwith_metric(mon_data: td.FieldData, threshold=-1) -> float:\n", "    \"\"\"Calculate the fractional bandwidth metric given a simulation result\"\"\"\n", "    flux_x, _ = compute_flux_polarization_components(mon_data)\n", "    # The co-polarization reflection coefficient in dB [1]. The source is normalized to 1 Watt.\n", "    Rxy_dB = 10 * np.log10(flux_x).squeeze()\n", "\n", "    peak = Rxy_dB.max().item()\n", "    if peak < threshold:\n", "        return 0.0\n", "\n", "    # Find the max value, and from there find where Rxy crosses the threshold of -1 dB.\n", "    low_freq, high_freq = find_frequency_bounds(Rxy_dB, threshold=threshold)\n", "    freq0 = (low_freq + high_freq) / 2\n", "    bandwidth = high_freq - low_freq\n", "    # Fractional bandwidth in percent\n", "    fractional_bandwidth = 100 * bandwidth / freq0\n", "    return fractional_bandwidth\n", "\n", "\n", "def make_structures_and_gridspec(l_head: float, l_stem: float) -> tuple[td.Structure, td.GridSpec]:\n", "    \"\"\"Recreates the structures that are affected by a new arrow head length and stem length.\"\"\"\n", "    # Update unit cell parameters\n", "    array.unit_cell_0.l_head = l_head\n", "    array.unit_cell_1.l_head = l_head\n", "    array.unit_cell_0.l_stem = l_stem\n", "    array.unit_cell_1.l_stem = l_stem\n", "\n", "    all_structures, all_mesh_overrides, arrow_snapping_points = array.make_array(\n", "        bit_mask=bool_array, ground_width=substrate_width\n", "    )\n", "\n", "    grid_spec = td.GridSpec.auto(\n", "        min_steps_per_wvl=10,\n", "        wavelength=td.C_0 / freq_stop,\n", "        override_structures=all_mesh_overrides,\n", "        snapping_points=arrow_snapping_points,\n", "        dl_min=0.018 * mm,\n", "    )\n", "    return all_structures, grid_spec\n", "\n", "\n", "def pre(l_head, l_stem) -> td.Simulation:\n", "    \"\"\"Pre-processing function, which creates a ``Simulation`` from the design parameters.\"\"\"\n", "    all_structures, grid_spec = make_structures_and_gridspec(l_head, l_stem)\n", "    return sim.updated_copy(structures=all_structures, grid_spec=grid_spec)\n", "\n", "\n", "def post(data: td.SimulationData) -> float:\n", "    \"\"\"Post-processing function, which processes the tidy3d simulation data to return the function output.\"\"\"\n", "    mon_data = data[R_mon.name]\n", "    frac_bw = calculate_fractional_bandwith_metric(mon_data, threshold=-1)\n", "    return frac_bw\n", "\n", "\n", "# Setup of the parameters for the optimization step. The span indicates the bounds of the associated parameter.\n", "param_l1 = tdd.ParameterFloat(name=\"l_head\", span=(2.2 * mm, 2.83 * mm), num_points=1)\n", "param_l2 = tdd.ParameterFloat(name=\"l_stem\", span=(2.2 * mm, 3.4 * mm), num_points=2)\n", "\n", "method = tdd.MethodBayOpt(\n", "    initial_iter=50,\n", "    n_iter=10,\n", "    acq_func=\"ucb\",\n", "    kappa=0.6,\n", "    seed=1,\n", ")\n", "\n", "design_space = tdd.DesignSpace(parameters=[param_l1, param_l2], method=method)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## Running the Optimization\n", "\n", "Next, we use the run command to start the optimization."]}, {"cell_type": "code", "execution_count": 8, "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\">10:15:26 CEST </span>Running <span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">50</span> Simulations                                            \n", "</pre>\n"], "text/plain": ["\u001b[2;36m10:15:26 CEST\u001b[0m\u001b[2;36m \u001b[0mRunning \u001b[1;36m50\u001b[0m Simulations                                            \n"]}, "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\"><span style=\"color: #7fbfbf; text-decoration-color: #7fbfbf\">10:18:50 CEST </span>Best Fit from Initial Solutions: <span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">56.604</span>                           \n", "<span style=\"color: #7fbfbf; text-decoration-color: #7fbfbf\">              </span>                                                                  \n", "</pre>\n"], "text/plain": ["\u001b[2;36m10:18:50 CEST\u001b[0m\u001b[2;36m \u001b[0mBest Fit from Initial Solutions: \u001b[1;36m56.604\u001b[0m                           \n", "\u001b[2;36m              \u001b[0m                                                                  \n"]}, "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\"><span style=\"color: #7fbfbf; text-decoration-color: #7fbfbf\">10:18:51 CEST </span>Running <span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">1</span> Simulations                                             \n", "</pre>\n"], "text/plain": ["\u001b[2;36m10:18:51 CEST\u001b[0m\u001b[2;36m \u001b[0mRunning \u001b[1;36m1\u001b[0m Simulations                                             \n"]}, "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\"><span style=\"color: #7fbfbf; text-decoration-color: #7fbfbf\">10:19:01 CEST </span>Running <span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">1</span> Simulations                                             \n", "</pre>\n"], "text/plain": ["\u001b[2;36m10:19:01 CEST\u001b[0m\u001b[2;36m \u001b[0mRunning \u001b[1;36m1\u001b[0m Simulations                                             \n"]}, "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\"><span style=\"color: #7fbfbf; text-decoration-color: #7fbfbf\">10:19:18 CEST </span>Running <span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">1</span> Simulations                                             \n", "</pre>\n"], "text/plain": ["\u001b[2;36m10:19:18 CEST\u001b[0m\u001b[2;36m \u001b[0mRunning \u001b[1;36m1\u001b[0m Simulations                                             \n"]}, "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\"><span style=\"color: #7fbfbf; text-decoration-color: #7fbfbf\">10:19:48 CEST </span>Running <span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">1</span> Simulations                                             \n", "</pre>\n"], "text/plain": ["\u001b[2;36m10:19:48 CEST\u001b[0m\u001b[2;36m \u001b[0mRunning \u001b[1;36m1\u001b[0m Simulations                                             \n"]}, "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\"><span style=\"color: #7fbfbf; text-decoration-color: #7fbfbf\">10:20:20 CEST </span>Latest Best Fit on Iter <span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">3</span>: <span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">58.209</span>                                 \n", "<span style=\"color: #7fbfbf; text-decoration-color: #7fbfbf\">              </span>                                                                  \n", "</pre>\n"], "text/plain": ["\u001b[2;36m10:20:20 CEST\u001b[0m\u001b[2;36m \u001b[0mLatest Best Fit on Iter \u001b[1;36m3\u001b[0m: \u001b[1;36m58.209\u001b[0m                                 \n", "\u001b[2;36m              \u001b[0m                                                                  \n"]}, "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\"><span style=\"color: #7fbfbf; text-decoration-color: #7fbfbf\">10:20:21 CEST </span>Running <span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">1</span> Simulations                                             \n", "</pre>\n"], "text/plain": ["\u001b[2;36m10:20:21 CEST\u001b[0m\u001b[2;36m \u001b[0mRunning \u001b[1;36m1\u001b[0m Simulations                                             \n"]}, "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\"><span style=\"color: #7fbfbf; text-decoration-color: #7fbfbf\">10:20:31 CEST </span>Running <span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">1</span> Simulations                                             \n", "</pre>\n"], "text/plain": ["\u001b[2;36m10:20:31 CEST\u001b[0m\u001b[2;36m \u001b[0mRunning \u001b[1;36m1\u001b[0m Simulations                                             \n"]}, "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\"><span style=\"color: #7fbfbf; text-decoration-color: #7fbfbf\">10:21:03 CEST </span>Running <span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">1</span> Simulations                                             \n", "</pre>\n"], "text/plain": ["\u001b[2;36m10:21:03 CEST\u001b[0m\u001b[2;36m \u001b[0mRunning \u001b[1;36m1\u001b[0m Simulations                                             \n"]}, "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\"><span style=\"color: #7fbfbf; text-decoration-color: #7fbfbf\">10:21:28 CEST </span>Running <span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">1</span> Simulations                                             \n", "</pre>\n"], "text/plain": ["\u001b[2;36m10:21:28 CEST\u001b[0m\u001b[2;36m \u001b[0mRunning \u001b[1;36m1\u001b[0m Simulations                                             \n"]}, "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\"><span style=\"color: #7fbfbf; text-decoration-color: #7fbfbf\">10:21:38 CEST </span>Running <span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">1</span> Simulations                                             \n", "</pre>\n"], "text/plain": ["\u001b[2;36m10:21:38 CEST\u001b[0m\u001b[2;36m \u001b[0mRunning \u001b[1;36m1\u001b[0m Simulations                                             \n"]}, "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\"><span style=\"color: #7fbfbf; text-decoration-color: #7fbfbf\">10:22:00 CEST </span>Running <span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">1</span> Simulations                                             \n", "</pre>\n"], "text/plain": ["\u001b[2;36m10:22:00 CEST\u001b[0m\u001b[2;36m \u001b[0mRunning \u001b[1;36m1\u001b[0m Simulations                                             \n"]}, "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\"><span style=\"color: #7fbfbf; text-decoration-color: #7fbfbf\">10:22:09 CEST </span>Best Result: <span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">58.208955223880594</span>                                   \n", "<span style=\"color: #7fbfbf; text-decoration-color: #7fbfbf\">              </span>Best Parameters: l_head: <span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">2596.2990867530775</span> l_stem:               \n", "<span style=\"color: #7fbfbf; text-decoration-color: #7fbfbf\">              </span><span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">2943.467020495493</span>                                                 \n", "<span style=\"color: #7fbfbf; text-decoration-color: #7fbfbf\">              </span>                                                                  \n", "</pre>\n"], "text/plain": ["\u001b[2;36m10:22:09 CEST\u001b[0m\u001b[2;36m \u001b[0mBest Result: \u001b[1;36m58.208955223880594\u001b[0m                                   \n", "\u001b[2;36m              \u001b[0mBest Parameters: l_head: \u001b[1;36m2596.2990867530775\u001b[0m l_stem:               \n", "\u001b[2;36m              \u001b[0m\u001b[1;36m2943.467020495493\u001b[0m                                                 \n", "\u001b[2;36m              \u001b[0m                                                                  \n"]}, "metadata": {}, "output_type": "display_data"}], "source": ["results = design_space.run(pre, post, verbose=True)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["The optimization results in a final design with a fractional bandwidth of 58%."]}, {"cell_type": "markdown", "metadata": {}, "source": ["## Post-Processing and Plotting\n", "\n", "The results from running the ``DesignSpace`` can be viewed as a pandas Dataframe for easy reference."]}, {"cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [{"name": "stdout", "output_type": "stream", "text": ["         l_head       l_stem     output\n", "0   2462.723863  3064.389392  16.885553\n", "1   2200.072056  2562.799087  23.437500\n", "2   2292.456211  2310.806314  10.131332\n", "3   2317.343933  2614.672872  25.049702\n", "4   2449.963509  2846.580081  35.876289\n", "5   2464.092544  3022.263400  18.113208\n", "6   2328.804917  3253.740924  11.978221\n", "7   2217.254184  3004.561012  13.075061\n", "8   2462.902025  2870.427794  37.344398\n", "9   2288.443771  2437.721787  18.532819\n", "10  2704.469078  3361.913891  28.471002\n", "11  2397.457232  3030.787139  12.060302\n", "12  2752.125166  3273.527996  25.891182\n", "13  2253.577853  2246.865740   0.000000\n", "14  2306.993164  3253.771004  11.978221\n", "15  2261.958505  2705.329150  30.181087\n", "16  2803.470404  2839.798342  22.978723\n", "17  2635.882582  2578.618757  37.638376\n", "18  2632.495584  3201.550806  33.730835\n", "19  2211.521615  3100.173178  12.060302\n", "20  2822.982486  3097.798785  28.832952\n", "21  2376.679715  3147.135194  13.284133\n", "22  2265.032384  2737.472231  29.149798\n", "23  2772.415167  2552.336978  11.450382\n", "24  2381.298463  2356.034287  14.800759\n", "25  2212.201183  3014.602640  13.075061\n", "26  2333.325713  2518.655991  22.396857\n", "27  2509.691090  2264.035054  18.476499\n", "28  2561.694091  2376.074290  30.260870\n", "29  2571.262488  3039.710032  19.354839\n", "30  2264.470690  2696.867185  27.766600\n", "31  2637.472099  2697.015123  43.902439\n", "32  2231.470679  2843.075687  34.426230\n", "33  2618.190626  2817.866934  50.656660\n", "34  2795.094696  2903.866049  32.119914\n", "35  2769.143207  2364.969645   6.716418\n", "36  2287.744099  3168.869546  12.110092\n", "37  2450.536407  2398.425037  17.274472\n", "38  2784.330406  2617.319032  12.815534\n", "39  2673.011625  3071.197582  34.657040\n", "40  2756.482837  2948.406648  42.323651\n", "41  2673.093733  2618.678010  35.294118\n", "42  2370.054572  3275.063462  11.978221\n", "43  2469.697450  3357.808057  11.978221\n", "44  2617.968144  2946.034864  56.603774\n", "45  2272.289963  3339.387110  10.830325\n", "46  2483.444644  2894.067537  37.344398\n", "47  2457.126186  2484.432376  21.093750\n", "48  2769.129098  2888.415384  36.325678\n", "49  2201.808306  2940.573896  15.529412\n", "50  2640.367296  2910.644674  52.671756\n", "51  2608.103669  2930.054229  56.603774\n", "52  2620.107926  2936.791251  55.787476\n", "53  2596.299087  2943.467020  58.208955\n", "54  2588.824524  2938.765801  42.323651\n", "55  2603.690268  2950.648729  57.410882\n", "56  2596.517303  2943.453058  58.208955\n", "57  2594.052195  2951.397788  42.323651\n", "58  2610.128107  2943.002309  56.603774\n", "59  2610.116221  2950.940604  56.603774\n"]}], "source": ["result_df = results.to_dataframe()\n", "print(result_df)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Another option is to make a scatter plot with the color scale indicating the fractional bandwidth. From the plot, it is evident that the highest fractional bandwidths are achieved where the stem length is around 2.9 mm and the head length is close to 2.6 mm."]}, {"cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [{"data": {"image/png": "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", "text/plain": ["<Figure size 500x400 with 2 Axes>"]}, "metadata": {}, "output_type": "display_data"}], "source": ["f, ax1 = plt.subplots(1, 1, figsize=(5, 4))\n", "result_df_process = copy(result_df)\n", "result_df_process[\"l_head\"] = result_df_process[\"l_head\"] * 1e-3\n", "result_df_process[\"l_stem\"] = result_df_process[\"l_stem\"] * 1e-3\n", "result_df_process = result_df_process.rename(columns={\"output\": \"Fractional Bandwidth (%)\"})\n", "im = result_df_process.plot.scatter(\n", "    x=\"l_head\", y=\"l_stem\", s=75, c=\"Fractional Bandwidth (%)\", cmap=\"magma\", ax=ax1\n", ")\n", "ax1.set_xlabel(r\"$L_{\\rm H}$ (mm)\")\n", "ax1.set_ylabel(r\"$L_{\\rm S}$ (mm)\")\n", "plt.tight_layout(pad=0.2)\n", "plt.show()"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Finally, we plot the co- and cross-polarization reflection coefficients from the design with the maximum fractional bandwidth, over the frequencies from 4 GHz to 16 GHz."]}, {"cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [{"name": "stdout", "output_type": "stream", "text": ["Range 7.60-13.84 GHz, Bandwidth: 6.24 GHz, Fractional Bandwidth: 58.21%\n"]}, {"data": {"image/png": "iVBORw0KGgoAAAANSUhEUgAAAsoAAAICCAYAAADWLeuZAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjMsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvZiW1igAAAAlwSFlzAAAPYQAAD2EBqD+naQAAx8FJREFUeJzsnXd4FAX6xz9b0ntIIYQSAoQmHURQmgUQ9Q7b4aGnqMdhP5XT07PrqajYTrF7oKc/e1csSBFQmlQlQOhppPe+7ffH7CwBkpCyu7OzeT/Ps082u7Mz7242M9955/u+r8HhcDgQBEEQBEEQBOEYjFoHIAiCIAiCIAi+iAhlQRAEQRAEQWgCEcqCIAiCIAiC0AQilAVBEARBEAShCUQoC4IgCIIgCEITiFAWBEEQBEEQhCYQoSwIgiAIgiAITSBCWRAEQRAEQRCaQISyIAiCIAiCIDSBCGVBEARBEARBaIJOI5QXLVpESkoKwcHBjB07lo0bN2odkiAIgiAIgn+xaBGkpEBwMIwdCzrXW51CKH/wwQfcfvvtPPDAA2zZsoVhw4Yxbdo0CgoKtA5NEARBEATBP/jgA7j9dnjgAdiyBYYNg2nTQMd6y+BwOBxaB+Fpxo4dy5gxY3jxxRcBsNvt9OjRg5tvvpm77rpL4+gEQRAEQRD8gLFjYcwYcOot7Hbo0QNuvhl0qrfMWgfgaRoaGti8eTN333236zGj0cjZZ5/NunXrmnxNfX099fX1rt+tViu7du2iR48eGI2dIgkvCIIgCEInxmG3U52ZSb9BgzCZG8nFoCDldjwNDbB5MzTSWxiNcPbZ0Ize0gN+L5SLioqw2WwkJiYe83hiYiK7d+9u8jWPP/44Dz30kDfCEwRBEARB8FnKgcjGDzzwADz44IkLFhWBzQbH6S0SE6EZvaUH/F4ot4e7776b22+/3fV7VlYWp5xyCqtXr6ZHjx4aRtY5sVgsrF69mokTJxIQEKB1OLpgT36V29ZltVrZunUrI0aMwGyWXYa3kc9fW+Tz9zz9E8ObfFz2/dpSlpVF6sSJ2H//XbFPqDSVTfZj/P6/Pi4uDpPJRH5+/jGP5+fn07Vr1yZfExQURFCjL0JUVBQAPXr0ICUlxWOxCk1jsVhIT08nJSVFdpatpNJc7rZ1Wa1WDh46TLfkHiIUNEA+f22Rz9/zpHSPavJx2fdrSwlKJrkiKgoiI0+2OMTFgckEx+kt8vOhGb2lB/zecBsYGMioUaNYvny56zG73c7y5csZN26chpEJgiAIgiD4CYGBMGoUNNJb2O3K7zrWW53i9Pj222/nqquuYvTo0Zx66qk899xzVFdXc/XVV2sdmiAIgiAIgn9w++1w1VUwejSceio89xxUV4OO9VanEMqzZs2isLCQ+++/n7y8PIYPH8533313QoGfIAiCIAiC0E5mzYLCQrj/fsjLg+HD4bvvTizw0xGdQigD3HTTTdx0001ahyEIgiAIguC/3HSTcvMTOo1Q9gR2u53a2lpqamqorq6mpqaGmpoaGhoaCAsLIyIigsjISCIiIo4pDhQEQRAEQRB8HxHKbWDevHnU1tZSWFhIYWEhJSUltHawYUBAAD179uT888/nD3/4AxMmTJAqXkEQBEEQBB9GhHIb+OGHH5p9Ljg4mLCwMEJDQwkICKC6uprKykpqamoApc3N/v37ef7553n++eeJiopixowZ/OEPf+CCCy4gLCzMW29DEARBEARBaAUilNvAgw8+yIABA4iPjyc+Pp64uDgiIiIIDQ1tdrS1zWajqqqKiooKNm/ezJdffsnXX39NYWEh7733Hu+99x6DBg3il19+cfVr9meqq6spKChw3UpLS6mpqaG2tpa6ujpqa2upra3FbrdjMpkwmUwAHDx4kK1btxIdHe26RUVFER0dTWxsLElJSQQGBmr87gRBEARB8CdEKLeBq666qs0DR0wmE1FRUURFRdGjRw9mzpyJzWZjw4YNfPHFFyxevJj09HQuv/xyvvjiC5cw1Ct2u53s7Gz27NnDnj172L17N3v27GH//v3k5+e7MuzuxmAwkJSURM+ePenZsyc9evQgNTWVYcOGMXToUCIiIjyyXUEQBEEQ/BcRyhpgMpkYP34848eP509/+hNnnHEG33zzDffddx+PPfaY1uG1CZvNxpYtW1i1ahUrV65k7dq1VFZWtvia4OBgEhMTSUhIIDY2lpCQkBNuRqMRm82GzWajoaGBAwcOkJycTHV1NWVlZZSXl1NWVkZZWRklJSXU19eTm5tLbm4u69evP2Gbffr0YdiwYQwfPpyxY8cyYcIEQkJCPPWxCIIgCIKuKSoqIlbrIHwAEcoaM2rUKN58800uv/xyHn/8cYYNG8asWbO0DqtFysvLeeedd/juu+9YvXo1FRUVxzxvNpvp06cPAwYMoH///gwYMIB+/fqRlJREQkIC4eHhGAyGVm/PYrGwdOlSZsyY0WQBpMPhoLCwkMzMzGNue/bsYfv27eTk5LB//37279/Pp59+CihjyidMmMDUqVOZOnUqQ4YMadY+IwiCIAidhZKSEhYuXMh/n3uOPK2D8QFEKPsAs2fPZvv27Tz55JNcffXVpKWlMWLECK3DOoHdu3fz4osv8tZbb1FVVeV6PCoqiokTJzJlyhQmT57MKaec4tWOHgaDgYSEBBISEhg9evQJzxcVFbF9+3a2b9/O1q1bWbVqFdnZ2fz444/8+OOP3HnnnSQkJHDJJZdw7bXXMnLkSK/FLgiCIAi+QEVFBc8//zwLFy6koqICMSwqiFD2ER577DF27NjBd999x8yZM9m0aRMJCQlah4Xdbufbb7/lhRde4Pvvv3c9PmjQIObMmcOZZ57J8OHDfdpbHRcXx1lnncVZZ50FKBnoPXv28MMPP/DDDz+watUqCgoKeOmll3jppZcYMWIE1157LbNnzyYmJkbj6AVBEATBc9TX1/Of//yHJ554guLiYgCGDBnC3TfeCNddp3F02iPXmn0Ek8nEe++9R1paGpmZmVxyySU0NDRoGtPhw4c57bTTOP/88/n+++8xGAz84Q9/4Mcff+T333/njjvuYNSoUT4tkpvCYDAwYMAAbrnlFr7++mtKSkr4/vvvueyyywgMDGTr1q3cdNNNdOvWjb/85S/s3LlT65AFQRAEwe1s3LiRkSNHcuedd1JcXExaWhrvv/8+27ZtY9q0aVqH5xOIUPYhoqOj+eKLL4iMjGTNmjU88cQTmsWyYsUKRo8ezaZNm4iMjGT+/Pns27ePL774grPOOqtNHmNfJzAwkKlTp/Lee++Rm5vL888/z5AhQ6irq+Odd95h6NCh/PWvfyUnJ0frUAVBEAShw9TW1nLnnXcybtw40tPTSUhIYPHixezcuZNZs2ZJzU4j5JPwMQYMGMCCBQsARax6G4fDwdNPP80555xDUVERI0eOZMeOHSxcuJDU1FSvx+NtunTpwi233ML27dvZuHEjF198MXa7nTfffJN+/fpxzz33UF5ernWYgiAIgtAufv75Z4YPH85TTz2F3W7n8ssvJz09nTlz5mA2iyP3eEQo+yBjxowBYNeuXV7dbnV1NbNnz+Yf//gHdrudK6+8krVr19KrVy+vxuELGAwGxowZw8cff8wvv/zCGWecQW1tLY899hh9+/blxRdfxG63ax2mIAiCILSKhoYGbrvtNiZMmEBGRgbdunXjyy+/5J133qFLly5ah+eziFD2QQYMGABAfn4+paWlXtnmoUOHGDduHO+//z5ms5kXXniBJUuWSK9hYNy4caxevZrPP/+c/v37U1RUxM0338yMGTMoLCzUOjxBEARBaJGysjLOPfdcnnvuORwOB9dccw07d+7kggsu0Do0n0eEsg8SHh5O9+7dAe9klR0OB3/+85/57bffSExMZMWKFdx0001+5UPuKAaDgT/+8Y/8/vvvLFq0iJCQEL7//ntGjBjBL7/8onV4giAIgtAkhw4dYvz48axYsYLw8HC+/PJL3nzzTaKjo7UOTReIUPZRBg4cCHhHKL///vusX7+esLAwNmzYwIQJEzy+Tb1iNpu54YYb2LBhA/379ycnJ4dJkybxzDPP4HA4tA5PEARBEFxs3LiRsWPHsmvXLpKTk1m7dq1kkduICGUfRRXKu3fv9uh2amtr+ec//wnAXXfd1Sn9yO1hyJAhbNq0iVmzZmG1Wpk/fz4XX3wxZWVlWocmCIIgCHz22WdMnjyZgoIChg0bxvr16xk2bJjWYekOEco+ircyys888wxZWVn06NGD+fPne3Rb/kZERATvvfceixYtIjAwkM8++4yxY8eSlydDPwVBEATteOGFF7j44oupra1lxowZrFmzxmXpFNqGCGUfRS3o86RQPnLkCI8//jgACxYskMK9dmAwGLjhhhv4+eef6dGjBxkZGUydOpWSkhKtQxMEQRA6If/3f//HLbfcgsPh4Prrr+eLL74gIkIGUrcXEco+ippRPnjwILW1tR7Zxr333kt1dTVjx47lz3/+s0e20VkYPXo0K1euJCkpid9++41zzz2XyspKrcMSBEEQOhFr167l6quvBuD2229n0aJF0hu5g4hQ9lESEhKIiYnB4XCQkZHh9vVv3bqVxYsXA/Dss89Khws30KdPH5YtW0aXLl3YuHEjF1xwgcdOcgRBEAShMfv27WPmzJk0NDRw4YUX8tRTT8mx3Q2IUPZRDAaDxwr6HA4Ht99+Ow6Hg8suu4xx48a5df2dmcGDB/P9998TERHBTz/9xCWXXEJDQ4PWYQmCIAh+THFxMTNmzKC4uJgxY8bwzjvvyBhqNyGfog/jKZ/yF198wapVqwgODnaNyxbcx6hRo/jmm28ICQlh6dKlXHHFFdhsNq3DEgRBEPyQ+vp6LrroIvbu3UvPnj358ssvCQ0N1Tosv0GEsg/jic4XDQ0N3HHHHYDiX5J2cJ5hwoQJfPbZZwQEBPDRRx9x6623ah2SIAiC4Gc4HA7mzp3L6tWriYyM5JtvvqFr165ah+VXiFD2YTwhlD/88EP27dtHYmIid911l9vWK5zItGnTeP/99wF48cUX+e677zSOSBAEQfAnnnrqKf73v/9hMpn46KOPOOWUU7QOye8QoezDqEI5IyPDbZfuN2zYAMDll18u7WK8wEUXXcQtt9wCwLXXXktpaanGEQmCIAj+wN69e7n//vsBJRkzdepUjSPyT0Qo+zC9evUiODiY+vp6Dh065JZ17tixA4Dhw4e7ZX3CyXn88cdJS0sjNzfXJZoFQRAEob04HA5uvPFG6uvrmTp1KvPmzdM6JL9FhLIPYzKZSEtLA9xjv3A4HC6hPHTo0A6vT2gdoaGhvPXWWxiNRt555x0+/fRTrUMSBEEQdMwHH3zAsmXLCAoKYtGiRdIGzoOIUPZx3OlTzs7OpqysDLPZ7OqoIXiH0047jX/+858AzJs3j4KCAo0jEgRBEPRIWVkZt912GwD33HMPffv21Tgi/0aEso/jTqG8fft2QGk7FxQU1OH1CW3jgQceYOjQoRQVFTFv3jwcDofWIQmCIAg649577yUvL4+0tDTuvPNOrcPxe2SuoY/jTqGs2i6GDRvW4XUJbScoKIi3336bMWPG8Pnnn/POO+/wl7/8Reuw2oShvp7AQweoT+0LAQFahyMch7G8jKAD+zAXFTa6FWAuKsIRYMYaG4c1Lh5bbBesXeKwxiVQN2AQjpAQrUMXBKEVbNq0iZdeegmAl19+WZJeXkCEso+jWiR2796Nw+HokA9J/MnaM2zYMB588EHuuecebr75ZqZMmUL37t21DqtFjFWV9F2/lpQP3iJy5Y+YqippSEqm5MprKZl9FbbYLlqH2GkxlpcRtnEdYevWEr5uDcE7f8PQxisV9sBAakaMpnr8BKrHTaBm5BgccvAVBJ/DZrNx3XXX4XA4uOKKKzjzzDO1DqlTIELZx0lLS8NoNFJWVkZ+fn6HGomLUPYN7rzzTr788ks2bNjAPffcw1tvvaV1SCficBD19edEf/oB4atXMqyh/uhTZjOBR3Lo+sTDJDz3BGUzL6X4mnnUDRqiYcCdB3N+HjEfvkvUt18S/PuOE4SxpWs3LAmJWOPiXTdblziw2ZQMc0kR5uJiTEWFBOTlElBYQPiGXwjf8As8+wT2oGCqTz2N0ksvp2LGH0Q0C4KP8NJLL7Flyxaio6NZuHCh1uF0GkQo+zjBwcH07t2b/fv3s2vXrnYL5draWvbs2QOIUNYas9nMCy+8wKmnnsq7777L/fffT58+fbQO6xhi336T5Hv/4fq9LDGJ+pmXUHneH6kbeApR33xOlzdfIfS3bcR+8A6xH7xD1fgJZD/1ApaeKdoF7qcY7DYiV/xA3AfvELn8ewyN+qrXp/alatwZVJ92BtWnnY61a1LrV+xwEHjoAGG/rCH8lzWErVtDQGEBEWtWEbFmFdaH7qbksispuWIOlu493f6+BM9grKwg4sfviVr6BWEbfsFhNmMPDcMeFoY9LBx7aBiWpG6UzJ5D7YhRWocrtILc3FzuueceABYsWEBiYqLGEXUeRCjrgIEDB7qE8pQpU9q1jvT0dOx2O3FxcSQlteFAKniEMWPGcO655/Ltt9/y+OOP88Ybb2gdkovAgwdIelRpYl/8l2spuHwOywuLOP2MCZjNyi6j7OLLKLtoFqGbN9LlzVeI+vZLwn9ZQ98LzuLwa/+jZux4Ld+C32AqLiJu8atc+b//ElFS7Hq8evRYSmddQeXks9smjI/HYKChdx8aeveh9PI54HAQtHcPUUu/IPbdtwjIyyVh0TPEv/wclWdNo+jqeVSfMQmkFZXPYSwvI/LH74j6+nPCV6/A2NBw0tfEvv8/qsaOp+j6v1M55RwwSn2/r/LEE09QWVnJ2LFjmTt3rtbhdCpEKOuAAQMG8PXXX3eooK+x7UL6LfoG9913H99++y1vvfUW9957LykpKVqHBDYb3effgLG2hqrxE8j991NY7XYoWnvisgYDNaPHUjN6LHlZh+k170pCfttO7z//kdzHnqH0Mn0VKvoSptJS4l57kS6LX8VUXQWANTqGsosvo+TPV1Lff6BnNmwwUJ82gIK0ARTcNJ/IZUvp8vabhK/9ichl3xK57FuqzpjEkXsepu4UKQr2BQwNDcS9+gIJ/1mIsa7W9Xhdn35UnPdHKs6ZgSMoEGN1tXKrqcJYVUX4L2uI+uJjl+2mLm0ARX+7ibKZl4rdxseoqKhg8eLFADz88MMY5YTGq4hQ1gFq54vdu3e3ex3iT/Y9xo0bxznnnMOyZctYsGABr7zyitYhEff6IsI2rccWHkH204uUDJPdftLXWXr0Yv8n39L99huI/vpzut9xM0EZu8m752EwmbwQuX9grCgn7s2XiXv9JUyVFQDUnDKUNRPPJvGW2zGFhXsvGLOZinP/QMW5fyBoXwaxb71O7P+9Rfjan+g7YzJlF88i7877sCYley8m4RhCN60n+a7bCM5Qkih1aQMoP++PlJ83k/q0AS1m/ssunU3enfcS9+YrxL67hOCM3XT/x03Ev/gMhxe/T33fNG+9DeEkLFmyhMrKSgYOHMg555yjdTidDjkt0QHuaBGn9lCW1nC+xX333QfAf//7X7KysjSNJWh3OolP/RuAIw881mZPqiMklKxF/yX/NmWwSvzri0i5+jKMFeVuj9XfMNTVEffSc/QfP4zEZxZgqqygrv8gDr/2P/Z8uZy94yfiCArWLL76vmkceeQpMlZtouyPl2BwOIj5+H36TxhF4hOPYHSKesE7GMvL6Hb3bfS5aDrBGbuwxnYh6/lX2fvjOgpuv1u54tCKK4fWpGTy7n2E3Rt+58i/HsKSkEjQoQP0mXkOYT//5IV3IpwMu93OCy+8AMDNN98sV4Q1QISyDlCFck5ODhUVbT8gyehq32XChAlMnjwZi8XCE088oV0gFgs9brsOY0MDFWdPo3TWFe1bj9FIwe13k/nSYuxBwUSsXEafC6djzjvi3nj9iIjl39Pv7HEkPf4g5vIy6vqmkbnov+z9YS0V517gU35gS49eZL34Bvu+XE71qeMw1teR8OLTpE0ZS8Ty77UOr1MQufQL0s4cS5d3lEvxJbOuUE5gLprV7u+KPTKKouv/zt4ffqZ61KmYysvpfcXFxHzwjjtDF9rB0qVL2bdvH9HR0Vx55ZVah9MpEaGsA6Kjo13dLtpjvzhy5AjFxcUYjUYGDRrk7vCEDnL//Urh3BtvvEFubq4mMST85ylCft+BNTqGnAXPd1iclV9wIQc++RZLYhLBGbtIvfQ8AnK0zZj7GgGHD9Hr6stImTOLoMMHsSR0JeuZl9j74zrK/3CRTxdW1Y4YxYGPl3LojXepT0klIP8IKXNm0f226zGWlWkdnn9is9H13/fRa95VBBTkU9enHwc+/JqchS9ii4l1zya6xHHw/S8pu+AiDFYr3f9xE4kLHm6V/UrwDP/5z38A+Otf/0pYWJjG0XROfHdPLByDOnikPfYLNZvcv39/goO1u3wrNM3kyZM544wzqK+v56mnnvL69kO2byXhhacByH3sGayJ7e/V3ZjaYSPY/+m3NPToSdChA6ReMoOAw4fcsm49Y6itJeHpx0g7ayyRP36Hw2ym8LpbyPhpE2WXztaPp9tgoHLaeez94WcK/3YTDoOBmI/fI+3scZJddjPGinJ6XfNn4l9VLsEXXv939n2/lupxZ7h9W47gYLJefIOCW5T2kAmLnqHHjddgqK09ySsFd5Oens6yZcswGo3ceOONWofTaRGhrBM6UtAn/mTfxmAwuLLKr7zyCnl5ed7buM1G99tvwGCzUXbBRZRfcKFbV2/pmcL+T76lvncfArOz6HPxuQTu3+vWbeiJsDWr6Hf2OBKfexJjfT1VZ0xi7w8/k3fPw9jDI7QOr104QkLIu+/fHPj0O+pT+zbKLl8n2WU3EHjwAH1mTiVyxQ/Yg4LJXPRf8v71kGc7UxiN5N9xL1nPvIQ9IIDorz8n5ZrLwGLx3DaFE1C9yX/84x99oytSJ0WEsk7oSEGf+JN9n7PPPpvTTjuNuro6nn76aa9tN3TTeoIzdmGLjCT3Uc9MerImJXPg46XUpQ0kIP8IqZeeR9DudI9sy1cxlZbQ/bbrSZ09k6DMQzQkJXP4lbc4+H+fU9+vv9bhuYWa0WPZ+90aCufdjMNoJObj9+k3/QxCf92gdWi6JWztT/S54EyC9+7B0rUb+z/9TrHleImyS2dz6N1PsYWFE772J5LvmQ9tHJEutI/S0lLefvttAG655RaNo+nciFDWCSKU/ZvGWeWXXnqJoqIir2w36pvPAaiYep7bfI5NYU1I5MBHX1M7eAgBhQWk/ul8gn/b5rHt+QwOB1FffEK/M8cS8/F7OAwGiq7+G3tXrKfivD/6VKGeO3CEhJB37yPs/+x76lNSCczJJvWSGcQvelZ8rm0k9u036X3FRZjLy6gZMZp9X6+gbuhwr8dRPW4CWYvexGE0Evve28S99qLXY+iMvPHGG9TU1DB06FAmTZqkdTidGhHKOkH1KO/fv5+GVkxcUqmvr3fZNUQo+zbTp09nxIgR1NTU8O6773p+gzYbUUu/BHC75aLJzcV24cD7X1EzfBTm0hJS/3QBYevWeHy7WhGQm02vay6j503XElBUSF3aAA589j1HHn5StzaL1lI7cgz7vv2JspmXYrDZ6LrgIVKuuBhzYYHWofk+DgcJCx8l+Z75GGw2Si+exYEPv3Zb7UB7qDxrGkfuU1pHdn30fiJ+WKpZLJ0Bq9XKiy8qJyR///vfpSWcxohQ1gnJyclERERgs9nYu7f1Hs9du3ZhtVqJiYmhe/fuHoxQ6CgGg4Grr74awCtCOXTTegIK8rFFRVF1xmSPbw/AHh3Nwf/7jKpxZ2CqqiTliouJ/PZLr2zba9jtxC55nX5nnkbkj99jDwggf/7d7Pt2NTWjTtU6Oq9hD48g6z+vkb3wRewhoUSsWUnfaWcQvnql1qH5LjYb3f51O4nPK0W9+fPvJvvZV3D4QBF28bXXU3zFNRgcDnrcPJfgnTu0Dslv+fLLL8nMzKRLly78+c9/1jqcTo8IZZ1gMBja1flCRlfri1mzZmEymdi0aVObTojag2q7KJ96Ho7AQI9uqzH2iEgOvf0x5edegLGhgZ7XzSHm3SVe274nCcrYTepF00m+7w5M1VVUjx7Lvu/WUHDrP736GfsMBgOls65QbAP9BxFQWEDKFReRsPBRsNm0js6nMNTX0/OGq+nyzmIcBgM5jz1Dwa3/9B17jsFA7sNPUDlhCqaaalLmXCb90T3E888/D8C8efMICQnROBpBhLKO6NGjBwAFBa2/fCn+ZH2RkJDgGlHq0axyI9tFxfkzPbedZnAEB5P58hKKL5+DwW6n+123kvDck7otFDLU15Pw7AL6Tp9A2OaN2MLCyXnkKQ588q0ySriTU582gH1fLVf+3g4Hic8/RcpfLsFU7B0vvq9jrKwg5apLiVr6JfbAQDJfXkLJX67ROqwTCQgg8+XF1PVNIyAvl17XzsZQW6N1VH5Feno6q1evxmQyccMNN2gdjoAIZV2h9kCur69v9WtEKOuPyy+/HFCEssNDwlEL28UJmEzkPv4s+X+/A4DEpx+j23136q7oK3TDL/SdMZnEZxZgtFioOGsae1esp2TOXJ8eGuJtHCEh5C54jqznX3VZMfpNn9jpu2KYigpJnXUB4T+vxhYWzqG3P1IKPX0Ue1Q0hxd/gDUmltAdW0n+13ytQ/IrvvjiCwCmTZtGcnKyxtEIIEJZVwQ5+2bW1dW1+jXSQ1l/zJw5k9DQUPbt28fGjRs9so3orz8HvG+7OAGDgYJ/3EPuI0/iMBjo8tbrpMyZpYtMozk/j+63/I0+l8wgOGMX1i5xZL74JocXv4+lm9QDNEfZRbPY99Vy6vr0IyAvl9RLz6PLGy/p9mpCRwg8dJA+M6cS8tt2rF3iOPDh11Sf7vsdDhpSepP56tvONoDvEfXFJ1qH5Dd8/fXXAFxwwQUaRyKoiFDWEapQbm1GOT8/n4KCAgwGA4MHD/ZkaIIbCQ8PZ+bMmYCH7Bc2m6uATgvbRVMUz/kbWS++iT0omIiVy+g3bQKh63/WOqymsViIe+1F0iaPIeazD3EYDBRfPoeMlRsp/+PFvuMp9WHq+w9k/9crKDv/QgxWK90e+hc9brgaY2WF1qF5jeAd20i9cCpBhw/S0LMX+z/7XpP2b+2letwZFNysZJOT/3UbAVmHNY5I/xQVFbFu3ToAzjvvPI2jEVREKOuItgpl1XbRr18/QkNDPRaX4H5U+8UHH3yA1Wp167rDNq7T3nbRBOV/uEjJNPZNUwaTzLqA+P8s9CkrRtgvq+k3fSJJj9yLqaqSmuGj2P/lcnIXPOfRPtT+iD08gqyX/kvuQwtwmM1Ef/05fc+dRPDv27UOzeOEr15J6p/OJ6CokNrBQ9j/2Q809O6jdVhtpuDWf1I96lRMFRX0+Ps8cPO+qrOxdOlSHA4Hw4cPd9UkCdojQllHtNWjLP5k/XLOOecQFxdHQUEBP/74o1vXHfWN4oHT3HbRBPUDB7P/6xWUXnIZBrudrk/92yf674b+uoGU2TNJnfUHxWYR24Xsp/7D/i+WUTt8pKax6RqDgeJrrmP/J9/SkNydoMMH6fPHc4h9+02/tWJEf/YhKVddiqm6iqrTJ3Lgo2+wJiRqHVb7MJvJ+s9r2MIjCNu0noQXPDPds7Og2i7OP/98jSMRGiNCWUe01aMs/mT9EhAQwKxZswA32y9sNiKXOoWyF4aMtAd7WDjZz75C1tOLjum/G/PuErBYvBpLyNZfSbniYvpcOI2INatwmM0UXzWXjFW/UnrZlVKs5yaUASVrqDh7GsaGBpLvmU+PG67xOytG3Gsv0uOWv2GwWin7w8Uceusj7BGRWofVISw9U8h57BkAEp57ktBN6zWOSJ80NDTw/fffAyKUfQ3Zy+uI9lovJKOsT1T7xWeffUZ1dbVb1hm2cR0BhQXYoqJ8vmio7E+XK/130wYSUFhA97tuJW3KqUR/+oFne/A6HIRuWk+vq/5E3z+cTcRPy3GYTJRc9hf2rN5M7r+fwhYT47ntd1JsMTEc/u/7HLn3EacV4zP6zpjsF1YMQ3093e66laRH7gWg6NrryXrhdRzOfbreKb/wUkovnoXBbqfHLXMxVpRrHZLuWLt2LRUVFSQkJDBmzBitwxEaIUJZR7RFKFssFtLT0wERynrltNNOIzU1lerqalfLoI4SpXa7mHa+z9kumqI+bQD7vllJ7oOPY4mLJ+jwQXr8fR79pp6uZMbdeHk+IPMQCc89SdrEUfS5aDqRK35QBPKfLmfPT5vJeeoFLD16uW17QhMYDBTNu5kDHy+loVt3gg4doM8fziZ+0bO6HVBizs+j96wL6PLuEhwGA0fueYQjDzzmd1cjch95ivqeKQRmZ5F89+1+a53xFF999RWgFPEZ/ey7oXfkr6Ej2uJRPnDgABaLhfDwcHr1koO7HjEYDMyePRtwk/2iUbeLch/pdtEaHMHBFF97PRlrt5L3z/uxRUURnLGbXvOuot+UU0l66F+Er/yx7YMPHA4CcrKIee9tel8ygwGnDyfx6ccIOnQAW2gYJbOuIGPlJnKeXoSlV4pH3pvQNDWjTmXfd6spnzoDo8VC1wUPkXrJDAIPHtA6tDYRsmUTfWdMVobQREVx6K0PKbruZr/sjGKPiCTrxTdwmExEf/kJ0Z99qHVIusHhcLiEstgufA+z1gEIractGeXKykoAoqOjZXS1jrn88sv597//zffff09hYSHx8fHtXlfYxl8IKCzAGhXt87aLprCHhVN40+0U/+Ua4l5fRNwbLxO8fy/B+/cS98ZL2AMDqRk9lqqJZ1KfkoojMBBHUDD2oCAcQcpJZtDe3YTs/I3g9N8ITv8dc3mZa/0Og4GqMyZRdvFlVEw/H3tYuEbvVACwxcSS+ca7RH/0f3R74C7Cft1Av2lncOTeR5SpdT6+X4t572263fsPjA0N1KUN5PAb79LQO1XrsDxK7YjR5N92F10XPkq3++6gatwZWJNkaMbJyMjIYP/+/QQGBromswq+gwhlHdGWYj5VTKtZaEGfDBgwgJEjR7JlyxY+/PBDbrzxxnavK+prxb5RMc33ul20BXtUNAX/uIeiuTcSsXol4WtWEr56BYE52YT/sobwX9a0el0Os5m6AYMou+Aiyi68VA7qvobBQNmfLqd6/AS6334D4evWknzPfCK//4acp/7jk4NdjNVVdP33fXR5ZzEA5dPPJ/vZl7GHR2gcmXcovPE2In/8jtBtm+k+/0YOvfOp39lM3I3a7WLy5MlERHSO74meEKGsI9qSUVbFtAhl/XPFFVewZcsW3n333Q4J5fCflgNQca5/THyyR0VTfsGFSvcOh4PAg/sJX72S8F9WYyopxlhfj6G+zvXTYLVR3zuVusFDqB00hLpBp1Dfb4DfFFT5M5buPTn4/pd0WfwqXR9/iIjVK0ibNIbCG/5O4XW34AjxjT7x4St/JPlftxGYnYXDYCB//r8ovHl+5xKKZjNZz71Cv+kTiViziti331TGuQvNIrYL30aEso5oj1AOEhGgey677DJuv/121q1bR15eHl27dm3zOkylJQQdPghAzaix7g5RewwGGlL7UpLaVw7K/orRSPG111M16SyS7/w7YZvWkfjMAmLef4e8ux/UdCqiqaSYpIfuJuZTxZfb0L0HOU/8h6qJUzSJR2sa+vQj756H6HbfnSQ9ej9VE6fQkNpX67B8ktLSUtauXQuIUPZVOtFprv5pSzGfWC/8h6SkJIYPHw7AqlWr2rWOkO1bAajv3Udamwm6pr5vGgc+WUrmS4tpSO5OYG42PW/+K6kXTXd9z72Gw0H0Zx+SNuVUYj79EIfRSNFfb2Dvj+s6rUhWKb7yr1ROmIyxrpYet14nU/ua4fvvv8dmszF48GB69+6tdThCE4hQ1hFt8ShLRtm/OPPMMwFYsWJFu14fum0zALXDZIqc4AcYDJRfcCEZKzeRP/9f2ENCCft1A33Pn0LKFRcT8eN3nm0n5+wgk3rxufS45W+YS4qpHTCI/Z8v48gDj0khKIDRSM7CF7FFRhK69VfiX3pO64h8EpnG5/v4vVBOSUnBYDAcc1uwYIHWYbWLtlgvJKPsX6hCefny5e16fcj2LQDUyLhlwY9whIRQcOud7PnpV0ovnoXDYCDip+WkXH0Z/SeOJO6VFzCVlrpte8aKcuJee5H+E0bQ629XErZpPfbAQPLuuJf936yidsQot23LH7B0607uw08CkPjsAr8YHuNOrFYrS5cuBTqpUH70URg/HkJDITpa62iaxe+FMsDDDz/MkSNHXLebb75Z65DahXiUOy8TJkzAZDJx4MABDh061LYXOxwuoVw7XA7kgv9hTepG9nOvsmfNVgrn3Yw1KprAzMMkPXofA8YMpPstfyPm/f8RuH9vmwdhmMrL6PHbVro/cBcDTh1M0iP3EpiViTUmloKb5rNn7TYKb/mHrjvJeJKyi2ZRfu4FGKxWevz9Ogy1tVqH5DOsW7eO0tJSYmNjGTdunNbheJ+GBrj0Urj+eq0jaZFOUcwXERHRrgIoX0M8yp2XyMhIxowZw/r161m5ciVXX311q18bkJtNQGEBDrOZ2kFDPBilIGiLpVcKefc+Qv78u4n+4mO6LHmdkJ2/EfPZh8Q4B2BYY7tQPXosNWNOo6FXCg6TGUdAAJjMOMwmcDgI3rOLkG1bCN22maCD+2k827QubSBFf72espmX4ggJ0eaN6gmDgZzHnyX01w0EZ+wi6ZF7yX3saa2j8glU28WMGTMwmUwaR6MBDz2k/FyyRNMwTkanEMoLFizgkUceoWfPnsyePZvbbrsNs7n5t15fX3+MGFWHd1gsFiwWi8fjbQ51rGV9ff1J46iurgYgMDBQ05jdgRq/3t9HR5k8eTLr16/nxx9/5IorrmhxWWujwpmwLb8CUNt/IJaAgDYX1ajrskoxjibI598OAgIpvGQ2hRf/mbDNG4lc8QPhv24gdPtWzCXFRP2wlKgflrZ6dWWJSdjGjqfkT5dTNX7C0e4a8jdpFdaoaA4vXETfqy6ly//epHzcGZQ3alPZ3L7d3/f9alu46dOn++R7dMVUWQkVFUefCApSbp0EvxfKt9xyCyNHjiQ2NpZffvmFu+++myNHjvDMM880+5rHH3+ch9QznUasXr2a9PR0T4bbIkVFRQDU1ta6fE3N8dtvvwGQn59/0mX1wrJly7QOQVNCQ5Vesd999x3ffPNNixMXs6qO3h+3VBlbfSAhiZ9/Xtvu7W/YsL7drxU6jnz+HeD0KXD6FIwWCwmH9pOUsZuuGbsIqazAaLNhtNsw2mwYbDaMdjtlXZPIT+1HQZ80Cnr3oS4i8ui6fvlZu/ehZ0wBjDv/QkZ9/Rnd/nETaxosVMYlAJB5ktpHf9z3V1RUsGvXLkAZYe2Lx+mGoiIuBSIHDTr2iQcegAcf1CIkTTA4HG00bPkAd911F0888USLy+zatYsBAwac8Ph///tf5s2bR1VVVbP+3eMzyjk5OQwaNIiMjAxSUlI6FHtHKCwsJDlZmRxWV1fnyjA3xT333MNTTz3FLbfcwsKFC70VokewWCwsW7aMc845h4CAAK3D0Yza2loSEhKor6/nt99+o3///s0u+3vO0bP/vrNnErFuLYcXPEfJrJYz0U1htVrZsGE9Y8ee1uKVGMEzyOevLfL5uxGLhbQ/nU/Yts1UjTqVve9/CWYzpyRHNrO4/+77ly1bxnnnnUffvn01TcC1RMmhQySmpVGRnk5kcqOppS1llO+6C06iz9i1CxrrsyVL4NZboaysgxF7Bl3+18+fP585c+a0uExqamqTj48dOxar1cqhQ4eaFRpBQUHHiOgK5yWHgIAATf9Zw8OPnnbb7fYWC/XUSyYhISF+s4PR+vPXmoCAAMaPH8/KlStZs2YNp5xySrPLug7oNhuhvymV5vUjx3ToQG82m0UoaIh8/toin78bMJvJWvQm/aZPJHzzRpL/s5D8O+896X7dH/f927ZtA2DMmDE++95ccUVEQGTTJzMnMH8+nESf0Yw+81V0+V8fHx9PfHx8u167bds2jEYjCQkJbo7K8zQuzKuvryekhUISKebzT84880xWrlzJ8uXLub4VlcJB+/diqqrEHhJKfb/mM9CCIAjewNIzhZwnnqfnDVcT/+LTiuf7sj9oHZbX+fVXpXZk9OjRGkfiZuLjlZsf4dft4datW8dzzz3H9u3bOXDgAO+++y633XYbV1xxBTE6nE7W+KzzZENH1OdFKPsXaj/llStXYrfbT7q8qy3ckGEg2TBBEHyA8gsupGT2VRgcDnr8/W9QUKB1SF7Hb4VyW8jMhG3blJ82m3J/2zaoqjrJC72LXwvloKAg3n//fSZNmsTgwYN59NFHue2223jttde0Dq1dGAyGVvdSlj7K/smYMWMIDw+npKSEHTt2nHT50G3OQSMykU8QBB8i98HHqUsbQEBBPsyeDT7Y9cFT5Ofnk5WVhcFgYMSIEVqHox333w8jRijFgVVVyv0RI8B5EuEr+LVQHjlyJOvXr6esrIza2lrS09O5++67dS0eWyuUxXrhnwQEBDBx4kSgdeOsZdCIIAi+iCMklMxF/8UWGgbLl8PcuW0eBqNX1GzygAEDiIiI0DgaDVmyRPmbH3+bPFnryI7Br4WyP9LaoSOSUfZfVPvFyYSyob6e4HSlTaCMrhYEwdeoHzCIrJcXg8kEb73VaVqOqUJ5zJgxGkcitAYRyjpDMsqCKpR/+umnFpvUB6f/jtFiwRoTi6VHL2+FJwiC0Goqz5wKL7+s/PLww/Dmm9oG5AXEn6wvRCjrDFUot7aYTzLK/sewYcOIiYmhqqqKzZs3N7vcMbaLFoaTCIIgaMrcuXDvvcr9efPg22+1jceDOBwOEco6Q4SyzpCMsmA0GpkyZQoAy5cvb3a50O2KiK4Z1omLRQRB0AcPPwxXXql0P7j0UtiyReuIPEJubi55eXmYTCaGDRumdThCKxChrDPa2vVChLJ/0hqfcsj2rYAU8gmCoAMMBnj9dTj7bKiuhhkzYP9+raNyO2o2efDgwYSGhmocjdAaRCjrDCnmEwDOOussAH7++ecmbTjGinKC9mUA0hpOEASdEBgIH38MQ4dCfj7mM86gy2+/aR2VWxHbhf4QoawzWutRFuuFf9O/f3+SkpKor69n3bp1Jzwf8ts2DA4HDd17YIvzrylJgiD4MVFR8N13MGoUhuJixj/4IMZXX9U6KrexadMmQISynhChrDNk4IgAyvCZluwXqu2iRmwXgiDojaQkWLMG+2WXYbTZMN18M1x3HTQ0aB1Zh5BCPn0iQllnSDGfoKIK5VWrVp3wXOg2pZCvVmwXgiDokZAQbG+9xc4rr8RhMMCrryr+ZR2Puz58+DDFxcUEBAQwdOhQrcMRWokIZZ0hHmVBZezYsQBs27YNu91+zHOuQj4RyoIg6BWDgX0XXYTt888hMhLWrIFRo5ThJDocea1mk4cOHSrHZh0hQllntCaj7HA4aHBeopKMsv/Sv39/goKCqKqq4sCBA0efOHKEwNxsHEYjtUOHaxafIAiCO3Ccey5s2ABpaZCdDXPmKPdffhlOUq/jS4jtQp+IUNYZrSnmayyiRSj7L2azmSFDhgBKVtmFs1ikvm9/7GHhGkQmCILgZgYMgM2bYcECSEiAQ4fghhsgNRWefhqqqrSO8KSIUNYnIpR1Rmsyyo1FtFze8W+GDx8OHCeUnTtjGTQiCIJfER4O//ynIpL/8x/o3h2OHIF//APi4+Gss+CRRxSLxknsid5GCvn0iwhlndEaodz4ucDAQI/HJGhHk0I5PR2AukGneD8gQRAETxMSAjffrAwkeeMN6NdPsWCsWAH33w8TJ0JMjFL89+STsGsXOByahrx//37Ky8sJCgpi8ODBmsYitA0RyjqjNcV8jQv5DAaDV+IStKFJobxnDwD1ffp5PyBBEARvERgI116r7PN27YKXXoI//UmxZtTWwvLlSgZ60CDF03z77bBqFVitXg9V7Z88fPhwAgICvL59of2IUNYZbfEoiz/Z/1FbDOXk5FBYWAh2O+zdC0BD775ahiYIguAdDAbFw3z99fDBB5CXBzt3wgsvwPTpiqDetw+efRamTFGE9BtveDVEsV3oFxHKOqMtHmXxJ/s/ERER9O2rCOLt27dDZibU12MPDKShR0+NoxMEQdAAg0HJIt90E3z7LRQVKaOxr7oKunSB0lKYOxfuvltJLngBEcr6RYSyzmiLR1kyyp2DY+wXTttFQ0oqmEzaBSUIguArRETAxRfDkiWQnw8PPKA8vmABXH65x1vM2Ww2tmzZAsCYMWM8ui3B/YhQ1hlt8SiLUO4cNCWU61PFdiEIgnACJhM8+KAims1meP99OOccKC722CYzMjKoqqoiNDSUAQMGeGw7gmcQoawzxHohHI8IZUEQhDZy1VXw/fcQFQVr18L48UoXDQ+g2i5GjhyJSa706Q4RyjpDivmE41GF8u7du7Ht3g1AgwhlQRCEljnzTPj5Z+jZEzIy4LTT4OBBt29G/Mn6RoSyzpCMsnA83bp1Iy4uDpvNhnXnTkBawwmCILSKwYOV8djDhilFf48/7vZNbN++HYARI2QIlB4RoawzpJhPOB6DwcDw4cMJBYLy8wERyoIgCK2ma1dYtEi5//bbSsGfG9m3bx8A/fv3d+t6Be8gQllnSDGf0BTDhw/HJY1jY7HFxGoZjiAIgr4YP16xXtTXHxXNbqC2tpacnBwA+vTp47b1Ct5DhLLOaItHWawXnYfhw4eTpv4iWQtBEIS2YTDAP/6h3F+0CGpq3LLaAwcOABAVFUWXLl3csk7Bu4hQ1hlt8ShLRrnzMHz4cFR57EhLa3FZQRAEoQlmzoTUVCgpgcWL3bLK/c5OGn369MFgMLhlnYJ3EaGsM6SYT2iK/v37M8io/DsXx8drHI0gCIIOMZng9tuV+888AzZbh1ep+pPVCaqC/hChrDNa41GWYr7Oh9lsZpjz752hcSyCIAi6Zc4ciI2FAwfg8887vLrGGWVBn4hQ1hmSURaaxOEgxWIB4NeKCo2DEQRB0ClhYXDDDcr9p54Ch6NDq5OMsv4RoawzGhfzOZr5B5aMcickP59QiwUbsCIzU+toBEEQ9MtNN0FQkNJf+eefO7QqySjrHxHKOqNxltjizCAejxTzdUKco6sPAb/+9pumoQiCIOiaxES48krl/sKF7V6NxWLh0KFDgGSU9YwIZZ3RWCg3Z7+Q9nCdEKdQ3gPk5ORQWlaqbTyCIAh6Ri3q+/JL1/61rWRmZmKz2QgODiYpKcmNwQneRISyzmiNUJaMcickQynhK4iKcv4qJX2CIAjtZsAAuOACxaP8zDPtWoXqT+7Tpw9Go8gtvSJ/OZ1hMpkwm81A80NHpJivE+LMeFhSUwERyoIgCB1GHUDy1lvQjiJp8Sf7ByKUdcjJOl9IMV8nxCmUQ4YPByCjnZcKBUEQBCcTJkBKijLWev36Nr9cOl74ByKUdcjJhLJklDsZDQ1Kz0+g66RJAOyRjLIgCELHMBjg9NOV++vWtfnlklH2D0Qo65CTDR2RjHIn4+BBZYJUWBgDzzoLgEOHDlFf37Q1RxAEQWgl48YpP3/5pc0vlYyyfyBCWYe0NqMsQrmToNos0tLolpxMXFwcdpuN/c4ssyAIgtBOVKG8fj3Y7a1+md1u54BzHywZZX0jQlmHNB460hTSHq6ToQrl/v0xGAwMF5+yIAiCexg6FEJDlWK+9PRWvyw3N5e6ujpMJhM9e/b0YICCpxGhrEMkoywcQyOhDDB06FDgqD9OEARBaCdmM5x6qnK/DT5ldf+bkpJCQECAJyITvIQIZR1ygkf57rvh3HPBagWkmK/ToRbuOYWy6ofLzsnRKiJBEAT/QbVftEMoi+1C/5i1DkBoOydklF9+GcrLlczi4MFSzNfZaORRhqM75hwRyoIgCB1n/HjlZxsK+qSQz3+QjLIOOcGjXFt7zE/JKHciysqgoEC57xTKqc6hIznZOThwaBSYIAiCn3DaacrPPXugpKRVL5GMsv8gQlmHHJNRttuVProAToEsGeVOhJpN7tYNIiIA6NmzJwajkfr6OoqLijUMThAEwQ+Ii3MlIlo7eEQyyv6DCGUdcoxQVkUyQG0tdrsdi8UCiFDuFBxXyAcQGBhI165dAcjJydYiKkEQBP+iDf2UHQ6HZJT9CBHKOuSYYr7GLeLq6o7phCHWi06AWsinZjucdE9OBqSgTxAEwS20oaCvuLiY8vJy4KgVTtAvIpR1yDEZ5cZCubb2mN7KklHuBDSRUQZIVoVytmSUBUEQOoxa0Ldxo6vDVHOo2eTk5GRCQkI8HZngYUQo65BjivmaEcoGgwGzWZqa+D3NCeXu3QHpfCEIguAWBg1S6kCqquD331tcVPzJ/oUIZR3SbEa5kfUiODgYg8GgRXiCt7DbYe9e5f5xQrm7KpSzRSgLgiB0GJMJxo5V7p/EfiH+ZP9ChLIOadaj3CijLLaLTkBWlvL3DwiAXr2OeUq1XkgxnyAIgptQ7RcnEcqSUfYvRCjrkNZklKWQrxOgFvL17auMWW2EKpSLioqO8a0LgiAI7aSVnS8ko+xfiFDWIa3xKEtGuRNw4IDys4mdcWRkJOHh4QDk5Ir9QhAEocOog0f27z866KkJJKPsX4hQ1iGSURYAOHxY+Xmc7QLAgOGoT1kK+gRBEDpOdLRS1AfN2i8qKyspcIpoySj7ByKUdUhr2sNJRrkT0IJQBkhOVoSytIgTBEFwEyfpp6zaLuLi4oiKivJWVIIHEaGsQ1pTzCcZ5U7AyYRyd2dBn3S+EARBcA8nKegTf7L/IUJZh7S2PZzg55xEKB+1XkhGWRAEwS2oGeVNm8BiOeFp8Sf7HyKUdYgU8wlYLJCbq9xv1nqhtoiTjLIgCIJb6N9f8SrX1sL27Sc8LRll/0OEsg6RYj6B7Gxl4EhQECQkNLlId3WMdU4Odofdm9EJgiD4J0Zjiz5lySj7HyKUdYgMHBFctouePZUddxMkJnbFaDJhaWigqKjIi8EJgiD4MS30U5aMsv8hQlmHHJNRdmaQAckodyZO4k8GMJvNJHVNAjqv/cKBg9KyUvZk7GHTr5uorq7SOiRBEPSOKpR//fWYh+vr68nKygIko+xPmE++iOBriEdZaI1QBqXzRU5ONtnZ2YwYPsILgWlLYVEhb77xBvv37ye/oIDCwkIsDQ2u5wODgpg8eTLnnXcep40di8kku0BBENrIgAHKz0OHwGp1TUY9ePAgDoeD8PBw4uPjtYtPcCtylNAhremjLBllP6e1Qlkt6PPzXsp2h53PP/+c5597vsmscUxsLIEBgeTn5/HD99/zw/ffE9ulC+dOP5fzLziffn37aRC1IAi6pFs3CAyEhgalXiQlBTjWn2wwGDQMUHAnIpR1iLSHE1orlDvDdL7DmYd59NFH2bJ5MwCDBg/m8tmzSUzsSkJiAnFxcQQGBOLAQXp6Oku/Wcp3331HSXEx7777Du+++w7XXHst1113HUaDuNEEQTgJRiP07g179sCBAy6hLP5k/0SEsg6RYj6h1UK5UecLf8NqtfK/d/7Ha6+9hqWhgeDgYK6/4QYuu+wyTEbTCcsbMDB40GAGDxrMrbfdyi+//MJXX37JqlWr+O+bb7Jv3z4eeeQRwkLDNHg3giDoitTUo0L5zDOBowmJHj16aBmZ4GZ0nT559NFHGT9+PKGhoURHRze5TGZmJueddx6hoaEkJCRwxx13YLVavRuom5H2cJ0cux0yM5X7J7Ve+OcY6/r6Ov42728sevFFLA0NnHbaaXzw4YdcPvvyJkXy8QSYA5g0cRILFz7NQw89REBgIKt/+omrr77a7z4rQRA8QGqq8vPAAddDeXl5ACQlJWkRkb44dAiuvVbJzIeEQJ8+8MADip3Fx9C1UG5oaODSSy/l+uuvb/J5m83GeeedR0NDA7/88gtvvfUWS5Ys4f777/dypO5FFcFWqxVHbe3RJySj3DnIz1d2JkYjODPGzaGOsS4tKaGmtsYb0XkcBw4WPPEEO7ZvJzwigoceeogXXnyR5G4tfxbNcd555/PG668TFxfHgf37ufKqK9m4aaOboxYEwa9oQSh37dpVi4j0xe7dStLn1Vdh50549ll45RX417+0juwEdC2UH3roIW677TaGDBnS5PM//PAD6enpvPPOOwwfPpxzzz2XRx55hEWLFtHgg2ctraVxtthe00j8NDTQIMV8/o9qu0hOhoCAFheNCI8gMioKgNycXE9H5hW++PxzvvrySwxGI08++STnnXc+BjpWODN48Cn87513GDz4FCrKy7npppv48KMP3RSxIAh+RxNCOT8/H4DExEQtItIX06fD4sUwdaryWf7hD/CPf8Cnn2od2Qn4tUd53bp1DBky5Jgv7bRp07j++uvZuXMnI0Y03S6rvr7eZWEAqKysBMBisWBpYra7tzGZjl5atlVX0/hCs8UZa0BAgE/E6g7U9+Ev76ejGPbvxwzYe/bE1sxn0thelNytGxXl5RzOPEyKs+ikLajr8gXL0u7du3niyScBuG7ePEaOGOm2uGKiY3jp5ZdY8PjjfPvttzz5xBNERERwztnnuGX97cWXPv/OiHz+nqe5fbtP7/t79CAAcBw4gNUZn5pR7tKli2/G3EZc76GyEioqjj4RFKTc3E15OcTGun+9HcSvhXJeXt4JZ3bq7+oXuikef/xxHnrooRMeX716Nenp6e4Nsh04HA4MBgMOh4Oy/HwaDzAudvor9+zZw9KlS7UJ0EMsW7ZM6xB8gr4//MBgIMdsZkszf+OsRh3SAgOVHdratWsxm07u322ODRvWt/u17qC6poZnn30WS0MDgwYPJrVPH37+ea3bt3PWWWdRU1PLTz+t4pFHHqGivNwnLqVq/fnrHavNRl5eHtnZ2WRnZZGdk4PRYCQhMYGuXbvSNTGRxMREoqOjm2ztJZ+/58gMb/l5X9z3m2trOQ8wFBfzw0cfUR8cTGFhIQA7d+70i05DDUVFXApEDhp07BMPPAAPPujeje3bBy+8AAsXune9bsDnhPJdd93FE0880eIyu3btYoDa8NsD3H333dx+++2u33Nychg0aBATJ05sV0bOEwQFBVFXV0dkYOAxj3cJUyr2x4wZw4wZM7QIze1YLBaWLVvGOeecQ8BJrAadAeN33wHQ7bTT6NrM3/j3nKNn/9t37GD79m0EBQZy+ulntHl7VquVDRvWM3bsaZjN2uwy7A478+fPp7SkhOTk7jz//PNEhEd4bHvjxo/n1ltvZdPGjbz//vssXryE8PCTHM09hC98/nqlvqGejz/6iBUrVpKxN+OY4TMqhw8fOub3sLBwpk6byl//+le6xHaRz98LnJIc2eTjvr7vd8THYygsZGq/fhxJTMThcGA0Gpk1a9YxV371SsmhQwBUpKcT2bgepqVs8l13wUk0HLt2HR3aApCTo1gxLr0U5s5tf8Aewuf+6+fPn8+cOXNaXCZV9QadhK5du7Jx47FFOaqHqKUMUVBQ0DEe3wrnJYeAgACf+WdVhbKh8QhrwOD0KIeHh/tMrO7Clz5/TXF2vDD16YOpmc+j8QG9p7NVUe6RIx060JvNZs2EwutvvM66X34hMCiIJ596kpjoGI9uz4yZxx57jCsuv4KsrCweeeQRnlr4lKZ9lrX8/PWGAwerVq3i2WefJbdRZi88PJyBgwYxcOBABg4cCMCB/fvZf+AABw8c4HBmJtXVVXz26ad89913zLnqKmbNugyQz9+TnGy/7rP7/tRUKCwkICuLEmd88fHxflNM7/rMIyIgsumTmROYPx9OouForOFyc2HKFBg/Hl57rV1xehqf+6+Pj4932+jHcePG8eijj1JQUEBCgmJQWLZsGZGRkQw6/lKCzlCFvKFxezhwtYuTYj4/ppU9lFWSu+u7Rdz69et59dVXAfjX3XfTP62/V7YbEx3Dk089ybXXXstPP63irbfe4uo5V3tl20L72btvL08vXMivv/4KQFx8PHPnzuXUU08lOTn5xJOdRh50i9XCtm3beOGFF0jfuZOXX36Zjz7+mLPOPIvTxo3D7HuHTEFLUlNhwwY4cIC80FBAOl4QH6/cWkNOjiKSR41SCvuMvtlfwjejaiWZmZls27aNzMxMbDYb27ZtY9u2bVRVKQbNqVOnMmjQIP7yl7+wfft2vv/+e+69915uvPFG3QtJ1xlrMxllfzmjFY7D4Wi7UHZeMsvNzcVmt3kqMo9gs9tYsOBxcDi48KKLOP/8C7y6/cGDBnPXP/8JwEsvvSQ+VR+morKCxx9/nNmzZ/Prr78SGBTEtX/9K59++ikXX3QxPbr3OOkVgQBzAGNGj2HJkiU8+thjJCUlUVRYyAcfvM+cq67iwMEDLb5e6GQ06nwhreHaSE4OTJ4MPXsqvuTCQsjLU24+hq6F8v3338+IESN44IEHqKqqYsSIEYwYMcKVSTCZTHz99deYTCbGjRvHFVdcwZVXXsnDDz+sceQdRxX6RlUoO4tPDDJwxL8pLQXniSA9e7bqJYmJiZhMZqwWC0XOYhO9sGLFCrKzs4mMijqmbsCbzJx5ITNnzsRht/Ovf93DkbwjmsQhNE9xcRHXXnstn3zyMQ67nbPPPpuPP/6Y66+7ntCQ0Davz2gwMm3qND7+5BNuvvlmgoOD2bt3L3+bO5e9+/Z64B0IuqR3b+WnCOW2s2yZUsC3fDl07w5JSUdvPoauhfKSJUtwOBwn3CZPnuxaplevXixdupSamhoKCwtZuHChX/jMXNYLtTjF2StXFc6SUfZT1GxyQoIyzagVmIwmunVTdj56GmXtwMFbS5YAMGvWLEKCW/d+PcEdd97JwEGDKC8v41//+hd2h12zWIRjyS/IZ+7f/sbBAweIi4/ntddfZ8GCJ+iW1K3D6w4KDOLyy6/g7rvvZsCAAZSVlTFv3jz27NnthsgF3dMooyw9lNvInDnKFdKmbj6GroVyZ8aVUVb7HMYoxU1Gp3AWoeyntNF2oaLaL/TkU964YQO7d+8mODiYWX+apWksQYFBPPnkk4SEhvLbjh388P33msYjKOQeyWXu3LlkHj5M165deeP1Nxg5YqTbtxMeHs4LL77oGkgz77rr2Jm+0+3bEXSGKpQPHSI/VxnoJBll/0OEsk4JDg4mADCoZ1/R0QCYncJZrBd+SjuFcndnQZ+eensueestAGbOnEm08/utJUldk7j6aqWY74UXXnSNixe0ITMrk7l/nUtuTg7du3fnjTfedH3PPUFEeASLFi1iyNChVFVWcsP1N/Db7795bHuCDujeHcxmsFiwObsRiVD2P0Qo65SgoCCOyRk7M8omySj7N+3NKKtCOVsfQjl9VzqbNm7EZDJz+RVXaB2Oi8tnz6Zr167k5+fx7rvvaB1Op+XgoYP8be5c8vPzSElJ4fU33vCKQAkPD+fFF19kxIgRVFdXceONN7J9+zaPb1fwUUwmcM5WCHImIUQo+x8ilHXKCULZ2eMw0Jlhloyyn9JB60VOjj6sF28tUbLJ06ZPI6mr7xR3BAUFc/MttwCweMkSCov0VRzpD2RmZTJ37lyKioro27cvr73+OvFx7mkp2hrCQsP4zwsvMHr0aGqqq7nxpps4eOig17Yv+BhO+0VkUREgHmV/RISyTjlGKAcFgbOHo1ruJBllP6UTeJQPZx5m+YrlAFx15ZUaR3MiU6dOZciQIdTV1vLyyy9rHU6nwmK1cM+//kVZaSkDBgzg1VdfJTYm1utxhASH8NxzzzNq1Gjqamu5//77sdmsXo9D8AGcQrlrba3yUzLKfocIZZ1yjFAODnZ1QAhu9Lzgh7TXo+wUymVlZVRXV7k7Krfyzv/+Bw4HEyZOpE+fvlqHcwIGDNw+fz4AX375pXRA8CIvv/wyu3btIjIqimeefZaoqGjNYgkODubfj/6b8IgIdqWns8TZoUXoZDiFcirKJLuYGM9ODRW8jwhlnRIcHHysUHZmkENQ+kf7Qws84Tiqq8F5ea+tQjksLNxVEJfjrM72RYqKivjq668BmHPVVRpH0zxDThnCtGnTweHgmWeexYHvtTTyNzb9uom3334bgPvvu4+E+ASNI4L4uHj+6RxI89prr7MnY4/GEQlep5FQ7tq1KwbnTAPBfxChrFNayiiL7cJPcVZVExnp6nLSFpK6KX1lj/iwUP6/9/4Pq8XC8OHDGTZsuNbhtMjNN99MYFAQmzf/yk+rVmkdjl9TXl7Gfffd55rQOHnyFK1DcjF9+nSmnHkmNpuVB+6/nwZLg9YhCd7kOKEs+B8ilHXKCUK5UUZZbBd+SjttFypxcXEAFJeUuCsit1JZVcnHH38MwFVz5mgbTCvo2rUrl19+OQDPP/88FqtF44j8EwcO/v3vf1NUWEivXimaTWhsDgMG7r77bqJjYti3bx+vv/aa1iEJ3sQplBOAlC5dtI1F8AgilHVKcxnlECSj7Ld0UCh3iVWKnkqKi90VkVv58ssvqamupk+fvpx++ulah9Mq5syZQ5cucWRlZblEvuBePvvsM1auXInZbOaxxx7VdEJjc8TGxPKvf/0LUPp/S3/lTkRUFDXO4++gVk5LFfSFCGWd0pxHORjJKPstHRTKsc5sh69mlFetXAnARRdfhNGgj11TWGgYf5v3NwDefecd6XzgZg4dOsTTC58G4KabbqJ//wEaR9Q8Z045k3NnzMBht/PAAw/IQJpORGF4OABpUhvkl+jjaCScgGSUOyEdzSirQtkHM8rlFeVs274dgIkTJ2ocTds4//zziY6OJi8vj9Vr1mgdjt9gtVq55557qK+vY+zY05jttLn4MnfccQdx8fFkHj7MokUvah2O4CWyAwMB6GmVE2V/RISyTmnOoywZZT/Gj60X6375BYfdTt++fX1qwEhrCAoM4sKLLgLg/ffe1zga/+HLr5TWe5FRUTz40IO6uMoQGRGpFB0C73/wAZlZmRpHJHiDA86fXWtqNI1D8Ay+v+cRmkQyyp0QP7ZerFmzFoAJEyZoHEn7uOSSSzCaTGze/Ct79+3VOhzdU19fx2vOori/zZ3r1cl7HeX08adzxhln4LDbpbdyJ2F3g9LpJLa8XONIBE8gQlmnSHu4TobFAmpbNz+zXthsVn7+5WcAztCpUE5MSOTMKUrLsg/el6xyR/ngww8pKiwkKSmJiy6+WOtw2sw1114LwDdff0NeXp7G0QieZntlJQDhBQUaRyJ4AhHKOiU4OJigo79Iezh/Jzsb7HZlXHlC+wYtdIlVhHJNdTX19b5TaLR9xw6qKiuJiormlFNO0TqcdnPZZX8GYOm331JeXqZtMDqmqqrKlYn927x5BAYEahtQOxg6ZChjxozBZrPy1ttvaR2O4EGqqqrY6SzcDFD304JfIUJZp4j1opNx6JDys2dPMLbv3zYsPIwAZ9GJL9kv1jgL4E4/43RMRpPG0bSfYcOH0b//ABrq6/n888+1Dke3/O+d/1FRXk7v3r2ZMWOG1uG0GzWr/Pnnn1OkTtQU/I78/HyyACtgaGg4euVP8BtEKOsUKebrZHTQnwzKYAS1oM+X7BdrVq8G9OtPVjFg4LI/XwbAhx9+JK3i2kFxSTHvvvsuADfceKOuT5xGjx7NkKFDsTQ08O6772gdjuAh8vLysAE5amu4AwdaXF7QHyKUdYpklDsZbhDKAF26KNP5fKXzRVZ2FocOHcJkMjPutHFah9Nhpk6dSnR0NPn5eaz66Setw9Ed/33zv9TV1jJ48ClMnjxZ63A6hAEDf3VmlT/6+GOx4/gpqge9ICxMeUCEst8hQlmnHDNwJCjomIyyCGU/xE1CObaLM6PsI9aLtWuVbhcjR44g3Nm0X88EBQa5is/el6K+NpF7JJdPPlGmG954040YMGgcUccZf/rp9O8/gLraWt577z2twxE8gCqUS2NilAdEKPsdIpR1SksZZbFe+CGqUE5J6dBqfM16ofqT9drtoinUVnFbt2xhT8YercPRDa+9+ipWq5Uxp57KqWNO1Toct2DAwDXXXgMoJ05VVVUaRyS4G1Uo13TtqjwgQtnvEKGsU5oTyoFASKD+qsSFk+Au60Wc71gvqqur2LJ5M6B/f3JjEuITOOusswD44IMPNI5GH+w/sJ9vli4F4KYbb9Q4GvcyZcoUevfuTVVVFR9+9KHW4QhuJj8/HwBLz57KAyKU/Q4RyjqluWI+gDCTfgtghCaw2yErS7nfUetFrO9YL9Zv2IDVaqVnr1707NFT63DcymWXKUV93377LWVlZdoGowNeeeUVHHY7U848k8GD9dsisCmMBiNXX6Nklf/v3XepravVOCLBnagZZVPfvsoDIpT9DhHKOqUloRwuQtm/KCiAhgalLVxycodW5UtjrNc6bRcTzvCfbLLK0KFDGThwIJaGBpZ+u1TrcHya3CO5rFy5EoDrr79e42g8w7SpU0lO7k5ZWRmffvKJ1uEIbkQVyiGDBysP5OdDdbWGEQnuRoSyTjmmmC84GEwmrM7+uqHt7LMr+Cg5OcrPxERQWxC1E9V6obVH2e6ws2atvsdWt4QBA+eddx4AP/74o8bR+Daff/45OByMOfVUUnunah2ORzCZzMy5eg4AH3/8MQ4c2gYkuA1VKHfp2xeio5UHDx7ULiDB7Yii0imNM8oOZ/Feg1Mgh4lQ9i9UodzBbDL4jvUifWc6ZaWlhIWFM3z4cE1j8RRnOn3KO7ZvJ78gX+NofBOr1coXn38BwMUXXaRxNJ5l2rRpBAUFk5WVRXp6utbhCG7A4XC4PMqJiYmQ6jzRE/uFXyGKSqc0FspWZ5axQTLK/okbhXLjMdZ1ddqNsV6zVrFdjB8/DnMHs+S+SkJ8AsOGDQdgxYoV2gbjo/y0+ieKi4uIiY1lks77Jp+M0JBQJk2eBMB3332ncTSCOygrK6OhoQEQoezPiKLSKY2FsiqQ65w/QzSKSfAQbhTKx46x1s5+4Y9t4ZrinHPOBmDZsmUaR+KbfPrJpwD88Q9/IMAcoHE0nmf69OkA/PD9D9jsNo2jETqKaruIjo5W5heIUPZLRCjrlKaEcr1BadAfYtB/o36hEW4UygYMxHVRssolGtkv8gvyydizBwwGTh9/uiYxeAuxXzRPdnY2GzasB4OBCy+8UOtwvMK4ceOIjIqiuLiIzc7WiMKJVFVV8f7773Po0CGtQ2kRVSh3VXso9+ih/MzN1SgiwROIUNYpRqPxxIyyUyAHO6RQxK9wo1AGiHXaL7TqfLFt2zYABg0aRLRa/OKnNLZfLF++XNtgfIzPPv8MgHGnnUZycneNo/EOAeYAzj5bucrw7bffahyNb5KRkcHYsWP585//TFpaGvfccw+LFy+mvLxc69BO4Bh/snJH+ekU0IJ/IEJZx6gWi7rjfsoAaz/D3ULZOca6SCOhnJGRAcCggQM12b63Ue0X0v3iKBarhS+//BLANfK7s6DaL1YsX0F9Q73G0fgWX3/9NWPGjCE9PZ3IyEgMBgM7d+5k3rx5dO3alcsuu8ynTjhPyCirQjlfrh75EyKUdYw6f0+1XKht7IPsdk3iETyEm4Wy1taLjD3KWOe0/v012b63EfvFiaxatYrSkhLi4uL8so92SwwfPpzExK5UV1fx888/ax2OT2C323nooYe44IILqKio4IwzzmDPnj3s27ePv/zlLwwcOJC6ujo++OADzj77bD7++GOtQwaaEMrqT8ko+xUilHWMmjlWM8k1TstFkFgv/IfqalAvOXbr5pZVxnbR1nqxx5lR7p+Wpsn2vU1CfIKrBZ4vZcO0RB268ceZM/2260lzGA1Gpk2fBkj3C1D8yDNnzuTBBx8E4MYbb2T58uV07dqVHj16cPHFF7Nt2zZ+/fVXLr30UgD+8Y9/aNq1R6XZjHJVlQwd8SNEKOsVqxX18KLuLmqdmWTJKPsRajY5LAwiI92ySi17KRcXF1FSXIzBaKRPn75e375WqL5UsV9AZlYmmzZtAoOBmTNnah2OJqj2izVr1lBVVaVxNNpRXl7GVVddxVdffUVQUBCLFy/mxRdfJDAw8JjlDAYDo0aNYsmSJXTv3p3Dhw/z3HPPaRN0I04QypGRR6fkiv3CbxChrFcanU2r96qdmeQAm7Qd8hvU6unkZHBTNxPVelFc5P2MsppNTunVS2mn1EkQ+8VRPvtUaQl3+vjTSeqapHE02tCvXz96p6ZiaWhgxcrO22P7zf/+l8OHD9G9e3fWrl3LnDlzWlw+NDSUxx9/HIDHHnvMVUynFScU8xkM4lP2Q0Qo65VGQrnGKYyrnT8DRSj7D272J0Mj64UGfZRd/uS0zuFPVhH7hUKDpYGvvvoKgIsu9u9JfC1hwMC5554LdF77RX5BPh999BEAb775JqNHj27V62bPns3o0aOprKzk/vvv92SIJ+WEjLLyi/qkBhEJnqDdQtlisZCVlcWePXs0Kwrq1DiFcgNQb7HgcDhcQtlstWoYmOBWPCGUNbReqBnltP6dw5/cGLFfwMoVKygrKyM+IYEzTvfvHtonY9o0xae8adMmioqKNI7G+7zxxhtYGhoYMXIk55xzTqtfZzQaefbZZ13r+O233zwVYovYbDYKCgqA44SyZJS9i8UCWVmwZw946JjWJqFcWVnJyy+/zKRJk4iMjCQlJYWBAwcSHx9Pr169mDt3ruI9EzyPUyjXAfX19VitVmqcTwVYLJqFJbgZDwhlLcdYZ+xRC/k6V0YZjrNf5HfObNM3S5cCMHPmTEymzlXEdzzJ3ZIZMnQoDrudZT92rsmNWdlZfPmF0h7wxhtuxNBGW9kZZ5zBJZdcgt1u5/bbb8ehQQF7UVERdrsdg8FAfHz80SdU0SxC2XNUVsLLL8OkSYovPCUFBg6E+Hjo1QvmzgU3atFWC+VnnnmGlJQUFi9ezNlnn83nn3/Otm3byMjIYN26dTzwwANYrVamTp3K9OnT2bt3r9uCFJrgOKFcX1/v8iqbJKPsP3hAKIeFhxEYFAR4d4x1bV0thzMPA9AvrZ/XtusrHGO/WNH5fKnV1VVs3LgRgKlTp2ocjW+gFvV9923nsl+89uqr2GxWxp9+uut/oq088cQTBAYG8uOPP7LUeQLmTVR/clxc3LGdW2ToiGd55hlFGC9eDGefDZ9/Dtu2QUYGrFsHDzwAVitMnQrTp4MbtGirhfKmTZtYvXo1Gzdu5L777mPatGkMGTKEvn37cuqpp3LNNdewePFi8vLymDlzJmvWrOlwcEILNBLKdXV11NXVufoomxoaNAtLcDMeEMoGDHRx2i+8aZvat28fOBzExcW5stqdjc5sv/hl3TqsFgs9e/UiJSVF63B8gnPOOQejycTOnb+TmZWpdTheYf/+fXzr9GXfcP0N7V5Pamoqf//73wGYP38+Fi9fSW3SnwxivfA0mzbB6tWwcSPcdx9MmwZDhkDfvnDqqXDNNYqIzsuDmTPBDVq01UL5vffeY/DgwSddLigoiOuuu45rrrmmQ4EJJ+G4jHJdXZ0ro2ysl2lPfoMHhDIcHWNd7EVv5J7du4HOM2ikKRrbLwqLCjWOxrv8tGoVAJMmTcKAezq46J3YmFjGjh0LdJ6Tp5dffhkcDs4662wGDBjQoXXdc889xMfHs2fPHl599VU3Rdg6mhXKUsznWd57D1qhRQkKguuuU4RzB5GuF3qlCeuFmlGmtra5Vwl6wm6HI0eU+24Wyl3inELZixll16CRTiyUE+ITGOgc3d2Z6jmsVitr164FYPLkydoG42NMmjgRgE1OW4o/szN9J6tWrcJgNHLd9dd1eH1RUVE8/PDDADz44INerbmQjHLnoV1CubjRRK+srCzuv/9+7rjjDrFbeJMWMsr4wMQiwQ0UFCheK6PxaJbCTWhhvThayNf5Ol40ZsyppwKdQxipbN6ymaqqKmJiYznllFO0DsenGDNmDADbtm+nvsG/rwa+tOglAM6bMYPeKb3dss6//vWvJCUlUVxc7NWR4Cf0UFaRjLL3aDxdNisL7r8f7rjDLXaLxrRJKP/222+kpKSQkJDAgAED2LZtG2PGjOHZZ5/ltddeY8qUKXz++eduDVBoBsko+z+q7SIxEdw85tfbY6xtNit79ylFFZ3ZegFHhdGmTZtw0DnGza9SbRcTJ2IymrQNxsfo2asXcfHxWBoa+G2HNq3OvMHmzb+yYcN6zGYzc//2N7et12w2u9rLedO+ctKMck2NMspacD+//aYU9CUkwIABSjHfmDHw7LPw2mswZYpS5Ocm2iSU77zzToYMGcLq1auZPHky559/Pueddx7l5eWUlpYyb948FixY4LbghBZooZhPhLKf4CF/MkAXp1Au8pJQzszKoqG+nuCQELp37+6Vbfoqw4cPx2w2k5eXR3Z2ttbheBwHDn766ScAJk+eonE0vocBg+vkaeMm/73K8NJLLwNKa8Dkbu7dp2lRJNusUA4Ph9BQdSGvxdOpuPNOpYBv9WqYPBnOPx/OOw/Ky6G0FObNAzdq0TYJ5U2bNvHoo49y+umns3DhQnJzc7nhhhswGo0YjUZuvvlmdjsLdgQP00J7OLFe+Anq+Opu3dy+apf1otg71oujE/nSMBo6d2lESHAIQ4YOBTqHT3n37t0U5OcTHBLCmFPHaB2OT9L4KoM/cujQIbZv34bZbObav/7V7es/y1kku3nzZkpLS92+/qZoVijLGGvPs2kTPPoonH46LFyoHCtvuEGxKRqNcPPN4EYt2qYjVklJietLER4eTlhYGDExMa7nY2JiqKysdFtwQgs04VGWjLKf4cGMsrfHWLsK+Tq5P1nFJYw6gU9Z7XYxfvx4ggKDtA3GR1G/Dzt37qS6plrjaNzPylUrAcWfHx8Xf5Kl2063bt0YOHAgDoeDlStXun39TaEK5RM8yiBDRzxNScnRzzg8HMLCoJEWJSZGGUriJtqc2jl+gk5bJ+oIbsLZAk6K+fwYTwplZ0bZW9YLV0a5k/uTVU4d4yzo27QJu8OucTSeZVWjtnBC0yR1TaJ79+7YbTa2bd2qdThuZ9XKVYBnO554037R0NDgKoQ+IaMMMnTEGxyvPT2oRdtcITRnzhyCnFO96urquO666wgLCwMUwSZ4ieM8ylLM54d4UCjHOTPKtTU11NXVERwc7PZtqDhwsLuR9UKAwacMJjg4mLKyMvbv30+/vv45qTAnJ5t9+/ZhNJk444wztA7HpxkzZgzZ2dls2rSJ00/3n8+qoLCAnTt/B4OByR48WTr77LN54YUXvCKUCwoKAKWQUE06HINklD3PnDlKr2RQ9NB11ymZZXAlEt1FmzLKV111FQkJCURFRREVFcUVV1xBt27dXL8nJCRw5ZVXujVAoRmkPZz/40GhHBrmvTHWxUXFlJWWYjAa6dunj0e3pRcCzAGMGDkSwDXW2R9Z5SziGzliBFGRURpH49uMdvmUf9U4EveiFnIOGTKELl3iPLadSZMmYTQa2bt3L5mZnp1yqNouEhISMBqbkFGSUfYsV12ldLyIilJuV1yh1PKovyckgBu1aJsyyosXL3bbhoUOIu3h/B8PCmV1jPWRI0coLi52exV6Y/ZkKNnklJQUgoI8l7nWG6eeeirrfvmFXzdt4vLZl2sdjkc42u1israB6IDRo0cDyv9LeXkZUVHR2gbkJlTP8JQpnu14EhUVxamnnsr69etZvnw5V199tce2pdou4uKaEf5SzOdZvKxFO3f5uZ5pqZjPalVugn6pqYGyMuW+B4QyHG0R5+leyhlSyNckY0YrGcTNW7Zgs/nf/2tZWRlbnX7bSSKUT0qX2C6k9ukDDgebt2zROhy3UFFZweZfNwPeOVnylk+5zLlvjo6ObnoBGTriV7Q6o3z77be3eqXPPPNMu4IR2oBTKNfTRHs49fnwcC0iE9yBmk0OC4PISI9sQu184ekx1nucbXr6Dxjg0e3ojbT+aURGRVFRXk76rl0MOWWI1iG5lbVr1+Cw20nr35+krklah6MLxowew4H9+9m0aRNnTjlT63A6zNq1a7HZrKT26UPPHj09vr2zzz6bf//73yxfvhyHw+GxZgOqUG7c9esYJKPsOdqgRXGTFm21UN56XCXuli1bsFqt9HdWsWdkZGAymRg1apRbAhNOQhMDR44RyrW1IpT1TGPbhYd29t4aY622hpNCvmMxGoyMHj2aFcuXs3HjRr8Tymq3C7FdtJ4xY0bzwQfv86uf9FP29nfgtNNOIyQkhPz8fHbu3Omxceltyig7HB7tyNDpOL4rzJYtyhV0taNSRgaYTOBGLdpq68XKlStdtwsuuIBJkyaRnZ3Nli1b2LJlC1lZWUyZMoXzzjvPbcEJLdCE9cIBWE2mY54XdIoH/ckqqvWiuKjIY9uorqkmKysLEKHcFGr/XH8RRip1dXWsW7cekLZwbWHkqFFgMHDw4EGKPPh/6Q3q6+v45eefAc/7k1WCgoKYOHEi4Fn7xUmFsppRrqtzaz9fAVi58ujtggtg0iTIzlYE85YtkJWljLB2oxZtl0f56aef5vHHHz9h2Mi///1vnn76abcFJ7RAE8V8ABaz8yKBFPTpGy8IZW9YL/bt2wcOB/EJCcREN3OZshNzqlMob9u+nfp6/zm53bhpI/X1dSQlJckJUhuIjIhkoNOi9Ouv+j552rBxI3V1dSQmdmWAF21X3vApn1Qoh4UdvaIr9gvP8fTT8PjjJw4b+fe/lefcRLuEckVFBYWFhSc8XlhYKJP5vEUTGWUAqyqUJaOsb9Tx1Z7MKHthjLUU8rVMz169iIuPx9LQwPYdO7QOx22oo5jHjz8dA3LZuS34S5s4tdvF5MmTvfodUIXyTz/9hMVi8cg2TiqUQVrEeYOKCmhCi1JYqO1kPoALL7yQq6++mk8//ZTs7Gyys7P55JNPuPbaa7nooovcFpzQAk0MHAGwBQYqz0tGWd94M6Nc7LlLvDKRr2UMGDj11KNT+vwFdbrcyFEjNY5Ef6h2nI2b9Ntf22azsvqn1QBMnjLZq9seOnQocXFxVFVVeaxHeWlpKXASoSxDRzzPhRfC1VfDp58q9ovsbPjkE7j2WnCjFm2XUH7llVc499xzmT17Nr169aJXr17Mnj2b6dOn89JLL7ktOKEFmskoi1D2E1Sh3K2bxzbRxQvWiz2SUT4pqv1ik58MHqmuqXZNYhwxYoTG0eiP4cOHYzKZOZKbS05ujtbhtItt27dTXl5GRGQkI738HTAajZx5ptIxxFP2C8ko+wivvALnnguzZ0OvXspt9myYPh3cqEXbJZRDQ0N56aWXKC4uZuvWrWzdupWSkhJeeukl1zhrwcM041G2q0JZrBf6xhvFfE7rRW1NDbV17j+xstltikcZ6CdCuVnUDOLO9HSqqqo0jqbj7NixA4fdTrfkZBLiE7QOR3eEhoS6ujXotchT7XYxccJETKY2zTVzC6r9Yvny5R5Zf5uEsmSUPUdoqCKIi4uVbhhbt0JJifKYG7Voq4VyUyMhw8LCGDp0KEOHDj1BIOfk6PNMWDc0k1G2S0ZZ/9jtXvEoNx5j7YmhIyUlJTTU12MymUn24PvQO4mJXenRsycOu50tW/U/aEJtJTpiuGST28uYMcqUPj3acRw4WOWaxjdZkxhUobxu3TqPnHy2SijL0BHP0NR48rAwGDpUuR0vkN2gRVstlMeMGcO8efNa/MctLy/n9ddf55RTTuGTTz7pcHBCCzQSyjabjerqagAcTuEjGWUdU1io9IU0GI7ubD2AAYNH7Rf5eUomJT4+DpPR5Pb1+xOnjvEfn7JLKI8Yrm0gOmZMo4I+Bw6No2kbGRkZHDlyhKCgYE47bZwmMfTu3ZvevXtjtVpZvXq129cvGWUNGTMG5s2DlvaV5eXw+utwyimKZ7mDtPqaSHp6Oo8++ijnnHMOwcHBjBo1im7duhEcHExpaSnp6ens3LmTkSNH8uSTTzJjxowOBye0gNNqocrh8vJyABzBwcoDklHWL+oZcGIiBAR4dFNdYmM5kpvrkYxyfr6SSUlQDxhCs4wZM5pPPvlYt5faVRosDfz+++8AjBgphXzt5ZQhQwgMCqK4uIhDhw7RO6W31iG1GjWbPG7caQSrxyMNOPvss3n99ddZvny5W/WIOuALJKOsCenp8OijcM45EBysDBbp1k25X1qqPL9zJ4wcCU8+CW7427c6o9ylSxeeeeYZjhw5wosvvki/fv0oKipi7969AFx++eVs3ryZdevWeU0kP/roo4wfP57Q0NBmv7AGg+GE2/vvv++V+DxKo4wyKC37AOXL0uh5QYd4wZ+s4sleyvkFBQAkilA+KWrR2779+z3iF/cW6TvTsTQ0EBMbS8+enh9Z7K8EBQYxePBgANJ37tQ4mrbx8y+/ADBJ44mMqv1CbVPnLtSklMFgIDIysvkFJaN8cv7wB+jZU9EtSUnwl78ctR02R5cuymjqI0fgxRehXz8oKgKnFuXyy2HzZli3zi0iGdqQUVYJCQnhkksu4ZJLLnFLAB2hoaGBSy+9lHHjxvHmm282u9zixYuZPn266/cWzwL1glMINxgM4HC4/nkJCVF+SkZZv3hRKLusF57IKDutF4kJUtB1Mrp0iSMuPp6iwkIy9uxh2LDhWofULrZuU20XI6R/cgfpn5bG1i1byMjY684hYx6lvqHe1RJypMZXFIYPHw7Anj17cDgcGNw0Rlq1XURFRWE0tpBrbNweTsZYN82UKfCvfykiOScH/vEPuOQScJ5stUhIiLKsF7So98tR3chDDz0EwJIlS1pcLjo6mq4e9Hp6HZsNnI3UHUFBUFd3VCiHhio/RSjrF28KZdfQEc9ZLxL96X/PgwwaNIjVP/1E+q5d+hXKW48KZaFjqJ1iMjL2aBxJ69mbsRer1Up0dDTdPNjasjWkpKRgNBqpqakhLy+PpKQkt6y3Vf5kOJpRrq9XPLP+kKBzN7fddvR+r15w110wc6aibzxsO2wLuhbKreXGG2/kr3/9K6mpqVx33XVcffXVLZ5dNm63BrimDVosFo9N+mkTNTWoXyFVKDc0NCgPOIv5bNXV2H0hVjegfuY+8dl7AVNWFkbA1rVru/+GVqu1VcupO/uioqJmX6M+3tp1quQ7LznGxcW1+bWdkf5paYpQ3rnzmM+rvZ+/t7HZbWzfth2AoUOG+Hy8rUWrz79vnz6A0ovcYrXoIkP/2++/ATBw0CBsVlurX9fcvr0j+36DwUCvXr04ePAgu3fvJi4urs3raIqiImVAU1RUVMtxmc2YIyMxVFRgyc52a7syb+F6f5WVyhQ8laAgl9ZwGyUl8O67MH68T4lk6ARC+eGHH+bMM88kNDSUH374gRtuuIGqqipuueWWZl/z+OOPu7LVjVm9ejXp6emeDLdVBFRWojpv6o97LqekhCTgYHo6O5cu9XJknmXZsmVah+AVTtuxg0Rge1ERWe38G2a1siNSgXP856FDh/j557UtLrthw/o2xZCZmQXAkSNHTrpuAewOpbvB5i1bmvy82vr5e5vsnByqq6sICgomv6DAJSj8BW9//haLBYPRSEV5OUu/+UYXlsGfnP2Tw8PD2/Q/nxne8vPt3ferHuLPPvvsaB1PB1m7VnlfNpuNpSfZP58VHk54RQUbvviCYmdvbD3RUFTEpUDkoEHHPvHAA/Dgg+7ZyD//qXiNa2rgtNPg66/ds1434nNC+a677uKJJ55ocZldu3YxYMCAVq3vvvvuc90fMWIE1dXVPPXUUy0K5bvvvpvbb7/d9XtOTg6DBg1i4sSJpKSktGq7HsVpdneYTIRHR1Os2i6AnmlpsGIFvbt1o5efdB6xWCwsW7aMc845hwAfO9P0BOZ77gFg6LnnMsRZkNJWfs9p3UEhPDyct996C6vVyumnn9HkMlarlQ0b1jN27GmYza3bZdhsVioqlRimnjPVbdkcf2bAwIG8+cYbFBQUMGLkSEJDFBtVez5/Lfjgww8AGDlyBBMnTNQ4Gveh5effu3dvDuzfT1RUVLP/n77Ef/7zAgDTp01rU7ynJDddFNfRff+3337L9u3bCQ0NdVuTAXVGRGpq6knXaUpNhdxcTuvdG4cOj8clhw4BUJGeTmRjK2BL2eS77oKTaDh27QJVw91xhzJy+vBheOghuPJKRSz7kKfb5/a68+fPZ86cOS0uk5qa2u71jx07lkceeYT6+nqCmvljBwUFHfOceiYaEBDgG0LNplzSMgQHn/AeApxn0Kb6eky+EKsb8ZnP39M4T4TMvXq1+xJUaw/o8c5Cu+KSkpO+xmw2t3q9xSXFOOx2TCYz8Qnx0ke5FSQmJJKQmEhBfj779+8/YWBHWz5/LdixfQegtIXz5Tjbixaff//+/Tmwfz/7Dxxg8uQpXt12W6mqquJw5mEAhgwd2qbP6mT79fbu+9OcPu+DBw+67dih6oHY2NiTr9NZn2EuKvI5O0FrcL2/iAhoqcNHY+bPh5NoOBpruLg45ZaWBgMHQo8esH49jNOmB3dT+NzeLD4+nvj4eI+tf9u2bcTExDQrknWB2vqtCaFsDg8/dhlBX9TWKr0gwavFfLU1NdTV1bmt76nqT04QkdwmBg4YSEF+Prt27dLVZDsHjmM6XgjuIS0tjW+XLiVjT4bWoZyUXbt3gcNBUlISsTGxWocDQN++fQHYt2+f29bZ6mI+6Jwt4uLjlVt7sNuVn/XHm0q1pdVCuXfv3u1qr3Lrrbe2aHPoCJmZmZSUlJCZmYnNZmPbtm2A8s8RHh7OV199RX5+PqedpjQ+X7ZsGY899hj/+Mc/PBKP12hJKEdEKHek64U+UTtehIa2/gy+A4SGhWEwGnHY7VRVVblNKBc4DwzSQ7ltDBo0kJ9+WsUuH6iFaAtZWVmUFBcTEBjIoOP9jEK7UTOiGXt9Xyir/Z4HDRqscSRHaSyU3dUirk1CWYaONM+GDcp0vTPOgJgY2L8f7rsP+vRpOZvcu3f7bBm33grt1KKtFsona8HWHJ709N5///289dZbrt/VTMbKlSuZPHkyAQEBLFq0iNtuuw2Hw0Hfvn155plnmDt3rsdi8gotCGWTKpQlo6xPGreG84JHy4CBsLAwqiorqa6ucpuX2JVRFqHcJgYMHAhAevoujSNpG1u3bAHglMGDCQrU8dU6H0MVyllZWVTXVBMW6rudE3Y6T+4Gn+I7Qjk1NRWDwUBFRQVFRUVuuVotGWU3ERoKn36qFAZWVyu9lKdPh3vvbdkD3U4tSge0aKuF8qRJk9q9EU+xZMmSFgX89OnTjxk04jc0EsrHZwADVOuFZJT1iRd7KKuEO4VyVVUrW2W0gjzJKLeLgU6hfDjzMNXVVYSFnaQdgI+g9k8eLrYLtxITHeMaRLNv3z6GDR2mdUjNsvN3JaM82IeuKAQHB9O9e3eysrLYt2+f94Vy46EjwrEMGQIrVrT9dRpo0VaPsG6J6667jgLnuFrBCzSTUQ4MDMQgA0f0jRZC2XlyVVVd7bZ1FuQ7x1fLVL42ERsTS2JiV3A42L1HP4Mmtm7dBog/2ROoWeW9Gb5rvyguKVYGDBkMrqsivoK7fcrtyiiL9cI7XHcdeECLukUon3vuucyYMYMHH3yQajcebIVmaEYoBwcHKzPTGy8j6AsNhLKatXRnRlmm8rWfQYMUobF7lz7sFwWFBeTkZGMwGhk2dKjW4fgd/Z1CeY8PC2V1vkDv3r19zh6iqVA+foy14FnOPRdmzFB6PLtRi7pFKP/xj39kw4YNJCYmMn78eF555RXsavWi4H6aEcpBQUHK/HOQjLJe0TKjLNYLn0BvPmXVdtE/LU03VhE9kda/P+DbGeWdv/8O+JbtQsVTQjkmJubkC6tX1CyWo92MBM/xxz8qRYKJicqEv1deOdpJowO4RSgDmEwmzjvvPG677TbuvfdeBg0axFdffeWu1QuNacajLBllP0CLjHK4kgFy19Ugq9Xqmsom1ou2o3aN2LVbH0J521ZpC+dJ0vr1A2Dv3n3Y7K0fC+1Njhby+d70OU0zysHBoC4nPmXvYDLBeefBbbcphYGDBkEHtahbhPL06dPp1asXs2fPZseOHbzwwgu8++67fP7559x6663u2ITQGLXHYFPWC8ko65sjR5Sf3bp5bZPuzigXFRWBw4HZbCYm1jf6qeqJgQOUjHLm4cNuzfJ7Cink8yzde/QgODiY+vo6srOytA7nBBw42OlqDeffGeW6ujrqncffVo8UF5+y95g+HXr1gtmzYccOeOEFePdd+PxzpT1cO3HLwJEFCxYwZMgQTKZjBwu8+eabrR41LbSBlqwXklHWLw7HUaGclOS1zYaFOTPKVe7JKKv+5ITERIwGt1206jRER0eTlJTEkSNH2L17N8OHD9c6pGapqKxg3/79AD4dp54xGU307duX33//nT0ZGfTqlaJ1SMeQm5NDRXk5ZrOZfs7sty/Rp08fAEpKSigtLW2dZaIZ1Gyy0Wh0JRhOSmIi7NkjGWVvsGCB0k3jOC3Km28eHZndDtxyFHvllVcoLi5u8rmlS5e6YxNCY1oq5pOMsn4pKzt6tcCLRXDuzijnF0jHi44yUCf2i927d4PDQXJyd7rEdtE6HL9F9Sln+GAnFNV2kda/P4EBgRpHcyJhYWEkORMP+50nde1FFcpRUVEYja2UTzJ0xHv89NOJIlmlA1rU410vUhvP9BbcQ2uK+Ww2pYBA0A9qNjkm5uiVAS+gCuXqajcJZSnk6zADXQV9vj2hb+/evQCkpfleJtGfUH3KGc7P25fwxf7Jx+Mu+0Wb/MkqMnTEe/z2G8ybp+gfgPR0+POflfsd0KLS9UKPtKaYr/Fygj5QMw5ebqkW7rReuCujXCBT+TrMoIH6aBGndmLo52xhJngGX84op6c7/cmDfWci3/G4SyiXOjtXtEkoy9AR7/HGG4rFYvp0uOQSuPJKuPjiDq9Wul7okdZ4lEHsF3pDA38yuN96Ia3hOo5a25GVlUVlVaXG0TSPmuFM80Fvqj/Rt29fMBgoKiqipLRE63Bc2GxWdjlP5gZ3AqHcoYyyWC88z6ZNsGaN0opv61b45BNFMHcQ6XqhR1ShHBR0okfZYDg6J10yyvpCI6Gs9r51V3s41XrRVYRyu4mKiqabs0Xgnt2+l0UEpQ3ggQMHAHyyiMufCA0JpUePHoBv9VM+ePAQdXV1hISG0qtXL63DaRZNhbJklL3Hbbcp0/l+/RXefx9mzoSff+7waqXrhR5pqZgPFJ9yfb1klPWGxhnlSrFe+BQDBwwkNyeHXbt3kdq7t9bhnMDhw4ewWiyEhoWR5MV2hp2V/mlpZGVmkrF3L2PHnqZ1OADsVG0XAwdhMjZTROUDSEa5k7B27dH7Y8bA11/Dn/7UYbHslozy8OHDTxDJKtL1wgM041F2iWZpEadPNPIou3PgiMVqocjZAUesFx1DHWW9y0d9yqrtol/fftIG0AuoPnBf8im7+icP9t1CPjjaIi4/P5/KyvZbmTqUUS4ocMuUOKENJCfD8uUdXk2b926HDx/mhx9+IK+Zs6Pc3NxjfpeuFx6gNRllkIyy3tA4o1xbU9PhyV+FhYXKsJGAgLYdTIQTUEdZ+6r1Qu140a9fX40j6Rz0T1MK+vb4kPUifafvd7wApZ1bfHw80LEWce0SymqbTKsVSnzHX657Dh+GH35oPlOvalE3dJBqk1B+77336Nu3L9OnTyc1NZX//e9/AGRmZrJgwQLGjh1Lz549OxyUcBJaKuYDEcp6RTOPcpjrfk1NTYfWVZCv9lCWYSMdRW0Rl5OTTXUH/y6eQDpeeJd+zhZ8hw4dor6hXuNooL6hnr17FSuDL46uPh532C/aJZQDA0GdUCo+Zffw3nvQt6/S3SI1FZxalMxMZejI2LHgRi3apiPZI488ws0338xvv/3GOeecw/XXX899991Hnz59WLJkCaNHj+ajjz5yW3BCM5wsoyzWC32ikVAODAgkIFAZFNDRzhfqVL7ErmK76CiREZEkJ3cHICcnR+NoTiQjQ+2hLELZGyQkJBAVFY3dZnMVUWpJRkYGNpuV6JgYunrZLtYeVPuFO4Rym6f7SS9l9/LII3DzzUrf5HPOgeuvh/vugz59YMkSGD0a3KhF21TMt3//fv7+97/Tq1cvFi1aRM+ePfn555/ZsWOHK/sheAGxXvgftbVQXq7c1+CgEx4eTmlJSYfHWLtaw8lUPrcwaNBAcnKyycrK0jqUYygpLaG4uAgMBpcAETyLAQNpaf3YtGkTGRkZDByg7TFXtV2cMngwBgyaxtIaNMsogyKUd+2Sgj53sX8//P3v0KsXLFqkZI9//hl27AAPaNE2ZZQtFgshThHWvXt3goODWbhwoYhkbyPFfP6HugMNDoaoKK9v3l1DR1zWCynkcwuqTzkn27cyyqo/uUf37oSGhGocTechLU0dPKK9T3mf0+vbXyedrTQVynFxyk9nobPQQSyWownB7t2V4+bChR4RydCOYr7/+7//Y/fu3YAyZKTNlyCEjiMZZf+jse3C4P3sjLuGjqjWC2kN5x56O9vCFRQWaBzJsYg/WRvS+js7X+zVXihnO69y9HT2d/Z1NBXKXbooP6WYz3383/+BU4tiMoEHtWibhPKECRN44IEHGDx4MHFxcdTV1fH888/z4Ycfkp6ejtVq9VScQmNOVswnGWX9oZE/WUUt6Kuu7qBQLpCMsjtJSUkBlG4idofvtJZSi7hk0Ih3SXO1iMvAgUPTWFQ7UHedCeWcnJx2FS07HI72C2W1mE+EsnuYMAEeeAAGD1ay9XV18Pzz8OGHkJ6udBhxI23yKP/000+Actlt8+bNbNmyhS1btvD2229TVlZGYGAgaWlp7Nixw61BCsdR76x4loyy/6AKZY2KYtyXUZapfO4kuVs3zGYzVouF/Px8enT3DVGiZjRldLV3SUlJAYOB6uoqSkpK6BLbRZM4GiwNrnqEHjoRyrGxsURHR1NWVsaBAwc4pY2dOurq6mhoaAA6IJTFeuEenFqUvXth82bYskW5vf02lJUpnUbS0hTPshto12S+fv360a9fPy677DLXYwcOHGDz5s1s3brVLYEJLXAyj7IIZf2hepQ1yyg7hXIHho40WBoocR4IxHrhHkwmM8nJ3Tl8+BCZhw/7hFC2WC0cVEdXi/XCqwSYA0hISKAgP5/c3FzNhHJuTi44HISGhenGfmkwGOjbty+//vor+/bta7NQLi0tBcBoNLoSC61GrBeeoV8/5dZIi3LggCKe3ahF3dboNDU1lUsvvZTHHnvMXasUmkPaw/kfGlsv3JFRLiwsBCAwKEiGjbiRXim9ADh0+LDGkSgcPnQYq9VKWFg4SRp9Xzszyc5x4bkatgzMylZsFz2699BFxwuVjviUG9suDG2tIxHrhfdITYVLLwU3atFWZ5R79+7d9i8HcOutt3LLLbe0+XVCMzgcx1ovnP1vlV/FeqFbtPYou2GMdX6j1nB6Onj6Or2cjfMzD2dqHImCarvo16+v/J01oFu3ZLZu3UrOcVNwvYnLn9y9u2YxtAd3CeU2I9YL99G7d/sK3m+9FdqpRVstlJcsWdKuDajFKIKbqG80kSk4mKCAANevUsynY/wgo6wK5YQEsV24E3UfmpnpGxll6XihLd2SfSCj7BTKPXqIUG4VYr1wH+3UonRAi7ZaKE+aNKndGxHcSGPxGxxMoMnU6FfJKOsWPyjmK1AzyjKVz6307OVb1gu1h7J0vNAG1XqhZUY52yWUtffMtwXNM8qlpWC3g9FtrtfOhwZaVP5aekMVykYjmM0YjUYCnfYLySjrFJsNnP5ezdvDdWAyn0zl8ww9ndaLwoICqms6NjnRHWQ4hXJaP8koa0G35GTAWVCnEXprDaeiCuXMzEzqG1+dbQVuEcoOh9KVQdAVIpT1hip+g4JcPh1VIEtGWacUFBzNMsTHaxKCO60X0kPZvURFRrn+PpmZ2vqUi0uKlc4mBgN9+sroai1IdgrlvLw8bHab17dvtVo5ckTp0qO3jHJCQgLh4eE4HA4OHjzYpteqQrldXT4CA0HtlCH2C90hQllvNOp4oTJp0iSSk5NdU7xEKOsM1XaRmKhMGNKAcDcMHDlqvdDGPuLPxDtPoA4fOqRpHPvU0dU9ehASHKJpLJ2V+Ph4zAEB2GxWCgq8P7ExLy8Pm81KUFAwcepoZp2gtoiDttsvOpRRBul8oWNEKOuNJoTyl19+ycGDB12Xz8V6oTM09ieDezLKea5iPrFeuBu1QPKwxj5lsV1oj9FgdLXl06KgT20Nl9w9GaNBfxJChLLQVvT3Le/sNCGUDQYDAY26X0hGWWdoPGwEOj5wpL6hnjJnQ36Zyud+EhKUjPIhjTPKGRlHW8MJ2qFlQZ+r44UPDL9pD336KJah/fv3t+l1HRbKaucLaRGnO0Qo640mhPIJSEZZX2jcGg6OZpStFgv1DW0rcgEoLDg6bCQyKsqtsQkQ57ReaN35QrVeSGs4bTla0KdBRlmnreFUVI+3WlPRWiSj3HkRoaw3WiOUJaOsL3xAKIeEHvWbtmfoSH6+khVPTEyUIRQeQO0kknk4E7vDrkkMFqvFVQCVJkJZU7TMKGdnZwP6K+RTUa1hbfV3i1DuvIhQ1huSUfY/fMCjbDKaCHV63NvjU853HnTEduEZYrt0wWw2U19f1+ZMmLs4ePAgVquV8PBwukrBpqZo2SIuW6et4VQ0F8pivdAdIpT1hmSU/Q8fyChDxwr6ZCqfZzEZjSQnK5e6Dx/Sxn7ReNCIXDXQlm6ujLJ3rRc2u40sP8kot/WEs9RZg9Fhj7JklHWHCGW9oTZJb01GWYSyPvCBYj5oNHSkPdYL53uQqXyeo1eKc0Lfobb1f3UXMrrad0jupmSUiwoL21VT0F4KCwqxWiyYzWbd9ktXhXJJSQkWi6VVr3E4HGK96MSIUNYbbcko19Upk4AE38Xh8I+MsvMypkzl8xy9nBP6tGoRlyGjq32GqOgoQkJDAchT9x9eQG0N1y05GZNRm57vHSU2Nhajc4R0UVFRq15TU1OD1WoFxHrRGRGhrDfaIpTtdmjlGbOgEWVlR68SaOz7dA0daYdQVg84cRpNFuwMpKSkANp1vlD7zvbrK0JZawwYXAV92V7sfKH31nAAJpPJNcCntT5lNZtsMpmOzitoK2K90C0ilPVGW4r5Gi8v+CZqNig6uuW/qRfoSEa5sqICUMYtC56hZy/VenHI69uurqlWRldz1AIiaIuroM+LnS+OdrzQZ2s4lbYW9DW2XRgM7fTni/VCt4hQ1hutEcpBQUfvi0/Zt/ERfzJ0zKNcWamI64jICLfGJBylp9N6UVhQQHVN+wbDtJccZ9YyKiqaiHD5G/sCakbZm72Uj/ZQ1m9GGdovlGNiYtq/UVUol5aCzdb+9QheR4Sy3miNUDYYpEWcXvARfzK0P6PswEFlVSUAEREiojxFVGQU0c4DdWZmple3rQqk7t31nUn0J9SMsjd7Keu9NZxKWztfdLiQD44KZYcDysvbvx7B64hQ1hutEcogLeL0gg8J5bDw9o2xrq2txe7MkIhQ9iwpTvvFYS/bL/zlkrs/0c3LGWUHjk6fUe6QUA4MBOc+VuwX+kKEst5orVCWFnH6wAeGjai0N6Os+pNNJjPBGvus/R21oM/bnS+yJaPsc6gt4ryVUS4uKqaurg6D0UiSD5zYdwRNhDJI5wudIkJZb6hCubEPuSkat4gTfBcfyii3Wyg38ifLIArP0kvtfKFZRlnfmUR/oluyklGurKhoVwFuW1G/A0lJSQSYAzy+PU+i9oD2ulCWzhe6RISy3hDrhX/hB8V84k/2Hr3Uzhfezig7RZJklH2H0JBQl3DzxoQ+tYeynlvDqWieURahrCtEKOuNtlovJKPs2/hBRrnCab0Qoex5VOtF5uFM7A67V7bZYGngiPOETu9FXP6GN1vEHfUn6/9kSYSy0BZEKOsNySj7Fz7kUXZllKvallGuqlQyypEilD1OcrdumM1m6uvrWl2x31GO5OaCw0FwSAix6oFe8Am82SLOXwr54NiuF45WTK91u/VCPMq6QoSy3pCMsv9QW3u0TZCOM8qVlWK98BYmk9klVA4f8o79IivL6U/u3l086D5GshdbxPlLazg4KpTr6upatb8rLS0FJKPcWRGhrDcko+w/qP7k4GCI0n6inWuEdU11my7rVzoPNOEilL2Cy6d86KBXtped7T8Cyd9wWS88nFFu3BrOH3zqYWFhhIaGAq2zX4j1onMjQllvSHs4/6GxP7m9Y1HdiJpRxuGgtqam1a9TPcqRkZGeCEs4jl5ebhEnhXy+i2q98HRGuaK83JV57e4U53qnLZ0vxHrRuRGhrDfamlEW64Xv4kP+ZIDAoCBMJjPQNvuF6lGOUIW24FHUgj5vdb5wWS8ko+xzqBnlI7m5ODi517a9qN+BhMREgoL8o1d6Wwr6JKPcuRGhrDfq65WfYr3QPz7U8QLAgOGoT7kNLeLEo+xdjlovDnlle5JR9l26du0KBgN1dXWUeFB8+VNrOJXWCmWHw+ESyjHOEfLtRoSyLhGhrDekmM9/8DGhDO0r6KtwCmXxKHsHVSgXFhRQXdO2DiVtxWa3kZMjQtlXCTAHkJigWAg82SLOn1rDqTTufNES1dXV2Gw2QKwXnRURynpDivn8Bx8aNqISFt72oSNqRlk8yt4hKjKKaGdmKzMz06PbKigowGq1YjabXZ5OwbdQJ/R5sqDPn1rDqbQ2o6xmkwMCAghRj6vtRc0ol5WBU3wLvo8IZb0hGWX/wU8yykc9ypJR9hYpzqzyYQ/bL1TbRbfkZExGk0e3JbQPbxT0uew3nVgoR0dHY+ho0bVq3XA4jrYGFXweEcp6wuGQjLI/4WPFfNC+MdZHPcpSzOctVBuEp7sduDKJfuRN9Te80SLOn1rDqbS264XbCvkAAgNBtaiJ/UI3iFDWExaLIpZB2sP5A36QUbbZba5lI8R64TWSnN+ZPPU75CGkkM/38XRGuaqqijLnwA1/+h60J6PsFqSgT3eIUNYTjW0U0h5O39hsUFio3PcloewaY906odw48xwu7eG8RldVKKs+dw/hyiT6URGXv3E0o+wZoayeLMV26UJYaJhHtqEFIpSF1iJCWU80Fr2BgS0vK9YL36agAOx2MBohPl7raFy0NaOs2i6CgoIJDDjJd1JwG2pG+YiXMspivfBdujkzynl5edjs7i8QO5KnfMfUzLW/oArloqIirFZrs8t5TCiL9UI3iFDWE6pQDgo6+SQ3KebzbVSBk5AAJt8pklI9yq0WyhVOf3KkFPJ5k65OX/uRI3keGzThwCHWCx0QHx+POSAAm83aquEZbaW4qAiAuLg4t69bS7p06YLBYMDhcFDcgmh1u1BWW8RJRlk3iFDWE60t5APJKPs6PuhPhqMZ5dYW81VWybARLVALkerr61wHcndTUlKijDI3GFwtyATfw2gwuq4weKKgTxWRXVSB5yeYzWbXe2rpBKPU6c8W60XnRYSynmiLUJaMsm/j40K5rdYLEcreJSgwiC5dlAyfp3zKaja5a2Ki2Gp8HNUWke0BoVykCmU/yyhD6zpfiEdZEKGsJySj7D/44LARgLA2jrCulB7KmpGUpNovPONTzvbDlmD+iqugzwOdL0qKFUEXqwo8P6I1BX0es16IR1k36FYoHzp0iGuvvZbevXsTEhJCnz59eOCBB2hoaDhmuR07djBhwgSCg4Pp0aMHTz75pEYRu4H2ZJRFKPsmPthDGdqRUa6oACBSPMpex9MFfa5CPj8aMuGvqBllz1gvnB5lP7NeQNuEcow6LKSjSEb5ROrrYfhwpfZq2zatozkBs9YBtJfdu3djt9t59dVX6du3L7///jtz586lurqahQsXAlBRUcHUqVM5++yzeeWVV/jtt9+45ppriI6O5m9/+5vG76AdtCejLNYL38RXM8ptHDhS6RTU4WK98DpqQZ+neilLIZ9+UDPKnjhpOupR9j/rhSYZZRHKJ3LnndCtG2zfrnUkTaJboTx9+nSmT5/u+j01NZU9e/bw8ssvu4Tyu+++S0NDA//9738JDAxk8ODBbNu2jWeeecb/hbK6TH295+IR2k9+vvJT7xll8Shrhqd7KR/toSwZZV9H7UhR7Gbx5cDhWmdsF/+1XuSr++MmEOuFh/n2W/jhB/jkE+W+D6JbodwU5eXlx/io1q1bx8SJEwls1HN42rRpPPHEE5SWljZ7KaW+vp76RgJTFQMWiwWLxeKh6E+OoboaM2APCsJ2sjhMJgIAR10dVg1jdgfqZ67lZ+9uzHl5GABrly44PPC+WuoL2hJBQUEANNTXU1tXS4A5wLWuptZZXlYOKJno9m5TaJnmPn/1IJ+be8Qjn72rmK9r1079t23p++8rRDpPVEtLStwaZ1VVFQ3OY2FUZKTHPoPm9u2e3verXS/y8vKa3YYqlMPCwtwTR0SEcmwuKfH5Y7Pr/VZWgtNmBygtap3Hig6Rnw9z58Lnn0NoaMfX5yH8Rijv27ePF154wZVNBuXL37t372OWU6tc8/LymhXKjz/+OA899NAJj69evZr09HQ3Rt02um/YwCigsLKS9UuXtrhsQFUVMwCDzca3X32Fw4d69baXZcuWaR2C2zgvJwczsGr3bqrLy92+/qzWJYRPwGa3u+6vWLHCNakPYMOG9Scsn5mVCSj/Tz//vLZ9GxVaxfGfv5pJzsrOcvtnX1tb6xII2dnZFKlTJDsxTX3/fYUaZy1KVVUVq1atJCAgwC3rLXD+3YODg/n111/dss6myDzJUE9P7fszM5X91969e1naxDG1oaHB9X+wdetWDh482OFtBpWVMR2grIylX33lU330j6ehqIhLgchBg4594oEH4MEHO7ZyhwPmzIHrroPRo+HQoY6tz4P4nFC+6667eOKJJ1pcZteuXQwYMMD1e05ODtOnT+fSSy9l7ty5HY7h7rvv5vbbbz9m/YMGDWLixImkpKR0eP3txeD0n8V3786MGTNaXrimxnX33ClTQMfjhS0WC8uWLeOcc85x2wFAU6qqMDttNJNmzfLI3+b3nIqTL9QMwcHB1NXVMXjQYLp3747VamXDhvWMHXsaZvOxu4y33n4bgBEjRnD66Wd0KGahaZr7/CurKnl64UJqqqsZOWoUIcEhbtvmnj27AYiJjeWsM89y23r1SEvff1/BgYOHHnwQq9XKwIEDSUx0j6Vr67atAMQnJHj0//uU5MgmH/f0vj82NpYFCxZgsViaPKZu3rwZu91OXFwcf/7znzGcbNBXa7BYYM4cDA4HM8aPP2rF8EFKnOK1Ij2dSKcPHmg5m3zXXXASDceuXYrdorIS7r6744F6GJ/7r58/fz5z5sxpcZnU1FTX/dzcXKZMmcL48eN57bXXjlmua9euJ3iP1N+7tuANDQoKcl2CBqUoECAgIEBboea8DGIMDcV4sjgaia8Amw38QGBq/vm7C9WbFhZGgLsqqY+jIwf08PBw6urqqK+vO2Y9ZrP5hPWqXubo6GifFRH+wvGff0x0DGFh4VRXV1FUVETvlN4tvLptqEVh3bt3l7+rk6a+/75ETGwshQUFVFRWkpzsngJMNZsaFxfn0fd+sv26p/b96vjvgoKCJte/Y8cOAEaOHHmMhbNDBARARARUVhJQWelzdSqNcX0mEREQ2fTJzAnMn69kilsiNRVWrIB1604U3aNHw+WXw1tvtTleT+Fz//Xx8fHEx8e3atmcnBymTJnCqFGjWLx4MUbjsd3uxo0bxz333IPFYnH9wZctW0b//v3d1+rFm7SlmM9kUv4hLRbpfOFrqMVXPrqDDA8Pp6ioqFUFfepJZGREK3eigltJSurKvn37OHLkiFuFcpa0htMdsTGKUC5xY0GfOr66ix/2UIajPv/q6mqqq6tdXX9UtmzZAihC2a3ExirZVH/sfBEfr9xOxn/+A//+99Hfc3Nh2jT44AMYO9Zz8bUD3fZRzsnJYfLkyfTs2ZOFCxdSWFhIXl7eMRXgs2fPJjAwkGuvvZadO3fywQcf8Pzzzx9jq9AVbRHKjZcToexb+LhQDgtr/dCRKlfXC/1ae/SMp3opZ2dJazi9ERurJH/cKpSd6/LH1nCgJAWCncfJplrEbd2qWE9GjBjh3g1L5wvo2RNOOeXoLS1NebxPH/Cx/Y7PZZRby7Jly9i3bx/79u07YWfucDgAiIqK4ocffuDGG29k1KhRxMXFcf/99+uzNRy0TyhXVopQ9jV8XCi3tkWcxWqhzvndkj7K2uBqEedmoZyVrbSGk4yyfoiNVcSXW4Wya3y17/poO4LBYCAhIYHMzEwKCgqOKf63WCxsd/b19UhGGfwzo+yH6FYoz5kz56ReZoChQ4eyZs0azwfkDSSj7B/4uFAOC2/d0BG1bSIcFdeCd3ENHXFzL2UZNqI/1IxyqVutF06h7KfWC+AYodyY3bt3U19fT2Rk5DF1UW5BhPKJpKQonTB8EN1aLzol7RXKMnTEt/DRYSMqrc0oq0I5LCwck9F3Wxz5M56wXtTX11Hg/I6KUNYPMU7xVVJa6rZ1lpT471Q+FbVl7PFCWbVdDB8+/IT6pw4j1gtdIUJZT6hCubWNviWj7Juo2T/nDtrXUAtaTiaUxZ+sPUeFsvsyyjm5uYByAuS2aWSCx4l1FqiXuFF8Ffm59QKaH2PtsUI+kIyyzhChrCfEeuEf+Lj1Qs0oV1edzHqhCOmI1rYNEtxOUldFKBcUFrhtalpj24UBN/SNFbxCrDNL6a6Mst1hp6TYOb7az60X0HxGWYSyIEJZT0hG2T/wdaHcyoxyRaXSGi5CCvk0I7ZLLOaAABx2OwWFJ1btt4esLLWQT2wXeiI2xmm9cJP4qqyowGZTTr46g1BuPHPBbrd7ruMFHLVeiFDWBSKU9YQ6d721jc9VQS1C2Xew23XjUa6ubp1HOSJchLJWGA1GujotPO4q6JNCPn0S4yrmK8VBx4uiVNtFVFQ0AWY/GPTUDE1llPfv309lZSXBwcHHTAF2G+qJh3iUdYEIZT2hXlpt7YQiySj7HqWlR094nDtoX6O1xXziUfYN3F3Ql5ujeJSTRSjrCnWIls1mdQ0C6ghqa7jYLv6bTYamhbKaTR42bJhnJhKK9UJXiFDWE6pQbu0/rghl30PN+sXGtt5C42XUgSMnaw9XoQpl8Shrirt7KauZadX/LOiDwIBA10luaUnHfcpqUWBcF/8t5IOmu16ohXwesV2ACGWdIUJZT4hQ1j8+7k+GtreHE4+ytqi9lN2VUVaFclcf/o4KTXO0oK/jAsw1bMTPhbKaUS4sLMRutwMe7ngBRz3KZWVgs3lmG4LbEKGsJ0Qo6x8dCGV14MjJRliLUPYNVOuFOzzKVVVVLm96YlffbF8oNI/aIs4dQ0eKXNYL/xbKcXFKj2i73U5JSQkOh8OzhXwAzr8TDocilgWfRoSynhChrH98vJAPGhfzVbdYFKR6lCNFKGuKO3spq2I7KiqakOCQDq9P8C7q0JFiNwhltTWcv2eUAwICXF098vPzyc7OpqioCLPZzCmnnOKpjYK63xT7hc8jQllPqEVgbRXKMpnPd9BDRtnZHs5us1FbW9vschUVilAOF6GsKaqXOC8vr8PdDsR2oW/UFnHuyCgXFxcB/u9RhmML+lTbxeDBgwlu7cyC9iDT+XSDCGU9IRll/ePjU/kAQkJCMJqUkdQtFfRVVon1whdISEwAg4H6+jpKOzhsIi9P8TmLUNYnaoeKEjcU8xV3EusFHCuUPW67UJGCPt0gQllPiFDWPzrIKBswtGqMdaXLeiFdL7QkMCDQlfXrqE9ZMsr6RrUQuKWYr6RzWC/g2M4XHi/kUxGhrBtEKOsJ6aOsf3QglOHodL7mxlg7cFBZoU7mkz7KWuOuXsouoZzk299PoWnUYj7VX9xebHab6+pEZxDKTVkvPC6UxXqhG0Qo64m2ZpRlMp/voRehfJIWcfV19Vid30fxKGuPu3opS0ZZ38S4KaNcVlqKw27HYDQSHR3thsh8G1Uo//777+Tk5GAwGBg2bJhnNyoZZd0gQllPiPVC31gsUKQUyPi6UFatF82NsVb9yUaTidDQUK/FJTSN2zPKPv79FJqmS6x7ivlU20VMTAwmo6nDcfk6qlBevnw5AGlpaa5kgccQoawbRCjrCRHK+qawUOmbaTIdvezmo5wso+zqoRwegQGD1+ISmkYVth3xKNtsVgoKC49Zn6Av1IxyVVUVDZaGdq+nswwbUVGFsrpf87jtAsR6oSNEKOsJEcr6RhUxCQmKWPZh1DHWzQpl8Sf7FO7opVxUVITdZsNsNncageRvREREYDIpx4eOZJWLnVe+1Ay1v6MKZRWPd7wAySjrCBHKekKEsr7RwbARFVdGuZn2cJWVioD+//buPDzK6t4D+HcyS7bJvgeTEAgQQCyLSkWRfakUpF6QKiLbtdXrrYRShD69FK29rRHRam1Z7q1I7+MFearS2t4qUcNSVFqgiAEMEAOGQBKykJCEbJP3/jHzvpkhk30y7zkz38/zzEMy887k5E2Y+eY3v3MOl4YTg7qW8pWS3rdeqNXo+IQEBBj40iAjAwyIinZM6OvDUoFtK17EemRcoku4ablOr1SUGZSlwWdDmXDDEblJMpEPcNrGuqOKsrqGcjiXhhNBkmOViprqatTfqO/VY7A/2TfERNvfDajsS0VZbb2I9Y93FnSpKKvv2jAoC49BWSasKMtNgs1GVM7bWLtTo7ZeWFlRFkFoqFVbfaS3fcoMyr4h2lFR7lvrhSMo+0nrRXh4OCwWCwAgLS1NW4+6X6lfgz3KwmNQlgmDstwkqih3NZmvVp3Mxx5lYSQ5fq96u/IFg7JvUCf0VfQhKFdW+tdkPoPBoFWVvdJ2AbQF5WvXAJvNO1+TeoVBWSbccERuEgXl0C42HNFWvWDrhTD6upayGpTViYEkJ3XTkb5UlMv9aPtqlRqUvdJ2AbQFZcAelklYDMqyUJS2vzpZUZaTREFZrSjX1FS7vZ2T+cTT17WUWVH2DWq47dNkPj9bHg4A7rzzTgDArFmzvPMFTSZAff5kn7LQGJRl4fzWDHfmk5NEQTklJQUAUHjhAmyt7d8WrLmuLg/HoCwKNSj3tkf5CoOyT+hrRbm5pRk11fY/kGP9KCj/5je/QUlJiRaYvULd9bDafUGCxMCgLAu17QLoeUW5qQlobfX8mKhnJArKaWlpCAwMQsONG7hUVNTudq1Hub93r6JuS9R6lHselOvqarWf6c1LZZFc+tqjrK6WYTSa/Kq1KiAgwPu/+2pQZuuF0BiUZdGXoAxwiTi93bgBOFaKkCEoGwOMGDIkAwCQf/Zsu9vZoyyevqylXOJY4zs8IgIhwdySXGbqig29XR6uQutPjuZ62v2NQVkK/F8gC3UNZaB3QZntF/pSNxsJCgIkCZfDhmUCAM7m57e7rUZb9YKtF6JQ11K+evUqWpz/sO4G9if7DjUoV1VWQYHS4/tXVtgDtj+1XegmIsL+L4Oy0BiUZeH8wtfd7Y9NJiDA8SNmUNaXc9uFwaDvWLopc7gjKJ871+626wzKwomKjobZYoHS2orSstIe3ZdB2XdEOXqUbbYW7f9pT1RU2Levjo5mUO53rChLgUFZFmpQDghoC79dMRi4O58oJNpsRDVs2DAAQP6X+VCUtspUq9Kqra8czqAsjABDAJKTkgEAxcXFPbqvuqQcg7L8LGaLtmqNWh3uiXI/25VPV5zMJwUGZVn0dLMRFZeIE4NEE/lUgwcPRoDRiOrqa7jmVPG4UV8PxTE51MqgLJRbbrkFQC+CMivKPkWd0FdZ1fOgrIZrf1oaTjesKEuBQVkWPd1sRMWgLAYJg3KgJRCD0tMBAMWXL2vXq/3JZosFgZZAXcZG7g24ZQAA4NKlSz26H4Oyb4nR+pR7HpTV1gt/2b5aV+xRlgKDsixYUZabhEEZaJvQ51yhZH+yuNSK8qUiBmV/1lZR7vmmI9pmI7GxHh0TucGKshQYlGXR26DMTUfEIGtQzrT3KRdfah+U2Z8snrbWi+4HZVurDaVlZQAYlH1FdJQjKDtCb0+o6y+z9cIL2KMsBQZlWbCiLDdJg3JmpqOifNkpKNdwVz5RDRjQ1nrR3aXBysvL0WqzwWg0MRz5iOho+8oXlZW9qCiXOyrKbL3of6woS4FBWRbqOsoMynKSNCgPGzoUAHCtqgrV1dcAANcdK15wIp94BiTbg3Jtba22DXFX1LaL+IR4GAO6ufQkCS3a8QdPTyfzNTY2oK7O/v87JoatF/2OQVkKDMqyYEVZXorStuGIZEE5NNSqvZ2v7tDX1nohx8Yp/iQoKAixjt7SS91c+YL9yb4n2rGWck8n86ltF5bAQIRaQz0+LroJJ/NJgUFZFgzK8qqpaTv/Eq2jrBriqCqrO/S1Teaz6jYm6pg2oa+bK18wKPsedTJfRU+DckVb24UBcmyMJDW1onz9OmCz6ToU6hiDsiz6GpS54Yh+1LaL8HAgOFjfsfSC2n6hVZTZoyy0nq6lzKDse9TJfD2uKJc7loZjr7p3qBVlwF5QISExKMuC6yjLS9L+ZNVQxw59Z/PV1gt7D2NYOFsvRDSAFWW/Fx1jD8q1tbVoam7q9v3aVrxgf7JXWCxASIj9Y7ZfCItBWRZsvZCX5EFZrShf/PoibjTcwPVarqMsMrZeUFhYGIxG+2tFVQ/WUlZbL9SgTV7APmXhMSjLgkFZXpIH5ZiYWHv1WFFw9uzZttYLK3uURaS1Xlxi64W/MsCAKG2JuO63X6hLw8Wy9cJ7uPKF8BiUZcGgLC/JgzIA3OJYnzc/P5878wlOXUu5tKy0y7fd6+rrtD98EiWcaEodi1Z35+tBUK6sdEzmY1D2HgZl4TEoy6K36yhzZz79+UBQVsNX/pf57FEWXFRUFIJDQgBFweXiy50eW+pYttAaFobQUL5D4EvUDUN6MqGvXGu9YFD2Gu7OJzwGZVmwoiwvHwjKyVpF+Uv2KAvOAEO3t7JW2y6SJP7dJPfUJeIqe9GjzIqyF7GiLDwGZVkwKMtL0s1GnKkV5fMFBaivqwMAhFkZlEV1i9NW1p1hf7LvUjcdqXSE364oULRj2aPsRZzMJzwGZVkwKMvLByrKMdHRsFqtaFFbgMANR0TW3ZUvGJR9V08ryvX19WhwvE6w9cKLWFEWHoOyLBiU5WSzAWVl9o8lnixlMBi09ZQBIDgkRFt+isSjBeUuNh1hUPZdPe1RVif9BQUHIzhIvo2RpMWgLDwGZVn0dcMR7synj4oKe1g2GIC4OL1H0yfqesoA+5NFN2AAK8r+rqfbWFdq21ezmuxVnMwnPAZlWbCiLCe17SI2tud/5AhmiFNQDmdQFprzNtYKlA6PY1D2XT1dHq6cm43ogxVl4TEoy4JBWU4+0J+sYkVZHomJiQgwGtHU2Ijy8nK3x9habShzTDRlUPY96mS+qsqqTv9YUqmBWm3ZIC/hZD7hMSjLorfrKDMo60sNyhL3J6sGDhwIi2NdbiuDstBMJpMWfjtqv6isrERLSwsCjEbExsZ6c3jkBWrrhc3Wom0S1JlKrqGsD1aUhcegLAtWlOWkBuWkJH3H4QFGowkZGRkAWFGWQdtW1u6Dstp2ER8Xx4mZPshitsDq2Ga+sqLr9gu1l5lrKHsZe5SFx6Asi94GZe7Mpy8far0AgMzMTABABHflE96ALtZSZn+y72tbIq7roNw2mY+tF17lHJRbW3UdCrnHMoIsWFGWkw9sNuLsu9/9LqqvVeP+++frPRTqQldrKZ/KywMApKSkeG1M5F3RUdEo+vrrbi0Rp1aU2XrhZWqPcmsrUFsLsAghHAZlWTAoy8mHepQBYFD6IGRnZ+s9DOoG55UvbtaqtCIn50MAwL2TJnl1XOQ96goW3dl0RG3PYEXZy4KCAIsFaGqy9ykzKAuHrRey6Os6ygzK+vCx1guSh7qNdZGbivIXX3yB0tIShISGYsKECd4eGnlJdJQjKHdjG+uKSk7m04XBwAl9gmNQlkVfK8qNjYDS9RJB5GEMyqQTtaJ8raoKdfV1Lrfl7NsHAJg0aRICLYFeHxt5R2ycfTWTq1evdnrcjYYbaLhxA0Db+svkRZzQJzQGZVn0NSi3trY9BnlHYyOg9gYyKJOXhYZaEel4AXZuv7C12vDhh/a2i5kzZ+oxNPKS+Ph4AEBpWVmnx6kV58DAIISEhPT7uOgmrCgLjUFZFn0NygDbL7xNfXEymwHH4v9E3uRuK+sTJ06gvLwcVqsV48eP12to5AVqUL7aRVBum8gXDQMM/T4uugk3HREag7IservhSKDT26oMyt7lPJEvgP/VyPvcTej7MCcHADBlyhRYzBZdxkXe0d2KcgWXhtMXK8pC46u3LHpbUTYYuJayXtifTDq7JcVRUS6yV5RtthZ8+NFHAIAZbLvweWpQvl5Tg4ZOnv+5K5/OGJSFxqAsi94GZYArX+jFx9ZQJvncvOnIsePHUVVZiYiISNx5x516Do28wGq1Iig4GABQdrXjqjJ35dMZJ/MJTdqgfOHCBaxcuRLp6ekIDg7G4MGDsXHjRjQ1NbkcYzAY2l0+++wzHUfeS30Jyqwo64MVZdJZW+uFPSirq11MnToFpt48l5BUDDB0q0+Zu/LpzF97lAcOtL/r7Xx5/nm9R9WOtM+UX375JVpbW7Ft2zZkZGQgLy8Pjz32GOrq6vDiiy+6HPvhhx9i5MiR2udS/tXMirJ8fGyzEZKPGpSvXClBY2MDPvr4YwDA9Bkz9BwWeVFCfDy+vnix0z5l7sqnM39uvfjZz4DHHmv7PCxMv7F0QNqgPHv2bMyePVv7fNCgQcjPz8eWLVvaBeWYmBgkyl7V6+2GIwCDsl5YUSadxcbGwmyxoLmpCe+99x5qqqsRGRWF28eN03to5CVx3aooc1c+XflzUA4LE/41Utqg7E51dbXbxdLnzZuHhoYGDB06FE8//TTmzZvX6eM0NjaisbFR+/z69esAgObmZjSrq094mbGpCQEAWgwGKD0cgykwEAYALbW1Pb6vCNRzrte57y3jlSv2n1lsrNfPe4sH18xWH8uTj0nd19fzPyA5GRcuXMDO3/8eADB16lQoCn+e3SX7739srH3TkZKSkg6/h0rHrnwREZG6fJ8dPbfL+tzfUwarFSYArVVVsAn0vWrn/fp1oKam7YbAQNcVtfri+eeB554DUlOBhx8GVq/u3Tvn/Uis0fTB+fPn8etf/9qlmmy1WrF582bcfffdCAgIwNtvv4358+dj7969nYblX/7yl3j22WfbXX/w4EGcPn26X8bflfFXriARwMlTp1D0f//Xo/ve29CAKABHDx9GqVMPt2xyHMtayWLaV1/BCuDTwkJU9vBn1ldFtZ5/zCNHJOzt9yG9Pf/Bjg0krly+DABISEjA4cN/89i4/IWsv/9qoefLL7/s8OdeVmbfua/wQiHq6vrhyaMLX1s7v1225/6eij5zBhMB1F+5go+8/FrRmabyciwEED5ihOsNGzcCzzzT9y/w1FPA2LFAdDTwySfAj38MXLkCvPRS3x/bgwyKIta+xuvXr0d2dnanx5w5cwaZmZna58XFxZg0aRImT56M//7v/+70vo8++igKCwtx6NChDo+5uaJcXFyMESNG4OzZsxg4cGD3vhEPM953HwI+/BAtO3ZAWby4Z/edNg0Bhw6hZdcuKP/yL/00wv7T3NyMnJwczJgxA+betJ7oxBQVBUNdHZpPnwYyMrz6tfOKa7o+qJtaWlpw5MhnGD/+m5wApoO+nv+XXn4Je956C4C9uvjHP/0JxgCjp4fps2T//T9w8ADWPf00ho8YgR2v72h3e2NjAyZNmgQA+PDDj2C1dpFa+8GtA8LdXi/rc3+P5eXBPHYslNhYtDj+oBVB5YULSBg6FDWnTyPcsYIOgM4ryuvXA11kOJw5AzhlOM3rrwPf/z5QW+u5irUHCPe/fs2aNVi2bFmnxwwaNEj7+PLly5gyZQomTJiA7du3d/n448eP7/Kv08DAQAQ6/ZBqHG85mM1m/f6z2mwAAFNQUM/7lB3LA5laWnrX4ywIXc9/T9XWAnV1AABzSorXz3t/vKCbTCYpg4Kv6O35T01J0T6ePn06Ai3ivADJRNbf/6SkJADA1atX3Y6/7Krj9c1iQURkhC4783X1vC7Vc39vxMUBAAzXrsFsMtlXfxCAds7DwoBw93/MtLNmDdBFhoNThnMxfrx9PtaFC8CwYd0dZr8T7n99XFwc4hy/NF0pLi7GlClTMG7cOOzYsQMB3dj97MSJE9oTh1S46oVc1Il8oaGADhUaItUAx8oXADCDq134nQTHZL6KigrYbC0wGl1fQ5wn8nH7ap2ok/laWoD6evvrhqzi4rTg32MnTth3sXX8zopCuKDcXcXFxZg8eTLS0tLw4osv4urVq9pt6goXO3fuhMViwZgxYwAA77zzDl5//fUu2zOExKAsF242QoIYNmwYzBYLBiQnY9Rtt+k9HPKyqOhoGI0m2GwtKK+oQEK863KVFZXclU93oaGA0Wh/5/jaNbmDcnd9+ilw5AgwZYq9Yv3pp/aJfI88AkRF6T06F9IG5ZycHJw/fx7nz5/X1gpVObddP/fcc7h48SJMJhMyMzPx1ltvYcGCBd4ebt8xKMuFS8ORIOLj4rF7925YrVYEGKTdY4p6KcAQgLi4WJSUlKCsrKx9UFY3G2FQ1o/BYK8qV1TYd+dz7gf2VYGBwO7d9kmBjY1Aero9KP/wh3qPrB1pg/KyZcu67GVeunQpli5d6p0B9TfuzCcXbjZCAklLTdN7CKSjuPh4LSjfjLvyCSIiwh6U/WUt5bFjAUl2SWZ5QRbccEQurCgTkSDUPmV3QZm78gnCnzcdERyDsizYeiEXBmUiEkRcJ0GZu/IJgkFZWAzKslB3yOlLUHZaG5r6GYMyEQlCqyiXugnKnMwnBjUoV1frOgxqj0FZFqwoy4VBmYgEoVWUr3bSesGKsr4iIuz/sqIsHAZlWTAoy4VBmYgEoa504bairE3mY0VZV2y9EBaDsiwYlOWhKFxHmYiEERdv3wCi7GoZFLQtn9rY1Ija2loAQHQMK8q6YlAWFoOyLBiU5VFV1dZTLtgOQ0Tkf9TdbpubmlB9ra0HtqqyCgBgMpsRFhamy9jIgUFZWAzKsmBQlofadhEd3baGNRGRTixmCyIdu5059ylru/Jx+2r9cTKfsBiUZcF1lOXBzUaISDDu+pQrK7k0nDA4mU9YDMqy4M588uBEPiISTLxTn7KqorwcALevFgJbL4TFoCwLT6yjzKDsHQzKRCSYeK2iXKpdx135BMKgLCwGZRkoCmCz2T9mUBYfgzIRCaatonxVu4678gmEQVlYDMoyUEMywJ35ZMCgTESCiU9oX1HmrnwCUXuUGxtZ1BIMg7IM1P5kgBVlGTAoE5Fg4uPaV5S5K59AwsMBg2PlEa58IRQGZRkwKMuFQZmIBOO2osxd+cQREGAPywDbLwTDoCwDBmW5cFc+IhKMWlGura1F/Y16AM6T+VhRFgL7lIXEoCwDTwXl5mbXfmfyvJYWQH1rk0GZiAQRGmpFSGgoAOBqWRmaW5pxvaYGACfzCYNBWUgMyjJQg3JAgP3SU2pQBjihr79dvWpfpSQgAOAEGSISSEJ8PAB7n7K62YjRaEKY+pY/6Uud0MceZaEwKMugL2soA67bKLP9on+p/cnx8YDRqO9YiIicxKlBubRUC8pR0VEIMDAKCIEVZSH1MnmRV/VlVz71fkajve2CQbl/cSIfEQnKuaIc6QhlsXznSxwMykLin5Ey6GtQBjihz1sYlIlIUM4VZe7KJyAGZSExKMvAk0GZPcr9i0GZiASlVpRLy8pQoS0Nx4l8wmCPspAYlGXAirI8GJSJSFBqRflqWZm2hjIrygJhRVlIDMoyYFCWB4MyEQnKpaLMXfnEw6AsJAZlGTAoy4ObjRCRoNSKcmVlpbZDH1svBMKgLCQGZRmoQdls7v1jMCh7h1pRdmwXS0QkisjISJjMZkBRcPbcOQBsvRAKg7KQGJRlwIqyPNh6QUSCCjAEIM6xlXV9XR0AVpSFwsl8QmJQlkFfNxwBGJS94caNtic4BmUiEpDap6xiRVkgrCgLiUFZBp6oKKu78zEo9x+1PzkwsK0yQEQkkDinoBxgNCKCz1XiUINyXV1bgYx0x6AsA7ZeyMG57cJg0HcsRERuOFeUo6O4fbVQnP9oYfuFMPg/RAYMynJgfzIRCc65osy2C8GYTIDVav+Y7RfCYFCWAXfmkwODMhEJzrmizIl8AuKEPuEwKMuAFWU5MCgTkeBcKsrRrCgLhxP6hMOgLAMGZTlwsxEiElxCfNsa79ExrCgLh0FZOAzKMuCGI3LgZiNEJLjY2FhtsjFbLwTEoCwcBmUZcB1lObD1gogEZzKZEONoueBkPgGpPcoMysJgUJYBWy/kwKBMRBIYNCgdAJCWlqbzSKgdtaLMyXzC6EPyIq9hUBafojAoE5EUnv3Zz/BVwVcYOWKk3kOhm7H1QjgMyjLgznziq6lpO7fsUSYigcXHxSM+Lr7rA8n7GJSFw9YLGbCiLL4rV+z/hocDISH6joWIiOTEoCwcBmUZcMMR8altF0lJ+o6DiIjkxcl8wmFQlgEryuJTK8rsTyYiot7iZD7hMCjLgEFZfKwoExFRX7H1QjgMyjJQ11HmhiPiYkWZiIj6Kjzc/i8rysJgUJYBK8riU4MyK8pERNRbao9yTY192VHSHYOyDBiUxcfWCyIi6is1KCsKUFur71gIAIOyHBiUxcfWCyIi6qvgYMBotH9cU6PvWAgAg7IcGJTFx4oyERH1lcHQVlVmn7IQGJRl4Omd+dj35FlNTUBFhf1jVpSJiKgvOKFPKAzKMvBkRRmwBzvyHLWabDYDMTH6joWIiOTmPKGPdMegLANPB2XuzudZalBOTLS/bUZERNRbbL0QCoOyDDyxjrLF0vYx+5Q9ixP5iIjIU9TWC1aUhcCgLANPVJQNBk7o6y+cyEdERJ7CirJQGJRl4ImgDDAo9xdWlImIyFNYURYKg7IMGJTFxl35iIjIU1hRFgqDsgwYlMXG1gsiIvIUBmWhMCjLgEFZbGy9ICIiT2HrhVAYlGXAoCw2VpSJiMhTWFEWCoOyDDwVlJ135yPPUBTXdZSJiIj6ghVloTAoy0BdR9lTFWVuOOI5FRVtPx8GZSIi6itWlIXCoCwDtaLclw1HALZe9Ae1mhwT47qpCxERUW9wC2uhMCjLgD3K4uJEPiIi8iS19YIVZSEwKMuAQVlcnMhHRESepFaUb9xoa+0j3TAoy4BBWVysKBMRkSeFhbV9zPYL3UkdlOfNm4fU1FQEBQUhKSkJS5YsweXLl12OOXnyJCZOnIigoCCkpKTghRde0Gm0fcCgLC7uykdERJ5kNgMhIfaPfb394i9/AcaPB4KDgagoYP58vUfUjtRBecqUKdizZw/y8/Px9ttvo6CgAAsWLNBur6mpwcyZM5GWloZjx45h06ZNeOaZZ7B9+3YdR90LDMriYusFERF5mj9M6Hv7bWDJEmD5cuDzz4HDh4GHH9Z7VO30MXnpa/Xq1drHaWlpWL9+PebPn4/m5maYzWa8+eabaGpqwuuvvw6LxYKRI0fixIkTeOmll/C9731Px5H3EIOyuNh6QUREnhYebn998dWKcksLsGoVsGkTsHJl2/UjRug3pg5IHZSdVVZW4s0338SECRNgdiyj9umnn+Lee++FxWnZrlmzZiE7OxtVVVWIiopy+1iNjY1odFpruNrxi1pUVNSP30HHIhsaEADgWmkpWi9c6PXjBN24gRAADWVlqO/D43hbc3MzysvLceHCBe1nK4qIoiIYAVQDsAl0Ti+X1nrssVpaWnCtqhKXi4tg6usfa9RjPP/64vnvf2EtVW6vF/m5v7+FBQXBDKDm7Fm0pKXpMoZrRUUwAWitrm5biQOwb16mbmDWW8ePA8XFQEAAMGaM/d3Z0aPtwfnWW/v22J6mSO7pp59WQkJCFADKN7/5TaW8vFy7bcaMGcr3vvc9l+NPnTqlAFBOnz7d4WNu3LhRAcALL7zwwgsvvPDi15dqQFGcLxs39j287dplf6zUVEX5wx8U5ehRRXnoIUWJiVGUioq+P74HGRRFUSCQ9evXIzs7u9Njzpw5g8zMTABAeXk5KisrcfHiRTz77LOIiIjAn//8ZxgMBsycORPp6enYtm2bdt/Tp09j5MiROH36NIYPH+728W+uKFdWViI9PR15eXmIUPuGyGuuX7+OESNG4PTp0whzng1MXsHzry+ef33x/OuH515fNdXVuOfWW1FQWIio6Oi2GzqrKK9fD3SR4XDmjL2ivHgxsG0boLbCNjYCt9wC/PznwPe/75lvwgOEex9pzZo1WLZsWafHDBo0SPs4NjYWsbGxGDp0KIYPH46UlBR89tlnuOuuu5CYmIjS0lKX+6qfJ3bSUxoYGIhAN78EKSkpCHd++4G8osYxmWHAgAE8/zrg+dcXz7++eP71w3Ovr5rwcFQBMEZHu7ZedGbNGqCLDIdBg9rm9zj3JAcG2m/7+uveDLffCBeU4+LiEBcX16v7tra2AoBWDb7rrrvwk5/8RJvcBwA5OTkYNmxYh/3JRERERNQLcXH2S1fGjbMH4/x84J577Nc1NwMXLgA69WR3RNrl4Y4cOYLXXnsNJ06cwMWLF/Hxxx/joYcewuDBg3HXXXcBAB5++GFYLBasXLkSp06dwltvvYVXXnkFP/zhD3UePREREZGfCg8HHn8c2LgR2LfPHpifeMJ+28KF+o7tJsJVlLsrJCQE77zzDjZu3Ii6ujokJSVh9uzZ+I//+A+tbSIiIgL79u3Dk08+iXHjxiE2NhY//elPe7w0XGBgIDZu3Oi2HYP6H8+/vnj+9cXzry+ef/3w3Our38//pk32ZW+XLLFv1z1+PPDxx/aNRwQi3GQ+IiIiIiIRSNt6QURERETUnxiUiYiIiIjcYFAmIiIiInKDQZmIiIiIyA0G5W56/vnnYTAYkJWVpfdQ/EZxcTEeeeQRxMTEIDg4GKNGjcLRo0f1HpZfsNls2LBhA9LT0xEcHIzBgwfjueeeA+f+9o+DBw9i7ty5SE5OhsFgwN69e11uVxQFP/3pT5GUlITg4GBMnz4d586d02ewPqiz89/c3Ix169Zh1KhRCA0NRXJyMh599FFcvnxZvwH7mK5+/509/vjjMBgM+NWvfuW18fm67pz/M2fOYN68eYiIiEBoaCjuuOMOfC3YxiD9hUG5G/7xj39g27ZtuO222/Qeit+oqqrC3XffDbPZjL/+9a84ffo0Nm/ezI1ivCQ7OxtbtmzBa6+9hjNnziA7OxsvvPACfv3rX+s9NJ9UV1eHb3zjG/jNb37j9vYXXngBr776KrZu3YojR44gNDQUs2bNQkNDg5dH6ps6O//19fU4fvw4NmzYgOPHj+Odd95Bfn4+5s2bp8NIfVNXv/+qd999F5999hmSk5O9NDL/0NX5LygowD333IPMzEzs378fJ0+exIYNGxAUFOTlkepEoU5dv35dGTJkiJKTk6NMmjRJWbVqld5D8gvr1q1T7rnnHr2H4bfmzJmjrFixwuW6Bx54QFm8eLFOI/IfAJR3331X+7y1tVVJTExUNm3apF137do1JTAwUNm1a5cOI/RtN59/d/7+978rAJSLFy96Z1B+pKPzf+nSJWXAgAFKXl6ekpaWprz88steH5s/cHf+Fy1apDzyyCP6DEgArCh34cknn8ScOXMwffp0vYfiV/70pz/h9ttvx8KFCxEfH48xY8bgv/7rv/Qelt+YMGECPvroI5w9exYA8Pnnn+Nvf/sbvvWtb+k8Mv9TWFiIkpISl+egiIgIjB8/Hp9++qmOI/Nf1dXVMBgMiIyM1HsofqG1tRVLlizB2rVrMXLkSL2H41daW1vxl7/8BUOHDsWsWbMQHx+P8ePHd9oe42sYlDuxe/duHD9+HL/85S/1Horf+eqrr7BlyxYMGTIEH3zwAZ544gk89dRT2Llzp95D8wvr16/Hd7/7XWRmZsJsNmPMmDHIysrC4sWL9R6a3ykpKQEAJCQkuFyfkJCg3Ube09DQgHXr1uGhhx5CeHi43sPxC9nZ2TCZTHjqqaf0HorfKSsrQ21tLZ5//nnMnj0b+/btw3e+8x088MADOHDggN7D8wppt7Dub0VFRVi1ahVycnL8pw9HIK2trbj99tvxi1/8AgAwZswY5OXlYevWrVi6dKnOo/N9e/bswZtvvon//d//xciRI3HixAlkZWUhOTmZ55/8VnNzMx588EEoioItW7boPRy/cOzYMbzyyis4fvw4DAaD3sPxO62trQCA+++/H6tXrwYAjB49Gp988gm2bt2KSZMm6Tk8r2BFuQPHjh1DWVkZxo4dC5PJBJPJhAMHDuDVV1+FyWSCzWbTe4g+LSkpCSNGjHC5bvjw4X4zy1Zva9eu1arKo0aNwpIlS7B69Wq+u6KDxMREAEBpaanL9aWlpdpt1P/UkHzx4kXk5OSwmuwlhw4dQllZGVJTU7XX4osXL2LNmjUYOHCg3sPzebGxsTCZTH79esyKcgemTZuGL774wuW65cuXIzMzE+vWrYPRaNRpZP7h7rvvRn5+vst1Z8+eRVpamk4j8i/19fUICHD9O9poNGrVBfKe9PR0JCYm4qOPPsLo0aMBADU1NThy5AieeOIJfQfnJ9SQfO7cOeTm5iImJkbvIfmNJUuWtJsjNGvWLCxZsgTLly/XaVT+w2Kx4I477vDr12MG5Q6EhYXh1ltvdbkuNDQUMTEx7a4nz1u9ejUmTJiAX/ziF3jwwQfx97//Hdu3b8f27dv1HppfmDt3Lv7zP/8TqampGDlyJP75z3/ipZdewooVK/Qemk+qra3F+fPntc8LCwtx4sQJREdHIzU1FVlZWfj5z3+OIUOGID09HRs2bEBycjLmz5+v36B9SGfnPykpCQsWLMDx48fx5z//GTabTesNj46OhsVi0WvYPqOr3/+b/zAxm81ITEzEsGHDvD1Un9TV+V+7di0WLVqEe++9F1OmTMH777+P9957D/v379dv0N6k97IbMuHycN713nvvKbfeeqsSGBioZGZmKtu3b9d7SH6jpqZGWbVqlZKamqoEBQUpgwYNUn7yk58ojY2Neg/NJ+Xm5ioA2l2WLl2qKIp9ibgNGzYoCQkJSmBgoDJt2jQlPz9f30H7kM7Of2FhodvbACi5ubl6D90ndPX7fzMuD+dZ3Tn/v/vd75SMjAwlKChI+cY3vqHs3btXvwF7mUFRuNUWEREREdHNOJmPiIiIiMgNBmUiIiIiIjcYlImIiIiI3GBQJiIiIiJyg0GZiIiIiMgNBmUiIiIiIjcYlImIiIiI3GBQJiLyM01NTcjIyMAnn3yi2xjWr1+PH/zgB7p9fSKi7mBQJiKpLVu2DAaDod3FeUtWcrV161akp6djwoQJLtfn5ubi29/+NuLi4hAUFITBgwdj0aJFOHjwoHbM/v37YTAYcO3atXaPO3DgQPzqV7/q1hh+9KMfYefOnfjqq6/68q0QEfUrBmUikt7s2bNx5coVl0t6enq745qamnQYnVgURcFrr72GlStXulz/29/+FtOmTUNMTAzeeust5Ofn491338WECROwevVqj48jNjYWs2bNwpYtWzz+2EREnsKgTETSCwwMRGJiosvFaDRi8uTJ+Pd//3dkZWVpwQwA8vLy8K1vfQtWqxUJCQlYsmQJysvLtcerq6vDo48+CqvViqSkJGzevBmTJ09GVlaWdozBYMDevXtdxhEZGYk33nhD+7yoqAgPPvggIiMjER0djfvvvx8XLlzQbl+2bBnmz5+PF198EUlJSYiJicGTTz6J5uZm7ZjGxkasW7cOKSkpCAwMREZGBn73u99BURRkZGTgxRdfdBnDiRMnOq2oHzt2DAUFBZgzZ4523ddff42srCxkZWVh586dmDp1KtLS0nDbbbdh1apVOHr0aHd/FJo33njDbaX/mWee0Y6ZO3cudu/e3ePHJiLyFgZlIvJpO3fuhMViweHDh7F161Zcu3YNU6dOxZgxY3D06FG8//77KC0txYMPPqjdZ+3atThw4AD++Mc/Yt++fdi/fz+OHz/eo6/b3NyMWbNmISwsDIcOHcLhw4dhtVoxe/Zsl8p2bm4uCgoKkJubi507d+KNN95wCduPPvoodu3ahVdffRVnzpzBtm3bYLVaYTAYsGLFCuzYscPl6+7YsQP33nsvMjIy3I7r0KFDGDp0KMLCwrTr3n77bTQ3N+Ppp592ex+DwdCj7x0AFi1a5FLh37VrF0wmE+6++27tmDvvvBOXLl1y+eOBiEgoChGRxJYuXaoYjUYlNDRUuyxYsEBRFEWZNGmSMmbMGJfjn3vuOWXmzJku1xUVFSkAlPz8fOX69euKxWJR9uzZo91eUVGhBAcHK6tWrdKuA6C8++67Lo8TERGh7NixQ1EURfmf//kfZdiwYUpra6t2e2NjoxIcHKx88MEH2tjT0tKUlpYW7ZiFCxcqixYtUhRFUfLz8xUASk5Ojtvvvbi4WDEajcqRI0cURVGUpqYmJTY2VnnjjTc6PF+rVq1Spk6d6nLd448/roSHh7tc94c//MHlnJ48eVJRFEXJzc1VALjcpl4MBoPy8ssvt/ua58+fV6Kjo5UXXnjB5frq6moFgLJ///4Ox0tEpCeTrimdiMgDpkyZ4tLrGhoaqn08btw4l2M///xz5Obmwmq1tnucgoIC3LhxA01NTRg/frx2fXR0NIYNG9ajMX3++ec4f/68S+UWABoaGlBQUKB9PnLkSBiNRu3zpKQkfPHFFwDsbRRGoxGTJk1y+zWSk5MxZ84cvP7667jzzjvx3nvvobGxEQsXLuxwXDdu3EBQUFC762+uGs+aNQsnTpxAcXExJk+eDJvN5nL7oUOH2n1vkydPbve41dXV+Pa3v405c+Zg7dq1LrcFBwcDAOrr6zscLxGRnhiUiUh6oaGhHbYaOIdmAKitrcXcuXORnZ3d7tikpKRur5ZhMBigKIrLdc69xbW1tRg3bhzefPPNdveNi4vTPjabze0et7W1FUBbkOzMv/7rv2LJkiV4+eWXsWPHDixatAghISEdHh8bG6sFcdWQIUNQXV2NkpISJCYmAgCsVisyMjJgMrl/mUhPT0dkZKTLdTcfa7PZsGjRIoSHh2P79u3tHqOyshKA6/kgIhIJe5SJyK+MHTsWp06dwsCBA5GRkeFyCQ0NxeDBg2E2m3HkyBHtPlVVVTh79qzL48TFxeHKlSva5+fOnXOpjI4dOxbnzp1DfHx8u68TERHRrbGOGjUKra2tOHDgQIfH3HfffQgNDcWWLVvw/vvvY8WKFZ0+5pgxY/Dll1+6hPwFCxbAbDa7/eOhL1avXo0vvvgCe/fudVvFzsvLg9lsxsiRIz36dYmIPIVBmYj8ypNPPonKyko89NBD+Mc//oGCggJ88MEHWL58OWw2G6xWK1auXIm1a9fi448/Rl5eHpYtW4aAANeny6lTp+K1117DP//5Txw9ehSPP/64S3V48eLFiI2Nxf33349Dhw6hsLAQ+/fvx1NPPYVLly51a6wDBw7E0qVLsWLFCuzdu1d7jD179mjHGI1GLFu2DD/+8Y8xZMgQ3HXXXZ0+5pQpU1BbW4tTp05p16WmpmLz5s145ZVXsHTpUuTm5uLChQs4fvw4Xn31Ve3r9MSOHTvw29/+Flu3boXBYEBJSQlKSkpQW1urHXPo0CFMnDixW5VzIiI9MCgTkV9JTk7G4cOHYbPZMHPmTIwaNQpZWVmIjIzUwvCmTZswceJEzJ07F9OnT8c999zTrtd58+bNSElJwcSJE/Hwww/jRz/6kUvLQ0hICA4ePIjU1FQ88MADGD58OFauXImGhgaEh4d3e7xbtmzBggUL8G//9m/IzMzEY489hrq6OpdjVq5ciaamJixfvrzLx4uJicF3vvOddi0hP/jBD7Bv3z5cvXoVCxYswJAhQ3DfffehsLAQ77//PkaNGtXtMQPAgQMHYLPZMG/ePCQlJWkX5+Xsdu/ejccee6xHj0tE5E0G5eYmOyIiamfy5MkYPXp0t3ee86ZDhw5h2rRpKCoqQkJCQpfHnzx5EjNmzEBBQYHbSY3e8Ne//hVr1qzByZMnO+yDJiLSGyvKRESSamxsxKVLl/DMM89g4cKF3QrJAHDbbbchOzsbhYWF/TzCjtXV1WHHjh0MyUQkND5DERFJateuXVi5ciVGjx6N3//+9z2677Jly/pnUN20YMECXb8+EVF3sPWCiIiIiMgNtl4QEREREbnBoExERERE5AaDMhERERGRGwzKRERERERuMCgTEREREbnBoExERERE5AaDMhERERGRGwzKRERERERuMCgTEREREbnx/4M3AFd4dGpbAAAAAElFTkSuQmCC", "text/plain": ["<Figure size 700x500 with 2 Axes>"]}, "metadata": {}, "output_type": "display_data"}], "source": ["idx = result_df[\"output\"].idxmax()\n", "name = results.task_paths[idx]\n", "sim_data = td.SimulationData.from_file(name)\n", "\n", "flux_x, flux_y = compute_flux_polarization_components(sim_data[R_mon.name])\n", "Rxy_dB = 10 * np.log10(flux_x.squeeze())\n", "Ryy_dB = 10 * np.log10(flux_y.squeeze())\n", "low_f, high_f = find_frequency_bounds(Rxy_dB)\n", "bandwidth = high_f - low_f\n", "fractional_bandwidth = calculate_fractional_bandwith_metric(sim_data[R_mon.name])\n", "print(\n", "    f\"Range {low_f * 1e-9:.2f}-{high_f * 1e-9:.2f} GHz, Bandwidth: {bandwidth * 1e-9:.2f} GHz, Fractional Bandwidth: {fractional_bandwidth:.2f}%\"\n", ")\n", "\n", "fig, ax = plt.subplots(1, 1, figsize=(7, 5))\n", "sub_ax = ax\n", "ax2 = sub_ax.twinx()\n", "(p1,) = sub_ax.plot(freqs / 1e9, Ryy_dB, \"-k\", label=\"Ryy-1\")\n", "(p2,) = ax2.plot(freqs / 1e9, Rxy_dB, \"-r\", label=\"Rxy-1\")\n", "ax2.axvspan(low_f / 1e9, high_f / 1e9, alpha=0.2)\n", "sub_ax.set_xlabel(\"Frequency (GHz)\")\n", "sub_ax.set_ylabel(r\"$|R_{yy}|$ (dB)\")\n", "sub_ax.set_xlim(4, 16)\n", "sub_ax.set_xticks([4, 6, 8, 10, 12, 14, 16])\n", "sub_ax.set_ylim(-30, 0)\n", "sub_ax.grid(True)\n", "ax2.set_ylabel(r\"$|R_{xy}|$ (dB)\")\n", "ax2.set_ylim(-6, 0)\n", "\n", "# Set axis colors\n", "sub_ax.yaxis.label.set_color(p1.get_color())\n", "ax2.yaxis.label.set_color(p2.get_color())\n", "sub_ax.spines[\"right\"].set_edgecolor(p1.get_color())\n", "ax2.spines[\"right\"].set_edgecolor(p2.get_color())\n", "sub_ax.tick_params(axis=\"y\", colors=p1.get_color())\n", "ax2.tick_params(axis=\"y\", colors=p2.get_color())\n", "plt.tight_layout(pad=0.2)\n", "plt.show()"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## References\n", "\n", "[1] H. Luyen, Z. Zhang, J. H. Booske, and N. Behdad, \u201cWideband, beam-steerable reflectarrays based on minimum-switch topology, polarization-rotating unit cells,\u201d *IEEE Access*, vol. 7, pp. 36 568\u201336 578, 2019."]}], "metadata": {"applications": ["Microwave and RF devices"], "description": "This example demonstrates how to design and optimize a wideband reflectarray based on polarization-rotating unit cells (PRUCs) using Tidy3D. The design is based on the work by Luyen et al., where a reflectarray design is demonstrated with wide bandwidth and beam-steering capabilities using minimum-switch topology. The design consists of: a polarization-rotating unit cell (PRUC) with two configurations (0\u00b0 and 180\u00b0 rotation); arrow-shaped metallic patches on the top layer; a ground plane with circular holes in the middle layer; a bottom layer with diagonal connecting strips, which enable the switching behavior; and susbrate layers composed of three Rogers RO4003C layers bonded by Rogers RO4450B prepregs.", "feature": ["Mesh override", "Parameter sweep", "Global optimization"], "feature_image": "./img/reflectarray.png", "kernelspec": {"display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3"}, "keywords": "microwave, RF, unit cell design, reflectarray, polarization-rotating unit cell, minimum-switch topology, periodic structures, 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.12"}, "title": "Wideband beam-steerable reflectarray with polarization-rotating unit cells in Tidy3D FDTD", "features": ["Global optimization"]}, "nbformat": 4, "nbformat_minor": 4}