{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Nanobeam cavity\n",
"\n",
"1D photonic crystal cavities, also known as nanobeam cavities, are widely used in photonics and quantum optics due to their high-quality factors (Q-factors) and low mode volumes. These attributes make them ideal for exploiting Purcell enhancement, which is crucial for applications involving quantum emitters. The cavities consist of a one-dimensional array of unit cells acting as Bragg mirrors surrounding a tapered region. In this region, the photonic bandgap is gently shifted, allowing the accommodation of an optical mode with minimal scattering and a high-quality factor. In other dimensions, the light confinement is due to total internal reflection.\n",
"\n",
"In this notebook, we will implement the basic simulation for such cavities, and go through analysis procedures to calculate mode volume and Q-factors, without the need to run the simulation until the total decay of the fields, which is not practical for high-Q cavities. The Q-factor is a figure of merit related to the photon lifetime in the cavity; hence, a high Q-factor means that the fields in the cavity will decay slowly over time. The mode volume is a metric to evaluate the volumetric distribution of the mode; a low mode volume indicates a highly concentrated field. To explore Purcell enhancement, a cavity with a high Q-factor and low mode volume is needed.\n",
"\n",
" As a reference, we will reproduce the results of the work of `Parag B. Deotare, Murray W. McCutcheon, Ian W. Frank,\n",
"Mughees Khan,and Marko Lončar, \"High quality factor photonic crystal nanobeam cavities\", Applied Physics Letters 94(12), (2009).` [DOI: https://doi.org/10.1063/1.3107263](https://doi.org/10.1063/1.3107263).\n",
"\n",
"The design consists of two stacks of unit cells that will act as mirrors, and a tapered region, where the parameters of the unit cell are modified given a polynomial function, to reduce abrupt mode mismatch and avoid scattering. It is possible to explore asymmetries in the cavities, reducing the number of unit cells in one direction and adding a tapered region at its end, allowing efficient light extraction with tapered fiber optics.\n",
"\n",
"\n",
"\n",
"\n",
"For more information, please refer to our [learning center](https://www.flexcompute.com/tidy3d/examples/), where you can find tutorials and examples on how to carry out [band structure calculation](https://www.flexcompute.com/tidy3d/examples/notebooks/Bandstructure/), use the [resonance finder plugin](https://www.flexcompute.com/tidy3d/examples/notebooks/ResonanceFinder/) and how to calculate [Q-factor and mode volume for a 2D photonic crystal cavity](https://www.flexcompute.com/tidy3d/examples/notebooks/CavityFOM/)\n"
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [],
"source": [
"from typing import Callable\n",
"\n",
"import matplotlib.pyplot as plt\n",
"import numpy as np\n",
"import tidy3d as td\n",
"from tidy3d import web\n",
"\n",
"# defining a random seed for reproducibility\n",
"np.random.seed(12)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Auxiliary Functions\n",
"\n",
"We will start defining some auxiliary functions to help us set up the simulation.\n",
"\n",
"Since for using the [resonance finder plugin](https://www.flexcompute.com/tidy3d/examples/notebooks/ResonanceFinder/) it is necessary to analyze the fields after the source decays, we will define a simple function to estimate the decay time of the source, given the relation of the temporal width ($\\Delta t$) and the spectral linewidth ($\\Delta \\nu$) of a gaussian pulse $\\Delta t \\Delta \\nu \\approx 0.44$, and the `offset` attribute of the `source_time`object."
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [],
"source": [
"def find_source_decay(source):\n",
" # source bandwidth\n",
" fwidth = source.source_time.fwidth\n",
"\n",
" # time offset to start the source\n",
" time_offset = source.source_time.offset / (2 * np.pi * fwidth)\n",
"\n",
" # time width for a gaussian pulse\n",
" pulse_time = 0.44 / fwidth\n",
"\n",
" decay_time = time_offset + pulse_time\n",
" return decay_time"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Next, we will define the function to return the tapered parameter as a function of the unit cell position. A given parameter in the tapered region will follow the definition:\n",
"\n",
"$P_{tapered}(x) = P[1 - M_d(2x^3 -3x^2 + 1)]$\n",
"\n",
"Where $x \\equiv \\frac{\\text{unit cell index}}{\\text{number of tapered unit cells}}$, and the unit cell at the center is indexed as 0. Hence $x$ ranges from 0 to 1, so the center unit cell would have a given parameter as $P(1- M_d)$.\n",
"\n",
"The $M_d$ parameter is a number ranging from $[0,1)$ and is interpreted as the maximum reduction of a given parameter, in proportion to its original value. For example, $M_d = 0.3$ means that the smallest value of this parameter will be 30% less than its original value.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {},
"outputs": [],
"source": [
"def taper_factor(\n",
" max_dip,\n",
" structure_index,\n",
" n_tapered_structures,\n",
" cubic_factor=2,\n",
" quadratic_factor=-3,\n",
" linear_factor=0,\n",
" offsetFactor=1,\n",
"):\n",
" cubic = cubic_factor\n",
" quadratic = quadratic_factor\n",
" linear = linear_factor\n",
" offset = offsetFactor\n",
"\n",
" \"\"\"\n",
" Compute a taper factor using a cubic polynomial.\n",
"\n",
" Parameters:\n",
" - max_dip: float, maximum dip in taper factor.\n",
" - structure_index: int, index of the current structure.\n",
" - n_tapered_structures: int, total number of tapered structures.\n",
" - cubic_factor: float, coefficient for cubic term (default 2).\n",
" - quadratic_factor: float, coefficient for quadratic term (default -3).\n",
" - linear_factor: float, coefficient for linear term (default 0).\n",
" - offsetFactor: float, constant offset (default 1).\n",
"\n",
" Returns:\n",
" - float, the taper factor for the given structure.\n",
" \"\"\"\n",
"\n",
" # to avoid division for 0 in a case where there is no tapered region\n",
" if n_tapered_structures == 0:\n",
" x = 1\n",
" else:\n",
" x = structure_index / np.ceil(n_tapered_structures / 2)\n",
"\n",
" # factor is 1 if the structure is not in the tapered region\n",
" factor = 1 if x >= 1 else 1 - max_dip * (cubic * x**3 + quadratic * x**2 + linear * x + offset)\n",
"\n",
" return factor"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"To reduce the computational cost, we can exploit mirror symmetries of the problem to reduce the computational size up to 8 times. However, to properly set the symmetries parity, it is necessary to consider the polarization and vectorial nature of the fields. For more information on how to set up symmetries and their relation with source polarization, please refer to our [symmetries tutorial](https://www.flexcompute.com/tidy3d/examples/notebooks/Symmetry/).\n",
"\n",
"The function defined below will generate the right symmetry parity for a given polarization."
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [],
"source": [
"def get_symmetry(polarization):\n",
" if polarization == \"Ex\":\n",
" sym = [-1, 1, 1]\n",
" elif polarization == \"Ey\":\n",
" sym = [1, -1, 1]\n",
" elif polarization == \"Ez\":\n",
" sym = [1, 1, -1]\n",
" elif polarization == \"Hz\":\n",
" sym = [-1, -1, 1]\n",
" elif polarization == \"Hy\":\n",
" sym = [-1, 1, -1]\n",
" elif polarization == \"Hx\":\n",
" sym = [1, -1, -1]\n",
" return sym"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Simulation Setup\n",
"\n",
"Now, we will start creating functions to set up the simulation.\n",
"\n",
"First, we will define a function that creates a stack of unit cells on one side of the nanobeam, positioning them correctly and defining the appropriate tapered parameter. Since unit cell assembly is consistent across different types, the function will accept a `unit_cell_function` argument, which returns the unit cell geometry. Additionally, it requires a list of original parameter arguments (`original_params`) and a list of the $Md$ parameters (`max_dip_params`).\n",
"\n",
"\n",
"Note that `n_tapered_structures` refers to the total number of tapered unit cells on both sides of the nanobeam. Hence, if there is an odd number of unit cells, the first one is exactly in the middle. Otherwise, it is separated by a lattice constant from its twin on the other side, plus a gap (`central_gap` argument). The definition of `n_constant_structures` refers to the mirror cells on each side."
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [],
"source": [
"def assemble_unit_cells(\n",
" unit_cell_function: Callable,\n",
" lattice_constant: float,\n",
" max_dip_lattice: float,\n",
" n_constant_structures: int,\n",
" n_tapered_structures: int,\n",
" original_params: list,\n",
" max_dip_params: list,\n",
" central_gap: float = 0,\n",
"):\n",
" \"\"\"\n",
" Assemble unit cells into a structure with tapered lattice constants and parameters.\n",
"\n",
" Parameters:\n",
" - unit_cell_function: callable, function to generate a unit cell given position and parameters.\n",
" - lattice_constant: float, base lattice constant for the unit cells.\n",
" - max_dip_lattice: float, maximum dip for tapering the lattice constant.\n",
" - n_constant_structures: int, number of constant lattice structures on either side.\n",
" - n_tapered_structures: int, total number of tapered structures.\n",
" - original_params: list of floats, original parameters to be tapered (default empty list).\n",
" - max_dip_params: list of floats, maximum dips for each parameter to be tapered (default empty list).\n",
" - central_gap: float, gap between central unit cells (only valid for an odd number of tapered structures).\n",
"\n",
" Returns:\n",
" - unit_cells: combined unit cells as generated by the unit_cell_function.\n",
" - pos_x: final position of the last unit cell in the x-direction.\n",
" \"\"\"\n",
"\n",
" unit_cells = None\n",
"\n",
" # start position\n",
" pos_x = 0\n",
"\n",
" # defining the number of unit cells for each side\n",
" positions = range(\n",
" n_constant_structures + int(np.floor(n_tapered_structures / 2)) + n_constant_structures % 2\n",
" )\n",
"\n",
" # iterating over the unit cells\n",
" previous_lattice_constant = 0\n",
" for i in positions:\n",
" # defining the current value of the unit cell given the position\n",
" current_lattice_constant = lattice_constant * taper_factor(\n",
" max_dip_lattice, i, n_tapered_structures\n",
" )\n",
"\n",
" # condition for odd or even number of unit cells\n",
" if i == 0:\n",
" if n_tapered_structures % 2 != 0:\n",
" pos_x = 0\n",
" else:\n",
" pos_x = central_gap / 2 + current_lattice_constant / 2\n",
" else:\n",
" pos_x += current_lattice_constant / 2 + previous_lattice_constant / 2\n",
"\n",
" # now we create a list of parameters to input to the unit_cell_function\n",
" parameters = []\n",
" for idx in range(len(original_params)):\n",
" original = original_params[idx]\n",
" max_dip = max_dip_params[idx]\n",
" tapered_param = original * taper_factor(max_dip, i, n_tapered_structures)\n",
" parameters.append(tapered_param)\n",
"\n",
" # defining the center\n",
" center = (pos_x, 0, 0)\n",
"\n",
" # creating the unit cell calling the unit_cell_function\n",
" new_unit_cell = unit_cell_function(center, *parameters)\n",
"\n",
" # adding the unit cell to the geometry (or initializing the variable if is the first unit cell)\n",
" unit_cells = new_unit_cell if unit_cells is None else unit_cells + new_unit_cell\n",
"\n",
" # the separation to the next unit cell is the mean value of the lattice constants of the current and next unit cells\n",
" previous_lattice_constant = current_lattice_constant\n",
"\n",
" # return the geometry and the position of the last unit cell\n",
" return unit_cells, pos_x"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Unit Cell Functions\n",
"\n",
"As an example, we will create 3 different unit cell functions. The first two are simple functions to return elliptical and square unit cells. The third one is an example of more complex geometry using the [PolySlab](https://docs.flexcompute.com/projects/tidy3d/en/latest/api/_autosummary/tidy3d.PolySlab.html).\n",
"\n",
"Given the definition `assemble_unit_cells` function, the first argument must be the center of the geometry object, and non-taper parameters must be passed as default arguments."
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [],
"source": [
"# function for creating ellipse unit cells\n",
"def ellipse_uc(center, x_axis, y_axis, height=0.5):\n",
" theta = np.linspace(0, np.pi * 2, 1001)\n",
" x = x_axis * np.cos(theta) + center[0]\n",
" y = y_axis * np.sin(theta) + center[1]\n",
"\n",
" geometry = td.PolySlab(\n",
" vertices=np.array([x, y]).T,\n",
" slab_bounds=(-height / 2 + center[2], height / 2 + center[2]),\n",
" axis=2,\n",
" )\n",
" return geometry\n",
"\n",
"\n",
"# function for creating ellipse unit cells\n",
"def square_uc(center, x_size, y_size, height=0.5):\n",
" geometry = td.Box(center=center, size=(x_size, y_size, height))\n",
" return geometry\n",
"\n",
"\n",
"# function for creating \"sawfish\" unit cells\n",
"def sawfish_uc(center, x, y, height=0.5, width=0.1):\n",
" e = 6\n",
"\n",
" yArray = []\n",
" numPoints = 501\n",
"\n",
" # defining the vertices for the PolySlab\n",
" xaxis = np.linspace(center[0] - x / 2, center[0] + x / 2, numPoints)\n",
" xArray = np.linspace(-x / 2, x / 2, numPoints)\n",
" yArray = y * ((np.cos((np.pi / x) * xArray)) ** e) + width / 2\n",
" yArray2 = -y * ((np.cos((np.pi / x) * np.flip(xArray))) ** e) - width / 2\n",
"\n",
" X = np.concatenate([xaxis, np.flip(xaxis)])\n",
" Y = np.concatenate([yArray, yArray2])\n",
" arr = np.array([X, Y]).T\n",
"\n",
" geometry = td.PolySlab(\n",
" vertices=arr,\n",
" slab_bounds=(-height / 2, height / 2),\n",
" axis=2,\n",
" )\n",
"\n",
" return geometry"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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",
"text/plain": [
"
"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"# plot the geometries\n",
"\n",
"args = dict(\n",
" lattice_constant=1,\n",
" max_dip_lattice=0.5,\n",
" n_constant_structures=15,\n",
" n_tapered_structures=8,\n",
")\n",
"\n",
"ellipse_geometry, _ = assemble_unit_cells(\n",
" unit_cell_function=ellipse_uc, original_params=[0.2, 0.3], max_dip_params=[0.4, 0.3], **args\n",
")\n",
"ellipse_geometry.plot(z=0)\n",
"\n",
"square_geometry, _ = assemble_unit_cells(\n",
" unit_cell_function=square_uc, original_params=[0.4, 0.3], max_dip_params=[0.4, 0.3], **args\n",
")\n",
"square_geometry.plot(z=0)\n",
"\n",
"sawfish_geometry, _ = assemble_unit_cells(\n",
" unit_cell_function=sawfish_uc, original_params=[1, 0.5], max_dip_params=[0.4, 0.5], **args\n",
")\n",
"sawfish_geometry.plot(z=0)\n",
"\n",
"plt.show()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Source and Monitors\n",
"\n",
"Auxiliary function for creating the [point dipole source](https://docs.flexcompute.com/projects/tidy3d/en/latest/api/_autosummary/tidy3d.PointDipole.html)"
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {},
"outputs": [],
"source": [
"def create_source(\n",
" polarization=\"Ey\",\n",
" wl1=0.7,\n",
" wl2=1.0,\n",
" center=(0, 0, 0),\n",
"):\n",
" # defining the frequencies based on the given wavelengths\n",
" freq1 = td.C_0 / wl1\n",
" freq2 = td.C_0 / wl2\n",
" freq0 = (freq1 - freq2) / 2 + freq2\n",
" fwidth = (freq1 - freq2) / 2\n",
"\n",
" # defining the source\n",
" source = td.PointDipole(\n",
" center=center,\n",
" name=\"pointDipole\",\n",
" polarization=polarization,\n",
" source_time=td.GaussianPulse(\n",
" freq0=freq0, fwidth=fwidth, phase=2 * np.pi * np.random.random()\n",
" ),\n",
" )\n",
"\n",
" return source"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Function for creating the monitors.\n",
"\n",
"For this simulation we will have distinct types of monitors:\n",
"\n",
"1. Some point [`FieldTimeMonitor`](https:/docs.flexcompute.com/projects/tidy3d/en/latest/api/_autosummary/tidy3d.FieldTimeMonitor.html), that will record the fields as a function of time in different positions of the cavity, and will be used for Q-factor and resonant frequency calculation. We will record fields during the entire simulation and select the portion we want to analyze during the data analysis process.\n",
"\n",
"2. Six [`FluxTimeMonitor`](https://docs.flexcompute.com/projects/tidy3d/en/latest/api/_autosummary/tidy3d.FluxTimeMonitor.html) surrounding the simulation domain, that will be used for discriminating the directions of losses, and calculation of directional Q-factors.\n",
"\n",
"3. One 3D `FieldTimeMonitor` for calculating the total energy at the end of the simulation. To reduce memory requirements, we will set the `interval` as `10`, which means that we will record fields at each 10 time steps. For this example, we will not apply spatial downsampling, although it is possible to further reduce memory usage by adjusting the `interval_space` parameter.\n",
"\n",
"4. One planar `FieldTimeMonitor`, also recorded at the end of the simulation, to show the field profile. \n",
"\n",
"\n",
"Note that, in principle, it would be possible to use a frequency-domain monitor to visualize the resonant mode profile. However, the exact resonance frequency is often not known beforehand, therefore it is difficult the set the exact frequency to visualize. On the other hand, setting the time field monitors to record only a fell oscillation cycle at the end of the simulation ensures that only the resonant modes are being recorded, as the other frequencies have already decayed."
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {},
"outputs": [],
"source": [
"def create_monitors(\n",
" simulation,\n",
" n_point_monitors=5,\n",
" center=(0, 0, 0),\n",
" deviation=(0.2, 0, 0),\n",
"):\n",
" simulation_size = simulation.size\n",
"\n",
" freq0 = simulation.sources[0].source_time.freq0\n",
"\n",
" # creating random positions around the center of the cavity\n",
" positions = np.random.random((n_point_monitors, 3)) * np.array(deviation) + center\n",
"\n",
" # creating the randomly positioned monitors\n",
" point_monitors = [\n",
" td.FieldTimeMonitor(\n",
" center=tuple(positions[i]),\n",
" name=f\"pointMon{i}\",\n",
" start=0,\n",
" size=(0, 0, 0),\n",
" interval=1,\n",
" )\n",
" for i in range(n_point_monitors)\n",
" ]\n",
"\n",
" # defining size for the 3D field monitor\n",
" size = tuple(np.array(simulation_size) * 0.9)\n",
"\n",
" # defining the start time of the monitors to record only the last two oscillations of the field\n",
" start = simulation.run_time - 1 / freq0\n",
"\n",
" # 3D field monitor for energy density calculation\n",
" field_monitor = td.FieldTimeMonitor(\n",
" center=(0, 0, 0),\n",
" size=size,\n",
" start=start,\n",
" name=\"fieldTimeMon\",\n",
" interval_space=(1, 1, 1),\n",
" interval=10,\n",
" )\n",
"\n",
" # 2D field monitor for visualizing the resonant mode profile\n",
" field_profile_monitor = td.FieldTimeMonitor(\n",
" center=(0, 0, 0),\n",
" size=(td.inf, td.inf, 0),\n",
" start=start,\n",
" name=\"fieldProfileMon\",\n",
" )\n",
"\n",
" # setup planar flux monitors surrounding the simulation volume\n",
" flux_monitors = []\n",
" for i in [-1, 1]:\n",
" for j in [(0.5, 0, 0), (0, 0.5, 0), (0, 0, 0.5)]:\n",
" j = np.array(j)\n",
" # defining the center\n",
" mon_center = tuple(np.array(size) * j * i + -1 * i * j * (0.95, 0.95, 0.95))\n",
"\n",
" # defining the size\n",
" j2 = np.array([0 if l == 0.5 else 1 for l in j])\n",
" mon_size = tuple(np.array(size) * j2 * 2)\n",
"\n",
" # defining the name\n",
" mon_name = np.array([\"x\", \"y\", \"z\"])[np.ceil(j).astype(bool)][0]\n",
" mon_name = (\"-\" + mon_name) if i == -1 else mon_name\n",
"\n",
" # creating the monitors\n",
" flux_monitors.append(\n",
" td.FluxTimeMonitor(center=mon_center, size=mon_size, start=start, name=mon_name)\n",
" )\n",
"\n",
" return (\n",
" point_monitors\n",
" + flux_monitors\n",
" + [\n",
" field_monitor,\n",
" field_profile_monitor,\n",
" ]\n",
" )"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Function for creating simulation object. Since many simulation parameters such as symmetry and source positions depend on the final nanobeam structure, it is convenient to wrap everything in a single function."
]
},
{
"cell_type": "code",
"execution_count": 10,
"metadata": {},
"outputs": [],
"source": [
"def create_simulation(\n",
" wl1: float,\n",
" wl2: float,\n",
" width: float,\n",
" height: float,\n",
" unit_cell_function: Callable,\n",
" lattice_constant: float,\n",
" n_constant_structures_right: int,\n",
" n_constant_structures_left: int,\n",
" n_tapered_structures: int,\n",
" n_tapered_output: int,\n",
" max_dip_lattice: float,\n",
" original_params: list,\n",
" max_dip_params: list,\n",
" polarization: str,\n",
" unit_cell_index: int,\n",
" waveguide_index: float,\n",
" run_time: float = 2e-12,\n",
" central_gap: float = 0,\n",
" delta_override: float = 0.01,\n",
" substrate_index: float = 1,\n",
" medium_index: float = 1,\n",
" sidewall_angle: float = 0,\n",
"):\n",
" \"\"\"\n",
" create a simulation with specified parameters and unit cells.\n",
"\n",
" Parameters:\n",
" - wl1: float, wavelength 2.\n",
" - wl2: float, wavelength 2 for the simulation.\n",
" - width: float, width of the waveguide structure.\n",
" - height: float, height of the structure.\n",
" - unit_cell_function: callable, function to generate unit cells.\n",
" - delta_override: float, spacing for mesh override.\n",
" - lattice_constant: float, lattice constant.\n",
" - n_constant_structures_right: int, number of constant structures on the right side of the nanobeam.\n",
" - n_constant_structures_left: int, number of constant structures on the left side of the nanobeam.\n",
" - n_tapered_structures: int, number of tapered structures at the cavity region.\n",
" - n_tapered_waveguide: int, number of tapered unit cells at the right end of the nanobeam.\n",
" - max_dip_lattice: float, maximum dip for the lattice constant tapering.\n",
" - original_params: list, list with the unit cell params.\n",
" - max_dip_params: list, list with the tapering params\n",
" - polarization: str, polarization of the source.\n",
" - unit_cell_index: int, index for the unit cell structure.\n",
" - waveguide_index: float, index for the waveguide.\n",
" - run_time: float, total run time for the simulation.\n",
" - central_gap: float, central gap between structures (if n_tapered_structures is odd).\n",
" - substrate_index: float, index for the substrate material.\n",
" - medium_index: float, index for the surrounding medium.\n",
" - sidewall_angle: float, waveguide sidewall angle.\n",
"\n",
" Returns:\n",
" - sim: the simulation object with defined structures, sources, and monitors.\n",
" \"\"\"\n",
"\n",
" # define the mesh override at the cavity region\n",
" mesh_override = td.MeshOverrideStructure(\n",
" geometry=td.Box(center=(0, 0, 0), size=(4, width, height)),\n",
" dl=(delta_override,) * 3,\n",
" )\n",
"\n",
" # define grid specification for the simulation\n",
" grid_spec = td.GridSpec.auto(\n",
" min_steps_per_wvl=15,\n",
" override_structures=[mesh_override],\n",
" )\n",
"\n",
" kwargs = dict(\n",
" unit_cell_function=unit_cell_function,\n",
" lattice_constant=lattice_constant,\n",
" max_dip_lattice=max_dip_lattice,\n",
" original_params=original_params,\n",
" max_dip_params=max_dip_params,\n",
" central_gap=central_gap,\n",
" )\n",
"\n",
" # assemble unit cells for the right side of the nanobeam\n",
" unit_cells_right, pos_x_right = assemble_unit_cells(\n",
" n_constant_structures=n_constant_structures_right,\n",
" n_tapered_structures=n_tapered_structures,\n",
" **kwargs,\n",
" )\n",
"\n",
" # assemble unit cells for the left side of the nanobeam\n",
" unit_cells_left, pos_x_left = assemble_unit_cells(\n",
" n_constant_structures=n_constant_structures_left,\n",
" n_tapered_structures=n_tapered_structures,\n",
" **kwargs,\n",
" )\n",
"\n",
" # rotate and adjust the position of the left unit cells\n",
" unit_cells_left = unit_cells_left.rotated(np.pi, axis=2)\n",
" pos_x_left *= -1\n",
"\n",
" # assemble and position the tapered output if applicable\n",
" if n_tapered_output > 0:\n",
" waveguide_tapered, pos_tapered = assemble_unit_cells(\n",
" n_constant_structures=0, n_tapered_structures=n_tapered_output * 2, **kwargs\n",
" )\n",
"\n",
" # rotate and position the tapered output\n",
" waveguide_tapered = waveguide_tapered.rotated(np.pi, axis=2)\n",
" waveguide_tapered = waveguide_tapered.translated(\n",
" x=pos_x_right + lattice_constant + pos_tapered, y=0, z=0\n",
" )\n",
"\n",
" # combine the left, right, and tapered waveguide geometries\n",
" nanobeam_geometry = unit_cells_left + unit_cells_right + waveguide_tapered\n",
"\n",
" else:\n",
" pos_tapered = 0\n",
" nanobeam_geometry = unit_cells_left + unit_cells_right\n",
"\n",
" # calculate sizes and defining the center of the nanobeam geometry\n",
" size_left = abs(pos_x_left) + lattice_constant + wl2 / 2\n",
" size_right = abs(pos_x_right + pos_tapered) + lattice_constant + wl2 / 2\n",
" nanobeam_size = size_left + size_right\n",
" nanobeam_center = size_left - nanobeam_size / 2\n",
"\n",
" # recenter the geometry to optimize the simulation space\n",
" nanobeam_geometry = nanobeam_geometry.translated(x=nanobeam_center, y=0, z=0)\n",
"\n",
" # define mediums for the substrate and nanobeam materials\n",
" nanobeam_medium = td.Medium(permittivity=unit_cell_index**2)\n",
"\n",
" # create the nanobeam structure\n",
" nanobeam_structure = td.Structure(\n",
" geometry=nanobeam_geometry,\n",
" medium=nanobeam_medium,\n",
" )\n",
"\n",
" # define the waveguide geometry\n",
" cell_size = (\n",
" nanobeam_size,\n",
" width + 2 * wl2,\n",
" height + 2 * wl2,\n",
" )\n",
"\n",
" # defining the waveguide. Use a PolySlab for the sidewall angle\n",
" geometry_wvg = td.PolySlab(\n",
" vertices=[\n",
" [-2 * cell_size[0], width / 2],\n",
" [2 * cell_size[0], width / 2],\n",
" [2 * cell_size[0], -width / 2],\n",
" [-2 * cell_size[0], -width / 2],\n",
" ],\n",
" axis=2,\n",
" slab_bounds=(-height / 2, height / 2),\n",
" sidewall_angle=sidewall_angle,\n",
" )\n",
" waveguide = td.Structure(\n",
" geometry=geometry_wvg,\n",
" medium=td.Medium(permittivity=waveguide_index**2),\n",
" )\n",
"\n",
" # substrate\n",
" substrate = td.Structure(\n",
" geometry=td.Box.from_bounds(rmin=(-999, -999, -999), rmax=(999, 999, -height / 2)),\n",
" medium=td.Medium(permittivity=substrate_index**2),\n",
" )\n",
"\n",
" # defining the source\n",
" sources = [\n",
" create_source(\n",
" polarization=polarization,\n",
" wl1=wl1,\n",
" wl2=wl2,\n",
" center=(nanobeam_center, 0, 0),\n",
" )\n",
" ]\n",
"\n",
" # boundary conditions\n",
" boundary_spec = td.BoundarySpec(x=td.Boundary.pml(), y=td.Boundary.pml(), z=td.Boundary.pml())\n",
"\n",
" # determine symmetry based on structure configuration\n",
" if (n_constant_structures_left == n_constant_structures_right) and (n_tapered_output == 0):\n",
" symmetry = get_symmetry(polarization=polarization)\n",
" else:\n",
" symmetry = [0] + get_symmetry(polarization=polarization)[1:]\n",
"\n",
" # create the simulation object\n",
" sim = td.Simulation(\n",
" size=cell_size,\n",
" structures=[substrate, waveguide, nanobeam_structure],\n",
" sources=sources,\n",
" monitors=[],\n",
" run_time=run_time,\n",
" boundary_spec=boundary_spec,\n",
" grid_spec=grid_spec,\n",
" symmetry=symmetry,\n",
" medium=td.Medium(permittivity=medium_index**2),\n",
" )\n",
"\n",
" # add monitors to the simulation\n",
" monitors = create_monitors(\n",
" sim, n_point_monitors=5, center=(nanobeam_center, 0, 0), deviation=(0.5, 0, 0)\n",
" )\n",
" return sim.updated_copy(monitors=monitors)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Running the simulation\n",
"\n",
"Finally, we will set the parameters as reported in the reference [paper](https://doi.org/10.1063/1.3107263) and run the simulation."
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "iVBORw0KGgoAAAANSUhEUgAAAnYAAAETCAYAAAC7hUuNAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjMsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvZiW1igAAAAlwSFlzAAAPYQAAD2EBqD+naQAAiu5JREFUeJzsvXecZEW5//+ukzpOWHaXDSxhSZIlI4rClf2KP1cBMfIVAQMowlXkXgNXAcWAWUzAxYRfLwpiAK8oioAIXEQJekUQEBYEls07oeMJVb8/znT39HSY7pme2WH3eb9s2Tmnznmq6nP61NMVnlLGGIMgCIIgCILwvMfa0hkQBEEQBEEQeoM4doIgCIIgCFsJ4tgJgiAIgiBsJYhjJwiCIAiCsJUgjp0gCIIgCMJWgjh2giAIgiAIWwni2AmCIAiCIGwliGMnCIIgCIKwlSCOnSAIgiAIwlaCOHaCIGy1/O53v0Mpxe9+97stnRWhx/zoRz9iu+22I5fLzbrthx56CMdxePDBB2fdtiBMhjh2giA877nsssu46qqrtnQ2psQPfvADLr300i2dDQC01nzuc59j+fLlJJNJDjjgAH74wx92fP3Q0BBnnnkmCxcuJJPJ8C//8i/cf//9TdP+/Oc/5+CDDyaZTLLTTjtx0UUXEYZhR3aiKOKiiy7iX//1X8lmsx3nr1fss88+rFy5kgsvvHDWbQvCZCjZK1YQhOc7++23HwsWLGjomdNa4/s+nudhWXPzd+yrX/1qHnzwQZ588sktnRXOP/98PvOZz3DGGWdw2GGHccMNN3DjjTfywx/+kDe/+c1tr9Va89KXvpS//OUvfOADH2DBggVcdtllPP3009x3333sscce1bS/+tWvWLlyJccccwwnn3wyf/3rX/nGN77BmWeeyeWXXz5pPq+//npOOukknn76aXbYYYdpl3sq/OpXv+JVr3oV//jHP9htt922SB4EoSlGEIStglwut6WzsMXYd999zdFHH72lszElVq5caXbeeectnQ3zzDPPGNd1zdlnn109prU2L33pS82yZctMGIZtr7/22msNYK677rrqsXXr1pnBwUFz8skn16XdZ599zAtf+EITBEH12Ec+8hGjlDIPP/zwpHk9/vjjzVFHHdVp0WYE3/fNvHnzzAUXXLBF8yEIE5mbP2EFYRvn2Wef5R3veAdLly4lkUiwfPlyzjrrLHzfB+Cqq65CKcXtt9/Oe97zHrbffnuWLVtWvf6yyy5j3333JZFIsHTpUs4++2yGhobqbDz22GO87nWvY/HixSSTSZYtW8ab3/xmhoeHq2luvvlmjjrqKAYHB8lms7zgBS/gP/7jPybNfyfXlctlLrroInbffXcSiQQ77rgjH/zgBymXyw33+6//+i8OP/xw0uk08+bN42Uvexm/+c1vANhll13429/+xu23345SCqUUxxxzDNB6jt11113HIYccQiqVYsGCBZxyyik8++yzdWlOP/10stkszz77LCeeeCLZbJaFCxfy7//+70RRNGkd3HDDDaxcubKq4W677cYnPvGJumuPOeYYbrzxRp566qlq3nfZZZeW9zz99NOr6SZ+Pvaxj02ap8nyGwQB73nPe6rHlFKcddZZPPPMM9x9991tr//xj3/MokWLOOmkk6rHFi5cyBvf+EZuuOGGqq4PPfQQDz30EGeeeSaO41TTvuc978EYw49//OO2dkqlEjfddBMrVqyoO/7kk0+ilGo6JD+xfj72sY+hlOLRRx/llFNOYWBggIULF3LBBRdgjOHpp5/mhBNOoL+/n8WLF/PFL36x4Z6u63LMMcdwww03tM2vIMw2zuRJBEGYTVavXs3hhx9ena+011578eyzz/LjH/+YQqGA53nVtO95z3tYuHAhF154Ifl8HogbrY9//OOsWLGCs846i0ceeYTLL7+cP/3pT9x11124rovv+xx33HGUy2X+9V//lcWLF/Pss8/yi1/8gqGhIQYGBvjb3/7Gq1/9ag444AAuvvhiEokE//jHP7jrrrva5r+T67TWHH/88dx5552ceeaZ7L333vz1r3/ly1/+Mo8++ijXX399Ne3HP/5xPvaxj/HiF7+Yiy++GM/zuOeee7j11lt5xStewaWXXlqda/WRj3wEgEWLFrXM31VXXcXb3vY2DjvsMC655BLWrl3LV77yFe666y4eeOABBgcHq2mjKOK4447jiCOO4Atf+AK//e1v+eIXv8huu+3GWWed1bYerrrqKrLZLOeddx7ZbJZbb72VCy+8kJGRET7/+c8D8JGPfITh4WGeeeYZvvzlLwO0nTP2rne9q8Ghuemmm7j66qvZfvvtq8c2bNjQNm8V+vr6SCQSADzwwANkMhn23nvvujSHH3549fxRRx3V8l4PPPAABx98cMOQ9+GHH86VV17Jo48+yv77788DDzwAwKGHHlqXbunSpSxbtqx6vhX33Xcfvu9z8MEHd1TGdrzpTW9i77335jOf+Qw33ngjn/zkJ9luu+34z//8T17+8pfz2c9+lquvvpp///d/57DDDuNlL3tZ3fWHHHIIN9xwAyMjI/T39087P4LQE7Z0l6EgCPWceuqpxrIs86c//anhnNbaGGPMd7/7XQOYo446qm6IbN26dcbzPPOKV7zCRFFUPf71r3/dAOY73/mOMcaYBx54oGHYbCJf/vKXDWDWr1/fVf47ue773/++sSzL3HHHHXXHr7jiCgOYu+66yxhjzGOPPWYsyzKvfe1r68pjTK0ujGk9FHvbbbcZwNx2223GmHj4bPvttzf77befKRaL1XS/+MUvDGAuvPDC6rHTTjvNAObiiy+uu+dBBx1kDjnkkPaVYIwpFAoNx971rneZdDptSqVS9dh0hmIfe+wxMzAwYP7P//k/dc8B0NHnu9/9bl0+dt111wYb+XzeAObDH/5w27xkMhnz9re/veH4jTfeaABz0003GWOM+fznP28A889//rMh7WGHHWZe9KIXtbXzrW99ywDmr3/9a93xVatWNZSpAmAuuuii6t8XXXSRAcyZZ55ZPRaGoVm2bJlRSpnPfOYz1eObN282qVTKnHbaaQ33/cEPfmAAc88997TNsyDMJjIUKwhzCK01119/Pa95zWsaejQgHlIazxlnnIFt29W/f/vb3+L7Pueee25dz8kZZ5xBf38/N954IwADAwMA/PrXv6ZQKDTNS6Xn6oYbbkBr3XEZOrnuuuuuY++992avvfZiw4YN1c/LX/5yAG677TYgniSvtebCCy9s6AmaWBedcO+997Ju3Tre8573kEwmq8dXrlzJXnvtVa2f8bz73e+u+/ulL30pTzzxxKS2UqlU9d+jo6Ns2LCBl770pRQKBf7+9793nfeJ5PN5Xvva1zJv3jx++MMf1j0HN998c0ef4447rnpNsVis9t6Np1JPxWKxbX46vb7y31ZpJ7OzceNGAObNm9c2XSe8853vrP7btm0OPfRQjDG84x3vqB4fHBzkBS94QVPNK3notIdUEGYDGYoVhDnE+vXrGRkZYb/99uso/fLly+v+fuqppwB4wQteUHfc8zx23XXX6vnly5dz3nnn8aUvfYmrr76al770pRx//PHV+UYQD1N961vf4p3vfCcf/vCHOfbYYznppJN4/etf33aFaSfXPfbYYzz88MMsXLiw6T3WrVsHwOOPP45lWeyzzz4d1cdktKofgL322os777yz7lgymWzI47x589i8efOktv72t7/x0Y9+lFtvvZWRkZG6c+PnMU6VM844g8cff5z/+Z//Yf78+XXnJg7XdkIqlWo6v7FUKlXP9+L6yn9bpZ3MTgXTg4AOO+20U93fAwMDJJNJFixY0HC84lA2y8NUfmQIwkwhjp0gPI/ptBFsxhe/+EVOP/10brjhBn7zm9/w3ve+l0suuYQ//OEPLFu2jFQqxe9//3tuu+02brzxRm666SauvfZaXv7yl/Ob3/ymrodoYp4mu05rzf7778+XvvSlpvfYcccdp1yuXtKqjJMxNDTE0UcfTX9/PxdffDG77bYbyWSS+++/nw996ENd9YA24ytf+Qo//OEP+a//+i8OPPDAhvNr1qzp6D4DAwPVZ2jJkiXcdtttGGPqHJXnnnsOiOfAtWPJkiXVtOOZeP2SJUuqxyfq/Nxzz1Xn9LWi4sRu3ry5bsFQK9o5gM30baV5s/tUHPyJjqAgbElkKFYQ5hALFy6kv79/yhHtd955ZwAeeeSRuuO+77Nq1arq+Qr7778/H/3oR/n973/PHXfcwbPPPssVV1xRPW9ZFsceeyxf+tKXeOihh/jUpz7FrbfeWh0qbcVk1+22225s2rSJY489lhUrVjR8Kj1qu+22G1prHnroobb2Ou0xaVU/lWMT62eq/O53v2Pjxo1cddVVvO997+PVr341K1asaDp82G1vzx133MG///u/c+655/KWt7ylaZolS5Z09Ln22mur1xx44IEUCgUefvjhunvdc8891fPtOPDAA7n//vsbnNZ77rmHdDrNnnvuWXefe++9ty7d6tWreeaZZya1s9deewGwatWqpudHR0fr/l67dm3b+02HVatWYVlWtWyCMBcQx04Q5hCWZXHiiSfy3//93w0NH0w+/LRixQo8z+OrX/1qXdpvf/vbDA8Ps3LlSgBGRkYaovzvv//+WJZVHSLbtGlTw/0rjW6zYbQKnVz3xje+kWeffZZvfvObDWmLxWJ1he+JJ56IZVlcfPHFDQ7D+PJlMpmGcC7NOPTQQ9l+++254oor6srwq1/9iocffrhaP9Ol0uszPo++73PZZZc1pM1kMh0PzT733HO88Y1v5KijjqqurG3GVObYnXDCCbiuW5dHYwxXXHEFO+ywAy9+8Yvr8vH3v/+dIAiqx17/+tezdu1afvrTn1aPbdiwgeuuu47XvOY11Tl1++67L3vttRdXXnllXeiXyy+/HKUUr3/969vWwSGHHILneU2/H0DDj46f/exn1bL0mvvuu4999923On1BEOYCMhQrCHOMT3/60/zmN7/h6KOProYCee6557juuuu4884768JxTGThwoWcf/75fPzjH+eVr3wlxx9/PI888giXXXYZhx12GKeccgoAt956K+eccw5veMMb2HPPPQnDkO9///vYts3rXvc6AC6++GJ+//vfs3LlSnbeeWfWrVvHZZddxrJly9qGvejkure+9a386Ec/4t3vfje33XYbL3nJS4iiiL///e/86Ec/4te//jWHHnoou+++Ox/5yEf4xCc+wUtf+lJOOukkEokEf/rTn1i6dCmXXHIJEDf2l19+OZ/85CfZfffd2X777asLMcbjui6f/exnedvb3sbRRx/NySefXA13sssuu/D+979/qrLV8eIXv5h58+Zx2mmn8d73vhelFN///vebOheHHHII1157Leeddx6HHXYY2WyW17zmNU3v+973vpf169fzwQ9+kGuuuabu3AEHHMABBxwATG2O3bJlyzj33HP5/Oc/TxAEHHbYYVx//fXccccdXH311XVDlOeffz7f+973WLVqVTXu3utf/3pe9KIX8ba3vY2HHnqouvNEFEV8/OMfr7P1+c9/nuOPP55XvOIVvPnNb+bBBx/k61//Ou985zsbwq1MJJlM8opXvILf/va3XHzxxQ3nb7rpJt7ylrfwspe9jEcffZQrr7ySdDrNb37zGw477DBe/epXd103zQiCoBpHUhDmFFtkLa4gCG156qmnzKmnnmoWLlxoEomE2XXXXc3ZZ59tyuWyMaYW7qRZSBRj4vAme+21l3Fd1yxatMicddZZZvPmzdXzTzzxhHn7299udtttN5NMJs12221n/uVf/sX89re/raa55ZZbzAknnGCWLl1qPM8zS5cuNSeffLJ59NFH2+a90+t83zef/exnzb777msSiYSZN2+eOeSQQ8zHP/5xMzw8XJf2O9/5jjnooIOq6Y4++mhz8803V8+vWbPGrFy50vT19RmgGvpkYriTCtdee231ftttt515y1veYp555pm6NKeddprJZDIN5auEypiMu+66y7zoRS8yqVTKLF261Hzwgx80v/71rxvyk8vlzP/9v//XDA4OGqBt6JOjjz66ZeiS8eE8pkoURebTn/602XnnnY3neWbfffc1//Vf/9WQrhIKZtWqVXXHN23aZN7xjneY+fPnm3Q6bY4++uiWz+jPfvYzc+CBB5pEImGWLVtmPvrRjxrf9zvK509/+lOjlKoLmVIJd/LpT3/arFixwiQSCbN8+XLz4x//2PzHf/yHSafT5uMf/7gxpqbhxJA8rTQ/+uijzb777lt37Fe/+pUBzGOPPdZRngVhtpC9YgVBEITnFVEUsc8++/DGN76RT3ziE0C888Ty5cv57ne/y+mnnz7jeTjxxBNRSlWHegVhriBz7ARBEITnFbZtc/HFF/ONb3yDXC436/YffvhhfvGLX1SdSkGYS4hjJwiCIDzveNOb3sSmTZvabsE2U+y9996EYdhxvElBmE3EsRMEQRAEQdhKkDl2giAIgiAIWwnSYycIgiAIgrCVII6dIAiCIAjCVoIEKO4QrTWrV6+mr69PNnwWBEEQBGHWMMYwOjrK0qVLsaz2fXLi2HXI6tWr+ea3vk3Fp1PE/zA0m6KoUJaDZTvoKGqRhrHN0A3GaDCVOKPx9SiFUhaWpeq23ZlgBcu2O7fR7B7jbdTlAVBW7210Uo66+8R10XMbk5VD9BA9JpZjmnqEYcDGdc81bI3WDUqp6tZcAGEYNmwNNxt4nldtXLTW+L4/63lwHAfHqTVh5XJ5RrYNa4foUUP0qNGNHkop5s2b11GH0ac//Wmefvppli1b1jadOHYdEvfUxS9pS9njm5g6DAZjDNn+QYyycazWYkXaoJTCUhCGPsVCvHl1Kt2H43hoE3vpdpt7hNp0bKMZ420Yo8mNbgbAcTxS6b6e2+ikHMXCKGEYfxGyffNQyuq5jcnKIXqIHhPLMV09FLDTsiVY0+zxHx4erjYU8+fPn/TX+0zg+351f9uBgQE8z5v1PGit2bhxIxA3pFtqv1bRI0b0qNGNHlEUsWHDhkkdu8oPwr6+vknti2PXIZVKt5SN5djxLxEDasIL3WiDMRGu66KVjWtbLQULwghLKYyO8MtFXDf+peGXi3heEtuy0cbgOnbT640xEOmObNh284c7ijTaGBxbkRsZwrYdHMcjCMroKCSRSvfMRiflKBcLaB2RSKQJQx+/XCTbP4iKTM9siB6ix0QbM62HUgqlIJX0WtrqhNHRUbTWZLNZyuUyxWJx1hsv3/cZGhoilUoBUCgUSKfTs+pMVJwI13VJJBKUSiWiKOqo0eslokeM6FGjWz1838eyrOqnFUEQAHTUsyeLJ7YwURiQG92MbTv0Dcyjb2Aetu2QG91MFAazkgdjNLmRIaIoJNs3j2z/IKlUlmIxR6mYn5U8AJSKeYrFHKlUlmz/INm+eURRSG5kqOVQWa8RPWqIHjFzRY/R0VFGRkbo7+9n/vz5LFiwgCAI2Lhx47SGd7vB9302bNiA67osWLCABQsW4LouGzZsmLXhv4oTEQQBCxYsYP78+fT39zMyMsLo6Ois5AFEjwqiR425oAeIY9cVVT95/LSBiVtxE/fkVaYWGGNafsIwIJ8bxrYcMn0DYxYUmb4BbMshnxsmDIO295jMRjVrLc5roynkRojCkEzfILbjYIwhkUqTTGUoFXL4pcK0bEx63hj8UoFSIUcylSGRSsfDX45Dpm+QKAwp5EbQRk/LhughemwxPYyhxRS8jhjfaFV6QTzPm9XGa3yjVekFsSyL+fPnz1rjNdGJqPSC9PX1zaozIXrEiB415oIeFWQotisUGlCm9oY2pv5tXXl/R9pgWfH8m2Zv9CgMKOaGsWwHL9NHqAFqD56X6SPKjVDMDQMD2I7bMletbFTQxqCjxvPGaIq5EXQUksoOYJRNENXyYHspXG3wx3olvGS6axvjGX/v8filAn4xj5fKYHup+nTKJpHpp5gbJj86TCrbj1Jtuqtb2KggetQQPWJmQw9jQE/Rs2vWaFWoNF4bNmxg48aNMzbs1KzRqlBpvDZu3MiGDRvqGvhe0sqJqFCpm5GRkbq/e43oESN61JgLeoxHHLuuMFjEY9xmrGeucbw7Pm5bCgM4lmpIE4YB5fwIlh33RDh2szlCFlbfAPnRYcr5ETL9gzgTGi9jTHXidsv5PZGO5xBNnAtoNPmRUYyOSGUHSI5bSTQeJ52J71PKY1uKZCrTsY0KkTbxXKgmc4tKxTxBKXYi0ulM03K4dgIYoJQfwc+PkukfaHAm2tmIy9u6rkSPGqJH5dre6qEUU1o00a7RqjDTjVe7RqvCTDdekzkRFWbamRA9YkSPGnNBjwZ7M3bnrZDq7+3x72c14YOqRGOITytV94nCkPzoELbjkM72YymrIU3lYymLdLYf23HIjw4RhWFDmmY26j6VrNVdY8iPDhPpkEx2AMdx297DS6ZJprOUinnKxUJHNjo5Xy4WKBXzJNNZvGS6bR4cxyWTHSDSIfnRYcB0l4cWdSV6iB6zoodSjUvoJ6GTRqvCTA07ddJoVZipYadOnYgKMzUMKHrEiB415oIeTW3N2J2FBsKgNhE82z9IuyGsCkpZZPsHqxPGw2B6E8YnTgRvN4Q1nmQqU5swXpj+hPFSoTYxv1kvRzNsx+3pBH7Ro4boETNX9Oim0arQ68arm0arQq8br26diAq9diZEjxjRo8Zc0KOlnRm561aMnmLjNZVGq0KvGq+JjZbjdtZoVUime9N41TkR6c6ciAqO2xtnQvSoIXrEzBU9ptJoVehV4zWVRqtCrxqvqToRFXrlTIgeMaJHjV7qEUzzx2hTGz2/41aOjkJMlw/DdBqtCtNtvKbbaFWYbuM1HSeiwnSdCdGjhugRM1f0mE6jVWG6jdd0Gq0K03UmputEVJiuMyF6xIgeNXqtx+bNm3u+YlccuykQBD5Gd7bCLQyn32hVaGi8Oozj1atGq8JUG69eOBEVpupMiB41RI+YuaJHLxqtClNtvHrRaFWYqjPRKyeiwlSdCdEjRvSoMRN6OI5DGIYtt0ac0r17dqdtBMu2wRjC0G8IdTKRKAzIj0Wrn26jVWF845UfGZo0SKsxmkJuuGeNVoXxjVe5VJg0fblU6JkTUWG8M1HIDU/qTIgeNUSPmLmiRy8brQrdNl69bLQqdOtM9NqJqNCtMyF6xIgeNWZKj8HBQZRS+L7fs31tJdxJFygUStnYjkUUBoSBj4NXXX0HlUCnUPYDysUclu2QSPcRRgao98gNEBmDDpt76hW3MWhyPpHuozAujtfEUA9xXuLgqjoKSWcHMMpquFc7G3XnI92wqM/2krhaV+N4JVrE8SrXxUVLts5DExvj0zStK2WRTPdTyA1TyI1Ai7hq4bi4aKKH6AGzrIeBZKq5HjPRaFXoNNTDTDRaFToN9TBTTkSFTkNviB4xokeNmdbDtuNtSiuOtuM0umaTdSTV3bNnuduGsGx7bLXcuJ67sbgJiliAcmG0GofLtmwspRo+1fs1OTfZeduyyfQNYNkOpfwIJgrrzisMpXwtuKrrelPKQyVNq3OpVAYvlcEv5glKhYbzwTgnIpXKTMnGZPl0XY9UdgAdhZTyIyhM3Xkzdlz0ED22mB6lfNOeu5lstCpM1jMxk41Whcl6imbaiagwWU+R6BEjetSYLT0SiUTLnjutdVeLLKTHrgsMphqTyhoLmhqFAWHo47oeyrKITITWEV4iQTLbj2PbdT1649GTbEDO2Abkrc5bRpHK9uPnRynkh6tDSfGcoRG0jkiPNVpTtWHGovLbbYK8JpJpLKBcLmBZVnVor1TIUy4XSKYyuMn0tGxMVlceHio7QKkwQjE/Uh3aC4OAQn4YZ2wHA9FD9NgSeiigXMqTyzkMDAwAs9NoVWjVMzEbjVaFVj1Fs+VEVGjVUyR6iB5bUg+lFIlEgnK5XNdzp7WmXC53dS/psZsGlmXjuB4YQxD46DAkCgMUkM6032qpVyhlkekfqE4YDwJ/SnG4pktiQhyv8RPzEx3GRZsuE+OqBYFfnZjfbHeEmUD0qCF61EikMiRTGUZHR6uf2Wq0KkzsmSiXy7PWaFWY2FNULpdn1YmoMLGnSPQQPeaKHhN77srlMsaYpsOzLe8zg3ncJrDsmnMXr8JTWFbrXoiZoDJh3LJsciPxasBeTgTvlPETxns9Mb9TKhP4wzAgN7IZy7J7NjG/U0SPGqJHjUQqQ19fHyMjI7PeaFWoNF6VngjHcWat0aowfjVgZRhwNp2ICuOdCdFD9IC5o0dibAvDcrmM1hrP87qLlTdTmRMEQRAEQRBmF3HspomOIsLAB6XGVt4ZtI66WsEyXSpxuLSOyPbPw3Hcnmyv1C3jh/t6ub1SN1SC3TqOS7Z/HlpHPdnuqhtEjxqiR41yMc/o6Cj9/f0zsndmJ1R6Iio9E2EY9nTvzE6ozOEKw7DaMzTTe2c2Y/xwn+ghesDc0aMypy6RSFTn+nWTB3HspoHWNafOdT0sx8F2XAxQyI/MSuNljCY/UovD5bpeXZDWyeJ49YpysT7YbV0cr+LsOBPRhGC3rutV53jlRyaPq9YLRI8aokeNcjFPqZinr6+v+pntxmviRPBEIjEjG6O3Y+LE/EQiMWsbo49n4hwu0UP0mCt6VObUeZ6H4zjVOXfdxLiTVbFdEAdJqKyEi+JGQSkcxwOlMMZgKQtj2URhRDE3gtU3gNViPlElThdR8wcmGuv1i1qc10ZTzI1gdEQmO4Cy7GraVKYSS2yYVHYAj+bzJSazUel3jLQZK30jlbhoyVQGN5Gq3stNpNBaUyrm0YDVYtJ+JzYmqys/8CnmhnEch1Smn/g7qFGWTTozQD43TCR6iB5bUI9EKkM2W5sz1Gkcr17QanVfp3G8ekGr1ZadxlXrFa0m5oseoseW1KMSx268Uwe1OXfFYrHje0mP3RSoOnXETp1SKn7Dm/g/SikS6T50FJIfHSbSEdqYhk/1fk3OTXY+0hH50WF0FJLM9KNsp+68QZHM9GPZDsXccLxqdwp5qKRpda5YzFfjornJdMN5N5muxlUrFvNTsjFZPoMxJ8KyHZKZfgyq7rwaOy56iB5bTI9kpmnA6NnomZgsZEOvNkZvx2QhNHq1Uf1kTLbaUvSIET1qzJYeE3vqxmNZFm4Xi72kx64LDAZjInQUVXvqrInxrcY0T3gulj1AOT9CuTDadCVgMEmcrmgshpbr2PX5MJrcyCjoiFR2gORYV20jNmT7KeVHKBVGmq4EbGWjZssQRBrXthpslAp5gnKhGuy2ZTyxsZ6hoFzAGRdXrRMbFVrVVRgElAojOE7sLHgtHn7HtgDRA0SPGrOnRzKVodVC+Znsmeg0DtdM9kx0GhdtpnuKOg2hIXrEiB41ZlqPKIrn5ScSiZZhTbqJtCE9dl0y3qmbrKJtxyXTP9j1xujtGL9heaZ/cNI4XEpZpLO1OF69mjBeFxetxdZV40kk0z2fwF+ZmG/bDuns5HHRRI8aokfMXNFjJnomug2uOhM9E90Gu52pnqJu46KJHjGiR42Z0mNoaKhlT91UEcduCsS7THTmPTsTgrROp/Ea32hl++Y13f+yGeM3Ru9F4zW+0eomLtr4CfzTdSbGOxHdxEUTPWqIHjFzRY9eNl5TjZjfy8ZrqjsY9NqZmGqwW9EjRvSoMRN6hGGI4zjYdvNRgakgjl2XWLaD6rILthKkdTqNV0Oj1WVw1V41XlNttCr0wpmYqhNRQfSoIXrEzBU9etF4TXcbpF40XtPdlqpXzsR0dzAQPWJEjxq91mPevHk9X5Ahjl2XtFrBNxnTabym22hVmG7jNd1Gq8J0nInpOhEVRI8aokfMXNFjOo1Xr/a2nE7j1au9RqfrTPRqWyrRI0b0qNFLPbpZFNEpc8qxu+SSSzjssMPo6+tj++2358QTT+SRRx6Z9LrrrruOvfbai2Qyyf77788vf/nLuvPGGC688EKWLFlCKpVixYoVPPbYYzNVjJZMpfHqVaNVYWLj1Wkcr1KxN41WhTpnosO4ahPjok13WyrRo4boETNX9JhK49XrDcun0nj1egP5qToTvd5rVPSIET1qzAU9WjGnHLvbb7+ds88+mz/84Q/cfPPNBEHAK17xCvL51g3N//zP/3DyySfzjne8gwceeIATTzyRE088kQcffLCa5nOf+xxf/epXueKKK7jnnnvIZDIcd9xxlEqlrvJXnVU3PlyVmfAZi3lSiZRgjKn72I5Dpm+QKAwp5EbQRjekqXy00RRyI0RhSKZvENtxGtI0s1H3qWSt7hpFpm8A23LI54YJw6DtPfxSgVIhRzKVIZFKd2Sjk/OJVJpkKkOpkMMvFdrmIQwD8rlhbMsh0zcAqO7y0KKuRA/RY1b0MKb+vdEB3TRevW60KnTTeM1Uo9WtMzFTG8iLHjGiR425oEczlKm8/eYg69evZ/vtt+f222/nZS97WdM0b3rTm8jn8/ziF7+oHnvRi17EgQceyBVXXIExhqVLl/Jv//Zv/Pu//zsAw8PDLFq0iKuuuoo3v/nNHeVlZGSEL3/5UizHxW7zUMQvc012YAFWmxUuURhUY32lsv0NvR1mLLiqjkJS2YFJV/dNhU5s+GPBVb1UBq+D1X1TYTIbk9VVLxA9OrchetToWA8DSsG8bKJl+JZWTNYwzlSj1Y2N2Wi0OrExU05ENzZEjxqiR0y7uvJ9n+eeew7LstrmLQgC/uM//oPh4WH6+/vb5mdOx7EbHh4GYLvttmuZ5u677+a8886rO3bcccdx/fXXA7Bq1SrWrFnDihUrqucHBgY44ogjuPvuu1s6duVyubpfG1Ri6Bgs4ngyZqxnrjHkSXzctuI49I6lmoZFce0EMEApP4KfHyXTXwsPEW+DNIoZF4erGcYYQm1a2gAIIh3HAmu6itfC6hsgPzpMOT9Cpn+wbiVhqZgnKMWNVjqdmaKNOCq/Nga3RYPmjA1dBaU8tqVIjtsRIQwDyvkRLDvuGXJarByazMZkdSV61BA9KvROD6XA6iIO1XjaxfGajUYL2sfxmrXhpUniqs2GEwGiRwXRo8Zc0GM8c2oodjxaa84991xe8pKXsN9++7VMt2bNGhYtWlR3bNGiRaxZs6Z6vnKsVZpmXHLJJQwMDFQ/O+64Y20kZfz7WU34oOL/jaVRSrX8OI5LJjtApOMI/JXx3Dgaf0gmO4DjuG3vMZmNatZanLeURTrbj+045EeHiMIQpRTlYoFSMU8yncVLpqdlY9LzSuEl0yTTWUrFPOViAaUUURiSHx3CdhzS2X4sZU3LhughemwxPZSqf290SbNhp9lqtCo0G3aa7Uar1TDgbDkRFUSPGNGjxlzQo8Kc7bE7++yzefDBB7nzzju3iP3zzz+/ridwZGSEb3372z23Y4/F8cqNbmZ0eDMAWkdk++ahLLtuW6OZojJhPDcyRG50M47jEQTlOLhqKk3QYp/MXpNMZVAoisUcYRgQhn51Yn4Yzc6MAdGjhugRM1f0GN8z4fs+5XJ51hqtCuN7JjZs2ABAGIaz2mhN7ClKJBKUSqVZcyIqiB4xokeNuaAHzNEeu3POOYdf/OIX3HbbbSxbtqxt2sWLF7N27dq6Y2vXrmXx4sXV85VjrdI0I5FI0N/fX/eZKRzXjSeMR2EcMb9vcNqr+7ql0ngZYwiCMq6b6Mnqvm5JpjO4boIgiPfN68Vqy24RPWqIHjFzRY++vj6SySSlUgljzKw2WhU8z2P+/PkEQUAQBMyfP39WGy2oORPGGEqlEslkcladiAqiR4zoUWNO6DGr1ibBGMM555zDz372M2699VaWL18+6TVHHnkkt9xyS92xm2++mSOPPBKA5cuXs3jx4ro0IyMj3HPPPdU0WxpjNKVCrvp3qZCjF9srdUu5WKz+Owz9nm2v1A1hEPcMNcvTbCF61BA9aswFPSo9ERXaRQyYKbTW1flMEL9PZ2Jj9MkYX/ZyuTxjG9W3Q/SoIXrEzAU95tRQ7Nlnn80PfvADbrjhBvr6+qpz4AYGBkilUgCceuqp7LDDDlxyySUAvO997+Poo4/mi1/8IitXruSaa67h3nvv5corrwTiuS3nnnsun/zkJ9ljjz1Yvnw5F1xwAUuXLuXEE0/sOo/GGIzW1cUTaNV43hiiMEQrgzK1uT4TiUKNxlAq5tBRSDozAEAhP8zI0CaSqSwGhaL5Q2GMIYomt2EUGNPch9eRRhvwi3nKpTyJZAYvmaCQG2V0eCOpTD9G2T2xMVk5dBBRrE7M78MvlSnkR4iiCNtN9MSG6CF6TLQxG3qosXm3QaCIoqlNtguCgM2bN+M4DvPmzaNQKDA0NEQYhmQys9N7aIxh8+bNhGHIvHnzANi8eTPr1q1j3rx5Leug1+TzeXK5HNlslnQ6XZeHmQj42gzRo4boETMVPYIgDqc0mfPXTQCTORXupNVD+N3vfpfTTz8dgGOOOYZddtmFq666qnr+uuuu46Mf/ShPPvkke+yxB5/73Od41ateVT1vjOGiiy7iyiuvZGhoiKOOOorLLruMPffcs+O8jYyM8KUvX4pj2yhLUam1iVk2Ju5hSGf6MVjYlmpIUyGMNDoKUZh4EvhYl7HROo6dhcKyHZyWKwvj1Ydtbeh4Ja/VYoWk1oYwCsFobLu2X50xEIU+2hiU5cTlnoYNTbxCuFU5wijC6DBeoeh4VVtRFBFFISgLx3amZWPSuhI9qrZEj1o5eqFHvIACUglnSqtjtdb4vh8vbPG86rsyDEOCIMB13Z5tIN4KYwy+72NMvGH5+FV/zfI2UzQrc6u8zRSiRw3RI2aqeoRhyNDQULxYq009aa35yEc+0lG4kznl2M1lRkZGuPRrl5HJ9GE7bnWF7MSvTBSFRGHAbvsdSSKdBdo3Gr04LzbEhtiY2zaMNriuxf67LiDl9W6zb0EQnt8MDw/zy1/+kkQi0bZ3s1Qq8e53v/v5H8durmFMvErPdV2iMX/YnuB9WwqU0WT7+nGSWVzHatlrUfQjgJYv+snOh9oQhFpsiA2xMcdtaG1Iejbz5s0jnZDXriAINRzHwXXdtosswjDs/H69yNS2gjEaSxFHjo802piGKPLGWFiRIunZhEA60XqoqBxqEo5FOtnaSy+HuuX5MNIMh77YEBtiY47b8Byr5XlBEIReIm8aQRAEQRCErQRx7LpBpiMKgiAIgjCHEceuKwx+afbjeAmCIAiCsHXS6zWs4th1haLsFygVZj/ooSAIgiAIWx+VMCm9Qhy7blCKhJemWMxRLopzJwiCIAjC9KgENu7VDhWyKrYLlLJwEiks26ZUzKMBK1Uf0VpHGq0NJT/CSUKhHLYMg6C1qYZTaEblXKHUfOuicCyGltgQG2JjbtsohZrk7G4XKQjC8wTP88jlcmzcuLEn+9uKY9cFlqUwxuAm02jibYYAEsl0NY02oI0hiDQOEISaqMULv0I5bO+ltzpfCY4qNsSG2Jj7NrQsvhIEoQmWZTFv3jyGh4dbOneFQqHj+4lj1wVRFGFbCtexqz11QbmAY1kk02M9dyYkLIf0pVxCYCDjtYxftTlXbhtDq1AKKIeaedlE0/NhpBnO+2JDbIiNOW5D4tgJgtAO13VZsGABGzZsaHDuRkdHyec7n/4lb5ppkEimSaWyFIs5SoU8xmgKudGer3ARBEEQBGHrxvM8FixYQBAEbNy4Ea01o6OjjIyMkMlkJr/BGNJjN00qPXXFYo5iMQfG4I0bmhUEQRAEQeiEinO3YcMGnnvuOQD6+/ux7c73mJYeux6QSKWq/7YdFzXNiY+CIAiCIGybeJ5HIlGb/tFNbx2IYzdtjNHkRoZQSuG6CcLAJ4par7ITBEEQBEFoxejoKKVSiWQyiVKqOizbKTIUOw1ip26UKArJ9s3DcV3yoxZR1Dw0giAIgiAIQisqc+r6+/vp6+vD9302bNhAEHTuV4hj1wWKOJyBMQZtNIXcCOiITP8gtuNgjMFLJikXNZHWYMWr5lqhtSHUpmWaUJs4TavzY8fFhtgQG3PbRgRYliyqEgShNROdOqjNuVu7dm3H9xHHrgss2ybUBhOGFHMj6CgklR3AKJtg7MUeRQaUTaEckXIgXwrb3jMINcOh3zbNcL79ebEhNsTG3LchCILQinw+T6FQqHPqKniex8DAQMf3EseuC3QUYSuDnx/F6IhUdoBkoj6+lTIKIkU6YWOATNJpGb9qOO/jOhbpRHMZCuWQINQMZJqHrA8jTb4Uig2xITaeBzZcR6Y0C4LQSBiG5PN5BgcHG5y6Co7Tubsmjl0XGAzFQg4wZLIDKNtBqfpo80oplALbsggBx24dmNSyFI6lWp53LEXU5nw1ndgQG2JjTtuwLYWl2u9MIQjCtkkQBGSz2ZZOXbfIT8huMAY9tlDCdppHqhcEQRAEQegU13W7DmnSDnHsusKQyvThuOLUCYIgCIIwfboZZu0Ecey6QVnYtjh1giAIgiDMTcSxEwRBEARB2EoQx04QBEEQBGErQVbFdoFt20TaEIQRlVCjQVi/fVgUakJtGC0GpDIphvM+ltV8NZzWhqIfUW4R40rr2MrmXLntebEhNsTG3LZRCjWeKwGKBUGYecSx6wKtDUrFYQsiE7+kJ4YwMCruBnXHQh+4joXT4oVf9GOnMNEivtVk50NtCEItNsSG2Hge2JBwJ4IgzAbi2HWBMRpLgW1bEGm0MfG/69JYWJEi6dmEQDrROnBpOdQkHIt0svWCjHKoW54PozhivtgQG2JjbtvwnNZx7gRBEHqJvGkEQRBmAa2jyRMJgiBME3HsBEEQZpjALzO8cQ2l/OiWzoogCFs54tgJgiDMMH4pjw4jNqx+cktnRRCErRxx7ARBEGYQE4WEfhkwrH/6MXQkQ7KCIMwc4tgJgiDMIIFfxhiDZTuUi3k2PvfUls6SIAhbMbIqtguUstAGokhXw51EUX38Kx3pOG6VH+EkoVAOW4ZBqMTQakXlXKEUND0fjsXQEhtiQ2zMTRsGQxD4GDuJIcQYw3OrHmbhsl1b2hQEQZgO4th1gWUpjDFoUws0Ov7f8d+ggSDSOEAQaqIWjUqFVsFRJztfCY4qNsSG2JibNkK/hNEGpSzAwnY9htavJj+yiUz/dm1tCoIgTAVx7LogiiJsS+E6NtFYHDvXsevSKDRoRV/KJQQGMl7L+FWbc+W2MbQKpYByqJmXTTQ9H0aa4bwvNsSG2JiTNgwbVz8HxsEixMJg2y5haYQ1Tz7Kbge8qOk9BUEQpkPXjt2qVau44447eOqppygUCixcuJCDDjqII488kmQyORN5FARBeN4RlEv45SLK7YexTQiVUli2zdp/PsrOex+M43pbNpOCIGx1dOzYXX311XzlK1/h3nvvZdGiRSxdupRUKsWmTZt4/PHHSSaTvOUtb+FDH/oQO++880zmWRAEYc5TyA1jjAalYNyMDcdLUi7m2bB6FYt3fsGWy6AgCFslHTl2Bx10EJ7ncfrpp/OTn/yEHXfcse58uVzm7rvv5pprruHQQw/lsssu4w1veMOMZHiLYjRRFADNh2UEQRAg3mWilBsem1tXj2VZgOG5Jx5m0U57omQPWUEQekhHjt1nPvMZjjvuuJbnE4kExxxzDMcccwyf+tSnePLJJ3uVvzmGopgfxXUTKMuePLkgCNskpdxwPCfXdmi25tZxE4xsWkduaAN98xbOev4EQZg7hGHY0/t1FMeunVM3kfnz53PIIYdMOUNzGqWwbIfc6GaisHn4A0EQtnUM+dGh+J8tOuNsx0VHIWuefGTWciUIwtwkCALy+XzP7jflVbHr1q1j3bp1aF0fBuCAAw6YdqbmKgpFKp3FLxXJ54ZJZvobVsIZYzAGIq3BilfNtUJrQ6hNyzShNnGaVufHjosNsSE25o6NoFwg8AOU7WJQoCwMBmNqfXdKKSzHYe0/H2OXfQ/F9WThmSBsq7iuSy6Xw3Ec+vr6pn2/rh27++67j9NOO42HH34YY2orvYwxKKWItuLtcizbJjIKL9NHlBuhmBsGBrCdWqiEKDJE2lAoR6QcyJfad7EGoWY49NumGc63Py82xIbYmDs2/GKZyO1DWbUffUY5sZM3DtdNUC4WWP/04yzdbd+29xcEYevFcRyy2SwjIyMATZ27boZru3bs3v72t7Pnnnvy7W9/m0WLFm1TE391FOFYCtdxsPoGyI8OU86PkOkfxBlz7pRRRH5EOmFjgEzSaRlDazjv4zoW6URzGQrlkCDUDGSah0QII02+FIoNsSE25oiNKArZtHkTtjFjiyQgdLIoE6JM/Y9eZVmgYPWqh1my6z7b1LtUEIR6MpkMjuM0de5832d4eLjje3Xt2D3xxBP85Cc/Yffdd+/20uc9ZnwsKmWRzvZTLoySHx0i2zcPx3XxSyW0jrAtixBwbKtlo2JZCsdSLc87liJqc76aTmyIDbExJ2z4hTxE8fxbo8feGXYaZXS1vy70y4SBHztyxlAYHZJFFIIgVJ258c6d7/ts2LAB2+58wWbXjt2xxx7LX/7yl23SsZuIUhbZ/kFyI0PkRjfjOB5+uUgimd7SWRMEYQuQSGXpX7AYDBijGd28HiZuOxhFpLIDLNsjno9s2TbpvsEtkFtBEOYa45073/cpl8u4rksqler4Hl07dt/61rc47bTTePDBB9lvv/1w3fqteI4//vhub/m8puLcDW1aTxCUcVyvK89aEIStB9txq3vA6iiKHbsmOK7Hsj32n82sCYLwPKHSU1cqlYA42kjl353QtWN39913c9ddd/GrX/2q4dzWvniiFeVisfrvKAwwTvN9JwVBEARBENpR6amrkM/nu+ow6iiO3Xj+9V//lVNOOYXnnnsOrXXdZ1t06kqFPMVijlQqy+B2C7Fsh1Bi3AmCIAiC0CWVOXWu67JkyRL6+/sZGRmhUCh0fI+ue+w2btzI+9//fhYtWtTtpVsF4WgB8mWMbVOOfMJyAc/2sEoRQSmHG1kE2mfkr49jLVqC3jSEFTZ3eMvz5+GXyhTzzQULM2miZAK9cXPT89qx8bcbFBtiQ2zMRRsK9HYGTQQ6wGhN8dn1QBG9epS//OzLTe8pCMK2Q97WFAcKBFqBgpytsQ24kcXomlEAHEszYnUewLhrx+6kk07itttuY7fdduv20uc9tm1jXAdtOfhBiSAo4ibSOG6SSnhSYytUBP5AP0nA324Q1SK4qbEtwkyKKNl871kzthKvPH9e2/NiQ2yIjblpI0oZUDbGcjCR9OQLgtCcSBmKtsE2kI0s1Li4l0ltEZrWgdYn0rVjt+eee3L++edz5513sv/++zcsnnjve9/b7S2fN2htwJg4snxUxnVTJGwPxu2+obRBGYMVBJAEyw+wguaBBcNMvMrFLpWndF67DtpzxYbYEBtz0YaCyDUYd2yVfBcvZkEQth0MULQ1jlENTl0Fr4vXx5RWxWazWW6//XZuv/32unNKqa3asTNGE5aLRDrEc5O4bhIV1P8KVzpCaY1TKELfIE4u33IYKEomsEtlnBbDQJU0rc5XhoE6tjEWN2tGbVSYYKszGwWsFtG129eV6r4cTepixvQYZ6tzG0WgUatJ9VCq+3JMqIvONfdn79l9PtpQECYMkZ0A44PysZKbwQdIkBn4B647QhD0kx/eldqUZ01m4AlcdwjHyxP6WYJgYEKabQBLgW78DrRFjf1fk/dc720p4rg23V02JVtTuQZavvN7bqvih8xGXUylTFO1NUuEymA16ambKl07dqtWrZq20cn4xje+wec//3nWrFnDC1/4Qr72ta9x+OGHt0x/3XXXccEFF/Dkk0+yxx578NnPfpZXvepV1fPGGC666CK++c1vMjQ0xEte8hIuv/xy9thjj+4yZgxBFJB0ErhusutneEvhzutjYO+dsJMeuhxQWr1hbK5Pa+x0kszyJai+NMN5n/R2WUqrnkOXW2+tpJQiteP2JJZsh+W6RMUSxafWERbbb8fk9mVg/gDzdl2MraC8fojCqjWYNotxlGOT2WUJ3sIBlGUxOlSgsGm0fUUA3nb9ZHfcHjuVQPsB5TWbKDy9ru2Lwkp4ZHZdQpBO4Yea7OJB8k+sJio278UZyyGpZQtILlmAlXCJSmVKz6ynHLR/aqxkAmfhIPP3WobRBn/jMIVVz6Fb9DhBvINBepfFJLafh3JsNm3KYTYOQxtnpVIX6Z0XYWdSmCCktG4zxafWts+f55BevhQrmSTh2rjlMoUnniPMF9tel1w8n+TS+XFdFMrknt1A+6cC7KRHauEA6YRDOFqg+Mx6tN96OFNZFont52GnE0Qln+KGkbb3V7aNnUrgeDaqVG77vKEUTjqBDnXb70Dlvsqx0YFPZBmMrbEigzIKbBfcEtnBR9l9wbeq1/jlAVY/8VoAlu76M7xEY5T5IJjHs/84geGNrffjduf1kdltKWG+SO6Rp9s2ZO52fWx3xD7Y2RT5fzzL8J8fa9swp3bcnoUrDiGxcJDS2k2sv/leSqs3tqkIWHDMQcx/6QG4g1lKz25gzS/vJvfwP1tfAwwcuDuLVh5JaocFhLkim+56kDU33o1p4ZwDOAMZdnj90fTvvxvKtsg99gyrf3I7pWc3tLW14JgDWXjsIXjz+/E3jrD+lvvY8Ls/t70mucMClr7uaLJ7LMNEmpG/Ps6zP76dcLj1HCjl2CxeeSTbvWQ/nGyK4uoNrP3F3Qz/+R9tbWX33oklJxxFeqdFRIUSm//4MM/dcBe63Pp7YGeSLD3pZQwctAeW51B44jlW//T3FJ5c09bWvBftw6JXHk5i+3kEQzk2/P4vrPv1n9q+G72Fg+zw+qPJ7r0zGMPow0+x+se3429os0uCpdj+uMNZ8LIX4g5kKK/dzNqb/sjmex5qm7/0rktY+tqXkV6+GO2HDN//KKt/+nuiQuv3sJVwWXLiUcw7bC+sZILi0+t47vo7yT3S/hmcbRSQ7pFTB6CMmYrr28hzzz3H97//fT74wQ9O6z7XXnstp556KldccQVHHHEEl156Kddddx2PPPII22+/fUP6//mf/+FlL3sZl1xyCa9+9av5wQ9+wGc/+1nuv/9+9ttvPwA++9nPcskll/C9732P5cuXc8EFF/DXv/6Vhx56iGSys823R0ZG+NKlXyVle6TcFMa2MZYVD7mOI9IRkQ55wZL9sBYtwZtk4na73oLKxO3EJBO329nQu+xAZkE/6WT9kHnxmfUUnnyuqQ0r4TF40B4oxyaMNMN5n4GMhxWGDD/wGHqCrUo5BneYT2L7xrlIG59YQ7kcNC2H258hvc8uDBcCBjJeNcJ/OJpn+H+fqL5U6upKKQYO2A2nrxYIulAKKAcR1qpnCEca61M7NnqHRcxful3DLgLltZvIPfZMUz0sx2Hg4D2wPDe2EWrmZROYIGToz4/VvWDH69G34/Ykd2jcSWD9MxvQ64eaau5kkjh77YIfGeZla3O+okKJ4T//A6N1U837912OO6+2/czmXJmEYxE9/gz+5kZnN8ykYV4fi3ZpXADlbxxh+LGnmz5XyrYYOHAP7FSiaiOddDFRxPBfHicqlOpsVJ6r9E6LSO1UbyuMNBue3Yi9el3TZze5eD7+4gVVGwDaDxj+yz+qdT7ehuXY9B+wG3a69n0uF8psXL0Jd8OmBhtONkXfvssZLkckHIuUrRh56Ml4cdSEujLZNAt3XICdjLcV8zcMk3v06aZ6pHdZQmqHBaAUT48+SbDhYdL2TihdwjYBS9f/ADfaTFatZon1v1U7E9/CrXYXMyiefuKdbF69d8O57Y7cl2X/91jUWFiE4tPrePyrPyHKN8a/Su+6lF3PeW21TABD9z3KU9+5salzl33Bjiw/+7VYTi3kgvZDHv/Kjymseq5pXpec9DK2X3FIff614cn//Dkjf32i6TUDB+/JLu9c2XB86P7HeOpbv2h6jZX02PP8t5BYOFh3PCqWefQzP8BfP9T0ukUrX8TilUc2HF9z4x9Ye+PdTa/xFg6y54f/L3aqfk5mef0Qj15yNbrU3Onf+Z0rGTx4z4bjT37rRobvf7TpNdm9dmLXc15bt+cwwOgj/+SJr/6kqU7KsdnjA28mtWN9W6mDkH984VqKT69ramv+0S9k2Zte3nB8w+/+zLM/uq3pNU5/hj3/4y24/Zm648Fwnkcv+a+m72GAHU4+lgUvbfxx8swPb2HjHf/b5ApI7byI3c97I5Zb3xdV+Oda/vH5azDN5tAqxW7nvp7sHsvqDptI88TXfkru0aeb2ppt8rbmnoECrlY4bRw734S87zMfY3h4mP7+/rb37Lpf/+1vf3vTzymnnMInPvGJbm/XwJe+9CXOOOMM3va2t7HPPvtwxRVXkE6n+c53vtM0/Ve+8hVe+cpX8oEPfIC9996bT3ziExx88MF8/etfB+LeuksvvZSPfvSjnHDCCRxwwAH8v//3/1i9ejXXX399l7lTuHbzPSPnIsqycCZ86SqkdliA5TXvsE0tW4hyGmPmWAmP5JL5Ta+xEm5Tpw4gsf1gyzymdl7ctBVz+jJ42zV/eL35A3VOXRWlSO+0uIUlhd3sGiCxaLuGF3WF5NL5WF5jXELlOqSaOG4AluuSXLqg6TmnPxMPCTQhtVPzvZftdLJlHbqD2TqnbjzpXVrVBbgD2abHvfn9ONnu6knZNqkdW9WF09DIVGiqIWM9kMsb8255LukW90ouW1jn1AHYCRcn2zxae3aPHesaCeU6ZPfcsWlab8FAnQPkLRiInbcJJBYOklq2EJTCYPib/zeWR/8kwQhptZmM2sAu9u3sYd9U59RB/Veg3ZaxCthhj/8G6hsyZyDDDifXnDqIe9iWnHBU0/ssO/nYujIBDB6yJ/0HNF8Ut/T1R9c5dRD33i496WVN07uDWRa+/KDG/FuKJa9tnieAJSc2Pzd48B6kdm4eiWH+Ufs3OHUAdirBolc2H+mxUwm2f8VhTc9t/4pDW74PFr3y8KbnEgsHmX9U84DTqZ0XNXXqoHV5AZYc/5IGpw6g7wU70bf3Lk2vGTz0BU2/b5brsOjVjU4sxD/YlrzmxU3PzX/ZC3FbvIcXHntwg1MH4A5kWPgvBze9xps/0NSpA1j8mhdDk/ICLF55ZINTB5DeaRGDh7yg6TV9++7S4NRBXN7Fxzcv75ai17tEdz0Uu3lzfa9LFEU88cQTPPzww1x22WXTyozv+9x3332cf/751WOWZbFixQruvrv5L6i7776b8847r+7YcccdV3XaVq1axZo1a1ixYkX1/MDAAEcccQR33303b37zm5vet1wu1wUIHBkZQSlQBCgiwEZhoZgwxw4NaCw242gHmxEsmvemOTrEMj42zYexjCmgtIdN825thY2jg5Y2nFQKHa3F8i2UanROvGSeKBxpsOEm+lBjvSJKa+wgQPlu7CgmRrGpH35xdIjrOahy865+Rwe4aiM2TXrsvAVE/nCdjWr+UqNEY7bG15WXtBtsWX6AHWncpNOQPwDbTUK0vsFG1VY6h6/zDXq4yTSqbOpsqHJirJ4KdbYqenipCOU3H9K0ozKuM4RF4zCh6w2i/ZE6G9X8JXMEbGzQ3EvRUBd2UMbSFk7CxVabGrqDjCri4KLKzYeu3eQoTqgbnisvmajaqtioPFeuV66ri8qz66bCpnWhtMbRAdhDENb3cjipFFa4vsEGgJsoVe2M/354qSyqXO/sKK1xVQnDxrpyWI6D4wxBub4cjgWuN4z2xw17W+WmdeVmYu3H65HI1p7LTeFGdhl9CisqYkebsEwRy5QJDQS0CDTa6ds9Wk96wd8oju5SPZTedTui8hqiCaNSyR1tVKI+7yrh4gyWCfLPNtw6tbPL6N8npHdsnEG/aXp3oWm4P0Byp3mExeY9eXYfWH1FjF8/vcBKelipHEE+1/S65I4OpTWNtrwlqmneANztm+cvsSxN5K8lajGqntjRpvhU43Xu9qalLW+Jal4XO+7Q8horBfZAuWlPnzM/bHldYkeb3ONNbC21WudvoW6aP2/hANpsRLcYSU7uZBPmm9ThYtrUBc3rYuf5La9BgbfYEGxsUu8Lo9Z1scxC/aVZvdutn4sFzetii2AZUKCsSV4BegZXxf7sZz9revxTn/oU119/Pe9617u6vWWVDRs2EEVRQ4y8RYsW8fe//73pNWvWrGmafs2aNdXzlWOt0jTjkksu4eMf/3jdsc996gO4KsJVGmMURKBUfaMZKguUzTz1J9KFCKVClN18tFuXXJTWKLu542ciG1OysOzm8ymMUpiC09KGCizM6hSWUthNeon6ywWy0GDDWZ1COfGj4QJuqHEcCwU4fkDCrh/a0SUXq6xwVzX/lWtrQ7JYbloOZ1UGLKvORvW6YpmU7VdtVOrKGkpgl+p7G2xt0MbgKNjObvKGiix4LtVgo3p9vkhaqQY97DVJrE1unQ13bCjXDUNcu+YEVvSwtMFd1bynaDDSmGIZZTfOmXP+mcFVqs5G9VzZJ2GXGzS3hl3soL6najDSY5rDdlZjI2kCG7U62WCjwkChRBYanit7fQJrxJtgI65NE0U4dm3opfLs2lrjrGrsmas8V5gi2BMcssDCWZVpsAFgwpqd8d8PZ3UKNeEXvQs4QQiqNOH7oXBXZZuWY1DnYFxa4zevKzcI8exinR7Oeg9rNK6febrEgL8JT0cMFv+MRYRCM6RtRmne690NatkDeMHj1b9DO8m6e25tSBcWSni7T3zPKdbe/TCqyTuhNLQZb/fGH5Jr7/570x9EOorwdm8c0oq8BOvuaT6EZ7TB3empJmcUa//wUNNeawA/Wo+3e+N3e3T1A5SLzXuVmpcftOex7p7/aXoNgM6sxtu90dna9PDfcJ5qPn3H3zyCt/umJvn+A+vuubHpNcYYnGX/pNm46ro/PFrXAzueUn4j3u6Njklu030E9ww2vSYq+3i7r248Ydusu+f+ptcARO4avN0bh/M3P/6/5NY3HxEKRvJ4uzfO446f01ta2lILnsab19gebnjg701HTgDKG4fwdh9qOF4c/RPr7tmu6TU6bP7cbgm8KIUa2Q9LBViqtfNmm8779bp27Fpx8skn88lPfrJXt9vinH/++XU9gSMjI/zo/12KUhEoQ9W3VhMnxwBYoEKU8ce88eaOnULHg+F2CzEtHd+u1XmlUCZqacMAKowdjmjiO1kbjPHBthpsRH4BNfZomLFbR8HYYqQgaGyIiR3dyI+aDu6byKAIm5YjKufBsetsVLMY+tVGdnxdmSAicuodI6Pjqo+iCJo4TUYprAgioxqHujRoXUbZVoMeOihgLLfexlhVm3II453yMT2MMUS+bjrkqiKDUS3qws+DbdfZqObfH6v3CZrrKIJA1/3UUzrWPtS6aV1gaQgNUbMXhQEdBSiLhudKBxozdr+KjcpzZfwJ9T727BqjiXzTUBfGED+DKmj4UWKAsBwvxhlvAybU+bjvR+TnG3qljQHCCKyo4fsRFkdRrl1XDhNGYE2oL0tDoIlM/YNtyo16REGIsUKwwDIRkVFE2CgTYlBAODaAOv2VrQbi56hSnlKOIDeElar/weNv3FiXrnp803qceROG4yNDMLIZ06Rx8TdvxBlsbMSDTaNN7x+WQsLiCKrJdI9wuND0GgB/aBNOf5MfRaEhzI9gmrznwuHN2P3Nm7JgeKipLROEBPlhrGSjs6DLATooNO0+CYY2oRKDTW2Fw5ub10VuhKicBqfxhuFIEaOa/3D3N2/CmdfEcYogyA031SkYGcIZ9Jrm3R8aaV7vOiQY2YyVafLD3I8Ii7nmdTG8CSvT3NkIhjc1tRWVckSlUXAbHVadL2N0uamt8uaNeAuaOO8GgtHmGge5Idwg2fTrFg7lWj6Ds02cD4NRpunzXaGb4dqeOXZ/+ctfOOigxjkV3bBgwQJs22bt2vqhm7Vr17J4cfP5QosXL26bvvLftWvXsmTJkro0Bx54YMu8JBIJEon6Bz3unYu/TKrl8rG4MVTKxzKlWI0WilQ1bPGen/T8mLl2NgiDeJXehOzqIEJZprkNDQRW/S90A0QajI4b/Sb5NIFqmIeDMZhIYxnTvByRj8KOG34zbtV8GMX1PdF/rtyj7DfOA9QGE0UN+YOx24Q+yrYaegR02KYuDODH11XvFYHRjXUxXg/j+1gTX14m7tnqpC7UOH/RRBqUHpsKQKPmfpO6MCauw2Z1YYBAgWmsCxNGWMq0fq6a1oUBXW9rfF0aP4ifi/H3MgZCXadxHcFYmVStLsyE569OLwOUy/X1EGksrZuXI/Lj8lccztCAbvFsh0CkqvN/4onapjZ0Mu53nvHLKMvCVhBh4h8kpgwo1NgR0+rLWilPuze4AWNsIuOgJvSAl9euwRnIYCc8jNaEowWiko9q0unjD23EmFI8n9JSaD8g2DQKJmyaPti8AZSPnan1VkW5IsHwaNP0lfx4CwfrNNEln2DzcMtRjGDTepQ9iJUY53BFGn/jMKigqa0oCPDXr8MdzNb9MgxzBcJ8rmX+/PVrG/Jnwgh//VDLUZSwMIwaiurnoRpDMJQjCoqt62Ldc3jzB2Dcd0eXA4JNQ63rYmgDygmwxs/pG1spj2muq4kCyuvW4m3XV1cXUb5EODrSOn8b1pGwBut6vU0U4a8fbjq6ABCVAoKNBmeg3vkMh/NEpXxLW6XKczGuLowfUt4whGrRiRGObsbyovp5tMbgbxrFRKXmtgyU162J52qP+2Gpi2WCoeGW+ZttlHHHfAaDatNj180Pwq4du4nz2SB2km644QZWrlxZd/5LX/pSV/f2PI9DDjmEW265hRNPPBEArTW33HIL55xzTtNrjjzySG655RbOPffc6rGbb76ZI4+MJ4ouX76cxYsXc8stt1QduZGREe655x7OOuusrvIXGQttEhhjYcZaWTUhnIAxCmMsQr0DJcfCLvstQw7opIeKNKpFKAvjOhjbwmqx0gpLESW8yW2EGse2UI6FiTS65FenXbW0EYDl2ijPJbTi86ZFPqvl8ENUqLAS8Tw2E0ZE5WDyckQKnUriqnheVFQOGlY5NasrFVnYCReUItQaDVjB5HVluw7KseNVjaWAysLwdnpYjo1JenHPX6mMDpq8+CfoocJ43pCyLcxYmIwoMYnmOBjLwRt7D0Ulv74uWmiuQhVPhldjsz6DcPLnquhjJ9y4YdOGqOzHTtokz5VlW0TpJJYxqHLQNBTLRM1VEC+wUbaFDiN0GE3+7NoelgbLaEwYxXlrYwMAn1qYq06/HzP0HSy5AeXkMEkzgEWIMiFe9E8c0+ReZsK/mzl3Y2lyw3uiS82Hc6O6qZvNp0ZUKI9CWY31jGoPJhkijkZjDe2UR1Qoo30FNF8AA/Hvw2hY4c7LYnkuUb5EMKKA5gtgKhRHwZuXrYbh8TcMo8PmQ2oV/BxEQ17VoQmGcoQ5BTQfKhyfP29+P1bSQ5d8/I0jGN184VOF8ihE2WTsSI45F1HRAlqvVNQ5iIYsvAUDKNchypfiFetm8rpwB7M4fanY6dw4gvabL1Krt+Xize9HWRbhSH6s3ptPDxlvy9uuHyuVQJeDuC6i9s9EOQfR5kR1AZe/eZSooIDmi7OgUu9WXO9j4Y/8TSNgmi/AqlAaBbc/jdOfwUQaf9MwujwADLS2lYNoyInrwrEJRwsEQwroLBrGbKB1ArSD0appL2yFbgKYdO3YPfDAA02PH3bYYaxbt4516+Ll1K3mSUzGeeedx2mnncahhx7K4YcfzqWXXko+n+dtb3sbAKeeeio77LADl1xyCQDve9/7OProo/niF7/IypUrueaaa7j33nu58sorq/k499xz+eQnP8kee+xRDXeydOnSqvO4LRC1apjaoIMIIo1OeKh2Mb7GYbQhmiRuXfPrNFGbBrjpNZEmHIthZFyn7tdwO6JyAG3iQDVDhxGmHMRbSDVz6prlzzClukBrwi71MtrU6iLpdT4Pfyp1EWlMEKLbOEQN+avYqtBiZXDDdVq3jeHX9Jo5EmAyGbiUGMBPWiQmdkxOcN505FEYWwyR7n8Sy27Uv5Km3MKpmxKmuwZDl4O2MdQabq8NfpPJ8JPlyd+Ug03NF1G0Iir6FJ9tE1evmSltKK9vE3OtBWGuRJhrnHfWDh1qSmuah65qRzCUIxjqri7ieKXd1gWUJ4n92IywUK6+ezq2FWnK64a6thWMFAhahFFphfZDSs81zn3cmunasbvttuYTYnvFm970JtavX8+FF17ImjVrOPDAA7npppuqix/++c9/Yo0bInzxi1/MD37wAz760Y/yH//xH+yxxx5cf/311Rh2AB/84AfJ5/OceeaZDA0NcdRRR3HTTTd1HMNOEARhKiQDF217lHBxVIlRfx5ecSGl/CJcL4dlBWjtEvj9VDy9cmk7XG8Ey/Kx7AAduWjt1aURBEFoRc8CFG/tjIyMcOXXP0HCBtdqPRQbakWgLQ5dsp5kdo4MxYoNsSE2tqgNtEYZSK7dgGqzg4IgCNsWOZ3g7tKuuEQ4bYZiA2M458Kv9C5A8Stf+Ur+8Ic/TJpudHSUz372s3zjG9/o5LaCIAiCIAhCD+loKPYNb3gDr3vd6xgYGOA1r3kNhx56KEuXLiWZTLJ582Yeeugh7rzzTn75y1+ycuVKPv/5z890vrcYluNguTbGGIwBy60fGrEisCILd7t+bCfE609jtZhvWA4ibEs1bHFVIYw0kTYkBptPRNXG4IdabIgNsTHHbVgqDrMzuPOClrYEQdj2cPLg/NnFdUyzKDA1/M7nGnfk2L3jHe/glFNO4brrruPaa6/lyiuvZHg4nnCqlGKfffbhuOOO409/+hN77924h+HWQhziRGPGTTg2E2KBxatiDSYsoKwQEyp0q4UkOo7/plsEHjTagDHosHlDYIxBaSM2xIbYmOM2IH5X6jBCa3HsBEGIMaGFMTbG6LYLv4yZgZ0nEokEp5xyCqeccgoAw8PDFItF5s+fj+s2jwi9tWEpg9JFVNgyEhVKWyjtYpVW4en2q6Ym23V2MnFUB/cQG2JDbMwFGwaFItQ20RQjBgiCsPVRLicx4d4YE6DbbBvWhV839QDFAwMDDAy0jh+zNaKNwlgpjGNVe+waArxGcQBSnVyO74U4lmoZ+iVosmXSeKIJW1hNxBhDqI3YEBtiY67bACylcPoTOC02OhcEYdsjUbBQThLleFhthmKV6XzRVc92ntgWiPvpLJSygXiO3cSXuVKglIVy0hgrRDlWy7k3mAhlKawWjYaONGjTuJtD5bwxmFCLDbEhNua4DZTCKLCcZEtbgiBseyhnzGdQTba7HJ+uzXZjE5E3jCAIgiAIwlaCOHZdEGm75Q6xgiAIgiAIWxpx7LrAAIWyPWe2LBIEQRAE4flNmzUTU6Jrx+60007j97//fW9z8TzBsSIioxgtWuLcCYIgCIIwbYIIwu62xG5L147d8PAwK1asYI899uDTn/40zz77bO9y8zwg40VEWpErSc+dIAiCIAjTQykYKSla7GzYNV2vir3++utZv3493//+9/ne977HRRddxIoVK3jHO97BCSecsFXHtLOVxiZPn2cxWk6RL2r6EsX6lSzagsiB3GN4iTiOXSv/r1JTrc5bYx9TbJ2nSgwtsSE2xMbctqEU+JFL2CK0iiAI2x7lUgLb7IaFw+acoj9ZwrUbx2ajsPOepCmFO1m4cCHnnXce5513Hvfffz/f/e53eetb30o2m+WUU07hPe95D3vsscdUbj2nMUaBcrBtRTYRkCsnGPWzZBPlqnNnlELjYJw+tJ2Mj7cPSE+rsFaTnY93wEBsiA2xMedtGCylsBJey5h5giBse9jawbJs+tyIgu8wUk4zkPJx7Zojpw3kgs7dtWnFsXvuuee4+eabufnmm7Ftm1e96lX89a9/ZZ999uFzn/sc73//+6dz+zmHRoFyUbaNYxkyypAvO+R8m76URqn4JR4aC5VcTOiEeG3iWwVj+1S2i6EVaYPTYgM5bQxBqMWG2BAbc9yGpRRagZNJyl6xgiBUcRQo28V2DIMeDOcVI6Ukg2mD68RO3WheEXUx96vrN0wQBPzkJz/h1a9+NTvvvDPXXXcd5557LqtXr+Z73/sev/3tb/nRj37ExRdf3O2tn3c4NvSl4jl3o0WLIIRcyW653ZggCIIgCEIzLAUDGYNjwVBB4Yexoxdq6EvM4M4TS5YsQWvNySefzB//+EcOPPDAhjT/8i//wuDgYLe3fl5Sce5GijajJRvLMrQIUi8IgiAIgtCSinM3lFMM5eO+t3kZjdEzOMfuy1/+Mm94wxtIJpMt0wwODrJq1apuby0IgiAIgiBMg66HYt/61re2deq2NcIIRovxnLu+ZITWirDzHlNBEARBEAQgnlM3nFdEBgYzGtc2DBUUQdT5JC+ZxTsNKk6dbRn6UhrXgWwykm3HBEEQBEHoiopTF2oYTBs8pzbnbrTc+Ryvaa2K3dawMGB8TKQII0W+nMC2QrJeGXQcx8pC4SgHU1qD4wWYAHQLR7sSqka3cq812IBuEbTQGHAMYkNsiI05byMOdxLmPYyEOxEEYYyw6GCixURoRn2HUFsMpHxsZdBjo399SQjzsxTuZFtDKQMmJIoscuUUtgrp84rxKtixbjplLCxAhaNYdhyguNVrvNKWqBZDt5OdH39vsSE2xMYct6FAl914drQgCAIQ+Qm0Xsho4GAM9CcLOEpjxsUoVkDW9Tu+pzh2XRAZi4gMRd/Ftg2ZRISy+yYkArAguwf+WBw71SK+lT8WQ6tVXKtoLIZWokUMLWMM/lgMLbEhNsTG3LVhKYVS4A1IHDtBEGqU8xApFw1slzW4TqZpOtt0vt+YvGG6JO/Hc+qyyYgW73FBEARBEISOiHvq4oDEvUAcuy4ItY2tTHWXCUEQBEEQhOng2uD0cPxUHLsuUEA6IT11giAIgiD0hlZ7UU/5fr293daNbUWyXZggCIIgCHMWcewEQRAEQRC2EmRVbBcoDKAxJl4NB2BMfR+eMQpjDCYsoKwQEyp0q7FbrTFGoU3z80YbMAYdNve/jTEobcSG2BAbc9wGgFIKHUbolkHzBEHY1jChhTE2xsS+Rct04+OfTII4dl1gKYPSRVRoWg7JKm2htItVWoWnS23v501ibzJxVAf3EBtiQ2zMBRsGhSLUNpFM0hUEYYxyOYkJ98aYAK1bO29d+HXi2HWDNgpjpTCOVe2xmxi7ykQKg0Inl+N7IY6lWsa3CiKNpRR2i4ClkTZoY3BbxL0yxhBqIzbEhtiY6zYASymc/gROr2dKC4LwvCVRsFBOEuV4WG12DVOm803oxbHrgrifzkIpGzAY0+jYKQVKWSgnjbFClGNhtfqFbiKUpbBaNBo60qANltNcbW0MJtRiQ2yIjTluA6UwCiwn2dKWIAjbHsoZ8xnGgpi3TKc634Ve3jCCIAiCIAhbCeLYCYIgCIIgbCWIYycIgiAIgrCVII6dIAiCIAjCVoI4doIgCIIgCFsJsiq2C2ylQRcgjP9WABNjy2gLIgdyj+El4jh2rdayuGP/bXXeGvuYYus8VWJoiQ2xITbmtg2lwI9cwhahVQRB2PYolxLocDe0iYjaxLHTUeerYsWx6wJjFCgHM25N8sSqNkphlI1x+tB2Ml6+3D4gfcsNgCc7H++AgdgQG2JjztswWEphJbyWMfMEQdj2sLWDUjbKUiirtfOmlOw8MSNoFCgXZdvxtmEGrAkvaQUoY6GSiwmdEK9NfKsgiLAniaEVaYPjto6hFYRabIgNsTHHbVhKoRU4mSSOxLETBGEMR4GyXZRt2gcojsKO7ylvGEEQBEEQhK0Ecey6oNVG4YIgCIIgCHMBcey6QBubUiBVJgiCIAhCbzCdr4voCPFSusBSEX5oU/Sl504QBEEQhOkTRL117sSx6wJLGTwnouhbFH2pOkEQBEEQpocxMFpQ6B45d7IqtgssDAmnhK1dSr4LJiLl1q9UMVphtI0prcHxAkwAukUHnz22elm38hE12IBusRjGGHAMYkNsiI05byMOdxLmPYyEOxEEYYyw6OCoJRS0zVBO058KaPaKMG1i3E1EHLsuUMqACUk7IZiIku+hTETK9WtpjAUGVDiKZccBilu9xittiYqmdn78vcWG2BAbc9yGAl12afrWFgRhmyTyEygWkvV8Cn6C4YLNQLLExOhJBb9zd00cuy6IjAVWGhyblG1AWRTDNNhJUl7ch2pCCEMLsnvgj8WxUy3iW/ljMbRaxbWKxmJoJVrE0DLG4I/F0BIbYkNszF0bllIoBd6AxLETBKFGOQ+W4+I5hoQHQwWHUd9jIGOqvwHzJUWpi50n5A0zDZKeJuXpsTl3CmMgX7Zabi0kCIIgCILQDNeBwbQh1DCcj+fc5UuKfFmRdmUodtaIe+oqzl085ybpiWsnCIIgCEJ3VJy7oYJiw0jc95ZJGFxLHLsZwRiItEJFtT0iLQOOZapLlS0V/7tQVgShhd9mqyE/MFhthoHCCLQ2BFGL7Y6MIQgRG2JDbMx1G0qBAtdVyEisIAgVRosQ6fhdU0XFU3GDMV/OdQxh0Pk9xbHrglKUpFyy4kmN4zrlIq0wxJOnDYpyCH9elUYpE+8d2+KFr03788YYDLRsMCrnFaC1ItLxZuXaxMccGwy9szFZOQyKMKpNIjdjeVD0zsZk5VBjeYjtxRuw2xZYVu9siB6iRzMbk+phQBurOm/GAK4d52m2MKYWM0uN6eHY8Wc2CaP4Y1m1vLg2DRPGZxKt47oY//0QPUSP2dYjimCkqFBKVcse6bH31JivsWazhWW5Hd9zzjh2QRDw0Y9+lF/+8pc88cQTDAwMsGLFCj7zmc+wdOnSttd+4xvf4POf/zxr1qzhhS98IV/72tc4/PDDq+dLpRL/9m//xjXXXEO5XOa4447jsssuY9GiRd1l0ihQpvqS1wbCsRgHjmWwLPBDMEahtSHpapSlUC1m3WltUGqSRsWA1WIVnQGMNpQjCz9UJFxN0jVEGnIlG20MKU9j9cDGZOXQBvJlB9sypBPxz4x82aLkKzKJCEtN38ZkdaUNFH2bSCuyyQjbglKgKAcWnmtI2KKH6LFl9IjG6sK1IZOK040WFIUI+pMGZxbexJVYWaGp2SyWFQVfkfYMqcTsTCEplhXFcTbDEEZKCh1BX9rMijMRhpDzFY6CbFr0ED22nB7h2Psnfg9BEIAmXgDhOrXevKhVPKUmzBnHrlAocP/993PBBRfwwhe+kM2bN/O+972P448/nnvvvbfldddeey3nnXceV1xxBUcccQSXXnopxx13HI888gjbb789AO9///u58cYbue666xgYGOCcc87hpJNO4q677uo6n4q4x0MD4VjwK8fS1eEV14ZQgx8qHAtSdtjyZ4+l4gelXaPS7jzGUIxsgkCR8kJSXtyA2xb0pzS5kkPJV2STYeuGqQMbxh77FdWqR0LHS7FdW5NNhtVk/amIXMmh4FtkE2HrIagObExWV1obCmUHY6A/FeDYcfpMAixlUfJtbEQP0WPL6FH0HVxLM5gx1XofzMJwwSZXgoFMRIuFtz1BGxguxs7svHG2+lJgWRb5koVlGTKJzufxTIV8OV5olk1GVVuOB7YNw/mxukhHMxoRJohix961TZ0t0UP02CJ6GIUiXjUfhqBR2MrgjnlnjjXm8IWdi6BM5c01B/nTn/7E4YcfzlNPPcVOO+3UNM0RRxzBYYcdxte//nUAtNbsuOOO/Ou//isf/vCHGR4eZuHChfzgBz/g9a9/PQB///vf2Xvvvbn77rt50Yte1FFeRkZG+MqXv4CtoriStRN3FauwrqvYGNBYpNwSfuiRckp1ce56STHwKIbJljZCbTHqZ7BVRJ9XmJFfXpPZMAZG/TSRsenz8jhdTADtlE5sTFZXvUD06NzGtqqHY6u6gHfGwHApTWQs+hMFXHtm9JjMRsH3KAQJ0m6ZtDczekxmI4gsRsppbKUZSM6MHpPZED1qiB41ZlKPUNtszGeJjEIbC1tpXLsxcGYQKi742KcYHh6mv7+/7T3nTI9dM4aHh1FKMTg42PS87/vcd999nH/++dVjlmWxYsUK7r77bgDuu+8+giBgxYoV1TR77bUXO+20U1vHrlwuUy6Xq3+PjIwAoLHROg5p4lgay6r/GWEAjCLhOVgWFIMMxk5Wewvq0k7SG9DufNG3KEU2SS8i6bkY5TWksYGMZciVPUZDr673ptM8MG4O0cSLw0iRCxwsS5NJarCyTQejMrYhV7IYDQbIJsNq700nNibLpzGQKzmEQDYZYjvppnlI2gbjix4gelSYdT1UBuXYDTYG3bhnYtTv73nPhDYwUrDRwGA2wrUzTdNlXVBli3wpg3JSPe+ZyJctCqFFJqXJJBJAoiFNwh2ri7zHSOD1vKcoiGC0aOM4lV6ovqbpRI8Y0aPGTOphRYrI2GjDWE+doplrZk98T7dhzjp2pVKJD33oQ5x88sktvdMNGzYQRVHDXLlFixbx97//HYA1a9bgeV6Dc7ho0SLWrFnT0v4ll1zCxz/+8bpjH//YBWhTGX6NV9NNDDcfz3VUKGXHYU8sQ8l3UEpXgxhXMKb9HCIwY5M4688XfUUpsEgmNEkHsJyWUe8d29CXjIedciWXvpSe0LA0t1E9q4iffkvV2QjHus9ty5BJGCzLbnkPyzJkk4Z8mbE8RHWTUVvZqMtHk7qKnQiLSCv6kiG21TpIrFGIHmOIHjVmSw9V+QGoGh07W8FgJo5bNVxwGEzXhmGmQ9xoxYtGBjMGd5IZ4Nlk/P7Kl20UFplkbwZz8iVFoazIJg2ZpCJ2qZvjOXFdDBUUIwWnLkjrdAhCGC4oHJuxe7bOg+hRQ/SoMVN6FH015tSB57ar3M7tbbGF91dffTXZbLb6ueOOO6rngiDgjW98I8YYLr/88i2Sv/PPP5/h4eHq5+mnnx5bPweubToOWZDyTF0Q4+lS9BVF3yLlNTaErXBs6EtFRFoxWrSqoVmmSjj2S8u2TJOGsDlKQV9KY1uG0aJdv7R7ChgDo8UxJ2KCY9IO0SNG9KgxF/SwVNzAOVbciAYt9qbtFG3ihjDUdNUQZpKxI5ovK/Kl6etRCa6aSZiOG8JmQVqnQxDGdepYdOyYiB41RI8aM6FHwY8XTvRygcgW67E7/vjjOeKII6p/77DDDkDNqXvqqae49dZb244lL1iwANu2Wbt2bd3xtWvXsnjxYgAWL16M7/sMDQ3V9dqNT9OMRCJBItHYPW2j4566Lh7u8UGMofMGZyITG61u7lJpvEaLNqNFq+MGZyLNGq1OG8KKMzFatBgt2l05AONp5kR00xiLHjGiR425oEel8RrOK4YKaso9E1NttCpUGvx8WdX93S1TcSIqjA/SOpxXU+4pmooTUUH0qCF61Oi1HmnPkDO9ncC4xXrs+vr62H333aufVCpVdeoee+wxfvvb3zJ//vy29/A8j0MOOYRbbrmlekxrzS233MKRRx4JwCGHHILrunVpHnnkEf75z39W03SKwqCmWGPT7ZmYSk/ERKbbMzGVnoiJTLenaKo9QxMRPWJEjxpzQY/p9kxMt9GqMN2eiek4ERWm21M0HSeiguhRQ/So0Us9ZiKMypyJgR4EAa9//eu59957ufrqq4miiDVr1rBmzRp8v7YK5dhjj62ugAU477zz+OY3v8n3vvc9Hn74Yc466yzy+Txve9vbABgYGOAd73gH5513Hrfddhv33Xcfb3vb2zjyyCM7XhFbYbo+9VQbr140WhWm2nj1otGqMFVnoldORAXRI0b0qDEX9Jhq49WrRqvCVBuvXjgRFabqTPTCiaggetQQPWrMBT1aMWcWTzz77LP8/Oc/B+DAAw+sO3fbbbdxzDHHAPD444+zYcOG6rk3velNrF+/ngsvvJA1a9Zw4IEHctNNN9UtqPjyl7+MZVm87nWvqwtQvCUYP+xkNKQmWV1T8i1KYW8arQrjh51yJZtMon1LHkbxhNFeNFoVxg8D5oo2mUSI2+ZnhjFxHnrlRFQQPWJEjxpzQY9uh5163WhV6HbYaSYarW6HAXvpRFQQPWqIHjXmgh7NmNNx7OYSlTh2loraLpwwKLRRzEvlsMfidzV7jouBRzHwSLo+6RZxvAqBRynwSLl+0zhc44VrvW6w9flQW4yWU9hK05coNm2QAm2RmyRNOxuTnTcGRsspImORTRSbbnQ8Pk1fotg0LlqneWiVRvQYOyd6VJkJPexKePkOiWNsJYm0RX+y1DTGVidppkvBdyn4HmnPJ+0137SykzTTIYgsRkpJbEszkCw116ODNNNB9KghetSYjh5hZLExn8ZS7Xf5iLThIxd++vkfx25Ootq/mGM3WWGUA2OR85t5zknPYFREKUiCskm59f3JxcChFLokvYCkazC03yduMu+82XnbhmwiIFdOMOpnySbKdUULI0WunMC2DNlECMpta2cqeUDF8c5y5QS5coZsolwXV80YyPkJIqPIJsrYto1pszy/k18pokeb86JHld7qMbYrraXahG9pRBHH+BopxoFcB1I+7jg9tIGRkktkLAbSPq5t0y58xVTJJEGpiLyfQCmb9IRezELZphA4ZBIh6QQwiR5TwbNgwAoZLnqMlNP0p4K63p8gUoyUPRxb05+KsFTv8yB61BA9akxHD2VUza9Qrd8grYNPNSKOXdeM7e9h4sZg4jtaMRbHzkpgVGUPyeYklQEFpSCBstzqUFLRV5RCi6SnSbo2ymouk4Fx+1Q2Z7L9Nh3LkFGGfNkh59vVoaQwgpxvY9uGTCJC2ckp25hsv01gLA8WOT9dt7IyV7SIjCKTDHEcb8o2Oqkr0aOG6BHTKz1Q8btB2XbXQ1EWY9sr5RUjpWR1KEkbGM0rIgPzMgbXaVzF30uyaVCWIl9OoKzaUFK+pCgElbhoLjPhRFRI2DDPgqGCw2ipFlctGNvf1LVhIKPaxkWbLqJHDdGjxlT1UADKit8R7d4NqvOeRnHstjApL24oKqEegOpE8KSrpx1TqxMmhnpIeboaXDWb0l2FdpkqSkE2pcmNhd7IJiOKfm1i/kzuVTge0SNG9KgxF/SYOKdoIG3Il3o/Z2gyJs4pqvx7pucMjWfiHK9M0sTBbns4h2syRI8aokeNuaAHiGM3J6iP40UtDtcszn6sNF4jRZvRUm0iOKq7mGTToTKBf6RoMVqKf+H1j/UW6ZndC7sO0SNG9KgxF/SoNF5DOcVQPq6LeRk9a41WhYYJ47PcaEHNmdictxjKKxzLzJoTUUH0qCF61JgLesyZcCeCIAiCIAjC9BDHbg5QH4erd9srdUMlDpdjGfqSEbpH2yt1QyUumtaKvmSE06PtrrpF9IgRPWrMBT0qIRsiA4MZjWubnmyv1C11IRt6uL1SN1RCaLi2YTCjiUxvtrvqBtGjhuhRYy7oIY7dFiZupGpxuOqDtM6OPBODq7pOLUhrbpYar+rE/LE5XHEeereXaaeIHjGiR425oMfEOFye09u9MztlYhyuXu+d2QkT46J5Pd7LtBNEjxqiR425oAfIHLspoGFsXzcFDROnjQGMwugyyjIQtZ5bXQocSoFF0i2TtEPMWGOZtME4DiXfBRM1hHoYj4K2Nip5bHU+jOJVPLYVkvXKcfGIF4RnvTicQ74E2USpZTCwyWxU0pgWzkAc7DZBpHUcQgNTTZv1GMuDagi90Y2Naj5Fj2oa0WM29TCAwkQK3WUwL21gpOgSaouBlI+tDHqsLvqS8bnNeash1EOvKZRt8r5DxgtJuVE1DykXjLbJlRyMDhtCPfSSIFIMFz0cK6IvGYCOl9TYCvqT8bmhnG4IvdFLRI8aokeNqephIgUmXrHbdofrLrIujl23GNN2trRCxWFQTAimfYDiUmCTdEukHb9BtLQTgIko+R7KRDMWgDUOrhrS5xUbHFXXgmwiJFdOkSs5MxYQN1dOERlDNlGIA+KOy4MC+ryA0XKKXNmd0YC4oofoMZ4Z0UMrzJQCFEN/soCjdOW1Ur1nfyJguJRkuODMcABWm7RXJuUGdXkA4mPGJV/2MCaa4YC4If2JEmrCq9hR0J8IGSklGS7YMxwQV/QQPWpMRw+jLTAek3lubZ2+CYhj1y3KjpffmOZx7OK6V2BnqnHsJlL0FcUojsOVSnigmsfXSdkGlEUxTIOdbLplUiVOVyvMWJyuiRkNIxiti8PV1/R6h0pMswSjgdd0y6RWNmoJ4hWME/NZ3WuUsbhobqbp5QrIWIZ82WbU72++hVULGw35FD1Ej4nnZ0GPiueonM7j2GkDI3mFBuZlDa7TXA+AeW48FDXqZ3se3iFfUhRDRTZlyCSTQLJpuj4XLFuRL6ex7N6uBAxCGPUVrlMJodE8Npvtgu2MxVXzvZ6uzBQ9aogeNaarh7YAa/I4dmqit9gGmWM3y4yfCJ70JhcqOQMTxsfPGcomo0l/RTk2ZKewMXo7xm8gn+1gr1GlIJuMej7HS/SIET1qzAU9ut3bcqobo09Gt3tbzsScom73Gp3qRvXtED1qiB415oIezRDHrgum+zzWr+7r/G71E8an9zBMnAjeadd4JY5XLxqv8U5ENxvIV+Kq9cqZED1iRI8ac0GPqW5Y3uvGa6oblvey8ZrqBvK9dCZEjxqiR425oEcrxLHrAoNqGDvvlKk2WhV60XhNtdGq0IvGa6pORIVeOROiR4zoUWMu6DHVRqtCrxqvqTZaFXrReE3ViajQC2dC9KghetTopR7Fcu+dO3HsuiTC6jrq/nQbrQrTabym22hVmE7jNV0nosJ0nQnRI0b0qDEX9Jhuo1Vhuo3XdButCtNxJqbrRFSYjjMhetQQPWr0Wo+Cr4h6vHBZHLsuUGODsUGkiDp07nrVaFWYSuPVq0arwlQar145ERWm6kyIHjGiR425oEevGq0KU228etVoVZiKM9ErJ6LCVJwJ0aOG6FFjJvRIewZtIOxhrD1ZFdsFCrCURhuLUCscNPYE1ziOYwfGRJQCi1KgSHphiw3LK/tdNv+mmLELjKk/n3TBGItS2QYNKS9sGUIhjCBXdnAsTTYZ1vI4iY36AjEWvq+WxrYgm9TkSg65kiKbDLFafOO1NuRKDtpANhlgWxP2+WxhY0JGmtZVNhmRKzmMliyyiRC35eWGkm+LHoge45lNPZSiacw8bWC4YBNFhoFM7GT3YgGGAvrT8b2H8jCQiXDbOPD5skW+pMgkI9KJZnpMjXQCDBa5koXBkEm0/lUcRDCcj1cj96ejOBZiD/Lh2DCQju89lIeBdNTSQRE9aogeNWZKj5SnGC44RAb8oDcrdsWx6xKLCNuKCLRDqBXKhFjjnDtl4i9N2Q/xQ4+Ukydl+dDEG5/sh0+782kLlO1R9JMoHTSN4xVqi7yfwVE+fU4B1aQXpZMfX63SuECfazHqZ8gXDX1evjHUg4G8n0YbTZ83imN0T+tCAX0OjPpp8iWbPi/fNK5aMfAohbboIXpUmX09ChijGO8jxnG40kTG0J8oYGvd9VSPyeh3YThKM5Sz6E8UmsbxKvgehSBB2i2Ssnx0j8OepSwwjke+mMCEZdJeox5BZDFSTmMrn363AGEc7LZX2ECfF9sYGtUMJAtNvx+iR4zoUWMm9dDaxlZZQBEZC0KNaze+jKKo865Scey6xCgbywJHGYLIIjAujqn13Bkg0opSmCLtRSQ9F6O85vcac/lVi96Eyc4nbYPxoRhkMHaS1LjwEGGkyAUOlqXJJDVY2aareiezgYnDIqo4UcNpmzimWa7sMRp6tZ4JxoLdlhxCIJsMsZ1085XFk9joJJ8Z25ArWYwGA2STYd2OCEXfohTZJEUP0WOMLaJH4DKYMNV3hTYwUrDRwGA2wrVbx+GaLoNu3DMx6vc39EzkyxaF0CKT0mQSCaB53MDpknVBlS3ypQzKSdX1FAWVvXidSu9N87iB0yXhjtVF3mMk8Op6ikQP0WNL6GFFCpSFa0MYmti5i1Rdz11kIOroZ2aMOHZTQSkswLUNYaQItYVSBsuKh3aMUSQ9TdIDLKd11HsTB0dt2WiMDUW1bNgUJD0DlqHkOygVz1MKI8iV4jlDmYTBsuxp2UAbsFTLcji2oa867OTSl4pfELnS2ByuZIhtWdOyMVldWZYhmzTky4zlIe6yL/oq3pYqoUk6iB6ixxbRI5vU5Es2I0XFYCZ2FkcK8VzdwYzBne4kx0mwFQxm4nlKwwWnOk8pX1IUyops0pBJKmJXdObIJmMnOF+2UVhkkoYghOGCiofnMgZLzWwePCeui6GCYqTgMCB6iB5bUg9F9Ueh54IfQGQUhPHfoabrBR7i2E0DpWLnLogUQaRQmrFGAJJujwbgOyDlGRTxhPEwip3NykTw2digHGoTxkeLNiPFuEtCj03Mt63ezImYjMoE/tGiFf/aHNMmDnZrphyqpltEjxjRo4Zjx/MP82WHoVz8Eo9MbyaCd0plwvhwXjFUULg2+GHvJoJ3SsVWvqwIorh3qFcT8zulMoF/qKBED9EDmDt61Jw7KAfx70YF2E2mtLRCVsVOE2VR3VjYVAWY/XykPFN1Mg30ZHVft1Qar0ireAeD5PRXW3ZLxZkwxKuXXdv0ZLVlt4geMaJHDceG/rQh1IpQKwZmsdGqUGm8jFH4ocJzZrfRqpBJGjzH4IcKY9SsOhEVXAcGRA9A9KgwV/Tw3DgvlRXDnkNXeohj1wPCcY60gVnriajLQxTPG6pQCmb5W0ns2Bb92iNV9HuzvVK3jC97GKmebXfVDaJHDdEjxhgojAtGmi/1ZnulbhkfEDWIuh/m6QVBGNtulqfZQhvqQn6IHs3zNFuIHjVCTV3Zu31nimM3TYIQtFFYyuCN9dxFpnshpsP4OFzzMlHP987shPFx0fpTEf093juzU8bHRZuX6f1epp0getQQPWLihStxuedlNPMyuqd7Z3bK+DhcC/p1z/fO7ITxcdEW9OtZ2TtzIuPjookeokeFuaBHZU6dAhJOPP8vMvGIR6eIYzcNwqjm1LlOPCzrWAYFFMqz03iFEeQmBFcdH6S15M+8xJVGa3yw2/FBWnMle1aciZJv1QW7HR80NzdLzoToUUP0iKnpEQ/zuM7MbIw+GRODq87UxujtaBbsdrY2Rq/QLNit6CF6zAU9xjt1ngOWFQ/L2ire0rRTZPFEt5gINATaRhsLS2lcK6oG+LGUwiiFpULyJUXWFHBbTHrsRCYFLYMHhdoiX05hqzJ9brEuDlfKAmyPou+B8Uk3iePViY3JzhsD+XKKyBj6EsW6uGgOcZyi0XKKfFHTlyi2nNfUUR7aUAw8SoFHyi3VxUVTQJ9LnIeSJXqIHsDs66EremhDNDYMbDEWx6uUZPOoZiBZmrF5fwXfpeB7pD2fpB0QjYvD1efBcCnJ5pxFf7LUNI5XLwiiuKy2penzSpgQKpIkbdCOS67ooSOftNfjwG1jxHHRkkQ6LqtldLUuRA/RY0vooSMLdJoICLWNwuDZY8Ggx0y5Nuiw8x+h4th1SDUCPTblSBG/zg2W0vHS5GrC+N8JO6AceoyU0mS8MrbV258ckVbk/QS2MiTdgNA4DSHtHVvj6pCinyDSFkm3tz85jIGCnyAyioxXxmAR6MaHL+X65P0Ew6UMaa/c8y9nKXDwQxfPCXBsTaAbH+ukG1DwE6IHokeF2dQjXdEjUnX1rYC055Mre2wupujz/J7rUQwcioFDyg3xbE0YNa6gybgBo77HUDFJNuHj9liPQCtyZS8OMeMGRLoxD56tiZyQXNkj0hapGdBj1PfihUQJH4VqqAvRo4boUWMm9QjHFrdpLMBgKx0HMp9gorJ4wnQw3KJMJ6kEnnnmGXbcccctnQ1BEARBELZRnn76aZYtW9Y2jTh2HaK1ZvXq1fT19bUJZjo1RkZG2HHHHXn66afp7+/v6b3nMttquWHbLbuUe9sqN2y7Zd9Wyw3bbtlnstzGGEZHR1m6dCmW1X5YVoZiO8SyrEm95OnS39+/TX0JKmyr5YZtt+xS7m2PbbXs22q5Ydst+0yVe2BgoKN0sipWEARBEARhK0EcO0EQBEEQhK0EcezmAIlEgosuuohEIrGlszKrbKvlhm237FLubavcsO2WfVstN2y7ZZ8r5ZbFE4IgCIIgCFsJ0mMnCIIgCIKwlSCOnSAIgiAIwlaCOHaCIAiCIAhbCeLYCYIgCIIgbCWIYzdD5HI5zjnnHJYtW0YqlWKfffbhiiuumPS66667jr322otkMsn+++/PL3/5y7rzxhguvPBClixZQiqVYsWKFTz22GMzVYwp8fDDD3P88cczMDBAJpPhsMMO45///Gfba7aGcld497vfjVKKSy+9dNK03/jGN9hll11IJpMcccQR/PGPf6w7XyqVOPvss5k/fz7ZbJbXve51rF27doZy3j1BEPChD32I/fffn0wmw9KlSzn11FNZvXr1pNc+38s+Wf4n8nx/xi+55BIOO+ww+vr62H777TnxxBN55JFHJr3u+V7uZnzmM59BKcW5557bNt3WUPZnn32WU045hfnz55NKpdh///259957217zu9/9joMPPphEIsHuu+/OVVdd1ZCm2+/PbBNFERdccAHLly8nlUqx22678YlPfGLSvVrnRNmNMCOcccYZZrfddjO33XabWbVqlfnP//xPY9u2ueGGG1pec9dddxnbts3nPvc589BDD5mPfvSjxnVd89e//rWa5jOf+YwZGBgw119/vfnLX/5ijj/+eLN8+XJTLBZno1iT8o9//MNst9125gMf+IC5//77zT/+8Q9zww03mLVr17a8Zmsod4Wf/vSn5oUvfKFZunSp+fKXv9w27TXXXGM8zzPf+c53zN/+9jdzxhlnmMHBwbq6eve732123HFHc8stt5h7773XvOhFLzIvfvGLZ7gUnTM0NGRWrFhhrr32WvP3v//d3H333ebwww83hxxySNvrnu9l7yT/49kanvHjjjvOfPe73zUPPvig+fOf/2xe9apXmZ122snkcrmW12wN5Z7IH//4R7PLLruYAw44wLzvfe9rmW5rKPumTZvMzjvvbE4//XRzzz33mCeeeML8+te/Nv/4xz9aXvPEE0+YdDptzjvvPPPQQw+Zr33ta8a2bXPTTTdV03T7/dkSfOpTnzLz5883v/jFL8yqVavMddddZ7LZrPnKV77S8pq5UnZx7GaIfffd11x88cV1xw4++GDzkY98pOU1b3zjG83KlSvrjh1xxBHmXe96lzHGGK21Wbx4sfn85z9fPT80NGQSiYT54Q9/2MPcT503velN5pRTTunqmq2h3MYY88wzz5gddtjBPPjgg2bnnXee1LE7/PDDzdlnn139O4ois3TpUnPJJZcYY+Iyuq5rrrvuumqahx9+2ADm7rvvnpEy9II//vGPBjBPPfVUyzTP97JPlv+JbC3P+HjWrVtnAHP77be3TLO1lXt0dNTsscce5uabbzZHH310W8duayj7hz70IXPUUUd1dc0HP/hBs++++9Yde9Ob3mSOO+646t/dfn+2BCtXrjRvf/vb646ddNJJ5i1veUvLa+ZK2WUodoZ48YtfzM9//nOeffZZjDHcdtttPProo7ziFa9oec3dd9/NihUr6o4dd9xx3H333QCsWrWKNWvW1KUZGBjgiCOOqKbZkmitufHGG9lzzz057rjj2H777TniiCO4/vrr2173fC83xGV/61vfygc+8AH23XffSdP7vs99991XVybLslixYkW1TPfddx9BENSl2Wuvvdhpp53mTLmbMTw8jFKKwcHBpuef72XvJP8T2Rqe8YkMDw8DsN1227VMs7WV++yzz2blypUNZWrG1lD2n//85xx66KG84Q1vYPvtt+eggw7im9/8ZttrJiv3VL4/W4IXv/jF3HLLLTz66KMA/OUvf+HOO+/k//v//r+W18yVsotjN0N87WtfY5999mHZsmV4nscrX/lKvvGNb/Cyl72s5TVr1qxh0aJFdccWLVrEmjVrqucrx1ql2ZKsW7eOXC7HZz7zGV75ylfym9/8hte+9rWcdNJJ3H777S2ve76XG+Czn/0sjuPw3ve+t6P0GzZsIIqiScvteV6DgzSXyj2RUqnEhz70IU4++eSWm2A/38veSf4nsjU84+PRWnPuuefykpe8hP32269luq2p3Ndccw33338/l1xySUfpt4ayP/HEE1x++eXsscce/PrXv+ass87ive99L9/73vdaXtOq3CMjIxSLxSl9f7YEH/7wh3nzm9/MXnvtheu6HHTQQZx77rm85S1vaXnNXCm7OHY94OqrryabzVY/d9xxB1/72tf4wx/+wM9//nPuu+8+vvjFL3L22Wfz29/+dktnt2dMLHdlIvUJJ5zA+9//fg488EA+/OEP8+pXv7qjhSPPFyaW+/bbb+crX/kKV111FUqpLZ29GaXZs14hCALe+MY3Yozh8ssv34K5FGaas88+mwcffJBrrrlmS2dlVnj66ad53/vex9VXX00ymdzS2Zk1tNYcfPDBfPrTn+aggw7izDPP5Iwzztiq3uet+NGPfsTVV1/ND37wA+6//36+973v8YUvfKGtUztXcLZ0BrYGjj/+eI444ojq3zvssAPHHnssP/vZz1i5ciUABxxwAH/+85/5whe+0LIbf/HixQ2r/tauXcvixYur5yvHlixZUpfmwAMP7GWROmJiuRcuXIjjOOyzzz516fbee2/uvPPOlvd5vpf7uuuuY926dey0007VY1EU8W//9m9ceumlPPnkkw33WLBgAbZtT1pu3/cZGhqq67kan2a2afasQ82pe+qpp7j11ltb9tbB87fsFTrJ/0Seb894O8455xx+8Ytf8Pvf/55ly5a1Tbu1lPu+++5j3bp1HHzwwdVjURTx+9//nq9//euUy2Vs2667Zmso+5IlS5q+z3/yk5+0vKZVufv7+0mlUti23fX3Z0vwgQ98oNprB7D//vvz1FNPcckll3Daaac1vWaulF167HpAX18fu+++e/UTBAFBEGBZ9dVr2zZa65b3OfLII7nlllvqjt18880ceeSRACxfvpzFixfXpRkZGeGee+6ppplNJpZ7YGCAww47rCEEwqOPPsrOO+/c8j7P93KfeeaZ/O///i9//vOfq5+lS5fygQ98gF//+tdN7+F5HoccckhdmbTW3HLLLdUyHXLIIbiuW5fmkUce4Z///OcWKTc0lj2VSlWduscee4zf/va3zJ8/v+09nq9lr9BJ/ifyfHvGm2GM4ZxzzuFnP/sZt956K8uXL5/0mq2h3ADHHnssf/3rX+u+44ceeihvectb+POf/9zg1MHWUfaXvOQlPX+fT+X7syUoFAo9b8Nnrew9W4Yh1HH00Uebfffd19x2223miSeeMN/97ndNMpk0l112WTXNW9/6VvPhD3+4+vddd91lHMcxX/jCF8zDDz9sLrrooqbL4wcHB80NN9xg/vd//9eccMIJc2p5/E9/+lPjuq658sorzWOPPVZd7n3HHXdU02yN5Z5Is1WxL3/5y83Xvva16t/XXHONSSQS5qqrrjIPPfSQOfPMM83g4KBZs2ZNNc273/1us9NOO5lbb73V3HvvvebII480Rx555GwVY1J83zfHH3+8WbZsmfnzn/9snnvuueqnXC5X021tZZ8s/1vjM37WWWeZgYEB87vf/a5O50KhUE2zNZa7FRNXxW6NZf/jH/9oHMcxn/rUp8xjjz1mrr76apNOp81//dd/VdN8+MMfNm9961urf1dCfnzgAx8wDz/8sPnGN77RNOTHZN//Lc1pp51mdthhh2q4k5/+9KdmwYIF5oMf/GA1zVwtuzh2M8Rzzz1nTj/9dLN06VKTTCbNC17wAvPFL37RaK2raY4++mhz2mmn1V33ox/9yOy5557G8zyz7777mhtvvLHuvNbaXHDBBWbRokUmkUiYY4891jzyyCOzUaSO+fa3v2123313k0wmzQtf+EJz/fXX153fWss9nmaO3c4772wuuuiiumNf+9rXzE477WQ8zzOHH364+cMf/lB3vlgsmve85z1m3rx5Jp1Om9e+9rXmueeem+Hcd86qVasM0PRz2223VdNtjWVvl/+t8RlvpfN3v/vdapqtsdytmOjYba1l/+///m+z3377mUQiYfbaay9z5ZVX1p0/7bTTzNFHH1137LbbbjMHHnig8TzP7LrrrnXPSIXJvv9bmpGREfO+973P7LTTTiaZTJpdd93VfOQjH6n7wTpXy66MmSSMsiAIgiAIgvC8QObYCYIgCIIgbCWIYycIgiAIgrCVII6dIAiCIAjCVoI4doIgCIIgCFsJ4tgJgiAIgiBsJYhjJwiCIAiCsJUgjp0gCIIgCMJWgjh2giAIgiAIWwni2AmCIPSIb3/727ziFa+YcTs33XQTBx54YNt9KwVB2DYRx04QBKEHlEolLrjgAi666KIZt/XKV74S13W5+uqrZ9yWIAjPL8SxEwRB6AE//vGP6e/v5yUvecms2Dv99NP56le/Oiu2BEF4/iCOnSAIwjjWr1/P4sWL+fSnP1099j//8z94nsctt9zS8rprrrmG17zmNXXHjjnmGM4999y6YyeeeCKnn3569e9ddtmFT37yk5x66qlks1l23nlnfv7zn7N+/XpOOOEEstksBxxwAPfee2/dfV7zmtdw77338vjjj0+9sIIgbHWIYycIgjCOhQsX8p3vfIePfexj3HvvvYyOjvLWt76Vc845h2OPPbbldXfeeSeHHnrolGx++ctf5iUveQkPPPAAK1eu5K1vfSunnnoqp5xyCvfffz+77bYbp556KsaY6jU77bQTixYt4o477piSTUEQtk7EsRMEQZjAq171Ks444wze8pa38O53v5tMJsMll1zSMv3Q0BDDw8MsXbp0yvbe9a53sccee3DhhRcyMjLCYYcdxhve8Ab23HNPPvShD/Hwww+zdu3auuuWLl3KU089NSWbgiBsnYhjJwiC0IQvfOELhGHIddddx9VXX00ikWiZtlgsApBMJqdk64ADDqj+e9GiRQDsv//+DcfWrVtXd10qlaJQKEzJpiAIWyfi2AmCIDTh8ccfZ/Xq1WitefLJJ9umnT9/PkopNm/ePOl9oyhqOOa6bvXfSqmWxyaGN9m0aRMLFy6c1KYgCNsO4tgJgiBMwPd9TjnlFN70pjfxiU98gne+850NvWXj8TyPffbZh4ceeqjh3MTh0yeeeKIneSyVSjz++OMcdNBBPbmfIAhbB+LYCYIgTOAjH/kIw8PDfPWrX+VDH/oQe+65J29/+9vbXnPcccdx5513Nhy/4YYb+OlPf8rjjz/Opz71KR566CGeeuopnn322Wnl8Q9/+AOJRIIjjzxyWvcRBGHrQhw7QRCEcfzud7/j0ksv5fvf/z79/f1YlsX3v/997rjjDi6//PKW173jHe/gl7/8JcPDw3XHV65cyec+9zn22Wcffv/733PZZZfxxz/+8f9v545tGISBAIpeWsQSVLSIXaiYhBloqFiAgmUYggHYISnSRIrSJFDk9N4Atsuvs+xYluWnc67rGn3fR1EUP60D5HK7v76fB+BrXddF27YxDENEPP+xa5ompmk6dZ/jOKKu69i2LaqqOnVt4L+Z2AGcZBzHKMvy8n32fY95nkUd8MbEDuAiV03sAD4RdgAASbiKBQBIQtgBACQh7AAAkhB2AABJCDsAgCSEHQBAEsIOACAJYQcAkMQDgxnpi3S7HQAAAAAASUVORK5CYII=",
"text/plain": [
"
16:02:39 CEST Maximum FlexCredit cost: 0.100. Minimum cost depends on task \n",
"execution details. Use 'web.real_cost(task_id)' to get the billed \n",
"FlexCredit cost after a simulation run. \n",
"
\n"
],
"text/plain": [
"\u001b[2;36m16:02:39 CEST\u001b[0m\u001b[2;36m \u001b[0mMaximum FlexCredit cost: \u001b[1;36m0.100\u001b[0m. Minimum cost depends on task \n",
"\u001b[2;36m \u001b[0mexecution details. Use \u001b[32m'web.real_cost\u001b[0m\u001b[32m(\u001b[0m\u001b[32mtask_id\u001b[0m\u001b[32m)\u001b[0m\u001b[32m'\u001b[0m to get the billed \n",
"\u001b[2;36m \u001b[0mFlexCredit cost after a simulation run. \n"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/html": [
"
16:02:41 CEST Maximum FlexCredit cost: 0.100. Minimum cost depends on task \n",
"execution details. Use 'web.real_cost(task_id)' to get the billed \n",
"FlexCredit cost after a simulation run. \n",
"
\n"
],
"text/plain": [
"\u001b[2;36m16:02:41 CEST\u001b[0m\u001b[2;36m \u001b[0mMaximum FlexCredit cost: \u001b[1;36m0.100\u001b[0m. Minimum cost depends on task \n",
"\u001b[2;36m \u001b[0mexecution details. Use \u001b[32m'web.real_cost\u001b[0m\u001b[32m(\u001b[0m\u001b[32mtask_id\u001b[0m\u001b[32m)\u001b[0m\u001b[32m'\u001b[0m to get the billed \n",
"\u001b[2;36m \u001b[0mFlexCredit cost after a simulation run. \n"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"# estimating the cost\n",
"task_id = web.upload(sim, \"nanobeam_test\")\n",
"cost = web.estimate_cost(task_id)"
]
},
{
"cell_type": "code",
"execution_count": 13,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"
Created task 'ellipse_nanobeam' with task_id \n",
"'fdve-acdf384e-bc65-4ece-9ade-e64873404df1' and task_type 'FDTD'. \n",
"
16:02:46 CEST Maximum FlexCredit cost: 0.100. Minimum cost depends on task \n",
"execution details. Use 'web.real_cost(task_id)' to get the billed \n",
"FlexCredit cost after a simulation run. \n",
"
\n"
],
"text/plain": [
"\u001b[2;36m16:02:46 CEST\u001b[0m\u001b[2;36m \u001b[0mMaximum FlexCredit cost: \u001b[1;36m0.100\u001b[0m. Minimum cost depends on task \n",
"\u001b[2;36m \u001b[0mexecution details. Use \u001b[32m'web.real_cost\u001b[0m\u001b[32m(\u001b[0m\u001b[32mtask_id\u001b[0m\u001b[32m)\u001b[0m\u001b[32m'\u001b[0m to get the billed \n",
"\u001b[2;36m \u001b[0mFlexCredit cost after a simulation run. \n"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/html": [
"
To cancel the simulation, use 'web.abort(task_id)' or \n",
"'web.delete(task_id)' or abort/delete the task in the web UI. \n",
"Terminating the Python script will not stop the job running on the\n",
"cloud. \n",
"
\n"
],
"text/plain": [
"\u001b[2;36m \u001b[0m\u001b[2;36m \u001b[0mTo cancel the simulation, use \u001b[32m'web.abort\u001b[0m\u001b[32m(\u001b[0m\u001b[32mtask_id\u001b[0m\u001b[32m)\u001b[0m\u001b[32m'\u001b[0m or \n",
"\u001b[2;36m \u001b[0m\u001b[32m'web.delete\u001b[0m\u001b[32m(\u001b[0m\u001b[32mtask_id\u001b[0m\u001b[32m)\u001b[0m\u001b[32m'\u001b[0m or abort/delete the task in the web UI. \n",
"\u001b[2;36m \u001b[0mTerminating the Python script will not stop the job running on the\n",
"\u001b[2;36m \u001b[0mcloud. \n"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"application/vnd.jupyter.widget-view+json": {
"model_id": "ac7662a2664548a9be8015deb3396314",
"version_major": 2,
"version_minor": 0
},
"text/plain": [
"Output()"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/html": [
"\n"
],
"text/plain": []
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/html": [
"
16:07:32 CEST WARNING: Simulation final field decay value of 0.268 is greater \n",
"than the simulation shutoff threshold of 1e-05. Consider running \n",
"the simulation again with a larger 'run_time' duration for more \n",
"accurate results. \n",
"
\n"
],
"text/plain": [
"\u001b[2;36m16:07:32 CEST\u001b[0m\u001b[2;36m \u001b[0m\u001b[31mWARNING: Simulation final field decay value of \u001b[0m\u001b[1;36m0.268\u001b[0m\u001b[31m is greater \u001b[0m\n",
"\u001b[2;36m \u001b[0m\u001b[31mthan the simulation shutoff threshold of \u001b[0m\u001b[1;36m1e-05\u001b[0m\u001b[31m. Consider running \u001b[0m\n",
"\u001b[2;36m \u001b[0m\u001b[31mthe simulation again with a larger \u001b[0m\u001b[32m'run_time'\u001b[0m\u001b[31m duration for more \u001b[0m\n",
"\u001b[2;36m \u001b[0m\u001b[31maccurate results. \u001b[0m\n"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"# running the simulation\n",
"sim_data = web.run(simulation=sim, task_name=\"ellipse_nanobeam\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"It is possible to notice a warning at the end of the simulation, stating that the fields haven't completely decayed. This is expected for high Q-factor cavities, and the suggestion to run with a larger `run_time` can be ignored in this case."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Data Analysis\n",
"\n",
"First, we will plot the electric field profile at the end of the simulation, where it is possible to observe a tightly confined mode."
]
},
{
"cell_type": "code",
"execution_count": 14,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "iVBORw0KGgoAAAANSUhEUgAAAnUAAAHWCAYAAAARl3+JAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjMsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvZiW1igAAAAlwSFlzAAAPYQAAD2EBqD+naQAAgM5JREFUeJzt3Xl8E2X+B/DPTO5e6UFPylEuOQTBgogXKix1rQfriYIgoqwIKvDzXAUUDxRvQGB1V3AVVsUVRFAEOQURBETlEBCQswdH2/ROMvP8/kgzbZo0aSGlafm8fc1LOvPMM88k0+Tb7zPPM5IQQoCIiIiIGjW5oRtARERERGePQR0RERFRE8CgjoiIiKgJYFBHRERE1AQwqCMiIiJqAhjUERERETUBDOqIiIiImgAGdURERERNAIM6IiIiCoqioiKsWrUKfK5Bw2BQR0REREHx0ssPol+/fliyZElDN+W8JPExYURERHS2jh49igsuaI9Bg67FDz/swG+/7Yder2/oZp1XmKkjIiKis/bssw/gxhsvw7szx0FVBd5//4mGbtJ5h5k6IiIiOiu//vorevfuhd92zEVaWjIWLfweo0e/hX37DiEyMrKhm3feYKaOiIiIzsrjj9+Pvz94E9LSkgEANw+8Am3bNcdrrz/cwC07vzBTR0RERGdsxYoVuOOOW7B33zzExkZp6zdu3InrMh7Dvn0HkJyc3IAtPH8wqCMiIqIzoigK0tMvwN2D/4L/+787vbbfecdziImJwPvvczTsucDuVyIiIjojH330LPLzizB69N98bn/p5Qfw8ccrsHPnznPcsvMTM3VERERUZ6WlpbjggtZ4+eUHcNfd/WssN27sdOzffxxLl248h607PzFTR0RERHX21tuPIj7eijsHXeu33DPPDsX69b9h9erV56hl5y9m6oiIiKhOTpw4gXbt0vC/L17ANdf0CFj+1Vfn44v/rcXmzbshy8wn1Re+skRERFQnL7zwIK64omutAjoAeOSRW5Gbm49PPvmknlt2fmOmjoiIiGrtjz/+QNeuXbD5p3+ic+fWtd7vo/98i+eem4Pff/8TZrO5/hp4HmOmjoiIiGrtqafux5Ahf6lTQAcAg4f8BTExkZg2fVz9NIyYqSMiIqLa2bhxI/7yl2vx+56PkZwcV+f9v/tuKwbd+Rz27z+E2NjYemjh+Y1BHREREQUkhMAVV3bDtddejOeeG37G9Vz/1yfQuUtrvPXmZ0FsHQEM6oiIiKgWFi5ciFGjRmDP3nmIiLCccT2//rofl/V5CLt2/Y60tLQgtpAY1BEREZFfDocDXbq0wbhxt2Pk32866/ruH/EqSkvt+OSTlUFoHblxoAQRERH5Nfufj0Gv1+G+EZlBqe/5yffhq69+wE8//RSU+siFmToiIiKqkc1mQ7t2rfDe+4/jxhsvC1q9Eyb8Gxs2/IY1q3+GJElBq/d8xkwdERER1WjBggVo2TIBN9zQJ6j1Pv74IGz5aQ927twZ1HrPZwzqiIiIqEZ2ux1JSXFBz6ZFRYUjIsKC8vLyoNZ7PtM3dAOIiIgo1AlAVeunXgoaZuqIiIiImgBm6oiIiMg/gXrK1FEwMagjIiKiAOqr+5WCid2vRERERE0AM3VERETknwDAaW1DHoM6IiIiCqCeul8ZJwYVu1+JiIiImgBm6oiIiMg/wYESjQEzdURERERNADN1RERE5F+9zVPHm+qCiUEdERERBcDu18aA3a9ERERETQAzdUREROQfHxPWKDCoIyIiogAEJMGgLtSx+5WIiIioCWCmjoiIiPyrr3nqOPg1qJipIyIiImoCmKkjIiKiwFSm1UIdgzoiIiLyj5MPNwrsfiUiIiJqApipIyIiogD4RInGgEEdERER+ScEwHnqQh67X4mIiIiaAGbqiIiIKDB2v4Y8ZuqIiIiImgAGdUREROSfEK556oK91HFGk3Xr1uHGG29ESkoKJEnCokWLqjVTYOLEiUhOTobFYkH//v2xb98+jzKnT5/G4MGDERUVhejoaIwYMQJFRUUeZX799VdceeWVMJvNaNGiBaZOnerVlgULFqBjx44wm83o2rUrvv7667qdTD1gUEdERET+ueepC/ZSR8XFxbjooovw7rvv+tw+depUTJs2DbNnz8amTZsQHh6OjIwMlJWVaWUGDx6MnTt3YsWKFViyZAnWrVuHkSNHatttNhsGDBiAVq1aYevWrXjttdfw3HPP4b333tPK/PDDD7jrrrswYsQI/Pzzzxg4cCAGDhyIHTt21PmcgkkSQnDmPyIiIvJp1qxZWLrgn1j8/qNBrzu591h8/e0qpKen13lfSZKwcOFCDBw4EIArS5eSkoL/+7//w2OPPQYAKCgoQGJiIubOnYtBgwZh9+7d6Ny5M3766Sf07NkTALBs2TJcf/31OHr0KFJSUjBr1iw888wzyM7OhtFoBAA89dRTWLRoEX7//XcAwJ133oni4mIsWbJEa8+ll16K7t27Y/bs2WfzkpwVZuqIiIgoAFFPmToBu90Om83msZSXl9e5hQcPHkR2djb69++vrbNarejduzc2btwIANi4cSOio6O1gA4A+vfvD1mWsWnTJq3MVVddpQV0AJCRkYE9e/YgLy9PK1P1OO4y7uM0FAZ1RERE5JckAElVg74AwJw5c2C1Wj2WKVOm1LmN2dnZAIDExESP9YmJidq27OxsJCQkeGzX6/WIjY31KOOrjqrHqKmMe3tD4ZQmRERE1GCGDx+O119/3WOdyWRqoNY0bgzqiIiIKADhGgFbD4xGI6Kios66nqSkJABATk4OkpOTtfU5OTno3r27ViY3N9djP6fTidOnT2v7JyUlIScnx6OM++dAZdzbGwq7X4mIiKjRS0tLQ1JSElauXKmts9ls2LRpE/r06QMA6NOnD/Lz87F161atzKpVq6CqKnr37q2VWbduHRwOh1ZmxYoVuOCCCxATE6OVqXocdxn3cRoKgzoiIiLyL0SmNCkqKsL27duxfft2AK7BEdu3b8fhw4chSRLGjh2LF198EYsXL8Zvv/2GoUOHIiUlRRsh26lTJ1x33XV44IEHsHnzZmzYsAFjxozBoEGDkJKSAgC4++67YTQaMWLECOzcuROffvop3nnnHYwfP15rx6OPPoply5bhjTfewO+//47nnnsOW7ZswZgxY872lT4r7H4lIiKiAET9PCasjj26W7ZswTXXXKP97A60hg0bhrlz5+KJJ55AcXExRo4cifz8fFxxxRVYtmwZzGazts+8efMwZswY9OvXD7Is49Zbb8W0adO07VarFcuXL8fo0aORnp6OZs2aYeLEiR5z2V122WWYP38+nn32WfzjH/9A+/btsWjRIlx44YVn+EIEB+epIyIiohrNmjULX386E4tnjAp63Ul9n8LXy1ef0Tx15I2ZOiIiIvJPwPVYLwppDOqIiIgogHrqfqWg4kAJIiIioiaAmToiIiLyzz36tV4qpmBhpo6IiIioCWCmjoiIiAKovydKUPAwqCMiIiL/6q37lYKJ3a9ERERETQAzdUREROSfEPUzTx17dIOKQR0REREFxu7XkMfuVyIiIqImgJk6IiIi8k/wiRKNATN1RERERE0AM3VEREQUWH0MlKCgYlBHRERE/gkBCD4mLNSx+5WIiIioCWCmjoiIiAJj92vIY1BHRERE/tXX6FfGiUHF7lciIiKiJoCZOiIiIgqM3a8hj5k6IiIioiaAmToiIiLyT4BPlGgEGNQRERGRf0Kw+7URYPcrERERURPATB0REREFVi9PlKBgYlBHRERE/rH7tVFg9ysRERFRE8BMHREREQVWH5k6wexfMDFTR0RERNQEMFNHRERE/tXXs18pqBjUERERUWAcKBHy2P1KRERE1AQwU0dERET+CTBT1wgwqCMiIiL/eE9do8DuVyIiIqImgJk6IiIiCoxzyoU8ZuqIiIiImgBm6oiIiCiwenmiRPCrPJ8xqCMiIiL/hODo10aA3a9ERERETQAzdUREROSfQD1NacLsXzAxqCMiIqIA2P3aGLD7lYiIiKgJYKaOiIiI/ONjwhoFZuqIiIiImgBm6oiIiCgwZupCHoM6IiIi8ksIQHDy4ZDH7lciIiKiJoCZOiIiIgpAuNJ1FNIY1BEREZF/HP3aKLD7lYiIiKgJYKaOiIiI/GOmrlFgpo6IiIioCWCmjoiIiALgs18bAwZ1RERE5B+7XxsFdr8SERERNQHM1BEREVFAfKJE6GNQR0RERP6J+rqnjlFdMLH7lYiIiKgJYKaOiIiI/ONAiUaBmToiIiKiJoCZOiIiIgqMmbqQx6COiIiIAhMM6kIdu1+JiIiImgAGdUREROSfAIQa/KUuFEXBhAkTkJaWBovFgrZt2+KFF16AqJJBFEJg4sSJSE5OhsViQf/+/bFv3z6Pek6fPo3BgwcjKioK0dHRGDFiBIqKijzK/Prrr7jyyithNpvRokULTJ069YxfunOJQR0RERH5556nLthLHXp0X331VcyaNQszZszA7t278eqrr2Lq1KmYPn26Vmbq1KmYNm0aZs+ejU2bNiE8PBwZGRkoKyvTygwePBg7d+7EihUrsGTJEqxbtw4jR47UtttsNgwYMACtWrXC1q1b8dprr+G5557De++9F5SXsj7xnjoiIiIKeT/88ANuvvlmZGZmAgBat26N//73v9i8eTMAV5bu7bffxrPPPoubb74ZAPCf//wHiYmJWLRoEQYNGoTdu3dj2bJl+Omnn9CzZ08AwPTp03H99dfj9ddfR0pKCubNmwe73Y4PPvgARqMRXbp0wfbt2/Hmm296BH+hiJk6IiIiCqw+MnV1cNlll2HlypXYu3cvAOCXX37B+vXr8de//hUAcPDgQWRnZ6N///7aPlarFb1798bGjRsBABs3bkR0dLQW0AFA//79IcsyNm3apJW56qqrYDQatTIZGRnYs2cP8vLyzuy1O0eYqSMiIqIGY7fbYbPZPNaZTCaYTCaPdU899RRsNhs6duwInU4HRVHw0ksvYfDgwQCA7OxsAEBiYqLHfomJidq27OxsJCQkeGzX6/WIjY31KJOWluZVh3tbTEzM2ZxuvWKmjoiIiPwS9ThQYs6cObBarR7LlClTvNrw2WefYd68eZg/fz62bduGDz/8EK+//jo+/PDDc/xqhC4GdUTngTVr1kCSJKxZs6ahm0JB9tlnnyE2NtZr9N65sGvXLuj1euzYseOcH5saQD11vw4fPhwFBQUey9NPP+11+McffxxPPfUUBg0ahK5du+Kee+7BuHHjtAAwKSkJAJCTk+OxX05OjrYtKSkJubm5HtudTidOnz7tUcZXHVWPEaoY1BE1ITNnzsTcuXMbuhlnZP78+Xj77bcbuhkAAFVVMXXqVKSlpcFsNqNbt27473//W+v98/PzMXLkSMTHxyM8PBzXXHMNtm3b5rPs4sWLcfHFF8NsNqNly5aYNGkSnE5nrY6jKAomTZqEhx9+GBEREbVuX7B07twZmZmZmDhx4jk/NjUdRqMRUVFRHkv1rlcAKCkpgSx7hi06nQ6q6kr5paWlISkpCStXrtS222w2bNq0CX369AEA9OnTB/n5+di6datWZtWqVVBVFb1799bKrFu3Dg6HQyuzYsUKXHDBBSHd9QowqCNqUmoK6q666iqUlpbiqquuOveNqqVQCuqeeeYZPPnkk/jLX/6C6dOno2XLlrj77rvxySefBNxXVVVkZmZi/vz5GDNmDKZOnYrc3FxcffXVXvNlffPNNxg4cCCio6Mxffp0DBw4EC+++CIefvjhWrXzq6++wp49exp0RN6DDz6IhQsXYv/+/Q3WBjoHBAC1HpY6uPHGG/HSSy9h6dKl+PPPP7Fw4UK8+eab+Nvf/gYAkCQJY8eOxYsvvojFixfjt99+w9ChQ5GSkoKBAwcCADp16oTrrrsODzzwADZv3owNGzZgzJgxGDRoEFJSUgAAd999N4xGI0aMGIGdO3fi008/xTvvvIPx48ef4Yt37nCgBDU5xcXFCA8Pb+hmhBRZlmE2mxu6GY3CsWPH8MYbb2D06NGYMWMGAOD+++9H37598fjjj+P222+HTqercf/PP/8cP/zwAxYsWIDbbrsNAHDHHXegQ4cOmDRpEubPn6+Vfeyxx9CtWzcsX74cer3r4zgqKgovv/wyHn30UXTs2NFvW+fMmYPLL78czZs3P9vTPmP9+/dHTEwMPvzwQ0yePLnB2kH1TAiIBn726/Tp0zFhwgQ89NBDyM3NRUpKCv7+9797ZIqfeOIJFBcXY+TIkcjPz8cVV1yBZcuWeXz+zZs3D2PGjEG/fv0gyzJuvfVWTJs2TdtutVqxfPlyjB49Gunp6WjWrBkmTpwY8tOZAMzUUYg7duwYRowYgZSUFJhMJqSlpWHUqFGw2+0AgLlz50KSJKxduxYPPfQQEhISkJqaqu0/c+ZMdOnSBSaTCSkpKRg9ejTy8/M9jrFv3z7ceuutSEpKgtlsRmpqKgYNGoSCggKtzIoVK3DFFVcgOjoaERERuOCCC/CPf/wjYPtrs195eTkmTZqEdu3awWQyoUWLFnjiiSdQXl7uVd/HH3+MSy65BGFhYYiJicFVV12F5cuXA3DN2bRz506sXbsWkiRBkiRcffXVAGq+p27BggVIT0+HxWJBs2bNMGTIEBw7dsyjzL333ouIiAgcO3YMAwcOREREBOLj4/HYY49BUZSAr8GXX36JzMxM7T10zwJfdd+rr74aS5cuxaFDh7S2t27dusY67733Xq1c9eW5554L2KZA7XU4HHjooYe0dZIkYdSoUTh69Kg2NUJNPv/8cyQmJuKWW27R1sXHx+OOO+7Al19+qb2vu3btwq5duzBy5EgtoAOAhx56CEIIfP75536PU1ZWhmXLlnlM3wAAf/75JyRJ8pmxrf76PPfcc5AkCXv37sWQIUNgtVoRHx+PCRMmQAiBI0eO4Oabb0ZUVBSSkpLwxhtveNVpMBhw9dVX48svv/TbXqKzFRkZibfffhuHDh1CaWkp9u/fjxdffNFj6hFJkjB58mRkZ2ejrKwM3333HTp06OBRT2xsLObPn4/CwkIUFBTggw8+8Lp9oVu3bvj+++9RVlaGo0eP4sknnzwn53i2mKmjkHX8+HFccskl2v1JHTt2xLFjx/D555+jpKTE4xf5oYceQnx8PCZOnIji4mIAri+s559/Hv3798eoUaOwZ88ezJo1Cz/99BM2bNgAg8EAu92OjIwMlJeX4+GHH0ZSUhKOHTuGJUuWID8/H1arFTt37sQNN9yAbt26YfLkyTCZTPjjjz+wYcMGv+2vzX6qquKmm27C+vXrMXLkSHTq1Am//fYb3nrrLezduxeLFi3Syj7//PN47rnncNlll2Hy5MkwGo3YtGkTVq1ahQEDBuDtt9/W7q165plnAHgP7a9q7ty5GD58OHr16oUpU6YgJycH77zzDjZs2ICff/4Z0dHRWllFUZCRkYHevXvj9ddfx3fffYc33ngDbdu2xahRo/y+DnPnzkVERATGjx+PiIgIrFq1ChMnToTNZsNrr70GwNXdWVBQgKNHj+Ktt94CAL/3iP3973/3CmaWLVuGefPmeUxXcPLkSb9tc4uMjNTu4fn5558RHh6OTp06eZS55JJLtO1XXHFFjXX9/PPPuPjii73u/bnkkkvw3nvvYe/evejatSt+/vlnAPCYLwsAUlJSkJqaqm2vydatW2G323HxxRfX6hz9ufPOO9GpUye88sorWLp0KV588UXExsbin//8J6699lq8+uqrmDdvHh577DH06tXLqxs/PT0dX375JWw2G6Kios66PRSi6thdWisNm/xregRRiBo6dKiQZVn89NNPXttUVRVCCDFnzhwBQFxxxRXC6XRq23Nzc4XRaBQDBgwQiqJo62fMmCEAiA8++EAIIcTPP/8sAIgFCxbU2I633npLABAnTpyoU/trs99HH30kZFkW33//vcf62bNnCwBiw4YNQggh9u3bJ2RZFn/72988zkeIytdCCCG6dOki+vbt63Wc1atXCwBi9erVQggh7Ha7SEhIEBdeeKEoLS3Vyi1ZskQAEBMnTtTWDRs2TAAQkydP9qizR48eIj093f+LIIQoKSnxWvf3v/9dhIWFibKyMm1dZmamaNWqVcD6fNm3b5+wWq3iL3/5i8d1ANdXRsBlzpw5Hu1o06aN1zGKi4sFAPHUU0/5bUt4eLi47777vNYvXbpUABDLli0TQgjx2muvCQDi8OHDXmV79eolLr30Ur/H+de//iUAiN9++81j/cGDB73OyQ2AmDRpkvbzpEmTBAAxcuRIbZ3T6RSpqalCkiTxyiuvaOvz8vKExWIRw4YN86p3/vz5AoDYtGmT3zZT4zRz5kxxfbvmovzpe4K+JISZxZYtWxr6FJsMdr9SSFJVFYsWLcKNN97olckAXCn2qh544AGP+5y+++472O12jB071iNj8sADDyAqKgpLly4F4Lp3AgC+/fZblJSU+GyLO2P15ZdfaqOsaqM2+y1YsACdOnVCx44dcfLkSW259tprAQCrV68GACxatAiqqmLixIleGaDqr0VtbNmyBbm5uXjooYc87jXJzMxEx44dtdenqgcffNDj5yuvvBIHDhwIeCyLxaL9u7CwECdPnsSVV16JkpIS/P7773Vue3XFxcX429/+hpiYGPz3v//1uA5WrFhRqyUjI0Pbp7S01OfIO/frVFpa6rc9td3f/f+aygY6zqlTpwAgKKPx7r//fu3fOp0OPXv2hBACI0aM0NZHR0fjggsu8Pmeu9tQ28woNUK1/hOpjgsFFbtfKSSdOHECNpsNF154Ya3KV5/9+9ChQwCACy64wGO90WhEmzZttO1paWkYP3483nzzTcybNw9XXnklbrrpJu3+IsDVNfWvf/0L999/P5566in069cPt9xyC2677TavAKuq2uy3b98+7N69G/Hx8T7rcM+ntH//fsiyjM6dO9fq9QikptcHADp27Ij169d7rDObzV5tjImJqdUjc3bu3Ilnn30Wq1at8po1vup9i2fqgQcewP79+/HDDz8gLi7OY1v1LtrasFgsPu9ndD8QvGqQejb7u/9fU9lAx3ET4uy/GVu2bOnxs9VqhdlsRrNmzbzWu4NJX204kz8wqPFo6IESFBiDOmoSavsF6Msbb7yBe++9F19++SWWL1+ORx55BFOmTMGPP/6I1NRUWCwWrFu3DqtXr8bSpUuxbNkyfPrpp7j22muxfPnyGkdC1mY/VVXRtWtXvPnmmz7raNGixRmfVzD5G+3pT35+Pvr27YuoqChMnjwZbdu2hdlsxrZt2/Dkk0/WKfPpyzvvvIP//ve/+Pjjj9G9e3ev7e7H/gRitVq1ayg5ORmrV6+GEMIjSMnKygIAbdqDmiQnJ2tlq6q+f3Jysra++vuclZWl3cNXE3cAm5eX5zE4qCb+gj9f729N77mvetzBffUgkIjOLXa/UkiKj49HVFTUGc9U36pVKwDAnj17PNbb7XYcPHhQ2+7WtWtXPPvss1i3bh2+//57HDt2DLNnz9a2y7KMfv364c0338SuXbvw0ksvYdWqVVr3aE0C7de2bVucPn0a/fr1Q//+/b0Wdyatbdu2UFUVu3bt8nu82mZKanp93Ouqvz5nas2aNTh16hTmzp2LRx99FDfccIM2BUZ1dc3yfP/993jssccwduxY7dmP1SUnJ9dq+fTTT7V9unfvjpKSEuzevdujLvfDvn0Fj1V1794d27Zt8wpYN23ahLCwMG0knrueLVu2eJQ7fvw4jh49GvA47ulODh486HN7YWGhx8/VZ8gPpoMHD0KWZa9RhtSEhMA8dRQYgzoKSbIsY+DAgfjqq6+8vvSAwF1O/fv3h9FoxLRp0zzK/vvf/0ZBQQEyMzMBuGYbrz57f9euXSHLstYtdvr0aa/63V+4vrrO3Gqz3x133IFjx47h/fff9ypbWlqqjeQdOHAgZFnG5MmTvYKFqucXHh7uNWWLLz179kRCQgJmz57tcQ7ffPMNdu/erb0+Z8ud7anaRrvdjpkzZ3qVDQ8Pr3V3bFZWFu644w5cccUV2ghaX87knrqbb74ZBoPBo41CCMyePRvNmzfHZZdd5tGO33//3WPm+dtuuw05OTn44osvtHUnT57EggULcOONN2r30HXp0gUdO3bEe++95zG9y6xZsyBJkjbHXU3S09NhNBp9/n4A8PqDY+HChdq5BNvWrVvRpUsX7ZYFaprq69mvFDzsfqWQ9fLLL2P58uXo27evNt1HVlYWFixYgPXr13tMuVFdfHw8nn76aTz//PO47rrrcNNNN2HPnj2YOXMmevXqhSFDhgBwPR5mzJgxuP3229GhQwc4nU589NFH0Ol0uPXWWwEAkydPxrp165CZmYlWrVohNzcXM2fORGpqqt+pLWqz3z333IPPPvsMDz74IFavXo3LL78ciqLg999/x2effYZvv/0WPXv2RLt27fDMM8/ghRdewJVXXolbbrkFJpMJP/30E1JSUrRnH6anp2PWrFl48cUX0a5dOyQkJGiDLqoyGAx49dVXMXz4cPTt2xd33XWXNqVJ69atMW7cuDN92zxcdtlliImJwbBhw/DII49AkiR89NFHPgOL9PR0fPrppxg/fjx69eqFiIgI3HjjjT7rfeSRR3DixAk88cQTXk956NatG7p16wbgzO6pS01NxdixY/Haa6/B4XCgV69eWLRoEb7//nvMmzfPo1vy6aefxocffoiDBw9q8+rddtttuPTSSzF8+HDs2rULzZo1w8yZM6EoCp5//nmPY7322mu46aabMGDAAAwaNAg7duzAjBkzcP/993tNqVKd2WzGgAED8N133/mc9HfZsmUYPHgwrrrqKuzduxfvvfcewsLCsHz5cvTq1Qs33HBDnV8bXxwOhzZPJBE1sAYZc0tUS4cOHRJDhw4V8fHxwmQyiTZt2ojRo0eL8vJyIUTllCa+pj0RwjWFSceOHYXBYBCJiYli1KhRIi8vT9t+4MABcd9994m2bdsKs9ksYmNjxTXXXCO+++47rczKlSvFzTffLFJSUoTRaBQpKSnirrvuEnv37vXb9truZ7fbxauvviq6dOkiTCaTiImJEenp6eL5558XBQUFHmU/+OAD0aNHD61c3759xYoVK7Tt2dnZIjMzU0RGRgoA2vQm1ac0cfv000+1+mJjY8XgwYPF0aNHPcoMGzZMhIeHe52fezqMQDZs2CAuvfRSYbFYREpKinjiiSfEt99+69WeoqIicffdd4vo6GgBwO/0Jn379q1xPF3VKTvOlKIo4uWXXxatWrUSRqNRdOnSRXz88cde5dzTvRw8eNBj/enTp8WIESNEXFycCAsLE3379q3xGl24cKHo3r27MJlMIjU1VTz77LPCbrfXqp1ffPGFkCTJY1oU95QmL7/8sujfv78wmUwiLS1NfP755+If//iHCAsLE88//7wQovI9rD7tTk3ved++fUWXLl081n3zzTcCgNi3b1+t2kyNz8yZM8X1ac1F6dghQV84pUlwSULUQy6eiIjqnaIo6Ny5M+644w688MILAFxPlEhLS8OcOXNw77331nsbBg4cCEmStO5danpmzZqFJa+9hP/dfE3Q62713uf4et16pKenB73u8xHvqSMiaqR0Oh0mT56Md999F0VFRef8+Lt378aSJUu0gJKaLiHq6Z46ppWCivfUERE1YnfeeSfuvPPOBjl2p06dvAYaURPGgQ0hj5k6IiIioiaAmToioiakdevW9TJtCVF9XFa8UoOLQR0RERH5JzivXGPA7lciIiKiJoCZulpSVRXHjx9HZGQkH1pNREQNTgiBwsJCpKSkQJbrOUfjfkwYhTQGdbV0/PjxkHm4OhERkduRI0eQmppar8cQYPdrY8CgrpYiIyMr/iUDYKaOiIgamit9Vvn9ROc7BnW1VNnlKoFBHRERhYpzckuQqJ/Rrxz+GlwcKEFERETUBDBTR0RERIGp7KUKdQzqiIiIyD/OU9cosPuViIiIqAlgpo6IiIj8EpAgBLtfQx2DOiIiIvKP3a+NArtfiYiIiJoAZuqIiIgoIGbqQh8zdURERERNADN1RERE5J8AB0o0AgzqiIiIyC8BQNTH5MN8TFhQsfuViIiIqAlgpo6IiIgCEsyqhTwGdUREROSfqJ/JhxknBhe7X4mIiIiaAGbqiIiIyK96GyhBQcVMHREREVETwEwdERER+Sc4UKIxCKlM3ZQpU9CrVy9ERkYiISEBAwcOxJ49ewLut2DBAnTs2BFmsxldu3bF119/7bFdCIGJEyciOTkZFosF/fv3x759++rrNIiIiJocUTFYIpgLBVdIBXVr167F6NGj8eOPP2LFihVwOBwYMGAAiouLa9znhx9+wF133YURI0bg559/xsCBAzFw4EDs2LFDKzN16lRMmzYNs2fPxqZNmxAeHo6MjAyUlZWdi9MiIiIiqneSEKGbUD1x4gQSEhKwdu1aXHXVVT7L3HnnnSguLsaSJUu0dZdeeim6d++O2bNnQwiBlJQU/N///R8ee+wxAEBBQQESExMxd+5cDBo0qFZtsdlssFqtAHQA+NcFERE1NAFAQUFBAaKiourtKLNmzcIXz0/Bh30ygl73Rd98jGUb1iM9PT3odZ+PQipTV11BQQEAIDY2tsYyGzduRP/+/T3WZWRkYOPGjQCAgwcPIjs726OM1WpF7969tTJERETknxDBXyi4QnaghKqqGDt2LC6//HJceOGFNZbLzs5GYmKix7rExERkZ2dr293rairjS3l5OcrLy7WfbTZbnc+BiIiI6FwJ2Uzd6NGjsWPHDnzyyScNcvwpU6bAarVqS4sWLRqkHURERA0v+IMkhJAADpYIqpAM6saMGYMlS5Zg9erVSE1N9Vs2KSkJOTk5HutycnKQlJSkbXevq6mML08//TQKCgq05ciRI2dyKkRERETnREgFdUIIjBkzBgsXLsSqVauQlpYWcJ8+ffpg5cqVHutWrFiBPn36AADS0tKQlJTkUcZms2HTpk1aGV9MJhOioqI8FiIiovORAKc0aQxC6p660aNHY/78+fjyyy8RGRmp3fNmtVphsVgAAEOHDkXz5s0xZcoUAMCjjz6Kvn374o033kBmZiY++eQTbNmyBe+99x4AQJIkjB07Fi+++CLat2+PtLQ0TJgwASkpKRg4cGCDnCcREVGjIgCVQVjIC6mgbtasWQCAq6++2mP9nDlzcO+99wIADh8+DFmuTDBedtllmD9/Pp599ln84x//QPv27bFo0SKPwRVPPPEEiouLMXLkSOTn5+OKK67AsmXLYDab6/2ciIiIiM6FkArqajNl3po1a7zW3X777bj99ttr3EeSJEyePBmTJ08+m+YRERGdlwQkCDX4mTrOahJcIRXUERERUQjivHKNQkgNlCAiIiKiM8NMHREREfklwIESjQEzdURERERNADN1REREFBDnlQt9DOqIiIjIPyGx+7URYPcrERERURPATB0RERH55X5MGIU2BnVEREQUkNrQDaCA2P1KRERE1AQwU0dERER+sfu1cWCmjoiIiKgJYKaOiIiIAqqPKU34PNngYlBHREREfgkhsfu1EWD3KxEREVETwEwdERERBaSyqzTkMVNHREREAbm7YIO5AHXr0j127BiGDBmCuLg4WCwWdO3aFVu2bKnSRoGJEyciOTkZFosF/fv3x759+zzqOH36NAYPHoyoqChER0djxIgRKCoq8ijz66+/4sorr4TZbEaLFi0wderUM37dziUGdURERBTy8vLycPnll8NgMOCbb77Brl278MYbbyAmJkYrM3XqVEybNg2zZ8/Gpk2bEB4ejoyMDJSVlWllBg8ejJ07d2LFihVYsmQJ1q1bh5EjR2rbbTYbBgwYgFatWmHr1q147bXX8Nxzz+G99947p+d7Jtj9SkRERH4JAGods2rB9uqrr6JFixaYM2eOti4tLU37txACb7/9Np599lncfPPNAID//Oc/SExMxKJFizBo0CDs3r0by5Ytw08//YSePXsCAKZPn47rr78er7/+OlJSUjBv3jzY7XZ88MEHMBqN6NKlC7Zv344333zTI/gLRczUERERUYOx2+2w2WweS3l5uVe5xYsXo2fPnrj99tuRkJCAHj164P3339e2Hzx4ENnZ2ejfv7+2zmq1onfv3ti4cSMAYOPGjYiOjtYCOgDo378/ZFnGpk2btDJXXXUVjEajViYjIwN79uxBXl5e0M8/mBjUEVGNJB//1abMmZarbV21bRsRBYlwzSkX7AUA5syZA6vV6rFMmTLFqwkHDhzArFmz0L59e3z77bcYNWoUHnnkEXz44YcAgOzsbABAYmKix36JiYnatuzsbCQkJHhs1+v1iI2N9Sjjq46qxwhVde5+PXjwIL7//nscOnQIJSUliI+PR48ePdCnTx+Yzeb6aCMRERE1IAGpXiYfBoDhw4fj9ddf91hnMpm8yqmqip49e+Lll18GAPTo0QM7duzA7NmzMWzYsHppW2NT66Bu3rx5eOedd7BlyxYkJiYiJSUFFosFp0+fxv79+2E2mzF48GA8+eSTaNWqVX22mYiIiJoIo9GIqKiogOWSk5PRuXNnj3WdOnXC//73PwBAUlISACAnJwfJyclamZycHHTv3l0rk5ub61GH0+nE6dOntf2TkpKQk5PjUcb9s7tMqKpV92uPHj0wbdo03HvvvTh06BCysrKwdetWrF+/Hrt27YLNZsOXX36pRdELFiyo73YT0RmqqYvTV1coJO+lajnPMroqS03ldDWWq00Zrf2S7N02dx21OFciqhv3QIlgL3WZ+u7yyy/Hnj17PNbt3btXSySlpaUhKSkJK1eu1LbbbDZs2rQJffr0AQD06dMH+fn52Lp1q1Zm1apVUFUVvXv31sqsW7cODodDK7NixQpccMEFHiNtQ1GtgrpXXnkFmzZtwkMPPYQWLVp4bTeZTLj66qsxe/Zs/P7772jTpk3QG0pEREQNp77uqautcePG4ccff8TLL7+MP/74A/Pnz8d7772H0aNHAwAkScLYsWPx4osvYvHixfjtt98wdOhQpKSkYODAgQBcmb3rrrsODzzwADZv3owNGzZgzJgxGDRoEFJSUgAAd999N4xGI0aMGIGdO3fi008/xTvvvIPx48cH8+WsF7Xqfs3IyKh1hXFxcYiLizvjBhFR3fnLPokqfwtr5SQJ3n/TqZCEq7w7ayZBB0je5QAFQqgVP8uQJB0kqfLjxLXNCQin6/iSDpJkcGXYoKsopUAIJwQcrk93SQdJ0lXUJ1fWI5wQkgIId7t0Ff+v0i6hQkgCEErluWrbq7bf1Wb3edb19SOihtOrVy8sXLgQTz/9NCZPnoy0tDS8/fbbGDx4sFbmiSeeQHFxMUaOHIn8/HxcccUVWLZsmcc9//PmzcOYMWPQr18/yLKMW2+9FdOmTdO2W61WLF++HKNHj0Z6ejqaNWuGiRMnhvx0JgAgCVHXWNklNzcXubm5UFXVY323bt2C0rBQY7PZYLVa4fpCYvcNhZZgBXUQInBQJ1SIiqBOC7J8BXXCWRG0CUiSvuagTjhcdUn6moO66sfzFdTBFdS5z9dfUOc+z7q+fkShRQBQUFBQUKt70s7UrFmzMO+Z1zG1yy1Br/uGTTOxYuM6pKenB73u81GdR79u3boVw4YNw+7du+GOByVJghACkiRBUZQANRCd36oGEP4ChjoHGpK7vGcQI0HyDGI8grVqARScANxZMR0k2QhJMkCW9BX1qlCFE6paDogyQJIgyybo5HDoZCNkWQ8hXGWcSglUpRgQTsiyCXpdJPQ6M6SK9imqHYpaBqdSCAh7jfUoShkUtRhClLsCP9kIWTJpQaQQTqjCCYhyiIrAVJJkSJLBx/mpEEJxnWPV19kryK0M/iRIXq/3mQaBtX3viYjORJ2Duvvuuw8dOnTAv//9byQmJkKSmLUiIiJqygQkCPZShbw6B3UHDhzA//73P7Rr164+2kMUEqpnYmrKqtSUsaltZse9vsbyNfzRVPWesKqZpsr93FknnXa/mVTRNenK0ukhy6YqGTigMgtXCrUiK6aTLdDrwqDXWaCryIw5lFLYnUVwVmS9dHI4woxxMOqjYJQsAIBytQhlzgKU2gFFsUGvi0SkOQUWXQz0MEFAQbkoQqnjNIrLVTiFAoPeijBjHEy6KOhggAoVDrUEJY6TKLM7AZRD1oXDoIuAQR8OneTK5jnVcjjVMjgVGYqiVAyGNUEnW6p1CVdk9FAto+ezi7kiOyepHndz+31f/NzJUtNkzIDva8tX+bpkdZkFpPqg8rIKeXV+okS/fv3wyy+/1EdbiIiIiOgM1TlT969//QvDhg3Djh07cOGFF8JgMHhsv+mmm4LWOKLaOJusWsCMmiRVjrqsVr7GrE0N92HVlHWrXt7/YAZ3XZUjVd0DG9yDB1zZKV21wQYOABKEcFRUbXBl4GQz9LIJkiRDCBUOtRQOpxEOcRKSJMOgj0C4MRFhcjRMUiRkIaPUUIAi5QRspSocznyYjTGIMaYhXrRAlAgHABTJJcg1HUWuUFCs2BBuikcL3UVIEHEwyzooQqBAlCLLdBhOtRyqcCLK3AKJcgfEqjEwSgY4hIICXQGypN/hcJZAqKUwG2IRZUpFmBwDgzDBIZWjTC1AsfMEilUnFKiQJBMMeiuM+kjoZSOEUKEIJxS1HE6lBIqqQKh27b479yCOyrfDAQEVknBCQIb7/jvf9955vidADSNra/nee7//VaqvKOJ1nWgFJC1bWJf7AGuTKWTmjwRQb0+UoOCpc1C3ceNGbNiwAd98843XNg6UICIiapp4T13oq3NQ9/DDD2PIkCGYMGGC1wNviWrD371E1ctUV5vsQ12yatWzH95lZC0D45VV8TnaFK4Zb4Sila2e4fEaAVntvq3Kun3dIwdAqAB0HvfJucu4s06yZKzIRLn2U1UnFLUMUsVNMbKkh0EXDrPeCpMcAYMUBgEFdlGKUt0p2NRiADqY9dGIk1shQU2CVbZAL0soVBzI1uVCMZUj33ka4YZmSFMvQJvwcCRaZEgA8uzhOFgYCbupCMVlfyJa3woXmZojLVKC1QA4BJBVYsLvBWYUGXPhVMvQQroQnY1JSA6TYdZJKFUEsorD4XDYUSAfgdBFopm5PZqr7REnwqGXJRQrTpxCAXIMOpQ7C2F3qDAarIgwJSFcHw8dDFDggEOUoFyxoQyuUbcCArJkhk62QJaNHllNIfQVZVCR4fTxnvic5sW9rtp7X+UaCfTe+80G1nidVNZf07XqL6vsdZg63P93pvf+MfNH57PJkyef0X5XX301rrrqKr9l6hzUnTp1CuPGjWNARz757Hastr36v8/0A77ON637+rKs/kVZ5Uuysn2yV9mqX9YeX/IVE/KKKl1h1eurGhBI7mCgaju8gofqbXZNLSIJ1es47oBOJxsrpgYxuKYGkR2QFBkO4YBQyyBJMoy6cITr4hCJBFhEGGRIKJVKUWCwoMR+Ck6lECZdFBLUJLS2RCLBIsMkSyhyGhBZ1BzFhjzkiZ0Il5uhtSkcF8UAF0SWQCcJ5JQZEa43IzevPY6JtUhWW6NHnIT0mCLEh5Wg3KnHPlskADP2FzaH3ViEDoZE9Gwmo114OcL0CvLseuw1GpGTk4Q/ZSP0OgtaqB1wQbgVzcwS9JKEPLsB5mIdSkQh8qSDkCQ9woxxiDG0QqyaBBkSHHCgSC6ADYBDKdOCXZ1sgUEfAV2V7mdVOOBUyiBLKlQoFQMm3O+3rM2j531tyZCE0/d7X/UxZ4Hee3/XlPvaqHadVL0efV2rlWUBr2lbJKmGQTfV1DL4c68PFPwF+t1n8Bd6XN2v9VPv+ebgwYNntJ/7+bX+1Dmou+WWW7B69Wq0bdv2TNrUBEjn3TQudc2s1WlEZ033FNU46lP4+ALyMYmuJGlfhq5DVszJ5nWvkFTxBVhxP5SPgEqqmLNMCEUr63r+qB6+53pTXZ9UHmXlKmXd929VTKgrnBXdGpXzPkqQfd4fV3kM9/6uyXtdIzl10MkG6GQTDPpwGGQLjLpwSNBBFQ7Y1SKU2HUoL8+CJOkQbmiGeNEKSVIMYkwGmHRAuQJkl8ejNKwAJ2xbEaFrhjRjFNLjgE5RZYgzlaHAbsQOmwXq8QtxxLABCWoqescDN3c4gvgMC6QIE5x7stFhTRzy7YnYWgB0iYjG3V3/RNygJKDjRYCtEJ1W7oT1q0Ts2p0GySjh2hQZt3Y9AOtVEZAizVAO5OLAunAcLY3H5tNGJJg6oo81GpfGOdAyvASSBOwvjMD2PBNKTjXHMZ0RRkMcUozd0A6t0CzM9fFW5FBx0mHFMZ0Eh74EpfZc6HSRsJiaway3wiCHAQCcohxOtQR2SQeHIkEoCiA5XG+lNnmyocr15Pl+CCFVvPc+rjttUuVA771c7b2vrF8SEgSUiitfguckzO7gTq2ciNndhqplq1/7FW3xLFvDHz9A5e9JgD+oAmYJaxgpfKbBn78yTdmZPTqAGtqcOXPqre46B3UdOnTA008/jfXr16Nr165eAyUeeeSRoDUuFF100UXQ6XSBC9I5VfWrwN/nnK9Q0Vf5msJ2UVMZ9xdWlU/ZgGWrlPfbhurlfXShiar7aJMLu/4AkSQBwAggGqoaDiFSIIQCWS6GJO/FKV0YCnVhkGUjAEBV7UhzRKKFswcgZeEPowNZhgSsleIRpiYCeqA4zobCmGPoXnohnNJOLLK0x8bcC5D0SSQMsoRypS1y1SIcb7sHFyddjH1he/HM8V5ImmlBmB5Q1AicLu+JI8ZsFHb6BbFCYJnJjl+PpCPyMwNkSCh2KsgV+Tja4he0bRYGi9mBHcaTOIx4mEQkFKHAFnESRZZcFMedQDtnGHT6BBj0Nth0B1AkGSCEAodSCodSgki1DOGqHi1FW8iyAZJkrAi2ANekxDKEsEAIE4Bo7XV1v6bVX/OgvJc+ynuVrc01VU2NdQYoV1N5xg6hSVEU/PLL1sAFg4T31AVfcXExwsPDg1bfGY1+jYiIwNq1a7F27VqPbZIkBSWoe/fdd/Haa68hOzsbF110EaZPn45LLrmkxvILFizAhAkT8Oeff6J9+/Z49dVXcf3112vbhRCYNGkS3n//feTn5+Pyyy/HrFmz0L59+7NuK3ly/8rXJbA606DKo1yVL0sJ8Ah0vMtVe+KCj6DIRa6WRfQs66urFpI7Y+CrbNVyrm40Ifko69EOz+yikHx1kwm4HqUFV0ZGcj+L1ahl7GRJD1U4YVdK4HAWQlGKIcsmmA0xiDIkI1akIBJh0EFCqezAMctBnCrZCwEFMcbW6CC1R9tIPZIsKnQSkF0Wiz0FzfGz2QFFdaCbrisuT5DROyUXlggnigpM+OVEDFZnp2O1fABtpHQMbmVEj7TjsLSWIYoVHNsdgZVZqVicVwRZ0qN/VGtcHl+EFvGnIMsCWSeisPlUPJac6oyiskNobuyBHpYUtIoAIvUKShUZfxQ2w56SRBwy/oxCZx7CjAlI0HdAjBoLs6xHqerAaeMp5KvHUWLPhV04AajQyREw6iOg15kAAIrqgEMphqKWQVUdgFC05826X1P3EzUq3zf4eG+873uTKt4Xj/dNiIprRfFx/VUpG/Ca8rz+fJWrfk1X8nfdeZJ8BKB1CRRr+8dU9fIMJkOHEJynrj4kJibijjvuwH333YcrrrjirOurc1B3pn3BtfXpp59i/PjxmD17Nnr37o23334bGRkZ2LNnDxISErzK//DDD7jrrrswZcoU3HDDDZg/fz4GDhyIbdu24cILLwQATJ06FdOmTcOHH36ItLQ0TJgwARkZGdi1a5fHQ37JtzMJ1Co7lHyU8xqsUEPHiUcAptZctlrw474B3atslQyWq6AIcE+T+8vVdXyhdamKauWkKhmfinpFxeO2tP1lVHbFSQB0QEXQIIS9htfIPfCh4ryE4pEhcmWaJFcXrKpAAjzKA6i4b64ZjFI4nKIcxfIpKEo5FBRXHEtCGGLR2hSN1DAZBhnIKzdBKWyFIkM2Su0nYZDMaBGhx9VJhWjbKQ+SUULu7xYY5WY4kJeK0/aDSAnX49pOR2B+1jWlUZiioN/cr3Hi21R8X2JBsjEcl/fPAYbcqJ1jy6wsXDl5D74/nYhwYUH/5Hy0HZUI9cIrAQAd9uyFecYRrD0RCZ0uHO10ibgqvhwXtcuBKVmGI1fFyh3NkVMajsOSDEk2IFKfjDQ5CalRekTogbxyI/YX6VAonfB4f436CEQak2CWoqBCQYmaB0W4HlsmSRIg6St60Z0VQbIrqyeEveK9hfd7L5SKWE3x8cdHRReoezJkSXE9ZlHUNFhCV+V9F5Dc11/1a6pad6mr+1WCgLNaC6r9QQF4Xc9SlbJaO1DTgA73PwL/jtaUpfT1GeHrcwQ+yvkqz3iDGqOPP/4Yc+fOxbXXXovWrVvjvvvuw9ChQ5GSknJG9dU5qKtJVlYWPvroIzzxxBNnVc+bb76JBx54AMOHDwcAzJ49G0uXLsUHH3yAp556yqv8O++8g+uuuw6PP/44AOCFF17AihUrMGPGDMyePRtCCLz99tt49tlncfPNNwMA/vOf/yAxMRGLFi3CoEGDzqq9DaWsrAxHjx5FaWkpLBYLUlNTfQaoQggcP34ceXl5kGUZCQkJaNasmc86bTYbjh8/DofDgaioKKSmpkJfpavZ/SHsdDpx5MgRFBUVwWg0IiUlBVGRkRWFJI8P/9zcXJw4cQJCCDSLa4bk5CSfxy4pKcGxY8dQVlaG8LBwtGjRAkaTsUqJiueOqgJHjx1Ffn4+DHoDkpKTERMT65m5qjh+Xl4+srKzoDgVRMfEoXnzJOh0VZ6gIAGSUFBut+PIkSMoLi6G2RyO1NTmCA+PqAy+oEAI1/GzsnJx6lQuJEhoFp+IpKQkVH2YvesZyAqKCotx9NgxlJeXIDIiEi1atILBaK7oDnW3QYKi2HH0aC4KCgpg0EtITGqGaKu1onmSR5B28mQ+Cgtc91RZo01o1iy84iQAoBwSdJBlAwoLi2AqbY9okQBb9B+Ij+mAMCUMdrkc5ZIrmJMlPURZLNrYeqDAVIboVBmtw50wyQLHdAbsLzJCEXYUFRUgVY3HCeFAao8CGDI6AQYDEnQ7EHdChSpU5J7ajwO4EuZWVQJbnQ76S9tBv6IMJSVlOCYXQr4wFZV3mwEiORlG/W4cLTuAZF0a4mNLoF54jbZdvaADLKb92FfyO8rtDhiiZbSyFiKsbxJE+1Yw/3kMYbtVFNvKYHG2xGlpDyRIsJr0SLWoiDM5cVxnwK48B1oWtMVxZxyOmtdBp1MgSzoYpXBEqtEAALsoheN0NEwlrZCr34HIGAFJBiTFCUCGLBkgSTqUlhfj9AkniooLYTYbEZ8YAbPZCFfQL7S8rqqqyDqei/wCG/R6I5KSEhEbG1Ml+JcAOAEh4XReAbKyjmnXaWpqKnSyVBkAQgBQUF5ehiNHjqK42AazyYzUFi0RHh4Bd/Dvuv6cgKQiK+sETp8+CSFUJCQkIjEhyStLLUGgsKgYx44dg728HBEREUhNTYXBqEPVjKIECU5FwdGjx2ArKIDeoEdKcgqs0VZ4Zv5cvyMnT51Gbk4OFFVBTEwMmqekeN+HLEkoK3V9hpWUlmifYRb3Z1jVP7yEwDEfn2G+sn8FBQXIysry+AzzdbuMw+HA0aNHtc+w5s2bIyIiwkeNQE5ODk6ePAkAiI2NRXJyss9yTZ9UP/PUnefR+MCBAzFw4ECcOHECH330EebOnaslnu677z7cdNNN0OtrH6rV+YkS9913n89lyJAheOGFF+panQe73Y6tW7eif//+lQ2UZfTv3x8bN270uc/GjRs9ygNARkaGVv7gwYPIzs72KGO1WtG7d+8a6wx1qqpi7969sNlscDgcsNls2LNnj885Ao8ePYqcnBzY7XaUlZXh8OHDOHXqlCurU6VcSUkJ/vjjD5SUlMDhcODUqVM4sP+AV30SgD/++AN5eXlwOBwoKS7B/j/2o6y8vPKDuOL/J06cwNGjR1FeXg673Y6srCwcz8qG67KrvLnb4XBi7969KCwshNPhREFBAfbu2w8h3FPqVnYdHTp0CCdOnIDD4UBpaSkOHjyIQlthte5XCTZbEQ4cPIDS0lI4HA6cOHEChw4dhztTVjULsnfvfuTn58PhcKCoqAj79h2Aw+GAa4CCpP0/OysHWVnHUF5ejvLychw/dhy5uafgCvxkSNBDknQoL3di3x8HUFxcDIfDgby8PPzxx/7KuqCHVFH+4MGjOHXqtOu1LCnBgQOHUFRcrL2OkqSDBAPy80qQm12C0tJylJXacSKnDHmnS6DTmVyvoxCQZBPKS2UUZceg1KagpMCO5oe7wWILg1UOg0UNg07SQxWlOHlCRYtjHdDc4cBQoxO9pRykRRYhJbwYMQYnVCFw9OhB/KX4ZtwXdQgvPH0C4R1cgZbaJg36Ds0gqQqWb3wfo3Q3463J+cA9Azyv0y6dcIl9N3799XtMsO4Horz/6Ggx/VIMLkuC7kApnAUlXtvjXu+LBa1lWA5fhN8P5SIqugxqt84QiUlQe6ej74ddMf3q7bgFJliP9kV+WQ6MMtDM5ETLiCKkmUsxJuwoLpJKkFpkRMyh3lCUMAgIGEUYImBBtBSOZocTEZWViKLCUtjzInDquB6yZKnM1kqugDn7iAP5+UWw252w2Upw+M88SDC4FtfzySAAr+v00KEsFBaWQYIOknbt62Cz2XDw4J8e1+mffx6tdk1JEELGvr1/oKCgoPI63fsHHA5Fu57dy/HjWcjKytKu06NHjiA3N7fy96OiXFlZGf7440/tOj2ddxp/7N/v+QdSxTkdPOD63HBfp/v370dxcYn2++b+7/TpfBw+fBhlZWWw2+3IycnB0aPHqgSUrkVRFOzdt8/jM2zv3r1QlKphv+v4R44cRW5Orsdn2OnTp72ulZLiEhzYf8DzM+xA5WeYVGWp+hlWXFyMffv2oby83KvO3NxcHDtW+TufleV6bc9Hop4WcomPj8f48ePx66+/4s0338R3332H2267DSkpKZg4cSJKSrw/H32pc1CXl5fnsZw8eRKbN2/GmjVr8Prrr9f5RKo6efIkFEXxmi4lMTER2dnZPvfJzs72W979/7rUCQDl5eWw2WweS6goKCiA0+nZvaIoCgoKCrzKnjp1ymvd6VOVH4iSn3JFRUWw2x0e60pLy7wuLiEETp/O8z72Se863X/xVpWfnw9V9fwwt9vtKCosqtJOCaqqIi+vynEqvihOnspD9UDx1KnTHvc7VR5HwPWF6QrUiopLYLfbtWMArqA5P78E2kjYimDs5KnT8PiVkWScPl1YOVq1Ql5egatrrYrSsnKUlJRW1OUK1uwOJ4qLyiraU+V1q/JeSJAhyzoU5JV5vW5FBU7oJIN2bFkyoLjA85x1koQUh0CUQQ+TZAAgw+kohVoYU7EPoJMEOlr3o0UHG+KiixGlV6BAxckTxVAEYNCpgNkAcddfKitukYTYsnwIUZGhjQwHUP1L0YkoU74rgDI6obap3p3gAKDCJAtY9DKip93gc7tOr8IBBywFCswpKhBVcUxX3hiyUYJeAuyKHcdy/oQsAVajHQnNi3BRxwOQVRV6yRXMKEKFvdACRdhhEAZYdHpESTJEqQOSJEEWrtGnZaV2OO2SNspVlg0oLxHa74Ok/UHiQFFhKWRZp72PruvH+3fx9KmCyvsdK66rU6fzvcoVFNgqunHd15SM4uIS2B2ev/OqAPLzbXAHgO5A8fTpYq86Xcep0vUPHfILij2uUwkSSktLq/x+u+q0250oLCxE9a+L06e9f8dOn/L+HPD1O19QUOj1GeZ0Ol2fs9Wyer4+m2q7rrCwEA6Ho9ofsKUoLS31KOf6DPMOFH213dc6orOVk5ODqVOnonPnznjqqadw2223YeXKlXjjjTfwxRdfYODAgbWqp87drwsXLvS5/qWXXsKiRYvw97//va5VhqQpU6bg+eefb+hmEBERhQQ+Jiz4vvjiC8yZMwfffvstOnfujIceeghDhgxBdHS0Vuayyy5Dp06dalVfnTN1NbnrrruwZs2as6qjWbNm0Ol0yMnJ8Vifk5ODpCTf92IlJSX5Le/+f13qBICnn34aBQUF2nLkyJE6n099sVqtXn3sOp0O1op7saqKi4vzWhcbF6v9W/gpFxERAaPRc8oai8WMsLAwj3WSJCE2Nsb72M286/R1P190dDRk2fNSNBqNiIisvMdFQECWZcTEVDmOcI30axYXA9dN2u4FiIuL9Zq3ynUcCa6bzV03qkeEh8FoNGrHAFxd/tHRYRVZDLXi/wqaxcVq9bt2UBEbGwkhBESV9TExVq97iCxmE8LCLBV1CQihwGjQIzzCjKrzhLnaXvm6CahQVQXWGO+uywirHkrFc0oBQBUOhFs9z1kRAscNEmwOJ8qFK/OlN1ggR+ZV7AMoQsLvBW1xZG8UTuWHw+bUQQcZzeLDoZMAhyIDZQ5I/11RWfGRbJw2R0OSCl0/FxYDMFVroR628mhIkGC36yEfOF5tuytzWK5KKHWqyH9kic/tilOGAQaUWnUoOy4DtopjQgKgh2oXcArAqDOieWJrqAIosBuReywCv/zeBqoswylc2RidJMMYWQqdZIRDcqBUccImVEgWA4QQUCUVAirMFiP0RqHNEaeqDpjCJO33wf2aGwwGRERaoKqK9j66rh/v38XYOGvFEysUiIrrKi422quc1Rrlup1Nu6ZUhIeHwWjw/J2XJSA6OqriuO5rX0FsrPf0CK7jVF7LgIJoa7jHdSogYLFYqvx+u+o0GvWIjIyEx7UP1/1l1X/HYuO8Pwd8/c5brZFen2F6vR5RUVFeo4d9fTbVdl1kZCQMBoNHK8PCLLBYLB7lXJ9hsajOV9truieZ6EwMHz4cKSkp2LBhA7Zv344xY8Z4BHQAkJKSgmeeeaZW9QUtqPvll1/Qo0ePs6rDaDQiPT0dK1eu1NapqoqVK1eiT58+Pvfp06ePR3kAWLFihVY+LS0NSUlJHmVsNhs2bdpUY50AYDKZEBUV5bGEClmW0aFDB0RFRcFgMCAqKgoXXHCBzxuCU1NTkZiYCKPRCLPZjJYtWyIuLs7rfoawsDC0a9cOYWFhMBgMiIuLQ5u2bbzqEwDatWuHmJgYGAwGhIWHoW27tjCbTJUfxhX/j4+PR2pqKkwmE4xGI5KTk5GSnITqAZjBoEeHDh0QGRkJvUEPq9WKDu3bQpLcj6uvnFKkVatWiI+Ph8FggMViQVpaGiKjIqvN5SUQFRWBNmltYLFYYDAYEB8fj1atUuD+YnN3O0mShA4d2iI6Otr1BR0Rgfbt21TMv6hoX4JCCCQlJyI5uTlMJhNMJhNSmqcgISEO7i9VASeEUGAy6dG+XRuEh4fDYDAgJiYG7dq1rawLTteXOpxIS0tFXFys67UMC0ObNq0Q4Z6zSIiKAMCB6JgwJCSFwWIxwWwxIj7RjJjYMChKOdyTLQu1HCaLioikPFiidAizGnGs5a8ojSpBgVqCUrkEinBClixoFi/jSPO9OGYw4D92PTaJRBwsjMDx4nDkOfSQJQmpqWlYEf4lPrC1woQp8SjeC8h79kI+cBDOvSchZB0G9HkAs5QvMW5iNPDRcs/rdOdubDZ2QrduV+KFgraAzbsL+cjDP2KeORtKGwv01jCv7aceW4vb/1RR2vIXdGyVAFu+GfKvuyDlZEPetBVrh/2Gh9d0xxcoR0HqWkSbE2FXgZPlehwuisDBMgtmlKTiFxGGoxF25LXaBJ2uxBVoSiUoQinyRTFOtsyBLTkHEZEWGGOKEJfihCpKAaFUvBUKVNWBpBYGREdHwGjUIyoqDC1bx0DA4VoqRrNKgNd12qpVMiIjzRBQKoI1VwAWFRWFtLTWHtdp69ap1a4pAUlS0b5DO1it1srrtEM7GAw67Xp2LykpyUhOTtau09QWLTxmDnCXM5vNaNeutXadxsbEol3btq7ft6q/y0IgrY3rc8N9nbZt2xbh4WHa75v7v9jYaLRs2RJmsxlGoxGJiYlITW2u/QHmXnQ6HTq0b+/xGdahQwfodNUfvybQokUqEhITPD7DfAVgYeFhaNO2jednWJvKz7Cq93FV/QwLDw9H+/btYTJV/6MESEhIQPPmlb/zycnJ5+1ACc93MHjL+S4rKwv//Oc/0atXrxrLWCwWTJo0qVb11bn7dfz48V7rcnJy8OWXXyIzM9Nj+5tvvlnX6jF+/HgMGzYMPXv2xCWXXIK3334bxcXF2mjYoUOHonnz5pgyZQoA4NFHH0Xfvn3xxhtvIDMzE5988gm2bNmC9957D4DrS3vs2LF48cUX0b59e21Kk5SUlFr3UYci1wdyu4DlJElC8+bN0bx584BlfQWvAt7TCuj1eqSlpfmupNpf2QkJCT6noqkuLCzMY95A7yS/69dfliW0aNECLVq0qFLO9bglyfPQiImJRnRMdGU5bX6wyudjuu73Mmof/q5yOm0btKkhXPskJycgKSneVVYr55lpE0IgPCIcF3RoW/n6STq4J7h11ekaVes6nwS0SI33umnY9eXq1M4yLi4SsbHuJ1/IUIVDm9LEVd4VeEREmIGIIyiRchBlSkAJTsOpK3c9MUG4AitVOKE3n8aByJ+RaOiMfIeKP4v1FVOaAKXCDp1kRESEFUcjTuCqiDQczbai7be7tSlNTtllyJKMhLi2aBNrRtkhBVo+UVHg/PEPONVUhIWZ0TwsEuqOo0D3bpXvcVYW7E4ZqeY2CIcFJ07LiNqxC+qFnV3v9Z69KC03on1YV/wmH4ZDUXGoIBLRa7Nh2psLR66KEqU5wqPMKFUOw1BqhoBAQbkTR0v1yHcYkVcOmAwG/NFsLwrLj8HglCCEDqpQYBfFKJR1UKHAqZbBEJuP8qgjiHK/nqqz4v1zPT5Mggqj0YDEZAkJiNEGFFROSVP5JAdZltE8NQnNU5O0qWYqs2SA+w8FAYGYGGtFxq3iRn5Jqijr1K4nV8bMiLZtWnleUxXXs/sacM+Tl5wUX3mdVlxLkntKFPcgIQhERISjQ4f2ldd+lWuv6nORdTodWrVsAYEqv3fa75LnlCbN4mIRV6U3wGeHnRAwm01o266GJxNVvdevhs+wqp9Nblar1WePRXUGg6Hmz7BqEhMT+VhMAK5YP/jdr+frhMafffYZBg4cqGXGjx49ipSUFK3XqqSkBDNmzKjzjCJ1Dup+/vlnn+t79eqF3NxcbZTVmT5K684778SJEycwceJEZGdno3v37li2bJn2S3X48GGPrrrLLrsM8+fPx7PPPot//OMfaN++PRYtWqTNUQcATzzxBIqLizFy5Ejk5+fjiiuuwLJlyzhHXS3VZoSSu0ygeaUEoE1kGrB+jy9BP2XdX2zV1nmVFaJiQtlqz7/0etZORV2i+iPMqpd1l5O9MoVV/wZ1Bwaum99FxfxgSpXAsVozUfEaub+sfX2QCgEBu6uuimyKqybXFBzuqTPsSjGEUD0mH1arzIsnIFCC0/iz3IxT5RWTDwsHsuVDKC+zQZJ0cIgyHClyYk12JH4vCK+YfFjGngIHCpxHAQDHi51Ytbs5ej/+TZXJh5OwI88Jp1KKLHsxNnzXDD32f+Ux+fD3J2KQJ/2OAkmP77LaoXT6KbSIX1Jl8uFYFMrHoSjF+EPJwboTKThU2hKRu92TD0vIFzZXt6bqQKEzCwf1kcjPrzL5sHwKilp1wI8Ku7MIhchGqc7VDa2oDtekw6gIooSiBeuuLli7Nq1N1ddOEqgSVIvKa8LrPa0I0IVSbdof7+uvsqxn16jPawoAhAyp4qjVy1U954pws8ZjVwZJVZ41q230/p3VArsAv6OeZWsuV3VdoM8Rf3UQNQZ33XUXsrKytKRH586dsX37di3BUFhYiKeffrrOQZ0kqg/TI59sNhusVisuuiidjwkLQbWdhNTXnxq+ytf0J4moqUzIPibMqI3idc3z54DrebEKZNkEWTZBrwuDsdpjwsocBXA6CwBJB7OxGcINCYiU4hEmXPc5Fks25KvHYCs9DEnSIc7SHokiDUkG92PCVOQ6i3Ace3CqeAeiwtqivdQLSWYLwvQyFFXgdLmCIyIbx+y/QAiBZNOFSBFJiDRUe0yY8xcUlv4JizkZVmNLRCEeJmGCAgU26SSKlFwUl5+A05kHnT4CBn0kjLpwyNUeE+Z6WkRZxbn7ekyY63WpfH4vHxMWqBw1LPdjwgoKCur1FqFZs2bhg6ffxLMd7gx63cN+fhsrf1yL9PT0oNcdymRZRnZ2thbURUZG4pdfftGCupycHKSkpPicqsyfoE0+fL745ZdfzjgL2VgFeqh21TJVVS/v78He3g8gr+E1rpLdqvHh4+5Mg68Hq1drp5ZdEap3uaqPhoLrvip3WffEwNCeEiFXOaYaoKznQ91dj/hyP4XC1QZXUOaeVFYHXw+Qd+3vhBAOV1ZRNkOvC4dONmuPBzPqXFOeqMIOu1qEEvsplJdnwWCIR2JEVySKNoiTYhBjNMCkA8oVILu8DLvFepyw/Yx2MTfiQmNnpMcBnaLKEWfKQYHdiB02C7473gLrbF+jV/jdGNgyBjd32IP4DAukCBOce07i1zVxeG9fC6w4/h88kPJXvHTlr4gblAR0TANsRVBW7sTarxLx+u7O+FP+E8NTjbi161ZYr4qAFGmGcuA0DqwLx/TdXfDR6V1IMBlwubUZLo2zo2V4PiQJ2F8Yge150fjpVHNsdi5Fmf0Y2kVci3ZohWZm18dbkUPFSUcZjumO4KTjD+SXuOYuCzMlwqy3wiCHAZDgFCqcainszmI4lBI4lRIItbSim1sPSTJo752v90NUDERxvx8CovJ6knRn+N5Xeb+F03VPXsU1BUlX7TqtuPaF6soyuttQtazXtY+KrGTdfqd8/i5XviAe9df2996jbPUqa/js8XhM23kYep7rnAwfExb6ahXUXXfddXjuuedw6aWX+i1XWFiImTNnIiIiAqNHjw5KA0OP8O6ta+Jq82FZ9QO8pvLaF4yv7qbq5Wq4d8OrbiHgdTNdxXqPskIFpIrHgnlQq5V1dSe57tFz/1v4LCvgrOj6kiDcX/LuL3go1cqqlfVJVf7yEu77sNQqH9BCK+96nqivv9Qqv7yFUF3Bg1CgqA4I4bonS5HtsCslEMJ1T5hTKYPDWVBxo7yCYsdJnNDrUCZKkVMWBhkSSqVSFCAb+SV/QpKMKFJO4mCJDUJE4nCxGSbZgiKnwOEiB35Vd8DhyEOufBSbTsTArrTABUfLoJMEcspaYnu+HtuKswEB7CzKx/zfWiP9aBHiw35BuVOPfbYUbDhhwEFpN07Y92DV8fYocbZBu73lCNMryLOnYG+hEXtsJVAUO7JLd2KjswVOl1nRzGyFXpKQZxc4WlyOY9IxKIoddscpHLf/inJjCWJLkiBDggMOFMkFsClZKHcWAZCgKDaUluvgVMqgk02QJNnjdVJVe0XALICKLlYhuZ4WUuP4sqrdsO73vuK6Q8X9bAHfe6FCSFKV977aNQVo9+K57pWTAXeQB3hex6JyAIMEd7at2q0Hrgp9/M5Wu+aqBWE1/S5rxavU56+sr999oHZ/SNZme9N3vp8/VVeroO7222/HrbfeCqvVihtvvBE9e/ZESkoKzGYz8vLysGvXLqxfvx5ff/01MjMz8dprr9V3uylE1eZDuLYf2LU5lr8vFu8dROUgiarrvMpI8LgHqcqXn9exKwZpuEdJ1livuxwASVS9N6riHqiq5bV7BOWKsmpFNsa9Xa3ct3qALByu1qquwRCS6tpPVZ1Q1DJXFknSQQgVdqUYxdIpOOVyFElhEFBgF6UodZ6CUykEoEO5YkOuPhsoBfLKLdDLEgoVB7KlXOQ5DkKSZBSrJ/FnSTFkKRzZZWGQAOTZBQ4WliEb+wBJQpb8J34+FY18ewSshgg4BJBVAvxeUIYCcQwl9lPYq8uB/mQSjpWYYNZJKFUEsopVZEnZUFQ7nEoJjpj2Qi1uj7jScOhlCcWKE6dQgELpBFThhBBOlNhPQZYMsOtLoIMBChxwqCUoV2xQ1HLX/XdChaKWAk5Ake0emVYhnBV1VQ58cL3f7vsiq70fFe9JZebL+5pyB2gB3/uq10r1a6p63VWuZ1FtsILP6xrwef17BWC1/XWq8rtcfX1N6xisNV6uh+CdX71U9e3bb7/VBva4Z/rYsWMHANdk+WeiVkHdiBEjMGTIECxYsACffvop3nvvPe3pBZIkoXPnzsjIyMBPP/1U6wny6PxVl8xfbcrV2K3kq1yALKFrZZV11R5k7pn9q/mLsmpZ7YtS+wL2c7yq66TKQND7C756hhEVgYUrW6S4s3dwByoOoCLokSoGTTiUYtc9Z3KxlqlyqKVwOEugqqWQZQvKnPk4JR9CqVwAkxQJWZVRKhWgSDmB4vIcADKKHSdx0LgHRSUtEFXsmo6lSCpBrnQU+WWHAQD5zkP4BfHIKouDWdZBEQIFaimydIdRVJoDh7MIR8QO2O12HC6LgVEywCEUFMgFOKkegKLaoSiFOFm2D3ZTKXKkGBhUExxyOcrUAhQ7TsCplEGSZDicBSiCa5CIXja6AjjhhKKWw6mUAFBc2VVRDkVVoYryKt2irsDY3TVa43viK+BC9YDNM/ivzXvva5RqTWU911UfgFH7bJlXlbX8nfK33l/dROQybNgwj5+rP7zhTG71qvU9dSaTCUOGDMGQIUMAuB5VVVpaqs1dRERERE0X76kLnuqPxgyWMx4oUdv5gIjqW12yerUto2Uqarih272utvcKVa0rUNs86q2eBaxSl68uLUmoEMIOSHLl4dxdg1WyS0I44FRKoKp22Kt03anCCVUt1booHc4iFAkVZbp86Cpu3HcopbA7iyq6aIEyex7ycBDF+lMwSq6Z+svVIpQ5C1DmcD1Ps7j8BI5Iv+CkLgZ6YYKAgnKpCKXlp1HuyIeqlsBWdgROYwlO6qKggwGqpMKhlKDEcdI1clU4UOY4DUW1o0gfDp2khxAqnGo5nGpZxVQtMoQoh8NZAFW1a4MNXOfs1LpoXfPLqQAcFfexVc/KVd7v5vG+1JRFq3hPqr+XnvvV8Fb6Kl/Le0/dqpf31wVaG8yoUXUCYPdrI8DRr0RERETnSFpa2hl1rY4dOxaPPPKI3zIM6oh8CGb2r3q52kzDUOfRhRX37GmDO7SsnOcIR+3+LuGEqqpQq0/HUjFthuvYTihqKVThrLgXrWKuO+GEqpZDqHZAkqCoxSixA+XOQsiyvmIUqWsfVSkGhIBTKURh2XGU6k5DqsgMKqodiloGRS0GhOK6F051olTO86hHUcogRLnrbJRi2CuyjJVTfrgzcK5HprkycK775WqcbsadVRMqXDmI6tN4+B5woGVH65jI8soAw/+1w3vVKOQIdr8Gy9y5c89ov9atWwcsw6COiIiI/BKon6DufIwT+/btW291M6gjOseCnQWs3KHKSEh/9WiPSxNwTYLr3qB6ZPQEFEC1Q0hOzwdPuefHq8gQqmo5hHBCUavev6Zqo20FBFS1HA6halOluNvpnjzZXUYIJ5yK7+yh62cnhCogYPea5qXqFC/a/XIARPXHwlV/2areK+frZT3L+9OCsR8RUW3UMItmzYYNG4Z169bVR1uIiIgoRLnnqgvmQsFV50xdQUEB+vfvj1atWmH48OEYNmwYmjdvXh9tI6JaqvO8fj4exF61Hnf2ypXR855Y2fN4asVoWcVjnUc5oUBArZY1qyxXtYxrBKvvMq52KRCS5LNdnj+6n7RQ83nW9DMRUWNU50zdokWLcOzYMYwaNQqffvopWrdujb/+9a/4/PPP4XA46qONRERE1IDc99QFe6HgqnNQBwDx8fEYP348fvnlF2zatAnt2rXDPffcg5SUFIwbNw779u0LdjuJKEiEn/+ql4PwXqqPvK3cplRZaiqn1FiuNmW09gvVu23uOmpxrkRUd2o9LBRcZxTUuWVlZWHFihVYsWIFdDodrr/+evz222/o3Lkz3nrrrWC1kYiIiIgCqPM9dQ6HA4sXL8acOXOwfPlydOvWDWPHjsXdd9+NqKgoAMDChQtx3333Ydy4cUFvMBEREZ1bAhKE4MCGUFfnoC45ORmqquKuu+7C5s2b0b17d68y11xzDaKjo4PQPCJqSHV5tNq5rKuuZYno7LG7NPTVOah76623cPvtt8NsNtdYJjo6GgcPHjyrhhERERFR7dU5qLvnnnvqox1EREQUokQ9jVZlvj24zmqgBBERERGFBj4mjIiIiAJiVi30MagjIiIiv1yTD3P0a6hj9ysRERFRE8BMHREREQXE7tfQx6COiIiI/HI/+7VeKqagYfcrERERURPATB0REREFxCdKhD5m6oiIiIiaAGbqiIiIyD/heqoEhTYGdUREROSXAKAi+PPUMU4MLna/EhERETUBzNQRERFRQOx+DX0M6oiIiMgvV/crhTp2vxIRERE1AczUERERkV/19kQJCipm6oiIiIiaAGbqiIiIKCAm6kIfgzoiIiLyT7D7tTEIme5Xh8OBJ598El27dkV4eDhSUlIwdOhQHD9+POC+7777Llq3bg2z2YzevXtj8+bNHtvLysowevRoxMXFISIiArfeeitycnLq61SIiIiIzrmQCepKSkqwbds2TJgwAdu2bcMXX3yBPXv24KabbvK736efforx48dj0qRJ2LZtGy666CJkZGQgNzdXKzNu3Dh89dVXWLBgAdauXYvjx4/jlltuqe9TIiIiahIEXPPUBXuh4AqZ7ler1YoVK1Z4rJsxYwYuueQSHD58GC1btvS535tvvokHHngAw4cPBwDMnj0bS5cuxQcffICnnnoKBQUF+Pe//4358+fj2muvBQDMmTMHnTp1wo8//ohLL720fk+MiIioCaiPeeoY1wVXyGTqfCkoKIAkSYiOjva53W63Y+vWrejfv7+2TpZl9O/fHxs3bgQAbN26FQ6Hw6NMx44d0bJlS62ML+Xl5bDZbB4LERERUagK2aCurKwMTz75JO666y5ERUX5LHPy5EkoioLExESP9YmJicjOzgYAZGdnw2g0egWGVcv4MmXKFFitVm1p0aLF2Z0QERFRI+Wepy7YCwVXgwV18+bNQ0REhLZ8//332jaHw4E77rgDQgjMmjWrQdr39NNPo6CgQFuOHDnSIO0gIiIib6+88gokScLYsWO1dbUZGHn48GFkZmYiLCwMCQkJePzxx+F0Oj3KrFmzBhdffDFMJhPatWuHuXPnnoMzOnsNdk/dTTfdhN69e2s/N2/eHEBlQHfo0CGsWrWqxiwdADRr1gw6nc7rDcvJyUFSUhIAICkpCXa7Hfn5+R7ZuqplfDGZTDCZTGdyakRERE1OKCXWfvrpJ/zzn/9Et27dPNaPGzcOS5cuxYIFC2C1WjFmzBjccsst2LBhAwBAURRkZmYiKSkJP/zwA7KysjB06FAYDAa8/PLLAICDBw8iMzMTDz74IObNm4eVK1fi/vvvR3JyMjIyMs75udZFg2XqIiMj0a5dO22xWCxaQLdv3z589913iIuL81uH0WhEeno6Vq5cqa1TVRUrV65Enz59AADp6ekwGAweZfbs2YPDhw9rZYiIiKhmodT9WlRUhMGDB+P9999HTEyMtt49MPLNN9/Etddei/T0dMyZMwc//PADfvzxRwDA8uXLsWvXLnz88cfo3r07/vrXv+KFF17Au+++C7vdDsA14DItLQ1vvPEGOnXqhDFjxuC2227DW2+9dbYvY70LmXvqHA4HbrvtNmzZsgXz5s2DoijIzs5Gdna29kIDQL9+/TBjxgzt5/Hjx+P999/Hhx9+iN27d2PUqFEoLi7WRsNarVaMGDEC48ePx+rVq7F161YMHz4cffr04chXIiKiRmb06NHIzMz0GAAJ1G5g5MaNG9G1a1ePe/EzMjJgs9mwc+dOrUz1ujMyMvwOrgwVITOlybFjx7B48WIAQPfu3T22rV69GldffTUAYP/+/Th58qS27c4778SJEycwceJEZGdno3v37li2bJnHG/bWW29BlmXceuutKC8vR0ZGBmbOnFnv50RERNRUCEj1Uq/dbveaYaKmW6A++eQTbNu2DT/99JPXttoMjMzOzvY5uNK9zV8Zm82G0tJSWCyWup3gORQyQV3r1q0hajET4Z9//um1bsyYMRgzZkyN+5jNZrz77rt49913z6aJRERE5yVRj6NV58yZg/fff99j3aRJk/Dcc895rDty5AgeffRRrFixAmazuX4a08iFTPcrERERnX+GDx/uMdtEQUEBnn76aa9yW7duRW5uLi6++GLo9Xro9XqsXbsW06ZNg16vR2JiojYwsqrqgyd9Da50b/NXJioqKqSzdACDOiIiIqqF+hooYTQaERUV5bH46nrt168ffvvtN2zfvl1bevbsicGDB2v/DjQwsk+fPvjtt988HiW6YsUKREVFoXPnzlqZqnW4yzSGwZUh0/1KREREVJPIyEhceOGFHuvCw8MRFxenrXcPjIyNjUVUVBQefvhhj4GRAwYMQOfOnXHPPfdg6tSpyM7OxrPPPovRo0drgeSDDz6IGTNm4IknnsB9992HVatW4bPPPsPSpUvP7QmfAQZ1RERE5JdAaM1TV5NAAyN1Oh2WLFmCUaNGoU+fPggPD8ewYcMwefJkrUxaWhqWLl2KcePG4Z133kFqair+9a9/hfwcdQCDOiIiIqqF+hgocbZVrlmzxuPn2gyMbNWqFb7++mu/9V599dX4+eefz7J15x7vqSMiIiJqApipIyIiIr9c3a+NoQP2/MagjoiIiPyrr3nqGCcGFbtfiYiIiJoAZuqIiIgoICbVQh8zdURERERNADN1RERE5JdA/T37lYKHQR0REREFJBjUhTx2vxIRERE1AczUERERkV8CgNrQjaCAGNQRERGRX6Ke5qljj25wsfuViIiIqAlgpo6IiIgC4kCJ0MegrpaEdjXzqiYiolDg+j4SjLaoAoO6WiosLKz4F28VJSKi0FFYWAir1Vrvx+G3X+hjUFdLKSkpOHLkCCIjIyFJ0hnXY7PZ0KJFCxw5cgRRUVFBbOG5wfY3rMbefqDxnwPb3/Aa+zkEq/1CCBQWFiIlJSWIravhWGD3a2PAoK6WZFlGampq0OqLiopqlB9Gbmx/w2rs7Qca/zmw/Q2vsZ9DMNp/LjJ01HgwqCMiIqKA2P0a+hjUERERkV+u7lf2v4Y6zlN3jplMJkyaNAkmk6mhm3JG2P6G1djbDzT+c2D7G15jP4fG3n4KXZJg6E1EREQ1mDVrFl4Z9zYy4u4Oet0fZ7+G7zevRXp6etDrPh+x+5WIiIj8EqifWVqZVQoudr8SERERNQHM1BEREVFAKtNqIY+ZurNUVFSEMWPGIDU1FRaLBZ07d8bs2bMD7rdgwQJ07NgRZrMZXbt2xddff+2xXQiBiRMnIjk5GRaLBf3798e+ffvq6zSwe/du3HTTTbBarQgPD0evXr1w+PDhRnUOAPDggw9CkiS8/fbbAcu+++67aN26NcxmM3r37o3Nmzd7bC8rK8Po0aMRFxeHiIgI3HrrrcjJyQlqex0OB5588kl07doV4eHhSElJwdChQ3H8+PFG0f7atKO6ULpupkyZgl69eiEyMhIJCQkYOHAg9uzZE3C/UDqHql555RVIkoSxY8f6LRdK7T927BiGDBmCuLg4WCwWdO3aFVu2bPG7z5o1a3DxxRfDZDKhXbt2mDt3rleZul6XZ0pRFEyYMAFpaWmwWCxo27YtXnjhhYAjRUPpHKjpYFB3lsaPH49ly5bh448/xu7duzF27FiMGTMGixcvrnGfH374AXfddRdGjBiBn3/+GQMHDsTAgQOxY8cOrczUqVMxbdo0zJ49G5s2bUJ4eDgyMjJQVlYW9HPYv38/rrjiCnTs2BFr1qzBr7/+igkTJsBsNjeacwCAhQsX4scff6zV7Oqffvopxo8fj0mTJmHbtm246KKLkJGRgdzcXK3MuHHj8NVXX2HBggVYu3Ytjh8/jltuuSWobS4pKcG2bdswYcIEbNu2DV988QX27NmDm266qVG0vzbtqCrUrpu1a9di9OjR+PHHH7FixQo4HA4MGDAAxcXFNe4Taufg9tNPP+Gf//wnunXr5rdcKLU/Ly8Pl19+OQwGA7755hvs2rULb7zxBmJiYmrc5+DBg8jMzMQ111yD7du3Y+zYsbj//vvx7bffamXqel2ejVdffRWzZs3CjBkzsHv3brz66quYOnUqpk+f3mjOoTYEXJm6YC8UZILOSpcuXcTkyZM91l188cXimWeeqXGfO+64Q2RmZnqs6927t/j73/8uhBBCVVWRlJQkXnvtNW17fn6+MJlM4r///W8QW+9y5513iiFDhtRpn1A7h6NHj4rmzZuLHTt2iFatWom33nrLb/lLLrlEjB49WvtZURSRkpIipkyZorXVYDCIBQsWaGV2794tAIiNGzcGvf1Vbd68WQAQhw4dqrFMqLQ/UDuqC7Xrprrc3FwBQKxdu7bGMqF4DoWFhaJ9+/ZixYoVom/fvuLRRx9tFO1/8sknxRVXXFGnfZ544gnRpUsXj3V33nmnyMjI0H6u63V5NjIzM8V9993nse6WW24RgwcPrnGfUDuHQGbOnClSTR3EsKRJQV/McrjYsmXLOT+npoqZurN02WWXYfHixTh27BiEEFi9ejX27t2LAQMG1LjPxo0b0b9/f491GRkZ2LhxIwDXX3HZ2dkeZaxWK3r37q2VCRZVVbF06VJ06NABGRkZSEhIQO/evbFo0SK/+4XaOdxzzz14/PHH0aVLl4Dl7XY7tm7d6tE2WZbRv39/rW1bt26Fw+HwKNOxY0e0bNky6O2vrqCgAJIkITo6OqTbX5t2VBdK140vBQUFAIDY2Ngay4TiOYwePRqZmZle7fIllNq/ePFi9OzZE7fffjsSEhLQo0cPvP/++2fV/jO5Ls/GZZddhpUrV2Lv3r0AgF9++QXr16/HX//610ZzDtR0MKg7S9OnT0fnzp2RmpoKo9GI6667Du+++y6uuuqqGvfJzs5GYmKix7rExERkZ2dr293raioTLLm5uSgqKsIrr7yC6667DsuXL8ff/vY33HLLLVi7dm2jOIdXX30Ver0ejzzySK3Knzx5EoqiBGy/0Wj0Cqzqo/1VlZWV4cknn8Rdd91V4zMhQ6X9tWlHdaF03VSnqirGjh2Lyy+/HBdeeGGN5ULtHD755BNs27YNU6ZMqVX5UGr/gQMHMGvWLLRv3x7ffvstRo0ahUceeQQffvhhndtvs9lQWlp6Rtfl2XjqqacwaNAgdOzYEQaDAT169MDYsWMxePDgRnMOtSHqoeuV3a/Bx6CuDubNm4eIiAht+f777zF9+nT8+OOPWLx4MbZu3Yo33ngDo0ePxnfffdfQzfWp+jm4bwq/+eabMW7cOHTv3h1PPfUUbrjhhloN+DjXqrd/7dq1eOeddzB37lxIktTQzQvI1zXk5nA4cMcdd0AIgVmzZjVgK89Po0ePxo4dO/DJJ580dFNq7ciRI3j00Ucxb948v/fAhipVVXHxxRfj5ZdfRo8ePTBy5Eg88MADIfnZU5PPPvsM8+bNw/z587Ft2zZ8+OGHeP311/0Gpo2VEMFfOFFdcHFKkzq46aab0Lt3b+3n5s2bo1+/fli4cCEyMzMBAN26dcP27dvx+uuv19gVkpSU5DUKMScnB0lJSdp297rk5GSPMt27dw/qOcTHx0Ov16Nz584e5Tp16oT169fXWE9DnUP19i9YsAC5ublo2bKltk5RFPzf//0f3n77bfz5559edTRr1gw6nS5g++12O/Lz8z2yXVXLBKP9zZs3B1AZ0B06dAirVq2qMUvX0O2vazuqa8hr358xY8ZgyZIlWLduHVJTU/2WDaVz2Lp1K3Jzc3HxxRdr6xRFwbp16zBjxgyUl5dDp9OFbPuTk5N9fvb873//q3GfmtofFRUFi8UCnU5X5+vybDz++ONatg4AunbtikOHDmHKlCkYNmxYozgHajqYqauDyMhItGvXTlscDgccDgdk2fNl1Ol0UFW1xnr69OmDlStXeqxbsWIF+vTpAwBIS0tDUlKSRxmbzYZNmzZpZYJ1DlarFb169fKaxmHv3r1o1apVyJ1D9faPHDkSv/76K7Zv364tKSkpePzxxz1GklVlNBqRnp7u0TZVVbFy5Uqtbenp6TAYDB5l9uzZg8OHDwe1/RaLRQvo9u3bh++++w5xcXF+62jI9te1HdU15LXvixACY8aMwcKFC7Fq1SqkpaUF3CeUzqFfv3747bffPK7/nj17YvDgwdi+fbtXQBdq7b/88suD/tlzJtfl2SgpKQn6d8C5PofaEBBQ62GhIGvggRqNXt++fUWXLl3E6tWrxYEDB8ScOXOE2WwWM2fO1Mrcc8894qmnntJ+3rBhg9Dr9eL1118Xu3fvFpMmTRIGg0H89ttvWplXXnlFREdHiy+//FL8+uuv4uabbxZpaWmitLQ06OfwxRdfCIPBIN577z2xb98+MX36dKHT6cT333/faM6hKl+jX6+99loxffp07edPPvlEmEwmMXfuXLFr1y4xcuRIER0dLbKzs7UyDz74oGjZsqVYtWqV2LJli+jTp4/o06dPUNtqt9vFTTfdJFJTU8X27dtFVlaWtpSXl4d8+wO1I9Svm1GjRgmr1SrWrFnj8dqXlJRoZUL9HKqrPvo1lNu/efNmodfrxUsvvST27dsn5s2bJ8LCwsTHH3+slXnqqafEPffco/184MABERYWJh5//HGxe/du8e677wqdTieWLVumlanN70ewDBs2TDRv3lwsWbJEHDx4UHzxxReiWbNm4oknnmg05xDIzJkzRYqxvbg7YWLQF7PE0a/BxKDuLGVlZYl7771XpKSkCLPZLC644ALxxhtvCFVVtTJ9+/YVw4YN89jvs88+Ex06dBBGo1F06dJFLF261GO7qqpiwoQJIjExUZhMJtGvXz+xZ8+eejuPf//736Jdu3bCbDaLiy66SCxatMhje2M4BzdfQV2rVq3EpEmTPNZNnz5dtGzZUhiNRnHJJZeIH3/80WN7aWmpeOihh0RMTIwICwsTf/vb30RWVlZQ23rw4EH3XSVey+rVq0O+/YHaEerXTU2v/Zw5cxrNOVRXPagL9fZ/9dVX4sILLxQmk0l07NhRvPfeex7bhw0bJvr27euxbvXq1aJ79+7CaDSKNm3aeLxfboF+P4LFZrOJRx99VLRs2VKYzWbRpk0b8cwzz3j8URbq5xCIO6i7K35i0BcTg7qgkoQIMO01ERERnbdmzZqFF8e+hSutdwW97kUn38CGn9YiPT096HWfj3hPHREREVETwNGvRERE5JdrChJ27IU6BnVEREQUECcLDn3sfiUiIiJqApipIyIiIr8EwHnlGgFm6oiIiIiaAGbqiIiIKCCOkwh9DOqIiIjIL8HHejUK7H4loqD797//jQEDBtT7cZYtW4bu3bv7fc4mEdH5gkEdEQVVWVkZJkyYgEmTJtX7sa677joYDAbMmzev3o9FdL5zzVUX5KWhT6qJYVBHREH1+eefIyoqCpdffvk5Od69996LadOmnZNjEZ2v3KNfg70wrAsuBnVE5NOJEyeQlJSEl19+WVv3ww8/wGg0YuXKlTXu98knn+DGG2/0WHf11Vdj7NixHusGDhyIe++9V/u5devWePHFFzF06FBERESgVatWWLx4MU6cOIGbb74ZERER6NatG7Zs2eJRz4033ogtW7Zg//79Z36yRERNAIM6IvIpPj4eH3zwAZ577jls2bIFhYWFuOeeezBmzBj069evxv3Wr1+Pnj17ntEx33rrLVx++eX4+eefkZmZiXvuuQdDhw7FkCFDsG3bNrRt2xZDhw71eFxRy5YtkZiYiO+///6MjklEtSAAVYigLxRcDOqIqEbXX389HnjgAQwePBgPPvggwsPDMWXKlBrL5+fno6CgACkpKWd8vL///e9o3749Jk6cCJvNhl69euH2229Hhw4d8OSTT2L37t3Iycnx2C8lJQWHDh06o2MSETUVDOqIyK/XX38dTqcTCxYswLx582AymWosW1paCgAwm81ndKxu3bpp/05MTAQAdO3a1Wtdbm6ux34WiwUlJSVndEwiCkzU038UXAzqiMiv/fv34/jx41BVFX/++affsnFxcZAkCXl5eQHrVRTFa53BYND+LUlSjeuqT2Fy+vRpxMfHBzwmEZ05tR4WCi4GdURUI7vdjiFDhuDOO+/ECy+8gPvvv98rS1aV0WhE586dsWvXLq9t1btMDxw4EJQ2lpWVYf/+/ejRo0dQ6iMiaqwY1BFRjZ555hkUFBRg2rRpePLJJ9GhQwfcd999fvfJyMjA+vXrvdZ/+eWX+OKLL7B//3689NJL2LVrFw4dOoRjx46dVRt//PFHmEwm9OnT56zqIaKa1d+UJhRMDOqIyKc1a9bg7bffxkcffYSoqCjIsoyPPvoI33//PWbNmlXjfiNGjMDXX3+NgoICj/WZmZmYOnUqOnfujHXr1mHmzJnYvHkzPvroo7Nq53//+18MHjwYYWFhZ1UPEfknhAj6QsHFZ78SkU9XX301HA6Hx7rWrVt7BWvVde7cGZmZmZg5cyaefvppbX3z5s2xYMECj7KjRo3S/u3rfr3qH/qtW7f2WHfy5El8/vnnXnPXERGdj5ipI6Kge+211xAREVHvx/nzzz8xc+ZMpKWl1fuxiM5n9dX9ylxdcDFTR0RB17p1azz88MP1fpyePXue8UTHRERNDYM6Iqp3a9asaegmENFZ4cCGxoBBHREREfkl4ArrKLTxnjoiIiKiJoCZOiIiIgqA3a+NAYM6IiIi8ss9+pVCG7tfiYiIiJoAZuqIiIgoAAG1XgZKMPsXTMzUERERETUBDOqIiIjILwFASGrQl7qYMmUKevXqhcjISCQkJGDgwIHYs2ePR5mysjKMHj0acXFxiIiIwK233oqcnByPMocPH0ZmZibCwsKQkJCAxx9/HE6n06PMmjVrcPHFF8NkMqFdu3aYO3fumbxs5xyDOiIiIgqooR8TtnbtWowePRo//vgjVqxYAYfDgQEDBqC4uFgrM27cOHz11VdYsGAB1q5di+PHj+OWW27RtiuKgszMTNjtdvzwww/48MMPMXfuXEycOFErc/DgQWRmZuKaa67B9u3bMXbsWNx///349ttvg/Ey1itJVH9iNhEREVGFWbNm4R+PTEWHiMyg172t4AP8+NP3SE9Pr/O+J06cQEJCAtauXYurrroKBQUFiI+Px/z583HbbbcBAH7//Xd06tQJGzduxKWXXopvvvkGN9xwA44fP47ExEQAwOzZs/Hkk0/ixIkTMBqNePLJJ7F06VLs2LFDO9agQYOQn5+PZcuWBefE6wkzdUREROSXqBgoEez/AMBut8Nms3ks5eXlAdtUUFAAAIiNjQUAbN26FQ6HA/3799fKdOzYES1btsTGjRsBABs3bkTXrl21gA4AMjIyYLPZsHPnTq1M1TrcZdx1hDIGdURERBSAqIfOV1dQN2fOHFitVo9lypQpflujqirGjh2Lyy+/HBdeeCEAIDs7G0ajEdHR0R5lExMTkZ2drZWpGtC5t7u3+Stjs9lQWlp6Zi/fOcIpTYiIiKjBDB8+HK+//rrHOpPJ5Hef0aNHY8eOHVi/fn19Nq3RYVBHREREfgkJUOs4WrW2jEYjoqKial1+zJgxWLJkCdatW4fU1FRtfVJSEux2O/Lz8z2ydTk5OUhKStLKbN682aM+9+jYqmWqj5jNyclBVFQULBZLnc7tXGP3KxEREYU8IQTGjBmDhQsXYtWqVUhLS/PYnp6eDoPBgJUrV2rr9uzZg8OHD6NPnz4AgD59+uC3335Dbm6uVmbFihWIiopC586dtTJV63CXcdcRypipIyIiogAa/okSo0ePxvz58/Hll18iMjJSuwfOarXCYrHAarVixIgRGD9+PGJjYxEVFYWHH34Yffr0waWXXgoAGDBgADp37ox77rkHU6dORXZ2Np599lmMHj1a6/J98MEHMWPGDDzxxBO47777sGrVKnz22WdYunRp8E8/yBjUERERkV8CqKegrvZmzZoFALj66qs91s+ZMwf33nsvAOCtt96CLMu49dZbUV5ejoyMDMycOVMrq9PpsGTJEowaNQp9+vRBeHg4hg0bhsmTJ2tl0tLSsHTpUowbNw7vvPMOUlNT8a9//QsZGRn1fo5ni/PUERERUY1mzZqFJx+dgtYR/QMXrqPd+f/Fjz+tP6N56sgbM3VEREQUgNCmIAlurRRMDOqIiIjIL1dIpzR0MygAjn4lIiIiagKYqSMiIqIA6qf7lYKLmToiIiKiJoCZOiIiIvJLoL6eKMGhEsHEoI6IiIgC4ECJxoDdr0RERERNADN1RERE5JfgQIlGgUEdERERBSCgCna/hjp2vxIRERE1AczUERERkV8CqKfHhHH0azAxU0dERETUBDBTR0RERAEICE5pEvIY1BEREZFfrrGvHP0a6tj9SkRERNQEMFNHREREAXGeutDHoI6IiIj8EwKC89SFPHa/EhERETUBzNQRERGRX/U3UILz1AUTM3VERERETQAzdURERBQA56lrDBjUERERUUBCcPRrqGP3KxEREVETwEwdERER+VVfAyU4TCK4GNQRERFRAJynrjFg9ysRERFRE8BMHREREfklUF+PCWMHbDAxU0dERETUBDBTR0RERP4JwSlNGgEGdURERBQAJx9uDNj9SkRERNQEMFNHREREAbH7NfQxqCMiIiK/BOrpnjoOfg0qdr8SERERNQHM1BEREVEA9fOYMKbqgouZOiIiIqImgJk6IiIi8ksIDpRoDBjUERERUQACQnCeulDH7lciIiKiJoCZOiIiIgpAQNTDQAkOkwguBnVERETklwDvqWsM2P1KRERE1AQwU0dEREQB1NMTJdgBG1TM1BERERE1AczUERERUQD1M1CCgotBHREREfnHyYcbBXa/EhERETUBzNQRERGRX6LeBkpQMDGoIyIiolpgUBfq2P1KRERE1AQwU0dEREQBcJ66xoCZOiIiIqImgJk6IiIiCoDz1DUGDOqIiIjIL8F56hoFdr8SERERNQHM1BEREVEAAoDS0I2gABjUERERUQCcfLgxYPcrERERURPATB0RERHVAuepC3XM1BERERE1AczUERERUQAC4D11IY9BHREREQUk2FUa8tj9SkRERNQEMFNHREREAQjUz0AJCiYGdURERBSYYPdrqGP3KxEREVETwEwdERERBcSBEqGPmToiIiKqkdFohOueumAHda76TCZTkOs9f0lCsJOciIiIfLPZbLBarXDlgYKZC1IACKiqCkmSgljv+YuZOiIiIqpRVFQUZsyYAdfo12DlgVyZv82bNzOgCyJm6oiIiMgvh8NR0Q0brGydAgAQfEpFUDFTR0RERH4ZDAZ88cUXCE62zpWlO3Bg/9k3jDwwU0dEREQBCSEgyzIACYDuLGpilq6+MFNHREREAUmShB9++AFnNxLWlek7depk8BpGGmbqiIiIqNYkyZ0Pqmu2TsCVpZMhhBLcRhEAZuqIiIioDvbt24szy9a5ypeWFge7SVSBQR0RERHVWrt27eC6r64u98QJACrmzZsHs9lcPw0jdr8SERFR3Zw8eRLx8fGo/RQnKgAViqJUDLag+sBXloiIiOqkWbNmcIUQtZnixJWlW7VqFQO6esZMHREREdVZaWkpwsLCEDhbxylMzhWGzERERFRnFosFH374Ifxn61wDKnbu3HHuGnYeY6aOiIiIzoiiKNDr9ag5W8cs3bnETB0RERGdEZ1Oh+XLl8N3ts6VpTt+/Ni5b9h5ipk6IiIiOiveExK7JxqWmKU7h5ipIyIiorPyyy/b4Tkhsev/hYW2BmrR+YlBHREREZ2Vbt26oXJCYtcUJrNnz0ZERETDNuw8w+5XIiIiOmtHjx5FixYt4AruBBwOR8UgCjpXmKkjIiKis5aamgp3QLd48WIGdA2ArzgREREFRWGhDZs3b8Y111zT0E05L7H7lYiIiKgJYPcrERERURPAoI6IiIioCWBQR0RERNQEMKgjIiIiagIY1BERERE1AQzqiIiIiJoABnVERERETQCDOiIiIqIm4P8BCXF6LshEJBcAAAAASUVORK5CYII=",
"text/plain": [
"
"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"sim_data.plot_field(\n",
" \"fieldProfileMon\",\n",
" \"Ey\",\n",
" val=\"abs\",\n",
" z=0,\n",
" t=sim_data[\"fieldProfileMon\"].Ez.t[-1],\n",
")\n",
"plt.show()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Resonance and Q-factor Analysis\n",
"\n",
"Next, we will collect the data for the point field monitors and use the `ResonanceFinder` plugin that implements the harmonic-inversion algorithm, which is a convenient technique to analyze exponential decaying fields, allowing us to get Q-factor information with a relatively short simulation time.\n",
"\n",
"For high Q-factor cavities (greater than $10^6$) a larger run time may be needed, as well as fine-tuning of the `freq_window` parameters, which is the frequency window where the resonances will be analyzed. \n",
"\n",
"Since the harmonic-inversion technique is valid for exponential decaying fields, we will only analyze the data after the sources decay. For high Q-factors, we usually want to analyze as much data as possible. Therefore, we apply a time filter to the fields signal now, allowing more flexibility to adjust the portion of the fields we want to analyze. An alternative approach is to set the `start` argument while defining the `FieldTimeMonitor` as show in other [example](https://www.flexcompute.com/tidy3d/examples/notebooks/ResonanceFinder/)."
]
},
{
"cell_type": "code",
"execution_count": 15,
"metadata": {},
"outputs": [],
"source": [
"def analyse_resonance_monitors(sim_data, start_time=1e-12, freq_window=None):\n",
" # importing needed libraries\n",
" from tidy3d.plugins.resonance import ResonanceFinder\n",
"\n",
" combinedSignal = 0\n",
" polarization = sim_data.simulation.sources[0].polarization\n",
"\n",
" # iterate through all monitors and combine the signal\n",
" i = 0\n",
" name = f\"pointMon{i}\"\n",
" while name in sim_data.monitor_data:\n",
" combinedSignal += sim_data[\"pointMon0\"].field_components[polarization].squeeze()\n",
" i += 1\n",
" name = f\"pointMon{i}\"\n",
"\n",
" # create the ResonanceFinder instance\n",
" rf = ResonanceFinder(freq_window=freq_window)\n",
"\n",
" # boolean mask to set the data after source decay\n",
" bm = combinedSignal.t >= start_time\n",
"\n",
" # data containing the resonance information\n",
" data = rf.run_raw_signal(combinedSignal[bm], sim_data.simulation.dt)\n",
"\n",
" # creating a DataFrame\n",
" df = data.to_dataframe()\n",
" df[\"wl\"] = (td.C_0 / df.index) * 10**3\n",
"\n",
" return df, combinedSignal"
]
},
{
"cell_type": "code",
"execution_count": 16,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"
\n",
"\n",
"
\n",
" \n",
"
\n",
"
\n",
"
decay
\n",
"
Q
\n",
"
amplitude
\n",
"
phase
\n",
"
error
\n",
"
wl
\n",
"
\n",
"
\n",
"
freq
\n",
"
\n",
"
\n",
"
\n",
"
\n",
"
\n",
"
\n",
"
\n",
" \n",
" \n",
"
\n",
"
1.941258e+14
\n",
"
7.709018e+07
\n",
"
7.911051e+06
\n",
"
63674.827463
\n",
"
0.989458
\n",
"
0.00361
\n",
"
1544.32022
\n",
"
\n",
" \n",
"
\n",
"
"
],
"text/plain": [
" decay Q amplitude phase error \\\n",
"freq \n",
"1.941258e+14 7.709018e+07 7.911051e+06 63674.827463 0.989458 0.00361 \n",
"\n",
" wl \n",
"freq \n",
"1.941258e+14 1544.32022 "
]
},
"execution_count": 16,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# defining the frequency window\n",
"freq0 = sim_data.simulation.sources[0].source_time.freq0\n",
"fwidth = sim_data.simulation.sources[0].source_time.fwidth\n",
"freq_window = (freq0 - fwidth / 2, freq0 + fwidth / 2)\n",
"\n",
"# start time to analyze the exponential decaying fields after source decay\n",
"start_time = 2 * find_source_decay(\n",
" sim.sources[0],\n",
")\n",
"\n",
"df, signal = analyse_resonance_monitors(sim_data, start_time, freq_window)\n",
"df.head(10)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"We note that the Q-factor is close of the one reported by the [paper](https://doi.org/10.1063/1.3107263). The resonance frequency is a few nanometers different, although this is due to the different taper function used in this notebook. In the paper, the tapering function is linear."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Mode Volume Calculation\n",
"\n",
"The mode volume will be calculated by the definition:\n",
"\n",
"$V_{eff} = \\frac{\\int\\varepsilon(r)|E(r)|^{2}d^{3}r}{max[\\varepsilon(r)|E(r)|^{2}(r)]}$,\n",
"\n",
"where $\\varepsilon(r)$ is the cavity permittivity distribution, which can be obtained from the simulation object.\n",
"\n",
"First, we will define a function to compute the energy density from the time field monitor, defining it as the temporal mean of the last two field oscillations. This approach ensures that we can estimate the mode volume without prior knowledge of the resonant frequency."
]
},
{
"cell_type": "code",
"execution_count": 17,
"metadata": {},
"outputs": [],
"source": [
"def get_energy_density(sim_data):\n",
" # retrieving monitor data\n",
" Efield = sim_data[\"fieldTimeMon\"]\n",
"\n",
" # retrieving permittivity data and interpolating it at the same grid points of the monitor data\n",
" eps = abs(sim.epsilon(box=td.Box(center=(0, 0, 0), size=(td.inf, td.inf, td.inf))))\n",
" eps = eps.interp(coords=dict(x=Efield.Ex.x, y=Efield.Ex.y, z=Efield.Ex.z))\n",
"\n",
" # calculating the energy density\n",
" energy_density = np.abs(Efield.Ex**2 + Efield.Ey**2 + Efield.Ez**2) * eps\n",
"\n",
" # calculating the temporal mean value\n",
" delta_t = energy_density.t[-1] - energy_density.t[0] # signal duration\n",
" energy_density_temporal_mean = energy_density.integrate(coord=(\"t\")) / delta_t\n",
"\n",
" return energy_density_temporal_mean, eps\n",
"\n",
"\n",
"energy_density, eps = get_energy_density(sim_data)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Now we will calculate the mode volume. As we can note, the value is close to $0.39 (\\frac{\\lambda}{n})^3$, as reported in the paper. \n",
"\n",
"It is important to note that mode volume values $<< 1$ are most like due to the absence of a resonance, hence the field integral would be near to zero."
]
},
{
"cell_type": "code",
"execution_count": 18,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Mode volume: 0.38 (lambda/n)^3\n"
]
}
],
"source": [
"def mode_volume(energy_density, eps):\n",
" # volume integral of the energy density\n",
" Integrated = np.abs(energy_density).integrate(coord=(\"x\", \"y\", \"z\"))\n",
"\n",
" # scaling factor to present in common units of (wl/n)^3\n",
" wl = abs(df.sort_values(\"Q\").iloc[-1][\"wl\"] / 1000) # um\n",
" index = np.sqrt(abs(eps.max()))\n",
"\n",
" Vmode = Integrated / np.max(energy_density) / (wl / index) ** 3\n",
"\n",
" return Vmode\n",
"\n",
"\n",
"Vmode = mode_volume(energy_density, eps)\n",
"print(f\"Mode volume: {Vmode:.2f} (lambda/n)^3\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Reducing Memory Usage for Mode Volume Calculation\n",
"\n",
"When calling `Efield = sim_data[\"fieldTimeMon\"]` in the `get_energy_density` function, a copy of the raw field monitor is created and expanded to symmetric coordinates, which increases memory usage.\n",
"\n",
"To reduce memory usage during mode volume calculation, one can use the raw fields without symmetry expansion and multiply the result by 8, since the integration is performed over only 1/8 of the total volume. The results may differ slightly due to the central coordinate being included in the reduced domain, which causes the central point to be overcounted in the integration. However, this does not substantially affect the results."
]
},
{
"cell_type": "code",
"execution_count": 19,
"metadata": {},
"outputs": [],
"source": [
"def get_energy_density_raw_data(sim_data):\n",
" # retrieving monitor data\n",
" Efield = sim_data.monitor_data[\"fieldTimeMon\"]\n",
"\n",
" # retrieving permittivity data and interpolating it at the same grid points of the monitor data\n",
" eps = abs(sim.epsilon(box=td.Box(center=(0, 0, 0), size=(td.inf, td.inf, td.inf))))\n",
" eps = eps.interp(coords=dict(x=Efield.Ex.x, y=Efield.Ex.y, z=Efield.Ex.z))\n",
"\n",
" # calculating the energy density\n",
" energy_density = np.abs(Efield.Ex**2 + Efield.Ey**2 + Efield.Ez**2) * eps\n",
"\n",
" # calculating the temporal mean value\n",
" delta_t = energy_density.t[-1] - energy_density.t[0] # signal duration\n",
" energy_density_temporal_mean = energy_density.integrate(coord=(\"t\")) / delta_t\n",
"\n",
" return energy_density_temporal_mean, eps\n",
"\n",
"\n",
"energy_density2, eps2 = get_energy_density_raw_data(sim_data)"
]
},
{
"cell_type": "code",
"execution_count": 20,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Mode volume: 0.37 (lambda/n)^3\n"
]
}
],
"source": [
"Vmode2 = 8 * mode_volume(energy_density2, eps2)\n",
"print(f\"Mode volume: {Vmode2:.2f} (lambda/n)^3\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Directional Q-factor Calculation\n",
"\n",
"We can decompose the total Q-factor into its directional contributions:\n",
"\n",
"$Q^{-1} = Q_x^{-1} + Q_{-x}^{-1} +Q_y^{-1} + Q_{-y}^{-1} +Q_z^{-1} + Q_{-z}^{-1}$\n",
"\n",
"This provides useful information for understanding the contribution of scattered losses ($z$ and $y$ directions) and waveguide losses ($x$ direction), which are due to fields that penetrate the Bragg mirror and propagate into the nanobeam slab. If the cavity is to be coupled to an optical fiber, it is desirable that the main direction of losses be waveguide losses in the direction of the fiber.\n",
"\n",
"To illustrate the directional Q-factor calculation we will run the simulation again using an asymmetric number of unit cells, and an output tapering region."
]
},
{
"cell_type": "code",
"execution_count": 21,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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",
"text/plain": [
"
16:08:58 CEST Maximum FlexCredit cost: 0.179. Minimum cost depends on task \n",
"execution details. Use 'web.real_cost(task_id)' to get the billed \n",
"FlexCredit cost after a simulation run. \n",
"
\n"
],
"text/plain": [
"\u001b[2;36m16:08:58 CEST\u001b[0m\u001b[2;36m \u001b[0mMaximum FlexCredit cost: \u001b[1;36m0.179\u001b[0m. Minimum cost depends on task \n",
"\u001b[2;36m \u001b[0mexecution details. Use \u001b[32m'web.real_cost\u001b[0m\u001b[32m(\u001b[0m\u001b[32mtask_id\u001b[0m\u001b[32m)\u001b[0m\u001b[32m'\u001b[0m to get the billed \n",
"\u001b[2;36m \u001b[0mFlexCredit cost after a simulation run. \n"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/html": [
"
To cancel the simulation, use 'web.abort(task_id)' or \n",
"'web.delete(task_id)' or abort/delete the task in the web UI. \n",
"Terminating the Python script will not stop the job running on the\n",
"cloud. \n",
"
\n"
],
"text/plain": [
"\u001b[2;36m \u001b[0m\u001b[2;36m \u001b[0mTo cancel the simulation, use \u001b[32m'web.abort\u001b[0m\u001b[32m(\u001b[0m\u001b[32mtask_id\u001b[0m\u001b[32m)\u001b[0m\u001b[32m'\u001b[0m or \n",
"\u001b[2;36m \u001b[0m\u001b[32m'web.delete\u001b[0m\u001b[32m(\u001b[0m\u001b[32mtask_id\u001b[0m\u001b[32m)\u001b[0m\u001b[32m'\u001b[0m or abort/delete the task in the web UI. \n",
"\u001b[2;36m \u001b[0mTerminating the Python script will not stop the job running on the\n",
"\u001b[2;36m \u001b[0mcloud. \n"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"application/vnd.jupyter.widget-view+json": {
"model_id": "61b8d1d912134d81a2b0fcaf63defc4c",
"version_major": 2,
"version_minor": 0
},
"text/plain": [
"Output()"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/html": [
"\n"
],
"text/plain": []
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/html": [
"
16:14:08 CEST WARNING: Simulation final field decay value of 0.0561 is greater \n",
"than the simulation shutoff threshold of 1e-05. Consider running \n",
"the simulation again with a larger 'run_time' duration for more \n",
"accurate results. \n",
"
\n"
],
"text/plain": [
"\u001b[2;36m16:14:08 CEST\u001b[0m\u001b[2;36m \u001b[0m\u001b[31mWARNING: Simulation final field decay value of \u001b[0m\u001b[1;36m0.0561\u001b[0m\u001b[31m is greater \u001b[0m\n",
"\u001b[2;36m \u001b[0m\u001b[31mthan the simulation shutoff threshold of \u001b[0m\u001b[1;36m1e-05\u001b[0m\u001b[31m. Consider running \u001b[0m\n",
"\u001b[2;36m \u001b[0m\u001b[31mthe simulation again with a larger \u001b[0m\u001b[32m'run_time'\u001b[0m\u001b[31m duration for more \u001b[0m\n",
"\u001b[2;36m \u001b[0m\u001b[31maccurate results. \u001b[0m\n"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"asymmetric_sim_data = web.run(asymmetric_sim, task_name=\"asymmetric_ellipse_nanobeam\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"First, we will plot the fields and recalculate the Q-factor and mode volume."
]
},
{
"cell_type": "code",
"execution_count": 23,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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",
"text/plain": [
"
"
],
"text/plain": [
" decay Q amplitude phase error \\\n",
"freq \n",
"1.941612e+14 1.635266e+08 3.730129e+06 18817.985879 -2.816392 0.000098 \n",
"\n",
" wl \n",
"freq \n",
"1.941612e+14 1544.038947 "
]
},
"execution_count": 24,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"asymmetric_energy_density, asymmetric_eps = get_energy_density(asymmetric_sim_data)\n",
"asymmetric_Vmode = mode_volume(asymmetric_energy_density, eps)\n",
"\n",
"print(f\"Mode volume: {asymmetric_Vmode:.2f} (lambda/n)^3\")\n",
"\n",
"asymmetric_df, asymmetric_signal = analyse_resonance_monitors(\n",
" asymmetric_sim_data, start_time, freq_window\n",
")\n",
"asymmetric_df.head()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Direction Q-factor definition\n",
"\n",
"To calculate the directional Q-factors, we will use the definition:\n",
"\n",
"$Q^i = \\omega \\frac{U_{stored}}{U^i_{lost}}$\n",
"\n",
"Where $U_{stored}$ is the total energy in the resonator and $U^i_{lost}$ is the energy leaking from the resonator in one oscillation of the field at coordinate $i$. The energy stored is calculated by integrating the energy density. The energy leaving in each direction is calculated as the temporal mean of the flux monitors around the simulation domain."
]
},
{
"cell_type": "code",
"execution_count": 25,
"metadata": {},
"outputs": [],
"source": [
"def get_directional_Q(sim_data, energy_density, resonant_frequency):\n",
" dict_fluxes = {}\n",
"\n",
" omega = 2 * np.pi * resonant_frequency\n",
"\n",
" # calculating the total energy\n",
" Energy = td.EPSILON_0 * np.abs(energy_density).integrate(coord=(\"x\", \"y\", \"z\"))\n",
"\n",
" # iterating through all flux monitors and calculating the Q factor\n",
" for coord in [\"x\", \"y\", \"z\"]:\n",
" for direction in [\"\", \"-\"]:\n",
" delta_t = sim_data[direction + coord].flux.t[-1] - sim_data[direction + coord].flux.t[0]\n",
" flux = abs(sim_data[direction + coord].flux.integrate(coord=\"t\")) / delta_t\n",
" dict_fluxes[direction + coord] = (omega * Energy / flux).values\n",
"\n",
" # estimating the total Q as the contributions of all directional Q factors\n",
" totalQ = sum([1 / i for i in dict_fluxes.values()]) ** -1\n",
" dict_fluxes[\"total Q\"] = totalQ\n",
"\n",
" return dict_fluxes"
]
},
{
"cell_type": "code",
"execution_count": 26,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Q x = 2.69 MM\n",
"Q -x = 81.60 MM\n",
"Q y = 16.45 MM\n",
"Q -y = 16.45 MM\n",
"Q z = 18.06 MM\n",
"Q -z = 18.06 MM\n",
"Q total Q = 1.62 MM\n"
]
}
],
"source": [
"resonant_frequency = abs(df.sort_values(\"Q\").index[0])\n",
"directional_Q = get_directional_Q(\n",
" asymmetric_sim_data, asymmetric_energy_density, resonant_frequency\n",
")\n",
"\n",
"for i in directional_Q.keys():\n",
" print(f\"Q {i} = {directional_Q[i] * 10**-6:.2f} MM\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"We can note that the x+ directional Q is lower than all the others, indicating that this is a preferential loss path. Also, the total Q calculated as the sum of all directional components agrees well with the one obtained using `ResonanceFinder`."
]
}
],
"metadata": {
"applications": [
"Passive photonic integrated circuit components",
"Photonic crystals",
"Quantum emitters"
],
"description": "This notebook demonstrates how to run an FDTD simulation of a nanobeam cavity using Tidy3D.",
"feature_image": "./img/NanobeamCavity_1.png",
"features": [
"Resonance finder"
],
"kernelspec": {
"display_name": "Python 3 (ipykernel)",
"language": "python",
"name": "python3"
},
"keywords": "nanobeam, photonic crystal cavity, photonics, optical cavity, optical resonantor, 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": "How to model a nanobeam cavity using Tidy3D | Flexcompute"
},
"nbformat": 4,
"nbformat_minor": 4
}
![\"Schematic](\"img/NanobeamCavity_1.png\")
\n",
"\n",
"\n",
"For more information, please refer to our [learning center](https://www.flexcompute.com/tidy3d/examples/), where you can find tutorials and examples on how to carry out [band structure calculation](https://www.flexcompute.com/tidy3d/examples/notebooks/Bandstructure/), use the [resonance finder plugin](https://www.flexcompute.com/tidy3d/examples/notebooks/ResonanceFinder/) and how to calculate [Q-factor and mode volume for a 2D photonic crystal cavity](https://www.flexcompute.com/tidy3d/examples/notebooks/CavityFOM/)\n"
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [],
"source": [
"from typing import Callable\n",
"\n",
"import matplotlib.pyplot as plt\n",
"import numpy as np\n",
"import tidy3d as td\n",
"from tidy3d import web\n",
"\n",
"# defining a random seed for reproducibility\n",
"np.random.seed(12)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Auxiliary Functions\n",
"\n",
"We will start defining some auxiliary functions to help us set up the simulation.\n",
"\n",
"Since for using the [resonance finder plugin](https://www.flexcompute.com/tidy3d/examples/notebooks/ResonanceFinder/) it is necessary to analyze the fields after the source decays, we will define a simple function to estimate the decay time of the source, given the relation of the temporal width ($\\Delta t$) and the spectral linewidth ($\\Delta \\nu$) of a gaussian pulse $\\Delta t \\Delta \\nu \\approx 0.44$, and the `offset` attribute of the `source_time`object."
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [],
"source": [
"def find_source_decay(source):\n",
" # source bandwidth\n",
" fwidth = source.source_time.fwidth\n",
"\n",
" # time offset to start the source\n",
" time_offset = source.source_time.offset / (2 * np.pi * fwidth)\n",
"\n",
" # time width for a gaussian pulse\n",
" pulse_time = 0.44 / fwidth\n",
"\n",
" decay_time = time_offset + pulse_time\n",
" return decay_time"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Next, we will define the function to return the tapered parameter as a function of the unit cell position. A given parameter in the tapered region will follow the definition:\n",
"\n",
"$P_{tapered}(x) = P[1 - M_d(2x^3 -3x^2 + 1)]$\n",
"\n",
"Where $x \\equiv \\frac{\\text{unit cell index}}{\\text{number of tapered unit cells}}$, and the unit cell at the center is indexed as 0. Hence $x$ ranges from 0 to 1, so the center unit cell would have a given parameter as $P(1- M_d)$.\n",
"\n",
"The $M_d$ parameter is a number ranging from $[0,1)$ and is interpreted as the maximum reduction of a given parameter, in proportion to its original value. For example, $M_d = 0.3$ means that the smallest value of this parameter will be 30% less than its original value.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {},
"outputs": [],
"source": [
"def taper_factor(\n",
" max_dip,\n",
" structure_index,\n",
" n_tapered_structures,\n",
" cubic_factor=2,\n",
" quadratic_factor=-3,\n",
" linear_factor=0,\n",
" offsetFactor=1,\n",
"):\n",
" cubic = cubic_factor\n",
" quadratic = quadratic_factor\n",
" linear = linear_factor\n",
" offset = offsetFactor\n",
"\n",
" \"\"\"\n",
" Compute a taper factor using a cubic polynomial.\n",
"\n",
" Parameters:\n",
" - max_dip: float, maximum dip in taper factor.\n",
" - structure_index: int, index of the current structure.\n",
" - n_tapered_structures: int, total number of tapered structures.\n",
" - cubic_factor: float, coefficient for cubic term (default 2).\n",
" - quadratic_factor: float, coefficient for quadratic term (default -3).\n",
" - linear_factor: float, coefficient for linear term (default 0).\n",
" - offsetFactor: float, constant offset (default 1).\n",
"\n",
" Returns:\n",
" - float, the taper factor for the given structure.\n",
" \"\"\"\n",
"\n",
" # to avoid division for 0 in a case where there is no tapered region\n",
" if n_tapered_structures == 0:\n",
" x = 1\n",
" else:\n",
" x = structure_index / np.ceil(n_tapered_structures / 2)\n",
"\n",
" # factor is 1 if the structure is not in the tapered region\n",
" factor = 1 if x >= 1 else 1 - max_dip * (cubic * x**3 + quadratic * x**2 + linear * x + offset)\n",
"\n",
" return factor"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"To reduce the computational cost, we can exploit mirror symmetries of the problem to reduce the computational size up to 8 times. However, to properly set the symmetries parity, it is necessary to consider the polarization and vectorial nature of the fields. For more information on how to set up symmetries and their relation with source polarization, please refer to our [symmetries tutorial](https://www.flexcompute.com/tidy3d/examples/notebooks/Symmetry/).\n",
"\n",
"The function defined below will generate the right symmetry parity for a given polarization."
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [],
"source": [
"def get_symmetry(polarization):\n",
" if polarization == \"Ex\":\n",
" sym = [-1, 1, 1]\n",
" elif polarization == \"Ey\":\n",
" sym = [1, -1, 1]\n",
" elif polarization == \"Ez\":\n",
" sym = [1, 1, -1]\n",
" elif polarization == \"Hz\":\n",
" sym = [-1, -1, 1]\n",
" elif polarization == \"Hy\":\n",
" sym = [-1, 1, -1]\n",
" elif polarization == \"Hx\":\n",
" sym = [1, -1, -1]\n",
" return sym"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Simulation Setup\n",
"\n",
"Now, we will start creating functions to set up the simulation.\n",
"\n",
"First, we will define a function that creates a stack of unit cells on one side of the nanobeam, positioning them correctly and defining the appropriate tapered parameter. Since unit cell assembly is consistent across different types, the function will accept a `unit_cell_function` argument, which returns the unit cell geometry. Additionally, it requires a list of original parameter arguments (`original_params`) and a list of the $Md$ parameters (`max_dip_params`).\n",
"\n",
"\n",
"Note that `n_tapered_structures` refers to the total number of tapered unit cells on both sides of the nanobeam. Hence, if there is an odd number of unit cells, the first one is exactly in the middle. Otherwise, it is separated by a lattice constant from its twin on the other side, plus a gap (`central_gap` argument). The definition of `n_constant_structures` refers to the mirror cells on each side."
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [],
"source": [
"def assemble_unit_cells(\n",
" unit_cell_function: Callable,\n",
" lattice_constant: float,\n",
" max_dip_lattice: float,\n",
" n_constant_structures: int,\n",
" n_tapered_structures: int,\n",
" original_params: list,\n",
" max_dip_params: list,\n",
" central_gap: float = 0,\n",
"):\n",
" \"\"\"\n",
" Assemble unit cells into a structure with tapered lattice constants and parameters.\n",
"\n",
" Parameters:\n",
" - unit_cell_function: callable, function to generate a unit cell given position and parameters.\n",
" - lattice_constant: float, base lattice constant for the unit cells.\n",
" - max_dip_lattice: float, maximum dip for tapering the lattice constant.\n",
" - n_constant_structures: int, number of constant lattice structures on either side.\n",
" - n_tapered_structures: int, total number of tapered structures.\n",
" - original_params: list of floats, original parameters to be tapered (default empty list).\n",
" - max_dip_params: list of floats, maximum dips for each parameter to be tapered (default empty list).\n",
" - central_gap: float, gap between central unit cells (only valid for an odd number of tapered structures).\n",
"\n",
" Returns:\n",
" - unit_cells: combined unit cells as generated by the unit_cell_function.\n",
" - pos_x: final position of the last unit cell in the x-direction.\n",
" \"\"\"\n",
"\n",
" unit_cells = None\n",
"\n",
" # start position\n",
" pos_x = 0\n",
"\n",
" # defining the number of unit cells for each side\n",
" positions = range(\n",
" n_constant_structures + int(np.floor(n_tapered_structures / 2)) + n_constant_structures % 2\n",
" )\n",
"\n",
" # iterating over the unit cells\n",
" previous_lattice_constant = 0\n",
" for i in positions:\n",
" # defining the current value of the unit cell given the position\n",
" current_lattice_constant = lattice_constant * taper_factor(\n",
" max_dip_lattice, i, n_tapered_structures\n",
" )\n",
"\n",
" # condition for odd or even number of unit cells\n",
" if i == 0:\n",
" if n_tapered_structures % 2 != 0:\n",
" pos_x = 0\n",
" else:\n",
" pos_x = central_gap / 2 + current_lattice_constant / 2\n",
" else:\n",
" pos_x += current_lattice_constant / 2 + previous_lattice_constant / 2\n",
"\n",
" # now we create a list of parameters to input to the unit_cell_function\n",
" parameters = []\n",
" for idx in range(len(original_params)):\n",
" original = original_params[idx]\n",
" max_dip = max_dip_params[idx]\n",
" tapered_param = original * taper_factor(max_dip, i, n_tapered_structures)\n",
" parameters.append(tapered_param)\n",
"\n",
" # defining the center\n",
" center = (pos_x, 0, 0)\n",
"\n",
" # creating the unit cell calling the unit_cell_function\n",
" new_unit_cell = unit_cell_function(center, *parameters)\n",
"\n",
" # adding the unit cell to the geometry (or initializing the variable if is the first unit cell)\n",
" unit_cells = new_unit_cell if unit_cells is None else unit_cells + new_unit_cell\n",
"\n",
" # the separation to the next unit cell is the mean value of the lattice constants of the current and next unit cells\n",
" previous_lattice_constant = current_lattice_constant\n",
"\n",
" # return the geometry and the position of the last unit cell\n",
" return unit_cells, pos_x"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Unit Cell Functions\n",
"\n",
"As an example, we will create 3 different unit cell functions. The first two are simple functions to return elliptical and square unit cells. The third one is an example of more complex geometry using the [PolySlab](https://docs.flexcompute.com/projects/tidy3d/en/latest/api/_autosummary/tidy3d.PolySlab.html).\n",
"\n",
"Given the definition `assemble_unit_cells` function, the first argument must be the center of the geometry object, and non-taper parameters must be passed as default arguments."
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [],
"source": [
"# function for creating ellipse unit cells\n",
"def ellipse_uc(center, x_axis, y_axis, height=0.5):\n",
" theta = np.linspace(0, np.pi * 2, 1001)\n",
" x = x_axis * np.cos(theta) + center[0]\n",
" y = y_axis * np.sin(theta) + center[1]\n",
"\n",
" geometry = td.PolySlab(\n",
" vertices=np.array([x, y]).T,\n",
" slab_bounds=(-height / 2 + center[2], height / 2 + center[2]),\n",
" axis=2,\n",
" )\n",
" return geometry\n",
"\n",
"\n",
"# function for creating ellipse unit cells\n",
"def square_uc(center, x_size, y_size, height=0.5):\n",
" geometry = td.Box(center=center, size=(x_size, y_size, height))\n",
" return geometry\n",
"\n",
"\n",
"# function for creating \"sawfish\" unit cells\n",
"def sawfish_uc(center, x, y, height=0.5, width=0.1):\n",
" e = 6\n",
"\n",
" yArray = []\n",
" numPoints = 501\n",
"\n",
" # defining the vertices for the PolySlab\n",
" xaxis = np.linspace(center[0] - x / 2, center[0] + x / 2, numPoints)\n",
" xArray = np.linspace(-x / 2, x / 2, numPoints)\n",
" yArray = y * ((np.cos((np.pi / x) * xArray)) ** e) + width / 2\n",
" yArray2 = -y * ((np.cos((np.pi / x) * np.flip(xArray))) ** e) - width / 2\n",
"\n",
" X = np.concatenate([xaxis, np.flip(xaxis)])\n",
" Y = np.concatenate([yArray, yArray2])\n",
" arr = np.array([X, Y]).T\n",
"\n",
" geometry = td.PolySlab(\n",
" vertices=arr,\n",
" slab_bounds=(-height / 2, height / 2),\n",
" axis=2,\n",
" )\n",
"\n",
" return geometry"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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",
"text/plain": [
"