tabular.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "tabular.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "toc_visible": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github"
      },
      "source": [
        "\u003ca href=\"https://colab.research.google.com/github/evgenii-nikishin/omd/blob/main/tabular.ipynb\" target=\"_parent\"\u003e\u003cimg src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/\u003e\u003c/a\u003e\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oEqeMO_W9Zj7"
      },
      "source": [
        "# Analysis of Optimal Model Design (OMD) for the Tabular Case"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yuXBiEBBqxbM"
      },
      "source": [
        "We recommend running the notebook in Google Colab to have all the dependencies installed."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "D2xpisIH9AQd"
      },
      "source": [
        "!pip install git+https://github.com/gehring/fax"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2cqOAaJJ7Hu2"
      },
      "source": [
        "import hypothesis.extra.numpy\n",
        "import hypothesis.strategies\n",
        "from functools import partial\n",
        "import numpy as np\n",
        "from tqdm import tqdm\n",
        "from tabulate import tabulate\n",
        "import time\n",
        "\n",
        "import jax.numpy as jnp\n",
        "import jax.test_util\n",
        "from jax import random\n",
        "from jax import tree_util\n",
        "from jax.config import config\n",
        "from jax.experimental import optimizers\n",
        "from jax.experimental.stax import softmax\n",
        "from jax.scipy.special import logsumexp\n",
        "from jax.lax import cond\n",
        "\n",
        "from fax import converge\n",
        "from fax import test_util\n",
        "from fax.constrained import implicit_ecp, cga_ecp\n",
        "\n",
        "config.update(\"jax_enable_x64\", True)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZEI-sV7kjImH"
      },
      "source": [
        "import matplotlib.pyplot as plt\n",
        "%matplotlib inline\n",
        "plt.style.use('default')\n",
        "plt.rcParams['figure.figsize'] = (4.8, 3.6)\n",
        "plt.rcParams['xtick.labelsize'] = 10\n",
        "plt.rcParams['ytick.labelsize'] = 10\n",
        "plt.rcParams['legend.loc'] = 'best'\n",
        "plt.rcParams['legend.fontsize'] = 11\n",
        "plt.rcParams['lines.linewidth'] = 1.5\n",
        "plt.rcParams['axes.formatter.offset_threshold'] = 1\n",
        "plt.rcParams['axes.labelsize'] = 12\n",
        "plt.rcParams['axes.grid'] = True"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GvdqIwtwbyls"
      },
      "source": [
        "## Defining the MDP\n",
        "\n",
        "The experiments use a 2 state, 2 action MDP described in [The Value Function Polytope in Reinforcement Learning](https://arxiv.org/abs/1901.11524) (Appendix A, part d)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ha_nvROPJmkf",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "8d288ea0-30cb-46fe-81c2-a079e8fd9f14"
      },
      "source": [
        "# based on https://github.com/gehring/fax/blob/master/fax/constrained/constrained_test.py\n",
        "\n",
        "true_transition = jnp.array([[[0.7, 0.3], [0.2, 0.8]],\n",
        "                            [[0.99, 0.01], [0.99, 0.01]]])\n",
        "true_reward = jnp.array(([[-0.45, -0.1],\n",
        "                          [0.5, 0.5]]))\n",
        "initial_distribution = jnp.ones(2) / 2\n",
        "temperature = 0.01\n",
        "true_discount = 0.9\n",
        "\n",
        "\n",
        "optimal_value = 1.0272727  # pre-computed\n",
        "kwargs = {'max_iter': 10000, 'lr_func': 0.01, 'optimizer': optimizers.adam}\n",
        "\n",
        "def smooth_bellman_optimality_operator(x, params):\n",
        "  transition, reward, discount, temperature = params\n",
        "  return reward + discount * jnp.einsum('ast,t->sa', transition, temperature *\n",
        "                                        logsumexp((1. / temperature) * x, axis=1))\n",
        "\n",
        "@jax.jit\n",
        "def objective_returns(x, params):\n",
        "  del params\n",
        "  policy = softmax((1. / temperature) * x)\n",
        "  ppi = jnp.einsum('ast,sa->st', true_transition, policy)\n",
        "  rpi = jnp.einsum('sa,sa->s', true_reward, policy)\n",
        "  vf = jnp.linalg.solve(jnp.eye(true_transition.shape[-1]) - true_discount * ppi, rpi)\n",
        "  return initial_distribution @ vf\n",
        "\n",
        "@jax.jit\n",
        "def objective_bellman(x, params):\n",
        "  return -np.mean(true_constraints(x, params) ** 2)\n",
        "\n",
        "@jax.jit\n",
        "def true_constraints(x, params):\n",
        "  del params\n",
        "  params = (true_transition, true_reward, true_discount, temperature)\n",
        "  return smooth_bellman_optimality_operator(x, params) - x\n",
        "\n",
        "@jax.jit\n",
        "def bellman_update(x, params):\n",
        "  transition_logits, reward_hat = params\n",
        "  # OMD does not have a constraint forcing p(s'|s,a) to be a distribution\n",
        "  transition_hat = softmax((1. / temperature) * transition_logits)\n",
        "  params = (transition_hat, reward_hat, true_discount, temperature)\n",
        "  return smooth_bellman_optimality_operator(x, params)\n",
        "\n",
        "@jax.jit\n",
        "def equality_constraints(x, params):\n",
        "  return bellman_update(x, params) - x\n",
        "\n",
        "@jax.jit\n",
        "def objective_bellman_model(x, params):\n",
        "  # we might want to have a weighted average instead of mean\n",
        "  return -np.mean(equality_constraints(x, params) ** 2)\n",
        "\n",
        "@jax.jit\n",
        "def grad_constraints(x, params):\n",
        "  return jax.grad(objective_bellman_model, argnums=0)(x, params)\n",
        "\n",
        "@jax.jit\n",
        "def tree_norm(tree):\n",
        "  return jnp.sqrt(sum((x**2).sum() for x in jax.tree_leaves(tree)))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "WARNING:absl:No GPU/TPU found, falling back to CPU. (Set TF_CPP_MIN_LOG_LEVEL=0 and rerun for more info.)\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fiMimpMcjDf8"
      },
      "source": [
        "Q_opt = jnp.array([[0.16363807, 0.06282009],\n",
        "                   [1.89091046, 0.66282009]])\n",
        "# uncomment to compute a fixed point of the _smooth_ Bellman optimality operator\n",
        "# Q_opt = jnp.zeros((2, 2))\n",
        "# for _ in range(1000):\n",
        "#   Q_opt = smooth_bellman_optimality_operator(Q_opt, (true_transition, true_reward, true_discount, temperature))\n",
        "assert jnp.allclose(Q_opt - smooth_bellman_optimality_operator(Q_opt, (true_transition, true_reward, true_discount, temperature)), 0).item()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-7rcxdVQdr-_"
      },
      "source": [
        "## Performance of OMD and MLE under the model misspecification\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ad2Ta0hoTPwV"
      },
      "source": [
        "# Projected Adam based on\n",
        "# https://jax.readthedocs.io/en/latest/_modules/jax/experimental/optimizers.html#sgd\n",
        "\n",
        "from jax.experimental.optimizers import optimizer\n",
        "from typing import Callable, Union\n",
        "\n",
        "Step = int\n",
        "Schedule = Callable[[Step], float]\n",
        "\n",
        "\n",
        "@optimizer\n",
        "def padam(step_size, norm_bound, b1=0.9, b2=0.999, eps=1e-8):\n",
        "  \"\"\"Construct optimizer triple for PROJECTED Adam.\n",
        "\n",
        "  Args:\n",
        "    step_size: positive scalar, or a callable representing a step size schedule\n",
        "      that maps the iteration index to positive scalar.\n",
        "    b1: optional, a positive scalar value for beta_1, the exponential decay rate\n",
        "      for the first moment estimates (default 0.9).\n",
        "    b2: optional, a positive scalar value for beta_2, the exponential decay rate\n",
        "      for the second moment estimates (default 0.999).\n",
        "    eps: optional, a positive scalar value for epsilon, a small constant for\n",
        "      numerical stability (default 1e-8).\n",
        "\n",
        "  Returns:\n",
        "    An (init_fun, update_fun, get_params) triple.\n",
        "  \"\"\"\n",
        "  step_size = make_schedule(step_size)\n",
        "  def init(x0):\n",
        "    m0 = jnp.zeros_like(x0)\n",
        "    v0 = jnp.zeros_like(x0)\n",
        "    return x0, m0, v0\n",
        "  def update(i, g, state):\n",
        "    x, m, v = state\n",
        "    m = (1 - b1) * g + b1 * m  # First  moment estimate.\n",
        "    v = (1 - b2) * jnp.square(g) + b2 * v  # Second moment estimate.\n",
        "    mhat = m / (1 - jnp.asarray(b1, m.dtype) ** (i + 1))  # Bias correction.\n",
        "    vhat = v / (1 - jnp.asarray(b2, m.dtype) ** (i + 1))\n",
        "    new_x = x - step_size(i) * mhat / (jnp.sqrt(vhat) + eps)\n",
        "\n",
        "    new_x_norm = tree_norm((new_x[0] / temperature, new_x[1]))  # softmax temp\n",
        "    \n",
        "    # projection\n",
        "    new_x = jax.lax.cond(\n",
        "      new_x_norm > norm_bound,\n",
        "      lambda z: jax.tree_map(lambda y: y * norm_bound / new_x_norm, z),\n",
        "      lambda z: z,\n",
        "      operand=new_x)\n",
        "\n",
        "    return new_x, m, v\n",
        "  def get_params(state):\n",
        "    x, _, _ = state\n",
        "    return x\n",
        "  return init, update, get_params\n",
        "\n",
        "### learning rate schedules\n",
        "\n",
        "def constant(step_size) -> Schedule:\n",
        "  def schedule(i):\n",
        "    return step_size\n",
        "  return schedule\n",
        "\n",
        "def make_schedule(scalar_or_schedule: Union[float, Schedule]) -> Schedule:\n",
        "  if callable(scalar_or_schedule):\n",
        "    return scalar_or_schedule\n",
        "  elif jnp.ndim(scalar_or_schedule) == 0:\n",
        "    return constant(scalar_or_schedule)\n",
        "  else:\n",
        "    raise TypeError(type(scalar_or_schedule))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ydd_3tulS6tc"
      },
      "source": [
        "# from https://github.com/gehring/fax/blob/master/fax/constrained/constrained.py\n",
        "\n",
        "\"\"\" Optimization methods for parametric nonlinear equality constrained problems.\n",
        "\"\"\"\n",
        "\n",
        "from fax.constrained.constrained import default_convergence_test\n",
        "import collections\n",
        "\n",
        "from scipy.optimize import minimize\n",
        "\n",
        "import jax\n",
        "from jax import lax\n",
        "from jax import jit\n",
        "from jax import grad\n",
        "from jax import jacrev\n",
        "#import jax.numpy as np\n",
        "from jax import tree_util\n",
        "from jax.experimental import optimizers\n",
        "from jax.flatten_util import ravel_pytree\n",
        "\n",
        "from fax import math\n",
        "from fax import converge\n",
        "from fax import implicit\n",
        "from fax.competitive import cga\n",
        "from fax.loop import fixed_point_iteration\n",
        "\n",
        "import functools\n",
        "import operator\n",
        "_add = functools.partial(jax.tree_multimap, operator.add)\n",
        "\n",
        "\n",
        "ConstrainedSolution = collections.namedtuple(\n",
        "    \"ConstrainedSolution\",\n",
        "    \"value converged iterations\"\n",
        ")\n",
        "\n",
        "\n",
        "def implicit_ecp(\n",
        "        objective, equality_constraints, initial_values, lr_func, max_iter=500,\n",
        "        convergence_test=default_convergence_test, batched_iter_size=1, optimizer=optimizers.adam,\n",
        "        tol=1e-6, constraints_solver=None, std=0., norm_bound=None, agent_type='omd', \n",
        "        seed=0):\n",
        "    \"\"\"Use implicit differentiation to solve a nonlinear equality-constrained program of the form:\n",
        "    max f(x, θ) subject to h(x, θ) = 0 .\n",
        "    We perform a change of variable via the implicit function theorem and obtain the unconstrained\n",
        "    program:\n",
        "    max f(φ(θ), θ) ,\n",
        "    where φ is an implicit function of the parameters θ such that h(φ(θ), θ) = 0.\n",
        "    Args:\n",
        "        objective (callable): Binary callable with signature `f(x, θ)`\n",
        "        equality_constraints (callble): Binary callable with signature `h(x, θ)`\n",
        "        initial_values (tuple): Tuple of initial values `(x_0, θ_0)`\n",
        "        lr_func (scalar or callable): The step size used by the unconstrained optimizer. This can\n",
        "            be a scalar ora callable taking in the current iteration and returning a scalar.\n",
        "        max_iter (int, optional): Maximum number of outer iterations. Defaults to 500.\n",
        "        convergence_test (callable): Binary callable with signature `callback(new_state, old_state)`\n",
        "            where `new_state` and `old_state` are tuples of the form `(x_k^*, θ_k)` such that\n",
        "            `h(x_k^*, θ_k) = 0` (and with `k-1` for `old_state`). The default convergence test\n",
        "            returns `true` if both elements of the tuple have not changed within some tolerance.\n",
        "        batched_iter_size (int, optional):  The number of iterations to be\n",
        "            unrolled and executed per iterations of the `while_loop` op for the forward iteration\n",
        "            and the fixed-point adjoint iteration. Defaults to 1.\n",
        "        optimizer (callable, optional): Unary callable waking a `lr_func` as a argument and\n",
        "            returning an unconstrained optimizer. Defaults to `jax.experimental.optimizers.sgd`.\n",
        "        tol (float, optional): Tolerance for the forward and backward iterations. Defaults to 1e-6.\n",
        "    Returns:\n",
        "        fax.loop.FixedPointSolution: A named tuple containing the solution `(x, θ)` as as the\n",
        "            `value` attribute, `converged` (a bool indicating whether convergence was achieved),\n",
        "            `iterations` (the number of iterations used), and `previous_value`\n",
        "            (the value of the solution on the previous iteration). The previous value satisfies\n",
        "            `sol.value=func(sol.previous_value)` and allows us to log the size\n",
        "            of the last step if desired.\n",
        "    \"\"\"\n",
        "\n",
        "    if constraints_solver is None:\n",
        "        constraints_solver = implicit.two_phase_solve\n",
        "\n",
        "    if agent_type == 'omd':\n",
        "        def _objective(init_xs, params, rng):\n",
        "            x_sol = constraints_solver(\n",
        "                param_func=make_fp_operator,\n",
        "                init_xs=init_xs,\n",
        "                params=params,\n",
        "            )\n",
        "            \n",
        "            # for the experiment with the IFT sensitivity to the inner loop solution\n",
        "            noise = jax.random.normal(rng, x_sol.shape) * std\n",
        "            x_sol = _add(x_sol, noise)\n",
        "\n",
        "            return -objective(x_sol, params), x_sol\n",
        "    elif agent_type == 'mle':\n",
        "        def mle_objective(params):\n",
        "            transition_logits, reward_hat = params\n",
        "            transition_hat = softmax((1. / temperature) * transition_logits)\n",
        "            loss_reward = ((reward_hat - true_reward)**2).mean()\n",
        "            loss_kl = (true_transition * (jnp.log(true_transition) - jnp.log(transition_hat))).mean()\n",
        "            loss_kl *= true_transition.shape[2]  # average over (s,a), sum over s'\n",
        "            return (loss_reward + loss_kl)\n",
        "\n",
        "        def _objective(init_xs, params, rng):\n",
        "            x_sol = constraints_solver(\n",
        "                param_func=make_fp_operator,\n",
        "                init_xs=init_xs,\n",
        "                params=params,\n",
        "            )\n",
        "\n",
        "            return mle_objective(params), x_sol\n",
        "\n",
        "    def make_fp_operator(params):\n",
        "        def _fp_operator(x):\n",
        "            return x + equality_constraints(x, params)\n",
        "        return _fp_operator\n",
        "\n",
        "    if norm_bound is None:\n",
        "      opt_init, opt_update, get_params = optimizer(step_size=lr_func)\n",
        "    else:\n",
        "      opt_init, opt_update, get_params = optimizer(step_size=lr_func, \n",
        "                                                  norm_bound=norm_bound)\n",
        "\n",
        "\n",
        "    grad_objective = grad(_objective, 1, has_aux=True)\n",
        "\n",
        "    def update(values):\n",
        "        i, old_xstar, opt_state = values\n",
        "        old_params = get_params(opt_state)\n",
        "        rng = jax.random.PRNGKey(10000*seed + i)\n",
        "\n",
        "        grads_params, new_xstar = grad_objective(old_xstar, old_params, rng)\n",
        "        opt_state = opt_update(i, grads_params, opt_state)\n",
        "\n",
        "        return i + 1, new_xstar, opt_state\n",
        "\n",
        "    def _convergence_test(new_state, old_state):\n",
        "        x_new, params_new = new_state[1], get_params(new_state[2])\n",
        "        x_old, params_old = old_state[1], get_params(old_state[2])\n",
        "        return convergence_test((x_new, params_new), (x_old, params_old))\n",
        "\n",
        "    x0, init_params = initial_values\n",
        "    opt_state = opt_init(init_params)\n",
        "\n",
        "    if max_iter >= 1:\n",
        "      solution = fixed_point_iteration(init_x=(0, x0, opt_state),\n",
        "                                      func=update,\n",
        "                                      convergence_test=jit(_convergence_test),\n",
        "                                      max_iter=max_iter,\n",
        "                                      batched_iter_size=batched_iter_size,\n",
        "                                      unroll=False)\n",
        "      return solution.value[1], get_params(solution.value[2])\n",
        "    else:\n",
        "      return x0, get_params(opt_state)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "OmSAg7y9IhQ4",
        "outputId": "4f4965ac-82b1-4aac-cf5d-5e3d31d8aef9"
      },
      "source": [
        "start = time.time()\n",
        "norm_bound_list = jnp.linspace(0, 6, 20)\n",
        "num_seeds = 10\n",
        "headers = [\"Seed\", \"Q\", \"Policy\", \"p_\\\\theta\", \"r_\\\\theta\", \"J\", \"\\|Q-B^true Q\\|^2\", \"Q-B^\\\\theta Q\", \"grad\\|Q-B^\\\\theta Q\\|^2\"]\n",
        "all_results = []\n",
        "\n",
        "for i, norm_bound in enumerate(norm_bound_list):\n",
        "  results = []\n",
        "  for j, seed in enumerate(range(1, num_seeds+1)):\n",
        "    kwargs['seed'] = seed\n",
        "    kwargs['norm_bound'] = norm_bound\n",
        "    kwargs['optimizer'] = padam\n",
        "    kwargs['lr_func'] = 0.01\n",
        "    kwargs['agent_type'] = 'mle'\n",
        "    \n",
        "    rngs = jax.random.split(jax.random.PRNGKey(seed), 3)\n",
        "    initial_values = (\n",
        "      jax.random.uniform(rngs[0], true_reward.shape),\n",
        "      (jax.random.uniform(rngs[1], true_transition.shape), \n",
        "      jax.random.uniform(rngs[2], true_reward.shape))\n",
        "    )\n",
        "\n",
        "    solution = implicit_ecp(objective_returns, equality_constraints, initial_values, **kwargs)\n",
        "\n",
        "    results.append([\n",
        "      seed,\n",
        "      solution[0], \n",
        "      softmax((1. / temperature) * solution[0]), \n",
        "      softmax((1. / temperature) * solution[1][0]), \n",
        "      solution[1][1], \n",
        "      objective_returns(*solution),\n",
        "      objective_bellman(*solution),\n",
        "      equality_constraints(*solution),\n",
        "      grad_constraints(*solution)\n",
        "    ])\n",
        "    \n",
        "  print('Done {}/{} bounds'.format(i+1, len(norm_bound_list)))\n",
        "  all_results.append(results)\n",
        "print('Done in {:.2f} minutes'.format((time.time() - start) / 60))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Done 1/20 bounds\n",
            "Done 2/20 bounds\n",
            "Done 3/20 bounds\n",
            "Done 4/20 bounds\n",
            "Done 5/20 bounds\n",
            "Done 6/20 bounds\n",
            "Done 7/20 bounds\n",
            "Done 8/20 bounds\n",
            "Done 9/20 bounds\n",
            "Done 10/20 bounds\n",
            "Done 11/20 bounds\n",
            "Done 12/20 bounds\n",
            "Done 13/20 bounds\n",
            "Done 14/20 bounds\n",
            "Done 15/20 bounds\n",
            "Done 16/20 bounds\n",
            "Done 17/20 bounds\n",
            "Done 18/20 bounds\n",
            "Done 19/20 bounds\n",
            "Done 20/20 bounds\n",
            "Done in 2.77 minutes\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CyLMBd0obK6W"
      },
      "source": [
        "# for the last norm bound\n",
        "print(tabulate(all_results[-1], headers=headers))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Cwdmiz5hi1Dn"
      },
      "source": [
        "Js_mle_mean, Js_mle_std = [], []\n",
        "for i, norm_bound in enumerate(norm_bound_list):\n",
        "  Js_mle = list(map(lambda x: x[5].item(), all_results[i]))\n",
        "  Js_mle_mean.append(np.mean(Js_mle))\n",
        "  Js_mle_std.append(np.std(Js_mle))\n",
        "Js_mle_mean, Js_mle_std = np.array(Js_mle_mean), np.array(Js_mle_std)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6k4eIbNnjN_B",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "6fcebc94-f8bf-40a9-ed1e-05b6e72aa577"
      },
      "source": [
        "start = time.time()\n",
        "norm_bound_list = jnp.linspace(0, 6, 20)\n",
        "num_seeds = 10\n",
        "headers = [\"Seed\", \"Q\", \"Policy\", \"p_\\\\theta\", \"r_\\\\theta\", \"J\", \"\\|Q-B^true Q\\|^2\", \"Q-B^\\\\theta Q\", \"grad\\|Q-B^\\\\theta Q\\|^2\"]\n",
        "all_results = []\n",
        "\n",
        "for i, norm_bound in enumerate(norm_bound_list):\n",
        "  results = []\n",
        "  for j, seed in enumerate(range(1, num_seeds+1)):\n",
        "    kwargs['seed'] = seed\n",
        "    kwargs['norm_bound'] = norm_bound\n",
        "    kwargs['optimizer'] = padam\n",
        "    kwargs['lr_func'] = 0.01\n",
        "    kwargs['agent_type'] = 'omd'\n",
        "    \n",
        "    rngs = jax.random.split(jax.random.PRNGKey(seed), 3)\n",
        "    initial_values = (\n",
        "      jax.random.uniform(rngs[0], true_reward.shape),\n",
        "      (jax.random.uniform(rngs[1], true_transition.shape), \n",
        "      jax.random.uniform(rngs[2], true_reward.shape))\n",
        "    )\n",
        "\n",
        "    # solution = implicit_ecp(objective_bellman, equality_constraints, initial_values, **kwargs)\n",
        "    solution = implicit_ecp(objective_returns, equality_constraints, initial_values, **kwargs)\n",
        "    \n",
        "    results.append([\n",
        "      seed,\n",
        "      solution[0], \n",
        "      softmax((1. / temperature) * solution[0]), \n",
        "      softmax((1. / temperature) * solution[1][0]), \n",
        "      solution[1][1], \n",
        "      objective_returns(*solution),\n",
        "      objective_bellman(*solution),\n",
        "      equality_constraints(*solution),\n",
        "      grad_constraints(*solution)\n",
        "    ])\n",
        "    \n",
        "  print('Done {}/{} bounds'.format(i+1, len(norm_bound_list)))\n",
        "  all_results.append(results)\n",
        "print('Done in {:.2f} minutes'.format((time.time() - start) / 60))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Done 1/20 bounds\n",
            "Done 2/20 bounds\n",
            "Done 3/20 bounds\n",
            "Done 4/20 bounds\n",
            "Done 5/20 bounds\n",
            "Done 6/20 bounds\n",
            "Done 7/20 bounds\n",
            "Done 8/20 bounds\n",
            "Done 9/20 bounds\n",
            "Done 10/20 bounds\n",
            "Done 11/20 bounds\n",
            "Done 12/20 bounds\n",
            "Done 13/20 bounds\n",
            "Done 14/20 bounds\n",
            "Done 15/20 bounds\n",
            "Done 16/20 bounds\n",
            "Done 17/20 bounds\n",
            "Done 18/20 bounds\n",
            "Done 19/20 bounds\n",
            "Done 20/20 bounds\n",
            "Done in 5.52 minutes\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-9yqNc0EXDWi"
      },
      "source": [
        "# for the last norm bound\n",
        "print(tabulate(all_results[-1], headers=headers))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7JXnuycbi2RP"
      },
      "source": [
        "Js_omd_mean, Js_omd_std = [], []\n",
        "for i, norm_bound in enumerate(norm_bound_list):\n",
        "  Js_omd = list(map(lambda x: x[5].item(), all_results[i]))\n",
        "  Js_omd_mean.append(np.mean(Js_omd))\n",
        "  Js_omd_std.append(np.std(Js_omd))\n",
        "Js_omd_mean, Js_omd_std = np.array(Js_omd_mean), np.array(Js_omd_std)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xn_dCfO9mIJz",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 366
        },
        "outputId": "12f7638b-18f0-4bd1-95ec-7e657c393e8b"
      },
      "source": [
        "idx = np.array([1, 2, 3, 4, 6, 9, 13, 16])\n",
        "plt.plot(norm_bound_list[idx], Js_mle_mean[idx], 'o-', c='b', label='MLE', markersize=6)\n",
        "plt.plot(norm_bound_list[idx], Js_omd_mean[idx], '^-', c='r', label='OMD', markersize=6)\n",
        "plt.plot((0, 5.2), (optimal_value, optimal_value), '--', c='black', label='Optimal')\n",
        "plt.xlim(0, 5.2)\n",
        "plt.ylabel('Expected Return')\n",
        "plt.xlabel('Model Parameter Norm')\n",
        "plt.legend()\n",
        "plt.tight_layout()\n",
        "plt.savefig('misspec_tab.pdf')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAdYAAAFdCAYAAAC+bUxBAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAAPYQAAD2EBqD+naQAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOzdd3xUVfr48c/MMGl0CCSUEJo/pGkUvkRQ6gJB0AWRDlIWcMVFVFyRLkVB1EVQ3AWl6i6CsogFBGKkKZEOKm0pgdASiEh6mczc3x+HmbTJkExmMinP+/WaV+7ce+bOmcOQJ/fcc56j0zRNQwghhBAuofd0BYQQQoiyRAKrEEII4UISWIUQQggXksAqhBBCuJAEViGEEMKFJLAKIYQQLiSBVQghhHChCp6uQFlksVi4fv06lStXRqfTebo6QgghikjTNBITE6lbty56veNrUgmsbnD9+nWCgoI8XQ0hhBAuduXKFerXr++wjARWN6hcuTIAUVFR1KhRw8O1KXlMJhM7d+6kZ8+eGI1GT1enxJH2cUzaxzFpH8ecbZ+EhASCgoJsv98dkcDqBtbu38qVK1OlShUP16bkMZlM+Pn5UaVKFfmPb4e0j2PSPo5J+zhW1PYpyO09GbwkhBBCuJAEViGEEMKFJLAKIYQQLiSBVQghhHAhCaxCCCGEC0lgFUIIIVxIAqsQwrO+/x5atFA/hShObvruSWAVQniOpsH06XD6tPqpaZ6uUdkmf8TYmDM1Eiaq717CxOmYM1333ZMEEW6UnJyMj49Pnv0GgyHH/uTk5HzPodfr8fX1dapsSkoKWj6/qHQ6HX5+fk6VTU1NxWKx5FuPihUrOixrMplIS0sjOTmZatWq2fanpaVhNpsLdN57lfXz87NN5E5PTyczM9MlZX19fW15QjMyMjCZTC4p6+Pjg8FgsJW1to+9CezZy5pMJjIyMvI9r7e3NxUqVCh02czMTNLT0/Mt6+XlZatbYcqazWbS0tKyDn7/PRw6pLYPHcK4dSteTzxhv+xd1u9PRkaG7bwWi4XU1NR862A0GvHy8ipQ2QoVKuDt7Q2o/LApKSkuKVuY//dF/R1h9/ujaeinTsXX+kfMn/5ESmpqifwdkV/ZIv2O0DSwWDClpfHTD758OWYba/9Q3z3vs4cYHvg1f36/O3375j1v9s9WIJpwufj4eA3I99G7d+8c5f38/PIt27lz5xxl/f398y3btm3bHGWDg4PzLduiRYscZVu0aJFv2eDg4Bxl27Ztm29Zf3//HGU7d+6cb1k/P78cZXv37u2w3bIbMGCAw7JJSUm2sqNGjXJY9ubNm7ayzz//vMOyUVFRtrJ///vfHZb97bffbGVff/11h2UPHjxoK7tw4UKHZXft2mUru2zZModlv/32W1vZNWvWOCz7+eef28p+/vnnDsuuWbPGVvbbb791WHbZa69p2g8/aNqXX2q7XnvNYdm3fXw07YknNO3Pf9YOdurksOzs++/XtIEDNW3gQO23sDCHZf/evLmmjRihac88o0U99ZTDss83b65p48Zp2rhx2s0RIxyWHdWsmab97W+aNnGilvTXvzosO+C++zRt8mRNe+UVTbvHd6d3kyaaNn26esyYofkZjfmW7RwcrGlz52ravHmaNm+e5u/g90lb0LS7D/MzI7XgatXyLduiRg1Ne/FFTXvhBU3729+0FtWr51s2uGJFTRs8WNMGDNC0/v21tg7O6280alqnTpr22GOa1qGD1rly5XzL+ul0mvb//p+mNW2qaY0aab19fR22m1a5sqZVrKhpvr7aAL3eYdmkbG0x0kE5UL8jrL/X4+PjtXsp1Vese/fu5Z133uHIkSPcuHGDL7/8kn79+jl8ze7du5k8eTInT54kKCiImTNnMnr06BxlPvzwQ9555x1iYmJ48MEH+eCDD2jXrp0bP4kQJUh6OsTHOy7z2Wewbx8kJMD5847LLlqkHgWRlgbfflugorozZ+DMmYKd9/Rp9XB12bNn1aMgzp2DxYsLVvbCBViwoGBlL1+G118vWNls9J9+4rjA7duwdGnBTpacDBs3FqysyQR79xasrKbB//5XsLIAiYkFL5uNq9cg02la6b2p8d133/HTTz/Rpk0b+vfvf8/AGhUVRatWrXjuuecYN24cERERvPTSS2zdupWwsDAANm7cyMiRI1m+fDmhoaEsWbKEL774grNnz1K7du0C1SshIYGqVaty+fJlatasmee4dAWb2LFjB2FhYeWvK1jToHNnOHoUHn4Y9uwBnS5H925ycjLffvstYWFhhe8KTktTQTEhARIS8E5NpUJSEsTHY7p9m4zbt9WxbGWs294JCVRISID0dDKB/Dt3wQuw1sxhWT8/vKpWxVi1KlStirlKFdIqVYLKlWH7drh5M0dxI+AVHAzTpmHWNNIyMrDdd717fWE2mzl16hQPtmyJr7c3aBoWs5lUa/vmKg9g1OvxuttmFrOZ1MzMfMtW0OnwvltWs1hIsbavnfIV9HpVVtNUV7Cd+lq3DTodPhUq2PYnZz9vrvIGwOduHe5VVg/4ZiubmJbGlatXCapXD71Ox+VoOLf7Kt35QZXN1t6b6EWz7kE0bqIHvR4MBvVTp0NnMODn46Oe6/WkZGaiZS+T7ZG7bKrZjEWnyypjMMDd55pOj7eXHxlmAxmZeuJTTKSbdGSYDaSb9JjMOtJNetIz1XO9rqJ6btKTkJJJagakmfSkZ+hJM+lJTVfH0jL0mEyVSM0wkJahJyklg5R0SM0wkJKmU+Uy9VjQsZUnCOVXjKjfTelAGnqOE0IX9rBtm45OnbJ/jf1ITEykatWqxMfH3zMHfKkOrNnpdLp7BtbXXnuNrVu38ttvv9n2DRkyhDt37rB9+3YAQkND+b//+z+WLVsGqPsxQUFBvPDCC0ydOrVAdbEG1ri4OLuBtbwzmUxs27aN3r17l78k4Tt2QK9eWc+3b4ewMPVLMjVVBcC4OCK3b6dDy5ZUSE7OCn4FeTi4h1polSrB3YDo1KNKFaiQT6dY7nbIzdoudpTr708BZG8fvd5Iw2CN/14L5WGOUoGsP0YzMXCUh3mqzgF+2q/DZFJfwbQ09bjXdmHK5t72ZNTpyQ52kP93L4ztjF4fxtChOfdbf68XJLCW6q7gwoqMjKR79+459oWFhfHSSy8B6qriyJEjTJs2zXZcr9fTvXt3IiMj8z1venp6jsEbCQkJgPqCO7qiKa+sbVLu2kbTMMyYgU6nQ6dpaAB//rMKYAkJ6O5eKRuBTo7Oc6+30enUFeHd4KZlC3SaNeDd3afl3rY+r1JFXWUU8fNi79/Y2g56PTo7PR+aXo82Ywbmrl3VVU4u5fb7U0AJCSauXavE9u1mdu3S0+La97TjUJ5yFTDTjkO0urGTRo3s/xFTHHx9NXx8wMcHfH3B29u6nbU/+8PXV8tW5t77fXyyznPsKDQYNAszegzk/e6Z0TOfWST4d8vz1S3M961cBdaYmBgCAgJy7AsICCAhIYHU1FT++OMPzGaz3TJnHNzLWbhwIXPnzs2zf9euXYUfTVaOhIeHe7oKxarWsWN0OHLE9lwH6grz9m3bPk2vx+TrS6afH6aKFTH5+dm2M/38sp5bt++Wyb6d6eurut8Kw9otXAz0JhM9LlzAJ5/bCTqLhfQLFwj/+mssDq5Iy9v3B9TfKomJXty86UtcnN/dn77cvOlHXJwvt275ER/vB/zJ+goOcO9A8r2uOz6+Fry8zBiNFry9zRiNZry8svZ5eZmzbed+rsqq12Rte3tbcp3HnO21FipUsNj726nIMjMhKUk9sqtgMdFQdxmDZv+7Z8BCsC6ayNtfsW1bzu+eoxHfuZWrwOou06ZNY/Lkybbn1gVxu3btKl3BdphMJsLDw+nRo0f56crTNCpk+47Yduv1aM2bY/76a6hWDSpVIjMz09Y+fmW1fR5+GFNcXL6HDbVq0at+fbvHyvL3x2SCa9cgOlpHdLT6eeVK9m1ISbl3JPLxyaRRIz01KqbT4HC03aAKKpAEcYWd36bRqYcX6u6ugaw76GXPtvdDmPtCPDpAyzZsSaf6kJjzYU369K+X53UJhfjDs1wF1sDAQGJjY3Psi42NpUqVKvj6+mIwGDAYDHbLBAYG5nteb29v21y27IxGY5n7j+9K5ap9/vlPuHgxz26dxYLu5En0585l3VO8+yd8mW6fxo3VowhKY/skJEB0tBrIa+/n9evgYFygTZ060KABBAfn/Vmnjon9+7fRp09v9Hpf2tc/hDnmFvZua+oAQ53aRIZVLHLPf2nR+6/BRF49xr///X9cu5YVWIOCYMkSeLK//dcV5rtWrgJr+/bt2bZtW4594eHhtG/fHlAT2du0aUNERIRtEJTFYiEiIoKJEycWe31FGXHzJrz8cv7H9XqYNQt69rR7T1GUDhYLxMQ4Dpx37tz7PN7eKkjmFzjr11dl8mMyZX2NDAaY+mEQAwYEATkHDVnLbFpW9NvppU379jeYMyeTn382cuOG+kOlY0fXtUOpDqxJSUmczzaHLioqiuPHj1OjRg0aNGjAtGnTuHbtGp98ouZrPffccyxbtowpU6bwl7/8hR9++IHPP/+crVu32s4xefJkRo0aRdu2bWnXrh1LliwhOTmZMWPGFPvnE2VARgY8/bTj0boWC1y5oso4+o0pPCotjbtdsvYD55Ur9sdq5VajRt5gmX27Vq3C3yJ3pH9/2LQJXnwRrl7N2l+/vrpC65/PFVpZZzBAly7uOXepDqyHDx+ma9eutufW+5yjRo1i7dq13Lhxg+joaNvxRo0asXXrVl5++WWWLl1K/fr1WblypW0OK8DgwYO5desWs2fPJiYmhpCQELZv355nQJMQBfLSS/Djj1CxIqxbB40a2S9Xu7YEVQ/SNDWGLL8rzcuX80y5tctggHr18r/abNBADQIvbv37Q9++KqeHO67QRE6lOrB26dIl36QGAGvXrrX7mmPHjjk878SJE6XrVxTdihXwr3+pPrcNG+BuDlyRxWwunl/2JpO6f5lf4IyOVsmD7qVixfwDZnAw1K2b/9RdT3PnFZrIqYR+BYQo5fbuBesfZ2++KUHVjs2b7XdPLl1a+O7JxETH9zavXSvYoKCAAMeBs3p1uQ0u7k0CqxCudvmyuq+amQlDhkABM3aVJ5s3w4ABeTPwXLum9m/alBVcLRaIjc0KlFFRevbubc3KlQauXFH7//jj3u/p5aVGfuYXOIOCVBIBIYpKAqsQrpScDP36QVwcPPQQrFollzi5mM3qStXeXRzrvmeegWXLVNC0juvKYgDyTtWpXt3xvc2AANcOChIiPxJYhXAVTYMxY+D4cTUYacsWkMxbeezbl7P7156UFNi1K+u5Xp81KCgoyILJdJ6uXZvQqJGB4GB1tXmP9K1CFBsJrEK4yoIF8MUXYDTCf/+rooDI4/r1gpWbMEH1pFsHBVnn55tMZrZtO03v3o0wGmVYqyh5JLAK4Qpffw0zZ6rtDz+Exx7zbH1KIE2D77+H+fMLVn7QIHIs3SVEaSF3HIQoqpMnYfhwtf23v8H48Z6tTwm0fz9066aSS5054/i2s06nunY7diy++gnhShJYhSiK27fVzPukJDVJ8L33PF2jEuXYMejTBx59FHbvViNzJ02ClStVAM0dYK3PlyyR5AWi9JKuYCGclZkJgwfDhQvQsGHW/VXB6dMwe7aaNgMqSI4Zo1IiW289V6smafZE2SSBVQhnvfqqumlYsSJ89RX4+3u6Rh4XFQVz58Knn6r5pzodDB0Kc+bAffflLCtp9kRZJYFVCGesXasurUDlAH7gAY9Wx9OuX1cJpj7+OCsRfd++aqBS69b5v07S7ImySAKrEIX188/w17+q7dmzVZalciouDhYtUskc0tLUvh494I03oF07z9ZNCE+RwCpEYVy7Bk89pVIBPfUUvP66p2vkEQkJsHixeiQmqn0dOqirVrkCFeWdBFYhCio1VQXTmBho1Up1AZezHHkpKerqdNEiNSAaICREBdTHH5fsjUKABFYhCkbT4Nln4dAhtVL1V19B5cqerlWxSU9X90/ffFP9XQFw//0wb57qCS9nf18I4ZAEViEKYvFi+Pe/1WibL76AxnmTwJdFmZlqhO/cuWplGVAzi+bMUTkxSurao0J4kvy3EOJeduyAKVPU9nvvqRRCZZzFouagzp4NZ8+qfXXqqKyN48apRA9CCPsksArhyP/+p5JAWCwwdmzW4uVllKbB1q0qgJ44ofbVqAHTpsHzz8tiPUIUhARWIfITH68mY8bHqyGvH35Ypkfn7NoFM2ZAZKR6XrkyvPIKvPyyLMkmRGFIYBXCHrNZ3UQ8c0bl2fvvf8Hb29O1cosDB1RAjYhQz3194YUXVO93zZqerZsQpZEEViHsmTlT9Yn6+KgFywMDPV0jl/vlF/Uxv/lGPTca1cDnGTPU/VQhhHMksAqR22efwVtvqe1Vq6BNG8/Wx8X+9z+V12LjRnVPVa+HUaPUQKWGDT1dOyFKPwmsQmR35Aj85S9qe8oUGDbMs/VxoehoNe907VrV0w1qXNbcudCsmUerJkSZIoFVCKvYWOjXTyW97d0bFizwdI1cIiZGfZQVK1QmRoAnnlAJ8kNCPFs3IcqiUp8v5cMPP6Rhw4b4+PgQGhrKwYMH8y3bpUsXdDpdnkefPn1sZUaPHp3neK9evYrjowhPSk9XKYSuXlWXb+vXl/r1y27fhqlToUkT+OADFVS7doX9+9V9VQmqQrhHqb5i3bhxI5MnT2b58uWEhoayZMkSwsLCOHv2LLVr185TfvPmzWRY/2QHfv/9dx588EEGDhyYo1yvXr1Ys2aN7bl3GR0NKu7SNDU/9aefoGpVla6walVP18ppiYlqRbt331XJ8gFCQ1U6wj/9ybN1E6I8KNWBdfHixYwfP54xY8YAsHz5crZu3crq1auZOnVqnvI1atTI8XzDhg34+fnlCaze3t4EFmIUaHp6Ounp6bbnCXd/m5lMJkzWxSmFjbVNSkrb6P/1LwwrV6LpdJg//RStceOsRUU9wNn2SU2FFSv0vP22nrg4Nd+2dWuNuXPN9OmjodN59GO5TEn7/pQ00j6OOds+hSmv0zRNK9TZS4iMjAz8/PzYtGkT/fr1s+0fNWoUd+7c4auvvrrnOVq3bk379u356KOPbPtGjx7Nli1b8PLyonr16nTr1o033niDmg4m9M2ZM4e5c+fm2b9+/Xr8JFVNieb/66+0f/119BYLJ0eN4vxTT3m6SoVmMumIiAjm88//H7dv+wJQt24SQ4ee4dFHr0mCfCFcICUlhWHDhhEfH0+Ve2RMKbWB9fr169SrV4/9+/fTvn172/4pU6awZ88eDhw44PD1Bw8eJDQ0lAMHDtAu24rM1qvYRo0aceHCBaZPn06lSpWIjIzEkM89N3tXrEFBQdy4ccNhQC6vTCYT4eHh9OjRA6PR6LmKREVRoUMHdL//jmXYMMxr1pSIzEoFbR+zGdav1/HGGwaiolS9GzTQmDnTzIgRWplNkF9ivj8llLSPY862T0JCAv7+/gUKrGX0v969rVq1itatW+cIqgBDhgyxbbdu3ZoHHniAJk2asHv3bv6Uzw0qb29vu/dhjUajfLEd8Gj7JCXBgAHw++/Qti36lSvRl7DM8vm1j6bB5s1q3umpU2pfQIBK7PDsszq8vcvHf2v5/+WYtI9jhW2fwpQttZ1E/v7+GAwGYmNjc+yPjY295/3R5ORkNmzYwNixY+/5Po0bN8bf35/z588Xqb6iBLFYYORI+PVXFZG+/FLl8SvhNA2++w7atlV/E5w6BdWrw8KFcOGCSkMo4+yE8LxSG1i9vLxo06YNEdYEp4DFYiEiIiJH17A9X3zxBenp6YwYMeKe73P16lV+//136kiOt7Jj/nwVTL281M/69T1do3vauxc6dVLTa48ehUqVYNYsuHhRTampWNHTNRRCWJXawAowefJkPv74Y9atW8fp06eZMGECycnJtlHCI0eOZNq0aXlet2rVKvr165fn/mdSUhKvvvoqP//8M5cuXSIiIoK+ffvStGlTwsLCiuUzCTfbvFmt0g2wfDnc448wTzt8GMLCoHNn+PFHdUX6yisqoM6bB9WqebqGQojcSvXNmMGDB3Pr1i1mz55NTEwMISEhbN++nYCAAACio6PR5xoSefbsWX788Ud27tyZ53wGg4FffvmFdevWcefOHerWrUvPnj2ZP3++zGUtC379VXUBA0yaBHf/ACuJoqMrM3CgAevg9goV1ALjM2dCvXqerZsQwrFSHVgBJk6cyMR8Fp/evXt3nn3NmjUjv4HQvr6+7Nixw5XVEyVFXJxaWzU5WWVJ+Mc/PFINsxn27YMbN9QKMh075kzwdP48zJ5tYMOGrmiaDr0eRoxQSfMbN/ZIlYUQhVTqA6sQ92QywaBBEBWlotPGjXhiLsrmzfDiiyprolX9+rB0KbRrp279rloFZrPqZXnqKQtvvKGnRYtir6oQoggksIqyb/Jk2LVLjfj5+muPrN69ebMayZu7s+TaNZWiuEIFyMxU+8LCLPTosZdJkx7FaCzVwyCEKJfkf60o21auhGXL1Pa//w0tWxZ7FcxmdaVq7w6EdV9mpuoW3rcPvvnGTNOm8cVbSSGEy0hgFWXXTz/B88+r7Xnz1D1WD9i3L2f3b37mzoXHHnN/fYQQ7iWBVZRNV65A//7q/uqAAWo4rYfcuFGwcjEx7q2HEKJ4SGAVZU9Kilqw/OZNeOABWLvWozmAC5pbRHKQCFE2SGAVZYumqQmfR4+Cv79aW9XDaYk6dnSc3Emng6AgVU4IUfpJYBVly9tvw2efqWG2mzZBw4aerhEGA/TpY/+Y9UJ6yZKc81mFEKWXBFZRdmzdCtYUlu+/r/IAlgDnz8Onn6rtqlVzHqtfX8X//v2Lv15CCPeQeayibDh9GoYNU13Bf/0rTJjg6RoBahrNyJHqtm/XrrBjhxqsnF/mJSFE6SeBVZRe33+vcv4uWABTpkBCgopU77/v6ZrZLFoEkZFQpYoaQ2U0Qpcunq6VEMKdJLCK0knTYPp0daU6apQKqg0aqH7VErJg+dGjWQvpfPCBqp4QouyTe6yidNq5Ew4dUtsJCSqYbtkCtWt7tl53paXBM8+oruD+/dW2EKJ8kMAqSh9NU6t8Z18SsH59CAnxXJ1ymT4dTp2CgABYscKj02iFEMVMAqsofaxXqxZL1r6LF9X+EmDXLnjvPbW9apWaTiuEKD8ksIrSxd7VKqihtbNm2c90X4zi49UtX4Bnn81//qoQouxyevCS2Wxmx44dXLx4kT/++CPP4uE6nY5Zs2YVuYJC5JD93mp2ZrPav3MnhIUVf73ueuEFlaa4SROPraUuhPAwpwLr4cOHefrpp7l69WqegGolgVW4XPar1ezdwFZ6vTres6dHbmr+978qEYReD598opZ/FUKUP051BT///POkpqayZcsWbt++jcViyfMwm82urqso7zIyIDraflAFtf/KFVWumN24ofJSALz2GnToUOxVEEKUEE5dsf7yyy+8+eabPPnkk66ujxD58/ZW3b0zZqhLw27d4J13cpapXVuVK0bWvP+//64GJlvnrgohyienAmv9+vXz7QIWwq3q1oUfflDbEyfCww97tj7Axx/Dtm0qnv/73yUmP4UQwkOc6gp+7bXX+Pjjj0lISHB1fYRwbM8euHYNqlWD3r09XRsuXIDJk9X2ggXQsqVn6yOE8DynrlgTExOpVKkSTZs2ZciQIQQFBWHIlUlcp9Px8ssvu6SSQtj85z/q58CBxd7lm1tmpsqolJys8v++9JJHqyOEKCGcCqx///vfbdvLli2zW0YCq3C5tDSVCxhgxAjP1gW19Gv2BPu5p9YKIconp34VREVF3fNx8eJFV9fVrg8//JCGDRvi4+NDaGgoBw8ezLfs2rVr0el0OR4+Pj45ymiaxuzZs6lTpw6+vr50796dc+fOuftjiIL49luVFzgoCB57zKNVOXYMXn9dbb//PgQHe7Q6QogSpNBXrKmpqSxdupSuXbt6fFTwxo0bmTx5MsuXLyc0NJQlS5YQFhbG2bNnqZ1PMvYqVapw9uxZ23NdrvmOb7/9Nu+//z7r1q2jUaNGzJo1i7CwME6dOpUnCIti9u9/q5/Dh3v08jAtTV0wWxPsjxzpsaoIIUqgQgdWX19fVqxYQYsWLdxRn0JZvHgx48ePZ8yYMQAsX76crVu3snr1aqZOnWr3NTqdjsDAQLvHNE1jyZIlzJw5k759+wLwySefEBAQwJYtWxgyZIjd16Wnp5Oenm57bh3UZTKZMJlMTn++ssraJoVqm9u3qbBtGzrANGgQeLBdp03Tc+qUgYAAjWXLMsnMdO35nWqfckTaxzFpH8ecbZ/ClHfqHmubNm347bffnHmpy2RkZHDkyBGmTZtm26fX6+nevTuRkZH5vi4pKYng4GAsFgsPP/wwCxYsoOXdoZxRUVHExMTQvXt3W/mqVasSGhpKZGRkvoF14cKFzJ07N8/+Xbt24efn5+xHLPPCw8MLXDZ4xw5CTCbiGzZkd3S0ShThAb/+WpOlSx8FYPz4Axw8GOu29ypM+5RH0j6OSfs4Vtj2SUlJKXBZpwLrkiVL6N27N61atWL06NFUqFD866XHxcVhNpsJCAjIsT8gIIAzZ87YfU2zZs1YvXo1DzzwAPHx8bz77rt06NCBkydPUr9+fWJiYmznyH1O6zF7pk2bxmTrnAvUFWtQUBBdu3alZs2azn7EMstkMhEeHk6PHj0wGo0Feo3h3XcBqPTXv9LbQ9Ns4uNh0qQKaJqOsWMtzJ7dxi3v40z7lCfSPo5J+zjmbPsUZnqpUxFx9OjR6PV6/vrXvzJp0iTq1auHr69vjjI6nY4TJ044c3q3ad++Pe3bt7c979ChA82bN2fFihXMnz/f6fN6e3vjbWfqh9FolC+2AwVun8uX4ccfQafDMGIEBg+16SuvqAvlxo1hyRI9RqN77/PK98cxaR/HpH0cK2z7FKasU4G1Ro0a1KxZk2bNmjnzcpfw9/fHYDAQG5uzKy42Njbfe6i5GY1GHnroIc6fPw9ge11sbCx16tTJcc6QErSIdrmzfr0XvvAAACAASURBVL362aWLWtDcAzZvVon1JcG+EOJenAqsu3fvdnE1Cs/Ly4s2bdoQERFBv379ALBYLERERDBx4sQCncNsNvPrr7/auhYbNWpEYGAgERERtkCakJDAgQMHmDBhgns+iHBM07JGA3to7mpMjFpbFVSC/Ucf9Ug1hBClRPHfHHWhyZMnM2rUKNq2bUu7du1YsmQJycnJtlHCI0eOpF69eixcuBCAefPm8cgjj9C0aVPu3LnDO++8w+XLlxk3bhyguq9feukl3njjDe677z7bdJu6devagrcoZidOwKlTKsvS008X+9tLgn0hRGE5FVj37t1boHKdOnVy5vQFNnjwYG7dusXs2bOJiYkhJCSE7du32wYfRUdHo8823/GPP/5g/PjxxMTEUL16ddq0acP+/ftzTB2aMmUKycnJPPvss9y5c4fHHnuM7du3yxxWT7FerT75JFStWuxvv3IlbN2qEut/+qkk2BdC3JtTgbVLly55EivYUxxrsk6cODHfrt/cXdbvvfce7733nsPz6XQ65s2bx7x581xVReEssxk++0xtDx9e7G9/4QJYs3IuWACtWhV7FYQQpZBTgXXXrl159pnNZi5dusRHH32ExWLhrbfeKnLlRDm3ezdcv65Wsnn88WJ9a7NZZVRKTobOnbMCrBBC3ItTgbVz5875Hhs9ejQdO3Zk9+7ddOvWzemKCWFbyWbQoGJfyebtt2H/fqhcGdatkwT7QoiCc/mvC71ez5AhQ1i5cqWrTy3Kk9TUrJVsirkb+PjxrAT7H3wgCfaFEIXjlr/Db9++zZ07d9xxalFefPstJCZCgwbFupKNNcG+yQRPPSUJ9oUQhedUV3B0Pnla79y5w969e3nnnXfo2LFjkSomyjnraOBhw4q1H3bmTDh5EgICYMUKKMAYPSGEyMGpwNqwYcN8RwVrmsYjjzzCihUrilQxUY7dvg3ffae2izEpxJ49sHix2l65EmrVKra3FkKUIU4F1tWrV+cJrDqdjurVq9OkSZMSsaScKMW++EL1xT74INxdecjd4uNVt681IcQTTxTL2wohyiCnk/AL4TYeSGH44osqwX6jRllXrUII4Qynbl41btyYr7/+Ot/j3377LY0bN3a6UqIcu3TJtpINQ4cWy1t++WXWlJpPP1VTbIQQwllOBdZLly6RlJSU7/GkpCQuX77sdKVEOWZdyaZrV6hXz+1vlz3B/pQpkmBfCFF0Tg+3dJTS8NChQ1SrVs3ZU4vyKvtKNsUwd1XTYPx4iItTt3PnznX7WwohyoEC32NdunQpS5cuBbJWgZkxY0aecvHx8dy5c4dhw4a5rpaifDh+HE6fLraVbFatUtNlvbxUPJcE+0IIVyhwYK1duzYt747QvHTpEvXq1aNerq46nU5HxYoVadOmDc8//7xrayrKPmsKw2JYyebixaz8v2++KQn2hRCuU+DAOnToUIbeHUzStWtXZs6cyZ/+9Ce3VUyUM2Zz1v1VN48GtibYT0qCTp0kwb4QwrVctrqNEEWyezfcuAHVq7t9JZt33oGffspKsG8wuPXthBDljNODlxISEnjrrbcICwvjoYce4uDBg4DKE7x48WLOnz/vskqKcsA6aGnQILfe7Dx+HGbPVtvvvw8NG7rtrYQQ5ZRTV6xXr16lc+fOXLlyhfvuu48zZ87Ypt/UqFGDFStWcPnyZdtgJyEcSk2F//5XbbtxNHBaGjzzjErq1K8fjBrltrcSQpRjTgXWV199lcTERI4fP07t2rWpXbt2juP9+vXj22+/dUkFRTnwzTdqJZvgYLdOJJ01C377DWrXho8+kgT7Qgj3cKoreOfOnUyaNIkWLVrYnc/auHFjrly5UuTKiXLCOhrYjSvZ7NkD//iH2pYE+0IId3Lqt1hqaiq1HPxmSkxMdLpCopz5/XfYtk1tu2k0cEKC6vbVNBg7Vs3mEUIId3EqsLZo0YK9e/fme3zLli089NBDTldKlCNffAGZmRASAm5aFenFF+HyZZVg/7333PIWQghh41Rgfemll9iwYQOLFi0iPj4eAIvFwvnz53nmmWeIjIzkZZkcKArCzSvZbNkCa9eq+6mffCIJ9oUQ7ufU4KURI0Zw+fJlZs6caUtr2KtXLzRNQ6/Xs2DBAvr16+fSiooyKCpKTSjV6WDIEJefPjZW5QIGlWD/scdc/hZCCJGH0yNFZsyYwYULF3jnnXeYMGEC48ePZ9GiRZw9e5bXXnvNlXV06MMPP6Rhw4b4+PgQGhpqm09rz8cff0zHjh2pXr061atXp3v37nnKjx49Gp1Ol+PRq1cvd3+Mckm/YYPacMNKNtkT7D/wgCTYF0IUH6euWK0aNGhgt8v3jz/+4IMPPmC2dSa+m2zcuJHJkyezfPlyQkNDWbJkCWFhYZw9ezbPFCCA3bt3M3ToUDp06ICPjw+LFi2iZ8+enDx5Mkfe4169erFmzRrbc29vb7d+jnJJ09C7MYXh6tVqFo81wb78Ewohikuhr1g1TSM2Npb09PQ8x65evcrkyZMJDg5mbjFcIixevJjx48czZswYWrRowfLly/Hz82P16tV2y//nP//h+eefJyQkhPvvv5+VK1disViIiIjIUc7b25vAwEDbo3r16m7/LOVN1YsX0Z09qyJe//4uPffFi/DSS2r7jTegdWuXnl4IIRwq8BWrpmnMnj2bDz74gMTERHQ6HX369GHNmjX4+Pgwffp0VqxYQUZGBr179+bVV191Z73JyMjgyJEjTJs2zbZPr9fTvXt3IiMjC3SOlJQUTCYTNWrUyLF/9+7d1K5dm+rVq9OtWzfeeOMNatasme950tPTc/yhkZCQAIDJZMJkMhXmY5ULJpOJ+nv2AGB54gnMfn4qHZILqAT7BpKS9HTsaOGFF8yuOnWxsX5n5Ltjn7SPY9I+jjnbPoUpX+DA+v777/Pmm28SHBxMz549iYqK4ptvvmHs2LHcunWLAwcOMGLECKZMmULz5s0LVWFnxMXFYTabCQgIyLE/ICCAM2fOFOgcr732GnXr1qV79+62fb169aJ///40atSICxcuMH36dB5//HEiIyMx5JOtfeHChXav0Hft2oWfn18hPlU5YTYTtm8fAIf+3/8jxjqP1QU2b27KTz+1xNfXxIgRu9ixI9Vl5y5u4eHhnq5CiSbt45i0j2OFbZ+UlJQCl9VpmqYVpOCDDz6Ir68ve/bssd1znDJlCu+++y7169dn69attC7GPrfr169Tr1499u/fT/v27W37p0yZwp49ezhw4IDD17/11lu8/fbb7N69mwceeCDfchcvXqRJkyZ8//33+S6TZ++KNSgoiBs3bji80i2vzDt24PPkk2g1apAZHe2ypPsnTkCHDhUwmXR8/HEmo0YV6Ktd4phMJsLDw+nRowdGo9HT1SlxpH0ck/ZxzNn2SUhIwN/fn/j4eKpUqeKwbIGvWM+dO8dbb72VYyDPuHHjePfdd5kxY0axBlUAf39/DAYDsbGxOfbHxsYSGBjo8LXvvvsub731Ft9//73DoAoqPaO/vz/nz5/PN7B6e3vbHeBkNBrli22H4fPPAbA8/TTGihVdcs70dPjLX1SPct++MHZshVKfC1i+P45J+zgm7eNYYdunMGULPHgpLS0Nf3//HPusV2NNmjQp8Bu6ipeXF23atMkx8Mg6ECn7FWxub7/9NvPnz2f79u20bdv2nu9z9epVfv/9d+rUqeOSepd7KSnotmwBQBs2zOnTmM1qCdfPPlM/Z8yAX3+VBPtCCM8r1HQbewn3gXzvPbrb5MmTGTVqFG3btqVdu3YsWbKE5ORkxowZA8DIkSOpV68eCxcuBGDRokXMnj2b9evX07BhQ2JiYgCoVKkSlSpVIikpiblz5/L0008TGBjIhQsXmDJlCk2bNiUsLMwjn7HM+eYbdImJpNSqhdHBH0CObN6s0hRevZr32Mcfq+AqhBCeUqjAOnXqVFuQAjCbzYDqEq6Yq0tPp9Nx4sQJF1Qxf4MHD+bWrVvMnj2bmJgYQkJC2L59u21AU3R0NPpsq6X861//IiMjgwEDBuQ4z+uvv86cOXMwGAz88ssvrFu3jjt37lC3bl169uzJ/PnzZS6rq9xdyeZq5840cmIlm82bYcAAlQDCnszMolROCCGKrsCBtVOnTnavWO0lYihOEydOZOLEiXaP7d69O8fzS5cuOTyXr68vO3bscFHNRB5xcfDdd8DdwFrIl5vN6ko1v6Cq06n5q337goc6UYQQouCBNXeQEqLQ7q5ko4WEkBgUVOiX79tnv/vXStPgyhVVrksX56sphBBF4Z5VpYWw5+5KNpahQ516+Y0bri0nhBDuIIFVFI+LF2H/ftDpsAwe7NQpCjowWwZwCyE8SQKrKB7WhPvdukHduk6domNHqF8//6k0Oh0EBalyQgjhKRJYhftpmm00cFFWsjEYYOlS+8eswXbJEhm4JITwLAmswv3+9S84cwaMxiKvZNO/P2zaBLlTMNevr/a7eKEcIYQotCKtxyrEPWkazJuntitVgsqVizzZ9KmnoEYNSEmB6dOhRw/V/StXqkKIkkCuWIV7ffcdWPM5//EH7NxZ5FNeuqSm3VSooAJrly4SVIUQJUeBrlgbNWqUbzrD/Oh0Oi5cuOBUpUQZoWnw8stZzw0GmDULunYt0mn37lU//+//wEU5/IUQwmUKFFg7d+6cJ7AePnyYkydP0qJFC5o1awbA2bNnOXXqFK1ataJNmzaur60oXXbuhP/9L+u52QyHDqEr4jqRd9dIp1OnIp1GCCHcokCBde3atTmeb9myhS1bthAeHp5nKbXw8HAGDRrE/PnzXVZJUQppmlpyJjeDAf3rr8PMmU6f2nrF2rmz06cQQgi3ceoe6+zZs3nhhRfsrk/ao0cPJk6cyMwi/OIUZcDOnXDkSN79ZjP6I0eodfy4U6e9dg0uXAC9Hh59tIh1FEIIN3AqsJ47d862Fqs9NWvWlPur5ZmmqXup+R3W62n+n//kn03fAevV6kMPQZUqzlZQCCHcx6nA2qRJE9asWUNSUlKeY4mJiaxevZrGjRsXuXKilMrIUEN386GzWPCNi1PlCknurwohSjqn5rG+8cYbDBgwgPvvv5/Ro0fTtGlTQF3Jrlu3jtjYWL744guXVlSUIt7e8MorMHUqNG0KGzfmOGzKzGTPr7/SzYk1buX+qhCipHMqsPbr149t27bx2muvsWDBghzHQkJCWLVqFWFhYS6poCil7q67yrhx8PDDOY+ZTKQ5sQTNzZtw+rTalnzAQoiSyunMSz179qRnz57ExMRw+fJlAIKDgwkMDHRZ5UQpdeVK1qXlkCEuO+2+fepn69Yq85IQQpRERU5pGBgYKMFU5LRhgxqY1LEjBAe77LTW+6vSDSyEKMmcTmkYHR3Nc889R7NmzahRowZ7716hxMXFMWnSJI4dO+aySopSxrqSzfDhLj2t9SJYBi4JIUoyp65YT506RceOHbFYLISGhnL+/Hky7yZW9/f358cffyQ5OZlVq1a5tLKiFDh5Ek6cUIl8Bwxw2Wn/+AN++UVtS2AVQpRkTgXWKVOmUK1aNX7++Wd0Oh21a9fOcbxPnz5szDUSVJQT1gXNH38cHMx1Lqwff1S9y82aQUCAy04rhBAu51RX8N69e5kwYQK1atWym5y/QYMGXLt2rciVE6WMpmUFVhd3A8v9VSFEaeFUYLVYLPjlXmk6m1u3buHtxBxFUcpFRqrEEJUqwZNPuvTUcn9VCFFaOBVYH374YbZu3Wr3WGZmJhs2bOCRRx4pUsVEKWQdtPTUU+DgD6/CSkyEo0fVtgRWIURJ51RgnTZtGtu3b2fChAn89ttvAMTGxvL999/Ts2dPTp8+zdSpU11a0fx8+OGHNGzYEB8fH0JDQzl48KDD8l988QX3338/Pj4+tG7dmm3btuU4rmkas2fPpk6dOvj6+tK9e3fOnTvnzo9QNphM8PnnatvF3cD796sV5xo1gqAgl55aCCFczqnA+vjjj7N27Vo2btxIt27dABgxYgQ9e/bk6NGjfPLJJ3QqhkuLjRs3MnnyZF5//XWOHj3Kgw8+SFhYGDdv3rRbfv/+/QwdOpSxY8dy7Ngx+vXrR79+/Wx/HAC8/fbbvP/++yxfvpwDBw5QsWJFwsLCSEtLc/vnKdXCwyEuDmrXBjurHhWF3F8VQpQmTieIeOaZZ+jfvz/h4eGcO3cOi8VCkyZNCAsLo3Llyq6sY74WL17M+PHjGTNmDADLly9n69atrF692u4V89KlS+nVqxevvvoqAPPnzyc8PJxly5axfPlyNE1jyZIlzJw5k759+wLwySefEBAQwJYtWxiSTxah9PR00tPTbc8TEhIAMJlMmEwml37mksrw6afoAfPAgVg0TV3B5sPaJgVtmz17DICeRx/NxGQq/Io4pU1h26e8kfZxTNrHMWfbpzDlnQqse/fupXnz5tSqVYt+/frlOR4XF8epU6fcetWakZHBkSNHmDZtmm2fXq+ne/fuREZG2n1NZGQkkydPzrEvLCyMLVu2ABAVFUVMTAzdu3e3Ha9atSqhoaFERkbmG1gXLlzI3Llz8+zftWuXw0FeZYUhNZVeX36JHvgpOJg/cnWv5yc8PPyeZdLTDRw82BsAs3kX27alFKWqpUpB2qc8k/ZxTNrHscK2T0pKwX/3OBVYu3btyqeffsqwYcPsHo+IiGDYsGGYzWZnTl8gcXFxmM1mAnJNagwICODMmTN2XxMTE2O3fExMjO24dV9+ZeyZNm1ajoCdkJBAUFAQXbt2dbhubVmh++wzKqSnozVpQvsXXwQ7U7CyM5lMhIeH06NHD4xGo8Oyu3fryMzUU6+expgxXe516jKhMO1THkn7OCbt45iz7WPtiSwIpwKrdo8FqtPT0zEYDM6culTy9va2O73IaDSWjy/23WQgumHDMHp5FfhlBWmfn35SPzt31uHlVQ7aMpty8/1xkrSPY9I+jhW2fQpTtsCBNTo6mkvZFq8+c+aMLT9wdnfu3GHFihUEuzD5uj3+/v4YDAZiY2Nz7I+Njc13UYDAwECH5a0/Y2NjqVOnTo4yISEhrqx+2XHrFuzYobZdPBoYZGFzIUTpU+DAumbNGubOnYtOp0On0/Hmm2/y5ptv5imnaRoGg4EVK1a4tKK5eXl50aZNGyIiImz3eS0WCxEREUycONHua9q3b09ERAQvvfSSbV94eDjt27cHoFGjRgQGBhIREWELpAkJCRw4cIAJEya49fOUWl98oebCtGmj8g26UHo6/Pyz2pYRwUKI0qLAgXXQoEG0atUKTdMYNGgQkyZNomOu1aZ1Oh0VK1YkJCQkz31Kd5g8eTKjRo2ibdu2tGvXjiVLlpCcnGwbJTxy5Ejq1avHwoULAXjxxRfp3Lkz//jHP+jTpw8bNmzg8OHDfPTRR7b6v/TSS7zxxhvcd999NGrUiFmzZlG3bl27g7QEWUkh8rnfXhSHDkFamprB4+KYLYQQblPgwNq8eXOaN28OqKvXTp060ahRI7dVrCAGDx7MrVu3mD17NjExMYSEhLB9+3ZbUI+Ojkavz5qq26FDB9avX8/MmTOZPn069913H1u2bKFVq1a2MlOmTCE5OZlnn32WO3fu8Nhjj7F9+3Z8fHyK/fOVeFFRKnuDTufSBc2tsqcxLA+DloQQZYNTg5eGDx/ucOhxQkICfn5+VKhQ5HXU72nixIn5dv3u3r07z76BAwcycODAfM+n0+mYN28e8+bNc1UVy67PPlM/u3WDunVdfnpJDCGEKI2cyrw0adIkOnTokO/xRx99lFdeecXpSolSQNPc2g2cmZk1IlgGLgkhShOnAuv27dsZ4GAR6wEDBuTJwSvKmBMn4NQp8PaGp592+emPHoXkZKheHbL11AshRInnVGC9fv069erVy/d43bp1ZT3Wss667uoTT0DVqi4/vfX+aseOoHfqWyqEEJ7h1K+smjVrcvbs2XyPnz59mipVqjhdKVHCWSxZ91fd0A0Mcn9VCFF6ORVYe/XqxYoVKzh27FieY0ePHuWjjz7i8ccfL3LlRAm1dy9cvaquVHv3dvnpzWbYt09ty/1VIURp49Sw3fnz57N9+3batWvHn//8Z1q2bAnAb7/9xjfffEPt2rWZP3++SysqShBrN/CAAeCGaUi//grx8VC5MkjCKyFEaeNUYK1bty6HDx9m6tSpfPXVV3z55ZcAVKlSheHDh7NgwQLqumH6hSgB0tNVtiVwWzew9f7qo49CMczYEkIIl3L611adOnVYt24dmqZx69YtAGrVqoVOZvKXbd99B3fuqHmrbroBKvdXhRClWZGvB3Q6Hd7e3lSqVEmCanlg7QYeOhTcsIKRpuXMuCSEEKWN0xMZDh8+TK9evfDz86NmzZrsuXuZERcXR9++fe1mPRKlXEICfPON2nZTN/Dp0xAXB76+0LatW95CCCHcyqnAun//fh577DHOnTvHiBEjsFgstmP+/v7Ex8e7fXUb4QGbN6us+PffDw895Ja3sF6ttm8PhVjaVQghSgynAuv06dNp3rw5p06dYsGCBXmOd+3alQMHDhS5cqKEsXYDDx/utqz4cn9VCFHaORVYDx06xJgxY/D29rZ7X7VevXrExMQUuXKiBImJgYgItT10qFveQu6vCiHKAqcCq9FozNH9m9u1a9eoVKmS05USJdCGDSrj0iOPQJMmbnmLCxfg+nXVBRwa6pa3EEIIt3MqsD7yyCNs2rTJ7rHk5GTWrFlDZ+nLK1uydwO7ifVqtV07NXhJCCFKI6cC69y5czl8+DB9+vThu+++A+DEiROsXLmSNm3acOvWLWbNmuXSigoPOncODh1S02sGDXLb28j9VSFEWeDUPNbQ0FC2bdvGhAkTGDlyJIBt/dUmTZqwbds2HnjgAdfVUniWdd3VHj2gdm23vY3cXxVClAVOJ4jo1q0bZ8+e5dixY5w/fx6LxUKTJk1o06aNJIooSzStWLqBo6Ph0iV1Udyhg9veRggh3K7ImZceeughHnLTnEZRAhw+rLqCfX2hb1+3vY31arVNG5Bxb0KI0szpwJqens7HH3/Mtm3buHTpEgANGzakd+/ejBs3Dh83rHoiPMDaDdy3r1puxk3k/qoQoqxwavDS1atXCQkJYdKkSZw4cYJatWpRq1YtTpw4waRJkwgJCeHq1auurqsobmazmmYDbu0GBgmsQoiyw6nA+re//Y3Lly/z+eefc+3aNfbs2cOePXu4du0aGzduJDo6mr/97W+urqsobj/8ALGxUKMG9Ozptre5cUP1Nut0aqk4IYQozZzqCo6IiODll19mwIABeY4NHDiQo0eP8sEHHxS5csLDrN3Agwa5NXGv9f5qSAhUq+a2txFCiGLh1BVr5cqVqe1g2kVgYCCV3Xg/ThSD1FSVdB/c3g0s02yEEGWJU4F1zJgxrF27lpSUlDzHkpKSWLNmDWPHji1y5Ry5ffs2w4cPp0qVKlSrVo2xY8eSlJTksPwLL7xAs2bN8PX1pUGDBkyaNIn4+Pgc5XQ6XZ7HBut9xvLk228hMREaNHD7/Be5vyqEKEuc6goOCQlh69at3H///YwaNYqmTZsCcO7cOT755BNq1KjBAw88wGbrFc9d/fv3L3qN7xo+fDg3btwgPDwck8nEmDFjePbZZ1lvnXOZy/Xr17l+/TrvvvsuLVq04PLlyzz33HNcv349T3rGNWvW0KtXL9vzauWxf9LaDTxsGOidXrb3nuLi4ORJtd2xo9veRgghio1TgXXIkCG27TfffDPP8atXrzJ06FA0TbPt0+l0mM1mZ94uj9OnT7N9+3YOHTpE27urYX/wwQf07t2bd999l7p16+Z5TatWrfjvf/9re96kSRPefPNNRowYQWZmJhUqZDVFtWrVCAwMLHB90tPTSU9Ptz1PSEgAwGQyYTKZCv35PO6PP6iwbRs6wDRoELj4M1jbxGQysWuXDqhAixYaVatmuvqtSqXs7SPykvZxTNrHMWfbpzDlnQqsu3btcuZlLhMZGUm1atVsQRWge/fu6PV6Dhw4wFNPPVWg88THx1OlSpUcQRXUqOdx48bRuHFjnnvuOcaMGeMwm9TChQuZO3dunv27du3Cz8+vgJ+q5AjeuZMQk4n44GB2R0ertEhuEB4ezqeftgKa0KDBJbZt+8Ut71NahYeHe7oKJZq0j2PSPo4Vtn3s3frMj1OB1dMr18TExOQZPFWhQgVq1KhR4HVg4+LimD9/Ps8++2yO/fPmzaNbt274+fmxc+dOnn/+eZKSkpg0aVK+55o2bRqTJ0+2PU9ISCAoKIiuXbtSs2bNQnyyksGweDEAlZ59lt69e7v8/CaTifDwcHr06MGcOWoZmxEjgujdu77L36s0yt4+RqPR09UpcaR9HJP2cczZ9rH2RBaEU4H1119/pXXr1g7LbNq0ye50HEemTp3KokWLHJY5ffp0oc5pT0JCAn369KFFixbMmTMnx7Hsq/I89NBDJCcn88477zgMrN7e3nh7e+fZbzQaS98X+8oV2LcPAMOIERjcWP+UFCMnTqiegG7dKlDamsrdSuX3pxhJ+zgm7eNYYdunMGWdGpXStm1bFi5caHex89u3bzN48GAGDx5c6PO+8sornD592uGjcePGBAYGcvPmzRyvzczM5Pbt2/e8N5qYmEivXr2oXLkyX3755T0bKzQ0lKtXr+a4h1qmbdigEu937KhGBLvRTz/p0DS47z6oU8etbyWEEMXGqSvWUaNGMWPGDL766ivWrVtHs2bNANiyZQsTJkwgMTGRJUuWFPq81tSI99K+fXvu3LnDkSNHaNOmDQA//PADFouF0NDQfF+XkJBAWFgY3t7efP311wXKZ3z8+HGqV69u94q0TCqGlWys9u1TV6syf1UIUZY4dcX60Ucf8d1333H16lUeeughFi1axIgRI+jfvz9NmjTh+PHjvPDCC66uq03z5s3p8Z6phAAAIABJREFU1asX48eP5+DBg/z0009MnDiRIUOG2EYEX7t2jfvvv5+DBw8CKqj27NmT5ORkVq1aRUJCAjExMcTExNhGK3/zzTesXLmS3377jfPnz/Ovf/2LBQsWuPWzlCinTsHx42A0QiG78Z1hDawyf1UIUZY4vbpNWFgYJ0+eJCwsjOnTpwMwY8YM5s2bVyzrsf7nP/9h4sSJ/OlPf0Kv1/P000/z/vvv246bTCbOnj1rG8l19OhRDhw4AGCbd2sVFRVFw4YNMRqNfPjhh7z88stomkbTpk1ZvHgx48ePd/vnKRGsc1d79QI3D7pKTTVw9KhcsQohyh6nA2tycjJTpkzh4MGDPPjgg5w7d47Vq1fTvn17t4wkza1GjRr5JoMAtYRd9nm0Xbp0yfHcnl69euVIDFGuhIfDO++o7WLoBj57tgaZmTqCgyE42O1vJ4QQxcapruBdu3bRunVr1q1bx8KFCzly5AjHjh2jYcOGPPnkk4wbN47ExERX11W4i6bBpEkqEYReD0884fa3PHlSXRHL1aoQoqxxKrB2796d6tWrc+TIEV577TX0ej333XcfP/74I4sWLWL9+vX3nI4jSpCdO+HMGbVtscCPP7r9La2BVe6vCiHKGqcC66xZszhw4AAtW7bMsV+n0/H3v/+dI0eOEBAQ4JIKCjfTNLh7jxxQV6yzZqn9bpKWBv/7X3VArliFEGWPU4F1zpw5edIAZte8eXMiIyOdrpQoRjt3wtGjWc8tFjh0SO13k4MHdWRmGqhTRyPXODIhhCj1Cjx46eDBgzRt2pQaNWrcs2xUVBT79u1j5MiRRaqccDNNg2ypGG0MBnXV2rMnuGGEt3WaTceOWrGMIBeiOJjN5hKR+N5kMlGhQgXS0tJctvBJWWKvfYxGIwaDwWXvUeDA2r59ez799FOGDRsGqAxL9evX57vvvsuTO3j//v2MGTNGAmtJ9913au5qbmZz1lVrWJjL3zZ7YBWitNM0jZiYGO7cuePpqgCqPoGBgVy5ckX+cLUjv/axrmrmijYrcGDNPVVF0zT5i6g00zSYMCH/49Z7rS6+as3IgMhIa2C1AK77K1EIT7AG1dq1a+Pn5+fxYGaxWEhKSqJSpUro3biWcmmVu300TSMlJcWWJreOC/KrOj2PVZRyly+rhPv5sVjU8YwMcGE6xyNHIDVVR5Uq6TRvLv/pRelmNpttQbWkrGRlsVjIyMjAx8dHAqsd9trH11etsnXz5k1q165d5G5hCazl1bRp6qq1RQtYu1bdV82tdm2XBlWAvXvVzxYtfkenu3deaCFKMus91dK47rLIyfpvaDKZJLAKJ+zcqVax0evh00/h4YeL7a337FE/W7b8HZDAKsoGT3f/iqJz5b9hoQLrpUuXOHp3akZ8fDwA586do1q1ajnKRUVFuah6wuVSU7PurU6aVKxBNTMzK/dEy5Zxxfa+QghRnAoVWGfNmpVjIXCA559/Pk85TZNpFCXWggVw8SLUqwfz5hXrW584AYmJULWqRnBwQrG+txBCFJcCB9Y1a9a4sx6iOJw+DYsWqe3334fKlYv17a3dwI8+qtm9pStEeWc2w759cOMG1KkDHTvaH/7gDnPmzGHu3LnUrVuXK1eu5Bn49Oijj7J//35GjRrF2rVrWbt2LWPGjOHWrVv4+/vbPWfDhg25fPmy3WM3btwgMDDQ5Z+jJChwYB01apQ76yHczTq9xmRSSfafeqrYq2AduCTzV4XIa/NmePFFuHo1a1/9+rB0KfTvXzx1MBqNxMXFsXfvXrp06WLbf/nyZSIjI6lUqVKhzzlgwABeeeWVPPtLyihqd5DBS+XFJ5+oS0Y/P1i2zC0ZlRyxWNRf4gCdOmnculWsby9EibZ5MwwYkDdF97Vrav+mTcUTXL28vOjevTufffZZjsC6YcMGWrZs6dRo2YCAAB555BEX1rLkk0lO5cHvv8Pf/662X3/dIwugnjwJt29DxYoQEiJXrKLs0jRITi74IyFBjSO0t+6Fdd+LL6pyhTmvs+toDB06lE2bNuVIz7h+/Xpb1j1xbxJYy4MpUyAuDlq3hpdf9kgVsu6vgtHokSoIUSxSUqBSpYI/qlZVV6b50TTVPVy1asHOV6WKnvr1q5GS4lz9n3zySdLT09l5dyGOU6dO8csvvzBkyBCnzqdpGpmZmTkeZT1jnwTWsm7fPli9Wm0vX+6xqGa9vyrLxAlRsvn5+dG3b182bNgAwGeffUb79u1p1KiRU+f75z//idFozPFo1qyZK6tc4sg91rIsIwOee05tjx8PHTp4pBqalnXFKgubi7LOzw+Skgpefu9e6N373uW2bSvYH6YWi4WEhAT8/KoUvBK5DB06lGHDhpGamsqGDRuYNGmS0+caNGgQr776ao59Pj4+Tp+vNJDAWpb94x9q9ZpateCttzxSBbMZ/vMfuHlTXSwXYz4KITxCp1NjCQqqZ081+vfaNfv3RXU6dbxnz4JNvbFY1P+7ooxPDAsLw2g0Mnv2bKKiohg0aJDT56pVqxZt27Z1vjKlkHQFl1UXL2YlgFi8GAqwjq6rbd4MDRuCdaaWyQTNmsGXX0ryECGsDAY1pQbyBkPr8yVLim8+K6hpN08//TSLFy+mW7duBAQEFN+blwESWMsiTYOJEyEtDbp1g+HDi70K1ukD2efkgfqrfMgQA5GRRV+aSYiyon9/NaWmXr2c++vXL76pNrmNGzeOJ598khdffLH437yUk67gsmjTJrWIuZcX/POfxT5n1WxW0wPymz6g08GqVa2YM0dGCAth1b8/9O3rucxLubVr144tW7bcs9w333xD5VxZ3Fq1asX9998PQGxsLD///HOe17Vs2TLP68qKUnvFevv2bYYPH06VKlWoVq0aY8eOJekeIwa6dOmCTqfL8XjOOrjnrujoaPr06YOfnx+1a9fm1VdfJTMz050fxbUSElRUA7U0nAdG3+3bl/dKNTtN0xEX58ePP0qXsBDZGQzQpQsMHap+lobUn3/5y18YOHBgjsemTZtsxzdt2kT79u3zPE6cOOHBWrtXqb1iHT58ODdu3CA8PByTycSYMWN49tlnWb9+vcPXjR8/nnnZks9nX0fRbDbTp08fAgMD2b9/Pzdu3GDkyJEYjUYWLFjgts/iUjNnqj9377sPpk71SBVu3HBtOSGE+82ZM4c5c+Y4LHP8+HHb9uj/3969h0VV7Y8ffw8DggqCKIggilhfL4Ta0ULwfkUlrI6XxBuaWkchI7STlgpqx0uZYWoeNRUzL+U1U1MxvHRMUykrzfyJeU9EJQG5Dsz+/THN6MiAYAMz6Of1PDwwa9Zee+01M3xm7b32WsOHM3z48BLzX7hw4e9XrBKqlIH19OnT7Nq1i2PHjhlGmy1YsIDevXszd+5cPD09i922WrVqxU78vGfPHn799Vf27t1LnTp1aNmyJTNmzOCtt94iNjaWKlWqlMvxmM3x47rpCkF3CthCQ9rrlvLyaWnzCSFEZVIpA+vhw4dxcXExGsLdrVs3bGxs+P7773mxhAnm16xZw2effYaHhwehoaFMmTLF0Gs9fPgw/v7+RiPggoODGTNmDKdOneLpp582WWZeXh55eXmGxxkZuiXRNBqN0bRg5aqwENtXXkGlKGjDwijs2FE3DNcC2rSBunVt/+qRFj3dq1Ip1KqVQ0AAaDQyveH99O+ZCnvvVDLW1D4ajQZFUdBqtWi1WktXB9DNdKT/bS11sibFtY9Wq0VRFDQajck5kcvyfquUgTUlJQV3d3ejNFtbW1xdXUlJSSl2u0GDBtGgQQM8PT35+eefeeuttzhz5gybN282lHv/sHL945LKnTVrFtOmTSuSvm/fPqNTzeXJd/t2/H/8kfzq1UkMDiZv584K2a8pigIODh0BF0DBOLgqKAqMHHmSxEQ5F1yShIQES1fBqllD+9ja2uLh4cGdO3fIz8+3dHWMZGZmWroKVu3+9snPzycnJ4eDBw+aHFeTXYY5Iq0qsE6cOJE5+vVCi3H69OmHLv+VV14x/O3v70/dunXp2rUr586do1GjRg9d7qRJk4iOjjY8zsjIwNvbm86dO1fM0khXr2I7dCgA6vfeo6uFJ8tevlzF+fO22Noq1KoF16/ffa5ePXjvvXyqVbtG9+7dsZNhwUVoNBoSEhKkfYphTe2Tm5vL5cuXcXR0tJrZhBRFITMzEycnJ1QVfEdAZVBc++Tm5lK1alU6dOhg8rXUn4ksDasKrOPHj3/gxXBfX188PDxITU01Si8oKCAtLa1MC+cGBAQAkJycTKNGjfDw8ODo0aNGea7/FRVKKtfe3h57e/si6fp5Mcvdm29CZia0aYP6X/9CbWO5wd7nz+uqAzB7toqoqPtvH1Ch1dqwc2cFtk8lJe1TMmton8LCQlQqFTY2NkUWBrcU/elNfb2EseLax8bGBpVKVez7qizvNasKrG5ubri5uT0wX2BgILdv3yYpKYlWrVoBkJiYiFarNQTL0tCPcKv71yiawMBA/vOf/5Cammo41ZyQkECNGjVo1qxZWQ+nYuzcqbtvVa2GJUvAgh8krRaGD9fNk9qhA0RF3b194P58QgjxqKqUX2eaNm1Kz549GT16NEePHuXQoUNERkYycOBAw4jgq1ev0qRJE0MP9Ny5c8yYMYOkpCQuXLjAtm3bGDZsGB06dKB58+YA9OjRg2bNmjF06FB++ukndu/ezeTJk4mIiDDZI7W47GyIiND9/cYb8NdxWEpcnG5CcUdHiI+vHPfgCSGEuVXKwAq60b1NmjSha9eu9O7dm3bt2rF06VLD8xqNhjNnzhguOFepUoW9e/fSo0cPmjRpwvjx4+nbty9fffWVYRu1Ws327dtRq9UEBgYyZMgQhg0bZnTfq1WZMQMuXID69eEB95+Vt1On4O23dX/PmwcPucKUEEJUelZ1KrgsXF1dS5wMwsfHxzCsGsDb25sD+rXLStCgQQN2WnBEbamdPAlz5+r+XrCgbMtpmJlGA8OGQV4e9OoFo0ZZrCpCCGFxlbbH+ljTanXrrBYUwAsvQJ8+Fq3Of/4DP/wANWvCJ59U+NTEQggzW7NmDUFBQTg5OeHo6EhgYCCrV682yhMbG4tKpcLLy8vk/bJt27ZFpVIZDUiNj483mlLWycmJJk2a8PLLLxcZOFqZSWCtjFauhEOHdL3Ujz6yaFWOH4d339X9/fHHUMKkV0KISuC1115j6NChNGvWjA0bNrBp0yaeeuopwsPDee2114zy2tnZcfPmTQ4ePGiUfvHiRQ4fPoyjo6PJfezatYvDhw/z5Zdf8vrrr/PLL7/Qpk2bB95uWVlU2lPBj6W9e3WDlfST7E6fDt7eFqtOTo7uFHBhIbz0EgwcaLGqCPHo2LsXxo3TfWnu1q1Cd71t2zYWLlxITEyM0bzBwcHBeHp6Mn36dHr06EFoaCigG7vSrVs31q1bR6d7hv+vX78ePz8/kzMYAbRq1YratWsD0KVLF1599VXCw8OZNGkSbdu2pV27duV2jBVBeqyVhaLoRgf9v/+nu2e1RQvdh8+CJk+G06fBwwMWLbJoVYR4NOg/56dP636bWnuxHMXFxVGzZk0mTJhQ5Lk333yTmjVrEhcXZ5QeFhbGxo0bjab8W7t2LYPKMFGNjY0N8+fPx97eno8//vjhD8BKSGCtLPbsgWPH7j4eMQJsLXfC4cAB+PBD3d/Ll0NFTDAlRKWgKJCV9XA/27bd/ZwfO6Z7/LBllTEoFxQU8N1339G5c2eTp3AdHR3p3Lkz3333ndGUf6GhoeTl5bFnzx4Afv31V37++WcGlvEUlqurK61ateLw4cNl2s4ayangykBR4J137j5WqWDNGl2P1QIjhTIzdRNBKIpuBHDv3hVeBSGsV3a27mZuc3jhhTJvYoNulm5tRgaUYSHxmzdvkpeXR/369YvNU79+fXJzc7l165YhrVq1ajz//POsX7+ekJAQ1q1bR2BgIA0f4p47b29vkpKSyrydtZEea2WwZw/c+2ZTFN232b++IVa06Gjd7bM+Prp7VoUQj7ewsDC+/PJLcnJyWL9+PWFhYQ9VjqIoj8T8xtJjtXaKAlOm6KYxKiy8m65W69J79KjQXuuOHXdvqYmPL9MXYiEeD9Wq6eb1LAtFgY4d4aefin7OW7TQXXsp5edcq9WSkZFBjTKurFW7dm3s7e25dOlSsXkuXbqEg4NDkcVFgoODsbOzY+rUqZw/f54BAwaUad96V65cKdN879ZKAqu1u//aql5h4d1ea3BwhVTl1q27kz9ERen+Dwgh7qNSlX3Clt27dTeD36+wUJd+6FDpP+darW67Mn7htrW1JSgoiP3795OVlUX1+44hKyuL/fv3ExQUhO194zvs7Ozo27cv8+bNo2vXrkWW3yyNW7ducfz4cfr161fmba2NnAq2ZvreanET69vY6J6voJGDERGQkgJNm+omhRBCmIEVfc6joqJIS0vjgw8+KPLcBx98QFpaGlFRUSa3HTVqFKGhobz++utl3q9WqyUqKor8/Hwi9POfV2LSY7Vm+flw6VLxy8FotXD5si5fOS8SsH49fP657szUp59C1arlujshHh9W9Dnv06cPkZGRxMbGcvnyZfr37w/Apk2bWLZsGZGRkYZ7WO/37LPPsnXr1lLtJykpCWdnZ3Jycjhz5gwrVqwgKSmJ9957j8DAQLMdj6VIYLVm9va60703bhSfx9293D9sf/wBY8fq/p48GVq3LtfdCfF4sZLPud6CBQto06YNixYtYt26dQD4+/uzatUqhg4dapZ99OzZE4Dq1avj5eVF27ZtWbRoEc8884xZyrc0CazWztvborMr6W+p+fNPaNXK+K4fIYSZWPhzfr/BgwczePDgEvPExsYazc5kin7Na73hw4cbzR38qJJrrKJEn3wCX3+t+7L86adgZ2fpGgkhhHWTwCqK9fvvuntWQTdYqVkzy9ZHCCEqAwmswqTCQt3sSnfuQPv2uttrhBBCPJgEVmFSXBx8+61uZrb4eN1oYCGEEA8mgVUUcerU3UFK8+aBr69l6yOEEJWJBFZhRKPRrbGalwe9et2daUkIIUTpyO02gsJC3Wnfa9fuzqxWs+bdOYGFEEKUngTWx9zmzfD663DlinH68OHg6WmRKgkhRKUmp4IfY5s3Q79+RYMq6AYvbd5c8XUSQojKTgLrY6qwUNdTLWle76go4xWshBBCPJgE1sfUt9+a7qnqKYpu3u9vv624OgkhrMOaNWsICgrCyckJR0dHAgMDWb169UOVFRcXx86dO4uk+/j4EBkZ+XerWmrx8fGoVCpu3rxZ7vuqtIE1LS2NwYMHU6NGDVxcXBg5ciR3Slhc+MKFC6hUKpM/GzZsMOQz9fz69esr4pAqVAlrGRu5dq186yGEsC6vvfYaQ4cOpVmzZmzYsIFNmzbx1FNPER4ezmuvvVbm8ooLrFu2bGHChAnmqLLVqbSDlwYPHsy1a9dISEhAo9EwYsQIXnnlFdauXWsyv7e3N9fuixJLly7l/fffp1evXkbpK1euNKy+AODi4mL+A7Cgb7/VrVJTGnXrlm9dhBDWY9u2bSxcuJCYmBijCfaDg4Px9PRk+vTp9OjRo9il48ri6aef/ttlWKtKGVhPnz7Nrl27OHbsGK3/WsNswYIF9O7dm7lz5+JpYjirWq3Gw8PDKG3Lli0MGDAAR0dHo3QXF5cieUuSl5dHXl6e4XFGRgYAGo0GjUZT6nLK259/wqRJalas0J2osLFR/loCsug9NSqVgpcXtGlTgLkPQd8m1tQ21kTap2TW1D4ajQZFUdBqtWiLW0+1gil/DZzQ16ss4uLiqFmzJtHR0UW2HT9+PAsWLCAuLo6QkBBGjBhBUlISc+bM4a233iI5ORk/Pz/DsnMAvr6+XLx4kUWLFrFo0SIAli9fzvDhw/H19SUkJIQFCxYAGMqbN28eEyZM4OzZszz77LOsXLmSGjVqMGbMGHbv3o2bmxvvvvsuL730kqFuO3bsYP78+fz888/k5ubStGlTYmJijDpI+uMprn20Wi2KoqDRaFCbmGquLO+3ShlYDx8+jIuLiyGoAnTr1g0bGxu+//57XnzxxQeWkZSUxIkTJwwv9r0iIiIYNWoUvr6+/Otf/2LEiBGoSrihc9asWUybNq1I+r59+6hWrVopj6r8KAr8739eLF/+FLdv65an6dHjAk2b3mL+/H8ACsbBVUFRYPDgY+zeXX7nghMSEsqt7EeBtE/JrKF9bG1t8fDw4M6dO+Tn5xs9l5WVVex2arUaBweHUuW1sbGhatWqZc6bmZn5wPrfq6CggO+++44ePXqg1WoNHYR7tWvXjoSEBNLS0tBoNPzxxx+MHTuWiRMn4uzsTFxcHD179iQpKQk3Nzc+/fRTBgwYQJs2bYiIiACgYcOGZGRkoNVqyc/PN+qIXLt2jejoaKKjo7Gzs2PixImEhYVRrVo1goKCGDRoEJ9++inDhg3Dz8+P+vXrA7rOVvfu3RkzZgw2Njbs3buX5557jm3bttGuXTsAcnNzAbhz5w729vZF2ic/P5+cnBwOHjxIQUFBkWPPzs4udVtWysCakpKCu7u7UZqtrS2urq6kpKSUqozly5fTtGlTgoKCjNKnT59Oly5dqFatGnv27GHs2LHcuXOHcePGFVvWpEmTiNYvA4Oux+rt7U3nzp2pVatWGY7M/C5cgHHj1OzapeulNmmisHhxIW3begFeBAUVEh2t5urVu9vUqwcffFDIiy8+DZj/dI1GoyEhIYHu3btjJ+vQFSHtUzJrap/c3FwuX76Mo6OjUaAEqFmzZrHb9erVi+3btxsee3l5FfuPu2PHjiQmJhoeP/nkk8UOwGndujVHjhwhMzMTJyenEjsE90tJSSEvLw9fX19q1KhhMo+vry+5ubloNBrs7Oz4888/+eKLL+jSpYvhuBo0aMDy5cuZOXMm7dq1w8HBAS8vL7p27WpUlo2NDVWqVDHsS1/e/v378fPzA+D27duMGzeOf//738yYMcPQHu7u7iQmJhr+L997rVar1RISEsLZs2dZs2YNvXv3BjC8PvozlPe3T25uLlWrVqVDhw5FXkvA5BeN4lhVYJ04cSJz5swpMc/p06f/9n5ycnJYu3YtU6ZMKfLcvWlPP/00WVlZvP/++yUGVnt7e+zt7Yuk29nZWeyDX1AA8+fD1KmQnQ1Vquiuq/773yrs7e++7AMGQN++d2deqlsX2rdXoVaX/1vDku1TGUj7lMwa2qewsBCVSoWNjQ02NqUfC6rfprTKWvbf2UdJ2+nLtrGxQaVS4ezsTLdu3QzP16xZk27dunH06FGjMoor8950lUqFp6cn/v7+hucbN24MQPfu3Q35XF1dcXd358qVK4a0K1eu8M4777B3716uXbtmON3bqlUrQ55792OqTvpjKu59VZb3mlUF1vHjxz9wdXlfX188PDxITU01Si8oKCAtLa1U10Y3btxIdnY2w4YNe2DegIAAZsyYQV5ensngaY2SkmD0aPjxR93jjh1hyRL46z1ahFoNnTpVWPWEeCyUdJfC/dfw7v9/dq/7A9KFCxdKnbcsateujb29PZdKuGXg0qVLODg4GM7Eubm5FclTp06dh+4A3T9QtEqVKsWm60/tarVa+vTpQ3p6OtOnT+eJJ56gevXqTJ06tcRjKU9WFVjd3NxMvlD3CwwM5Pbt2yQlJdGqVSsAEhMT0Wq1BAQEPHD75cuX06dPn1Lt68SJE9SsWbNSBNU7d2DKFPjoI9BqdfP9zp0LI0bInL9CVLTq1atbJO/DDqKytbUlKCiI/fv3k5WVVWQ/WVlZ7N+/n6CgIGxtdaHjxo0bRcq5fv06dSvwdoLk5GR+/PFHtm7dyvPPP29Iz8nJqbA63K9S3sfatGlTevbsyejRozl69CiHDh0iMjKSgQMHGkYEX716lSZNmnD06FGjbZOTkzl48CCjTCzb8tVXX/HJJ59w8uRJkpOTWbx4MTNnznyoe7cq2vbt4Oenm4pQq4VBg+C33+DllyWoCiFKJyoqirS0ND744IMiz33wwQekpaURFRVlSEtPTze6/puens7evXuNOjj39i7Lgz6A6nu3ABcvXuTQoUPlts8Hsaoea1msWbOGyMhIunbtio2NDX379uWjjz4yPK/RaDhz5kyRAQErVqygXr169OjRo0iZdnZ2LFq0iDfeeANFUXjiiSeYN28eo0ePLvfjeZB7V6DRXQfVncK9dk03NaF+jgsfH1i8GO4ZZS6EEKXSp08fIiMjiY2N5fLly/Tv3x+ATZs2sWzZMiIjI43uYXV1dWXkyJFMmzYNFxcXZs+ejaIoRsG3adOmJCYmkpCQQM2aNWnYsKFZB3U2adKEevXqMXHiRAoLC7lz5w4xMTF4eXmZbR9lVWkDq6ura7GTQYBuuizFxES4M2fOZObMmSa36dmzp9F9T9bC1Ao09epBSAisXw/p6bogGx0NMTFQhrNKQghhRH8f6qJFi1i3bh0A/v7+rFq1iqFDhxrlrVu3LnPmzOHNN9/k3Llz+Pn5sXv3burUqWPIM3PmTMaMGUPfvn3JzMxk5cqVDxxLUxb29vZs3ryZiIgI+vfvj7e3N5MnTyYxMZHjx4+bbT9loVJMRR/xt2RkZODs7MzNmzf/9jcz/Qo0Jb1KrVvDsmXQsuXf2lWF0Wg07Ny5k969e1t8VKc1kvYpmTW1T25uLufPn6dhw4Ymb9GwBP09qDVq1Phbg5keZPjw4Rw/fpyTJ0+W2z7KQ3Ht86DXUv9/PT09vdjbkfQqbY/1cVCaFWhcXODQId3tNEIIISyvUg5eelw8aAUagNu34bvvKqY+QgghHkx6rFastCvLyAo0QoiKFh8fb+kqWC3psVqx0t4KJivQCCGE9ZDAasXat9eN/i3uPlSVCry9dfmEEJYjY0ArP3O+hhJYrZharZvvF4oGV/3juDhdPiFExdOPSi7JEbUyAAAS7ElEQVTLyifCOulfQ3OMNJdrrFbun/+EjRtN38caF6d7XghhGWq1GhcXF8Ncv9WqVSvTijLlQb8cW25ubrneblNZ3d8+iqKQnZ1NamoqLi4uJtdiLSsJrJXAP/8Jzz9veuYlIYRl6Rf+KGki/YqkKAo5OTlUrVrV4kHeGhXXPi4uLqVaxKU0JLBWErICjRDWSaVSUbduXdzd3dFoNJauDhqNhoMHD9KhQweLT6BhjUy1j52dnVl6qnoSWIUQwgzUarVZ/zn/nXoUFBTg4OAggdWEimgfOQEvhBBCmJEEViGEEMKMJLAKIYQQZiSBVQghhDAjGbxUDvQzeGRmZsrgARM0Gg3Z2dlkZGRI+5gg7VMyaZ+SSfuU7GHbJyMjAyjdDE0SWMvBrVu3AGjYsKGFayKEEMKcMjMzcXZ2LjGPBNZy4OrqCsClS5ce+AI8jjIyMvD29uby5csPXDD4cSTtUzJpn5JJ+5TsYdtHURQyMzPx9PR8YF4JrOVAP42Ys7OzvLFLUKNGDWmfEkj7lEzap2TSPiV7mPYpbUdJBi8JIYQQZiSBVQghhDAjdWxsbKylK/EoUqvVdOrUCVtbOdtuirRPyaR9SibtUzJpn5KVd/uoFFmhVwghhDAbORUshBBCmJEEViGEEMKMJLAKIYQQZiSBVQghhDAjCaxmtmjRInx8fHBwcCAgIICjR49aukpW4+DBg4SGhuLp6YlKpWLr1q2WrpLVmDVrFs888wxOTk64u7vzwgsvcObMGUtXy2osXryY5s2bG27qDwwM5Ouvv7Z0tazW7NmzUalUREVFWboqViE2NhaVSmX006RJk3LbnwRWM/r888+Jjo4mJiaGH374gRYtWhAcHExqaqqlq2YVsrKyaNGiBYsWLbJ0VazOgQMHiIiI4MiRIyQkJKDRaOjRowdZWVmWrppVqFevHrNnzyYpKYnjx4/TpUsXnn/+eU6dOmXpqlmdY8eOsWTJEpo3b27pqlgVPz8/rl27Zvj53//+V347U4TZPPvss0pERIThcWFhoeLp6anMmjXLgrWyToCyZcsWS1fDaqWmpiqAcuDAAUtXxWrVrFlT+eSTTyxdDauSmZmpPPnkk0pCQoLSsWNH5fXXX7d0laxCTEyM0qJFiwrbn/RYzSQ/P5+kpCS6detmSLOxsaFbt24cPnzYgjUTlVF6ejpwd0EHcVdhYSHr168nKyuLwMBAS1fHqkRERBASEmL0f0jonD17Fk9PT3x9fRk8eDCXLl0qt33JtBxmcvPmTQoLC6lTp45Rep06dfjtt98sVCtRGWm1WqKiomjbti1PPfWUpatjNX755RcCAwPJzc3F0dGRLVu20KxZM0tXy2qsX7+eH374gWPHjlm6KlYnICCA+Ph4GjduzLVr15g2bRrt27fn5MmTODk5mX1/EliFsDIRERGcPHmyfK8BVUKNGzfmxIkTpKens3HjRsLDwzlw4IAEV+Dy5cu8/vrrJCQk4ODgYOnqWJ1evXoZ/m7evDkBAQE0aNCAL774gpEjR5p9fxJYzaR27dqo1WquX79ulH79+nU8PDwsVCtR2URGRrJ9+3YOHjxIvXr1LF0dq1KlShWeeOIJAFq1asWxY8eYP38+S5YssXDNLC8pKYnU1FT+8Y9/GNIKCws5ePAgCxcuJC8vD7VabcEaWhcXFxf+7//+j+Tk5HIpX66xmkmVKlVo1aoV33zzjSFNq9XyzTffyHUg8UCKohAZGcmWLVtITEykYcOGlq6S1dNqteTl5Vm6Glaha9eu/PLLL5w4ccLw07p1awYPHsyJEyckqN7nzp07nDt3jrp165ZL+dJjNaPo6GjCw8Np3bo1zz77LHFxcWRlZTFixAhLV80q3Llzx+gb4vnz5zlx4gSurq7Ur1/fgjWzvIiICNauXcuXX36Jk5MTKSkpgG5h5apVq1q4dpY3adIkevXqRf369cnMzGTt2rXs37+f3bt3W7pqVsHJyanI9fjq1atTq1YtuU4PTJgwgdDQUBo0aMAff/xBTEwMarWasLCwctmfBFYzeumll7hx4wZTp04lJSWFli1bsmvXriIDmh5Xx48fp3PnzobH0dHRAISHhxMfH2+hWlmHxYsXA9CpUyej9JUrVzJ8+PCKr5CVSU1NZdiwYVy7dg1nZ2eaN2/O7t276d69u6WrJiqBK1euEBYWxq1bt3Bzc6Ndu3YcOXIENze3ctmfLBsnhBBCmJFcYxVCCCHMSAKrEEIIYUYSWIUQQggzksAqhBBCmJEEViGEEMKMJLAKIYQQZiSBVQghhDAjCaxCCCGEGUlgFeJvUqlUxMbGlnm7CxcuoFKpHvtZp4R41EhgFY+E+Ph4VCoVKpXK5HJriqLg7e2NSqXiueees0ANH97+/fsNx6ZSqbCzs8PX15dhw4bx+++/W7p65erXX38lNjaWCxcuVNg+9e8lBwcHrl69WuT5Tp06yfy7okQSWMUjxcHBgbVr1xZJP3DgAFeuXMHe3t4CtTKPcePGsXr1apYuXUpISAiff/45zzzzDH/88Yelq1Zufv31V6ZNm1ahgVUvLy+P2bNnV/h+ReUngVU8Unr37s2GDRsoKCgwSl+7di2tWrWq1Gvjtm/fniFDhjBixAgWLFjA3LlzSUtLY9WqVX+rXEVRyMnJMVMtK4esrKwH5mnZsiXLli0r1y8uj2PbPw4ksIpHin4Fi4SEBENafn4+GzduZNCgQSa3ycrKYvz48Xh7e2Nvb0/jxo2ZO3cu969PkZeXxxtvvIGbmxtOTk706dOHK1eumCzz6tWrvPzyy9SpUwd7e3v8/PxYsWKF+Q4U6NKlC6Bbfg90K+F06dIFd3d37O3tadasmWHVnHv5+Pjw3HPPsXv3blq3bk3VqlUNi4WXtYz9+/cbyvD392f//v0AbN68GX9/fxwcHGjVqhU//vhjkTJ+++03+vXrh6urKw4ODrRu3Zpt27YZno+Pj6d///4AdO7c2XAqXL8PgK+//pr27dtTvXp1nJycCAkJ4dSpU0b7GT58OI6Ojpw7d47evXvj5OTE4MGDH9i+b7/9NoWFhaXqtRYUFDBjxgwaNWqEvb09Pj4+vP3220XWiy2u7fWn+7/44gumTZuGl5cXTk5O9OvXj/T0dPLy8oiKisLd3R1HR0dGjBgha9FaMVk2TjxSfHx8CAwMZN26dfTq1QvQ/fNNT09n4MCBfPTRR0b5FUWhT58+7Nu3j5EjR9KyZUt2797Nm2++ydWrV/nwww8NeUeNGsVnn33GoEGDCAoKIjExkZCQkCJ1uH79Om3atEGlUhEZGYmbmxtff/01I0eOJCMjg6ioKLMc67lz5wCoVasWoFt6zs/Pjz59+mBra8tXX33F2LFj0Wq1REREGG175swZwsLCePXVVxk9ejSNGzcucxnJyckMGjSIV199lSFDhjB37lxCQ0P573//y9tvv83YsWMBmDVrFgMGDODMmTPY2Oi+y586dYq2bdvi5eXFxIkTqV69Ol988QUvvPACmzZt4sUXX6RDhw6MGzeOjz76iLfffpumTZsCGH6vXr2a8PBwgoODmTNnDtnZ2SxevJh27drx448/4uPjY6hrQUEBwcHBtGvXjrlz51KtWrUHtm/Dhg0ZNmwYy5YtY+LEiXh6ehabd9SoUaxatYp+/foxfvx4vv/+e2bNmsXp06fZsmVLqdpe31ZVq1Zl4sSJJCcns2DBAuzs7LCxseHPP/8kNjaWI0eOEB8fT8OGDZk6deoDj0NYgCLEI2DlypUKoBw7dkxZuHCh4uTkpGRnZyuKoij9+/dXOnfurCiKojRo0EAJCQkxbLd161YFUN59912j8vr166eoVColOTlZURRFOXHihAIoY8eONco3aNAgBVBiYmIMaSNHjlTq1q2r3Lx50yjvwIEDFWdnZ0O9zp8/rwDKypUrSzy2ffv2KYCyYsUK5caNG8off/yh7NixQ/Hx8VFUKpVy7NgxRVEUQ7n3Cg4OVnx9fY3SGjRooADKrl27iuQvaxnfffedIW337t0KoFStWlW5ePGiIX3JkiUKoOzbt8+Q1rVrV8Xf31/Jzc01pGm1WiUoKEh58sknDWkbNmwosq2iKEpmZqbi4uKijB492ig9JSVFcXZ2NkoPDw9XAGXixIlFjs2Ue99L586dU2xtbZVx48YZnu/YsaPi5+dneKx/b4waNcqonAkTJiiAkpiYaEgrru31r/FTTz2l5OfnG9LDwsIUlUql9OrVyyh/YGCg0qBBg1Idj6h4cipYPHIGDBhATk4O27dvJzMzk+3btxd7Gnjnzp2o1WrGjRtnlD5+/HgUReHrr7825AOK5Lu/96koCps2bSI0NBRFUbh586bhJzg4mPT0dH744YeHOq6XX34ZNzc3PD09CQkJISsri1WrVtG6dWsAqlatasibnp7OzZs36dixI7///jvp6elGZTVs2JDg4OAi+yhLGc2aNSMwMNDwOCAgANCdoq5fv36RdP0I5rS0NBITExkwYACZmZmG9rl16xbBwcGcPXvW5GjceyUkJHD79m3CwsKM2litVhMQEMC+ffuKbDNmzJgSyzTF19eXoUOHsnTpUq5du2Yyj/69ER0dbZQ+fvx4AHbs2GGUXlzbAwwbNgw7OzvD44CAABRF4eWXXzbKFxAQwOXLl4uMJRDWQU4Fi0eOm5sb3bp1Y+3atWRnZ1NYWEi/fv1M5r148SKenp44OTkZpetPN168eNHw28bGhkaNGhnlu/c0HsCNGze4ffs2S5cuZenSpSb3mZqa+lDHNXXqVNq3b49araZ27do0bdoUW9u7H+FDhw4RExPD4cOHyc7ONto2PT0dZ2dnw+OGDRua3EdZyrg3eAKG57y9vU2m//nnn4DuFLKiKEyZMoUpU6aYrEdqaipeXl4mnwM4e/YscPc68/1q1Khh9NjW1pZ69eoVW15JJk+ezOrVq5k9ezbz588v8rz+vfHEE08YpXt4eODi4mJ4D+kV1/ZQtjbVarWkp6cbLgUI6yGBVTySBg0axOjRo0lJSaFXr164uLhUyH61Wi0AQ4YMITw83GSe5s2bP1TZ/v7+dOvWzeRz586do2vXrjRp0oR58+bh7e1NlSpV2LlzJx9++KGhXnr39kwftgy1Wm2yLsWlK38NBtOXM2HChGJ7bvcHqfvpy1i9erXJkd73fuEAsLe3N1zfLStfX1+GDBnC0qVLmThxYrH5VCpVqcoz1fZ6D9umwrpIYBWPpBdffJFXX32VI0eO8Pnnnxebr0GDBuzdu5fMzEyjXutvv/1meF7/W6vVcu7cOaNe6pkzZ4zK048YLiwsLDYIloevvvqKvLw8tm3bZtTrMXVKtDzLKA1fX18A7OzsHthGxQUr/ZkDd3f3CmnnyZMn89lnnzFnzpwiz+nfG2fPnjWc6QDdILbbt28b3kPi8SHXWMUjydHRkcWLFxMbG0toaGix+Xr37k1hYSELFy40Sv/www9RqVSGkcX63/ePKo6LizN6rFar6du3L5s2beLkyZNF9nfjxo2HOp4H0fdo7u3BpKens3LlygotozTc3d3p1KkTS5YsMXnd8t42ql69OgC3b982yhMcHEyNGjWYOXMmGo2mxDLMoVGjRgwZMoQlS5aQkpJi9Fzv3r2Bou+FefPmAZgcOS4ebdJjFY+s4k7F3is0NJTOnTvzzjvvcOHCBVq0aMGePXv48ssviYqKMvSMWrZsSVhYGB9//DHp6ekEBQXxzTffkJycXKTM2bNns2/fPgICAhg9ejTNmjUjLS2NH374gb1795KWlmb2Y+3RowdVqlQhNDSUV199lTt37rBs2TLc3d2LHXRTHmWU1qJFi2jXrh3+/v6MHj0aX19frl+/zuHDh7ly5Qo//fQToGt3tVrNnDlzSE9Px97e3nCf7eLFixk6dCj/+Mc/GDhwIG5ubly6dIkdO3bQtm3bIl+W/q533nmH1atXc+bMGfz8/AzpLVq0IDw8nKVLl3L79m06duzI0aNHWbVqFS+88AKdO3c2az2E9ZPAKh5rNjY2bNu2jalTp/L555+zcuVKfHx8eP/99w2jOvVWrFiBm5sba9asYevWrXTp0oUdO3YUGVhSp04djh49yvTp09m8eTMff/wxtWrVws/Pz+SpRHNo3LgxGzduZPLkyUyYMAEPDw/GjBmDm5tbkRGl5VlGaTVr1ozjx48zbdo04uPjuXXrFu7u7jz99NNG92Z6eHjw3//+l1mzZjFy5EgKCwvZt28f7u7uDBo0CE9PT2bPns37779PXl4eXl5etG/fnhEjRpi1vqC77jtkyBCTM1198skn+Pr6Eh8fz5YtW/Dw8GDSpEnExMSYvR7C+qkUufothBBCmI1cYxVCCCHMSAKrEEIIYUYSWIUQQggzksAqhBBCmJEEViGEEMKMJLAKIYQQZiSBVQghhDAjCaxCCCGEGUlgFUIIIcxIAqsQQghhRhJYhRBCCDOSwCqEEEKY0f8H72hkLUAIhA0AAAAASUVORK5CYII=\n",
            "text/plain": [
              "<Figure size 480x360 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Z847v6f8S6tb"
      },
      "source": [
        "## Comparing $Q^*$ approximations errors and error bounds\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Pa1vbjq7wKX0",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "299856e4-62b6-4567-d275-7bc3b40e5c02"
      },
      "source": [
        "start = time.time()\n",
        "norm_bound_list = np.linspace(0, 6, 20)\n",
        "num_seeds = 10\n",
        "headers = [\"Seed\", \"Q\", \"Policy\", \"p_\\\\theta\", \"r_\\\\theta\", \"J\", \"\\|Q-B^true Q\\|^2\", \"Q-B^\\\\theta Q\", \"grad\\|Q-B^\\\\theta Q\\|^2\"]\n",
        "all_errors_pr = []\n",
        "all_bounds_pr = []\n",
        "all_q_mle_approx = []\n",
        "all_bounds_mle_gap = []\n",
        "\n",
        "for i, norm_bound in enumerate(norm_bound_list):\n",
        "  results = []\n",
        "  for j, seed in enumerate(range(1, num_seeds+1)):\n",
        "    kwargs['seed'] = seed\n",
        "    kwargs['norm_bound'] = norm_bound\n",
        "    kwargs['optimizer'] = padam\n",
        "    kwargs['lr_func'] = 0.01\n",
        "    kwargs['agent_type'] = 'mle'\n",
        "    \n",
        "    rngs = jax.random.split(jax.random.PRNGKey(seed), 3)\n",
        "    initial_values = (\n",
        "      jax.random.uniform(rngs[0], true_reward.shape),\n",
        "      (jax.random.uniform(rngs[1], true_transition.shape), \n",
        "      jax.random.uniform(rngs[2], true_reward.shape))\n",
        "    )\n",
        "\n",
        "    solution = implicit_ecp(objective_bellman, equality_constraints, initial_values, **kwargs)\n",
        "    # solution = implicit_ecp(objective_returns, equality_constraints, initial_values, **kwargs)\n",
        "\n",
        "    results.append([\n",
        "      seed,\n",
        "      solution[0], \n",
        "      softmax((1. / temperature) * solution[0]), \n",
        "      softmax((1. / temperature) * solution[1][0]), \n",
        "      solution[1][1], \n",
        "      objective_returns(*solution),\n",
        "      objective_bellman(*solution),\n",
        "      equality_constraints(*solution),\n",
        "      grad_constraints(*solution)\n",
        "    ])\n",
        "    \n",
        "  print('Done {}/{} norm_bounds'.format(i+1, len(norm_bound_list)))\n",
        "  errors_pr = list(map(lambda x: [jnp.max(jnp.sum(jnp.abs(x[3] - true_transition), axis=-1)).item(),\n",
        "                                  jnp.max(jnp.abs(x[4] - true_reward)).item()], results))\n",
        "  errors_pr_means = np.mean(errors_pr, 0)\n",
        "  errors_pr_stderrs = np.std(errors_pr, 0) / np.sqrt(len(errors_pr))\n",
        "  all_errors_pr.append([errors_pr_means, errors_pr_stderrs])\n",
        "  \n",
        "  bounds_pr = list(map(lambda x: [jnp.max(jnp.abs(x[4] - true_reward)).item() / (\n",
        "      1 - true_discount) + true_discount * jnp.max(jnp.abs(true_reward)) * jnp.max(\n",
        "          jnp.sum(jnp.abs(x[3] - true_transition), axis=-1)).item() / (2 * (1 - true_discount) ** 2)], results))\n",
        "  bounds_pr_means = np.mean(bounds_pr, 0)\n",
        "  bounds_pr_stderrs = np.std(bounds_pr, 0) / np.sqrt(len(bounds_pr))\n",
        "  all_bounds_pr.append([bounds_pr_means, bounds_pr_stderrs])\n",
        "  \n",
        "  q_mle_approx = list(map(lambda x: [jnp.max(jnp.abs(Q_opt - x[1])).item()], results))\n",
        "  q_mle_approx_means = np.mean(q_mle_approx, 0)\n",
        "  q_mle_approx_stderrs = np.std(q_mle_approx, 0) / np.sqrt(len(q_mle_approx))\n",
        "  all_q_mle_approx.append([q_mle_approx_means, q_mle_approx_stderrs])\n",
        "\n",
        "  bounds_mle_gap = list(map(lambda x: [x[0][0] - x[1][0]], zip(bounds_pr, q_mle_approx)))\n",
        "  bounds_mle_gap_means = np.mean(bounds_mle_gap, 0)\n",
        "  bounds_mle_gap_stderrs = np.std(bounds_mle_gap, 0) / np.sqrt(len(bounds_mle_gap))\n",
        "  all_bounds_mle_gap.append([bounds_mle_gap_means, bounds_mle_gap_stderrs])\n",
        "\n",
        "print('Done in {:.2f} minutes'.format((time.time() - start) / 60))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Done 1/20 norm_bounds\n",
            "Done 2/20 norm_bounds\n",
            "Done 3/20 norm_bounds\n",
            "Done 4/20 norm_bounds\n",
            "Done 5/20 norm_bounds\n",
            "Done 6/20 norm_bounds\n",
            "Done 7/20 norm_bounds\n",
            "Done 8/20 norm_bounds\n",
            "Done 9/20 norm_bounds\n",
            "Done 10/20 norm_bounds\n",
            "Done 11/20 norm_bounds\n",
            "Done 12/20 norm_bounds\n",
            "Done 13/20 norm_bounds\n",
            "Done 14/20 norm_bounds\n",
            "Done 15/20 norm_bounds\n",
            "Done 16/20 norm_bounds\n",
            "Done 17/20 norm_bounds\n",
            "Done 18/20 norm_bounds\n",
            "Done 19/20 norm_bounds\n",
            "Done 20/20 norm_bounds\n",
            "Done in 2.84 minutes\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "EvFlrAllwKYG",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "57e6a172-578e-49ed-f350-2a7b2868b922"
      },
      "source": [
        "start = time.time()\n",
        "norm_bound_list = np.linspace(0, 6, 20)\n",
        "num_seeds = 10\n",
        "headers = [\"Seed\", \"Q\", \"Policy\", \"p_\\\\theta\", \"r_\\\\theta\", \"J\", \"\\|Q-B^true Q\\|^2\", \"Q-B^\\\\theta Q\", \"grad\\|Q-B^\\\\theta Q\\|^2\"]\n",
        "all_errors = []\n",
        "all_q_omd_approx = []\n",
        "all_bounds = []\n",
        "all_bounds_omd_gap = []\n",
        "\n",
        "for i, norm_bound in enumerate(norm_bound_list):\n",
        "  results = []\n",
        "  for j, seed in enumerate(range(1, num_seeds+1)):\n",
        "    kwargs['seed'] = seed\n",
        "    kwargs['norm_bound'] = norm_bound\n",
        "    kwargs['optimizer'] = padam\n",
        "    kwargs['lr_func'] = 0.01\n",
        "    kwargs['agent_type'] = 'omd'\n",
        "    \n",
        "    rngs = jax.random.split(jax.random.PRNGKey(seed), 3)\n",
        "    initial_values = (\n",
        "      jax.random.uniform(rngs[0], true_reward.shape),\n",
        "      (jax.random.uniform(rngs[1], true_transition.shape), \n",
        "      jax.random.uniform(rngs[2], true_reward.shape))\n",
        "    )\n",
        "\n",
        "    solution = implicit_ecp(objective_bellman, equality_constraints, initial_values, **kwargs)\n",
        "    # solution = implicit_ecp(objective_returns, equality_constraints, initial_values, **kwargs)\n",
        "    \n",
        "    results.append([\n",
        "      seed,\n",
        "      solution[0], \n",
        "      softmax((1. / temperature) * solution[0]), \n",
        "      softmax((1. / temperature) * solution[1][0]), \n",
        "      solution[1][1], \n",
        "      objective_returns(*solution),\n",
        "      objective_bellman(*solution),\n",
        "      equality_constraints(*solution),\n",
        "      grad_constraints(*solution)\n",
        "    ])\n",
        "    \n",
        "  print('Done {}/{} bounds'.format(i+1, len(norm_bound_list)))\n",
        "  errors = list(map(lambda x: [jnp.max(jnp.abs(smooth_bellman_optimality_operator(x[1], (\n",
        "      true_transition, true_reward, true_discount, temperature)) - smooth_bellman_optimality_operator(\n",
        "          x[1], (x[3], x[4], true_discount, temperature)))).item()], results))\n",
        "  errors_means = np.mean(errors, 0)\n",
        "  errors_stderrs = np.std(errors, 0) / np.sqrt(len(errors))\n",
        "  all_errors.append([errors_means, errors_stderrs])\n",
        "  \n",
        "  bounds = list(map(lambda x: [jnp.max(jnp.abs(smooth_bellman_optimality_operator(x[1], (\n",
        "      true_transition, true_reward, true_discount, temperature)) - smooth_bellman_optimality_operator(\n",
        "          x[1], (x[3], x[4], true_discount, temperature)))).item() / (1 - true_discount)], results))\n",
        "  bounds_means = np.mean(bounds, 0)\n",
        "  bounds_stderrs = np.std(bounds, 0) / np.sqrt(len(bounds))\n",
        "  all_bounds.append([bounds_means, bounds_stderrs])\n",
        "  \n",
        "  q_omd_approx = list(map(lambda x: [jnp.max(jnp.abs(Q_opt - x[1])).item()], results))\n",
        "  q_omd_approx_means = np.mean(q_omd_approx, 0)\n",
        "  q_omd_approx_stderrs = np.std(q_omd_approx, 0) / np.sqrt(len(q_omd_approx))\n",
        "  all_q_omd_approx.append([q_omd_approx_means, q_omd_approx_stderrs])\n",
        "\n",
        "  bounds_omd_gap = list(map(lambda x: [x[0][0] - x[1][0]], zip(bounds, q_omd_approx)))\n",
        "  bounds_omd_gap_means = np.mean(bounds_omd_gap, 0)\n",
        "  bounds_omd_gap_stderrs = np.std(bounds_omd_gap, 0) / np.sqrt(len(bounds_omd_gap))\n",
        "  all_bounds_omd_gap.append([bounds_omd_gap_means, bounds_omd_gap_stderrs])\n",
        "  \n",
        "print('Done in {:.2f} minutes'.format((time.time() - start) / 60))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Done 1/20 bounds\n",
            "Done 2/20 bounds\n",
            "Done 3/20 bounds\n",
            "Done 4/20 bounds\n",
            "Done 5/20 bounds\n",
            "Done 6/20 bounds\n",
            "Done 7/20 bounds\n",
            "Done 8/20 bounds\n",
            "Done 9/20 bounds\n",
            "Done 10/20 bounds\n",
            "Done 11/20 bounds\n",
            "Done 12/20 bounds\n",
            "Done 13/20 bounds\n",
            "Done 14/20 bounds\n",
            "Done 15/20 bounds\n",
            "Done 16/20 bounds\n",
            "Done 17/20 bounds\n",
            "Done 18/20 bounds\n",
            "Done 19/20 bounds\n",
            "Done 20/20 bounds\n",
            "Done in 5.05 minutes\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SYp_8_CFACdb",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 367
        },
        "outputId": "8b1db052-1f57-46e4-9ccc-36f36c23d500"
      },
      "source": [
        "idx = 17\n",
        "plt.figure()\n",
        "\n",
        "all_bounds_omd_gap_means = np.array(list(map(lambda x: x[0][0], all_bounds_omd_gap[:idx])))\n",
        "all_bounds_omd_gap_stderrs = np.array(list(map(lambda x: x[1][0], all_bounds_omd_gap[:idx])))\n",
        "plt.plot(norm_bound_list[:idx], all_bounds_omd_gap_means, 's-', c='r', label=r'$\\frac{\\epsilon}{1-\\gamma} - \\max_{s,a}|Q^*(s,a) - \\hat{Q}_{OMD}(s,a)|$', markersize=6)\n",
        "plt.fill_between(norm_bound_list[:idx], \n",
        "                 all_bounds_omd_gap_means + all_bounds_omd_gap_stderrs,\n",
        "                 all_bounds_omd_gap_means - all_bounds_omd_gap_stderrs, \n",
        "                 color='r', alpha=0.1)\n",
        "\n",
        "all_bounds_mle_gap_means = np.array(list(map(lambda x: x[0][0], all_bounds_mle_gap[:idx])))\n",
        "all_bounds_mle_gap_stderrs = np.array(list(map(lambda x: x[1][0], all_bounds_mle_gap[:idx])))\n",
        "plt.plot(norm_bound_list[:idx], all_bounds_mle_gap_means, 'o-', c='b', label=r'$\\frac{\\epsilon_r}{1-\\gamma} + \\frac{\\gamma \\epsilon_p r_{\\max}}{2(1-\\gamma)^2} - \\max_{s,a}|Q^*(s,a) - \\hat{Q}_{MLE}(s,a)|$', markersize=6)\n",
        "plt.fill_between(norm_bound_list[:idx], \n",
        "                 all_bounds_mle_gap_means + all_bounds_mle_gap_stderrs,\n",
        "                 all_bounds_mle_gap_means - all_bounds_mle_gap_stderrs, \n",
        "                 color='b', alpha=0.1)\n",
        "\n",
        "all_q_omd_approx_means = np.array(list(map(lambda x: x[0][0], all_q_omd_approx[:idx])))\n",
        "all_q_omd_approx_stderrs = np.array(list(map(lambda x: x[1][0], all_q_omd_approx[:idx])))\n",
        "plt.plot(norm_bound_list[:idx], all_q_omd_approx_means, '^-',  c='r', label=r'$\\max_{s,a}|Q^*(s,a) - \\hat{Q}_{OMD}(s,a)|$', markersize=6)\n",
        "plt.fill_between(norm_bound_list[:idx], \n",
        "                 all_q_omd_approx_means + all_q_omd_approx_stderrs,\n",
        "                 all_q_omd_approx_means - all_q_omd_approx_stderrs, \n",
        "                 color='r', alpha=0.1)\n",
        "\n",
        "all_q_mle_approx_means = np.array(list(map(lambda x: x[0][0], all_q_mle_approx[:idx])))\n",
        "all_q_mle_approx_stderrs = np.array(list(map(lambda x: x[1][0], all_q_mle_approx[:idx])))\n",
        "plt.plot(norm_bound_list[:idx], all_q_mle_approx_means, 'v-',  c='b', label=r'$\\max_{s,a}|Q^*(s,a) - \\hat{Q}_{MLE}(s,a)|$', markersize=6)\n",
        "plt.fill_between(norm_bound_list[:idx], \n",
        "                 all_q_mle_approx_means + all_q_mle_approx_stderrs,\n",
        "                 all_q_mle_approx_means - all_q_mle_approx_stderrs, \n",
        "                 color='b', alpha=0.1)\n",
        "\n",
        "plt.yscale('log', basey=2)\n",
        "plt.xlabel('Model Parameter Norm')\n",
        "plt.legend()\n",
        "plt.tight_layout()\n",
        "plt.savefig('tightness_bound_tab_with_q_approx.pdf')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAdYAAAFeCAYAAAA4+T7vAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAAPYQAAD2EBqD+naQAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOyde1xU1fr/P8NV7iCIgpIoChrKLSHAFPGo5auXHvR4y1SovOUFzbycOmWhkqRI9PV4KU9BYCheAP2RGUgEeStCLoqlqGCkkjeuwgzDzPP7Y5od48zAzDDDIK7367Vfstde+9nPPLPdn1l7rfUsHhERGAwGg8FgaAUDfTvAYDAYDEZPggkrg8FgMBhahAkrg8FgMBhahAkrg8FgMBhahAkrg8FgMBhahAkrg8FgMBhahAkrg8FgMBhahAkrg8FgMBhaxEjfDrRFLBbj9u3bsLKyAo/H07c7DAaDwWAAAIgIDQ0NcHZ2hoFB+23SbiWst2/fhouLi77dYDAYDAZDIVVVVRgwYEC7dbqVsFpZWQGQOG5tbd1pe0KhEFlZWZg0aRKMjY07ba+nw+KlHixe6sHipR4sXuqjy5jV19fDxcWF06n26FbCKn39a21trTVhNTc3h7W1NbsxVYDFSz1YvNSDxUs9WLzUpytipko3JRu8xGAwGAyGFmHCymAwGAyGFmHCymAwGAyGFmHCymAwGAyGFulWg5eeBkQiEYRCob7dUIhQKISRkRH4fD5EIpG+3en2sHipB4uXerB4qY+mMTM2NoahoaHW/OixwioSAXl5POTn94eFBQ+hoYAW46Y2RITq6mrU1tbqz4kOICL069cPVVVVLEGHCrB4qQeLl3qweKlPZ2Jma2uLfv36aSXWPVJY09KAVauAP/4wAjAKcXHAgAHAp58C06frxyepqDo6OsLc3Lxb/kcRi8VobGyEpaVlh5lFGCxe6sLipR4sXuqjScyICE1NTbh79y4AwMnJqdN+9DhhTUsDZswAiGTLb92SlB850vXiKhKJOFG1t7fv2ourgVgsRktLC3r16sX+I6sAi5d6sHipB4uX+mgaMzMzMwDA3bt34ejo2OnXwj3q2xKJJC3Vx0UV+Lts9WpJva5E2qdqbm7etRdmMBgMhkpIn8/aGAPTo4T1xx+BP/5QfpwIqKqS1NMH3fH1L4PBYDC0+3zuUcJ654526zEYDAaDoS49SlhV7XO2tdWtHwwGg8F4eulRwjpmjGT0b0ct+tdfB5KSALG4a/xiMBhdx6xZs2BjY4Pq6mp9u8J4SulRwmpoKJlSA8iLq3TfwQGorgbCwwF/f+DMma71kcFg6I7s7GxcvHgRS5cuxZo1a/TtDuMppUcJKyCZSnPkCNC/v2z5gAHA0aOSwUtRUYClJXDhAvDCC8DMmUBlpV7cZTAYWkIgEGD16tVITk5GdHQ0ysvL8f333+vbLcZTSI8TVkAirpWVQHZ2K9as+QXZ2a2oqJCU9+oFbNwIlJcD8+ZJWrJHjgDDhgHvvgs0NOjbewZDNeivOWQREREy+08rpqamKCsrw6hRo2BkZISCggKMHz9e324xnkJ6pLACktfCISGEsWNvISSE5NIZ9usHJCcDv/wCBAcDAgGwdSswdCiQkMD6Xxndn5SUFERFRaG5uRknTpzAm2++qW+XGAwGerCwqoqfH3D6NHDoEODqCvz5p2Rw03PPAfn5+vbuyeXcuXMICAiAt7c3fHx8cIZ1ZgMAKisrwePxUKmg70EsFuOzzz5DUFAQbGxsYGFhgdGjR+PYsWMKbb366qsIDAxEeno6UlNTsXfvXqXXDQgIwK5du7T1MVRi0aJFWLRoUZdcS93YdRXdKe7t3XsMLUPdiLq6OgJAdXV1WrHX0tJCGRkZ1NLSolJ9Pp9oyxYiKysiSToJounTiW7c6Jwfzc3NdPnyZWpubu6cIR0jEomopqaGRCJRp235+fnRzz//rAWvtEN4eDh5enpSdnY2jRw5knr16kVjx46liooKevDgAc2cOZOsrKxo8ODBdPDgQZlzz549S1OmTCEnJycyNzcnb29vSkpKkolXXV0dPfPMM/Svf/1L5twlS5ZQ79696datW0REVFFRQQCooqJCpl5DQwOFhISQtbU1vfvuu/Ttt9/S0aNH6eWXXyYAtG/fPrnPlJKSQh9++CHNmjWLMjMz6c0331T42dPS0qhPnz7U1NTUiQiqT3l5OZmYmNDVq1eJSLv3V1s0iV1X0Nm4axqvx+MuRdm915PozD3W0XNaHX1iwqqAP/8kCg8nMjCQiKuJCdH69URt3WptJcrNJUpJkfzb2qrc3tMorFu2bCFra2sKCQnpvGNaIDw8nOzt7cnLy4sOHjxIR48epf79+1NwcDBNmDCBNm3aRFlZWTRz5kwyMjKiyspK7twDBw5QTEwMffPNN5STk0ObNm0iY2Nj+vLLL2XilZOTQzwej5KSkoiI6MSJEwRARqiVPdxeeuklcnR0pLKyMplysVhMISEhZGtrS42NjXLHpJ+t7f7jjB07liIjI9UPmhYIDQ2lVatWEZHuhFWT2HUFnY17Z+LVNu5SmLC2DxNWFdFUWKUUFRGNGfN367VPH6J9+4gOHyYaMODvckCyf/SoYjtaE9abN4kKC5VvN292yry2HnwXLlygefPmdXkLqT3Cw8OJx+PRpUuXuLKdO3cSANqwYQNXVlNTQ4aGhhQfH6/QjlgsJqFQSIsXL6agoCC5eEVGRpKNjQ0VFRWRk5MTvfLKKzLnK3q4JScnEwBKS0tTeM39+/cTAMrKylL7c9+4cYN4PB7l5+fLHTt16hSFhIRQ7969ycLCgkaMGEH79+9X2XZqaiqFhoZSnz59yMzMjLy9vSkzM1Omzu7du8nBwYGEQqFOhFWXsesM2oi7snipG3cpTFjbR5vC2uNWt9EmPj5AXh6QkQGsXQvcuAEo6zLS+eo5v/8OeHgAfL7yOr16AVeuAM88owMHVOfQoUNwdXXlVoyoqamBnZ2dXn0CAGdnZ3h6enL77u7uAIAJEyZwZba2tnB0dERVVRVXVlNTgw8++ADHjh3DrVu3uAWUFa1UFBMTg6ysLAQGBsLBwUGl/rXY2Fh4eHhg2rRpCo+7uroCAO5okIszJycHRkZGCAgIkCk/ffo0Xn75ZaxZswbvv/8+WlpaUFBQAGNjY5VtX7x4EXPmzIGbmxtEIhEOHDiAGTNm4Nq1a+j/13y34OBg3L9/H8XFxfDz81Pb/47QZew6Q3eK+6hRo7T62Rgdw4S1A3g8YNo04OWXgdhY4L33lK+ew+NJVs/55z91sKj6/fvtiyogOX7/vt6Fdc6cOXjttdeQlpYGCwsLvPHGG1iyZIlefQIkotkWExMTpeX8NrGOiIjA2bNnsXHjRnh6esLa2hp79uxBamqq3DXMzMwQFhaGmJgYzJ07t8MfFDdv3kRJSQmioqKU1nn06BEAzVZHKigogLu7O0xNTWXKv/76a4SEhOCjjz7iyiZPnqyW7c2bN3N/t7a2Ijg4GImJibhw4QL3gPf09IShoSF++uknrQurrmPXGbpT3Jmwdj1MWFXExEQyLae9qYJtV88ZN64Dg0RAU5PqDjQ3q17vr4dJh5ibd5z/UQO8vb1x4cIFrdutq6tTqeUxePBgTjQ7C5/PR2ZmJuLi4rBy5UquXKxkPlZpaSni4uLg6+uLnTt34rXXXsPw4cOV2i8tLQUAPPvss0rrFBQUdFhHGXfu3EGfPn3kys3NzZGXl4ePP/4Yc+fOhYuLi1p2+Xw+9u7di4SEBNy4cQONjY3cMUtLS+5vIyMj2NraKv3eOvOd6jp2naG7x52hW5iwqoFWV89papKkf9I2L7yget3GRsDCQvs+6IjDhw+rNH3j119/xbBhw7RyTYFAALFYLPNQb2howPHjx+XqtrS0YP78+QgICEBOTg5Gjx6NBQsW4Ny5czAyUvxfrb6+HgDg4OCg1IekpCS4ublpJA58Pl+u1QQAUVFRICLExsbinXfewejRo7F9+3YEBgZ2aJOIMHXqVJSWluKtt96Cj48PevfujW+++QZRUVFyfpqamqJZyQ/DznynmsbuzJkzeP/99/HgwQOIxWK8+OKLiI6OhqmpKTIzMzFlyhRs27YN69atAwA8ePAAQ4YMwZAhQ1BQUIDMzEzMnz8fAwcOBBHB3Nwca9euxb/+9S/uGt097gzd8tTPY1UHVVfP6d1bt37oCx6P16Xb4yxcuBAkGXDX7qYtUQUAGxsb+Pv7IyYmBkeOHEFGRgYmTpwIGxsbubobN27E9evXkZiYCBMTEyQlJeHSpUvYsmWLUvtOf91Ubft025KWloarV69i/fr1Gvnfu3dv1NbWypVbWloiLi4Od+/eRW5uLmpqajBz5kyVbJ47dw7Z2dk4ePAgNmzYgBdffBH+/v4oLy9H37590bdvX5n6tbW1Cvujgc59p5rELjs7GxEREfjkk09QUlKCwsJClJeXc69Xi4qK4Ovri8uXL3PnREVFwdXVFT4+PlydhQsXori4GCUlJUhISMDKlSuRl5fHndPd487QLUxY1UDV1XPefBPIze3AmLm5pMWo6nb6tGpOnj6tuk01+51UeQBqc+supKSkYMiQIQgPD0dkZCRmzJiBBQsWyNQ5e/Ystm/fjh07dsDNzQ0AMHz4cGzduhXR0dH45ZdfFNoOCgqCnZ0dEhIS5I5dunQJS5cuxfjx47Fw4UKNfPfw8EBFRYXS4zweDyEhIZg2bRpaW1tVsikVMg8PD66ssLAQhw4dgre3t0zde/fuoampSaautlA3dgKBAEuWLEFiYiLnp4mJCVavXo2jR48CAIqLi7FgwQJOWMvLy3HmzBn4+PjA19eXq+Pl5cVda9iwYViwYAHS09O5sp4cd4YKdDhuuAvpbtNtFHH0KBGPJ9naTreR7tva/l322mtEDx9qabpNYaHsBZVthYUaX0JX8wx7KprES9GUhy+//JIA0NSpUyktLY1OnjxJ77zzDllZWdGYMWOotrZWYx+/++47AkBVVVVc2aJFi2jp0qWUmppKubm5tG3bNjI3N6fo6GiuTm5uLgGghIQEOZtXrlwhQ0NDmj17Np06dYo++eQTGjp0KFlYWNC6detk6krn8lZXV+vk/lIndsnJyeTv7y9n4/Tp0+Tk5ERERIMGDaIrV67QoEGDiIgoLCyMTp48SX5+fnTmzBmuTnFxsYyNqKgomj9/Prevjbg/Hi9N4y6FTbdpHzaPVUV0IaxEEnF9fB6ri4ukvK6O6PXXZee+pqf3HGFdvHgxOTs7Uzf7TaYXtCWsRESZmZn0wgsvkIWFBQEgABQfH0+t7WUeUQGBQED29vb0+eefc2VxcXEUEBBAtra2ZGlpSc899xyX1KKtPwDo22+/VWh337595OzsTJaWljRlyhQqLi4mHo8nNx9z5cqVNGbMGCLS3Q83VWO3du1aWrx4sdz58fHx9OKLL1JtbS1ZWlqSSCSicePG0f79+2nSpEkkFArJzMyMGhsbqba2lkxMTEggEMjYmDdvHm3ZsoXb10bcFcVLk7hLYcLaPkxYVURXwkrUceal3FyiIUMkWjdwYDP98MNlqqvrhLDevEnUq1f7otqrV6eSRKhyU+bl5VF1dTUTVtKusLalsLCQDA0NafPmzVrwkmjNmjUUGhqq1jnvvfceeXp6Ks3mpApCoZCcnJzoq6++IqKueSPSXuy2bNnCZamSIhAIyMPDgzIyMuiHH36gwMBAIpIk+rC1taWSkhIqLS0ld3d3IiL64YcfaOTIkTI2bt++TdbW1nIpBDsbd03j9XjcpTBhbR8mrCqiS2FVBT6faMMGoiFDmunbby/TL780059/Emn8rOpGmZc6K6x//PEHPfPMM5SXl8eVRUZGUmxsbKfsakpGRgb5+/uTt7c3eXh4UGlpqdK6p06doqCgIPL19SUPDw+lrTpFqPpwW7duHZmYmMil6dOE27dvk7m5udzry/YIDQ2lr7/+ulPX/eqrr2jo0KFc9p+u6mpQFrvS0lKyt7en8vJyIiKqr6+nV155hV577TUikrRcly5dSkREBQUFlJycTERESUlJNHv2bK7OvHnzOJvXrl2j0aNHy7zOldLZuGsar8fjLoUJa/swYVURfQurlJKSZsrJuUwFBc1UUEB0+TJRN8r2x9GVwkpE9MUXX3D5TEtKSsjLy0vuYdAVCIVCcnFx4frjHj16RHw+X2n9+/fvk0gkIpFIRDk5OXKv3NpDXw+3Q4cOUXZ2dpdeMzk5mX788Uduvzv04aelpZGvry95eXmRt7c3xcbGcv6Eh4fT3r175c55++23aevWrVwdR0dH8vX1JT8/P/rHP/6hNJ0iUefirmm8Ho+7FCas7cNSGj5huLsDRkaAlRVw754kf8Ply5LpO/36AQY9aGy2n58ffv/9d7nyUaNG4eTJkzJl3t7eXPaiFStW4NNPP1U631OX8Hg8mJmZYfXq1Zg9ezYmTpwIw3ZSZ6WnpyMhIQGNjY1oaGjAkCFDutBbzVB1Soc2mTdvXpdfsyOmTZumNP1hYmKiwvLY2NgO6yiDxf3phAlrF8HjAX36AI6OwM2bQH09cPs28PChZB1YXeSK0AfqZFzy8PDAb7/9huTkZPTv3x/jOkxXpRsMDQ1RWlqKrKws7Nq1C7t371aYAAKQzI1MTU3F8ePHYWdnx+V7VRVXV9duNZWI8fTA7r2uowe1lZ4MTE2BoUOBQYMkrVg+H/jtN4nY/pXbHYBkNFJDA/DggeTfnvj/wdLSEmKxGB9++KFMq6CruXLlCkxMTDBlyhQsW7YMTW1STT4+P7G4uBjPP/887O3tUVZWhj179nCJAxgMBgNgLVa9wOMB9vaAjY1k0ZqHDyWviGtrgYED/8453LYhZGICuLgA+l4kJiIiAqdOnQIADBgwAKGhoUhOTtbYnru7OyZNmsQlD9cHsbGxyMvLg6WlJezt7bFnzx7u2IULFxAZGcntz58/H2FhYThx4gQCAgLQp08fLnEAg8FgAExY9YqRETB4sERkb96UCOm1a4rrtrQA168Dbm76FVd1+5g64t69e5gxY4ZWbarLvn37FJbX1tbC2dlZZnWQoUOHoqysDIAkEX99fT2sra27xE8Gg/FkwF4FdwNsbABPT0n/a0dUVfWc18ICgQB37tzB4MGD9e2KQmxtbZGVlaVvNxgMxhMGE9ZugqGhai3RlhZJmt+egKmpKe7du6cw4T6DwWA8qTBh7UaoOrhUjUGoDAaDwehimLB2I1Rdm1tLa3gzGAwGQwcwYe1GWFp2LJrGxj1nziuDwWD0RJiwdiN4PMmUmvYQiSSZmxgMBoPRPWHC2s2ws5NMqXm85WpsLCkTi4GrV4G6Ov34x2AwGIz2YfNYuyF2doCtrWT0b0uLRFAtLSWieu2aJBPTtWuSZBIODvr2lsFgMBht0UmLtampCQMHDsTatWt1Yf6pgMeTJO23t5f8y+NJpuQMHSoRXiKgshKorta3pwwGg8Foi06ENTo6GoGBgbow/dRjYCDJ1iRNJvHHH5K0iD0laQSDwWA86WhdWMvLy/Hbb79h8uTJ2jbN+AseD3jmGUCaXvfuXeDGDcmrYgaDwWDoF7WFdevWrfD394eVlRUcHR0RFhaGK1eucMfXrl2LrVu3atVJhmKcnCRLzgFATQ1QXi67Qg6DwWAwuh61hTUvLw/Lly/H+fPnkZ2dDaFQiEmTJuHRo0c4duwY3N3d4e7urgtfGQpwcACGDJG8Im5oAK5cAYRCfXvFYDAYTy9qjwo+efKkzH5iYiIcHR1RWFiI8+fP4+DBgzh8+DAaGxshFAphbW2NjRs3KrQlEAggEAi4/fr6egCAUCiEUAvqILWhDVud9YOIIBaLIdbB+1pra2DoUB6uXQOamnj47TfC0KGkdoYm6SLIUl8Z7dM2XkKhEIaGhnr2qHvD7i/10Ea8Zs+ejaysLPz666/o16+fNt3rlnQmZmKxuN3/y+roCI86uaT8tWvXMHToUFy8eBEjRozgyhMTE3Hp0qV2F7D+8MMPERUVJVeekpICc3PzzrjVrTAyMkK/fv3g4uICEx3mI2xpMcDt2xZobTWEoaEYzs6NMDVlD7DHuX37Nl588UXs3bsXo0ePBgD8+9//xoABA7BixQr8/PPPeOeddyAQCMDj8bB9+3aFg/HWrVsHIsKVK1dgamqKI0eOdPVHYTCUkpubi3//+9946aWXcOvWLfzvf//Tt0vdmpaWFlRVVaG6uhqtra1yx5uamjB37lzU1dV1uFRkp4RVLBZj6tSpqK2txenTp2WOqSKsilqsLi4uuH//vlbWuBQKhcjOzsbEiRNhbGzcaXuawufzUVVVBVdXV/Tq1Uun1xIKgfJyHvh8HgwMCEOGAJaWqn3FRISGhgZYWVn1+BVnvvzyS1y8eBGffPIJSktLER4ejoKCAhgZGcHf3x+7d++Gv79/uzZeeOEF9O/fH8nJyTr9wdRTeJruL23QmXgJBAKMGjUKCQkJ8PHxwejRo7F161aMHz9eR952DzoTMz6fj8rKSri4uCh8TtfX18PBwUElYe1Ugojly5fj0qVLcqIKABERER2eb2pqClNTU7lyY2NjrQqhtu2pi0gkAo/Hg4GBAQwMdJvsytQUGDZMMpDp0SMeysuBQYN46N2743Olr06kvmrKuXPnsGrVKq7Ft2vXLq5l2F3w9fXF4cOHYWBggMjISHz66aecOE6fPh2TJk2Cr68vfvjhB4Xni8VilJWV4auvvoKJiYnOv9eegLbuL0UQEXg8HiIiIpCYmMjtP8l0Jl5mZmYoKyvj9gsKCrTqW3elMzEzMDAAj8dTqhfqaIjGwrpixQpkZmYiPz8fAwYM0NQMQwcYGQEeHsD165LUhzduAK2tqi2krg1WrFiBvXv3dtji0yceHh747bffkJycjP79+2PcuHEAgKKiIvz222+orq6GmZmZ0vOvXbsGV1dX9OnTp4s8ZrRHSkoKrl27hubmZpw4cQLHjx/H3r179e0W4ylF7Z+NRIQVK1YgPT0d33//PQYNGqQLvxidxMBAMlpYmvLw99+BW7e6JpHE9OnTMWHCBE6suiOWlpYQi8X48MMPZborDh06BFdXV05Ua2pq8OjRIwwbNgz/+c9/MHnyZFy7dg1FRUXw9fWVsZmYmIhXXnkFa9aswVtvvYXNmzcjLCwM+fn5qK6uxn/+8x+8/fbb3PWys7Px/vvvo7KyErNmzXrqBvRUVlaCx+OhsrJS7phYLMZnn32GoKAg2NjYwMLCAqNHj8axY8cU2nr11VcRGBiI9PR0pKamtiuqAQEB2LVrl7Y+hkosWrQIixYt6pJrqRs7XaGPOC9evBirVq2SK2/vXtMFagvr8uXLsX//fqSkpMDKygrV1dWorq5Gc3OzLvxjdAIeT5JP2MlJsn/nDnDzpkRciSTTcx48kPyrLcFt2+JT9Bq1O4mHu7s7Fi9ejP7STBsA5syZg2+++Qaenp4ICAjAoUOHUFBQgMmTJyM6OhoLFizA6dOnUVRUBD8/Pzmb48aNQ1xcHAoKCrB27Vp8/PHHOHr0KIyNjdHS0gILCwvs378fADBx4kQYGRlh3rx5+O9//9tlr5MjIiIwYsQInDp1Cl5eXjAzM0NISAgqKyvx8OFDzJo1C9bW1nBzc0NqaqrMuefOncPUqVPh7OwMCwsL+Pj4IDk5WaZOfX09Bg4ciBkzZsiUv/nmmxg8eDBu377drn+NjY0YP3481q9fj/HjxyM1NRXJycmws7NDWFiYwkE4Bw4cwPnz5zFt2jTMmjULy5YtU2g7PT0dlZWVeP3111UJldbYsGEDkpKSUF5ertPraBI7XaCvOK9fvx4HDx7UeZw7hNQEgMItISFBXVNy1NXVEQCqq6vrtC0iopaWFsrIyKCWlhat2NOU5uZmunz5MjU3N+vNhz//JCookGxlZUTFxX/vFxQQlZQQPXggppqaGhKJRBpf59///je999573P7Dhw+psbGRRo4cSdu2baNz585p4+MQEVFubi5pcAtzjBw5kq5du9Zhva1bt9L+/fuJiGjDhg106dIlIiISiUQy8UpISKADBw4QEdGLL75IREQVFRW0ZMkS2rFjB2VmZhIRka+vL2d70aJFNHnyZKqsrNT4c6hLeHg42dvbk5eXFx08eJCOHj1K/fv3p+DgYJowYQJt2rSJsrKyaObMmWRkZCTj24EDBygmJoa++eYbysnJoU2bNpGxsTElJibKXCMnJ4d4PB4lJSUREdGJEycIAH3xxRdcvCoqKggAVVRUyJz70ksvkaOjI5WVlcmUi8ViCgkJIVtbW2psbJQ7Jv1sbfcfZ+zYsRQZGalewLREaGgorVq1SuX6j99fqqBJ7HSBvuIsEolozJgxctdWdq+1paPntDr6pPlTSQcwYVWN1lai3FyilBTJv62tqp334AHRL7/ICqrsJqaqqsZOCWtxcTH5+vrSs88+S/7+/rR371768ccfacOGDRrbVEZnhJXP55ODg4PSB3BbZsyYQWvXrqW33nqLPv30U65cHWH9+eefac6cOfTxxx+Tu7s7ERHt3buX9u3bR3fv3qXp06d32X0aHh5OPB6P+4FARLRz504CIPM91dTUkKGhIcXHxyu0IxaLSSgU0uLFiykoKEjueGRkJNnY2FBRURE5OTnRnDlzZOKl6GGXnJxMACgtLU3hNffv308AKCsrS+3PfePGDeLxeJSfny937NSpUxQSEkK9e/cmCwsLGjFiBPdjShVSU1MpNDSU+vTpQ2ZmZuTt7c39kJKye/ducnBwIKFQqJJNdYVVl7FTB33GWSQSUWxsrFycu1pY2bJxTxhpacCqVZLk+1IGDAA+/RSYPr39c+3sJH2tCqZocdy/3wvOzpr75+3tjQsXLsiUffrpp90ud7SpqSnu3bunUt3W1lZs3769w3ptR8JLE6m4urpy/X0HDhwAIHldBQBLlizh6h89elQlX7SFs7MzPD09uX1ptrQJEyZwZba2tnB0dERVVRVXVlNTgw8++ADHjh3DrVu3IPorh6a9vb3cNWJiYpCVlYXAwEA4ODjgv//9b4d+xcbGwsPDA9OmTVN43PWvHJ537tzp+EM+Rk5ODoyMjGi58AkAACAASURBVBAQECBTfvr0abz88stYs2YN3n//fbS0tKCgoECtUaAXL17EnDlz4ObmBpFIhAMHDmDGjBm4du0a19UQHByM+/fvo7i4GKNGjVLb/47QZezUQd9xDggI0GmcVYEJ6xNEWhowY4Z8f+itW5LyI0faF9fGxvZFFeChtdUQjY0ELUwj5igqKsIbb7zRaTtExD3IAXB/Pz6Z28hIu7d1enq6Vu11B2xtbWX2pVONFJXz+XxuPyIiAmfPnsXGjRvh6ekJa2tr7NmzR64vFpBM+QgLC0NMTAzmzp0LOzs7LruaIm7evImSkhKFSWOkPHr0CAA0SiBTUFAAd3d3uSl+X3/9NUJCQvDRRx9xZer+ENy8eTP3d2trK4KDg5GYmIgLFy5wD3xPT08YGhrip59+0voDX9exUwd9x3n48OE6i7OqMGHVE0RAU5Pq9UUiIDJS8SAjIslApVWrgAkTJOu2KqKmBmg7xqxXL8l5j6PtDJCJiYlasfPVV1/htddekyt//BdvRUUF9+u8p1JXV6dSy2Pw4MFaS17B5/ORmZmJuLg4rFy5kitXNiCttLQUcXFx8PX1xc6dOxEeHi4zUExRfQB49tlnldaRzsdsr44y7ty5o3B6lLm5OfLy8vDxxx9j7ty5cHFxUcsun8/H3r17kZCQgBs3bqCxsZE7Zmlpyf1tZGQEW1tbpd/b49+pWCxGY2MjLC0tZQa2KfpOdR07dejuce4KmLDqiaYmoM290GmIJK+HbWxUPyc/H1A0VVOPuTTaZcqUKTIT3QsLC7F06VK5ye/OnXmX/YRw+PBhlaZv/Prrrxg2bJhWrikQCCAWi2Ue6g0NDTh+/Lhc3ZaWFsyfPx8BAQHIycnB6NGjERERgW+//VapfWlr1kE6R0wBSUlJcHNz00gc+Hy+woQ0UVFRICLExsbinXfewejRo5WmsXwcIsLUqVNRWlqKt956Cz4+Pujduze++eYbREVFyflpamqqdAZFZ75TTWKXmZmJKVOmYNu2bVi3bh0A4MGDBxgyZAiGDBmCgoICZGRkID4+Xm6Ef2ZmJubPn4+BAwdyZf/617/w/vvvd/s4dwVMWBltIBgZiWFpyQMg35Tt6kw29Fjz3N7eXqYvT/qLtaPXPU96Bh5APhYLFy7EwoULu9QHGxsb+Pv7IyYmBn369IGRkRFiYmJgY2ODu3fvytTduHEjrl+/jpKSEpiYmCApKQl+fn6IjY2VeRXYFqe/5oW17dNtS1paGq5evYrPPvtMI/979+6tcB6jpaUl4uLisGPHDuTn52P58uWYOXOmUj/acu7cOWRnZyM3N1dm3nZ8fDz69u2Lvn37ytSvra1V2B8NyH+nYrEY9fX1sLa27nAqliaxk87Fvnz5MlcWFRUFV1dX+Pj4AACKi4u5v9tSVFSEJUuWICYmRu5Yd49zV8DysOkJc3NJn6eq24kTqtk9caJ9O1VVkpZqfr7kVfDjODjw5Qv/giSjyLts0xa68k8kEqGmpgYikeiJiUVnSUlJwZAhQxAeHo7IyEjMmDEDCxYskKlz9uxZbN++HTt27ICbmxsASb/XRx99hB07duCXX35RaDsoKAh2dnZISEiQO3bp0iUsXboU48eP1/gHhYeHByoqKpQe5/F4CAkJwbRp0xQmYVeEVBQ8PDy4ssLCQhw6dAje3t4yde/du4empiaZutpCk9gVFxdjwYIFnLCWl5fjzJkz8PHx4ZKfKBPW4uJiPPfccwp90Xec79+/r7M4q0yH44a7EDbdRjmtrUQDBhDxeNL0DrIbj0fk4qLa1JuHDyXzVnUxj7Ur6ew81s6iyTzDp5nH46VoCsSXX35JAGjq1KmUlpZGJ0+epHfeeYesrKxozJgxVFtbq/H1v/vuOwJAVVVVXNmiRYto6dKllJqaSrm5ubRt2zYyNzen6Ohoro70PlM0V//KlStkaGhIs2fPplOnTtEnn3xCQ4cOJQsLC1q3bp1MXelc3urqapX8Vff+Ujd2gwYNoitXrtCgQYOIiCgsLIxOnjxJfn5+dObMGSIiGjhwIBUVFclda9CgQTR8+HDy9vYmb29vmj59OndMn3EWiUR06NAhuTizeaxMWJVy9KhEQB8XV2nZ0aOq2xKLiaqrJaJaVCTZV+U/8uLFi8nZ2VmvgialpwlrdnY2vfHGGxQeHi7zwOkpqCKsRESZmZn0wgsvkIWFBZeAJj4+nlpVnbCtBIFAQPb29vT5559zZXFxcRQQEEC2trZkaWlJzz33HJfUoq0/AOjbb79VaHffvn3k7OxMlpaWNGXKFCouLiYejyc3P3PlypU0ZswYlf3V5P5SNXa1tbVkaWlJIpGIxo0bR/v376dJkyaRUCgkMzMzamxspJqaGjIxMSGBQCB3rrW1tVIf9BlnkUhEixcvloszE1YmrO1y9Kik5dpWWF1c1BNVKa2tf7dYBQLV/iPn5eVRdXV1txBWfaPLFuvEiRO1blPfqCqsbSksLCRDQ0PavHmzVnxYs2YNhYaGqnXOe++9R56eniolE1GGUCgkJycn+uqrr1Q+p7P3V3ux++GHHygwMJCIJIk8bG1tqaSkhEpLS7kEJrm5ueTl5aXw3ICAgHavra84CwQC6tevn1yrt6uFlfWxPmFMnw5UVgK5uUBKiuTfioqOk0MowtBQsswcoPrUn7Fjx8oNFNCEW7duYeDAgcjPz+fKVq1ahR07dnTa9uM8ePAAkydPhoeHB0aOHInXX39dZh3g1tZWBAUFoba2FoAkcUP//v11PuiptbUVgYGB3HWlfPHFF5gyZYpOr90ex44dQ0BAAHx8fDBs2DBcvHix3fo5OTkIDg6Gn58fnn32WWRlZWnNFz8/P6xZswabN2+WGWSjKWvXrsVPP/2EkpISlc85c+YM3n333U7dDykpKbC0tMTcuXM1tqEu7cWubd/p/PnzsXPnTnh5eaG4uFil/tXhw4e3e219xtnCwqJL46wQdX4N6BrWYu16rl2TtFj/+EO9X8jauHW++OILLndqSUkJeXl5qZzuTR0ePHhAeXl5RCT5jHPmzKHY2FjueGJiIq1fv57bV7VVro0W6+7du2nTpk3c/o4dO2jnzp0a2+ssQqGQXFxcuP64R48eEZ/Pb/ec+/fvczH4+eeflb7u1KTFqgsOHTpE2dnZXXrN5ORk+vHHH9U6R5dvRMLDw2nv3r1y5W+//TZt3bqVq2NjY0MDBw7ktkuXLlF4eDg5Ojpy/ave3t70//7f/5OzpY84f/XVV3TixAm5mLFXwUxYu5TbtyXCWl6uHWH19fUle3t7uU2aO7ctv/zyC02aNImIiMaMGUO5ubmd+iyqEhsbK5Oke+zYsfTLL7/I1dOGsP7xxx/0zDPPcMJOJHn1JhX2e/fukZubGxFJHr5ubm60ZMkSWrZsmVqfSVu0traSu7s7RURE0LfffqtSv+a+ffsoODiYvLy8yM3NjftOH6e7COuTAhscpz7KYsZyBTO6FGmCCL7yWTZq8Xie4PZQtti4LuHz+UhMTORy/wqFQhQVFSl85aUN+vfvjw8++ABpaWkYO3YsSktL8cMPP6CwsBCAZEI/EaGqqgrz5s3DvHnzdOKHqhgaGqK0tBRZWVnYtWsXdu/erTABhJS0tDSkpqbi+PHjsLe3x+bNm9HQ0KDStVxdXbvVVCJGz6Wr7zXWx/qUI00byucDXb1UqrLFxnWFWCxGeHg4QkND8dJLLwGQzHmzsrKCobI8kErw8/ODo6Mj3Nzc4OjoCAcHBzg4OHB22+Lt7Y1ff/0VALBixQp8+umnMvmM+/Xrh1u3bnXik2mPK1euwMTEBFOmTMGyZcvQ1KbzfcGCBXJ5k4uLi/H888/D3t4eZWVliI+Pl1sAnsF42mAt1qccY2PAyEiSnF+VAUwRERE4deoUAGDAgAEIDQ2VW+haHdzd3TFp0qR2c8hqi+XLl8PAwADx8fFcmZmZmUySeVW5cOGCyplxOmqZNzc3w0xRbkk9EBsbi7y8PFhaWsLe3h579uzhjl24cAGRkZEy9efPn4+wsDCcOHECzz//PBwdHZmwMp56mLA+5fB4klZrfT3Q1MRTmI2pLdpKqC/l3r17mDFjhlZtKmL9+vWoqqpCenq6jAja2trCzMwM9+/fbzfPamdo2zJvOwoakLSiq6qquGXb9M2+ffsUltfW1sLZ2VkufeTQoUNRVlbWFa4xGE8M7FUwg+tn7eqc1QKBAHfu3MHgwYN1ep2ysjJs374d169fh7+/P3x8fLik4wAwdepUZGdnc/sREREYMGAAAEmrfP78+Z32wd3dHYsXL5Zrmf/0008IDAzsNi1WZdja2mp1Gg2D0ZNhLVYG18/a3CxZDL2rUGex8c7g6enZ7sCFVatWYcWKFXjllVcAaL9VDihvme/btw+rV6/W+vUYDIb+YC1WhswApqdxkKaHhwfCw8NRV1enE/vKWuYikQj+/v74xz/+oZPrMhgM/cBarAxuwXOxmAeh8On8raXLaS7KWuaGhoZ48803dXZdBoOhH57OpyhDBh7v737Wlhb1pp0wGAwGQxYmrAwAf78OFgiYsDIYDEZnYMLKAMCElcFgMLQFE1YGgL+Flb0KZjAYjM7BhJUBQNrHSmhtNYBQqG9vGAwG48mFCSsDgOzarI8e6XYdUgaDwejJMGFlcLRNFMFgMBgMzWDCyuDQV2pDBoPB6EkwYWVwtG2xPo0ZmBgMBkMbMGFlcJiZSdRUIABEIj07w2AwGE8oTFgZHMbGgKGhGABPpbVZGQwGgyEPE1aGDKamkqYqE9anm1mzZsHGxgbV1dX6doXBeOJgwsqQwcREIqxsANPTS3Z2Ni5evIilS5dizZo1+naHwXjiYMLKkEHaYmUDmJ5OBAIBVq9ejeTkZERHR6O8vBzff/+9vt1iMJ4o2LJxDBmkwipdm5XXw3NFEBF4PB4iIiKQmJjI7T+tmJqaoqysjNsvKCjQozcMxpMJE1aGDMbGYhgYEMRiHvj8v6fg9FRSUlJw7do1NDc348SJEzh+/Dj27t2rb7cYDMYTDHsVzJCh7dqsjx7p1xdlVFZWgsfjobKyUu6YWCzGZ599hqCgINjY2MDCwgKjR4/GsWPHFNp69dVXERgYiPT0dKSmprYrqgEBAdi1a5e2PoZKLFq0CIsWLeqSa6kbu66iO8W9vXuPwZDChJUhR3sZmCIiIjBixAicOnUKXl5eMDMzQ0hICCorK/Hw4UPMmjUL1tbWcHNzQ2pqKnfeuXPnMHXqVDg7O8PCwgI+Pj5ITk6WsV1fX4+BAwdixowZMuVLly6Fvb09bt++3a7fjY2NGD9+PNavX4/x48cjNTUVycnJsLOzQ1hYGP73v//JnXPgwAGcP38e06ZNw6xZs7Bs2TKFttPT01FZWYnXX3+9XR+0zYYNG5CUlITy8nKdXkeT2HUFPT3ujB4KdSPq6uoIANXV1WnFXktLC2VkZFBLS4tW7GlKc3MzXb58mZqbm/XqR0eIRCKqqamhP/8UU0EB0W+/ydcJDw8ne3t78vLyooMHD9LRo0epf//+FBwcTBMmTKBNmzZRVlYWzZw5k4yMjKiyspKIiA4cOEAxMTH0zTffUE5ODm3atImMjY0pMTFRxn5OTg7xeDxKSkoiIqITJ04QADp48CBXp6KiggBQRUWFzLkvvfQSOTo6UllZmUy5WCymkJAQsrW1pcbGRrlj0s/Vdv9xxo4dS5GRkQrjJRKJFJ6jLUJDQ2nVqlU6vYYmsVMXTeKlKO5dhaK4K7v3dEFX3V89ic7ErKPntDr6xIS1C9CJsGZnEw0fLvlXS0hvyoYGibAWFRE9rjPh4eHE4/Ho0qVLXNnOnTsJAG3YsIErq6mpIUNDQ4qPj5e7jlgsJqFQSIsXL6agoCC545GRkWRjY0NFRUXk5OREr7zyisxxRQ+35ORkAkBpaWkKP9v+/fsJAGVlZakSChlu3LhBPB6P8vPzZcpFIhFlZGRQSEgI9e7dmywsLGjEiBG0f/9+lW2npqZSaGgo9enTh8zMzMjb25syMzNl6uzevZscHBxIKBSq7bsq6DJ2bVH3oacs7kREp06d0kvcmbB2b7qLsLJXwU8iRMC77wK//ir5V8vzYnr1kthrbQVaWuSPOzs7w9PTk9t3d3cHAEyYMIErs7W1haOjI6qqqgAANTU1iIyMxMCBA2FsbAxjY2N8/vnnuHr1qpz9mJgYODk5ITAwEAYGBir1r8XGxsLDwwPTpk1TeNzV1RUAcOfOnQ5tPU5OTg6MjIwQEBAgU3769GnMnj0bQUFBOHToEA4fPoyZM2fC2NhYZdsXL17EnDlzcODAAWRkZMDX1xczZszArVu3uDrBwcG4f/8+iouL1fZdFXQZu87QXtxffvllBAcHP9FxZ/Rc2KhgfUGkeXqjU6cA6TSIggLg+HGgjaipjLm5wvk0BgZAr16SKTePHv29TqsUW1tbmX0TExOl5Xw+H4Ckb/bs2bPYuHEjPD09YW1tjT179sj0w0oxMzNDWFgYYmJiMHfuXNjZ2bX7MW7evImSkhJERUUprfPor5FY5hoMcy4oKIC7uztMHwtESkoKRo8ejejoaBgYSH6jTp48WS3bmzdv5v5ubW1FcHAwEhMTceHCBfTv3x8A4OnpCUNDQ/z0008YNWqU2v63h65j1xmUxf3rr79GSEgIPvroI67sSYs7o2fDhFVfNDUBlpbasRUWptl5jY2AhYXCQ+bmEmFtagJ69+6EbwD4fD4yMzMRFxeHlStXcuVisVhh/dLSUsTFxcHX1xc7d+7Ea6+9huHDhyu1X1paCgB49tlnldaRzsdsr44y7ty5gz59+siVm5ub48yZM9i2bRteffVVuLi4qGWXz+dj7969SEhIwI0bN9DY2Mgds2xzbxgZGcHW1lZpi7Gurk6l1uTgwYO5H0FSdB27ztBe3PPy8vDxxx9j7ty5eos7g6EM9iqYoRBtLnouEAggFotlHuoNDQ04fvy4XN2WlhbMnz8fAQEBOH/+PEaMGIEFCxagtbVVqf36+noAgIODg9I6SUlJcHNz00gc+Hy+XKsJAD788EO88cYb2LFjBwYOHIgxY8bg/PnzKtkkIkydOpVrlR85cgQ///wzPvjgAwDyImZqaopmJV/G4cOHMXz48A63GzduyJ2raezOnDmD8ePHw9vbGyNHjsTatWshEAgAAJmZmeDxeNi+fTtX/8GDB7C3t8f48eO5OnZ2dvDx8YG3tzeCgoJw9OhRmesqi3tUVBSWLVuG2NhYvcadwVAGE1Z9YW4uaTGqszU0AH5+gKGhrC1DQ0l5Q4N69tp5tSedciPNwNQZbGxs4O/vj5iYGBw5cgQZGRmYOHEibGxs5Opu3LgR169fR2JiIkxMTJCUlIRLly5hy5YtSu07OTkBANef+zhpaWm4evUq1q9fr5H/vXv3Rm1trVy5paUloqOjUV1djdzcXNTU1GDmzJkq2Tx37hyys7Nx8OBBbNiwAS+++CL8/f1RXl6Ovn37om/fvjL1a2trYW9vr9DWwoULQZKBiO1uw4YNkztXk9hlZ2cjIiICn3zyCUpKSlBYWIjy8nLu9WpRURF8fX1x+fJl7pyoqCi4urpi5MiRXJ2FCxeiuLgYJSUlSEhIwMqVK5GXl8ed017c4+LicPfuXb3GncFQBhNWfcHjSV7DqrOdOQNcuCC/WKpIJCk/c0Y9e+2k7pNqrrbWZk1JScGQIUMQHh6OyMhIzJgxAwsWLJCpc/bsWWzfvh07duyAm5sbAGD48OHYunUroqOj8csvvyi0HRQUBDs7OyQkJMgdu3TpEpYuXYrx48dj4cKFGvnu4eGBiooKpcd5PB5CQkIwbdq0dlvWbZEKmYeHB1dWWFiIQ4cOwdvbW6buvXv30NTUJFNXW6gbO4FAgCVLliAxMZHz08TEBKtXr+ZanMXFxViwYAEnrOXl5Thz5gzXupXW8fLy4q41bNgwLFiwAOnp6VxZT447o4ej9phkHcKm27SDWEzk709kYEAkaUTKbgYGkuNK5mGqwuND1YuLiQoKiLT0dWgNRVMevvzySwJAU6dOpbS0NDp58iS98847ZGVlRWPGjKHa2lqNr/fdd98RAKqqquLKFi1aREuWLKEvv/yScnJyaNu2bWRubk7R0dFcndzcXAJACQkJcjavXLlChoaGNHv2bDp16hR98sknNHToULKwsKB169bJ1JXO5a2urtb4M7SHOrFLTk4mf39/ORunT58mJycnIiIaNGgQXblyhQYNGkRERGFhYXTy5Eny8/OjkydPkkgkokGDBlFxcbGMjaioKJo/fz63ryzuS5cupdTUVMrNze3yuLPpNt2b7jLdhglrF6AVYeXzifr2VSyq0q1fP0k9DXn8prxyRSKst29r7rYuUPZwy8zMpBdeeIEsLCwIAAGg+Ph4am1t7dT1BAIB2dvb0+eff86VxcXFUUBAANnY2JClpSU999xzXFKLtv4AoG+//Vah3X379pGzszNZWlrSlClTqLi4mHg8ntx8zJUrV9KYMWM69Rk6QtXYrV27lhYvXix3fnx8PL344otUW1tLlpaWJBKJaNy4cbR//36aNGkSCYVCMjMzoz/++IMePnxIJiYmJBAIZGzMmzePtmzZwu23F3dbW1u9xJ0Ja/eGCasCmLB2wO+/ExUWKt/a/LLXhMdvyqoqibBev945t7WNKg+3wsJCMjQ0pM2bN2vlmmvWrKHQ0FCZso7+E7/33nvk6empNJuTKgiFQnJycqKvvvpKYxvq0l7stmzZwmWpkiIQCMjDw4MyMjLohx9+oMDAQCKSJPqwtbWlkpISKi0tJXd3d6qpqaHvv/+eRo4cKWPj9u3bZG1tTVevXpUpVxT3jtBl3Jmwdm+6i7BqtY+1trYWo0aNgo+PD0aMGIF9+/Zp0zzDxUUySEnZNmCAVi/XdmSwqgOYjh07hoCAAPj4+GDYsGG4ePGi0ro5OTkIDg6Gn58fnn32WWRlZWnBawl+fn5Ys2YNNm/eLDOIRlPWrl2Ln376CSUlJSqfc+bMGbz77rudWoYuJSUFlpaWmDt3rsY21KW92E2dOhWZmZm4du0aAMno7oiICAQHB+Of//wniouL4ePjAwCYP38+du7cCS8vL5nykpISmf7M69evY+bMmdiwYQOGDh0qc72nKe6MnoNW57FaWVkhPz8f5ubmePToEUaMGIHp06ezUXVPKFJh5fMBsVh+MPLjtLa2YuXKlbh48SJsbGzQ1NQEw3ZO8vHxwenTp2FgYICCggK8/fbbmDRpktb837ZtG7Zt26YVW05OTkhMTMS9e/dUPkcbC4QbGBjgyy+/hJFR1045Vxa7kSNHYt++fZg1axZEIhF4PB7mz5+Pt956C4BktG9QUBAAYNSoUVxihZKSEk5Yi4qKkJWVBT8/P/B4PNjZ2eHtt99WmPnpaYs7o2eg1bvG0NCQy84iEAi4Yf6MJxNTU0kWJrFYIq5Kcklw8Hg8mJmZYfXq1Zg9ezYmTpzYrrCmp6cjISEBjY2NePToETcSuLui6pQObTJv3rwuv2ZHTJs2TWn6w8TERIXlsbGxEIvFqK+vR0JCApepShVY3BlPGmq/Ct66dSv8/f1hZWUFR0dHhIWF4cqVK9zx2tpaeHt7Y8CAAVi3bl27E88Z3Zu2a7Oqkn3R0NAQpaWlmD59Onbt2qX04QtI5kempqbi+PHjKCkpQXh4uNx0B2W4urqCiLgctgxGV8HuPYYqqC2seXl5WL58Oc6fP4/s7GwIhUJMmjSJyydqa2uLkpISVFRUICUlBX/++afWnWZ0HdLXwaoI65UrV2BiYoIpU6Zg2bJlaPrrpMfnJwKSeYzPP/887O3tUVZWhvj4ePj6+mrbfQaDwehy1H4VfPLkSZn9xMREODo6orCwEGPHjuXK+/btC29vb/z4449yC1dLEQgEXBo04O/0akKhEEKhUF3X5JDa0IatzvpBRBCLxUrz43YHpK/tpb4CgJkZDwAPzc0Esbj91/rbt29Hfn4+LC0t0bt3b+zatQtisRgXLlzAihUrZD77q6++iunTp+PEiRMICAiAo6MjvL29u3V8HkdRvBjKYfFSDxYv9elMzMRiMYgIQqFQYReWOjrS6T7Wuro6AJL0Y3/++SfMzc1hZWWFuro65Ofn480331R67tatWxWuqpGVlaXVlTSys7O1ZksTjIyM0K9fPzQ2NqJF0Tps3YyGhgbub7HYEIAVmpsJdXX17SVrQmxsrFxZVVUVHB0d4e7uzv1wAiQ/vM6cOSNXv22dJ4W28WJ0DIuXerB4qY8mMWtpaUFzczPy8/MVZvJqUmM1Mh51YnSRWCzG1KlTUVtbi9OnT+Pnn3/G4sWLuUFLy5cvx5IlS5Ser6jF6uLigvv378Pa2lpTtziEQiGys7MxceJEtdZq1DZ8Ph9VVVVwdXVFr1699OZHRxARGhoaYGVlxU1VIAKKiiStVk9PsdwSck8ziuLFUA6Ll3qweKlPZ2LG5/NRWVkJFxcXhc/p+vp6ODg4oK6urkN96lSLdfny5bh06RJOnz4NAAgICFBrUWBTU1OFq1dIF8LWFtq2py7SaQkGBgZqjYbsaqSvTqS+SpGuzdrcbMANZmIojxdDMSxe6sHipT6diZmBgQF4PJ5SvVBHQzT+tlasWIHMzEzk5uZigJYTEzC6F+oMYGIwGIynHbWFlYiwYsUKpKen4/vvv8egQYN04RejG6FJBiYGg8F4WlH7VfDy5cuRkpKCY8eOwcrKCtXV1QAka26asfeEPZLHhZV19zAYDIZy1G6x7tmzB3V1dRg3bhycnJy4LTU1VRf+MboB0t9LLS3aWZuVwWAwejJqt1hZisKnD2NjySYUSvpZbWz07RGDwWB0X9hQM4ZKsAFMDAaDoRpMWBkqwYSVwWAwVIMJK0Ml2i4hx3oDGAwGQzlMWBkqIR3AJF2blcFgMBiKYcLKUAlTU8lC4g2LOwAAIABJREFU50SSaTcMBoPBUAwTVoZKqLs2K+PJZtasWbCxseHmqTMYDNVhwspQGTaA6ekgOzsbFy9exNKlS7FmzRp9u8NgPHEwYWWoDBvA1PMRCARYvXo1kpOTER0djfLycnz//ff6dovBeKLo9HqsjKcH6avgnpTakIjA4/EQERGBxMREbv9pxdTUFGVlZdx+QUGBHr1hMJ5MmLAyVMbMTCKmIhEgEKBHLCGXkpKCa9euobm5GSdOnMDx48exd+9efbvFYDCeYNirYIbKGBhI1mYF9NvPWllZCR6Ph8rKSrljYrEYn332GYKCgmBjYwMLCwuMHj0ax44dU2jr1VdfRWBgINLT05GamtquqAYEBGDXrl3a+hgqsWjRIixatKhLrqVu7HRFd4pze/cag6EMJqwMtdi4MQKzZ4/Ad9+dgpeXF8zMzBASEoLKyko8fPgQs2bNgrW1Ndzc3GQWZjh37hymTp0KZ2dnWFhYwMfHB8nJyTK26+vrMXDgQMyYMUOmfOnSpbC3t8ft27fb9a2xsRHjx4/H+vXrMX78eKSmpiI5ORl2dnYICwvD//73P7lzDhw4gPPnz2PatGmYNWsWli1bptB2eno6Kisr8frrr6saKq2wYcMGJCUloby8XKfX0SR2uqCnx5nxlEDdiLq6OgJAdXV1WrHX0tJCGRkZ1NLSohV7mtLc3EyXL1+m5ubmTtn5/XeiwkLlW1VV5/wUiURUU1NDIpFIaZ1Zs8LJxsaePDy86MCBg3T06FHq378/BQcH04QJE2jTpk2UlZVFM2fOJCMjI6qsrCQiogMHDlBMTAx98803lJOTQ5s2bSJjY2NKTEyUsZ+Tk0M8Ho+SkpKIiOjEiRMEgA4ePMjVqaioIABUUVEhc+5LL71Ejo6OVFZWJlMuFospJCSEbG1tqbGxUe4YEVF4eLjM/uOMHTuWIiMj1Y6XNggNDaVVq1bp9BqaxE5dVImXojh3FYrirOxe6wq66v7qSXQmZh09p9XRJyasXYA2hJXPJ+rbl0gybEjx1q+fpJ6mqHJTzp0bTjwej44evUTSajt37iQAtGHDBq5eTU0NGRoaUnx8vJwNsVhMQqGQFi9eTEFBQXLHIyMjycbGhoqKisjJyYleeeUVmeOKHnbJyckEgNLS0hT6vX//fgJAWVlZygOghBs3bhCPx6P8/HyZcpFIRBkZGRQSEkK9e/cmCwsLGjFiBO3fv19l26mpqRQaGkp9+vQhMzMz8vb2pszMTJk6u3fvJgcHBxIKhWr7rgq6jF1bOrq/lMWZiOjUqVN6iTMT1ieL7iKs7FXwE4KJCfDMM5J+TkUYGAAuLpJ6usTQEOjTxxnPPOOJ1lZJmbu7OwBgwoQJXD1bW1s4OjqiqqoKAFBTU4PIyEgMHDgQxsbGMDY2xueff46rV6/KXSMmJgZOTk4IDAyEgYGBSv1tsbGx8PDwwLRp0xQed3V1BQDcuXNHnY8LAMjJyYGRkRECAgJkyk+fPo3Zs2cjKCgIhw4dwuHDhzFz5kwYGxurbPvixYuYM2cODhw4gIyMDPj6+mLGjBm4desWVyc4OBj3799HcXGx2r6rgi5jpw7txfnll19GcHDwEx1nxtMDGxWsJ4jUHwD0n/8AYWGKj4nFkuPq2DQ3V3/KjIEBYGVlC0ByLRMTwOQvNbe1tZWpa2JiAj6fDwCIiIjA2bNnsXHjRnh6esLa2hp79uyR6YeVYmZmhrCwMMTExGDu3Lmws7Nr16ebN2+ipKQEUVFRSus8evQIAGAunYyrBgUFBXB3d4epqalMeUpKCkaPHo3o6GgY/PWLZ/LkyWrZ3rx5M/d3a2srgoODkZiYiAsXLqB///4AAE9PTxgaGuKnn37CqFGj1Pa/PXQdO3VQFuevv/4aISEh+Oijj7iyJy3OjKcLJqx6oqkJsLTUrk1loquMxkbAwkL960hbzU1NwGNaqhA+n4/MzEzExcVh5cqVXLlYSTb/0tJSxMXFwdfXFzt37sRrr72G4cOHK7VfWloKAHj22WeV1pHOx2yvjjLu3LmDPn36yJWbm5vjzJkz2LZtG1599VW4uLioZZfP52Pv3r1ISEjAjRs30NjYyB2zbHNzGBkZwdbWVmmLsa6uTqXW5ODBg7kfQVJ0HTt1aC/OeXl5+PjjjzF37ly9xZnBUBX2KpihNlJhlSaK6AiBQACxWCzzUG9oaMDx48fl6ra0tGD+/PkICAjA+fPnMWLECCxYsACt0vfOCqivrwcAODg4KK2TlJQENzc3jcSBz+fLtaIA4MMPP8Qbb7yBHTt2YODAgRgzZgzOnz+vkk0iwtSpU7lW+ZEjR/Dzzz/jgw8+ACAvYqampmhWsvrB4cOHMXz48A63GzduyJ2rSewyMzPB4/Gwfft2rs6DBw9gZ2cHf39/AEBGRgbGjRsnZ+vkyZOwt7eHj48Pt0lbk8riHBUVhWXLliE2NlavcWYwVIW1WPWEubmkxaguREBICFBSIknUYGgIeHsDeXnqv9bV9M2e9DqqCquNjQ38/f0RExODPn36wMjICDExMbCxscHdu3dl6m7cuBHXr19HSUkJTExMkJSUBD8/P2zZsgUffvihQvtOTk4AwPXnPk5aWhquXr2Kzz77TOXP2JbevXsrnMdoaWmJ6Oho/N///R9Onz6N5cuXY+bMmUr9aMu5c+eQnZ2N3NxcGQGKj49H37590bdvX5n6tbW1sLe3V2hr4cKFWLhwoVqfSYomsSsqKoKvry8uX77MlUVFRcHV1RU+Pj4AgOLiYu7vtly8eBGLFy/Gxx////bOOz6qYv3/n7ObTSEVSEISQosiTUIn0jsICIIXC4ggKtcCIhf0XsQCXL2CioIVQX+UF8pXBAUVgdBBkB4CAkrvNQHS25b5/fFwds+2bMludpM879drXufsOWdnZ2fPns88z8w8877VudLq+eOPP8ZHH32EHTt2+KyeGcZZ2GL1EZJEblhXU1gY8N57JKoAbd97j467mpe7kftki7W42Pm1WZctW4Z7770Xo0ePxoQJEzBs2DCMGjXK7Jo//vgDH374IT766CPcc889AIAmTZpg5syZ+N///ocDBw7YzLtDhw6oXr06Fi1aZHXu6NGjeOGFF9CzZ0+3xadRo0Y4d+6c3fOSJKFbt24YOnRoqZa1ElkUGjVqZDx28OBB/PDDD2jRooXZtRkZGSgoKDC71lO4U3fp6ekYNWqUUVhPnTqFXbt2oWXLlmjVqpXxGnvC2rp1a5tlqcz1zFQxXB6T7EV4uo1zGAxCtGtHU2zataPXnsDZoeoGgxBpaULs3y9ETo5nPtsVbE2BWLhwoQAgBg8eLH766Sexfv168frrr4vw8HDRpUsXkZWV5fbnpaamCgDikmKi8NixY8Xzzz8vFi5cKDZv3iw++OADUa1aNfG///3PeM3WrVsFALFo0SKrPE+cOCHUarV4/PHHxaZNm8ScOXNEw4YNRWhoqHjttdfMrpXn8l6/ft3t71AartZdgwYNxIkTJ0SDBg2EEEIMGTJErF+/XrRu3Vrs2rVLCCFEvXr1xKFDh8zep9frRb169USTJk1EixYtRIsWLcQjjzxiPG+vnl944QWxfPlysXXr1nKvZ55uU7Hwl+k2LKzlgKeFVQghNm4UokkT2noKV27Kv/4iYfXSs75U7D3s1qxZIzp37ixCQ0MFAAFAzJ07V+h0ujJ9XnFxsahZs6ZYsGCB8djHH38s2rdvLyIjI0VYWJho06aNMaiFsjwAxLp162zm+/XXX4uEhAQRFhYmBg0aJNLT04UkSVbzM19++WXRpUuXMn0HRzhbd1lZWSIsLEzo9XrRvXt38e2334q+ffsKrVYrQkJCRF5enrhz544IDAwUxcXFZu+9ffu2CA8Pt3t/lVbPUVFRPqlnFtaKBQurDVhYfYsrN+WFCySs5855zmJ2FmcedgcPHhRqtVq88847HvnMSZMmiR49epgdc1Rfb775pmjWrJndaE7OoNVqRXx8vFiyZInbebhKaXW3bds28cADDwghKJBHVFSUOHz4sDhy5Ii47777hBBkQSYnJ1u9d8uWLaJNmzal3l+26tkR3qxnFtaKhb8IK/exMm4hD3yyHMD0888/o3379mjZsiUaN26MP//8024emzdvRseOHdG6dWs0bdoUGzZs8Fj5WrdujUmTJuGdd94xG2TjLq+++ir27t2Lw4cPO/2eXbt2YerUqWVahm7ZsmUICwvDiBEj3M7DVUqrO2Xf6VNPPYXPPvsMycnJSE9Pd9i/evjwYWMwEXtUpXpmKi88KphxC1uLnut0Orz88sv4888/ERkZiYKCAqjVart5tGzZEjt37oRKpcL+/fsxefJk9O3b12Nl/OCDD/DBBx94JK/4+HgsXrwYGRkZTr/HEwuEq1QqLFy4EAEB5ftXtVd3hw4dQocOHQAAbdu2NQZSOHz4sNmI4J9//tkYsQkAfvvtNxw6dAibNm0yG7z07rvv4qGHHjK+rmr1zFRO+C5i3CI42HxtVoriJCEkJAQTJ07E448/jj59+pQqrKtWrcKiRYuQl5eH/Px840hgf+XRRx8t988cOXJkuX9maSxevNjm8dmzZzu8ZtGiRcjJyUFERIQxUpUtuJ6Zig67ghm3sLU2q1qtxpEjR/DII4/giy++sBt7FqD5kcuXL8cvv/yCw4cPY/To0VbTH+xRv359CCHMLCKG8QZ8rzHuwMLKuI3sDi4oIHfwiRMnEBgYiEGDBuGll15CwV3FHTVqFFatWmX23vT0dKSkpKBmzZo4duwY5s6da+yjYxiGqciwK5hxm2rVgFu3TAOYZs+eje3btyMsLAw1a9bEvHnzAABpaWmYMGGC2XufeuopDBkyBGvXrkVKSgpiY2NZWBmGqRSwsDJuYzmA6euvv7a6JisrCwkJCVarhTRs2BDHjh0rj2IyDMOUK+wKZtwmJIS2Wi1gL8JcVFSUR6fRMAzD+DssrIzbBASYFlZ3dW1ZhmGYygoLK1MmlAOYGIZhGBZWpozI7mBnl5BjGIap7LCwMmUiNJS2yghMDMMwVRkW1nJEVELlkV3BxcWmNWIZhmEqGp58PrOwlgMajQYAjAETKhMaDaBWk7VaWOjr0jAMw7iH/HyWn9dlgeexlgNqtRpRUVG4efMmAKBatWplWonDWxgMBpSUlKCoqKjUWK6WBAcD+flAdrZplHBVwN36qqpwfbkG15fruFNnQggUFBTg5s2biIqKKjW+ubOwsJYTcXFxAGAUV39ECIHCwkKEhIS4JPy3bwO5uWSx5uZScP6qgLv1VVXh+nINri/XKUudRUVFGZ/TZYWFtZyQJAnx8fGIjY2FVqv1dXFsotVqsWPHDnTt2tUld0h6OvD668D99wPffQcEBXmxkH6Eu/VVVeH6cg2uL9dxt840Go1HLFUZFtZyRq1We/QH9CRqtRo6nQ7BwcEu3ZT33w9cuEBxgwHTqjeVHXfrq6rC9eUaXF+u4y91xo57psw0bkxWal4ecPq0r0vDMAzjW1hYmTKj0QBNmtB+Wppvy8IwDONrWFgZjyCvUX7kCGAw+LYsDMMwvoSFlfEI8lKqx47RajcMwzBVFRZWxiO0bk3bv/5iYWUYpmrDwsp4BNkVfP06cOOGb8vCMAzjS1hYGY8QEQE0aED7Bw74tiwMwzC+xKPCeunSJXTv3h1NmzZFcnIyVqxY4cnsGT9HtlrT03mlG4Zhqi4eFdaAgADMnTsXx48fx4YNGzBx4kTk5+d78iMYP6ZlS9oeP879rAzDVF08GnkpPj4e8fHxACg2bnR0NG7fvo1QedFOplIjD2CShbUqBeRnGIaRcdlinTlzJtq1a4fw8HDExsZiyJAhOHHihNV1Bw8ehF6vR506dTxSUMb/kYX13DkKxs8wDFMVcVlYt2/fjnHjxmHPnj3YuHEjtFot+vbta+byvX37NkaNGoUFCxZ4tLCMf5OQANSsSQuep6f7ujQMwzC+wWVX8Pr1681eL168GLGxsTh48CC6du2K4uJiDBkyBFOmTEHHjh09VlDG/5EkoHlzYNs24NAhoF+/qrOEHMMwjEyZ+1izs7MBADVq1IAQAk8//TR69uyJp556yuF7i4uLUVxcbHydk5MDgJb+8cTSanIe/rpMm7/hifpq0UKFbdvUOHpUj8JCAyrzohx8f7kG15drcH25jjfrzJU8JSHcnxhhMBgwePBgZGVlYefOndi5cye6du2K5ORk4zVLly5F8+bNbb5/+vTpmDFjhtXxZcuWoVq1au4Wi/Eh27fXxpw5bdGkyS3MnLnT18VhGIbxCAUFBRgxYgSys7MRERFR6rVlEtYXX3wR69atw86dO5GYmOjy+21ZrHXq1EFmZqbDgjuDVqvFxo0b0adPH17P0Ak8UV/HjwMtW2pQrZrA+fM6REV5uJB+BN9frsH15RpcX67jzTrLyclBdHS0U8Lqtit4/PjxWLNmDXbs2OGWqAJAUFAQgoKCrI5rNBqPVoqn86vslKW+mjWjhc4LCiScPatBSoqHC+eH8P3lGlxfrsH15TreqDNX8nN5VLAQAuPHj8eqVauwZcsWNJDj2DEMgIAAoGlT2j940LdlYRiG8QUuC+u4cePw7bffYtmyZQgPD8f169dx/fp1FBYWeqN8TAVE7mL/809Ap/NtWRiGYcobl13B8+bNAwB0797d7PiiRYvw9NNPe6JMTAWndWtg8WJTBKYAj8b3YqoCQgAlJUBxsXXcaXtTuNw9HhiISj16nSl/XH7klWGsE1NFsFybNSTEt+Vh/B+lkBYVAdnZwO7dtAxhTAzQpg2guutfsxRK+ZFk67gtURUCMBioqyIzkwKb9OkDVK/OAst4BrYlGI8jr3KTkQHMnw+0awd06QKo1b4tF+M/yEJaUgIUFgL5+bSv1QKbNwOzZpGoysTHA//9LzBgQNk/e+1a4O23gWvXTMdq1QLeegt44glaApEFlikLLKyMx9mwgURUrwf+/W86lpAAvPceMHgwvZYtCUky37d1zNZ5vR7YtYsWVU9MZOH2d2QhBchKLCoyCakkAUFB5Nn4/XfgX/+ydv9evw7885/AggVlE9e1aykfy/xv3gRefpnK89BDZL2ywNr3BjClw8LKeJSffgKGDbN+cF27BowZA3z8MbndLLHltpOPWQrrxo3AzJnmFk1CAjBnDvDYY577Loz7CEEiVVxMKS8PKCigc5mZJKLBwUB4uOk9ej1ZkrZ6m+Rj//43uXEDAsg1rFabb0vbFwKYOtV+/pIEfPghCfe1a8CdO1VTYGWXfH4+sGUL/V5JSfS/tTE7krEBCyvjMfR64JVXSn8wvvce0LYtUK0aPViDgmhbWotYfq8QwLp1wMSJtoX7iSdoVZ3HHqM8q9LDUInBQA/HHTuAK1eAuDigc2cSI7mhIieVyvy1u8hCWlJC1mhensnVK0k0QCg4mK6NirL2LuTnA0uXmrtnbXHnDvD88+6X09F3uHoVOHIE6NiRXNRVQWD1elMDKDeXfr+1a8kdf+OG6bq4ODr2xBMssI5gYWU8xu+/A5cvl35NRga5bS1Riqy8tTwWFEQt6NIsjjffpD7dkBAgLIxSSEjlGpksBD0MdTrayvuykK1ZA7zzjrlFX6sW8PrrQN++1uJqKbSlJfk6g4EGF924QSsa3X8/lUMppEFBVP8yer1pPzMT2L8f2LsX2LcPOHrU/HxpJCWROMv1oNdTeeSkfK3cLyhwbjnD1asp0ElkJN07lU1ghTAJaUEBpaIiOqfR0H9s0iTr/9mNG+R1ys0FHn2U6sFRo7iqUokeN4yvcWRtyAQGkhAYDKZjRUWm0aDuIgSJSXo6WWh37gC3btGfPywMCA31H5HV66khcu0aDcxR9hErBUMpoFot1ZFWaxINpRipVDTwZ8IE232I//oX8NVXwIMP0nlbSaezf07Oc+NG29bMtGnAoEG2XfoXLwK7d0tYv74Fzp4NwJkz1nUSHU2C64j33yeL0lX++IMEwRHffQesWAH06gUMGULbGjUqtsDK905REQljSQn91gEB9H+MjKT7R6+nQWKlNV7few/o2hW4fZvqIDKSPFAql6MiVF784BHDVBbi45277rvvgA4d6I9dVGSaYqFMymPy/r599MBzxJgxppHIXbsCjRvTQyAz09SvJ4usLwY8/fQTucyV1n1CAvDuu9SPVVJiLqzyQ06tNiWNhr6Lsvx6PT30SnsozpgB9O/vfuNi7Vr71sxLL1G+/foBf/9Nv5ecyHoOAFDf+J7Gjel3SkkB2rcncU5JoWttfQdJonvM3TCZKSn0fnv5A3RvxMUBp05Rt8O6ddQo698fGDoU6NSJRMrfBdaWe1f2JgQFkRDaugfkxp49hKDzJ0/Sb5aTA2Rl0f+penXa+kPD1ddwFTAeo0sXGqF75YrjB6Mk0cNIozEfwFIa9es7J6wGA7kY9+4FZs+mFnWnTiSyKSlAbKy5yFarZi2ypVmUziJbm7LFqdMBq1YBY8fa7iN+9lngk09o8IxaTdfn59OD684dSrb25W1GBj3o7CH3IbZoQXUgWxuRkeRalfeVx+RroqLot3I0uGj8eLKALF2uAQFAcrIBdeuewaBBDZCSEoDq1a3z+e9/adSuJJl/jmwFz5jhfmNIrXac/8cfk4j+9Re5hFevpvt5xQpK0dE0sn3IEKBJE3OBDQ+n7w545v5xBVvuXTm4hkZD5QoNtfYmaLXA4cM0wn7XLvrPOMOlS+Q1iIw0udkvXaL/UVSUeV1URVhYGY+hVpMwDBtm/8H12mv08FeOAi5tQI3yfOvWpVscsnAvX04PiR07aJudTZbW2rV0Xf36JLIPPAC0akUPAaUlu24duU2VFmViIn23Rx4xHZPLID/QZHetPIDHYDCJKkAiOWVK6cI0aRL1j2Znm6aneBpZmF0lIMBxiEq5LkJDKahD+/bUmGnVCggM1CMt7That65vV2QGDKApNZbzTOPigOnTyRrW661Hilvu28Ne/vHxJNryVJ6mTSlNmQIcOEANol9/pQbZwoWU6tUDHn6YhDgx0SSwmzcDkyc7vn9cxbLvWKsFdu4k4Q8Pp1CiQtD/MCiIGkWW7lmDgSKi7dpF7927l+5LV3n9dXr/0KHUaAgLo88uKqJ6ld3EVbUftkzLxnmanJwcREZGOrUsj10uXjR21Gh1OuzauROdOneGRvZPREcDdeu6X0hF/jbx9/xLQavVYu3atRgwYECZVoaw5epMTKR+ucGD6c+t7LdTPiwsB6LId6e8n5pKeQO2hXvePOrnk9HrqUW+fTtZEAcPmouDWg20bEmt7/btqS/y1Vfth9FbsoQepEVFQEGBFn/9tRYNGgxAVpYGN27Q+zMzyXq8eZPSjRvUGMjKcr0uNRp6WMspKsr+9sIFKrsj3n+fRCE72zxlZZn2ZRefvO/swCIA+M9/TG5hJXq9Fmlpa9G69QCo1db3lzyyWKul/syDB6mPPDaWRpLLIqH8bWztKxtt9qZxyZGXMjIoslNKComRRmPflanVUmNt9Wpg/XrT9CGARPihh0hE3nnH/v2zcqVJXJX3vq1BV8XFWuzduxbJyQMghMbs2vXrrfu5bQXREAI4c4ZEcNcu6me2vA+jouj+79SJumiefLJ0d7k8R12mRg36zw0dSr+TJJksZ7WaRL+8+mGVzzCVSoPffycvTUJC2b0GruhT5RLWixeBRo1MQ9xsERwMnDjhnjhV9Pzlz7Aj3FqdDluPHEGP0aPLvOSSp1xh8sNHKcSrVpFFcOWK6bqEBOCNN2igiSyccl9kQICpDywvjx4uO3ZQshxEY2lpWxIeTg+RW7eAmzcNuHy5CFlZIdBqPdcknzKFHr5RUfQwcra1r9c710e5Z49rv4UQVG9btpBgOmLFCtuDiyyFVaczCalOZxpNrNGQBRQYSEmeg6osT2n7rp7X6UjIi4tNZQFM943y/pEpKKBBXKtXA1u30vscIUl0n+7ebfpcS2FVlksILc6eXYv77huAwECN0ZuzYQPwwgv2xXvmTKq3nTvpXleODgfIm5CSQkLauTM1CpSCJwfRsKwrOf/58+k+WrUK+OUX88dJnTrkJh86lB5lWi3VlRD0uVFR9Nt6yi2uHIsgN0Z27lyLjIyBePvtADOvRFm9BlVXWNPSyP/kiIMHTQFtq1L+Tgi3XqOB4a+/oLnnHtfzlz+jHCxuW8KtUpke1LI7tqDA1M8JWIvtlSsksNu3k3C44xYD6KETE0Muy1q1aBsXR2WT9y9eBJxZp8KeMMnYEw6AHoovvGB9Tn4oliVyUVmEWwigsFCLY8fWIilpACRJY/wN5D5uWVR9NRDIYDDdP7LVXFhoun9kN6vy/pEkcgGvXWtaeMIRjzwCNGxomstdrZopyYEzQkIAjUaLkyc3oX373ggNpfqSfwNnR+ADZIm3bUtC2qkT9bE7qmNbYR8TEszd5QDVy86dJLLr1pn/f5o0oe/68MN0/xcW0v8yJIS8LCEh5Iq2NzJe6cWyHCUvTy2z9HQJocV33x3CBx+0gxDmLVJbXgNXYGF1xEcfAffdZz7MUhnCxVZSqWio4z/+4Tj/vXtpuKOrHQt+ItzavXuhad/e9fx9bHEDsBJupXvRkdj++iv1rTqiTx96CMTG6pCd/Qe6deuAuDgNNBpr97bS2tZqgZ49yX1nT5hq1SJ3t1pdukuztP0NG6wjU8XFkYu2d29TP7YyKpHydWm3rSNrRhZu2RqVRzjTZ2hx4sRapKQMQGioxiik/jxNQ+4nl+8h5f2j1VIdqFT0PdaupeAl3kIWdGdW6LzvPppW1akT/eVdWQhDCFMM5717yV0eF0du4pAQ+79XYaHJit+yxdyKf+ABsmQHDqRHwJo11CVhGT1NOTLeUjQB83vXVtStkhIt2rbV4datYADWN7IkkeV67pzrVjMLq7+gVtM/wV6yPF9SQuLtiMGDqYknP5mUTX3LY8rtxYto5hbfAAAgAElEQVQ0esgB2s2boenc2dQkdxY/sLidEW57YrtrFzB6tONiLFlC/bFaLbnqkpKoP0cWP1sBFeSfOjWVRgXL5ZCRq3npUmrhWx53dV+OpXz9Oon1Aw+YYiwrLTN5cJVlH5/sErcVGnDDBrJcLAf/TJ0K9OhhGokqW6PBwXT7SZIWGzaUvQ/f18huXLkO5f7EnTuBp55y/P7evWlQjzydrLDQ3r5AcbF7XQxffEFC5gxypC75+8hTcpQBPgoKTBanwWD+uLEltLIVv2oVeTDke12jIUv2yBHr98j37qef0jgGIehzlX3+yiSPiFemjAyBnBzHdbZ1K2Cx8qlDXNGnqjkquHFj+rdbjpZRvrbcl59GeXnOf47J8e/Z8v/yi2fzs0DTq5fphWUIpNJCJDnrR929m/6l1apRx4tyS09g2++To7eXRlERXVeKsMp9efIUBID+xAm6i3gDKlxBAgSsnxYSDEjEFfRqKKCOovzPnqWWtlxsW5GKlFbgs30uovoHOrzyYSIu3zTNR0iMLcHcVy/jkS4BQJhnBqfZislsC8vBM5Z/ATmYgCzCPXqQJbR/P1kzsbFkzcjuTHkQkOVP6Uw/ZEVAOVVMSXw89Y9fvVq6R+Lzz6mO5HjH9tDrdThwYC3uv38Aios1KCqiv86ECY7LGBtbWr4mIdXpqAyBgSSi8u8XGGg+iKt6dfO5sbLQ5uTYFtrq1WkQ1JNPUnfLr7/SoMZjx2yLKmCqs4kTKYKaPHvANZxriLjiSneHqims331XusVkOcpB9uWlpTk3O/2336hZJj+N5DvYcqvc1+tpVvrUqY7zf/ppcnnKTzx5q+wgskw6HTXp/vrLcf5K5OazJxk/3v45tdpabENDKTk7/yQtjZ5iYWE02kh+YpTyFJMkICQ/E5/gXQzDSkgwmImrBPJFzcUrqB30JhBX1ygUTgcIuGtxP1JUhIehwu/ogmuIRzyuocuN36F+zQC8Vb6ucsDUCHA0sV/Z72UwAA0amALilzaatqoQFETWVmnTzd59l66T+3DlqUNyd4S8la9XqajdKjcAhwwxufmdDaKhdMsbDCYhlUM2ykLqyDWqVpsaT/aENjvb3GMRFATUrk39/i+8APzwg+PuFr3ePAKbPOjJMsmj4ZXp3DkdXnvN8Y3obDAbd6nifwU72JokBzj/5IiLo6eOq6SlOSesL7/s3T7WjRuhadLE5CMtLjb5qOStZWik4mLg/Hngm28cl6NBA9OkN/kfKauUXk9N1dIiHThC9rUqkST6hyrFVt7K+wUFeASrsBLD8Ao+wWXUMb49EZcxFxPxCFYBF0eRSRAQAJU8C98ZFBa3GgZ0x3bra5ywuO3i5T5uWQB4eT77PPIIDY6xNd1s7lw6L4esVLaz5b9SSQn9JZRTzQoLTRauM0Eu3n6b/o6ykMoNH3nAkBzHuax925ZCK7fx5ZVxioqoLa8UWmd7AN56i4azREa6FmiiTRuBWbMKcft2sNXgJcDUx2orXrknYWFlrImIoGamq6SlOSesK1dSw0A5wkdeW8wy5eeb0smTNF7eEYmJpnH++fmmp5Scp+X8AwsewSo8jJ/NLUr8DvVdqxVDhwIANACMU2Zll7hyaKflME9nLf9TpyiyfXg4/RbONug85CpnyoY8EtbedDNJMg2rUKLsu9Xp6PY9e5bOFRWZRiZ36ECW8f/+Z73Qwn/+Q32HKhU5J+T+bXt9oZ5E/k6lCW21as7llZxMo+xlLwlgHq/aMn61vK/XA8899yc++KCd3YbH3LnebxxWLmGV7yRHLfbo6KqZv78h+yAB+uc7im2YluacsK5eTaF+ZL9lXh5ZwNnZFGsvJ8d0TCni584ZYybatSgBEknlhEfAZHK4EwXCkieesP688HDzJIe1iYgwvS7LCgaMR1GrXR8cY9l3K4/krVePzil7ex5+mFYq2rOH+rlr16bPCw01Camvox3ZEtpataj/9Nq10vuhGzakwUm2IrCVtg8AHTpcw2ef6fHuuwFmDQ+l18DbVC5hrVuX3Fzeirxkkb9N/Dl/J4Rbr9GQtVSRUY4iCgggv5cz3yktzblgxBs3Ai1bQltYiA2bNqFvixbQyD68ggIS6cJC02vZ3X3+PE12dEREhMm9DpgmVN686fi9zuAoLiHjV8jTeSxdogaDSXRdHcDvCwICqA342Wel90N/9BFw7722xdORsOp0NIzkn/8UeOGF8o3XbPZdy+djypG6dU3Co9Ui+9o1sl48Nbxfmb838Gb+DoTbGHnJi8JdKSzukBCjaaALCaGngKP7SwgKOuuMsP78M/nCCgpMlrbS4lZa2/LrvDwajupMFPVu3Wi+0AMPUOidzp1hMyK+LXwYcpMxR6WqmAuOO9MP7S7KxoU7XgNPUfmElSmd0oRbq0VhWcah+4HF7bfCLY/8cYaICArAWqOG9TllBArL7aFDJJKOKCoyxXT84AMqW6NGJLQdO1IejRpZd8qVRwAQpkrgqB+6osPCyngWH1rcACq/cCuXALLE2fA6n39Oy48cOEBifOkSBSb5+2+TRR0dTdHD5Ojs7duXz+AotoirDL60KL0NCytTsWDhLjsdOgDNm5sCrp49Sy7k/ftJaI8fpzqQV/oGqIPP3fjRzsIWMVNJYGFlGCVVRbjl4afywqktWlDgkeJikzW7fz8N6Dp8mI45G1xkyxbqA46OphQZaVq5HTDNn7CEpwsxlQQWVoYpT/xVuC3nRtSvT+vjlZTQwKgTJygm3ZdfOi6HZTxqtRqIjERAVBQ6BwVB/cknpj5kOUVHe2aqkiPY1cyUAyysDFOZ8JRwK8PqREXR6JKQEOeEtX59snyzskxx+27fhnT7NmoCrofVtOTbb4HTp6lMiYk08VGOB1haFAR2NTPlBAsrwzCOUatJdJzhk09o9WyDgYT19m3gzh3o7txB2smTaB0cjIDcXJo+lJ1NApydTWGElPMv7DFnjvnrgACyNGNjTYvh1q5NwpuQQPuJiZQ/u5qZcoCFlWEYz1K7tilCv2LpHFFSgmu//w7RoYNp7T55AQohaNkTZ9Y7btPGFDDj1i3K4/p1h6Eqy2XhV3Y1M2BhZRjGWZwdHBUTYztav7zQQvXq5gE15Hm4t245V4633gKaNTPFmM7MpNXjMzNJbDMyKGVmmu/bGzRlyTPPUFCZ++4j13GTJs4FAWFXM3MXFlaGYZzDW6OaleumOUNiorlFfO+95taxHCNauWSiVksrkT/3nOP8Dx+mpEStpviBDRtSatSI1nVu3JgsdEniUc2MERZWhmGcx5ujmstqEZeGweD8IgUTJpAQnztH8Z0vXCDX89mzlFJTza+vVg1ISqJyMQxYWBmG8Re8Oc/XmZXcZZ58kmI1y/2/JSWm6FRnzpC4yqJ75QrFdD561PUyMZUWFlaGYfwHby9y4QwBAdYjoGNiaA1hvd4kuDodWddnzpDo7twJLFzoOH9n+3qZCks5DJNjGIbxA2RXc2k4CimpVtOSMtWq0WIJsbEUInLMGODFF50rxz/+QVOSyiMgBuMT2GJlGKZq4O2Qks5O57l4EZg4EZg2DRgxAhg3jgZDOeuqZvwe/iUZhqk6+IOr+ZlngA0bKBjGvHnA/PlA797ACy8AffqQNVwec24Zr8G/HsMwjCdw1tU8dSpw8CDw1Ve0Bq7BQEL7yCMU/OL992mwlKOpO4zfwhYrwzCMJ3DV1fzMM8CwYcC+fbQO7q+/AidPkvB+8AFUw4YhOCWF+mIjIqhvF+DoThUAFlaGYRhP4YqrWaMBatYkN3D79sC//w18/z2ly5eh/uYb9Fm4EFixAhg9GujcmZbja9fOu9GdWLjLDAsrwzCML5EFNiKCVgZ67jlg/XoY/u//oNq7l9zEGzbQwgbdunk3uhOHZfQILKwMwzD+gCyw4eHAk09C368ftqWmovsff0D1yy/A8eOUnCEvj5JKZZ0kiZItOCyjR2BhZRiG8ScCA8ndGhKC3Pr1oe/XD6qXX6Y+2IULS3fTysyfT0vmqdU0jUejMd8GBNDnBAZS361GQ/sXLnj/+1UBWFgZhmH8kcBA2tapQ0JbqxbQsiXNfXXEsmXeLVtOjnfzr+CwsDIMw/gzgYFAaCj1wV686Nx7+vSh6/V6U9LpzMMxKl/Lx/LyaKqPI3r0oP7gli0p1GO7dkDbtqVHrZKpAoOjWFgZhmEqAoGBtJatM4wdS4OdAFrvVkbuW5X7WS3T8ePAkCHOfcb585RWrzYdS0wksW3ThsS2dWsgPt50vooMjmJhZRiGqWxER1Mfq6VwKgcv2Trn7NJ6K1aQOB45Qiv7HD9O/bOXL1Nas8Z0ba1aJLBt2gBRUVVicBQLK8MwTEXB2TVr77nHeetWibOhFJOSTKv9yIvJ37pFEaXS0khsjx6l5fVu3ADWraNURWBhZRiGqSh4eyEBZ4Vb7ktVLjgfFgbUq0ehGWXBzc4GDh0iwU1PBw4cIPexIy5fBlq1sj8tyM/xuLAOHToU27ZtQ69evbBy5UpPZ88wDFO18eZCAp4Sbllwg4OBBx+kBAD791OUKUc8/DAQF0fRprp2pW1ysknESyEkI4PE3N5qQeUwOMrjwvrKK6/gmWeewZIlSzydNcMwDONtvCncTggjABLF69eBlSspARQ444EHTELbvj2tBKTk4kX0euklqLVa+3mXw+Aojwtr9+7dsW3bNk9nyzAMw1QVNm+mqT/btwN791K/bW4usHEjJYCCWrRuDXTpQkLbqRNw61bpogqUy+Aol4V15syZ+Omnn/D3338jJCQEHTt2xPvvv49GjRp5o3wMwzBMVSMsjCzTAQPodUkJ9dNu3Qrs2UMrAt24QaK7dy8wezYAIKBePR8W2oTLwrp9+3aMGzcO7dq1g06nw9SpU9G3b18cP34coaGh3igjwzAMUxlwdXCUTGAg0KEDJYDWsD15EtiyBfjjDxLaU6cg+UlIRpeFdf369WavFy9ejNjYWBw8eBBdu3Z1Ka/i4mIUFxcbX+fcDZOl1WqhdWTOO4GchyfyqgpwfbkG15drcH25RqWsr/h4moZz65b9a2rWpOscfe977qE0diy9vnoVYtEiBM6Y4bAYWp3Ocf6W73Hh+jL3sWbfnVBco0YNl987c+ZMzLBRCRs2bEA1y07pMrBR9skzTsH15RpcX67B9eUaVa6+rl0j8XWDyIgIdHfiul07dyL72jWX8i4oKHD6WkkIZbwr1zAYDBg8eDCysrKwc+dOAEDv3r1x+PBh5Ofno0aNGlixYgU6yOa7BbYs1jp16iAzMxMRERHuFsuIVqvFxo0b0adPH2g0mjLnV9nh+nINri/X4PpyDa4v19Ht24eQzp0dXqfdu5fmybpATk4OoqOjkZ2d7VCfymSxjhs3DkePHjWKKgBs2rTJ6fcHBQUhKCjI6rhGo/HojeTp/Co7XF+uwfXlGlxfrsH15QJO1pNGXkLPpaydv95tYR0/fjzWrFmDHTt2IDEx0d1smHLm0iUgI8P2OZ0OyMwM9lr+ABAbS3G6q2r+DMN4kZo1oddoHM9jdWYVnjLgsrAKIfDyyy9j1apV2LZtGxo0aOCNcrmN8sGo0wFnzkSaBeHw9wevN/MvLqYFJ27csHeFBlFR3fD44y435pzMn4KpnD9PaytXtfyBin3/VIb8mUpO3brY/OWX6JGcTFapLfwx8tK4ceOwbNky/PzzzwgPD8f169cBAJGRkQgJCfF4AV3B+sGoASy6sv35wevt/AMD6X7KyKDR6paoVALR0YUIDAxzPXOn8qc1m+X1m6ta/hX9/qno+QPcMKgKFMbEUP+pD93nLgvrvHnzAFCEJSWLFi3C008/7YkyuU1Ff/B6O39JAt55xxS20xKDQcKTT/4FSWrnpfyB6dPdytrp/N95x/243d7Ov6LfPxU9/8rQMAAqfuOgKjQ+3HIF+yvOPBib6v/Ee/3v0MNRku5uVab1f1WSxTkJkgoA6HXLkCjsN9iOMmUwAC0izuKjp/MhQGscCkml2L+7FRKgkiCgOHd32zg6GPsNMXbzvzcuF2+9rIeAKW+rfcifZXFMUB6xsUDGTUGfKdcdBKKqA+vX18eBA2rj4hTupNIYOND891KpXEuSRA1RrVYAUCqcQFCQhIkTza9Vbm0dszwnSRSSNDfXuuxRUcD8+cA338ghT9W4fr01Vq5UIyCAjsl52dpXq4EGDSgOub3ft2VL4NNPTTHMXU3/+Efp+T//PK3kFRBgntRq89dyfSjhho1v8wcqfuOgPBofGRnBpcbgLw/hLtN0G0+Tk5ODyMhIp4Yz20MIIKW9wIEDAgJOri3IMIwVtkRXrQbu3LHdgAoJAe67zyTMstjL+5JkwO3bmahVKxoBASqzc6ZrKBTs7dv0X5aRJHogjhlDwqTR2E+lnT9wAHjlFfvfecUKoE8f8+8tl8sZUlPtNwwAYP16oF8/5/LSarVYu3YtBgwYYByRKgSQkkLR/eyJd5s2FOXPnQZIRc8/L0+LOnX0yMqyPwjTXeF2RZ8qnbACQOr/DuDBN9taHe8buRcJkXlkMUIY/7hmW+O+sD53d3stPwLbC6yXPuoeshvxwVl37UNAEgZIMAACkGCAdPcDlFvz8wYAAldKYrBOZ/3ve0i1BvVUlylfRVLBAOluwSVzG9WYlOcAgUUYg+uIh4AKEgyojcuYjI8QCC00LqQA6Gwc06I/1uMIkqFHANTQIRmHsQm9IaCCQZGoBlQuJT1UGI0lOIHGMEANFfS4DyfxFZ6HgAp6lQYiIBD6gEAYNIEwqAMh7m71miAY1BoYAgIhAjTQqwNhUN+9Xq2BIUADg6TBuwcfxIXCGAioIUGPOqFZeGXAKRgCg6APCIY+IBA6dQCuZFxGbGITGDQhlD/URs+AXk9bIWggnXz8wgVgwwbr+7ZzZyAmxvQ+vd69/dxcmmNvSVgYPbj0eiqPvGUco1JZi62trUpFS4naitgXFkbWmkZj3VixtS9Jely+fB733lsfGo3aePzcOeDbb+2XdfJk6mK09Eo4m3btAkaPtp+/K40DW3iy8WFJSYkWzZrl4ezZKBgM1spcFuGu2sIqBET7FKQc+AJpaGV8sLfGIextOw7SPjebQt7OX6Hcon0KUg5+aZ1/6xch7f7D+j3Kp7fBYHpqKp+g8pNXpwMeewypx+vgQbHOmNV6qT/6NDyL3599Fp2aNkWAnJ/8fq3W/Gls6zPk677+GqnXkvEgTOEv1+NB9Is+SEG1lfm5utXpgPx8pOZ2wINIVeTfD/1gQ63cJBV93ctfowFCQ0tNolooUn6YjLQ79U2/b62r2Pv5fkhhimvDwszf6+RgDIMBSEkROHTAAD3UUEOPVm1V2L2b7kshzJPS7S9XsVzllsd0OoqH/sILwOnT9FkqFbm433vPlJ+l4BsMgFarw9mzh1GnTgsAAWbnlPs6HfD//h+tGiYE/Z1iYoChQ63LZev2KCkx/w6W5/PyaP1txj0kibwCshBrNLa39s6p1RRHPzvb2isRHQ3jrARX86bGiA4//ngK33/fxG753RXuqi2sd5tDdh+MHmpuVfT8BYAU7MV+tEc77MNepEAC8Me0aWj3xhvuT0h3kH+Zyi+bfA88AJF2CCmGP0z5qzpCSm4OrFpFT9aiItO2uNg8Kc/LSas17Z88CbF6tXX577+f5sAVFACFhRAFBdDl5iKgpASSi6afW8IdGEgCW62ateiGhZmOhYUh9UBNPLj5NVP+E9ej33vdyF/rASytDmd+VluuTU/mbwtbHichKJb7oUMk5mo19W3v2EHnlCKs3JcbIMq2pTIp24uvvkqWpdzwqFsXmDLFdlvU3mutVo+rV08jOvpeGAxqs3bt5cuArdU5W7WisQDKay23pZ0zfTbtVybUalplzl03c9UVVoUDXxgM1g9GD3YQVPT8YTBgE3phAj7Fp5iA3tgMoVIhKykJYceOQePOCAsH+Ze5AwUwe+Ja5Q+UveEhf4e0NGzSdzflr95m+lfevU5bUoK1qakY0Ls3NLIPNjeXTCLLlJ9PglxQABw/DvHTT9a/r9xBWVhouraw0C1/rd2GTc2aNIImMRGoV4/269UzLW4dH+/UYtTCIJASfhz7C5qhXbVj2JvbFJKq9N/UFWGVf4b9+8l9WpZbxhaeEm5v5l9afSluU2PjwBnRsGxoWB5Tpk6dgPR0U/7330/tVlteA1vJkffgk0+Aq1dNXolatYDhw60bMLa8JpYNHdP1BuTmZqO4OAoXL1pXRFl+Z5f0SfgR2dnZAoDIzs52L4OiIiFq1TLeGxvRSzTBMbERvUz3S1wcXcf520yFUVGiJDfXa/mXqfwGgxDt2gmhUtnOW6Wi8waDe/kLIcT69aWXf/1646UlJSVi9erVoqSkxPXvoFab/75qtRBt2wqh1VIqKaF6KiwUIitLiIsXhTh+XIh9+4TYvFmI1auF+O47IRYsEOKjj4T473+FmDJFiJdfFqJfP/v3j6OkVguRmChEhw5CPPqoEJMmCTFnjhA//STEgQNCZGbSd1i/3jx/Rb3Yw9X62rhRiCZNaOtpDAYh2t2XJQDaluWWsZt/O6pSd29JR/Vleas68RO4REXL32AQoriY6qywsES0bUu3s3xbl/XR4Io+lXl1G78iKIiauHcnSXXT6fDlzvXo1Pk989BL7o7jtsi/N4DjKALwgemaCpS/JVqdDtv//BM9vZQ/gLKVv6QEuHjR9nBCgI5fukTXufMZQgBvvUWWtb0hi2+9BfTt6775tGGDcT5Mb2zGcTSj43rQkNXNm62b1MHBQGSk898hJQVQq9Fbr8hfrQaaNQM+/5yGRF64QP7Eq1cpXb9OcyBkP+Ply/Y/IzgYEAK9UUz5SxIw9iR1stauTVZv7do0b6kM9MYmHMcEAJ+C/g2eQ4LAe5iKCRiH9/AFJHwO8+lbZcxfouqYMIG2nrS2Zfr2JWtetur79q3a+cvT5QC63d991+Q10OvLNlXLVSqXsALk2qpTh/a1WloayJNROJT5ewNf5q/VosjFpZRcyr+ssHA7RiHcZuj1wJEj5F5+6ik6phzQptdT//PVq9Q5eP487V+5QkOMr10j8b1923rIqxBUL3K+MmFh9HvExgK1akFVqxYaFhZCunqVhDchgVJsrPWkQyGAqVOBv/6iba9enn0qbtiA3ie/xHF8CZwEsGGwZ33BAHr3Bo4f92iWZnhbvCt6/t5uGJRG5RNWpnLDwm0fV4VbjmAhNzrDwqgPtnlz0/Beyw6trCzgoYeAU6esPyMkBKhRgxaxLioy9S+fPQsAUANoCgBLl5q/T62m4aB3BRi1atH75QbC/v309L33XtMgM7kjr7R9uYNPOUBNq6UGxMmTps+XJOCf/6RJrC1bli2CQznjbfGuyPmXh9fAHiysDKOEhZuQJNMcBiUHDwInTth+T2Eh8OGHQMeOJMA3b5KVm5EB3LwJfUYGrpw7h8TiYqgyM4HMTLKA9XpyQ9+4Afz5p+28P/+89PKWBSGo3lJSqF5ataL9jh1p+HBiYvk+lRmP4e2GgT1YWBmmPKnIwu2MRTxnDvDEEzTCWDk5Va+HobgYh37/HfEpKRQTraSExDgjg0T15k1KBw8Cv/5qnX+rVmTNymGU5EmMtkIuBQaaXsv7cnr3XXJ1W34HtZqs2T17KH3yCR2Pjydfoiy27dvTlCdHbNpE5tKnn9ITnqkysLAyTGXCm8LtqkUsxzSUkV2sNWua3M9CkItX2d/brRu9TzmRUs7nu+9MMQaVAZ9L21dam6mpRte0FXo9WcZCkLAeOkTW+bVrwC+/UJLL0qwZCawsto0b02fKeLuPmPFrWFgZhnEOb1jEkmQSYI2GhC8tzfo6vZ6Ebv/+sgUYcWRxL1lCk0FfeokaCFlZ9Hr3bipXejp9/yNHKH3zDb03KoomkrZvDzzwAFniyj7iDRs8PjiK8V9YWBmGcR5vWsTeHjXtqsUdHEwR2x9+GBg0yBSx68wZ4I8/SGgPHwaOHSMB3rKFkiWSBIwfT42GxERTUGGm0sLCyjCMf+DtUdNlsbhVKhLa4GCKHtaqlSk8ZlYWWdMHDpBFu2+f+WcIQYGV77mHRk3fdx/QtCmFMmreHEhOJovXHwXX2/3EFT1/O7CwMgzjH3h78BXgOYtbpaLpRSEhFLyjTh1y9RYXA92705QjWw2E27dNg6OUJCaaBDc5mQS3YUM6Z6+hAXhXOLzdT1zR8y8FFlaGYfwHbwdI8Ray0O7YQe5he0ydStedPk0u5ZMnaSS0HO1K4UoOCAhAj4QEqJOTabCUbN0mJZlGRXs5iIZX+4krev6lwMLKMAzjCZzpI05NpbCVWq1p5aWMDODvv0lkz5wh0T11ClJuLiIuXiT3+Jo1pnxCQ8majYgwF47hw6lRogyMYRkR31YwDeUxZUCNW7fMyz9wILmsLVemlwONKFetd3RMpaLBX0qGDaOGgzKEsFyvcpKXyLRMd+s7wGBAz9xcBFSrRmE7ZdTqskc1cwEWVoZhGE/gTB/xlSvmsZ8NBnID338/iVpRkXFJQ+358zj4++9ol5cHtSy4Z87QSknp6db5L1/uve8G0MhsS7H1JHl5NCisDEgAbEao1uvL1WplYWUYhvEE7vQRq1T0WnlMDicZH48bhYUwpKRArdORdVtYSPNwf/3VNNVHSffutAygWm29Grjlvr0AGgEBwH/+QyKubCSoVGQpf/qpyUpUJp3OVHbZsrQIEmLczppFA9EsVzqvW5c+29IatrWv3N4tn04I7PnrL3RasgSSvCCuTDlarSysDMMwnsITfcRyOMngYHotB9QwGMhlW78+MH26dRANlQq4cwf49lt6v+yCdTaQhry/YQPFgrbEYKCAGUKUzepLTSXL3hIhyH2blOR2/kKrheroUUhnzlifLEer1c/GdjMMwzA2ka3bXbtoeo9SVAESvsOHgaNHKfRjdDRN76lenVzPERG0lA9PCaAAABM9SURBVF9oKIVkDAmh/GTLVbYS337b/rQfeS6x0tJ0BWU/tJfyb/LddxDeyt9JWFgZhmEqCt4WJlfmEvtp/iGZmZC8lb+TsCuYYRimouDPQTT8JP/tH36InsnJ0FiuzOSJ/J2EhZVhGKaiUJGCaPgo/6KYGIqMJS/04ANYWBmGYSoSFTWIRhWC+1gZhmEYxoOwsDIMwzCMB2FhZRiGYRgPwsLKMAzDMB6EhZVhGIZhPAgLK8MwDMN4EL+abiPuRgvJycnxSH5arRYFBQXIycmBxodzmioKXF+uwfXlGlxfrsH15TrerDNZl4QTUa38Slhzc3MBAHV4jhbDMAzjh+Tm5iJSXvbPDpJwRn7LCYPBgKtXryI8PBySB5b1ycnJQZ06dXDp0iVERER4oISVG64v1+D6cg2uL9fg+nIdb9aZEAK5ublISEiAyl6s5rv4lcWqUqmQmJjo8XwjIiL4xnQBri/X4PpyDa4v1+D6ch1v1ZkjS1WGBy8xDMMwjAdhYWUYhmEYD6KePn36dF8Xwpuo1Wp0794dAfaWEGLM4PpyDa4v1+D6cg2uL9fxhzrzq8FLDMMwDFPRYVcwwzAMw3gQFlaGYRiG8SAsrAzDMAzjQSqtsH7xxReoX78+goODkZKSgn379vm6SH7Ljh07MGjQICQkJECSJKxevdrXRfJrZs6ciXbt2iE8PByxsbEYMmQITpw44eti+S3z5s1DcnKycW5hhw4dsG7dOl8Xq8Iwa9YsSJKEiRMn+roofsn06dMhSZJZaty4sU/LVCmFdfny5Zg0aRKmTZuGtLQ0tGjRAv369cPNmzd9XTS/JD8/Hy1atMAXX3zh66JUCLZv345x48Zhz5492LhxI7RaLfr27Yv8/HxfF80vSUxMxKxZs3Dw4EEcOHAAPXv2xMMPP4xjx475umh+z/79+zF//nwkJyf7uih+TbNmzXDt2jVj2rlzp28LJCoh7du3F+PGjTO+1uv1IiEhQcycOdOHpaoYABCrVq3ydTEqFDdv3hQAxPbt231dlApD9erVxTfffOPrYvg1ubm5omHDhmLjxo2iW7du4pVXXvF1kfySadOmiRYtWvi6GGZUOou1pKQEBw8eRO/evY3HVCoVevfujd27d/uwZExlJTs7GwBQo0YNH5fE/9Hr9fj++++Rn5+PDh06+Lo4fs24ceMwcOBAs2cZY5tTp04hISEBSUlJePLJJ3Hx4kWflqfSzTrOzMyEXq9HrVq1zI7XqlULf//9t49KxVRWDAYDJk6ciE6dOuH+++/3dXH8lj///BMdOnRAUVERwsLCsGrVKjRt2tTXxfJbvv/+e6SlpWH//v2+Lorfk5KSgsWLF6NRo0a4du0aZsyYgS5duuDo0aMIDw/3SZkqnbAyTHkybtw4HD161Pd9On5Oo0aNkJ6ejuzsbKxcuRKjR4/G9u3bWVxtcOnSJbzyyivYuHEjgoODfV0cv6d///7G/eTkZKSkpKBevXr44Ycf8Oyzz/qkTJVOWKOjo6FWq3Hjxg2z4zdu3EBcXJyPSsVURsaPH481a9Zgx44dXlmVqTIRGBiIe++9FwDQpk0b7N+/H5988gnmz5/v45L5HwcPHsTNmzfRunVr4zG9Xo8dO3bg888/R3FxMdRqtQ9L6N9ERUXhvvvuw+nTp31WhkrXxxoYGIg2bdpg8+bNxmMGgwGbN2/mPh3GIwghMH78eKxatQpbtmxBgwYNfF2kCofBYEBxcbGvi+GX9OrVC3/++SfS09ONqW3btnjyySeRnp7OouqAvLw8nDlzBvHx8T4rQ6WzWAFg0qRJGD16NNq2bYv27dtj7ty5yM/Px5gxY3xdNL8kLy/PrHV37tw5pKeno0aNGqhbt64PS+afjBs3DsuWLcPPP/+M8PBwXL9+HQCt1RgSEuLj0vkfr7/+Ovr374+6desiNzcXy5Ytw7Zt25Camurrovkl4eHhVv31oaGhqFmzJvfj2+DVV1/FoEGDUK9ePVy9ehXTpk2DWq3G8OHDfVamSimsjz/+ODIyMvD222/j+vXraNmyJdavX281oIkhDhw4gB49ehhfT5o0CQAwevRoLF682Eel8l/mzZsHAOjevbvZ8UWLFuHpp58u/wL5OTdv3sSoUaNw7do1REZGIjk5GampqejTp4+vi8ZUAi5fvozhw4fj1q1biImJQefOnbFnzx7ExMT4rEy8ug3DMAzDeJBK18fKMAzDML6EhZVhGIZhPAgLK8MwDMN4EBZWhmEYhvEgLKwMwzAM40FYWBmGYRjGg7CwMgzDMIwHYWFlGIZhGA/CwspUaiRJwvTp011+3/nz5yFJEkeeYhjGZVhYGa+zePFiSJIESZJsLq8mhECdOnUgSRIeeughH5TQfbZt22b8bpIkQaPRICkpCaNGjcLZs2d9XTyvcvz4cUyfPh3nz58vt8+U76Xg4GBcuXLF6nz37t05ni7jc1hYmXIjODgYy5Ytszq+fft2XL58GUFBQT4olWeYMGECli5digULFmDgwIFYvnw52rVrh6tXr/q6aF7j+PHjmDFjRrkKq0xxcTFmzZpV7p/LMM7AwsqUGwMGDMCKFSug0+nMji9btgxt2rSp0OvldunSBSNHjsSYMWPw2WefYfbs2bh9+zaWLFlSpnyFECgsLPRQKSsG+fn5Dq9p2bIlvv76a682XKpi3TOegYWVKTfkFSg2btxoPFZSUoKVK1dixIgRNt+Tn5+PyZMno06dOggKCkKjRo0we/ZsWK4dUVxcjH/961+IiYlBeHg4Bg8ejMuXL9vM88qVK3jmmWdQq1YtBAUFoVmzZli4cKHnviiAnj17AqAl+ABa+aZnz56IjY1FUFAQmjZtalwlR0n9+vXx0EMPITU1FW3btkVISIhxMXBX89i2bZsxj+bNm2Pbtm0AgJ9++gnNmzdHcHAw2rRpg0OHDlnl8ffff2PYsGGoUaMGgoOD0bZtW/zyyy/G84sXL8ajjz4KAOjRo4fRFS5/BgCsW7cOXbp0QWhoKMLDwzFw4EAcO3bM7HOefvpphIWF4cyZMxgwYADCw8Px5JNPOqzfqVOnQq/XO2W16nQ6vPPOO7jnnnsQFBSE+vXrY+rUqVbrwdqre9nd/8MPP2DGjBmoXbs2wsPDMWzYMGRnZ6O4uBgTJ05EbGwswsLCMGbMGF5rtopTKZeNY/yT+vXro0OHDvi///s/9O/fHwA9fLOzs/HEE0/g008/NbteCIHBgwdj69atePbZZ9GyZUukpqbitddew5UrVzBnzhzjtc899xy+/fZbjBgxAh07dsSWLVswcOBAqzLcuHEDDzzwACRJwvjx4xETE4N169bh2WefRU5ODiZOnOiR73rmzBkAQM2aNQHQUnPNmjXD4MGDERAQgF9//RUvvfQSDAYDxo0bZ/beEydOYPjw4Xj++ecxduxYNGrUyOU8Tp8+jREjRuD555/HyJEjMXv2bAwaNAhfffUVpk6dipdeegkAMHPmTDz22GM4ceIEVCpqZx87dgydOnVC7dq1MWXKFISGhuKHH37AkCFD8OOPP2Lo0KHo2rUrJkyYgE8//RRTp05FkyZNAMC4Xbp0KUaPHo1+/frh/fffR0FBAebNm4fOnTvj0KFDqF+/vrGsOp0O/fr1Q+fOnTF79mxUq1bNYf02aNAAo0aNwtdff40pU6YgISHB7rXPPfcclixZgmHDhmHy5MnYu3cvZs6cib/++gurVq1yqu7lugoJCcGUKVNw+vRpfPbZZ9BoNFCpVLhz5w6mT5+OPXv2YPHixWjQoAHefvtth9+DqaQIhvEyixYtEgDE/v37xeeffy7Cw8NFQUGBEEKIRx99VPTo0UMIIUS9evXEwIEDje9bvXq1ACDeffdds/yGDRsmJEkSp0+fFkIIkZ6eLgCIl156yey6ESNGCABi2rRpxmPPPvusiI+PF5mZmWbXPvHEEyIyMtJYrnPnzgkAYtGiRaV+t61btwoAYuHChSIjI0NcvXpV/Pbbb6J+/fpCkiSxf/9+IYQw5qukX79+IikpyexYvXr1BACxfv16q+tdzeOPP/4wHktNTRUAREhIiLhw4YLx+Pz58wUAsXXrVuOxXr16iebNm4uioiLjMYPBIDp27CgaNmxoPLZixQqr9wohRG5uroiKihJjx441O379+nURGRlpdnz06NECgJgyZYrVd7OF8l46c+aMCAgIEBMmTDCe79atm2jWrJnxtXxvPPfcc2b5vPrqqwKA2LJli/GYvbqXf+P7779flJSUGI8PHz5cSJIk+vfvb3Z9hw4dRL169Zz6PkzlhF3BTLny2GOPobCwEGvWrEFubi7WrFlj1w28du1aqNVqTJgwwez45MmTIYTAunXrjNcBsLrO0voUQuDHH3/EoEGDIIRAZmamMfXr1w/Z2dlIS0tz63s988wziImJQUJCAgYOHIj8/HwsWbIEbdu2BQCEhIQYr83OzkZmZia6deuGs2fPIjs72yyvBg0aoF+/flaf4UoeTZs2RYcOHYyvU1JSAJCLum7dulbH5RHMt2/fxpYtW/DYY48hNzfXWD+3bt1Cv379cOrUKZujcZVs3LgRWVlZGD58uFkdq9VqpKSkYOvWrVbvefHFF0vN0xZJSUl46qmnsGDBAly7ds3mNfK9MWnSJLPjkydPBgD89ttvZsft1T0AjBo1ChqNxvg6JSUFQgg888wzZtelpKTg0qVLVmMJmKoDu4KZciUmJga9e/fGsmXLUFBQAL1ej2HDhtm89sKFC0hISEB4eLjZcdndeOHCBeNWpVLhnnvuMbtO6cYDgIyMDGRlZWHBggVYsGCBzc+8efOmW9/r7bffRpcuXaBWqxEdHY0mTZogIMD099q1axemTZuG3bt3o6CgwOy92dnZiIyMNL5u0KCBzc9wJQ+leAIwnqtTp47N43fu3AFALmQhBN566y289dZbNstx8+ZN1K5d2+Y5ADh16hQAUz+zJREREWavAwICkJiYaDe/0njzzTexdOlSzJo1C5988onVefneuPfee82Ox8XFISoqyngPydire8C1OjUYDMjOzjZ2BTBVCxZWptwZMWIExo4di+vXr6N///6Iiooql881GAwAgJEjR2L06NE2r0lOTnYr7+bNm6N37942z505cwa9evVC48aN8fHHH6NOnToIDAzE2rVrMWfOHGO5ZJSWqbt5qNVqm2Wxd1zcHQwm5/Pqq6/atdwsRcoSOY+lS5faHOmtbHAAQFBQkLF/11WSkpIwcuRILFiwAFOmTLF7nSRJTuVnq+5l3K1TpurBwsqUO0OHDsXzzz+PPXv2YPny5Xavq1evHjZt2oTc3Fwzq/Xvv/82npe3BoMBZ86cMbNST5w4YZafPGJYr9fbFUFv8Ouvv6K4uBi//PKLmdVjyyXqzTycISkpCQCg0Wgc1pE9sZI9B7GxseVSz2+++Sa+/fZbvP/++1bn5Hvj1KlTRk8HQIPYsrKyjPcQw3gS7mNlyp2wsDDMmzcP06dPx6BBg+xeN2DAAOj1enz++edmx+fMmQNJkowji+Wt5ajiuXPnmr1Wq9X4xz/+gR9//BFHjx61+ryMjAy3vo8jZItGacFkZ2dj0aJF5ZqHM8TGxqJ79+6YP3++zX5LZR2FhoYCALKyssyu6devHyIiIvDee+9Bq9WWmocnuOeeezBy5EjMnz8f169fNzs3YMAAANb3wscffwwANkeOM0xZYYuV8Qn2XLFKBg0ahB49euCNN97A+fPn0aJFC2zYsAE///wzJk6caLSMWrZsieHDh+PLL79EdnY2OnbsiM2bN+P06dNWec6aNQtbt25FSkoKxo4di6ZNm+L27dtIS0vDpk2bcPv2bY9/1759+yIwMBCDBg3C888/j7y8PHz99deIjY21O+jGG3k4yxdffIHOnTujefPmGDt2LJKSknDjxg3s3r0bly9fxuHDhwFQvavVarz//vvIzs5GUFCQcZ7tvHnz8NRTT6F169Z44oknEBMTg4sXL+K3335Dp06drBpLZeWNN97A0qVLceLECTRr1sx4vEWLFhg9ejQWLFiArKwsdOvWDfv27cOSJUswZMgQ9OjRw6PlYBiAhZXxY1QqFX755Re8/fbbWL58ORYtWoT69evjww8/NI7qlFm4cCFiYmLw3XffYfXq1ejZsyd+++03q4EltWrVwr59+/Df//4XP/30E7788kvUrFkTzZo1s+lK9ASNGjXCypUr8eabb+LVV19FXFwcXnzxRcTExFiNKPVmHs7StGlTHDhwADNmzMDixYtx69YtxMbGolWrVmZzM+Pi4vDVV19h5syZePbZZ6HX67F161bExsZixIgRSEhIwKxZs/Dhhx+iuLgYtWvXRpcuXTBmzBiPlhegft+RI0fajHT1zTffICkpCYsXL8aqVasQFxeH119/HdOmTfN4ORgGACTBPewMwzAM4zG4j5VhGIZhPAgLK8MwDMN4EBZWhmEYhvEgLKwMwzAM40FYWBmGYRjGg7CwMgzDMIwHYWFlGIZhGA/CwsowDMMwHoSFlWEYhmE8CAsrwzAMw3gQFlaGYRiG8SAsrAzDMAzjQVhYGYZhGMaD/H8ms1i5DwTFdQAAAABJRU5ErkJggg==\n",
            "text/plain": [
              "<Figure size 480x360 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "b8I6NBdZUuAO"
      },
      "source": [
        "## Analysis of the IFT sensitivity to the inner loop solution and the Jacobian"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jJXQRTxFX1pD"
      },
      "source": [
        "# code from https://github.com/gehring/fax/blob/master/fax/implicit/twophase.py\n",
        "# we only modify two_phase_rev function to substitute the Jacobian with I\n",
        "\n",
        "from fax.implicit.twophase import default_convergence_test, default_solver\n",
        "\n",
        "import functools\n",
        "import logging\n",
        "import operator\n",
        "\n",
        "import jax\n",
        "#import jax.numpy as np\n",
        "\n",
        "from fax import converge\n",
        "from fax import loop\n",
        "\n",
        "logger = logging.getLogger(__name__)\n",
        "\n",
        "_add = functools.partial(jax.tree_multimap, operator.add)\n",
        "\n",
        "\n",
        "@functools.partial(jax.custom_vjp, nondiff_argnums=(0, 3))\n",
        "def two_phase_solve_identity(param_func, init_xs, params, solvers=()):\n",
        "    \"\"\" Create an implicit function of the parameters and \n",
        "        define its APPROXIMATE VJP rule.\n",
        "    Args:\n",
        "        param_func: A \"parametric\" operator (i.e., callable) taking in some\n",
        "            parameters and returning a function for which we seek a\n",
        "            fixed-point.\n",
        "        init_xs: The initial \"guess\" for the fixed-point of\n",
        "            `param_func(params)(x) = x`.\n",
        "        params: The parameters to use when evaluating `param_func`.\n",
        "        solvers (optional): A sequence of solvers to be used for solving for\n",
        "            the different fixed-point required for solving the given parametric\n",
        "            fixed-point and its derivatives. Specifying solvers is optional. If\n",
        "            a `None` value is encountered in the sequence, the default solver\n",
        "            will be used.\n",
        "            The first solver in the sequence is used to solve for the\n",
        "            parametric fixed point and every subsequent solver is used to\n",
        "            compute the derivatives of increasing order. For example,\n",
        "            `solvers[1]` is the solver used when computing the first order\n",
        "            while `solvers[2]` would be used to solve for the second order\n",
        "            derivatives.\n",
        "            Each solver should be a callable taking in a parametric function\n",
        "            (i.e., a callable which returns a callable) for which we seek a\n",
        "            fixed-point, the initial guess, and the parameters to use. Except\n",
        "            for the first solvers, the function given as first argument will\n",
        "            not be `param_func` but a VJP function derived from `param_func`.\n",
        "            Formally, a solver is expected to have the following signature:\n",
        "            ```\n",
        "            ((b -> (a -> a)) -> a -> b) -> a\n",
        "            ```\n",
        "            For `solver[0]`, a is simply the type of `init_xs`, b is the type\n",
        "            of `param`.\n",
        "    Returns:\n",
        "        The solution to the parametric fixed-point with reverse differentiation\n",
        "        rules defined using the implicit function theorem.\n",
        "    \"\"\"\n",
        "\n",
        "    # If no solver is given or if None is found in its place, use the default\n",
        "    # fixed-point iteration solver.\n",
        "    if solvers and solvers[0] is not None:\n",
        "        fwd_solver = solvers[0]\n",
        "    else:\n",
        "        fwd_solver = default_solver()\n",
        "\n",
        "    return fwd_solver(param_func, init_xs, params)\n",
        "\n",
        "\n",
        "def two_phase_fwd(param_func, init_xs, params, solvers):\n",
        "    sol = two_phase_solve_identity(param_func, init_xs, params, solvers)\n",
        "    return sol, (sol, params)\n",
        "\n",
        "\n",
        "# we only change this part of code\n",
        "def two_phase_rev_identity(param_func, solvers, res, sol_bar):\n",
        "    sol, params = res\n",
        "    _, dparam_vjp = jax.vjp(lambda p: param_func(p)(sol), params)\n",
        "    return jax.tree_map(jnp.zeros_like, sol), dparam_vjp(sol_bar)[0]\n",
        "\n",
        "\n",
        "# def two_phase_rev(param_func, solvers, res, sol_bar):\n",
        "\n",
        "#     def param_dfp_fn(packed_params):\n",
        "#         v, p, dvalue = packed_params\n",
        "#         _, fp_vjp_fn = jax.vjp(lambda x: param_func(p)(x), v)\n",
        "\n",
        "#         def dfp_fn(dout):\n",
        "#             dout = _add(fp_vjp_fn(dout)[0], dvalue)\n",
        "#             return dout\n",
        "\n",
        "#         return dfp_fn\n",
        "\n",
        "#     sol, params = res\n",
        "#     dsol = two_phase_solve(param_dfp_fn,\n",
        "#                            sol_bar,\n",
        "#                            (sol, params, sol_bar),\n",
        "#                            solvers[1:])\n",
        "#     _, dparam_vjp = jax.vjp(lambda p: param_func(p)(sol), params)\n",
        "#     return jax.tree_map(np.zeros_like, sol), dparam_vjp(dsol)[0]\n",
        "    \n",
        "\n",
        "two_phase_solve_identity.defvjp(two_phase_fwd, two_phase_rev_identity)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fIwT8i-VUuAQ",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "8a6f37fc-27b6-419a-8263-0ddd3f3c3854"
      },
      "source": [
        "start = time.time()\n",
        "std_list = np.logspace(-3, 0.5, 30)\n",
        "num_seeds = 10\n",
        "Js_inv_jac = np.zeros((len(std_list), num_seeds))\n",
        "Bs_inv_jac = np.zeros((len(std_list), num_seeds))\n",
        "Js_no_inv_jac = np.zeros((len(std_list), num_seeds))\n",
        "Bs_no_inv_jac = np.zeros((len(std_list), num_seeds))\n",
        "\n",
        "kwargs = {'max_iter': 10000, 'lr_func': 0.01, 'optimizer': optimizers.adam}\n",
        "\n",
        "for i, std in enumerate(std_list):\n",
        "  for j, seed in enumerate(range(1, num_seeds+1)):\n",
        "    kwargs['seed'] = seed\n",
        "    kwargs['std'] = std\n",
        "    \n",
        "    rngs = jax.random.split(jax.random.PRNGKey(seed), 3)\n",
        "    initial_values = (\n",
        "      jax.random.uniform(rngs[0], true_reward.shape),\n",
        "      (jax.random.uniform(rngs[1], true_transition.shape), \n",
        "      jax.random.uniform(rngs[2], true_reward.shape))\n",
        "    )\n",
        "\n",
        "    solution = implicit_ecp(objective_bellman, equality_constraints, initial_values, **kwargs)\n",
        "    Js_inv_jac[i,j] = objective_returns(solution[0], solution[1]).item()\n",
        "    Bs_inv_jac[i,j] = -objective_bellman(solution[0], solution[1]).item()\n",
        "\n",
        "    solution = implicit_ecp(objective_bellman, equality_constraints, initial_values, \n",
        "                          **kwargs, constraints_solver=two_phase_solve_identity)\n",
        "    Js_no_inv_jac[i,j] = objective_returns(solution[0], solution[1]).item()\n",
        "    Bs_no_inv_jac[i,j] = -objective_bellman(solution[0], solution[1]).item()\n",
        "  \n",
        "  print('Done {}/{} stds'.format(i+1, len(std_list)))\n",
        "print('Done in {:.2f} minutes'.format((time.time() - start) / 60))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Done 1/30 stds\n",
            "Done 2/30 stds\n",
            "Done 3/30 stds\n",
            "Done 4/30 stds\n",
            "Done 5/30 stds\n",
            "Done 6/30 stds\n",
            "Done 7/30 stds\n",
            "Done 8/30 stds\n",
            "Done 9/30 stds\n",
            "Done 10/30 stds\n",
            "Done 11/30 stds\n",
            "Done 12/30 stds\n",
            "Done 13/30 stds\n",
            "Done 14/30 stds\n",
            "Done 15/30 stds\n",
            "Done 16/30 stds\n",
            "Done 17/30 stds\n",
            "Done 18/30 stds\n",
            "Done 19/30 stds\n",
            "Done 20/30 stds\n",
            "Done 21/30 stds\n",
            "Done 22/30 stds\n",
            "Done 23/30 stds\n",
            "Done 24/30 stds\n",
            "Done 25/30 stds\n",
            "Done 26/30 stds\n",
            "Done 27/30 stds\n",
            "Done 28/30 stds\n",
            "Done 29/30 stds\n",
            "Done 30/30 stds\n",
            "Done in 13.61 minutes\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2_AK6qvk3ZWU",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 366
        },
        "outputId": "aa2e6c3e-6253-4f34-a168-3afd05406e56"
      },
      "source": [
        "m, s = Js_inv_jac.mean(1), Js_inv_jac.std(1)\n",
        "plt.plot(std_list, m, label='With Inverse Jacobian', alpha=0.8)\n",
        "plt.fill_between(std_list, m - 0.3 * s, m + 0.3 * s, alpha=0.2)\n",
        "\n",
        "m, s = Js_no_inv_jac.mean(1), Js_no_inv_jac.std(1)\n",
        "plt.plot(std_list, m, label='With Identity Approximation', alpha=0.8)\n",
        "plt.fill_between(std_list, m - 0.3 * s, m + 0.3 * s, alpha=0.2)\n",
        "\n",
        "plt.xscale('log')\n",
        "plt.legend()\n",
        "plt.ylabel('Expected Return')\n",
        "plt.xlabel(r'Noise Std $\\sigma$')\n",
        "plt.yticks()\n",
        "plt.xticks()\n",
        "\n",
        "plt.tight_layout()\n",
        "plt.savefig('ift_approx_tab.pdf')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 480x360 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "F66G8LyObVA2"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}