diff --git a/ard/api/interface.py b/ard/api/interface.py
index 40a795db..73ec9032 100644
--- a/ard/api/interface.py
+++ b/ard/api/interface.py
@@ -1,6 +1,7 @@
 import importlib
 import openmdao.api as om
 from openmdao.drivers.doe_driver import DOEGenerator
+from wisdem.optimization_drivers.nsga2_driver import NSGA2Driver
 from openmdao.utils.file_utils import clean_outputs
 from ard.utils.io import load_yaml, replace_key_value
 from ard.utils.logging import prepend_tabs_to_stdio
@@ -229,29 +230,35 @@ def set_up_system_recursive(
         if analysis_options:
             # set up driver
             if "driver" in analysis_options:
-                Driver = getattr(om, analysis_options["driver"]["name"])
-
-                # handle DOE drivers with special treatment
-                if Driver == om.DOEDriver:
-                    generator = None
-                    if "generator" in analysis_options["driver"]:
-                        if type(analysis_options["driver"]["generator"]) == dict:
-                            gen_dict = analysis_options["driver"]["generator"]
-                            generator = getattr(om, gen_dict["name"])(
-                                **gen_dict["args"]
-                            )
-                        elif isinstance(
-                            analysis_options["driver"]["generator"], DOEGenerator
-                        ):
-                            generator = analysis_options["driver"]["generator"]
-                        else:
-                            raise NotImplementedError(
-                                "Only dictionary-specified or OpenMDAO "
-                                "DOEGenerator generators have been implemented."
-                            )
-                    prob.driver = Driver(generator)
+
+                name_driver = analysis_options["driver"]["name"]
+
+                if name_driver == "NSGA2":
+                    prob.driver = NSGA2Driver()
                 else:
-                    prob.driver = Driver()
+                    Driver = getattr(om, name_driver)
+
+                    # handle DOE drivers with special treatment
+                    if Driver == om.DOEDriver:
+                        generator = None
+                        if "generator" in analysis_options["driver"]:
+                            if type(analysis_options["driver"]["generator"]) == dict:
+                                gen_dict = analysis_options["driver"]["generator"]
+                                generator = getattr(om, gen_dict["name"])(
+                                    **gen_dict["args"]
+                                )
+                            elif isinstance(
+                                analysis_options["driver"]["generator"], DOEGenerator
+                            ):
+                                generator = analysis_options["driver"]["generator"]
+                            else:
+                                raise NotImplementedError(
+                                    "Only dictionary-specified or OpenMDAO "
+                                    "DOEGenerator generators have been implemented."
+                                )
+                        prob.driver = Driver(generator)
+                    else:
+                        prob.driver = Driver()
 
                 # handle the options now
                 if "options" in analysis_options["driver"]:
diff --git a/ard/viz/utils.py b/ard/viz/utils.py
new file mode 100644
index 00000000..30a4581a
--- /dev/null
+++ b/ard/viz/utils.py
@@ -0,0 +1,27 @@
+import numpy as np
+
+
+def get_plot_range(values, pct_buffer=5.0):
+    """
+    get the min and max values for a plot axis with a buffer applied
+
+    Parameters
+    ----------
+    values : np.array
+        the array of values in a given dimension
+    pct_buffer : float, optional
+        percent that should be included as a buffer, by default 5.0
+
+    Returns
+    -------
+    float
+        minimum value for the plot range
+    float
+        maximum value for the plot range
+    """
+    min_value = np.min(values)
+    max_value = np.max(values)
+    dvalues = max_value - min_value
+    min_value = min_value - pct_buffer / 100.0 * dvalues
+    max_value = max_value + pct_buffer / 100.0 * dvalues
+    return min_value, max_value
diff --git a/examples/06_onshore_multiobjective/inputs/ard_system.yaml b/examples/06_onshore_multiobjective/inputs/ard_system.yaml
new file mode 100644
index 00000000..d0e54031
--- /dev/null
+++ b/examples/06_onshore_multiobjective/inputs/ard_system.yaml
@@ -0,0 +1,91 @@
+modeling_options:
+  windIO_plant: !include windio.yaml
+  layout:
+    type: gridfarm
+    N_turbines: 25
+    N_substations: 1
+    spacing_primary: 7.0
+    spacing_secondary: 7.0
+    angle_orientation: 0.0
+    angle_skew: 0.0
+  aero:
+    return_turbine_output: True
+  floris:
+    peak_shaving_fraction: 0.2
+    peak_shaving_TI_threshold: 0.0
+  collection:
+    max_turbines_per_string: 8
+    solver_name: highs
+    solver_options:
+      time_limit: 60
+      mip_gap: 0.02
+    model_options:
+      topology: radial  # radial, branched
+      feeder_route: segmented
+      feeder_limit: unlimited
+  offshore: false
+  floating: false
+  costs:
+    rated_power: 3400000.0  # W
+    num_blades: 3
+    rated_thrust_N: 645645.83964671
+    gust_velocity_m_per_s: 52.5
+    blade_surface_area: 69.7974979
+    tower_mass: 620.4407337521
+    nacelle_mass: 101.98582836439
+    hub_mass: 8.38407517646
+    blade_mass: 14.56341339641
+    foundation_height: 0.0
+    commissioning_cost_kW: 44.0
+    decommissioning_cost_kW: 58.0
+    trench_len_to_substation_km: 50.0
+    distance_to_interconnect_mi: 4.97096954
+    interconnect_voltage_kV: 130.0
+    tcc_per_kW: 1300.00  # (USD/kW)
+    opex_per_kW: 44.00  # (USD/kWh)
+
+system: onshore
+
+analysis_options:
+  driver:
+    name: NSGA2
+    options:
+      max_gen: 10
+      pop_size: 10
+      run_parallel: False
+  design_variables:
+    spacing_primary:
+      lower:  3.0
+      upper: 12.0
+      scaler: 0.14
+    spacing_secondary:
+      lower:  3.0
+      upper: 12.0
+      scaler: 0.14
+    angle_orientation:
+      lower: -180.0
+      upper:  180.0
+      scaler: 0.025
+    angle_skew:
+      lower: -45.0
+      upper:  45.0
+      scaler: 0.11
+  constraints:
+    boundary_distances:
+      units: km
+      upper: 0.0
+      scaler: 2.0
+    spacing_constraint.turbine_spacing:
+      units: km
+      lower: 0.552
+  objectives:
+    financese.lcoe:
+      scaler: 10.0
+    # AEP_farm:
+    #   scaler: -0.01
+    #   units: GW*h
+    area_tight:
+      units: km**2
+      scaler: 0.1
+  recorder:
+    filepath: cases.sql
diff --git a/examples/06_onshore_multiobjective/inputs/windio.yaml b/examples/06_onshore_multiobjective/inputs/windio.yaml
new file mode 100644
index 00000000..b69c8274
--- /dev/null
+++ b/examples/06_onshore_multiobjective/inputs/windio.yaml
@@ -0,0 +1,34 @@
+name: Ard Example 01 onshore wind plant
+site:
+    name: Ard Example 01 offshore wind site
+    boundaries:
+        polygons:
+            - x: [ 1500.0,  3000.0,  3000.0,  1500.0, -1500.0, -3000.0, -3000.0, -1500.0]
+              y: [ 3000.0,  1500.0, -1500.0, -3000.0, -3000.0, -1500.0,  1500.0,  3000.0]
+    energy_resource:
+        name: Ard Example 01 offshore energy resource
+        wind_resource: !include ../../data/windIO-plant_wind-resource_wrg-example.yaml
+wind_farm:
+    name: Ard Example 01 offshore wind farm
+    layouts:
+        coordinates:
+            x: [
+                -2500.0, -1250.0,     0.0,  1250.0,  2500.0,
+                -2500.0, -1250.0,     0.0,  1250.0,  2500.0,
+                -2500.0, -1250.0,     0.0,  1250.0,  2500.0,
+                -2500.0, -1250.0,     0.0,  1250.0,  2500.0,
+                -2500.0, -1250.0,     0.0,  1250.0,  2500.0
+            ]
+            y: [
+                -2500.0, -2500.0, -2500.0, -2500.0, -2500.0,
+                -1250.0, -1250.0, -1250.0, -1250.0, -1250.0,
+                    0.0,     0.0,     0.0,     0.0,     0.0,
+                 1250.0,  1250.0,  1250.0,  1250.0,  1250.0,
+                 2500.0,  2500.0,  2500.0,  2500.0,  2500.0
+            ]
+    turbine: !include ../../data/windIO-plant_turbine_IEA-3.4MW-130m-RWT.yaml
+    electrical_substations:
+        - electrical_substation:
+            coordinates:
+                x: [100.0]
+                y: [100.0]
\ No newline at end of file
diff --git a/examples/06_onshore_multiobjective/optimization_demo.ipynb b/examples/06_onshore_multiobjective/optimization_demo.ipynb
new file mode 100644
index 00000000..85ef49dc
--- /dev/null
+++ b/examples/06_onshore_multiobjective/optimization_demo.ipynb
@@ -0,0 +1,434 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "0a8540f7",
+   "metadata": {},
+   "source": [
+    "# 06: Onshore multi-objective\n",
+    "\n",
+    "In this example, we will demonstrate `Ard`'s ability to run a multi-objective analysis and optimization.\n",
+    "\n",
+    "We can start by loading what we need to run the problem."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "d75b4457",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from pathlib import Path  # optional, for nice path specifications\n",
+    "\n",
+    "import pprint as pp  # optional, for nice printing\n",
+    "import numpy as np  # numerics library\n",
+    "import matplotlib.pyplot as plt  # plotting capabilities\n",
+    "\n",
+    "import ard  # technically we only really need this\n",
+    "from ard.utils.io import load_yaml  # we grab a yaml loader here\n",
+    "from ard.api import set_up_ard_model  # the secret sauce\n",
+    "from ard.viz.layout import plot_layout  # a plotting tool!\n",
+    "from ard.viz.utils import get_plot_range  # buffered range tool\n",
+    "\n",
+    "import openmdao.api as om  # for N2 diagrams from the OpenMDAO backend\n",
+    "\n",
+    "%matplotlib inline"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "cf2ceef4",
+   "metadata": {},
+   "source": [
+    "This will do for now.\n",
+    "We can probably make it a bit cleaner for a later release.\n",
+    "\n",
+    "Now, we can set up a case.\n",
+    "We do it a little verbosely so that our documentation system can grab it, you can generally just use relative paths.\n",
+    "We grab the file at `inputs/ard_system.yaml`, which describes the `Ard` system for this problem.\n",
+    "It references, in turn, the `inputs/windio.yaml` file, which is where we define the plant we want to optimize, and an initial setup for it."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "29850609",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Running OpenMDAO util to clean the output directories...\n",
+      "\tFound 1 OpenMDAO output directories:\n",
+      "\tRemoved case_files/ard_problem_out\n",
+      "\tRemoved 1 OpenMDAO output directories.\n",
+      "... done.\n",
+      "\n",
+      "Created top-level OpenMDAO problem: top_level.\n",
+      "Adding top_level.\n",
+      "\tAdding layout2aep.\n",
+      "\t\tAdding layout to layout2aep.\n",
+      "\t\tAdding aepFLORIS to layout2aep.\n",
+      "\tActivating approximate totals on layout2aep\n",
+      "\tAdding boundary.\n",
+      "\tAdding landuse.\n",
+      "\tAdding collection.\n",
+      "\tAdding spacing_constraint.\n",
+      "\tAdding tcc.\n",
+      "\tAdding landbosse.\n",
+      "\tAdding opex.\n",
+      "\tAdding financese.\n",
+      "System top_level built.\n",
+      "System top_level set up.\n"
+     ]
+    }
+   ],
+   "source": [
+    "# load input\n",
+    "path_inputs = Path.cwd().absolute() / \"inputs\"\n",
+    "input_dict = load_yaml(path_inputs / \"ard_system.yaml\")\n",
+    "\n",
+    "# create and setup system\n",
+    "prob = set_up_ard_model(input_dict=input_dict, root_data_path=path_inputs)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b0732705",
+   "metadata": {},
+   "source": [
+    "Above, you should see each of the groups or components described as they are added to the `Ard` model and, occasionally, some options being turned on on them, like semi-total finite differencing on groups.\n",
+    "\n",
+    "Next is some code you can flip on to use the [N2 diagram vizualization tools from the backend toolset, OpenMDAO, that we use](https://openmdao.org/newdocs/versions/latest/features/model_visualization/n2_basics/n2_basics.html).\n",
+    "This can be a really handy debugging tool, if somewhat tricky to use; turned on it will show a comprehensive view of the system in terms of its components, variables, and connections, although we leave it off for now."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "aa48878e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "if False:\n",
+    "    # visualize model\n",
+    "    om.n2(prob)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "723f8210",
+   "metadata": {},
+   "source": [
+    "Now, we do a one-shot analysis.\n",
+    "The one-shot analysis will run a wind farm as specified in `inputs/windio.yaml` and with the models specified in `inputs/ard_system.yaml`, then dump the outputs."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "b74f9d45",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "\n",
+      "RESULTS:\n",
+      "\n",
+      "{'AEP_val': 406.5372933434125,\n",
+      " 'BOS_val': 41.68227106807093,\n",
+      " 'CapEx_val': 110.5,\n",
+      " 'LCOE_val': 37.274982094458494,\n",
+      " 'OpEx_val': 3.7400000000000007,\n",
+      " 'area_tight': 13.2496,\n",
+      " 'coll_length': 21.89865877023397,\n",
+      " 'turbine_spacing': 0.91}\n",
+      "\n",
+      "\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "# run the model\n",
+    "prob.run_model()\n",
+    "\n",
+    "# collapse the test result data\n",
+    "test_data = {\n",
+    "    \"AEP_val\": float(prob.get_val(\"AEP_farm\", units=\"GW*h\")[0]),\n",
+    "    \"CapEx_val\": float(prob.get_val(\"tcc.tcc\", units=\"MUSD\")[0]),\n",
+    "    \"BOS_val\": float(prob.get_val(\"landbosse.total_capex\", units=\"MUSD\")[0]),\n",
+    "    \"OpEx_val\": float(prob.get_val(\"opex.opex\", units=\"MUSD/yr\")[0]),\n",
+    "    \"LCOE_val\": float(prob.get_val(\"financese.lcoe\", units=\"USD/MW/h\")[0]),\n",
+    "    \"area_tight\": float(prob.get_val(\"landuse.area_tight\", units=\"km**2\")[0]),\n",
+    "    \"coll_length\": float(prob.get_val(\"collection.total_length_cables\", units=\"km\")[0]),\n",
+    "    \"turbine_spacing\": float(\n",
+    "        np.min(prob.get_val(\"spacing_constraint.turbine_spacing\", units=\"km\"))\n",
+    "    ),\n",
+    "}\n",
+    "\n",
+    "print(\"\\n\\nRESULTS:\\n\")\n",
+    "pp.pprint(test_data)\n",
+    "print(\"\\n\\n\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b3085438",
+   "metadata": {},
+   "source": [
+    "Now, we can optimize the same problem to understand the tradeoff between LCOE and land use area!\n",
+    "The optimization details are set under the `analysis_options` header in `inputs/ard_system.yaml`.\n",
+    "Here, we still use the four-dimensional rectilinear layout parameterization ($\\theta$) as design variables, constrain the farm such that the turbines are in the boundaries and satisfactorily spaced, and then we optimize for both LCOE and land use area.\n",
+    "$$\n",
+    "\\begin{aligned}\n",
+    "\\textrm{minimize}_\\theta \\quad & \\begin{pmatrix}\n",
+    "    A_{\\mathrm{landuse}}(\\theta, \\ldots) \\\\\n",
+    "    \\mathrm{LCOE}(\\theta, \\ldots)\n",
+    "\\end{pmatrix} \\\\\n",
+    "\\textrm{subject to} \\quad & f_{\\mathrm{spacing}}(\\theta, \\ldots) < 0 \\\\\n",
+    "                          & f_{\\mathrm{boundary}}(\\theta, \\ldots) < 0\n",
+    "\\end{aligned}\n",
+    "$$"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "b0009663",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "generation: 0 of 10\n",
+      "generation: 1 of 10\n",
+      "generation: 2 of 10\n",
+      "generation: 3 of 10\n",
+      "generation: 4 of 10\n",
+      "generation: 5 of 10\n",
+      "generation: 6 of 10\n",
+      "generation: 7 of 10\n",
+      "generation: 8 of 10\n",
+      "generation: 9 of 10\n",
+      "generation: 10 of 10\n",
+      "\n",
+      "\n",
+      "RESULTS (opt):\n",
+      "\n",
+      "{'AEP_val': 424.40487848403035,\n",
+      " 'BOS_val': 39.600972465841274,\n",
+      " 'CapEx_val': 110.5,\n",
+      " 'LCOE_val': 35.337890055621564,\n",
+      " 'OpEx_val': 3.7400000000000007,\n",
+      " 'area_tight': 4.701829411011188,\n",
+      " 'coll_length': 11.907005558904213,\n",
+      " 'turbine_spacing': 0.43220837800684214}\n",
+      "\n",
+      "\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "optimize = True  # set to False to skip optimization\n",
+    "if optimize:\n",
+    "    # run the optimization\n",
+    "    prob.run_driver()\n",
+    "\n",
+    "    # collapse the test result data\n",
+    "    test_data = {\n",
+    "        \"AEP_val\": float(prob.get_val(\"AEP_farm\", units=\"GW*h\")[0]),\n",
+    "        \"CapEx_val\": float(prob.get_val(\"tcc.tcc\", units=\"MUSD\")[0]),\n",
+    "        \"BOS_val\": float(prob.get_val(\"landbosse.total_capex\", units=\"MUSD\")[0]),\n",
+    "        \"OpEx_val\": float(prob.get_val(\"opex.opex\", units=\"MUSD/yr\")[0]),\n",
+    "        \"LCOE_val\": float(prob.get_val(\"financese.lcoe\", units=\"USD/MW/h\")[0]),\n",
+    "        \"area_tight\": float(prob.get_val(\"landuse.area_tight\", units=\"km**2\")[0]),\n",
+    "        \"coll_length\": float(\n",
+    "            prob.get_val(\"collection.total_length_cables\", units=\"km\")[0]\n",
+    "        ),\n",
+    "        \"turbine_spacing\": float(\n",
+    "            np.min(prob.get_val(\"spacing_constraint.turbine_spacing\", units=\"km\"))\n",
+    "        ),\n",
+    "    }\n",
+    "\n",
+    "    # clean up the recorder\n",
+    "    prob.cleanup()\n",
+    "\n",
+    "    # print the results\n",
+    "    print(\"\\n\\nRESULTS (opt):\\n\")\n",
+    "    pp.pprint(test_data)\n",
+    "    print(\"\\n\\n\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d5fb8cca",
+   "metadata": {},
+   "source": [
+    "The result is no longer a single farm... we need to extract the multi-objective data now."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "49f0bc84",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Extract the multi-objective data from the driver\n",
+    "obj_nd = prob.driver.obj_nd.copy()\n",
+    "obj_nd = obj_nd[obj_nd[:, 0].argsort()]  # Sort rows by the first column"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "22d330a2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Access the recorder data\n",
+    "case_reader = om.CaseReader(prob.get_outputs_dir() / \"cases.sql\")\n",
+    "\n",
+    "# Get all driver cases\n",
+    "driver_cases = case_reader.list_cases(\"driver\", out_stream=None)\n",
+    "\n",
+    "# Extract data from all cases\n",
+    "results = []\n",
+    "for case_id in driver_cases:\n",
+    "\n",
+    "    case = case_reader.get_case(case_id)\n",
+    "\n",
+    "    # Extract specific variables you're interested in\n",
+    "    result = {\n",
+    "        \"case_id\": case_id,\n",
+    "        \"LCOE\": case.get_val(\"financese.lcoe\", units=\"USD/MW/h\")[0],\n",
+    "        \"area_tight\": case.get_val(\"area_tight\", units=\"km*km\")[0],\n",
+    "    }\n",
+    "    results.append(result)\n",
+    "\n",
+    "# Convert to arrays for plotting/analysis\n",
+    "case_id_history = np.array([int(r[\"case_id\"].split(\"|\")[-1]) for r in results])\n",
+    "lcoe_history = np.array([r[\"LCOE\"] for r in results])\n",
+    "area_tight_history = np.array([r[\"area_tight\"] for r in results])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "20c15747",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjIAAAG5CAYAAACUU97fAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjcsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvTLEjVAAAAAlwSFlzAAAPYQAAD2EBqD+naQAAjpVJREFUeJzt3QWYlGXXB/D/5HYvsUt3d3eDgEj5ikEJIqhIiUgoKKIoSqighISihKT40dIp3d0LbLDdMfFd515m2dnd2ZiZnZ04v/d6XmaeqWdm1n3O3ve5z5FotVotGGOMMcZskLSoD4AxxhhjzFgcyDDGGGPMZnEgwxhjjDGbxYEMY4wxxmwWBzKMMcYYs1kcyDDGGGPMZnEgwxhjjDGbxYEMY4wxxmwWBzKMMcYYs1kcyDDGGGPMZnEgwxhjjDmgw4cPo1evXggMDIREIsHWrVvzfMyhQ4fQqFEjODs7o2LFili8eDGKGgcyjDHGmANKSEhAvXr1sHDhwnzd//79++jRowfatGmD8+fPY+rUqRgzZgw2bdqEoiThppGMMcaYY5NIJNiyZQv69Olj8D6ffPIJtm3bhuvXr2fsGzVqFC5evIgTJ06gqMjhYDQaDZ4+fQoPDw/xxTHGGGOGaLVaxMXFiekXqbTwJjGSk5ORmppqluOVZDm3OTk5ic1UFKx07dpVb1+3bt2wfPlypKWlQaFQoCg4XCBDQUyZMmWK+jAYY4zZkKCgIJQuXbrQgpgK5dwREqY2+bnc3d0RHx+vt2/GjBn4/PPPTX7ukJAQlChRQm8fXVepVAgPD0dAQACKgsMFMjQSo/uh9PT0LOrDYYwxZsViY2PFH7+6c0dhoJEYCmLuny0HTw/jR31i4zSo0OhhtvObOUZjdLKO9tAIUE77LcnhAhndh01fMgcyjDHGCnLuKEwUxJgSyOgU1vmtZMmSYlQms7CwMMjlcvj5+aGoOFwgwxhjjFkjtVYDtda0xxemFi1a4J9//tHbt2fPHjRu3LjI8mMIL79mjDHGrIAGWpO3gqBcmgsXLohNt7yaLj969EhcnzJlCgYPHqy3Qunhw4eYMGGCWLm0YsUKkeg7ceJEFCUekWGMMcasgEb8z7THF8SZM2fQoUOHjOsUoJAhQ4Zg1apVCA4OzghqSIUKFbBjxw6MHz8eixYtEiu5fvzxR/Tv3x9FyeHqyFDilpeXF2JiYjhHhjHGWJGfM3Sv8fRmaZOTfQOrPXa48xuPyDDGGGNWQK3Vis2UxzsiDmQYY4wxK2BMnktmpjzWllltsu/s2bPFcrdx48Zl7Nu8ebOoIujv7y9u0yUoMcYYY8wxWWUgc/r0aSxduhR169bN1uCqVatW+Oabb4rs2BhjjLHCQCMqahM2jYOOyFjd1BItB3vrrbewbNkyzJo1S++2QYMGiX8fPHgAa6VW3Ycm7QYgcYZc2QwSqWtRHxJjjDEbwFNLdjIi88EHH6Bnz57o3LmzWZ4vJSVFZIRn3gqDRvUACeGvIyGsHZKiRiIpcgjiQhsiOXYetIVcpIgxxhhzVFY1IrNu3TqcO3dOTC2ZM9fmiy++QGHSqIOREN4XWk20/g3aRKTGL4BWEw4X768L9RgYY4zZNl61ZOMjMtTkauzYsfjjjz/g7OxstuelyoS0pl630euYW0rcz8+DmJw7l6Yl/gF12m2zvy5jjDH7oTHD5oisZkTm7NmzovlUo0aNMvap1WocPnwYCxcuFFNEMpmswM9LXT/N2fkzK61WjbSkvwwGMelkSEvaAJliaqEdB2OMMeaIrCaQ6dSpEy5fvqy37+2330b16tXxySefGBXEWIQ2EdAm5X03dahFDocxxpht0q0+MuXxjshqAhkPDw/Url1bb5+bm5toDa7bHxkZKfo+PH36VFy/efNmRmtx2oqEhFYl0VRYcm53gkRazIIHxRhjzNZQ52vTul/DIVlNjkx+bNu2DQ0aNBCrmsjrr78uri9evLjIjkkikUHhSg2zchsxUj2/D2OMMZYzzpGx8RGZnBw8eFDv+tChQ8VmbZzc30da0v8B2vgccmUkkLv0h0xRo4iOjjHGGLNfNjUiY62k8jJw898MqUJ/agxwgsJtBFy85xTRkTHGGLMVGkigNmHTQAJHZNUjMrZEpqgC92L/QJ12Feq0G5BQZV+n1pBIvYr60BhjjNkAjTZ9M+XxjogDGTOTKWqJjTHGGGOFjwMZxhhjzAropohMebwj4kCGMcYYswIcyBiHk30ZY4wxZrN4RIYxxhizAhqtRGymPN4RcSDDGGOMWQGeWjIOTy0xxhhjzGbxiAxjjDFmBdSQis34xzsmDmQYY4wxK6A1MUdGyzkyjDHGGCsqnCNjHM6RYYwxxpjN4qklxhhjzAqotVKxGf94OCQOZBhjjDErQN2rNSZMlGjgmJEMTy0xxhhjzGbxiAxjjDFmBTjZ1zgcyDDGGGN2kSOjhSPiqSXGGGOM2SwekWGMMcasJtnXhKaR4KaRjDHGGCsiGhNbFGh41RJjjDHGmG3hqSXGGGPMCnCyr3E4kGGMMcasZGqJC+IVHAcyjDHGmBVQayViM+XxjoiXXzPGGGPMZvGIDGOMMWYF1CauWlI76KolDmQYY4wxK6DRSsVm/OO1cEQ8tcQYY4wxxxyRSUtLQ0hICBITE1GsWDH4+vqa78gYY4wxB8JTSxYakYmPj8eSJUvQvn17eHl5oXz58qhZs6YIZMqVK4cRI0bg9OnTRh4OY4wx5pg0mVYuGbNp4JgKFMjMnz9fBC7Lli1Dx44dsXnzZly4cAE3b97EiRMnMGPGDKhUKnTp0gUvvfQSbt++XXhHzhhjjDGHV6CppePHj+PAgQOoU6dOjrc3bdoUw4YNw+LFi7F8+XIcOnQIVapUcfgPmTHGGCv8gnhSh/yQCxTIbNiwIV/3c3Jywvvvv2/sMTHGGGMOx/QWBVI4Iqt917Nnz4ZEIsG4ceMy9mm1Wnz++ecIDAyEi4uLyNO5evVqkR4nY4wxxmx01dK+ffvEFhYWBo1GP81oxYoVRj8vJQsvXboUdevW1ds/Z84czJs3D6tWrULVqlUxa9YskY9DOToeHh5Gvx5jjDFW1DSghF3j2wxoTHisQ47IfPHFF+jatasIZMLDwxEVFaW3GYtWRb311lsiodjHx0dvNGbBggWYNm0a+vXrh9q1a+O3334TS7/XrFlj9Osxxhhj1jS1ZMrmiIwekaGEXhoZGTRokFkP6IMPPkDPnj3RuXNnMeKic//+fVGzhoKnzLk47dq1E0nII0eOzPH5UlJSxKYTGxtr1uNljDHGrKOOjNQhvwijA5nU1FS0bNnSrAezbt06nDt3Lsc6NBTEkBIlSujtp+sPHz7MNdeGRo8YY4wxZn+MDt/eeecds07pBAUFYezYsfjjjz/g7Oxs8H6UAJwZTTll3ZfZlClTEBMTk7HR6zDGGGPWRkNF7UzcHFGBRmQmTJiQcZmSeykh999//xVJuQqFQu++lJRbEGfPnhVJw40aNcrYp1arcfjwYSxcuFAk9OpGZgICAjLuQ4/JOkqTGU0/0cYYY4xZM6oDY8r0kIanlvJ2/vx5vev169cX/165ckVvf24jJIZ06tQJly9f1tv39ttvo3r16vjkk09QsWJFlCxZEnv37kWDBg0ypreo6N63335b4NdjjDHGmIONyFBV38JCy6dpJVJmbm5u8PPzy9hPNWW+/vprUS2YNrrs6uqKN998s9COizHGGLMEjVYqNlMe74gKnOx7584dVK5cGUVh0qRJSEpKElWDaYl3s2bNsGfPHq4hwxhjzOapIRGbKY93RBItZcsWgFQqRalSpdChQ4eMjRpJ2gpafk1duynx19PTs6gPhzHGmIOfM3Sv8eWpjnB2N75ObXK8Cp813e9w57cCf2KUk0LbwYMHMXr0aCQnJ6Ns2bKiG7YusKFAhzHGGGP5x1NLFgpk2rRpI7ZPP/0UaWlpOHHihAhqaFu7dq0oPkdTT7pVRowxxhjLm9rE6SG1g37IJvVaoiXXbdu2RZMmTdCiRQvs3r1btBagPBrGGGOMMasMZGg6idoC0ComGomhSrwVKlQQ7QJ++eUX8S9jjDHG8o+nliwUyFCQQoFLpUqVxGjMhx9+KPblVpSOMcYYY7kztfGj2kGXXxf4XdNIjL+/v0jqpSJ2lOTLQQxjjDFmGi0k0JiwaY3Mr/n555/FrAq1B6Lq+keOHMn1/n/++Sfq1asn6rhRpX0qXhsREQGbCWSio6NFawJ6A1RRl1Yo1alTR6xg2rhxI549e1Y4R8oYY4wxs1q/fr0oNjtt2jRRvZ8W83Tv3h2PHj3K8f5Hjx7F4MGDMXz4cFy9ehUbNmwQszTUf9Fm6shkFRcXJ96YLl/m4sWLoupu1rYF9lwTgD7C63F3cCbyIlI1qSjjGog2/s3gKncxy/Mzxhiz/zoyHx/vCSd3/b6FBZESn4bvWm4v0LFSYdmGDRuK/FadGjVqoE+fPpg9e3a2+3///ffivnfv3s3Y99NPP2HOnDlF1pTZpFVLujYCvr6+YvPx8YFcLsf169fhKGLT4jHnxiLcjr8PmYQGuCRQa9X44+EmfFB5KJr7vWiCyRhjjBliagdrzfPHUmCUn+bJ1K+QGjZPnjxZb3/Xrl1FGklOWrZsKUZvduzYIUZuqHEzzcb07NkTNjO1RF2vT506JaIvehPe3t7ijdEcGzV1XLRoEe7duwdHQCMx31xfiLvxD8V1tVYjghiSqknDglu/4kYsL0VnjDFmOWXKlBEjPLotp5EVEh4eDrVanS3Pla6HhITk+Bg631OOzIABA6BUKsV5n+IAGpUpKgUekaEDTkhIEAk+7du3x7x580TiL61icjRXYm/ibsIDg7dLIMHWJ7sw2XO0RY+LMcaY7VFDKjZTHk9oiifz1FJOozGZSSSSbH+kZ92nc+3aNYwZMwbTp09Ht27dEBwcjI8//hijRo3C8uXLYROBzHfffScCl6pVq8LRnYo4D5n4wdPkeLsGGlyIvipGZ5RS4+c9GWOM2T9zTS15enrmK0eGViDLZLJsoy80XWRoNTKN7rRq1UoEL6Ru3boixYSShGfNmiUGOSytwKHfyJEjOYh5LkWTgrwypbXQIk2TZtSXwxhjjBUWpVIpllvv3btXbz9dpymknCQmJorm0ZlRMERMXDtkuRGZYcOG5et+K1asgL0r5RIgApXceCo84CJzttgxMcYYs00aSMVmyuMLasKECRg0aBAaN24sWg1ReRVaek1TRWTKlCl48uQJfv/9d3G9V69eGDFihFi5pJtaouXbTZs2RWBgIGwikFm1ahXKlSuHBg0aFFn0ZS3aF2+B9UHbMhJ8c8qR6VaiPaRiNRNjjDFmmFpLq15NaBqpLfhjKWmXitnNnDlTBCW1a9cWK5LoPE9oX+aaMkOHDhVlVxYuXIiPPvpI5M1SYVyqK2czdWTef/99rFu3DmXLlhWjMwMHDhRLrx21JsCBsGNYfHc1pKKyolYviKnoVg4zak2Ak0xp8uswxhiz7zoy7x3pZ3IdmV/abC7UY7VGBR4qoGXWFKF98skn+Oeff8Qyr9dee010vnbEEZoOxVthao0xqOrxYtWWu9wN/Up1x/Ra4zmIYYwxVqBkX1M2R2RUQTxayvXGG2+I7eHDh2K6iUZq0tLSxNIsd3d3OJJ63jXFlqBKFIm9Hgp3yCTpyU+MMcZYfmi1UtEB25THOyKTK/vSWnPaaDSGiuU5Mje5a1EfAmOMMRulpsrwRjZ+JKY81pYZFb6lpKRg7dq16NKlC6pVq4bLly+LxB9KCHK00RjGGGOM2dCITOZkX2rdTZf9/PwK5+gYY4wxB6HRvihqZ+zjHVGBA5nFixeLIKZChQo4dOiQ2HKyefNmcxwfY4wx5hA0JubImPJYhwpkhgwZUjhHwhhjjDFW2IEMdbrs06cPmjVrVtCHMsYYY8wAjahHZsLUEjjZN1+ouRSVKKbGUO+++66oAEjJv4wxxhgzvbKvKZsjKvCE2sqVKxEaGoq//vpLlCamPg3UQbNfv36inkx4eHjhHCljjDHGWBZGZQZR3Rhq2T1nzhzcuHEDp06dQvPmzbFs2TKUKlUKbdu2xffffy8aTTHGGGMs/8m+pmyOyOSCeKRGjRpimzRpEsLCwkTrgm3btonbJk6caI6XYIwxxuw/R8aU5ddwzKklswQymRUvXhzDhw8XG2OMMcZYYTJqHEqlUiE1NVVv36+//iqWZv/0008O2TySMcYYM4X2+aolYzetg47IGBXIDBw4EDNmzMi4vmTJEowdOxYJCQmYOXMmpk6das5jZIwxxuwed7+2YCBz9uxZvPTSS3qBzIIFC7Bx40Zs2LABa9asMfJwGGOMMcfEyb4WyJGh3kokKCgIP/74I3777TcxjXTx4kXs3LkTJ06cENNOT58+xbBhw8R9V6xYYeShMcYYY4yZMZChGjJk//79GDdunFiCvX37dhw7diyjt1JMTAz+/vtvDmAYY4wxI6aWjKXhgnj51759e4wcORKzZ8/G+PHjMWDAgIzbaHSmSpUqRn0Jv/zyC+rWrQtPT0+xtWjRQoz06FAhvqFDhyIwMBCurq5ieuv27dtGvRZjjDFmTUxJ9NWY2N7A4XJk5s2bh0aNGolcmI4dO+ol927dulUkAxujdOnS+Oabb3DmzBmx0XP37t0bV69eFVNY1OPp3r17YsTn/PnzKFeuHDp37iySjBljjDHmeCRaK18r7evri++++05MY1WrVg1XrlxBrVq1xG1qtVrUrfn222/xzjvv5Ov5YmNj4eXlJabAaNSHMcYYK8pzhu41eu5+Bwo3pdHPk5aQiu3dfnW481uBRmQePXpUoCc3pUUBBSnr1q0Toy00xaRrTOns7JxxH5lMBqVSiaNHjxp8Hnoc/ZBk3hhjjDFrw8uvLRDINGnSBCNGjBC9lQyhSJB6LtWuXTsjAbggLl++DHd3dzg5OWHUqFHYsmULatasierVq4uppClTpiAqKkoU5KNpKOrGHRwcbPD5KI+HIl3dVqZMmQIfE2OMMcbsYNXS9evX8fXXX4skW4VCgcaNG4vEWxoloeDi2rVrIp+F9tN0UPfu3Qt8QDR9dOHCBURHR2PTpk2iWvChQ4dEMEPXqfUBTTfRaAzlx+T1GhT4UIduHRqR4WCGMcaYteFVSxbMkUlOTsaOHTtw5MgRPHjwAElJSfD390eDBg3QrVs3MRpjLhSsVKpUSRTdyzzqQyMyxYoVQ7NmzUTgtGjRonw9H+fIMMYYs8YcmS47RpqcI7O3xxKHy5ExqmkkjcD069dPbIWN4ixdfowOfeGEll7T6qYvv/yy0I+DMcYYYw7Q/doUtIybpopo6icuLk4k+x48eBC7du0St1P7AxqFKVu2rMilof5OtCS7a9euRX3ojDHGmEloesSUWjBaB/38rSqQoYJ3gwYNEsm7NOpCxfEoiOnSpYu4nfZTvgvdLyAgAIMHD8Znn31W1IfNGGOMmYxzZOwgkFm+fHmut48ZM0ZsjDHGmL3hQMaClX0ZY4wxxqyBVY3IMMYYY47KEUZkkpKSxCIe6pdIHj58mFEvzth8Vx6RYYwxxqyAI1T27d27N37//XdxmerFUQmVuXPniv3UONoigUyPHj3EGnWdr776ShyMTkREhIisGGOMMcYyO3funOidSDZu3IgSJUqIURkKbn788UdYJJDZvXu3Xl0XatgYGRmZcV2lUuHmzZtGHQxjjDHmqLRaicmbtUtMTISHh4e4vGfPHlGPTiqVonnz5iKgsUggk7UQsJU3z2aMMcZsAtWQMXWzdpUrV8bWrVsRFBQkBkZ0eTFhYWFGVyPmHBnGGGOMWcT06dMxceJElC9fXuTHtGjRImN0htocWWTVkkQiEVvWfYwxxhgzniOsWnr11VfRunVrUeC2Xr16Gfs7deqEvn37WiaQoamkoUOHwsnJKaOB5KhRo+Dm5iauZ+2LxBhjjLH8nF9Ny3PR2kAgQ0qWLCk2XcPM/fv3o1q1aqhevbplApkhQ4boXR84cGC2+1DrAMYYY4yxzF577TW0bdsWo0ePFjVlGjdujAcPHohBEuqv2L9/fxR6ILNy5coCvwhjjDHGcucIU0uHDx/GtGnTxGUqhEcBDJVw+e233zBr1izLBDJZhYeHixwZPz8/OAKtVoNHCWfxKPGcuBzgUhMVPVpBJuEiyYwxxkw5v9j/1FJMTAx8fX3FZWoKTYELVfnt2bMnPv74Y6Oe06izL0VPFFGtX78eUVFRYp+Pjw9ef/11EVF5e3vDHsWkPsXfj6chKjUIUsjEvvNRm+Am80Wv0l+ihEu1oj5ExhhjNooCEY2dBzJlypTBiRMnRDBDgQxNJxGKJZydnS0TyFDxO1ou9eTJE7z11luoUaOGGBq6fv06Vq1ahX379uH48eMisLEnqZokbHz0ERJU6cX/NFBn3JaojsbmoI8xsMKv8FAUL8KjZIwxxqzXuHHjROzg7u6OsmXLon379hlTTnXq1LFMIDNz5kwolUrcvXtXlBbOehsVt6F/58+fD3tyI+ZfxKue5XibFhqkaZJxMepvtC4+wuLHxhhjzPZReVlTasxqYf3ef/99NG3aVBTE69Kli6jqSypWrChmdCxSEI8q8n3//ffZghhCy6nmzJkjEnjsze24g1Qxx+DtFMzcij1g0WNijDFmPxyhsi+hlUqUE0MzO9TWiND1Vq1awSIjMlTEplatWgZvr127NkJCQmBvUtWJeca7aZqkAj/v7bhgbHz0Hy5HPYRCKkfr4tXRt3QT+DsbV6qZMcYYs+ZeSx9++KFYpURu3bolRmPGjBmDwMBATJ48ufBHZPz9/cWab0Pu379vlyuY/JzKQ/I8wTcnEkjh41SuQM+57sExvHXsJ2x7fAZ34kNxPfYJlt/Zj/5H5uFc5H0zHDVjjDFb4QhNI6dMmYKLFy/i4MGDesm9nTt3FguIjFHgQOall14SK5ZSU1Oz3UZVfT/77DNxH3tTx6cXtJkSfHOaWqrn80q+n+9MxF3Mu7FdXFZrNRn7NdAiRZ2GCWd/R0wqjQIxxhhzpDoypmzWjtJTFi5cKNoUZG5vVLNmTZF7a5GppS+++ELMb1WpUgUffPBBRknha9eu4eeffxbBzOrVq2FvqF5MfZ9+uBC1OYdbJajo3hJVPNrl+/nWPDgGmUSqF8RkDmaS1Cn4vyfn8FaF1iYeOWOMMWYdnj17huLFs6/uTUhIMLpvY4EDmdKlS4vl1RTE0BARLb0mdACUgUyRFq0Tt0dti78nppjORqxHdNoTsc9N7icCnIa+r0IqMTz1lNOITE5BjA59qqcj73IgwxhjDoJOpyatWtLC6jVp0gTbt28XeTJEF7wsW7YsoxO2RQriUWLOzp07RQGb27dvi32VK1fOqNZnr+gDr+3dA7W8uiNBFSFqybjL/QsUwOho87FQThckMsYYs3+OUNl39uzZIv2EZnFoxdIPP/yAq1eviiJ5hw4dskyODHWppLks6lhJRe9oPThtFMRQ6WFa0XTkyBHYe0DjrvCHp6KEUUEMqetTDtJchtEkkKC+T3kTjpIxxhizLi1bthSzOrR6qVKlStizZ48o50KBTKNGjSwzIrNgwQKMGDECnp7Zlwd7eXlh5MiRmDdvHtq0aWPUATmKN8q1wumInBObKLxRSGV4pbRxXypjjDHbY+8jMmlpaXj33XfFoiDd8mtzKPCIDC2bym1VElX2PXv2rKnHZfeoXszwSh3EZUr61aHLcokMs+u/CT8njyI8QsYYY5Zk76uWFApFoRTMLXAgExoaKg7GELlcLrKSWd5GVumCn5sMR5ti1UXQUtLZG/3LNMOa1mPRpnj6ajDGGGOOlexrymbt+vbtK5Zgm1OBp5ZKlSqFy5cvi+TenFy6dAkBAQFwNLFJyXgcHQsXhQLl/bzzvYyssV8lsTHGGGP2rnLlyvjyyy9FngzlxLi5uendThV+Cz2Q6dGjB6ZPn47u3btna7mdlJSEGTNm4OWXX4ajeBaXgO/3HMGOyzeh0qQvp67o74MPO7bES7WrFvXhMcYYsxHpoyqm5MjA6v3666/w9vYWKShZ01BoAMAigcynn36KzZs3o2rVqhg9ejSqVasmXvz69etYtGgR1Gq1qPzrCCLiEzFg6VqExcVDrXnxE3Q/PArj/9qOiIREvNWsfpEeI2OMMdtg78m+ujZG5lbgQIaWSdGQ0HvvvZetIF63bt1Edd+cOmPbo0UHT2YLYoju2jc7D6F77arwdXMtkuNjjDHG7J1RBfHKlSuHHTt2iIJ4d+7cEcEMtSygujKOIiVNhS3nr2YLYjJTa7XYdvEGhrZsaNFjY4wxZnvobGLK7JAW1m/ChAk57qfBEEpXoRya3r17F6jArlGBjA4FLlRuOLOgoCCRJ7NixQrYs8jEJCSnqXK9j0wiQVBktMWOiTHGmO1yhKml8+fP49y5cyINhVJTaCCEOgTIZDLRu5FmdT766CMcPXpUFN8tlOXXeYmMjDRroRtr5e6kFIXr8mpD4OHsZKEjYowxxqwbjbZ07twZT58+Fcm+FNQ8efJE9Gp84403xOW2bdti/Pjx+X5OswcyjoIClFaVc28zQNNOPepUs+hxMcYYs/G5JVM2K/fdd9+J5deZuwPQ5c8//xxz5syBq6urWBldkMK6VhXI/PLLL6hbt654U7RRJ0xqTqkTHx8vVkpRB24XFxfUqFFDPKaofNChBSiOySmUoQCnW60qqFrCvwiOjDHGmM15PrVk7AYjp5ZoOqdChQoiR4Vqu+TVLzElJUWsTqZ8WScnJ9EzKb/pJNSTMSwsLNt+KqRLPRwJLc9OTU21zUCGApRvvvkGZ86cEVvHjh3FMBR1xiQ01LRr1y788ccfYrk3XadW4H///XeRHG/9MgH4+c3e8HJJr6cjl0pFAEM/Sj3qVMU3/Qy3cmCMMcaK2vr16zFu3DgRmFD+CvVJpDpxjx49MviY1157Dfv27cPy5ctx8+ZNrF27VuS35Aed04cNGyZaFTx+/FhMJdHl4cOHo0+fPuI+p06dEiVe8kui1a2fzqd+/frlent0dLRoxU2JPOZAmcs0FEVvsnbt2hgwYIBoOKVD0SMV6aOhqvygiI+aW1JUmFPjS2OkqtTYd+MO7j2LhKtSiU41KqGsr7dZnpsxxljRKYxzhqHXqLByGqSu+oVmC0KTmIz7b39VoGNt1qwZGjZsqDe7QbMdFFTMnj072/1pMOH111/HvXv3CrSyKPPMCg1C/P7771CpVBmtjYYMGYL58+eLSr8XLlwQ++vXr184q5bow87r9sGDB8NUFAht2LABCQkJYoqJtG7dGtu2bRPRXGBgIA4ePIhbt27hhx9+yHUIjDYd3dCVOSnlMnSvzbkwjDHGin7VUmyW8xxN/9CWFU3fUC7K5MmTszV/pnpxOaFzcOPGjUU+y+rVq0Xg8corr4jBBEr5yIu7uzuWLVsmghYKhmgshaamaL9OfgMYowOZlStXojBRHycKXJKTk8UboyEn3RKsH3/8ESNGjBBTUBTBSaVSUe6YAhxDKKL84osvCvWYGWOMMZOZkOciPH9smTJlkBmVRKFk2qzCw8PFoEHWIrZ0PSQkBDmh4IOWRlM+DZ2f6Tnef/99sWK5IGVX6PxOIzpUPyZzEGMMq8qRIbSunIaVTp48KaoH03DTtWvXMgIZ2k8RIUWRc+fOFR/gv//+a/D5qPowDbPpNqpzwxhjjNmroKAgvfMenQdzk7XJMY2SGGp8rNFoxG1//vknmjZtKlI75s2bh1WrVol+i3mhx8+cOVPM3lCycNmyZUVyL43o0G3GMKkgXmFQKpUZnbVp+Or06dNi6mjBggWYOnWqiAB79uwpbqcVThT0fP/992Jdek4MDakxxhhj1tc00rTHE93K37z4+/uLQnRZR19oVZGhVkMBAQEoVaqUXpoJ5dRQ8EPJu1TlPzeUVExJwrSwp1WrVuJxx44dEyNGNBPz1VdfweZHZLKiN0k5LmlpaWKj6aTM6EswNopjjDHGHLWOjFKpFAtm9u7dq7efrrds2TLHx1DwQcXsKGlXh3JV6dxMaR95oYK5lBJCMy40GFGvXj0xs0J5MzSqY/MjMjTiQsu+aH4vLi4O69atEwm9lCVN0WW7du3w8ccfi4QiGpKi1VGU+UzDWowxxhgreO+jQYMGiRkQyk9dunSpWHo9atQocTtNS9ESaTrXkjfffFNMA7399tsi/5RyZOi8TItw8pPsS7k0OS3Vpn10m80HMqGhoeIDDQ4OFsNWFK1REEOliwkFNvShvvXWW+INUzBDw1C6D5wxxhizVUXRa2nAgAGIiIgQeSt07qUyJ9QUms6vhPZlrilDibk0YkM13Cj48fPzE3VlZs2ala/XoxGYhQsXipzXzGgf3WaMAteRsXWWqAnAGGPMPliyjkzZpdMhfV5g1RiapGQ8enemVZ/faCaF8lwpyZdGgChxmJZ6U4IyBVBUkM8qRmRorqx9+/aikB3Nv9mjmNQwXI7Zj9i0cLjJvVHbqz38nPKeH8zqQUIotj4+gXNRt0E1gRv7VkWf0i1QxrVYoRw3Y4wxVlQoRYRyahYtWoQbN26IPFgqtEt5MlQfzhiFEsjQWvKHDx9izJgxIhvZntCHfijsDxwL/0sEHvQ/6nJ99Nk61Pfuiu6BH0AqkeXruXYHn8Xsa+tFRKrWpicsP0p8hs2Pj2F6rTfRoYRxw2yMMcZsT1FMLVkSLdihYntLliwxanWSRQOZoUOHZhThsTenIv7GsfD14jIFMJnn5S5E74GT1BWdA97J83nuxgeLIEZDz5Bpdk8X0My8ugaVPQJ5ZIYxxhyFqR2stbBqCoUCV65cMVijxlhSU4KVw4cPw5GoNWkZQYwhZ6L+D0nqF8vSDNkcdCzXL5N+HmnKiTHGGLMXgwcPFnVkzMnoERlaHk1DRLRUmpZhUQVeKpJjzx4n3UCSOi7X+6i1KtyNO4Pa3u1zvd+ZyFsZoy850Wg14j6MMcYcBf1xa8pohQTWjvo7UR0ZWvlEq56oV1NmxpRTMTqQ2bRpk1iy9ccff4giNjSNRNV1qUs1temmISR7k6pJNtv98jMCqD9xxRhjzK7Z+dQSoakl6rZNKOk3M2OnnEzKkaH142PHjhXb+fPnRZIv1YGhdeYDBw4UWch5lSu2Jf5O+o24DCnmXDbP+zT0qYzdIWcNjsrIJFI08rGfz44xxlgeHCCQOXDggNmf0ywtCqhgzp49e8RGLQOoidTVq1dF12pq1W0vfJQlUd6tHiQGPjba76csjdIuNfJ8rn5lWuU6tUSro/qUzrlENGOMMWbrgoKCRH+mIgtkaBkVTS+9/PLLogLghg0bMH78eBHUUC8FCmpWr14tqgXak+4BH8BZ5g5plo+Oghi5RIFXSk/I1/BYVY9S+Lj6qxmjLzp0WQoJptYcgHJuxQvhHTDGGLNKtHza1M3KqVQqfPbZZ6IAYPny5UX8QJc//fRTEVdYdGqJOmBSs8Y33ngDp06dQv369bPdp1u3bqI9tz3xdQrE8IoLRN2YyzEHoNamiaCmumdrtC72er6mlXR6lWqG6p6lxQqms1F3RE2aJn5V0a90K1R0L1mo74Mxxph9dr+2ZqNHj8aWLVswZ84cUdmXnDhxQnS/pr5NixcvtlyLAhpt+d///gdnZ+PLKdt6uWmVJlWsYnKWuUEhta3PgTHGmHW1KCi98AuTWxQ8Hj3DqlsU0PukvonUIDqznTt34vXXXxfHbrERGUrqdXRyqRIeUr+iPgzGGGP2wAGSfZ2dncWUUla0T6lUGvWcclNaf+eE8kPoQCtXriyWYfv6+sKe0YDWpcchuBnyDM5yOVpVKQ8/d9eiPizGGGO2xtQ8F63158h88MEH+PLLL7Fy5Uo4OTmJfSkpKaJlAU07WTSQoeXW586dg1qtRrVq1cQJ/fbt22LVUvXq1fHzzz/jo48+wtGjR8XqJXt0KyQckzbsxK3Q8Ix9MqkE/2tcB5N7tIdSnr+eS4wxxpgjOH/+PPbt24fSpUujXr30foIXL14UhfI6deokGkjqbN68uXADGd1oC0VVurk4muejgnitW7fGiBEj8Oabb4qVTLt374a9CYqMxsBl65GYqp9lrdZosf70JUQnJmPe6z2L7PgYY4zZFok2fTPl8daOFgD1799fbx91CDCF0YHMd999J0oMZ04oosuUeUytC6hI3vTp08Vle7Ts8GkkpaVBk0OuNO3adeUWhj9pjFqlShTJ8THGGLMxDpAjs3LlSrM/p9F1ZCizOCwsLNv+Z8+eiZEZXeRFw0X2Rq3R4J8L18XoiyE0xbTtwnWLHhdjjDHmaKSmTC0NGzZMrAenynxPnjwRl2lqqU+fPuI+VF+matWqsDfJaSqkqNS53odGZSITEi12TIwxxmycAxTEKwxGTy0tWbJE5L/Qum+q1CeeTC4XXbB1bQko6Ze6XNobF4UCbk5KJKSkQOamEg1H1YkyQPMiLqTiviW9PIr0OBljjNkQB5hasqpAhhpDLlu2TAQt9+7dE6uWKlWqJPbr5FTt1y5ItKjfxBVXNEGQKtJ/cqhtUspTFyTd9xABDU079W1Yq6iPlDHGmK3gQMZyU0vUD6FDhw6iBTcFLnXr1hXLqDIHMfbsyyt/4ZrsBiTyF+EvtUtyKpUEjwaR0Ci0qFmhBPbeuYu7EZFFeqyMMcaYPTNqREahUODKlSv5ao5ob85F3sOekPPicta3T9dpqsmpbAKuhj3D5UNh+P7gUXStWhnf9XoJrkpF0Rw0Y4wx6+cgIzL79u0TGy0Yop6Nma1YscJyyb6DBw/G8uXL4WiW3NmdZ2MulxKJUGk0GUuz/719F2O3brfMATLGGLNNDpDs+8UXX4iyLBTIUJPIqKgovc2iOTK0rJoSeamWTOPGjeHm5qZ3+7x582CP7sWHZBuJyYxuk8r1I0wKaA7evY9LT0NQN5C7WjPGGHNMixcvxqpVq8zar9HoQIamlho2bCguU65MZvY85USlY2igpaBvUS6VYsf1WxzIMMYYc9jKvqmpqWjZsqVZn9PoQObAgQNwRBXcAnA97r6YjKzr/gR13IPFtOTVhEBcjAuEVitBWkrOPZbiUlIsfryMMcZshAPkyLzzzjtYs2YNPvvss6IPZMiRI0dEPRlafr1hwwaUKlUKq1evRoUKFUS/JXv0TuVO+O7K95hUbj9KKOLFCA3p6XMdT1I9seBxO1wOLQsttJBQgZlM00tlfbyL7sAZY4yxIpacnIylS5fi33//FSueafGQqWkpRif7btq0Cd26dYOLi4vogk1tuElcXBy+/vpr2Ksycjk+r7ALxeTx4rqUcmKexysBilhMLfsvXDVp0GYJEeku/erYZxdwxhhjLD8uXbokasxJpVKRokLdsHXbhQsXYNERmVmzZomkHVq9tG7duoz9NPc1c+ZM2KuTQTPQwDs1I3jJjPZ5y5IwoPoZLInqCKjSx2Ro0GZyp7Yo5q6fEM0YY4zp0PnCpBwZWL/CSEsxekTm5s2baNu2bbb91AE7Ojoa9qq820lQBoyzRAYXiQyyLD869DPYstjdjOsV/XzxQ58eGNokPTGaMcYYY8jo02gqo0dkAgICcOfOHZQvX15v/9GjR1GxYkW7/I7iUx6iglMKXCXOeiuzkrVqxGhSoXk+KuMqTcXMjp3Qpkx5lPX2sutVXIwxxszE1FowWus/11ABPJrRmTt3LuLj01M0PDw88NFHH2HatGliysligczIkSMxduxYUYWPTtRPnz7FiRMnMHHiREyfPh32JlUVj6TwLvCQSLMFJk6Qwk/qhHBNCtRaIErlijfr1IOUAxjGGGP55QCrlqZNmyaK6X7zzTdo1aqV6NN47NgxfP755yIR+KuvvrJcIDNp0iTExMSInkv04jTN5OTkJAKZ0aNHw948CJ+KclLq8p094qXARqYFXCVyJECF6yll0ZmDGMYYYwXhAIHMb7/9JorpvvLKKxn7qFcjrXp+//33LRvIEHpBiq6uXbsmhotq1qxpt40j3VX/QivV5jpNRDkzF5O9EKwuZ9FjY4wxxmxBZGQkqlevnm0/7aPbLJrsq+Pq6ipaFDRt2tTkIOaXX34R68opYZi2Fi1aYOfOnRm3UxCR0/bdd9+hsDlJUnMNYug2KSTYFlMHFdyqFPrxMMYYs8/KvqZs1o5GXxYuXJhtP+2j24wht6YOlqVLlxbzZpUrV84Ygurdu7dYX16rVi0EBwfr3Z+CnOHDh6N///4obMlaZ7hpEwwGMzTPl6KVQAspIpP9C/14GGOM2RkHmFqaM2cOevbsKQri0WAFnVOPHz+OoKAg7Nixw7IjMoXRwbJXr17o0aMHqlatKjaauqJRnpMnT4rbS5Ysqbf9/fffIkfHEqukEhXd81x9dCnZG4/ivLHu/h08S44r9GNijDHGbEm7du1Ef8a+ffuKUi00ndSvXz9R0qVNmzaWHZEpjA6WmanVatH2ICEhQURtWYWGhmL79u1i1CY3VHFYV3WYxMbGGnU8Ffy/RHjwP/CWpmQLaGg0JkkrwbwHzfAgyVdEh7ueXsagiuZtjMUYY8yOOcCIDAkMDDQqqdfsgUxhdLAkly9fFoELrYSi0ZgtW7aIJOKsKIChtecUyeVm9uzZYvTIVHKZM7xLHsGT4O4IlEVkLK2mIOZxmhPG3OqCJynpvZTotvAUHpFhjDGWf/ba/frSpUuoXbu2qBFDl3NDebIWC2QKo4MlqVatmui3QENO1M9pyJAhOHToULZghnJw3nrrLTg7O+f6fFOmTMGECRP0RmTKlClj1LE5y4vBv8RhvHpoMrr734ZMosGByPK4mVhc735qrRbFnT2Neg3GGGPMntSvXx8hISEoXry4uEyzGjQIkBXtp9kYiwUyhdHBkiiVyoxkX1oNdfr0afzwww+iy3bmrts0n7Z+/fo8n49q29BmLl5KV1TxboYVT71FwJITmUSClwLrmO01GWOMOQA7rex7//59FCtWLOOyuclN7WBJqINlZuYsyS9WA2XKcSFUFbBRo0ZGL9Uy1YfVu+Bk+F2kqFXQ5DApOapqB/g52Wc9HcYYY4XETnNkypV7UVvt4cOHIi1FLtcPP1QqlVi9lPm+hR7IFEYHy6lTp6J79+5i6icuLk501T548CB27dqlNzVEScDUp6GoVPIojlUtR2Dmpb9xNeZFwysvhQtGVu2AN8s3L7Jjs0ZpKjUO/ncbx87eg0qlRtWKxfFyhzrw9XIt6kNjjDFmQbTSmEqp0DRTZrpOARadWioMtBKJVkHRm/Ty8hJTVhTEdOnSJeM+FNzQKM0bb7xRpMda3SsAa9qMwu3YEDxMiIC73BmN/MpBIbWqj7TIPQ6JwtgvNyL4WSykUpoXBQ78dxu/rj+Oz0Z3R5dW2Ss8MsaYI7LXZN/M6Pyd06xNREQE3NzcYAyTzrqUq0K5K3fv3sXGjRtFr4TVq1ejQoUKaN26dYGfj6aM8vLuu++KzVpU8SwpNpZdapoKY77ciGcR6Su4NJoX/5Wp1Fp88eMOBBTzRO2qgfzxMcaYnU4tEd0KYwpihg4dqpe7SqMwlK5i7Epoowvi0Yqibt26wcXFRVTe1eWx0JTQ119/DUey5fp5DNm+DGP2/oU7keFFfThWg6aTQp7FQp0pgMmMgvI1/5yx+HExxphVMrU9gRZWi2ZZaKMRGSqdortOGxW4pQGKP/74w7IjMrNmzRJF8QYPHiyme3Qoopo5cyYcwY+ntyMIK1DX6wn6Vk+GSivFpsfLcfxEHazo+AX8XIwbJrMXR8/cFdNJmUdiMqMAh+5jaKiRMcaYfVi5cqX4t3z58pg4caLR00hmDWRo+XPbtm2z7admj1QDxt79eOb/4Oz+LVop06dN6DyskGhQ1S0Ulas9w3tH4/Fbh5/gItdflu5oSb6GghgdtVoj8mY4jmGMOTw7nlrSmTFjBszN6KmlgIAA3LlzJ9v+o0ePWqT3UVGiEYRw2RIUU8aJE3Dmk7BUQpsG/cqfxdyTu+HIqpQvLkZkDKHPrXxpv1zvwxhjDhfImLLZAMqpfe2119C8eXM0bNhQb7NoIDNy5EiMHTsW//33n5gWePr0Kf78808xZPT+++/Dnm28fRK1PZ6KoCUntN9FloYH6o2w10Du1I1H+GHLEczfdBh7z95CWg5L5np1rI3cQhQaiflfD+N+cBljjNmeH3/8EW+//bZYfk35tU2bNoWfnx/u3bsnyq9YdGpp0qRJGeu+qcovTTNRFjIFMqNHj4Y9+y/sBNoE5r7WXa2VIMA9EvYmODIWYxf9jTtPwyGTSsWoikqtgZ+nK+a/1xu1y79YwVXM1wOTR3XF17/sFsGubpqJghu61K5pFRHsMMYYc4zl1z///LPoCkAlVKhnIsUSNIszffp00QnboiMyhLpXhoeH49SpUzh58iSePXuGL7/8EvbOx8knz/tIoIVaI4M9SU5V4d35G3E/JEJcV2s0IoghUXFJGLVgI55G6HcX79m+NhZ9PgAtGlTIaLRZrpQvPn6nM2ZNeFkEQ4wxxhzDo0ePMpZZ06pnWulMqIbc2rVrjXpOk6u3ubq6ip5IjmRYjX7Y82QpvORJBpNUaXpJldAE9mTP2Zt4Eh6T420aaiWRpsL6gxcwvr9+Enj9GqXFRiMyGo0Gcrl9BXiMMcbyh5ZaU/E7akVAGw2CULsh6sGUUyPJ/OA/h40Q4O6Fc+G1DAYxNIMSnOyJL1tPgj2hXJjcVhfRcuqdp28YvJ2SejmIYYwxx0327dixI/755x9xefjw4Rg/fryo3j9gwAD07dvXqOfkevpGmtN8MWaefQNN/W+LwEWX90EjMZFpbmjq/ROcsjTFsnVxSSkiQTc3icmpljocxhizK46QI7N06VIxMk9GjRoFX19fsdq5V69e4roxCnSmpRLCtWvXhpTzGuAkk+Orphvw991/cCl6BbyUsUjVKCBNa4nxDadAJrW/+jGVAv1w9UGIwUq9FMSVL+lr8eNijDFmGyh+yBxD0DJs2kxRoECmQYMGGV0rKcv49OnTYtmUI+tdqRd6oxccQf/WdbDl6BWDt1N881q7ejneFvksDns3nUbQ3TA4uzqhVbfaqN+iMlf0ZYyxzGxgVMUUFDu0a9dOdAbI3G+JFg7RUmxahl2ogYy3t7dIyKFA5sGDBxnDQ8wx1CxXEoM6N8Lqf89mTKXpUO5Mi5rl0aNpjWyP27H2JH7+YqtICKZl2HTf7WtOoFq9Mpi5bBg8fRy7lQNjjDlKZd8HDx5ALpejTZs2+Pvvv0VxXV3jyIcPHxZ+sm///v1FJEXdremERKuVKLrKaWPmkZJ2G1FxKxAV9yuSUs4bndVtLuP6tcH0gV1Qprh3xj5fDxe893JLzB/1CuQy/R+pk/uv4cfpm5Emk0DlrIBKKROdr8ntK0/wxXu/Ffl7Yowxa2BKw0iJifk1lkKxw65du1C6dGkRQ9DMjqnkBU3SoVbc1JpgzJgxGDFihOhiycxPrY5EcOQYJCTvf15CjjYNnBR1Eei/GEp5+SL7IezTqjZ6t6yFsOh4UUumuLdHtgCGpKakYfaEP6Eq5g7QkmtdUyUamUlIhSwuGdfOPsD18w9Rs2HRvB/GGGOWQ3+4uru7Y/PmzZgyZYoYHKHYglYuGavAy2peeukl8e/Zs2dFiwIOZMxPq01F0LPXkZJ2XbcnY8wwJe0qHoX2RfmS/0IuK7r8JApoSvjkHsR+PXIZEjxcMj8o41+tmxJqCeCUmIoTe69yIMMYYw4wtSTJVMNj9uzZqFWrlhgUoUq/xpKb0pKbulzPnTsX169fFwdXs2ZNDBs2DF5eXkYfEKNlzjuQkmYoqVYNteYZouN/h7/XeKv9uBJiEnDs3CPAyz3n1tYUzLgqoUlOQ0pKWlEcImOMWRVHWH6tzZJKMHDgQFSqVMnoGjImFcQ7c+aMePH58+eL/giUcTxv3jyx79y5c0YfkCOiLzY+LQlxaYnicmzCpjy+Gg1iE/6CNTt34Cq0hoKYTFRKOSpUS0/2YowxZt80lI5QvLjevhYtWuDixYvYv59SKSw4IkPV+F555RUsW7ZMZCATlUqFd955B+PGjcPhw4fhaFJUYQiO34T41JuQSpxRzLUT/Fw7QCrJ+WOmoGVz0FH8G/wnSiofixSSJ6ll8H7gfbhKcl8RptZYd0PK+ISUPIMYIpVL0f7l+hY5JsYYs2pFNLX0888/47vvvhPlVWiqZ8GCBWJVUV6OHTsmclyovtyFCxdgihIlSojNooEMjchkDmLEk8nlopOlo/VeIk/jNuFmxGfQZvwkSRCSsAWuioqoX2IFnOUB2YKYGZe+QwPXNRgWEC1qsBCp5ApS1VI4yySQGhwnlEAhLwNrVq9VNeCXg1T9KNf7NW9TDS5uL2oJMMaYwyqCQGb9+vVi8IGCmVatWmHJkiXo3r07rl27hrJlyxp8XExMDAYPHoxOnTohNDQ019do2LAh9u3bBx8fH1GPLnOeTFbGzOgYHch4enqKLpbVq1fX2x8UFORwCcCRSSdwI2Jajj9FiWkPcSF0OJoF/gOJ5EWzxO1BB9DGYyU8ZMkZVXF1ZFJ1LkEM0cLLbSCsWWD54ijppkBIgkr/zWUxZtorFj0uxhizd7GxsXrXqfBc5uJzmVFKCPU8otkUQqMxu3fvxi+//CKScQ0ZOXIk3nzzTchkMmzdujXX4+ndu3fG6/fp0wfmZnQgQw2e6M1///33oiU3RVjUL+Hjjz82KfvYFj2MWfo8p0Wdw61qJKbdRUTSIfi7dszYezVqITp459w9WysBUrUSKEAF5LLeKoWzsi683AbAEhJTUrH5xBVsPnkFYTHx8PNwRd/mtdG/RR14uOQ+kjJjwUB8MGIlRN3EzMHM82XYAwY0ha+fe+G/CcYYc6Bk3zJl9EfsZ8yYgc8//zzb/VNTU8UK5MmTJ+vt79q1K44fP57rYp+7d+/ijz/+wKxZs/I8Lnr9nC4XeSBDAQwFLzS0RLkxRKFQ4L333sM333wDR6HRpiIq+USuY3oSyBCeeEAvkKnpeieXZ5UgUStHilqJAKUUGm3c871O8HQbgOLen0EqzbSsuZBEJyTh7Z/+wv2Q9Hwc7fPGkQv+OYKNxy9j1ZjX4O9puCpvlRql8fPy4fhq2kYEhaW/B+LiJMfgYW3x6hstCv09MMaYo00tBQUFiVkTHUOjMbRIhyrqZs1NoeshISE5Pub27dsi8Dly5Iheaokx4uPjs3UIyHzc+WX0USiVSvzwww9i6IkiM8r5qFy5MlxdXeFINNq0PH/y6FaNNkVvn6ssNddcWKlEggStEpUCz4jaMVqo4aSoAZm04F+ysWb9tQ8Pw6KyvTsaUHkaGYPP1uzGL6P65foclasFYuXGMQh+Go2goAi4uChRs2YpyORGL5hjjDGWC09PzwIFBFlzVuh8nlMeCwU9NJ30xRdfoGrVqkZ9B9TmaPTo0Th48CCSk5OzvSa9RkGZFk7RCdnVFXXq1IGjkklc4SQLRIr6aS730sBdqd+DKFrlDndZssH0EY1Wgug0DzHy4uJk+eTp0Oh47Lt0R/RHygl1wD5+4yEePYtG2WIv2hUYEhDoLTbGGGPWkezr7+8vclyyjr6EhYXluIIoLi5OLPQ5f/68CEYIjahQEEKjM3v27EHHji9mHnLy1ltviX9XrFghXiO3xF+LBTKOjr6EMp6DcCdqjoGfIgmtMUKAu36Ck1rWHVLJaoPPS8m+SifzJ0Xl19VHIQaDmMwuPQzOVyDDGGPMugriKZVKNGrUCHv37tUrSEfXKUE3KxrluXz5st4+Wu1E9V82btwo+jDm5dKlSyIvp1q1ajAXDmTMoLTnQEQkHUVUsi45SpuRG0PLsWsW+xYKmY/eY/qWn4Ztd/eitFNItlEZWor9MLk0+lWZiKIizWWlUWYyM0TTjDHGimb59YQJEzBo0CBRNoUK01HfI1qRPGrUKHE79UN68uQJfv/9d0ilUlEzJjMqbufs7JxtvyFNmjQROTwcyFgZqUSJeiUW40ncWgTFrkayKohO8fBzaY9yXiPg5dwg22MUMmf0qLgX2+6PQGnFaSil6fOCyRo5nqY1R5/KSyGXFl2c2aBCKShkUqSpNbnm8TSqXNqix8UYY8x8BgwYgIiICMycOVMUxKOAZMeOHShXrpy4nfZRYGMuv/76qwiSKDii16JFQpnVrVu3wM8p0WZtfJBP9MZoiVdOSUIUbeVWSKeo19dTLygq5mNMdnR+VzJJIIdEkr+E1vi0SNyPPSY+y4qebeAqt45eVbM27MOm45dznGKib71z3cr4flivIjk2xhizl3OG7jVqjP4aMidno59HnZKM6wunFuqxmurkyZMiYfjBgwcZ++jcVyTJvjQXRpFa1p4J1HeJbjPmYOxphKYg3BW+qONnfQHBxN7tEPQsGidvPRKBizZTDRh5jApXl1/AP54l0evVJkV9qIwxZvscoPv1sGHDRHXftWvXFn2yr6HlWbQunObLmO1zVsrx86i++OiztTj+6AnUSglkqVq4hKXCKUIFmnRa+M12eHm7om3nWkV9uIwxxqzcw4cPsW3bNlGuxVzkxiQGEQpiPvvsM726MTQK899//6F+fW4CaAytlkIDiVkiVHN5FhKD63tuw8dApE+HunrJAbTpVNOqjpsxxmyOA4zIdOzYUXS6LtJAhtaP60ZkaBkWLd/Socv16tXDxIlFt9rG1tDn+DB+H65HrUV4yjWxWLuESyPU8nkLgW7Ni/rwcPzADXFML5ph6qOZpkf3w/HkUQRKl/O3+PExxpi9oD8FTflzUALr16tXL4wfP17ED1SDLmuy7yuvvFL4gcyBAwfEv2+//bao7GutCUW2EsSceTYfN2L+gkT0aqJwQYvQpLMISTqNRv4foqZPevGgopKUlCqWYqvVuYf6SYmpFjsmxhhjtmnU82XdtEoqK2OTfY2uE09FcDL3WaB5L+qaSZX9jEXdNmnpla68Mq1p37lzp959rl+/LiI2yvCmLtvNmzc369IwS3qaeEIEMUQrMk6gd/ls+E+ISrmNolSmvD/UuSzBJjKZFCW4ai9jjJlnasmUzcpRJWBDm7GLhIwOZKjqHxXIIdHR0WjatCnmzp0r9lNAYozSpUuLhpNUApk2mkuj57t69aq4nXo6tW7dGtWrVxd9GmiejfJ0bDW5+Eb0BlE0T0cJNVwkaZBmKqh3K2ZLER4h0KJdNXh6uRjsCyWVSdG2Sy14ejlWjy3GGCusyr6mbI7I6FVL586dw/z588VlKk1csmRJkT+zadMmTJ8+XXTBNmbuLLOvvvpKBEW07rxWrVqYNm0aevTogTlzqB1AuooVK+b6nCkpKWLLvF7fWkQkXxfNIP2kSaigiIGXLH16RqWVIFjlhntp3ghPTg/iiopCIcfHX/TFjI/WUdEhaKjs8HNSmQS+fm54Z0yXIj1GxhizC3aa7Pvjjz/i3XffFYMOdDk3Y8aMsVwgk5iYKKZ2CE0n9evXT5QvpqkemmYyFQ0xbdiwAQkJCWKKiYadtm/fjkmTJqFbt24iaKJ6NVQ+uU8fwz2JqDs3deq0RjKJAgGyeNR0ihRJszpyiRal5fHwkSXjAYp+WXPT1lXx/dKh+GPpQZz7757Yp1DK0blnXQwa2QF+/uk/B4wxxlhWNOhBzSIpkNENgOSEcmQsGsjQ0qmtW7eKRlO7d+8WWci6rpmmJABTJjMFLtTe293dHVu2bEHNmjVFd06qUUNTT7NmzcK3336LXbt2iQCKEpDbtWuX4/NRoKNbMq4bkaGKxNagnFtTlEw7q6sxp4euu0GFyooXbc6LUq16ZTF70WDExiQiMSEF3r5ucHYuWOE/xhhjtjmqYor79+/neNlcjM6RoekjWmZdvnx5NGvWTAQfutEZqtpnLGokdeHCBTGdRNNTQ4YMwbVr18SIDKGcGQqaqFbN5MmT8fLLL2Px4sUGn8/JySkjeVi3WYvyTsr05XYG8k9ov4uaAp00WAvKhSkZ6MNBDGOMmZkj5MjMnDlTzOhklZSUlONKpkINZF599VWxWoiScmlkRKdTp065Dh3lhWrR0GgPdeKkaSGqS0PLvP39/cUqKRqdyaxGjRo2u2pJro0EJC+SfXOi1cZDo4my2DExxhhjhYVSPWh2JSsKboxNAzGpvTIl+NKWGa1eMnetFUrWpQCH2n/fvHlT7/Zbt25ldOm0NRKpmyg2l8e9IJHwiiDGGLN7dprsm5/2RrQK2dfXFxYPZGjZ9fLly0VtFzowGh0ZPny4qPFijKlTp6J79+4ihyUuLg7r1q0Ty6x1Iz4ff/yxaDnetm1bdOjQQez/559/xH1skYvLy0iINzwtBsjg5NQaUqk7rElocDR2b7+IkOBoeHi6oEOXWqhes1RRHxZjjNk0U6eHJFYcyPj4+Ig4gbaqVavqBTO0uIdGaXTF8iwWyNCUEq0ecnFxEaMwFGXRlNLXX38t8mQaNmxY4OcMDQ3FoEGDRFdtCoaoOB4FK126pC/vpcRiyoehKSfKbKZ8GlruTbVlbJFC0QBKp7ZITTlGX2WWW9P7Tbt7jIO1oO/4j5VHsHr54fQfQvqhBLB5/Sk0b1UF077sB2dn/XLTjDHG2IIFC8Q5hLpf0xRS5gEPmnGhfFtdrm1BSbT0zEZo06aNyGVZtmxZRoVflUqFd955B/fu3cPhw4et8pujVUv0AcbExFhF4q9GE4eoyFFISaHWD7LnaUtpkEjc4O3zA1xcesBa7Pj7HOZ/uyPH26iNQfvONTHl874WPy7GGLPlc4buNeoM/xoypfEFXtWpybi8fKrVnN9ycujQIbRs2TJbjyVTmDQikzmIEU8ml4s6L5Soy/JHKvWAn/+fSEu9gqTkHdBqkyCXV4GLSx9IpdaTG0NtCv5YedTg7VQob/+eq3h7ZAeUDPC26LExxpg9sOepJR0qlUJTSVRIN3NaCq1IzhxPWCSQoWiPVgtRu4DMgoKCMgrlsfxTKGuLzVo9uPcMz8Jyr4pMs00nj95Gn/81sdhxMcYYsx1XrlwRQQvVhqP0EN2inWLFimHbtm2iI7bFll9T0i0l9q5fv14EL48fPxbJuTS19MYbbxj7tMxKpSTnXctGIpUgJcV6at4wxphNcYCmke+8845oOUQxA7U6oo1iCMqJpTYGFh2R+f7778WQ0ODBg0VuDKE5LypiR9V3mX0pXdZXdLnOrRO2Rq1F+YrFLXpcjDFmNxxg+fXFixdFagqtYtKhy9RbkUqsGMPoERnKMqZCdVFRUaISL/U+ioyMFCuXqJouMx7lX6cWoJ15fGoqbkdG4GlcbKFW9KVkXmoUaWhayVkpw9E1R7Bt6X4kxGSv3MgYY8yxK/tWq1ZNrFDOitob0QIii9eRIa6urkbNabEXQhLjsPbWRZwKCcLjyBg8C02ENg4I8PDAG43rYVCzBnBVZs/wfpaQgO9OHMHft25kBD51ipfA+GYt0aF87l3BjTHyw864evkxwkJi9LpgU7MorUYL1aMQ7L96H/+uOYbln2/E5F9HoEUP49tVMMYYsy9ff/21KJ/y+eefiybThFoSUXsC6qFIK7h08rvyyujl11TLpUSJEmJNeGYrVqzAs2fP8Mknn8AaWdvy6413L+OT4ztF40iN7qugQQ8VoAxRQK6SombJYvht6P/gpnzRpPFZYgL6rP8ToQnxUGf6CmmIja591/kl9K9h3s7Zaakq/Dbn/7B18xmkKJSATCqCGElcIiTh0ZBkzo+R0IosKX74dyqq1C9v1uNg2d25H4Yd+64g9FksvD1d0KV9TdSrWTrHCpqMMetcfl1vsOnLry/+bt3Lr+m8oKP7/aQLQzJfp8u0uqlQR2SWLFmCNWvWZNtPSTyvv/661QYy1uR06GN8fGzHi2lNiRZ+bgko5RUFuVSD+BJOCLlcAtdCnmHRwZOY1LVtxmPnnTyWLYghugyWTw/8i66VKsNDaZ5pPsqN+XLYUpzZd1X8kIkOUVIJtGpNepOF5009M9AwJ4ANP+7G1BUjzXIMLDsaGVuw9F9s3XkhI4dJJpPgnz2X0KxhBXw5uTecnbhIIWO2QEIncOPGFgRTHmspBw5QzTTzMjqQoaVTAQEB2fbTEiqqzMvytuTqf5BKJKjg9gxNfR+hnG8kIiTOCFW5pd/BB6gRGIzrl8th/bnLGNuxJZzkciSmpWHLjWvZgpjMUtQq/HPrBt6sXc8sX8WRbWdx+t8rGdfTg5dMPTNkMhHUiKGl5+ikenz7eYO9NZjp1mw+JYIY3eed/m/6d3D6/APM/WUvpo2znqKKjDHH1q5dO+sJZKgf0rFjx1ChQgW9/bQvMDDQHMdm1+jkfvnZRaxu9jequUdknP/pfP8kzQ1/xdREgiZ9NKVW3Yc4l6zE05g4VPDzESMxKXkMucmlUtyPNl/X7P9bdVhU79XLjcnyfsRUk0r/uFSpKvEYGiVg5pWapsLaLacM3k5TlXsOXsOIgW1Q3J9rOzFm9Rxg1VJOfRpr1qwp0lSM7dMoNWUt+Lhx47By5Uo8fPhQbJQfM378eIwYMcLYp3UYanUcVjdbgypuEeL689ZFQoA8AcN8LkDxvP8SxQiVqj6Bk1xM6MA9U65Mbicxc00rkSd3wwwGMUTXeynrvlKVSogpD2Z+N26HIC4+Odf7UIB56tx9/vgZswGOsGrpzJkzqFSpkljhTCudw8PDMW/ePLGPaspYdESGWhHQQbz//vtITU0V+5ydnUVuzJQpU4x9WocRFTcPvorkrOd+QSoBPKVpaOL6BMcTy4r7eHknwsUlPZm2mKsbGgeUwrmQpy8ShLOgaaeelaua7XjdPF0QHR5n8Pacc8a1eOXdjmY7BqYvLS3vRDj62aGRG8YYswY02PHKK6/k2KeRBkeM6dNo9J/K9Nc2LZWiFUq0dIqK3FBgM336dGOf0qGkJG3O8z51nfXX2ieo4jMuj2vWIj33JIfHUd4NBTGVfP1gLh36NxVTS4aIWzIVy6Ofjwbta6Ln2+afD2Xpypf1y/U7IRRfVqlYgj8yxmyBA1T2PXPmjBjwyKlPI91mDJPH/N3d3UU1vtq1a3MhvIJ88Nq4HEdjdOg2F6lK74R0N+HFFEGrMuXw00svw5WWQVNVZakUsudPSEHM911egjn1HNwGHj5ukOYwTUQnUwWtjHm+csk/0AfDZvTDF+vGQK4wuVQRM8DPxx3tWlQ1GMzQ/gpl/VG7OuesMWYLHGFqyfN5n8asTOnTyGeZIpKidYECaWIaKScUuCRo5BmX07QKRKbqJ+/2rFJNFL7beecW7kVFijozL1Wqgoo+vmY/Xu9iHpizZTy+GLoET++FQSanGjLpK2XK1yyFGatGwdPHDWlpKrh7ufIqJQsZ+24n3LwTgpBnsXo5TDKpBC4uSsyY+DJ/F4wxq6Hr00htjlq2bCl+Px09ehQff/yx0X0aOZApImplB0hVfxu8nQZXrqb4pxfKgwRJajncZM+XZWfiqlCYvfBdVlEJSdhx8SbCYuLR7tteKJ0oxZOLT8Rf/PVaV0OtZpUyTpbO4PYUluTr7Yalcwfhr21nsW3XBUTHJsHVRYmXOtbC632aoGRx41YBMMaKgAOsWvq+EPo0Gl3Z11ZZS2XfxLSneBzSGr7S1GxTTPSNRGiUWB7RAPFqZyRpFJBAirn15sJH+aLRVmGjH41fD57Gwr0noNZoIJNKodZoxSjSiA5NMbpLC/5r38qo1BrIeZUYYzZZ2bfRgK9Mrux7dv20Ij+/5UdiYiLu3r0rzjPUY4naHRmLR2SKiKsiEGujWuJlr9MoI0+As0QGhSR9eXWURo5/oishWuUGjVYCaCXoVKKTRYMYsubERSzYdUzvJEmo3triff/BWSEXAQ2zHhzEMGbDHGBEpjD6NBYokJkwYUK+70vrwlnuopMrYENaCj4qeQXuUjUVyhWrf4rLgPH+d7EzPh5boirCOaEq3ihr3NyhsVJVaizaeyLX+yzdfwpvtcq5oSVjjDFmCQUKZM6fP693/ezZs6KpE7XlJrdu3YJMJkOjRo3Me5R26vpjd6xoeh0+0vR6ILrEX91MUw+PUFwJLoFmpQdAKrFsUbmz9x8jJjH3YmuJqWk4cfshOtUyrvU6Y4wxfbaw8simA5nMzZ5oxIWWSv3222/w8Umf8oiKisLbb7+NNm3amP9I7VA9j4coKU8vJpgTGqEZWO4WAspYvnt0XLLh48osPp/3Y4wxlgdKkDQlbVXrmFGQ0X/mz507F7Nnz84IYghdnjVrlriN5a1Hmbsi38TglyMBAp2Skap6aPGPs7x//vJxyvl7F/qxMMYYY2YPZCjLOjRUv/IsCQsLQ1yc4VL27IViLnn3TCLBiZcs/rFVDfBHrVLFRZXgHGm1kCdrEXQ5+88AY4yxgnOEgnhWFcj07dtXTCNt3LgRjx8/FhtdpkI3/fr1M+9R2ikvt4Z5fgFJGim2Bi9DaNIdWNoX/btAKZdlb4Mghj8Bj/tpmD9/Nw4fuWnxY2OMMbvjAC0KrCqQWbx4MXr27ImBAweiXLlyYnvrrbfQvXt3/Pzzz+Y9SjtV3Gcc1fYVuTA5of2XUtxFA8ijz/7I13PSmvxjoXcx/tRG9N+/DCOOrcE/QZeRqsm7wWBWNUoVx8I3ekEZrX4x96rVQhmjge+NNCgTtKIGzsqVhw00jWSMMcYKl9yUNeAUsHz33Xd6RW3c3LJXn2U5U8h8EOk6Eb6Jc0TQolu1pIsJQtRKnEjyhRYa3I0/hWR1PJxl7gY/TpVGg4mnN2Pnk2ui7xIFQFJIcDj0Dn69dRyrWg+Cj1PBig49ufEMPnfVUMtU0MglkKq0yNQCShzrw4cRePw4CmXKmL81AmOMOQqJJn0z5fGOyKQ1vUeOHMHIkSMxatQo+Pv7iyBm9erVom8Cy58SXu/ghKY3bqW6ZiT+xmlkOJLkg/WxgVAhvUgejRlGJkfm+lyLbhzCrifXxGUKYojm+Vjj7dgwTDy9pcBfS1JiqmhFQMEL5cRkDmL07pfEq5cYY8wkPLVk2UBm06ZN6NatG1xcXHDu3DmkpKSI/ZTo+/XXXxv7tA7J2bk5ticEYn5UBcyNrIClMeVxKtkX6owgBlBrJOi8dD1mHTiI5LS0bM+RrE7D73dOGZwiFdNTYXdxN/ZZgY6NRlmoMWRuZDIJSpTgnj6MMcZsKJChZdaUJ7Ns2TLR8EmHullSYMPyr6ZXh+dl8KSgyaCsNBoJ7j4tgRS1DL+dO4/hm7cgTa2f83I9OgTxqvRg0hB6hRPP7hfoq2nZsgo8PZyz9YPSodGatm2rw8vLpUDPyxhjLMvvaF61ZNlA5ubNm2jbtm22/dSoKjo62tindUjucl/Udf2fuJw1Z5aCmFSVDGduV0q/rtXiZNBj/N8N/ZVCuqmk3Emg0hZsElWplGPSpJ6iOSQFLZnRdR8fN4waSYEYszepajX2PryD1dfOY9f9W0h+3qmWMVbIBfFM2RyQ0cm+AQEBuHPnDsqX1686S/kxFStWNMexOZSox/Vw7MElNKhxF64uL/JNnkT44Ni16ohLepGkS7Vd1l66hL61ambsq+ZVHEqpLNfVSVpo0dC3TIGPjUZl5s19E6tWHcGFi4/EPrlchs6dauLtt9uiWDGPAj8nMy/KZbp946n4PVapakm4exjfQZf8fecaPj++H1EpSWIkj349eiqd8EnTtnirRn2zHTdj7AVTa8FIHDOOMT6QoSTfsWPHYsWKFeKv9adPn+LEiROYOHEipk+fbt6jdAB+Hm64cb8Mbj4oBd8SMVAqVIhOcENcUvYpGxqVCYqO0dvnoXBG/3INsP7BWXF7VjKJFNW9SqCubymjjq9u3TKYN+9NREcnIiEhBb6+bnDJZ0E/VnhSU1VYtXg//tl8FinJ6blTCqUM3V6ujxEfdjHqO9p+7ybGHtiecV330xSbmoJpR/eKQPqN6vXM9h4YY6xIAplJkyYhJiYGHTp0QHJysphmcnJyEoHM6NGjTTooR9SxTmVItwAaqQShkd7pk34G8lJot49L9gDn4zqdcS06GBejnmT8FU1oCbavkyt+aPaqycfp7e0qNlb0KAn7i0/+wpmT6eUPdNJS1dix9Rzu3Q7Fdz8PgULxImk8LxQEf3XyRU+1nHx76jD6V6kNpSz/z8uYJaUkpSL0UTicnJUoXtZP/LFtE0wtaqeFQzI6kCFfffUVpk2bhmvXrkGj0aBmzZpwdzdc54QZJpNK0alcBex9fB9StRaaPLKX+teulW2fm1yJ1W2HYPPDC1h//yyeJMbAW+mCPmXr4Y2KjUUww+zHyaO3cPpEzhWfNRotrl1+jAO7L6Pry/mfCjoX+gRPE3JvMRKdkowjjx+gU7n0vC3GrEVCTCJ+n7kJu347hOSE9MUP5WuVxpuT+6Ddq81g7XhqqQjqyOgK4zVu3BhNmzY1OYj55ZdfULduXZEwTFuLFi2wc+fOjNuHDh0qIuvMW/PmzWEvfhraG7U9i0GiMhyZU6G7QE9P/C+HQIY4yeQiaNnaaSRO95qEvd0+xAc12nIQY4d2/n0+WwJ2ZvTfx/atBVtBGJGclM/7JRboeRkrbAmxSZjQ6UtsW/JvRhBDHl57gq8HLcTmH1+cS5h9MTqQ6dixI7744ots+6OiosRtxihdujS++eYbnDlzRmz0PL1798bVq1cz7vPSSy8hODg4Y9uxYwfsBZ14No0diNVvvIrKUi/INS9OUrrmjXVKlsC611+Dp7NpyZzM9oUER4mRF0NouonuUxCBbvlL3A505wRvZl02LtiBRzeeQpOl7pVu2nXplLUIf5J7UdEix6uWLDu1dPDgQVy+fBnnz5/Hn3/+mdGaIDU1FYcOHTLqOXv16pVt6opGaU6ePIlatdJHICgPp2TJkvl+TirUpyvWp+vabe2aVSmL3ROHi8s3nj3DiUdB4nLjUqVEIMMY8fZxQ9CDCMN9riTp9ymI2v4lUNnbF3ejI3OcbqdwuoSrO1oElOUvgVkN+m/g/5buyxbEZP1Dcffvh/HWlD6wVjy1VARTS//++y9CQkLE9M6DBw9gTmq1GuvWrUNCQoKYYsocQBUvXhxVq1bFiBEjEBYWluvzzJ49G15eXhlbmTIFX35clKoXK4a3GzUUGwcxLLMuPerl2qyTgo6uPQu2VJp+2c9s1UWMAFKSeNbnIzNbdRY5XYxZi8S4ZMRG5J7bRZ7cDrHI8TDLMum3EdWSodEXymtp0qSJCDJMRaM8lGtDIy/Uw2nLli0iiZhQZ20a/dm/fz/mzp2L06dPi+mnzCMuWU2ZMkWsrtJtQUHpoxuM2boOXWqjfKXikMqy58nIZFKUCPDGS70KXvOlZWBZ/NHjNVT19dPbX8HLByu69UfX8lVMOm7GzM3JRQGpLPfTGc3Ou3pa+ZQ891qy7NSSbjkbBRwUXFDLAspf+eSTT2CKatWq4cKFC6I6MPVzGjJkiAiWKJgZMGBAxv1q164tkozLlSuH7du3o1+/fjk+Hx0fbczyElVxCE95ArlUiZLO5SCV8HJdc1I6yTFn4SDM+WKrWIJN6D9LGqSpUbs0pnzZD27uxv3ibhFYFjv7DcWNyGcISYxHMRc31PIrbjvLWJlDkSvkaPlKIxzfdtbg9JJapUG7V617cQhPLVk4kMk6pP3pp5+iRo0aIvAwhVKpROXKlcVlClRo1OWHH37AkiVLchwRokDm9u3bJr0my/17vvwgBNtOXsWzmAT4ebiiV7OaqF8p0OBJLUEVg53Bq3A5+gg0SK807CH3Qdtir6KZX3c+GZoR5cB8veAtBD0Mx4UzD8T3VbteWVSsYnouFX2/NfyKi60gkpNScfPqE2jUWlSqXhKeXrzsnxW+1z9+BSf/7xy0Wgm0WZLgabSmVosqqN2qGn8VdsjoQOb+/fsoVqyY3r7+/fujevXqYsWRudAvZkNTRxEREWKqiAIaZn4qtQbTf9+FnWduQiaVQK3Rin+3HL+CDvUq4Zu3e0Cp0P8RSlLHY+ndKYhKDYUWL/4yilNFYXvwMsSqwtG15GD+usysTDl/sRWltDQVfvt5P/5ZfwrJSelVhuVyKTr2rIdRE18yenSIsfyo0qA8Zm7+CLMHL0JcVAJkCpkIaGiEpkGHmpi6erT1/xFFAVguKxHz9XgHVKBAZsKECfjyyy/FCiUaJTG3qVOnijwYSsiNi4sTyb6Ud7Nr1y7Ex8fj888/F8ESBS6UXEz39/f3R9++fc1+LAxY9M8x7DqT3pySgpjM/x68dA/fbzqEqa930vuojj37O1sQk9mRZ1vQ0KcT/J2Ma5XArBMVxPz6kw04cfCm3mitSqXBv/9cwP1bIZi7YjicnBVFepzMvjXqXAdr7v+Eo1tO48HVIChdlGjRsyEq1SsHm8CVfQs/kKGl1mlpaRmXDTE26g0NDcWgQYNEfRhaYURJxBTEdOnSBUlJSSIR+Pfffxf5MxTMUHuE9evXw8ODa1qYW3xSCtYevGCw4jWdrGhk5r2XW8LH3SVj3+nIPQaDGCKFFOei9vGojJ05d/Iejh+4keNtVOvmzo1g7Nl2Hr1ea2rxY2OORemkQMfXW8IW0ZnTpKaRcEwFCmQOHDiQ42VzWb58ucHbXFxcsHv3brO/JsvZ+btPkJJGJYZzn3o6ffMRujZKn3dWaVORqM69Tg914I5KzX3JPLM9u7aeE3kIudXx2LHpDAcyrNCFPYnErj+P4/71p1A6K9CiWx206lEfCqVJHXmYFeNv1k7djnmG1bfP4GDwXdEIsGnxshhSpTHq+eVvSidNZfiElFmqKj2Zl8gkCsglCqi06aN2OaHqJK4yHkGzNyFPonINYmi2KTRYv2M7Y+a2/fejWDTtL7F6j5LNqTTB4W3nULLs/+Gbvz5EiTL6JQWsjq6yrymPd0AFzpHJr3nz5hlzPMwMtj+6hnEnt0ICCdTa9JPL/z26hr8fXsGn9bvg7Wp5D+9XK11Mr4O2ITXKvFjRIpVIUde7LS5EHYDGwPQSrWKq692mgO+IWTtvXzfR9ym3lgle3DWdFaKzh65j4ZT14rLup5CCGRL2JApT31iEpQenQSa33jIQvPzaAgXxKC8mPxvVgWFF41FcFCac/FuMwuiCGKK7POvCXpwNf5zn85Ty90LLmuXFKqWc0H5agl0pMH2lzO2rT/DHz/sQtr04JBqZGHnJivZVcq+Hsq41THiHzBp1frl+rkGMRCpBt94NLHpMzLFsWLQ3x+KQhEYLn95/hlP7XvTtYy/8/PPPqFChApydndGoUSMcOXIEhmzevFnkrdKqZV1z56JO+zA6R4ZZl2NPH2Lp5VM4EnYHUGjE0GpOqHv2qlun0Mi/dJ7P+dmbnTFk7no8i44XgZEO/eXt7eaCLwd3Q2x0ImaNW4NLp++LHAl6XaftpVF5wlM4+aVAS40vJVoxulPDqzn6l/nQ+pdAsgJr3bEGqtQMxN2bwRl/BWeuMuzj744erzbmT5YVitSUNFw8lns9MZlcilP/XkGLbnWt91soglVL69evx7hx40Qw06pVK1GzjVYPX7t2DWXLZu+pdvjwYRHIfP311/D29sbKlStFn8T//vsPDRoUzR8rnCNjB1ZfP49Pj+8VQQqcdUGMFhKJFlJp+k82FYnSaGiqCTgZ9jBfz1vCxwNrPnkTaw6cx5bjlxEZlwQvN2f0aVELAzs2EquVxr+5GHeuP834q0cjlyBaXgLBSwLgWz4GHiUToFVL8eyOLxLKVUT/CXITG2Mwcwt9EoXta0/ixL/XkJaqQrV6ZdDrrRao3bhCvp9DrpBh9i+DMXf6Fpw4lL5kX6da7VKY/PWrXBiPFRqq2psX+lssLSX3BQxFTaLVis2Ux+fUHDm3CveUBjJ8+HC888474vqCBQvECAs1bKZehVnR7ZlRQPP333/jn3/+sc1AhoafKHq7e/cuNm7ciFKlSmH16tViiKp169bmO0pm0IPYKHx2fK+4rNZqkT77q4VCoc4oV59OC5mM6npkbQWYO18PV4x+pZXYaHl15tGUU4dv4taVJ3r3TyzrBo2TTNTKj3zoIzadkzEPseSvY/jwrXb8jVqJiyfvYsbIVSKA0U0NhYfE4PCOS3jj/Y4YPLZrvp/Lw9MFny94E0+DInHh1D2o1RrUrFcWlarlv1s9Y8ZwdlWKRN7QxxEGRyWoOF7luo7Rtb1MlubIM2bMEHXYskpNTcXZs2cxefJkvf1du3bF8ePH811Diuq++fr6oqgY/bcx9UHq1q2bWBZNeTG66rv0hihCY5bxx/ULolOxjlYtEUGMDt2k24hcrkE9P+MqIWedEjq867Jeoza1kxRqD+WLF8uCAqHN/15EYnKqUa/PchcVk4g798PwLB9dgEl8bBK+eO83pKa8CGIIBSBk7c/7ceLfgucUBJbxRY/+jcVSaw5imCXQ76bew9sZ/iNNAiic5Oj0qpXXMdKYYQNExfvMzZKpeXJOwsPDoVarUaKEfksTuh4Skr9O4dTAOSEhAa+99hqKitEjMtQkcvHixRg8eLCowKvTsmVLzJw501zHx/JwOTxEjMTo0HRS+r/Z76sboTFXOYXE+GQRjeuo3BXpL5BLDkxyShpuPQhD/ep55+iw/Hn4OAKLfz+MY2fuZozA1a1ZCiPfaoO6NQ1/zv9uOSv6IhkayaZcqC2/HUWLzrX4q2BWr9fQtrhw9KZI6BUrLrUvcrTo4qSFQ+Bh5SvnzDW15OnpKbZ8Py7L7+yso++GrF27Voz00NRS8eIF68lmTkaf0m7evIm2bdtm208fHlXeZZbhJJPrLZOWKXKfK6afzdMR+cuRyUupcv7pS26zJHfmxUFLHZgkNjIee9Ycx397LiItVY0ajSqgx9B2UDnJMWryGhEgZv5cr9x4ijGfrcecz/qjaf3yOT7nlTP3c31NGqW5+rwRJSdoM2tHeVrTl4/ArjUnsG3FITy6EyKK4LV8qS76j+qEKg4yrVQQ1OJHJpNlG30JCwvLNkqTU5Iw5dZs2LABnTt3RlEyOpChFgF37txB+fL6vySPHj2KihUrmuPYWD50KlsJh5+8OCFlnkYyJEVtnoS3l15tjA0rXizTkyeo8nxxpUKGquX0m42y3N04ew/T/vcDEuOSM/oY3Tr/AFuX7odv74YiiMm69Jmu01fxzU+7sGHpu+Kv0mzEd5WfakGM2QaqEdNzcGux2WQAbuFVS0qlUiy33rt3r17PQrreu3fvXEdihg0bJv7t2bMniprROTIjR47E2LFjxZIr+mF5+vQp/vzzT0ycOBHvv/++eY/SwcSkJCE4IRap6he5Lob0q1wLvs6u6SuW6ASmkuY64kGpvlU8i5ltRGbQB8+bRkoAWbIasvg0g0MudIivdKgDN9ecs+dZdgmxifj0tR+RFP8iiNGtEFM7yfEoIs5g/Ra6+7PIeJy5mPMIXJ0mtCrJ8A8LjbbVblIh28ng6YNwXP7vLoLuhPJXxqyWzQUxmSv7mrIVEBW6/fXXX7FixQpcv34d48ePx6NHjzBq1ChxO+XXUAqJDgUvdJ1yY5o3by5Gc2ijXBybG5GZNGmSOHBq3JicnCymmWh5FwUyo0ePNu9ROogTIQ/x4+WjOBn6SFx3kyvxeuV6+LBOK3g5pTdmzMpD6YQ/u7+Ggbv+QnhSIjSpcsDZ8IiLBloMrGi+hLe33u+IEqV8sHbpATx5EAHXR/GIr+QJrfJ5jCxqhWup7C+kz+LQKsDKS4RbmX/XnxTBTE6/n7T56CRNH//jkCg0Q/al1J37NMLvC/YgKTFVrOjIigKkfm+/qMJ888JDLPliC66ffZCxr1KtUhg+rTcatK5asDfGGMv+36vWxKaR2oI/ZsCAAYiIiBC5rdSwuXbt2tixYwfKlUvvGE77KLDRoZXKKpUKH3zwgdh0hgwZglWrVqEoSLSZ/8wzQmJioiicQ0mfNWvWhLu7O6wZra+nztoUhBUkGaqw/d/D6xhzZKv4KyJz8TkaaSnv4YtN3QYZDGZIkioN/9y7gUOP7+F+cijupwSL0RcKXIjub5POgTUwv+mrkEnMW8yFfoxCHkdiUtdZCA16htSyfkgr7w+tUg5JYgqU955B8TgKAeWKYdWNBbb511IRmPHWQvy351KOAydqdyckN0j/ZZObaWO746X2tQzmyXz6zgpRX0M3skPTULRyaeCHnfHW6PS57+tn7+OTAYugVqn1RoDE9ygBPl8xAk071jT+jTLmwOcM3Wu0a/kZ5HJno59HpUrGoeNfWt35zWpHZN5++20MHDgQHTt2ROPGXLHTFPFpKZh0fLu4nDmIIbQi6UFcJH64fBTTG3cx+BwucgVeq1pHbGR/8E0sv3UM5yKDxPXSrj4YVLkZ3qjQxOxBjO6EFvU4AqF3gsV15e1QsWUVfC8U147fQq1W6R2zWe7EUmhDq4riUyBJToPWSW4wN0khl6FVk0oGn5+K3v26eyJ2rPtPLLWmpdjV6pZBr4EtUaP+i+TIRZ9uhEqlzjZyI/IQAPw0ZT1WHZ+Rcy4OYyx/uGmkZQMZGoqiJB8/Pz+8/vrrGDRoEOrXr2/s0zm0bQ+uIVmdZjBbgYKZ9Xcu4pMGHcQqpfzoGFBNbDRSo9Kq4S53KvRRkNBH4fm83zMOZPKpRuOKOLf/ao55MPRtOj2KQHJVwwXn3uzbBB5uuf+F51/CSxS+M1T87v71p7h7Vb/wYdbfveHBMbh0/DYatOEAlTFjSTTpmymPd0RG//m0bds2keBDFQOpMiBlPtPUEhXDe/DgxRw6y9vdmIg8R0kSVWkIS4ov8MdJIzUeCmeLTOV4+Xvk636e+byfrVNrNDhy4R4+XbIDo7/fhNm//Yur9/JXZErnpYGtIaVuvYZ6Z4XGonfLalDSFB79ZSL6XUlEoi4FMcNeb2Xy+wgNiszf/R7n736MMWZOJpVGo4ZR7777rtgeP34sspkp83n69OkiGYjlj6tcka9Vc65yZYE+Uhr2Pxp6D6vvnMGVqGAopTJ0LVUdAys3Rln3F60DzKVu2xrwLu6J6DD9Ph9Zg5j6BvI17El8YgrGzt+CS3eeptfa0WhFx/DNBy+hb/s6mDyos9ifF7+S3pi89B18PXypCFR0VXepojKtXOr3XmeMmPgyRiWmYv+xmwgLj4W3pys6tKoGPx83s7wXD5/8FRHzMNPrMeaweGrJKGap8ZqWloYzZ86Ipdg0GpNXIR2mr1uZalh4xXBfC0rarV8sEH7OrgUKYr6+uBerbp8SCcO66r+/3zmFNXfPYmnrAWhZIv9NAfNDrpBj+FdvYu6IxQbvM/yrN8T97AG1WngaEQsXpQKB/p56o14zft2FK/fS84V000Lq5/9uOXgZpfy9MKRn/laPtX65IX4++Bm2Lt2HEzsvQpWmQo1GFfHKiI5o0rm2eF13Nye80rVwuvpWb1ge/gHeCA82XOjS1d0JjdtXL5TXZ8xhFEH3a3tg0hnlwIEDWLNmjei7RP0a+vXrJzpgUgIwy7/afiXRPrAijgTf12s3oKOFFmPqFKwJ547H10QQQzI/J13WaNV47/gGHH15jJh2MqduQ9uLE+2yT/5EYlxSxmiEi4czRsx+C92H2f7PRnRcEhZtOYrtx68hVZVe66digB/e7d0CnRtXxaOQKBw+fzfX5/hj11m82a2RSMbNj/I1SmHc/MEYNx8WRwm8w6b0wpwxqw3eZ9BHPeDkXLARQ8YYK9JApnTp0iLhlxpH0rryXr16wdnZvCdFR/JTmz744PAWHA6+L/JlxDSCViOmg75q3h3tAgtWLXnlrf/0ll9nDYySVKnY/OAShlQxfxO1niM6o9NbbXDy/84iMjgavgHeaP5yIzjbQSG8mPgkDJu9Fk/CYzJGWMj9kAhMXvx/mPh6e/G563cezy46Pgm3HoWhVkXjGnhaWoc+jZCakoalX2xBYnwKpLL01hRKZwUGfdQdvYdlb1fCGCuaXkuOxuhAhvJg/ve//8HHx/y5Fo7IXeGE3zq9jksRwdj16KZYkl3Jyw99K9SGp7JgASIFQJcin+Y6yiiBBGfDgwolkCEUtLR/rSXszcodp/A4PCbbKiLd74/5fx3C8J7NxedLAWNu0lTmXWJA04kUZMhkkkIJGrsNaI72vRvixJ4rYprJx98DLbrVgas7/wHDmFlwjoxlAxlK8GXmV9cvQGymoJNofnroSLkoXYGo1BpsOXzZYEuAjKXIsfHZ6gFlpZBLUbGUeaocp6Wp8OWnG3HizH2IFHuNFn5KOd4b1RGd+pq3xhNNH7V/paFZn5MxxkxhUvWqI0eOiKJ4LVq0wJMn6XUmVq9eLRpHsqJDAUqTYmXEFIchNOXUvHjOXZFZzmITkpGQnJrrxyORSsSUU/kAX7FKKSe0v0fLmvDMo75LfiQlpaBXr3k4cv4hVPR6VJBOLkWEVotZC/di0Vd/89fJmK2gv380JmxaOCSjAxlK8KX8GBcXF5w/fx4pKSlif1xcnKglw4rW8KotcsyPIRTgeCmd8UrZ2hY/Llvm6qTIs7M4Dcl4uDjhmw9ehpuLMlswQyuMKgT6YewA8+SUjHx3BVKeL8nOODjdv1IJNu69gtuX06s7M8ZsI0fGlM0RGR3IzJo1C4sXL8ayZcugULxoXteyZUucO3fOXMfncB5ce4wlU9Zi5ps/YcHoFbh05IZe1+P86hhYBRNqtxeXMxfboyDGTaHE8jZvFLgujaNzdlKgTd2KBkdaCI3GdGlSDZVK+WPNzMF4vUtDeLu7iMeUKuaF0a+2xvJpr8PD1fTRmKioBASFxBhsTyD2K+VY9cs+k1+LMWap5demdL+GQzI6R+bmzZui43VW1KgqOtpwvQmWMwpWlkxegy2L9kAmp2JnWrEyZOeqQ2jYsTZmrB0DZ7eCJXC+V6M12pSshD/vnMGlqGA4y+ToElgN/6tQH37OXLzMGMNfbo5jlx9AItFmW5VEU3otapdDrQrpLQNK+Hpg3OvtxFYY9u+/ZjiI0dFqce1O9p5XjDEGRw9kAgICcOfOHZQvr59nQfkxFSsWbKkwAzYv3C2CGKJ+vppFrUo/U144eBXzR6/AlJXvFfijqu0TgNlNevFHbCYUpMz7sDem/7oTMQnJoiUAJfZSAnDb+hUxc3h3i33Wuiq/eaEqwIwxG8CrliwbyIwcORJjx44VLQlo3v/p06c4ceIEJk6cKJZms/yjAnLr5/6fwdvpJHlw40kM++J/KFHWnz/aItaqTgXs/P5dHDh/B/eeRsBZqUCHBpVFgm9h0Wg0OHvsDk4fuwVVmhpVa5VCk0bl8csybe6jMhIJmjbhPywYswn0t4kpbfE0cEhGBzKTJk1CTEwMOnTogOTkZDHN5OTkJAKZ0aNHm/co7dydCw8REx6X633oZ/v0nkt4+R3br4xrD5QKObo1tUxJ/tCnUfjs/d/x6N4zMe1Idmw4DTd3J/gGeiIyJinnYIaS/zRajJ7YwyLHyRhjNtei4KuvvsK0adNw7do18Rcjdb92d3c339E5iLSUtLzvJJGIyqrMsaSmqjB5xEqEPo3Wm3YkiQmpkD6IhNzfTdS4EbKUFJ7yUQ+4ebpY/sAZYwXGlX2NU6BAZsKECfm+77x584w5HodUtnqpjG7Ghmg1WlSuW86ix8WK3tG9VxAcFJnjbWI1m1qLzo0qIFEuxbGTd6HWaNKXeJfywaef9UGFisUtfsyMMSNxjkzhBzJULyY/MncBZnnz8vdAu/5NcWjTqRyDGQpyAioUR53W1fjjdDDH9l0TRfYokDWU8Pvf/hvYfOIzix8bY4zZXCBD3a5Z4Rj17Vu4efY+Qh480wtmKIhxdlVi2u/vc4DogJITUw0GMTo85ciYneARGaPwukwr4V3MEz8enIHXP3pZXCZUN6b70Hb4+fiXqMTTSg6pfOUSuS6fpsHP0hWKWfSYGGOFxKRieFq9/DhHYlWBzC+//IK6deuKonq0UQ+nnTt3Glz+TVNYCxYsgL3w8HHDkOn9sf7+T9getRxbQ5ZgzA9DxbQSc0wv9W+ce+6UFnjljeZmf13Kv7l+MxhzF+7GpBkbMXveDpw5/yDXhpmMMWZzq5bMrXTp0vjmm29QuXJlcf23335D7969RW5OrVq1Mu63detW/PfffwgMDIS9kius6qthRSAlJQ2XHoTCt1U5BD2KgCxVA0VMCmTJanE7BfKNWlVG197m7UZNeTdzftyFXf9egUwmgVqtFf/u2ncFjeqXw1ef9YWLM7e3YMzsuI6MUazqbNmrV69sy7tplObkyZMZgQx12aY6Nbt370bPnj3zfE5qZqlraEliY2ML4cgZM6/Q8Fh8OOMvPAmNFgGL1kUOjQuQ5qWEIjIZgVIl+r7ZAn0HtYRcITPra/++7rgIYggFMZn/PX/pEeb+tAeffvyyWV+TMcbLr+1iaikztVqNdevWISEhQUwxEapVM2jQIHz88cd6IzS5mT17Nry8vDK2MmXKFPKRM2b6tM6kb7Yg5FlMxvXM0nyd8dqkrvjfsDZmD2JoFGjD1jMGb6eppX8PXUdYHgUcGWNG4BwZ+whkLl++LIrqUZXgUaNGYcuWLaLQHvn2228hl8sxZsyYfD/flClTRAVi3RYUFFSIR8+Y6c5fDcKdB89EJ+2cUHGDNX+fMaorel6u3QxGQmJqrveh1z197r7ZX5sxxmx+aolUq1YNFy5cEB20N23ahCFDhuDQoUNISkrCDz/8gHPnzhVoGTIFRLQxZitOXXwImUxqsCkkhS805UTTTyWLeZn1tVUqtVnvxxgrAPrjRWLCHygax0zGt7pARqlUZiT7Nm7cGKdPnxYBTI0aNRAWFoayZcvqTT999NFHYuXSgwcPivCoGTMfmkLNT6iuep63Yk6VKhSHVCrJc3VStSolzf7ajDk8riNjH4FMTsPYlKxLuTGdO3fWu61bt25i/9tvv11kx8eYudWsEvCid5IBXh4uKOnvYfbX9vVxQ7tW1XDo2M0cgxkKcipVKIbqVQLM/tqMMWbzgczUqVPRvXt3kZAbFxcnkn0PHjyIXbt2wc/PT2yZKRQKlCxZUkxHMWYvWjepDH8fd0TGJOQYTNDU6qs9GkAuN2+ir8649zrj9t1QPA2OhiZTHg4FMR7uzpg+SX91IWPMXEwtaqd1yK/CqpJ9Q0NDxQgLBSadOnUStWIoiOnSpUtRHxpj2cSnpuJ6+DPcj44ya+KtXCbFN5/0gbOTQgQPOrrcsKb1ymFQn2aF9o14e7li8fxBeHtgKxTzcxfVg708XfBa3yZY/tNQlC2t/wcFY8xMeNWSUSTawlj6YMWojgwtw6YVTFQ9mLGCik5OwnfHj2Lz9atIUacnvVbw9sGHTVugT/UaGfej/7TOXXiEfw9cQ3RMIooX80D3rnVQvWr+pmVCnsVi485z2Hv0BhKTUlE20Af9utVHt3a1RLDDGLOPc4buNTpX+BByqfGLU1SaFPx7/yeHO79Z1dQSY9YuNiUZr25Yi4fR0VBn+hvgQXQUJuzZgdCEOIxs1BRJyan47MutOHPugV513L+3X0CPbnXx0Yddxcqk3JQs5onRg9uLjTHmAMRUMq9aKij+s46xAlh85nS2IIbortFITXBcHOb+uAfnLjzMsTrujt2X8Of6k/y5M8b0aTWmbw6IAxnG8okSX9deuZQtiMnqtzNnse/gtVyXMK/ffBopqSr+7BljzEQcyDCWT/GpKYhJSc71PpSOe+Hh0zwXHiQkpODGzWD+7BljL3Cyr1E4R4aZBSW23ngQhtiEZAT4e6JsSR+7+2Sd5QrIJJI8RmQkcEL+lkWnpXF1XMZYJpwjYxQOZJjJ9p2+hYXrj+DJ8yaHpG6VQHw8qCOqlStuN5+wUiZD10pVsOfubYPBjFqrwSvVq+MnpOfHGELLqiuU9y+kI2WM2SSu7GsUnlpiJtl+9BqmLPw/vSCGXLkbjHdmrcOtR8/s6hN+v3HT9GmjnOIYLdCweAD6Nq2DShXTS/3nhPa3a10Nfr7uhX68jDFm7ziQYUZLTk3D96v3w9MnHl37nMQHEzZizMS/MGDIHviWiECaSo0Faw7a1Sf84GEknJ4AEt2sUKagRp4IxF5PEKPD0yf3gru7c7Zghq4HlPTCmPc6Wf7gGWPWTfw+0ZqwwSHx1BIz2qGzd1G66k30630YrrK0jARXf7dY1Hr3EY5fqoldW1oiJCIWJf3sozjTqn1noEiWQPYAULkBGictoJFAngDI0iQIRTwOXrmLzvWq4NeFQ7Fx62ns3HMF8QnJ8PVxxys96qFf70ai1D9jjOnhqSWjcCDDjBYcfx19ex+BizRNXH9eQT9Dq3rX8CzMC6ERcXYRyMQmJuPW03BxWQIJFAm0/Ej/TculUvx385EIZKiS7/sjOoqNkqF1LQYYY4yZDwcyzGgS/91wlaZmC2Ay/3HRuc05uxl9yNxAsaD34yCGMZb3Lw8qaKcx8fGOh3NkmNGc3S7nejsFOO7OKYjX3rOLT9nL1Rml/b1ErRhDVBoN6lcItOBRMcbsBteRMQoHMsxoEvGXgxYyqCGHGhIDmWYpafF28SnTqMqg9g0N5tNJJRJ4uzmja4OqFj4yxhhzXBzIMKNotKnwkUngIU2BqzRN5Mm4SVLgLEnVC2g0WgnK+Va3m0/5tdb10KNR9YzARUcmlcBZKccPI3rDScEztowxI/CIjFH4Ny4rMEpcvfXsQ7jJQ/X203ldrtVAJklFglYJrVaCsKiaKF4xwG4+ZVo+/dWgl9CpfmWsP3xRJP+6OMnRrUFVDGhTH4G+tp/UzBgrIlzZ1ygcyLACi035D5FJe3O8TQxSaLVQQI3oFA90rvSd3X3CFMzQqiTaGGOMFS0OZFiBhcVvpMkUKshv8D4yrQzNA7ci0KsMf8KMMZYPWq1GbMbSmvBYW8aBDCuwFFVwrkEMjcooZRoOYhhjrKA5MmJ6yUhaxyzty4EMKzAneQkgJfcRGYXMjz9ZxhgrCION3AryeMfDq5ZYgRVz65trEEM/VsXdX+NPljHGWKHjQIYVmJdzK3g7tzXw4yODUlYcAR6D+ZNljLGCVuY1dXNAHMiwApNIpKhWbDGKu/0Pkiyzk55OTVCn5EYoZL78yTLGWEFwHRmjcI4MM4pM6ozK/rNR1ucjxCafhFargptTHbgqKvEnyhhjzGI4kGEmUcr84e/2Mn+KjDFmIq1GA62El18XFAcyjDHGmDXgVUtG4RwZxhhjjNksHpFhjDHGrAEVw5NwHZmC4kCGMcYYs5qpJROWUGu5IB5jjDHGmE3hERnGGGPMCmg1WmhNmFrSOuiIDAcyjDHGmDUQ3atNmVrSwBHxqiXGGGPMWkZkTNyM8fPPP6NChQpwdnZGo0aNcOTIkVzvf+jQIXE/un/FihWxePFiFCUOZBhjjDEHtX79eowbNw7Tpk3D+fPn0aZNG3Tv3h2PHj3K8f73799Hjx49xP3o/lOnTsWYMWOwadMmFBWJ1sEm1WJiYuDt7Y2goCB4enoW9eEwxhizYrGxsShTpgyio6Ph5eVVaK9Bz90aPSCHwujnUSENR7Ej2/nNyclJbDlp1qwZGjZsiF9++SVjX40aNdCnTx/Mnj072/0/+eQTbNu2DdevX8/YN2rUKFy8eBEnTpxAUXC4HJm4uDjxL/1gMsYYY/k9dxRWIKNUKlGyZEkcDdlh8nO5u7tnO7/NmDEDn3/+ebb7pqam4uzZs5g8ebLe/q5du+L48eM5Pj8FK3R7Zt26dcPy5cuRlpYGhcL4QMxYDhfIBAYGimjVw8MDEokEtvCXgCOMHjnSe3W09+tI79XR3q8jvFeatKAghs4dhYVyTWjKhgILcxyvJMu5zdBoTHh4ONRqNUqUKKG3n66HhITk+Bjan9P9VSqVeL6AgABYmsMFMlKpFKVLl4YtoV8Q9vpLwpHfq6O9X0d6r472fu39vRbWSEzWYIa2oiDJEvjkFAzldf+c9lsKJ/syxhhjDsjf3x8ymSzb6EtYWFi2URcdmgLL6f5yuRx+fn4oChzIMMYYYw5IqVSKZdR79+7V20/XW7ZsmeNjWrRoke3+e/bsQePGjYskP4ZwIGPFaF6TkrQMzW/aE0d6r472fh3pvTra+3Wk92qvJkyYgF9//RUrVqwQK5HGjx8vll7TSiQyZcoUDB48OOP+tP/hw4ficXR/ehwl+k6cOLHI3oPDLb9mjDHGmH5BvDlz5iA4OBi1a9fG/Pnz0bZtW3Hb0KFD8eDBAxw8eFCvIB4FPFevXhVJ0LQkWxf4FAUOZBhjjDFms3hqiTHGGGM2iwMZxhhjjNksDmQYY4wxZrM4kGGMMcaYzeJAxspQPwyqjph5owJE9uLw4cPo1auXyHSn97Z161a922kRHX0GdLuLiwvat28vMuPt8b3SaoCs33Xz5s1hi6i5XJMmTUTrj+LFi4uGczdv3rTb7zY/79devl9qJli3bt2M6r1UR2Tnzp12+b0y28SBjBWqVauWWAan2y5fvgx7kZCQgHr16mHhwoU53k5LAOfNmyduP336tAjiunTpktHs057eK3nppZf0vusdO0xvGlcUaDnmBx98gJMnT4piWdR3hRrL0Wdgj99tft6vvXy/1NLlm2++wZkzZ8TWsWNH9O7dOyNYsafvldkoqiPDrMeMGTO09erV0zoC+vHbsmVLxnWNRqMtWbKk9ptvvsnYl5ycrPXy8tIuXrxYa0/vlQwZMkTbu3dvrT0KCwsT7/nQoUN2/93m9H7t/fv18fHR/vrrr3b/vTLbwCMyVuj27dtimLZChQp4/fXXce/ePTgC6v5KPTwyt4iniqHt2rUz2FLe1lGRKZqaqFq1KkaMGCF6ltiDmJgY8a+vr69DfLdZ36+9fr/UKXndunVi5ImmmOz9e2W2gQMZK9OsWTP8/vvv2L17N5YtWyZ+SVDPi4iICNg7XSOygrSUt2Xdu3fHn3/+if3792Pu3LliWJ6G7VNSUmDLaACKype3bt1aVAm19+82p/drb98vTW+7u7uLIIUquG7ZsgU1a9a06++V2Q55UR8A00e//HTq1Kkj/uqpVKkSfvvtN/HL0hEUtKW8rRowYEDGZToBUtO1cuXKYfv27ejXrx9s1ejRo3Hp0iUcPXrUIb5bQ+/Xnr7fatWq4cKFC4iOjsamTZswZMgQkSdkz98rsx08ImPl3NzcREBD0032Trc6qyAt5e1JQECAONHZ8nf94YcfYtu2bThw4IBIErX379bQ+7W375e6JFeuXFkEY7Rii5LYf/jhB7v9Xplt4UDGytEwNHUYpV+C9o5ygugXY+YW8ampqeIvP0Mt5e0JTR8GBQXZ5HdNf4HTyMTmzZvFVAp9l/b83eb1fu3t+83p/dPvJnv7Xplt4qklK0Ot0Kn2SNmyZcVfNbNmzUJsbKwYyrUH8fHxuHPnTsZ1ShakIWtKkqT3PG7cOHz99deoUqWK2Oiyq6sr3nzzTdjTe6WNam/0799fnNiou+zUqVPh7++Pvn37wtbQUuQ1a9bg77//FrVVdH+he3l5idoiNM1gT99tXu+Xvnt7+X7puGnKu0yZMmJJNSX7UhLzrl277O57ZTaqqJdNMX0DBgzQBgQEaBUKhTYwMFDbr18/7dWrV+3mYzpw4IBYppp1o6WqhJZz0hJ0WtLp5OSkbdu2rfby5ctae3uviYmJ2q5du2qLFSsmvuuyZcuK/Y8ePdLaopzeJ20rV67MuI89fbd5vV97+n6HDRumLVeunFapVIr306lTJ+2ePXvs8ntltklC/1fUwRRjjDHGmDE4R4YxxhhjNosDGcYYY4zZLA5kGGOMMWazOJBhjDHGmM3iQIYxxhhjNosDGcYYY4zZLA5kGGOMMWazOJBhjDHGmM3iQIYxxhhjNosDGWa12rdvL/q42MvrMOtHjR2LFy8ueiMV5s/Gq6++innz5pn9eRlzRBzIMMZMcv78eSgUCrRp08bmP8nZs2eLpq3ly5cv1NeZPn06vvrqK9EQljFmGg5kGLMDqampRfbaY8aMEV3bL168SE1oYauSkpKwfPlyvPPOO4X+WnXr1hXB0p9//lnor8WYveNAhtmEXbt2oXXr1vD29oafnx9efvll3L17V+8+NA1AJ9VJkybB19cXJUuWxOeff653n4SEBAwePBju7u4ICAjA3Llz83xtOuEsWLBAb1/9+vX1nnvjxo2oU6cOXFxcxPF17txZvBahk/ucOXNQsWJFcXu9evXE/U15v/ReR48ejQkTJsDf3x9dunTJ92vl57PMrzVr1sDHxwcffPAB4uLicO/ePdiqnTt3Qi6Xo0WLFgbvQ5+dl5cXfv/994zv4cMPPxTTT/Q5lChRAkuXLhXf/dtvvw0PDw9UqlRJPHdWr7zyCtauXVuo74kxR8CBDLMJdGKgk/bp06exb98+SKVS9O3bFxqNRu9+v/32G9zc3PDff/+JE/rMmTOxd+/ejNs//vhjHDhwAFu2bMGePXtw8OBBnD171qRjCw4OxhtvvIFhw4bh+vXr4jn79euXMTrx6aefYuXKlfjll19w9epVjB8/HgMHDsShQ4dMer/0XunEe+zYMSxZsiTfr5XfzzIv9DxTp07Ft99+i9KlS4sT/IULF2CrDh8+jMaNGxu8fd26dXjttddEEEPBcObvgYLJU6dOiaDmvffew//+9z+0bNkS586dQ7du3TBo0CAkJibqPV/Tpk3FY1JSUgr1fTFm97SMWal27dppx44dm+NtYWFhFCVoL1++rHf/1q1b692vSZMm2k8++URcjouL0yqVSu26desybo+IiNC6uLgYfB1Srlw57fz58/X21atXTztjxgxx+ezZs+JYHjx4kO2x8fHxWmdnZ+3x48f19g8fPlz7xhtv5PEJGH6/9F7r169vltfK6bPMjylTpmhHjhyZcb1FixbaTz/9NOP6/fv3tY0aNdKaasiQIdp//vlHW9h69+6tHTZsWI4/g4sWLdJ6eXlp9+/fn+32zD9zKpVK6+bmph00aFDGvuDgYPH5njhxQu+xFy9eNPhzwxjLP3lRB1KM5QdNfXz22Wc4efIkwsPDM0YPHj16hNq1a+vlHmRG00dhYWEZz0G5JJmnDmgKqlq1aiZ9CTR906lTJzG1RH99d+3aVaxKoamGa9euITk5OWPqR4eOo0GDBia936yjB/l9rfx+lrmhKSSaQrly5UrGPnqsLY/IUI6Ms7Nztv2bNm1CaGgojh49KkZRssr8MyeTycR0Hf0s6NB0E9H9HOrQ1B/JOlLDGCsYDmSYTaCVJGXKlMGyZcsQGBgoTr504sya5EqrZzKTSCQZJ2pjE1Fp6iXrY9PS0vROXjR9dfz4cTFd9dNPP2HatGliekv32tu3b0epUqX0nsPJycmk90tTaJnl97Xy+1nmhqasaKkyTSllfv2sr5v5NZ8+fSqmUWi6j6beaIlz7969Rb4RTbFQQEDTN/SdUaBFuT2U66P77On+FCCeOXNGXKcEYzruoUOHIj4+Xtz25MkTcdv3338vgkrdNBsFeH369BGvbQhND0VFRWXbT8dHU0T0XE2aNBHHl9fPXOZ9uvtnnbqLjIwU/xYrVszgMTHG8saBDLN6dMKk3BPKA9Et8aW/jguqcuXK4gRDIxFly5YV++jEdevWLbRr187g4+hEQ3kwOrRk9v79+3r3oZNVq1atxEZLa8uVKyfycEaMGCGCCBrtyO01zPF+a9asmedrmeOzpKCN8nJo2TXl6OhQzg3lCdFr0KhEZpRHQqNfMTExaNasmcjJIXQs69evF6NiHTp0EMdC74GSamkVFD1XjRo18P777+d6TLt37xavSY+jwIcSj2mEaseOHThx4oT4fihoosuGknlp1OqPP/7Itp+SdSkpnBJ7KWhduHAhzIFGsygQpACKMWY8DmSY1aMpGjpJ0VQGTRXRiXry5MkFfh5aqTR8+HCR8EvPR0P+NHJCIy656dixI1atWiVGFehYaLSATmg6NPJCSbM0pUTF1Oj6s2fPxAmYVq3QyAGNYNBf5LRaiAIhGr2h4xkyZIjZ3m9+XsvUz1KlUmHs2LHiM6SRisw8PT3FvzS9RFNtmc2fPx/btm0Tl+k1Q0JCxGUKYKpXr54RSNCoCwUvFOgolUpxjPT554Wmcuh904o1eiwFK/SdUODSqFEjcR8ataFpNUOBDI3gTJkyRQS39DllVrVqVZEkTsEMBW9ZV7EZ48iRI+JnhjFmGg5kmNWjQIOmHGhpNU0l0Mnvxx9/FCeVgvruu+/ECY2WvtKJ/6OPPhKjBLmhkxvlhNAyZVqZ8+WXX+qNyNAJnFa80MmNAgcajaG/4Lt37y5up/tTgEPF1uh5aNlzw4YNxYofc7/fvF4rP89NQRstHc5pKo6mzSjQoKXfWdF0laura7ZAhgIAGsGhkTDKC6HARbdSJ/OUFwWHarVavG7W6RtCAUTm6ZnMq30o0KARIppWo0CLVhXR87z77rtihCw/KBiivKO//voLI0eOzHY7fVb79+/PGJnJz9J9Q2iqi0bsaCSJMWaiAiQGM8YcAK3GotU4ptKtWtq6dav21VdfFfv+++8/rUQiEbdlXdX00UcfaVeuXCnuQ6vNUlJSxIofb29vsWqJrpcoUUIbGxsrVqBVq1ZN3J88efJEm5SUJC7/8ccfYqUWrcKqWbOmNjIyUuwPCgrShoeH53rM27dv19aoUUOrVqu1hWnhwoXaLl26FOprMOYoeESGMaaHRgl++OEHs30qNGWzaNEiMRVFK7wyr+jJCa0MosdQ8i+NgrRt21bsp6kmmjqiEaYqVaroPc/ly5fFtBqNlNCoD1XopZyhTz75RIyg0EgOjcDRaFTW/J3MevTogdu3b4ukYRphKiyUq0WjW4wx00komjHD8zDGGGOMWRxX9mWMMcaYzeJAhjHGGGM2iwMZxhhjjNksDmQYY4wxZrM4kGGMMcaYzeJAhjHGGGM2iwMZxhhjjNksDmQYY4wxZrM4kGGMMcaYzeJAhjHGGGM2iwMZxhhjjMFW/T9Xm0WKIbiXKAAAAABJRU5ErkJggg==",
+      "text/plain": [
+       "<Figure size 640x480 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Plot all of the points in the optimization histories\n",
+    "fig, ax = plt.subplots()\n",
+    "ct0 = ax.scatter(area_tight_history, lcoe_history, c=case_id_history / max(case_id_history))\n",
+    "cb0 = fig.colorbar(ct0)\n",
+    "ax.set_xlabel(\"land use area, $A_{\\\\mathrm{landuse}}$ (km)\")\n",
+    "ax.set_ylabel(\"levelized cost of energy, $\\\\mathrm{LCOE}$ (\\\\$/MWh)\")\n",
+    "cb0.set_label(\"optimization progress\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "26d7da02",
+   "metadata": {},
+   "source": [
+    "These results can be hit or miss when there are not enough points sampled.\n",
+    "We use a population size of ten per generation over ten generations for the example, which is _not_ a lot.\n",
+    "But we should see that as the optimization progresses, the points should tend toward lower LCOE and lower land use.\n",
+    "You can change `pop_size` and `max_gen` in `inputs/ard_system:analysis_options` to improve the resolution of the Pareto fronts.\n",
+    "\n",
+    "We can also post-process the results to extract the Pareto front."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "5b6cd3eb",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 800x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Combine AEP and LCOE into a single array for easier processing\n",
+    "data = np.column_stack((area_tight_history, lcoe_history))\n",
+    "\n",
+    "# Sort by AEP (descending) and then by LCOE (ascending)\n",
+    "data = data[np.lexsort((lcoe_history, area_tight_history))]\n",
+    "\n",
+    "# Compute the Pareto front\n",
+    "pareto_front = [data[0]]\n",
+    "for point in data[1:]:\n",
+    "    if point[1] < pareto_front[-1][1]:  # Check if LCOE is lower\n",
+    "        pareto_front.append(point)\n",
+    "\n",
+    "pareto_front = np.array(pareto_front)\n",
+    "\n",
+    "# Extract AEP and LCOE values for the Pareto front\n",
+    "pareto0 = pareto_front[:, 0]\n",
+    "pareto1 = pareto_front[:, 1]\n",
+    "\n",
+    "# Plot the Pareto front\n",
+    "plt.figure(figsize=(8, 6))\n",
+    "plt.scatter(area_tight_history, lcoe_history, label=\"All Points\", alpha=0.5)\n",
+    "plt.plot(pareto0, pareto1, \"-o\", color=\"red\", label=\"Pareto Front\", linewidth=2)\n",
+    "plt.xlabel(\"AEP (GW*h)\")\n",
+    "plt.ylabel(\"LCOE (USD/MW/h)\")\n",
+    "plt.legend()\n",
+    "plt.grid(True)\n",
+    "plt.xlim(*get_plot_range(pareto0))\n",
+    "plt.ylim(*get_plot_range(pareto1))\n",
+    "plt.show()"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "ard-dev-env",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.11"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/test/unit/ard/api/inputs_onshore/ard_system_NSGA2.yaml b/test/unit/ard/api/inputs_onshore/ard_system_NSGA2.yaml
new file mode 100644
index 00000000..ef439ede
--- /dev/null
+++ b/test/unit/ard/api/inputs_onshore/ard_system_NSGA2.yaml
@@ -0,0 +1,98 @@
+modeling_options: &modeling_options
+  case_name: test_multiobjective
+  windIO_plant: !include windio.yaml
+  layout:
+      type: gridfarm
+      N_turbines: 25
+      N_substations: 1
+      spacing_primary: 7.0
+      spacing_secondary: 7.0
+      angle_orientation: 0.0
+      angle_skew: 0.0
+  aero:
+    return_turbine_output: True
+  floris:
+    peak_shaving_fraction: 0.2
+    peak_shaving_TI_threshold: 0.0
+
+system:
+  type: group
+  systems:
+    layout:
+      type: component
+      module: ard.layout.gridfarm
+      object: GridFarmLayout
+      promotes: ["*"]
+      kwargs:
+        modeling_options: *modeling_options
+    aepFLORIS:
+      type: component
+      module: ard.farm_aero.floris
+      object: FLORISAEP
+      promotes: ["AEP_farm"]
+      kwargs:
+        modeling_options: *modeling_options
+        data_path:
+        case_title: "default"
+    lug:
+      type: group
+      systems:
+        landuse:
+          type: component
+          module: ard.layout.gridfarm
+          object: GridFarmLanduse
+          promotes: ["*"]
+          kwargs:
+            modeling_options: *modeling_options
+      promotes: ["*"]
+    boundary:
+      type: component
+      module: ard.layout.boundary
+      object: FarmBoundaryDistancePolygon
+      promotes: ["*"]
+      kwargs:
+        modeling_options: *modeling_options
+  connections:
+    - ["x_turbines", "aepFLORIS.x_turbines"]
+    - ["x_turbines", "aepFLORIS.y_turbines"]
+
+analysis_options:
+  driver:
+    name: NSGA2
+    options:
+      max_gen: 3
+      pop_size: 2
+      Pc: 0.9
+      eta_c: 20.0
+      Pm: 0.1
+      eta_m: 20.0
+      run_parallel: False
+  design_variables:
+    spacing_primary:
+      lower:  3.0
+      upper: 20.0
+    spacing_secondary:
+      lower:  3.0
+      upper: 20.0
+    angle_orientation:
+      lower: -180.0
+      upper:  180.0
+    angle_skew:
+      lower: -45.0
+      upper:  45.0
+  constraints:
+    boundary_distances:
+      units: km
+      upper: 0.0
+      scaler: 2.0
+  objectives:
+    AEP_farm:
+      scaler: 1.0
+      units: GW*h
+    lug.landuse.area_tight:
+      scaler: 1.0
+      units: km**2
+      index: 0
+
+  recorder:
+    filepath: cases.sql
diff --git a/test/unit/ard/api/test_multiobjective.py b/test/unit/ard/api/test_multiobjective.py
index 7260acb3..38097ae0 100644
--- a/test/unit/ard/api/test_multiobjective.py
+++ b/test/unit/ard/api/test_multiobjective.py
@@ -1,5 +1,9 @@
 from pathlib import Path
 
+import numpy as np
+
+from wisdem.optimization_drivers.nsga2_driver import NSGA2Driver
+
 from ard.utils.io import load_yaml
 from ard.api import set_up_ard_model
 
@@ -86,3 +90,77 @@ def test_raise_scipy_MOO_error(self):
 
             # attempt to run the driver
             self.da_plough.run_driver()
+
+
+class TestNSGA2:
+    def setup_method(self):
+
+        # create the simplest system that will compile
+        input_dict = self.input_dict = load_yaml(
+            Path(__file__).parent / "inputs_onshore" / "ard_system_NSGA2.yaml"
+        )
+
+        # create an ard model
+        self.da_plough = set_up_ard_model(
+            input_dict=input_dict,
+        )
+
+    def teardown_method(self):
+
+        # cleanup the ard model
+        self.da_plough.cleanup()
+        # necessary due to final_setup() call below?
+
+    def test_instantiation(self, subtests):
+
+        # make sure the driver is the right type
+        with subtests.test("driver type"):
+            assert type(self.da_plough.driver) == NSGA2Driver
+
+        # make sure the default parameters are in the driver
+        for opt_name, opt_val, comparison_fun in [
+            ("run_parallel", False, np.equal),
+            ("procs_per_model", 1, np.equal),
+            ("penalty_parameter", 0.0, np.isclose),
+            ("penalty_exponent", 1.0, np.isclose),
+            ("compute_pareto", True, np.equal),
+        ]:
+            with subtests.test(f"driver default {opt_name}"):
+                assert comparison_fun(self.da_plough.driver.options[opt_name], opt_val)
+
+        # make sure the parameters we set in the ard yaml are set
+        with subtests.test("driver setting max_gen"):
+            assert (
+                self.da_plough.driver.options["max_gen"]
+                == self.input_dict["analysis_options"]["driver"]["options"]["max_gen"]
+            )
+        with subtests.test("driver setting pop_size"):
+            assert (
+                self.da_plough.driver.options["pop_size"]
+                == self.input_dict["analysis_options"]["driver"]["options"]["pop_size"]
+            )
+        with subtests.test("driver setting Pc"):
+            assert (
+                self.da_plough.driver.options["Pc"]
+                == self.input_dict["analysis_options"]["driver"]["options"]["Pc"]
+            )
+        with subtests.test("driver setting eta_c"):
+            assert (
+                self.da_plough.driver.options["eta_c"]
+                == self.input_dict["analysis_options"]["driver"]["options"]["eta_c"]
+            )
+        with subtests.test("driver setting Pm"):
+            assert (
+                self.da_plough.driver.options["Pm"]
+                == self.input_dict["analysis_options"]["driver"]["options"]["Pm"]
+            )
+        with subtests.test("driver setting eta_m"):
+            assert (
+                self.da_plough.driver.options["eta_m"]
+                == self.input_dict["analysis_options"]["driver"]["options"]["eta_m"]
+            )
+
+    def test_driver_run(self):
+
+        # make sure the driver runs to completion
+        self.da_plough.run_driver()
diff --git a/test/unit/ard/viz/test_utils.py b/test/unit/ard/viz/test_utils.py
new file mode 100644
index 00000000..02bd37c3
--- /dev/null
+++ b/test/unit/ard/viz/test_utils.py
@@ -0,0 +1,36 @@
+import numpy as np
+
+import ard.viz.utils as viz_utils
+
+
+def test_get_plot_range(subtests):
+    """
+    test the get_plot_range function by feeding it multiple arguments for
+    matches against gold standard values
+    """
+
+    values_args_truths = [
+        (
+            np.array([4.0, 5.0, 6.0]),
+            None,
+            (4.0 - (6.0 - 4.0) * 0.05, 6.0 + (6.0 - 4.0) * 0.05),
+        ),
+        (
+            np.linspace(-3.0, 10.0, 25),
+            None,
+            (-3.0 - (10.0 - -3.0) * 0.05, 10.0 + (10.0 - -3.0) * 0.05),
+        ),
+        (
+            np.linspace(-3.0, 10.0, 25),
+            7.5,
+            (-3.0 - (10.0 - -3.0) * 0.075, 10.0 + (10.0 - -3.0) * 0.075),
+        ),
+    ]
+
+    for idx, (value, arg, truth) in enumerate(values_args_truths):
+        with subtests.test(f"value {idx:02d}"):
+            if arg is None:
+                rv = viz_utils.get_plot_range(value)
+            else:
+                rv = viz_utils.get_plot_range(value, arg)
+            assert np.allclose(rv, truth)