{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "# Tutorial 2: Minimizing the superquantile/conditional value-at-risk\n", "In this tutorial, we will:\n", "- Setup and solve a superquantile/conditional value-at-risk (CVaR) minimization problem. \n", "- Show how to use the SciPy interface to access algorithms implemented in `scipy.optimize`.\n", "\n", "To run this with MPI for parallel sampling, export this notebook as a python script.\n", "\n", "## Problem definition\n", "\n", "We use again use the Poisson equation with a log-normal coefficient field with a distributed source as the control. Since CVaR may be sample-intensive, \n", "to reduce the notebook's runtime, we will pose the problem in the 1D domain $\\Omega = (0,1)$. Recall the PDE is given by,\n", "\n", "\\begin{align*}\n", "\\nabla \\cdot (e^{m} \\nabla u ) + z &= 0 \\qquad x \\in \\Omega, \\\\\n", "u &= 0 \\qquad \\text{at } x = 0, \\\\\n", "u &= 1 \\qquad \\text{at } x = 1. \\\\\n", "\\end{align*}\n", "\n", "Here $u$ is the PDE solution, $m$, the uncertain parameter, is the log-coefficient field, and $z$, the optimization variable, is a distributed source.\n", "We will again use $R(u,m,z)$ to denote the residual of the PDE. The corresponding weak form is \n", "\n", "$$\n", "\\text{Find } u \\in \\mathcal{U} \\text{ s.t. } \n", "r(u,m,v,z) :=\n", "\\int_{\\Omega} e^m \\nabla u \\cdot \\nabla v dx - \\int_{\\Omega} z v dx = 0 \\qquad \\forall v \\in \\mathcal{V}\n", "$$\n", "\n", "with the trial and test spaces \n", "\n", "\\begin{align*}\n", "\\mathcal{U} := \\{u \\in H^1(\\Omega) : u = x \\text{ on } \\Gamma_{D} \\}, \\\\\n", "\\mathcal{V} := \\{v \\in H^1(\\Omega) : v = 0 \\text{ on } \\Gamma_{D} \\}.\n", "\\end{align*}\n", "\n", "As with tutorial 1, we choose the log-coefficient $m$ to be distributed as a Matern Gaussian random field, $m \\sim \\mathcal{N}(\\bar{m}, \\mathcal{C})$, where the covariance operator $\\mathcal{C} = \\mathcal{A}^{-2}$ is given by the squared-inverse of an elliptic operator \n", "\n", "$$ \\mathcal{A} = -\\gamma \\Delta + \\delta \\mathcal{I} $$\n", "\n", "with Homogeneous Neumann boundary conditions. We will assume $(\\gamma, \\delta) = (0.5, 10)$ and $\\bar{m} = -3$ is a constant.\n", "\n", "The quantity of interest to minimize is the $L^{2}(\\Omega)$ misfit between the state and a target value of $1$ over a predefined observation region, \n", "\n", "$$ Q(u,m,z) = \\int_{\\Omega} \\chi_{(0.4, 0.6)} (u - 1)^2 dx, $$\n", "\n", "where $\\chi_{(0.4, 0.6)}(x)$ is the indicator function over the interval $(0.4, 0.6)$.\n", "\n", "We will still consider the $L^2$-penalization term for the control \n", "\n", "$$ P(z) := \\alpha \\int_{\\Omega} z^2 dx $$\n", "\n", "that accounts for the cost of applying the source control. Let's suppose it is very costly to apply the control, so we will use a large value $\\alpha = 1$.\n", "\n", "The CVaR is defined for a given quantile, $\\beta \\in (0, 1)$, and is the *conditional expectation of $Q$ given that it exceeds the $\\beta$ quantile.*\n", "This can be conveniently formulated as a minimization problem with respect to an auxiliary scalar $t \\in \\mathbb{R}$,\n", "\n", "$$ \\mathrm{CVaR}_{\\beta}[Q] = \\min_{t \\in \\mathbb{R}} t + \\frac{1}{1-\\beta} \\mathbb{E}[(Q - t)^{+}], $$\n", "\n", "where $(x)^{+} = \\max(x, 0)$. Note that this maximum function is not differentiable at zero. Instead, we often use a smooth approximation of the maximum function (see Kouri and Surowiec 2016), e.g. \n", "\n", "\n", "$$\n", "(x)_{\\epsilon}^{+} = \\begin{cases}\n", " 0 & x \\leq 0 \\\\\n", " x^3/\\epsilon^2 - 0.5 x^4/\\epsilon^3 & x \\in (0, \\epsilon) \\\\\n", " x - 0.5 \\epsilon & x \\geq \\epsilon \n", "\\end{cases}\n", "$$\n", "\n", "The CVaR minimization can be formulated in terms of a similar cost functional with the auxiliary scalar, \n", "\n", "$$ \n", "\\min_{z,t} J_{\\epsilon}(z,t) := t + \\frac{1}{1-\\beta} \\mathbb{E}[(Q(u,m,z) - t)_{\\epsilon}^{+}] + P(z) \n", " \\qquad \\text{s.t. } R(u,m,z) \n", "$$\n", "\n", "As in tutorial 1, a sample average can be used to approximate the expectation, leading to the SAA cost functional\n", "\n", "$$ \n", "\\min_{z, t} \\widehat{J}_{\\epsilon}(z,t) \n", " := t + \\frac{1}{(1 - \\beta)N} \\sum_{i=1}^{N} (Q(u_i, m_i, z) - t)_{\\epsilon}^{+} + P(z) \n", " \\qquad \\text{s.t. } R(u_i,m_i,z) = 0 \n", "$$\n", "\n", "that is, we sample realizations of $m_i \\sim \\mathcal{N}(\\bar{m}, \\mathcal{C})$ and solve the PDE to obtain samples of the state $u_i$ to evaluate the expectation.\n", "\n", "### References\n", "D. Kouri, T. Surowiec, *Risk-Averse PDE-Constrained Optimization Using the Conditional Value-At-Risk*, SIAM Journal on Optimization, 26 (2016). pp. 365–396\n", "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 1. Import libraries \n", "Note: hippylib and soupy paths need to be appended if cloning the repos instead of installing via pip" ] }, { "cell_type": "code", "execution_count": 33, "metadata": {}, "outputs": [], "source": [ "import sys \n", "import os \n", "sys.path.append(os.environ.get('HIPPYLIB_PATH')) # Needed if using cloned repo\n", "sys.path.append(os.environ.get('SOUPY_PATH')) # Needed if using cloned repo\n", "import time\n", "\n", "import logging \n", "logging.getLogger('FFC').setLevel(logging.WARNING)\n", "logging.getLogger('UFL').setLevel(logging.WARNING)\n", "\n", "import scipy.optimize \n", "import numpy as np \n", "import matplotlib.pyplot as plt \n", "import dolfin as dl \n", "import hippylib as hp \n", "from mpi4py import MPI \n", "\n", "import soupy " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 2. Setup the function space\n", "We will set up the mesh in 1D. Note that we will implement the code to be amenable for parallel sampling (see tutorial 1a). \n", "To do so, we give the mesh the `MPI.COMM_SELF` communicator and save the `MPI.COMM_WORLD` communicator for sampling." ] }, { "cell_type": "code", "execution_count": 34, "metadata": {}, "outputs": [], "source": [ "N_ELEMENTS_X = 16\n", "\n", "comm_mesh = MPI.COMM_SELF\n", "comm_sampler = MPI.COMM_WORLD\n", "\n", "mesh = dl.UnitIntervalMesh(comm_mesh, N_ELEMENTS_X) # Using MPI.COMM_SELF for the mesh so it does not partition\n", "\n", "Vh_STATE = dl.FunctionSpace(mesh, \"CG\", 1)\n", "Vh_PARAMETER = dl.FunctionSpace(mesh, \"CG\", 1)\n", "Vh_CONTROL = dl.FunctionSpace(mesh, \"CG\", 1)\n", "Vh = [Vh_STATE, Vh_PARAMETER, Vh_STATE, Vh_CONTROL] " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 3. Define the PDE problem and Prior\n", "This is the same as in tutorial 1, except for the change in the definition of the boundaries. " ] }, { "cell_type": "code", "execution_count": 35, "metadata": {}, "outputs": [], "source": [ "# Define PDE \n", "\n", "def residual(u,m,v,z):\n", " return dl.exp(m)*dl.inner(dl.grad(u), dl.grad(v))*dl.dx - z * v *dl.dx \n", "\n", "def boundary(x, on_boundary):\n", " return on_boundary and (dl.near(x[0], 0) or dl.near(x[0], 1))\n", "\n", "boundary_value = dl.Expression(\"x[0]\", degree=1, mpi_comm=comm_mesh) # Need to use the same mpi_comm as the mesh\n", "\n", "bc = dl.DirichletBC(Vh_STATE, boundary_value, boundary)\n", "bc0 = dl.DirichletBC(Vh_STATE, dl.Constant(0.0), boundary)\n", "pde = soupy.PDEVariationalControlProblem(Vh, residual, [bc], [bc0], is_fwd_linear=True)\n", "\n", "# Define prior\n", "PRIOR_GAMMA = 1.0\n", "PRIOR_DELTA = 10.0\n", "PRIOR_MEAN = -3.0\n", "\n", "mean_vector = dl.interpolate(dl.Constant(PRIOR_MEAN), Vh_PARAMETER).vector()\n", "prior = hp.BiLaplacianPrior(Vh_PARAMETER, PRIOR_GAMMA, PRIOR_DELTA, mean=mean_vector, robin_bc=False)\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 4. Define the QoI and control model\n", "Here we prescribe the new QoI in its variational form, using an expression to define the indicator function. " ] }, { "cell_type": "code", "execution_count": 36, "metadata": {}, "outputs": [], "source": [ "# Define QoI\n", "OBSERVATION_CENTER = 0.5 \n", "OBSERVATION_RADIUS = 0.1\n", "TARGET_VALUE = 0.0\n", "\n", "\n", "observation_region = dl.Expression(\"pow(x[0] - center, 2) < pow(radius, 2)\", \n", " center=OBSERVATION_CENTER,\n", " radius=OBSERVATION_RADIUS,\n", " degree=2, mpi_comm=comm_mesh) # Need to use the same mpi_comm as the mesh\n", "def l2_qoi_form(u,m,z):\n", " return observation_region * (u - dl.Constant(TARGET_VALUE))**2 * dl.dx \n", "\n", "qoi = soupy.VariationalControlQoI(Vh, l2_qoi_form)\n", "\n", "# Combine into control model\n", "control_model = soupy.ControlModel(pde, qoi)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 5. Define the superquantile/CVaR risk measure with the sample communicator\n", "The `soupy.SuperquantileRiskMeasureSAA` class implements the superquantile/CVaR risk measure. Similar to the mean + variance example, \n", "we can provide the selected qunatile value (in this case $\\beta = 0.8$), sample size, and initial random seed as settings.\n", "\n", "The superquantile will use the smooth quartic approximation of the maximum function described above by default. \n", "\n" ] }, { "cell_type": "code", "execution_count": 37, "metadata": {}, "outputs": [], "source": [ "QUANTILE = 0.8\n", "SAMPLE_SIZE = 200\n", "RANDOM_SEED = 1\n", "EPSILON = 1e-6\n", "\n", "risk_settings = soupy.superquantileRiskMeasureSAASettings()\n", "risk_settings[\"beta\"] = QUANTILE\n", "risk_settings[\"sample_size\"] = SAMPLE_SIZE \n", "risk_settings[\"seed\"] = RANDOM_SEED\n", "risk_settings[\"epsilon\"] = EPSILON\n", "\n", "risk_measure = soupy.SuperquantileRiskMeasureSAA(control_model, prior, risk_settings, comm_sampler=comm_sampler)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "An important difference with the superquantile risk measure is the auxiliary variable $t$. This is represented in SOUPy as a `soupy.AugmentedVector`, \n", "which is a wrapper around a standard dolfin vector for the control variable, `z`, and a scalar `t`. \n", "\n", "**Note:** Currently `AugmentedVector` only works with serial meshes \n", "\n", "We can see this by calling `risk_measure.generate_vector(soupy.CONTROL)`, which, instead of returning a vector corresponding to `Vh_CONTROL`, \n", "will return an augmented of this kind.\n", "\n", "On the outside, the `AugmentedVector` has methods matching the `dolfin.Vector` class, such as `axpy`, `inner`, `get_local`, `set_local`, `apply`, etc.\n", "The local numpy array will be the local array of `z` with the scalar `t` appended to it.\n", "\n", "One can also extract the internal information by methods like `get_vector`, `get_scalar`, `set_scalar`. \n" ] }, { "cell_type": "code", "execution_count": 38, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "zt is a \n", "The AugmentedVector has shape: (18,)\n", "The Vector component has shape: (17,)\n", "After setting local, the AugmentedVector is \n", " [1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 0.]\n", "The scalar component is: 0.0\n", "After setting both vector and scalar, the AugmentedVector is \n", " [ 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. -8.]\n" ] } ], "source": [ "# zt is a wrapper around a vector `z` and a scalar `t`. \n", "zt = risk_measure.generate_vector(soupy.CONTROL)\n", "print(\"zt is a \", zt)\n", "\n", "# Calling `get_local` for the `AugmentedVector`` will return an array where the scalar is appended to the end of the \n", "print(\"The AugmentedVector has shape: \", zt.get_local().shape)\n", "\n", "# This will return the vector `z` \n", "z = zt.get_vector()\n", "print(\"The Vector component has shape: \", z.get_local().shape)\n", "\n", "# Can `set_local`` to the vector, which will modify the vector in `zt`\n", "z.set_local(np.ones(z.get_local().shape))\n", "print(\"After setting local, the AugmentedVector is \\n\", zt.get_local())\n", "\n", "# Can get the value of the scalar part by `get_scalar`\n", "print(\"The scalar component is: \", zt.get_scalar())\n", "\n", "# Can set the value of scalar \n", "zt.set_scalar(-8.0)\n", "\n", "# Now the full AugmentedVector is\n", "print(\"After setting both vector and scalar, the AugmentedVector is \\n\", zt.get_local())\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 6. Define the penalization and cost functional\n", "We now proceed to define the penalization. The penalization terms are defined in terms of the control variable $z$, as per usual.\n", "It will only apply to the $z$ part of $(z,t)$." ] }, { "cell_type": "code", "execution_count": 39, "metadata": {}, "outputs": [], "source": [ "PENALTY_WEIGHT = 1\n", "def l2_penalization_form(z):\n", " return dl.Constant(PENALTY_WEIGHT) * z**2 * dl.dx \n", "\n", "penalty = soupy.VariationalPenalization(Vh, l2_penalization_form)\n", "\n", "cost_functional = soupy.RiskMeasureControlCostFunctional(risk_measure, penalty)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 7. Optimization using SciPy\n", "We will now use the `soupy.ScipyCostWrapper` to turn `cost_functional` into functions of numpy arrays. \n", "\n", "The `scipy_cost` can return three functions\n", "- `scipy_cost.function()` returns a function that is $f(x)$, the cost functional\n", "- `scipy_cost.jac()` returns a function for the gradient $\\nabla f(x)$ \n", "- `scipy_cost.hessp()` returns a function for the hessian vector product $\\nabla^2 f(x) p$\n", "\n", "These are arguments for `scipy.optimize.minimize`. Here, we will use the BFGS algorithm, which requires only the `function` and `jac`. \n", "\n", "We also need an initial guess for `scipy.optimize`. We will just use the numpy array for the joint vector `zt` from before.\n", "\n", "Running this might take a while if using the notebook. \n", "\n", "**Note:** If using bounds, make sure exclude the **last component of the array** from the bounds, since that corresponds to $t \\in \\mathbb{R}$. " ] }, { "cell_type": "code", "execution_count": 40, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Optimization terminated successfully.\n", " Current function value: 0.026421\n", " Iterations: 36\n", " Function evaluations: 57\n", " Gradient evaluations: 57\n" ] } ], "source": [ "# Interface with scipy.optimize.minimize\n", "scipy_cost = soupy.ScipyCostWrapper(cost_functional, verbose=False)\n", "\n", "# The initial guess as a numpy array \n", "zt_initial_np = zt.get_local()\n", "\n", "# These are usual options for scipy.optimize.minimize\n", "DISPLAY_ITERATIONS = True\n", "MAX_ITER = 200\n", "options = {'disp' : DISPLAY_ITERATIONS, 'maxiter' : MAX_ITER}\n", "results = scipy.optimize.minimize(scipy_cost.function(), zt_initial_np, method=\"BFGS\",\n", " jac=scipy_cost.jac(), options=options)\n", "zt_optimal_np = results['x']\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 8. Postprocessing\n", "We will now plot a sample of the parameter and solution at the optimal control.\n", "\n", "Since the result is in the form of a numpy array for the augmented vector, we need to set it to a dolfin vector for solving the PDE. \n", "Remember to exclude the last component when setting it to a vector representing the control variable. " ] }, { "cell_type": "code", "execution_count": 41, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "\n", "# Initialize vectors for the state, parameter, adjoint (not used) and control variables\n", "x = control_model.generate_vector()\n", "\n", "# Initialize the noise vector \n", "noise = dl.Vector(comm_mesh)\n", "prior.init_vector(noise, \"noise\")\n", "\n", "# Use hippylib's rng to sample Gaussian white noise \n", "rng = hp.Random(seed=111)\n", "\n", "# This is sampling noise with 1.0 standard dev to the noise vector\n", "rng.normal(1.0, noise) \n", "\n", "# The prior then turns the noise into a parameter sample\n", "prior.sample(noise, x[soupy.PARAMETER])\n", "\n", "# Also set the CONTROL component of x to the optimal control z\n", "x[soupy.CONTROL].set_local(zt_optimal_np[:-1])\n", "\n", "# Solve the forward problem\n", "control_model.solveFwd(x[soupy.STATE], x)\n", "\n", "# Convert to functions and plot\n", "u_fun = dl.Function(Vh[soupy.STATE], x[soupy.STATE])\n", "m_fun = dl.Function(Vh[soupy.PARAMETER], x[soupy.PARAMETER])\n", "z_fun = dl.Function(Vh[soupy.CONTROL], x[soupy.CONTROL])\n", "\n", "plt.rcParams.update({'font.size': 14})\n", "\n", "if comm_sampler.rank == 0:\n", " plt.figure(figsize=(8,6))\n", " plt.subplot(311)\n", " dl.plot(z_fun, title=\"Optimal control\")\n", " plt.xlabel(\"$x$\")\n", " plt.ylabel(\"$z(x)$\")\n", " plt.subplot(312)\n", " dl.plot(m_fun, title=\"Parameter\")\n", " plt.xlabel(\"$x$\")\n", " plt.ylabel(\"$m(x)$\")\n", " plt.subplot(313)\n", " dl.plot(u_fun, title=\"State\")\n", " plt.xlabel(\"$x$\")\n", " plt.ylabel(\"$u(x)$\")\n", "\n", " x_obs = np.linspace(OBSERVATION_CENTER-OBSERVATION_RADIUS, OBSERVATION_CENTER+OBSERVATION_RADIUS, 10)\n", " plt.plot(x_obs, np.ones_like(x_obs)*TARGET_VALUE, '--r', label=\"Target\")\n", " plt.legend()\n", " plt.tight_layout()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 9. Comparing this to the expectation as a risk measure\n", "We can also solve the problem using the mean risk measure, as in the previous tutorial\n", "\n", "$$ \\min_{z} \\mathbb{E}[Q] + P(z) $$\n", "\n", "We will use the same sample size and random seed. \n", "For convenience, we will also use the optimal control from the superquantile optimization as the initial guess." ] }, { "cell_type": "code", "execution_count": 42, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Optimization terminated successfully.\n", " Current function value: 0.021642\n", " Iterations: 5\n", " Function evaluations: 6\n", " Gradient evaluations: 6\n" ] } ], "source": [ "VARIANCE_WEIGHT = 0.0\n", "\n", "mean_risk_settings = soupy.meanVarRiskMeasureSAASettings()\n", "mean_risk_settings[\"beta\"] = VARIANCE_WEIGHT\n", "mean_risk_settings[\"sample_size\"] = SAMPLE_SIZE \n", "mean_risk_settings[\"seed\"] = RANDOM_SEED\n", "\n", "mean_risk_measure = soupy.MeanVarRiskMeasureSAA(control_model, prior, mean_risk_settings, comm_sampler=comm_sampler)\n", "mean_cost_functional = soupy.RiskMeasureControlCostFunctional(mean_risk_measure, penalty)\n", "\n", "mean_scipy_cost = soupy.ScipyCostWrapper(mean_cost_functional, verbose=False)\n", "\n", "# The initial guess as a numpy array \n", "z_initial_np = zt_optimal_np[:-1]\n", "\n", "mean_results = scipy.optimize.minimize(mean_scipy_cost.function(), z_initial_np, method=\"BFGS\",\n", " jac=mean_scipy_cost.jac(), options=options)\n", "z_optimal_mean_np = mean_results['x']" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Distribution of QoIs at optimal controls\n", "\n", "We have now solved the OUU problem using two different risk measure\n", "1. Optimal control from superquantile/CVaR, $z_{\\mathrm{CVaR}}^{*}$.\n", "2. Optimal control from mean, $z_{\\mathrm{Mean}}^{*}$.\n", "\n", "We can compare the QoI distributions at the optimal controls. This can be done by solving the PDE at a bunch of samples using either of the two optimal controls.\n", "\n", "Here, to see a little more detail about risk measure classes in SOUPy, \n", "we will instead create a third risk measure using a large sample size and use that to draw the samples of the QoIs. \n", "\n", "The risk measures have two methods that will be useful:\n", "- `computeComponents(z, order)` will compute components (sampling) at `z` required to evaluate the function and its derivatives up to `order`\n", "- `gather_samples` will return the QoI samples computed from `computeComponents`. When running in parallel, this will gather across all MPI processes\n", "\n", "We go through and create this evaluation risk measure (either mean + variance or CVaR be fine since we only need the samples). Sampling may take a while." ] }, { "cell_type": "code", "execution_count": 43, "metadata": {}, "outputs": [], "source": [ "SAMPLE_SIZE = 2000\n", "RANDOM_SEED = 111\n", "\n", "risk_settings_evaluation = soupy.meanVarRiskMeasureSAASettings()\n", "risk_settings_evaluation[\"sample_size\"] = SAMPLE_SIZE \n", "risk_settings_evaluation[\"seed\"] = RANDOM_SEED\n", "risk_evaluation = soupy.MeanVarRiskMeasureSAA(control_model, prior, risk_settings_evaluation, comm_sampler=comm_sampler)\n", "\n", "z = risk_evaluation.generate_vector(soupy.CONTROL)\n", "\n", "# For the CVaR result, make sure to exclude last component\n", "z.set_local(zt_optimal_np[:-1])\n", "risk_evaluation.computeComponents(z, order=0)\n", "qoi_samples_cvar = risk_evaluation.gather_samples()\n", "\n", "# For the CVaR result, make sure to exclude last component\n", "z.set_local(z_optimal_mean_np[:-1])\n", "risk_evaluation.computeComponents(z, order=0)\n", "qoi_samples_mean = risk_evaluation.gather_samples()\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We can now plot these both the optimal controls and their corresponding QoI distributions.\n", "\n", "When using the CVaR as the risk measure, we see that the optimal control is a stronger control despite the penalization, since CVaR places greater emphasis on the upper tail of the distribution." ] }, { "cell_type": "code", "execution_count": 44, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "80% CVaR of QoI samples\n", "Using CVaR as risk measure, 0.0110839\n", "Using Mean as risk measure, 0.0132091\n" ] }, { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAnAAAAHVCAYAAABxKsZjAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/NK7nSAAAACXBIWXMAAA9hAAAPYQGoP6dpAAC0NElEQVR4nOzdd1xV9f/A8de97L1VXCAKIo4cKebCjbO0oQ1zpKYNU8sySkVN07K0tJ/V11LbmQ0t98Sd5ioXihNUcAsIsu79/P44cpMAGQKX8X4+HvfxOJ7P53zO+wJy35zP0imlFEIIIYQQoszQmzsAIYQQQghRMJLACSGEEEKUMZLACSGEEEKUMZLACSGEEEKUMZLACSGEEEKUMZLACSGEEEKUMZLACSGEEEKUMZLACSGEEEKUMZLACSGEEEKUMZLACSHKvcmTJ6PT6Rg8eLC5Q8kXnU6HTqfj7Nmz5g6lXGrfvj06nY7FixebOxQhCk0SOCFEkfjrr7948cUXqVevHi4uLtjZ2eHj40O/fv34+eefKa5d+xYvXszkyZM5ePBgsbQvitbBgweZPHmyJE9C3CdJ4IQQ9yUtLY2hQ4fSokULPv30U86cOUONGjUICgoiMTGRpUuX8sQTT9CyZUsuXLhQ5PdfvHgxU6ZMuWcC5+npSd26dfH29i7y+4uCOXjwIFOmTJEEToj7JAmcEKLQjEYjDz/8MAsXLsTe3p7Zs2dz9epVDh8+zL59+7hy5Qp//PEHtWrVYs+ePTz00ENcunSpxON8+eWXiYyMZMaMGSV+byGEKA6SwAkhCu39999n7dq1WFlZsXr1asaOHYujo6Op3MLCgl69erFjxw58fX2JiYkpM+PQhBCiNJMETghRKLdu3eL9998HYNy4cbRr1y7Xut7e3nz22WcArFmzhl27dmUpHzx4MDqdjsmTJ3Pjxg1Gjx5NrVq1sLGxoVq1ajz//PNcvHgxyzURERHodDq2bNkCwJAhQ0yD/3U6He3btzfVzW0Sw9mzZ031AdauXUunTp1wc3PDxcWFzp07s3PnTlP9qKgoBg0aRLVq1bC1taV+/fp8/vnnOb7ntLQ0fv31V5577jkaNmyIu7s7tra2+Pr6MmjQIA4fPnyPr27h3bhxg6lTp9K8eXNcXV2xs7Ojdu3aPPbYYyxdujTHa9asWcPDDz9M5cqVsba2pkqVKvTt25fNmzfnWD/za+/r6wvA77//Tvv27XF1dcXBwYHg4GB+/PHHbNf5+voyZMgQALZs2ZLl+3X3pI3/tv/NN9/Qpk0b3Nzc0Ol0WbrLY2JiGDVqFAEBAdjZ2eHi4kKLFi2YPXs2KSkpBf76bdmyhccee4xq1aphbW2Nq6srAQEBPP744yxatKjA7QlRbJQQQhTCTz/9pACl1+vVxYsX83VNYGCgAtSLL76Y5fygQYMUoF555RVVu3ZtpdPpVFBQkHrggQeUhYWFAlSlSpXUsWPHTNfs379ftW7dWjk7OytA+fv7q9atW5teL7/8sqlueHi4AtSgQYOy3PfMmTMKUID67LPPlE6nU5UrV1ZNmzZVjo6OClC2trZqx44daufOncrFxUU5OjqqZs2aqUqVKpmuff/997O910OHDpm+PlWqVFFNmjRR9evXN7VrY2OjVqxYkePXKbPdM2fO5Ovrmmn37t2qSpUqpuv9/f1Vs2bNlJeXlwKUi4tLtmvGjBljql+pUiXVvHlz5enpaToXHh6e7ZrNmzcrQPn4+KgpU6YoQFWuXFk1a9ZMubi4mK6dN29elusef/xx5e/vrwDl7Oyc5fvVunVrFRsbm639UaNGKUBVqVJFNW/eXFWuXFkdOHBAKaXUli1bTPeztrZWTZo0UXXr1jXdv1mzZurq1avZ4g8JCVGAWrRoUZbzCxcuVDqdTgHK1dVVPfDAA6pRo0bKzc1NAapatWoF+n4IUZwkgRNCFMorr7yiANWgQYN8X/Piiy8qQD3wwANZzmcmcFZWVqpOnTrq8OHDprLo6GjVokUL03UZGRlZrs3tw/hu+Ung7Ozs1IIFC5TRaFRKKXXr1i3VrVs3BajmzZurmjVrqpEjR6qkpCTT9RMmTFCAsre3VwkJCVnajouLU9988426du1alvMpKSnqk08+URYWFsrT0zNLe5kKk8DFxsaakspOnTqpU6dOZSmPiopS77zzTpZzixcvVoCysLBQn376qTIYDEoppTIyMtQHH3xgSmZ+++23LNdlJlhWVlbKzs5Offfdd6ay9PR0NXLkSAUoR0fHbF+XRYsWKUCFhITk+l4y27ewsFC2trbqhx9+MJUZDAaVmpqqrly5YkpMe/XqlSVR27dvn6pRo4YC1COPPJKt/Zx+ZjIyMpSHh4cC1Ny5c1V6enqWa44dO6Y+/vjjXGMWoqRJAieEKJS+ffsqQPXp0yff18yZM0cBysPDI8v5zAQOUDt27Mh23dmzZ5WlpaUC1LJly7KUFVUC99+ngkopdeTIEVN5w4YNTQlOprS0NOXt7Z1jXHl55plnFKCWLFmSrawwCdyrr76qABUUFKRu376dr2tq166tAPXSSy/lWD5gwAAFqMaNG2c5n5lgAdmSQqWUSk5ONiVXy5cvz1JWkAQOUDNnzsyxztSpUxWgvLy8ckyCN2zYYGrj4MGDWcpy+pmJjY01PXkToiyQMXBCiEJJTEwEyDJpIS+ZdePj43Msb968Oa1atcp23sfHh759+wKwatWqgoaaL88//3y2c0FBQdjZ2QEwdOhQ9PqsvzKtrKx44IEHADh16lSO7W7cuJHXXnuN3r17ExISQps2bWjTpg1bt24FYP/+/UUS/y+//ALAa6+9hq2tbZ71IyMjTTGPGzcuxzqvv/46oC398d8xiJlefPHFbOfs7Oxo0qQJACdPnsw7+HvIHDP3XytXrjTd397ePlt5p06dTDFk1r0XLy8vbG1tuXnzJr///vt9RCxEybA0dwBCiLLJyckJ0CYz5FdmXRcXlxzLGzRokOu19evXZ+nSpRw7dqwAUeZfnTp1cjzv5eVFdHR0ruWVKlUCsn8dbt26xaOPPsr69evved9r164VItqsEhMTOXfuHECOCXBOjh8/DmhJdeZkgf8KCgrCwsICg8FAZGQkVatWzVLu6emJu7t7jtdWrlwZKNjPx395enqavr7/lRl/w4YNc72+YcOGHDhwgMjIyDzvZWFhwWuvvcb06dN55JFHCAoKokuXLrRo0YL27dtne+9CmJs8gRNCFEr16tWBgj1hiYqKynLtf2V+6N+rLPPJX1FzcHDI8XzmDNW8yo1GY5bz48aNY/369Xh6evLFF19w8uRJkpOTUdrQFSZOnAhAenr6fceekJBgOnZ1dc3XNZlfxypVquRax9LSEk9Pzyz175bb1wQwPa3879elIO7Vfn7iz1y4Ob8/M++88w6ff/45jRo14ujRo3z88cc888wzVK9enS5duvDPP/8UIHohipckcEKIQmnTpg0AR48eJTY2Nl/XZC5L0bp16xzL77XIb2ZZ5pO/0iwjI4PvvvsOgK+++oqhQ4dSu3ZtU3csFM2Tt0zOzs6m45s3b+brmsyv472+5hkZGVy9ejVL/dIiM564uLhc62T+XOY3dp1Ox/PPP8/ff//N5cuX+fXXXxk1ahReXl5s2LCBjh075tqVLERJkwROCFEoPXr0wNXVFaPRyCeffJJn/XXr1pm6P59++ukc6xw5ciTX6zPL6tWrl+V85hOw0uTKlSumrsO2bdvmWOfu9eXul5OTEz4+PgVqNzAwEMja/fpfx44dw2AwZKl/v4rq+5UZz73W08ss++/PTH54eXnRt29f5s6dS1RUFL6+vly7do2ffvqpcAELUcQkgRNCFIqjo6NpkPusWbNMg/JzEhcXx4gRIwDo0qVLrk/g9uzZk22RX4Do6GiWLVsGQPfu3bOUZQ5gv337doHfQ3G5e1B9Tk9sNmzYcM+9Wwvj8ccfB2D27NmkpqbmWb9u3bqmcX2zZ8/Osc4HH3wAQJMmTYpsDFhRfb969uwJwKeffppjW5s3bzZNEOnRo8d93cvZ2dk0WUWewInSQhI4IUShjR8/ns6dO5Oenk737t356KOPsgxaNxgMrFixglatWnH27FmqVavGV199lWt7VlZWDB48OMtEhfPnz9O/f3/S09Np2LAhvXv3znJNZhISERGBUqqI32HhuLi4mD7wR48ezY0bN0xlmzdv5qmnnsrXTNGCeP3116lUqRJHjhzh4Ycf5syZM1nKT506xbRp07KcmzBhAgDz58/niy++MH39jEYjH330Ed988w0AkyZNKrI4M79fR44cua99cUeOHImXlxeXLl3i6aef5vr166ayAwcOmGav9unTx/S9uJejR48ydOhQtm/fnm3c3vr169m4cSOgzZQWolQw7yomQoiyLiUlJcs6bjY2NqpBgwaqWbNmphXsAfXggw+q6OjoHNvIaSeG+vXrq8aNG5vWf/P09MyywG+m3bt3K71erwBVvXp11aZNGxUSEqJGjx5tqpOfdeBy4+PjowC1efPme8b+3x0L1q5da9pFwsHBQTVp0kTVqlXLtK7auHHjcoxJqfvbiSFzMV+dTqfq1q2rHnzwQdO5nHZiGD16tOl+lStXVs2bNzet4QaoSZMmZbvm7p0ScpPb18VoNKqGDRuavi7NmzdXISEhKiQkJMedGO4lIiLCtBOHjY2Natq0qWm3D0A1bdo03zsxHDhwwHSdvb29atSokWrevLmqWrWq6XyfPn1MCz0LYW7yBE4IcV9sbGxYvHgxu3fvZsSIEfj6+nL27FkOHz6Mo6Mjjz32GD/99BN79uyhRo0a92zLzc2Nv/76i1GjRnHr1i2OHj2Kl5cXQ4cO5cCBA9SvXz/bNS1atGDZsmW0b9+eW7dusXPnTrZs2VLkXZQF1bVrVzZv3kznzp3R6XRERkZiY2PDhAkT2LFjxz1nWBZWixYtOHr0KBMnTqRRo0ZcuHCBI0eO4OjoyOOPP87ChQuzXfPRRx+xatUqevXqhdFo5MCBA+h0Oh555BE2btzIlClTijRGnU7HqlWrGDRoEO7u7hw8eJAtW7awZcuWAu9dGhISwqFDh3j55ZepXr06R44c4fz58zz44IN88MEH7NixAw8Pj3y1FRAQwJdffsnTTz9NzZo1iYmJ4cCBA6SlpdG5c2e+/vprfvnll1I55lJUTDqlSkmfgxCiwho8eDBfffUV4eHhTJ482dzhCCFEqSdP4IQQQgghyhhJ4IQQQgghyhhJ4IQQQgghyhhJ4IQQQgghyhiZxCCEEEIIUcbIEzghhBBCiDLG0twBiKJnNBq5ePEiTk5OsmaREEIIUUYopUhMTKRq1aro9fd+xiYJXDl08eLFPBdMFUIIIUTpFBMTQ/Xq1e9ZRxK4csjJyQnQfgCcnZ3NHI0QQggh8iMhIYEaNWqYPsfvRRK4ciiz29TZ2VkSOCGEEKKMyc/wJ5nEIIQQQghRxkgCJ4QQQghRxkgCJ4QQQghRxkgCJ4QQQghRxkgCJ4QQQghRxkgCJ4QQQghRxkgCJ4QQQghRxkgCJ4QQQghRxpT7BO6vv/6iR48euLm54eDgQIsWLfj+++8L1IbRaOSTTz6hUaNG2NnZ4eXlRb9+/YiKiiqy+yYkJPDqq6/i4+ODjY0NPj4+vPrqqyQkJBQoViGEEEKUfzqllDJ3EMUlIiKC0NBQrK2tefLJJ3FxceHXX3/lzJkzTJ8+nbfeeitf7Tz//PMsWLCAoKAgevbsyaVLl1iyZAm2trbs3LmToKCg+7pvUlISbdq04eDBg3Tp0oWmTZvy999/s2bNGho3bsz27dtxcHDI9/tOSEjAxcWF+Ph42YlBCCGEKCMK9Pmtyqn09HRVu3ZtZWNjo/bv3286n5CQoOrXr68sLS3ViRMn8mxn06ZNClBt27ZVKSkppvMbNmxQOp1OtWvX7r7vO2nSJAWoN954I8fzkyZNKtB7j4+PV4CKj48v0HVCCCGEMJ+CfH6X2y7UTZs2cerUKZ5++mmaNGliOu/k5MTEiRPJyMhg0aJFebazYMECAKZNm4aNjY3pfKdOnQgNDWXr1q2cOHGi0PdVSvHFF1/g6OjIpEmTstw7LCwMNzc3vvzyS1T5fVAqhBBCiAIqtwlcREQEAF27ds1Wlnluy5Yt+WrHwcGB1q1bZysLDQ3N1k5B7xsVFcXFixdp3bp1tm5SW1tb2rVrx4ULFzh58mSesRa79NvE//4mlzfNN3ckQgghhHkoxcnfZ5GReNWsYZTbBC5zgoG/v3+2Mjc3Nzw9Pe85CQG0sWmxsbHUqlULCwuLbOWZbd/dTkHve6/6ud3jv1JTU0lISMjyKg6H1nyJy/5Pcdo6BeP1s8VyDyGEEKI0O7XlO+rsn8bN2S1IuZ1ktjjKbQIXHx8PgIuLS47lzs7Opjr308bd9Qpz38Lc479mzJiBi4uL6VWjRo1c694Pr7bPsU8FYkcKl78fCdKtK4QQogIx3E7AZas23Olvr97Y2uV/gmFRK7cJXEUSFhZGfHy86RUTE1Ms96nias+pVjNJUVZUubqLpD8XFst9hBBCiNLoxE8T8TRe4zyVaPzUFLPGUm4TuMwnWrk9ucqcqnu/bdxdrzD3Lcw9/svGxgZnZ+csr+LyaOcQvrZ7FgCL9RMh/kKx3UsIIYQoLRKj/6HOmW8AONp4Ih5urmaNp9wmcPcaO3bjxg2uXr2a67izTA4ODnh7e3PmzBkMBkO28pzGrxX0vnmNcctrjFxJs7TQ07TfWxww1sHWmET80pekK1UIIUT5phTXfhqFFQa2W7akQ+8B5o6o/CZwISEhAKxbty5bWea5zDp5tZOUlMSOHTuyla1duzZbOwW9r7+/P1WrVmXHjh0kJWUdDJmSksLWrVupWrUqderUyTPWkvKgnxcb/CeRqixxOb8Zw8EfzB2SEEIIUWziti3G99ZBbitrrHu+h5WF+dMn80dQTDp16oSfnx/ff/89Bw8eNJ1PTEzknXfewdLSksGDB5vOX716lcjISK5ezTot+PnnnwdgwoQJpKWlmc5v3LiRtWvX0q5dOwICAgp9X51Ox7Bhw7h16xZTp07Ncu8ZM2Zw48YNhg0bhk6nu4+vRtF7rm83Ptc9AUDGyvGQGGfmiIQQQoiip27fwC5iMgCrPQbSokljs8ZjUuzLCpvRpk2blJWVlXJ0dFTDhw9Xr732mqpVq5YC1LRp07LUDQ8PV4AKDw/P1s6wYcMUoIKCgtTrr7+uBg4cqGxsbJSLi4s6cuTIfd1XKaVu3bqlGjdurADVpUsX9eabb6ru3bsrQDVu3FjdunWrQO+7pHZi+G5nlPpnYiOlwp1Vytf9lTIai/V+QgghREk79/ULSoU7q5OTAtW5SzeK9V6yE8MdHTp0YPv27bRp04affvqJ+fPn4+Hhwbfffsvbb7+d73Y+//xz5s6di06nY+7cuaxcuZLevXuzZ8+ebPugFua+Dg4OREREMHbsWCIjI/nwww85fPgwY8eONS0kXBr1D67NAo/XSVcW2JxaDUd+NXdIQgghRJFJjd5HtVPaMKG99d+mZiVX8wZ0l3K9mX1FVZKb2R86H8+mz8Yw2vJX0m3csXrlL3DwLNZ7CiGEEMXOaCRuThuqJB5hrb4tbd9chr21ZbHesiCf3+X6CZwofg2ru3Cz2SscM9bAKvU6hpXjzB2SEEIIcd9u7viCKolHSFR2qK7Tij15KyhJ4MR9G9OtAdOtXiZD6bE4+hsc+8PcIQkhhBCFl3QVq83axMKfnQcSGvyAmQPKThI4cd9c7Kx4rFcvPjf0AsDwx1hIvm7mqIQQQojCufJbGA7GRI4afWjeb3ypWwkCJIETRaRP42rsqj6MKGM1LJKvwJowc4ckhBBCFJjh3J94nfwJgC3+b9KghoeZI8qZJHCiSOh0Oib1bUqYYQQGpYN/foQTa80dlhBCCJF/hgwSfh4FwK90oF/fx8wcUO4kgRNFJqCyE83adOVLQw8A1B+jISXnPV6FEEKI0ub2js9wSzzBTeVASshEPBxtzB1SriSBE0XqlY7+fG8/gDPGyugSY2HdBHOHJIQQQuQtMQ59xHQAFtsP4ol2Tcwc0L1JAieKlIONJW8+3IQ30kdoJ/Z/Dac2mTcoIYQQIg8Jy9/AxpjMQWNtmj86tlTsd3ovpTs6USaF1q+CQ0BbFmd0BUD9/gqkJpo5KiGEECJn6nQEzieXY1Q6VtV8ndb+lcwdUp4kgRNFTqfTMeXh+nzE08QYvdDFx8CGyeYOSwghhMguI42k38YC8L3qwrOPPmLmgPJHEjhRLHw8HBjcvj7jM4ZrJ/76As5sM29QQgghxH+k75iHY+Jprihn4luOp4a7vblDyhdJ4ESxGRlSmwtuLfg+o6N24veXIS3JvEEJIYQQmW5Gw5b3AfjUahBDOjc2bzwFIAmcKDa2VhZMebg+72Y8TaxyhxtnYdM0c4clhBBCAHD7jzewMqaw2xhIk14vlLr9Tu9FEjhRrNrXrUTbBn68ma51pao/P4Xo3WaOSgghRIV3Yh12p1aTofT8VGkMvR6oau6ICkQSOFHsJvYK4i/LpizNaIcOBctfgvTb5g5LCCFERZV+m5TfXwNgoaE7zz3ao1Tud3ovksCJYlfV1Y7Rnfx5J2MAV3CDa1EQMdPcYQkhhKigjNtmY3srmljlTmzj0dSv6mLukApMEjhRIp5rU4vKlaoQlvacdmLnXLiwz7xBCSGEqHiunUJt/wiAD3WDGdW9dO+4kBtJ4ESJsLLQM61PAzYYm7Hc0AqUEZa9BBmp5g5NCCFERaEU6Stew8KYxlZDQxp2GYi7g7W5oyoUSeBEiQn28+DRJtWYnD6QGzpXuHIMtn5g7rCEEEJUFMd+x+rMZlKVJYtcXuaZlj7mjqjQJIETJSqsRz0ybN15K3WQdmL7bIj9x7xBCSGEKP9Sb5G+cjwAnxt6MbxPZyxL+X6n91J2IxdlkpeTDW+E1mW1MZh1BIMxA5a/CIZ0c4cmhBCiHFNb3sMqKZZooxcnA0bQqo6nuUO6L5LAiRL3dLAPDau58FbKYJIsnCHuENwZUCqEEEIUucvHULvmAzBdDeb1Xo3NG08RkAROlDgLvY53+jTgms6Ft24P0E5ueQ8uHzNvYEIIIcofpTCseA29ymCdoRl12/UrM/ud3oskcMIsGtdw5ekWNVlubM0uyxZgTIdlL4Ihw9yhCSGEKE/++QmL6B3cVtZ8ZjecF0JqmzuiIiEJnDCb10Pr4u5gw5hbA0m1dISL++HP/zN3WEIIIcqL2zcxrH0bgHkZfXiuVwh21hZmDqpoSAInzMbV3pqw7oFcwp0paXe6UjdNh6tR5g1MCCFE+bD5XSySr3DK6M3fNQbQs6G3uSMqMpLACbN6rGl1mvu68X1aW47YNwdDqrZXqtFg7tCEEEKUZRcPov5aAEB4xhAmPNKkzO13ei+SwAmz0t+Z0GCh1zP8+rNkWDpAzG7Y8z9zhyaEEKKsMhpRK19Dp4z8YWhJrRY9qeftbO6oilS5TuDi4uIYNmwY3t7e2NraEhAQwNSpU0lLSytwW2vXrqV9+/Y4Ozvj5ORE+/btWbt2bbZ6SUlJfPvtt/Tr14+AgADs7OxwdXUlJCSEH374Ice2IyIi0Ol0ub7+/PPPAsdblgRWcWZIK18u4slH+oHayQ1T4Ppp8wYmhBCibDrwNboLe0lUdnxsMYRXuwSYO6IiZ2nuAIpLXFwcwcHBxMTE0KdPHwICAti+fTvh4eHs2rWLlStXotfnL3/97rvvGDBgAJ6engwaNAidTsdPP/1Et27d+Pbbb3nmmWdMdbdt28azzz6Lh4cHnTp14rHHHuPy5cv8+uuvPP300+zcuZN58+bleJ+QkBDat2+f7Xz16tUL9TUoS8Z0CeCPfy7yfwmt6V/5L2rE74XfX4GBv0M+v09CCCEESdcwrp+MHvgo4zEG9WqJWxnd7/SeVDk1cOBABaj58+ebzhmNRjVo0CAFqIULF+arnevXrytXV1fl6empoqOjTecvXryoqlSpolxdXdX169dN5w8ePKi+++47lZaWlqWduLg45ePjowC1Z8+eLGWbN29WgAoPDy/EO80uPj5eASo+Pr5I2ispf/x9QfmMX6E6vr1IGd6prFS4s1J7Fpg7LCGEEGXJ8peVCndWRyc2UN1nb1LpGQZzR5RvBfn8LpePNhITE1myZAl+fn6MHDnSdF6n0zFjxgz0ej0LFizIV1tLly7l5s2bjBo1iho1apjOe3t7M2bMGG7evMnSpUtN5x944AGefvpprKyssrRTuXJlRowYAcCWLVvu5+2VWz0betPW35NTGV585/ScdnJ9ONyMNm9gQgghyoaYPbD/awAmpA9h4sONyvR+p/dSLt/Vrl27SE1NpUuXLtlmnHh7e9OwYUN2795NSkpKnm1FREQA0LVr12xloaGhQP4TssykztIy557rqKgo5s6dy8yZM/nhhx+4evVqvtotL3Q6HVMero+1hZ5JsQ9x3aMZpN3SulKVMnd4QgghSjNDBmrlqwAszWhHlQbteai2h5mDKj7lMoGLitLWEfP398+x3N/fH6PRyOnTeQ+Sv1dbmecy69yLwWDg66+/RqfT0blz5xzrfP/994wePZqwsDCefvppatasyaxZs/JsOzU1lYSEhCyvssrPy5ERIX4o9IxIGIKytIXTm2H/V+YOTQghRGm290t0cYe4qRyYrRtAWI9Ac0dUrMplAhcfHw+Ai4tLjuXOzs5Z6hW2LQcHBywsLPLVzsSJEzl06BBDhgyhQYMGWcq8vLyYNWsWx44dIykpiQsXLvDtt9/i7u7OG2+8weeff37PtmfMmIGLi4vpdXdXb1n0Uoc61HC3469EdzZW1bqdWfu2dKUKIYTIWWIcatM7AMzK6E//kCZUdyv7+53eS6lO4Dw9Pe+5vMZ/X5ndnaXN//73P2bMmEGTJk34+OOPs5XXr1+fcePGERgYiL29PVWrVuWZZ55hzZo1WFtbEx4ejtFozLX9sLAw4uPjTa+YmJjifDvFztbKgsm96wPw4skW3K7SXOtKXf4S3OPrIIQQooJaNxFdaiJ/G/3Y6tiDkeVkv9N7KdXLiDz11FMkJibmu36VKlWAf5+W5fZkLLOLMbcndHe7uy0Pj6x96UlJSRgMhnu2s2jRIkaOHEnDhg1Zv349jo6Oeb+ROxo0aEBwcDDbtm3j5MmTBATkvI6NjY0NNjY2+W63LOhUrzJdgiqz/uglxhtG8rHlYXRntsK+hdB8mLnDE0IIUVqc2QaHfsKodExIf46wJxpga1U+9ju9l1KdwOW2Xlpe8hqbFhUVhV6vx8/PL19t7d27l6ioqGwJXF5j7RYuXMjw4cMJCgpi48aN2a7PD09PTwCSk5MLfG1ZF947iG1RV/g9xo7nmo2h8ZEZsG4S1OkMbr7mDk8IIYS5ZaTBnYkL3xk64VirOd0bVDFzUCWjVHehFlbLli2xsbFh/fr1qP/MXoyNjeXQoUMEBwdja2ubZ1shISEArFu3LltZ5k4MmXXutnDhQoYNG0ZgYCCbNm3Cy8urwO8jIyOD/fv3o9PpqFmzZoGvL+uqu9nzSictOR52rAkZ1R+C9CRY/rJ0pQohhICdc+HqCa4oZz4w9Cf84aBytd/pvZTLBM7Z2Zn+/ftz+vRpPvvsM9N5pRRhYWEYjUaGDx+e5Zrk5GQiIyOJjs46UL5fv364uLgwb968LGPLYmNj+eijj3B1deWJJ57Ics2XX36ZJXmrVKnSPePdtWtXtkQzIyOD119/nXPnzhEaGoq7u3uBvgblxbA2fvhXcuRqcgZzHMeAlQOc3QZ/fWHu0IQQQpjTjbOordpKDdPTB/BIyyACq5Sv/U7vRaf+mzmUE7GxsQQHB3P+/Hn69u1LQEAA27ZtY8eOHYSGhrJq1aosW2lFRETQoUMHQkJCsk2G+Pbbb3n22Wfx9PTkySefRK/Xs2TJEi5dusQ333zDgAEDTHU3bdpE586dUUoxYsQI07i8uzVu3Jg+ffqY/u3r64tOp6NVq1ZUq1aNmzdvsnXrVo4fP07NmjXZunUrPj4++X7vCQkJuLi4EB8fb5pxW5btPn2N/v/7E50OtrY/RY1dE8HKHkZuB4/yP1BVCCHEfygF3/eHqLXsNATxkuVkNr/eAVf7sr1lVkE+v0v1GLj74e3tze7du5kwYQIrV65kxYoV1KxZkylTpjB+/Ph874MKmPZBnTFjBosXLwagadOmfPXVV6bFfDNFR0ebnqbltvzHoEGDsiRwL7zwAmvWrCEiIoKrV69iaWlJnTp1ePvtt3nttddwc3Mr2JsvZ4L9PHisaXV+2X+ekcce4A/fdujPbtVmpQ5eJXulCiFERRO5AqLWko4FEzOGMK5XYJlP3gqq3D6Bq8jK2xM4gGu3Uun44Rbib6fzficX+v3VX1taJHQGPPSiucMTQghRUlJvwf+1gIQLfJLxCKsrDef3l9tgoS/7Y98K8vktjy5EmeDhaMP4btqq2lO3J5HQLlwr2DgFrp40Y2RCCCFK1JaZkHCBaOXFJxl9mPJw/XKRvBWUJHCizHiyeQ2a1HTlVmoGYeeagV8HyEiBZS+A0WDu8IQQQhS3uMOoXfMBmJQ+mO5N/HjQt2JO8pMETpQZer2OaX0aoNfBykNx/NlwCtg4w/k9sOv/zB2eEEKI4mQ0wspX0SkDqw3N+cvyQd7sXr73O70XSeBEmVK/qguDW9UCYPyG66R3nqYVbJoGV46bMTIhhBDF6uC3ELObZGyZmj6QUZ38qeyc93qu5ZUkcKLMebVrAJWdbTh3LZl5N1pCnS5gSNW6Ug0Z5g5PCCFEUUu6BusnATA7/TFsPWsypLWveWMyM0ngRJnjaGPJpF7aZvefbTnNudbvgo0LXNinrcothBCifNkwCW7fINJYg8WGUCb1DsLGsvzvd3ovksCJMqlHwyq0C/AizWDk7Y03UN1maAURM+DSUfMGJ4QQouic2wUHvgXgrfShhARWpUPde+9wVBFIAifKJJ1Ox9SH62NtqWf7yav8oWsPAd3AkHanKzXd3CEKIYS4X4Z002b1P2R04LA+kIm9gswcVOkgCZwos3w9HXipfR0A3ll5jMQus8DWFWIPwo6PzBmaEEKIovDnfLh8lJs4817GkwxrWwtfTwdzR1UqSAInyrSR7f3w83TgSmIqH+5KhB7axsZEvAdxh80bnBBCiMK7GQMRMwGYnv4kts5evNShjpmDKj0kgRNlmo2lBe/0aQDA17vOcti9KwT2AmM6LBspXalCCFFWrXkT0pPZq+rys6EdYT0CcbApt1u4F5gkcKLMa13Hk4cfqIpRwdvLDmPoMRvs3CHuEGz70NzhCSGEKKjjayByBQYseCvtOZr7ar/nxb8kgRPlwoRe9XCyseTv8/F8fzQFen6gFWydBbF/mzc4IYQQ+ZeWDKteB2BBRg9OUoPJD9dHp6t4+53eiyRwolyo5GTLuNC6ALy/JpIrNXtC0CNgzIDfXoCMNDNHKIQQIl+2vg/x0VzSefFxRl+eCfYhqKqzuaMqdSSBE+XGgJY+NKzmQmJKBu+ujoSes8HeEy4f0X4hCCGEKN0uR8LOeQBMSH0WG3snXu0SYOagSidJ4ES5YaHXMb1vA3Q6+O3ABXbGAr1ma4XbZsOF/WaNTwghxD0oBStfA2MGETRjvfFBxnWti5uDtbkjK5UkgRPlSqPqrgwI9gFgwvLDpAb0gvqPgjJoC/xmpJo5QiGEEDn6+0c4t500nQ0TUgcS5O3MUy1qmjuqUksSOFHujAuti6ejDaevJLFg62no8QE4eMGVSG2rLSGEEKVL8nVYNwGA2el9Oa+8mPJIfSz0MnEhN5LAiXLHxc6KCT3rATBv00miU+yg1xytcMfHcH6vGaMTQgiRzcapkHyVaIuafJnRg0caV6W5r7u5oyrVJIET5dIjjavSqrYHqRlGwn8/jArsBQ37gTJqXanpt80dohBCCICYv2DfIgDGJQ/CytqGsO71zBxU6ScJnCiXdDodUx9pgJWFjs3Hr7D2SBx0fw8cK8PVE7B5urlDFEIIYciAFWMBWKFrzx5Vj5c71qGKi6154yoDJIET5VadSo6MaFcbgCl/HCXJwhl6f6wV7vwEonebMTohhBDs+R9cOsRtC2cm3X4SXw97hrapZe6oygRJ4ES59nLHOtR0tyc2PoWPNpyAut3hgacBpXWlpiWbO0QhhKiYEi6aekOmp/bjOs5M6h2EjaWFmQMrGySBE+WarZUFUx6pD8DCHWc5FpsA3WaAkzdcPwWbppk5QiGEqKDWhEHaLU5a1+O7jPZ0DKxEx8DK5o6qzJAETpR7HepWonuDKhiMignLDmO0cYGHtZW++XM+nNtp3gCFEKKiObkBji7DqLNgVOJArCwsmdgryNxRlSmSwIkKYVLvIBysLdh37gZL98WAfxdo8ixaV+qLkJZk7hCFEKJiSL8NK8cBsNSiJ8eUD0Pb1qKWp4OZAytbJIETFYK3ix1j7+ynN2N1JNeT0iB0OjhXhxtnYMMUM0cohBAVxLbZcOMMt6wrMfXWI1R2tuHlDnXMHVWZIwmcqDAGt/IlsIoTN5PTmbn6GNi6wMNztcI9n8OZbeYNUAghyrurJ2HHRwC8ffsZkrDjrR71cLCxNG9cZZAkcKLCsLTQM71vAwB+2nuev85ehzqdoNlgrcLyFyH1lvkCFEKI8kwpWPkqGNI4Yt+C5ekP0tzXjYcfqGruyMqkcp3AxcXFMWzYMLy9vbG1tSUgIICpU6eSlpZW4LbWrl1L+/btcXZ2xsnJifbt27N27doc6w4ePBidTpfjKzAwMMdrjEYjn3zyCY0aNcLOzg4vLy/69etHVFRUgWMVuWvm486TzWsAMOG3w6QbjNB1GrjUhJvRsH6SmSMUQohy6vAvcGYLRgsbXrjxFHqdjskP10enk/1OC6PcPrOMi4sjODiYmJgY+vTpQ0BAANu3byc8PJxdu3axcuVK9Pr85a/fffcdAwYMwNPTk0GDBqHT6fjpp5/o1q0b3377Lc8880yO140ePRpXV9cs5zw9PXOsO3LkSBYsWEBQUBCjRo3i0qVLLFmyhHXr1rFz506CgmR2TlEZ3y2QdUcvcfxSIgu3n2FESG14ZB58/Qjs/RLq9YbaHcwdphBClB8p8bD2LQC+sXqCaFWZZ4JrUr+qi5kDK8NUOTVw4EAFqPnz55vOGY1GNWjQIAWohQsX5qud69evK1dXV+Xp6amio6NN5y9evKiqVKmiXF1d1fXr17Nck3mPM2fO5OsemzZtUoBq27atSklJMZ3fsGGD0ul0ql27dvlqJ1N8fLwCVHx8fIGuq0iW/BWtfMavUIETVqvzN5K1kyteVSrcWanZ9ZW6LV87IYQoMivHKRXurG6+30j5j/9NNZq8Vl2/lWruqEqdgnx+l8su1MTERJYsWYKfnx8jR440ndfpdMyYMQO9Xs+CBQvy1dbSpUu5efMmo0aNokaNGqbz3t7ejBkzhps3b7J06dL7ijczlmnTpmFjY2M636lTJ0JDQ9m6dSsnTpy4r3uIrB5vWp3mvm7cTjcw5fcj2snOU8DVB+JjYP1E8wYohBDlxYX9sEf7nBuXNJA0rBjXNQA3B2szB1a2lcsEbteuXaSmptKlS5dsfeve3t40bNiQ3bt3k5KSkmdbERERAHTt2jVbWWhoKABbtmzJ8dqVK1cyc+ZM5syZw8aNGzEYDLnew8HBgdatWxf4HqJw9Hod0/o0xFKvY93RS2w8dglsHOGR/9Mq7FsMpzaZNUYhhCjzjIY7m9UrDrp2YX1KIPW8nXk62MfckZV55TKByxz47+/vn2O5v78/RqOR06dP31dbmedym2jw8ssvExYWxquvvkrnzp0JCgpi//79WeokJSURGxtLrVq1sLDIvv9bXvcASE1NJSEhIctL5K1uFSeGttU2TQ7//Qi30wxQqy20eF6rsHwUpMjXUgghCm3vQog9iMHameGX+gIwuXcQFnqZuHC/ymUCFx8fD4CLS86DI52dnbPUK2xbDg4OWFhYZGsnJCSEX375hZiYGG7fvs2xY8cYM2YMp06domvXrly8eLFIY50xYwYuLi6m191dveLeRnfyp5qrHedv3GbepjtJcqdwrSs14bx0pQohRGElXoKNUwH40uZZrihXHn6gKsF+HmYOrHwo1Qmcp6dnrstx5PTK7O40tyFDhvDoo49SvXp1bG1tCQwMZM6cOYwfP55r164xZ86cIr1fWFgY8fHxpldMTEyRtl+e2VtbEt5bm+G7YNtpTl5OlK5UIYQoCuvehtQEbrjWZ+aVh7CzsiCsR85LaYmCK9XLiDz11FMkJibmu36VKlWAf59m5fbUKrOLMbenXne7uy0Pj6x/NSQlJWEwGPLVDsDQoUN599132bFjR47tFzZWGxubLJMfRMF0rV+FzvUqseHYZSYsO8wPw1uiy+xK3fM/rSv1xV1g62zuUIUQomw4HQGHlqJ0ekbfGoQRPS93rIO3i525Iys3SnUCN2/evEJdl9e4saioKPR6PX5+fvlqa+/evURFRWVL4PIaa/dfmWvAJScnm845ODjg7e3NmTNnMBgM2cbBFfQeonDCe9dn+8mr/Hn6Or8duMCjTatD58kQtQ5unIV1E/7ddksIIUTuMlJh5WsA7Kv0KFvPVcfHw55hd8Yci6JRqrtQC6tly5bY2Niwfv16lFJZymJjYzl06BDBwcHY2trm2VZISAgA69aty1aWuRNDZp287N69GwBfX99s90hKSsryZK6w9xCFU8Pdnlc6aUny9JXHiE9OB2uHf7tS938FJzeaMUIhhCgjdsyFayfJsK/E8PPdAZjUKwgby+wT9UThlcsEztnZmf79+3P69Gk+++wz03mlFGFhYRiNRoYPH57lmuTkZCIjI4mOjs5yvl+/fri4uDBv3rwsY8tiY2P56KOPcHV15YknnjCdj4uL49SpU9liunDhAq+88gqgdQ3f7fnntVmPEyZMyLLN18aNG1m7di3t2rUjICCgoF8GUUDD2vjhX8mRa0lpzFoXqZ30bQMtRmjHv78is1KFEOJerp+BbR8AsMB+KDcMdrSv60XHwEpmDqz80an/PqIqJ2JjYwkODub8+fP07duXgIAAtm3bxo4dOwgNDWXVqlVZttKKiIigQ4cOhISEZJsM8e233/Lss8/i6enJk08+iV6vZ8mSJVy6dIlvvvmGAQMGZGmnY8eOtGnThsDAQNzd3Tl79iwrVqwgKSmJQYMGsWjRomzr0w0fPpwvvviCoKAgevbsadpKy9bWtsBbaSUkJODi4kJ8fLxpFqvIn12nrvHUgj/R6WDZi615oIYrpCXBp620rtSmg6QrVQghcqIUfN8PotZxvfJDND33MlYWetaOaYefl6O5oysTCvL5XS6fwIG2YO/u3bsZMmQIO3bsYPbs2Vy6dIkpU6awfPnyfO+DCjBgwABWr15NUFAQixcvZuHChdStW5c1a9ZkSd4AateuzdChQ4mPj+fnn3/mww8/ZMOGDbRq1Yoff/yRxYsX57hx7+eff87cuXPR6XTMnTuXlStX0rt3b/bs2SP7oJagh2p70LdJNZSCicsPYzAq6UoVQoj8iFwBUetQFta8kjAA0PFcm1qSvBWTcvsEriKTJ3D353JiCp0+3EJiSgbv9GnAsy3vrBi+6g3Y8zk4V4cXd4KtbMIshBAApN6C/2sBCRf4q+ZQnjjRiUpONmwa1x5Hm1I9X7JUkSdwQtyHSk62jOtaF4BZayK5eitVK+gcDm61tAV+100wY4RCCFHKbHkPEi6Q4VyT58+2ByCsR6Akb8VIEjghcjCgpQ/1qzqTkJLBjFV3JjRk6Ur9WrpShRAC4NJR+HM+AIudX+BGmgVNa7rSp3E1MwdWvkkCJ0QOLPQ6pvVpgE4Hv+w/z54z17UC39b/mZWa93ZsQghRbimlrflmzOBmza5MO6kNOQnvXT/H8d6i6EgCJ0QumtR048nmNQGYuOww6QajViBdqUIIofn7B4jeibKy57VEbYmsJ5pV12bwi2IlCZwQ9/BGaF3cHaw5fimRxTvOaiezdaVuMFt8QghhNsnXYd1EAA7VGcnGWBscrC14vVtdMwdWMUgCJ8Q9uDlY82Y3bfPlORtOEBt/WyvwbQ3BI7Vj6UoVQlREm96B5KsYPOsyIqoFAKM6+VPJKe9djsT9kwROiDw83qw6zXzcSE4zMG3FsX8LOk2605V6QbpShRAVy/l9sHcRAD96jSX2lhFfD3uGtPY1b1wViCRwQuRBf2dCg4Vex8pDsWw5cUUrsHaAPvMBnXSlCiEqDqMBVowBFLfqPsGUf1wBmNBT9jstSZLACZEP9bydGfSQLwDhyw+Tkm7QCnxaQbDMShVCVCB/fQlx/4CtC5Nu9yPNYKStvyed6sl+pyVJEjgh8mlsF38qOdlw9loy/9t6+t+Cu7tS175tvgCFEKK4JV7Sxr4BJxu+yq8n0rHQ65jUK0iWDSlhksAJkU9OtlZM6KXtS/t/m08SfS1ZK7i7K/XANxAlXalCiHJq3duQmoCxalNeimwEwMCHfPCv7GTmwCoeSeCEKIDejbxpXceD1Awj4b8fxrSVsE+rf2el/iFdqUKIcuj0Fji0FNCxssY4jl+5jZu9FWM6BZg7sgpJEjghCkCn0zH1kQZYWejYfPwK645e+rdQulKFEOVVRpq24wKQ0mQIb+/W9jh9rWtdXOytzBlZhSUJnBAFVNvLkefb+QEw5fcjJKdlaAXW9tKVKoQon3bNg2tR4FCJD9KfICElg8AqTjzVoqa5I6uwJIETohBe7uBPNVc7LsanMG/TyX8LpCtVCFHe3DgLW2YBcCF4Agv33QC0/U4t9DJxwVwkgROiEOysLZjycH0AFmw9TdSlxH8LO00Cd787XalvmSlCIYQoIqvfhIzbKN82jDsWgFFBj4ZVeKi2h7kjq9AkgROikDoHVaZzvUpkGBUTl981ocHaHh7J7Er9VrpShRBlV+QqOLEa9FZsDwhj15nr2FjqCetez9yRVXiSwAlxH8J718fWSs+fp6/z+98X/y3weQhavqAdS1eqEKIsSkuC1W8AkNHyZcK2pQEwop0fNdztzRmZQBI4Ie5LDXd7RnX0B+CdFcdISEn/t7DjROlKFUKUXVtnQXwMuNTkC91jnL9xmyrOtoxsX9vckQkkgRPivg1rWws/Tweu3kpl9roT/xZk60pdb7YYhRCiQC5Hws55ANwIeYePt14AIKxHIPbWluaMTNwhCZwQ98nG0oKpjzQA4OtdZzl84a7u0ru7Un9/BW7fLPkAhRCiIJSCVePAmAEB3Zlywofb6QYe9HHj4Qeqmjs6cYckcEIUgTb+nvRq5I1RwYRlhzEa1b+FHSeCe21IvKhtQyOEEKXZPz/B2W1gacehRm+x7OBFdDptzK/sd1p6SAInRBGZ2CsIRxtLDsbc5Ke9Mf8WZFngV7pShRCl2O2bpj80je1e5+2IBACeaFadhtVdzBiY+C9J4IQoIpWdbRnbRdsTcOaaSK4npf1bWLMltHxRO5auVCFEabVpGiRdAc8AfrXtyz/n43G0sWRcaF1zRyb+QxI4IYrQoId8CKzixM3kdN5bHZm1sOOEf7tSZa9UIURpc2E//PUFAMld3mPmutMAvNKpDpWcbM0ZmciBJHBCFCFLCz3T+mgTGpbsjWHfuRv/Ft7dlXrwWzixzjxBCiHEfxkNsPJVQEHDfnx82purt1Kp5enA4Fa1zB2dyIEkcEIUsQd93en3YHVAm9CQYTD+W3h3V+ofo6UrVQhROuxbBBcPgI0z0Q++xcLtZwCY0LMe1paSKpRG8l0RohiM7xaIi50Vx2IT+HrXuayF0pUqhChNbl2GDVO1444TmRpxlXSDIiTAi46Blcwbm8hVuU7g4uLiGDZsGN7e3tja2hIQEMDUqVNJS0vL++L/WLt2Le3bt8fZ2RknJyfat2/P2rVrs9U7e/YsOp3uni8LC4ss10RERNyz/p9//lnor4EwDw9HG8Z3CwRg9voTXE5I+bdQulKFEKXJuomQGg/eD7DF5WE2HLuMpV7HxF71ZNmQUqzcLqccFxdHcHAwMTEx9OnTh4CAALZv3054eDi7du1i5cqV6PX5y1+/++47BgwYgKenJ4MGDUKn0/HTTz/RrVs3vv32W5555hlTXVdXV8LDw3NsZ+/evaxcuZLQ0NAcy0NCQmjfvn2289WrV89XnKJ0ebJ5DZbsjeHvmJtMW3mMuU81+bewZkt46CXY9Ym2V+qLf4Kdq9liFUJUUGe3wz8/Ajoyun/IOz8fB2DgQ77UqeRk3tjEvalyauDAgQpQ8+fPN50zGo1q0KBBClALFy7MVzvXr19Xrq6uytPTU0VHR5vOX7x4UVWpUkW5urqq69ev56utXr16KUD98ssvWc5v3rxZASo8PDxf7eQlPj5eASo+Pr5I2hOF90/MTVXrzRXKZ/wKtSPqStbC1CSlPm6iVLizUr+9YJ4AhRAVV3qqUp+00H4H/TFGLdx+WvmMX6GaTF2nbianmTu6Cqkgn9/lsgs1MTGRJUuW4Ofnx8iRI03ndTodM2bMQK/Xs2DBgny1tXTpUm7evMmoUaOoUaOG6by3tzdjxozh5s2bLF26NM92Ll68yOrVq6lUqRK9e/cu+JsSZVLD6i4829IHgAnLD5OWcdeEBmt76PMpWlfqd3Aie5e8EEIUmz/nw5VIsPfkess3mbNe28t5XNe6uNhZmTk4kZdymcDt2rWL1NRUunTpkq3/3tvbm4YNG7J7925SUlJyaeFfERERAHTt2jVbWWZX6JYtW/JsZ/HixRgMBgYOHIiVVc7/MaKiopg7dy4zZ87khx9+4OrVq3m2K0q/V7vWxdPRhtNXkliw7XTWwprBWlcq3Fng90b2BoQQoqjdjIYt72nHXafx4bbLJKRkUM/bmf7Na9z7WlEqlMsELioqCgB/f/8cy/39/TEajZw+fTrH8vy2lXkus05ulFIsXLgQgKFDh+Za7/vvv2f06NGEhYXx9NNPU7NmTWbNmpVnjKJ0c7Gz4u2e2oSGeZuiOH8jOWuFjhPAwx9uxcHqN80QoRCiwlkTBunJULMVR7168MOeaAAm9w7CQi8TF8qCcpnAxcfHA+DikvO+bc7OzlnqFbYtBwcHLCws8mxny5YtnDp1ijZt2hAYGJit3MvLi1mzZnHs2DGSkpK4cOEC3377Le7u7rzxxht8/vnn92w/NTWVhISELC9RuvRpXI3gWu6kpBuZ8sfRrIVWdlpXqk6vDSaOXGWeIIUQFcPxNRC5AvSWqJ4fMmXFUYwKejbyJtjPw9zRiXwq1Qmcp6dnnkty3P3K7O4sbb788ksg96dv9evXZ9y4cQQGBmJvb0/VqlV55plnWLNmDdbW1oSHh2M0GnO8FmDGjBm4uLiYXneP1ROlg06nY1qfBljqdaw/eomNxy5lrVCjObQapR2vGAPJ10s8RiFEBZCWDKtf144feonVl93YfeY6NpZ6wrpnf8AgSq9SvYzIU089RWJiYr7rV6lSBfj3aVluT8Yyn1Dl9oTubne35eGR9S+TpKQkDAbDPdu5efMmv/zyC87OzvTr1y/vN3GXBg0aEBwczLZt2zh58iQBAQE51gsLC+PVV181/TshIUGSuFLIv7ITQ9vW4vMtpwn//QitantiZ33XmoDt39L+Mr56HFa/AY99Yb5ghRDl07YPtfFvztVJafUa0+ftA2BESG2qu9mbOThREKU6gZs3b16hrstrbFpUVBR6vR4/P798tbV3716ioqKyJXB5jbUDbVzb7du3GThwIPb2Bf/P4enpCUBycnKudWxsbLCxsSlw26LkvdLRnz8OXuT8jdvMjzjJa13r/ltoZQt9P4UvusChpRD0CNSTGctCiCJyNQp2fKwdd5/Jgj8vc+HmbbxdbBkZkvfnoShdSnUXamG1bNkSGxsb1q9fj1IqS1lsbCyHDh0iODgYW1vbPNsKCQkBYN267KvlZ+7EkFknJ5ndp8OGDct3/JkyMjLYv38/Op2OmjVrFvh6Ufo42FgyqXcQAJ9vOc3pK7eyVqjWDFqP1o5XjIWkayUcoRCiXFIKVr4GxnTw70qsdyfmR5wCIKxHPeytS/XzHJGDcpnAOTs7079/f06fPs1nn31mOq+UIiwsDKPRyPDhw7Nck5ycTGRkJNHR0VnO9+vXDxcXF+bNm0dMTIzpfGxsLB999BGurq488cQTOcZx8OBB9u/fT6NGjXjwwQdzjXfXrl3ZEs2MjAxef/11zp07R2hoKO7u7vl+/6J0C61fhfZ1vUgzGJm0/Ei27z3t3wSvepB0BVaNM0+QQojy5fAvcGYLWNpC9/eZueY4t9MNPOjjRu9G3uaOThRCuU25Z86cyebNm3nppZfYsGEDAQEBbNu2jR07dhAaGsqgQYOy1N+zZw8dOnQgJCQky2QINzc3PvnkE5599lmaNm3Kk08+iV6vZ8mSJVy6dIlvvvkGNze3HGPI79O3p556Cp1OR6tWrahWrRo3b95k69atHD9+nJo1a2ZJQkXZp9PpmPJwfbrM2cr2k1dZeSiWXo2q/lvB0kbrSl3QCY78qnWl1u9jtniFEGVcSjysfUs7bjuOvQkuLD94FJ0OJj9cX/Y7LaPK5RM40Bbs3b17N0OGDGHHjh3Mnj2bS5cuMWXKFJYvX57vfVABBgwYwOrVqwkKCmLx4sUsXLiQunXrsmbNGgYMGJDjNSkpKXz33XfY2NjkWifTCy+8gK+vLxEREXz88cem695++20OHjyIj49Pgd67KP18PBx4sX1tAN5ZcZRbqRlZK1RtAm3vTExZ+SrculLCEQohyo3N78KtS+BRB+NDo0xLGfV/sAYNquU9mU+UTjqVrf9GlHUJCQm4uLgQHx9vWvNOlD4p6QZCP9rKuWvJDG1Ti4m9grJWyEiDBR3g0mHtKVy/r80TqBCi7Lp4UPs9oozw7DJ+ul6HN375BycbSzaNa4+Xk0yAK00K8vldbp/ACVHa2VpZMPWRBgAs3nmWoxf/swCzpTX0mQ96Szi6HA7/aoYohRBlltGoPcFXRmjwGInV2vD+2kgAXunkL8lbGScJnBBmFBLgRc+G3hiMignLDmE0/ueBuPcD0PbORIaVr8GtyyUfpBCibNq/GC7sA2sn6DqdTzad5OqtNPw8HRjUytfc0Yn7JAmcEGY2sVcQDtYW7I++yZK9MdkrtH0NqjSE29e1pUVk1IMQIi+3rsCGydpxxwmcTnVi4Y4zgPY7x9pSPv7LOvkOCmFmVVxsGdtF22Vj5upIrt1KzVrB0lrbK1Vvqe1fePgXM0QphChT1k/SZp9WaQTNhzF95THSDYr2db3oEFjJ3NGJIiAJnBClwOBWvtTzdib+djozVkdmr1ClIYSM145XvgaJcSUboBCi7Di7A/7+HtBBrzlEnLzOxsjLWOp1TOgZlOflomyQBE6IUsDSQs+0PtqEhp/3nWfPmRw2s28zVhsTl3JTulKFEDkzpGsTFwCaDSbduynvrNCWDRncypc6lRzNGJwoSpLACVFKNPNx46kWNQCYsOwQ6QZj1goWVne6Uq3g+Cr45yczRCmEKNV2/R9ciQR7T+g0iW92nePUlSQ8HKwZ1Sn3fbtF2SMJnBClyPhugbg7WHPi0i2+3H4me4XK9bWttgBWvw4JsSUboBCi9LoZA1ve0467vsM1owNzNpwAYFxoXVzsrMwYnChqksAJUYq42lsT1j0QgI83RHH+RnL2Sq3HaDs1pMTDH6OlK1UIoVnzJqQnQ81W8MBTzF5/gsSUDOp5O9PvwRrmjk4UMUnghChlHm9WnRa+7txON5i2vMnCwlLrSrWwhqi18PcPJR+kEKJ0Ob5Gm6Wut4ReszkWl8gPe6IBCO8dhIVe9jstbySBE6KU0el0TOvbAEu9jvVHL7Hh6KXslSrVgw53Nqde/SbEXyjZIIUQpUdasjakAuChl1BegUz94yhGBT0betPSz8O88YliIQmcEKVQQGUnhratBUD470dITsvIXumhUVCtGaTGwx+vSFeqEBXVtg/gZjQ4V4d2b7D2SBy7Tl/DxlLPm3eGZIjyRxI4IUqp0Z38qeZqx4Wbt/lk08nsFUxdqTZwcgMc+LbkgxRCmNeVE7Bjrnbc/T1S9HZMW3kMgOfb+VHD3d6MwYnidF8J3MaNG3n77bfp0KED/v7+uLm5Ua1aNRo3bsyzzz7LF198QVycLDgqRGHYW1sS3ltbdHPBttOcvJyYvZJXXeg4QTte+xbEny/BCIUQZqWUtuabMR38QyGwJ19uP8P5G7ep4mzLC+1rmztCUYx0ShWs3+XWrVvMnTuXBQsWEB0dTebltra2uLu7c/v2beLj4zEatTWsLC0tefjhhxk7diytW7cu+ncgsklISMDFxYX4+HicnZ3NHY64T8O++osNxy7T0s+dH4a3RKf7z2BkowEWdoPze6B2RxjwK/y3jhCi/PlnKfw6DCxt4aXdXLKoQocPIkhOM/BR/8b0aVLN3BGKAirI53eBnsB99tln1KlThwkTJuDq6sq0adPYtGkTCQkJJCcnc/78ea5du0Z6ejqRkZF89dVX9O/fn3Xr1tGuXTseffRRzpzJYW0rIUSuwnvXx9ZKz5+nr/PbgRwmK+gtoM987Zf4qU2w/6uSD1IIUbJu39SeugO0Gwduvry3JpLkNANNa7rySOOqZg1PFL8CJXCjRo2iW7duHDp0iAMHDhAWFkb79u1xdMy6NYdOpyMgIIBnn32Wb775hkuXLrFgwQIOHTrEN998U6RvQIjyroa7Pa/cWUF9+spjxCenZ6/k6Q8dJ2rHa9/WBjQLIcqvTdMg6TJ4+EOrVzgQfYNf92t/4IX3rp/9Sb0odwqUwEVGRrJ48WLq169foJvY2dnx3HPPERkZyaBBgwp0rRAChrXxw7+SI9eS0nh/bQ6b3QO0fAFqtIS0W7D8ZZmVKkR5dfEA/PWFdtzzQ4x6a9OakY81rc4DNVzNF5soMQVK4GrXvr8BkRYWFvj4+NxXG0JURNaWet65s9n993uiORhzM3slU1eqHZzZAnsXlmyQQojiZzTAirGAgoZPgF8Iy/++wMGYmzhYWzC+W11zRyhKyH3NQt22bVtRxSGEyENLPw8ebVoNpeDt3w6R8d/N7gE8akPncO143US4cbZEYxRCFLN9i7QncDbO0HU6SakZzFytPZV/qWMdKjnbmjlAUVLuK4ELDQ1l2bJlRRSKECIvb/Woh4udFUcuJvDNn+dyrtRihLYXYnqS1pVqzCHRE0KUPbcuw4ap2nHHieBUmU8jTnEpIZUa7nY817qWeeMTJeq+ErhatWrxxBNP8L///S/XOrdu3SI8PPx+biOEuMPT0YY37nSRfLjuBJcSUrJX0uuhz/+BlT2c3QZ7vyzhKIUQxWLdBG3nFe8HoPlQYq4n879tpwF4u0cQtlYWZg5QlKT7SuB27NhBy5YteeGFF5g6dWqWsrS0NObMmYOfnx/Tpk27ryCFEP96qnlNGtdw5VZqBu+syGGzewB3P+g8RTtePwmuny65AIUQRe/MNvhnCaCDXnNAb8GM1cdIyzDSqrYHofUrmztCUcLuK4FzdXVlw4YN9OnTh8mTJ/Piiy+SkZHB4sWLCQgIYNy4cRgMBknghChCer2OaX0aoNfBin9i2RZ1JeeKzYeBb1tIT5auVCHKsow0WPmadvzgc1CtGbtOXWPVoTj0OpjUO0iWDamA7nsvVBsbG37++WdeeuklPv/8cypVqsTQoUO5ceMGb7/9NmfOnCEsLKwoYhVC3NGgmgsDH/IFYOKyw6SkG7JX0uvhkU/AygHO7YA9uQ91EEKUYrs+gavHwcELOk3EYFRMvfP0/engmgRWkR13KqIi2cx+9+7dREZGopTi5s2bVK5cmePHjzN16lTZykmIYvJa1wAqOdlw9loyn205lXMlN1/oemd4w4bJcC2XekKI0unGOdjyvnbcdRrYubHkrxiOxSbgbGvJq11k2ZCK6r4SuH379tGzZ09at27Npk2beOaZZxg9ejRxcXEMHjyYpKSkoopTCPEfTrZWTOylbXY/P+IUZ6/m8v+t2XNQKwQybsOyF7V1pIQQZcOaN7X/uz5toFF/4m+n88G64wCM7RKAu4O1mQMU5nJfCVzz5s1ZvXo13bp148CBA3zzzTfMmTOHOXPmsH79etq3b8+VK7mMzxFC3Ldejbxp6+9JWoaRicsPo3LafSGzK9XaEWL+hN2flXygQoiCi1wFx1eB3hJ6fgg6HXM3RnE9KY06lRwZ0FIWxq/I7iuBa9myJREREaxcuZJGjRqZzo8ePZrvvvuOQ4cO0bp1a9nAXohiotPpmPpIA6wt9WyLusrKQ7E5V3StqXW/AGycClejSi5IIUTBpSXB6je041ajoFIgJy/f4qudZwGY2CsIK4siGQUlyqj7+u7v3LmTdu3a5Vj25JNPsmLFCuLi4mjVqtX93KbQ4uLiGDZsGN7e3tja2hIQEMDUqVNJS0srUDvz5s1jyJAhNGrUCEtLS3Q6HREREUV6b6PRyCeffEKjRo2ws7PDy8uLfv36ERUlH7Ti3mp5OvBCiLbN3dQ/jpKYksNm9wDNBoNfB8hIka5UIUq7rbMgPgZcakK71wGYvvIoGUZFp8BKhAR4mTlAYW7Fmr537tw5z0SnuMTFxREcHMzChQt56KGHGDNmDJUqVSI8PJxHHnkEYwGWVHjllVdYvHgxV69excsr7/80hbn3yJEjGTVqFAaDgVGjRtGjRw9+//13mjdvztGjuaz1JcQdL7Svja+HPZcTU5m9/kTOlXQ6eHgeWDvB+T2w6/9KNkghRP5cjoSd87Tj7u+BtQObIy+z+fgVrCx0vN2znnnjE6WDKgGnTp0qidtkMXDgQAWo+fPnm84ZjUY1aNAgBaiFCxfmu60VK1ao2NhYpZRSI0aMUIDavHlzkd1706ZNClBt27ZVKSkppvMbNmxQOp1OtWvXLt+xKqVUfHy8AlR8fHyBrhNl25bjl5XP+BWq1psr1KHzN3OvuO8rpcKdlZrqpdTl4yUXoBAib0ajUgt7aP9Hv39SKaVUarpBdfhgs/IZv0JNX3nUzAGK4lSQz+8CPYHr1asX+/btK3CS6Ofnx+3bt/nggw/49NNPC3x9QSUmJrJkyRL8/PwYOXKk6bxOp2PGjBno9XoWLFiQ7/Z69uxJlSpViu3emf+eNm0aNjY2pvOdOnUiNDSUrVu3cuJELk9VhLijXYAXPRt5Y1QwYdlhjMYcJjQANHkW6nQGQyosGwmGjJINVAiRu3+WwLntYGkH3WYC8PWus5y+koSHgzUvd6xj5gBFaVGgBC4mJoYWLVrQqVMnFi9eTEJCQp7X7N27lzFjxuDj48OkSZPw9PQsdLD5tWvXLlJTU+nSpUu21am9vb1p2LAhu3fvJiUlh30kzXDviIgIHBwcaN26dbb2QkNDAdiyZUuRxyrKn0m9gnC0seRgzE1++Cs650o6HfSeCzYucGEf7JpXskEKIXJ2+4a23ylAyBvg5sO1W6l8vFEbC/16aF2cba3MGKAoTSwLUvngwYMsWrSIqVOn8txzzzFs2DACAwNp2rQplStXxs3Njdu3b3P9+nWioqLYu3cv8fHx6PV6+vXrx/Tp0/H19S2mt/KvzIH//v7+OZb7+/vz999/c/r0aYKCgsx676SkJGJjY2nQoAEWFtk3Is5s516TGVJTU0lNTTX9Oz+JtSifKjvb8mqXAKauOMp7qyMJrV8FT0eb7BVdqkG3GbD8Rdj8LgR0h0qBJR+wEOJfG9+BpCvgWRceehmAD9efIDElg/pVnXniwRpmDlCUJgVK4HQ6Hc899xyDBw9m5cqVLF68mC1btvDtt99mq6vX62nUqBF9+vRh2LBhVK1atciCzkt8fDwALi4uOZZn7g6RWc+c9y6KWGfMmMGUKVMKF7AodwY+5MPP+85zNDaBd1cdY3a/xjlXbPw0HF0OUWu1rtShG8CiQL8ShBBF5fw+2LtQO+75IVhac+RiPD/s0Z6kh/euj4Ve9jsV/yrUb2u9Xk/v3r3p3bs3AMeOHeP8+fNcu3bNtARG/fr1c01K8svT05Nr167lu/7mzZtp3779fd2zLAoLC+PVV181/TshIYEaNeQvtYrK0kLP9L4NePTTnfy6/wL9HqxBSz+P7BV1Ouj9EcxvCRcPwI6PoN24kg5XCGE0wMqxgIJGT0KttiilmPrHUZSCno28aVHL3dxRilLmvv7cnjVrFu3atSM4OJh69Yp+WvNTTz1FYmJivutnTjTITBxze2qV2cV4vwlmTgp676KI1cbGJsvkByGa1HTjqRY1+X53NBOXHWblK22xtsxhyKtzVej+Pvw2AiJmQt3uULl+yQcsREX215cQ+zfYukDXdwBYcziO3WeuY2OpJ6y7DG8Q2d1XAjd+/Hj0ej0LFy5k4MCBRRWTybx5hRtcnde4saioKPR6PX5+foWOraju7eDggLe3N2fOnMFgMGQbB5fXmDohcjM+NJC1h+OIunyLL7ef4YX2tXOu2Kg/HFkGJ1bDshdg2EawkIHSQpSIxEuwSUva6DQJHCuRkm5g+qpjAIwIqU11N3szBihKq/teyNfa2pqhQ4fy/fff51i+YMECnnzyyfu9TYG0bNkSGxsb1q9fn21vyNjYWA4dOkRwcDC2tral4t4hISEkJSWxY8eObO2tXbvWVEeIgnCxt+KtHtqT8bkbozh/Iznnipldqbau2lOA7R+VVIhCiHVvQ2oCVG0CzYYA8MW205y/cRtvF1tGhhT9gwZRPtx3Ajd27Fg6derE4MGD+emnn7KVX7x4kaVLl97vbQrE2dmZ/v37c/r0aT777N+Nu5VShIWFYTQaGT58eJZrkpOTiYyMJDo6l6UXivHezz//PAATJkzIstXWxo0bWbt2Le3atSMgIOC+4hIV06NNqxFcy53b6QYm/36PHT2cqkCPD7TjLe9B3KGSCVCIiuz0Fji0FNBBrzmgtyAuPoX/23wKgDe7B2JvLROLRM7u+yfDxsaG5cuX07NnTwYMGICVlRV9+/Ytitjuy8yZM9m8eTMvvfQSGzZsICAggG3btrFjxw5CQ0MZNGhQlvp79uyhQ4cOhISEZNv+a+bMmURGRgLaOm+Z5xYvXgzAsGHDaNOmTaHv3aFDB4YNG8YXX3xBkyZN6NmzJ5cuXWLJkiU4OzuXyOLHonzS6XRM69OA7h9vY8OxS6w/eokuQZVzrtzwcTi6DCJXaF2pwzdLV6oQxSUjFVa+ph03H6Y9gQPeXxPJ7XQDzXzcePiBklu9QZRB97Plg06nU1OmTFFKKZWcnKzat2+vrK2t1e+//26qM3nyZKXX6+/nNoV28eJF9dxzz6nKlSsra2trVadOHTVlypQs21Vl2rx5swJUSEhItrKQkBAF5PpatGjRfd1bKaUMBoOaO3euql+/vrKxsVEeHh7q8ccfV8ePF3yrI9lKS/zXzNXHlM/4FarVjI0qKTU994qJl5Sa6att47N5RskFKERFs+V97f/Z+3WUSr6hlFJq37nrymf8CuUzfoX6O+aGWcMT5lGQz2+dUv8ZqFUAer2eyZMnM2nSJEDrhgwNDeWvv/7it99+o3v37kyZMoWpU6diMBjuM9UU+ZWQkICLiwvx8fGmdeRExXY7zUDn2Vu4cPM2I0Nq8+a9ZrUd+hl+GQp6Sxi+CbwfKLlAhagIbpyF/wuGjBR49Ato9ARGo6Lvpzv5O+YmTzSrzqwn5P9dRVSQz+/7HgN3N3t7e1avXk3Tpk157LHHWLduXVE2L4QoJDtrC6Y8rC0P8sW205y4dI/leRo8BvUeBmMGLHsRMtJyryuEKBilYNUbWvJWq502dAH47cAF/o65iYO1Ba93q2vmIEVZcF8JXFBQEJaWWYfROTo6snbtWho2bEjfvn3Ztm3bfQUohCganYMq0yWoMhlGxYTfDmebJW2i00HP2WDvAZcOw9ZZJRuoEOVZ5Ept9xO9FfT4EHQ6klIzeG+NNs765Y7+VHIq+hUSRPlzXwnc4cOHeeutt7Kdd3JyYt26dQQGBrJp06b7uYUQoghNfrg+dlYW7Dl7nZ/3nc+9oqOXtp0PwLYPtZ0ahBD3Jy0JVo/Xjlu/Al7a6gLzI05yOTEVHw97nmvja774RJlSpF2od3NxcWHDhg106dIFOzu74rqNEKIAqrnaMaaztij0jNWR3Ei6R/do/b7aSxnudKWmllCUQpRTW2dBwnlwqQlttW3roq8ls2DbGQDe7lEPG0uLe7UghEmxJXAAbm5urF27tkDbYQkhitdzbWpRt7IT15PSTN02uerxITh4weWj2vpwQojCuRwJO+/sLtTjfbDWdld4d9Ux0jKMtKnjmfsSP0LkoFgTuEw6na4kbiOEyAcrCz3T+jYA4Me/Yth79nrulR08tPFwANvnwIV9JRChEOWMUrBqnDYxqG4Pbc9hYOepq6w5EodeBxN7BclnpSiQEknghBClS3Nfd/o/WAOACcsOk24w5l456GFo8Dgoo9aVmp5SQlEKUU4cWgpnt4GlHXSbCUCGwcjUP7TdUQa09KFuFSdzRijKIEnghKig3uweiJu9FZFxiSzacebelXvMAodKcCUSImaUTIBClAe3b8Lat7XjkNfBzQfQnn5HxiXiYmfF2M6yVaIoOEnghKig3BysCbuz2f2c9VFcuHk798r27tqG9wA750LMX8UfoBDlwebpkHQZPAPgoVEAxCen8+G64wC82iUANwdrc0YoyihJ4ISowB5vWp3mvm7cTjcw5fcj964c2BMa9de6Upe/COn3SPiEENryO399oR33+AAstUTt441R3EhOx7+SI88E1zRjgKIskwROiApMr9cxrU9DLPU61h29xIajl+59QbeZ4FgZrp7QniwIIXJmNMCKV7U/eBo+AX4hAJy8fIuvd50FYFLvICwt5GNYFI785AhRwdWt4sSwtn4AhP9+hOS0jNwr27tD74+1452fQPTuEohQiDJo/1dwcT/YOEPXaabT7646RoZR0SmwEm39vcwYoCjrJIETQvBKpzpUc7Xjws3bzN148t6V63aHB54GFCx7AdKSSyRGIcqMW1dgwxTtuOMEcKoCwJYTV9gUeRlLvY63e9YzY4CiPJAETgiBvbVlls3uj8flsfh2txng5A3XT8GmafeuK0RFsyEcUm5ClUbw4FBAWzZk2gpt2ZBBrXzx83I0Y4CiPJAETggBaJvdd83c7H7ZIYzGXDa7B7Bzhd5zteM/58O5XSUSoxCl3rmdcPA77bjnbLCwBOCHPdFEXb6Fm70Vr3T0N2OAoryQBE4IYRJ+Z7P7v87e4Of999jsHiCgKzQZAChtVmpaUonEKESpZUiHla9px00HQY3mgLZsyOz1JwBt2RAXeytzRSjKEUnghBAm1VztGNvlzmb3q47de7N7gNB3wbkaXD8NG6eWQIRClGK7P9P2DbZzh86TTafnbvp32ZCnWsiyIaJoSAInhMhiSGtts/sbyenMXJ3HZve2LvDwna7U3Z/B2e3FH6AQpVH8Bdh8Z5eSLlO1GdvA6Su3+GrnWQAm9JJlQ0TRkZ8kIUQWVhZ6pt/Z7H7J3hj+utdm9wB1OkPTgdrx8pcg9VYxRyhEKbQ2DNKToEYwNH7GdPrdVZFkGBUd6noREiDLhoiiIwmcECKbB33debL5nc3uf8tjs3uArtPBuTrcOAsbJhd7fEKUKlEb4Ohy0FloExf02kfr9qirbDh2CQu9jrd7Bpk5SFHeSAInhMjR+G6BuDtYc/xSIgu357HZva0zPPKJdvzXAjiztfgDFKI0SE+BVeO04+CRUEV7ep1hMPLOnWVDnm3pQ51KsmyIKFqSwAkhcuTmYE1Y90AAPtoQxfkbeSzYW7sDNBuiHUtXqqgodnwEN85o6yK2f9N0esneGI5fSsTFzooxnWXZEFH0JIETQuTq8WbVaVHLXdvs/o+jeV/Q9R1wqQk3o2H9pOIPUAhzun4ats3WjkPf1Z5EAwkp6Xy4Tls2ZGxnf1ztrc0VoSjHJIETQuRKp9MxrU8DLPU61h+9xLojcfe+wMbp367UvV/Cqc3FH6QQ5qAUrHodDKng1wHq9zUVfbLpJNeT0qjt5cAzLX3MGKQozySBE0LcU0BlJ4a30za7n/LH0Xtvdg/gFwLNh2nHv4+ClIRijlAIMzj2B5zcABbW0OMD0OkAOHs1iUU7tDGjE3oFYSXLhohiIj9ZQog8vdLR37TZ/ccbo/K+oPMUcPWB+BhYP7H4AxSiJKXegjV3xru1HgOedUxF7646RrpBERLgRYe6lcwTn6gQJIETQuTJztqCqY9om91/ue0MkXF5PFWzcYRH/k873rcYTm4s3gCFKElb3oOEC9ofKW1fNZ3eeeoq645qy4ZM6FnPjAGKikASOCFEvnSqV5nQ+nc2u//t8L03uweo1RZajNCOfx8FKfHFH6QQxe3SUfhzvnbc4wOwsgPAYFS8s+IYAM8E18S/spO5IhQVRLlO4OLi4hg2bBje3t7Y2toSEBDA1KlTSUvLY3/H/5g3bx5DhgyhUaNGWFpaotPpiIiIyLFuUlIS3377Lf369SMgIAA7OztcXV0JCQnhhx9+yPGaiIgIdDpdrq8///yzoG9diGIR3rs+9tYW7D13g5/35bHZPUDncHCrpT2tWPtW8QcoRHFSStus3pgBgb0goKupaOneGI7FJuBsa8mYzgFmDFJUFJbmDqC4xMXFERwcTExMDH369CEgIIDt27cTHh7Orl27WLlyJXp9/vLXV155BQBvb2+8vLyIi8t9Jt62bdt49tln8fDwoFOnTjz22GNcvnyZX3/9laeffpqdO3cyb968HK8NCQmhffv22c5Xr149X3EKUdyqutoxtnMA01cd493Vx+gcVBl3h3sskWDtAH0+hUXd4cC3UO9hCAgtuYCFKEp//wjRO8HKHrrNNJ1OTEnng3XHARjdOeDe/yeEKCqqnBo4cKAC1Pz5803njEajGjRokALUwoUL893WihUrVGxsrFJKqREjRihAbd68Oce6Bw8eVN99951KS0vLcj4uLk75+PgoQO3ZsydL2ebNmxWgwsPD8x3TvcTHxytAxcfHF0l7QtwtLcOgQudsUT7jV6jXlx7M30Vr3lIq3FmpWQFKJV8v3gCFKA7J15V6z0/7Od42J0vRjFXHlM/4FarDrM0qNd1gnvhEuVCQz+9y2YWamJjIkiVL8PPzY+TIkabzOp2OGTNmoNfrWbBgQb7b69mzJ1WqVMlX3QceeICnn34aKyurLOcrV67MiBHaeKAtW7bk+95ClDZ3b3b/097z7DmTx2b3AB0ngEcduBUHq9/Mu74Qpc3GdyD5KngFQssXTaejryWbtpp7u2c9rC3L5ceqKIXK5U/arl27SE1NpUuXLujurM2Tydvbm4YNG7J7925SUlJKNK7MpM7SMuee66ioKObOncvMmTP54YcfuHr1akmGJ0S+NfNx56kWdza7X3Yo783ureygz2eg08M/P0LkyhKIUogicmEf7F2oHff8ECz/7SKdsfoYaQYjbf096Rgoy4aIklMuE7ioKG2dKn//nPef8/f3x2g0cvr06RKLyWAw8PXXX6PT6ejcuXOOdb7//ntGjx5NWFgYTz/9NDVr1mTWrFklFqMQBZG52f2JS7f4Mq/N7gFqNIdW2nhS/hgNSdeKN0AhioLRACteBRQ06g++bUxFf56+xurDceh1MKFnULYHBkIUp3KZwMXHa8sVuLi45Fju7OycpV5JmDhxIocOHWLIkCE0aNAgS5mXlxezZs3i2LFjJCUlceHCBb799lvc3d154403+Pzzz+/ZdmpqKgkJCVleQhQ3V3tr3uqhrXX10YYTxFzPY7N7gPZhWhdU0hVYNa6YIxSiCOxdCLEHwcYFurxjOq0tG6LtD/x0cE3qVpFlQ0TJKtUJnKen5z2X1/jvK7elPcztf//7HzNmzKBJkyZ8/PHH2crr16/PuHHjCAwMxN7enqpVq/LMM8+wZs0arK2tCQ8Px2jMvYtqxowZuLi4mF41atQozrcjhMljTasRXMudlHQjU/44kvcFVrbarFSdBRz5FY78VvxBClFYty5rY98AOk0Ep8qmol/2n+fIxQScbC0ZK8uGCDMo1cuIPPXUUyQmJua7fuZEg8wnb7k9Yct8QpXbE7qitGjRIkaOHEnDhg1Zv349jo6O+b62QYMGBAcHs23bNk6ePElAQM6/JMLCwnj11X9XA09ISJAkTpSIzM3uu3+8jQ3HLrPuSBxd6+cx4adaU231+q2ztDW1fNqAo1fJBCxEQaybCKnx4P0APPic6fSt1AxmrdWWDXmloz8ejjbmilBUYKU6gcttvbS8ZI59yxwL919RUVHo9Xr8/PwKHVt+LFy4kOHDhxMUFMTGjRvx8PAocBuenp4AJCfn3j1lY2ODjY38AhHm4V/Ziefb+TE/4hSTfz9C6zqeONjk8aul3RtwfDVcOgwrx0K/b0ybgQtRKpzdrk24QQc954DewlT0acRJriSm4uthz6BWvmYLUVRspboLtbBatmyJjY0N69evR6ms2/3ExsZy6NAhgoODsbW1LbYYFi5cyLBhwwgMDGTTpk14eRX8CUNGRgb79+9Hp9NRs2bNYohSiKIxqqM/1d3suBifwtz8bHZvaa11peot4dgfcPiX4g9SiPzKSNOeDgM8OASqNzMVxVxPZsE2bdLOWz1k2RBhPuXyJ8/Z2Zn+/ftz+vRpPvvsM9N5pRRhYWEYjUaGDx+e5Zrk5GQiIyOJjo6+7/t/+eWXWZK3SpXuPbV8165d2RLNjIwMXn/9dc6dO0doaCju7u73HZcQxeXuze6/2J6Pze4BvBtpT+JA+7BMzH2HEyFK1J/z4Uok2HtCp0lZimauiSQtw0ir2h50CaqcSwNCFD+d+m/mUE7ExsYSHBzM+fPn6du3LwEBAWzbto0dO3YQGhrKqlWrsmylFRERQYcOHQgJCck2GWLmzJlERkYCWrJ14sQJQkNDTWPuhg0bRps22tTyTZs20blzZ5RSjBgxIscFgBs3bkyfPn1M//b19UWn09GqVSuqVavGzZs32bp1K8ePH6dmzZps3boVHx+ffL/3hIQEXFxciI+PN824FaIkjPxmH2uOxNHMx42lIx5Cr8+jW9SQDl90gti/IaA7PPWDdKUK87oZA//XAtKTtafEjZ82Ff119jpPfLYLvQ5WvtKWet7y+1UUrYJ8fpfqMXD3w9vbm927dzNhwgRWrlzJihUrqFmzJlOmTGH8+PH53gcVYM2aNdl2T1i7dq3puH379qYELjo62vQ0LbflPwYNGpQlgXvhhRdYs2YNERERXL16FUtLS+rUqcPbb7/Na6+9hpubW75jFcKcJvUOYmvUFfadu8HSfTH0b55H17+FlbbA7+ft4MRqba/Jxk+VTLBC5GRtmJa81WwFD/z7s2g0Kqb+oS0b0r95TUnehNmV2ydwFZk8gRPm9MW200xbeQxXeys2vhqSvxl62z6EjVO1tbZe3AUu1Yo/UCH+68Q6+P4JbZmbkduhcpCp6Od95xm39G8cbSyJeL09njLzVBSDgnx+l8sxcEII8xncypd63s7cTE5nxurI/F3UajRUa6Yt2fDHKyB/V4qSln4bVr+uHT/0YpbkLSk1g/fXaD/LozrWkeRNlAqSwAkhipSlhZ5pfbTdRn7ed57dp/OxZZaFpTbeyMIGTm6AA98Uc5RC/Mf2OXDjLDhVhZA3sxR9vuUUlxNTqeluz+DWvmYJT4j/kgROCFHkmvm48VQLbfzbhGWHScvIY7N7AK+60HGCdrzmLbh5/zPChciXa6e0BA6g+0yw+XfB9Qs3b/P5Vm3f7Ld6BGJjaZFTC0KUOEnghBDFYny3ung4WBN1+RZfbD+dv4seeglqBENaIix/WbpSRfFTStuX15AGdTpDvYezFL+3OpLUDCPBtdwJzWuXESFKkCRwQohicfdm93M3RhF9LR+b3est4JH5YGkHZ7ZoG4kLUZyOLoNTm7Tu++7vZ1nGZt+56/z+90V0OpjYKwidLHEjShFJ4IQQxebRptV4yM+DlHQjE5YfzrZgdY4860DncO143US4fqZ4gxQVV0oCrAnTjtuMBY/apiKjUTF1xTEA+jWrQYNqxb93thAFIQmcEKLY6HQ6pvdtgLWFnq0nrrDin9j8XdhiBPi0hvQkrSvVmI8xdEIUVMRMSIwFt1paAneX5X9f4O+YmzhYW/BaaICZAhQid5LACSGKlZ+XIy91qAPAlD+OEp+cnvdFej088n9g5QDntsOe/xVzlKLCiTsEu+9stdjjA7D6d2/s5LQM3lt9HICXOtahklPx7ZstRGFJAieEKHYj2/vh5+XA1VupvLc2n2vDudeCLlO04w2TtZmCQhQFo1Hbf1cZIOgR8O+cpfjzLaeJS0ihupsdz7WuZaYghbg3SeCEEMXOxtKCd/s2BOD73dHsO3c9fxc+OBRqhUDGbVj2IhgNxRilqDAOfgcxu8HaEbrNzFIUG3+bz7dqfyy81aMetlaybIgonSSBE0KUiJZ+HjzRrDoAb/16mHRDPsa16fXwyCdg7QQxf8Kf84s5SlHuJV+H9ZO04/Zh4Fw1S/H7a46Tkm6kha873RvIsiGi9JIETghRYt7qUQ93B2uOX0pkwbZ8rg3nWhNCp2vHG9+BKyeKL0BR/m0Ih9vXoVJ9CB6RpehA9A1+O3BBlg0RZYIkcEKIEuPmYM2EntracB9vyOfacABNB0LtTmBIhWUjwZBRjFGKcitmD+z/Wjvu+SFYWJmKlFJMXXEUgMeaVqdhdVk2RJRuksAJIUpU3ybVaFXbg9QMI28vO5S/teF0Onh4Hti4wIV9sHNu8QcqyhdDBqx4VTtuPAB8HspS/PvfFzkQfRN7awteD61rhgCFKBhJ4IQQJUqn0zGtTwOsLfVsi7rK739fzN+FLtW0fSoBImbApaPFF6Qof/b8Dy4dAjs36DI1S9HtNAPvrdZmR7/YvjaVnWXZEFH6SQInhChxfl6OvHxnbbh3VuRzbTiAB56CgG7avpXLRoIhn9eJii3hImy+M46y82Rw8MhSvGDbaS7Gp1DN1Y5hbf1KPj4hCkESOCGEWYwI8aNOJUeu3kpj5pp8rg2n00Hvj8HWFWL/hu1zijVGUU6sfRvSbkG1B6HJwCxFcfEpfBqhLRvyZvdAWTZElBmSwAkhzMLG0oLpfRoA8MOeaPaezefacE5VtJXzAba8B7H/FFOEolw4tQmO/Ao6PfSarS1Nc5dZa49zO91AMx83ejXyNlOQQhScJHBCCLMJ9vOg/4M1AAj79RBpGfnc87Th4xDYC4wZsOwFyEgrxihFmZWRCivHacctRoD3A1mKD52P55f95wFZNkSUPZLACSHMKqxHIB4O1kRdvpX/teF0Oug1B+zc4dJh2DqreIMUZdOOj+H6KXCsAh3eylKklOKdO8uG9GlclcY1XM0QoBCFJwmcEMKsXO2tmdBLWxtu7sYozl5Nyt+FjpW0LjGAbR/Chf3FFKEok66fhq13utpDp4Otc5biNYfj2HP2OrZWet7oFmiGAIW4P5LACSHMrk/jarSp40lqhpGJyw/nb204gPp9tZcy3OlKTS3eQEXZoBSsHq8t/FwrBBo8lqU4NcPAjDvLhjzf1o+qrnbmiFKI+yIJnBDC7Aq9NhxAjw/BwQuuRGrrwwkRuQKi1oGFtbbjwn/Gti3ecZbo68lUcrJhREhtMwUpxP2RBE4IUSr4ejrwSsd/14a7mZzPiQkOHtp4ONDGPMX8VUwRijIh9Zb29A2g9Wjw9M9SfPVWKp9sOgnA66F1cbCxLOkIhSgSksAJIUqN59vV/ndtuNX5XBsOoF5vaNgPlFHrSk2/XXxBitJty3uQcAFcfaDta9mK56w/QWJqBg2qOfNY0+pmCFCIoiEJnBCi1LC21PNu34YA/PhXDHvO5HNtOIDu72mzDa9FwaZpxRShKNUuHYU/52vH3d8Hq6xj247HJfLDnmgAJvYMQq+XZUNE2SUJnBCiVGlRy50nm2trw731WwHWhrN313ZpANj1CZzcUEwRilJJKVj5mrY2YGAvqNvtP8WKaSuPYlTQrX4Vgv08cmlIiLJBEjghRKnzZvdAPB2tOXn5Fv/beir/F9btBg8O1Y5/HQEJscUToCh9/v4BoneClT10m5mtOOL4FbZFXcXaQk9YD1k2RJR9ksAJIUodV3trJvYKAmDuppP5XxsOIPRdqNwAkq/Cr8PBaCimKEWpkXwd1k3UjkPGg2uNLMXpBiPTVmqL9g5u7YuPh0NJRyhEkSvXCVxcXBzDhg3D29sbW1tbAgICmDp1KmlpBdt2Z968eQwZMoRGjRphaWmJTqcjIiIi1/qDBw9Gp9Pl+AoMzPkvP6PRyCeffEKjRo2ws7PDy8uLfv36ERUVVaBYhSgvHn6gKm39PUnLMDJhWQHWhrOyhScWg5UDnN0muzRUBJve0RJ2r0Bo+WK24h/2RHPqShLuDta8fGemsxBlXbmdPx0XF0dwcDAxMTH06dOHgIAAtm/fTnh4OLt27WLlypXo9fnLX1955RUAvL298fLyIi4uLl/XjR49GldX1yznPD09c6w7cuRIFixYQFBQEKNGjeLSpUssWbKEdevWsXPnToKCgvJ1TyHKi8y14brO2cr2k1dZdvACfZvkc9agp7+2tMhvz0PETPBpBbXaFW/AwjzO74O9i7Tjnh+CpXWW4vjkdOasPwHA2C4BONtalXSEQhQPVU4NHDhQAWr+/Pmmc0ajUQ0aNEgBauHChflua8WKFSo2NlYppdSIESMUoDZv3pxr/cx7nDlzJl/tb9q0SQGqbdu2KiUlxXR+w4YNSqfTqXbt2uU7VqWUio+PV4CKj48v0HVClEafbIpSPuNXqCZT16nrt1ILdvFvLyoV7qzUrAClEi8XT4DCfAwZSn3WVvse//J8jlXe+eOI8hm/QnX+MEKlZxhKOEAhCqYgn9/lsgs1MTGRJUuW4Ofnx8iRI03ndTodM2bMQK/Xs2DBgny317NnT6pUqVIcoQKYYpk2bRo2Njam8506dSI0NJStW7dy4sSJYru/EKXZ8LZ+BFR25HpSAdeGA+jxPnjWhVtx8NsIMOZzRqsoG/76EmL/BlsX6PpOtuIzV5P4atdZAN7uWQ9Li3L5kScqqHL507xr1y5SU1Pp0qULuv9soeLt7U3Dhg3ZvXs3KSkpxRrHypUrmTlzJnPmzGHjxo0YDDkPpo6IiMDBwYHWrVtnKwsNDQVgy5YtxRqrEKXV3WvDLdkbw+7T1wpwsYM2Hs7SFk5thJ0fF0+QouQlXtLGvgF0mgSOlbJVmbHqGOkGRUiAF+3rZi8Xoiwrlwlc5sB/f3//HMv9/f0xGo2cPn26WON4+eWXCQsL49VXX6Vz584EBQWxf//+LHWSkpKIjY2lVq1aWFhY5BgrcM/JDKmpqSQkJGR5CVGePOjrzlMtagLa2nCpGQWYWVo5SFvUFWDjOxC9uxgiFCVu3QRITYCqTaDZkGzFO09dZd3RS1jodUzoWc8MAQpRvMplAhcfHw+Ai4tLjuXOzs5Z6hW1kJAQfvnlF2JiYrh9+zbHjh1jzJgxnDp1iq5du3Lx4r8bdRdFrDNmzMDFxcX0qlGjRq51hSir3uymrQ136koSn28p4B9fTQdCg8dBGeDn57RlJ0TZdWYrHPoJ0EHP2aDP+sevwaiYtuIYAE+3qIl/ZSczBClE8SrVCZynp2euy3Hk9LrX0h4laciQITz66KNUr14dW1tbAgMDmTNnDuPHj+fatWvMmTOnSO8XFhZGfHy86RUTE1Ok7QtRGrjYW5nWhvtk80lOX7mV/4t1Om1WqrsfJJyH5S9pK/eLsicjTdtxAaD5UKjWNFuVX/ad52hsAk62loztElDCAQpRMkr1MiJPPfUUiYmJ+a6fOdEg82lWbk+tMrsYc3vqVVyGDh3Ku+++y44dO0zniiJWGxubLJMfhCivHn6gKj/vO8+2qKtMWHaY74YFZxvnmitbZ3h8EXzZBY6vgt2fQcsXijdgUfR2zYOrJ8DBCzpOzFZ8KzWDWeuOA/BKR3/cHayz1RGiPCjVCdy8efMKdV1e48aioqLQ6/X4+fkVOrbCyFwDLjk52XTOwcEBb29vzpw5g8FgyDYOLq/xfEJUJDqdjul9GtJlzhZ2nrrGbwcu8GjTfK4NB1C1MXSdDqtf11burxGc4xMcUUrdOAdb7izM3HU62Llmq/JZxCmuJKbi42HPwFY+JRufECWoVHehFlbLli2xsbFh/fr12VZvj42N5dChQwQHB2Nra1uice3erQ2e9vX1zXI+JCSEpKSkLE/mMq1du9ZURwgBNT3sGd1Z+4Nm2spj3Egq2M4qtBiubXZuTIefh0BK8YyFFcVgzZuQcRt82kCjftmKL9y8zYJt2vjIsO71sLHMPjFMiPKiXCZwzs7O9O/fn9OnT/PZZ5+ZziulCAsLw2g0Mnz48CzXJCcnExkZSXR09H3dOy4ujlOnsm++feHCBdOODk899VSWsueffx6ACRMmZNnma+PGjaxdu5Z27doRECDjOITINLytH3UrO3E9KY0Zq48V7GKdDh75BFxqwo2z8MdoGQ9XFkSu0rq+9Zbajgs5dJ2/tzqS1AwjwbXcCa1f2QxBClFydOq/j6jKidjYWIKDgzl//jx9+/YlICCAbdu2sWPHDkJDQ1m1alWWrbQiIiLo0KEDISEh2SZDzJw5k8hIbQHRXbt2ceLECUJDQ01j7oYNG0abNm1M7XTs2JE2bdoQGBiIu7s7Z8+eZcWKFSQlJTFo0CAWLVqUbdzO8OHD+eKLLwgKCqJnz56mrbRsbW0LvJVWQkICLi4uxMfHm2axClHe7Dt3ncc+3QXAj8+3pKWfR8EaiPkLFnUDY4Y2weHB54ohSlEk0pLg/1pCfDS0HgNdpmSrsj/6Bo/O34lOB3+83IYG1Up2jLMQRaFAn9/FvCuEWV28eFE999xzqnLlysra2lrVqVNHTZkyJct2VZk2b96sABUSEpKtLCQkRAG5vhYtWmSqGx0drYYNG6YaNWqk3NzclKWlpfLw8FBdunRRP/74Y66xGgwGNXfuXFW/fn1lY2OjPDw81OOPP66OHz9e4PctW2mJiiLs13+Uz/gVqsMHm1VKekbBG9j+sbYN01QvpWIPFX2Aomisn6x9n2bXVyr1VrZio9Go+vzfduUzfoUa99NBMwQoRNEoyOd3uX0CV5HJEzhRUcTfTqfTh1u4eiuVsZ0DTGPj8s1ohB/6Q9Q68PCH5yPAxrFYYhWFdOU4fNpaG7P45PcQ2DNbleUHLzD6x4PYW1sQMa49lZxLdnyzEEWlIJ/f5XIMnBCiYnCxsyK8tza84P8KujYcgF4PfT4Dp6pwLQpWjSuGKEWhKaWt+WZMh4BuULdHtiop6Qbeu7NH7gshtSV5ExWGJHBCiDKtVyNvQgK8SDMYefu3w9lmnufJwQMe/xJ0evj7BzjwXfEEKgru0FI4uw0s7aD7ezlOXPhi22kuxqdQ1cWW4e1KdmkoIcxJEjghRJmm0+mY1qcBtlZ6dp2+xi/7LxS8EZ9W0OEt7XjVOLgcWbRBioK7fRPWvq0dtxsHbr7ZqlxOTGF+hDbrf3z3QGytZNkQUXFIAieEKPNquNszupO21M70lUe5XtC14QDavAp+7SE9WVsfLi05z0tEMdo8HZIua2MTW43KscqHa0+QnGagcQ1XHn6gagkHKIR5SQInhCgXhrWtRWAVJ24kpzN9ZQHXhgNtQ/S+/wOHSnD5qLZorDCPiwfgry+0454fgGX2rQKPXIznp33avs8TewXlf0s1IcoJSeCEEOWClYWedx9tiE4Hv+w/z7ojcQVvxKkyPPo/QAf7v4JDPxd5nCIPRgOseBWUERo8rj0V/Q+lFNNWHEMp6P1AVZr5uJV8nEKYmSRwQohyo2lNN55vqw1kf/PXQ1xOTCl4I7U7aGOuQNul4Vr2nVVEMdo+Gy7uBxtnCJ2eY5X1Ry+x6/Q1rC31jO9Wt4QDFKJ0kAROCFGuvNo1gHrezlxPSuP1pf8UfFYqQMibULMVpN2CpYMhI7XI4xQ5OPo7bJqmHYdOB6cq2aqkZRh5d5XWRT6sTS2qu9mXZIRClBqSwAkhyhUbSws+frIxNpZ6tpy4wjd/nit4IxaW8NgXYOcOcf/AuolFH6jIKvZv+G2EdtzieWg6MMdqX+86y9lryXg62vBihzolGKAQpYuluQMQpUd6ejoGg8HcYQhxXywsLAio7ERY90Am/3GU6SuP8ZCfB/6VnQrWkEs16PsZfN8P9nwOtdpCvd7FE3RFl3gJfnhKmwFcuyOEzsix2o2kNOZujAJgXNcAHG3kI0xUXPLTL0hISODq1aukpko3kSgfbGxs6FPfg03Hvdh64gqjfzzIspdaY21ZwE6HgFBtCYud82D5S1ClEbj5FE/QFVV6Cvz4NCRc0JYMeXyR9gQ0Bx9tOEFCSgb1vJ154sEaJRyoEKWLJHAVXEJCAhcuXMDR0RFPT0+srKxkOr4os5RSpKenEx8fT2zsRaZ19+OR8zc5GpvA7PUneLN7YMEb7TgJzu2CC3vh5+fguTVgYVX0wVdESsHvo7Svra0rPL0E7FxzrHryciLf7o4GYGLPeljo5feUqNgkgavgrl69iqOjI9WrV5fETZQLdnZ2ODk5cf78edJvJzDj0UaM/HYfn289RUiAFw/V9ihYg5bW8PhC+KytlmhsnApd3yme4Cua7bPh0E+gs4B+X4NH7VyrTl95DINR0bleZVrV8SzBIIUonWQSQwWWnp5OamoqLi4ukryJckWn0+Hi4kJqaiqd6nrQ/8EaKAWv/XSQ+NvpBW/QzQce+UQ73jkXTqwr2oAromN/aMkwQI/3wS8k16pbT1xh8/ErWOp1vNWjEE9RhSiHJIGrwDInLFhZSXeQKH8yf64NBgOTegfh42HPxfgUJi0/XLgGgx7WZkeCNlsyvhB7rgpN7D/w652vZYvnofmwXKtmGIxMW3kUgIEP+eLn5VgSEQpR6kkCJ+TpmyiX7v65drCxZE7/xljodSw/eJHlBwuZfHV5R5vIcPs6/DIMDBlFFG0FcveMU78Ouc44zfTjXzGcuHQLV3srRnfyL6EghSj9JIETQlQITWu6Maqjtm7YhGWHOX+jEJvVW9nCE4vB2hGid8KW94o2yPIuPQWWPAMJ58GjDjyR+4xTgISUdOasPwHAmE7+uNhLb4EQmSSBE0JUGC93qEOTmq4kpmTw2k9/YzAWYpcGj9rQ+2PteOssOB1RpDGWW0rBH6/A+b/A1gWeWgJ2997D9P82neRaUhq1vRx4pqUs3yLE3SSBE6IYDR48GJ1Ox9mzZ80digAsLfR81L8x9tYW7D5znQXbTheuoYaP39kpQMEvw+HW5SKNs1zaPhv+WaLNOH3iK/C89y4K0deSWbTjLABv96yHlYV8XAlxN/kfISqsiIgIdDodgwcPvq86ZZFSil9//ZVHH32U6tWrY2Njg5OTEw888ABjx47l6FFt0PjatWvR6XR069YtzzYfe+wxdDodv/76a4FiOXv2LDqdLsvLysqKatWq0a9fP/bu3Vuo95gbHw8HJveuD8CH645z+EJ84Rrq9h541YOky/DLUEgrRJdsRXFsxb8zTru/B7U75HnJjNXHSDMYaevvSYe6lYo5QCHKHknghChGM2bM4NixY1SrVs3coZhcv36dzp0789hjj7F582ZatWrF2LFjGT58OFWqVGH+/Pk0bNiQiIgIunTpQs2aNVm/fj3nz5/Ptc2rV6/yxx9/4OXlRe/ehdtuqnbt2oSHhxMeHs6YMWOoW7cuS5cupVWrVmzdurWwbzdHTzxYnW71q5BuUIz+8QC30wqxhZy1vTYeztIOzmyFL7vAtVNFGme5EHfo3xmnzYdDi+F5XrLnzHVWH45Dr4MJPYNkopUQOZAETohi5O3tTWBgYKlZqiUjI4O+ffuyadMmBgwYwLlz5/jpp5+YOXMms2fPZu3atZw9e5ZBgwYRHx+PXq9n8ODBGI1Gvvrqq1zb/eabb0hPT2fgwIGFfq916tRh8uTJTJ48mVmzZrFp0yZmzJhBeno6EycW7WbyOp2Odx9tSCUnG05dSWLm6mOFa6hSIDyzFBy84NJh+F97bX0zobl1Gb5/EtKTwK89dJuZ5yVGo+KdFdoT4Cdb1KRulQLuYStEBSEJnBCFEBUVxZAhQ6hVqxa2trZ4enrStGlTXnvttSz1choDl9ktO3nyZPbv309oaChOTk64uLjQt2/fXMfL/frrrzz44IPY2dlRuXJlhg8fzo0bN/D19cXX1zdfcX/zzTds3bqVdu3a8dVXX+Hs7Jytjre3NwsXLjR1mw4ZMgSdTsfixYtzbXfRokUAPPfccwAsXLiQRx55BF9fX2xtbXF3dyc0NJTNmzfnK85MQ4cOBWDfvn0Fui4/3B2s+eCJBwD4atc5Nh8v5Di2Wm1hxFao0RJSE2DJAFg3AQyFWDC4PElPgR/vnnG6+J4zTjN9t/schy7E42RjyatdAoo/TiHKKEnghCigixcv0qJFC7777jsaN27MmDFjePLJJ/Hy8mLevHn5bmfv3r20bdsWS0tLRowYwYMPPsiyZcvo3LkzKSkpWeouXLiQxx57jFOnTjFw4EAGDRrErl276NKlC+np+U8UvvzySwAmTJiAXn/v//42NjYA+Pr60qlTJ06ePJljV+bevXs5dOgQDz30EEFBQQC89NJLXLp0ic6dOzN27Fj+v707j4uy2h84/hkEBpRNBXHHFf2JeyqaC2oZmmSau3nF3bq2mVtaieRNLW1xyduKmqmYWVaomFyVq2iKW3ldcQ0TFIxNhBGY8/uDmKRBHWBgGPi+X695pec5c57vcxqZL+d5zjkBAQEcPHiQxx9/nO+//97kePPY2pbMrn89vD0Y17UBADM3/8qt27qiNeRSG8aGQZcXcv9+YAWsHQBp8eYJ1NoYZpweNnnGKcCZuFQWbMsdDZ3Wxxt3J21JRyqE1ZK9UEWBlFJkZBXhuaBS5mhXqdSfj9myZQvJycksW7aMl156Kd+xxMREk9vZtm0boaGhDB8+3FA2ZswY1q1bx9atWxkxYgQAycnJvPzyyzg7O3P06FEaNWoEwMKFC+nXrx9Hjx7Fy+vhSyxkZ2dz+PBhbG1t6d69u8lxQu5IWEREBKtXr6ZHjx75joWEhBjq5Dl9+jQNGzbMVy8uLo4OHTowc+ZMnn76aZPO+8knnwDQrVu3QsVbGLP7NifqQiLnb9zmtW9P8uk/HinaZ6qSHfi/DfU6wdapuevEfdw9dx/VhoXrb6u3/4NCzTgFuHM3mxc2HONutp7ezWsYEmshRMEkgRMFysjKocW8nZYO46FOv+VPZXvLfIwdHR2NytzdTd9ku0ePHvmSN8i9Bblu3Tqio6MNCdz333/P7du3mTZtmiF5g9xRqQULFhAREWHS+W7dukVWVhY1a9bEwcHB5DgBBg0aRNWqVdm8eTMrVqzAySl3O6PMzEw2btxIlSpV8l3L35M3yL01O3jwYFasWMHVq1eNks4LFy4wf/58ANLT04mOjiYyMpIaNWqwZMmSQsVbGA52lfhweDsGfhTFrtM3CI2OZWSn+kVvsMXTUMMHvh4DN0/BlwPgsXnw6MvwkFHPcuHstkLPOAWY9/0pLiak4+miZenQNjJxQYiHqAA/TYQwr4CAACpXrszUqVMZNmwYISEhnD9/vtDttG/f3qisbt26QO6oW55ffvkFgEcffdSofqdOnUrs9uK9tFotzz77LOnp6Xz99deG8m+//Zbk5GSGDRtmSOoALl26xKRJk2jcuDEODg6G5UHybjFfv37d6BwXL14kODiY4OBgli5dakje9u3bx//93/+V6PW1qO3CTP9mALz142kuJ6YXr0H3JjAxAtqMBKWHiPm5OxBkJBU/2LIs/mTuunio3P1NTZhxCvDd8Wt8c/QaNhpYNqId1arYl2ycQpQDMgInCuRoV4nTb/lbOoyHcrSrVOT35j0Dptfr71sn79i9z4s1bNiQgwcPEhwczI4dO9i8eTMAzZo1Y8GCBQwdOtSk87u6uhqV5SVjOTl/3b5OTU0FwMPDo8BrMHXUr3r16tjZ2XHr1i10Op3hGTdTTZgwgZUrV7J69ep8kxXyjuW5cOECnTp1IjU1lV69evHUU0/h4uKCjY0Ne/fuJTIyEp3O+Fkzf39/wsPDAUhISGDt2rXMnj2bgQMHcvjw4XwJYkmY0K0hu8/e5OClW7yy6QTfPNeleIvH2leGgf+Ger6wYxac2w6f+MHwdVCrjfkCLytu3/xzj9N0aOhn0oxTgMuJ6bzx3f8AeOmxpnRuVL0koxSi3CjXI3Dx8fFMnDiRWrVq4eDggLe3N2+99RZ3794tVDsrVqxg3LhxtG7dGltbWzQaDXv37i2wbkGLkv79ValS/qQjb1bi/V4///xzUbugyDQaDZXtbcv8qzi3WfISqFu3bt23Tt4zbX9Ptlq3bs2WLVv4448/OHjwIPPmzePGjRsMHz6cqKioIsdUkLyZogkJCUbH9Hq9yc/d2dra0qlTJ7Kysoq0rlrbtm1p3749+/fv5/z58/z222/s3r2bZs2a0bVrV0O9Dz74gKSkJNauXcuuXbv48MMPeeutt5g/fz7Nmzc36VweHh7MmDGDuXPncubMGd54441Cx1tYNjYa3hvWBhcHW36JTWbFf2KK36hGAx3GwYSfwK0+JF+Fz/vAsS+L33ZZkjfjNCUWqjWGYWtznwl8CF12Di9sOEb63Rx8G1bjxd6yWb0Qpiq3I3Dx8fH4+voSGxvLwIED8fb2Zv/+/QQFBXHw4EG2bdv20Fl4efIeVK9VqxYeHh7Ex99/ZpmbmxtBQUEFHjty5Ajbtm3D37/gkS0/Pz969uxpVJ53W02YV7NmzbC3tyc6Oprs7OwCb0UePHgQyE3YCmJnZ0fnzp3p3LkzTZo0YcyYMYSFheVLaIqrTZvc0ZoDBw4wZMiQfMcOHz5Mdna2yW1NmDCBqKgoFi5cyOOPP/7ABLigUboJEyZw7Ngx1qxZg1arRSmVb/QNcm+FAgwYMCBfuV6vL3RyO3fuXEJCQli1ahWvvPKKyculFFVtN0cWPtOKFzYcZ+WeC/g18+ARr2pmaLgdTI6E756DmJ3ww4vw2yF4cknuSJ01Uwp+fPmvGaejTJtxCrBo+1lOXU+lWhV7lo1oRyUbee5NCJOpcmrMmDEKUKtWrTKU6fV6FRgYqAAVEhJiclthYWEqLi5OKaXUlClTFKD27NlT6JgCAgIUoLZs2ZKvfM+ePQpQQUFBhW6zICkpKQpQKSkpD6yXkZGhTp8+rTIyMsxyXms0evTo+/b9r7/+qpycnJSzs7NKSkoylB8+fFjduHHDqP6SJUsUoIKDgw1leZ+3y5cvG8oe9P/78uXLClCBgYGGsqSkJEMcly5dMpRnZWWpxx9/XAHKy8vLpOvNyspS3bt3N5wjNTXVqE58fLyaOHGi2rp1q9GxpKQk5eDgoOrUqaMaNGigbG1tVXx8fL46kydPVoDavn17vvKFCxcqwOjfT941+/v7FxjzsmXLFKDGjx9v0jXmKc7ne1roceU1O0x1e+c/Ki0zq9Dvv6+cHKX+u1Sp+W5KBbkotepRpRIvmK99S9j3fu61zK+q1IX/mPy2nf+LU16zw5TX7DC1+4zxvychKiJTv7+VUqpc3kJNS0tj06ZNNGrUiOeee85QrtFoWLRoETY2Nnz22Wcmt9e/f39q1qxZrJiuX7/Ojh07qFGjRpG3GhLm995779G0aVOCg4Pp0KED06dP5/XXX2fo0KF06NABnU7HF198gZubm+E969evp27dujzxxBP885//5LXXXmPAgAG89tpruLu7G54PMxc3Nzfef/990tLSaN++Pc899xyzZ8+mXbt2JCUlUbt2bZNHk21tbdm6dSu9e/dm7dq1eHl5MWLECObMmcP06dPp168fDRo0YPXq1fmu+d5YBg8ezO+//86VK1cICAjA09MzX53nnnsOOzs7nnnmGcaOHcv06dPp2rUrb731Fv379y/09U+ePJnatWvz5ZdfGkb3Str8p32o4+ZI7B8ZzP/hlPkatrGB7tPhH1uhsvs9uzeEme8cpensdogIzv1zv3egcW+T3vZ7cgYzv/kVgEndG9Kruex1KkRhlcsE7uDBg+h0Ovr06WN0i6hWrVq0atWKQ4cOGS2WWpLWrFlDTk7OA7caiomJYfny5SxevJiNGzcWak0xUTQ1atQgOjqaoKAgsrOz+eSTT1iyZAmHDh1iyJAhHDp0yGhSwsiRIxk/fjxxcXFs3LiR5cuXc/bsWaZOncqxY8dK5Jb3pEmT2Lx5Mw0bNmTNmjWsWbOGzp0789NPP5Gamlrgjgr3U61aNSIiIvjmm2/w8/Nj3759vP/++3z88cdcu3aNyZMnc/LkSfz8/Ap8/723TAtKVtu1a8dPP/3EI488wrfffktISAhubm5ERUXRoUOHQl+7g4MDc+bMITs7m+Dg4EK/vyhcHOz4YHhbbDTwzdFrbD8ZZ94TNPKD5/bds3vDs3/u3mD67XCLi/8fbJkIKOgwweQZp9k5el7eeJyUjCza1HVlpr9pz0UKIf6mFEYES93KlSsVoJYuXVrg8SFDhihAnTp1qtBtF+UWql6vV40bN1aAOnPmjNHxvFtqf385Ojqqd999t9Axyi3UiiMmJkYBatiwYZYOpcwxx+f73fAzymt2mGoTvFPFJZfAv5Psu0qFz829BRnkotQXfZVKjTP/ecwt7YZS7/vkxrzmqdzrMNGS8LPKa3aYajkvXF1NTC/BIIWwPhX+FmpKSgpQ8DIN8Nesvrx6JS0yMpKLFy/SrVu3AmfheXh4sGTJEs6cOUN6ejq///47X331FdWqVWPWrFmG1ejvR6fTkZqamu8lypekpCSjpTcyMjKYNm0aAAMHDrRAVOXfK49707quK8l3spix+Rf0emXeE+Tt3jDsS7B3/mv3hiv7zXsec8rW5e73mhIL1Rr9ucfpw2ecAuyPSeSjvRcAWDS4FfWrW/kEDiEsqEwncO7u7g9dkuPe1/2W9rC0vP0n/z5bL4+Pjw8zZsygefPmVK5cmdq1a/Pss88SHh6Ovb09QUFBD1yrbNGiRbi6uhpe9erVK5HrEJYTGRlJ7dq1GTlyJLNnz2bChAm0aNGCsLAwevfubbSjgzAPu0o2fDC8LQ52Nuy/kMjqA1dK5kQtnobJe6FGC0i/CWufyt2OSpk5YSyuvBmnsYdA++cep5VNm6WbkKbjlU0nUApGdqpPQOvaJRysEOVbmV5GZOTIkaSlpZlcP2+iQd7I2/1G2PJGqO43QmdOycnJbNmyBRcXF4YNG1ao97Zs2RJfX1/27dvHhQsX8Pb2LrDenDlzePXVVw1/T01NlSSunPHx8aFPnz5ERUWxdetWAJo0acKCBQuYMWOGyZMYROE19nDijf4teGPr/3gn/Cxdm1SneU3Tnzk0Wd7uDWGvwq+hubs3xB7OXQzY0c385yuKqGXwy8Y/9zhdDR4F/0z6O71e8erXJ0i8rcPb04l5AS1KOFAhyr8yncDlbbtTWE2b5i4GGRNT8EKcMTEx2NjY5NtXsqRs2LCBjIwMxowZQ+XKhb9dkLfK/p07d+5bR6vVFnpVfWFdmjZtSmhoqKXDqLCe9a3PnrM3+c/Zm7wSeoKtU7viUIxdQO7LvgoM+hjqd/5r94ZP/XJvsVp694az23OTSsjdZaHJYya/9ZP/XmJfTCIOdjZ8NKo9jvYl0HdCVDDl8tf2zp07o9Vq2bVrF+pvtyDi4uI4efIkvr6+hd7Quyjybp9OnDix0O/Nzs7m2LFjaDQa6tcvxubaQohi0Wg0vDOkNe5O9pyNT2PpznMlebL8uzckXbH87g35ZpyON3nGKcDRq0ks/Sm3v4IH+NDU07mEghSiYimXCZyLiwvDhw/n0qVLfPzxx4ZypRRz5sxBr9czaVL+H0B37tzh7Nmz/Pbbb2aL48SJExw7dozWrVs/cPmEgwcPGiWa2dnZzJw5k6tXr+Lv70+1amZYDV4IUWTuTlreGZy7I8fn+y8TdaGEl/nJ272hqT/k6HJ3b9g6FbIyzH8ufQ5kJEPKNbh5Fq4dgYt74MyPcGLjPXuc9oB+7+YmmSZIuZPFSxuPk6NXDGhTm2Ed5NEOIcylTN9CLY7FixezZ88epk6dSkREBN7e3uzbt4+oqCj8/f0JDAzMV//w4cP06tULPz8/o8kQixcv5uzZs8BfWystXryYNWvWALmja926dTOKwdTRt5EjR6LRaHj00UepU6cOycnJ/Pe//+XcuXPUr18/XxIqhLCcx/7Pk9Gd6/PVz78x/etfCH+lO26V7UvuhJWrwchQ2P8+7HkbTnwFcb/k7jXqXBN0t+HubdCl/fnfQvz93rJsE5LCao1gqGl7nELuL8yzt/zK78kZeFWvzNuDWhZr72IhRH7lNoGrVasWhw4d4o033mDbtm2EhYVRv359goODmT17dqEe+g4PDycyMjJf2c6dOw1/7tmzp1ECl5mZyfr169FqtYwePfqB7T///POEh4ezd+9eEhMTsbW1pUmTJrz++utMnz6dqlVN21dQCFHyXn+yBQcu3uJSQjpzvzvJR6Pal2xiYmMDPWZA3Q7wzQS4cRJWtC+hc9mC1jl3SROtE9g75f7XuRb0mGnyjFOAr36+SvipeOwqaVgxsh3ODqYlfkII02jU3+/dCauXmpqKq6srKSkpD1yhPzMzk8uXL9OwYcNSeR5QiNJUkp/vk9dSGLQqimy94r2hbRj8iPl33yhQ6vXcJO63A3+V2Tv9mXQ53ZN0FfHvtlqTb48+yKnrKQxadYC72XreDGjBhG4Ni92mEBWBqd/fUI5H4IQQoqS0quvKtD7eLNl5jqAfTtGpYTXqVSuFRWldasO47XDnVm6yZVcld4SuDEnXZfPixuPczdbzWPMajO/awNIhCVEula1/+UIIYSWe82tMxwZVua3L5qXQ46RmZpXOiTUaqOKeO2pWxpI3gHnfn+JSQjo1XRxYMrSNPPcmRAkpe//6hRDCClSy0fD+sLY4a205/lsyTy7bx7HfkiwdlkV9e+waW45dw0YDy0e2o1qVEpzgIUQFJwmcECVo7NixaDQarly5YulQRAmoV60y6yb6UreqI9eSMhj28UFW7b1g/j1TrcDFhNu8sfV/QO4esp0aytJHQpQkSeBEhbV37140Gg1jx44tVh1rsmbNGsPewSNGjLhvveXLlxvqPffcc6UYofVpW8+N7S93J6B1LbL1infDzzEm5DA30zItHVqpyczK4cUNx7lzN4cujaoztVcTS4ckRLknCZwQJWjRokWcOXOGOnXqWDqUfGxtbdm6dStJSQXf8lu9ejW2tjLHyVQuDnasGNmOdwa3Mmx83+/Dfew9d9PSoZWKRdvPcDoulepV7PlwRFsq2chzb0KUNEnghChBtWrVonnz5tjZla01sPr164dOp2P9+vVGx44dO8aJEyd48sknLRCZ9dJoNAzvWJ+wF7vRvKYzt9LvMnZ1NG9vO83dbL2lwysx4f+LZ+3BqwC8N6wNni6yJJEQpUESOCGKICYmhnHjxhnWGHN3d6d9+/ZMnz49X72CnoHLuy07f/58jh07hr+/P87Ozri6ujJo0KD7Pi/37bff0qFDBxwdHfH09GTSpEkkJSXRoEEDGjRoUKj4H330UZo1a0ZISIjRsZCQEOzs7B64AHVaWhpBQUH4+Pjg6OiIm5sbffv2Zf/+/UZ1jx49ygsvvEDLli1xdXXF0dGRVq1asXjxYrKyjGdu5l1Peno6r776KnXq1EGr1dK6dWu++eabQl2nJTSp4czWqV0Z08ULgM/2XWbIxwe4kphu4cjM71rSHWZ98wsAU3o0omezGhaOSIiKQxI4IQrp+vXrdOrUifXr19O2bVteeeUVRowYgYeHBytWrDC5nSNHjtC9e3dsbW2ZMmUKHTp0YOvWrTz++ONkZuZ/fiokJITBgwdz8eJFxowZQ2BgIAcPHqRPnz4FJkGmGDduHMePH+eXX34xlOl0OjZs2EBAQAAeHh4Fvu+PP/6gS5cuvPXWW1SvXp3nn3+ewYMHc+TIEXr16sXWrVvz1f/ss8/47rvvaNWqFVOmTGHChAmGfYnv9xxeVlYWTzzxBDt27OCZZ55h9OjRXLx4kWHDhvHTTz8V6XpLk4NdJd56uiWf/OMRXB3t+PVaCv2X72Pr8d8tHZrZZOXoeTn0BKmZ2bSp58b0J5pZOiQhKhYlyp2UlBQFqJSUlAfWy8jIUKdPn1YZGRnGB/V6pXS3y/5Lry9yP+3Zs0cBKjAwsFB1li9frgC1bNkyo/oJCQn5/h4YGKgAdfnyZaM2ARUaGpqv/j/+8Q8FqI0bNxrKkpKSlJOTk3J2dlYXL140lGdlZanHH39cAcrLy8uka169erUC1KJFi1RcXJyytbVVL730kuH4hg0bFKB+/PFHQ5xTpkzJ18aoUaMUoEJCQvKVx8fHq3r16ikPD498n6krV66o7OzsfHX1er0aP368AtT+/fvzHfPy8lKAevrpp5VOpzOUR0REKED5+/ubdK0P/HyXot+T7qih/z6gvGaHKa/ZYerVTSfU7cwsi8ZkDu/sOKO8ZoeplkHh6rdb6ZYOR4hywdTvb6WUkqeURcGy7sDC2paO4uHmXgf7KhY5taOjo1GZu7u7ye/v0aMHw4cPz1c2fvx41q1bR3R0tGF06vvvv+f27dtMmzaNRo0aGera2tqyYMECIiIiihR/zZo16du3L+vXr2fJkiXY29sTEhJCrVq16NevH/v27TN6T2JiIps2beKxxx5j3Lhx+Y55enoyc+ZMXnrpJSIiIggICADAy8vLqB2NRsPUqVMJCQkhIiKCrl27GtX54IMPsLf/ax2xxx57DC8vL6Kjo4t0vZZS282RDZN8WbnnAsv/E8OWY9c4/lsSy0e2o2UdV0uHVyT7YhL4d+RFABY/07p0dqEQQuQjCZwQhRQQEMBrr73G1KlT2bVrF3379qVbt254e3sXqp327Y03JK9bN3dPzeTkZENZ3i3ORx991Kh+p06dijVbdPz48YSFhfH999/j6+vL7t27mTlzJpUqVSqwfnR0NDk5OWRmZjJ//nyj4zExMQCcPXvWkMDdvXuXlStXEhoaytmzZ7l9+zbqni2Yr1+/btSOm5sbDRsa759Zt25dDh48WJRLtSjbSja88rg3XRpV5+XQE1xKTOeZVQd4rV9zxnVtYFW7FdxMy2TaphMoBaN869O/dS1LhyREhSQJnCiYXeXc0a2yzq7ov/nb/LkNkV5//xmCecds7tmyqGHDhhw8eJDg4GB27NjB5s2bAWjWrBkLFixg6NChJp3f1dV49CUvGcvJyTGUpaamAhT4TJqNjU2hRv3+Lu9Zt5CQEE6fPo1erzcaWbvXH3/8AUBUVBRRUVH3rZee/tcD+0OGDOHHH3/E29ub4cOHU6NGDezs7EhOTmbZsmXodDqj9xfUN5DbPw/6/1XW+Taqzo6XuzNry6/sOn2Dt8JOE3UhkSVD21jFrgV6vWL617+QePsuzWs6My+ghaVDEqLCkgROFEyjsditydKSlyTcunXrvnUSExPz1c3TunVrtmzZQlZWFkePHmXHjh0sX76c4cOHU7t27QJvCRaVi4sLAAkJCUbH9Ho9iYmJRV5nLm+26bJlyzhx4oRhdurDYpk+fTpLly59aPvR0dH8+OOP+Pv7s23btnwjez///DPLli0rUtzWrGoVez79xyOs+/kq/9p2hv+cvUm/Zf/lw+Ht6NK4uqXDe6B/R15kX0wijnaVWDmqHQ52BY/UCiFKnsxCFRVWs2bNsLe3Jzo6muzs7ALr5N2ua926dYHH7ezs6Ny5M8HBwSxfvhylFGFhYWaNs02bNgAcOHDA6Njhw4fvG7upJkyYgF6vJz4+nvHjxz+wbseOHdFoNCbfxrx4Mfc5qf79+xvdli3oGbuKQqPRMKZLA7b+syuNPapwI1XHqM9/5r2fzpGdUzZHGI9e/YP3d50HIPhpH5rUcLZwREJUbJLAiQrLwcGBYcOGkZCQwL/+9S+j4ydPnuTzzz/H2dmZQYMGGcqjo6O5edN4hf0bN24ABU9uKI6nn34aJycnPv/8cy5fvmwoz87O5s033yx2+z4+Pmzfvp3vvvuOkSNHPrBuzZo1GTZsGAcOHGDJkiX5nmXLc+jQIe7cuQP8NYHh7+vDnTp1ikWLFhU7dmvXorYLP77YjeEd6qEUrNh9gRGf/szvyRmWDi2f5Dt3eWnjCXL0iqfb1mboI3UtHZIQFZ7cQhUV2nvvvcehQ4cIDg4mLCwMPz8/HBwcOH/+PD/88ANKKdavX4+bm5vhPevXr2fVqlX07NmTJk2a4OLiwunTp9m+fTvu7u4PHcUqLDc3N95//30mT55M+/btGT58OK6urmzfvh2tVkvt2rXzPaNXFP369TO57qpVqzh37hyzZs1i3bp1dOnSBVdXV2JjYzl69CgxMTHExcVRuXJlOnXqRKdOnfj666+Ji4ujc+fO/Pbbb/zwww/079/fKhbmLWmV7W15Z0hrujV1Z+63JzlyNYl+H/6Xd4e0pm9Ly08QUEox65tf+T05gwbVK/P2oFZWNelCiPJKEjhRodWoUYPo6Gg++OADtm7dyieffMLdu3epWbMmQ4YMYcaMGbRr1y7fe0aOHElmZiZRUVFER0ej0+moW7cuU6dOZcaMGYaZpOY0adIkqlatysKFC1mzZg2urq4MGDCAd955By8vLxo3bmz2c95PtWrVOHDgACtXrmTTpk2sX78evV5PzZo1adOmDW+++aZhYkWlSpUICwvjtddeIzw8nOjoaJo2bcrSpUvp16+fJHD3eKpNbdrUdeOl0OOciE3mua+O8axvfd4MaFFqz5rl6BWxf9zh3I00zsence5GGmfj07hw8zZ2lTSsHNUeJ618bQhRFmhUQfdAhFVLTU3F1dWVlJQUw0PnBcnMzOTy5cuG7aCE9blw4QJNmzZl2LBhbNq0ydLhlCnW+vnOytHz3k/n+fjPddaaeTqzYlQ7vD3N98yZUoobqTpDonY2Po3zN9KIuZlGZpbxM3g2GlgwsCXP+hqv6SeEMB9Tv79BRuCEsApJSUlUrlwZrVZrKMvIyGDatGkADBw40EKRCXOzq2TDa/2a07VJdaZt+oVzN9IYsHI/8wJ8GNmpXqFvXyal3+X8jdzRtHN/Jmrn4tNIzSx48ovW1oamnk54ezrTzNMZ75rOtKjlIpvUC1HGSAInhBWIjIxkwoQJPPHEE9SvX5/ExER2797NlStX6N27t9GODsL6dW/qwY6XuzN98y/893wCc787SdSFRBY+0wpXRzuj+um6bGJu3jbc+sxL1G6mGa+zB1DJRkND9yq5SZqnM81q5r7qV6tMJRt5xk2Isk4SOCGsgI+PD3369CEqKsqwWXyTJk1YsGABM2bMKPYkBlE2eThrWTO2I5/vv8S74efYdjKOE7HJzB/gw5272X8mabc5dyOV2D/uP3O1blVHmt2TpHl7OtPIowpaW1nHTQhrJQmcEFagadOmhIaGWjoMYQE2Nhom92iMb8PqvLjxOL/9cYdJXx4psK67k5bmNfNG1HJvgzb1dJaJB0KUQ/KvWgghrECbem5se6kbb/14msjzCdSvVhnvms6GW6Denk5Ud9I+vCEhRLkgCZwQQlgJZwc7lgxtY+kwhBBlgDw4I4QQQghhZSSBEwVuhySEtZPPtRCiPJMErgLL21w8KyvLwpEIYX55n+u8z7kQQpQnksBVYHZ2dmi1WlJSUmS0QpQrSilSUlLQarXY2RmvmSaEENauXE9iiI+P54033mDbtm0kJSVRv359Ro8ezWuvvYa9vb1JbcTExLB582bCw8O5cOECiYmJeHp60qtXL+bOnUvz5s3Ncm69Xs+qVav49NNPiYmJwcnJiV69evH222/TtGnTYvXDg7i7u/P7779z7do1XF1dsbOzk42qhdVSSpGVlUVKSgq3b9+mTp06lg5JCCFKRLndCzU+Ph5fX19iY2MZOHAg3t7e7N+/n6ioKPr27cu2bdtMWvx0xIgRbNq0iZYtW9KtWzdcXFw4efIkO3bswNHRkZ07d9K9e/din3vy5Ml89tlntGjRgv79+3Pjxg02bdqEg4MDBw4coEWLFiZfe2H2Usurn5iYiE5X8IrtQlgbrVaLu7u7SZ9/IYQoKwrz/V1uE7jAwEC+/PJLVq1axfPPPw/k/nY+btw41q5dS0hICOPGjXtoO2vWrKFdu3a0aZN/6n5oaCgjR46kRYsWnDp1qljn3rNnD71796Z79+7s2rXLsN/lf/7zH/r06UP37t2JjIw0+doLm8DlycrKIicnx+T6QpRFlSpVktumQgirVOETuLS0NDw8PKhTpw4XLlzId0swLi6OunXr4uvry4EDB4p1nmbNmnH+/HkSEhJwd3cv8rlHjRrFxo0biYyMpEePHvnO0a9fP8LDwzl37hze3t4mxVXUBE4IIYQQllOY7+9yOYnh4MGD6HQ6+vTpY/Q8V61atWjVqhWHDh0iMzOzWOfJ+y3f1vavRwmLcu69e/dSpUoVunbtanQOf39/gEKNwAkhhBCifCuXCVxMTAzAfR/+b9q0KXq9nkuXLhX5HIcPH+bUqVN07NgRNze3Ip87PT2duLg4GjZsWOByB3nt5LVbEJ1OR2pqar6XEEIIIcqvcpnApaSkAODq6lrg8bxhybx6RWk/MDAQGxsb3n333WKd2xyxLlq0CFdXV8OrXr16hbgaIYQQQlibMp3Aubu7o9FoTH7t3bu3xGPKzMzkmWee4ezZsyxYsICePXuW+DkfZs6cOaSkpBhesbGxlg5JCCGEECWoTK8DN3LkSNLS0kyuX7NmTeCv0az7jVrl3WK836jX/eh0OgYNGsTu3buZM2cOc+fONapT2HObI1atVmuYuSqEEEKI8q9MJ3ArVqwo0vse9txYTEwMNjY2NGrUyOQ2MzMzGThwIDt37mTWrFksXLjQLOeuUqUKtWrV4vLly+Tk5Bg9B/ewZ+qEEEIIUfGU6QSuqDp37oxWq2XXrl0opYyW8jh58iS+vr44ODiY1N69yduMGTN45513zHpuPz8/QkNDiYqKMlpGZOfOnYY6pspbGUYmMwghhBDWI+9726QV3lQ5NWbMGAWoVatWGcr0er0KDAxUgAoJCclXPz09XZ05c0ZdvXo1X3lGRoZ64oknFKBeffXVEjn37t27FaC6d++udDqdoTwiIkJpNBrVo0cPk69bKaViY2MVIC95yUte8pKXvKzwFRsb+9Dv+nK5kC/kjnb5+vpy7do1Bg0ahLe3N/v27SMqKgp/f3+2b9+ebzurvXv30qtXL/z8/PJNhhg7dixr166lZs2aTJkypcBzjR07lgYNGhT53ACTJk3i888/N8tWWnq9nuvXr+Ps7Gz2fU1TU1OpV68esbGxskhwCZJ+Lh3Sz6VD+rn0SF+XjpLqZ6UUaWlp1K5d++HbfRZqaMfKXL9+XY0fP155enoqe3t71aRJExUcHKwyMzON6u7Zs0cBys/PL1+5n5/fQzPlPXv2FOvcSimVk5Ojli9frnx8fJRWq1XVq1dXQ4YMUefOnTNHV5hNSkqKAlRKSoqlQynXpJ9Lh/Rz6ZB+Lj3S16WjLPRzuR2BEyVDtukqHdLPpUP6uXRIP5ce6evSURb6uUyvAyeEEEIIIYxJAicKRavVEhQUJOvOlTDp59Ih/Vw6pJ9Lj/R16SgL/Sy3UIUQQgghrIyMwAkhhBBCWBlJ4IQQQgghrIwkcEIIIYQQVkYSOCGEEEIIKyMJnCA6Oponn3ySqlWrUqVKFTp16sSGDRsK1YZer2flypW0bt0aR0dHPDw8GDZsGDExMSUUtfUpbj/v37+f6dOn88gjj1C9enUcHBxo3rw5s2fPJjk5ueQCtzLm+DzfKysri7Zt26LRaGjevLkZI7Vu5urntLQ0goKCaNmyJZUrV8bNzY327dsTHBxcAlFbH3P0c3JyMvPmzaN169Y4Ozvj7u5Ox44dWblyJZmZmSUUufX46quvmDJlCh06dECr1aLRaFizZk2h2yn170GLLSEsyoQ9e/Yoe3t75eTkpCZOnKimT5+uGjZsqAD19ttvm9zOpEmTFKBatGihZs6cqcaMGaO0Wq1ydXVVp06dKsErsA7m6GdPT09VqVIl5efnp1555RU1bdo01a5dOwWoxo0bqxs3bpTwVZR95vo83+vNN99UVapUUYBq1qyZmSO2Tubq56tXr6rGjRsrjUaj+vTpo2bNmqVefvll1b9/f9WqVasSvALrYI5+TkpKUo0aNVKA6tatm5o+fbp64YUXVOPGjRWgevfurXJyckr4Sso2Ly8vBSh3d3fDn1evXl3odkr7e1ASuAosKytLNW7cWGm1WnXs2DFDeWpqqvLx8VG2trbq/PnzD21n9+7dClDdu3fPt1VYRESE0mg0qkePHiUSv7UwVz8vXrxYXb9+PV+ZXq9Xzz//vALUP//5T7PHbk3M1c/3Onr0qLK1tVXLly+XBO5P5urn7Oxs1bFjR+Xo6Kh2795d4HkqMnP18zvvvKMANW3atHzlOp1OdezYUQEqMjLS7PFbk127dqkrV64opZRatGhRkRI4S3wPSgJXge3cuVMBaty4cUbHQkNDFaDmzJnz0HZGjhx53x8Cffv2VUCZ29O1NJmrn+/n+vXrClA+Pj7FCdPqmbufdTqdatWqlerWrZvS6/WSwP3JXP2cV/fNN98siTCtnrn6ecqUKQpQu3btMjo2d+5cBajNmzebJebyoKgJnCW+B+UZuAps7969ADzxxBNGx/LKIiMjTWqnSpUqdO3a1eiYv7+/ye2UV+bq5/uxs7MDwNbWtshtlAfm7uf58+cTExPDF198gUajMUuM5YG5+nnTpk0ADB06lNjYWD7++GMWL17M5s2buX37tvkCtlLm6mcfHx8AwsPD85VnZWURERGBo6MjXbp0KWa0whLfgxX7J34Fl/dgZdOmTY2OVa1aFXd394c+fJmenk5cXBwtW7akUqVKRsfz2q7IkxnM0c8PEhISAhT8g74iMWc/R0dH8+6777Jw4UK8vb3NGqe1M1c/HzlyBMidnDNt2jR0Op3hmIeHB19//TU9e/Y0T9BWyFz9PHHiRNatW8d7773HkSNH6NixIzqdjvDwcJKSktiwYQN16tQxe/wViaW+B2UErgJLSUkBwNXVtcDjLi4uhjrFaePeehWROfr5fk6cOEFwcDA1atRg1qxZRY6xPDBXP+t0OsaOHUu7du2YPn26WWMsD8zVzzdv3gTgxRdf5JVXXiE2NpaEhASWL19OSkoKAwcOJC4uznyBWxlz9bOjoyN79+5l9OjRREZGsnTpUlasWMHFixcZNWoU3bp1M2vcFZGlvgclgRPCSl2+fJmAgABycnIIDQ3F3d3d0iGVC2+++SYxMTGEhIQU+Nu0MA+9Xg9AQEAAixcvpm7duri7u/Piiy8ybdo0UlJS+OKLLywcpfVLTEykT58+/Pzzz2zbto3k5GTi4+P5+OOPWb16Nb6+viQlJVk6TFEEksBVYHm/Ldzvt4LU1NT7/kZRmDburVcRmaOf/+7q1av06tWLhIQEvvnmG3r16lXsOK2dOfr52LFjvP/++7z++uu0atXK7DGWB+b6POfVGTBggNGxp556CvjrNmtFZK5+fvXVVzlw4ABbtmzhySefxNXVFU9PTyZNmsS7777LpUuX+PDDD80ZeoVjqe9BSeAqsAfdl09KSiIxMbHA5y/uVaVKFWrVqsXly5fJyckxOv6g5zgqCnP0872uXLlCz549uX79Ol9//TUBAQFmi9WamaOff/31V3Jycpg/fz4ajSbfC+DcuXNoNBrc3NzMHr+1MNfnuVmzZgAF9mVeWUZGRtEDtXLm6udt27ZRrVo1WrdubXSsd+/eABw9erSY0VZslvoelASuAvPz8wPgp59+MjqWV5ZX52HtpKenExUVZXRs586dJrdTXpmrn+Gv5O33339n06ZNPP300+YL1MqZo5+9vb2ZMGFCgS/I/Q16woQJjBkzxszRWw9zfZ7zkofTp08bHcsra9CgQVHDtHrm6ue7d++SmprK3bt3jY4lJCQAoNVqixOqwELfg2ZdlERYlaysLNWoUSOl1WrV8ePHDeX3LhR577o1CQkJ6syZMyohISFfO/cuYKjT6QzlspBvLnP18+XLl5WXl5eytbVVW7ZsKa3wrYa5+vl+kHXglFLm6+dLly4prVaratSooa5du5avnbZt2ypARURElPj1lFXm6md/f38FqDfeeCNfeWZmpuHYihUrSvRarMnD1oErS9+DksBVcLt371Z2dnbKyclJTZo0Kd9WLf/617/y1Q0KClKACgoKMmpn4sSJspXWA5ijn/O2eOncubMKCgoq8FXRmevzXBBJ4P5irn7O2+GievXqauLEiWrq1KmqQYMGClCTJ08upaspu8zRz8ePH1fOzs4KUJ06dVLTpk1Tzz//vGF7rUceeURlZGSU4lWVPZ999pkKDAxUgYGBqn379gpQXbt2NZR99913hrpl6XtQEjihDh06pPr27atcXV2Vo6Oj6tChg/rqq6+M6j3og5uTk6OWL1+ufHx8lFarVdWrV1dDhgyp0Dsw/F1x+xl46EuY5/NcEEng8jNXP//www+qe/fuysnJSTk4OKhHHnlEffrppyUcvfUwRz+fP39ejRs3TtWvX1/Z2dkpR0dH1apVKxUcHKzS09NL4SrKtsDAwAf+XL23T8vS96BGKaXMe1NWCCGEEEKUJJnEIIQQQghhZSSBE0IIIYSwMpLACSGEEEJYGUnghBBCCCGsjCRwQgghhBBWRhI4IYQQQggrIwmcEEIIIYSVkQROCCGEEMLKSAInhBBCCGFlJIETQgghhLAyksAJIYQQQlgZSeCEEEIIIayMJHBCCFHGdenSBY1GQ3R0dL7ypKQkfHx8cHBwIDIy0kLRCSEsQRI4IYQo4xYvXgzAvHnzDGWZmZkMGDCAs2fPsn79evz8/CwVnhDCAiSBE0KIMs7Pz49+/foRHh7OgQMH0Ov1PPvss+zfv5+VK1cyePBgS4cohChlGqWUsnQQQgghHuyXX36hXbt29O7dm+bNm/PRRx8xb948goODLR2aEMICJIETQggrMXr0aNavXw/A5MmT+eSTTywckRDCUuQWqhBCWAl3d3cAXF1dWbFihYWjEUJYkiRwQghhBZYtW8ayZcvw9PQkJSWFr776ytIhCSEsSG6hCiFEGRcaGsqoUaN47LHHWLt2Lc2bN8fNzY3z58/j4OBg6fCEEBYgI3BCCFGGRUREEBgYSNu2bfn222+pXbs2L7/8MrGxsXz00UeWDk8IYSEyAieEEGXUsWPH6NmzJx4eHhw4cABPT08AUlJSaNiwITY2Nly6dAkXFxcLRyqEKG0yAieEEGXQxYsXefLJJ3FwcGDnzp2G5A1yJzHMmDGDW7dusWTJEgtGKYSwFBmBE0IIIYSwMjICJ4QQQghhZSSBE0IIIYSwMpLACSGEEEJYGUnghBBCCCGsjCRwQgghhBBWRhI4IYQQQggrIwmcEEIIIYSVkQROCCGEEMLKSAInhBBCCGFlJIETQgghhLAyksAJIYQQQlgZSeCEEEIIIayMJHBCCCGEEFbm/wHwWyTHztSLAQAAAABJRU5ErkJggg==", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "if comm_sampler.rank == 0:\n", " print(\"80% CVaR of QoI samples\")\n", " print(f\"Using CVaR as risk measure, {soupy.sample_superquantile(qoi_samples_cvar, QUANTILE):g}\")\n", " print(f\"Using Mean as risk measure, {soupy.sample_superquantile(qoi_samples_mean, QUANTILE):g}\")\n", " \n", " plt.figure()\n", " z_fun.vector().set_local(zt_optimal_np[:-1])\n", " dl.plot(z_fun, label=\"Using CVaR\")\n", " z_fun.vector().set_local(z_optimal_mean_np)\n", " dl.plot(z_fun, label=\"Using Mean\")\n", " plt.title(\"Optimal controls\")\n", " plt.xlabel(\"$x$\")\n", " plt.ylabel(\"$z(x)$\")\n", " plt.legend()\n", "\n", " plt.figure()\n", " bar = plt.hist(qoi_samples_cvar, bins=50, label='QoI using CVaR', alpha=0.5)\n", " bar = plt.hist(qoi_samples_mean, bins=50, label='QoI using Mean', alpha=0.5)\n", " plt.xlabel(\"$Q$\")\n", " plt.ylabel(\"Frequency\")\n", " plt.legend()\n", "plt.show()\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "kernelspec": { "display_name": "soupy", "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.10.6" }, "orig_nbformat": 4 }, "nbformat": 4, "nbformat_minor": 2 }