diff --git a/doc/conf.py b/doc/conf.py index 6b63d735..92c533ca 100644 --- a/doc/conf.py +++ b/doc/conf.py @@ -109,6 +109,9 @@ # NOTE: high order variational equations # take too long in debug mode. "oppenheimer_volkoff*", + # NOTE: the neuralODE II notebook + # runs a stichastic graident descent which takes long + "NeuralODEs_II", ] # Force printing traceback to stderr on execution error. diff --git a/doc/examples_ml.rst b/doc/examples_ml.rst index 2e8b78af..2ef5d064 100644 --- a/doc/examples_ml.rst +++ b/doc/examples_ml.rst @@ -28,7 +28,8 @@ Machine Learning notebooks/ffnn notebooks/torch_and_heyoka - notebooks/NeuralODEs + notebooks/NeuralODEs_I + notebooks/NeuralODEs_II notebooks/NeuralHamiltonianODEs notebooks/thermoNETs notebooks/differentiable_atmosphere diff --git a/doc/notebooks/NeuralHamiltonianODEs.ipynb b/doc/notebooks/NeuralHamiltonianODEs.ipynb index b5945284..e201f6d4 100644 --- a/doc/notebooks/NeuralHamiltonianODEs.ipynb +++ b/doc/notebooks/NeuralHamiltonianODEs.ipynb @@ -10,7 +10,7 @@ "\n", "*Greydanus, S., Dzamba, M., & Yosinski, J.* (2019). Hamiltonian Neural Networks. Advances in neural information processing systems, 32.\n", "\n", - "in that only the perturbation of the Hamiltonian is parametrized by a network. Let us consider the same system as [in the previous example](./NeuralODEs.ipynb), but this time using the Hamiltonian formalism. We will shortly summarize, in what follows, the obvious as to show later how to obtain the same symbolically and using *heyoka*.\n", + "in that only the perturbation of the Hamiltonian is parametrized by a network. Let us consider the same system as [in the previous example](./NeuralODEs_I.ipynb), but this time using the Hamiltonian formalism. We will shortly summarize, in what follows, the obvious as to show later how to obtain the same symbolically and using *heyoka*.\n", "\n", "Let us first introduce our Lagrangian coordinates $\\mathbf q = [x, y]$ and their derivatives: $\\dot{\\mathbf q} = [v_x, v_y]$. Under this choice we may compute the kinetic energy of the system as:\n", "\n", diff --git a/doc/notebooks/NeuralODEs.ipynb b/doc/notebooks/NeuralODEs_I.ipynb similarity index 99% rename from doc/notebooks/NeuralODEs.ipynb rename to doc/notebooks/NeuralODEs_I.ipynb index 8c513a42..1b4ef0f3 100644 --- a/doc/notebooks/NeuralODEs.ipynb +++ b/doc/notebooks/NeuralODEs_I.ipynb @@ -5,10 +5,9 @@ "id": "894ad88d", "metadata": {}, "source": [ - "(tut_neural_ode)=\n", - "# Neural ODEs\n", + "# Neural ODEs - I\n", "\n", - "We here consider, check also [Neural Hamiltonian ODE](<./NeuralHamiltonianODEs.ipynb>) example, a generic system in the form:\n", + "We here consider a generic system in the form:\n", "\n", "$$\n", "\\dot {\\mathbf x} = \\mathbf f(\\mathbf x, \\mathcal N_\\theta(\\mathbf x))\n", @@ -23,7 +22,11 @@ "\n", "Whenever we have a Neural ODE, it is important to be able to define a training pipeline able to change the neural parameters $\\theta$ as to make some loss decrease. \n", "\n", - "We indicate such a loss with $\\mathcal L(\\mathbf x(t; x_0, \\theta))$ and show in this example how to compute, using *heyoka*, its gradient, and hence how to setup a training pipeline for Neural ODEs." + "We indicate such a loss with $\\mathcal L(\\mathbf x(t; x_0, \\theta))$ and show in this example how to compute, using *heyoka*, its gradient, and hence how to setup a training pipeline for Neural ODEs.\n", + "\n", + "See also:\n", + "* [Neural ODEs II](<./NeuralODEs_II.ipynb>)\n", + "* [Neural Hamiltonian ODEs](<./NeuralHamiltonianODEs.ipynb>)" ] }, { diff --git a/doc/notebooks/NeuralODEs_II.ipynb b/doc/notebooks/NeuralODEs_II.ipynb new file mode 100644 index 00000000..8df04be3 --- /dev/null +++ b/doc/notebooks/NeuralODEs_II.ipynb @@ -0,0 +1,766 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "894ad88d", + "metadata": {}, + "source": [ + "# Neural ODEs - II\n", + "We here implement, in ```heyoka```, a standard traning pipeline for NeuralODE replicating this [torcheqdiff demo](https://github.com/rtqichen/torchdiffeq/blob/master/examples/ode_demo.py).\n", + "\n", + "We will be using the very same parameters and dynamics, of the original demo but only use a simple fixed learning rate stochastic gradient descent. Note that it is also possible to use more advanced optimizers such as those implemented in [pytorch](https://pytorch.org/docs/stable/optim.html) while computing the gradients using heyoka, but in this tutorial we keep it simple and just update the gradient naively.\n", + "\n", + "See also:\n", + "* [Neural ODEs I](<./NeuralODEs_I.ipynb>)\n", + "* [Neural Hamiltonian ODEs](<./NeuralHamiltonianODEs.ipynb>)" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "7030234e", + "metadata": {}, + "outputs": [], + "source": [ + "# The main imports\n", + "import numpy as np\n", + "import time\n", + "from itertools import batched\n", + "from copy import deepcopy\n", + "\n", + "# Import Heyoka\n", + "import heyoka as hy\n", + "\n", + "%matplotlib inline\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "markdown", + "id": "a2b09adc", + "metadata": {}, + "source": [ + "## Generating the ground truth" + ] + }, + { + "cell_type": "markdown", + "id": "7c4b5f34", + "metadata": {}, + "source": [ + "The dynamics we consider is a simple third order system:\n", + "\n", + "$$\n", + "\\left\\{\n", + "\\begin{array}{l}\n", + "\\dot x = -0.1 x^3 - 2y^3 \\\\\n", + "\\dot y = 2 x^3 - 0.1y^3 \n", + "\\end{array}\n", + "\\right.\n", + "$$\n", + "\n", + "which we implement in ``heyoka`` as follows:" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "9a6e3dcd", + "metadata": {}, + "outputs": [], + "source": [ + "# The symolic variables representing the system state.\n", + "x, y = hy.make_vars(\"x\", \"y\")\n", + "\n", + "# We now assemble the dynamics.\n", + "A = np.array([[-0.1, 2.0], [-2.0, -0.1]])\n", + "tmp = np.array([[x*x*x, y*y*y]]) @ A\n", + "dyn = [(x, tmp[0][0]), (y, tmp[0][1])]\n", + "\n", + "# For convenience we store here the dimension of the state.\n", + "dim = len(dyn)" + ] + }, + { + "cell_type": "markdown", + "id": "773923a2", + "metadata": {}, + "source": [ + "To generate groundtruth observations from this system we will use the following parameters:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "a244453e", + "metadata": {}, + "outputs": [], + "source": [ + "# This is the number of observations (i.e. the ground truth).\n", + "data_size = 1000\n", + "# This is the initial condition used to generate the observations (i.e. the ground truth).\n", + "ic = [2.0, 0.0]\n", + "# This is the time grid used to generate the observations (i.e. the ground truth).\n", + "t_grid = np.linspace(0.0, 25, data_size)" + ] + }, + { + "cell_type": "markdown", + "id": "a5012ce1", + "metadata": {}, + "source": [ + "We start by instantiating a ``heyoka.taylor_adaptive`` object that will generate our observations. These will be considered as ground truth. Note that in other settings this data may be observed from a real phenomena, rather than generated numerically. In that case there will be noise which is here not modelled." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "9466ccf5", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--- 0.16298365592956543 seconds --- to build (jit) the Taylor integrator\n" + ] + } + ], + "source": [ + "start_time = time.time()\n", + "ta = hy.taylor_adaptive(\n", + " # The ODEs.\n", + " dyn,\n", + " # The initial conditions.\n", + " ic,\n", + " # Do not operate in compact mode.\n", + " compact_mode=False,\n", + " # Define the tolerance\n", + " tol=1e-18,\n", + ")\n", + "print(\n", + " \"--- %s seconds --- to build (jit) the Taylor integrator\"\n", + " % (time.time() - start_time)\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "60333a38", + "metadata": {}, + "source": [ + "We are thus ready to generate the the ground truth using the method ``propagate_grid`` method of the Taylor adaptive integrator." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "fd5fd029", + "metadata": {}, + "outputs": [], + "source": [ + "# It is good practice to always set initial conditions explicitly\n", + "ta.time = 0\n", + "ta.state[:] = ic\n", + "# This is our ground truth (gt)\n", + "gt = ta.propagate_grid(t_grid)[5]" + ] + }, + { + "cell_type": "markdown", + "id": "e93e8ada", + "metadata": {}, + "source": [ + "Let us have a look at the generated observations." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "3776ae92", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(gt[:, 0], gt[:, 1], 'k.')" + ] + }, + { + "cell_type": "markdown", + "id": "d391ded5", + "metadata": {}, + "source": [ + "## Instantiating the neural ODE\n", + "\n", + "So far we have only generated the data we want to teach our Neural ODE to replicate. We now need to instantiate the Neural ODE system so that we can make predictions and compute the gradient of our loss.\n", + "Let us start with instantiating a feed-forward neural network using ``heyoka.models.ffnn``." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "0ff3f007", + "metadata": {}, + "outputs": [], + "source": [ + "# We define as nonlinearity a simple linear layer\n", + "linear = lambda inp: inp\n", + "\n", + "# We call the factory to construct a FFNN. Following the torcheqdiff example here we put cubes as inputs:\n", + "ffnn = hy.model.ffnn(\n", + " inputs=[x*x*x, y*y*y],\n", + " nn_hidden=[50],\n", + " n_out=2,\n", + " activations=[hy.tanh, linear],\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "53cad793", + "metadata": {}, + "source": [ + "We are now able to build a {class}`~heyoka.taylor_adaptive_batch` numerical integrator which will propagate the dynamics in batches as to leverage SIMD instructions:\n", + "\n", + "$$\n", + "\\left\\{\n", + "\\begin{array}{l}\n", + "\\dot x = \\mathcal N_{\\theta, x}(x^3, y^3) \\\\\n", + "\\dot y = \\mathcal N_{\\theta, y}(x^3, y^3) \\\\\n", + "\\end{array}\n", + "\\right.\n", + "$$\n", + "\n", + "And since we will want to be able to compute the sensitivities of this ODE we are first going to augment such dynamics with the first order variational equations:" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "52f24c4e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Batch size for SIMD use in integration: 4\n" + ] + } + ], + "source": [ + "# We decide on whether to use single or double precision. In this example it may\n", + "# Not be too important, but in other settings it can give a speedup when connected with batch and ensamble propagation.\n", + "# The single precision does effect, though, the quality of thegradient direction.\n", + "precision = np.double # np.single\n", + "batch_size_simd = hy.recommended_simd_size(fp_type=precision)\n", + "print(\"Batch size for SIMD use in integration: \", batch_size_simd)\n", + "\n", + "# We thus define the neural dynamics\n", + "dyn_n = [(x, ffnn[0]), (y, ffnn[1])]\n", + "\n", + "# We augment it with the variational one (only order 1 - i.e. gradient)\n", + "var_dyn_n = hy.var_ode_sys(dyn_n, args=hy.var_args.params, order=1)" + ] + }, + { + "cell_type": "markdown", + "id": "ba292011", + "metadata": {}, + "source": [ + "... and instantiate the variational integrator. For convenience we also instantiate the non batched version" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "223554ec", + "metadata": {}, + "outputs": [], + "source": [ + "# This is the batched version, which we will use for gradient computation\n", + "ta_var_b = hy.taylor_adaptive_batch(\n", + " # The ODEs.\n", + " var_dyn_n,\n", + " # The initial conditions.\n", + " np.ones((dim, batch_size_simd), dtype=precision),\n", + " # Operate in compact mode.\n", + " compact_mode=True,\n", + " # Define the tolerance (low tolerance is enough here)\n", + " tol=precision(1e-4),\n", + " # Single precision is enough here\n", + " fp_type=precision,\n", + ")\n", + "\n", + "# This is the normal version used for wuick plotting and visualization of a single solution\n", + "ta_var = hy.taylor_adaptive(\n", + " # The ODEs.\n", + " var_dyn_n,\n", + " # The initial conditions.\n", + " ic,\n", + " # Operate in compact mode.\n", + " compact_mode=True,\n", + " # Define the tolerance (low tolerance is enough here)\n", + " tol=precision(1e-4),\n", + " # Single precision is enough here\n", + " fp_type=precision,\n", + ")\n", + "\n", + "# We store for convenience the initial conditions in a numpy array (including the variational state)\n", + "ic_var_b = np.array(ta_var_b.state)\n", + "ic_var = np.array(ta_var.state)" + ] + }, + { + "cell_type": "markdown", + "id": "9de5ff0d", + "metadata": {}, + "source": [ + "Before starting the training, we define the details on the batch we are going to use in the generic step of stochastic gradient descent:" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "23c8bd9d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "This must be an integer: 5.0\n" + ] + } + ], + "source": [ + "# This is the number of initial conditions to use in one batch (M)\n", + "batch_size_ic = 20\n", + "# This is the number of observations to predict from each sampled initial condition (T)\n", + "batch_size_time = 10\n", + "# We check that the observation batch size is a multiple of the simd batch size\n", + "print(\"This must be an integer: \", batch_size_ic/batch_size_simd)" + ] + }, + { + "cell_type": "markdown", + "id": "e71863d4", + "metadata": {}, + "source": [ + "This helper function creates a randomly generated batch from the available observation:" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "9d01356f", + "metadata": {}, + "outputs": [], + "source": [ + "def get_batch(t_grid, gt, batch_size_ic=20, batch_size_time=10):\n", + " # We select the initial conditions from which generate predictions\n", + " s = np.random.choice(\n", + " np.arange(gt.shape[0] - batch_size_time, dtype=np.int64),\n", + " batch_size_ic,\n", + " replace=False,\n", + " )\n", + " batch_ic = gt[s, :] # (M, D)\n", + " # Assuming uniform grid and a non-autonomous system, all predictions will be made on the same time grid\n", + " batch_t_grid = t_grid[:batch_size_time] # (T)\n", + " batch_y = np.stack([gt[s + i] for i in range(batch_size_time)]) # (T,M,D)\n", + " return batch_ic, batch_t_grid, batch_y" + ] + }, + { + "cell_type": "markdown", + "id": "be2d039d", + "metadata": {}, + "source": [ + "Let us visualize what a batch looks like. First we generate one:" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "732e8dec", + "metadata": {}, + "outputs": [], + "source": [ + "batch_ic, batch_t_grid, batch_y = get_batch(t_grid, gt, batch_size_ic, batch_size_time)\n", + "\n", + "# We need the tgrid repeated as per heyoka API of the taylor adaptive batch\n", + "t_grid_b = np.repeat(batch_t_grid, batch_size_simd).reshape(-1, batch_size_simd)" + ] + }, + { + "cell_type": "markdown", + "id": "3d0af1cd", + "metadata": {}, + "source": [ + "Then we plot it overlapped to all the observations:" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "3ed00a54", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(gt[:, 0], gt[:, 1])\n", + "for i in range(batch_size_ic):\n", + " plt.plot(batch_y[:, i, 0], batch_y[:, i, 1], \"k.\")" + ] + }, + { + "cell_type": "markdown", + "id": "a9f583ef", + "metadata": {}, + "source": [ + "We initialize the network weights and biases." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "0d510306", + "metadata": {}, + "outputs": [], + "source": [ + "# We compute initialization values for weigths / biases\n", + "n_pars = len(ta_var_b.pars)\n", + "nn_wb = np.random.normal(loc=0, scale=0.1, size=(n_pars,))" + ] + }, + { + "cell_type": "markdown", + "id": "4e9b20f6", + "metadata": {}, + "source": [ + "And visualize the prediction of the starting random network." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "f6427200", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--- 0.015778303146362305 seconds --- to compute prediction over the whole batch\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(gt[:, 0], gt[:, 1])\n", + "for i in range(batch_size_ic):\n", + " plt.plot(batch_y[:, i, 0], batch_y[:, i, 1], \"k.\")\n", + "\n", + "start_time = time.time()\n", + "for batch in batched(batch_ic, batch_size_simd):\n", + " ta_var_b.set_time(precision(0.))\n", + " ta_var_b.state[:,:] = deepcopy(ic_var_b)\n", + " ta_var_b.state[:dim,:] = np.array(batch).T\n", + " ta_var_b.pars[:] = np.tile(nn_wb, (batch_size_simd,1)).T\n", + " sol_b = ta_var_b.propagate_grid(np.array(t_grid_b, dtype=precision))[1]\n", + " for sol in [sol_b[:,:,i] for i in range(batch_size_simd)]:\n", + " plt.plot(sol[:, 0], sol[:, 1], \".\")\n", + "print(\n", + " \"--- %s seconds --- to compute prediction over the whole batch\"\n", + " % (time.time() - start_time)\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "bb3058e1", + "metadata": {}, + "source": [ + "## Training" + ] + }, + { + "cell_type": "markdown", + "id": "db03cbec", + "metadata": {}, + "source": [ + "To train we need to first compute the gradient of the loss over the batch (M initial conditions and T times). Formally\n", + "\n", + "$$\n", + "\\mathcal L_{\\theta} = \\sum_{i=0}^{M}\\sum_{j=0}^T (\\pmb y_{ij} - \\hat {\\pmb y}_{ij})\\cdot (\\pmb y_{ij} - \\hat {\\pmb y}_{ij})\n", + "$$\n", + "\n", + "$$\n", + "\\frac{\\partial L_\\theta}{\\partial \\theta} = 2 \\sum_{i=0}^{M}\\sum_{j=0}^T (\\pmb y_{ij} - \\hat {\\pmb y}_{ij})\\cdot \\frac{\\partial \\pmb y_{ij}}{\\partial \\theta}\n", + "$$\n", + "This helper function computes the loss and the gradient over one batch. The gradient is computed rearranging the ODE sensitivities computed propagating the variational dynamics:" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "0679911a", + "metadata": {}, + "outputs": [], + "source": [ + "def loss_and_gradient(nn_wb, batch_ic, batch_y):\n", + " # We reset the batch_loss value\n", + " batch_loss = 0\n", + " # We reset the gradient loss\n", + " grad = np.array([0.0] * ta_var_b.pars.shape[0])\n", + " counter=0\n", + " # We process the batch (of the dataset) in batches for SIMD efficient processing\n", + " for batch_simd in batched(batch_ic, batch_size_simd):\n", + " ta_var_b.set_time(precision(0.))\n", + " ta_var_b.state[:,:] = deepcopy(ic_var_b)\n", + " ta_var_b.state[:dim,:] = np.array(batch_simd).T\n", + " ta_var_b.pars[:] = np.tile(nn_wb, (batch_size_simd,1)).T\n", + " sol_b = ta_var_b.propagate_grid(np.array(t_grid_b, dtype=precision))[1]\n", + " # The numerical integration on the simd_batch is done, we process its result \n", + " # accumulating loss and gradient on the predictions\n", + " for sol in [sol_b[:,:,i] for i in range(batch_size_simd)]:\n", + " # Here is the term (y-y_hat)\n", + " diff = sol[:, :dim] - batch_y[:, counter, :]\n", + " counter+=1\n", + " # Which is then summed sum sum (y-y_hat).(y-y_hat)\n", + " batch_loss += np.sum(diff**2)\n", + " # And the gradient computed as 2 sum (y-y_hat).dy\n", + " for dy in sol[:, dim:].reshape(batch_y.shape[0], dim, -1):\n", + " grad += 2 * np.sum(diff @ dy, axis=0)\n", + " # We then take the mean over the points used\n", + " batch_loss /= batch_size_ic * batch_size_time\n", + " grad /= batch_size_ic * batch_size_time\n", + " return batch_loss, grad" + ] + }, + { + "cell_type": "markdown", + "id": "4276d991", + "metadata": {}, + "source": [ + "Using the various blocks defined above the training loop takes the form:" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "ae139626", + "metadata": {}, + "outputs": [], + "source": [ + "# We reset initialization values for weigths / biases\n", + "n_pars = len(ta_var_b.pars)\n", + "nn_wb = np.random.normal(loc=0, scale=0.1, size=(n_pars,))" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "c3b6cfcb", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "iter: 2999, loss : 1.385e-04\n", + "--- 27.929445266723633 seconds --- to perform 3000 epochs\n" + ] + } + ], + "source": [ + "# We loop over the epochs\n", + "n_epochs = 3000\n", + "start_time = time.time()\n", + "for i in range(n_epochs):\n", + " # 1 - generate a batch\n", + " batch_ic, batch_t_grid, batch_y = get_batch(\n", + " t_grid, gt, batch_size_ic=batch_size_ic, batch_size_time=batch_size_time\n", + " )\n", + " # 2 - compute the loss and gradient on the batch\n", + " batch_loss, grad = loss_and_gradient(nn_wb, batch_ic, batch_y)\n", + " print(f\"iter: {i}, loss : {batch_loss:.3e}\", end=\"\\r\")\n", + " # 3 - update the weights and biases (learning rate here is fixed, we use a naive update rule which in this case works)\n", + " nn_wb = nn_wb - 0.1 * grad\n", + "print(f\"iter: {i}, loss : {batch_loss:.3e}\", end=\"\\n\")\n", + "print(\n", + " \"--- %s seconds --- to perform %i epochs\"\n", + " % (time.time() - start_time, n_epochs)\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "035475d5", + "metadata": {}, + "source": [ + "**NOTE**: For comparison we also called the [torcheqdiff demo](https://github.com/rtqichen/torchdiffeq/blob/master/examples/ode_demo.py) using the following command line 'python ode_demo.py --niters 3000'. This triggers a comparable number of gradient evaluations on CPU. The iterations done in `torcheqdiff` complete in **348 seconds** showing how on common CPUs, the use of ``heyoka`` may offer a significant speedup for NeuralODE research." + ] + }, + { + "cell_type": "markdown", + "id": "fa0f713a", + "metadata": {}, + "source": [ + "We are now ready to visualize the result of the learned neural ODE:" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "c0e33797", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAi8AAAGfCAYAAACX9jKsAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAACuZ0lEQVR4nOydd3zTdf7Hn99vVndKNxTKKHvIlCUIiKKo6Lk9PfE88fSnHiB6Ko5z3Cnnnafgqec5Eff2RBFFBUE2lA2yoaVQSlua7rRJvr8/Mpq2SQdt8v0m/TwfjzySfkfyTpN8v6/ve0qKoigIBAKBQCAQhAiy2gYIBAKBQCAQtAQhXgQCgUAgEIQUQrwIBAKBQCAIKYR4EQgEAoFAEFII8SIQCAQCgSCkEOJFIBAIBAJBSCHEi0AgEAgEgpBCiBeBQCAQCAQhhRAvAoFAIBAIQgohXgQCgUAgEIQU+kA++bx58/j888/59ddfiYyMZOzYsTzzzDP06dOn0f1+/vln5syZw65du+jUqRP3338/d9xxR7Ne0+FwcPz4cWJjY5EkqS3ehkAgEAgEggCjKAqlpaV06tQJWW7Ct6IEkAsvvFB56623lJ07dypbt25VLrnkEiUjI0MpKyvzu8+hQ4eUqKgoZdasWcru3buV1157TTEYDMqnn37arNfMyclRAHETN3ETN3ETN3ELwVtOTk6T53pJUYI3mPHUqVOkpKTw888/c+655/rc5oEHHuCrr75iz549nmV33HEH27ZtY+3atU2+hsViIT4+npycHOLi4trMdoFAIBAIBIGjpKSELl26UFxcjNlsbnTbgIaN6mOxWABISEjwu83atWuZMmVKnWUXXnghb7zxBjU1NRgMhjrrrFYrVqvV83dpaSkAcXFxQrwIBAKBQBBiNCflI2gJu4qiMGfOHMaNG8fAgQP9bpeXl0dqamqdZampqdhsNgoKChpsP2/ePMxms+fWpUuXNrddIBAIBAKBdgiaeLn77rvZvn07H3zwQZPb1ldd7siWLzU2d+5cLBaL55aTk9M2BgsEAoFAINAkQQkb/elPf+Krr75i5cqVdO7cudFt09LSyMvLq7MsPz8fvV5PYmJig+1NJhMmk6lN7RUIBAKBQKBdAup5URSFu+++m88//5yffvqJ7t27N7nPmDFjWLZsWZ1l33//PSNGjGiQ7yIQCAQCgaD9EVDxctddd/Huu+/y/vvvExsbS15eHnl5eVRWVnq2mTt3LtOnT/f8fccdd3D06FHmzJnDnj17ePPNN3njjTe47777AmmqQCAQCASCECGg4uU///kPFouFiRMn0rFjR8/to48+8mxz4sQJsrOzPX93796dJUuWsGLFCoYMGcJf//pXXnjhBa666qpAmioQCAQCgSBECGqfl2BQUlKC2WzGYrGIUmmBQCAQCEKElpy/xWwjgUAgEAgEIYUQLwKBQCAQCEIKIV4EAoFAIBCEFEK8CAQCgUAgCCmEeBEIBAKBQBBSBHUwo0AgEIQzdodCjd3hujV8XG1z/m1zKNTYHFS71tnstY8b7O/ap9q1HYDJIBOh12EyyJj0OiJc9ya9TITBed9gndc2Jr3crOF3AoFWEeJFIBCEDYqiYLU5qKqxU1ljp7LaeV9VY6eiuu7fzscOKqttzm1r7FRWO/e12hxeIqJWOLhFhW8R4sARQo0n3CImwtCECKojiHREuO5N3veubaKNeromRpEeH4ksC3EkCBxCvAgEgqDgFhYV1bXCwltkVNT7u47oqLFT5d7Pa31DMWJvtYBIo5Duch6HHWnk0XCeWkvQyRIGnYRBljHoZedjnYxRJ6N3PXb/bdA7/9bLMkZ97bpEewFptmNYorpSFZmGgoK1xoHV5sBqs7se26ly3bvFm9XmwFrjoMq1TZXNjndXL+f+DkqqbK37h/kg0qCjR3I0mckx9Exx3jKTY+iWFIVJr2vz1xO0P4R4EQgEOBwKVbbmiYi6osNBZY2tVkzUODwio6LaRlWNo87z+KMtBYMbvSwRadQRadB57iMMXn+717n+jjDoGFqwmAl7/4aMAwWZrUOe4ETmNS4hIblEhuwSGRJG12P3Or2uVqAYdDK61nofshbB4lmgOECSYdoCGDa96f18oCgKNXalgcDxJXS8RZH3NobyE8SWH+WELp2TUmID4WSprCG7qILKGju7jpew63hJHRt0skRGQhSZydFkpsTQMznGeZ8SQ1yEmF0naD6iw65AEGLY7A7KrXbKqm2UW22UVjnvy1y3cquNsiobZdXO+3KrjfLqut6Jyho7MdaTpNTksq8mhWxbh6C+B6Ne9giHq6SfuNf6EjIKDmQWJd3D5sRpRBqc20QYdUQZ9EQa5VoBUk94eP8d4Xps0LWwHsGSC/MHOoWCG0kHs3eAOb1t/wGhaE8zhVSN3UFOUQUH8ss4cKqMg/nlrvsyyqz+vTwpsaYGnpqeKTGkxplEfk47oSXnb+F5EQiCQI3dQbnVRmVBNjWnDlAc2YUiXTLlVrtTgFj9CBDvv612yqw1VNU4mn7BJrhWt5x5+tfRSQp2ncRcZQYf2ycBEOESDVFGvfOxD69FlNHrby/PhXO/WgFR3+vh3s/jkbDkwvyrAec1lIyD3xfO5/c33Rr8E3TRwbpCAUCxQ9EhdcSCluyx5NYKF3DeL54NmZMb2GLQyfRIjqFHcgxTvJYrikJ+qdUpavLLOHiq9v5kiZX8Uudt7aHCOs8XY9J7PDXe4iYjIarlAlUQNgjxIhC0EEVRKK6o4VSZlfwSK6fKqsh3HXxPuW6WyhrKq2sFiNXmqCMY0hWJubZawXAmGPUyMSY9MSY90SY9sSY90Sad83GEnmijnpgI5/ooo94jHMy2fEb/7w0kl9NVJyk8Y3yTJ+6aiSmhS3ATLbV0gk7IdHoU6ns6EnoE1w4t2tMGn5MkSaTGRZAaF8E5PZPqrCupquFgfhkHT5V7xM2hU2UcLaqgzGpj2zEL245Z6uxj0El0TYx2hZ6inaImOZYeydFEm8SpLdwRn7Cg/WDJdR6EEzJ9HnBr7A4K3IKk1H0lWOX12EqBS5xU21vm/Uij0CNcwCkY5hneoCT9XKqjOhLtEiExJh0xJgPRJp1TgNQRJvo6YsWoP8OrzsP7GpyIJMVOZOlRSMo4s+c8U7R0gjanO0Mhi2c7T8ySDqbNV8frojV7Avw5xUUYGJrRgaEZdcOXVpudo4UVHPT21rhCUeaafJILdrI1P42lu+rmSXUyR9Tx1IzukUjPlJg2sVWgDUTOiyDsKbPaqFz3Fkkr7kdSHDiQWdp9Lj9ETvF4SvJLrRSVV7foeeOjDCTHmEiJM5ESG0FyrImUWBPJsSbMkQaP+Igx6YnPW0fMR1c0fJKbv4bu49vonTYTTeZSzK57gj7DpNQ2wZLr9Cgk9FBPuGjRHg19To7NbyN9Pdvze/6i8/18ZJ/IwfwyCv38jkf3SODGUV25cEDamQt/QUBpyflbiBdBSKMoCjlFlew8buFwQbmXGKnyhHHiqvNZbZrp8XoA2BSZcdYFDSpb9LJEkkuQuIVJspcwcYuT5FhTy0o+hWBoHK2coAWNo4XPqYnf0unyag6eqs2p2XOilDUHCzwl9EkxJq47uzPXn51Bl4Qodd6DwCciYVcQljgcCkeLKtiZa3HejlvYmVuCpbKm0f0Gy3l1hAuAXnLw4CgjtozBdYRJhyhjYHI+tBQCAKdQyZys/onIjTldfRsETaOFz6mJ/JsO0UZGRCcwoluCZ/Xx4ko+3JjDhxuyyS+18tLyg7y84iCT+qTwu9EZTOid0vqydkFQEZ4XgSZxOBQOFZSz67iFHcecQmVXbgmlPkotjTqZPmmx9EqNITUuokEoJ1UpIOrlIdrwemjhylUgCGVa4cWssTv4YfdJ3l1/lNUHaqua0uMjuWFUBteO6EJyrClQlguaQISNhHjRJn4SZu0OhYOnytiZa2FHrlOk7Dpuoby6YVMzo16mX8c4BnaKY1C6mYHpZnqnxjYdw9ZamEQgEJw5bfB7PnSqjPfXZ/PJ5mMe761BJ3HhgDR+N7oro7oniP4yQUaIFyFetIdXgytFktk06DG+1p3PzuMl7D5e4rP7aoRBpn9Hp0gZkG5mULqZnikxZ97bQXg9BILwoY1+z1U1dr7efoL31h9lS3axZ3nPlBhuHJXBlcM6Y44U3X+DgRAvQrxogmqbg/35pRw8sJdLf7oQmVo3b/2E2SijjgGd4hiYbmZgJzODOpvpkRSNXjShEggEQWJnroX31mfzv625VLg8v5EGHZcN7sSNozM4q3O8ugaGOUK8CPESdOwOhd3HS9jhDv0ct/DriVKq7Q7GyLv4wPhUg33e6f0Ssf0mMTDdTPekaJEwJxAINEFpVQ1fbsnl3XXZ7D1Z6ll+VmczvxvVlWmDOxFpFAMm2xohXoR4CRrHTlfw8cYcPt50jLySqgbr4yL0nJtWzQt50+t4XlQtExYIBIJmoCgKm46e5t11R/l2R56nOWVshJ6rhnXmd6Mz6JkSq7KV4YMQL0K8BJRqm4Mf9pzkw405rNp/Cvc3KDZCz5Au8bWhn3QzXRIinUlvImFWIBCEMIVlVj7ZfIz312dTXZTjmYLerUcv0fyujRDiRYiXgHDwVBkfb8zh083H6nSxPKdnItefncGUAamNN24TCbMCgSDEcWx+G2nxbCQc2L1mlLmb3/12ZAadO4jmd2eCEC9CvLQZVTV2vt15gg825LDhcJFneUqsiWtGdOa6ERlkJIofqkAgaAf46DHjQOYy/SvsLHPOTpIkRPO7M0R02BU0j0YGFe45UcKHG7L5YksuJVXOxnCy60d5/cgMJvVJFpVAAoGgfeGju6+Mgy9/25FlFb08ze9++jWfn37NF83vAojwvLRXvPquIMkwbQFlA25g8bbjfLghu874+fT4SK4/uwtXj+hMR3OkikYLBAKBijSju6+v5ncRBpkF1w/lwgFpalgdMoiwkRAvjePH9TnZ8SKHq+MBZ6fJC/qncv3ZGYzrmRSYeT8CgUAQajSz+MDd/O7tNUfYkWtBluBvvxnEDaMygm5yqCDCRoLG8eP6TLUdR0pO5/qzu3DlsM4kxQg3p0AgENShmUNNIww6rh7emd8M6cQjX+7kw405PPTFDk6VWpk5uacYPdBKhHhpRyiKwrpDRXy7ppLHFKnOpGUHMg/ccDFDBvQXPyqBQCBojBZM19brZOZdOYjkWBP//ukAz/+wj4IyK49fNkAk87YCIV7aAadKrXy6+RgfbczmSGEFAFW6GcwzvIEOB4qkQ542n6EDB6hsqUAgEIQfkiRx75Q+JMWYeHzxLt5Zd5TCcivPXTuECIPo1HsmCPESxuw+XsILP+7nhz0nsTmcXpZoo47LhqTz25GPIMfOhqLDSKLvikAgEAScm8d2IzHGyJyPtrFkRx5F5Rt4dfoI4iLE4MeWIhJ2wxBFUXh/QzZPLN5Ntc2Z2zI0I57fnp3BJWd1JNokNKtAIBCoxZoDBfzxnc2UWW306xjH27ecTUpchNpmqY6oNmrH4qXcauOhL3bwv63HAZjcN4X7L+pLnzQxf0MgEAi0ws5cC79/ayMFZVY6d4jknVtH0T0pWm2zVKUl52/RZSyM2JtXymUv/sL/th5HJ0s8dHFfXr95hBAuAoFAoDEGppv5/P/G0jUximOnK7n6P2vYfqxYbbNCBiFewoRPNx/j8pd+4eCpctLiIvjoj6P547mZonJIIBAINEpGYhSf3jGWgelxFJZXc/2r61i575TaZoUEQryEOJXVdu7/dBv3fbKNqhoH43sl8c3McYzolqC2aQKBQCBoguRYEx/+cQzjeiZRUW3nDws38r+tuWqbpXkCKl5WrlzJtGnT6NSpE5Ik8eWXXza6/YoVK5AkqcHt119/DaSZIcuhU2Vc8fJqPt50DFmCORf0ZuEtI0kUzeUEAoEgZIgx6Xnz92czbXAnbA6FWR9u5fVVh9Q2S9MEtOykvLycwYMHc8stt3DVVVc1e7+9e/fWSdZJTk4OhHmhg48Biou3HefBz7ZTXm0nKcbIC9cPZWzPJJUNFQgEAsGZYNTLLLhuCEkxRt5afYTXv/mFyNw13DB1IpK5s9rmaY6AipepU6cyderUFu+XkpJCfHx82xsUitQboFhz8fP89fgIFq09CsCo7gn8+7dDRZmdQCAQhDiyLPGXS/tzbtlSzv31r+h+VXD8KmO/dD76ETerbZ6m0GTOy9ChQ+nYsSOTJ09m+fLlapujHpbcWuECoDiQv7mH79dmAXDXpEzemzFKCBeBQCAIE6SS40za9zfP+BYZB9LXs6ksOKqyZdpCU+KlY8eOvPrqq3z22Wd8/vnn9OnTh8mTJ7Ny5Uq/+1itVkpKSurcwgYfAxR1OBgYWchbvz+bP1/YF71OUx+hQCAQCFqDn+P+U+8soai8WiWjtIemWq326dOHPn36eP4eM2YMOTk5PPvss5x77rk+95k3bx5PPPFEsEwMLgmZKJKM5PVFtiPz1z9cRscuKSoaJhAIBIKAkJAJklxHwNiR+eFkNGteWcOiP4ykc4coFQ3UBpq/bB89ejT79+/3u37u3LlYLBbPLScnJ4jWBZYTJPCf2JnYFOfH5EBGuWQ+HbtkqmyZQCAQCAKCOR2mLQDJNbBR0lEw8RkkczqHTpVz1X/WsDevVF0bNYCmPC++2LJlCx07dvS73mQyYTKFX2nwz/tOcc9HWykqH8nnppd4+txoRg4fgSwGKAoEAkF4M2w6ZE6GokOQ0INUczqfD61k+hsb2J9fxjWvrOH1m89mZPf2288roOKlrKyMAwcOeP4+fPgwW7duJSEhgYyMDObOnUtubi6LFi0CYP78+XTr1o0BAwZQXV3Nu+++y2effcZnn30WSDM1hd2hMP+Hfby4/ACKAgM6xfHyjRPpmti+Z14IBAJBu8Kc7mmNAdDRHMknd4xhxtub2HT0NDe9sZ5//3YoUwakqWikegRUvGzatIlJkyZ5/p4zZw4AN998MwsXLuTEiRNkZ2d71ldXV3PfffeRm5tLZGQkAwYM4JtvvuHiiy8OpJmaIb+0ilkfbGXtoUIAbhyVwaOX9ifCoFPZMoFAIBCoTXyUkXduHcWfPsjihz353PHuZp66YhC/HZmhtmlBR0yV1ggnS6q47MVfOFliJcqoY96Vg7h8iAgRCQQCgaAuNruDh7/YyUebnDmecy7ozZ/O6xnys+zEVOkQQ1EUHvxsOydLrPRIiuaru88RwkUgEAgEPtHrZP5+1SDuntQTgOeW7eOrbcdVtiq4CPGiAT7ZfIzle09h1Mn896bh9EyJVdskgUAgEGgYSZK478I+3DnRWX06/4f92OyOJvYKH4R4UZnjxZX8dfFuAOZM6U2vVCFcBAKBQNA87pzUk4RoI4cLyvlya/vxvgjxoiKKovDAZ9sptdoYmhHPbeN7qG2SQCAQCEKIGJOe2891njte+HE/Ne3E+yLEi4p8uDGHVfsLMOllnr1mMDo5tJOtBAKBQBB8bhrTlaQYI9lFFXyedUxtc4KCEC8qcex0BX/72hku+vOFfchMjlHZIoFAIBCEIlFGPXdMcOa+vPDjAapt4e99EeJFBRwOhfs/3U55tZ0RXTtwyznd1TZJIGifWHLh8ErnfbD3V/O1BWHHjaO6khxrIre4kk82h8+YHH8I8aIC723IZs3BQiIMMv8U4SKBQB0RkLUI5g+Et6c577MWBW9/NV9bEJZEGnWeyqMXfzqA1WZX2aLAIprUBQtLLhQdJFfuxAVvHKCi2s7j0/rze+F1EYQLru84CZl12po3SdYiWDzLOUVXkp1D6YZND+y+llznSd9rci+SDmbvQInrhNXmoNruoNrmcD62OaixO3AoCnaHgq70BH0+HFNn4rsi6dh8xc9URXbErig4FAWHQ8GhgE4Gg05GL8tEVeVx1qfjGuxbMGMTsjkdvU7GqJPR6yT0stSw8Vgjtjf7/36mn5VA01TV2Jnwz+WcLLHy5OUDmD6mm9omtYiWnL81P5gxLPA6wHZE4lL7DI52vyrkvliCEOJMT07BFiCW3Nr9wHm/eLZzKJ3r9e0OhaoaO5U1diqr7Z7H9tPHGPLVLCRq93V8NYtF+ZkUyklUVrv2qXHt4/rbanPQt3Ir85R6eQGKnRv/+QGrbf2aNHuMvIsPjHX3lxQ7z364lHWO/me0759e+qzBvjpZwhxpID7SQFykgfgoAyMcO7nbh+1792xD18OMOdKAOdKAUe/Hsd4asSjQNBEGHXdP6smj/9vFS8sPcO2ILmE7XkaIl0BT7+AsozBP/wZ5F92BLMJFgsYItpBo4X6KomC1OagqzMG8eFatJ0FxoCyexc/2s7AYkj2ioarG0UBIdLZsYraPE/H//fsT1tj7U1lj95t86EsEyDhYunJNkwLiBLHYTRI6qdbxbFNkDtpSGmxr1MkY9TIGnYTO5Qkpoyv2GgkdtfvbkZETe9BXF4ssScgy6CTn9g5FocauUGN3YKvpjr2y3r6KTA4NB+zZHQpF5dUUlVd7lv2Knv/zYfvNXxaQx8+eZalxJromRtMtMcp1H02myUKfep9VfbHYJMJro2muPbsL/1lxkOOWKj7YkB22OZVCvASaooN13buATnKQ7jgB9FTHJkHwaekBvw09Gcri2Vg6nUt5RCqV1TYqqu2uW+1jqeQ4V62chVzPi/Hg1mROKAkN9ql0PXYo/jwJDl75YlmTIiINA3/ycSLeUpaAhZoG20cYZCINOiINOuz6HjjKJWQvEeBAZtCgIfSJ6kiEUefZNtKoI8LguumdYuTw4afJXP8IkmJHkXQUn/cMn591DUbXeqMrfOP3IiPL6jzxK3aQdOimzef9YVc1/RkBZFXW3fey+awedhMOh4LN4RI5doXKGjuWyhqKK6qd95U1WCpqWHbkIaYcmoeMAzsy/4m9G2N0F+Iqqim12lAUOFli5WSJlQ2Hizwv6+uzQrHzy4YNxPSdRLfEKOKjjI3YLbw2Wsek13H3eb146IsdvLziINefnUGkMfy8LyLnJdBYclHmD2wQ35ZaEp8WhDYtPeD7yGlw51MU6ZIprbJRWlVDaZWNMquNEq+/u5Vu5onTDzZ4yuurH2lUSDhPak+1eD+ANApZbZpZR4DYkbkjcSEVkalEukSD595Y+3ekQaZ/3v8YsfMJZMWBIskcHfM0ZQNuINKoq7OvSe9DSGQtqiMCmDa/ZSdTSy4UHYKEHmf2e2zN/gF6bbtDobiimpzTlRwtLOdIQYXzvrCcqsIcFtvuaCAWx1kXkEciAN2TohnZLYGR3Z23zh0inXk3bZFrIwgK1TYH5/1rBcdOV/LIJf2YESINUFty/hbiJQis/OhfjN39N/SSwylcWnqAFWiHlnpQGhEiJ0miqKKa066wQFF5NacrqulcvIl5pQ81eKozFRLuk1ORPpkoo44ol4CIMuqdfxt1dJJO89cj19d6XnB6Mb6cuBTJnE6koXZb730jXc+n3/aueiKitSKgnVG1/i1MS+9FUuw4kPms0318qpzH0cIK8kqqGmzf0RzByO4JTIs7wPkbZjR8wpu/hu7jg2C5oCV8vDGH+z/bTmK0kVUPTCLKqP1AixAvGhIvB/LLuOSFVXSwneKpCdFMHjtaHGBDlSY8KBXVNo4XV3HCUsnx4kqOF1cRlbua24/MbvBUjQkRf56MG2NepyoyjdgIPXERBmIj9MRG6Ikx1T6OjTDQ89jndcIh1ov+hX7Ezeh1TXRGUNuLIQgefj4rS2UNm48WseHwaTYcLmT7MQs2h/N76Ot7qUg67DO3oe/QJehvQdA4NXYHv332MwyWw1w8YRw3XThWbZOaRIgXjYgXu0Phqv+sYWtOMef2TubtW85uWPYoUJfmelJ8eFAcyDzQ5X12lsVwvLgSS2XDHA1/QuSG6NdwxHYiIdpIQrSRDlHG2sfRRnrmfE7n1Q95BEiLvXVnKiSEABF4UVFtY2t2MesPF7HhcBE9jn3GE9Lr6CUHNkXmIdutLNFfwHl9U7h2RBfGZib6zhESSb7BJ2sRiqsaz45EzcXziRj5e7WtahQhXjQiXl75+SB///ZXYiP0fH/PuXQ0R6pqj6AejXhSKqptHMgvY//JMvbll6I78gv3n7yvwVPU96DEmvR0jI+gozmSTvGRdDJHMKZkCcO3P46ktDBsKISEQGNU2xz8uu9XDu/dwc8FMSw7pqfUavOsT4+P5JoRnbl6eGc6d4hyLhRJvsHHz8WWfM9OTR9LhHjRgHjZf7KUS174hWq7g39efRbXjBBuVU3h58d9f+f3WFcYwbHTlXU29+VBcSDz+YSlJHbqTidzJB3jI4iLMPh/PSFEBGGG3aGw7Vgxn2cd439bj1Na5RQykgTjeiZx0wADF3w3uU7BgkjyDQKHVzq7L9ej/LdfEt1nkgoGNQ/RpE5lbHYH936yjWq7g/P6pnD18M5qmyTwosxq4+D2zQyuV8Iu4+DYoV0cc3lSkmKM9EyJoXdqLL1SBnCk5Gl6rHPmkiDpkKfN5+pho5r3ouZ0cbAWhB06WWJYRgeGZXTg4Yv7892uPD7elMOag4Ws2l+A7eAupvgozabokPg9BJKETKeXy+sYZ1NkPjxg4NY+KtrVhgjxEgAWrT3K9mMW4iL0zLtykMhzCSY+YutF5dVsPOKM2W88UsSu4yUkO4pZXa+/iB2Zy88bzz09etErNZaE6Pr9Lu6E0ZcLD4pA4INIo47fDE3nN0PTySmq4JNNOfy8qQy7VWrgsSyLykD9coowxpzuDM+5EvAdksxDNbfy7cZyrp5UgznKj4c4hBBhowBw2Yu/sP2YhScuG8DNY7upYkO7xCu2rkgyq/s9ynMFo8jKLm6waecOkfwpfi3XnHgWGVHCLhAEArtD4eB3L5O5/hF01Cb5fm+awr1T+nDDyAwxmDaQuMLVjg7dmfrWIfaeLGXmeT2ZM0Wb7heR86KieDlhqWTMvJ+QJNjw0Pkkx5qCbkO7xEczQO/mW71TYzjb1Xjr7G4JdIqP9OwnPCkCQYCx5FJ6fB/fHo/k1W1WDuSXAdCvYxxPXDaAkd0TfO4jKpTajqU7T3DHu1nEmPSsun8SHRp4ltVH5LyoyA+7TwIwLKODEC5BwFJRw3e78jiwYQkP1cth0UsOHjsngmETJpMaF+H7CUQuikAQeMzpxJrTubYfXDnRwXvrs/nX93vZc6KEa/+7lssGd2LuxX1rKzJFhVKbM6V/Gv07xrH7RAmvrTrE/Rf1VdukVtFE1ypBS/neJV6m9E9V2ZIwwpLrzJ635AJOV/SSHSe4deFGRjy1jPs/285XOZHYlXruZ0nH1HPP8S9cBAJB0NHrZG4e240Vf57EDaMykCT4attxznv2Z15afoCqwmzfk8Zdv3/BmSHLEvdc0BuAhWuOUFhmVdmi1iE8L22IpbKGtQcLAbhAiJe2oV4ey6ZBj/HAoSEcKij3bNI3LZZpg/twWvdPkpY/ULdDrPCqCASaJCHayNNXDOKGkRk8/tUuNh09zT+/28u+dQdZ4GPSuKhQaj3n90thULqZHbkWXl15iLkX91PbpDNGiJc2ZMXefGwOhZ4pMfRIjlHbnNCn3oRkSXEwdNsTVFgXEB+Vxu9GdeU3QzvRMyXWtUNPGHyxyGERCEKIgelmPrljDF9tO87TS/aw3hKPvV4lIJLO+ZsWtApJkrjngl78YeEm3l57hBnje4RseoMIG7Uhy1whI+F1aRsqT+6rO8EWZx7Lw2NMrH7gPO67sI+XcHFhTncOiRPCRSAIGSRJ4vIh6fx070SumDiSR+23YVOcpycHsvCitiGT+qQwuEs8VTUOXvn5oNrmnDFCvLQRVpudFXtPASLfpbVYKmpY8MN+Lv8gr0EeiyLpmDZxHNEm4TQUCMKNaJOeBy7qy22zH+eBLu9xffUjjK1awJO5I3A4wqowVjUkSWKOK/fl3XVHyfcxSTwUEOKljVh3qIgyq42UWBODO8erbU7o4JWMqygKH2/MYdw/fuL5H/axrzKO5yLuwiG5vqbuXiziCkwgCGu6J0Xz7K1TmXjhleSRyJurD3PX+1lU1djVNi0sOLdXEsO7dsBqc/DyitD0vojL17bAksv+9T+QhsR5/Yf6nqoqaEi9ZNy3OszmyeMjAOiTGstd5/XkkkEXI5feKfJYBIJ2hiRJ3DEhk47mCP78yXa+3ZlHful6Xps+om73a9EPpsW4vS83vr6e99dnc+ekTFJiQ6sqUzSpay1Zi1AWz0JSHNgVif2jnqLvxXcF/nVDHR+DEW2KzCT7v/ndBWOYMb6H6LwpEAgAWHeokD8u2kRJlY3uSdEsvOVsuiZGi34wrUBRFKa9+As7c0t4/rrBXDFU/Rl8LTl/i7BRa3BVw7i7uuokhT4bHxX9CJpD0UGfybgfXJnM7RMyhXARCAQeRvdI5PM7x5IeH8nhgnKufHkNu37dI/rBtAJJkhjVPRGALT5GqGgdIV5ag48TsOTuRyBolB9PxmKnYTJu58yBKlkkEAi0TM+UWL64cywD0+MoLK/mH+990+D4izj+toihGfEAZGWfVteQM0CIl9bgHjvujehH0CjlVht/+mALt355nLk1M7AjknEFAkHzSImL4KM/jmFin2T21qT47Kotjr/NZ1hGBwD2nCilotqmsjUtQ4iX1mBO59Skf3j6ESiiq2tDvKqJLJU13PTGehZvO45OlkibcBv2mdvh5q9h9g4RqxYIBE0SbdLz+vQRTDx7CHNtMzzHX9FVu+V0io8kLS4Cu0Nh+zGL2ua0CFFt1Eq+4DzetC5gWucqHr7pEvHD8aZ+NVHk3WQVjSYuQs+bvz+bEd1ck2QTuqhrp0AgCCn0Opl5Vw7iBfPtjPvhLHro8vnz9RcxdJAIO7eUYV3jWbIjj6zs04zukai2Oc1GeF5aybLdJ8kjkc7Dpgjh4o2P1v53l79I/+hSPrp9TK1wEQgEgjNAkiRmTu7J2KFnscbejz9+lUd+aWg2XFMTd+go1JJ2hXhpBQVlVjYddSY6iZEA9fBTTfTatAT6dQxCCbtAIAh7JEnib1cMpHdqDKdKrcz6YCs2u6PpHQUe3Em7W7JPE0qdUwIqXlauXMm0adPo1KkTkiTx5ZdfNrnPzz//zPDhw4mIiKBHjx688sorgTSxVfy0Jx9FgYHpcXSKj1TbHG2RkIlSL5lZkXSkdx+gkkECgSAciTLq+c/vhhNt1LH2UCHP/7BPbZNCigGdzBh0EgVl1eQUVaptTrMJqHgpLy9n8ODBvPjii83a/vDhw1x88cWMHz+eLVu28NBDDzFz5kw+++yzQJp5xny/Ow+AKf3TVLZEe+wsi+FJbq+TzCyqiQQCQSDITI7h71edBcBLyw/y068na1d6FQ0IGhJh0DGgkxkIrZLpgCbsTp06lalTpzZ7+1deeYWMjAzmz58PQL9+/di0aRPPPvssV111VYCsPDMqqm2s2l8AiJBRffIsVUx/cwNFleM5nDaaFy40E9eptxAuAoEgYEwb3IlNR4p4e+1R7vloG9/MHEfnw5+KDrzNYFhGB7bmFJOVfZrfDA2N47Smcl7Wrl3LlClT6iy78MIL2bRpEzU1NT73sVqtlJSU1LkFg5X7CrDaHHRJiKRvWmxQXjMUsNkdzPxgC0Xl1fTrGMcLd1xCXL9JQrgIBIKA89Al/RjcJR5LZQ1/WfQ9iujA2yyGdY0HQsvzoinxkpeXR2pqXS9GamoqNpuNgoICn/vMmzcPs9nsuXXpEpyy2+W/5gNwQb80JEm0sne7Zt9c8gsbjhQRbdTx8o3DiIswqG2ZQCBoJ5j0Ol66YSjmSAOVJ/d5Rrd4EB14G2LJZZS0izQK2XOilMrq0JjcrSnxAjQQAu7sZ38CYe7cuVgsFs8tJycn4DYCHC4oB2CIK1O7XZO1yDlk8e1p3LrpMq7VLefpKwfRPSlabcsE7R1/+Q6+lrdk2zNZLggKnTtEMf+6IRx2pIkOvE3hOnYnf3Y1qyNmcpX0E9uPFattVbPQVJO6tLQ08vLy6izLz89Hr9eTmOi7eY7JZMJkMgXDvDrklTj7CXQ0h9YY8TanXj8XnaTwd8MbyN3vUdkwQUhhyXWW1ydk1oYYfS1rybb+Jg77Wg7N3/ZMlrfkvQhazaS+KVw9aRRzV85gnuENdDhEB9761D92o/C0/g3e33clo3qMVdm4ptGUeBkzZgyLFy+us+z7779nxIgRGAzaCT8oiuIRL2lx7Vy8+OjnIuNwumbFQSL8aK2gaK7IgCbFgSLJVF30HDaHQsz39yK5lh07Zx4FaeMZ8tUsJGrzHRxfzWLJyQQuXj/L+R31Wg4KMkqdZW/si+LWXxtu+3mOmSu31Fu+eBbrSlMZs7zuayqLZyNVnoYfHm+90BG0iFnn9+L87ZdwTuFZPDTaxGWTxon/pzd+enGdPLobaOfipaysjAMHDnj+Pnz4MFu3biUhIYGMjAzmzp1Lbm4uixYtAuCOO+7gxRdfZM6cOdx2222sXbuWN954gw8++CCQZraY0xU1VNucH3pKXPC9PpoiIRMHcu2BHIRrVuucqdBoprdBuXQ+dgfolsz2CIrj4/9Ojd1B19UPIeFAQWbjoMc4HD+aa1Y1LSbsX83ij0sreLX6QXSu5ZLiwLjkHowouKPKkuKg46q5/L3mLl4yNhTVWb98y6UGH2K7HjIOTuxYjuxj290bvufq+ssVBz98/xVj6y2XFDv27/+Czh29cL2/j47Gcf22ukKHxbPBn9Dx9xkJ/GLQycw8rxf3flLBY9sNnDc1lRi1jdIS7sHCXgLGpsgsz4/hPkXRfC5nQMXLpk2bmDRpkufvOXPmAHDzzTezcOFCTpw4QXZ2tmd99+7dWbJkCffccw8vvfQSnTp14oUXXtBcmXSexel1SYw2YtLrVLZGXXaXx7Ko5lb+pn8DvSRcs0GhjbwciiRjnfo81ho7cT/c5xQayOwY9iRWm53h259AxoEDmeVd7mRSzst1RIb9q1k8sNLOM8X3eASF8+Q8GwlHHUGR9vMD4C0ycDBs+xO8XXMX1/kQGfXR4aBr+Q50hrodQHVSw46geslBclwE9iqp1i7Ajoyp+zk4jr1f5zUcyNQRS65lXYech2NXw23jeo/HcbjucjsyZSkjsJ9+r+5rKlIDG2Uc7N+0DKme0EGx41j2WB3RpiyejZQ5GQ7+KLw0Z8DlQzrx0vIDHCooZ+Hqw9x9Xi+1TdIO5nTn92jxbFDsKJKOR223stsay7HTlXRJiFLbwkYJqHiZOHFio+2GFy5c2GDZhAkTyMrKCqBVreekK2SU2t5DRsBzy/byg30Scq/zeXpCtNPjIg6ibYv3CareSUy5dD5Wu4Lp23s84mPjoMcos9qYuO8pj/hYmDCbdfIQ/lMws47nwvDNbAz1RMWAzY8CCrJrmYyDidkvIdc7CetwEHdqkw9B4UN8+BEZwzIScOTJTYoJRdJx3VXXoix+v04FiSLJoChIXtsi6Xj8/26BgxmeAzOSDt20+Tww7AbIstVZLk+b79yv3rKbh10FmeUNls8edj1kVTd47n8Mmw5Zujong5qJjyL//GQdmx3IdOh7Lo6D9QSQD6EjKXb+9eY73GN5po5wbNJLIwCcAxxnnd+LWR9u5dWVh5g+tpuogPRm2HTInAxFh5ASerD73SPg6vfSrsVLuOLJd2nnybpbsk/zw558ZAlmXDIOkoVTtkU04S1xxHaidO2bHq+IA6eakOt5OQzeXg4cDN/+OPXFx/TC+WyuuQudsWnPhb9lDqS63glJ5oILL0f56f3a8Af+BIVzGfVExq2/vQ4OJjUpJqRp8+kzbAKwoMHy+tt6PH9eB+Y6otrf8pZs24zlUkIPIszpEJfY4P39adh1kGWtI3SODv0z3bb8o46gsSkyh06VIRsbemmUZY/V/o/dgiZzsvNv4Y3xcOlZnXjxpwPszy/jzV8OM/v83mqbpC3M6Z7vybCMYrblFJN19DSXD9H2d0eIlzPghKWde15cJ9i3vi8BJK4a1pkeQrg0jR8PiiLJ7BnxV/JLrJy792/IOLAj8U/bDfxZ9z6SS0x4Cwc3LfFyzBjfA2W9fMZCQz7/MfjhiTon4THDpkBMMwWFr2WNiYzWCg+oc2Cug6/lLdm2JcubKXR6mNOhS3odQVM06RmmykNw/PhSk14aFDusfwXWvii8MV7oZInZ5/fmrvezeGPVYX4/thvxUUYRcvPBsIwOvLX6CFkhMGFaUkJpjGQzKCkpwWw2Y7FYiIsLwPRiSy7//WIZb/0q89vzxzDr/HYWQ/XKmbArEo/Yb+POOU9o3sUYdHwkuyqLZ3lCO0q9sIizH4VSm9iJnxNUPVoiPpi9wyWaZjctKnwt8+RY+BAJvpY3d5mgLr7+R1mLvESNzDcptzP15Cv18mtkJKnu98rzuUO7PlE7HAoXv7CKX/NKuXtST+5LXi/GBvggt7iSc/7+E3pZYsfjFxJpDG5OZ0vO30K8tIR6J+6ssx7n7Ktmt+1raBlLrrMZXb34vXzPznZ5QPSLd1IsMj91uZNJOS/59Jw0hYJUT5hIoEjg3bcCmi8+QAiNUKXe5+HY/DbS1/c4K5qQed02ldv13zTcb+xM4Y0BvtuVx+3vbKaHsZgfdXfX7b7rFnnt/HuuKAqjnv6R/FIrH98+hpHdE4L6+i05f4uwUXPx0YxtxM4n4Pxr2s8XXvR08Y8lF0fBAfZboNdXtaW/kp9k1wb48ZZI9UI1TJvf/LBJS0IpLQmjCNSh3uchD78Zep4PRYeQE7pzzvESHB99Wy+8JCOt+XedPCkWz4aUAVBT3q48MVP6pzIwPY7YE7uQ5IY5ROI45uxkPyyjA0t35ZGVfTro4qUlCPHSXHycuCWlnZ24EzJRJLnhFUt77OniCgvZO/Tg0LqvyFz3MDIOeilSw6ocSTlzD8qw6TDw6oYiRIgPAXg+YwkYaAYuW+Asr3Z7Y+w+vDGKHV6fDCjtyhMjSRJzLujNQwsPNwzJttfjmA+GdY13ipej2h7SKMRLc/HR0EeRdEjt6QtvTufQ6KfouuZh9JLD+f7bY08Xr/wVCYlMxauyR1JQgDrtnVrrQREiRNBchk139oVxeWMGHSrE8b8ldcvOwXeVUjv4jk3qk0Jyeg/m5s1wjjERYwMaMCyjAwBZ2cUoGm5WJ8RLc3E19PFc1Sgy8rTn290X/o2K8fxkXcAtfRVuv+L8dvX+rUXZbF/zPcM33euZaCqj1FMqeAqa63hVWuNBEQhagpc3ZuzQzqC84HXc8lOllLMBihLDPowkSRJXDUvn8cWTOJ02ntcuTRA5XfUYmG7GoJMoKLNqulmdEC8tYdh0thiG8Y8PvsUe351Phl+ttkVBpcbuYOnOPIpIZMA5o8CcpLZJgcUVGqqM7crGHz/lnD1/5ezmJN1KOrh1GdRUCA+KQH1c3hh74UF+PFDK5DU31qlSUiQJ6dNbaC9hpKmDOvLE17tZlqvneIcRdDJHqm2Spogw6OjfMY5txyyablYnN72JwJscewfWOfqji29nJyFLLrvXfI2x/ASJ0UZG99BuIlebkLUIZf5AeHsaphcHM273k3UO+HWQJDw/JbenpfNw6D5eiBWBNjCno+txLlOmXELNxfNdXYyd5fiKd6K4O4xkyVXN1ECTGhfB2V2dx68lO06obI02GeoKHW3RcL8X4XlpIe4Gde1qmrSr9Hew4mC1SeKrTg+g112gtlWBwZKLkrMOvprpyQvwFRry0Fj+ikCgQSJG/h76XEDW1s18tCKLZ5Tn627QDsJIFw9KY8ORIpbsOMGM8e0ob7GZDOvagYVrjpCVrd2kXSFeWoh7KGNqexkN4KNE/DfH/gmW6eF3UPNKxG0SSYar3oQuI/3nrwgEWsWczrAJ6XTrPQjHfxfUKa9uD2Ekd+goK7uY48WVdIoXoSNvhmXEA7D7eAlVNXYiDNobQCzCRi3EPZSxY3vxvPgsEXf1RAgjHMXHcHzViHBpEBpaAAOvEIJFENIkdOwO0+qHkSDcw0gidNQ46fGRpMSasDkUth+zqG2OT4R4aSHtbiiju0TcmzDriVBw/BAfvFX36rMOkg6mvQD37ISbv3Z24gyzK1FB+0UefjPyPTv5YeSbzLb9qWEnaMUOu78MOwFzyVkdAfhGiJcGSJLEUJf3ZYtGQ0dCvLSQvPY2lNGcTs3Fz2NXnF8VJcx6IuT++F86vDqMGy2v0mBQhiTD1QtrxYo5XSThCsITczrnX3wVN1x9tWvOVj2+e8g5GiRrUfBtCxBTB6YhSc6k1NziSqc4O7wy7ETamVLb70WIl5DH7lDIL7UC7cjzAmxPuYxzrAu4XX4CZm8PD6+DJZesJW+StvJ+TxVRnV5MIjQkaIeMGTqY/aOeqr1Y8V4ZZiGkFK/Q0cHvXnaKs7enhZ1IO1PO6hwPwK95peoa4gchXlpAYZkVu8PZTTU5xqS2OUFjS3YxeSRi7zoOydxZbXNaT9YilOcHMmzDPXWmOHu48GkRGhK0W/pefBcrpv7EX2t+17DILszy3S45qyNpFDJuz19rc/vCTKSdKR1dF+j5JVa0OL9ZiJcW4M53SY41ode1n3/d1pxiAE8MNKQ5thnHVzORGstv6f8b4W0RtGsmjx7KkAt/3zCEJMlQfipsTuxTB6bRXc7znecTRiLtTEiJc16gV9bYKbPaVLamIe3nDNwGlFU5P0BzpEFlS4KIJRf56CrSKGRIl3i1rWkdWYtQXp/c8EDlJszyeQSC1jDt3LP5uuuD2DwhJMk5+fzTW8ImtJISF0F0xz4+RFp4FSWcCVFGPbEmZzeVkyVWla1piBAvZ4Dkt2NZmOHqMvuC9S+sNs1kWOFitS06cyy5KF/NqjvZ2U39xFyBQADA1On3c3viQu6snolz5Gj4lVB37d6LubYZnnJxcRFTi9v7kl9apbIlDRFN6s4ApTnzbUIdV3M6yas5XeTSe6HvlJD8UZ/Y9TMdfYaK5NrEXEF44ppRhSEaasr934dpN9nWYNTLPDl9Co8vOIhc/7DnDq2E+P9sSJd4/vTLJPKTx7Hw8kTRJduLlNgIDp4q51Sp9jwvQry0hHbicAF8NqcL1YNVzcaFpH4/u+EKSYZbf3DOIRKoR3PFxZnc7/4C1rwIzRqoKcOYu6D/FbViBhq3rR0InvT4SG64aBL2JU/WnUgtyWDQ5tC+luAOh/+Sb6Sq81hNdpNVC7fnxd2cVUsI8SLwjbs5nbeACcU4sCUX3Tf3+MhzcXlchHBpOW0pNloiLuqh4LyeaOq++U/ogDX/Rlnzb9d+7r0bsa2+4AlTUTNx5BAWbpjDTQXPo5cczv+t4oA3zg/58QGdO0SSFGOioMzKzlwLI7qF+dDZFuDuZ5avwZwXIV7OAA1WjbU95nSYtgD7V7PQ4UCRdEghGAfes2EZ/XyFi65+U4SKoOVC5NAKWPUcjZ3QmysqWiwu6iE18/5Mn7dZgsoleFjz73pPIsG4e6HHhLAQMpIkccHv7uO3zyXwofxwbYsBd+5L5uSQfY+SJDGkSzw/7DnJ1pxiIV7cWHIZXLOdNKycLO2ktjUNEOKlBbSbRF0XJf1/y5SPoZt8krfmXEtkUle1TWoRNRsX0mf17IYrJJ1zoGJ7wJILOeudj+O7+hUibSk4misqwvrXpCiw6lnnzVc4KgRP9J07RDF9RBK6LfVWhGg42ZuhGU7xssXVFqLdk7UIFs/iEsXBRSaJ1/JmAUPVtqoOQrycAe3B8QJwvLiSPBKxRqSFnHBpPFw0P6QPtA3w9p4UHwVAic+gcutnRG56uU7ww58QEYIjgNT3zrjFzKj/C7nv4ZTxY7FvkTxdqYHQDCfXw533sjW7WFU7NIGrWAOvYo3bLC+A5Y+a+r4K8dICTBUnGCPvQnFkqm1KUDheXAkQkuPiLbm/Yg7HcFE9oVK1fwWmbYuQvLwnACgQVb91hZ/7sEeSYczdzuaDNRXOJNP697u/dOXeeOd4Sa4rlYaXK60KeXmLmQv+CufMPNNnCjqmhAzWDnyMs3c86cx9kWSkMXeqbVarOauzGUmC3OJK8kurSIltP+NfGuCjWEOHQ3PeNSFemkvWIoYunsUHRgf2MgmyykM6Sa055J4OXfGyee1PTFJ8zCsKxXCRS7DY9i9Ht+b5OkLF+xBb562GkjJpjrhozX1zSl87D4dRdzgP0N77Qd1lrnvJj+BpsahZ9qjz+YfeFDIhpeG/mcXV+9O5qPxL/qhfgrTm37D2pZBO3I2NMNArJYZ9J8vYml3MlAFptRcKIfCZtCk+ijVsiow1JoNoFc2qjxAvzaF+zxOUkE9SaxJLLrqjv5CGg/T4bmpb0yJKTh5lQvZLDU/g5z8WOp+X68BZvOsH4ja9gIyCzkuMqa5NJBnGzYEeE4MjLoKBOd23Hf5s8yF4pEPLYdXz4G/8hC82v+W8gfMDPv9JTXtjjHqZ6WO6cvnyJbVh2TBI3B3SJd4pXnKKmWL9vjZ0IskhLcxajKtYg8WzQbFjV2Qest3KHSSipeCgEC/NIYx6njQLV7LWDYqD60wSqyseBQaobVWzWb38G6ZKPjKTOg0LvjEtxZKL5funid31LjJg9hYsgVIsZyJEtCI41Ka+4Ok+HkbcWitovLwzzfLKKEqtN+bcP2v2f3xJp8q6PV8g5I+JQ7p04ONNx8g+sh/W1+Z8hIMwazHDpjvfb9EhfvvJSTYURXJlqZUeyTFqW+ZBiJfmEC49T5qDj2StcXv/BpbrQ+KH69j8Nhf++lDDFVr+vCy5VB9Zy7GspXQ7+glmr1WtFiySDMNuhu4TID5DCJFg4C1ovLwzkiEKtryLsvnNpkWM2xuj0ZwYU2ovHMjIdXKEQrtpnTtpt/zEPpDa0cWqP1zfY8m8FoqKyNdYl10hXpqDy42mLJ6NpNixI6MLt4oVNz68TLKivWQtn1hykRbP9jG/SLsVRtaf52Nc/hhGaIVLVoKxf3LmjBRnOxe5hYoQJupTT8xICd1g2WM0q25x2aPO7c6ZFUADzwBzOqcmPkPi8gfCpmldz5QYZAn2WJNRImVPmgCg7YufAJPiaVSnrS67Qrw0l2HT2WoczjPvL8ER352Ph12ttkWBwYeXSZF0SKHwwy06iBQiFUbVNgc737mPoUffaHn+ijvMkzrQ+XeXkXWv9AXa5pxZMPBqWP9K80JKyx5zbq8xEZo68Y88uMPIUwWzwqJpnVEv0yk+kmOnEzky5mm6r33Y6XFp54MaU2PdwxmF5yVkscV0ZJ2jPz1kLeVctzH1vEw2RUa55DkMIfDDrcnJQh8CFUabtu+g6H8Pc4Ht5+aHhbzzUoQ3JfQxp8OUv9aGlA4tR1n1nO+p5yiw8lmY9nzQzWyK8zOj0RXWWxjCIZZuidEcO13JpoRL6T77Muf7aOe/N89kaeF5EWieYdPJTzmHWS9/zjHSWDXid2pb1DSWXPQ/PaHpCqOqGjvL33yEC4+/jCzRjOxNCcbfKwRLOOMOKXUfjzTiVizfP03crncbfjU2vwkomkviHTpkBPb1Ur2BjaEbYslIjIIDkF1UAeY+mvpfq4V7vtFJjc03EuLlDGgPHXZLjamsc/THHGlACoWmIf5CRhqpMDp0qox1r9/Db6s+btrbMvwWZ4KtdzhIEP6Y0zFf8xLVBh3GrW83XK/BJN7ETt15JX4WM4pfQC+5yorPfzxkv7fdEp0Jx0cKK1S2RDske8JG2vK8yGobEEqEwCm8zSi32gCINobIePjjWxuKSo1cAW46UsQPL/2paeEy6Fq4Z7czvj7wipA9AQhah3HSA41fIC17FFYvCJY5TRI56haesV3nvHRQHPDDY852CyFIRoIzJeBoYbnKlmgHd7dhrU2WDop4efnll+nevTsREREMHz6cVatW+d12xYoVSJLU4Pbrr78Gw9RmobSDsdI1RTmMkXfR1VCstilNY8lF+eGxhuJSAyGjn349yfo35nCb8nnjwmX8fXDVa6rbK9AA5nSkC/7ahIB5zNnWQANM6WzjQf2HtScTd9KuRuxrCd2SnJ6Xo8Lz4iHVlfNSarVRWW1X2ZpaAh42+uijj5g9ezYvv/wy55xzDv/973+ZOnUqu3fvJiMjw+9+e/fuJS4uzvN3cnJyoE1tklCInrQJWYsY/pVzFIIjFEYhFB2sW9boRuWQ0eoDBex57wHulL9o/LujoTCApjm2GfYtBZ3zYEpFAUQlQWQ8VBY3/28AuxV6X6Td6qxzZjrHQCx7TPNJvB3txyFMGtZlJDjFi6WyhuKKauKjjCpbpD4xJj2RBh2VNXbyS6vomqiNgpWAi5fnnnuOW2+9lRkzZgAwf/58vvvuO/7zn/8wb948v/ulpKQQHx8faPME9XGPQnDlj8ihMAohIdNHwyx1Q0a/5pVwcNFd3Ckv9S9cBl0b0vkBLcaf+GjO473fwvFNbWvPyn9A+gjoPVWbwuacWUgDr6byx2eI2P627yTehG7q94DR4O/vTIky6kmJNZFfauVoYYUQL4AkSaTGmThSWMHJEmv7EC/V1dVs3ryZBx98sM7yKVOmsGbNmkb3HTp0KFVVVfTv359HHnmESZMmBdLUFhHWQaNQHIVgTme5aRLnVf1YKxTOuk41ey0VNRT99zfcJG32L1zG3weTHw2qXW2CJdcpJAoPgGwER3XtvbfgqL9s+0dQuE89u/2Ru8l5q8/Kf0DqWdDtHOd7SOwBXUYF/ztlTifyyhc4XmGl04EPG65f9rj6PWDM6Wwf+gQDsx6rTdoN4UnT3RKjyS+1cqSwnMGurrvtnZTYCI4UVmgqaTeg4qWgoAC73U5qamqd5ampqeTl5fncp2PHjrz66qsMHz4cq9XKO++8w+TJk1mxYgXnnntug+2tVitWa20iUUlJSdu+iTq0g7hRCI5CsBcfY2LVT3WFwvaP4LxHgn5QVxSFTa/cxnmOEBQubs9IjbWuKHHfF+yFgz+pbWXwOLndefOm10Uw4f6ge2U6TfsLjuc/9JGkqI3u110m3864tfH8Xr+U20N80nRGYhQbjhTV5r201+nSXiR7er1oJ2k3KKXS9UttFUXxW37bp08f+vTp4/l7zJgx5OTk8Oyzz/oUL/PmzeOJJ55oW4P94DbZEc4Ju64mdY6vZiHjcLqDNd5dMv/IbjpqJOa+57OnOM/SSI6LFoRLfe9JZREc+QWKD6trVyiwf6nzljIQLnsheCLGnI5t7D0Y1jzf8BLq0HLnQEgVSYwxkR4fyW2VS2pzdEK02667XPpoYYVnSG27nC7tRaqr4uhke/G8JCUlodPpGnhZ8vPzG3hjGmP06NG8++67PtfNnTuXOXPmeP4uKSmhS5cuZ2ZwE0TonWXDVTUtGHcfigybzrv5PVmycjUDBg7h0WEXqG1Ro5Qf2Yjiq7NukL1F5aeO0nfns/6Fy8jb1REubrFyfCsU7oecdcG3IdzI3wmvnxdUEWPsdR6s8ZGgu+o55yRrlQXCuUkl6I5p4yKiNbhzOkrzj8Cedj5d2oW7y+6p9uJ5MRqNDB8+nGXLlnHFFbWzZZYtW8bll1/e7OfZsmULHTt29LnOZDJhMplabWtziDY5xYu7B0o4Ux7hbFLXxZCitimNY8mlx1YfgkGFMulvf17N1f4yonpdCBf/I3jGuAXLjk/CT6z0mQadhkLFKYhK9qomavxve8UprIYOVOdkYT66tG2CwG4Rkz4Crl0U2O9cQiYKko/qI21UHiVn9MeeE/rddjvFRwJgKjkSevl/AcJdLt1uPC8Ac+bM4aabbmLEiBGMGTOGV199lezsbO644w7A6TnJzc1l0SJnU6P58+fTrVs3BgwYQHV1Ne+++y6fffYZn332WaBNbZJok/PfVVFtx+FQkOV2kAOjdYoO1q1ycBPkMuniimpObf8eRfJRUj/kRvjNy8Ex5Nhm+PEJOPxzcF7vTKgvPqDpx5HxEJXQqq7DOiDKdcOSCzkboKLII3QqjQmUHtpAUu6yljfAyt0Ez/cPbNm7OR3pgidRlj2qycqjzJ69mfvzDOYZ3kCHO8wyP+RO9CmujrLbKhJRDGK6NGizUV3Axct1111HYWEhTz75JCdOnGDgwIEsWbKErl27AnDixAmys7M921dXV3PfffeRm5tLZGQkAwYM4JtvvuHiiy8OtKlNEm2s/XdV1NiJMYXvdAUlVGqqEjJxIDlLuj1IQT/A/G/lRm6X/OS6DP5t4A04thm+uAOlcF9w0sqT+kCvqeCwgmxy3nsLDl/LEntBn4u0cTIzp4O57qTxSCByMh5hU5a3D8vuH+lYtL75YmbZo1BlCVx48JyZKAUHkbYs9PHaj6taeTQg3cxn4MoPAUI0NzApxilesm0dqJr2HJFL723306VTNDhZOihn3zvvvJM77/RdOrdw4cI6f99///3cf//9QbCq5UQYZGQJHApUWG1hLV6iq04yRt5FvC0E+xwE2SFmszvYu/EHfDviAiykLLko718PJ7fTrFmPzaHH+ZDcq1aAeN8bTc4QmNo9UAKJS9jEDISY8x8ASy65O36maP37DChZ5edz9mLVs877AAkYeeL9KFsW+vis1a08iqk6yTzD69QOFAmBHlE+iDTqiDXpKbXaON7jGjJnT2n306VTXMMZLZU1VNXYiTCoPzYmfM++AUCSJKKNzi91mdWGxrNBzpysRdy0bhY3Gx049sqQpeEM+6KD9bwuOK/4gngQX3OwkOHW9b5/TYOuCZwdS/6MsuHV1gmWHudDXCdAcYZytOIZ0RLmdNLH3UD6uBs4fvQAxz59gLNLfmi8a3IgBYw5neox92Bc83xDGwxRbf96zaXoILoGv8XQzBFJjjNRespGfomVzMz0kLO/rYmL0GPSy1htDk6VWumSoOL3zIUQLy0k2qXIKzQ046FNcXXYlT0ddjWeYZ+QiR2p7kEzyHHpFRu38ohute+VfQIT7rQ9Pxid5UjLhUuX0dBziqvpmpha3VI6de1Jp3s/Y8O2HcR+8Tv6Kkf8i5hVz0JEXEDyUEy9z4O1PhJ0d3+pnlcsjDrtJseYOHSqnFNl2gmTqImzy24E2UUVnCyp0oR4EVOlW4Ill7G6XaRRSFm4Vhw11mFXgyhxnfjCPr5ueD2I3XXtDoXS/av9hxK6jGzz16z8e++WCZcuo+Hi55wTq2/9DibcK6ZWt5KRgweR/uAmlsX9pvHUjmV/CcyAwoRMFF+H7zUvqjcQ0ZzO5kGPYVNcdklyyI6/SHbleJzSUI6H2mgt70WIl+aStQjmD+S5ykdZbZqJec8HalsUGNwddr3R8NWTtSiHK+RVDbvrBukAvu1YMaNtG3yvHHRtmx+4S/7el4jKk00Llw496gqWker3AQk34iIMTL5nISvTbm5cwLxzVdu/uDkd+2hfeYQOdS80hk/nGdt12MF5EfTDY85jZ4ghxEtDUjxddrVRLi3ES3NwhVLcHgmdpNBn06MhOfK9Sdwddl1fDTvaLne0ntxft68EBNVTtHXnLq4IUsjo5LOjia080XiuRVQSzPgJZm0RgiUI6GSJc+9Y0LiAKdgDCy9r89fWD7zSd03goeVt/lrNpZuhmAf1H9Ym7bobu4XYsVKIl4a4q7AKy6tVtsSJEC/NwUcoRVZUvsIJJMOm89Wk77i++hEe7PK+dpN1gfLorjgaHMGDVypdfWRtUEJGx168lJTSPY0Ll5G3w/0Hw7sSSINIksT42xewosMV/gXMkZ/hxyfb9oVryn174FY9r5pYSLLmqHox0VYku07UIuelFnOkAYCSyhqVLXEixEtz8BFKcSBrNpTSFjhiO7HO0Z88EtQ2pVEqauw0KBAOYql0tnt4W32G39JmXo89m1aQfmqVf+FiiHWGh4LZwVdQB1mWGPl/r5OlO8u/gFn1r7YVFa6Ouw1R78JKSuyJvcHvUbthZ38Iz0tD4iKc4sUixEsI4QqlIDmdoTZF5qdeD4W1S97kmuNktWl7jpO94ABygys9JSgH71OlVnaUx/s+WQ29qU1eo7SqhpSvb2rc43L3+rD+LoYK0SY9kTO+4VdHZ/8b5fjJjzoTzOkwfo7v0JFaJdPmdBYlzgn5pF0hXhqSRiFj5F3IpcfVNgUQ4qX5DJsOs3fwTu+XGGddwMYOl6ptUUCJrc5njLyLWGu+2qY0SlVsN+yKOld6+/NLyZBP+RYWxdk+FracxZ+8RYJS4n+DC54MuRNDONO/UxzLhr3kI5TpYlXbzh+Sekz07Wis8eMRDAIHu1zBM7brcCCFbNKuW7wUlVuxOxSnx+zwypDL3WkzshZx6U9T+MD4FM/m3qiJz1OIl5ZgTudU8kjySKS8OkxLpQGyFjH+64l8YHyK14pu1sQX1R810R353D6u7tVnkEqlj52u5Dw5y/fKiqJWP/+hU2VctP9x/16XITeqOstG4Jtbpp7Dz5Kf2VontzlHObQVhmhteV6AnhElPKj/sLZ5ZAgm7SZGm5Bc3dTL170J8wfC29Oc9xo+HgYEV8GK5On9pWji8xTipYXEeCZLh3eTOq19Uf1hKD/Blbpf6l59BqlUujjviP9Ko6jW5wr9/PW7dJDKfa+M6BC8YY+CFhEbYeDkkFn+c1/2fdd2L+YvaXf3l233Gi2ku5QX8km7OlnCHGkgjUJil91XW7ARgkKs1Wi095cQLy0kyjWcsVw0qdMEESVHVDtQmk5sClilUVF5NWmHPvPvdfmd+lPWBf6ZOuUS9ip+cl9yN7XdCyVkotTvywSqNquLSuutWii3LYmPNNBdzqs7VRo0fTwMCBrt/SXESwtxD2MM27CRRr+o/qiK66ZaqXS51U/WfRtUGn2z4wRD2Ot7ZXSaKIfWOOYoA0eSz/O98uCPbScszOlIY+7ysUK9iqMOHbsz1zYDuydpNzSnMZujjBx2pDXsZKzh42FAcBWsKF4FKzUXP6f65ynESwuJMoZ52KjeF9WuaLtJnRN1SqUP25IDVmm0e+Ny0mSL75UZo1r9/ILAk3Z2I6MD9i5tuxfqf4Wm8l6SY0x8bJ/Eb6yPU3P+3+DWZZruFeWPDlEG8khk01mPeSpNQ1WItZph01Fmbee31Y8wzrqA032vV9siMZixpXg8L+EaNgIYNp2yzhO4bf7HHHGk8vNZN2JS2yY/RJQe8V8qHeADTEzVMf+VRq3wjJRU1TD45BdI/n6dQ2444+cWBI8BZ0/iwNJO9MJHaWnh/rZ7IX95LypVHMVF6vmtfgV/072G7gfF6cmdpuHJ9H6IdzVl25p0GWfPvsZ5TEno0f6Eiws5vjO7TYOxVNZQUllDSmyEuvao+uohSJRLvITtVGkXUUkZriZ1iZRVaVeoKR0yVQsbGa1+PCOtrDRae7CQzuT5edFY6HNRq55fEBwMOpnD8ef6Xim34eWAxiqOpJLj/E3/Wm0uWogmucZHGQE4XVHtFCzdx7db4eLG3WVXC43qhHhpIe5qo7CdKu1CJ0ueEJmW36vJIKNW2Mje6DS+M2dSnxQGdPZTrZQucl1CiW7xftxn+75tuxcpPur7K99GvYZaTNFBdPXlVAgmucZHOU/UxRo4UWuF2hEB6p8ThHhpIe5qo4pwTdj1wh0i07J4iSk/qlqHXUeAxItRL9PBpPO9sn7lg0DTJHQd4HtF4d627feiJRIyPYNdPYRgkqs7bGSpEOLFTVyk85wgPC8hSLTrhF5jV7Dawjh0ZMllnH43aRRqOmykT+qpWlmm3W8b1TZA9iNefJXFCjRL4rDL8Cs326rfS3xX32Gj+Iy2ef6WYk7nw9R7Q35EQIdor7CRABBho5DG7Y0ANH1SbxVZi2D+QJ6rfJTVppnE7vlAbYv8Ykrs4uyw6330DlKH3SJHjO8VbdCgDocfYSw8LyGFZO7M5shzfK/UtVHeiwYb1e1LD/0RAe4TdbHwvHhwD2fUwmRpIV5aiE6WPAKmJBzFi6vDrvskqZMU+m56VLPJdhEVec4Ou95H7yB12M12JPkuhW2LK15TtO/lRj/LBZqlLGFQYF/AV28mULVRXYb+dMiPCHAn7GrBy6AVhOclxImLcIkXDXyAbY6PDruyol7Dq6aQTx9SrcNuN31h4IYy+otIBTBSJQgM6YYy3ysqTrXNC5jTQWON6jI4EfIjAjq4E3ZF2MhDnBAvoY37AyypUv8DbHN8XMU5kLWbbJeQ6SOnIDil0omyn5PS3iWtf3K/YaMwzrMKU+Ji/YQX27JcWmON6nRJvUJ+REB8pNPzUl5tp9omwrWgrXOfEC9nQG3cLwzDRq4Ou3i1gl6WOVfjyXbqlEqXyWbfK3Z80nr3eNfRvpdn+Fku0Cxmox93mcPadi+isUZ1kUldnCMC8EraDbHOtLEReo9ntbiy2vmbPrwypEJfbY0IG4U47nIxLajPgDBsOszewQf9XmacdQFrzZeobZF/ig7WxtXdBKlUeo++r48GeQAK5Gxo3ZMP/q2f5eq35Ra0jIi4ZN8rovwsPxM01qjOfYGH2y8aoLYCgUSWJWLdBRpZ78D8gfD2NOd9iCUftxXulAmLBi7chXhpKZZchtl3kEZheOa8uDGnU5QyijwStT0KISHTWdHgTZDc08WGZN63+xm+11rM6XDZv2tDeJLs/DuErlwFTqRguAI15nnpYD/FPP3r1Bb8KyGXsAvOMEkahSSvuL82FzAEk4/bitomdeqf+4R4aQmuEuI7s+9htWkmXY9+prZFASU2QvtN6jCnsyryfFVKpY06mY9sEwPXY2PYdJi9E27+2nkfYrNhBC4qCvwsb6OEXdCc58VccTTkE3bB6UHqLuch1W9REILvpS0Q4iUU8VFCPOXQvLBW38mOAsbIuzCUn1DbFP9Ychlf+aMqpdIxJj0Z8qnAtmYXM1VCH9noZ3kbJuxqzPMSmdY75BN2wZkicNiRhhIGHYPbAnfCbqnVFtgmnc1AiJfm4quEWMVSxICTtYiLll3AB8anmH/id9qN8RYddH4O3gTpqigmQo8Zf2WwrRvOKAgjHH5KbdsyYVdjnhfJ3Jm/yrd7ddnVhVzCLkBshIE8Elk/8C+eIoZQfS9tQW0uE5SqnPPpZ2qYoAHuEmIvAWNHRheO6tvlZZJcokB2x6szJ2vvB+uao9JAwBzf4vRYBJBoo/j5CJpBVJKf5W2YsKsxzwvA8qiL2FzYiZfGV5Mx+DzoHHpDRd0n6y1JlzF69rXOi6KEHto7DgYJo14m0qCjssaOpbLG08hPDYTnpbn4KCH+b9zM8PwS+/AyaTbGa05nVbe7GxYz/PB4wENHMRFCvAg0gsY8LwBX8RNfmh4jY+Pf4I3zteu9bYQ6laUihAtoZ7K0EC8twVVCvPP89xhnXcAXBKjSRG18tRvXcIy3rMPAhp1ugyC2Yk1CvAiaQTASdrXmebHkcnf5i7VJuyFaoaOlWT5aQSu9XoR4aSku9Z1HYvj2eXF5mRQvL1PNxc9p9orD3qG7j34rge+yGy3Ei6A5BCNsZPAz80otz4uKuWhtiSdBNRzn2J0hbm+UEC8hSFh32HUzbDqOWdu5vvoRxlkXYOnnp2maBog1GVCjy25MhJ5iAjhZWiBoLjXlfpar5Hlx5aLVQcPeW3945tiF64XqGWDWyIgAIV7OALfyrKwJ75kXuvjO7DKcRR6JqqvsxkiqPobcoKdE4Lvsxpr05DiSfecanNwZ0NcWhBBB6vPie7lKnhdzOt92f9Cr2kiG8x/XrPfWH3Ea6muiFbQynFGIlzMgxitcoHa5WKAJhR+vLrmnamGjGNnq28mz6l8hF98XBIgg9XnxvVy9aqMjGVfxjO06ZwdsxQE/PBZySbuxHs9LGHvZW4g78iDESwii18keARPWX2pLLuP0e5yjEDT8PqNNOtQIG8VGGDjsSPMx1RraZL6RIDwIUp8X38vVqzZKkwp5UP9h7eyxEEzaFQm7DdFKl10hXs4QTyw0XL/UrlEIz5Q9xGrTTMx7PlDbIr+YK3JUCRuZI50NrL6Xz/W9gWhUJ4Cg9XnxvVw9z0taTW7IjwjQSn6HlmhXYaOXX36Z7t27ExERwfDhw1m1alWj2//8888MHz6ciIgIevTowSuvvBIMM1tEXDh/qX2MQjhry2OavWKKSOulSity94Fts6N3QF9HIGgSDXpe5KTMkB8R4Pa8VNU4sNrszmPg4ZWaPRYGg3ZTKv3RRx8xe/ZsHn74YbZs2cL48eOZOnUq2dm+Z78cPnyYiy++mPHjx7NlyxYeeughZs6cyWefaWsIYlhXHIXYKISIxAy+dIwP+nBG94+4qsYe0NcRhDhB6vPik91ftt1rtBBTYgZzbTOwE7ojArwbUVZvfBvmD4S3pznvQyx/p60wuyZtdy3ZrKqIC7h4ee6557j11luZMWMG/fr1Y/78+XTp0oX//Oc/Prd/5ZVXyMjIYP78+fTr148ZM2bwhz/8gWeffTbQpraIOp0Xww0fTeocyNq9YrLk8hvdqqAPZ3SLF7u688kEWicYYSNfjSUB1ryo2gnGHGngY/skbuRvcOHTcOuykJuMrpMlYk160igk5vt7ay/qQjB/p63IzPmM1aaZ/M0yV1URF1DxUl1dzebNm5kyZUqd5VOmTGHNmjU+91m7dm2D7S+88EI2bdpETU1DoWC1WikpKalzCwZhncjlYxTCF53v1+4VU9FBdPULloMQW48wyBh1Im1MoAHM6TDmLh8r1POYxkUYuFa3nPeUh+G7h0J4RICB7nIeUqiMTAkklly6r3tYE52TA3rkLSgowG63k5qaWmd5amoqeXl5PvfJy8vzub3NZqOgoKH7dd68eZjNZs+tS5cubfcGGiGsc17AMwrh2+GvMc66gJ+iLlTbIv8kZDrLMetzfEtAX1aSJM/3QCDwSzDCRgD9r9DUfKO4mpPM07+uiRNda4iN0HPYkYYSBk33Wk3RQc2IuKBcNkr1Bs8oitJgWVPb+1oOMHfuXCwWi+eWk5PTBhY3TW21URjmvLgxp1PRaaxzFIKWPUzmdD6Kn6HKcEZzpOiyK2iCYISNQHPzjUyWIyFfbQROD1IeiewY9qTHGx2K+TttQkImikbm3gV0OEtSUhI6na6BlyU/P7+Bd8VNWlqaz+31ej2JiYkNtjeZTJhMbdjsqZmEvefFRe371LZIK4jtj1Rcb6H7QBnAA4w50uDpstvgxHFyJwy8ImCvLRDUwTVZusH3UK2Ko4RM7Eh1Q7oh6K1w5zfuSrucs2Zf6TymJPRof8IFwJyONG2B04Om2FUVcQH1vBiNRoYPH86yZcvqLF+2bBljx471uc+YMWMabP/9998zYsQIDAbtuOjDOufFiyT7KcbIuzCVn1DblEapiu2mSpddc6RBdNkVNE6wwkYa87xgTmd+xF1eIwJC01tR51jvGswbau+hTXGlFHDz1857lZKwAz4Wd86cOdx0002MGDGCMWPG8Oqrr5Kdnc0dd9wBOMM+ubm5LFrkTOS64447ePHFF5kzZw633XYba9eu5Y033uCDD7TVJK222kjbHolWkbWIIYtn8YHRgb1CgqwKzVYLONt4S1DnKi/wr2uONLDH1WW34ZWAq8uuWXhf2jXBGA8A2vO8AGvMl7CiOIVnzi6n/6gLofNw1Ww5U9qLl71FmNNVF3ABFy/XXXcdhYWFPPnkk5w4cYKBAweyZMkSunbtCsCJEyfq9Hzp3r07S5Ys4Z577uGll16iU6dOvPDCC1x11VWBNrVFhL3nxdWozp2cpUNBWTwbKXOy6l9aX3RWTvjvshvgsFEeiexOvIiBhUsbbiC67AqCMR4AtOd5AS61/cB003Podiiw85/OKkaNXgD5o13kN4YgARcvAHfeeSd33nmnz3ULFy5ssGzChAlkZWUF2KpWYMml4+ntrpk/wc+3CQo+GtVJQcghOVOUDj1wKCDXOXoHJ2wEcDCiPwPxIV4EgmAl7Gqty64ll5sLn6+9qHBXG2n0Asgfbs9LuA/hDTWCIl7CiqxFsHgW3RUHq00Sj1X9EThfbavaHnfTKy8Bo0g6JI0m28VEGFAjbOQ+sFXW+B7PKBAEDa3NNyo66OzM7Y2GL4D84fGyh3OKQAgiOmy1BB8zfx6XXqO6KDjl2UHFR6O6kxP+rtmDTkrNMdWGMwJUVIsRAQI/BCthV2uel4RMZ2dub0Kw2ig23IfwhihCvLQEH6EUveSgMm+/SgYFGFdW+ayIvzLOuoBj3a5W2yK/GJJ7qVZtBGK+kaARgtjnxfdy9aqNfu7ziFe1kQznP67ZCyB/iIRdbSLES0vwMT/EpshYooLT1VcVzOkcih7mbFSn4R9vbKS72siLIFUbgXPqrECgKlrzvAC53a/mGdt1zg7YigN+eCzkRgSE9RDeEEaIl5ZQL5RiR+Yh262c1rXxFZTG0MoI9MaIr8xWJ2wU5cp58Rc2ylkX0NcXhABB7PPie7l61UbJSgEP6j9EJnRHBPgcwmvJhcMrQ+p9hBsiYbelDJvuzJYvOsTNX5zil3wT0zTskWgLMvSnGSPvwnY6Ceistjk+iUjthV2R6rUjD/wkbLewy6uJBF89FHd8EpKuckEbEsQ+L76Xq+d5Sa4+5n9EQIj8Jtyel4pqOzV2B4Zt79bmPkpySJZ/hwPC83ImuLosVkd1BMLcnZi1iL8d+S0fGJ/iqpUXadblK5k785R8B3bFO1akwMEfA/q6bvGy0d7L91A8d6M6QfsliH1efC9Xz/MiJ/Ws95sk5JJ23Qm7AOWnsusUbYSiJylcEOKlFfh0J4YTruoqd7mjjLZ/qDsjR9RbogTc3kiDDoNOIo9EKvpc6Xsj0aiufdNe+7wAEYldmGubgZ3QHRGg18lEG52pAlUn9zUo2gjFYZPhgAgbtYKw77Lro7pKyy7f3ob8oLuoJUnCHGmgoKwaS9Jwovd+HpDXEQiaRIOel9gIAx/bJ3GArnx+qQxdRofkiIDYCAPl1XZOR2SQVq//Vah5ksIF4XlpBWFfQuejukrLP9Sy6K6qlEsnRDtzGsqrwzh8KDhz2mufF5whl2t1y/lE/yh89xC8cb5mQ8+N4fayF+mS6hRthKInKVwQnpdWEPYzL1zVVY7Fs5AVB3ZkdBr+ocapNJwxNS6CfSfLKA1XD5ygdbTXPi9AdNVJ5ulfr/WIhuqIAG8vu1fRBgk9Qup9hBPC89IKwt7zAjBsOusuW8H11Y/wh/g3NZ1V303KU6VcOiU2AmikfbgolxYEAw16XnSnD/kP5YYQDY71rqINIVzUQ4iXVhD2OS8uTAkZrHP051C1WW1TGqXa3F2VsFFqnLPk9ZTNz8ljxyeaTXIWBIF23OeFhEzsDZpHajf07I+w97KHIEK8tIJaNR7eX2hzZGj8cJ2fR/C77KbGOT0vWfT2s4Uol27XtOM+L5jTWRB5l9eIgNDMEWkXXvYQQ+S8tAJPqXSYe17ibacYI+/iSFUaDoeCLAdBEZwBXTnhP2wUwIOl2/OypzwWBl3j9LTUR5RLt1/acZ8XgNVxl7D8dAr/GFlBv5FTQrLayO1lLw3zC9VQQnheWkHtqPQwFi9Zi0h8bTgfGJ/iF+NMqjYsVNsiv5hS1BnO2CXBeWWbXVThLAUVCLxpx31eAC6uWcaXpsfot/3vIVttJCZLaw8hXlpBKMz8aRWuJnWSq6eBTlKI/O5ezeZvJMYaUSNs1C3RedIoKq+mwt90aZG0Kwg0WvS8WHK5pWh+w2ojjR5D/CHCRtpDiJdWEOc1UbjK30krlPHRpE7ScKVAcnWuKtVG0SY9ybGupF27SNoV1GP7R76XB6HPiwLqel6KDno6dHvQ8DHEH7EiYVdzCPHSCuIi9Ohc+R/FFWGoyH00qVOkwA87PFOiO/ZuOEcF4PiWgL92d5f35VdDPz9biKTddsmxzVC4z/e6xF5t+1o+PC8SqF5t5Kh/mgnBaqNok1O8VNQI8aIVhHhpBZIk0SHK6X05XeEnKS+UcTWpc3eTtCkym896XLOVApK5M68Yp6PUz3v54fGAez0yU2IA2FIc7Uza9YVI2m1/7Fvqc7EC0Oeitn0tLXpezOkszngg5KuNoo1O8VJuDUMPe4gixEsriY9ylkGeLg9D8QLOpnSzd/Bil+cZZ13AlsRpalvUKCej+yLVd74EwU09KN3ZA2dnrkUk7QpqqfFdUaT0CECHWS16XoA9HX/DOOsCPu3xN7jqdWd32hAjyjWYsdzq5Xmx5MLhlSIcrBJCvLSSBLd4CcewkRtzOoUpo8gjUfMepmpzD1UqjtziZUeuBYUGBjgRSbvtj7ytPhfLyf56ArUCLXpegAiDzLm67Vx56C/w6S0wf2DIVRzFuMNG1S7PS9Yi5/t4e1pIvp9wQIiXM8WlurubigEo0vhJvbV08Ig0bb/P5Bh1Ko56p8Vg0ElYKmsodMT43mjHx+IqrT1hyYXDP/te19Zl0qBZz0uivYB5+tdrE3dDsOIoyuTyvFTbUCzHYPGs2mKGEHw/4YAQL2eCl+qed/QGrtUtD9+wkYvOuiLGyLuwF2v7B9rXeEqViiOTXkf/Tk7vywZbI4mYPzweUDsEGiJnvf91iQHwBGrU85JcfSzk5xu5c14UBapPHmhQhRlq7yccEOKlpbh6n7i/vDIOnta/ga34mMqGBZCsRVyx4iI+MD7F37N/q2kXaUynPqpVHJ2TmQjAD7l66H2h742E96X9sPNTn4sVgC4j2/71NOp5scZ1a/ibDLGKo0iDzvO4LKZrgyrMUHs/4YAQLy3FR+8TveTAWHxYJYMCjLtRHW6xpmjaRdoxI5O/265vmHUShIqjcT2dnVR/OVCAcu79/jcUJdPhjyUXfv3G5yprjymBqbbRaIddJS6dubYZtSXTkhxyFUeyLBHtStotM6XUqcIM1QqqUEfMNmop7t4nXgLGpsgcsKeqaFQA8SHWPC5SDf5YMxKi2Kn0aJjmEgSbh3XtQJRRR36plW1KT4Z0GgHHNzXccOenMPCKgNkh0AB7v/W5WAEiznswMK+pxQ67OBN2nbhzRPwktGucKJOe8mq7s1x62HRn1VTRIafHRYPHwnBHeF5aSr3eJ4ok85DtVg5Vm1U2LED4bFSnXRdphEFHWXRXVSqOIgw6Jvdzitivtx2HsXf53vDXr2H1CwG1RaAya1/0ubggolvgBhNq1PMSWXnSlbDrRtveW3+4PS8V1a5yaXM6dB8vhItKCPFyJrh6n3Dz1+y4ZjUf2ydRFK4Juz4a1eVP+Lumf7CdO0SiRsURwKVndQTg6+0nsHduJK9h2V9C7uAtaCZL7ofTvsPIlUNnBO51Nep5iS4/GvIJuwBR7kZ11aJRnRYQ4uVMcanu2JSuQJiOB3DjEmtzIv/GOOsCDna5Um2LGmWUuViViiOACb2TMUcayCup4qfjBhj+ez9binEBYcnqBbDhvz5XOYAuowMYLtSo56UyJvQTdgGiTT4a1QlUQ4iXVuIeD1BmtVFtczSxdQhjTudEh7PJI5FTpb67hmqFxIx+qlUcRRh0XD+yCwBvrT4MjSXu/vJcwO0RBBFLrtOj5odDaRcjmTsH7vV3f+F7ucqel+roNObaZmD3JOyGZoKre76REC/aQIiXVhIXYcA1m5FijTdway3uycknS6pUtqRxemT2Vq3iCGD6mG7oZIk1BwvZWRbj3/uStx2+vDPg9giCRCM9fBxA2pV/D9xrW3JhjY88Gw0MUpUk+Ng+ifvi/gUXPg23LnN6c0MMd6+XChE20gRCvLQSWZY83WfDvctu36gSxsi7KMvPVtuURumVEsseKdN/xVGASY+P5LLBnQCY9+0elHP/7H/jre/Be9cG3CZBgPnxr84ePj5QFNjQczYxrhBzQCg6CL7GUoy5W3UPh6LAtbrl/KtkDnz3ELxxvqZ7RfnD5KqaqqoR4kULCPHSBsS7Qkdhm7QLkLWI/9vyGz4wPsXsnVdq+uBj1MskJiT4rsgMUvx/zgW9MepkVh8oZEWeEcbf63/j/d85kzwFocmS+2HVs35Xf6+fwJDr/IeT2gR/3XX7/yawr9sM5NLjrmoj1w8yRNvp610udlvDUkaBCgjx0gYkRDs9L2GbtNugUZ32Dz4Dk3QNp0tD0OL/XRKiuHms80r7L//bSdm4h6CXn6674EzyFAImtLDkwmuT/SboAjgUSLtyHhFeHVoDgo98Fy101wUwWg6HRbWRXuc8XdrsQrxoASFe2oB4d9goXD0vjTWq0yidMweqlrTrZubkXnTuEElOUSV/XbwbbvwYhtzof4cN/xUhpFDAkusU78/3h1wfTQhdKAqs7PonBg8YEHh7NJrvAlAcmREW1UZuz4vd4XUsdA3o1fKFXLgixEsbkBDl9ryEqXgJsUZ1AIP693cm7da/SApS0i5AbISBf10zGEmCjzbl8OWWXPjNy5A+wv9O+78TSbxaZvULTtGy+a1GN1MU+Dr+Bs79/V8Db5OG810ALIaUsKg20ssuz4s7bOQ1oJf5AzUdSg9HAipeTp8+zU033YTZbMZsNnPTTTdRXFzc6D6///3vkSSpzm306NGBNLPVxEe7c17CNGzko1Fd7rh5mj74dO4QxcmYfg1DR0H2GI3qkcidEzMBuP/T7aw7VAjXNnGQ2/oevDIedn4urui0gCXX+VksuhKWPdrk5ooCn0Vfz3l3/htZDkJ3RA3nuwBU2+ystJ/FW2mPwNULnQ0+Q7DaSK/zynmpN6A3VPN4QpmAipcbbriBrVu3snTpUpYuXcrWrVu56aabmtzvoosu4sSJE57bkiVLAmlmq3F7Xk6Hq+cFPI3qHon/O+OsC9iRcpnaFjVJl8xBqoeOAO69oA9TB6ZRbXfwx0WbnOXTl/278Z3ytsOntziv8n98MjiGCmqx5MKG1+Hty52fwae3wKEfm9zNocA7cbcyddZLnr4gAUfD+S4AXY58ymrTTGbkPQmf/QEONv1/1CKehF27EpKh9HAjYL+uPXv2sHTpUtatW8eoUaMAeO211xgzZgx79+6lT58+fvc1mUykpaUFyrQ2p0N0mOe8uDGnY0kdTV7ecbKLtHFgbIzhZw3g79uu5yHDB3XLppc9BgOvCprnSJYlnr9uCCdL1pGVXcxvX1vHm7+/lLPvmQwfT280bwKAVf+C/ctg3D3QZZSmPV4hiyUXctZDRZHz3k/Zsz8UBb61n01W/wf487XnYdIHOEHXjZ98F0WSkbQQ1rXkMmn/07Udr90eiszJIfc9rq02cvgc0BuKeTyhTMDEy9q1azGbzR7hAjB69GjMZjNr1qxpVLysWLGClJQU4uPjmTBhAk899RQpKSmBMrXVpMZFAJBn0XbztrZgSFw5BfIu8nONQKba5jTK2Mwk3tH19DHWyAHrX4EpQchHcBFh0PH2H0byh4Ub2XjkNDe8to6/XNqf3834Ael/dzlDRY3h9sQADLoGuoyGqAQhZlqKt0hxcwZixRuHAs8qN9Lp0gd4eFQGks8ytwDhJ99F0ki+C0UHndWJ3mh4Kn1jeKqNHEptKH3xbOf7CdE8nlAmYOIlLy/Pp+BISUkhLy/P735Tp07lmmuuoWvXrhw+fJhHH32U8847j82bN2MymRpsb7VasVpr29WXlJS0zRtoAc5BgHDsdAWKogT34BVMshbxh42zuNXowLFPgqwXNB27jjDo6NJrEPYDoKv/kax9EUbdEdSDTWyEgbf/MJI/f7Kdb3ac4NH/7WLz0dM8Nm0+HcoLnMm6zWHHJ86bG7eYgfYnaHyJETeVxVBRAFFJEBnfapFSH4cC79nPY236Ldx/zWS6JfmZLRRI/OS7SBrJdyEhEwdyXQEToh4KnbvayF0qPWy604NUdMj5ftrLb04jtFi8PP744zzxxBONbrNx40YAnyfxpk7u1113nefxwIEDGTFiBF27duWbb77hyisbDgScN29ek/YEmvR4p3gpr7ZjqazxlE6HFQ16vSgoi2cjadz9O374EF7fewm367+pu0JxqHL1F2XU8+INQxmyKp553+7hy63HWbW/gEcufY7fpL2JtOpfLX/S+mIG6goan4a0ochpTEA09vrxXaH4aMv286aNxUhzURRY5+jLczH3MePS8bzUP1W9CxaN57tgTuc180xuLX4BveQIaQ+FO2xU410qbU4PyfcSDrRYvNx9991cf/31jW7TrVs3tm/fzsmTJxusO3XqFKmpqc1+vY4dO9K1a1f279/vc/3cuXOZM2eO5++SkhK6dOnS7OdvCyIMOpJijBSUVXPsdGV4ihcfCWpSCLh/J/ZJ5nnT5cywLWnYKOv4Fug+Pug2SZLEbef2YFjXeOZ+voN9J8u456NtLOx8Hn+edjnnmA4i/fK8M1R0pvgSNL5oTOQ0R2CoJCCCjUOBpfbh7FW6cjhhHOefP5UPBqZ5QgmqoPH+Lm4+Vc7ja2sC88dWkTnsfOg8XG2Tzgj3Z20XHXY1QYvFS1JSEklJSU1uN2bMGCwWCxs2bGDkyJEArF+/HovFwtixY5v9eoWFheTk5NCxY0ef600mk89wUtCw5ELRQc6Kq+CnMj3HTlcyMN2snj2BwkeCmmaSAhvBoJM5d8Rg/v6L+om79RneNYGv/zSe11Yd4t8/7WfbMQu/+8TCwPRkpo9+n9+cfgPjmucDa0RzRU47xKHAKscAltpHssk4kpHDB3H18M7M7hKvjdDwyn+i5f4u4PS0jy7+hsdNr6LLUmDL3525IhoON/ujTrWRQHUCdtnQr18/LrroIm677TbWrVvHunXruO2227j00kvrJOv27duXL75wuj7Lysq47777WLt2LUeOHGHFihVMmzaNpKQkrrjiikCZeuZ4NSl6vej3XKtbTm5xpdpWBQYfvV6W93pYMwfJxrhhZAa7lB7+E3dVxKiXuWtST3554DxuP7cHkQYdO3NLuP+z7Qz9ZTRP9fmUHWMWYBt4Dfh4B4K2xaHAZ7ax3Fk9kytMr7J06H+ZdOODLH74Op66YhBDMzpoQ7isXuCnUZ7kzOXSCKX52TwuvVrr9Qzhfii1fV4cTWwpCAYBbUTw3nvvMXPmTKZMmQLAZZddxosv1nVz7t27F4vFAoBOp2PHjh0sWrSI4uJiOnbsyKRJk/joo4+IjY0NpKktp16TIhkHT+vf4IWTlwDd1bUtULgS1P730y/MW29lpDSI89S2qRlkJEbRvfdg7Ie1kbjri6QYE3Mv7scfz+3Bx5uO8dHGbI4UVvDaNjuvkUyk4Wou7XYVF5mP0iu2hk6l29Dv/BSfV96CRnEo8IV9LJsddSsejXFJyF1G0T2zN7O7J9ArJUYbQqU+llyn19AXY/+k+nfZm9M5e4jzN9dIQ3Y2B+F50RYBFS8JCQm8++67jW6jePVvj4yM5LvvmllxoTY+ckD0kgNHwUFgkjo2BQNzOrH9JpK3fhO7TwS/sutMuXbyKF7/r5/E3ZwNYNaGZy8xxsT/Tczkjgk9WH+4iK+3H+fHPfmcsFTxyX74BGc+l0nfk3OSL2Vi9BG6RVWRHBNBx5JtmA98gRQigkahbXxJ/sRIHOUkSiUUKHGU4qzKKZFiyY0dhDm1G5nJMfRMcd56p8Ridk2H1zzr/4Nv0aotrwtAjtSRzopUN98sRKuN7K7DvS4YXZMFTRKkFpBhiI8cEJsis70yUUWjgsNQcwVj5F0czk/jdHm1p0mflhncJZ53u9+EPdtH4u5nf4DqUk3F4SVJYnSPREb3SOSvlyvsOl7Cyv2nyDp6ms1HT3O6ooafThj4iV5ee/UijUmMMhyka1QV0UYdkXo9EUaZSIMOk0GHXpboXLqdXvlLmiUcmiswHMAK40R2yv2otjmotitU2+3U2Bw+T7PFxJLjSKKLXEA8pc35l/ikmFh2SH2wRqURH2UgPtKIOcpAfKQBYkwYzREMM0eQFhdBR3MEiTGm0D75+GtKB0gXPKk5b8aBqji+ss1gnuENdIR2tVFFtQ2ASGOQGhAKGkWIlzOlXpMiRdLxUM0f2GZRoddDMMlaRIfFs/jA6MCuSOxdXkKHS+9W26pmMeOScTz07xk8pX8dvbeAURzw1SzNdv2UJImB6WZPIriiKBwuKGdvXin7Tpax72QpR4vKOVFcRV55Iv+rSQRLY894FmlMZZi8v1Hh0FyBUUwsWY5e5FU1LtyNepkoo44og45Io44oo54Co44Ko44oo45Ig9653uheryPSqCfK4L3MuU2EQUe0SUd8pJEIg6zN8E5bY8mF7x/GZ1O64bfAOTODb1MT7D1Zxkr7WXzd/0kuH9wZuozU5G+sOVRW2wGIEuJFEwjx0hq8mhSVR2fw8XM7obKGMquNmGDNNQkm9fJ8dJJC302PwvgrQuKA1CctFt2Im5m5MYKXjfVnCwW/6+6ZIkkSPZJj6JEcw9RBdddV1djJs1Rx3FKJpaIGS2UNJVU1lFTaKKmqocbuoNqmUGPvRI19APl2BzV2BVkCWZKQZanO426ShEkvI+llTHodJoNMhOve5FoWYZC5RK9z/m2QfQqRSINO3bLiUCdrEXw1E1/CRUFCOvfPwbepGaQf+oTVphfQ7VfggByylUYAlTVO8RJhEOJFC4ThGTbIuJoUxQDmyL1YKmvIPV1JnzSNJRi3BT7yfGTUafZ2pjxwYV+u3zEQu91H8u6afzsn8YZoHwpwHli7JUWr0+1VEBjcFw1+cpkkjSXpurEXH+P/Sl9oWGmkUQ9nU1T48ry4WmWQkBmS7ymUEZdCbYi70+6x0xrpbtnWuPN8vLArMlVxXVUyqOWYowzccdl4Xrdf4mOtAm9Mdl7lCgRawB0qqj/B2IOsuSRdN/lHdjfMLwvhyctVLs9LpNvz4tUqg/kDxXEjyAjx0oa4Zxy1l14vdmTm2m5le0mMyoa1jMuHpHO8z83YFR95EorizH85tjn4hgkE3qx+AZ7vD7sajgAAZ5NILlug2Sv+3VXJDX9jIVppBLWel0ijvkEIPZT714QqQry0Ielu8XI6TMULOOPVs3fAzV/zaLcP+Ng+iY1HznA2jYrcd815PGu607eAwSE8MAL1sOQ6T4TLHvW7ib3fFUizd2o6f2TlSQN/t/0Wh7teLYQrjcBLvBh0PkPooexVCkWEeGlDasNGYSxewHnw6T6efn36ArD813yVDWo5sREGrrh1LjfwFA7hgRFohaxF8PwAP91znSjI6C56SvMiIHbPBzyo/wDZXXB//mOaFltN4Q4bRRl1PkPooexVCkWEeGlDOneIAuBYuIaN6nFB/zTSKMSQ8wsFuaF3xdE7NZY7briGh2wz/HtgXj8Pvn9EuIMFgefYZljsu6LIjSLJSBoOFbk5lXuIeypf8sp5UeCHJ0L6d+Tu8xJh0DUIoYe6VykUEdVGbUjn9hA28iLt4MesiZiJjILjtXnO+HuIXVlN6pNC8dWzueLjLnxpfAy5foIhOKuQ1r4U0mWeAg1jyXV2zV3zIv6EiwIow25BnvDnkDhB/rprC+PDZCyAm8oaZ5jIU23k1SqDhB4h+75CFSFe2hC3eCkos1JVYw/vfgCuhDXZdbCVCd0yyCuGdsZacwUP/i+HefrXG1ZIQG0ju5QBIV1KLdAQzRAt4OrjcsETSOfMCp5trWRFQRxjw2QsgJtKXx12Xa0yBMFHhI3aEHOkgWjXFztsK47chFnC2vUjMxh37Ryusf3Vdw4MIMJIgjPGkguHVzrvLbnO79DzA5xePT/CxQGUDrsT6Z5dEELCxWqz8+l+hbm2Gc6KKAiLsEqdhF2B6gjPSxsiSRLpHSLZd7KM3NOVZCaHVglxi/Ax28khycghfGV12eBOJMfcwJPvHuMRx3/rjhDwxh1GOv9x6DRUNKgS+MftXVn7kuu3ItGcSeAOJKQZPxDbeUTATWxrlv96isjKPMpi0nHcvAydrTIswiruDrtitpE2EOKljencIYp9J8vILgrTRnVu6s12siky7yTewy0hfoAak5lI5z89xm3vjGH0qY+ZofumYSdecJ6Ilv3F+VgK7bbngjbCu9sq+AkJNS1cFElGnrYAQlC4AOT//BqrTf9CZ1PgTddvo/t4tc1qFYqieGYbCc+LNhDipY3pkxbLT7/ms/1YMRA6nWfPCFfCWs7BnVzz8UkKTiRxcUkVqXERalvWKrokRPHKXdP4x9LeXLF6lP9EXjciH6b94RYqhmioKYfjW+GHx1rkXamPgoQ09k9Io+4IWS9Fycmj3Jj/r7AZCeCmoKwam0NBkiAxxqi2OQKEeGlzhmV0ACAru1hdQ4KFOZ0uw9LJ2LCWvCNFvLP2KPdd2Edtq1qNSa/j0Uv7s3lQGv96P597ql7yH0YCPI3tzn+iNpQEYu5JqFPfm1J0sJ5Q8UXLhEs4iBY36zdt4IIwqzICOFpYDkAncyQmvfC8aAEhXtqYoRnxABzIL8NSUYM5yqCuQUHi/4ZGoMvexQ/rS7n7vJ5hU2k1vGsCA//8JB/9dAnW1S9zM1+jkxR32626KEptKMmzVnGGlUR+jHbwJUh8PW6QqwJn4lHxxqFIIIGMgoKMNPbusBAtAHaHwmu7JM4LsyojgKOFzjSArolRKlsicCPESxuTFGOia2IURwsr2JJzmol9UtQ2KfBkLWLi0llMMjqw2yU2f5XHyKtmq21Vm2HS67hxylgKxw7npWVr2ZS1mT6OAzyo/8B3WTVQ5yRXPz/GW8iA8M40RnOFRnMfNwjvAHWkqPtx/c+1laIFiSO9b6HThfcQoddB0SGkMEhi9WbJjhNkF1XwTsSl3Cx9g6Q4wqLKCGo9L10TxbR2rSDES1viOtBO6ljDwkJn6CjsxYur34vkcqHrJIXhO55AOf9qJHNnlY1rWxJjTMy8YiKFF4zhjV8OM33dIN5RHmo8H6Y+3kKmMe8M+D4Ja+0k0Nbi4oyERksee+MvkfbMhIqigCQ19K7YR9+Jfsyd9PD+7LT2ObYSh0Nh/9KXWW16ER0KKBKMnemceB0G7/VokfC8aA0hXtqKrEWeKaN/QaZCdytbspPUtirw+Oj3osPBzh1bGTguvMSLm8QYE/df1Jeqyb3Y8nUNQ7Y9jg6H5+TVfPx4Z/ydeH2Fn1ojHlq7/8EfvSbrtpW4aI3QaFsx0hjuz9p9b0dmfeafiO0xkp59z3IN73N6V/RhcPJuipWbtzGr4sW64wDWvuQUL2HAEVfYqJu3ePH+7bSDz1hrCPHSFtQbjy7j4Gn9G1yYPQy7YyQ6uUVntNDCR78XmyLz5h6J58apaFcQiDDoGH7FLDjvak4e2cO+rT8z9vCL6HBgVyQkQJaU1omaxsJPZ10P2z88M/HQ2v0biIy2EhdtLzTaAocCSJJzFAYym3vPIqrb2WSkJRErV6NL6MHY+iewdnJCs9kdLP15NRPDMFHXTbYrbJSR4AobeV2silYJ6iDES1vgw/uglxwkV+eyP7+UvmlxKhkWBOr1e1EkHY/YbuXzg3DVgQLO6dkOvE/mdFIHp5M6+Hyw3MGp7D38XBDL+kNFFOTsoadtPw/oP0QvnYl3xg+KA7a9772gZY9bu79GRUZz8HhLvASmwyXGnOLEuVxCQUHi9ODbiTr3Lk+uipzQg7PD4ITcVixcc4QVBbHYIyRnyMhNGCTqAlgqazhdUQO4wkb1LlbDpRw81BDipS3w4X2wI3PEkUrW0eLwFi9QZ0CZlNCDiJ+LYc0Rnli8i29mjsega0dTKMzpJA9K52rg6klgd1zE7uMlfL73Zk4d3YOct5XbrIvQS631zrQPfAkNf4/rCxDfj2X2D74XOg4jIq0nHaJMxJQfRU50h8QO1XaJdn2fE8I4V6W15BRV8O73a+ku57G9zz0M3bfA6XEJk0RdgGxXyCgpxkS0SQ/HGxmNEgbvN1QQ4qUtqOd9QNKxrPuD5O1OJCv7NDeMylDbwsDjNaDsnvNTWLtlOwmndvH5ChPXTR6tsnHqoZMlBnU2M6jzaMD5f6gsuJdjR/ZwwJbM0cIKKvL2EVWwnd9XvI2unqhpTOC0VvC0dn+7awaUrhFBUUdceCWyNldoZPWZRWnCIGzx3Yk06IivzEFJ7EGkQUdMeTam1F5EGWVMlqN1REdjj/s0OMF4NZMUQqXZKIrC9+/+kx/l59HpFJR97pysYWExDsDNEVfIyJPv4uNiNVy8TKGEEC9tRb3x6MYTeti9iazs02pbFnTMv37AUmUWktGBfdXTlEU9R8yYP6htlmaITMqgW1IG3TxLXMlBlj9jzT9AgTGdgjIrlSf3k0NHCsqqMJUcJalkF5fkv+rMqUFmmWEiF9hWoMPhPOkrXiKBxh/bkflGGs8lrKrdn5YJizX9H6UobRyJ1blOcWGUia84Bok9iDDIxJRnY0juhckgYbQcQU7w7d1o7PGIBifAwV6PvZohJnhdIPgTIGFyMtUK36/L4veFz3uSdCXFAT88AbN3hNX/2j3qJcMtXnxcrIaLlymUEOKlLfHyPgzVVwNw6FQ5p8ur6RDdTlpKu0uncZVOoxD13b3Q/0Lx424KczomczrpQDrAgAE08FlZZkLRIXQJPbjIUy3UfDHgfqxL6MFlrdhfTujBeJ+f51lej3vXPmypuBDfFU2z72QpHy5dwYVhnKTr5kiB2/Pi1eOl3sVqOL3fUEGIlwDRIdpIj6RoDhWUsyXnNOf1TVXbpODgI3lZxsHBvdvJHCl+4K3GSyD7/bulj1uzv6DdUZx3hJfe+ooCqx5HhLMCy0MYhk/89nip/9sRBJV2lEkZfIa65xwdLVbXkGDijgd7YVNkHlxRTklVjUpGCQSCtsC26W3iXhnKAuujfBnxGNUDrnUKFgjb8MlRT5m0aFCnJYR4CSDDusYDtK+8F3c82HVAUyQd/zT8HxuLIrn34204HKFbYisQtGcUyzHkr2cje4WEI3Z/Crcug5u/dua6hFmvk9Pl1ZwssQL1wkYC1RFhowAyvKvT87Itpxib3YG+vZQM1yudvrgkmiWvfE3Zr7tY9L2V3190jtoWCgSCFqAoCu9/u4Ib8VEiXFMB3cerY1iA+XnfKQD6psW2n7zFEEGIlwDSKyWWGJOeMquNvSdLGdDJrLZJwcMrHjz44CJWGpxJvPa1EvuUp+g99S6VDRQIBM3BUXyMNxf/yP92FXO9KfwmRjfG8r35AEzqG+Yz6kKQduIKUAedLDGkSzzgHNLYLqlffSQpZK5/hONHD6hsmEAgaAr7prdh/iBmHJzJl6bHONp5WtjnuLixOxSP52VSuA/YDUGEeAkwwzLiAdhytB3lvXjjZ3Djgk++o7iiWiWjBAJBU1QWHEXyznGRFHoc/yasc1y82ZpzmuKKGuIi9J7juEA7CPESYIa68l7aVdKuNz6qj+zI/FwQy/WvrqOgzKqSYQKBwB+/5pXwyJtfeYSLB+8clzD1uLhZ/qvT63Ju7+T2k68YQohPJMAM69IBSXKOVHc3O2pX1Ks+QtJxauIz2GM78WteKXf+ZzFFO39whpcEAoGqKJZj/Pjtp/zxxa9YXWTGTr35EWGe4+KNJ99FhIw0iRAvAcYcZWBC72QAPtiQrbI1KjFsutPF7HI1p038Ix/fPoY/xvzCB2UzSPj0KpT5A51j5gUCgSpUrX8L5flBTF5/K8t1d3Nbp8NUXvhcu8lx8eZkSRW7jpcgSTChT3LtCksuHF4pLrY0gKg2CgK/G9WVFXtP8fGmHO65oDcRBp3aJgWfet0ouxuKmWt/BclrLoqyeDaSGCsvEAQVRVFYtn4Lk5fe4+mWq5MU/nB6AVL/Hc7RHu2sDf4Kl9flrM7xJMWYnAuzFsHiWc4cPkl2epTDOOdH6wjPSxCY1DeFTuYITlfUsHRnntrmaIOig85Bbl5Iip2dO7aoZJBA0M6w5HJ447f838uLeeurH9BRt4Gk5D2nqB3kuHjjzneZ5Pa6uKomPcUHisM5mFF4YFQjoOLlqaeeYuzYsURFRREfH9+sfRRF4fHHH6dTp05ERkYyceJEdu3aFUgzA4slF93RVcwY7FTv7647qrJBGsHPGIHbvinimaW/UmN3+NlRIBC0lrK1b+J4fiDdv7mel/KnM0R/GEf900E7ym/xptrm4JcDBYBXvouPqknPEEqBKgRUvFRXV3PNNdfwf//3f83e5x//+AfPPfccL774Ihs3biQtLY0LLriA0tLSAFoaILIWwfyB8PY0btk4jd/qV7Dp6Gl+zStR2zL18TFG4H9d/swJJZH/rDjI7S9+Rd7W78WVjUDQhhwvrmTB5yuIXDqnTgn0/bqPkC94ol3mt9Rn05Eiyqw2kmKMDEp3NRb1cbHVXsWdVghozssTTzwBwMKFC5u1vaIozJ8/n4cffpgrr7wSgLfffpvU1FTef/99br/99kCZ2vbUczNKioO/6V9nuW0Q763L5q+/GaiygRqg3hiBq8zpRO04wfrP5vNo0X/RfamgIMO0+UjDb1bbWoEgNLHkcmT/Dhb+KvPubhtns5NZRh8hok5DnYn17Sy/pT7uKqMJvVOQZVe1lftia/Fsp8elHYs7raCphN3Dhw+Tl5fHlClTPMtMJhMTJkxgzZo1PsWL1WrFaq3tFVJSohGvhp/mbN3kk3yxJZcHp/Yl2qSpf7861EvknZrh4CLpVSRX/F3CgX3xbApSx5HaOVMtKwWCkKPa5uDA0pfpu+lRuuHgUUWiQppBeecJKCdlT9droNaLUO/32B5ZvteV79I3ue4Kr4ut9izutIKmEnbz8pzJrKmpqXWWp6ametbVZ968eZjNZs+tS5cuAbezWfhwMyqSDkd8d8qsNv639bhKhmkcH4m8Ohzc998vmPftHiwVNSoZJhBoGFcJr2I5xqYjRTzy5Q6mPfURfTY+Uic89IzxTV66YRjSZQtEiMgHWdmnOZBfhl6WGN8rueEG7TB5Wau0WLw8/vjjSJLU6G3Tpk2tMkqS6jZGUhSlwTI3c+fOxWKxeG45OTmteu02w0dzNmnafKaMGQbAe+uPoihKI0/QTvHTkXd/TQr//fkQ4//xE+98t4bq/StEPoxAACib33b2SXp7Go7nB/Lxa0/z7rpsEqw5dYco4lVBVK/3kij5dfLsd3sBuHJYOuZIg8rWCBqjxXGLu+++m+uvv77Rbbp163ZGxqSlpQFOD0zHjh09y/Pz8xt4Y9yYTCZMJtMZvV7A8eFmvLqimn98t5ddx0vYmlPM0IwOalupLXzEluVLn+epqAv5x9K9DC74ihvWvI5urTMfxnHpfHQjRD6MoB1gyXWGoxMyKdIns2r/Kbbt2s3D+2d5ypx1KMzTv0FM/wu5cOBFKF/Oq+vJ9E4yFSGiOqw5UMCag4UYdBIzJ/dS2xxBE7RYvCQlJZGUlBQIW+jevTtpaWksW7aMoUOHAs6KpZ9//plnnnkmIK8ZcOodIOKjjFx6Vkc+z8rlvfXZQrz4op7ok8zpTAYmdqxBnv9GnXwYvp7Nm/mZXDJuBKlxEeraLRAEiIp1bxG5dA4SDhxIPFMzg4/skxgj70JXL/lWJzn4y9gI6H4W2EWSaXNQFIV/fu/0utwwMoPOHaJUtkjQFAHNGM3OzqaoqIjs7Gzsdjtbt24FoGfPnsTExADQt29f5s2bxxVXXIEkScyePZunn36aXr160atXL55++mmioqK44YYbAmlqUPnd6K58npXL4m3HeeSSfsRHGdU2SXv4uCrUnT4ENMyH+f6XtTz1SwmT+qRww6guTEircW6bkCkO1ILQwpJLzakD7LelsLEokm05xRw7eoAPyu/xdKOWUXhK/wa5iWMZ1WMUylY/ybcgkkybyfK9+WzJLibCIHPXpJ5qmyNoBgEVL3/5y194++23PX+7vSnLly9n4sSJAOzduxeLxeLZ5v7776eyspI777yT06dPM2rUKL7//ntiY2MDaWpQGdolnn4d49hzooTPsnK5dVx3tU0KDdz5MF5ucIckY07vjT1H4Yc9J0nY9yETDK8DCookI4kW3gIt4RX6scV05GhRBftPlnEgv5TEfR9xXd6zGFDoo0gstM3gc/skxsiHGnhX9JKDd69IdiaPZjThXRHhoUZxOBSe/W4fADeP6UaK8OCGBJISZlmjJSUlmM1mLBYLcXFxapvjl/fWH+XhL3bSIzmaH+dM8JuQLKhH1qKGB+ph09l/spRvVm/mT9t/U6fNuR2Z/wz5khFnDWR41w4YdHKdE4g4qAtaRFPfnXrry6w2jp2u4FhRJZE732PM7r8i48COxKO223jfNhGANApZbZpZJ8HWjsybI75iQHocY76a2DB3ZfaOWhssucK7coZ8s/0Ed72fRYxJz6r7J9EhWnjC1aIl52/RaEQlLh+SztPf7OHQqXLWHipkbGZg8ojCDj9u8F6pscweKsP2evF/HPyyYQPPrisj1qTnzykbuOnUc043uxiu1r5oofBogNdgPkWSOX3ePznS9SryS6ycKq0i9cDHnH9wHrIrL+VJ6XYWVp4LuMXJk8hSbWLtk7rXWSMNIS61KxdFn0R3tOF397YBQPfBoAjvSiCwOxSeW+bMdbl1XPe6wkVc5GgaIV5UIsak54ph6by7Lpv31mUL8dIS/B2o/YSV+vUfzP7DEobyE9yY/y9P7gCKA8dXs/iwsBc9MnszoFMcsREGcdDSGs35PFogPNyi1XrWjZRW2SitsqHf9g6dV81FwoGCzKp+j7Cxw6WcrqjmdEUNckkuC/JmeqYuS4qDuB/+zJ1WI3kkusTJ0x5xIqPwiONVljKAqqg0JsWUoitpGPr56ZYuyD3GgaU7zK/73RW5K4Hniy25HDxVTnyUgRnjvcL3YoK05hHiRUVuHNWVd9dl892uPPJLq0iJFbHWVuGrzHrafB4bNoVHHQqHN32LbkndE4iMg6+W/8K6H4uQJLgzbg33Wl9Gdp3ETk/+J+ZzbkUn1wvrCYHTNqKiiW2UzW/D17ORXN6Ogkn/4FTP66issVFRbafcaid5/0cM3fa4y+Mhs6TrA6w2X0JFtXObiIoTdYQHigP7/2Yx4WO8hMeDHlEr4WDs7r9xvzWZPBIBGCPvQfaRdzIitphj8ZmM1x9Hd8K3OInqMwksA2D+Iw3EiZzo6hrdnPbzwrvSplTbHCz40ZnrcseETOeFC/ifIJ05Wfz/NYQQLyrSr2Mcw7t2YPPR03y4IUf0FmgL/FyhyrJEZp/B8G09zwwyGT0Hkn3SiMOSy5yqlzxXzxLOq+sJ35rQd+hMl4QoMhKiuKDqeybs/ZvzKl2SsV8yH72/XjNBOMG3aJu2eq6sRSiLZ3lERfHkZynsfR1VNXYqa+xUVttJ2PchAzb9xVXeK7Oi98NsSZpGZbVrmxo7QwsWc2P+c55Qy/zIu/hCmkxltQNzTT7fM8uTByIpDjr8eD/Tlpg8osIpPB7z8ng4uOjIM/zN2qlR4aGTnKM68hyJ9DOdatDMTS85QzaW1J7ERxnpKKeifD+vTlWPIul48e6rnP8fSzeYf38DcRKV1tv5uDniRHhXgsrHm3LIKaokKcbEzWO61a5obIK0+Ew0gxAvKnPT6K5sPnqal1cc4OJBafRMCZ+qKtXwd4XqxzPzj2FTAbDs/hHdxw1PYp3JY11hAkcKK0ijkCdNf629SnddlV3wtQFbTCc6RBlIiDaRGG1kYsVSLjw0z+PF2THsSQr7XEeUQUekUUeUUUfC3o/o8NOfPSLAetFzOIbehE6W0EkSOllC2vJOnVwL+yXzsQ/5HYrijNk7FAXd1neJ/G6O53lOnvsMp3pdR7XdjtXmoNp1SznwMYO3POYRFL/0fYQdqZd7trHa7Aw8+T+uOPZPjyfjv3Ez+cZwPpXVdqpqHMRW5/ONfWYdURG77D6mfm2oJyoe9SrvdXDu3qd4aHtKnW3+afpXnVDLzIqX+djahwIS6SUf81llMzi6CKOpC1FGHaOkbHSnG25z3wgDxan9iDLqSXSkoXzXUHi8OutaopMz0JUOgfl/ayA8br3M+0q7O0TU/e5I3uKjrcSJ8K4EhaoaO//+aT8Ad0/KJNKoq13pI/wsJkhrD1FtpDIOh8L0Nzfwy4EC+nWM44s7xxJh0DW9o+DM8VeZYcmF+QPrHLQUScfJP2zkSE082UUVcHgl1+66s8FTXl/9COsc/T1/+6oesSky46wL6p3gg7NNWz7XGHkXHxifavA/uJXH2WU8i0ijjpHs4pmyhxps81bPf5OXeDaRBh2ZZVlM29pw2Oq+qR9gzxhHjPUknd8e2XSVTb3PrME24LdKrdnr3TRV1SOqfkKCV1ce5Oklv5IeH8lP903ApK93zG3u90HQpohqoxBCliWeu3YwFy1YxZ4TJTyz9FcemzZAbbPCmxZ4ZqRp80nrkkkaMLpHIvSaCLvlBgJn3ozLOSUlUVRupai8hsjc1ei2N/QITEopZb2SQVW1nf7VBeiUhtu4wxkA3eU8nyGN5mwzLOY0O41dMOplTHqZYY6j6IobbndLX4Vj8V0x6mV6lZ9Gt6fhNv+5uAPWzqOJNOiIre6J8m7DtvNvzL7WS1T08pnjccs0L2+GJRq2NbzC7d13MJjjgLjm5YE0tQ007fVobsimKc+I8JxonrUHC/mna4bRzMk9GwoXECG8EEB4XjTCT7+e5A8LnQMt3/z9CM7r63uWkyAINHX13JyrsuZ4BPx4eirv3IItthMOh4JiySX+1WF1hIIi6Sj7vy1I5nRkCeTS45heHNy4h6IVNp2RJ6Mtt2mON0N4PATN4EB+KVe+vIaSKhuXnNWRf18/FLl+Mr5ANVpy/hbiRW28EiMf/7mYhWuOkBBtZOms8aLTo5ZpzskymCf45rq52/K52kpUCOEhCAIFZVaueHk1OUWVDO/agfdmjBIheo0hxEuoiJd6vQRqLn6ey9ZksudECeN6JrHoDyPFVUGoE8wTfHNFgBAUgnZGVY2d619dx9acYjISovjizrEkxpjUNktQDyFeQkG8+HHPH75pLVPfOkRVjYO5U/ty+4RM9WwUCASCEMfhULjr/Sy+3ZmHOdLA53eOJTM5Rm2zBD5oyflbDpJNgvr46SXQXcr3JOz+87u9bMspDr5tAoFAECb8femvfLszD6NO5tWbhgvhEiYI8aIW7l4C3rh6CVx/dhemDkzD5lCY+eEWyqw2dWwUCASCEObddUd5deUhAP5x9VmM6pHYxB6CUEGIF7Vwl3hKroQxrxJPSZL4+5Vn0ckcwdHCCv7yv52qmioQCAShxvK9+Z5j55wLevObofUq7w6vdN4LQhKR86I2jSRGbjxSxHX/XYtDgQXXD+HyISJxUiAQCJpi9/ESrnllDeXVdq4e3pl/Xn0WkuQqfhBDFzWLyHkJJczp0H28z4qOs7sl8KfznPOOHv5iJ9mFFcG2TiAQCEKKE5ZK/rBwI+XVdsb0SOTpKwbVChd/QxeFBybkEOJF4/zpvJ6M6NqBMquNmR9uocbuaHongUAgaIdYKmr4w8JN5JVUkZkczSu/G45R73Waa2zooiCkEOJF4+h1MvOvH0JchJ6tOcU8v2yf2iYJBAKB5th4pIiLX3COWUmKMbLwlpGYowx1N2qkUEIQWgjxEgJ07hDF3686C4D//HyQNQcKVLZIIBAItIHN7uC5Zfu47r9ryS2uJCMhirf/MJIuCVENN26kUEIQWoiE3RDiwc+28+HGHFLjTLw3YzQ9U0S/AoFA0H7JKapg9kdb2Xz0NABXDkvnycsHEmNqYuaw6CCtSUSH3TAVLxXVNi57cTUH8suIMel57trBTBmQprZZAoFAEHS+2nachz/fQanVRqxJz9+uGCgqMkMcUW0UpkQZ9Xxw22hGdk+gzGrjj+9s5l/f78XuCCv9KRAIBH4ps9q49//bu/eopq58D+DfJOTBI4RHDAmKPBRheqmtigqO+JxS7dt21E4dir2jt+OaPpx2rdZ2pqPetVxqV2s7M211zdSx7bS3Tx93Wru8Za4gOoKiQrX1qliDQDUEEEgg5L3vH3lIeCfmkBz4fdbKSnKyc9jbLeSbffbZ57Nv8czH1TBa7Jg+MQ5fP1tAwWWMofDCM+PkUny0Zjae+GkaAODPhy/jV+9XocNkC23FCCGEY982tOPePx3F3jONEAqAZxZNxmdP5vc/v4WMahReeEjceR0bc1qx84EkyMRClF1sxgNvH8MFnSHUVSOEkKBzOhl2lv2AR3Yex9VWE5IVMny8Ng/PFWYhQkQfY2PRELOaSNjpsTrkUoEQUxduw8qqTFxtNWHZ28ex/edT8cAdyaGuJSGEBIWuw4znPqvB8R9aAQD33K7G1mVTfU+D7vjRtYZLwiSagDtG0IRdPun4EXgzx3eRJYEI7U+ewdMHm3C01nUK9dqCdLy4JJu+kRBCeIsxhkPf6fDS/nNoN9kQKRZh8wP/huW5E26umAvQcv+jCE3YHa0GWB0yrrsB7z0xC+sWTAIA/PWoFkW7T6K10xKCShJCSOCsdif2nWnEvX86hnUfnUG7yYac8bH46pm5WDEzxTe40HL/YxYdNuITz+qQvUZekJABkVCAF5dkY+p4BZ7//FtUXGnF/X8+hl1FMzB1QlzIqkwIIcPRYbLhv07W473jWjQZXF+8IsUiPPHTNKz/2RTfZf49Blvunw4fjWoUXvjEszrkl+tdv6D9rA659HYNJqti8B9/Pw1tSxd+vqsCWx7KwfLclJBVmxBCBtJww4Tdx7T47FQDTFYHANdZlavnpGHV7ImIi5IM/OZBvtCR0Y3mvPDRMFaHNJhteO7TGvzz//QAgKK8VLxy3239f3shhJARdqa+De8evYJD3+ngWaoqWy3Hr+am44E7kyGNEA1zRx/0/UJHc154iVbYHe3hZZicToY/H76MN//3EhgDclPj8c6q6VDFykJdNULIGORwMpSc1+GvR7XeJf0BoCBTibUFGSjIVPrOaRkuWu5/VKDwQuHFx+ELTXj2kxoYzXaMk0vx6s+nYsGUcYH9kSCEED+ZrHZ8fqoRf/uXFldbTQAAiUiIB+9MxpqCDGSp5SGuIQkHFF4ovPShbenCk38/hUtNnQACHJ4lhBA/1Lea8ElVPT46UY+Obtcq4HFRYvxydioen5MKldw9CkzrtBBQeKHwMoAuix2vf3MJn1TV+0yMK85PxarZqYiPHmRiHCGEDKHTYkflD60or21G+aVm1LlHWQAgLTEKv5qbjkdmTECUpMe5IrROC3Gj8ELhZVAdJhv+u7wKladO4ExnInRIhEwsxPIZKfj3uelIV0aHuoqEEB5wOhm+v2bwhpUz9W2wOW5+pEQIBZiVnoDiOWn42U+SIBL2OlQ9wMKbWH+ORmDGIH8+v+lU6TFIceFjPH7iWTzOnGAyIf4Y9RTevJGHv1dexYcnruJnP0nC2oIMzEyLp3kxhBAfeoMZR2tbUF7bjGO1LWjtsvq8npoYhXmZ41CQqUT+pETIZeIB9gRap4UEjMLLWNNrRUoBnHi2+23MfWwF3jljxuELepScb0LJ+SZMnaDAmoIM3JOjpksNEDJGWewOnKprQ/mlZhy51IwLOqPP69ESEfInKTF/ihLzpoxDaqIfI7e0TgsJEKfhZcuWLTh48CBqamogkUjQ3t4+5HtWr16N999/32fb7NmzUVlZyVEtx5h+vukImAO58nb8bXUBLus7sfuYFvvONOJsYwee+bga2+MisXpOGlbOSkHsYN+iCCG8Z7LacVnf6Qostc2ovNIKs833b8bt4xWYN0WJeZnjMD01HuJAv9wMY+FNQvrD6ZyXjRs3Ii4uDo2Njdi9e/eww0tTUxP27Nnj3SaRSJCQkDCsn0lzXoYwzGPMrZ0WfFhZjw8q6rzDwjHSCKycmYInfpqGCfFRI11zQkgQeULKpaZO1OqNqG3qxKUmIxrbuvuUHSeXYl7mOMybosTcyUokxkhdLwTrLCFap4UgDCfsvvfee1i/fv2ww0t7ezsOHDgQ0M+i8DIMfqxIabY5cKD6R7x7TIvLetdp1iKhAEtz1FhTkIE7U+JGrNqEEP91WVwhpVbfidomI2r1A4cUj8RoCW5LjsXcya5DQdlqed/5b3SWEAky3k/YLSsrg0qlQlxcHObPn48tW7ZApVKFulqjx/THgUmLh/VNRyYW4dFZE7EiNwVHapux+6gWxy634Kuz1/HV2evIVsuRl5GImWkJmJkWT6v3EhIivUPKJXdQGSykKGMkmKyKwZQkOTJVMch033tHVgYy0NWcJy2mkRMyIsIuvCxduhTLly9HamoqtFotXnnlFSxatAinT5+GVNr3F8piscBisXifGwyGkawufynG+/VHRigUYGGWCguzVDh/zYB3j13Bl99ewwWdERd0Rrx3vA6A60yD3NQEzEqPx8y0BKQro+mMJUJugdnmQLPRAr3RjCaDBXqDGXqjxfXYaEaz0YImgxltJtuA+1DGSJCpkiMz6WZAmZIkR0KgazvRWUIkxPwOL5s2bcLmzZsHLVNVVYXc3NyAKrRy5Urv45ycHOTm5iI1NRUHDx7Eww8/3Kf81q1bh6wPCa7bkmOxY8WdePmen6DySitO1bXhhx8uwd5cC22rGntbTdh7phGA649mbmoCctPiMSs9AbdpYunMJUIAdFsdNwOJ0Qy9wYImoxnN7nu9wQK90eJdmXY4PCFlSlIMJifJMcU9muINKT3nqEQnBl55OkuIhJjfc15aWlrQ0tIyaJm0tDTIZDcPH/gz56U/mZmZWLNmDV588cU+r/U38pKSkkJzXkZSj2PfDEL8T8ZL+JupADWN7bDafb+dRUlEmD7RNSozMz0e01LiESmhyxMQ/nE4GTrNdhjMNnR022Aw22DotsNotsFgtsPg3mbs8djQbYfRYkN7lw1Gi33YP0sSIURSrBQquQwquRRJsTKMk0u9j1WxUqhjZYiLGmQkJdhzVOhqziTIOJ3zolQqoVQqA66cv1pbW9HQ0ACNRtPv61KptN/DSWSE9LNuzBLtNixZvwqW6Fk419iBqro2VNXdwKm6GzCY7Th2uQXHLrsCcIRQgJzxCsxMcweatAS6TAHhBGMMZpsTJqsdJqsDJqsDXVY7uq0OdFns6LY50GVxwOTZZnU9NvYbROzo9CN8DEQmFrrCh1wKledeLkOauA0TnNcRkzwFCZoMxEZG3NrhVy7mqPgxd46QYON0zkt9fT1u3LiB+vp6OBwO1NTUAAAmT56MmJgYAEB2dja2bt2KZcuWobOzE5s2bcIjjzwCjUaDuro6vPzyy1AqlVi2bBmXVSWBGuTYt1QxHrlpCchNS8A6TILTyXBJb0SV9gZO1rWhSnsDOoMZNQ3tqGlox1+PagEAk1UxyFTFIClWBrVCBnWve5mYRmpGI8YYrA4nzFYnTDZXgOi2OWC2uYJGz+fdVgdMNgfM7m2e17t6BBOTO3yYrA6YLHaYbA4E89xKNVqRLtThmigZ3TI1YiPFiJVFQC4Tex/HRoohl0Ugtte2WJkYqlgp5NJ+QgkXZ/FwNUfFz7lzhAQLp+HlD3/4g8+Cc9OmTQMAlJaWYsGCBQCAixcvoqOjAwAgEolw7tw5fPDBB2hvb4dGo8HChQvx6aefQi6nS6aHJT+OfQuFAmSrY5GtjkVRfhoYY2hs68apqzdwUusanbms7/TePDwfElqnGjokQhEphkYhc4WbWBmSFDJo3OHGE3jio8Q0UTiIGGOw2J2u4OAJD1aHz3Ofe3ewMPV83t/7PO9xl3MGeeEGNVox2f1/pws353jIxEJESSIQJRG5bxE+99FSESLFrsexkTfDhyeIJGs/h7L0BQg8AWNpkE4T5uosHpqjQkYZujAjuXVBPPZ9o8uK6vo2NLZ1Q2cwI/XqXqy4/hqEcMLBBHjJvgafORYOuR9JhNA1UuMON+pYKdSKSKhjZYiPFkMaIYREJIIkQuh63OPmek0Y1uHH6XSPUtgcMNucsNhd92abwxsyzDYHzHYnLD3ufV4b5H2mXqMcXAQLj97hFADEIgFkYhEixSJESnrdi0WQSUSI6rFNJnYHDkkEot2BJKNhHzJP/h4C5gQTCGG86zUIZxQjUizqe4FAf3B5MUFtOfD+/X23F38FpBfc2r5pjgoJc2G3SN1IovASIlyskNnPhwQTiKD9ZQUaHQnQdZihM7hvHa5bk8Hc50JxQ+nvwxMAJKJegcYdany3iSARuR57yggErsmcdieDw8kQY9Ej0dIAXcR4tAiV7u1OONyve8r1fm53OuF0AnZ3Wc92i93pMxF6oPoHS+/99wwWURJXcPCECO/z/kKH+7WoHiFkfN0XmPivl7wBw7xkByJyiwNfbt6DrwGD66ss00q2JIzxfpE6wkNcHPse4DpMGUI9MiZlDfg2i90BvcHiE2p6hpyObhus7gCw1FaC3zt3QSRgfUZ2rA4nrA4nYBnwRw1phagU/xnxbr/7D4YVolJs9ewfAmyPWId/yu6GJEIImVgEmdh1L/U8j3Btk4pFkEW47r2vuctH9ggf6h8+h7r8RW+4cNz7JiJyi4NT+Y4fgY9eujnZmzkReeh5ILvw1v8vcbkOCZeHYLi+1g/NUSGjBI28kPA1Et9C+xnZ6VxXDXOk2hVe7DdvFrvDde/wPO/5ugNWhxMWmxMMrksoKKx6PFZxL4S4uX+nQIhDi0tgjdZAJBQgQiiAqMctQijs9dz3sVAocI/yiBDZrUP0zjtd8y5G6N8nqPvn8wgG14dgaISEjEE08kJGB66/hQ4wsiPvqodclXrr+9deAyp89y9kTtwzvhtID0IbWq5yu8op16uo8nkEg+vThGmEhJBBUXgh4Y3LDwmuz8Cg/Q+OAgYhJEC0TjsJf4rxrsMIXHz43P9H14cmwM38Atr/4KY/7jqUU/yV6z7YZ79w9X+HEBJSNOeFEK7nF9D+CSFkSDTnhRB/cD38T/snhJCgosNGhBBCCOEVCi+EEEII4RUKL4QQQgjhFQovhBBCCOEVCi+EEEII4RUKL4QQQgjhFQovhBBCCOEVCi+EEEII4RUKL4QQQgjhFQovhBBCCOEVCi+EEEII4ZVRd20jz3UmDQZDiGtCCCGEkOHyfG4P53rRoy68GI1GAEBKSkqIa0IIIYQQfxmNRigUikHLCNhwIg6POJ1OXLt2DXK5HAKBINTVCZjBYEBKSgoaGhqGvDT4aDDW2gtQm8dCm8dae4Gx1+ax1l6AuzYzxmA0GpGcnAyhcPBZLaNu5EUoFGLChAmhrkbQxMbGjplfCGDstRegNo8FY629wNhr81hrL8BNm4cacfGgCbuEEEII4RUKL4QQQgjhFQovYUoqlWLjxo2QSqWhrsqIGGvtBajNY8FYay8w9to81toLhEebR92EXUIIIYSMbjTyQgghhBBeofBCCCGEEF6h8EIIIYQQXqHwQgghhBBeofASJrZs2YI5c+YgKioKcXFxw3rP6tWrIRAIfG55eXncVjSIAmkzYwybNm1CcnIyIiMjsWDBAnz//ffcVjSI2traUFRUBIVCAYVCgaKiIrS3tw/6Hj718zvvvIP09HTIZDLMmDEDR48eHbT8kSNHMGPGDMhkMmRkZGDXrl0jVNPg8afNZWVlffpSIBDgwoULI1jjwJWXl+P+++9HcnIyBAIBDhw4MOR7+N7H/raZ7328detWzJw5E3K5HCqVCg899BAuXrw45PtGup8pvIQJq9WK5cuXY926dX69b8mSJbh+/br39vXXX3NUw+ALpM2vvvoqduzYgbfeegtVVVVQq9W46667vNe0CnePPfYYampqcOjQIRw6dAg1NTUoKioa8n186OdPP/0U69evx+9+9ztUV1ejoKAAS5cuRX19fb/ltVot7rnnHhQUFKC6uhovv/wynnnmGezdu3eEax44f9vscfHiRZ/+zMzMHKEa35quri7ccccdeOutt4ZVfjT0sb9t9uBrHx85cgS/+c1vUFlZiZKSEtjtdhQWFqKrq2vA94SknxkJK3v27GEKhWJYZYuLi9mDDz7IaX1GwnDb7HQ6mVqtZtu2bfNuM5vNTKFQsF27dnFYw+A4f/48A8AqKyu92yoqKhgAduHChQHfx5d+njVrFvv1r3/tsy07O5tt2LCh3/IvvPACy87O9tn25JNPsry8PM7qGGz+trm0tJQBYG1tbSNQO24BYPv37x+0zGjo456G0+bR1MeMMabX6xkAduTIkQHLhKKfaeSF58rKyqBSqTBlyhSsXbsWer0+1FXijFarhU6nQ2FhoXebVCrF/Pnzcfz48RDWbHgqKiqgUCgwe/Zs77a8vDwoFIoh6x/u/Wy1WnH69GmfvgGAwsLCAdtWUVHRp/zdd9+NU6dOwWazcVbXYAmkzR7Tpk2DRqPB4sWLUVpaymU1Q4rvfXwrRksfd3R0AAASEhIGLBOKfqbwwmNLly7FRx99hMOHD+P1119HVVUVFi1aBIvFEuqqcUKn0wEAkpKSfLYnJSV5XwtnOp0OKpWqz3aVSjVo/fnQzy0tLXA4HH71jU6n67e83W5HS0sLZ3UNlkDarNFo8Je//AV79+7Fvn37kJWVhcWLF6O8vHwkqjzi+N7HgRhNfcwYw3PPPYe5c+ciJydnwHKh6OdRd1XpcLJp0yZs3rx50DJVVVXIzc0NaP8rV670Ps7JyUFubi5SU1Nx8OBBPPzwwwHt81Zx3WYAEAgEPs8ZY322jaThthnoW3dg6PqHYz8PxN++6a98f9vDmT9tzsrKQlZWlvd5fn4+Ghoa8Nprr2HevHmc1jNURkMf+2M09fFTTz2Fs2fP4tixY0OWHel+pvDCoaeeegqPPvrooGXS0tKC9vM0Gg1SU1NRW1sbtH36i8s2q9VqAK6Ur9FovNv1en2f1D+Shtvms2fPoqmpqc9rzc3NftU/HPq5N6VSCZFI1GfEYbC+UavV/ZaPiIhAYmIiZ3UNlkDa3J+8vDx8+OGHwa5eWOB7HwcLH/v46aefxj/+8Q+Ul5djwoQJg5YNRT9TeOGQUqmEUqkcsZ/X2tqKhoYGnw/2kcZlm9PT06FWq1FSUoJp06YBcM07OHLkCLZv387JzxyO4bY5Pz8fHR0dOHnyJGbNmgUAOHHiBDo6OjBnzpxh/7xw6OfeJBIJZsyYgZKSEixbtsy7vaSkBA8++GC/78nPz8eXX37ps+2bb75Bbm4uxGIxp/UNhkDa3J/q6uqw6stg4nsfBwuf+pgxhqeffhr79+9HWVkZ0tPTh3xPSPqZs6nAxC9Xr15l1dXVbPPmzSwmJoZVV1ez6upqZjQavWWysrLYvn37GGOMGY1G9vzzz7Pjx48zrVbLSktLWX5+Phs/fjwzGAyhaoZf/G0zY4xt27aNKRQKtm/fPnbu3Dn2i1/8gmk0Gt60ecmSJWzq1KmsoqKCVVRUsNtvv53dd999PmX42s+ffPIJE4vFbPfu3ez8+fNs/fr1LDo6mtXV1THGGNuwYQMrKirylr9y5QqLiopiv/3tb9n58+fZ7t27mVgsZl988UWomuA3f9v8xhtvsP3797NLly6x7777jm3YsIEBYHv37g1VE/xiNBq9v6cA2I4dO1h1dTW7evUqY2x09rG/beZ7H69bt44pFApWVlbGrl+/7r2ZTCZvmXDoZwovYaK4uJgB6HMrLS31lgHA9uzZwxhjzGQyscLCQjZu3DgmFovZxIkTWXFxMauvrw9NAwLgb5sZc50uvXHjRqZWq5lUKmXz5s1j586dG/nKB6i1tZWtWrWKyeVyJpfL2apVq/qcUsnnfn777bdZamoqk0gkbPr06T6nVxYXF7P58+f7lC8rK2PTpk1jEomEpaWlsZ07d45wjW+dP23evn07mzRpEpPJZCw+Pp7NnTuXHTx4MAS1DoznNODet+LiYsbY6Oxjf9vM9z7ur629/w6HQz8L3JUlhBBCCOEFOlWaEEIIIbxC4YUQQgghvELhhRBCCCG8QuGFEEIIIbxC4YUQQgghvELhhRBCCCG8QuGFEEIIIbxC4YUQQgghvELhhRBCCCG8QuGFEEIIIbxC4YUQQgghvELhhRBCCCG88v8P3DLbMMzldAAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(gt[:, 0], gt[:, 1])\n", + "\n", + "ta_var.time = precision(0)\n", + "ta_var.state[:] = list(ic_var)\n", + "ta_var.state[:2] = ic\n", + "ta_var.pars[:] = np.array(nn_wb, dtype=np.single)\n", + "sol = ta_var.propagate_grid(np.array(t_grid, dtype=precision))[5]\n", + "plt.plot(sol[:, 0], sol[:, 1], \".\")" + ] + }, + { + "cell_type": "markdown", + "id": "0860dfc7", + "metadata": {}, + "source": [ + "It is also of interest to visualize the predictions of the trained system over a new random batch, as opposed to the predictions of the entire trajectory from the first observation:" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "79f8bd93", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--- 0.016167402267456055 seconds --- to compute prediction over the whole batch\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "batch_ic, batch_t_grid, batch_y = get_batch(t_grid, gt, batch_size_ic, batch_size_time)\n", + "\n", + "plt.plot(gt[:, 0], gt[:, 1])\n", + "for i in range(batch_size_ic):\n", + " plt.plot(batch_y[:, i, 0], batch_y[:, i, 1], \"k.\")\n", + "\n", + "start_time = time.time()\n", + "for batch in batched(batch_ic, batch_size_simd):\n", + " ta_var_b.set_time(precision(0.))\n", + " ta_var_b.state[:,:] = deepcopy(ic_var_b)\n", + " ta_var_b.state[:dim,:] = np.array(batch).T\n", + " ta_var_b.pars[:] = np.tile(nn_wb, (batch_size_simd,1)).T\n", + " sol_b = ta_var_b.propagate_grid(np.array(t_grid_b, dtype=precision))[1]\n", + " for sol in [sol_b[:,:,i] for i in range(batch_size_simd)]:\n", + " plt.plot(sol[:, 0], sol[:, 1], \".\")\n", + "print(\n", + " \"--- %s seconds --- to compute prediction over the whole batch\"\n", + " % (time.time() - start_time)\n", + ")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "shota", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.7" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/doc/notebooks/ffnn.ipynb b/doc/notebooks/ffnn.ipynb index ac3d8c02..dc180f16 100644 --- a/doc/notebooks/ffnn.ipynb +++ b/doc/notebooks/ffnn.ipynb @@ -7,7 +7,7 @@ "# Feed-Forward Neural Networks\n", "\n", "In this tutorial, we will introduce feed-forward neural networks (FFNNs) in *heyoka.py*, and how to use *heyoka.py* FFNN factory to create FFNNs. \n", - "For an example on how to load a FFNN model from torch to *heyoka.py*, please check out: [Interfacing torch to heyoka.py](<./torch_and_heyoka.ipynb>); while for an example on applications of FFNNs in dynamical systems, check out: [Neural Hamiltonian ODE](<./NeuralHamiltonianODEs.ipynb>) and [Neural ODEs](<./NeuralODEs.ipynb>).\n", + "For an example on how to load a FFNN model from torch to *heyoka.py*, please check out: [Interfacing torch to heyoka.py](<./torch_and_heyoka.ipynb>); while for an example on applications of FFNNs in dynamical systems, check out: [Neural Hamiltonian ODE](<./NeuralHamiltonianODEs.ipynb>) and [Neural ODEs - I](<./NeuralODEs_I.ipynb>) and [Neural ODEs - II](<./NeuralODEs_II.ipynb>)\n", "\n", "To facilitate the instantiation of FFNNs, *heyoka.py* implements, in its module *model*, a Feed Forward Neural Network factory called ``ffnn()``. The Neural Network inputs $\\mathbf {in}$, with dimensionality $n_{in}$ are fed into a succession of $N \\ge 0 $ neural layers defined by:\n", "\n", diff --git a/doc/notebooks/single_precision.ipynb b/doc/notebooks/single_precision.ipynb index 8eea1be7..a3d3470f 100644 --- a/doc/notebooks/single_precision.ipynb +++ b/doc/notebooks/single_precision.ipynb @@ -14,7 +14,7 @@ "\n", "In previous tutorials we saw how heyoka.py, in addition to the standard [double precision](https://en.wikipedia.org/wiki/Double-precision_floating-point_format), also supports computations in [extended precision](./ext_precision.ipynb) and [arbitrary precision](./arbitrary_precision.ipynb). Starting with version 3.2.0, heyoka.py supports also computations in [single precision](https://en.wikipedia.org/wiki/Single-precision_floating-point_format).\n", "\n", - "Single-precision computations can lead to substantial performance benefits when high accuracy is not required. In particular, single-precision [batch mode](<./Batch mode overview.ipynb>) can use a SIMD width twice larger than double precision, leading to an increase by a factor of 2 of the computational throughput. In scalar computations, the use of single precision reduces by half the memory usage with respect to double precision, which can help alleviating performance issues in large ODE systems. This can be particularly noticeable in applications such as [neural ODEs](./NeuralODEs.ipynb).\n", + "Single-precision computations can lead to substantial performance benefits when high accuracy is not required. In particular, single-precision [batch mode](<./Batch mode overview.ipynb>) can use a SIMD width twice larger than double precision, leading to an increase by a factor of 2 of the computational throughput. In scalar computations, the use of single precision reduces by half the memory usage with respect to double precision, which can help alleviating performance issues in large ODE systems. This can be particularly noticeable in applications such as [neural ODEs](./NeuralODEs_I.ipynb).\n", "\n", "In NumPy, single-precision values are represented via the {py:class}`numpy.single` data type. Correspondingly, and similarly to what explained in the [extended precision](./ext_precision.ipynb) and [arbitrary precision](./arbitrary_precision.ipynb) tutorials, single-precision computations are activated by passing the ``fp_type=numpy.single`` keyword argument to functions and classes in the heyoka.py API.\n", "\n", diff --git a/doc/notebooks/var_ode_sys.ipynb b/doc/notebooks/var_ode_sys.ipynb index 7c3ad114..ecccdc69 100644 --- a/doc/notebooks/var_ode_sys.ipynb +++ b/doc/notebooks/var_ode_sys.ipynb @@ -25,7 +25,7 @@ "\\boldsymbol{x} = \\boldsymbol{x}\\left(t, \\boldsymbol{x}_0, t_0, \\boldsymbol{\\alpha} \\right).\n", "$$\n", "\n", - "When solving numerically initial-value problems, it is often useful to compute not only the solution, but also its partial derivatives with respect to the initial conditions and/or the parameters. The derivatives with respect to the initial conditions, for instance, are needed for the computation of [chaos indicators](https://en.wikipedia.org/wiki/Lyapunov_exponent) and for [uncertainty propagation](https://en.wikipedia.org/wiki/Propagation_of_uncertainty), and they can also be used to propagate a small neighborhood in phase space around the initial conditions. The derivatives with respect to the parameters of the system are required when formulating optimisation and inversion problems such as orbit determination, trajectory optimisation and training of neural networks in [neural ODEs](./NeuralODEs.ipynb).\n", + "When solving numerically initial-value problems, it is often useful to compute not only the solution, but also its partial derivatives with respect to the initial conditions and/or the parameters. The derivatives with respect to the initial conditions, for instance, are needed for the computation of [chaos indicators](https://en.wikipedia.org/wiki/Lyapunov_exponent) and for [uncertainty propagation](https://en.wikipedia.org/wiki/Propagation_of_uncertainty), and they can also be used to propagate a small neighborhood in phase space around the initial conditions. The derivatives with respect to the parameters of the system are required when formulating optimisation and inversion problems such as orbit determination, trajectory optimisation and training of neural networks in [neural ODEs](./NeuralODEs_I.ipynb).\n", "\n", "There are two main methods for the computation of the partial derivatives. The first one is based on the application of automatic differentiation (AD) techniques directly to the numerical integration algorithm. This can be done either by replacing the algebra of floating-point numbers with the algebra of (generalised) [dual numbers](https://en.wikipedia.org/wiki/Dual_number) (aka truncated Taylor polynomials), or via [differentiable programming](https://en.wikipedia.org/wiki/Differentiable_programming) techniques. The former approach is used by libraries such as [pyaudi](https://github.com/darioizzo/audi), [desolver](https://github.com/Microno95/desolver) and [TaylorIntegration.jl](https://docs.sciml.ai/TaylorIntegration/stable/jet_transport/), while differentiable programming is popular in the machine learning community with projects such as [PyTorch](https://pytorch.org/), [JAX](https://jax.readthedocs.io/en/latest/) and [TensorFlow](https://www.tensorflow.org/). Differentiable programming is also popular in the [Julia programming language](https://en.wikipedia.org/wiki/Julia_(programming_language)) community.\n", "\n", @@ -757,7 +757,7 @@ "source": [ "## A note on computational efficiency\n", "\n", - "{class}`~heyoka.var_ode_sys` uses internally the {func}`~heyoka.diff_tensors()` and {class}`~heyoka.dtens` API to formulate the variational equations. This means that the computation of the symbolic derivatives is performed in an efficient manner. For instance, reverse-mode symbolic automatic differentiation will be employed when computing the first-order variationals of ODE systems containing a large number of parameters (e.g., in [neural ODEs](./NeuralODEs.ipynb)).\n", + "{class}`~heyoka.var_ode_sys` uses internally the {func}`~heyoka.diff_tensors()` and {class}`~heyoka.dtens` API to formulate the variational equations. This means that the computation of the symbolic derivatives is performed in an efficient manner. For instance, reverse-mode symbolic automatic differentiation will be employed when computing the first-order variationals of ODE systems containing a large number of parameters (e.g., in [neural ODEs](./NeuralODEs_I.ipynb)).\n", "\n", "See the [computing derivatives](<./computing_derivatives.ipynb>) tutorial for a more in-depth discussion of how heyoka.py computes symbolic derivatives." ]