PINA/tutorials/tutorial1/tutorial.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Tutorial 1: Physics Informed Neural Networks on PINA"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this tutorial we will show the typical use case of PINA on a toy problem solved by Physics Informed Problems. Specifically, the tutorial aims to introduce the following topics:\n",
    "\n",
    "* Defining a PINA Problem,\n",
    "* Build a `PINN` Solver,\n",
    "\n",
    "We will show in detailed each step, and at the end we will solve a very simple problem with PINA."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Defining a Problem"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Initialize the Problem class\n",
    "The problem definition in the PINA framework is done by building a phython `class`, inherited from `AbsractProblem`. A problem is an object which explains what the solver is supposed to solve. For Physics Informed Neural Networks, a problem can be inherited from one or more problem (already implemented) classes (`SpatialProblem`, `TimeDependentProblem`, `ParametricProblem`), depending on the nature of the problem treated. \n",
    "Let's see an example to better understand:\n",
    "#### Simple Ordinary Differential Equation\n",
    "Consider the following:\n",
    "\n",
    "$$\n",
    "\\begin{equation}\n",
    "\\begin{cases}\n",
    "\\frac{d}{dx}u(x) &=  u(x) \\quad x\\in(0,1)\\\\\n",
    "u(x=0) &= 1 \\\\\n",
    "\\end{cases}\n",
    "\\end{equation}\n",
    "$$\n",
    "\n",
    "with analytical solution $u(x) = e^x$. In this case we have that our ODE depends only on the spatial variable $x\\in(0,1)$ , this means that our problem class is going to be inherited from `SpatialProblem` class:\n",
    "\n",
    "```python\n",
    "from pina.problem import SpatialProblem\n",
    "from pina.geometry import CartesianDomain\n",
    "\n",
    "class SimpleODE(SpatialProblem):\n",
    "    \n",
    "    output_variables = ['u']\n",
    "    spatial_domain = CartesianDomain({'x': [0, 1]})\n",
    "\n",
    "    # other stuff ...\n",
    "```\n",
    "\n",
    "Notice that we define `output_variables` as a list of symbols, indicating the output variables of our equation (in this case only $u$). The `spatial_domain` variable indicates where the sample points are going to be sampled in the domain, in this case $x\\in(0,1)$\n",
    "\n",
    "What about if we also have a time depencency in the equation? Well in that case our `class` will inherit from both `SpatialProblem` and `TimeDependentProblem`:\n",
    "```python\n",
    "from pina.problem import SpatialProblem, TimeDependentProblem\n",
    "from pina.geometry import CartesianDomain\n",
    "\n",
    "class TimeSpaceODE(SpatialProblem, TimeDependentProblem):\n",
    "    \n",
    "    output_variables = ['u']\n",
    "    spatial_domain = CartesianDomain({'x': [0, 1]})\n",
    "    temporal_domain = CartesianDomain({'x': [0, 1]})\n",
    "\n",
    "    # other stuff ...\n",
    "```\n",
    "where we have included the `temporal_domain` variable indicating the time domain where we want the solution.\n",
    "\n",
    "Summarizing, in PINA we can initialize a problem with a class which is inherited from three base classes: `SpatialProblem`, `TimeDependentProblem`, `ParametricProblem`, depending on the type of problem we are considering. For reference:\n",
    "* `SpatialProblem` $\\rightarrow$ spatial variable(s) presented in the differential equation\n",
    "* `TimeDependentProblem` $\\rightarrow$ time variable(s) presented in the differential equation\n",
    "* `ParametricProblem` $\\rightarrow$ parameter(s) presented in the differential equation\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Write the problem class\n",
    "\n",
    "Once the problem class is initialized we need to write the differential equation in PINA language. For doing this we need to load the pina operators found in `pina.operators` module. Let's again consider the Equation (1) and try to write the PINA model class:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pina.problem import SpatialProblem\n",
    "from pina.operators import grad\n",
    "from pina.geometry import CartesianDomain\n",
    "from pina.equation import Equation\n",
    "from pina import Condition\n",
    "\n",
    "import torch\n",
    "\n",
    "\n",
    "class SimpleODE(SpatialProblem):\n",
    "\n",
    "    output_variables = ['u']\n",
    "    spatial_domain = CartesianDomain({'x': [0, 1]})\n",
    "\n",
    "    # defining the ode equation\n",
    "    def ode_equation(input_, output_):\n",
    "\n",
    "        # computing the derivative\n",
    "        u_x = grad(output_, input_, components=['u'], d=['x'])\n",
    "\n",
    "        # extracting u input variable\n",
    "        u = output_.extract(['u'])\n",
    "\n",
    "        # calculate residual and return it\n",
    "        return u_x - u\n",
    "\n",
    "    # defining initial condition\n",
    "    def initial_condition(input_, output_):\n",
    "        \n",
    "        # setting initial value\n",
    "        value = 1.0\n",
    "\n",
    "        # extracting u input variable\n",
    "        u = output_.extract(['u'])\n",
    "\n",
    "        # calculate residual and return it\n",
    "        return u - value\n",
    "\n",
    "    # Conditions to hold\n",
    "    conditions = {\n",
    "        'x0': Condition(location=CartesianDomain({'x': 0.}), equation=Equation(initial_condition)),\n",
    "        'D': Condition(location=CartesianDomain({'x': [0, 1]}), equation=Equation(ode_equation)),\n",
    "    }\n",
    "\n",
    "    # defining true solution\n",
    "    def truth_solution(self, pts):\n",
    "        return torch.exp(pts.extract(['x']))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "After the defition of the Class we need to write different class methods, where each method is a function returning a residual. This functions are the ones minimized during the PINN optimization, for the different conditions. For example, in the domain $(0,1)$ the ODE equation (`ode_equation`) must be satisfied, so we write it by putting all the ODE equation on the right hand side, such that we return the zero residual. This is done for all the conditions  (`ode_equation`, `initial_condition`). Notice that we do not pass directly a `python` function, but an `Equation` object, which is initialized with the `python` function. This is done so that all the computations, and internal checks are done inside PINA.\n",
    "\n",
    "Once we have defined the function we need to tell the network where these methods have to be applied. For doing this we use the class `Condition`. In `Condition` we pass the location points and the function to be minimized on those points (other possibilities are allowed, see the documentation for reference).\n",
    "\n",
    "Finally, it's possible to defing the `truth_solution` function, which can be useful if we want to plot the results and see a comparison of real vs expected solution. Notice that `truth_solution` function is a method of the `PINN` class, but it is not mandatory for the problem definition."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Build PINN object"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In PINA we have already developed different solvers, one of them is `PINN`. The basics requirements for building a `PINN` model are a problem and a model. We have already covered the problem definition. For the model one can use the default models provided in PINA or use a custom model. We will not go into the details of model definition, Tutorial2 and Tutorial3 treat the topic in detail."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pina.model import FeedForward\n",
    "from pina.solvers import PINN\n",
    "\n",
    "# initialize the problem\n",
    "problem = SimpleODE()\n",
    "\n",
    "# build the model\n",
    "model = FeedForward(\n",
    "    layers=[10, 10],\n",
    "    func=torch.nn.Tanh,\n",
    "    output_dimensions=len(problem.output_variables),\n",
    "    input_dimensions=len(problem.input_variables)\n",
    ")\n",
    "\n",
    "# create the PINN object, see the PINN documentation for extra argument in the constructor\n",
    "pinn = PINN(problem, model)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Creating the pinn object is fairly simple by using the `PINN` class, different optional inputs can be passed: optimizer, batch size, ... (see [documentation](https://mathlab.github.io/PINA/) for reference)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sample points in the domain and create the Trainer"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once the `PINN` object is created, we need to generate the points for starting the optimization. For doing this we use the `.discretise_domain` method of the `AbstractProblem` class. Let's see some methods to sample in $(0,1 )$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# sampling 20 points in (0, 1) with discrite step\n",
    "problem.discretise_domain(20, 'grid', locations=['D'])\n",
    "\n",
    "# sampling 20 points in (0, 1) with latin hypercube\n",
    "problem.discretise_domain(20, 'latin', locations=['D'])\n",
    "\n",
    "# sampling 20 points in (0, 1) randomly\n",
    "problem.discretise_domain(20, 'random', locations=['D'])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We are going to use equispaced points for sampling. We need to sample in all the conditions domains. In our case we sample in `D` and `x0`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# sampling for training\n",
    "problem.discretise_domain(1, 'random', locations=['x0'])\n",
    "problem.discretise_domain(20, 'grid', locations=['D'])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Very simple training and plotting\n",
    "\n",
    "Once we have defined the PINA model, created a network and sampled points in the domain, we have everything that is necessary for training a `PINN`. For training we use the `Trainer` class. Here we show a very short training and some method for plotting the results. Notice that by default all relevant metrics (e.g. MSE error during training) is going to be tracked using a `lightining` logger, by default `CSVLogger`. If you want to track the metric by yourself without a logger, use `pina.callbacks.MetricTracker`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "GPU available: False, used: False\n",
      "TPU available: False, using: 0 TPU cores\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "IPU available: False, using: 0 IPUs\n",
      "HPU available: False, using: 0 HPUs\n",
      "/Users/dariocoscia/anaconda3/envs/pina/lib/python3.9/site-packages/lightning/pytorch/trainer/connectors/logger_connector/logger_connector.py:67: UserWarning: Starting from v1.9.0, `tensorboardX` has been removed as a dependency of the `lightning.pytorch` package, due to potential conflicts with other packages in the ML ecosystem. For this reason, `logger=True` will use `CSVLogger` as the default logger, unless the `tensorboard` or `tensorboardX` packages are found. Please `pip install lightning[extra]` or one of them to enable TensorBoard support by default\n",
      "  warning_cache.warn(\n",
      "\n",
      "  | Name        | Type    | Params\n",
      "----------------------------------------\n",
      "0 | _loss       | MSELoss | 0     \n",
      "1 | _neural_net | Network | 141   \n",
      "----------------------------------------\n",
      "141       Trainable params\n",
      "0         Non-trainable params\n",
      "141       Total params\n",
      "0.001     Total estimated model params size (MB)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 2999: : 1it [00:00, 226.55it/s, v_num=10, mean_loss=2.14e-5, x0_loss=4.24e-5, D_loss=2.93e-7]  "
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "`Trainer.fit` stopped: `max_epochs=3000` reached.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 2999: : 1it [00:00, 159.67it/s, v_num=10, mean_loss=2.14e-5, x0_loss=4.24e-5, D_loss=2.93e-7]\n"
     ]
    }
   ],
   "source": [
    "# create the trainer\n",
    "from pina.trainer import Trainer\n",
    "from pina.callbacks import MetricTracker\n",
    "\n",
    "trainer = Trainer(solver=pinn, max_epochs=3000, callbacks=[MetricTracker()])\n",
    "\n",
    "# train\n",
    "trainer.train()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "After the training we can inspect trainer logged metrics (by default PINA logs mean square error residual loss). The logged metrics can be accessed online using one of the `Lightinig` loggers. The final loss can be accessed by `trainer.logged_metrics`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'mean_loss': tensor(2.1357e-05),\n",
       " 'x0_loss': tensor(4.2421e-05),\n",
       " 'D_loss': tensor(2.9291e-07)}"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# inspecting final loss\n",
    "trainer.logged_metrics\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "By using the `Plotter` class from PINA we can also do some quatitative plots of the solution. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAArwAAAKnCAYAAABkq54bAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABjpUlEQVR4nO3dZ3gUVcPG8Xuz6aQRIA1CF1RQQQUEGyiCgDSlI02KYlARK/b2CCL62BAbitQgSlFAkCJNmiLYQXpNQk02jU3Z837wMa+RGkgyu5v/77rmw86e2dzrGLgdz5yxGWOMAAAAAC/lY3UAAAAAoCRReAEAAODVKLwAAADwahReAAAAeDUKLwAAALwahRcAAABejcILAAAAr0bhBQAAgFfztTqAO3K5XDp48KBCQ0Nls9msjgMAAIB/McYoPT1dcXFx8vE58zVcCu8pHDx4UPHx8VbHAAAAwFns27dPVapUOeMYCu8phIaGSvrrH2BYWJjFaQAAAPBvDodD8fHxBb3tTCi8p/D3NIawsDAKLwAAgBs7l+mn3LQGAAAAr0bhBQAAgFej8AIAAMCrUXgBAADg1Si8AAAA8GoUXgAAAHg1Ci8AAAC8GoUXAAAAXo3CCwAAAK9G4QUAAIBXs7Twjho1So0aNVJoaKiioqLUqVMnbd269YzHNG/eXDab7aStXbt2BWP69+9/0vu33nprSX8dAAAAuCFfK3/4ihUrlJCQoEaNGikvL09PPPGEWrVqpd9//13lypU75TGzZs1STk5OweujR4/qiiuuUNeuXQuNu/XWW/XJJ58UvA4ICCiZLwEAAAC3ZmnhXbhwYaHXEydOVFRUlDZu3KgbbrjhlMdERkYWep2YmKjg4OCTCm9AQIBiYmKKNzAAAAA8jlvN4U1LS5N0cqk9kwkTJqhHjx4nXRFevny5oqKiVLduXQ0dOlRHjx497Wc4nU45HI5CGwAAALyDzRhjrA4hSS6XSx06dFBqaqpWr159Tsds2LBBTZo00fr169W4ceOC/X9f9a1Ro4Z27NihJ554QiEhIVq7dq3sdvtJn/Pcc8/p+eefP2l/WlqawsLCzv9LAQAAoEQ4HA6Fh4efU19zm8I7dOhQff3111q9erWqVKlyTsfcfffdWrt2rX7++eczjtu5c6dq1aqlJUuW6Oabbz7pfafTKafTWfDa4XAoPj6ewgsAAOCmilJ43WJKw7BhwzRv3jx9++2351x2MzMzlZiYqIEDB551bM2aNVWxYkVt3779lO8HBAQoLCys0AYAAADvYOlNa8YY3XfffZo9e7aWL1+uGjVqnPOxM2fOlNPp1J133nnWsfv379fRo0cVGxt7IXEBAADggSy9wpuQkKApU6Zo2rRpCg0NVXJyspKTk5WdnV0wpm/fvho5cuRJx06YMEGdOnVShQoVCu3PyMjQI488onXr1mn37t1aunSpOnbsqNq1a6t169Yl/p0AAADgXiy9wjt+/HhJfz1M4p8++eQT9e/fX5K0d+9e+fgU7uVbt27V6tWr9c0335z0mXa7XT///LM+/fRTpaamKi4uTq1atdKLL77IWrwAAABlkNvctOZOijIJGgAAAKXP425aAwAAAEoKhRcAAABejcILAACAC3Zi1TvSsZ1WxzglCi8AAAAuSPbWpQpc+qSc7zRT5rGDVsc5CYUXAAAA5y8nS9lfDJMkLfBpLp+QaIsDnYzCCwAAgPOW/OWzisw5qIMmUrG3j1KQv93qSCeh8AIAAOC85OzbqEq/fiRJWljtUV1z6bk/Nbc0UXgBAABQdPm5Sk28R3a59I3tWt3RY5DViU6LwgsAAIAiO/TNWEVl/qnjJkQ+bccoPNjP6kinReEFAABAkeQf3q6I9a9JkmZH3aubr65ncaIzo/ACAADg3LlcOjR1iPyVqzXmcrXtPUI2m83qVGdE4QUAAMA5O7rqI8WmblSWCdCh5qMVExFkdaSzovACAADgnBjHQQUuf06S9Hl4P3W4sZm1gc4RhRcAAADnZP/UYSpnMvWzqaUb7nxaPj7uPZXhbxReAAAAnNXxH75QfMpS5Rq7tjV5WdWjwqyOdM4ovAAAADgjk3Vctq8fliTNCu6qjq1bWZyoaCi8AAAAOKO9Mx5WRP4x7TBxatj7JfnaPatCelZaAAAAlCrHH8tUbc/nkqQfLn9edapUsjhR0VF4AQAAcGq52XLOSpAkfeXfRp07drE40Pmh8AIAAOCU9nzxtCrlHlSSiVS17q/K39czq6NnpgYAAECJytz9gypvmSBJWlXncV1eK97iROePwgsAAIDC8nLkSBwiX7m01H6d2ncdZHWiC0LhBQAAQCH7vvqPYk/s0FETqrDb/6sgf7vVkS4IhRcAAAAFTuz/RTE/vSNJWlztITWqV8fiRBeOwgsAAIC/5Ofp2PTB8lOeVtgaq23PBKsTFQsKLwAAACRJBxeOVVzmH0ozwbJ3eF1hQf5WRyoWFF4AAAAoJ2WrKn4/VpL0Vdz9uq7hZRYnKj4UXgAAgLLOla8jUwbJX7n6Tg3UtvcIqxMVKwovAABAGZey5C3Fpf+sdBOk7NavKTIkwOpIxYrCCwAAUIblH9mpiDWjJEmzK96tm6+5yuJExY/CCwAAUFa5XEqZMkQBcmq96ql138dks9msTlXsKLwAAABl1JGVHygu9XtlmQAdvvFVRYcHWx2pRFB4AQAAyqD843sVvOI5SdIXEXepXfNm1gYqQRReAACAssYYJU25W8EmW5tMHTXv86RXTmX4G4UXAACgjDmy+hNVObpGTuOnfde/qviKoVZHKlEUXgAAgDLElXZQgcueliR9Ed5Xt910o8WJSh6FFwAAoKwwRvunDFWIydAvpqau7/ucfHy8dyrD3yi8AAAAZcSRddNV9fBy5Ri7dl07RvEVw6yOVCoovAAAAGWAK/2w/Bc/LkmaE9pLt7VsaXGi0kPhBQAAKAP2Tk1QmCtNW0xVNen7YpmYyvA3Ci8AAICXO/L956qevEh5xkfbrhmtalHlrY5Uqii8AAAAXsxkHpHf1w9Jkr4K6ap2rdtanKj0UXgBAAC82N7J9yrclao/TRU17Du6TE1l+BuFFwAAwEsdXZ+oav+byvB7kzGqHh1pdSRLUHgBAAC8kElPkf+iRyRJs0O6q/2tZW8qw98ovAAAAN7mfw+YCHU5tMVU1VV9Xpa9DE5l+BuFFwAAwMscWz9d8SlLlWvs+r3JGNWMKZtTGf5G4QUAAPAixpEk/28elSR9HtJTHW+91eJE1qPwAgAAeAtjdHDKPQpxpes3U12N7nypTE9l+BuFFwAAwEukrpusyoeWK8fY9XvjV1Q7tmw9YOJ0KLwAAABewKQdkN/ikZKkz8rdqdvbtLY4kfug8AIAAHg6Y5Q09W6Vc2XoF1NT1/R9nqkM/0DhBQAA8HDH13yiuEOr5DR++r3JGNWOYSrDP1F4AQAAPJjr+D4FLHlSkpQY0kddbm1pcSL3Q+EFAADwVMYoecpgBZssbTYX6fq+zzGV4RQovAAAAB7q6MoPFHd0rU4YP+249lXVjA63OpJbovACAAB4oPxjuxW8/FlJ0mfhA9S5ZXNrA7kxCi8AAICncbmUPHmwgky2NpqL1aLvM/JhKsNpUXgBAAA8zKHl76ry8Q3KNv46cONriq8YanUkt0bhBQAA8CB5R3YqbOULkqTPIwerfYtrLU7k/ii8AAAAnsKVr5TJAxUop77XpWrZ70nZbExlOBsKLwAAgIdI/uZ1VU77URkmUEdvfl2xEeWsjuQRKLwAAAAeIPfgr6qwbrQk6YtK96r1dddYnMhzUHgBAADcXV6Ojk8dID/laaWuVNu+jzGVoQgovAAAAG4u5avnFZX5p46ZEOW0fVOVwgKtjuRRKLwAAABuzLl7nSr+9K4kaVbcw2rZ+HKLE3keCi8AAIC7yslUxvRBssulBbYbdMedCVYn8kgUXgAAADd1aNajquDcpyQTqeCOr6t8OX+rI3kkCi8AAIAbOrHlG0VtmSJJ+rLak2re4CKLE3kuCi8AAIC7yT6unC+GSpJm+rRRj579LA7k2Si8AAAAbubwjPsVlntEO1yxiu0yRuFBflZH8miWFt5Ro0apUaNGCg0NVVRUlDp16qStW7ee8ZiJEyfKZrMV2gIDCy/NYYzRM888o9jYWAUFBally5batm1bSX4VAACAYpH140xV2v2l8oyPFtV9XtddWtXqSB7P0sK7YsUKJSQkaN26dVq8eLFyc3PVqlUrZWZmnvG4sLAwJSUlFWx79uwp9P6YMWP01ltv6b333tP69etVrlw5tW7dWidOnCjJrwMAAHBhHEky80dIkqb6d1G/LndYHMg7+Fr5wxcuXFjo9cSJExUVFaWNGzfqhhtuOO1xNptNMTExp3zPGKM33nhDTz31lDp27ChJmjRpkqKjozVnzhz16NGj+L4AAABAcTFGh6YOUVS+Q7+4quuyni+pXIClVc1ruNUc3rS0NElSZGTkGcdlZGSoWrVqio+PV8eOHfXbb78VvLdr1y4lJyerZcuWBfvCw8PVpEkTrV279pSf53Q65XA4Cm0AAAClyfHdh4pKWSmn8dMPDUfryprRVkfyGm5TeF0ul4YPH65rr71W9evXP+24unXr6uOPP9bcuXM1ZcoUuVwuNWvWTPv375ckJScnS5Kiowv/SxIdHV3w3r+NGjVK4eHhBVt8fHwxfSsAAICzM0d3yn/p05KkSeX6qXf71hYn8i5uU3gTEhL066+/KjEx8YzjmjZtqr59+6pBgwa68cYbNWvWLFWqVEnvv//+ef/skSNHKi0trWDbt2/feX8WAABAkbjydXjyAAWaE1pvLlHzvs/I39dtKppXcIt/msOGDdO8efP07bffqkqVKkU61s/PTw0bNtT27dslqWBub0pKSqFxKSkpp533GxAQoLCwsEIbAABAaTi6eKyiUjcr3QRpz3VjdVFMuNWRvI6lhdcYo2HDhmn27NlatmyZatSoUeTPyM/P1y+//KLY2FhJUo0aNRQTE6OlS5cWjHE4HFq/fr2aNm1abNkBAAAuVN7BnxW2dowkaVrkUHW5+VqLE3knS2/9S0hI0LRp0zR37lyFhoYWzLENDw9XUFCQJKlv376qXLmyRo0aJUl64YUXdM0116h27dpKTU3Vq6++qj179mjQoEGS/lrBYfjw4XrppZd00UUXqUaNGnr66acVFxenTp06WfI9AQAATpLn1PEpd6mS8vStrlb7vo/Ix8dmdSqvZGnhHT9+vCSpefPmhfZ/8skn6t+/vyRp79698vH5/wvRx48f1+DBg5WcnKzy5cvrqquu0po1a3TppZcWjHn00UeVmZmpIUOGKDU1Vdddd50WLlx40gMqAAAArHJozpOKytqmoyZU2W3+q7jywVZH8lo2Y4yxOoS7cTgcCg8PV1paGvN5AQBAsXNuXaaA6Z0lSe/FvaS7Bw+TzcbV3aIoSl9zi5vWAAAAyoysY3J+PkSSNMvnFvW4827Kbgmj8AIAAJQWY3Q48V6F5R7WTleMKnV5TRHB/lan8noUXgAAgFKS+f0UVdr7tXKNXd9c/JKuv7Sa1ZHKBAovAABAaTi+Wz4LH5UkTQroob5dOlscqOyg8AIAAJQ0V76OTh6gIFeWfnDV1VW9X1Swv6WLZZUpFF4AAIASlr5kjCoc+1HpJkg/NXpFDapVsDpSmULhBQAAKEGufRsVtOZVSdJHoUPVt+2NFicqeyi8AAAAJSUnU+nTB8hX+fradY069B0hPzv1q7TxTxwAAKCEpM55VOFZe5RkIpV68xjVigq1OlKZROEFAAAoATm/zVfE71MkSZOiH1OPGy63OFHZReEFAAAobhmHlDs7QZI02dZeA/r052lqFqLwAgAAFCdjdGzaYJXLO64/XFVV+Y5RigoNtDpVmUbhBQAAKEaZ372vyIPL5TR+WnzJS7qpfrzVkco8Ci8AAEAxMYe2yG/p05KkjwL7afAdt1mcCBKFFwAAoHjk5ej4lP7yNzla7bpMN/Z5SkH+dqtTQRReAACAYnF8wfOKdPyh4yZEu64bq/pVylsdCf9D4QUAALhAuTtWKfzHcZKkiRUeVO+WTSxOhH+i8AIAAFyIrGPKnnGXfGQ0Wy3Uo1+CfHxYgsydUHgBAADOlzE6lniPwnIOaYcrVuU6jlVseJDVqfAvFF4AAIDzlLVugiL3LlKOsWveRS+oVcPaVkfCKVB4AQAAzoM59Id8v3lCkvRhQB8N6na7xYlwOhReAACAoso9obQp/eRvnFrpulzNej+jcgG+VqfCaVB4AQAAiih9/pOKcGzVEROmbU3HqGG1ClZHwhlQeAEAAIogf8tChW7+SJL0QeRD6t/6GosT4WwovAAAAOcqPVnOL+6RJE0xbdSnzxDZWYLM7VF4AQAAzoXLJUfiIAXnHtfvrmoKa/+y4iODrU6Fc0DhBQAAOAcnVr2lsAOrlG38NafWC+pwdU2rI+EcUXgBAADOwhzYJN9vX5QkveU3UAnd2lmcCEVB4QUAADgTZ4YypvWTr/K00NVYLe98ROFBflanQhFQeAEAAM7AMechhWbu0UETqX3XjtJV1VmCzNNQeAEAAE4j7+cvFPZHolzGpg8rPq67brnK6kg4DxReAACAU0ndq7y590uSJtg66+6+/ViCzENReAEAAP4tP09pU/orMD9DP7pqq0aXFxUTHmh1KpwnCi8AAMC/ZC4ZpfAjG+UwQVpRf5Ra1q9idSRcAAovAADAP7h2r1HQ2tclSe+WS9DQzjdbnAgXisILAADwt6xjypreXz5yaY7rBt3Rb7gC/exWp8IFovACAABIkjFKSxyiEGeKdrpilNN6jC6KDrU6FYoBhRcAAECS87t3Fb53sZzGT9OrvaCuzS62OhKKCYUXAADg4CbZlzwjSXrbr7+G9bxdNhtLkHkLCi8AACjbTjiUMaWPfJWnRfmNdGPvkQoP5tHB3oTCCwAAyi5jlPHFMIVk7dN+U1G7rn1FjWrw6GBvQ+EFAABlVt4Pnypk21zlGR+Nr/iEBre60upIKAEUXgAAUDYd+kPm60clSe/YeiqhTy8eHeylKLwAAKDsyclSxpQ75edyakX+5arX9WnFRQRZnQolhMILAADKnMwvH1aIY7sOmQh933CUbqkXa3UklCAKLwAAKFPyf5qpcr9OlcvY9Fb4o7q/QzOrI6GEUXgBAEDZcXSH8r68X5L0gW7X4H795e9LHfJ2nGEAAFA25DmVPrWvAvKztN51seI7P6dqFcpZnQqlgMILAADKhKwFTyr02K86ZkL0bb2X1a5BVasjoZRQeAEAgNfL/2O+gn/8UJL0RsiDGn57c2sDoVRReAEAgHdL26+cL4ZKkia62qlvv3sU6Ge3OBRKE4UXAAB4r/w8pU/pq6C8NP3kqqmw9i+pdlSI1alQyii8AADAa2UvfkmhhzfKYYI0v85/dHujmlZHggUovAAAwCu5/lyigHVvSJLeDErQA11bWRsIlqHwAgAA75N2QM6ZA+Ujo2muW9Sl3wMqF+BrdSpYhMILAAC8S36uMqb2VVBuqn51VZft1pd1SWyY1algIQovAADwKs5Fzynk0A9ymCDNrPmSejS9yOpIsBiFFwAAeA2zZYECNrwjSXo14D491ONW2Ww2i1PBahReAADgHVL3yvn53ZKkia426t5vmMIC/SwOBXdA4QUAAJ4vL0cZU+5UYJ5Dm121FNDmJdWvHG51KrgJCi8AAPB42QueVMiRn5Rqymlu7ZfU45paVkeCG6HwAgAAj5b/21wF/fiBJGls8HA93L0V83ZRCIUXAAB4rmM7lTdrqCTpI1d79e0/lPV2cRIKLwAA8Ey5J5Qx+U4F5Gfqe1cdlW//oupEh1qdCm6IwgsAADxS1rzHFHL8Nx01oVp8ySjd0aiG1ZHgpii8AADA4+T/9JmCf5ool7Hp9ZCHNKJLC6sjwY1ReAEAgGc5sk35cx+QJH2ozhrYf7AC/ewWh4I7o/ACAADPkZOljMm95e/K0tr8S1Wl8/OqWSnE6lRwcxReAADgMTLnjFBI2lYdNuFafcUotWtQ1epI8AAUXgAA4BHyNk5Vud+ny2VsejP8Md3f6XqrI8FDWFp4R40apUaNGik0NFRRUVHq1KmTtm7desZjPvzwQ11//fUqX768ypcvr5YtW2rDhg2FxvTv3182m63Qduutt5bkVwEAACUp5TeZeQ9Kksbbuuru/gMU4Mu8XZwbSwvvihUrlJCQoHXr1mnx4sXKzc1Vq1atlJmZedpjli9frp49e+rbb7/V2rVrFR8fr1atWunAgQOFxt16661KSkoq2KZPn17SXwcAAJSEEw5lTu4pP+PUyvzLVKfL84qPDLY6FTyIzRhjrA7xt8OHDysqKkorVqzQDTfccE7H5Ofnq3z58nrnnXfUt29fSX9d4U1NTdWcOXPOK4fD4VB4eLjS0tIUFhZ2Xp8BAACKgTHKnNxL5XYu0AFTQTOvnKrhHZtanQpuoCh9za3m8KalpUmSIiMjz/mYrKws5ebmnnTM8uXLFRUVpbp162ro0KE6evToaT/D6XTK4XAU2gAAgPVyV7+pcjsXKMfY9U6Fp5VwWxOrI8EDuc0VXpfLpQ4dOig1NVWrV68+5+PuvfdeLVq0SL/99psCAwMlSYmJiQoODlaNGjW0Y8cOPfHEEwoJCdHatWtlt5883+e5557T888/f9J+rvACAGCh3auVP7GD7MrXy7bBumv4S4oJD7Q6FdxEUa7wuk3hHTp0qL7++mutXr1aVapUOadjRo8erTFjxmj58uW6/PLLTztu586dqlWrlpYsWaKbb775pPedTqecTmfBa4fDofj4eAovAABWSU9W9tvNFJRzVLPzr1OlPhN1XZ1KVqeCG/G4KQ3Dhg3TvHnz9O23355z2R07dqxGjx6tb7755oxlV5Jq1qypihUravv27ad8PyAgQGFhYYU2AABgkfxcZU65U0E5R7XFFa9DN46m7OKCWFp4jTEaNmyYZs+erWXLlqlGjRrndNyYMWP04osvauHChbr66qvPOn7//v06evSoYmNjLzQyAAAoYSe+flrlUr6XwwRpUtUXNfim+lZHgoeztPAmJCRoypQpmjZtmkJDQ5WcnKzk5GRlZ2cXjOnbt69GjhxZ8PqVV17R008/rY8//ljVq1cvOCYjI0OSlJGRoUceeUTr1q3T7t27tXTpUnXs2FG1a9dW69atS/07AgCAc5f/6xwF/jBekjQm8AE91vs2+fjYLE4FT2dp4R0/frzS0tLUvHlzxcbGFmwzZswoGLN3714lJSUVOiYnJ0ddunQpdMzYsWMlSXa7XT///LM6dOigOnXqaODAgbrqqqu0atUqBQQElPp3BAAA5+jINuXPGipJ+sjVXr36JSg8yM/iUPAGbnPTmjthHV4AAEqZM0OZ425UOcd2rXNdooPtE3V7o+pWp4Ib87ib1gAAQBlmjDK/GKZyju1KMRFaftloyi6KFYUXAABYKnft+yr352zlGR/9t/yTerDz9VZHgpeh8AIAAOvs2yDb4iclSW/69NH9/fsowPfkh0QBF4LCCwAArJF5RFlTe8vX5GlBfmM16fm04iKCrE4FL0ThBQAApc+Vr4ypfRV84pB2uGK1/4axPFwCJYbCCwAASl32Ny8o5OB3yjQBmhj/kgbdfOanpgIXgsILAABKVf4f8xW07g1J0muBCXr4zo48XAIlisILAABKz5Ftyvt8sCRpsutWden3IA+XQImj8AIAgNLhTFfmpO4KyM/UBlddhXQYrUvjeMATSh6FFwAAlDxjlPXZ3Srn2KFkU17LLhujzlfXsDoVyggKLwAAKHG5K15X8I75yjF2vV7+KR4ugVJF4QUAACXKbF8q+/KXJEmv+gzU8P69ebgEShWFFwAAlJzju+VM7C8fufRZfgvdfOdjPFwCpY7CCwAASkZOljIn9VBgnkObXTXlvGW0rqlV0epUKIMovAAAoPgZo8wvElTu+B86YsL0Zd1XdOf1da1OhTKKwgsAAIpd7trxKrd1lvKMj8aGj9Sj3W6WzcbDJWANCi8AAChWZvdq+XzzlCTpDZ++GjagvwL9uEkN1qHwAgCA4pN2QCem9ZFd+Zqbf62a9X5KVcoHW50KZRyFFwAAFI88p9In91JQzjH97qqmYze/qma1K1mdCqDwAgCA4pE5Z4RCj2xWqimnL2qPUv8bL7U6EiCJwgsAAIpB7oaPVe7XKXIZm8aGPqqHe9zKTWpwGxReAABwQcy+72X7+lFJ0js+PXX3XUMU5M9NanAfFF4AAHD+Mg4pa0ov+ZpcLcxvpCt7vqD4SG5Sg3uh8AIAgPOTl6P0ST1VznlI21yVldTidV1Xh5vU4H4ovAAA4Lxkzn1IoYd+kMMEKbHWKPVvcZnVkYBTovACAIAiy13/kcr9MkkuY9OrIY/qoZ7tuEkNbovCCwAAisTs/k4+/7tJ7W1bTw2+6x4F+/tanAo4PQovAAA4d6n7dGJqb9mVr6/yr1GDns+ragVuUoN7o/ACAIBzk5OljE+7Kyj3uH51Vdfhm17XjXWjrE4FnBWFFwAAnJ0xypx5j0KO/6YjJkyz6ozRgOY8SQ2egcILAADOyrnyvyq3ba5yjV2vRTypR7u35CY1eAwKLwAAOCPX1kXy+/YFSdLr9rs0fGB/BfrxJDV4DgovAAA4vSPblPPZXfKRUaLrZrXq94SiwwKtTgUUCYUXAACc2ok0ZUzsqsD8DH3vqqOADmPVsFqk1amAIqPwAgCAk7ny5ZjaXyEZu3TQROq7K/+rzlfXtDoVcF4ovAAA4CRZi15Q2L5lOmH89H7MC7qvw7VWRwLOG4UXAAAUkvfT5wpe/4Yk6bXAYRrRv4fsPqzIAM9F4QUAAAVM0k9yzblXkvSx6aAegx5WeJCfxamAC0PhBQAAf8k8osxPu8vfOLXCdblqdB+jWpVCrE4FXDAKLwAAkPJylPZpT4WcSNIuV7R23PCWWlwaa3UqoFhQeAEAKOuMUcasBxR+aIPSTZASa72iATc3sDoVUGwovAAAlHHO795VyO/T5DI2vR7+mB7s1YHHBsOrUHgBACjDXH8ult+SpyRJb9n76u6BQ3lsMLwOhRcAgLLq8FblzugnH7n0uau5buj3nGLCeWwwvA+FFwCAsijrmDI+uUMB+Zna4Kor+23/1ZU8NhheisILAEBZk58rx+TeCsnap/2motY3elOdG/PYYHgvCi8AAGWJMcqYM0JhSWuUYQI1IX6UEtpdY3UqoERReAEAKEOca95TyC+T5DI2jQ15RI/0vV0+PDYYXo7CCwBAGZG/bZl8Fz8hSXrHfqeGDE5QsL+vxamAkkfhBQCgLDiyXTmJfWWXS7NdN+iG/i8qLiLI6lRAqaDwAgDg7bKPy/HJHQrKT9dG10Xy7/SWGlQtb3UqoNRQeAEA8Gb5uUqd1Fthmbu131TUD03eVrsra1idCihVFF4AALyYY+4jikj6TlkmQJOrj9KQtqzIgLKHwgsAgJfKXvuBwn7+RJL0ZtjDevDOO2SzsSIDyh4KLwAAXih/+3L5L3pMkjTe3ksDB9+vQD+7xakAa1B4AQDwNkd3KGf6nbLLpS9d1+n6AaMUFRZodSrAMhReAAC8SdYxOSZ0VlB+uja5aivwjnGqXyXC6lSApSi8AAB4i7wcpU3srrCsPdpvKmrTte+q1RXVrU4FWI7CCwCANzBGjs/vVfihDUo3QZpa81UNaNXY6lSAW6DwAgDgBTKXvaqwLTOVZ3z034gn9ECvjqzIAPwPhRcAAA+X8/MXKrfqP5KkN/0HKWHw3azIAPwDhRcAAA/m2vu9NPseSdIUtVXHwc+oQkiAxakA90LhBQDAU6XuVfbkbvI3OVrmaqiavd5Q7ahQq1MBbofCCwCAJzrhUNqE21Uu95h+d1VTatv31KxOtNWpALdE4QUAwNPk5+n4pN4KT9+mFBOhlVe/rduvudjqVIDbovACAOBJjFHq7BEqf3Clso2/JlYbrSG33WB1KsCtUXgBAPAgmavGKeLXT+UyNr0V8age6NNNPj4sPwacCYUXAAAPkfP71wpc9rQk6T3/vho0+H6WHwPOAYUXAAAP4Dr4s1wzB8gul77QTWo16D8sPwacIwovAADuLj1ZGRPvUKDJ1hpXPcX1fle1o1l+DDhXFF4AANxZTpaOfXS7wnIOaYcrVodu/UBNL4q1OhXgUSwtvKNGjVKjRo0UGhqqqKgoderUSVu3bj3rcTNnztTFF1+swMBAXXbZZVqwYEGh940xeuaZZxQbG6ugoCC1bNlS27ZtK6mvAQBAyXDl6+ikPopM+03HTIiWXTVOnZrVtzoV4HEsLbwrVqxQQkKC1q1bp8WLFys3N1etWrVSZmbmaY9Zs2aNevbsqYEDB2rTpk3q1KmTOnXqpF9//bVgzJgxY/TWW2/pvffe0/r161WuXDm1bt1aJ06cKI2vBQBAsUid/bAq7F8ip/HTxKqjNLD9TVZHAjySzRhjrA7xt8OHDysqKkorVqzQDTecek3B7t27KzMzU/PmzSvYd80116hBgwZ67733ZIxRXFycHnroIT388MOSpLS0NEVHR2vixInq0aPHWXM4HA6Fh4crLS1NYWFhxfPlAAAogowVbynk279WZBgb/oSGDXuYFRmAfyhKX3OrObxpaWmSpMjIyNOOWbt2rVq2bFloX+vWrbV27VpJ0q5du5ScnFxoTHh4uJo0aVIw5t+cTqccDkehDQAAqzh/nqPgb5+RJL3r108DBg+n7AIXwG0Kr8vl0vDhw3Xttdeqfv3Tz09KTk5WdHThZ4VHR0crOTm54P2/951uzL+NGjVK4eHhBVt8fPyFfBUAAM5b/t4Nss0eLB8ZzVArlh8DioHbFN6EhAT9+uuvSkxMLPWfPXLkSKWlpRVs+/btK/UMAACYozt1YlJX+ZscfetqqJp9x7H8GFAM3KLwDhs2TPPmzdO3336rKlWqnHFsTEyMUlJSCu1LSUlRTExMwft/7zvdmH8LCAhQWFhYoQ0AgFKVdUxpH3VUubxU/eKqLmenj9SoZpTVqQCvYGnhNcZo2LBhmj17tpYtW6YaNWqc9ZimTZtq6dKlhfYtXrxYTZs2lSTVqFFDMTExhcY4HA6tX7++YAwAAG4l94SOTbhDEdl7td9U1E/Xf6Bbr6xtdSrAa/ha+cMTEhI0bdo0zZ07V6GhoQVzbMPDwxUUFCRJ6tu3rypXrqxRo0ZJkh544AHdeOONeu2119SuXTslJibqhx9+0AcffCBJstlsGj58uF566SVddNFFqlGjhp5++mnFxcWpU6dOlnxPAABOy+XS0al3qcLRH+UwwZp76Ru6t2Vjq1MBXsXSwjt+/HhJUvPmzQvt/+STT9S/f39J0t69e+Xj8/8Xops1a6Zp06bpqaee0hNPPKGLLrpIc+bMKXSj26OPPqrMzEwNGTJEqampuu6667Rw4UIFBgaW+HcCAKAojn/1hCrsnq8cY9eHlV/Q8K63yWazWR0L8CputQ6vu2AdXgBAaXCsfl9hSx6VJL0R+pDuuf9Jlh8DzpHHrsMLAEBZceK3r1VuyeOSpAl+PdXn7scou0AJofACAFDK8vZvkj7vL7tcmmO7STcPGctau0AJovACAFCKTOpeZU28Q4HmhL4zl6lqv/dVvVKI1bEAr0bhBQCgtGSn6tgHnRSWd1RbXPHK7jxRV1ZnrV2gpFF4AQAoDXlOHZ7QVRWydijZlNcvzSeoZQPW2gVKA4UXAICS5nLp8OS7VOnIBqWbIM2r/6a63tTE6lRAmUHhBQCghB2b85gq7ZmnHGPXJ/Ev6q47OlgdCShTKLwAAJSgtGX/VeTPfz0N9L2IhzSk313y8eHBEkBpovACAFBCsjbOUPjK5yRJ7wf0U9+7H2GtXcACFF4AAEpAzrbl8vvqXknSDJ+2uu2e0YoI9rc4FVA2UXgBAChm+Um/KH9aL/kpT4t0ja4YPF6VywdbHQsosyi8AAAUI5O6VxkTOinIZGqDuUTle3+ii2MjrI4FlGkUXgAAikvWMR17v4PC845oq6uKHB0nqvFFcVanAso8Ci8AAMUhN1uHPrxDFbJ3KclE6tcWH6vllRdbnQqAKLwAAFw4V75SJvZV1PEf5TDBWtRgnO5owYMlAHdB4QUA4EIYo0OfPaDoA9/IaXw1reZo9evUxupUAP6BwgsAwAU4smi0orZMlsvY9HHU4xp0Zx/ZbDxYAnAnFF4AAM5T6tpJqrhutCTpk9DB6j94hHzt/NUKuBt+KwEAOA+Zv3+jkEXDJUmJfp3Veeh/FOTPU9QAd0ThBQCgiJx7vpd9Zh/5Kl8Lbdfr2nveUWQ5nqIGuCsKLwAARZB/6E/lfHqHAs0JrTWXqdrAiYqvEGJ1LABnQOEFAOAcmbQDSv/wNoW60vSLq6Z8ek7VJVUqWh0LwFlQeAEAOBdZx3T0/dsUkZuina5YJbefoiYXV7M6FYBzQOEFAOBscrJ06IPOqpi1U8mmvDY1n6BbGtWzOhWAc0ThBQDgTPJzlTyhh6JSNyvNBGvxle/qjpuutToVgCKg8AIAcDoul5InD1ZMygqdMH6aWec13dmBp6gBnobCCwDAaSTPekwxu2crz/jo0yrP666ePXmKGuCBKLwAAJzC4YVjFPPrB5KkCRUe1oABQ+XjQ9kFPBGFFwCAfzm6+hNVWvcfSdInIYPU557H5O/LX5mAp+K3FwCAf3D89KUiloyQJH3m31md7x2lYH9fi1MBuBAUXgAA/idr2yoFzB4ou1yab79JN9w7XhHBPDIY8HQUXgAAJDkP/CIzrbsClKOVukqX3j1RMRFBVscCUAwovACAMi/v6G5lf9xR5UymfjR1VWHANNWICrc6FoBiQuEFAJRpJj1Fx99vp4j8o9pq4pXXPVH1qsVYHQtAMaLwAgDKruxUHRrfTpVy9mu/qaik9lPV+NKaVqcCUMwovACAsiknS0nvdVR01jYdNuH6ucWnan71FVanAlACKLwAgLInL0dJH3ZRbNpmpZlgfdv4fbVtfp3VqQCUkPNaWPCFF1444/vPPPPMeYUBAKDEufJ18JM+ijv8nbJMgOZe+qb6tmtjdSoAJei8Cu/s2bMLvc7NzdWuXbvk6+urWrVqUXgBAO7JGB2ccrfiDixUjrFres3RuqtbV6tTAShh51V4N23adNI+h8Oh/v37q3PnzhccCgCAYmeMDs58RHE7Zyrf2DSp8jMa0GeAbDab1ckAlLBim8MbFham559/Xk8//XRxfSQAAMUmaf5/FPf7h5KkTys+pH4D75fdh7ILlAXFetNaWlqa0tLSivMjAQC4YIeWvq3YH16VJE0Ku1u97nlCfnbu2wbKivOa0vDWW28Vem2MUVJSkiZPnqw2bZj4DwBwH0fWTFbUqqckSTOCe+r2hJcV6Ge3OBWA0nRehfe///1vodc+Pj6qVKmS+vXrp5EjRxZLMAAALtTxH+cq4pv7JUlz/G9T64Q3FRJwXn/1AfBg5/Vbv2vXruLOAQBAsXL88a3KfTlQvnJpoW8LNUv4UBHlAqyOBcACTGACAHidjF3r5Tujp/yVqxU+jVXvnkmKCg+2OhYAi1B4AQBe5cSB32Qm3aFgZWuD6qvKoOmKrxhmdSwAFqLwAgC8Rs7hXcr+uL1CTbp+Vm2F9PtMteIqWh0LgMUovAAAr5Cful+O929V+fyj2maqKL/nTF1ao7LVsQC4AQovAMDjuRwpOvburaqYl6w9JlpHO89Qw7o1rY4FwE1QeAEAHs1kHdPh8W1UKWefDpoK2tV2mq5pUN/qWADcCIUXAOCxzIk0JY1rp+jsHTpkIvTTzZPVvMnVVscC4GYovAAAz5STqYPvdlBc5u86ZkK07rqP1eaGa61OBcANUXgBAJ4n94T2j++syo7NcphgrWjyoTrccrPVqQC4KQovAMCz5Odq3wfdVOX4emWaAH3T8B11btvW6lQA3BiFFwDgOVz52vtRb8UfXqETxk9f1fuvunS6w+pUANwchRcA4BlcLu395C5VTVqkHGPXrDqvqHvXXlanAuABKLwAAPdnjPZMuVdV981RnvHRzBovqGevu2Sz2axOBsADUHgBAO7NGO2Z8ZCq7Zwul7FpRpUn1LNvAmUXwDmj8AIA3NreWc+o2pYJkqTE6BHqMfBh+fhQdgGcOwovAMBt7f1qlKr+8pYkKbHCvep691OyU3YBFBGFFwDglvYvelNVN46WJM0MH6DOQ1+Sn52/tgAUHX9yAADczsGl76rK2mckSbNDeqj9sNcU4Gu3OBUAT0XhBQC4leTlHypu1UhJ0pfBt6vVsHcU6EfZBXD+KLwAALeRsnqiopY/Ikn6MrCDmt/3vsoF+lmcCoCno/ACANzCoTVTVHHJg/KR0Vf+bXT9sI8UFuRvdSwAXoDCCwCw3OF1iYr85j7Z5dLXfq3U7L5PVD4kwOpYALwEhRcAYKnDG75Q+YX3ylcuLfK7WY3un6QKoUFWxwLgRSi8AADLHN44VxELhshX+Vrs21wNh01WRcougGJG4QUAWOLI5vkK/+ou+SlPS32v1+XDpioqvJzVsQB4IUsL78qVK9W+fXvFxcXJZrNpzpw5Zxzfv39/2Wy2k7Z69eoVjHnuuedOev/iiy8u4W8CACiKoz8vUuicfvJXnpbbm6revdMVHRFidSwAXsrSwpuZmakrrrhC48aNO6fxb775ppKSkgq2ffv2KTIyUl27di00rl69eoXGrV69uiTiAwDOw7HflqrcrDsVoFytsjdSnXtnKCYy1OpYALyYr5U/vE2bNmrTps05jw8PD1d4eHjB6zlz5uj48eMaMGBAoXG+vr6KiYkptpwAgOJx/PflCprZU4HK0Rqfq1TjnpmKqxB+9gMB4AJ49BzeCRMmqGXLlqpWrVqh/du2bVNcXJxq1qyp3r17a+/evWf8HKfTKYfDUWgDABSv41tWKeCzHgqSU+ttDRR/z+eqUqm81bEAlAEeW3gPHjyor7/+WoMGDSq0v0mTJpo4caIWLlyo8ePHa9euXbr++uuVnp5+2s8aNWpUwdXj8PBwxcfHl3R8AChT0ratlX9iVwUrW9/bLlfsPV8oPirS6lgAygibMcZYHUKSbDabZs+erU6dOp3T+FGjRum1117TwYMH5e9/+ifxpKamqlq1anr99dc1cODAU45xOp1yOp0Frx0Oh+Lj45WWlqawsLAifQ8AQGFp29fLPqWzQpSpjbZ6qjBkrqrHVrI6FgAP53A4FB4efk59zdI5vOfLGKOPP/5Yffr0OWPZlaSIiAjVqVNH27dvP+2YgIAABQTwRB8AKG7pO9bJPvV2hShTm2yXqPyg2ZRdAKXOI6c0rFixQtu3bz/tFdt/ysjI0I4dOxQbG1sKyQAAf8vYsV4+UzorxGTqR12isEFzVLNytNWxAJRBlhbejIwMbd68WZs3b5Yk7dq1S5s3by64yWzkyJHq27fvScdNmDBBTZo0Uf369U967+GHH9aKFSu0e/durVmzRp07d5bdblfPnj1L9LsAAP5f+o51sk3ppHImSz/qEoUOmqNalVk9B4A1LJ3S8MMPP6hFixYFr0eMGCFJ6tevnyZOnKikpKSTVlhIS0vTF198oTfffPOUn7l//3717NlTR48eVaVKlXTddddp3bp1qlSJ/4UGAKXBsW2t7FNvVzllaaMuVejA2bqoCmUXgHXc5qY1d1KUSdAAgP+Xtm2NfKfeUVB2wwZRdgGUDK+/aQ0A4H7+XXbDB81R7SrM2QVgPQovAOCCpf35nXyn3aFyytZG1VPE4NmqxQ1qANyER67SAABwH6l/ri4ouz/Y6ili8BzKLgC3whVeAMB5O751tfyndykou5GD56hmXJTVsQCgEK7wAgDOy7Etq/5RduurAmUXgJviCi8AoMiObVmlwMQuCtYJ/WCrr4pD5vAENQBui8ILACiSf5fdSkPmqBplF4AbY0oDAOCcHft9+T/K7mWKupuyC8D9cYUXAHBOjv2yWEFf9FaQnPrB5zJFD5mj+JiKVscCgLPiCi8A4KyO/rRA5b7opSA5tc6noWLumUvZBeAxKLwAgDM6vHGuQmf3UYBy9J3P1ap8zyxViapgdSwAOGcUXgDAaR1a/7kivrpL/srTCvs1qnbvF4qPirQ6FgAUCYUXAHBKyWumKfLrwfJTnpb5Xq+6CZ+rSsUIq2MBQJFx0xoA4CQHV05U9LIHZZdLS/xa6Iph01QpPNjqWABwXrjCCwAoZP+yDxSzbLjscmlRQCtdef90yi4Aj0bhBQAU2PvN26qy8hH5yGhBYDtdc/8URYYGWR0LAC4IUxoAAJKkPQteU7UNL0iS5gV31I33faTQIH+LUwHAhaPwAgC0e+7Lqr7pFUnSlyFddfOw8SoX6GdxKgAoHhReACjjds16TjV+/q8kaU5Yb9067C0F+vPXAwDvwZ9oAFBWGaOdM59Uzd/HSZJmR/RXm4TXFehntzgYABQvCi8AlEXGaOf0h1TzzwmSpFkVhui2oa/I35d7mQF4HwovAJQ1Lpd2TbpHNXfPkCTNihqmDne/KF87ZReAd6LwAkBZkp+n3R/3V40DX8llbPq88iO6Y9ATsvvYrE4GACWGwgsAZUVejnZ/0FPVDy1RnvHR59WeVrf+D8qHsgvAy1F4AaAMMDlZ2vteF1U/9p2cxldzav9H3e+8WzYbZReA96PwAoCXMycc2jeuo6ql/6gsE6Cv67+mbl3upOwCKDMovADgxVyZx3RgXDtVzfpdDhOk5VeN0x0d7rA6FgCUKgovAHipvLRkHXq3reKdO3TMhGj9tR+pQ6s2VscCgFJH4QUAL+Q8tlfHx7dRXO5+HTIR+vXmT9XmhuZWxwIAS1B4AcDLnEjZrvQP2ikmP1kHTEXtbDtNNzVpYnUsALAMhRcAvEjm/t/k/Li9KrmOareJ1aHOM3R9gyusjgUAlqLwAoCXcOz8QWZyZ0Uah7aZeGV2/0KNL61rdSwAsByFFwC8wLGtq+Q/vbtClKnfVEs+fWepQa3qVscCALdA4QUAD3d48wKFzOmvIDm1yXaJwu6apVrxcVbHAgC3QeEFAA+Wsi5RkQsT5Kc8rfNpqMpDPld8TEWrYwGAW/GxOgAA4PwcXDpeFRcOlZ/ytMz3OlUbNpeyCwCnwBVeAPBA+758WfE/viJJWuB/qxoP+0QVw4ItTgUA7onCCwCexBjtmfGIqm35UJI0u1x33TzsHYUF+VscDADcF4UXADyFK1+7P71b1ffMlCTNKD9EHYaOVpC/3eJgAODeKLwA4AnynNr94Z2qnvKN8o1Nn8U+rC6Dn5CfnVsxAOBsKLwA4OaMM0N7x9+h6qnrlGPsmlPzeXXvM0w+PjarowGAR6DwAoAbc2Ue14F3b1O1zF+VaQK0qP5r6trlTtlslF0AOFcUXgBwU7mpB3V4fDvFO3cq1ZTTd43H6/Z2Ha2OBQAeh8ILAG7IeWiH0j5op7i8JKWYCP1606dqd2Nzq2MBgEei8AKAm8nY97NyPumoKNcx7TVR2nfbNN3cqJHVsQDAY1F4AcCNpG5dJXtiD0WaDG0z8UrvOlPX1r/E6lgA4NEovADgJo5snKPQrwYrQDn6SXXk3/dzXVmrmtWxAMDjUXgBwA2krPhIFb59RL5y6Tufq1R58AxVj61kdSwA8AoUXgCwkjHaP+9lVdk4RpK0yO8mXT70U8VGhlkcDAC8B4UXAKzicmnv9AdVddtESdLs4C5qkfCuIsoFWJsLALwMhRcArJCXoz0f91e1g/MlSYnl71HHoS8ryN9ucTAA8D4UXgAoZeaEQ/ve76pqx9cp19g1s8pIdb3rIfnZfayOBgBeicILAKXIlX5YSeNvU9WsLcoyAZp/ySvq2b0/jwoGgBJE4QWAUuI8skup79+myrn7dcyE6LvG49W1XQerYwGA16PwAkApyNy7WTkTOyvadUwHTEVtveVTtb/uOqtjAUCZQOEFgBKW+sdy+X7WS+VNpv408Uq9PVE3XVHf6lgAUGZQeAGgBB3a8LnCF9yjAOVqky6Wf9/P1JinpwFAqaLwAkAJObD4HcV897Tscmm1vbHiB09XtZiKVscCgDKHwgsAxc0Y7ftipOJ/HS9JWuTfSg0TPlFUeIjFwQCgbKLwAkBxysvRvk8HKX7fXEnS56F91Pre1xUa5G9xMAAouyi8AFBMzIk07X+/m+KPr1Oe8VFi9Ah1HfKEAnx5ehoAWInCCwDFID8tSYfea6/47G3KMgGafdF/1KvXIPn48EAJALAahRcALpAz6XelT+ik2LwUHTZh+q7xu+rdrr3VsQAA/0PhBYAL4Ni6UrbEnqpoMrTLxGjXrZPUqWkTq2MBAP6BwgsA5+nIhs8UtuBe+StXP+ki5XWfrpsuvcjqWACAf6HwAsB5OLjoDcWsfU4+Mlrp01hxd01V7SpRVscCAJwChRcAisLl0t7PHlHVLR9JkuYFtFWjoR8pOqKcxcEAAKdD4QWAc5Xn1J6P+6nawa8lSTPCBqjt0DGssQsAbo7CCwDnwGSnat97d6ha2g/KNXZ9Vvkxdb3rEfn7+lgdDQBwFhReADiL3KO7dfSDTqrq3KV0E6SFl45Rr259ZLOxxi4AeAJLL02sXLlS7du3V1xcnGw2m+bMmXPG8cuXL5fNZjtpS05OLjRu3Lhxql69ugIDA9WkSRNt2LChBL8FAG+Wvft7ZY5roRjnLiWb8lp13afq2r0vZRcAPIilhTczM1NXXHGFxo0bV6Tjtm7dqqSkpIItKur/74yeMWOGRowYoWeffVY//vijrrjiCrVu3VqHDh0q7vgAvNzxTXNlm9hOEa5j2mKqalv7uWp7S2urYwEAisjSKQ1t2rRRmzZtinxcVFSUIiIiTvne66+/rsGDB2vAgAGSpPfee0/z58/Xxx9/rMcff/xC4gIoQ1IWv6mK3z0nu1xaowYK6TtF19eKtzoWAOA8eOTdFg0aNFBsbKxuueUWfffddwX7c3JytHHjRrVs2bJgn4+Pj1q2bKm1a9daERWAp3Hla//0BxT93TOyy6V5fq1U5d4vdTllFwA8lkfdtBYbG6v33ntPV199tZxOpz766CM1b95c69ev15VXXqkjR44oPz9f0dHRhY6Ljo7Wli1bTvu5TqdTTqez4LXD4Six7wDAjeVkad+E3opPWSZJmhZ6l9rd84rCy7HsGAB4Mo8qvHXr1lXdunULXjdr1kw7duzQf//7X02ePPm8P3fUqFF6/vnniyMiAA/lcqQo+f1Ois/8XU7jpxlVnlCPAcNZdgwAvIDH/0neuHFjbd++XZJUsWJF2e12paSkFBqTkpKimJiY037GyJEjlZaWVrDt27evRDMDcC/Og7/p2Fs3KC7zdx0zIZpzxXj1GfQgZRcAvITH/2m+efNmxcbGSpL8/f111VVXaenSpQXvu1wuLV26VE2bNj3tZwQEBCgsLKzQBqBsSPt9ifI+vEUV85K128To+5s+U/fbu7LsGAB4EUunNGRkZBRcnZWkXbt2afPmzYqMjFTVqlU1cuRIHThwQJMmTZIkvfHGG6pRo4bq1aunEydO6KOPPtKyZcv0zTffFHzGiBEj1K9fP1199dVq3Lix3njjDWVmZhas2gAAf0tZ9Ykilz4sP+XpR9VVfrepal3vIqtjAQCKmaWF94cfflCLFi0KXo8YMUKS1K9fP02cOFFJSUnau3dvwfs5OTl66KGHdODAAQUHB+vyyy/XkiVLCn1G9+7ddfjwYT3zzDNKTk5WgwYNtHDhwpNuZANQhhmj/bOfUZWf35IkLbVfp+oDJ6pWXCWLgwEASoLNGGOsDuFuHA6HwsPDlZaWxvQGwNvkObV34iBV3f+lJOnzoK5qfu/bqhgaZHEwAEBRFKWvedQqDQBwIUzGYSV9cIeqOn5SnvFRYtRwdRnylAL97FZHAwCUIAovgDIhJ/kPOSbcrrjcg3KYYM27eJR6de8nHx9uTgMAb0fhBeD1HL99I/vn/VXRZGqPidLm6z9Qr5Ytzn4gAMArUHgBeLVDy8YpcuVT8pVLG83FOnHHp+p4+cVWxwIAlCIKLwDv5MrXgRkjVHnrREnS1/bmqj1wgq6Kq2htLgBAqaPwAvA+znTt/6iXqhxeKUmaGtJPre8eo4qhgRYHAwBYgcILwKvkH9ujIx92VpXsHTph/JRY5Sn16H8fKzEAQBlG4QXgNbJ2rlPulB6Kdh3XIROhbxu+qX4dO/KYYAAo4yi8ALzC0fXTFfr1fQpWrv4w1XSwzUR1v+ZKq2MBANwAhReAZzNGB796QXE/vi5JWmW7SuF9J+vmmpUtDgYAcBcUXgCeK/eE9k8apCr7vpIkfRHQSU3vHqe4yBCLgwEA3AmFF4BHMo4kJX/YRVXSf1WusWt6xft1x5CnVC6AP9YAAIXxNwMAj+Pcu1HZk7opNu+IUk05zb/kFfXudqfsPCYYAHAKFF4AHiV1Q6KCFtyvCDm13VTWluYfqHeL66yOBQBwYxReAJ7B5VLyl88qZvNbkqRVaij/Hp/otktqWBwMAODuKLwA3J8zQwcn9lNc0hJJ0kz/zmoy+G1VrRRqcTAAgCeg8AJwa65je3Tko9sVl7VdTuOrqZVGqOugRxUa6Gd1NACAh6DwAnBbWdtXK29ab0W5UnXYhGth/dfU744u3JwGACgSCi8At3R01QSFLX1UwcrTb6a69reeoD7NrrY6FgDAA1F4AbiX/Dwd/PwRxf3xsSRpqa2povp+rNY14ywOBgDwVBReAO7jRJoOfNRTlY98J0maFtxbN989VtHhwRYHAwB4MgovALeQe+hPHZ/QRZWde5Rt/JVY+Qn1HHC/Av3sVkcDAHg4Ci8Ay6X/Ml8+swYrymTqoInU6qvfUv/bbpPNxs1pAIALR+EFYB1jdPjr0aqw4RX5yOhHU1cZHT5Wt6vqW50MAOBFKLwArJGTqaRP71LsgYWSpLm+rXXJXeN1ZVwFi4MBALwNhRdAqXMd3aUjE7ooNmu7coxdk8on6PbBTyuynL/V0QAAXojCC6BUZW5ZKvNZP0W50nXYhGvexa+of7fu8rX7WB0NAOClKLwASocxOrzkDUV+94LsculnU0sHWn+gATxMAgBQwii8AEpebrYOTrlHcXvmSJLm+7RQtb7vq031aGtzAQDKBAovgBLlOr5Phyd0U1zG78ozPpocPkTtBz+viqGBVkcDAJQRFF4AJSZr2yrlJd6p6PxUHTMh+vKil3Vnzz7yY74uAKAUUXgBlIjD376r8iueUrDy9Yepph03faD+N15jdSwAQBlE4QVQvHJP6OD0+xS38zNJ0mKfaxXV+0PdVquyxcEAAGUVhRdAsTGp+3RoQnfFpf8ml7FpWmh/tRo8SlHhQVZHAwCUYRReAMUi+89vlTejv6LzU3XchGh2zRd0Z+8B8vdlvi4AwFoUXgAXxhgdWfyayq/5j4Lk0m+murY1H6+7WjSzOhkAAJIovAAuhDNDSZMHKnb/QknSPJ/miuv9njrVirU4GAAA/4/CC+C85B/epuMfd1Vs9i7lGLs+DR+qjoOeUlQY83UBAO6FwgugyNI3z5V97j2qaLKUYiK04JJX1L9rN9bXBQC4JQovgHPnylfKl88qevPbkqQfzMU62vYDDWhyhcXBAAA4PQovgHOTdUxJn/RR7OHVkqQv/G5T/f5v6+rKkRYHAwDgzCi8AM4qZ/9mZUzqodicJGUbf02JekjdBz6ksEA/q6MBAHBWFF4AZ3R87SQFL3pIkcrRHhOlNVe9oYG3tZWPj83qaAAAnBMKL4BTyz2h5M+GK2bbdEnSajWUretH6lm/tsXBAAAoGgovgJOY47t15OMeikn/Qy5j0/SgHrph8FjFVwixOhoAAEVG4QVQSOavC6RZQ1TJla7jJkQzqz+nvnfepUA/u9XRAAA4LxReAH9x5evwV8+p0qa3JEk/uWppR4t3Nbh5E9lszNcFAHguCi8AKfOIkj/prZgj6yRJX9jbqM6AN3V7tWiLgwEAcOEovEAZ59y5VtnT+igm77CyTIAmV3pI3e96UBHB/lZHAwCgWFB4gbLKGB1d9pbCVz2vCOVruytOGxq/qcFtb2HJMQCAV6HwAmWRM11Jkwcrdv/XkqRvbM0U1mu8el1c3dpcAACUAAovUMbkJv2mtE97KPbEXuUYu6aEDVG7Qc8qOjzI6mgAAJQICi9QhqSum6LAhSNUUU4dNJFaXG+M+t5xh3ztPlZHAwCgxFB4gbIgN1tJM4YrdnuiJGmNLteJju+r35WXWhwMAICSR+EFvJzr0J86+mkvxWZuK3hq2nUDx6hapTCrowEAUCoovIAXc3w/XX4LHlQlk63DJkxzaj6vPr368dQ0AECZQuEFvFFutlI+e1DR26ZLktaZejp8yzsafN2VFgcDAKD0UXgBL5N/6E8d/7SXov83hWFqQHc1GfCKromNsDoaAACWoPACXsSxYbr8vn5QFf83hWF29ed0Z+9+CvbnVx0AUHbxtyDgDXKzlfzZcMVs+2sVhvXmUh1u9a6GXNvQ4mAAAFiPwgt4uPzD23Tsk56KyfrfFIbA7rqm/ytqwhQGAAAkUXgBj/b3FIa/V2GYXeM59enVX0H+rMIAAMDfKLyAJ8rNVvKM4YrZ/v9TGI62fldDmjGFAQCAf6PwAh7m31MYpgV21zUDXlGTmAirowEA4JYovIAHSdswVf5fP6RKJltHTJjm1HhOvZnCAADAGVF4AU/gzFBS4jDF7potSdpgLtXR1uM0qBkPkgAA4GwovICby92/WY7JfRTr3Kt8Y9O0oJ5q2n+UGjOFAQCAc0LhBdyVMTq67C2FrXpBFZSngyZSi+q8qJ7deirQjykMAACcKwov4I4yjyhp0l2KTVkhSfpWjWTr9I4GNLzY4mAAAHgeCi/gZrL//FY5nw1UbN5ROY2fpoQPVtu7nlZsRLDV0QAA8EgUXsBd5Ofp0FfPqeLmdxQko+2uOG24aqz6t28ru4/N6nQAAHgsHyt/+MqVK9W+fXvFxcXJZrNpzpw5Zxw/a9Ys3XLLLapUqZLCwsLUtGlTLVq0qNCY5557TjabrdB28cX8b2C4N9exPUp56yZFbX5bPjL60udmpfVZrF4d21F2AQC4QJYW3szMTF1xxRUaN27cOY1fuXKlbrnlFi1YsEAbN25UixYt1L59e23atKnQuHr16ikpKalgW716dUnEB4qF48fPlf1OM0Wn/SSHCdKH0U/phocTddVFVayOBgCAV7B0SkObNm3Upk2bcx7/xhtvFHr98ssva+7cufrqq6/UsOH/P1LV19dXMTExxRUTKBk5WUr67EHF/u/xwJtNbe268S0NatFMNhtXdQEAKC6WXuG9UC6XS+np6YqMjCy0f9u2bYqLi1PNmjXVu3dv7d2794yf43Q65XA4Cm1AScpN+lWH/3utYrcnymVsmu5/h4KGLFbnm66l7AIAUMw8uvCOHTtWGRkZ6tatW8G+Jk2aaOLEiVq4cKHGjx+vXbt26frrr1d6evppP2fUqFEKDw8v2OLj40sjPsoiY3RsxXi53m+hStk7dchEaGKt19Xp4Q9Vt3Lk2Y8HAABFZjPGGKtDSJLNZtPs2bPVqVOncxo/bdo0DR48WHPnzlXLli1POy41NVXVqlXT66+/roEDB55yjNPplNPpLHjtcDgUHx+vtLQ0hYWFFel7AKeVeURJkwcpNvlbSdJqNdCJduPUslF9i4MBAOB5HA6HwsPDz6mveeSyZImJiRo0aJBmzpx5xrIrSREREapTp462b99+2jEBAQEKCAgo7phAgczfFilv1j2KzT8mp/HV9NABannXc6oSGWJ1NAAAvJ7HTWmYPn26BgwYoOnTp6tdu3ZnHZ+RkaEdO3YoNja2FNIB/5J7QkkzHlC5md0Unn9M20xlfd7wU9354BjKLgAApcTSK7wZGRmFrrzu2rVLmzdvVmRkpKpWraqRI0fqwIEDmjRpkqS/pjH069dPb775ppo0aaLk5GRJUlBQkMLDwyVJDz/8sNq3b69q1arp4MGDevbZZ2W329WzZ8/S/4Io03IP/qLUyf0Um71DkvSFb1vV7PW6etfkP74AAChNll7h/eGHH9SwYcOCJcVGjBihhg0b6plnnpEkJSUlFVph4YMPPlBeXp4SEhIUGxtbsD3wwAMFY/bv36+ePXuqbt266tatmypUqKB169apUqVKpfvlUHYZoyNL3pT5oIUqZe/QYROmCVVfUetHJqshZRcAgFLnNjetuZOiTIIG/smkJytp0l2KO/ydJGmlGsrZ9m3d0vgyi5MBAOBdvP6mNcAdpf/0pTR3mOJcaTph/DQtYojaDHhKsRHBVkcDAKBMo/ACFyonSwc/e0hx26dJkv4w1fRzk9fU/9aW8vHhIRIAAFiNwgtcAOfeH5U+tZ/inH/NNf/Mr5Pq9XlV3atGWZwMAAD8jcILnA+XS4cXvaqI9WNUUXlKMRFaUPs59ejeV0H+dqvTAQCAf6DwAkVkUvcp+dMBij3+vSRpmRrL3vltDWhwscXJAADAqVB4gXNljFLXT5XfokcVazKVZQKUWCFB7fs/pkphgVanAwAAp0HhBc5F1jEdmHKPKh9cJEn6ydTSzute14CWN8pm48Y0AADcGYUXOIv0XxbINSdBlfOPKdfY9Vm5nmrS9z/qHBNhdTQAAHAOKLzA6TgzdGDmQ6q8PVGStN3EaUPD0erWvr387JY+pBAAABQBhRc4hewda5U1Y6Aq5xyQJH3u1151e49Vr+oxFicDAABFReEF/ikvR0lfPquon99TkFw6YCpoSZ1n1b3bnQr0Y7kxAAA8EYUX+J/cpN90bPIAxWZtlSR97XOjynd5Q/0urWlxMgAAcCEovIDLpUOL/6uItaMUrVwdMyH6ssqj6nznvQoP8rM6HQAAuEAUXpRp+cf2KGXSAMWlbpQkrVJD5bZ7U/0bX2FxMgAAUFwovCibjNHR7yYqaOkTijNZyjQB+rziULXp97iiwoKsTgcAAIoRhRdljklP0YEp96hKyjJJ0iZTRweav6G+zZvxEAkAALwQhRdlyvENifJd+IiquBzKMXbNDO2r6/u9qIaVQq2OBgAASgiFF2WCyTis/VMTFJ/016OB/zDV9GvjV9Sjza2y+3BVFwAAb0bhhddL3fiFfOaPULwrVXnGR5+X66Gr+7ykrrEVrI4GAABKAYUXXstkHtX+acMUf2CBJGmriddPV49Sl7bt5MujgQEAKDMovPBKqZvmyDZvuOLzjyvf2PRFcFc17DNK3eIqWh0NAACUMgovvIrJOq590x9Q1X1zJUnbTWX9eOXL6nxbB/lxVRcAgDKJwguvkfbzfJm596lq/lHlG5tmB92u+r1Hq1t8lNXRAACAhSi88Hwn0rR3+nBV3TNLkrTTxOr7K/6j2zt25qouAACg8MKzOX5dqPw5w1Q177BcxqbZgR11Se8x6l412upoAADATVB44Zmc6dqb+JCq7pohSdpjorX28pd0e8cu8vflqi4AAPh/FF54nLRfvlb+3PtVNe+QJGm2f3vV6fWqelSPtTgZAABwRxReeAyTdUz7pj+oqvvmSJL2mCitrfecOt/eQwG+dmvDAQAAt0XhhUc4tvEL2ec/pKqu43IZm+YEdlDdnq9wVRcAAJwVhRduzZV+SPumJqha8jeS/lpXd3PDF9WxPSswAACAc0PhhXsyRkfWTpH/kidUzeVQnvHR7HJd1bD3f9SlciWr0wEAAA9C4YXbyU89oANT7lHVIyslSX+YatrSZLRuv7WN7D42i9MBAABPQ+GF+zBGKcs/UMjK51TVZMlpfDUnrLeu6fOCOkdFWJ0OAAB4KAov3ELukV1KnjJE8akbJEk/mYu07/pX1e3m5rLZuKoLAADOH4UX1nK5dHDxm4pcO0rxcirb+Gtu5F26se/TuqJ8iNXpAACAF6DwwjLO5C06PHWwqqT/LEn6QZfqeMvX1P26plzVBQAAxYbCi9KXl6N9815W9Oa3VUV5SjdBmhd9j27p85iuDg2yOh0AAPAyFF6Uqoxta5Tx+b2Kd+6SJH1na6i8dq+rZ6MrLU4GAAC8FYUXpcKcSNOezx5X1Z3TFSKjIyZMS6o9qDY9hik82N/qeAAAwItReFHijm6cI9uCh1Q9/4gkaaHvTYq6Y6x6XFLL4mQAAKAsoPCixOSnJWnv1GGqcWiJJGmPidb39Z9R+849FeBrtzgdAAAoKyi8KH4ul5K+fV+hq19UDZOpPOOjr8rdoct6v6wulaOsTgcAAMoYCi+KlTPpD6VMG6qq6ZskSb+YWtp73Wh1vPkW+fBYYAAAYAEKL4pHXo72fPkfxf78jqoqT5kmQPMrDtSNfZ7SZRHlrE4HAADKMAovLpjjz++U+UWCqv1vqbE1tiuV23asujW+yuJkAAAAFF5cAJOdql2fjVT1XdMV9r+lxr6tPkK39khQaBBLjQEAAPdA4UXRGaND62fI75uRquk6Jkla5HezoruMVde6NS0OBwAAUBiFF0XiPLxDSdOGqfrxNZKkXSZGmy97Ru069ZS/r4/F6QAAAE5G4cW5ycvRnnmjFbP5bVVXjpzGV/PDe+iqXi+oc0wFq9MBAACcFoUXZ5X6x3KdmH2/quXskSR9b7tM6S1fUedrm8lmY6kxAADg3ii8OC1XxhHtmv6Qah2YI0k6YsK0vPpwtepxn8K4KQ0AAHgICi9OZowOLP9IoStfUC3jkCR9HXCrqnYboy61qlkcDgAAoGgovCgk68CvOjI9QVUzNkuS/jRVta3xi7q1TUfZeVIaAADwQBReSJJMTqZ2zXpeVbd8pKrKV5YJ0MJKA3Rt76fUrnyo1fEAAADOG4UXOrLpK5n5D6tmXrIkaZW9keztxur2KxtYGwwAAKAYUHjLsJxj+7Rv+nDVOrxEknTQVND6ix9Xmy4DFehntzgdAABA8aDwlkV5Odo9/1VFb3pLtXRCecZHC0M66ZJeo9S5cozV6QAAAIoVhbeMOfbLYuV8NULVc/ZKkjbrYh258T9q1+Jm1tQFAABeicJbRuQc26+9iSNU+9AiSX+tqbuq+v26qfsDahDMmroAAMB7UXi9XX6uds9/TVE/vqHayla+sWlR8G2q2W2UOteItzodAABAiaPwerFjvy6V88sRqp6zW5L0s+ro0I0v69bmLeXDmroAAKCMoPB6odzUg9ozfYRqp3wtSTpqQrWq2jC16PGgLg8OsDgdAABA6aLwepP8PO1e8LoqbXxdtZUtl7Hpm+C2qtZllDrxSGAAAFBGUXi9xLHfl+vE3AdV3blTkvSLaiv5+pfU6qZbmb4AAADKNAqvh8tNPajdiQ/rouT5kqTjJkQrqiaoRY+HdFk5pi8AAABQeD1VXo52zh+r6E1v6aL/TV9YHHSrqnYdrU61qludDgAAwG1QeD3QoR/nyfX1Y6qZu1+S9KtqK+m6F3TLzW2ZvgAAAPAvFF4Pkp38pw7OGKFax1dJ+uvhEd9Vv0/Nuz+g+qy+AAAAcEoUXg9gnOna/sULqvbnx6qlPOUauxaHdlTdbi+pY9XKVscDAABwaxRed2aM9q+apODlz+si11FJ0nqfBspp+bLaNG0mm43pCwAAAGfjY+UPX7lypdq3b6+4uDjZbDbNmTPnrMcsX75cV155pQICAlS7dm1NnDjxpDHjxo1T9erVFRgYqCZNmmjDhg3FH76EOXb+oN1jb1CVZfcr0nVU+0yU5l06Vlc8vlTXN7uWsgsAAHCOLC28mZmZuuKKKzRu3LhzGr9r1y61a9dOLVq00ObNmzV8+HANGjRIixYtKhgzY8YMjRgxQs8++6x+/PFHXXHFFWrdurUOHTpUUl+jWOWlH9afHw1UyKSWqp75s7JMgL6sMFA+923Qbd0GK9Cfi/IAAABFYTPGGKtDSJLNZtPs2bPVqVOn04557LHHNH/+fP36668F+3r06KHU1FQtXLhQktSkSRM1atRI77zzjiTJ5XIpPj5e9913nx5//PFzyuJwOBQeHq60tDSFhYWd/5cqivw87Vz0tip9P1ahJkOS9K3fDQrvMEpXXla/dDIAAAB4iKL0NY+6XLh27Vq1bNmy0L7WrVtr+PDhkqScnBxt3LhRI0eOLHjfx8dHLVu21Nq1a0szapEc/mWJcr56RDVz/npK2hZV055Gz+rmWzvL127pRXgAAACP51GFNzk5WdHR0YX2RUdHy+FwKDs7W8ePH1d+fv4px2zZsuW0n+t0OuV0OgteOxyO4g1+BulpxxTwRR9VUpaOmxCtjL9HN3R/WBeHBpVaBgAAAG/mUYW3pIwaNUrPP/+8JT87NDxSi6reLR3ZpmpdXlbHmtUsyQEAAOCtPKrwxsTEKCUlpdC+lJQUhYWFKSgoSHa7XXa7/ZRjYmJiTvu5I0eO1IgRIwpeOxwOxcfHF2/4M2jR9xn52W2svAAAAFACPGqCaNOmTbV06dJC+xYvXqymTZtKkvz9/XXVVVcVGuNyubR06dKCMacSEBCgsLCwQltp8vf1oewCAACUEEsLb0ZGhjZv3qzNmzdL+mvZsc2bN2vv3r2S/rry2rdv34Lx99xzj3bu3KlHH31UW7Zs0bvvvqvPPvtMDz74YMGYESNG6MMPP9Snn36qP/74Q0OHDlVmZqYGDBhQqt8NAAAA7sHSKQ0//PCDWrRoUfD672kF/fr108SJE5WUlFRQfiWpRo0amj9/vh588EG9+eabqlKlij766CO1bt26YEz37t11+PBhPfPMM0pOTlaDBg20cOHCk25kAwAAQNngNuvwuhNL1uEFAADAOStKX/OoObwAAABAUVF4AQAA4NUovAAAAPBqFF4AAAB4NQovAAAAvBqFFwAAAF6NwgsAAACvRuEFAACAV6PwAgAAwKtReAEAAODVKLwAAADwahReAAAAeDUKLwAAALwahRcAAABejcILAAAAr0bhBQAAgFej8AIAAMCrUXgBAADg1Si8AAAA8GoUXgAAAHg1Ci8AAAC8mq/VAdyRMUaS5HA4LE4CAACAU/m7p/3d286EwnsK6enpkqT4+HiLkwAAAOBM0tPTFR4efsYxNnMutbiMcblcOnjwoEJDQ2Wz2Ur85zkcDsXHx2vfvn0KCwsr8Z+H4sc59HycQ8/G+fN8nEPPV9rn0Bij9PR0xcXFycfnzLN0ucJ7Cj4+PqpSpUqp/9ywsDB+yT0c59DzcQ49G+fP83EOPV9pnsOzXdn9GzetAQAAwKtReAEAAODVKLxuICAgQM8++6wCAgKsjoLzxDn0fJxDz8b583ycQ8/nzueQm9YAAADg1bjCCwAAAK9G4QUAAIBXo/ACAADAq1F4AQAA4NUovKVk3Lhxql69ugIDA9WkSRNt2LDhjONnzpypiy++WIGBgbrsssu0YMGCUkqK0ynKOfzwww91/fXXq3z58ipfvrxatmx51nOOklfU38O/JSYmymazqVOnTiUbEGdU1POXmpqqhIQExcbGKiAgQHXq1OHPUosV9Ry+8cYbqlu3roKCghQfH68HH3xQJ06cKKW0+KeVK1eqffv2iouLk81m05w5c856zPLly3XllVcqICBAtWvX1sSJE0s852kZlLjExETj7+9vPv74Y/Pbb7+ZwYMHm4iICJOSknLK8d99952x2+1mzJgx5vfffzdPPfWU8fPzM7/88kspJ8ffinoOe/XqZcaNG2c2bdpk/vjjD9O/f38THh5u9u/fX8rJ8beinsO/7dq1y1SuXNlcf/31pmPHjqUTFicp6vlzOp3m6quvNm3btjWrV682u3btMsuXLzebN28u5eT4W1HP4dSpU01AQICZOnWq2bVrl1m0aJGJjY01Dz74YCknhzHGLFiwwDz55JNm1qxZRpKZPXv2Gcfv3LnTBAcHmxEjRpjff//dvP3228Zut5uFCxeWTuB/ofCWgsaNG5uEhISC1/n5+SYuLs6MGjXqlOO7detm2rVrV2hfkyZNzN13312iOXF6RT2H/5aXl2dCQ0PNp59+WlIRcRbncw7z8vJMs2bNzEcffWT69etH4bVQUc/f+PHjTc2aNU1OTk5pRcRZFPUcJiQkmJtuuqnQvhEjRphrr722RHPi7M6l8D766KOmXr16hfZ1797dtG7dugSTnR5TGkpYTk6ONm7cqJYtWxbs8/HxUcuWLbV27dpTHrN27dpC4yWpdevWpx2PknU+5/DfsrKylJubq8jIyJKKiTM433P4wgsvKCoqSgMHDiyNmDiN8zl/X375pZo2baqEhARFR0erfv36evnll5Wfn19asfEP53MOmzVrpo0bNxZMe9i5c6cWLFigtm3blkpmXBh36zK+lvzUMuTIkSPKz89XdHR0of3R0dHasmXLKY9JTk4+5fjk5OQSy4nTO59z+G+PPfaY4uLiTvrlR+k4n3O4evVqTZgwQZs3by6FhDiT8zl/O3fu1LJly9S7d28tWLBA27dv17333qvc3Fw9++yzpREb/3A+57BXr146cuSIrrvuOhljlJeXp3vuuUdPPPFEaUTGBTpdl3E4HMrOzlZQUFCp5uEKL1DCRo8ercTERM2ePVuBgYFWx8E5SE9PV58+ffThhx+qYsWKVsfBeXC5XIqKitIHH3ygq666St27d9eTTz6p9957z+poOEfLly/Xyy+/rHfffVc//vijZs2apfnz5+vFF1+0Oho8EFd4S1jFihVlt9uVkpJSaH9KSopiYmJOeUxMTEyRxqNknc85/NvYsWM1evRoLVmyRJdffnlJxsQZFPUc7tixQ7t371b79u0L9rlcLkmSr6+vtm7dqlq1apVsaBQ4n9/B2NhY+fn5yW63F+y75JJLlJycrJycHPn7+5doZhR2Pufw6aefVp8+fTRo0CBJ0mWXXabMzEwNGTJETz75pHx8uGbnzk7XZcLCwkr96q7EFd4S5+/vr6uuukpLly4t2OdyubR06VI1bdr0lMc0bdq00HhJWrx48WnHo2SdzzmUpDFjxujFF1/UwoULdfXVV5dGVJxGUc/hxRdfrF9++UWbN28u2Dp06KAWLVpo8+bNio+PL834Zd75/A5ee+212r59e8F/qEjSn3/+qdjYWMquBc7nHGZlZZ1Uav/+DxhjTMmFRbFwuy5jya1yZUxiYqIJCAgwEydONL///rsZMmSIiYiIMMnJycYYY/r06WMef/zxgvHfffed8fX1NWPHjjV//PGHefbZZ1mWzGJFPYejR482/v7+5vPPPzdJSUkFW3p6ulVfocwr6jn8N1ZpsFZRz9/evXtNaGioGTZsmNm6dauZN2+eiYqKMi+99JJVX6HMK+o5fPbZZ01oaKiZPn262blzp/nmm29MrVq1TLdu3az6CmVaenq62bRpk9m0aZORZF5//XWzadMms2fPHmOMMY8//rjp06dPwfi/lyV75JFHzB9//GHGjRvHsmRlwdtvv22qVq1q/P39TePGjc26desK3rvxxhtNv379Co3/7LPPTJ06dYy/v7+pV6+emT9/fiknxr8V5RxWq1bNSDppe/bZZ0s/OAoU9ffwnyi81ivq+VuzZo1p0qSJCQgIMDVr1jT/+c9/TF5eXimnxj8V5Rzm5uaa5557ztSqVcsEBgaa+Ph4c++995rjx4+XfnCYb7/99pR/r/19zvr162duvPHGk45p0KCB8ff3NzVr1jSffPJJqef+m80Y/r8AAAAAvBdzeAEAAODVKLwAAADwahReAAAAeDUKLwAAALwahRcAAABejcILAAAAr0bhBQAAgFej8AIAAMCrUXgBAADg1Si8AAAA8GoUXgDwUocPH1ZMTIxefvnlgn1r1qyRv7+/li5damEyAChdNmOMsToEAKBkLFiwQJ06ddKaNWtUt25dNWjQQB07dtTrr79udTQAKDUUXgDwcgkJCVqyZImuvvpq/fLLL/r+++8VEBBgdSwAKDUUXgDwctnZ2apfv7727dunjRs36rLLLrM6EgCUKubwAoCX27Fjhw4ePCiXy6Xdu3dbHQcASh1XeAHAi+Xk5Khx48Zq0KCB6tatqzfeeEO//PKLoqKirI4GAKWGwgsAXuyRRx7R559/rp9++kkhISG68cYbFR4ernnz5lkdDQBKDVMaAMBLLV++XG+88YYmT56ssLAw+fj4aPLkyVq1apXGjx9vdTwAKDVc4QUAAIBX4wovAAAAvBqFFwAAAF6NwgsAAACvRuEFAACAV6PwAgAAwKtReAEAAODVKLwAAADwahReAAAAeDUKLwAAALwahRcAAABejcILAAAAr0bhBQAAgFf7P8ETwIgDz/X3AAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 800x800 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from pina.plotter import Plotter\n",
    "\n",
    "# plotting the loss\n",
    "plotter = Plotter()\n",
    "plotter.plot(trainer=trainer)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7693a9f2",
   "metadata": {},
   "source": [
    "The solution is completely overlapped with the actual one. We can also plot easily the loss:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "d18e866e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plotter.plot_loss(trainer=trainer, metric='mean_loss', log_scale=True)"
   ]
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "56be7540488f3dc66429ddf54a0fa9de50124d45fcfccfaf04c4c3886d735a3a"
  },
  "kernelspec": {
   "display_name": "Python 3.9.16 64-bit ('dl': conda)",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.16"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}