{ "cells": [ { "cell_type": "markdown", "metadata": { "id": "C4nZjbMHWcm_" }, "source": [ "# OTT vs. POT\n", "\n", "The [Python Optimal Transport (POT)](https://pythonot.github.io/) toolbox paved the way for much progress in OT. `POT` implements several OT solvers (LP and regularized), and is complemented with various tools (barycenters, domain adaptation, Gromov-Wasserstein distances, sliced W, etc.).\n", "\n", "The goal of this notebook is to compare the performance `OTT`'s {class}`~ott.solvers.linear.sinkhorn.Sinkhorn` and `POT`'s {func}`~ot.sinkhorn` solvers. `OTT` benefits from just-in-time compilation, which should give it an edge.\n", "\n", "The comparisons carried out below have limitations: minor modifications in the setup (e.g. data distributions, tolerance thresholds, type of accelerator...) could have an impact on these results. Feel free to change these settings and experiment by yourself!" ] }, { "cell_type": "markdown", "metadata": { "id": "dpTlNSRqXevL" }, "source": [ "## Installs toolboxes" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "import sys\n", "\n", "if \"google.colab\" in sys.modules:\n", " !pip install -q git+https://github.com/ott-jax/ott@main\n", " !pip install -q POT" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "import timeit\n", "\n", "import ot\n", "\n", "import jax\n", "import jax.numpy as jnp\n", "import numpy as np\n", "\n", "import matplotlib.pyplot as plt\n", "import mpl_toolkits.axes_grid1\n", "\n", "import ott\n", "from ott.geometry import pointcloud\n", "from ott.problems.linear import linear_problem\n", "from ott.solvers.linear import sinkhorn" ] }, { "cell_type": "code", "execution_count": 3, "metadata": { "id": "ysURew0UKhHE" }, "outputs": [], "source": [ "plt.rc(\"font\", size=20)" ] }, { "cell_type": "markdown", "metadata": { "id": "rzeoMqPlcGMT" }, "source": [ "## Regularized OT in a nutshell\n", "\n", "We consider two probability measures $\\mu,\\nu$ compared with the squared-Euclidean distance, $c(x,y)=\\|x-y\\|^2$. These measures are discrete and of the same size in this notebook:\n", "\n", "$$\\mu=\\sum_{i=1}^n a_i\\delta_{x_i}, \\nu =\\sum_{j=1}^n b_j\\delta_{y_j},$$\n", "\n", "to define the OT problem in its primal form,\n", "$$\\min_{P \\in U(a,b)} \\langle C, P \\rangle - \\varepsilon H(P).$$\n", "\n", "where $U(a,b):=\\{P \\in \\mathbf{R}_+^{n\\times n}, P\\mathbf{1}_{n}=b, P^T\\mathbf{1}_n=b\\}$, and $C = [ \\|x_i - y_j \\|^2 ]_{i,j}\\in \\mathbf{R}_+^{n\\times n}$.\n", "\n", "That problem is equivalent to the following dual form,\n", "$$\\max_{f, g} \\langle a, f \\rangle + \\langle b, g \\rangle - \\varepsilon \\langle e^{f/\\varepsilon},Ke^{g/\\varepsilon} \\rangle.$$\n", "\n", "These two problems are solved by `OTT` and `POT` using the *Sinkhorn iterations* using a simple initialization for $u$, and subsequent updates $v \\leftarrow a / K^Tu, u \\leftarrow b / Kv$, where $K:=e^{-C/\\varepsilon}$.\n", "\n", "Upon convergence to fixed points $u^*, v^*$, one has $$P^*=D(u^*)KD(v^*)$$ or, alternatively, \n", "$$f^*, g^* = \\varepsilon \\log(u^*), \\varepsilon\\log(v^*)$$" ] }, { "cell_type": "markdown", "metadata": { "id": "OhSVMQUWYZiY" }, "source": [ "## OTT and POT implementation\n", "\n", "Both toolboxes carry out Sinkhorn updates using either the formulas above directly (this corresponds to `lse_mode=False` in `OTT` and `method='sinkhorn'` in `POT`) or using slightly slower but more robust approaches:\n", "\n", "`OTT` relies on log-space iterations (`lse_mode=True`), whereas `POT`, uses a stabilization trick , using the `method='sinkhorn_stabilized'` flag, designed to avoid numerical overflows, while still benefitting from the speed given by matrix vector products. \n", "\n", "The default behaviour of `OTT` and [POT](https://github.com/PythonOT/POT/blob/f6139428e70ce964de3bef703ef13aa701a83620/ot/bregman.py#L413) is to carry out these updates until $\\|u\\circ Kv - a\\|_2 + \\|v\\circ K^Tu - b\\|_2$ is smaller than the user-defined `threshold`." ] }, { "cell_type": "markdown", "metadata": { "id": "yjjlf297b-WF" }, "source": [ "## Common API for `OTT` and `POT`\n", "\n", "We will compare in our experiments `OTT` vs. `POT` in their more stable setups (`lse_mode` and `stabilized`). We define a common API for both, making sure their results are comparable. That API takes as inputs the measures' info, the targeted $\\varepsilon$ value and the `threshold` used to terminate the algorithm. We set a maximum of 1000 iterations for both." ] }, { "cell_type": "code", "execution_count": 6, "metadata": { "id": "cM2cM87nZ6XU" }, "outputs": [], "source": [ "def solve_ot(a, b, x, y, 𝜀, threshold):\n", " _, log = ot.sinkhorn(\n", " a,\n", " b,\n", " ot.dist(x, y),\n", " 𝜀,\n", " stopThr=threshold,\n", " method=\"sinkhorn_stabilized\",\n", " log=True,\n", " numItermax=1000,\n", " )\n", " f, g = 𝜀 * log[\"logu\"], 𝜀 * log[\"logv\"]\n", " f, g = f - np.mean(f), g + np.mean(\n", " f\n", " ) # center variables, useful if one wants to compare them\n", " reg_ot = (\n", " np.sum(f * a) + np.sum(g * b) if log[\"err\"][-1] < threshold else np.nan\n", " )\n", " return f, g, reg_ot\n", "\n", "\n", "@jax.jit\n", "def solve_ott(a, b, x, y, 𝜀, threshold):\n", " geom = pointcloud.PointCloud(x, y, epsilon=𝜀)\n", " prob = linear_problem.LinearProblem(geom, a=a, b=b)\n", "\n", " solver = sinkhorn.Sinkhorn(\n", " threshold=threshold, lse_mode=True, max_iterations=1000\n", " )\n", " out = solver(prob)\n", "\n", " f, g = out.f, out.g\n", " f, g = f - np.mean(f), g + np.mean(\n", " f\n", " ) # center variables, useful if one wants to compare them\n", " reg_ot = jnp.where(out.converged, jnp.sum(f * a) + jnp.sum(g * b), jnp.nan)\n", " return f, g, reg_ot" ] }, { "cell_type": "markdown", "metadata": { "id": "bPWuBwYvC-y-" }, "source": [ "To test both solvers, we run simulations using a random seed to generate random point clouds of size $n$. Random generation is carried out using {func}`jax.random.PRNGKey`, to ensure reproducibility. A solver provides three pieces of info: the function (using our simple common API), its numerical environment and its name." ] }, { "cell_type": "code", "execution_count": 7, "metadata": { "id": "kchT2nnMKl2q" }, "outputs": [], "source": [ "dim = 3\n", "\n", "\n", "def run_simulation(rng, n, 𝜀, threshold, solver_spec):\n", " # setting global variables helps avoir a timeit bug.\n", " global solver_\n", " global a, b, x, y\n", "\n", " # extract specificities of solver.\n", " solver_, env, name = solver_spec\n", "\n", " # draw data at random using JAX\n", " rng, *rngs = jax.random.split(rng, 5)\n", " x = jax.random.uniform(rngs[0], (n, dim))\n", " y = jax.random.uniform(rngs[1], (n, dim)) + 0.1\n", " a = jax.random.uniform(rngs[2], (n,))\n", " b = jax.random.uniform(rngs[3], (n,))\n", " a = a / jnp.sum(a)\n", " b = b / jnp.sum(b)\n", "\n", " # map to numpy if needed\n", " if env == \"np\":\n", " a, b, x, y = map(np.array, (a, b, x, y))\n", "\n", " timeit_res = %timeit -o solver_(a, b, x, y, 𝜀, threshold)\n", " out = solver_(a, b, x, y, 𝜀, threshold)\n", " exec_time = np.nan if np.isnan(out[-1]) else timeit_res.best\n", " return exec_time, out" ] }, { "cell_type": "markdown", "metadata": { "id": "DxySanaEOwYX" }, "source": [ "Defines the two solvers used in this experiment:" ] }, { "cell_type": "code", "execution_count": 8, "metadata": { "id": "EWmVxyysvEKT" }, "outputs": [], "source": [ "POT = (solve_ot, \"np\", \"POT\")\n", "OTT = (solve_ott, \"jax\", \"OTT\")" ] }, { "cell_type": "markdown", "metadata": { "id": "szWoHukXOz08" }, "source": [ "## Runs simulations with varying $n$ and $\\varepsilon$\n", "We run simulations by setting the regularization strength 𝜀 to either $10^{-2}$ or $10^{-1}$.\n", "\n", "We consider $n$ between sizes $2^{8}= 256$ and $2^{12}= 4096$. We do not go higher, because `POT` runs into out-of-memory errors for $2^{13}=8192$ in this RAM restricted colab environment. `OTT` can avoid these by setting the flag `batch_size` to, e.g., `1024`, as done in the tutorial for grids, and also handled by the [GeomLoss](https://www.kernel-operations.io/geomloss/) toolbox. We leave the comparison with `geomloss` to a different NB. \n", "\n", "When `%timeit` outputs execution time, **notice the warning message** highlighting the fact that, for `OTT`, at least one run took significantly longer. That run is that doing the **JIT pre-compilation** of the procedure, suitable for that particular problem size $n$. Once pre-compiled, subsequent runs are order of magnitudes faster, thanks to the {func}`jax.jit` decorator added to `solve_ott`." ] }, { "cell_type": "code", "execution_count": 6, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "9VWhb6B3VFJN", "outputId": "7b85bed2-903e-465f-b7eb-cf8479554c4e" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "----- POT\n", "10 loops, best of 5: 43.7 ms per loop\n", "100 loops, best of 5: 11.9 ms per loop\n", "1 loop, best of 5: 230 ms per loop\n", "10 loops, best of 5: 41.4 ms per loop\n", "1 loop, best of 5: 33.4 s per loop\n", "10 loops, best of 5: 155 ms per loop\n", "1 loop, best of 5: 2min 13s per loop\n", "1 loop, best of 5: 367 ms per loop\n", "1 loop, best of 5: 6min 21s per loop\n", "1 loop, best of 5: 1.22 s per loop\n", "----- OTT\n", "The slowest run took 66.78 times longer than the fastest. This could mean that an intermediate result is being cached.\n", "1 loop, best of 5: 11.2 ms per loop\n", "1000 loops, best of 5: 1.04 ms per loop\n", "The slowest run took 128.37 times longer than the fastest. This could mean that an intermediate result is being cached.\n", "1 loop, best of 5: 6.12 ms per loop\n", "1000 loops, best of 5: 1.08 ms per loop\n", "The slowest run took 94.84 times longer than the fastest. This could mean that an intermediate result is being cached.\n", "1 loop, best of 5: 8.95 ms per loop\n", "1000 loops, best of 5: 1.42 ms per loop\n", "The slowest run took 33.90 times longer than the fastest. This could mean that an intermediate result is being cached.\n", "1 loop, best of 5: 24 ms per loop\n", "100 loops, best of 5: 3.47 ms per loop\n", "The slowest run took 8.19 times longer than the fastest. This could mean that an intermediate result is being cached.\n", "1 loop, best of 5: 112 ms per loop\n", "100 loops, best of 5: 14.3 ms per loop\n" ] } ], "source": [ "rng = jax.random.PRNGKey(0)\n", "solvers = (POT, OTT)\n", "n_range = 2 ** np.arange(8, 13)\n", "𝜀_range = 10 ** np.arange(-2.0, 0.0)\n", "\n", "threshold = 1e-2\n", "\n", "exec_time = {}\n", "reg_ot = {}\n", "for solver_spec in solvers:\n", " solver, env, name = solver_spec\n", " print(\"----- \", name)\n", " exec_time[name] = np.ones((len(n_range), len(𝜀_range))) * np.nan\n", " reg_ot[name] = np.ones((len(n_range), len(𝜀_range))) * np.nan\n", " for i, n in enumerate(n_range):\n", " for j, 𝜀 in enumerate(𝜀_range):\n", " t, out = run_simulation(rng, n, 𝜀, threshold, solver_spec)\n", " exec_time[name][i, j] = t\n", " reg_ot[name][i, j] = out[-1]" ] }, { "cell_type": "markdown", "metadata": { "id": "zruxPCbHN1HY" }, "source": [ "## Plots results in terms of time and difference in objective\n", "\n", "When the algorithm does not converge within the maximal number of 1000 iterations, or runs into numerical issues, the solver returns a NaN and that point does not appear in the plot." ] }, { "cell_type": "code", "execution_count": 24, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 540 }, "id": "xj_9C6-3uHMH", "outputId": "736a26fd-3a0f-4b0f-b107-843a84503bc7" }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light", "tags": [] }, "output_type": "display_data" } ], "source": [ "list_legend = []\n", "fig = plt.figure(figsize=(14, 8))\n", "\n", "for solver_spec, marker, col in zip(solvers, (\"p\", \"o\"), (\"blue\", \"red\")):\n", " solver, env, name = solver_spec\n", " p = plt.plot(\n", " exec_time[name],\n", " marker=marker,\n", " color=col,\n", " markersize=16,\n", " markeredgecolor=\"k\",\n", " lw=3,\n", " )\n", " p[0].set_linestyle(\"dotted\")\n", " p[1].set_linestyle(\"solid\")\n", " list_legend += [name + r\" $\\varepsilon $=\" + f\"{𝜀:.2g}\" for 𝜀 in 𝜀_range]\n", "\n", "plt.xticks(ticks=np.arange(len(n_range)), labels=n_range)\n", "plt.legend(list_legend)\n", "plt.yscale(\"log\")\n", "plt.xlabel(\"dimension $n$\")\n", "plt.ylabel(\"time (s)\")\n", "plt.title(\n", " r\"Execution Time vs Dimension for OTT and POT for two $\\varepsilon$ values\"\n", ")\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": { "id": "ma5sqdMtzggT" }, "source": [ "For good measure, we also show the differences in *objectives* between the two solvers. We substract the objective returned by `POT` to that returned by `OTT`.\n", "\n", "Since the problem is evaluated in its dual form, a *higher* objective is *better*, and therefore a positive difference denotes better performance for `OTT`. White areas stand for values for which `POT` did not converge (either because it has exhausted the maximal number of iterations or experienced numerical issues)." ] }, { "cell_type": "code", "execution_count": 21, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 357 }, "id": "RCoef_sbzyFn", "outputId": "42851943-d6e7-4765-9432-5f95237a4b4f" }, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAzsAAAFUCAYAAAADEiKJAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOzdebhcVZ3u8e+biBAChFlQlAASoEVERQYjMikiqKCg7dC0QZRGQRDUKyJKUHHoblFA6Tb2hdjYilxRQUWZQWQUWlQUCFMQDIiEeYac3/1jrc3ZqVSdqtpVJ7Ur5/08z3722dNaq8azf7UmRQRmZmZmZmbLmkmDLoCZmZmZmdl4cLBjZmZmZmbLJAc7ZmZmZma2THKwY2ZmZmZmyyQHO2ZmZmZmtkxysGNmZmZmZsskBztmS4Gk2ZJC0txBl6UTvZRX0vR87dCMa1+UV9L0QZfFqpE0N7+GswddFmtvaX5PDNv3r5n1l4Mdqx1JK0j6kKQzJN0u6VFJT0m6R9KFkr4gaYtBl9PqT9KO+UZnr0GXZdhJeoOkn0m6V9KTkm6VdLykFwy6bBOBpPXyd9/Vkv6evxMXSDpf0qGSpja55rmAosIyv+q1g3h+6kjSlvn7Z1ab8z6Wz5u+VApmNsE8b9AFMCuT9FZgDrBOafeTwGPAWsBOeTlK0rnA+yLivqVe0O7dB9wE3D3ogiwFz5Aeax3sCBwNfBf46RjnFeV9ZrwLNIwkfQb4Yt4cAR4FNgQOAd4jaeeIuH5Q5VvWSfo48AVgSt61CHiY9D25LrAL8ClJ/xwR55cuXQT8rUWya5F+8HyM9Ho2uh1Yocn+lYCppPfB37t7JIup0/fEeNmS9P1zCTB3jPM+BqwPXAzMH+9CmU00rtmx2pC0P+mGdB3SP8EPAC+MiCkRsTrwfODVwGeBBcCuwHoDKm5XIuKbEbFpRHx60GUZbxHx1/xYNx10WTpVlDci/jrostSNpN0ZDXS+BqwaEdOAzYHrSDfNZ0pafkBFXKZJ+hLw76RA5zxgB2D5/J04FdgHmEcKes6W9Jbi2oi4MyLWabYAd+bT/r3FOTu1uO7f83Vjpd3WMH5PmNlwcrBjtSDpVcBJpPfkmcCWEXFKRDxXExIRiyLifyPii8AGpBsw/xJvViLp7ZJW7mOSX8rrn0TEJyLiEYCI+BPwVkZreQ7oY54GSNoDKH4g+VZE7BoRv46IRQAR8UREnAFsBVwJLAf8t6QXDabEZmb142DH6uKLpJqbO4B/iognxzo5Ip6OiM/mG67FSHqVpK9I+o2kv+S27QslXSzpg5ImN0uz3IlV0iRJh0n6vaTH8vVnSdq6yoMbq4NsuXO8pJdI+o6ku3K5b5f075JWqZJvTn+VnP/vc/+nRyX9QdIxkqZ1cH1Xz4U66HgsaS1JX5b0x1yexyRdL+lYSau3Kc9mkv5T0jxJj0t6MKdzgqRXl8tAakIC8P4mfQuml9Jstu+8vO/fGYOkb+fzftLk2CRJ++a0/i7paaV+Fj+UtM1Y6fbg68A9kr6r1GdJVROS9DLgFXnz3xqPR8RdwA/y5vu6SHf7/Jzd2+TYpPyahqQbmhxfSdIzja9XwzmTcz+I3+f3yP2Sfi5pqzblWknSkZJ+K+khpb5JN+f31otbXHNxLsssSVPyZ+0mSU8o9W86TdLGnT0zS/hqXv+e1NSpqRyAvht4HFgNOKJifktNu+8JSXtKOlvS3/LrfX9+Xn8g6R97yLfSd3u3n+X8uE7Jmzs0+f4p+hMGqQkbwEUN51zcJN1e36OrSvqqpBuL78+unkCzYRQRXrwMdAFeDEReDutDeveV0nsMeKC0HcAvgOc1uW52Pv5d4Mf572eAB0vXPgv8Y4UyFWnPbXKsSHtPYGH+++Gcd3Hst8ByFfJ9KakNePn5eKy0fQewcT+fC2B6cU6LMr2u9DgDeAp4orT9F2CTFtd+NOdbnPtow+t7cek9dU8+Hjn9exqWFzd5DaaX9u2X990JTGpRnuVKj+WdDcdWJjU7KtIeAR4qbS8CDh6Hz9OFDe/320hB3/QKaR2c03hwjOdg79LjW6nDdJcvveabNRx7VUP51244vmvx3m3YPzfv/yLwq/z308AjpbSeALZrUabNWPyz8kzp/RPA/cDMJtddnI8fAvxv/vtJUuBRXLsQ2KjL535m6fr3dHjNnNLn4vltzi0e6+wuyzU7Xze/x/fp9OLxNTl2bMN74GEW/464p2KZK323U+GzTPqOKc55miW/f14LfCL/vaj0Hiuf8+M+v0c/Cdxaeo8+DDzYy+voxcswLAMvgBcvwD+Vvqxn9CG975N+5VyntG9qzufu4ku/yXXFP8QH8z++w4Ap+dhGwLn5+ON0f+NSpD23ybHisT8AXABsnvcvT+q39GQ+/pEu83w+6RfhIoB4I6C87EIKdAK4ntQHoC/PBWPfxKzPaHByEikYm5SXzYFz8rE/AZMbrn1n6bn6f5RukoHVSTULX+v0eW/xGkwv7ZvG6A3WDi2u24PRm7EVGo79JB+7lnSDvkLevxrwGdIN0CKa3Jz04TPwauBEFg/8R/L765+AFTtM56R87RVjnLNZKY+tuijjxfmaAxv2H1Z6TgPYp+F4cSP83w375zL6OVoIvIt8ww9sAfwxH7+6SVmmkTrkB3B6Pn9yPrYh8D/52D2kPkvNHscDOY03AZPze3p7UrAcwOldvoafYfRGutMgcvfSa/HaNufOp4bBTt5f3Px/CVizdGwtUnD9fyuWudJ3OxU/y8AsSj/CdPBa7DjGOf14jz5C+l+wG/nHC+ClvbyOXrwMwzLwAnjxwujNyxOAxjmv7XNetzc5VvxDDOAzTY6vANyYj/9Xl/kWac9tcqzIc4mgIx8/MR+/sMs892X0V8XNmxx/WT4WwAf69VwwdrDzvXzsyy3KXA7Q9intXw64K+//fj+e9xavwfSG/Wfk/d9ucV3xeL7bsP8Nef+NwLQW1x6Rz/n5OL7flwPeThr44+nS43wI+A7tb4iLm7wzxjhnWindt3ZRtmPyNT9o2P/TvL/4Xjix4fhv8v79G/bPLZXjdU3ye3Xp+Esajn2x3XsL+GU+5xMN+y9m9EZ5iRtHRmu+nqRNbUvDdcXN67wurlmv9Bj3b3PufOoZ7Lwr77+hj5+D2aXnpdvvs8qfZfob7PTjPdr0f4EXL8v64j47VgdFH40HIyKanSDpM0rz7DQux3eTUURcSvp1b7qkF7Y47XHgG02ufZI0GhXA3r30hWjhuIh4qsn+YsjkzbtMb5+8PjOaDAscqb/Tj/Lmu1qk0bfnQtKKpNqZEeC4ZudExNOlMr2xdGgX4EWkX08/2S6vPvp+Xu8jabnyAUlTSE0Py+cV3p/X34mIh1qk/T95vZNa9CPrVUQ8ExE/iYi9SM/fx4DfAasAHwQuy/0gjlDzTu3F3C1PjJHN46W/V+qieL/O6x2KHfl9tD3pF+jjybVqpeNTgNfkzUtapHtpRPymcWdEXEsKmGHJz1Lxen2N1orX+I0tjv8oIm5psv8s0uNYnlST2anie3FhF9eUh+Ffo4vr6uThvJ6WvzP6qcr3WS0+y/TnPfrLZv8LzJZ1nmfHhsXKQLPJC5t2sJf0TlKzpleRmj40my/ihaQhrBtdExGPtShHcYO1KmlEuNvGKHO3fttifzEc8mpdpveqvL5ojHMuBN5TOrdRP5+LV5NqbgL44xjxUTGXSLmz7bZ5/ftYusND/4J087U6qXnSz0vH3ka6ub8XOL/hutfm9VGS2gVnK5JuTJforN9PEfF3UgBxvKSXk351fh8wA/gycKyk9SMNOrA0XEHqc7CupI0j4mbg5aTn+lcRca+k64HNJa0REQuB7UjvoQUtAgto/TmC9Flaj9JnKXfqLoawP7tVh/mcLyz+vmybb0Q8kwdieAHdf4YnoqtIfU/WBa6Q9C3gvIi4vQ9pV/k+G/hnuY/v0Sv6WS6zYeFgx+rg/rxeVZKa1e5ExBGURhiS9D2ajP4k6Xmk9sxvL+1+ivSL56K8XUymt8SM49lYN9PlY2vR32DnkRb7i5Hpuv28rpXXYz2e4sZ2jRbPfT+fi3XzWjQPXBuVf9Utzv9LB9f1TUQ8KenHpMDgPSwe7Lwnr0+PPBRwSfFYV+0wq37/gj2miPijpNNIn4EPMdpvqvE9VtwYTqG1ctmbTU7ZqgyPS/ot6WZyB+BmRmtxLs7rS0gB0PakGs7i+K9prdXnCEY/S+VaunVLf6/dtuCtX6tu822n+F7spoZmzSbXD5WIeEDSvqQmolsA3waQdA+pb83JEdGqVq+dKt9ndfgs9+s92ssksGZDy83YrA6K4WVXAKoO0Vr4ECnQeZw0OtKLI2KFiFgrRie8K2pz+t0Mra6a1WoNQvF981BEqINlx0EWtqRoGrJn0axG0qrAmxuOlxWP9e0dPtb54/sQEknr5SZrNwBXA/+Sy/pb4CMsWdNZbLdq8tl47O6WZzXX2JStWF/SsG51vB/K/wdX6+C1mt7HvMdSfC9uJKnT5oFblP7+c5/Ls9RExNmk2pUDSD9eLSBNNv3PwMWS5izF4tThs9yv92jjjzJmE4KDHauD8o3LHj2m9c68/kJEnNjYJCe3p15zycsW0+mNXd1/JSvK95IxzimaRixs0V+qn8/F3/J6FXUwv0+La9fv8rp+uJA0wtFUUtM1gHeQmozcHhHNmoYU5R3ruV8qJK0o6Z8knUcage/LwKakMn6N1GF564j4j9xnqqy4Yd5MUqv/F/+Q18HoDXqnGoOZ15Nqh67J288FQ5KWB7ZpuK4f/lb6e+CvV0nR/HQSafLWTuyV148x+hwOpYh4KCK+ExH/GBEvIg2o8p18+ENKE652q8r3WR0+y3V9j5oNBQc7NnARcSdpFBmAQ7v4FbOZ4ub9dy2Oz6R9TcdWY3SMLW7KHiQNA1pn/5vXO41xzs4N5zbq53NxDWnYV5GGPu3GlXm9RYuO9K2M5HXlWrzcRO30vPnevC6asP1gySuA0bbxb25xfFwp2VHSKaQbpVNJo0otIjUH2xNYLyI+EU0m5i0pbrinMTowQKNd8/qqMfpDtHJZLtOLJb2F1Hzo8oh4FiAi7iWNgvUKUp+pFYB7I6LboKql3BekuJkcyOvVTERcRhqCHeD/5Ca6LUlan9GmvXObBK5DLSL+HBEHMPpdsMNY57dQ5fusl89yp98/Y55X1/eo2bBwsGN1cRRpWMz1ge9Jqtr0qhgt5+WNB/LNwhc7SGMqcGiT65cHDs+bP2o1clyNFKOavVnSKxsPSnoZoyO2nd54POvbcxFplvcz8ubnJa3c6lxJz2sIei8gtamfDPxbu7xKipGdOm1v30rRVO1NkjZjNIBs1oQN0jDIxfljBnaS+tppXdKnSDdrF5H6Gq1EmmPmcOBFEfH2iDirCCjGEhF/Jg0FDk1GwcsjGhaB3/80Hu8g/UcY/WHic3l9ccNpl5D+Vx2Vt8fqr1PV3Lz+xFjBdA4ie30vdePTeb0lTUYRK+TPymmkvhoPAl8d/6KND0nPb3NKMTLg8hWSr/J9Njevq3yWO/3+6eS8ohx1e4+a1Z6DHauFiPhfUp+BEdKvztdJ+oCk5zpm5i/xjfKIOG9qkdR5ef1ZSXsWw4BK2hT4GbA1o52uW3kI+IKkQ/NQt0jaEDiTNIHik8BXqjzOpeyHwB/y3z+V9IZiSFVJuwBnkzpM/4nWN6r9fi6OIHWcngFcLmm3Ykjn/PpuLOlw0q/5WxUXRcQzwMfz5nsknZ5fU/K1q0v6kKQTGvIrfhl/naTK/cEi4irSzOPPJ3Wcngz8oVWtSET8ijRTu4CfSPqkpGLAiKK8e0k6iybDcEuaLykkza1Q3A8zOnnrt0gTfW4REV/PI7J168i83lvSvxZBqqR/IH2mViZ15v5Oi+vbKYKXVkNKX9LmeD98hfQY1iS9L99VvN8BJL1E0gGkGtC9WqTRdxHxM0aD+4MknSNp+6JJoaQpkvYm1ZpuSxrdblauLR9WH86P870N3/+rSjoS2DHvOqdC2l1/n/X4WS6+H/5B0ja0Vpz3njF+6Kvle9RsKEQNJvvx4qVYSG3T72Z0Argg/ZL3d9I/ovL+s4FNGq5fHbildM7TpH9wQWpCNYsWE7gxOvHcd0n/3IrrHyil9yzw7gqPq0h7bpNjRdrTW1w7vTinQr4vLT3eIAV6j5W27wBmjFHerp+LduUl3bT+teE1uo80al759d2hybWHMzq7epBGwCqX6eKG85crvR9GSEPCzs/Lep2+BvmcLzSU71NtnvupjE7KWeT/AOlX3HI6pzS5tnjNlni/dPCafwf4R5pMUNvD5/Kohtf9odL23+lhokJSP6jy+3O5huMvbHi+Xt4inbm0mSST0ckVZ7X4rPy54XHeRxrspJz/+ztNs8nruWPF5+j/kL4HizI8Q/rRYKS0725g1y7SLMrU8vlqcd1sxndS0Y81PN+PsvhnPGgxyW8HZa703d7jZ/mS0vGFjH7/bFs6Z+fSOU8Bd+ZzTlta71EvXpblxTU7ViuRfsnckDQKz09IN+MjpEkQHyD94/gS8LKI2D0ibmq4/n7SL5z/weiwyk+Qh62NiLmdFIM00MHhpA7Xz895/5w04/xpPTzEpSrSXCSvAD4PlCeTu550875FRMwbKwn6/FxExG9JHeQ/BVxOuplZlfQP+xrgBNJrtcQv+BFxHPBK4BTSzcByuYx/IM0hc1jD+c+QJiQ9lRRgrUaq9Vif7ofyLjdZC1r31ynyfiwi3g68hXSDtYDUzKgIwE4H9gM+Wr4uN7csBtEYa86YVvl+KCJ+GM0nqK0kIr5ImqjwF6TXf3nSr8wnkAKdXiYqvJTRPguX59esnPcC0vMF6QZ/XCZFzJ+VV5JqmC8iPc5ppBvKPwBzSAOofG888m9Ttn8FNiF9911Lusku5ni6kPS+3zgizl3aZRsH3yeNqvlD0nfOM6THejdpgta3RcS/VEy70vdZ1c9y9g7gJFLT0pUY/f55rgYnIi4kjSJ6Cen/1YvyOes0lKO271GzOlNEDLoMZrUgaTZwNPDdiJg12NIML0kvJc2Z8nREVGlXP6FJ2pbUKfqvwEb9DFrMzMwmGtfsmFm/FUO49nUW8Qlkh7z+qgMdMzOz3jjYMbO+yR1mD86bVw+yLEPs9aQmO1U7/JuZmVnWbZt1M7OmJF1AqpWYTOqDcfxgSzScIqLXiXXNzMwsc82OmfXLGqQRjq4G9oqI8ZgPxczMzKxjHqBgnDx/0pSY8rxVBl0MW9pipP05tszZ+BXrD7oIZmY2zq699tr7ImKtZsfetNPUWHj/oqVdpOdc+4enzomIMSe+najcjG2cTHneKrz2Be8edDFsKYsnnxx0EWwAfnXNtwddBDMzG2eS7mh1bOH9i7j6nJcszeIsZvK6N6/Z/qyJycGOmZmZmVkP0myzbt1RRw52zMzMzMx6EixyU/ZacrBjZmZmZtaDVLPjfvB15GDHzMzMzKxHbsZWTw52zMzMzMx6EASLPMJxLXmeHTMzMzOzHo0QA1s6JWk9SSdLWiDpKUnzJX1D0mrdPFZJq+fr5ud0FuR012tx/j6STpR0qaSHJYWk73WQz2slnS3pfklPSPqDpI9JmtxpWV2zY2ZmZmbWgwAW1bzPjqSNgMuBtYEzgRuBrYFDgd0kzYyIhR2ks0ZOZwZwIXAasCmwH7CHpO0i4raGy44CXgE8CtyVz2+Xz57AGcCTwA+B+4G3Al8HZgLvbJcGONgxMzMzM+vZEAxQcBIp0DkkIk4sdko6DjgMOBY4sIN0vkQKdI6LiI+X0jkEOD7n0zjB6WGkIOcWYAfgorEykLQK8B1gEbBjRFyT93+WFGDtI+ndEXFau8K6GZuZmZmZWQ8CWBQxsKWdXKuzKzAf+FbD4aOBx4B9JU1tk85KwL75/NkNh78J3AG8SdKGiz0/ERdFxM0RHXds2gdYCzitCHRyOk+SaokAPtxJQg52zMzMzMx6NDLApQM75fW5EYtPCBQRjwCXASsC27ZJZ1tgCnBZvq6czghwTkN+Ve2c179qcuzXwOPAayUt3y4hBztmZmZmZj0IgkUDXDqwSV7Pa3H85ryesZTSaadlPhHxLHA7qTvOho3HG7nPjpmZmZlZLwIWDbbLzpqSriltz4mIOaXtaXn9UIvri/2rtsmnX+m007d8HOyYmZmZmfUg6Lg52Xi5LyK2GmwR6snBjpmZmZlZT8QiNOhCjKWoCZnW4nix/8GllE47fcvHfXbMzMzMzHoQwEgMbunATXndqi/Nxnndqi9Ov9Npp2U+kp4HbAA8CzTO57MEBztmZmZmZj1alGt3BrF0oJjXZldJi93/S1qZNEnn48CVbdK5EngCmJmvK6cziTS8dTm/qi7M68b5egBeTxo57vKIeKpdQg52zMzMzMx6ENQ72ImIW4FzgenAQQ2HjwGmAqdGxGPFTkmbStq0IZ1HgVPz+bMb0jk4p39ORLStcWnjR8B9wLslPdcXSdIKwBfz5n90kpD77JiZmZmZ9Wgkat1nB+AjwOXACZJ2AW4AtiHNiTMP+EzD+TfkdeMDOxLYEThc0pbA1cBmwJ7AvSwZTCFpL2CvvLlOXm8naW7++76I+ERxfkQ8LOlDpKDnYkmnAfcDbyMNS/0j4IedPGgHO2ZmZmZmPShqduosIm7NtSSfJzUP2x24GzgeOCYiHugwnYWStgOOJgUw2wMLgVOAz0XEXU0u2xJ4f8O+DRmdJ+cO4BPlgxHxU0k7kIKwvYEVgFuAw4ETIqKj3koOdszMzMzMehCIRUPQOyQi7gT26/DcltFbRNwPHJqXTtKazZLN3jq57jJSUFaZgx0zMzMzsx4NQTO2CcnBjpmZmZlZD4ahGdtE5WDHzMzMzKwnYlHUvxnbRORgx8zMzMysBwGMDEGfnYnIwY6ZmZmZWY/cjK2eHOyYmZmZmfUgws3Y6srBjpmZmZlZj0Zcs1NLDnbMzMzMzHqQRmNzzU4dOdgxMzMzM+uJm7HVlYMdMzMzM7MeeDS2+nKwY2ZmZmbWg0A8HZMHXQxrwsGOmZmZmVmPRtyMrZYc7JiZmZmZ9cADFNSXgx0zMzMzsx4EYlF46Ok6crBjZmZmZtYjD1BQTw52zMzMzMx6EIGHnq4pBztmZmZmZj0RI7gZWx052DEzMzMz60Hgmp26crBjZmZmZtYjj8ZWTw52zMzMzMx6EIgRj8ZWSw52zMzMzMx65JqdenKwY2ZmZmbWgwBG3GenlhzsmJmZmZn1RCzyaGy15GDHzMzMzKwHrtmpLwc7ZmZmZmY9cs1OPTnYMTMzMzPrQYRcs1NTDnbMzMzMzHrkSUXrycGOmZmZmVkPAhhxM7ZacrBjZmZmZtYTuWanproOdiQtFxHPjEdhzMzMzMyGTRqNzTU7dVSlZudUSVtExD/0vTRmZmZmZkNoEa7ZqaMqwc4rgNtaHZS0AvBN4JSIuKxqwczMzMzMhkEg1+zUVJUQ9IXAzcWGpNdJelexHRFPApsAh/RePDMzMzOz+hth0sAWa63KszMZeKy0vQvwg4Zz/gS8qmqhzMzMzMyGRQQsCg1s6ZSk9SSdLGmBpKckzZf0DUmrdfN4Ja2er5uf01mQ012vX3lLmizpfZIulXSPpMclzZN0iqSXdVrWKs3YFgAbl7ZXzgUqD1xwH7BOhbTNzMzMzIZO3ZuxSdoIuBxYGzgTuBHYGjgU2E3SzIhY2EE6a+R0ZgAXAqcBmwL7AXtI2i4ibmu4pkre3wfeBdwF/Bh4BHg58H7gvZLeHBEXtitvlWDnfGCWpFcANwBvzvtfmrcBpgHLVUjbzMzMzGyopD47tW9OdhIp2DgkIk4sdko6DjgMOBY4sIN0vkQKdI6LiI+X0jkEOD7ns1sveUt6DSnQ+ROwdUQ8Xjq2H3AycBQp2BpTlVfl+Lz+LfBXYA3gGuAjuQCTgDfmY5UNqppN0j6STsxVZg9LCknf6+WxmJmZmdmybREa2NJOrlnZFZgPfKvh8NGkLir7SpraJp2VgH3z+bMbDn8TuAN4k6QNe8y7uP6CcqCTnZnXa41V1kLXwU5E3ATsTgp2FgIfAL4NHCTpbODXpGZu53WbdiE/KdeSqsOuBr5OGgHuUOCKXH3WSTprAFfk627N6Vyd0722/EKUHAUcDGxJjwGbmZmZmS37inl2BrV0YKe8PjciRhYre8QjwGXAisC2bdLZFpgCXJavK6czApzTkF/VvP+U1ztLmtJQhrfk9fltygpUa8ZGRFwMzCzvk/RK4MOkAGoe8PkqaWeDrGY7jNQ28BZgB+Ci6g/DzMzMzJZ9tW/Gtklez2tx/GZS7csM4IIe0yGnUznviLhe0tdJ9+U3Svo5qc/Oy0j37qeRKija6turEhEfBdYldRzaPCIWVElnkNVs+XFcFBE3R0RUKb+ZmZmZTTwjaGALsKaka0rLAQ3Fm5bXD7UofrF/1TYPs0o6lfKOiMNJlRtrkbrLfIpUq/N74LsRUR4duqW+hqAR8feI+FNEPNtDMoOsZjMzMzMz60oNhp6+LyK2Ki1zBv2c9ELJCaSKj88DLyaNAL09qdXgLyUd1Eladaxvq1I9Np7pmJmZmZmNaSQmDWzpQFF7Mq3F8WL/g+OQTpVr3g98FDghIr4SEXdFxKMR8RvgrcATwFdyS64xVeqzM84GWc3Wk1xleADACpNX7leyZmZmZlZjaejpWs+zc1Net/qRv5hDs1UlQS/pVLmmGIRgib7zEXGPpBuBV5IqN64dq8B1DHaGVq4ynAMw7fkvcJ8fMzMzswlipIMhoAeoCBp2lTSp3FVE0sqkgcceB65sk86VpFqVmZJWLncVydPP7NqQX9W8l8/rVsNLF/ufblPeWjZjG2Q1m5mZmZlZV+o+9HRE3AqcC0wHGvu6HANMBU4td/qXtKmkTRvSeRQ4NZ8/uyGdg3P650TEbb3kDVya14dLWuxeXtKBwHrAPcCfWzzk59SxZmeQ1WxmZmZmZl2r+dDTkEY0uxw4QdIuwA3ANqTBuuYBn2k4/4a8boymjgR2JAUiW5LmsNwM2BO4lyUDmip5nwS8D9gCmCfpLFIFxauAnYFFwEERsajdg67jq7JYVVf5QC/VbA3ptKpmMzMzM6N6iRAAACAASURBVDPrzgBrdTrtK5RrWLYC5pICjY8DG5Hmntw2IhZ2mM5CYDvgBOClOZ1tgFOAV+d8eso71yDNJE07czfwXuBjpKDq/wGvjYgfd1Le2tXsRMStks4lBSMHASeWDhdVXd9urGbL195YSudRSaeSBgyYTXpSC02r2czMzMzMuhXUvs8OABFxJ7Bfh+e2fEARcT9waF76nnc+/1HSsNOf7/SaZioFO5J2AD4JbA2sRvMaooiIqsHUwKrZJO0F7JU318nr7STNzX/fFxGfqPSozMzMzGyZVPPR2CasroMRSXsAPwUmA38h9Y3pZRLRJeTana1IkdxuwO6kKqzjgWMi4oEO01koaTtSFdhepImIFpKq2T4XEXc1uWxL0tjeZRvmBeAOwMGOmZmZmQGjAxRY/VSpeZkNPAPsERHn9rc4owZVzRYRs1lydAkzMzMzs5Yc7NRTlWBnc+C08Qx0zMzMzMyGxRBMKjphVQl2HgXu73dBzMzMzMyG1TAMUDARVQl2LiANN2dmZmZmZuFmbHVVZZ6dTwEbSTpKkl9VMzMzM5vQigEK6jzPzkRVpWbnaOBPpDlvPiDpOtKMpo0iIvbvpXBmZmZmZsPAQUc9VQl2ZpX+np6XZgJwsGNmZmZmyzQPUFBfVYKdDfpeCjMzMzOzITbGTCg2QF0HOxFxx3gUxMzMzMxsWHk0tnqqUrOzGEkrA6sCD0XEw70XyczMzMxseIRHY6utKqOxIel5ko6QdAtpcIL5wAOSbsn7ew6izMzMzMyGRYQGtlhrXQclkp4P/ArYgTQIwZ3A3cC6pMEKjgV2k7RrRDzdv6KamZmZmdWRByioqyo1O4cDOwK/ADaLiOkRsV1ETAc2AX4GbJ/PMzMzMzNb5rlmp56qNDd7L3A9sFdEjJQPRMStkt4BXAe8D/hK70U0MzMzM6uvYlJRq58qNTsvBX7ZGOgU8v5fAhv1UjAzMzMzs6EQaZCCQS3WWpWanaeBldqcMxV4pkLaZmZmZmZDx0NP11OVmp0/APtIWqvZQUlrAvsAv++lYGZmZmZmwyBwn526qhLsfBNYC7ha0v6SNpQ0RdIGkvYDrsrHv9nPgpqZmZmZ1VMajW1Qi7XWdTO2iDhd0pbAEcCcJqcI+NeIOL3XwpmZmZmZDQP3namnSpN/RsSRks4C9gdeCUwDHgJ+B5wcEVf0r4hmZmZmZvXm5mT1VCnYAYiIK4Er+1gWMzMzM7Ohk0ZFc7BTR5WDHTMzMzMzS9x3pp7aBjuSTiYNMnFkRPwtb3ciImL/nkpnZmZmZjYE3Gennjqp2ZlFCna+Cvwtb3ciSH16zMzMzMyWaW7GVk+dBDsb5PVfG7bNzMzMzCa8wPPd1FXbYCci7hhr28zMzMxsonMrtnrqelJRSf8saYs257xc0j9XL5aZmZmZ2ZDIo7ENarHWug52gLnAXm3OeRtwSoW0zczMzMyGTwxwsZbGa+jpyfipNzMzM7MJwjUs9TRewc4M4IFxStvMzMzMrDYCGBlxsFNHHQU7TebW2UvS9CanTgZeAmwP/KKnkpmZmZmZDYMAXLNTS53W7Mwq/R3AlnlpJoCrgMOqF8vMzMzMbHgMw6SiktYDPg/sBqwB3A38FDgmIjpulSVpdeBzpH786wILgV8Bn4uIu/qZt6R9gA8BrwZWAu4Ffgd8OSKubFfWToOdYm4dAbcB3wCOb3LeIuCBiHisw3TNzMzMzIZfzYMdSRsBlwNrA2cCNwJbA4cCu0maGRELO0hnjZzODOBC4DRgU2A/YA9J20XEbb3mLel5wHeB9wI3Az8EHgLWAbYjBT/9CXbKc+tIOga4yPPtmJmZmZkBwzGp6EmkYOOQiDix2CnpOFKLrGOBAztI50ukQOe4iPh4KZ1DSJUhJ5Fqb3rN+xhSoHMsqcZopHxQ0nIdlLX7oacj4piI+HW315mZmZmZLbNqPPR0rlnZFZgPfKvh8NHAY8C+kqa2SWclYN98/uyGw98E7gDeJGnDXvKWtA7wCeDKiDiqMdABiIhnxiproco8O2ZmZmZmVqj/pKI75fW5jYFDRDwCXAasCGzbJp1tgSnAZfm6cjojwDkN+VXNex/g+cBpkqZI2kfSEZIOkvSKNmVcTOWhpyWtC+wCvAhYvskpERFfqJq+mZmZmdnQqHefnU3yel6L4zeTal9mABf0mA45nV7yfk1er0jq3/OS8gWSzgD+OSIeH6OsQMVgJ/fbOaLhejH6Mhd/O9gxMzMzswlgoH121pR0TWl7TkTMKW1Py+uHWlxf7F+1TT5V0qlyzdp5/QVSzc9epGBpc1Jzub2BR1l8xOimum7GJul9wGeBS0lVTGJ0pITvACOkURl27jZtMzMzM7OhNNg+O/dFxFalpRzoDKMiRrkfeGtE/C4iHouIq4C3kQKdfSW9qNOEuvFh4C5gt4j4Sd43PyJOi4gDgbcA7wJWqZC2mZmZmdnwqfEABYzWnkxrcbzY/+A4pFPlmuLvCyLi4fLJEXE3aU7PScBWbcpbKdh5OXB2RDxb2je5VIBzSJ2TPlkhbTMzMzOz4RJAaHBLezfl9YwWxzfO61b9anpJp5drWgVfxSSkU1ocf06VYGc50iyphSdYMlK7HuhqpAQzMzMzs2EVMbilAxfl9a6SFrv/l7QyMBN4nPaTdF5Juvefma8rpzOJNNBAOb+qeZ+f15u3KMfL8vr2NuWtFOzcDaxb2v4LsEXDOS8EnsXMzMzMbCKocTO2iLgVOBeYDhzUcPgYYCpwakQ8VuyUtKmkTRvSeRQ4NZ8/uyGdg3P650TEbb3kTRob4DrgdZLeXr5A0oeAzYBbgPKgDE1VGY3tdyweZV0IHCBpX+DHwI6kgQsuq5C2mZmZmdnw6aw52SB9BLgcOEHSLsANwDakeXDmAZ9pOP+GvG58YEeS7vcPl7QlcDUp+NgTuJclA5qu846IkPR+4BLgDEk/y+e9DHgzaSLS90fEonYPukrNzs+BzSVtkLe/Qup4NBd4GDiL9KQcVSFtMzMzM7Ohoxjc0olcw7IV6Z59G+DjwEbA8cC2EbGw9dWLpbMQ2A44AXhpTmcb4BTg1TmfnvOOiD8ArwL+mzTvzseAVwL/k/O5vJPydl2zExFzc0GL7TslvaZU6PnASRHxx27TNjMzMzMbOp2PijZQEXEnsF+H57asqoqI+4FD89L3vEvX3E4Hc+mMpdKkoi0KcnA/0jIzMzMzGy4dj4pmS1mVSUVPlnSipNXHOGdPSSf3VjQzMzMzsyFR4wEKJrIqfXZmkTsZSdqwxTlbAu+vWigzMzMzs6HiYKeWqgQ7kEZk2xC4QtJ2fSyPmZmZmdnwcbBTS1WDnbOA3YEVgAskvat/RTIzMzMzGyJB6rMzqMVaqhrsEBHnk2Y8/TvwfUmf6lupzMzMzMyGSN2Hnp6oKgc7ABFxPWms7N8DX5I0R9LkvpTMzMzMzGxYuBlbLfU89HRE3CNpe+CHwAeBlwB/7jVdMzMzMzOzXvRrnp3HJe1JmgX1IOAN/Uh3mMUzz/DsXxcMuhhmthS8cdI7B10EG5Az7rpy0EWwAVhp0gqDLoLVkJuT1VOVYOcO4MHGnRExAnxU0q3A13otmJmZmZnZ0PBAAbXUdbATERu0Of4NST8gjdRmZmZmZrZsc9+Z2upLM7ZGEfG38UjXzMzMzKyWHOzU0rgEO2ZmZmZmE4n77NRT22BH0smkWPXIiPhb3u5ERMT+PZXOzMzMzGwYONippU5qdmaRXr6vAn/L250IwMGOmZmZmS37HOzUUifBTjEgwV8bts3MzMzMJjyFm7HVVdtgJyLuaNi1PvBwRFw3PkUyMzMzMxsyHnq6liZVuOYi4IB+F8TMzMzMbGjFABdrqcpobPcBT/S7IGZmZmZmw8rN2OqpSrBzMfDaPpfDzMzMzGx4OdippSrN2I4CNpH0BUnL9btAZmZmZmZDJUYHKRjEYq1Vqdn5NHA9cCSwv6TfA/ewZDzreXbMzMzMbGJw0FFLVYKdWaW/18lLM55nx8zMzMwmBgc7tVQl2PE8O2ZmZmZmJW5OVk9dBztN5t0xMzMzMzOrnSo1O2ZmZmZmVuaanVqqHOxIWhfYBXgRsHyTUyIivlA1fTMzMzOzoeBR0WqrUrAj6RjgiIbrxWhMW/ztYMfMzMzMln0Odmqp63l2JL0P+CxwKbAPKbD5LvBe4DvACHAasHP/imlmZmZmVmMxwMVaqlKz82HgLmC3iHhWEsD8iDgNOE3ST4BfAD/oXzHNzMzMzOpJuBlbXXVdswO8HDg7Ip4t7Ztc/BER5wDnAJ/ssWxmZmZmZsPBNTu1VKVmZzlgYWn7CWBawznXAwdWLZSZmZmZ2dDwAAW1VSXYuRtYt7T9F2CLhnNeCDyLmZmZmdlE4GCnlqo0Y/sdsHlp+0Jge0n7SpoqaQ/SwAW/60cBzczMzMxqbwiasUlaT9LJkhZIekrSfEnfkLRaNw9V0ur5uvk5nQU53fXGK29JR0mKvLyh07JWCXZ+DmwuaYO8/RXgIWAu8DBwFqmf1lEV0jYzMzMzGzqKwS0dlU/aCLgW2A+4Gvg6cBtwKHCFpDU6TGcN4Ip83a05natzutdK2rDfeUt6FfA54NFOyljWdbATEXMjYsWIuD1v3wm8BvgP4FxgDvCaiLiy27TNzMzMzIZS/Wt2TgLWBg6JiL0i4oiI2JkUeGwCHNthOl8CZgDHRcQuOZ29SIHL2jmfvuUtaQXgVOC3wE86LONzqtTsLCEibo+IgyPizRHx4Yj4Yz/SNTMzMzOrvUEGOh0EO7lmZVdgPvCthsNHA48B+0qa2iadlYB98/mzGw5/E7gDeFO5dqcPeX8Z2ACYRZrPsyt9CXbMzMzMzCaymjdj2ymvz42IxQKGiHgEuAxYEdi2TTrbAlOAy/J15XRGSNPPlPPrKW9JO5NqjD4dETe3KVtTDnbMzMzMzHpV45odUlMxgHktjheBxIxxSKdS3pKmkcYEuBQ4oU25Wmo79LSkkyumHRGxf8VrzczMzMyGxoDn2VlT0jWl7TkRMae0XcyJ+VCL64v9q7bJp0o6VfM+EVgd2DEiKj+7ncyzM6ti2gE42DEzMzOzZd9gg537ImKrgZagjyTtTeobdFBE3NZLWp0EOxu0P8XMzMzMbILqblS0QShqT6a1OF7sf3Ac0unqGkmrA/8JXEAa7bknbYOdiLij10zMzMzMzJZVykuN3ZTXrfrkbJzXrfrV9JJOt9e8BFgT2AUYkZo+s+fl/YdFxDfGKnAnNTtmZmZmZjaWetfsXJTXu0qaVB4VTdLKwEzgcaDdPJlXAk8AMyWtXB6RTdIk0hDT5fyq5L0Q+L8t8n89KTj6JbAAuL5NebsPdiR12m4uImKjbtM3MzMzMxs2Ax6gYEwRcaukc0nByEGkzv+FY4CpwLcj4rFip6RN87U3ltJ5VNKpwAGkeXY+XkrnYGA6cE65n023eUfEncAHmz0OSXNJwc5xEXF+J4+9Ss3OJJrHrqsy2uZuAfBMhbTNzMzMzIZPjYOd7CPA5cAJknYBbgC2Ic2DMw/4TMP5N+R1YzuyI4EdgcMlbQlcDWwG7AncSwpoes27b7oOdiJieqtjkl5KGgd7KvCm6sUyMzMzMxsiNQ92cg3LVsDngd2A3YG7geOBYyLigQ7TWShpO+BoYC9ge1LTs1OAz0XEXeOVdxV97bMTEbdIegep/dzRwKf7mb6ZmZmZWe1EvZuxFXITsf06PLflmAsRcT9waF76nvcYacyiy2lxJvWSYYtCPAmcB7yn32mbmZmZmdVSDHCxlsZrNLZngXXGKW0zMzMzs1oZhpqdiajvwY6kNYG3A3f2O20zMzMzs1pysFNLVYae/twYab2YNBLDNNxfx8zMzMwmCNfs1FOVmp3ZbY4/DHwxIv61QtpmZmZmZsMlgJG2Z9kAVAl2dmqxfwR4ALgxIp6tXiQzMzMzs+EhXLNTV1Xm2blkPApiZmZmZja0HOzU0niNxmZmZmZmNmEoHO3UkYMdMzMzM7NeeL6b2qoyGtttHZw2Qhqo4AbgxxFxRrf5mJmZmZkNC/fZqacqNTuT8nUvzNvPAguBNUrpLQDWBrYE3i3pbGCviFjUW3HNzMzMzGrIwU4tTapwzRbAX4FLgdcBK0TEusAKwPZ5/13Ai4BNgF8BuwOH9qPAZmZmZmZ1oxjcYq1VCXaOJU0auktEXB4RIwARMRIRlwFvBFYFjo2Im4F3koKj9/WpzGZmZmZm9RIDXKylKsHO24GzWs2lExFPAz8D3pG3HwcuAGZULaSZmZmZWW0NsFbHNTtjq9JnZw3g+W3OWS6fV7inYl5mZmZmZvXnoKOWqtTs3AbsLWnlZgclrQLsDdxe2r0ucH+FvMzMzMzMak24ZqeuqgQ7c0iDD1wl6X2Spkuaktf/BFxFGqnt2wCSBOwIXNenMpuZmZmZ1UvE4BZrqeumZRFxvKRNgAOB/25yioA5EXF83l4b+AFwXuVSmpmZmZnVmGtY6qlKzQ4R8RHg9cApwO9ITduuy9s7RsSBpXP/FhGfjogL+1DeliStJ+lkSQskPSVpvqRvSFqtizTeKOlrki6QtFBSSPrNeJbbzMzMzIbcIEZgKy/WUuVBAyLiN0AtAgFJGwGXk2qRzgRuBLYmze2zm6SZEbGwg6QOAvYEngRuAVYfnxKbmZmZ2bJEI4MugTVTqWanIGmqpFdK2r5fBaroJFKgc0hE7BURR0TEzsDXSRObHtthOl8FNgdWAt46LiU1MzMzs2WPa3ZqqVKwk5uMnQE8AFwDXFQ69jpJf5a0Y3+K2LYsGwG7AvOBbzUcPhp4DNhX0tR2aUXEFRHxp4hY1PeCmpmZmdkyy6Ox1VPXwY6kdUkjru0J/By4gjQoQeEqUi3LP/ajgB3YKa/PjYjFKhAj4hHgMmBFYNulVB4zMzMzm0gCj8ZWU1Vqdo4mBTNvjIh30DDKWkQ8A1wKzOy9eB3ZJK/ntTh+c17PWAplMTMzM7MJyDU79VQl2NkdOCsiLhrjnL+Q5tpZGqbl9UMtjhf7Vx3vgkg6QNI1kq55hqfGOzszMzMzq4tB9ddxsDOmKqOxvYDR2pJWngHa9pFZ1kTEHNKkq6yi1f3WMzMzM5sAhGtY6qpKsHM/8OI258wA7qmQdhVFzc20FseL/Q8uhbKYmZmZ2UTjvjO1VSXYuQx4m6R1ImKJgEbSxsBuwPd6LVyHbsrrVn1yNs7rVn16zMzMzMx64pqdeqrSZ+ffgBWASyS9mTTSWTHnzpuBnwEjwNf6VsqxFX2HdpW02OORtDJpoITHgSuXUnnMzMzMbKJxn51a6rpmJyKukvQvwH+Qhp4uPJzXzwIfiIg/9aF8nZTnVknnkubaOQg4sXT4GFLfoW9HxGPFTkmb5mtvXBplNDMzM7Nlm2t26qlKMzYi4mRJlwIfIc1fswap78yVwDcj4qaxrh8HHwEuB06QtAtwA7ANaQ6eecBnGs6/Ia/L8wMh6XXAB/PmSnm9saS5xTkRMaufBTczMzOzIRfAiKOdOuo62JH0euDhiLgOOKz/Repert3ZCvg8qb/Q7sDdwPHAMRHxQIdJvRR4f8O+tRv2zeqttGZmZma2zHGsU0tVanYuAr5Nqk2pjYi4E9ivw3PVYv9cYG7/SmVmZmZmE4GbsdVTlQEK7gOe6HdBzMzMzMyGVjH89CCWDklaT9LJkhZIekrSfEnfkLRaNw9V0ur5uvk5nQU53fX6kbekF0n6qKRflvJYKOk8Se/opqxVanYuBl5b4TozMzMzs2VS3Wt2JG1E6uO+NnAmcCOwNXAosJukmRGxsIN01sjpzAAuBE4DNiW1sNpD0nYRcVuPeX8U+BRwO6lV2T3A+sA7gDdI+npEHN7J464S7BwFXCXpC8DnI+KZCmmYmZmZmS0bhmMI6JNIwcYhEfHc6MWSjiP1wz8WOLCDdL5ECnSOi4iPl9I5hNRf/iRSH/pe8r4a2DEiLiknImkz0oBoh0n6n4i4tl1hFV3O9irpZFJH/pnA34Dfk6KtxoQiIvbvKvFlyCpaPbbRLoMuhpmZjaMz7vIUbhPRSpNWGHQRbAAmr3vLtRGxVbNjq6yyXmy1zcFLu0jPuej8T7csGzxXs3ILMB/YKCJGSsdWJg3sJWDt8nQtTdJZCbiXNKfmuhHxSOnYJOA2Ug3MRkXtTr/yLl0zB/gQ8ImIaDuvZ5WanVmlv9fJSzMBTNhgx8zMzMwmkJH2pwzQTnl9bjnYAIiIRyRdRpqzclvggjHS2RaYktN5pHwgIkYknQMckPMrmrL1K+9C0ars2Q7OrRTsbFDhGjMzMzOzZZa6bC21lG2S1/NaHL+ZFHDMYOyAo5N0yOn0O28krQLsTapUOXescwtdBzsRcUe315iZmZmZLbMG32dnTUnXlLbnRMSc0va0vH6oxfXF/lXb5FMlnb7kLUnAfwEvAE6KiBvGLmpSpWbHzMzMzMye090Q0OPgvrH67Cwjvga8E7gU6GgkNnCwY2ZmZmbWs5oPPV3UnkxrcbzY/+A4pNNz3pL+lTRq26+BPSLiqTblfI6DHTMzMzOzXtW7z85NeT2jxfGN87pVv5pe0ukpb0lfBz5Gmm/nLRHxeJsyLsbBjpmZmZlZLwJU79HYLsrrXSVNajL880zgcdIcNmO5EngCmClp5SZDT+/akF/lvHMfnW8CHwHOA/aMiCc6ebBlk7q9wMzMzMzMGkQMbmlbtLiVNHrZdOCghsPHAFOBU8vz3EjaVNKmDek8Cpyaz5/dkM7BOf1zijl2eshbwBxSoPNL4G1VAh1wzY6ZmZmZWe9q3YoNSIHD5cAJknYBbgC2Ic2DMw/4TMP5xWhnath/JLAjcLikLYGrgc2APUkTjjYGNFXy/hzwQVIt0nXAESn+Wcx1EfHTMR8xDnbMzMzMzHpW83l2iIhbJW0FfB7YDdgduBs4HjgmIh7oMJ2FkrYDjgb2ArYHFgKnAJ+LiLv6kHcxr+cU4NMtivJdwMGOmZmZmdm4q3mwAxARdwL7dXjuElUppWP3A4fmZTzyngXM6jTtsTjYMTMzMzPrRQD1HqBgwnKwY2ZmZmbWAxG1b8Y2UTnYMTMzMzPrlYOdWnKwY2ZmZmbWKwc7teRgx8zMzMysF+6zU1sOdszMzMzMeuQ+O/XkYMfMzMzMrFcOdmrJwY6ZmZmZWU/CwU5NOdgxMzMzM+tF4GCnphzsmJmZmZn1ygMU1JKDHTMzMzOzHnmAgnpysGNmZmZm1isHO7XkYMfMzMzMrBcBjDjYqSMHO2ZmZmZmPfFobHXlYMfMzMzMrFcOdmrJwY6ZmZmZWa8c7NSSgx0zMzMzs164z05tOdgxMzMzM+tJQHiinTpysGNmZmZm1is3Y6slBztmZmZmZr1wM7bacrBjZmZmZtYr1+zUkoMdMzMzM7NeOdipJQc7ZmZmZmY98aSideVgx8zMzMysFwGMeDS2OnKwY2ZmZmbWK9fs1JKDHTMzMzOzngQscs1OHTnYMTMzMzPrRUB4UtFacrBjZmZmZtYrz7NTSw52zMzMzMx65T47teRgx8zMzMysFxEeja2mHOyYmZmZmfXKNTu15GDHzMzMzKxH4ZqdWnKwY2ZmZmbWk3DNTk1NGnQBzMzMzMyGWpBGYxvU0iFJ60k6WdICSU9Jmi/pG5JW6+bhSlo9Xzc/p7Mgp7teP/OW9A+STpd0r6QnJd0k6RhJUzotq2t2zMzMzMx6VfN5diRtBFwOrA2cCdwIbA0cCuwmaWZELOwgnTVyOjOAC4HTgE2B/YA9JG0XEbf1mrekbXL6ywE/Au4EdgY+B+wiaZeIeKpdeR3smJmZmZn1IICo/zw7J5GCjUMi4sRip6TjgMOAY4EDO0jnS6RA57iI+HgpnUOA43M+u/WSt6TJwCnAisCeEXFW3j8JOB3YO1/3lXaFVbh94bhYRavHNtpl0MUwM7NxdMZdVw66CDYAK01aYdBFsAGYvO4t10bEVs2OraLVY9vn7bq0i/Sc8579YcuywXM1K7cA84GNIkaroSStDNwNCFg7Ih4bI52VgHuBEWDdiHikdGwScBuwfs7jtqp5S9oZuAD4dUTs0FCGDYFbgTuADaJNMOM+O2ZmZmZmPYqRGNjSgZ3y+txysAGQA5bLSLUo27ZJZ1tgCnBZOdDJ6YwA5zTkVzXvnfP6V40FyEHUPFJQtWGb8jrYMTMzMzPrWYwMbmlvk7ye1+L4zXk9YxzSWVrXNOU+O+PkER647/z40R2DLseArAncN+hC2FLn131imtCv+7QXDboEAzWhX/sJbCK/7uu3OvAID5xzfvxozaVZmAYrSLqmtD0nIuaUtqfl9UMtri/2r9omnyrpLK1rmnKwM04iYq1Bl2FQJF0zVrtRWzb5dZ+Y/LpPXH7tJya/7s1FRGOHfKsJN2MzMzMzM1u2FTUh01ocL/Y/OA7pLK1rmnKwY2ZmZma2bLspr1v1cdk4r1v1keklnaV1TVMOdmw8zGl/ii2D/LpPTH7dJy6/9hOTX/fhdFFe75qHiH5OHv55JvA40G48/SuBJ4CZ+bpyOpOAYvzti0qHquR9YV4v0TwwDz09gzT09G2Nxxs52LG+a+gQZxOEX/eJya/7xOXXfmLy6z6cIuJW4FxgOnBQw+FjgKnAqeU5diRtKmnThnQeBU7N589uSOfgnP45xRw7VfMGLgFuAF4v6W2lMk0Cvpo3/7PdHDvgSUXNzMzMzJZ5eXLPy4G1gTNJwcQ2pHlw5gGvjYiFpfMDICLUkM4aOZ0ZpBqYq4HNgD1JE46+Ngc4lfPO12yT018O+BHwF2AXYCvS3Dy7RMRTbR+3gx0zMzMz+//t3Xm4HFWdxvHvK4SAhEHCjixREIGJCkEUAgjIoKLggguOoyAKIyibK4LI4iAiqIj4jMsARmWJMyCCGkQDhFUYQMKmDotEDAQMO2FJCPzmj9/ppKhU9+3O3eLN+3meeir3VMFwfwAAEx5JREFUnKpTp7o6VX3qbDbySVoP+ArZPGxVYBZwPnBsRDxa27axsFPixgJHA+8G1gYeBi4CjoqImf09dmWfzcjan52Alcima+cAJ0TEM12dsws7ZmZmZmY2ErnPji0gaVVJ+0o6X9Jdkp6R9LikqyR9vKFT2ThJ0WGZ3OFYK0v6iqRbJM2R9ISk2yT9QNKowT9bq5M0o8O1fKC27ShJh0j6kaTpkuaV7fbtkP62kk6UdL2k2ZLmSrpH0mmSNhr8M1x6SXqfpFMlXVn+r4WkM/vYZ6KkKZIeKfeCWyQdKmmZhm03l3SMpKslzSrfh/sknSNpQpd5XK3sG5KuWtxztYV6vadX9uv62jfsK0m/q9w7Gufzk/QaSWdV8nWfpMsk7dkuX7b4JH24ck0a79OSdpM0rXxH5ki6TtLeHdLcqDwDZpb/87Mk/VTZXKlTXiZIOrvsN1fSg5Iul7RXf8/TrIlrdmwBSfsD3yOrFS8j20auCexBjmd+HvD+VmcwSeOAe4CbgV80JHlbRJzbcJxNyI5qLwemAtPJ9pjjyGrK9UoHOBtCkmaQMxF/uyF6TkR8o7Lty4BWlfODwDxgPWC/iDitTfoPAKuTbXZvBOYD2wATgaeAXSLi9wNyMvYikqYDrwPmADOBTYCzIuLDbbZ/F/n//VngZ8AjwO7Aq4FzI+L9te2vJdte3whcV46zOTkqz3xgz4j4eR95PK9sPwa4OiK2W6yTtQV6vaeXfXq69g3HPAg4GXgOWB4YFRHza9vsDvwceAG4ELgbWA14DzAWOC0i9uvPudtCyqZDtwLLkP+/FrlPSzoQOJVsivQz8p7+PmBd4JsR8bna9q8n+1KsBFwC3ARsQF7Dp4EdI+KmhrwcCJxCPj9+DdxHXvPxwMyI+ODAnLVZRUR48UJEALyZfKi9pBa+FvmQDOC9lfBxJWxSD8d4KdkR7VFg64b4ZSmFcC9Dfv1nADO63HY5YFdg7fL3MeW7sG+HfQ4D1mkIP6Lse+twfwYjdSFfIrwKELBj+bzPbLPtP5EdTOcCr6+EL08WVAP4YG2fg4CNGtL6t7L9Q8ByHfK3V9nugLK+arg/s5GwLMY9vedrX0v31eQP3RPK/SSAZRu2u73E7dCQrwdL3PrD/fmNhKX8n59KFihParpPl2f5s2RBZ1wlfBXgrrLPNrV9bi7hn66Fb0e+4Jhef5aTLzNeAC4GVmrI66jh/ry8jMzFVcW2QERcGhG/jIgXauEPAN8vf+7Yz8PsT/7oOjwiFhnLPSLmR4SrG5dwETEvIi6KiFk97PP1iLi/Ierr5Jj945UjvNgAi4jLIuLOLv9vvY+sgZscETdU0ngWOLL8eUAt/VMj4q6G454F3El2RH1N08EkrQ98Bzid7NxqA2Qx7uk9X/uW0lztp+ScF0f3kbVXAk9ExOUN+bqu/Ll6H2lYdw4mC737kDXoTT4GjAa+GxEzWoGRHcaPL3/u3wpXznHyWrJgfEo1oYi4CvgVWZO8fe04J5H3+g9FxJP1TETEc92elFkvGtvSmjVo3YTmN8StI+kT5A+ah4HfR8QtbdL5EPk2aHJpBrcr2XTqXuA3URt20IbcaEkfBtYnH4y3AFdExPODeMxg4fdqMI9j3XlzWf+mIe4K8s39REmjo4shP+lw75AkYBLwOPAZsjmLDY2m69Kfa38ksAVZAzA3L21btwNbStqu/DgGQNIawBvIZnd/7PpMrJGkTclatlMi4gpJb26zaafrflFtG8gaOMiWAC+wqNb8KjuT3xskjScLSL8AHpG0E7Alef+fDlzWJi2zfnNhx/pU3ti1Og423Qx3KUt1n2nA3hFxbyVsFPm2ZzawH/nGqPodfErSwRFxxsDl3nq0Fvl2tuoeSfvU38IOoPeT7b6vjYjHBukY1r1Xl/Ud9YiImC/pHuCfybfzf+qUkKStgc3Idvm3NWxyKFmz8JaIeEI5lKkNsg739MW69pK2Ar5EDgV7Q33fBp8m3/5PlXQB+eN4NXII28fIN/9dDSlrzSo1bfeSTYU76XTdZ0l6ClhX0ksj4mmyWSrABpLUUGP8ylq6AFuV9d+BacCbavvcKmmPphpis/5yMzbrxglk58EpEXFxJfxp4D/ItzOrlGUHsiPsjsAlklasbD+WLNysCnyt7Lse+ZDbl3zDc1qHt082uH5Evolbi5zN+DXAD8j23BdJet1AH1DSK8hOsfPJN/s2/FYu68fbxLfCX9YpkVJw+Un589P12kHl3AnHkzNgT13MvNriaXdP7/naS1qB/FF9Ozl/Rp8i4kpycJK7gA8AXySfAaPJ+9CtXZ2FdXIUWdP20S4Kjt1e95UBIuIOsnnqmmQzuQUkTQR2K3+uUolao6w/Tj5T3lHS2xg4k3ze/FrScn3k1axnLuxYR5IOBj4L/Bn4SDUuIv4eEUdFxB8i4rGyXEF2QrwO2Ih8gLW0vm/LkKPtfCUiZkbEwxFxOvn2SWRHdhtiEXFsaeP/YEQ8HRG3RcT+wLeAFchBCAZMabJyEdk2/5DwSGwjRnnJcQHZP+/EiPifWvwo8gfyLOALQ5/DpVene/piOpF8k793t30uJO0CXEnW+G1JvlzZEDgN+Cr5oswtTxaTctb5I8hR1Abrvro/OWLbt8tQ4ycpp5uYxsLCarVZWvX5/8GImBIRT0TEnWQt4w1kwee9g5RfW4q5sGNtVYaI/COwU0Q80s1+kcOMtoa1rFZVV98and+wayvsDT1m1QZXqyNzvdnBYisFnUvJZg6HRMR/DlTa1m8veovboBXe2OSwFHR+TY7K9K2IaHp5cTj51nmf8DDzQ6aLe3pP117SDsCngOMi4uYu8zCWHNr4GeA95WXZ0xHxl4j4DNmnYyLQOCy6dVYKiT8hm6R9ucvdur3uC57hEXEpsDU5hPjmwCFlfRjZcgOyyVpL637xQL0AVprBXVD+9PPfBpwLO9ZI0qFk86LbyIfiA33sUje7rBc0Yyttff9W/mz6odSat2WFHo9lg2uRa9kfktYm3/5tBnwqIr4zEOnagPm/st64HlF+SL2CbHb4l4b4lcjauh3IGp3PtjnGBLIWd1plosMg5+0C2LaEuQ/XAOnynt7rtd+CvI7HqjYRMTnnCsBzJWzz8vdEsnnTdeWZUHdZWW/Z2xlaMYa8fpsCz9auSWuUvP8qYa051Tpd97XJe//M+vWKiJsi4r0RsXpELBcRm0TEyWQTSYDrK5u3jtHu/7Sf/zZoXE1si5B0GNmmezo50eNDfezSZOuyrv8gmkoOgTmehUOMtrRukPdgS5J217JnktYla3Q2AvaPiB/2N00bcJeS8+O8DTinFvcmcq6sK+qjcUlamezsvjXw1Yg4kvZ+x8JOzlVjgD3JuVZ+RfYLtH7q4Z7e67W/jRwyvMme5PU8g+yP2Rppc3RZtxtauhU+r028dTaX9tdkAllAvYosfLRqWC4FtiWve73Z266VbfpUmqj+KznaX3VS8WvJET7HSVoxIurDYPv5b4MnloDJfrwsOQtZ7R1k+9mxfWw7gdpkdSV8Z3KCsgAm1uK2JIcXvhNYvRK+PFkQCuCo4f4clraFfAu4YkP4uHKtAjiiw/7H0PekohuQBabnyU6zw37eS+NCd5OKzqa3SUVXId/i9uv/LwsnKvakogN3vXu5p/d87TukNYOGSUWBdcgfws+To/BV49Yjmz4F8Pbh/uxG2tLuPk3W2PU6qeiKwDK1sGWB75XtT2g4/ikl7mQqE46SgxM8U74XGw735+Rl5C2K8PyNliTtTc558TzZ3KFpZJYZETGpbD+N7IB8DTCzxL+WhePxfzkijms4zlHAseRD7ULyJvvWSlo7R05iZ0NE0jFkp+UrgL8CT5Idht9B/tCZQravn1fZ54vAJuXPzclhxa8hC0eQP1hPq2x/D/lj9kbyrX2TSVGZ1M4GhqR3k8P6Qo6291ay4HllCXsoIj5X2/5c8v/mZOAR4J1kH6tzgQ9E5eEhqTUC493kyEpNfhER0/vI5zjyze7VEbFd1ydojXq9p5d9err2HY49g3zBMSqyH2c1rvUMeIG8F/yZ/F7uQdYGnR8Re3R/ptaNcp8/Gtivem8ucQeRk/s+TPapmkdOMrsuOdDB52rb70b2zZ1KPv/HkDVDG5Lfkw9FbcAKSf8EXE4+L64DriZHdNuDbL52aES8aJJSswEx3KUtL0vOwsK3Pp2WaZXtP04+qGYAc8i3gfeSN8rt+zjWHuQP6yfIh+rt5DwNo4f7c1gaF7KPxTnkj47HyDdss8nmRntReQtX2WdaH9+VSbXt+/puBbDjcH8WI3Hp4v/2jIZ9tiULuY+Sb11vJedHWaZh2xldXNuPdpHPcbhmZyiv+4vu6Ytz7Tscu/WdWLZN/LvI/l2zyX5AT5AvSw7o5TheFuv70FgDD+xOFkaeJJucXU+Oste07cbAeWQ/3Lnlu3IZ2QxykedFZb8x5Ih7d5T9HgN+S62Wz4uXgVxcs2NmZmZmZiOSR2MzMzMzM7MRyYUdMzMzMzMbkVzYMTMzMzOzEcmFHTMzMzMzG5Fc2DEzMzMzsxHJhR0zMzMzMxuRXNgxMzMzM7MRyYUdM7MhJmlGmWG+9fc4SSFp0vDlamgtjedsZmZDz4UdMzMzMzMbkZYd7gyYmRn3AZsCjw93RobQ0njOZmY2xBQRw50HM7OlSqsJW0SMG96cmJmZjWxuxmZmNgiUDpR0u6RnJd0n6buSVm7YtrH/SjVc0oaSzpX0sKQnJf1W0viy3eqSfihpVjnW9ZJ2apOvN5Z0HpA0T9LfJP1A0jqd8lX+PVnSQ+UYN0jarWGfd0q6pORlrqT7JV0u6ZPdnHOJ+4CkKyQ9LukZSbdKOlzS6P7mrxNJu5T0viZpvKSzJT0oaY6kayS9sZf0zMxs+LmwY2Y2OL4NnAqsAvwQmAy8DZgKLNdjWuOA64A1gUnAb4F/AaZJehVwLbAV8DPgv4HXARdJWr+aiKSPAVcDuwKXlTzeAOwL3FDfvmID4H9LPn5ajjMeuKBaqJL078AFwGbAL4FvAlOAFYB9ujlRSceX9DcFzga+Cwg4HrhYUtNn11X+urBFWW8MXA+MAX4MXA5sA1woaaUe0jMzs+EWEV68ePHiZQAXYCIQwF3A2Er48sDvS9yMSvi4Ejaplk4rPIAv1eK+XMIfAb4PvKQS95ESd3IlbGNgXsnTy2tp7Qw8D5zf4fhH1+LeWsKnVMJuBOYCazR8Jqu1SXtSJWybEnYvsFYlfFmy8BTAEYubvy6u2+Syz9+BCbW480rc9sP9/fLixYsXL90vrtkxMxt4rVqMr0bEI63AiHgWOHwx0psBnFAL+3FZjwY+HxEvVOLOBuYDm1fCDgBGAYdExH3VhCLiEuBCYPc2NRd/BY6r7XMxWSh5Q23b+cBz9QQi4qGGdOs+VtbHRcQDlX3nA58FXiBrofqTv05aNTv7RMQfanF/Kuvle0jPzMyGmUdjMzMbeBPK+vKGuKvIWpReTI+I+j73l/UdEfFkNSIinpf0ILBuJXibst5B0lYNx1gDWIasAbqxi+MD/K2SLsBZZNO1P0qaTJ7/1RExu8151bU+t0vrERFxh6SZwCskrRwR1VHcus1fW5LGAK8iC05TGjZ5ZVnf3U16Zma2ZHBhx8xs4LUGIXiwHhER8yV1U8tRtcjwzCWdxrhiPlmT07JqWX++j2ONaQh7rMMxFrQQiIhvlXP7JHAwcCgQki4na59u6OPYrc9tVpv4WcD6wMt48Xl3lb8+bE72DfpdRDQNUzqhHPOeLtMzM7MlgJuxmZkNvNYP8TXrEZKWBVYb2uwAC/O0ckSow9JUG9W1iPhJRGxNFq7eAZwOvIkcXGD1LvO4Vpv4tWvbDaRWrVK9VovStG9j4KY2BSEzM1tCubBjZjbwWv09dmiI245sLjbUri3r7YfiYBHxWERMiYj9yBHkxpKFnk5uKusd6xGSNiKb5d0TEe1qcvqj1V+nqfZpC7LWZ5GCkJmZLdlc2DEzG3iTyvpLksa2AiUtD3xtWHKUQzg/B5wsaeN6pKTlJPWrICRpJ5W2dTVrlPXTfSRxRlkfWa0FkrQM8A3ymXV6f/LYwQRytLpbGuK2LOv6oAVmZraEc58dM7MBFhFXSzoVOAi4TdK5ZEHjXcCjtO+TMph5+nOZZ+cM4HZJvwHuIPv1rE/W+MwGNunHYc4H5ki6lhxBTiXdrchakal95PEaSScCX2Dh5/YUOS/QeHJwh5P6kb9GZbLSzYBbImJewyatwo5rdszM/sG4sGNmNjgOIQsTnwI+ATxMFgaOAG4ejgxFxJmSbiaHcd4JeAtZmLgfOJecjLM/vkjObzMBeDvwLDm62WHA9yJikSGpG/J4mKSbgAOBvcjC2N3AkcA32xRG+ms8+TxsN4DClsAc8nqamdk/ELmvpZmZmZmZjUTus2NmZmZmZiOSCztmZmZmZjYiubBjZmZmZmYjkgs7ZmZmZmY2IrmwY2ZmZmZmI5ILO2ZmZmZmNiK5sGNmZmZmZiOSCztmZmZmZjYiubBjZmZmZmYj0v8DmCG47zgp+CwAAAAASUVORK5CYII=\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light", "tags": [] }, "output_type": "display_data" } ], "source": [ "fig = plt.figure(figsize=(12, 8))\n", "ax = plt.gca()\n", "im = ax.imshow(reg_ot[\"OTT\"].T - reg_ot[\"POT\"].T)\n", "plt.xticks(ticks=np.arange(len(n_range)), labels=n_range)\n", "plt.yticks(ticks=np.arange(len(𝜀_range)), labels=𝜀_range)\n", "plt.xlabel(\"dimension $n$\")\n", "plt.ylabel(r\"regularization $\\varepsilon$\")\n", "plt.title(\"Gap in objective, >0 when OTT is better\")\n", "divider = mpl_toolkits.axes_grid1.make_axes_locatable(ax)\n", "cax = divider.append_axes(\"right\", size=\"5%\", pad=0.1)\n", "plt.colorbar(im, cax=cax)\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": 45, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "ZxwbScNpz3LR", "outputId": "36eed4e2-4fca-4cb1-fe00-cf10c4291c09" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "---- POT\n", "Objective\n", "[[-0.00862313 -0.79116929]\n", " [-0.02666368 -0.93283839]\n", " [ nan -1.07958862]\n", " [ nan -1.22432204]\n", " [ nan -1.36762311]]\n", "Time\n", "[[0.04367424 0.01185102]\n", " [0.22960342 0.04137421]\n", " [ nan 0.15465033]\n", " [ nan 0.3669143 ]\n", " [ nan 1.21968372]]\n", "---- OTT\n", "Objective\n", "[[-0.00783848 -0.79117149]\n", " [-0.02610656 -0.93283963]\n", " [-0.05083928 -1.07959068]\n", " [-0.06328616 -1.21402502]\n", " [-0.07956241 -1.35710597]]\n", "Time\n", "[[0.01124264 0.00103751]\n", " [0.00612156 0.00107929]\n", " [0.00895449 0.00142238]\n", " [0.02404206 0.00346715]\n", " [0.11208566 0.01432985]]\n" ] } ], "source": [ "for name in (\"POT\", \"OTT\"):\n", " print(\"----\", name)\n", " print(\"Objective\")\n", " print(reg_ot[name])\n", " print(\"Execution Time\")\n", " print(exec_time[name])" ] } ], "metadata": { "accelerator": "GPU", "colab": { "collapsed_sections": [], "name": "OTT & POT", "provenance": [] }, "kernelspec": { "display_name": "ott", "language": "python", "name": "ott" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.10.6" } }, "nbformat": 4, "nbformat_minor": 1 }