{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "6f71ca5c",
   "metadata": {},
   "source": [
    "# Tutorial: Physics Informed Neural Networks on PINA"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "ef4949c9",
   "metadata": {},
   "source": [
    "In this tutorial, we will demonstrate a typical use case of **PINA** on a toy problem, following the standard API procedure. \n",
    "\n",
    "<p align=\"center\">\n",
    "    <img src=\"../../readme/API_color.png\" alt=\"PINA API\" width=\"400\"/>\n",
    "</p>\n",
    "\n",
    "Specifically, the tutorial aims to introduce the following topics:\n",
    "\n",
    "* Explaining how to build **PINA** Problems,\n",
    "* Showing how to generate data for `PINN` training\n",
    "\n",
    "These are the two main steps needed **before** starting the modelling optimization (choose model and solver, and train). We will show each step in detail, and at the end, we will solve a simple Ordinary Differential Equation (ODE) problem using the `PINN` solver."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "cf9c96e3",
   "metadata": {},
   "source": [
    "## Build a PINA problem"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "8a819659",
   "metadata": {},
   "source": [
    "Problem definition in the **PINA** framework is done by building a python `class`, which inherits from one or more problem classes (`SpatialProblem`, `TimeDependentProblem`, `ParametricProblem`, ...) depending on the nature of the problem. Below is an example:\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 the analytical solution $u(x) = e^x$. In this case, our ODE depends only on the spatial variable $x\\in(0,1)$ , meaning that our `Problem` class is going to be inherited from the `SpatialProblem` class:\n",
    "\n",
    "```python\n",
    "from pina.problem import SpatialProblem\n",
    "from pina.geometry import CartesianProblem\n",
    "\n",
    "class SimpleODE(SpatialProblem):\n",
    "    \n",
    "    output_variables = ['u']\n",
    "    spatial_domain = CartesianProblem({'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$), this is done because in **PINA** the `torch.Tensor`s are labelled, allowing the user maximal flexibility for the manipulation of the tensor. 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 if our equation is also time-dependent? In this case, our `class` will inherit from both `SpatialProblem` and `TimeDependentProblem`:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2373a925",
   "metadata": {},
   "outputs": [],
   "source": [
    "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({'t': [0, 1]})\n",
    "\n",
    "    # other stuff ..."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "ad8566b8",
   "metadata": {},
   "source": [
    "where we have included the `temporal_domain` variable, indicating the time domain wanted for the solution.\n",
    "\n",
    "In summary, using **PINA**, we can initialize a problem with a class which inherits from different base classes: `SpatialProblem`, `TimeDependentProblem`, `ParametricProblem`, and so on depending on the type of problem we are considering. Here are some examples (more on the official documentation):\n",
    "* ``SpatialProblem`` $\\rightarrow$ a differential equation with spatial variable(s) ``spatial_domain``\n",
    "* ``TimeDependentProblem`` $\\rightarrow$ a time-dependent differential equation with temporal variable(s) ``temporal_domain``\n",
    "* ``ParametricProblem`` $\\rightarrow$ a parametrized differential equation with parametric variable(s) ``parameter_domain``\n",
    "* ``AbstractProblem`` $\\rightarrow$ any **PINA** problem inherits from here"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "592a4c43",
   "metadata": {},
   "source": [
    "### Write the problem class\n",
    "\n",
    "Once the `Problem` class is initialized, we need to represent the differential equation in **PINA**. In order to do this, we need to load the **PINA** operators from `pina.operators` module. Again, we'll consider Equation (1) and represent it in **PINA**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "f2608e2e",
   "metadata": {},
   "outputs": [],
   "source": [
    "from pina.problem import SpatialProblem\n",
    "from pina.operators import grad\n",
    "from pina import Condition\n",
    "from pina.geometry import CartesianDomain\n",
    "from pina.equation import Equation, FixedValue\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 the u input variable\n",
    "        u = output_.extract(['u'])\n",
    "\n",
    "        # calculate the residual and return it\n",
    "        return u_x - u\n",
    "\n",
    "    # conditions to hold\n",
    "    conditions = {\n",
    "        'x0': Condition(location=CartesianDomain({'x': 0.}), equation=FixedValue(1)),             # We fix initial condition to value 1\n",
    "        'D': Condition(location=CartesianDomain({'x': [0, 1]}), equation=Equation(ode_equation)), # We wrap the python equation using Equation\n",
    "    }\n",
    "\n",
    "    # sampled points (see below)\n",
    "    input_pts = None\n",
    "\n",
    "    # defining the true solution\n",
    "    def truth_solution(self, pts):\n",
    "        return torch.exp(pts.extract(['x']))\n",
    "    \n",
    "problem = SimpleODE()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "7cf64d01",
   "metadata": {},
   "source": [
    "After we define the `Problem` class, we need to write different class methods, where each method is a function returning a residual. These functions are the ones minimized during PINN optimization, given the initial conditions. For example, in the domain $[0,1]$, the ODE equation (`ode_equation`) must be satisfied. We represent this by returning the difference between subtracting the variable `u` from its gradient (the residual), which we hope to minimize to 0. This is done for all conditions. 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 neural network where these methods are to be applied. To do so, we use the `Condition` class. In the `Condition` class, we pass the location points and the equation we want minimized on those points (other possibilities are allowed, see the documentation for reference).\n",
    "\n",
    "Finally, it's possible to define a `truth_solution` function, which can be useful if we want to plot the results and see how the real solution compares to the expected (true) solution. Notice that the `truth_solution` function is a method of the `PINN` class, but it is not mandatory for problem definition.\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "78b30f95",
   "metadata": {},
   "source": [
    "## Generate data \n",
    "\n",
    "Data for training can come in form of direct numerical simulation results, or points in the domains. In case we perform unsupervised learning, we just need the collocation points for training, i.e. points where we want to evaluate the neural network. Sampling point in **PINA** is very easy, here we show three examples using the `.discretise_domain` method of the `AbstractProblem` class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "09ce5c3a",
   "metadata": {},
   "outputs": [],
   "source": [
    "# sampling 20 points in [0, 1] through discretization in all locations\n",
    "problem.discretise_domain(n=20, mode='grid', variables=['x'], locations='all')\n",
    "\n",
    "# sampling 20 points in (0, 1) through latin hypercube sampling in D, and 1 point in x0\n",
    "problem.discretise_domain(n=20, mode='latin', variables=['x'], locations=['D'])\n",
    "problem.discretise_domain(n=1, mode='random', variables=['x'], locations=['x0'])\n",
    "\n",
    "# sampling 20 points in (0, 1) randomly\n",
    "problem.discretise_domain(n=20, mode='random', variables=['x'])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8fbb679f",
   "metadata": {},
   "source": [
    "We are going to use latin hypercube 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": 4,
   "id": "329962b6",
   "metadata": {},
   "outputs": [],
   "source": [
    "# sampling for training\n",
    "problem.discretise_domain(1, 'random', locations=['x0'])\n",
    "problem.discretise_domain(20, 'lh', locations=['D'])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ca2ac5c2",
   "metadata": {},
   "source": [
    "The points are saved in a python `dict`, and can be accessed by calling the attribute `input_pts` of the problem "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "d6ed9aaf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Input points: {'x0': LabelTensor([[[0.]]]), 'D': LabelTensor([[[0.7644]],\n",
      "             [[0.2028]],\n",
      "             [[0.1789]],\n",
      "             [[0.4294]],\n",
      "             [[0.3239]],\n",
      "             [[0.6531]],\n",
      "             [[0.1406]],\n",
      "             [[0.6062]],\n",
      "             [[0.4969]],\n",
      "             [[0.7429]],\n",
      "             [[0.8681]],\n",
      "             [[0.3800]],\n",
      "             [[0.5357]],\n",
      "             [[0.0152]],\n",
      "             [[0.9679]],\n",
      "             [[0.8101]],\n",
      "             [[0.0662]],\n",
      "             [[0.9095]],\n",
      "             [[0.2503]],\n",
      "             [[0.5580]]])}\n",
      "Input points labels: ['x']\n"
     ]
    }
   ],
   "source": [
    "print('Input points:', problem.input_pts)\n",
    "print('Input points labels:', problem.input_pts['D'].labels)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "669e8534",
   "metadata": {},
   "source": [
    "To visualize the sampled points we can use the `.plot_samples` method of the `Plotter` class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "33cc80bc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from pina import Plotter\n",
    "\n",
    "pl = Plotter()\n",
    "pl.plot_samples(problem=problem)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "22e502dd",
   "metadata": {},
   "source": [
    "## Perform a small training"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "075f43f5",
   "metadata": {},
   "source": [
    "Once we have defined the problem and generated the data we can start the modelling. Here we will choose a `FeedForward` neural network available in `pina.model`, and we will train using the `PINN` solver from `pina.solvers`. We highlight that this training is fairly simple, for more advanced stuff consider the tutorials in the ***Physics Informed Neural Networks*** section of ***Tutorials***. For training we use the `Trainer` class from `pina.trainer`. 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) are 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": null,
   "id": "3bb4dc9b",
   "metadata": {},
   "outputs": [],
   "source": [
    "from pina import Trainer\n",
    "from pina.solvers import PINN\n",
    "from pina.model import FeedForward\n",
    "from pina.callbacks import MetricTracker\n",
    "\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\n",
    "pinn = PINN(problem, model)\n",
    "\n",
    "# create the trainer\n",
    "trainer = Trainer(solver=pinn, max_epochs=1500, callbacks=[MetricTracker()], accelerator='cpu', enable_model_summary=False) # we train on CPU and avoid model summary at beginning of training (optional)\n",
    "\n",
    "# train\n",
    "trainer.train()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f8b4f496",
   "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,
   "id": "f5fbf362",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'x0_loss': tensor(1.0674e-05),\n",
       " 'D_loss': tensor(0.0008),\n",
       " 'mean_loss': tensor(0.0004)}"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# inspecting final loss\n",
    "trainer.logged_metrics"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0963d7d2",
   "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,
   "id": "19078eb5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Intel MKL WARNING: Support of Intel(R) Streaming SIMD Extensions 4.2 (Intel(R) SSE4.2) enabled only processors has been deprecated. Intel oneAPI Math Kernel Library 2025.0 will require Intel(R) Advanced Vector Extensions (Intel(R) AVX) instructions.\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAqgAAAKTCAYAAADVBfoyAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAAB8fUlEQVR4nOzdd3RU5eL18e+kTQopBFIh9F5DFxAEBQGp0ntHpCMiiFcRyxW7oCAoKkVAQFGQLiABERBRERFEQDqETipJJjPn/SOv+d1IkUCSM0n2Z61Zi5l5zmSfTMLsnPIci2EYBiIiIiIiTsLF7AAiIiIiIv9LBVVEREREnIoKqoiIiIg4FRVUEREREXEqKqgiIiIi4lRUUEVERETEqaigioiIiIhTcTM7QFZwOBycPXsWX19fLBaL2XFERERE5B8MwyAuLo7w8HBcXG6/jTRPFNSzZ88SERFhdgwRERER+RenTp2iaNGitx2TJwqqr68vkLbCfn5+JqcRERERkX+KjY0lIiIivbfdTp4oqH/v1vfz81NBFREREXFid3I4pk6SEhERERGnooIqIiIiIk5FBVVEREREnEqeOAb1Ttntdmw2m9kxRPIUd3d3XF1dzY4hIiJ5SL4oqIZhEB0dzbVr18yOIpInBQQEEBoaqnmIRUQkS+SLgvp3OQ0ODsbb21sfoiJZxDAMEhMTuXDhAgBhYWEmJxIRkbwgzxdUu92eXk4LFSpkdhyRPMfLywuACxcuEBwcrN39IiJyz/L8SVJ/H3Pq7e1tchKRvOvv3y8d4y0iIlkhzxfUv2m3vkj20e+XiIhkpXxTUEVEREQkd1BBFRERERGnkqmCOnXqVOrUqYOvry/BwcF06NCBQ4cO3XaZJk2aYLFYbri1bt06fUz//v1veL5ly5Z3t0aS45o0acLYsWPNjpHtpkyZQmRkZI59vXnz5hEQEHDPrxMVFYXFYtE0ayIikmtkqqBu3bqVESNGsGvXLjZu3IjNZuPhhx8mISHhlst8+eWXnDt3Lv22f/9+XF1d6dKlS4ZxLVu2zDDus88+u7s1ykP+Lu6vvvpqhsdXrFiRq475mzdv3k3/6Lh27RoWi4WoqKg7fq3+/fvToUOHrA2Yh9zsj4UGDRpw7tw5/P39zQklIiKSSZmaZmr9+vUZ7s+bN4/g4GB++uknGjdufNNlAgMDM9xfsmQJ3t7eNxRUq9VKaGhoZuLkC56enrz22msMHTqUggUL5ujXttlsuLu7Z8lrubm5sWnTJrZs2ULTpk2z5DVzimEY2O12s2PcNQ8PD/1uiYhIrnJPx6DGxMQAN5bQ2/n444/p3r07Pj4+GR6PiooiODiY8uXLM2zYMC5fvnzL10hOTiY2NjbDLTMMwyAxJdWUm2EYmcrarFkzQkNDmTp16m3Hbd++nUaNGuHl5UVERASjR4/OsGXbYrGwYsWKDMsEBAQwb948AI4fP47FYmHp0qU88MADeHp6smjRIi5fvkyPHj0oUqQI3t7eVK1a9a62bvv4+DBw4ECefvrp2447deoUXbt2JSAggMDAQNq3b8/x48eBtF3s8+fPZ+XKlemHgkRFRdG5c2dGjhyZ/hpjx47FYrHwxx9/AJCSkoKPjw+bNm0C0n5+Ro8eTXBwMJ6entx///38+OOP6cv/vUt83bp11KpVC6vVyvbt22/IevToUUqVKsXIkSNv+r4ahsGUKVMoVqwYVquV8PBwRo8enf781atX6du3LwULFsTb25tWrVpx+PDhW35vbrb1eOzYsTRp0iT9+a1btzJ9+vT078/x48dvuot/+fLlVK5cGavVSokSJXjrrbcyvG6JEiV45ZVXGDhwIL6+vhQrVowPP/zwltlERESy0l1P1O9wOBg7diwNGzakSpUqd7TM7t272b9/Px9//HGGx1u2bEnHjh0pWbIkR48e5ZlnnqFVq1bs3LnzppN+T506lRdeeOFuo3PdZqfS5A13vfy9OPBiC7w97vzb7urqyiuvvELPnj0ZPXo0RYsWvWHM0aNHadmyJS+//DKffPIJFy9eZOTIkYwcOZK5c+dmKt/TTz/NW2+9RY0aNfD09CQpKYlatWoxceJE/Pz8WLNmDX369KF06dLUrVs3U689ZcoUypQpwxdffEHnzp1veN5ms9GiRQvq16/Pd999h5ubGy+//DItW7Zk3759jB8/noMHDxIbG5u+XoGBgfz222988MEH6a+zdetWChcuTFRUFBUqVODHH3/EZrPRoEEDACZMmMDy5cuZP38+xYsX5/XXX6dFixYcOXIkwx9bTz/9NG+++SalSpWiYMGCGQ5F2LdvHy1atGDQoEG8/PLLN13f5cuX884777BkyRIqV65MdHQ0v/76a/rz/fv35/Dhw3z99df4+fkxceJEHnnkEQ4cOHBXW66nT5/On3/+SZUqVXjxxRcBCAoKSi/4f/vpp5/o2rUrU6ZMoVu3buzYsYPhw4dTqFAh+vfvnz7urbfe4qWXXuKZZ57hiy++YNiwYTzwwAOUL18+09lEREQy4663oI4YMYL9+/ezZMmSO17m448/pmrVqjcUm+7du9OuXTuqVq1Khw4dWL16NT/++OMtj02cNGkSMTEx6bdTp07d7WrkCo8++iiRkZE8//zzN31+6tSp9OrVi7Fjx1K2bFkaNGjAu+++y4IFC0hKSsrU1xo7dmz6HwthYWEUKVKE8ePHExkZSalSpRg1ahQtW7Zk2bJlmV6P8PBwxowZw3/+8x9SU1NveH7p0qU4HA4++ugjqlatSsWKFZk7dy4nT54kKiqKAgUK4OXllX44SGhoKB4eHjRp0oQDBw5w8eJFrl69yoEDBxgzZkz6z09UVBR16tTB29ubhIQEZs2axRtvvEGrVq2oVKkSc+bMwcvL64Y/nF588UWaN29O6dKlMxTXHTt20KRJE8aPH3/Lcgpw8uRJQkNDadasGcWKFaNu3boMGTIEIL2YfvTRRzRq1Ijq1auzaNEizpw5c8OW7jvl7++Ph4cH3t7e6d+fm/2B9/bbb/PQQw/x3HPPUa5cOfr378/IkSN54403Mox75JFHGD58OGXKlGHixIkULlyYLVu23FU2ERGRzLirLagjR45k9erVbNu27aZb9G4mISGBJUuWpG/ZuZ1SpUpRuHBhjhw5wkMPPXTD81arFavVmuncf/Nyd+XAiy3uevl74eV+d5eBfO2113jwwQcZP378Dc/9+uuv7Nu3j0WLFqU/ZhgGDoeDY8eOUbFixTv+OrVr185w326388orr7Bs2TLOnDlDSkoKycnJd31lrokTJ/LBBx/wySef0LVr1xvW48iRI/j6+mZ4PCkpiaNHj97yNatUqUJgYCBbt27Fw8ODGjVq0KZNG2bOnAmkbVH9ezf40aNHsdlsNGzYMH15d3d36taty8GDBzO87j+/F5BWOps3b85///vff525oEuXLkybNo1SpUrRsmVLHnnkEdq2bYubmxsHDx7Ezc2NevXqpY8vVKgQ5cuXvyFHVjt48CDt27fP8FjDhg2ZNm0adrs9vdRWq1Yt/XmLxUJoaCgXLlzI1mwiIiKQyYJqGAajRo3iq6++IioqipIlS97xsp9//jnJycn07t37X8eePn2ay5cvExYWlpl4d8xisWRqN7szaNy4MS1atGDSpEkZdsMCxMfHM3To0AzHN/6tWLFiQNo6//M4yZtdlvKfxwa/8cYbTJ8+nWnTplG1alV8fHwYO3YsKSkpd7UeAQEBTJo0iRdeeIE2bdrcsB61atXKULT/FhQUdMvXtFgsNG7cmKioKKxWK02aNKFatWokJyezf/9+duzYcdNi/2/++b34O0d4eDifffYZAwcOxM/P75bLR0REcOjQITZt2sTGjRsZPnw4b7zxBlu3bs10FgAXF5c7eg+zyj8PM7BYLDgcjmz7eiIiIn/L1C7+ESNGsHDhQhYvXoyvry/R0dFER0dz/fr19DF9+/Zl0qRJNyz78ccf06FDBwoVKpTh8fj4eJ566il27drF8ePH2bx5M+3bt6dMmTK0aGHOVk5n9eqrr7Jq1Sp27tyZ4fGaNWty4MABypQpc8PNw8MDSCtW586dS1/m8OHDJCYm/uvX/P7772nfvj29e/emevXqlCpVij///POe1mPUqFG4uLgwffr0G9bj8OHDBAcH37Aef0+R5OHhcdMz6h944AGioqKIioqiSZMmuLi40LhxY9544w2Sk5PTt5iWLl0aDw8Pvv/++/RlbTYbP/74I5UqVfrX7F5eXqxevRpPT09atGhBXFzcv45v27Yt7777LlFRUezcuZPffvuNihUrkpqayg8//JA+9vLlyxw6dOiWOf75HgLs3bs3w/1bfX/+V8WKFTOsP6S9z+XKlbvpIQEiIiI5LVMFddasWcTExNCkSRPCwsLSb0uXLk0fc/LkyRs+RA8dOsT27dsZNGjQDa/p6urKvn37aNeuHeXKlWPQoEHUqlWL77777p524+dFVatWpVevXrz77rsZHp84cSI7duxg5MiR7N27l8OHD7Ny5coMZ7Y/+OCDzJgxg19++YU9e/bw+OOP39GJOGXLlmXjxo3s2LGDgwcPMnToUM6fP39P6+Hp6ckLL7xww3r06tWLwoUL0759e7777juOHTtGVFQUo0eP5vTp00Da2eX79u3j0KFDXLp0KX0L4t/Hof7+++/cf//96Y8tWrSI2rVrp28N9fHxYdiwYTz11FOsX7+eAwcOMGTIEBITE2/683kzPj4+rFmzBjc3N1q1akV8fPxNx82bN4+PP/6Y/fv389dff7Fw4UK8vLwoXrw4ZcuWpX379gwZMoTt27fz66+/0rt3b4oUKXLD7ve/Pfjgg+zZs4cFCxZw+PBhnn/+efbv359hTIkSJfjhhx84fvw4ly5duukWzyeffJLNmzfz0ksv8eeffzJ//nxmzJhxV1uZRUREskOmCqphGDe9/e8u56ioqPSpi/5Wvnx5DMOgefPmN7yml5cXGzZs4MKFC6SkpHD8+HE+/PBDQkJC7mqF8roXX3zxhtJRrVo1tm7dyp9//kmjRo2oUaMGkydPJjw8PH3MW2+9RUREBI0aNaJnz56MHz/+jo4jffbZZ6lZsyYtWrSgSZMmhIaGZslE+f369aNUqVIZHvP29mbbtm0UK1aMjh07UrFiRQYNGkRSUlL6rvQhQ4ZQvnx5ateuTVBQUPqWwKpVqxIQEEBkZCQFChQA0gqq3W5PP/70b6+++iqdOnWiT58+1KxZkyNHjrBhw4ZMzTNboEAB1q1bh2EYtG7d+qYXqwgICGDOnDk0bNiQatWqsWnTJlatWpW+F2Hu3LnUqlWLNm3aUL9+fQzDYO3atbf8w6FFixY899xzTJgwgTp16hAXF0ffvn0zjBk/fjyurq5UqlSJoKAgTp48ecPr1KxZk2XLlrFkyRKqVKnC5MmTefHFF284dERERMQsFiOzE3M6odjYWPz9/YmJibnhmMCkpCSOHTtGyZIl8fT0NCmhSN6m3zMREfk3t+tr/3RPE/WLiIiISC5lTwV79p1sey9UUEVERETyo13vw5ymcPYXs5PcQAVVREREJL+58hdseQWif0u7ORkVVBEREZH8xDBg1RhIvQ4lG0ONPmYnuoEKqoiIiEh+8stCOLYN3Lyg7XSwWMxOdAMVVBEREZH8Ii4avvkPAKkPTCLOO8LkQDengioiIiKSX6ybAEkxEBbJe9eb03Lad+z667LZqW6Quy5ILyIiIiJ35+BqOLASLK4cqvcKM5Ydx+4wuBiXbHayG2gLqmSrqKgoLBYL165du6fXOX78OBaL5YZrz4uIiMgduH4N1jwJQGr90Yz4NhW7w6B1tTDaVg+//bImUEF1UhaL5ba3KVOmmB0x2/Tv3/+Gy6lGRERw7tw5qlSpYk4oERGR3GzjZIiPhkJleCOpPUcuxBPka+Xl9s75uapd/E7q3Llz6f9eunQpkydP5tChQ+mP/X29eQDDMLDb7bi55d2309XVldDQULNjiIiI5D7HvoOf5wNwoPbLfPj1WQBe7ViVgj4eZia7JW1BdVKhoaHpN39/fywWS/r9P/74A19fX9atW0etWrWwWq1s3779plsex44dS5MmTdLvOxwOpk6dSsmSJfHy8qJ69ep88cUXt83y/vvvU7ZsWTw9PQkJCaFz587pzyUnJzN69GiCg4Px9PTk/vvv58cff7zla02ZMoXIyMgMj02bNo0SJUqkPz9//nxWrlyZvrU4Kirqprv4t27dSt26dbFarYSFhfH000+Tmpqa/nyTJk0YPXo0EyZMIDAwkNDQ0Dy95VlEROQGtuuwanTaP2v0Z+h3VgwDutYuykMVQ0wOd2t5d5Pb7RgG2BLN+dru3lk239jTTz/Nm2++SalSpShYsOAdLTN16lQWLlzI7NmzKVu2LNu2baN3794EBQXxwAMP3DB+z549jB49mk8//ZQGDRpw5coVvvvuu/TnJ0yYwPLly5k/fz7Fixfn9ddfp0WLFhw5coTAwMBMr9P48eM5ePAgsbGxzJ07F4DAwEDOnj2bYdyZM2d45JFH6N+/PwsWLOCPP/5gyJAheHp6Ziih8+fPZ9y4cfzwww/s3LmT/v3707BhQ5o3b57pbCIiIrlO1KtpV43yDeMVW3dOXblCkQAvnmtTyexkt5U/C6otEV4x6YDgZ86Ch0+WvNSLL76YqaKVnJzMK6+8wqZNm6hfvz4ApUqVYvv27XzwwQc3LagnT57Ex8eHNm3a4OvrS/HixalRowYACQkJzJo1i3nz5tGqVSsA5syZw8aNG/n444956qmnMr1OBQoUwMvLi+Tk5Nvu0n///feJiIhgxowZWCwWKlSowNmzZ5k4cSKTJ0/GxSVt50C1atV4/vnnAShbtiwzZsxg8+bNKqgiIpL3nd0LO94D4LfI55m78QoAb3Sphq+nu4nB/l3+LKh5RO3atTM1/siRIyQmJt5QzlJSUtJL5z81b96c4sWLU6pUKVq2bEnLli159NFH8fb25ujRo9hsNho2bJg+3t3dnbp163Lw4MHMr1AmHDx4kPr162P5n63RDRs2JD4+ntOnT1OsWDEgraD+r7CwMC5cuJCt2URERExnT4WvR4FhJ6V8ewb/EAQk079BCRqULmx2un+VPwuqu3falkyzvnYW8fHJuCXWxcUFwzAyPGaz2dL/HR8fD8CaNWsoUqRIhnFWq/WmX8PX15eff/6ZqKgovvnmGyZPnsyUKVNue5zp7fxbxqzm7p7xL0SLxYLD4ci2ryciIuIUds6A6H3gGcCL9n6cj02iVGEfJrasYHayO5I/C6rFkmW72Z1JUFAQ+/fvz/DY3r1700tapUqVsFqtnDx58qa782/Fzc2NZs2a0axZM55//nkCAgL49ttvadGiBR4eHnz//fcUL14cSCubP/74I2PHjr1lxujoaAzDSN/6+c+5TT08PLDb7bfNVLFiRZYvX57hdb7//nt8fX0pWrToHa+biIhInnP5KERNBWBf5Qks/D4JFwu82bU6Xh6uJoe7M/mzoOZRDz74IG+88QYLFiygfv36LFy4kP3796fvvvf19WX8+PE88cQTOBwO7r//fmJiYvj+++/x8/OjX79+N7zm6tWr+euvv2jcuDEFCxZk7dq1OBwOypcvj4+PD8OGDeOpp54iMDCQYsWK8frrr5OYmMigQYNumrFJkyZcvHiR119/nc6dO7N+/XrWrVuHn59f+pgSJUqwYcMGDh06RKFChfD397/hdYYPH860adMYNWoUI0eO5NChQzz//POMGzcu/fhTERGRfMcwYNUYSE0ipVhj+v9SFrDx+AOlqVnszk6odgb6JM9DWrRowXPPPceECROoU6cOcXFx9O3bN8OYl156ieeee46pU6dSsWJFWrZsyZo1ayhZsuRNXzMgIIAvv/ySBx98kIoVKzJ79mw+++wzKleuDMCrr75Kp06d6NOnDzVr1uTIkSNs2LDhlrMKVKxYkffff5+ZM2dSvXp1du/ezfjx4zOMGTJkCOXLl6d27doEBQXx/fff3/A6RYoUYe3atezevZvq1avz+OOPM2jQIJ599tm7+daJiIjkDT8vgOPfYbh787wxhCuJNiqE+jKmWVmzk2WKxfjnAYG5UGxsLP7+/sTExGTYEgeQlJTEsWPHKFmyJJ6eniYlFMnb9HsmIuIEYs/CzHqQHMu+Sk/R7ucauLtaWDnifiqF+/378tkd7zZ97Z+0BVVEREQktzMMWDUWkmNJCalBn99rATC2WTmnKKeZpYIqIiIiktvtWwaHN2C4evAsw4lJdhAZEcDQxqXMTnZXVFBFREREcrO487BuAgB7Sw1l2QkfPN1deKtrddxcc2fVy52pRURERCRt1/6acZB0jeSgKvT94z4AJrasQOmgAiaHu3v5pqDmgXPBRJyWfr9ERExyYAX8sRrDxY1n7MOIs1moX6oQ/eqXMDvZPcnzBfXvSeoTExNNTiKSd/39+/XPK3eJiEg2SrgEa9Kmavyp2ACWny1IAasbr3euhouL5V8Wdm55fqJ+V1dXAgIC0q+/7u3tneH67SJy9wzDIDExkQsXLhAQEICra+64QomISJ6wbiIkXiI5sDz9DqddIfK5NhWJCMy6y6qbJc8XVIDQ0FCA9JIqIlkrICAg/fdMRERywB9rYP8XGBYXJqQ+ToLdhQcrBNO1doTZybJEviioFouFsLAwgoODsdlsZscRyVPc3d215VREJCddvwqrnwDgx/DerDwaQoC3O692rJpn9hLni4L6N1dXV32QioiISO624T8Qf54k/9L0O/YQAC+1r0KwX965kl+eP0lKREREJM84vBH2LsLAwgTbY1x3uNOmWhhtq4ebnSxLqaCKiIiI5AZJsbBqDAC7g7vy9ZUIgnytvNS+isnBsp4KqoiIiEhusPE5iD1Dkm9x+p9qCcCrHatS0MfD5GBZTwVVRERExNn9FQU/zQPgqZTBXDesdK1dlIcqhpgaK7uooIqIiIg4s+R4+HoUALsKPcqqmNIUCfDiuTaVTA6WfVRQRURERJzZ5hfh2kmSvMMZdKYNAG90qYavZ969ep8KqoiIiIizOrEDdn8AwFPJg0jAi/4NStCgdGGTg2UvFVQRERERZ5SSCCtHArDD7xFWJVSkVJAPE1tWMDlY9lNBFREREXFGUa/AlaNc9wzm8QuP4upi4Z2ukXh55P2LDqmgioiIiDibU7th50wAnkoaQCw+jGxahuoRAebmyiEqqCIiIiLOJCURVgwDw8F272asTqpOtaL+jHywjNnJcowKqoiIiIgz+fZluHyERGsQw690xermwttdI3F3zT+1Lf+sqYiIiIizO7EDdr0PwNjEgcRSgEmtKlAmuIDJwXKWCqqIiIiIM0hJgBXDAYONng/zja0695cpTN/6JcxOluNUUEVEREScwaYpcPUYcdYQxl3riq+nG290qYaLi8XsZDnOzewAIiIiIvneX1th94cAjIgfSBzeTGtfhTB/L5ODmUNbUEVERETMlByXPiH/1+4t2WavSuuqYbSPDDc5mHlUUEVERETM9M1zEHOSqx5hTIrrQrCvlZc7VMFiyX+79v+mXfwiIiIiZjmyGX6aC8Dw+IEk4MWMztUo6ONhcjBzaQuqiIiIiBmSYuDrUQAsc32EnY7K9KpXjKblg00OZj4VVBEREREzbHgGYs9w0b0Izyd0pkQhb/7TuqLZqZyCCqqIiIhITvtzA/yyEAMLw+IHkWzx5K2ukXh76OhLUEEVERERyVnXr8LXowH4lNbsMSowrElpahUvaHIw56GCKiIiIpKT1j0N8dGcc4vgv0mdqRzux5iHypmdyqmooIqIiIjklD/WwL4lOHBheMJgDDdP3ukWiYebKtn/0ndDREREJCckXIZVYwD42NGWX4yyTGhRnnIhviYHcz4qqCIiIiI5Yd1TkHCRk67FeSOlI/eVCmRgw5Jmp3JKKqgiIiIi2e33FbB/OQ5cGZ44BA+rF292qY6LS/69WtTtaC4DERERkewUfxHWjAPgfXt79huleKNtJYoW9DY5mPPSFlQRERGR7GIYacedJl7mqEsJpts68HClEDrXKmp2MqemgioiIiKSXfYuhkNrsFvcGHH9cfwLeDO1Y1UsFu3avx3t4hcRERHJDldPwLqJALxh68wfRjE+6liNQgWsJgdzftqCKiIiIpLVHA5YMRxS4vjVUoEPU9vQrXYEzSqFmJ0sV1BBFREREclqu96HE9tJtngyKmkoRQML8FzbSmanyjW0i19EREQkK104CJtfBOD5lN6cJoTPu0VSwKradae0BVVEREQkq6SmwJePgT2ZrdRkib0pI5uWoVbxgmYny1VUUEVERESyyrbXIXofcS5+jE8aTPWiAYx6qKzZqXIdFVQRERGRrHDqR/juLQAmJA0g3r0Q73SLxN1VdSuz9B0TERERuVcpCfDVUDAcrHTczzpHPZ5tU5FSQQXMTpYrqaCKiIiI3KuNk+HKUS5aCvFcSj8eqhBMz7rFzE6Va2WqoE6dOpU6derg6+tLcHAwHTp04NChQ7ddZt68eVgslgw3T0/PDGMMw2Dy5MmEhYXh5eVFs2bNOHz4cObXRkRERCSnHdkEP34EwNjkx3D3KcirnarpalH3IFMFdevWrYwYMYJdu3axceNGbDYbDz/8MAkJCbddzs/Pj3PnzqXfTpw4keH5119/nXfffZfZs2fzww8/4OPjQ4sWLUhKSsr8GomIiIjklMQrsHIkAHNTW/C9oyqvdapGkK+uFnUvMjUh1/r16zPcnzdvHsHBwfz00080btz4lstZLBZCQ0Nv+pxhGEybNo1nn32W9u3bA7BgwQJCQkJYsWIF3bt3v2GZ5ORkkpOT0+/HxsZmZjVEREREssba8RB3jhOWIryW2p0edYvpalFZ4J6OQY2JiQEgMDDwtuPi4+MpXrw4ERERtG/fnt9//z39uWPHjhEdHU2zZs3SH/P396devXrs3Lnzpq83depU/P39028RERH3shoiIiIimffbF7B/OXZcGJ00lNBCBXm2dUWzU+UJd11QHQ4HY8eOpWHDhlSpUuWW48qXL88nn3zCypUrWbhwIQ6HgwYNGnD69GkAoqOjAQgJyfjXRkhISPpz/zRp0iRiYmLSb6dOnbrb1RARERHJvNizsOZJAGakdmC/pSzvdIvER1eLyhJ3/V0cMWIE+/fvZ/v27bcdV79+ferXr59+v0GDBlSsWJEPPviAl1566a6+ttVqxWrVsR0iIiJiAsNIO+406Rq/U4r3UjswqlkZahTT1aKyyl1tQR05ciSrV69my5YtFC1aNFPLuru7U6NGDY4cOQKQfmzq+fPnM4w7f/78LY9bFRERETHNno/h6GZScGd08jCqRBRmZNMyZqfKUzJVUA3DYOTIkXz11Vd8++23lCxZMtNf0G6389tvvxEWFgZAyZIlCQ0NZfPmzeljYmNj+eGHHzJseRUREREx3eWj8M1zALxq684592JM6xaJm64WlaUytYt/xIgRLF68mJUrV+Lr65t+jKi/vz9eXl4A9O3blyJFijB16lQAXnzxRe677z7KlCnDtWvXeOONNzhx4gSDBw8G0s7wHzt2LC+//DJly5alZMmSPPfcc4SHh9OhQ4csXFURERGRe2C3wZePgS2RnY5KzLW3YGr7SpQo7GN2sjwnUwV11qxZADRp0iTD43PnzqV///4AnDx5EheX//sr4urVqwwZMoTo6GgKFixIrVq12LFjB5UqVUofM2HCBBISEnjssce4du0a999/P+vXr79hQn8RERER02x7A87sIR4fnkx5nGaVwuhWRzMJZQeLYRiG2SHuVWxsLP7+/sTExODn52d2HBEREclrTu2GT1qA4WBUykh2ejdlw9hGFCqgk7bvVGb6muZCEBEREbmd5Dj4cggYDr6yN2SVowFzO1dTOc1GOqJXRERE5HbWTYSrxzlLEJNtA+h9XzGaVgg2O1WepoIqIiIiciu/r4C9i3BgYUzyMIKCgvjPI5X+dTG5N9rFLyIiInIzsWdh1RgAZqW25RdLRb7sFomXh6vJwfI+bUEVERER+SeHA756HJKusd8oxbTUzjzRvBzVigaYnSxfUEEVERER+add78OxrSRhZXTKcGqWDObxB0qbnSrf0C5+ERERkf8VvR82vwDAi7beXLIWY2G3SFxdLCYHyz9UUEVERET+ZktKm1LKnsIme00W2x9kZrdqhAd4mZ0sX9EufhEREZG/bZoCFw5wBX8m2obQpVYErauFmZ0q31FBFREREQE4shl+SLus+7iUx/AtFMaUdpVNDpU/aRe/iIiISMJlWDEcgAWpzdlOTb7oXgMfq6qSGbQFVURERPI3w4BVoyE+mqNGOK+k9uSJ5uWIjAgwO1m+pYIqIiIi+dsvn8Ifq7HhxuiUkVQrGaYppUym7dYiIiKSf10+CuueBuBNWxdOWcuwTlNKmU4FVURERPInuw2+fAxsCexyVGSOvTXvdqtKEU0pZTrt4hcREZH8adsbcGYPcXgzLmUYj9YsRptq4WanElRQRUREJD86sQNj2xsA/CdlIO6FivFCe00p5Sy0i19ERETyl+tXYfkQLIaD5fZGrKEhX3SLpICmlHIa2oIqIiIi+YdhwKoxEHuaE0Yok239GftQWWoUK2h2MvkfKqgiIiKSf/y8AA6sJBVXRqWMoHKJIgxvWsbsVPIP2pYtIiIi+cPFP2F92pRSb9i6csxannXdqmtKKSekgioiIiJ5X2oyLB8ItkS2O6rwob0107tWpWhBb7OTyU1oF7+IiIjkfZumQPRvXMWPJ1KG8WjNCNpV15RSzkoFVURERPK2wxth1/sAPJnyGF6BRXihnaaUcmbaxS8iIiJ5V9x5+OpxAOamtmArtfi8eyS+nu4mB5Pb0RZUERERyZscDljxOCRe4pBRjFdTezDmobLU1JRSTk8FVURERPKmXTPh6LckY2VEykgiS4YyQlNK5QraxS8iIiJ5z9lfYNMLALxg680lr5J82j1SU0rlEiqoIiIikrckx8MXg8BhY529DovtD/Jhp2qE+XuZnUzukHbxi4iISN6ybiJcOUo0hXjaNoS+9UvwcOVQs1NJJqigioiISN6xfznsXYgDC2OShxMWGsYzj1Q0O5Vkknbxi4iISN5w9QSsGgvAjNT2/OpWmVU9auDp7mpuLsk0bUEVERGR3M+eCssHQ3IsPzvKMj21E5PbVKZsiK/ZyeQuqKCKiIhI7rf1NTi9m3i8GW0bycNVitCjboTZqeQuqaCKiIhI7nbsO/juTQAmpQzE4RfBqx2rYbFoSqncSsegioiISO6VcClt177hYFnqA6wxGrC0Rw38vXUp09xMW1BFREQkd3I44KuhEB/NUaMIz6f2Y8xD5ahTItDsZHKPVFBFREQkd9r5HhzZRDIeDE8ZRdWS4Yx8UJcyzQu0i19ERERyn1M/wuYXAZhi60O0Z2nmdtOlTPMKFVQRERHJXa5fhS8GgiOV1fb7+Mz+ILM7VSM8QJcyzSu0i19ERERyD8OAr0dBzElOE8Ik22B631ecllV0KdO8RAVVREREco8fP4KDq0jFjWHJowgLCebZ1pXMTiVZTLv4RUREJHc4tw82PAPAK7Ye/Olahq971NSlTPMgbUEVERER55ccB18MAHsKmx01+cTekufaVKJ8qC5lmhepoIqIiIhzMwxY8yRcPsJ5SyGeTBnKI1XD6FWvmNnJJJuooIqIiIhz27sY9i3FjgsjkkbgGxjMVF3KNE/TMagiIiLivC4egrXjAXjb1pm9lop80aMm/l66lGlepi2oIiIi4pxs1+Hz/mBL5HtHVWbZ2/F0qwpERgSYnUyymQqqiIiIOKf1k+DCAa5Y/BmbMowmFUIZdH9Js1NJDlBBFREREeez/0v4aS4OLIxKHo6rXyhvdqmu407zCR2DKiIiIs7lyjFYNQaA91PbsdOoypIeNQj08TA5mOQUbUEVERER55GakjbfaXIsPxnleSe1M080K0fdkoFmJ5McpIIqIiIizmPjZDj7C7EWX0Ymj+S+MsEMb1rG7FSSw1RQRURExDkc+Bp+mAXAE8mPYSsQxjvdInF10XGn+Y2OQRURERHzXfkLVo4AYHZqW741arGgWyTBvp4mBxMzaAuqiIiImMuWBMv6/f/jTivwZmoXhj1QmkZlg8xOJiZRQRURERFzbZgE0fuIsfgxPHkkkcWDGNe8nNmpxEQqqCIiImKefZ/Dnk8wsDAyeThJXiFM71EDN1dVlPxMx6CKiIiIOS7+mT7f6bupHfjOUY05XapTJMDL5GBiNv15IiIiIjkvJRGW9QVbArupzPTUTgxoWILmlULMTiZOQAVVREREct7a8XDxIFddCjIiaQSVixTk6VYVzE4lTkIFVURERHLWLwth7yIcuDAsaQTXrYV5r0cNrG6uZicTJ6FjUEVERCTnRO+HNU8C8KatM7sclXi/czVKFPYxOZg4E21BFRERkZyRHAef94PUJLYTySx7O/o3KMEjVcPMTiZORgVVREREsp9hpJ2xf/kIl1wKMyrpcaoVLcikR3TcqdxIBVVERESy356PYf9y7BZXHrs+ErtnIDN61tRxp3JTOgZVREREstfZX2D9JACmpnTnZ6McH3apTkSgt8nBxFlpC6qIiIhkn+vX4PP+YE/hW2rzkf0RhjQqycOVQ81OJk5MBVVERESyh2HAyhFw9TjnXUIYm/QYNYsVZEJLHXcqt6eCKiIiItlj1/vwx2pSLe4Mvj4KF++CzOhZE3dX1Q+5vUz9hEydOpU6derg6+tLcHAwHTp04NChQ7ddZs6cOTRq1IiCBQtSsGBBmjVrxu7duzOM6d+/PxaLJcOtZcuWmV8bERERcQ4ndsA3zwHwYkpPfjNK8U7XSMIDvEwOJrlBpgrq1q1bGTFiBLt27WLjxo3YbDYefvhhEhISbrlMVFQUPXr0YMuWLezcuZOIiAgefvhhzpw5k2Fcy5YtOXfuXPrts88+u7s1EhEREXPFnYfPB4BhZ43RkAX2hxnWpDRNKwSbnUxyCYthGMbdLnzx4kWCg4PZunUrjRs3vqNl7HY7BQsWZMaMGfTt2xdI24J67do1VqxYcVc5YmNj8ff3JyYmBj8/v7t6DREREckC9lRY0A5OfM9xl2K0SpxC1RLhLB5SDzft2s/XMtPX7uknJSYmBoDAwMA7XiYxMRGbzXbDMlFRUQQHB1O+fHmGDRvG5cuXb/kaycnJxMbGZriJiIiIE9g8BU58T5KLNwOvj8bbx493e9RQOZVMueufFofDwdixY2nYsCFVqlS54+UmTpxIeHg4zZo1S3+sZcuWLFiwgM2bN/Paa6+xdetWWrVqhd1uv+lrTJ06FX9///RbRETE3a6GiIiIZJUDX8OO9wAYm/QYxwhnWvdIQv09TQ4muc1d7+IfNmwY69atY/v27RQtWvSOlnn11Vd5/fXXiYqKolq1arcc99dff1G6dGk2bdrEQw89dMPzycnJJCcnp9+PjY0lIiJCu/hFRETMcukwfNgUUuKYa7ThheSejH6oLOOalzM7mTiJbN/FP3LkSFavXs2WLVvuuJy++eabvPrqq3zzzTe3LacApUqVonDhwhw5cuSmz1utVvz8/DLcRERExCQpCbC0D6TEsc+1Mi8nd6NB6UKMeais2ckkl8rUpU4Nw2DUqFF89dVXREVFUbJkyTta7vXXX+e///0vGzZsoHbt2v86/vTp01y+fJmwsLDMxBMREZGcZhiwagxcPEisWyCD4odTsIA307pH4upiMTud5FKZ2oI6YsQIFi5cyOLFi/H19SU6Opro6GiuX7+ePqZv375MmjQp/f5rr73Gc889xyeffEKJEiXSl4mPjwcgPj6ep556il27dnH8+HE2b95M+/btKVOmDC1atMii1RQREZFs8eNH8NvnOCyuDEoYyWVLQd7tEUmwr447lbuXqYI6a9YsYmJiaNKkCWFhYem3pUuXpo85efIk586dy7BMSkoKnTt3zrDMm2++CYCrqyv79u2jXbt2lCtXjkGDBlGrVi2+++47rFZrFq2miIiIZLlTP8L6tI1Sr6b25EejAuOal6NB6cImB5Pc7p7mQXUWmgdVREQkhyVcgtmNIO4sW1zrMyBhJA9VCGFO39q4aNe+3ESOzYMqIiIi+ZDDDl8MhLiznHOPYGTCYCICvXm7a6TKqWQJFVQRERHJnC3/hWNbsbl40Sd+FDY3H2b1qoW/t7vZySSPyNRZ/CIiIpLP/bEWvnsLgCeTB3HEKMqr7SpTpYi/ycEkL9EWVBEREbkzV/6Crx4H4DPLI3xtb0CXWkXpVkdXdJSspYIqIiIi/y4lEZb2heQY/nCvxOTr3akY5sdLHapgsei4U8laKqgiIiJye4YBa56E878R71aQfnHD8fT0ZHbvmni6u5qdTvIgHYMqIiIit/fjR/DrYgxcGJI4nPME8mGX6hQv5GN2MsmjtAVVREREbu3ETlj/NABvOnqy01GZxx8ozcOVQ00OJnmZCqqIiIjcXOw5+LwfOFLZ4taImSmtuK9UIOMfLmd2MsnjVFBFRETkRqkpsKwvxJ/njEcphscPINjXk/d61MTNVfVBspd+wkRERORG6yfC6d0ku/nSI24UKS5ezOxVkyBfq9nJJB9QQRUREZGMfl4Aez7BwMLwpOGcNEKY1KoCdUoEmp1M8gkVVBEREfk/p39Km1IK+NC1O5tTq/NI1VAG3V/S5GCSn6igioiISJr4i7CsD9hT2OPVgFcTWlOqsA+vdaqmyfglR6mgioiICNht8Hl/iD3DZa8S9L86EE93d2b1roWvp7vZ6SSf0UT9IiIiAt88Bye2k+rmQ9drI4jHm+mdqlI+1NfsZJIPaQuqiIhIfvfrUvhhFgDjbMM4ahRhYMOStI8sYnIwya9UUEVERPKzc7/CqjEALPToytfJNalbMpBJj1QwOZjkZyqoIiIi+VXiFVjaG1Kvs9+7LpNj2xHiZ2Vmz5q4azJ+MZF++kRERPIjhx2+GAjXThLjWZSeVwbj6urKrN61NBm/mE4nSYmIiORHm1+Ev7Zgd/Wie+xIYinAf9tVpmaxgmYnE9EWVBERkXzn96/g+2kAPOMYykFHMbrVjqBn3WLm5hL5/1RQRURE8pPzv8OKEQAs9+zI0ut1qVbUnxfaV9Zk/OI0VFBFRETyi8Qr8FkPsCXwp08tJlx7lEAfD2b1roWnu6vZ6UTSqaCKiIjkB/ZU+LwfXDtBnFcRul5+DMPiyoweNSgS4GV2OpEMVFBFRETyg2+ehWPbsLt50y12NNfw5elWFWhQprDZyURuoIIqIiKS1/2yMP1KUZOMERywR9C6WhhDGpUyOZjIzamgioiI5GWnfoTVTwCwzKcXyxJqUC6kAK93qqaTosRpqaCKiIjkVbHn0q4UZU/hgH9jJl5uha/VjQ/61MbHqqnQxXmpoIqIiORFtiRY2gvio4nxLUuX8/0wcOGdbpGULOxjdjqR21JBFRERyWsMI223/pmfSLUG0PHqSBLwYvRDZWlWKcTsdCL/SgVVREQkr9k1C35djGFxZZzjCY6mBtG0fBBjHyprdjKRO6KCKiIikpcc/Ra++Q8A83yH8HVcWUoU8mZatxq4uOikKMkdVFBFRETyistH4fMBYDj4OfARXrjQCB8PV+b0rY2/t7vZ6UTumAqqiIhIXpAcB0t6QtI1LgdUo8fZroCFd7pFUjbE1+x0IpmigioiIpLbORzw5VC4+AcpXsG0uziUZDx4olk5Hq4canY6kUxTQRUREcnttr4Kh9ZguHrwWMoTnLEXpEXlEEY9WMbsZCJ3RQVVREQkNzuwEra+BsB075FEJRSnXEgB3uoaqZOiJNdSQRUREcmtovfDV8MA2BbYhWkXa+Pv5c6cvrUpoCtFSS6mgioiIpIbxV+Ez7qDLYEzgfUYcLYdLhaY0bMGxQvpSlGSu6mgioiI5DapybC0N8Sc4rpvcdpGD8aOK5NaVaRR2SCz04ncMxVUERGR3MQwYNVYOLULh4cfPeOf4IrDh0drFGFwo5JmpxPJEiqoIiIiucmOd9MvY/qs+5P8cj2YqkX8mdqxKhaLToqSvEEFVUREJLc4tA42Pg/A54WHs/hyWQoX8OCDPrXwdHc1OZxI1lFBFRERyQ3O/w7LBwMG+8M6MeHUfbi5WHi/Vy3CA7zMTieSpVRQRUREnF38RVjcHVLiuRp8H48ebw9YmNKuMnVLBpqdTiTLqaCKiIg4s/Qz9k9i8ytB2/NDsBlu9KhbjN73FTc7nUi2UEEVERFxVoYBq5+AU7swPHwZkjqe08le1C5ekBfaVTY7nUi2UUEVERFxVjveg72LMCwuvOk/iagrgYT5e/J+75p4uOkjXPIu/XSLiIg4o0PrYeNkANYXHc3MUyXwcndlTt/aBPt6mhxOJHupoIqIiDib8wdg+SDA4EhEZ4YdrgPA212rU6WIv7nZRHKACqqIiIgzSbgEn3WDlHhiQu6jzdG0M/bHNS9Hq6phZqcTyREqqCIiIs4iNQWW9oFrJ7H5l6D9hcdIcrjSploYox4sY3Y6kRyjgioiIuIMDAPWPAEnd2BYfXnc/hTHr3tStYg/b3SursuYSr6igioiIuIMds6EXxZiWFyY5j+JzZcKEuxrZU7f2nh56DKmkr+ooIqIiJjtjzXwzbMAbI4YzfSTJbC6ufBh39qE+uuMfcl/VFBFRETMdHYvLB8MGPxVvBuD/0w7Y//1ztWIjAgwM5mIaVRQRUREzBJzBj7rDrZEYsIb0eZIW8DCyKZlaB9ZxOx0IqZRQRURETFDcnzadFJx57AFlqPd+cEk2l14uFII45qXMzudiKlUUEVERHKaw562Wz/6NwzvIAanTuREgjsVw/x4p1skLi46Y1/yNxVUERGRnPbNc/DnOgxXK68XfJ6tF7woXMCDOX1r4WN1MzudiOlUUEVERHLSjx/BrpkArCk9mVlHA/FwdeGDPrUoWtDb5HAizkEFVUREJKcc3gRrJwDwR6UxjNxXEoD/PlqFWsUDzUwm4lRUUEVERHLC+QPweX8w7Fwp25n2++4D4LHGpehSO8LcbCJORgVVREQku8Wdh8VdISWO5CL1eeSvziSnGjxYIZiJLSuYnU7E6aigioiIZCfbdVjSA2JO4ShYil6xI4lOcFAh1Jd3e9TAVWfsi9xABVVERCS7OBzw1eNw5icMr4I87fkcey5aCPK18kn/OhTQGfsiN6WCKiIikl22vAwHVoCLO3OLvMSyY1Y83V34uF9twgO8zE4n4rRUUEVERLLDL4vgu7cA+K7ic7y4P+0s/WndIqlWNMDEYCLOTwVVREQkqx37DlaNAeB4pWH0+7kMAE+3qkDLKmFmJhPJFTJVUKdOnUqdOnXw9fUlODiYDh06cOjQoX9d7vPPP6dChQp4enpStWpV1q5dm+F5wzCYPHkyYWFheHl50axZMw4fPpy5NREREXEGFw/B0t7gsBFbqg1t9jfGYUC32hEMbVzK7HQiuUKmCurWrVsZMWIEu3btYuPGjdhsNh5++GESEhJuucyOHTvo0aMHgwYN4pdffqFDhw506NCB/fv3p495/fXXeffdd5k9ezY//PADPj4+tGjRgqSkpLtfMxERkZwWfwEWdYaka9jCatHudC/iUwwalC7ESx2qYLHojH2RO2ExDMO424UvXrxIcHAwW7dupXHjxjcd061bNxISEli9enX6Y/fddx+RkZHMnj0bwzAIDw/nySefZPz48QDExMQQEhLCvHnz6N69+7/miI2Nxd/fn5iYGPz8/O52dURERO5eSgLMaw1nf8FRsCR9Lf9l+1koFeTDV8Ma4u/tbnZCEVNlpq/d0zGoMTExAAQG3vrybDt37qRZs2YZHmvRogU7d+4E4NixY0RHR2cY4+/vT7169dLH/FNycjKxsbEZbiIiIqZx2OGLQXD2FwyvQKYUeIHtZ6Ggtzuf9KujciqSSXddUB0OB2PHjqVhw4ZUqVLlluOio6MJCQnJ8FhISAjR0dHpz//92K3G/NPUqVPx9/dPv0VE6BJxIiJiEsOAdRPhz3XgamVRqddYcNgND1cXPuhTmxKFfcxOKJLr3HVBHTFiBPv372fJkiVZmeeOTJo0iZiYmPTbqVOncjyDiIgIADtnwI9zAAs7qk/l2Z/SCulrnatSt+St9zCKyK3d1SUsRo4cyerVq9m2bRtFixa97djQ0FDOnz+f4bHz588TGhqa/vzfj4WFhWUYExkZedPXtFqtWK3Wu4kuIiKSdX5fAd88C8DxWk/Td2cYYDD6wTI8WuP2n48icmuZ2oJqGAYjR47kq6++4ttvv6VkyZL/ukz9+vXZvHlzhsc2btxI/fr1AShZsiShoaEZxsTGxvLDDz+kjxEREXE6J3+ALx8DIKZqf9r/VINUh0Hb6uE80bycyeFEcrdMbUEdMWIEixcvZuXKlfj6+qYfI+rv74+XV9ol2/r27UuRIkWYOnUqAGPGjOGBBx7grbfeonXr1ixZsoQ9e/bw4YcfAmCxWBg7diwvv/wyZcuWpWTJkjz33HOEh4fToUOHLFxVERGRLHL5KHzWHezJpJRuQYejbYlJSqZmsQDe6FxN00mJ3KNMFdRZs2YB0KRJkwyPz507l/79+wNw8uRJXFz+b8NsgwYNWLx4Mc8++yzPPPMMZcuWZcWKFRlOrJowYQIJCQk89thjXLt2jfvvv5/169fj6el5l6slIiKSTRIuwcJOcP0KjrAa9I97nGNXrlO0oBcf9q2Np7ur2QlFcr17mgfVWWgeVBERyRG26zC/LZz+ESOgGJMKvsOSg8n4ebqxfFgDyob4mp1QxGnl2DyoIiIi+YbDDl8OgdM/gmcAH0a8xpKDybi7Wviwb22VU5EspIIqIiJyJ755Dg6uAlcP1ld9m6k/pu2AfKNzde4rVcjkcCJ5iwqqiIjIv/nhA9g1E4Df6rzK8O1p50g81aI8HWoUMTOZSJ6kgioiInI7f6xJu1IUcK7ORLp+XwSHAd3rRDC8SWmTw4nkTSqoIiIit3LqR/hiEGAQX6U3bX+uzXWbncblgnipQxVNJyWSTVRQRUREbubSYVjcFVKvYyvVjEePd+RSgo1KYX6836sm7q76CBXJLvrtEhER+ae487CwY/pcpwMTRnD4UhJh/p7MHVCHAta7ulK4iNwhFVQREZH/lRQLizrDtZMYgaV41nsy3524jq/VjbkD6hDip4vIiGQ3FVQREZG/pabAsj4QvQ+8CzOn2Bss/v06bi4WZvepRYVQXQxGJCeooIqIiAA4HLByBPwVBe4+rI+cwSu7kgF4tVM1GpYpbG4+kXxEBVVERARg8xT4bRlYXPm1wbuMiEqbiH9ss7J0rlXU3Gwi+YwKqoiIyK7Z8P10AE43fp0eWwpgdxh0rlWUMQ+VNTmcSP6jgioiIvnb71/B+qcBiGkwiY47SpCYYuf+MoV55dGqmutUxAQqqCIikn8d3w5fPgYYJNcYQKff7uNCXDIVQn15v3dNPNz0MSliBv3miYhI/nT+AHzWE+wp2Mu3oc+ZThy5mEConyef9K+Dn6e72QlF8i0VVBERyX9iTsPCTpAcgxFxH6OTh7P7ZCx+nm7MH1iX8AAvsxOK5GsqqCIikr9cv5pWTuPOYhQuz3/9JrPmj2t4uLkwp29tyof6mp1QJN9TQRURkfzDlpS2W//iH+AbxrySb/HRT9ewWGB6t0jqlSpkdkIRQQVVRETyC4cdvhwCJ3eA1Y8NkTN44btYAF5oV5lWVcNMDigif1NBFRGRvM8wYN0EOPg1uHrwc4MZDN+cAsCIpqXpW7+EuflEJAMVVBERyfu2vgY/fgRYONboLXpu8kifiH/8w+XNTici/6CCKiIiedvuORA1FYCLjV6i47ZQkmwOmpQPYmpHTcQv4oxUUEVEJO/a/yWsfQqAhPue5NE9lbmaaKN6UX9m9qyJu6s+BkWckX4zRUQkbzq6Jf0qUSk1+tPljyacvnqdEoW8+aR/HXysbmYnFJFbUEEVEZG858xPsKQXOGzYK3Zg4IWuHIiOo3ABDxYMrEehAlazE4rIbaigiohI3nLpMCzqArYEjJIP8FTqcLYfvYaPhyvzBtSlWCFvsxOKyL9QQRURkbwj9ix8+igkXoawSN4IeI4vf7uEm4uF2X1qUaWIv9kJReQOqKCKiEjekHgFPu0IMaegUBkWlnmL93deAOCNLtVoVDbI5IAicqdUUEVEJPdLSYTF3eDiQfANY13k+zy78TwAk1pV4NEaRU0OKCKZoYIqIiK5m90Gn/eD07vB05+dDeYwct1lAAbfX5LHGpcyOaCIZJYKqoiI5F4OB6wcAYe/ATcvfm8yh/5r4rE7DDrVLMozj1TURPwiuZAKqoiI5E6GAd88C/uWgsWVE83ep/s6SE510KxiCK91qoqLi8qpSG6kgioiIrnT99Ng10wALj70Np02+RGXnErdkoHM6FkDN10lSiTX0m+viIjkPj8vgE1TAIh74AUe/b4Yl+KTqRjmx0f9auPp7mpuPhG5JyqoIiKSu/y+AlaNASCp3mg6762ZfgnTBQPr4ufpbm4+EblnKqgiIpJ7HNkEyweD4SA1sg+9jrXk0Pk4gn2tfDqoHkG+uoSpSF6ggioiIrnDiZ2wpDc4bDgqPcqQK7346eQ1/DzdWDCoLhGBuoSpSF6hgioiIs7v3L60ifhTr2OUac54+3C2/HkFT3cX5g6oQ4VQP7MTikgWUkEVERHndukIfPooJMdgFKvPKwUm8eWvF3FzsTCrdy1qFQ80O6GIZDEVVBERcV7XTsGC9pB4CUKr8UGRqczZFQ3AW12r07R8sMkBRSQ7qKCKiIhzir8In3aA2NNQuBzLKk7n1S1nAZjSthLtI4uYm09Eso0KqoiIOJ/r12Dho3D5CPhH8E2t2Uxcfw6A0Q+VpX/DkubmE5FspYIqIiLOJSUx7YSo6N/AJ5hd93/CiNXnMQzoc19xnmhW1uyEIpLNVFBFRMR5pKbA0t5wahd4+rPvwbn0W3kZm92gbfVwXmhXGYvFYnZKEclmKqgiIuIcHHb4cggc3Qzu3vzZbC49VsaTnOqgWcVg3u5aHRcXlVOR/EAFVUREzGcYaZcvPbACXD04+fAcuqyxk5Bip0HpQszoWRN3V31kieQX+m0XERFzGQZ88yz88ilYXDj/8Pt03OBJzHUbNYoFMKdvbTzdXc1OKSI5SAVVRETMte1N2DkDgKvN3qbjlkJcik+mQqgv8/rXxcfqZnJAEclpKqgiImKene/DlpcBiG/6Mp12luTMteuUKuzDp4Pq4e/tbnJAETGDCqqIiJhjzyewYRIASQ0n0vmX6vx1KYEiAV4sHFyPIF+ryQFFxCwqqCIikvN+XQKrxwGQct9ouh9qzB/RcQT5Wlk0uB7hAV4mBxQRM6mgiohIzvp9BawYBhik1n6MficeYe/pGAK83Vk4qB4lCvuYnVBETKaCKiIiOefPDbB8EBgOHJF9GHqxMzuPXcHHw5X5A+pSPtTX7IQi4gRUUEVEJGcc3QJL+4AjFUeVLoxJ6MfmQ5ewurnwcf86VI8IMDuhiDgJFVQREcl+J3bCkp5gT8ao0Jr/GMNZ9dsF3F0tzO5Ti/tKFTI7oYg4ERVUERHJXmd+gkVdwJaIUaYZr3hN4LOfzuFigWndatC0fLDZCUXEyaigiohI9oneD592hJQ4KNGIdwtNZs7OMwC82qkarauFmRxQRJyRCqqIiGSPi3/Cpx0g6RoUrcPssJd5Z+tpAKa0rUTX2hGmxhMR56WCKiIiWe/KMVjQHhIuQmg15pZ4k1e3pG05ndSqAv0bljQ5oIg4MxVUERHJWjGnYUE7iDsLQRVZXH46L2xKK6dPNi/H0AdKmxxQRJydCqqIiGSduPNpW06vnYTAUiyvMoNnNpwDYNSDZRj1UFmTA4pIbqCCKiIiWSPhctoxp5ePgH8Eq2t8wJPrzgMwtHEpxjUvZ24+Eck1VFBFROTeJV6BT9vDhQNQIJSNdecwau1FAPo3KMHTrSpgsVhMDikiuYUKqoiI3Jvr1+DTRyH6N/AJZmv9T3h8zVUMA3rWK8bzbSupnIpIpqigiojI3UuKgYUd4dxe8C7M9w0/YdCaGOwOgy61ivJy+yoqpyKSaSqoIiJyd5LjYGHntCtFeRVkd+O59F8TR6rDoENkOK92qoaLi8qpiGSeCqqIiGReSgIs6gqnd4OnP3ubzqf36gRsdoPWVcN4s0t1XFVOReQuqaCKiEjmpCTC4m5wcgdY/dn/4Hy6r0okJdVB80ohTOseiZurPl5E5O7pfxAREblztuvwWXc4/h14+HKw+Ty6rU4myeagSfkgZvSsgbvKqYjcI/0vIiIid8aWBEt6wbGt4FGAww/Po+sqGwkpdu4vU5jZvWthdXM1O6WI5AGZLqjbtm2jbdu2hIeHY7FYWLFixW3H9+/fH4vFcsOtcuXK6WOmTJlyw/MVKlTI9MqIiEg2SU2GZX3h6GZw9+bIw3PptNpOXHIqdUsGMqdvbTzdVU5FJGtkuqAmJCRQvXp1Zs6ceUfjp0+fzrlz59Jvp06dIjAwkC5dumQYV7ly5Qzjtm/fntloIiKSHew2+HwAHN4Abl781fwTOq42iE1KpXbxgnzSvw5eHiqnIpJ13DK7QKtWrWjVqtUdj/f398ff3z/9/ooVK7h69SoDBgzIGMTNjdDQ0MzGERGR7GS3wRcD4dAacPPkr+Yf0WGtS3o5nTewLgWsmf4oERG5rRw/BvXjjz+mWbNmFC9ePMPjhw8fJjw8nFKlStGrVy9Onjx5y9dITk4mNjY2w01ERLKYPRW+HAIHvwZXD441m0OHde4qpyKS7XK0oJ49e5Z169YxePDgDI/Xq1ePefPmsX79embNmsWxY8do1KgRcXFxN32dqVOnpm+Z9ff3JyIiIifii4jkHw47rHgcfv8KXNw5/tAHtF9vJTYplVoqpyKSzXK0oM6fP5+AgAA6dOiQ4fFWrVrRpUsXqlWrRosWLVi7di3Xrl1j2bJlN32dSZMmERMTk347depUDqQXEcknHHZYMRx++xxc3Djx0CzabyyQXk7nq5yKSDbLsf9hDMPgk08+oU+fPnh4eNx2bEBAAOXKlePIkSM3fd5qtWK1WrMjpohI/uaww4phsG8pWFw5+eAM2m3yJ+a6LW3L6YA6Kqciku1ybAvq1q1bOXLkCIMGDfrXsfHx8Rw9epSwsLAcSCYiIkBaOf3q8bRy6uLGyYdm0nZzIWKu26hZLIB5A+rg6+ludkoRyQcyXVDj4+PZu3cve/fuBeDYsWPs3bs3/aSmSZMm0bdv3xuW+/jjj6lXrx5VqlS54bnx48ezdetWjh8/zo4dO3j00UdxdXWlR48emY0nIiJ3w54KXw2F35alldMHM5bT+QPrqpyKSI7J9H6aPXv20LRp0/T748aNA6Bfv37MmzePc+fO3XAGfkxMDMuXL2f69Ok3fc3Tp0/To0cPLl++TFBQEPfffz+7du0iKCgos/FERCSz/i6n+79IO+b0wfdpt7mgyqmImMZiGIZhdoh7FRsbi7+/PzExMfj5+ZkdR0Qk97CnwlePwf7l6SdEtdsUoHIqIlkuM30tx+dBFRERJ5GhnLpz4qHZtN+cVk5rqJyKiIl0KqaISH5kT4UvB6fPc3qi2Szab/LnWmJaOV2gcioiJlJBFRHJb+w2WD4YDqz4/5Pwz6b9Rj9tORURp6GCKiKSn9htsHwQHFgJLu4cfXAWHTb6Epf0f+XUT+VUREymgioikl/YbfDFQDj4Nbh68GeT9+m40Y/45FTqlCjI3AG6QpSIOAf9TyQikh/8o5webPw+nTb6kpiSSv1Shfi4f228PfSRICLOQf8biYjkdXYbfDEADq4CVw/2N3qfzpsKkGSz06hsYT7sUxsvD1ezU4qIpFNBFRHJy1KT07ac/rEaXK382nAmXTYVICXVwYMVgnm/V0083VVORcS5qKCKiORVtiRY1gcOfwOuVn5qMIPum32w2R08XCmEGT1r4uGm6bBFxPmooIqI5EUpibCkJ/y1Bdy82H3fDHpu9ibVYdC6ahjTukfi7qpyKiLOSQVVRCSvSY6Hz7rD8e/A3Yft9d6n37ce2B0G7SPDeatLddxUTkXEiamgiojkJUmxsKgLnNoFHr5sqfM+gza74jAMOtcqymudquHqYjE7pYjIbamgiojkFdevwsJOcOYn8PTnm5qzGPotGAb0qBvBfztUxUXlVERyAe3jERHJCxKvwPx2aeXUK5DVNT7gsf9fTvvWL65yKiK5iragiojkdvEXYUF7uPA7+ATxZdX3GbfFBsCg+0vybOuKWCwqpyKSe6igiojkZnHRaVtOLx2CAqEsrjCDZ6JSABjWpDQTWpRXORWRXEcFVUQkt4o5A/PbwpWjGH5FmFNyGq9sTyunYx4qy9hmZVVORSRXUkEVEcmNrp5IK6fXTmAEFOOd8Ld494e03frPPFKBxxqXNjmgiMjdU0EVEcltLh9N260fexojsBQvF36Nj3+2YbHAyx2q0KtecbMTiojcExVUEZHc5OKfsKAdxJ3DKFSOZ/xe5rN9NlxdLLzZpRqP1ihqdkIRkXumgioikltE74dPH4WECziCKjLW+gJfH0zF3dXCez1q0rJKqNkJRUSyhAqqiEhucPonWNgRkq5hD6nG4/yHjUdS8XR34YM+tXmgXJDZCUVEsowKqoiIszu+HRZ3g5R4UsPr0Df5KXacSaWA1Y1P+tehbslAsxOKiGQpFVQREWd2eBMs7QWpSaQUa0TXmFHsPZ9KgLc7CwbWpVrRALMTiohkORVUERFndWAlfDEIHDaSSj1M+/NDOHTZRuECVhYNrkf5UF+zE4qIZAsVVBERZ7T3M1g5HAwHCWXb0epkH07G2CgS4MXCwfUoWdjH7IQiItlGBVVExNn8+BGseRKAmArdaHGkE9HxNkoW9mHh4HoUCfAyOaCISPZSQRURcSbfT4eNkwG4VHkADx9oyZXrqZQP8eXTwXUJ9vU0OaCISPZTQRURcQaGAVv+C9veAOB0lRG0/K0x8cl2qhf1Z/7AugR4e5gcUkQkZ6igioiYzTBgwzOw630A/qz6JG1+qUNKqp36pQrxYd9a+Hq6mxxSRCTnqKCKiJjJYYfVY+HnBQD8XOU/dN5TGYfh4OFKIbzbowae7q7mZhQRyWEqqCIiZrHb4KuhsH85WFzYWuF5+u0pC0CXWkWZ2rEqbq4uJocUEcl5KqgiImawJcEXA+DQWgwXN74u8yJjfikBwJBGJXnmkYpYLBZzM4qImEQFVUQkpyXFwpKecPw7DDdP5ke8xJR9RQCY0LI8wx4orXIqIvmaCqqISE5KuAQLO8G5vRgevkwPfpFpB0OwWOC/HarSs14xsxOKiJhOBVVEJKfEnIZPH4VLf2J4FWKy3wt8eiQQd1cL07rVoHW1MLMTiog4BRVUEZGccOkwLOgAsadx+IYz2v15Vp/wxcvdlQ/61KJxuSCzE4qIOA0VVBGR7HZ2b9pu/cRLpBYsTb/UZ/j+rBf+Xu7MHVCHmsUKmp1QRMSpqKCKiGSn49thcXdIiSM5qCqd4sax/5qVED8rnw6qR7kQX7MTiog4HRVUEZHscmgdfN4fUpNICLuPRy6M4ESCKyUKefPpoHpEBHqbnVBExCmpoIqIZIdfl8KKYWDYuVL0IR4+NYBLyS5UDPNjwcC6BPlazU4oIuK0VFBFRLLartmwfiIAp4u15+GjXUi0u1C3ZCBz+tbG38vd5IAiIs5NBVVEJKsYBkS9CltfBeBAsZ60OfwIDsOFlpVDmdY9Ek93V5NDiog4PxVUEZGs4HDA+qdh9wcAbC86hN5/NgEs9L6vGC+0q4Kri64OJSJyJ1RQRUTuld0GK0fAvqUAfBU6hieO1APgyeblGPlgGV26VEQkE1RQRUTuRUpi2pn6hzdgWFz5MPApph6vhosFXnm0Kt3r6tKlIiKZpYIqInK3Eq/A4q5w+kcMN0/+6z2Rj86Ux+rmwsyeNWlWKcTshCIiuZIKqojI3bh2ChZ2hEt/YrcGMNb1aVZdKIa/lzuf9K9NreKBZicUEcm1VFBFRDLrwkH4tCPEncXmE0af5Ansigkh3N+TBYPqUiZYV4cSEbkXKqgiIplxclfabv2kGBL9y9Du2jiOJAdQLqQA8wfWJczfy+yEIiK5ngqqiMid+p9Ll14NjOTh8yO5aPemTomCfNS3Dv7emoBfRCQrqKCKiNyJnz+FVWPAsHM6qBHNTw/kumGlReUQpnevoQn4RUSykAqqiMjtGAZsfxs2vwjAvsKt6XiqG6m40bNeMV5qrwn4RUSymgqqiMitOBywYRL8MBuAbwJ78tjp1oCFcc3LMUoT8IuIZAsVVBGRm0lNhq8eh9+/BGCe31CmnH0ANxcLr3aqRudaRU0OKCKSd6mgioj8U3IcLO0Nf0VhuLjzinU0cy7UooDVjdm9a3F/2cJmJxQRydNUUEVE/lf8RVjUCc79it3NmzHGk6y+WpFQP0/mDqhDxTA/sxOKiOR5KqgiIn+7fBQWdoKrx0ixBtLr+nh+TClBhVBf5g6oozlORURyiAqqiAjA6T1pE/AnXibeqwjtY57kqCOUhmUKMat3Lfw8NcepiEhOUUEVEfljLXwxEFKvE+1TgTaXx3AJfzrWLMKrHavh4eZidkIRkXxFBVVE8rcfP4a148FwcLBAPTpdGkoinox+sAxPNC+naaREREyggioi+ZNhwLcvwXdvARDl3YLBl3phuLjzaocqdK9bzOSAIiL5lwqqiOQ/qSmwajT8+hkAn3r25LkrrfH2cGNmr5o0LR9sckARkfxNBVVE8pekWFjWF/7agmFx5RXXx5lzrSFBvlbm9q9DlSL+ZicUEcn3VFBFJP+IPQeLusD530h182ZEymg2XK9GmeACzBtQh6IFvc1OKCIiqKCKSH5x4Q9Y1BliTnHdI5Du8eP41VGKBqXTppHy99I0UiIizkIFVUTyvhM74LPukBTDZWsEHWLHccoIoWvtorzcoaqmkRIRcTIqqCKSt/3+FXz5GNhTOGKtRJeY0VzFj6dalGd4k9KaRkpExAmpoIpI3rXzfdjwDGCww/0+BsQ8juHmyYyu1WlTLdzsdCIicgsqqCKS9zjssH4S7P4AgM9dWjExrhcFfTyZ0682NYsVNDmgiIjcjgqqiOQtKQnwxSD4cx0Abzp6MiOpNWWCfZnbvw4RgTpTX0TE2WX6zIBt27bRtm1bwsPDsVgsrFix4rbjo6KisFgsN9yio6MzjJs5cyYlSpTA09OTevXqsXv37sxGE5H8Li4a5j4Cf67D7uLBCNtoZqS0oWGZwiwf1kDlVEQkl8h0QU1ISKB69erMnDkzU8sdOnSIc+fOpd+Cg//vSi1Lly5l3LhxPP/88/z8889Ur16dFi1acOHChczGE5H86vwB+KgZnNtLglsAXa4/wxr7fXSrHcG8AXU1jZSISC6S6V38rVq1olWrVpn+QsHBwQQEBNz0ubfffpshQ4YwYMAAAGbPns2aNWv45JNPePrppzP9tUQknzm6Je3qUMmxRLsVpWvCk5w0QpjQsjzDHtCZ+iIiuU2OTf4XGRlJWFgYzZs35/vvv09/PCUlhZ9++olmzZr9XygXF5o1a8bOnTtv+lrJycnExsZmuIlIPvXzp2kT8CfHst+tMi3iJ3PeNYyZPWsyvEkZlVMRkVwo2wtqWFgYs2fPZvny5SxfvpyIiAiaNGnCzz//DMClS5ew2+2EhIRkWC4kJOSG41T/NnXqVPz9/dNvERER2b0aIuJsHA7Y/CJ8PRIcqay3NKJj/ATcCwTy2WP30bpamNkJRUTkLmX7Wfzly5enfPny6fcbNGjA0aNHeeedd/j000/v6jUnTZrEuHHj0u/HxsaqpIrkJ7YkWDkc9i8HYKajI2+kdKJciC8f99OZ+iIiuZ0p00zVrVuX7du3A1C4cGFcXV05f/58hjHnz58nNDT0pstbrVasVmu25xQRJ5R4BZb0hJM7sVtcmZgymC/sD/BghWCmd4/E11MnQ4mI5HamXIB67969hIWl7X7z8PCgVq1abN68Of15h8PB5s2bqV+/vhnxRMRZXT6adqb+yZ0kuvjQJ3kiX9gfYEijkszpW1vlVEQkj8j0FtT4+HiOHDmSfv/YsWPs3buXwMBAihUrxqRJkzhz5gwLFiwAYNq0aZQsWZLKlSuTlJTERx99xLfffss333yT/hrjxo2jX79+1K5dm7p16zJt2jQSEhLSz+oXEeHkD/BZd7h+hfMuwfS6Pp4TLhG81qkK3eoUMzudiIhkoUwX1D179tC0adP0+38fC9qvXz/mzZvHuXPnOHnyZPrzKSkpPPnkk5w5cwZvb2+qVavGpk2bMrxGt27duHjxIpMnTyY6OprIyEjWr19/w4lTIpJP/fYFrBgO9mR+t5Shf+I4Ur2D+LR3Le4rVcjsdCIiksUshmEYZoe4V7Gxsfj7+xMTE4Ofn5/ZcUQkqxgGbH0NoqYCsNGow6jk4UQEF+LjfnUoVkgnQ4mI5BaZ6WumnCQlIvKvbEmwcgTs/wKA2alteD21O43KhfBezxr46XhTEZE8SwVVRJxP/IW0M/VP/4gdVybZBrLM3pSBDUvyzCMVcHM15fxOERHJISqoIuJczv8Oi7tBzCniLAUYkjyWPVTmlUer0LOeToYSEckPVFBFxHn8+Q18MQBS4jlpCaNv0niueRVjQa+aNChd2Ox0IiKSQ1RQRcR8hgE/zIYNz4DhYJdRmaFJYygcFMKKfnUoUdjH7IQiIpKDVFBFxFx2G6ybAHs+AWBJahOeSx1I/XJhvNejBv5eOhlKRCS/UUEVEfNcvwaf94e/tuDAwiu2nnxkf4THGpdmYssKuLpYzE4oIiImUEEVEXNc+SvtZKhLf3IdK6NTRrDVpS5vd61Kx5pFzU4nIiImUkEVkZx3Ygcs6ZV22VICGZg8nku+5VnWpzaREQFmpxMREZOpoIpIzvplEcaqMVgcNvY5SjE45UnCI0qyqk8tgv08zU4nIiJOQAVVRHKGww4bJ8POGViANfa6PGkbRuuapfnvo1XwdHc1O6GIiDgJFVQRyX5JMfDFQDiyCYDpqY/yrr0Tz7SpwsCGJbBYdDKUiIj8HxVUEclel4+mnQx1+TBJePBkyuN853E/c/vWpHG5ILPTiYiIE1JBFZHsc/TbtGmkkmI4ZwQyJGUcSUHVWNm3NiU1+b6IiNyCCqqIZD3DgN0fYqyfhMWw87OjDENTxlG9Yjne6RaJr6cm3xcRkVtTQRWRrJWaAmvHw8/zsQDL7Y14xjaIwU0r8mTz8rho8n0REfkXKqgiknUSLsGyvnDiexxYmGrrwUKXdrzVszptqoWbnU5ERHIJFVQRyRrR+2FJD7h2kjjDi1G2kRwr2JCv+tSiQqif2elERCQXUUEVkXv3xxqM5UOw2BI47ghhsO1JiparwdfdauDvreNNRUQkc1RQReTuGQZ89yZ8+zIW4Ht7ZUbYRtPnwRqMbVYOVx1vKiIid0EFVUTuTkoifD0S9i8HYH5qc95xHcBrfWrRonKoyeFERCQ3U0EVkcy7egKW9oLo37AZrkxJ7cfOwPZ80acWZYJ9zU4nIiK5nAqqiGTOsW0Yn/fHkniZS4Yfw1PG4FehCSu7Vdf8piIikiVUUEXkzhgG/PABxoZnsBh2fnOUYKjtSbo3q8/IpmU0v6mIiGQZFVQR+Xe2JFj9BPy6GAvwpf1+XnF9nNf71eXBCiFmpxMRkTxGBVVEbi/mDCztDWd/xm5YeCW1F9sCu/B5vzqULOxjdjoREcmDVFBF5NZO7sJY2gdLwgWuGgUYaRuFf+XmrOhcHR+r/vsQEZHsoU8YEbm5PZ9grJ2AxWHjoKMYQ23j6NGiMY8/UAqLRcebiohI9lFBFZGMUlNg3VPw0zwswGr7fbzsNoLXe9encbkgs9OJiEg+oIIqIv8n7nzaLv3TP+AwLLyR2o0dob35onctihb0NjudiIjkEyqoIpLm9E84lvTCJf4csYY3o20jKVKnHcvaVsLq5mp2OhERyUdUUEUEfl6AY814XOzJHHYUYaQxnsc6PUynWkXNTiYiIvmQCqpIfpaajLH2KSw/z8cF+MZei2m+TzKtTyMqhvmZnU5ERPIpFVSR/CrmNI4lfXA59zMOw8KbqV04Wm4IS7rVwE+XLBUREROpoIrkR39txf75AFyvX+aqUYCxthHUb9GN2Y01hZSIiJhPBVUkPzEM2PEexqbncTUc7HeUYJL7BJ7p25L6pQuZnU5ERARQQRXJP5LjcKwYicvBFViAL+yNWR42jjm96hPq72l2OhERkXQqqCL5waXDpC7uiduVP0kxXHkxtS8e9YawoHVF3F1dzE4nIiKSgQqqSF53cDX2L4fiZosn2ijIE8Y4enXrTJtq4WYnExERuSkVVJG8ymHH+PZlLNvfxhX4wVGBN3yf5tV+zSgT7Gt2OhERkVtSQRXJixKvYFs2APfjUQB8lNqKfRXHMa9zTQpY9WsvIiLOTZ9UInnN2V9IWdwbj/jTJBpW/mN/jJpthjC9XjFNISUiIrmCCqpIXmEYGHvm4lg7AQ/DxjFHCC94T2J8n45UKeJvdjoREZE7poIqkhekJJCyciwevy/DlbRLlq4r/Tzvdm+gq0KJiEiuo4IqkttdOkzSol54Xj1EquHC245uBLWYwNsNS2qXvoiI5EoqqCK5mPH7CmxfDsfTnsAFI4AXrE8ypE9fIiMCzI4mIiJy11RQRXIju42U9c/i8eNsPIBdjop8XnwK/+3xIAHeHmanExERuScqqCK5TcwZEhf3xfv8HgBm29vh9tBzvPlAWe3SFxGRPEEFVSQXMY5uIXnpQLxTrhBrePOS+2i6DxhKreKBZkcTERHJMiqoIrmBw0FK1Ou4bXsVTwx+dxRnXtEXmdTrEQJ9tEtfRETyFhVUEWeXeIWEJQPxObkFgCX2plx74GVee7AyLi7apS8iInmPCqqIEzNO/0Tiwl74JJ0jyXDnNbfHaNn3SeqVKmR2NBERkWyjgirijAyDpO0zcdv8PD6kcswRwkdhU3iiTycKF7CanU5ERCRbqaCKOJvrV4lZMhT/ExsAWO+oy9kH3uClptW1S19ERPIFFVQRJ+I4tYeERb3xTzpHsuHGTI8BNOn9DC11lr6IiOQjKqgizsAwSNj2HtYtL+BLKiccwSwu9iLDe3XG38vd7HQiIiI5SgVVxGzXr3Jl0RACT28EYK3jPuKav8XT91fWxPsiIpIvqaCKmMh+8kfiF/UhMDltl/5sz0E83O8/VAz3NzuaiIiIaVRQRcxgGMRumY73thfxx85xRwgryrzMY9074u2hX0sREcnf9EkoktMSr3Bx0WCCzmwGYL1xH6ltpjO2bgWTg4mIiDgHFVSRHGQ7/gMJi/sSlBJNsuHGRwUe45H+/6FkUAGzo4mIiDgNFVSRnGAYXNn8Dn7bXyYAO8ccIXxT+VUGd2qP1c3V7HQiIiJORQVVJLslXuHcggGERUcBsIH6uHeaydDqpc3NJSIi4qRUUEWyUeKR7SQtGUhY6nmSDXfm+w+lzYD/EF7Q2+xoIiIiTksFVSQ7OOycXf0yIT9PwxsHx41QdtZ8k0Ft2+Cqy5WKiIjclgqqSBazXzvNubl9KBrzMwDrXR8gpMcMepQpZnIyERGR3EEFVSQLXf5pBR6rR1LUiCPBsPJl2JO07z8OP09drlREROROqaCKZAVbEseXjKPE0UUA/G6U5PRDM+ndqIEuVyoiIpJJKqgi9+j62QNcXdCHEklHAFjh9Sg1BrxNi+BAk5OJiIjkTiqoInfLMDjz7YcEfvcc4SRzyfAjquILtO/SH3dXF7PTiYiI5FqZ/hTdtm0bbdu2JTw8HIvFwooVK247/ssvv6R58+YEBQXh5+dH/fr12bBhQ4YxU6ZMwWKxZLhVqKDLPorzciRe4+isrhT5bgJeJLPbUo3jnb+hc/eBKqciIiL3KNOfpAkJCVSvXp2ZM2fe0fht27bRvHlz1q5dy08//UTTpk1p27Ytv/zyS4ZxlStX5ty5c+m37du3ZzaaSI648sd2Lr9Vl9IXvsFmuLI8cDBln9xI7aoVzY4mIiKSJ2R6F3+rVq1o1arVHY+fNm1ahvuvvPIKK1euZNWqVdSoUeP/gri5ERoamtk4IjnH4eDIipcpse8d3HBw2gji9/rv0LFFG50IJSIikoVy/BhUh8NBXFwcgYEZTyA5fPgw4eHheHp6Ur9+faZOnUqxYjefNzI5OZnk5OT0+7GxsdmaWeT6lTOc/aQvZeL3ALDVvRERfT+gRUQRk5OJiIjkPTl+sNybb75JfHw8Xbt2TX+sXr16zJs3j/Xr1zNr1iyOHTtGo0aNiIuLu+lrTJ06FX9///RbRERETsWXfOj4ji9Jeq8+peP3kGhYWVn8Geo9tYJSKqciIiLZwmIYhnHXC1ssfPXVV3To0OGOxi9evJghQ4awcuVKmjVrdstx165do3jx4rz99tsMGjTohudvtgU1IiKCmJgY/Pz8Mr0eIjdjT07gwPwxVD37OQB/WkoQ2/oDate+z+RkIiIiuU9sbCz+/v531NdybBf/kiVLGDx4MJ9//vltyylAQEAA5cqV48iRIzd93mq1YrVasyOmCADRh3aTumwgVe2nANjs34maA6dRzl9/AImIiGS3HNnF/9lnnzFgwAA+++wzWrdu/a/j4+PjOXr0KGFhYTmQTuT/GA47vy17iUKLW1LUfoqLRgDf1fuQB8d+TEGVUxERkRyR6S2o8fHxGbZsHjt2jL179xIYGEixYsWYNGkSZ86cYcGCBUDabv1+/foxffp06tWrR3R0NABeXl74+/sDMH78eNq2bUvx4sU5e/Yszz//PK6urvTo0SMr1lHkjsScP070vP5Uvf4LWGC3tT7hfebQqKiOcRYREclJmd6CumfPHmrUqJE+RdS4ceOoUaMGkydPBuDcuXOcPHkyffyHH35IamoqI0aMICwsLP02ZsyY9DGnT5+mR48elC9fnq5du1KoUCF27dpFUFDQva6fyB35Y/OnMKsh5a//QqJh5duy/6HmU2soqnIqIiKS4+7pJClnkZmDbkX+V1L8Nf6YO5zIy2sA+MOlDEbHOVSsUtPkZCIiInmLU54kJeJsjv8ahcfKx4l0nMNhWNgW0pu6A97A28vL7GgiIiL5mgqq5DuOVBu/LHqW6n99iJvFwTkKc+bB6TR5oI3Z0URERAQVVMlnLp48xNWF/amVcgAssMunKWX6f0jtoGCzo4mIiMj/p4Iq+YLhcPDL6tmU+/lFgrhOnOHFvuqTafDoMCwWi9nxRERE5H+ooEqed+3SeY7MG0rt+C0AHHCrhE+PT2hYuqLJyURERORmVFAlT9u75QvCtz5Fba6Qariwu/hj1OnzEu7uHmZHExERkVtQQZU8KT4uht/mjaH+5a8AOOVShOQ2s2hQ8wGTk4mIiMi/UUGVPOf3Hzbht34k9Y1zAOwO7kK1/u/g6e1rcjIRERG5EyqokmckJV1nz4JJ1D8zD1eLwQUKcbnZ29S9v4PZ0URERCQTVFAlTzi8/0f4cij3O46CBX72b07ZAbOoGKDL5YqIiOQ2KqiSq6WmprJz8cvUPToDq8XGNQpwsv5/qdmiv9nRRERE5C6poEqudeLoH8QuGUIj2z6wwH7vuhTp9zHVQoqZHU1ERETugQqq5DoOu4Pvv3yPyP1TKW65TiJW/qz+NNXbj8Xi4mJ2PBEREblHKqiSq0SfPcWpBUNplPQ9WOBPj0oE9PqYyOKVzI4mIiIiWUQFVXIFwzDYufZTyu9+ljqWGFIMV34vN4LI7s9jcdWPsYiISF6iT3ZxehcvnufP+aNoGL8BLHDCtThunedQo2I9s6OJiIhINlBBFadlGAa7vllKqZ2TaMgVHIaFXyN6U7XP67hZvc2OJyIiItlEBVWc0qVLlzg4fxSN4tYCcMYlDFvbmdSo8ZDJyURERCS7qaCK09m18XOKfz+RRlxO22papDtV+r6Ju2cBs6OJiIhIDlBBFadx+cplDswbQ6PYVQCccwklqfV71Kj1sMnJREREJCepoIpT+GHzV0R89xSNuAjAL2FdqdznbTy8fU1OJiIiIjlNBVVMdeXqFX6b9wQPxKwAINolmOut3qVGnVbmBhMRERHTqKCKaX7YsooiW5/kAc4DsDekE5X6TcPD28/kZCIiImImFVTJcVevXePX+eNocnU5AOctQSS0nEZkvTYmJxMRERFnoIIqOerHrWsI2TKOJkQDsDe4AxX7TSPEp6DJyURERMRZqKBKjoiJieGX+eNpfPlzXCwGFyyFiXv4bSLrtzc7moiIiDgZFVTJdj9t/ZrgLU+lbTW1wK9BbSnf9z2CfbXVVERERG6kgirZ5uqVyxxcMJYG174G4IKlEHHN3qR6w44mJxMRERFnpoIq2WLPN0souuMZGnAZgJ+DH6VS33cILqCtpiIiInJ7KqiSpS5dOMeRT0dxX9xGAM64hHK95TRq1tW8piIiInJnVFAlSxiGwe61n1Dmxxe4jxjshoVfwntQte/rWL10NSgRERG5cyqocs/Onz3BqYXDqZe4HYATrsVwtJ1B7cgHTE4mIiIiuZEKqtw1w+Fg14r3qfTrK9S2JGAzXNlbvD+Rvf6Lu9XL7HgiIiKSS6mgyl05c/xPLn42jPrJe8ACR93K4N7xfepUqmd2NBEREcnlVFAlU+x2Oz98/ibVD75NEUsSyYY7+8oOo2b3ybi6uZsdT0RERPIAFVS5Yyf+3Ef858NoYNsPFjjkXokCXWdRp2yk2dFEREQkD1FBlX+VmpLEns9epMZfH2K12Eg0rByo9AQ1Oz2Fi5t+hERERCRrqV3IbR3buxXLqlHcZz8BFtjvWZOgHrOoXbyC2dFEREQkj1JBlZtKTrjGgU+fovq5z3GxGFzBl6M1/kPttkOxuLiYHU9ERETyMBVUucHh75bh/+3T1DAugwV2+T5M6d7TqBNSxOxoIiIikg+ooEq6+EunOLZwFFWvbQHgNCGcvf8V7mvW2eRkIiIikp+ooAo4HBxYM4OIn6ZSlURSDRe2B3WnRp9Xqevvb3Y6ERERyWdUUPO5yyf2c2XJMCpd3wfAIZfSJLV6hyZ1dJlSERERMYcKaj5lpCbz+7IXKffnbAqRSqJhZWeJYTTs+QyeVqvZ8URERCQfU0HNh879tpXUlaOoknoCgJ/ca+Hb+V0eKl/F5GQiIiIiKqj5SmrCVf5Y/BSVTn+Bi8XgsuHHr1WepvGjj+Pm5mp2PBERERFABTV/MAxOfbcQny3PUcW4ChbY6tOC0j3f4cEimjpKREREnIsKah6XFH2Ys4uHUyp2NwDHCOdU/Zdp/HBHLBaLyelEREREbqSCmlelJnPi61cI3TeTUthINtzZVLgP9fq8QOMAP7PTiYiIiNySCmoeFHdgM9dXjKF4yikAdluqY2/9Jq3r1DU5mYiIiMi/U0HNQ4y485xa+iTFTq/CF7hgBLC15DhadR9OAU93s+OJiIiI3BEV1LzA4eDStg/x2voSxYx4HIaFVdZWFO88lS7lSpidTkRERCRTVFBzOduZX7m0ZARhcb8B8LtRgoO1XqR967a4u7qYnE5EREQk81RQc6vkeM6tfJ7gA58QhoM4w4sVBfvTuNckOgf5m51ORERE5K6poOZC8b+uJHX1eMJsFwDYZLkPe4up9L6vhqaOEhERkVxPBTUXMS7/xfllYwk9vxWAU44gNpd6ike7DsTfWydBiYiISN6ggpob2K5zbePreO9+j1BspBiuLLd2oFzXl+hfRleCEhERkbxFBdXJ2Q6uJXHleAKSzgDwvaMqx+s9T5cWD+HhppOgREREJO9RQXVWV49z7ctxBJzajD9wzgjk80LDaddjGA2DCpidTkRERCTbqKA6G1sSSVFv47rjHQKMFGyGK4tc2lCo9bOMql1WJ0GJiIhInqeC6kSMPzeQuHI8PgknAfjeXpld5Z9mUMeWBHh7mJxOREREJGeooDqDqydI/PopvI9twAeINgoyx2sQD3cZxpOlC5udTkRERCRHqaCayZZE6vZ34bs38XYkYzNcmWc8QmrD8Ux4qCpWN1ezE4qIiIjkOBVUsxzexPWvx+EVdwKAnfZKfBk2lmFdWlNKJ0GJiIhIPqaCmtOuHCN57SSsR9bhBZw3AnjXtT912g3h9RpFdBKUiIiI5HsqqDklJQHHd29jfP8uVkcKqYYLc+2tOF9jDBMeqYm/l64EJSIiIgIqqNnPMOD3L0lZ9x88Es4BsN1emc8CRzC0S2uqFQ0wN5+IiIiIk1FBzU7Rv5G65incTu3EAzjlCOItl77UatWHd+8rgauLdueLiIiI/JMKanZIvILx7cuwZy5uOLhuePB+ajvOV3mMZ9pUJ9jX0+yEIiIiIk5LBTUr2VPhp7nYN7+Ea3IMAKvt97HIbzCjOjalgeY0FREREflXLpldYNu2bbRt25bw8HAsFgsrVqz412WioqKoWbMmVquVMmXKMG/evBvGzJw5kxIlSuDp6Um9evXYvXt3ZqOZ6/h2HB80hrXjcU2O4aAjgj72yZx4cCbzn+ikcioiIiJyhzJdUBMSEqhevTozZ868o/HHjh2jdevWNG3alL179zJ27FgGDx7Mhg0b0scsXbqUcePG8fzzz/Pzzz9TvXp1WrRowYULFzIbL+ddOwWf94d5rXG58DvXDB+etQ3g7ZIf8coTwxjRtAwebpn+NouIiIjkWxbDMIy7Xthi4auvvqJDhw63HDNx4kTWrFnD/v370x/r3r07165dY/369QDUq1ePOnXqMGPGDAAcDgcRERGMGjWKp59++l9zxMbG4u/vT0xMDH5+fne7Opljuw473sPx3du4pF7HblhYZG/GZz69eaLdfTSvFKI5TUVERET+v8z0tWw/BnXnzp00a9Ysw2MtWrRg7NixAKSkpPDTTz8xadKk9OddXFxo1qwZO3fuvOlrJicnk5ycnH4/NjY264Pfzp/fYKx5EkvMSVyAHxwVeMnen/vvb8ryh8rg7aFDe0VERETuVrY3qejoaEJCQjI8FhISQmxsLNevX+fq1avY7fabjvnjjz9u+ppTp07lhRdeyLbM/+av40cpFXOSs0Ygr9h6caHYI7z9aFXKhfialklEREQkr8iVm/omTZrEuHHj0u/HxsYSERGRY18/yuth5tkOstnanHHtatCxpi5RKiIiIpJVsr2ghoaGcv78+QyPnT9/Hj8/P7y8vHB1dcXV1fWmY0JDQ2/6mlarFavVmm2Z/03fBiV5P2UUa+oXJ8Dbw7QcIiIiInlRtp9eXr9+fTZv3pzhsY0bN1K/fn0APDw8qFWrVoYxDoeDzZs3p49xNm6uLox+qKzKqYiIiEg2yHRBjY+PZ+/evezduxdIm0Zq7969nDx5Ekjb/d63b9/08Y8//jh//fUXEyZM4I8//uD9999n2bJlPPHEE+ljxo0bx5w5c5g/fz4HDx5k2LBhJCQkMGDAgHtcPRERERHJbTK9i3/Pnj00bdo0/f7fx4L269ePefPmce7cufSyClCyZEnWrFnDE088wfTp0ylatCgfffQRLVq0SB/TrVs3Ll68yOTJk4mOjiYyMpL169ffcOKUiIiIiOR99zQPqrMwZR5UEREREbljmelrusSRiIiIiDgVFVQRERERcSoqqCIiIiLiVFRQRURERMSpqKCKiIiIiFNRQRURERERp6KCKiIiIiJORQVVRERERJyKCqqIiIiIOBUVVBERERFxKiqoIiIiIuJUVFBFRERExKmooIqIiIiIU1FBFRERERGnooIqIiIiIk5FBVVEREREnIoKqoiIiIg4FRVUEREREXEqKqgiIiIi4lRUUEVERETEqaigioiIiIhTcTM7QFYwDAOA2NhYk5OIiIiIyM383dP+7m23kycKalxcHAAREREmJxERERGR24mLi8Pf3/+2YyzGndRYJ+dwODh79iy+vr5YLJYc+ZqxsbFERERw6tQp/Pz8cuRrStbR+5f76T3M/fQe5n56D3O3nH7/DMMgLi6O8PBwXFxuf5RpntiC6uLiQtGiRU352n5+fvqlzMX0/uV+eg9zP72HuZ/ew9wtJ9+/f9ty+jedJCUiIiIiTkUFVUREREScigrqXbJarTz//PNYrVazo8hd0PuX++k9zP30HuZ+eg9zN2d+//LESVIiIiIikndoC6qIiIiIOBUVVBERERFxKiqoIiIiIuJUVFBFRERExKmooIqIiIiIU1FBvY2ZM2dSokQJPD09qVevHrt3777t+M8//5wKFSrg6elJ1apVWbt2bQ4llZvJzPs3Z84cGjVqRMGCBSlYsCDNmjX71/dbsl9mfwf/tmTJEiwWCx06dMjegPKvMvseXrt2jREjRhAWFobVaqVcuXL6v9REmX3/pk2bRvny5fHy8iIiIoInnniCpKSkHEor/7Rt2zbatm1LeHg4FouFFStW/OsyUVFR1KxZE6vVSpkyZZg3b16257wpQ25qyZIlhoeHh/HJJ58Yv//+uzFkyBAjICDAOH/+/E3Hf//994arq6vx+uuvGwcOHDCeffZZw93d3fjtt99yOLkYRubfv549exozZ840fvnlF+PgwYNG//79DX9/f+P06dM5nFz+ltn38G/Hjh0zihQpYjRq1Mho3759zoSVm8rse5icnGzUrl3beOSRR4zt27cbx44dM6Kiooy9e/fmcHIxjMy/f4sWLTKsVquxaNEi49ixY8aGDRuMsLAw44knnsjh5PK3tWvXGv/5z3+ML7/80gCMr7766rbj//rrL8Pb29sYN26cceDAAeO9994zXF1djfXr1+dM4P+hgnoLdevWNUaMGJF+3263G+Hh4cbUqVNvOr5r165G69atMzxWr149Y+jQodmaU24us+/fP6Wmphq+vr7G/Pnzsyui/Iu7eQ9TU1ONBg3+Xzv3F9JUH4cB/Hl1HeeFESGbBhpsEIUVgaJMhWEIQlCXCcXYRSKhXQWaJDHJPwwRb0ITTfROkSiIlKisLiq9sQ0EzbCh3TRBEBoZbLpvN7m36fT1nLedHen5wLn5+Tv4HB4OfnfcVioPHjwQt9vNATXF1HZ4//59sdlsEg6H9YpIe1DbX319vZw/fz5u7ebNm1JWVpbUnLQ/+xlQGxsbpaCgIG6turpaqqqqkpgsMf6LP4FwOIyZmRlUVlbG1tLS0lBZWYmpqamE50xNTcXtB4Cqqqpd91PyaOlvu/X1dUQiERw9ejRZMWkPWju8e/cuLBYLrl27pkdM2oOWDp88eQKHw4H6+npYrVacPn0aHR0d2Nzc1Cs2/aKlv9LSUszMzMTeBhAIBDAxMYELFy7okpn+PyPNMibdf+MBsLq6is3NTVit1rh1q9WKjx8/JjwnGAwm3B8MBpOWkxLT0t92t27dwrFjx3bcqKQPLR2+ffsWg4OD8Pv9OiSk/6Klw0AggFevXuHq1auYmJjA4uIi6urqEIlE4PF49IhNv2jp78qVK1hdXUV5eTlEBBsbG7h+/Tpu376tR2T6A3abZb59+4YfP34gMzNTtyx8gkq0jdfrxejoKB4/fgyz2ZzqOLQPoVAILpcLAwMDyM7OTnUc0igajcJisaC/vx+FhYWorq5Gc3Mz+vr6Uh2N9uHNmzfo6OhAb28vPnz4gEePHmF8fBytra2pjkYHEJ+gJpCdnY309HSsrKzEra+srCAnJyfhOTk5Oar2U/Jo6W9LV1cXvF4vXr58ibNnzyYzJu1BbYefP3/G0tISLl68GFuLRqMAAJPJhIWFBdjt9uSGpjha7sPc3FwcOnQI6enpsbVTp04hGAwiHA5DUZSkZqZ/aenvzp07cLlcqKmpAQCcOXMG379/R21tLZqbm5GWxmdiRrfbLHP48GFdn54CfIKakKIoKCwsxOTkZGwtGo1icnISDocj4TkOhyNuPwC8ePFi1/2UPFr6A4DOzk60trbi2bNnKCoq0iMq7UJthydPnsTs7Cz8fn/suHTpEioqKuD3+5GXl6dnfIK2+7CsrAyLi4uxFxcA8OnTJ+Tm5nI41ZmW/tbX13cMoVsvNkQkeWHpjzHULKP7x7IOiNHRUcnIyJDh4WGZm5uT2tpaOXLkiASDQRERcblc0tTUFNv/7t07MZlM0tXVJfPz8+LxePg1Uymktj+v1yuKosjDhw/l69evsSMUCqXqEv56ajvcjp/iTz21HX758kWysrLkxo0bsrCwIE+fPhWLxSJtbW2puoS/mtr+PB6PZGVlycjIiAQCAXn+/LnY7Xa5fPlyqi7hrxcKhcTn84nP5xMA0t3dLT6fT5aXl0VEpKmpSVwuV2z/1tdMNTQ0yPz8vPT09PBrpozo3r17kp+fL4qiSHFxsUxPT8d+5nQ6xe12x+0fGxuTEydOiKIoUlBQIOPj4zonpt+p6e/48eMCYMfh8Xj0D04xau/B33FANQa1Hb5//15KSkokIyNDbDabtLe3y8bGhs6paYua/iKRiLS0tIjdbhez2Sx5eXlSV1cna2tr+gcnERF5/fp1wr9tW7253W5xOp07zjl37pwoiiI2m02GhoZ0zy0i8o8In7sTERERkXHwPahEREREZCgcUImIiIjIUDigEhEREZGhcEAlIiIiIkPhgEpEREREhsIBlYiIiIgMhQMqERERERkKB1QiIiIiMhQOqERERERkKBxQiYiIiMhQOKASERERkaH8BLlkhrznCq94AAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 800x800 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# plotting the solution\n",
    "pl.plot(solver=pinn)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bf47b98a",
   "metadata": {},
   "source": [
    "The solution is overlapped with the actual one, and they are barely indistinguishable. We can also plot easily the loss:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "bf6211e6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "pl.plot_loss(trainer=trainer, label = 'mean_loss', logy=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "58172899",
   "metadata": {},
   "source": [
    "As we can see the loss has not reached a minimum, suggesting that we could train for longer"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "33e672da",
   "metadata": {},
   "source": [
    "## What's next?\n",
    "\n",
    "Congratulations on completing the introductory tutorial of **PINA**! There are several directions you can go now:\n",
    "\n",
    "1. Train the network for longer or with different layer sizes and assert the finaly accuracy\n",
    "\n",
    "2. Train the network using other types of models (see `pina.model`)\n",
    "\n",
    "3. GPU training and speed benchmarking\n",
    "\n",
    "4. Many more..."
   ]
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "aee8b7b246df8f9039afb4144a1f6fd8d2ca17a180786b69acc140d282b71a49"
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}