From eb4a4943a651c323d26279a752d90996d7a418f4 Mon Sep 17 00:00:00 2001
From: Enrique Morell <emorell96@hotmail.com>
Date: Sun, 12 Jul 2020 06:13:08 -0700
Subject: [PATCH] added the summary. Matches fit. TODO: add batch support.

---
 mcmc_nuts_clean.ipynb | 1558 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 1558 insertions(+)
 create mode 100644 mcmc_nuts_clean.ipynb

diff --git a/mcmc_nuts_clean.ipynb b/mcmc_nuts_clean.ipynb
new file mode 100644
index 0000000..9539977
--- /dev/null
+++ b/mcmc_nuts_clean.ipynb
@@ -0,0 +1,1558 @@
+{
+  "nbformat": 4,
+  "nbformat_minor": 0,
+  "metadata": {
+    "colab": {
+      "name": "mcmc_nuts_clean.ipynb",
+      "provenance": [],
+      "collapsed_sections": [],
+      "toc_visible": true,
+      "mount_file_id": "1iBwnZZznV3qXtQKGTt68kolisfZ0beWO",
+      "authorship_tag": "ABX9TyMSgdutGp7p33yECMmcUd6v",
+      "include_colab_link": true
+    },
+    "kernelspec": {
+      "name": "python3",
+      "display_name": "Python 3"
+    }
+  },
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "view-in-github",
+        "colab_type": "text"
+      },
+      "source": [
+        "<a href=\"https://colab.research.google.com/github/emorell96/BPD/blob/master/mcmc_nuts_clean.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "sbDSkPEvnzQi",
+        "colab_type": "text"
+      },
+      "source": [
+        "# Imports"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "jE-DDwinwRKk",
+        "colab_type": "code",
+        "colab": {}
+      },
+      "source": [
+        "!pip3 install arviz"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "P1uhEQp4-4nZ",
+        "colab_type": "code",
+        "colab": {}
+      },
+      "source": [
+        "#Goal of this notebook is to create some simple code that can take a 1d array which we will suppose we have, i.e. it will be one of the inputs\n",
+        "#and we will take it and compare it to simulated data.\n",
+        "\n",
+        "## Imports:\n",
+        "import pandas as pd\n",
+        "import seaborn as sns\n",
+        "\n",
+        "import numpy as np\n",
+        "import tensorflow as tf\n",
+        "import tensorflow_probability as tfp\n",
+        "from scipy.integrate import odeint\n",
+        "from scipy.interpolate import interp1d\n",
+        "from scipy.integrate import solve_ivp\n",
+        "from multiprocessing import Process, Queue\n",
+        "import time\n",
+        "import matplotlib.pyplot as plt\n",
+        "from IPython.core.pylabtools import figsize\n",
+        "from functools import partial\n",
+        "from tensorflow_probability import distributions as tfd\n",
+        "from tensorflow_probability import bijectors as tfb\n",
+        "from scipy.optimize import curve_fit\n",
+        "import arviz as az\n",
+        "class _TFColor(object):\n",
+        "    \"\"\"Enum of colors used in TF docs.\"\"\"\n",
+        "    red = '#F15854'\n",
+        "    blue = '#5DA5DA'\n",
+        "    orange = '#FAA43A'\n",
+        "    green = '#60BD68'\n",
+        "    pink = '#F17CB0'\n",
+        "    brown = '#B2912F'\n",
+        "    purple = '#B276B2'\n",
+        "    yellow = '#DECF3F'\n",
+        "    gray = '#4D4D4D'\n",
+        "    def __getitem__(self, i):\n",
+        "        return [\n",
+        "            self.red,\n",
+        "            self.orange,\n",
+        "            self.green,\n",
+        "            self.blue,\n",
+        "            self.pink,\n",
+        "            self.brown,\n",
+        "            self.purple,\n",
+        "            self.yellow,\n",
+        "            self.gray,\n",
+        "        ][i % 9]\n",
+        "TFColor = _TFColor()\n",
+        "\n"
+      ],
+      "execution_count": 41,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "uZR5e4lrwoD9",
+        "colab_type": "code",
+        "colab": {}
+      },
+      "source": [
+        "sns.set_palette(\"muted\")\n",
+        "np.random.seed(1324)\n",
+        "dtype=tf.float32\n",
+        "params = {\n",
+        "    'legend.fontsize': 'x-large',\n",
+        "    'figure.figsize': (9, 6),\n",
+        "    'axes.labelsize': 'x-large',\n",
+        "    'axes.titlesize':'x-large',\n",
+        "    'xtick.labelsize':'x-large',\n",
+        "    'ytick.labelsize':'x-large'\n",
+        "}\n",
+        "plt.rcParams.update(params)\n",
+        "%config InlineBackend.figure_format = 'retina'"
+      ],
+      "execution_count": 18,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "OrS6QGPbpVLN",
+        "colab_type": "text"
+      },
+      "source": [
+        "# Global Constants"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "rXvqbNSppYit",
+        "colab_type": "code",
+        "colab": {}
+      },
+      "source": [
+        "# number of \"pixels\" on the direction\n",
+        "N = 150"
+      ],
+      "execution_count": 2,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "OTaSxYXBoa9D",
+        "colab_type": "text"
+      },
+      "source": [
+        "# Data Import"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "ty8OTXZYDhlt",
+        "colab_type": "text"
+      },
+      "source": [
+        "We will take some data and turn it a 1d array with the data along a given direction.\n",
+        "\n",
+        "The idea is that the data is a 2d matrix, we will interpolate it to get a function OD(x, y) that will provide the optical density at pixels x,y. We want to be able to slice it, so that we give a direction like \\[0,1] or \\[1,1] and with N bins. Each bin would represent a pixel. \n",
+        "\n",
+        "We have used the DataManager made by Peter to get a CSV file that I will use for this run."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "5vTRmA0rls47",
+        "colab_type": "text"
+      },
+      "source": [
+        "Load the optical density (could add some kind of interworking with matlab maybe).\n",
+        "\n",
+        "All of the od < 0 should be equal to 0."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "vpFe4lyrRv9h",
+        "colab_type": "code",
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 35
+        },
+        "outputId": "92a84394-3e71-4c87-91bf-52ac5f6b14a7"
+      },
+      "source": [
+        "#load csv file:\n",
+        "od = np.loadtxt(r\"/content/drive/My Drive/Colab Notebooks/Weld Lab/data/optical density run 18.csv\", delimiter=\",\", encoding='utf-8-sig').T\n",
+        "od[od < 0] = 0 #isn't this so easy with numpy?? How do you even do the same on matlab? Is it as easy, maybe?\n",
+        "od.shape"
+      ],
+      "execution_count": 4,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "(41, 390)"
+            ]
+          },
+          "metadata": {
+            "tags": []
+          },
+          "execution_count": 4
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "QgLoa-I4Fcqe",
+        "colab_type": "code",
+        "colab": {}
+      },
+      "source": [
+        "#import scipy:\n",
+        "from scipy.interpolate import RectBivariateSpline"
+      ],
+      "execution_count": 5,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "fzW2fla2pz4d",
+        "colab_type": "code",
+        "colab": {}
+      },
+      "source": [
+        "#@title Interpolation of OD\n",
+        "X = range(od.shape[0])\n",
+        "Y = range(od.shape[1])\n",
+        "optical_density = RectBivariateSpline(X, Y, od)"
+      ],
+      "execution_count": 6,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "-DTsv2PZojGg",
+        "colab_type": "text"
+      },
+      "source": [
+        "## Helper function to cut through the data"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "Xgo_RsAEqrUO",
+        "colab_type": "code",
+        "colab": {}
+      },
+      "source": [
+        "#@title Helper Function\n",
+        "#this function will provide an array of points, so X, and Y where X[i], Y[i]\n",
+        "#are places where to evaluate this the function along a given direction.\n",
+        "def points(start, end, Nx, Ny, N):\n",
+        "  x1 = start[0]\n",
+        "  y1 = start[1]\n",
+        "  x2, y2 = end\n",
+        "  line = lambda x: (y2-y1)/(x2-x1)*(x-x1)+y1\n",
+        "  \n",
+        "  \n",
+        "  xinit = (x2*y1-x1*y2)/(y1-y2)\n",
+        "  xfinal = (Ny*(x1-x2)-x1*y2+x2*y1)/(y1-y2)\n",
+        "  print(f\"xinit is {xinit:.2f}, xfinal is {xfinal:.2f}.\")\n",
+        "  if xinit<0:\n",
+        "    xinit = 0\n",
+        "  elif xinit > Nx:\n",
+        "    xinit = Nx\n",
+        "  if xfinal > Nx:\n",
+        "    xfinal = Nx\n",
+        "  elif xfinal < 0:\n",
+        "    xfinal = 0\n",
+        "  \n",
+        "  X = np.linspace(xinit, xfinal, N)\n",
+        "  Y = line(X)\n",
+        "  return (X, Y)"
+      ],
+      "execution_count": 26,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "w-xpFQDSqzQA",
+        "colab_type": "code",
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 666
+        },
+        "outputId": "606864e8-15a6-4f9a-cb01-56f37cb66ed8"
+      },
+      "source": [
+        "#@title Set up of the Slice\n",
+        "X, Y = points((15,196),(25,189), od.shape[0], od.shape[1], int(N))\n",
+        "plt.figure(figsize=(5,5))\n",
+        "plt.plot(X, Y)\n",
+        "plt.xlim(0, od.shape[0])\n",
+        "plt.ylim(0, od.shape[1])\n",
+        "plt.figure(figsize=(5,5))\n",
+        "Slice = optical_density(X, Y, grid=False)\n",
+        "plt.plot(Slice)"
+      ],
+      "execution_count": 25,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "text": [
+            "xinit is 295.00, xfinal is -262.14.\n"
+          ],
+          "name": "stdout"
+        },
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "[<matplotlib.lines.Line2D at 0x7f727eefd3c8>]"
+            ]
+          },
+          "metadata": {
+            "tags": []
+          },
+          "execution_count": 25
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "image/png": "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\n",
+            "text/plain": [
+              "<Figure size 360x360 with 1 Axes>"
+            ]
+          },
+          "metadata": {
+            "tags": [],
+            "image/png": {
+              "width": 330,
+              "height": 307
+            },
+            "needs_background": "light"
+          }
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "image/png": "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\n",
+            "text/plain": [
+              "<Figure size 360x360 with 1 Axes>"
+            ]
+          },
+          "metadata": {
+            "tags": [],
+            "image/png": {
+              "width": 326,
+              "height": 307
+            },
+            "needs_background": "light"
+          }
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "Yy2DvQe6q95m",
+        "colab_type": "code",
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 396
+        },
+        "outputId": "c2892178-5ce7-43d7-955a-3f63495eb2e8"
+      },
+      "source": [
+        "#@title Normalization of the Slice\n",
+        "#normalize the slice: (add option to normalise with true dx later)\n",
+        "from scipy.integrate import trapz\n",
+        "Slice = Slice/trapz(Slice)\n",
+        "#make sure there's no negative numbers:\n",
+        "Slice[Slice < 0] = 0\n",
+        "plt.plot(Slice)\n",
+        "trapz(Slice)"
+      ],
+      "execution_count": 24,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "1.0"
+            ]
+          },
+          "metadata": {
+            "tags": []
+          },
+          "execution_count": 24
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "image/png": "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\n",
+            "text/plain": [
+              "<Figure size 648x432 with 1 Axes>"
+            ]
+          },
+          "metadata": {
+            "tags": [],
+            "image/png": {
+              "width": 555,
+              "height": 361
+            },
+            "needs_background": "light"
+          }
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "EFk6hAUAx6I1",
+        "colab_type": "code",
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 1000
+        },
+        "outputId": "9990b3e6-2caa-45a5-a40b-53a8b2a20ee0"
+      },
+      "source": [
+        "#@title Using Panda to keep tidy data\n",
+        "X = np.linspace(0, int(N), num=int(N), endpoint=False)\n",
+        "data = np.column_stack((X, Slice))\n",
+        "print(data)\n",
+        "df = pd.DataFrame(data, columns = ['x','od'])"
+      ],
+      "execution_count": 23,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "text": [
+            "[[0.00000000e+00 1.36998896e-03]\n",
+            " [1.00000000e+00 1.49374255e-03]\n",
+            " [2.00000000e+00 1.37891159e-03]\n",
+            " [3.00000000e+00 1.08380348e-03]\n",
+            " [4.00000000e+00 1.07875221e-03]\n",
+            " [5.00000000e+00 1.75929177e-03]\n",
+            " [6.00000000e+00 1.99981644e-03]\n",
+            " [7.00000000e+00 1.70262054e-03]\n",
+            " [8.00000000e+00 1.40308284e-03]\n",
+            " [9.00000000e+00 1.60540531e-03]\n",
+            " [1.00000000e+01 2.25717986e-03]\n",
+            " [1.10000000e+01 2.74954317e-03]\n",
+            " [1.20000000e+01 2.53527737e-03]\n",
+            " [1.30000000e+01 2.03352730e-03]\n",
+            " [1.40000000e+01 1.81509154e-03]\n",
+            " [1.50000000e+01 1.83498057e-03]\n",
+            " [1.60000000e+01 1.59075295e-03]\n",
+            " [1.70000000e+01 9.48814728e-04]\n",
+            " [1.80000000e+01 3.08547493e-04]\n",
+            " [1.90000000e+01 3.44082633e-05]\n",
+            " [2.00000000e+01 2.04151782e-06]\n",
+            " [2.10000000e+01 8.21533121e-06]\n",
+            " [2.20000000e+01 0.00000000e+00]\n",
+            " [2.30000000e+01 5.67343923e-06]\n",
+            " [2.40000000e+01 1.70164921e-05]\n",
+            " [2.50000000e+01 9.34596089e-06]\n",
+            " [2.60000000e+01 0.00000000e+00]\n",
+            " [2.70000000e+01 8.03908860e-07]\n",
+            " [2.80000000e+01 7.29124434e-06]\n",
+            " [2.90000000e+01 8.89244929e-07]\n",
+            " [3.00000000e+01 0.00000000e+00]\n",
+            " [3.10000000e+01 0.00000000e+00]\n",
+            " [3.20000000e+01 0.00000000e+00]\n",
+            " [3.30000000e+01 2.97842681e-06]\n",
+            " [3.40000000e+01 1.69986134e-05]\n",
+            " [3.50000000e+01 1.84566971e-05]\n",
+            " [3.60000000e+01 6.44253665e-06]\n",
+            " [3.70000000e+01 0.00000000e+00]\n",
+            " [3.80000000e+01 1.95128155e-06]\n",
+            " [3.90000000e+01 1.14765841e-05]\n",
+            " [4.00000000e+01 0.00000000e+00]\n",
+            " [4.10000000e+01 0.00000000e+00]\n",
+            " [4.20000000e+01 0.00000000e+00]\n",
+            " [4.30000000e+01 0.00000000e+00]\n",
+            " [4.40000000e+01 6.01795669e-05]\n",
+            " [4.50000000e+01 2.14274938e-04]\n",
+            " [4.60000000e+01 4.67794192e-04]\n",
+            " [4.70000000e+01 9.00630361e-04]\n",
+            " [4.80000000e+01 1.53723395e-03]\n",
+            " [4.90000000e+01 2.20186107e-03]\n",
+            " [5.00000000e+01 2.73940964e-03]\n",
+            " [5.10000000e+01 3.28290350e-03]\n",
+            " [5.20000000e+01 4.06424738e-03]\n",
+            " [5.30000000e+01 4.84962987e-03]\n",
+            " [5.40000000e+01 5.00837960e-03]\n",
+            " [5.50000000e+01 4.15838769e-03]\n",
+            " [5.60000000e+01 2.72563504e-03]\n",
+            " [5.70000000e+01 1.65876962e-03]\n",
+            " [5.80000000e+01 1.71092999e-03]\n",
+            " [5.90000000e+01 3.04646085e-03]\n",
+            " [6.00000000e+01 4.96397726e-03]\n",
+            " [6.10000000e+01 6.74088894e-03]\n",
+            " [6.20000000e+01 8.05013163e-03]\n",
+            " [6.30000000e+01 9.06287933e-03]\n",
+            " [6.40000000e+01 1.03690608e-02]\n",
+            " [6.50000000e+01 1.24989675e-02]\n",
+            " [6.60000000e+01 1.62467395e-02]\n",
+            " [6.70000000e+01 2.13421199e-02]\n",
+            " [6.80000000e+01 2.61271473e-02]\n",
+            " [6.90000000e+01 2.89577566e-02]\n",
+            " [7.00000000e+01 2.98215264e-02]\n",
+            " [7.10000000e+01 3.13796942e-02]\n",
+            " [7.20000000e+01 3.54582049e-02]\n",
+            " [7.30000000e+01 4.14531817e-02]\n",
+            " [7.40000000e+01 4.62164288e-02]\n",
+            " [7.50000000e+01 4.68417456e-02]\n",
+            " [7.60000000e+01 4.35503292e-02]\n",
+            " [7.70000000e+01 3.87174662e-02]\n",
+            " [7.80000000e+01 3.47954176e-02]\n",
+            " [7.90000000e+01 3.22798320e-02]\n",
+            " [8.00000000e+01 3.04677559e-02]\n",
+            " [8.10000000e+01 2.96984204e-02]\n",
+            " [8.20000000e+01 3.10086001e-02]\n",
+            " [8.30000000e+01 3.39767328e-02]\n",
+            " [8.40000000e+01 3.59892339e-02]\n",
+            " [8.50000000e+01 3.43510454e-02]\n",
+            " [8.60000000e+01 2.90106391e-02]\n",
+            " [8.70000000e+01 2.19343447e-02]\n",
+            " [8.80000000e+01 1.64681998e-02]\n",
+            " [8.90000000e+01 1.42455361e-02]\n",
+            " [9.00000000e+01 1.47293947e-02]\n",
+            " [9.10000000e+01 1.56658744e-02]\n",
+            " [9.20000000e+01 1.44269407e-02]\n",
+            " [9.30000000e+01 1.11928869e-02]\n",
+            " [9.40000000e+01 7.48165094e-03]\n",
+            " [9.50000000e+01 5.09137358e-03]\n",
+            " [9.60000000e+01 4.51293975e-03]\n",
+            " [9.70000000e+01 4.84820320e-03]\n",
+            " [9.80000000e+01 4.95014019e-03]\n",
+            " [9.90000000e+01 4.04593966e-03]\n",
+            " [1.00000000e+02 2.24151579e-03]\n",
+            " [1.01000000e+02 6.00214208e-04]\n",
+            " [1.02000000e+02 0.00000000e+00]\n",
+            " [1.03000000e+02 4.89694059e-05]\n",
+            " [1.04000000e+02 1.43587708e-04]\n",
+            " [1.05000000e+02 4.64204761e-05]\n",
+            " [1.06000000e+02 0.00000000e+00]\n",
+            " [1.07000000e+02 7.33813429e-07]\n",
+            " [1.08000000e+02 2.98263491e-05]\n",
+            " [1.09000000e+02 1.13301986e-06]\n",
+            " [1.10000000e+02 0.00000000e+00]\n",
+            " [1.11000000e+02 2.73250005e-05]\n",
+            " [1.12000000e+02 1.40784417e-04]\n",
+            " [1.13000000e+02 2.52797075e-04]\n",
+            " [1.14000000e+02 2.94297858e-04]\n",
+            " [1.15000000e+02 2.27314518e-04]\n",
+            " [1.16000000e+02 6.05179510e-05]\n",
+            " [1.17000000e+02 0.00000000e+00]\n",
+            " [1.18000000e+02 0.00000000e+00]\n",
+            " [1.19000000e+02 0.00000000e+00]\n",
+            " [1.20000000e+02 0.00000000e+00]\n",
+            " [1.21000000e+02 0.00000000e+00]\n",
+            " [1.22000000e+02 0.00000000e+00]\n",
+            " [1.23000000e+02 0.00000000e+00]\n",
+            " [1.24000000e+02 0.00000000e+00]\n",
+            " [1.25000000e+02 3.75867207e-04]\n",
+            " [1.26000000e+02 8.13035274e-04]\n",
+            " [1.27000000e+02 1.15263640e-03]\n",
+            " [1.28000000e+02 1.41646123e-03]\n",
+            " [1.29000000e+02 1.67145928e-03]\n",
+            " [1.30000000e+02 1.90561726e-03]\n",
+            " [1.31000000e+02 1.99862566e-03]\n",
+            " [1.32000000e+02 1.80465868e-03]\n",
+            " [1.33000000e+02 1.32218788e-03]\n",
+            " [1.34000000e+02 6.80223762e-04]\n",
+            " [1.35000000e+02 1.17230245e-04]\n",
+            " [1.36000000e+02 0.00000000e+00]\n",
+            " [1.37000000e+02 3.97590063e-04]\n",
+            " [1.38000000e+02 1.38066216e-03]\n",
+            " [1.39000000e+02 2.33601244e-03]\n",
+            " [1.40000000e+02 2.59504894e-03]\n",
+            " [1.41000000e+02 2.17667238e-03]\n",
+            " [1.42000000e+02 1.77302229e-03]\n",
+            " [1.43000000e+02 1.94256668e-03]\n",
+            " [1.44000000e+02 2.63005207e-03]\n",
+            " [1.45000000e+02 3.32494082e-03]\n",
+            " [1.46000000e+02 3.43351452e-03]\n",
+            " [1.47000000e+02 2.64604346e-03]\n",
+            " [1.48000000e+02 1.38173086e-03]\n",
+            " [1.49000000e+02 6.68596913e-04]]\n"
+          ],
+          "name": "stdout"
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "iVBbha_Oy_mQ",
+        "colab_type": "text"
+      },
+      "source": [
+        "# Visualisation of data"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "bdzqsQqGzEaE",
+        "colab_type": "code",
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 413
+        },
+        "outputId": "9cc42ef6-7e2a-4702-f144-ffb1d131d7af"
+      },
+      "source": [
+        "plt.scatter(df['x'],df['od'],c='b',label='Normalized Optical Density')\n",
+        "plt.legend(loc= \"upper right\")\n",
+        "plt.xlabel(\"Pixel (arbitrary units)\")\n",
+        "plt.ylabel(\"Optical Density (a.u)\")\n",
+        "plt.title(\"Original OD\");"
+      ],
+      "execution_count": 28,
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "image/png": "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\n",
+            "text/plain": [
+              "<Figure size 648x432 with 1 Axes>"
+            ]
+          },
+          "metadata": {
+            "tags": [],
+            "image/png": {
+              "width": 573,
+              "height": 396
+            },
+            "needs_background": "light"
+          }
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "dZRltlUA082k",
+        "colab_type": "code",
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 413
+        },
+        "outputId": "c1664a53-4eef-4c7d-f563-39c959c4902a"
+      },
+      "source": [
+        "#@title Fit using curve fit\n",
+        "#Fitting function:\n",
+        "from scipy.stats import norm\n",
+        "def gaussian(x, amplitude, mu, sigma):\n",
+        "  return amplitude*norm.pdf(x, loc=mu, scale=sigma)\n",
+        "pop, pcov = curve_fit(gaussian, df[\"x\"], df[\"od\"], p0=[0.04, 80, 20])\n",
+        "print(pop)\n",
+        "plt.plot(df[\"x\"], df[\"od\"])\n",
+        "plt.plot(df[\"x\"], gaussian(df[\"x\"], pop[0], pop[1], pop[2]))"
+      ],
+      "execution_count": 36,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "text": [
+            "[ 0.91796437 77.19525379  9.08106136]\n"
+          ],
+          "name": "stdout"
+        },
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "[<matplotlib.lines.Line2D at 0x7f727ed8ee80>]"
+            ]
+          },
+          "metadata": {
+            "tags": []
+          },
+          "execution_count": 36
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "image/png": "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\n",
+            "text/plain": [
+              "<Figure size 648x432 with 1 Axes>"
+            ]
+          },
+          "metadata": {
+            "tags": [],
+            "image/png": {
+              "width": 555,
+              "height": 361
+            },
+            "needs_background": "light"
+          }
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "ZDgXlFlwmUTH",
+        "colab_type": "text"
+      },
+      "source": [
+        "# Markov Chain Monte Carlo Set Up\n",
+        "\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "eA1duz8go0oH",
+        "colab_type": "text"
+      },
+      "source": [
+        "## Initial Step Set Up"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "7Si8UYMHz0dn",
+        "colab_type": "code",
+        "colab": {}
+      },
+      "source": [
+        "#@title Distribution for normal distribution\n",
+        "root = tfd.JointDistributionCoroutine.Root\n",
+        "\n",
+        "def normal_single_regression():\n",
+        "    amplitude = yield root(tfd.Sample(tfd.Normal(1.0,2.0),1))\n",
+        "    mu = yield root(tfd.Sample(tfd.Normal(77.0,10.0),1))\n",
+        "    sigma = yield root(tfd.Sample(tfd.Normal(9.0, 1.0)))\n",
+        "    \n",
+        "    y = yield tfd.Independent(\n",
+        "        tfd.Normal(\n",
+        "            loc = tfd.Normal(loc=mu, scale=sigma).prob(tf.cast(df['x'],dtype))*amplitude,\n",
+        "            scale = 0.2\n",
+        "        ), reinterpreted_batch_ndims=1\n",
+        "    )"
+      ],
+      "execution_count": 110,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "CDEPuTU86pWt",
+        "colab_type": "code",
+        "colab": {}
+      },
+      "source": [
+        "normal_single_regression_jd = tfd.JointDistributionCoroutine(normal_single_regression)\n",
+        "normal_single_log_prob = lambda *args: normal_single_regression_jd.log_prob(args + (tf.cast(df['od'],dtype),))"
+      ],
+      "execution_count": 38,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "_TvYbTvt7vZ3",
+        "colab_type": "code",
+        "colab": {}
+      },
+      "source": [
+        ""
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "QFJZsSs0vEig",
+        "colab_type": "code",
+        "colab": {}
+      },
+      "source": [
+        "X = tf.cast(tf.constant(range(N)), dtype=tf.float32)\n",
+        "print(X)\n",
+        "sigma = 8.\n",
+        "def gaussian_rates(sigma, mu, w):\n",
+        "  # Xmod = tf.transpose(X*tf.ones(( mu.shape[0], X.shape[0])))\n",
+        "  # print(Xmod)\n",
+        "  # Mumod = mu*tf.ones((X.shape[0], mu.shape[0]))\n",
+        "  # print(Mumod)\n",
+        "  # I0 =  Xmod - Mumod\n",
+        "  # print(I0)\n",
+        "  # I1 = -1.*(tf.pow(I0, 2.)/sigma)\n",
+        "  return w*tf.exp(  -1.*tf.pow(tf.transpose(X*tf.ones(( mu.shape[0], X.shape[0])))-\n",
+        "                    mu*tf.ones((X.shape[0], mu.shape[0])), 2.)/sigma )\n",
+        "\n",
+        "def sim_od_dist(sigma, mu, w):\n",
+        "  rate = w*tf.exp(-(tf.pow(X-mu, 2.)/sigma))\n",
+        "  rate = rate.numpy()\n",
+        "  rate[rate < 1e-8] = 1e-10\n",
+        "  #let's try 3 poisson distributions centered at different places.\n",
+        "\n",
+        "  # print(\"rate \", rate)\n",
+        "  return tfd.Independent(tfd.Poisson(rate=tf.convert_to_tensor(rate, dtype=tf.float32)), reinterpreted_batch_ndims=1)\n",
+        "  # return tfd.Independent(tfd.Normal(loc=w*tf.exp(-(tf.pow(X-mu, 2.)/sigma)), scale=2.), reinterpreted_batch_ndims=1)\n",
+        "def sim_od_multiple_dist(sigma, mu, w):\n",
+        "  # rates = gaussian_rates(sigma, mu, w)\n",
+        "  return tfd.Independent(tfd.Normal(loc=tf.reduce_sum(gaussian_rates(sigma,\n",
+        "                                                                     mu, w),\n",
+        "                                                      axis=1),\n",
+        "                                    scale=tf.ones((int(N),))*0.2), reinterpreted_batch_ndims=1)\n",
+        "\n",
+        "\n",
+        "\n",
+        "dists = [\n",
+        "         #w\n",
+        "         tfd.Uniform(low=0.0, high=10000.0),\n",
+        "         #mu\n",
+        "         tfd.Normal(loc=50., scale=8.),\n",
+        "         #sigma\n",
+        "         tfd.Normal(loc=20., scale=10.),\n",
+        "         #total atoms\n",
+        "         tfd.Normal(loc=10000., scale=50.),\n",
+        "         lambda atoms, sigma, mu, w: sim_od_dist(sigma, mu, w)\n",
+        "]\n",
+        "def generate_multiple_dists(n: int):\n",
+        "  return [\n",
+        "         #w\n",
+        "         tfd.Independent(tfd.Uniform(low=[0.0]*n, high=[10000.]*n),reinterpreted_batch_ndims=1),\n",
+        "         #mu\n",
+        "         tfd.Independent(tfd.Normal(loc=[80.]*n, scale=[50.]*n), reinterpreted_batch_ndims=1),\n",
+        "         #sigma\n",
+        "         tfd.Independent(tfd.Normal(loc=[50.]*n, scale=[5.]*n), reinterpreted_batch_ndims=1),\n",
+        "         #total atoms\n",
+        "         tfd.Normal(loc=1000., scale=80.),\n",
+        "         lambda atoms, sigma, mu, w: sim_od_multiple_dist(sigma, mu, w)\n",
+        "        ]\n",
+        "\n",
+        "\n",
+        "od_dist = tfd.JointDistributionSequential(dists)\n",
+        "od_multiple_dist = tfd.JointDistributionSequential(generate_multiple_dists(3))\n",
+        "print(od_multiple_dist.resolve_graph())\n",
+        "s = od_multiple_dist.sample(1)\n",
+        "print(\"sample \", s)\n",
+        "od_multiple_dist.log_prob_parts(s)\n"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "5fhYxZ2yrdZ_",
+        "colab_type": "code",
+        "colab": {}
+      },
+      "source": [
+        "def target_log_prob_tr(*init_state):\n",
+        "  try:\n",
+        "    #print(\"init st = \", init_state, \"\\n len init\", len(init_state))\n",
+        "    atoms = init_state[3]\n",
+        "    inp = list(init_state)+[Slice*atoms]\n",
+        "    return od_dist.log_prob(inp)\n",
+        "    #print(\"inp \", inp, \"\\n\", len(inp))\n",
+        "  except Exception as e:\n",
+        "    # print(e)\n",
+        "    atoms = init_state[0][3]\n",
+        "    # print(atoms)\n",
+        "    inp = list(init_state[0])+[Slice*atoms]\n",
+        "    # print(inp)\n",
+        "    try:\n",
+        "      return od_dist.log_prob(inp)\n",
+        "    except Exception as e:\n",
+        "      print(e)\n",
+        "      print(init_state)\n",
+        "      exit()\n",
+        "\n",
+        "def target_log_prob_multiple_normals(*init_state):\n",
+        "  try:\n",
+        "    # print(\"init st = \", init_state, \"\\n len init\", len(init_state))\n",
+        "    atoms = init_state[3]\n",
+        "    inp = list(init_state)+[Slice*atoms]\n",
+        "    return od_multiple_dist.log_prob(inp)\n",
+        "    #print(\"inp \", inp, \"\\n\", len(inp))\n",
+        "  except Exception as e:\n",
+        "    # print(e)\n",
+        "    atoms = init_state[0][3]\n",
+        "    # print(atoms)\n",
+        "    inp = list(init_state[0])+[Slice*atoms]\n",
+        "    # print(inp)\n",
+        "    try:\n",
+        "      return od_multiple_dist.log_prob(inp)\n",
+        "    except Exception as e:\n",
+        "      print(e)\n",
+        "      print(init_state)\n",
+        "      exit()"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "hQTjumTnrhYJ",
+        "colab_type": "code",
+        "colab": {}
+      },
+      "source": [
+        "#creation of the distribution used:\n",
+        "# dist = closed_joint_dist_gen(int(N)) #N is the number of pixels in the slice, set globally\n",
+        "# dist = \n",
+        "#how many chains should we use?\n",
+        "chains = 1\n",
+        "#sample it:\n",
+        "# start = dist.sample()\n",
+        "step_size = 0.1"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "BCk2UKeQr0tu",
+        "colab_type": "code",
+        "colab": {},
+        "cellView": "form"
+      },
+      "source": [
+        "#@title Bijectors\n",
+        "# Since HMC operates over unconstrained space, we need to transform the\n",
+        "# samples so they live in real-space.\n",
+        "# unconstraining_bijectors = [\n",
+        "#     tfp.bijectors.Exp(),       # Maps a positive real to R. for x_tail\n",
+        "#     tfp.bijectors.Exp(), # for lambda center\n",
+        "#     tfp.bijectors.Exp(), # for lambda left\n",
+        "#     tfp.bijectors.Exp(), # for lambda right\n",
+        "#     tfp.bijectors.Exp(), # for sigma center\n",
+        "#     tfp.bijectors.Exp(), # for sigma left\n",
+        "#     tfp.bijectors.Exp(), # for sigma right\n",
+        "#     tfp.bijectors.Exp(), # for sigmai\n",
+        "#     tfp.bijectors.Exp(), # for amplitude\n",
+        "#     tfp.bijectors.Sigmoid(), #for mix center\n",
+        "#     tfp.bijectors.Sigmoid() #for mix left\n",
+        "#     # tfp.bijectors.Sigmoid(),       # Maps [0,1] to R. for gamma\n",
+        "#     # tfp.bijectors.Sigmoid(),   # Maps [0,1] to R. for delta\n",
+        "#     # tfp.bijectors.Exp(),        # Maps a positive real to R. for I0\n",
+        "#     # tfp.bijectors.Exp(), # Maps a positive real to R. for R0\n",
+        "#     # tfp.bijectors.Sigmoid() # Maps [0,1] to R. for care\n",
+        "# ]\n",
+        "unconstraining_bijectors = [\n",
+        "    tfp.bijectors.Exp(),       # Maps a positive real to R. for x_tail\n",
+        "    tfp.bijectors.Exp(), # for mu\n",
+        "    tfp.bijectors.Exp(), # for sigma\n",
+        "    tfp.bijectors.Exp() # for atom number\n",
+        "    # tfp.bijectors.Exp(), # for lambda right\n",
+        "    # tfp.bijectors.Exp(), # for sigma center\n",
+        "    # tfp.bijectors.Exp(), # for sigma left\n",
+        "    # tfp.bijectors.Exp(), # for sigma right\n",
+        "    # tfp.bijectors.Exp(), # for sigmai\n",
+        "    # tfp.bijectors.Exp(), # for amplitude\n",
+        "    # tfp.bijectors.Sigmoid(), #for mix center\n",
+        "    # tfp.bijectors.Sigmoid() #for mix left\n",
+        "    # tfp.bijectors.Sigmoid(),       # Maps [0,1] to R. for gamma\n",
+        "    # tfp.bijectors.Sigmoid(),   # Maps [0,1] to R. for delta\n",
+        "    # tfp.bijectors.Exp(),        # Maps a positive real to R. for I0\n",
+        "    # tfp.bijectors.Exp(), # Maps a positive real to R. for R0\n",
+        "    # tfp.bijectors.Sigmoid() # Maps [0,1] to R. for care\n",
+        "]"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "8Lzf3dO6r5Qa",
+        "colab_type": "code",
+        "colab": {}
+      },
+      "source": [
+        "#@title Starting MCMC Code\n",
+        "from google.colab import output\n",
+        "chains = 1\n",
+        "local_runtime = False #@param {type:\"boolean\"}\n",
+        "# wrap the mcmc sampling call in a @tf.function to speed it up\n",
+        "#@tf.function(autograph=False)\n",
+        "calls = 0\n",
+        "def graph_sample_chain(*args, **kwargs):\n",
+        "  print(\"current = \",kwargs[\"current_state\"])\n",
+        "  start_time = time.time()\n",
+        "  out = tfp.mcmc.sample_chain(*args, **kwargs)\n",
+        "  print(f\"It took: {(time.time()-start_time)/60} min\")\n",
+        "  return out\n",
+        "def trace_fn(_, pkr):\n",
+        "    return (\n",
+        "        #pkr.inner_results.inner_results.target_log_prob,\n",
+        "        pkr.inner_results.inner_results.leapfrogs_taken,\n",
+        "        pkr.inner_results.inner_results.has_divergence,\n",
+        "        pkr.inner_results.inner_results.energy,\n",
+        "        pkr.inner_results.inner_results.log_accept_ratio\n",
+        "           )\n",
+        "# r0, gamma, delta, I0, rho, _ = mdl_ols_batch.sample(nchain)\n",
+        "# init_state = [b0, b1]\n",
+        "# # step_size = [tf.cast(i, dtype=dtype) for i in [.1, .1]]\n",
+        "# target_log_prob_fn = lambda *init_state: mdl_ols_batch.log_prob(\n",
+        "#     list(init_state) + [Y_np])\n",
+        "num_burnin_steps = 10000\n",
+        "num_results = 5000\n",
+        "\n",
+        "\n",
+        "\n",
+        "print(step_size)\n",
+        "kernel=tfp.mcmc.TransformedTransitionKernel(\n",
+        "        inner_kernel=tfp.mcmc.HamiltonianMonteCarlo(\n",
+        "            target_log_prob_fn=target_log_prob_multiple_normals,\n",
+        "            num_leapfrog_steps=2,\n",
+        "            step_size=step_size,\n",
+        "            state_gradients_are_stopped=False),\n",
+        "        bijector=unconstraining_bijectors)\n",
+        "\n",
+        "kernel = tfp.mcmc.SimpleStepSizeAdaptation(\n",
+        "    inner_kernel=kernel, num_adaptation_steps=int(num_burnin_steps * 0.8))\n",
+        "\n",
+        "#kernel.bootstrap_results(init_state)\n",
+        "\n",
+        "# # Sample from the chain.\n",
+        "# [\n",
+        "#     r0_samples,\n",
+        "#     gamma_samples,\n",
+        "#     delta_samples,\n",
+        "#     I0_samples,\n",
+        "#     posterior_care,\n",
+        "# ],\n",
+        "kernel_results = graph_sample_chain(\n",
+        "    num_results=num_results,\n",
+        "    num_burnin_steps=num_burnin_steps,\n",
+        "    current_state=init, #put init in here if you want to start from init\n",
+        "    #previous_kernel_results=kernel.bootstrap_results(initial_chain_state),\n",
+        "    kernel = kernel, parallel_iterations=chains)\n",
+        "#save the kernel_results to drive:\n",
+        "[w_samples, mu_samples, sigma_samples, atom_samples], extra = kernel_results\n",
+        "# [xtail_samples, lambdac_samples, lambdal_samples, lambdar_samples, sigmac_samples, sigmal_samples, sigmar_samples, sigmai_samples, amplitude_samples, mixc_samples, mixl_samples], extra = kernel_results\n",
+        "#save data as plain npz files:\n",
+        "base = r\"Desktop/covid19/\" if local_runtime else r\"/content/drive/My Drive/Colab Notebooks/Weld Lab/data/\"\n",
+        "output_path = base + f\"out/output_run18_{time.strftime('%Y-%m-%d-%H:%M %Z', time.localtime())}.npz\"\n",
+        "np.savez(output_path, w_samples, mu_samples, sigma_samples, atom_samples)# xtail_samples, lambdac_samples, lambdal_samples, lambdar_samples, sigmac_samples, sigmal_samples, sigmar_samples, sigmai_samples, amplitude_samples, mixc_samples, mixl_samples)\n",
+        "\n",
+        "# notify.send(\"Finished!\")\n",
+        "#np.savez(\"/content/drive/My Drive/Colab Notebooks/out/output_acceptance.npz\", tf.cast(extra.inner_results.inner_results.is_accepted,dtype=tf.float32)).numpy(), extra.inner_results.inner_results.accepted_results.step_size[-100:])\n",
+        "# tau_samples = tf.floor(posterior_care * tf.cast(tf.size(cases),dtype=tf.float32))\n",
+        "output.eval_js('new Audio(\"https://upload.wikimedia.org/wikipedia/commons/0/05/Beep-09.ogg\").play()')"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "w92_LnY-sB1x",
+        "colab_type": "code",
+        "colab": {}
+      },
+      "source": [
+        "#@title Calculate Acceptance Rate\n",
+        "print(\"acceptance rate: {}\".format(\n",
+        "    tf.reduce_mean(tf.cast(extra.inner_results.inner_results.is_accepted,dtype=tf.float32))))\n",
+        "print(\"final step size: {}\".format(\n",
+        "    tf.reduce_mean(extra.inner_results.inner_results.accepted_results.step_size[-100:])))\n",
+        "# extra\n",
+        "# step_size = [o[-1] for o in extra.inner_results.inner_results.accepted_results.step_size]\n",
+        "step_size =  tf.reduce_mean(extra.inner_results.inner_results.accepted_results.step_size[-100:])\n",
+        "tf.reduce_mean(extra.inner_results.inner_results.accepted_results.target_log_prob, axis=0)\n",
+        "# step_size = 0.1"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "dKwDiR25xDjD",
+        "colab_type": "text"
+      },
+      "source": [
+        "# NUTS Kernel"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "ua5kqnaVxko9",
+        "colab_type": "text"
+      },
+      "source": [
+        "Code taken from https://adamhaber.github.io/post/nuts/"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "WsRVb0JGxY2I",
+        "colab_type": "code",
+        "colab": {}
+      },
+      "source": [
+        "#@title trace to Arviz function\n",
+        "# using pymc3 naming conventions, with log_likelihood instead of lp so that ArviZ can compute loo and waic\n",
+        "sample_stats_name = ['log_likelihood','tree_size','diverging','energy','mean_tree_accept']\n",
+        "\n",
+        "def tfp_trace_to_arviz(\n",
+        "    tfp_trace,\n",
+        "    var_names=None, \n",
+        "    sample_stats_name=sample_stats_name):\n",
+        "    \n",
+        "    samps, trace = tfp_trace\n",
+        "    if var_names is None:\n",
+        "        var_names = [\"var \" + str(x) for x in range(len(samps))]\n",
+        "        \n",
+        "    sample_stats = {k: v.numpy().T for k, v in zip(sample_stats_name, trace)}\n",
+        "    # print(samps)\n",
+        "    posterior = {name : np.transpose(samp.numpy(), axes=[1, 0, 2]) for name, samp in zip(var_names, samps)}\n",
+        "    print(posterior[\"amplitude\"].shape)\n",
+        "    return az.from_dict(posterior=posterior, sample_stats=sample_stats)"
+      ],
+      "execution_count": 100,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "yUyR6GwQtDk9",
+        "colab_type": "code",
+        "colab": {},
+        "cellView": "both"
+      },
+      "source": [
+        "#@title Trace Function for NUTS\n",
+        "def trace_fn(_, pkr):  \n",
+        "    return (\n",
+        "        pkr.inner_results.inner_results.target_log_prob,\n",
+        "        pkr.inner_results.inner_results.leapfrogs_taken,\n",
+        "        pkr.inner_results.inner_results.has_divergence,\n",
+        "        pkr.inner_results.inner_results.energy,\n",
+        "        pkr.inner_results.inner_results.log_accept_ratio\n",
+        "    )"
+      ],
+      "execution_count": 19,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "BUuEGof6t5l1",
+        "colab_type": "code",
+        "colab": {},
+        "cellView": "both"
+      },
+      "source": [
+        "#@title Nuts template\n",
+        "n_chains = 10\n",
+        "def run_nuts_template(\n",
+        "    trace_fn,\n",
+        "    target_log_prob_fn,\n",
+        "    inits,\n",
+        "    bijectors_list=None, \n",
+        "    num_steps=500,\n",
+        "    num_burnin=500,\n",
+        "    n_chains=n_chains):\n",
+        "    \n",
+        "    step_size = np.random.rand(n_chains, 1)*.5 + 1.\n",
+        "    \n",
+        "    if not isinstance(inits, list):\n",
+        "        inits = [inits]\n",
+        "        \n",
+        "    if bijectors_list is None:\n",
+        "        bijectors_list = [tfb.Identity()]*len(inits)\n",
+        "\n",
+        "    kernel = tfp.mcmc.DualAveragingStepSizeAdaptation(\n",
+        "        tfp.mcmc.TransformedTransitionKernel(\n",
+        "            inner_kernel=tfp.mcmc.NoUTurnSampler(\n",
+        "                target_log_prob_fn,\n",
+        "                step_size=[step_size]*len(inits)\n",
+        "            ),\n",
+        "            bijector=bijectors_list\n",
+        "        ),\n",
+        "        target_accept_prob=.8,\n",
+        "        num_adaptation_steps=int(0.8*num_burnin),\n",
+        "        step_size_setter_fn=lambda pkr, new_step_size: pkr._replace(\n",
+        "              inner_results=pkr.inner_results._replace(step_size=new_step_size)\n",
+        "          ),\n",
+        "        step_size_getter_fn=lambda pkr: pkr.inner_results.step_size,\n",
+        "        log_accept_prob_getter_fn=lambda pkr: pkr.inner_results.log_accept_ratio,\n",
+        "    )\n",
+        "    \n",
+        "    res = tfp.mcmc.sample_chain(\n",
+        "        num_results=num_steps,\n",
+        "        num_burnin_steps=num_burnin,\n",
+        "        current_state=inits,\n",
+        "        kernel=kernel,\n",
+        "        trace_fn=trace_fn\n",
+        "    )\n",
+        "    return res"
+      ],
+      "execution_count": 106,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "cJ7c4fTDxB3x",
+        "colab_type": "code",
+        "colab": {},
+        "cellView": "both"
+      },
+      "source": [
+        "#@title Optimized functions\n",
+        "run_nuts = partial(run_nuts_template, trace_fn)\n",
+        "\n",
+        "run_nuts_opt = tf.function(run_nuts)\n",
+        "run_nuts_defun = tf.function(run_nuts, autograph=False)"
+      ],
+      "execution_count": 107,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "pSM-kgfS7GJ1",
+        "colab_type": "code",
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 1000
+        },
+        "outputId": "23a9188f-f23f-47a7-ee1e-bba78514064d"
+      },
+      "source": [
+        "#@title Run nuts\n",
+        "%%time\n",
+        "init = [tf.ones((n_chains,1))*0.92, tf.ones((n_chains,1))*77.2, tf.ones((n_chains,1))*9.08]\n",
+        "# res = run_nuts(normal_single_log_prob, init)\n",
+        "run_nuts_template(trace_fn, normal_single_log_prob, init)"
+      ],
+      "execution_count": 112,
+      "outputs": [
+        {
+          "output_type": "error",
+          "ename": "ValueError",
+          "evalue": "ignored",
+          "traceback": [
+            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+            "\u001b[0;31mInvalidArgumentError\u001b[0m                      Traceback (most recent call last)",
+            "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/tensorflow/python/framework/ops.py\u001b[0m in \u001b[0;36m_create_c_op\u001b[0;34m(graph, node_def, inputs, control_inputs, op_def)\u001b[0m\n\u001b[1;32m   1653\u001b[0m   \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1654\u001b[0;31m     \u001b[0mc_op\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpywrap_tf_session\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mTF_FinishOperation\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mop_desc\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1655\u001b[0m   \u001b[0;32mexcept\u001b[0m \u001b[0merrors\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mInvalidArgumentError\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;31mInvalidArgumentError\u001b[0m: Dimensions must be equal, but are 150 and 10 for '{{node mcmc_sample_chain_2/trace_scan/while/smart_for_loop/while/dual_averaging_step_size_adaptation___init___2/_one_step/transformed_kernel_one_step/NoUTurnSampler_2/.one_step/while/loop_tree_doubling/build_sub_tree/while/loop_build_sub_tree/leapfrog_integrate/while/leapfrog_integrate_one_step/maybe_call_fn_and_grads/value_and_gradients/JointDistributionCoroutine/log_prob/mcmc_sample_chain_2_trace_scan_while_smart_for_loop_while_dual_averaging_step_size_adaptation___init___2__one_step_transformed_kernel_one_step_NoUTurnSampler_2_one_step_while_loop_tree_doubling_build_sub_tree_while_loop_build_sub_tree_leapfrog_integrate_while_leapfrog_integrate_one_step_maybe_call_fn_and_grads_value_and_gradients_JointDistributionCoroutine_log_prob_Normal_3/prob/truediv}} = RealDiv[T=DT_FLOAT](mcmc_sample_chain_2/trace_scan/while/smart_for_loop/while/dual_averaging_step_size_adaptation___init___2/_one_step/transformed_kernel_one_step/NoUTurnSampler_2/.one_step/while/loop_tree_doubling/build_sub_tree/while/loop_build_sub_tree/leapfrog_integrate/while/leapfrog_integrate_one_step/maybe_call_fn_and_grads/value_and_gradients/JointDistributionCoroutine/log_prob/Cast, mcmc_sample_chain_2/trace_scan/while/smart_for_loop/while/dual_averaging_step_size_adaptation___init___2/_one_step/transformed_kernel_one_step/NoUTurnSampler_2/.one_step/while/loop_tree_doubling/build_sub_tree/while/loop_build_sub_tree/leapfrog_inte...",
+            "\nDuring handling of the above exception, another exception occurred:\n",
+            "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
+            "\u001b[0;32m<ipython-input-112-f55c2f0db281>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mget_ipython\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrun_cell_magic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'time'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m''\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'init = [tf.ones((n_chains,1))*0.92, tf.ones((n_chains,1))*77.2, tf.ones((n_chains,1))*9.08]\\n# res = run_nuts(normal_single_log_prob, init)\\nrun_nuts_template(trace_fn, normal_single_log_prob, init)'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+            "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/IPython/core/interactiveshell.py\u001b[0m in \u001b[0;36mrun_cell_magic\u001b[0;34m(self, magic_name, line, cell)\u001b[0m\n\u001b[1;32m   2115\u001b[0m             \u001b[0mmagic_arg_s\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvar_expand\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mline\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstack_depth\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2116\u001b[0m             \u001b[0;32mwith\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbuiltin_trap\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2117\u001b[0;31m                 \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfn\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmagic_arg_s\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcell\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   2118\u001b[0m             \u001b[0;32mreturn\u001b[0m \u001b[0mresult\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2119\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<decorator-gen-60>\u001b[0m in \u001b[0;36mtime\u001b[0;34m(self, line, cell, local_ns)\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/IPython/core/magic.py\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(f, *a, **k)\u001b[0m\n\u001b[1;32m    186\u001b[0m     \u001b[0;31m# but it's overkill for just that one bit of state.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    187\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mmagic_deco\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0marg\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 188\u001b[0;31m         \u001b[0mcall\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mlambda\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mk\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mk\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    189\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    190\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mcallable\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0marg\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/IPython/core/magics/execution.py\u001b[0m in \u001b[0;36mtime\u001b[0;34m(self, line, cell, local_ns)\u001b[0m\n\u001b[1;32m   1191\u001b[0m         \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1192\u001b[0m             \u001b[0mst\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mclock2\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1193\u001b[0;31m             \u001b[0mexec\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcode\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mglob\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlocal_ns\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1194\u001b[0m             \u001b[0mend\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mclock2\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1195\u001b[0m             \u001b[0mout\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<timed exec>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-106-4f68eb7e1057>\u001b[0m in \u001b[0;36mrun_nuts_template\u001b[0;34m(trace_fn, target_log_prob_fn, inits, bijectors_list, num_steps, num_burnin, n_chains)\u001b[0m\n\u001b[1;32m     40\u001b[0m         \u001b[0mcurrent_state\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0minits\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     41\u001b[0m         \u001b[0mkernel\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mkernel\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 42\u001b[0;31m         \u001b[0mtrace_fn\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mtrace_fn\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     43\u001b[0m     )\n\u001b[1;32m     44\u001b[0m     \u001b[0;32mreturn\u001b[0m \u001b[0mres\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/tensorflow_probability/python/mcmc/sample.py\u001b[0m in \u001b[0;36msample_chain\u001b[0;34m(num_results, current_state, previous_kernel_results, kernel, num_burnin_steps, num_steps_between_results, trace_fn, return_final_kernel_results, parallel_iterations, name)\u001b[0m\n\u001b[1;32m    357\u001b[0m                                             trace_fn(*state_and_results)),\n\u001b[1;32m    358\u001b[0m         \u001b[0;31m# pylint: enable=g-long-lambda\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 359\u001b[0;31m         parallel_iterations=parallel_iterations)\n\u001b[0m\u001b[1;32m    360\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    361\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0mreturn_final_kernel_results\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/tensorflow_probability/python/mcmc/internal/util.py\u001b[0m in \u001b[0;36mtrace_scan\u001b[0;34m(loop_fn, initial_state, elems, trace_fn, parallel_iterations, name)\u001b[0m\n\u001b[1;32m    392\u001b[0m         \u001b[0mbody\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0m_body\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    393\u001b[0m         \u001b[0mloop_vars\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minitial_state\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtrace_arrays\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 394\u001b[0;31m         parallel_iterations=parallel_iterations)\n\u001b[0m\u001b[1;32m    395\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    396\u001b[0m     \u001b[0mstacked_trace\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnest\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmap_structure\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstack\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtrace_arrays\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/tensorflow/python/util/deprecation.py\u001b[0m in \u001b[0;36mnew_func\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    572\u001b[0m                   \u001b[0mfunc\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__module__\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0marg_name\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0marg_value\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'in a future version'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    573\u001b[0m                   if date is None else ('after %s' % date), instructions)\n\u001b[0;32m--> 574\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    575\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    576\u001b[0m     doc = _add_deprecated_arg_value_notice_to_docstring(\n",
+            "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/tensorflow/python/ops/control_flow_ops.py\u001b[0m in \u001b[0;36mwhile_loop_v2\u001b[0;34m(cond, body, loop_vars, shape_invariants, parallel_iterations, back_prop, swap_memory, maximum_iterations, name)\u001b[0m\n\u001b[1;32m   2489\u001b[0m       \u001b[0mname\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mname\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2490\u001b[0m       \u001b[0mmaximum_iterations\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mmaximum_iterations\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2491\u001b[0;31m       return_same_structure=True)\n\u001b[0m\u001b[1;32m   2492\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2493\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/tensorflow/python/ops/control_flow_ops.py\u001b[0m in \u001b[0;36mwhile_loop\u001b[0;34m(cond, body, loop_vars, shape_invariants, parallel_iterations, back_prop, swap_memory, name, maximum_iterations, return_same_structure)\u001b[0m\n\u001b[1;32m   2764\u001b[0m       \u001b[0mops\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0madd_to_collection\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mops\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mGraphKeys\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mWHILE_CONTEXT\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mloop_context\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2765\u001b[0m     result = loop_context.BuildLoop(cond, body, loop_vars, shape_invariants,\n\u001b[0;32m-> 2766\u001b[0;31m                                     return_same_structure)\n\u001b[0m\u001b[1;32m   2767\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0mmaximum_iterations\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2768\u001b[0m       \u001b[0;32mreturn\u001b[0m \u001b[0mresult\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/tensorflow/python/ops/control_flow_ops.py\u001b[0m in \u001b[0;36mBuildLoop\u001b[0;34m(self, pred, body, loop_vars, shape_invariants, return_same_structure)\u001b[0m\n\u001b[1;32m   2246\u001b[0m       \u001b[0;32mwith\u001b[0m \u001b[0mops\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_default_graph\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_mutation_lock\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m  \u001b[0;31m# pylint: disable=protected-access\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2247\u001b[0m         original_body_result, exit_vars = self._BuildLoop(\n\u001b[0;32m-> 2248\u001b[0;31m             pred, body, original_loop_vars, loop_vars, shape_invariants)\n\u001b[0m\u001b[1;32m   2249\u001b[0m     \u001b[0;32mfinally\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2250\u001b[0m       \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mExit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/tensorflow/python/ops/control_flow_ops.py\u001b[0m in \u001b[0;36m_BuildLoop\u001b[0;34m(self, pred, body, original_loop_vars, loop_vars, shape_invariants)\u001b[0m\n\u001b[1;32m   2171\u001b[0m         expand_composites=True)\n\u001b[1;32m   2172\u001b[0m     \u001b[0mpre_summaries\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mops\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_collection\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mops\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mGraphKeys\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_SUMMARY_COLLECTION\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# pylint: disable=protected-access\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2173\u001b[0;31m     \u001b[0mbody_result\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mbody\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mpacked_vars_for_body\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   2174\u001b[0m     \u001b[0mpost_summaries\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mops\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_collection\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mops\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mGraphKeys\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_SUMMARY_COLLECTION\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# pylint: disable=protected-access\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2175\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mnest\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mis_sequence_or_composite\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbody_result\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/tensorflow_probability/python/mcmc/internal/util.py\u001b[0m in \u001b[0;36m_body\u001b[0;34m(i, state, trace_arrays)\u001b[0m\n\u001b[1;32m    381\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    382\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0m_body\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstate\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtrace_arrays\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 383\u001b[0;31m       \u001b[0mstate\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mloop_fn\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mstate\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0melems_array\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mread\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    384\u001b[0m       trace_arrays = tf.nest.pack_sequence_as(trace_arrays, [\n\u001b[1;32m    385\u001b[0m           a.write(i, v) for a, v in zip(\n",
+            "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/tensorflow_probability/python/mcmc/sample.py\u001b[0m in \u001b[0;36m_trace_scan_fn\u001b[0;34m(state_and_results, num_steps)\u001b[0m\n\u001b[1;32m    341\u001b[0m           \u001b[0mbody_fn\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mkernel\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mone_step\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    342\u001b[0m           \u001b[0minitial_loop_vars\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mlist\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mstate_and_results\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 343\u001b[0;31m           parallel_iterations=parallel_iterations)\n\u001b[0m\u001b[1;32m    344\u001b[0m       \u001b[0;32mreturn\u001b[0m \u001b[0mnext_state\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcurrent_kernel_results\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    345\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/tensorflow_probability/python/mcmc/internal/util.py\u001b[0m in \u001b[0;36msmart_for_loop\u001b[0;34m(loop_num_iter, body_fn, initial_loop_vars, parallel_iterations, name)\u001b[0m\n\u001b[1;32m    314\u001b[0m           \u001b[0mbody\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mi\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mlist\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbody_fn\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    315\u001b[0m           \u001b[0mloop_vars\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mint32\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0minitial_loop_vars\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 316\u001b[0;31m           \u001b[0mparallel_iterations\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mparallel_iterations\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    317\u001b[0m       )[1:]\n\u001b[1;32m    318\u001b[0m     \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0minitial_loop_vars\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/tensorflow/python/util/deprecation.py\u001b[0m in \u001b[0;36mnew_func\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    572\u001b[0m                   \u001b[0mfunc\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__module__\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0marg_name\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0marg_value\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'in a future version'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    573\u001b[0m                   if date is None else ('after %s' % date), instructions)\n\u001b[0;32m--> 574\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    575\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    576\u001b[0m     doc = _add_deprecated_arg_value_notice_to_docstring(\n",
+            "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/tensorflow/python/ops/control_flow_ops.py\u001b[0m in \u001b[0;36mwhile_loop_v2\u001b[0;34m(cond, body, loop_vars, shape_invariants, parallel_iterations, back_prop, swap_memory, maximum_iterations, name)\u001b[0m\n\u001b[1;32m   2489\u001b[0m       \u001b[0mname\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mname\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2490\u001b[0m       \u001b[0mmaximum_iterations\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mmaximum_iterations\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2491\u001b[0;31m       return_same_structure=True)\n\u001b[0m\u001b[1;32m   2492\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2493\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/tensorflow/python/ops/control_flow_ops.py\u001b[0m in \u001b[0;36mwhile_loop\u001b[0;34m(cond, body, loop_vars, shape_invariants, parallel_iterations, back_prop, swap_memory, name, maximum_iterations, return_same_structure)\u001b[0m\n\u001b[1;32m   2764\u001b[0m       \u001b[0mops\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0madd_to_collection\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mops\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mGraphKeys\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mWHILE_CONTEXT\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mloop_context\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2765\u001b[0m     result = loop_context.BuildLoop(cond, body, loop_vars, shape_invariants,\n\u001b[0;32m-> 2766\u001b[0;31m                                     return_same_structure)\n\u001b[0m\u001b[1;32m   2767\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0mmaximum_iterations\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2768\u001b[0m       \u001b[0;32mreturn\u001b[0m \u001b[0mresult\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/tensorflow/python/ops/control_flow_ops.py\u001b[0m in \u001b[0;36mBuildLoop\u001b[0;34m(self, pred, body, loop_vars, shape_invariants, return_same_structure)\u001b[0m\n\u001b[1;32m   2246\u001b[0m       \u001b[0;32mwith\u001b[0m \u001b[0mops\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_default_graph\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_mutation_lock\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m  \u001b[0;31m# pylint: disable=protected-access\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2247\u001b[0m         original_body_result, exit_vars = self._BuildLoop(\n\u001b[0;32m-> 2248\u001b[0;31m             pred, body, original_loop_vars, loop_vars, shape_invariants)\n\u001b[0m\u001b[1;32m   2249\u001b[0m     \u001b[0;32mfinally\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2250\u001b[0m       \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mExit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/tensorflow/python/ops/control_flow_ops.py\u001b[0m in \u001b[0;36m_BuildLoop\u001b[0;34m(self, pred, body, original_loop_vars, loop_vars, shape_invariants)\u001b[0m\n\u001b[1;32m   2171\u001b[0m         expand_composites=True)\n\u001b[1;32m   2172\u001b[0m     \u001b[0mpre_summaries\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mops\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_collection\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mops\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mGraphKeys\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_SUMMARY_COLLECTION\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# pylint: disable=protected-access\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2173\u001b[0;31m     \u001b[0mbody_result\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mbody\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mpacked_vars_for_body\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   2174\u001b[0m     \u001b[0mpost_summaries\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mops\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_collection\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mops\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mGraphKeys\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_SUMMARY_COLLECTION\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# pylint: disable=protected-access\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2175\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mnest\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mis_sequence_or_composite\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbody_result\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/tensorflow_probability/python/mcmc/internal/util.py\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(i, *args)\u001b[0m\n\u001b[1;32m    312\u001b[0m       return tf.while_loop(\n\u001b[1;32m    313\u001b[0m           \u001b[0mcond\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mi\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mi\u001b[0m \u001b[0;34m<\u001b[0m \u001b[0mloop_num_iter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 314\u001b[0;31m           \u001b[0mbody\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mi\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mlist\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbody_fn\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    315\u001b[0m           \u001b[0mloop_vars\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mint32\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0minitial_loop_vars\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    316\u001b[0m           \u001b[0mparallel_iterations\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mparallel_iterations\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/tensorflow_probability/python/mcmc/dual_averaging_step_size_adaptation.py\u001b[0m in \u001b[0;36mone_step\u001b[0;34m(self, current_state, previous_kernel_results)\u001b[0m\n\u001b[1;32m    436\u001b[0m       \u001b[0;31m# Step the inner kernel.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    437\u001b[0m       new_state, new_inner_results = self.inner_kernel.one_step(\n\u001b[0;32m--> 438\u001b[0;31m           current_state, inner_results)\n\u001b[0m\u001b[1;32m    439\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    440\u001b[0m       \u001b[0;31m# Get the new step size.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/tensorflow_probability/python/mcmc/transformed_kernel.py\u001b[0m in \u001b[0;36mone_step\u001b[0;34m(self, current_state, previous_kernel_results)\u001b[0m\n\u001b[1;32m    321\u001b[0m       transformed_next_state, kernel_results = self._inner_kernel.one_step(\n\u001b[1;32m    322\u001b[0m           \u001b[0mprevious_kernel_results\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtransformed_state\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 323\u001b[0;31m           previous_kernel_results.inner_results)\n\u001b[0m\u001b[1;32m    324\u001b[0m       transformed_next_state_parts = (\n\u001b[1;32m    325\u001b[0m           \u001b[0mtransformed_next_state\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/tensorflow_probability/python/mcmc/nuts.py\u001b[0m in \u001b[0;36mone_step\u001b[0;34m(self, current_state, previous_kernel_results)\u001b[0m\n\u001b[1;32m    373\u001b[0m               \u001b[0minitial_step_state\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    374\u001b[0m               initial_step_metastate),\n\u001b[0;32m--> 375\u001b[0;31m           \u001b[0mparallel_iterations\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparallel_iterations\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    376\u001b[0m       )\n\u001b[1;32m    377\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/tensorflow/python/util/deprecation.py\u001b[0m in \u001b[0;36mnew_func\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    572\u001b[0m                   \u001b[0mfunc\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__module__\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0marg_name\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0marg_value\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'in a future version'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    573\u001b[0m                   if date is None else ('after %s' % date), instructions)\n\u001b[0;32m--> 574\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    575\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    576\u001b[0m     doc = _add_deprecated_arg_value_notice_to_docstring(\n",
+            "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/tensorflow/python/ops/control_flow_ops.py\u001b[0m in \u001b[0;36mwhile_loop_v2\u001b[0;34m(cond, body, loop_vars, shape_invariants, parallel_iterations, back_prop, swap_memory, maximum_iterations, name)\u001b[0m\n\u001b[1;32m   2489\u001b[0m       \u001b[0mname\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mname\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2490\u001b[0m       \u001b[0mmaximum_iterations\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mmaximum_iterations\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2491\u001b[0;31m       return_same_structure=True)\n\u001b[0m\u001b[1;32m   2492\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2493\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/tensorflow/python/ops/control_flow_ops.py\u001b[0m in \u001b[0;36mwhile_loop\u001b[0;34m(cond, body, loop_vars, shape_invariants, parallel_iterations, back_prop, swap_memory, name, maximum_iterations, return_same_structure)\u001b[0m\n\u001b[1;32m   2764\u001b[0m       \u001b[0mops\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0madd_to_collection\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mops\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mGraphKeys\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mWHILE_CONTEXT\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mloop_context\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2765\u001b[0m     result = loop_context.BuildLoop(cond, body, loop_vars, shape_invariants,\n\u001b[0;32m-> 2766\u001b[0;31m                                     return_same_structure)\n\u001b[0m\u001b[1;32m   2767\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0mmaximum_iterations\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2768\u001b[0m       \u001b[0;32mreturn\u001b[0m \u001b[0mresult\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/tensorflow/python/ops/control_flow_ops.py\u001b[0m in \u001b[0;36mBuildLoop\u001b[0;34m(self, pred, body, loop_vars, shape_invariants, return_same_structure)\u001b[0m\n\u001b[1;32m   2246\u001b[0m       \u001b[0;32mwith\u001b[0m \u001b[0mops\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_default_graph\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_mutation_lock\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m  \u001b[0;31m# pylint: disable=protected-access\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2247\u001b[0m         original_body_result, exit_vars = self._BuildLoop(\n\u001b[0;32m-> 2248\u001b[0;31m             pred, body, original_loop_vars, loop_vars, shape_invariants)\n\u001b[0m\u001b[1;32m   2249\u001b[0m     \u001b[0;32mfinally\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2250\u001b[0m       \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mExit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/tensorflow/python/ops/control_flow_ops.py\u001b[0m in \u001b[0;36m_BuildLoop\u001b[0;34m(self, pred, body, original_loop_vars, loop_vars, shape_invariants)\u001b[0m\n\u001b[1;32m   2171\u001b[0m         expand_composites=True)\n\u001b[1;32m   2172\u001b[0m     \u001b[0mpre_summaries\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mops\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_collection\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mops\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mGraphKeys\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_SUMMARY_COLLECTION\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# pylint: disable=protected-access\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2173\u001b[0;31m     \u001b[0mbody_result\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mbody\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mpacked_vars_for_body\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   2174\u001b[0m     \u001b[0mpost_summaries\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mops\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_collection\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mops\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mGraphKeys\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_SUMMARY_COLLECTION\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# pylint: disable=protected-access\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2175\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mnest\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mis_sequence_or_composite\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbody_result\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/tensorflow_probability/python/mcmc/nuts.py\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(iter_, state, metastate)\u001b[0m\n\u001b[1;32m    368\u001b[0m               \u001b[0miter_\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    369\u001b[0m               \u001b[0mstate\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 370\u001b[0;31m               metastate),\n\u001b[0m\u001b[1;32m    371\u001b[0m           loop_vars=(\n\u001b[1;32m    372\u001b[0m               \u001b[0mtf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mzeros\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdtype\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mtf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mint32\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mname\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'iter'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/tensorflow_probability/python/mcmc/nuts.py\u001b[0m in \u001b[0;36mloop_tree_doubling\u001b[0;34m(self, step_size, momentum_state_memory, current_step_meta_info, iter_, initial_step_state, initial_step_metastate)\u001b[0m\n\u001b[1;32m    539\u001b[0m           \u001b[0minitial_step_metastate\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcontinue_tree\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    540\u001b[0m           \u001b[0minitial_step_metastate\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnot_divergence\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 541\u001b[0;31m           momentum_state_memory)\n\u001b[0m\u001b[1;32m    542\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    543\u001b[0m       \u001b[0mlast_candidate_state\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0minitial_step_metastate\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcandidate_state\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/tensorflow_probability/python/mcmc/nuts.py\u001b[0m in \u001b[0;36m_build_sub_tree\u001b[0;34m(self, directions, integrator, current_step_meta_info, nsteps, initial_state, continue_tree, not_divergence, momentum_state_memory, name)\u001b[0m\n\u001b[1;32m    731\u001b[0m               \u001b[0mmomentum_state_memory\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    732\u001b[0m           ),\n\u001b[0;32m--> 733\u001b[0;31m           \u001b[0mparallel_iterations\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparallel_iterations\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    734\u001b[0m       )\n\u001b[1;32m    735\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/tensorflow/python/util/deprecation.py\u001b[0m in \u001b[0;36mnew_func\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    572\u001b[0m                   \u001b[0mfunc\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__module__\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0marg_name\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0marg_value\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'in a future version'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    573\u001b[0m                   if date is None else ('after %s' % date), instructions)\n\u001b[0;32m--> 574\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    575\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    576\u001b[0m     doc = _add_deprecated_arg_value_notice_to_docstring(\n",
+            "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/tensorflow/python/ops/control_flow_ops.py\u001b[0m in \u001b[0;36mwhile_loop_v2\u001b[0;34m(cond, body, loop_vars, shape_invariants, parallel_iterations, back_prop, swap_memory, maximum_iterations, name)\u001b[0m\n\u001b[1;32m   2489\u001b[0m       \u001b[0mname\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mname\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2490\u001b[0m       \u001b[0mmaximum_iterations\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mmaximum_iterations\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2491\u001b[0;31m       return_same_structure=True)\n\u001b[0m\u001b[1;32m   2492\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2493\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/tensorflow/python/ops/control_flow_ops.py\u001b[0m in \u001b[0;36mwhile_loop\u001b[0;34m(cond, body, loop_vars, shape_invariants, parallel_iterations, back_prop, swap_memory, name, maximum_iterations, return_same_structure)\u001b[0m\n\u001b[1;32m   2764\u001b[0m       \u001b[0mops\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0madd_to_collection\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mops\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mGraphKeys\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mWHILE_CONTEXT\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mloop_context\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2765\u001b[0m     result = loop_context.BuildLoop(cond, body, loop_vars, shape_invariants,\n\u001b[0;32m-> 2766\u001b[0;31m                                     return_same_structure)\n\u001b[0m\u001b[1;32m   2767\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0mmaximum_iterations\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2768\u001b[0m       \u001b[0;32mreturn\u001b[0m \u001b[0mresult\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/tensorflow/python/ops/control_flow_ops.py\u001b[0m in \u001b[0;36mBuildLoop\u001b[0;34m(self, pred, body, loop_vars, shape_invariants, return_same_structure)\u001b[0m\n\u001b[1;32m   2246\u001b[0m       \u001b[0;32mwith\u001b[0m \u001b[0mops\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_default_graph\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_mutation_lock\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m  \u001b[0;31m# pylint: disable=protected-access\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2247\u001b[0m         original_body_result, exit_vars = self._BuildLoop(\n\u001b[0;32m-> 2248\u001b[0;31m             pred, body, original_loop_vars, loop_vars, shape_invariants)\n\u001b[0m\u001b[1;32m   2249\u001b[0m     \u001b[0;32mfinally\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2250\u001b[0m       \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mExit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/tensorflow/python/ops/control_flow_ops.py\u001b[0m in \u001b[0;36m_BuildLoop\u001b[0;34m(self, pred, body, original_loop_vars, loop_vars, shape_invariants)\u001b[0m\n\u001b[1;32m   2171\u001b[0m         expand_composites=True)\n\u001b[1;32m   2172\u001b[0m     \u001b[0mpre_summaries\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mops\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_collection\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mops\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mGraphKeys\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_SUMMARY_COLLECTION\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# pylint: disable=protected-access\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2173\u001b[0;31m     \u001b[0mbody_result\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mbody\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mpacked_vars_for_body\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   2174\u001b[0m     \u001b[0mpost_summaries\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mops\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_collection\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mops\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mGraphKeys\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_SUMMARY_COLLECTION\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# pylint: disable=protected-access\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2175\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mnest\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mis_sequence_or_composite\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbody_result\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/tensorflow_probability/python/mcmc/nuts.py\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(iter_, energy_diff_sum, init_momentum_cumsum, leapfrogs_taken, state, state_c, continue_tree, not_divergence, momentum_state_memory)\u001b[0m\n\u001b[1;32m    719\u001b[0m                               \u001b[0miter_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0menergy_diff_sum\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minit_momentum_cumsum\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    720\u001b[0m                               \u001b[0mleapfrogs_taken\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstate\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstate_c\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcontinue_tree\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 721\u001b[0;31m                               not_divergence, momentum_state_memory)),\n\u001b[0m\u001b[1;32m    722\u001b[0m           loop_vars=(\n\u001b[1;32m    723\u001b[0m               \u001b[0mtf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mzeros\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdtype\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mtf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mint32\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mname\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'iter'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/tensorflow_probability/python/mcmc/nuts.py\u001b[0m in \u001b[0;36m_loop_build_sub_tree\u001b[0;34m(self, directions, integrator, current_step_meta_info, iter_, energy_diff_sum_previous, momentum_cumsum_previous, leapfrogs_taken, prev_tree_state, candidate_tree_state, continue_tree_previous, not_divergent_previous, momentum_state_memory)\u001b[0m\n\u001b[1;32m    768\u001b[0m                      \u001b[0mprev_tree_state\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstate\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    769\u001b[0m                      \u001b[0mprev_tree_state\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtarget\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 770\u001b[0;31m                      prev_tree_state.target_grad_parts)\n\u001b[0m\u001b[1;32m    771\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    772\u001b[0m       next_tree_state = TreeDoublingState(\n",
+            "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/tensorflow_probability/python/mcmc/internal/leapfrog_integrator.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, momentum_parts, state_parts, target, target_grad_parts, name)\u001b[0m\n\u001b[1;32m    289\u001b[0m               \u001b[0mstate_parts\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    290\u001b[0m               \u001b[0mtarget\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 291\u001b[0;31m               \u001b[0mtarget_grad_parts\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    292\u001b[0m           ])\n\u001b[1;32m    293\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/tensorflow/python/util/deprecation.py\u001b[0m in \u001b[0;36mnew_func\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    572\u001b[0m                   \u001b[0mfunc\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__module__\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0marg_name\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0marg_value\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'in a future version'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    573\u001b[0m                   if date is None else ('after %s' % date), instructions)\n\u001b[0;32m--> 574\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    575\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    576\u001b[0m     doc = _add_deprecated_arg_value_notice_to_docstring(\n",
+            "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/tensorflow/python/ops/control_flow_ops.py\u001b[0m in \u001b[0;36mwhile_loop_v2\u001b[0;34m(cond, body, loop_vars, shape_invariants, parallel_iterations, back_prop, swap_memory, maximum_iterations, name)\u001b[0m\n\u001b[1;32m   2489\u001b[0m       \u001b[0mname\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mname\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2490\u001b[0m       \u001b[0mmaximum_iterations\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mmaximum_iterations\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2491\u001b[0;31m       return_same_structure=True)\n\u001b[0m\u001b[1;32m   2492\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2493\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/tensorflow/python/ops/control_flow_ops.py\u001b[0m in \u001b[0;36mwhile_loop\u001b[0;34m(cond, body, loop_vars, shape_invariants, parallel_iterations, back_prop, swap_memory, name, maximum_iterations, return_same_structure)\u001b[0m\n\u001b[1;32m   2764\u001b[0m       \u001b[0mops\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0madd_to_collection\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mops\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mGraphKeys\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mWHILE_CONTEXT\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mloop_context\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2765\u001b[0m     result = loop_context.BuildLoop(cond, body, loop_vars, shape_invariants,\n\u001b[0;32m-> 2766\u001b[0;31m                                     return_same_structure)\n\u001b[0m\u001b[1;32m   2767\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0mmaximum_iterations\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2768\u001b[0m       \u001b[0;32mreturn\u001b[0m \u001b[0mresult\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/tensorflow/python/ops/control_flow_ops.py\u001b[0m in \u001b[0;36mBuildLoop\u001b[0;34m(self, pred, body, loop_vars, shape_invariants, return_same_structure)\u001b[0m\n\u001b[1;32m   2246\u001b[0m       \u001b[0;32mwith\u001b[0m \u001b[0mops\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_default_graph\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_mutation_lock\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m  \u001b[0;31m# pylint: disable=protected-access\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2247\u001b[0m         original_body_result, exit_vars = self._BuildLoop(\n\u001b[0;32m-> 2248\u001b[0;31m             pred, body, original_loop_vars, loop_vars, shape_invariants)\n\u001b[0m\u001b[1;32m   2249\u001b[0m     \u001b[0;32mfinally\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2250\u001b[0m       \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mExit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/tensorflow/python/ops/control_flow_ops.py\u001b[0m in \u001b[0;36m_BuildLoop\u001b[0;34m(self, pred, body, original_loop_vars, loop_vars, shape_invariants)\u001b[0m\n\u001b[1;32m   2171\u001b[0m         expand_composites=True)\n\u001b[1;32m   2172\u001b[0m     \u001b[0mpre_summaries\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mops\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_collection\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mops\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mGraphKeys\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_SUMMARY_COLLECTION\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# pylint: disable=protected-access\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2173\u001b[0;31m     \u001b[0mbody_result\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mbody\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mpacked_vars_for_body\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   2174\u001b[0m     \u001b[0mpost_summaries\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mops\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_collection\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mops\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mGraphKeys\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_SUMMARY_COLLECTION\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# pylint: disable=protected-access\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2175\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mnest\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mis_sequence_or_composite\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbody_result\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/tensorflow_probability/python/mcmc/internal/leapfrog_integrator.py\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(i, *args)\u001b[0m\n\u001b[1;32m    283\u001b[0m           \u001b[0mcond\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mi\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0m_\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mi\u001b[0m \u001b[0;34m<\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnum_steps\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    284\u001b[0m           body=lambda i, *args: [i + 1] + list(_one_step(  # pylint: disable=no-value-for-parameter,g-long-lambda\n\u001b[0;32m--> 285\u001b[0;31m               self.target_fn, self.step_sizes, *args)),\n\u001b[0m\u001b[1;32m    286\u001b[0m           loop_vars=[\n\u001b[1;32m    287\u001b[0m               \u001b[0mtf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mzeros_like\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnum_steps\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mname\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'iter'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/tensorflow_probability/python/mcmc/internal/leapfrog_integrator.py\u001b[0m in \u001b[0;36m_one_step\u001b[0;34m(target_fn, step_sizes, half_next_momentum_parts, state_parts, target, target_grad_parts)\u001b[0m\n\u001b[1;32m    324\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    325\u001b[0m     [next_target, next_target_grad_parts] = mcmc_util.maybe_call_fn_and_grads(\n\u001b[0;32m--> 326\u001b[0;31m         target_fn, next_state_parts)\n\u001b[0m\u001b[1;32m    327\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0many\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mg\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mNone\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mg\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mnext_target_grad_parts\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    328\u001b[0m       raise ValueError(\n",
+            "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/tensorflow_probability/python/mcmc/internal/util.py\u001b[0m in \u001b[0;36mmaybe_call_fn_and_grads\u001b[0;34m(fn, fn_arg_list, result, grads, check_non_none_grads, name)\u001b[0m\n\u001b[1;32m    262\u001b[0m     fn_arg_list = (list(fn_arg_list) if is_list_like(fn_arg_list)\n\u001b[1;32m    263\u001b[0m                    else [fn_arg_list])\n\u001b[0;32m--> 264\u001b[0;31m     \u001b[0mresult\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mgrads\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0m_value_and_gradients\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfn\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfn_arg_list\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mresult\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mgrads\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    265\u001b[0m     if not all(dtype_util.is_floating(r.dtype)\n\u001b[1;32m    266\u001b[0m                for r in (result if is_list_like(result) else [result])):  # pylint: disable=superfluous-parens\n",
+            "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/tensorflow_probability/python/mcmc/internal/util.py\u001b[0m in \u001b[0;36m_value_and_gradients\u001b[0;34m(fn, fn_arg_list, result, grads, name)\u001b[0m\n\u001b[1;32m    222\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    223\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0mresult\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 224\u001b[0;31m       \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfn\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mfn_arg_list\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    225\u001b[0m       \u001b[0;32mif\u001b[0m \u001b[0mgrads\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mNone\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0mtf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mexecuting_eagerly\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    226\u001b[0m         \u001b[0;31m# Ensure we disable bijector cacheing in eager mode.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/tensorflow_probability/python/mcmc/transformed_kernel.py\u001b[0m in \u001b[0;36mtransformed_log_prob_fn\u001b[0;34m(*state_parts)\u001b[0m\n\u001b[1;32m    100\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0menable_bijector_caching\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    101\u001b[0m       \u001b[0mstate_parts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0mtf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0midentity\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msp\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0msp\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mstate_parts\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 102\u001b[0;31m     \u001b[0mtlp\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mlog_prob_fn\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mfn\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mstate_parts\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    103\u001b[0m     \u001b[0mtlp_rank\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mprefer_static\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrank\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtlp\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    104\u001b[0m     \u001b[0mevent_ndims\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mprefer_static\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrank\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msp\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0mtlp_rank\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0msp\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mstate_parts\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-38-3a3f2bd3d322>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(*args)\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mnormal_single_regression_jd\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtfd\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mJointDistributionCoroutine\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnormal_single_regression\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mnormal_single_log_prob\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mlambda\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mnormal_single_regression_jd\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlog_prob\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0margs\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mtf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcast\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdf\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'od'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mdtype\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+            "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/tensorflow_probability/python/distributions/joint_distribution.py\u001b[0m in \u001b[0;36mlog_prob\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    443\u001b[0m         \u001b[0mmodel_flatten_fn\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_model_flatten\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    444\u001b[0m         model_unflatten_fn=self._model_unflatten)\n\u001b[0;32m--> 445\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_call_log_prob\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mvalue\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0munmatched_kwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    446\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    447\u001b[0m   \u001b[0;31m# Override the base method to capture *args and **kwargs, so we can\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/tensorflow_probability/python/distributions/distribution.py\u001b[0m in \u001b[0;36m_call_log_prob\u001b[0;34m(self, value, name, **kwargs)\u001b[0m\n\u001b[1;32m    942\u001b[0m     \u001b[0;32mwith\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_name_and_control_scope\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mname\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvalue\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    943\u001b[0m       \u001b[0;32mif\u001b[0m \u001b[0mhasattr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'_log_prob'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 944\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_log_prob\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mvalue\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    945\u001b[0m       \u001b[0;32mif\u001b[0m \u001b[0mhasattr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'_prob'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    946\u001b[0m         \u001b[0;32mreturn\u001b[0m \u001b[0mtf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmath\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlog\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_prob\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mvalue\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/tensorflow_probability/python/distributions/joint_distribution.py\u001b[0m in \u001b[0;36m_log_prob\u001b[0;34m(self, value)\u001b[0m\n\u001b[1;32m    385\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    386\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0m_log_prob\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvalue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 387\u001b[0;31m     \u001b[0mxs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_map_measure_over_dists\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'log_prob'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvalue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    388\u001b[0m     \u001b[0;32mreturn\u001b[0m \u001b[0msum\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmaybe_check_wont_broadcast\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mxs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvalidate_args\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    389\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/tensorflow_probability/python/distributions/joint_distribution.py\u001b[0m in \u001b[0;36m_map_measure_over_dists\u001b[0;34m(self, attr, value)\u001b[0m\n\u001b[1;32m    401\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0many\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mNone\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mtf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnest\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mflatten\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mvalue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    402\u001b[0m       \u001b[0;32mraise\u001b[0m \u001b[0mValueError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'No `value` part can be `None`; saw: {}.'\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mformat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mvalue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 403\u001b[0;31m     \u001b[0mds\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mxs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_call_flat_sample_distributions\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mvalue\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mvalue\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mseed\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m42\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    404\u001b[0m     \u001b[0;32mreturn\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mgetattr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0md\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mattr\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0md\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mx\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mzip\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mds\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mxs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    405\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/tensorflow_probability/python/distributions/joint_distribution.py\u001b[0m in \u001b[0;36m_call_flat_sample_distributions\u001b[0;34m(self, sample_shape, seed, value)\u001b[0m\n\u001b[1;32m    413\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0mvalue\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    414\u001b[0m       \u001b[0mvalue\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_model_flatten\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mvalue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 415\u001b[0;31m     \u001b[0mds\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mxs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_flat_sample_distributions\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msample_shape\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mseed\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvalue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    416\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    417\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0msample_shape\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0mvalue\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/tensorflow_probability/python/distributions/joint_distribution_coroutine.py\u001b[0m in \u001b[0;36m_flat_sample_distributions\u001b[0;34m(self, sample_shape, seed, value)\u001b[0m\n\u001b[1;32m    262\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    263\u001b[0m         \u001b[0mindex\u001b[0m \u001b[0;34m+=\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 264\u001b[0;31m         \u001b[0md\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mgen\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnext_value\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    265\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mStopIteration\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    266\u001b[0m       \u001b[0;32mpass\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-37-db6c8bf06e38>\u001b[0m in \u001b[0;36mnormal_single_regression\u001b[0;34m()\u001b[0m\n\u001b[1;32m      9\u001b[0m     y = yield tfd.Independent(\n\u001b[1;32m     10\u001b[0m         tfd.Normal(\n\u001b[0;32m---> 11\u001b[0;31m             \u001b[0mloc\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtfd\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mNormal\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mloc\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mmu\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mscale\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0msigma\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mprob\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcast\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdf\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'x'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mdtype\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mamplitude\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m             \u001b[0mscale\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m0.2\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m         )\n",
+            "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/tensorflow_probability/python/distributions/distribution.py\u001b[0m in \u001b[0;36mprob\u001b[0;34m(self, value, name, **kwargs)\u001b[0m\n\u001b[1;32m    985\u001b[0m         \u001b[0mvalues\u001b[0m \u001b[0mof\u001b[0m \u001b[0mtype\u001b[0m\u001b[0;31m \u001b[0m\u001b[0;31m`\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdtype\u001b[0m\u001b[0;31m`\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    986\u001b[0m     \"\"\"\n\u001b[0;32m--> 987\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_call_prob\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mvalue\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mname\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    988\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    989\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0m_call_log_cdf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvalue\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mname\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/tensorflow_probability/python/distributions/distribution.py\u001b[0m in \u001b[0;36m_call_prob\u001b[0;34m(self, value, name, **kwargs)\u001b[0m\n\u001b[1;32m    969\u001b[0m         \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_prob\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mvalue\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    970\u001b[0m       \u001b[0;32mif\u001b[0m \u001b[0mhasattr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'_log_prob'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 971\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mtf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mexp\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_log_prob\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mvalue\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    972\u001b[0m       raise NotImplementedError('prob is not implemented: {}'.format(\n\u001b[1;32m    973\u001b[0m           type(self).__name__))\n",
+            "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/tensorflow_probability/python/distributions/normal.py\u001b[0m in \u001b[0;36m_log_prob\u001b[0;34m(self, x)\u001b[0m\n\u001b[1;32m    193\u001b[0m     \u001b[0mscale\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mconvert_to_tensor\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mscale\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    194\u001b[0m     log_unnormalized = -0.5 * tf.math.squared_difference(\n\u001b[0;32m--> 195\u001b[0;31m         x / scale, self.loc / scale)\n\u001b[0m\u001b[1;32m    196\u001b[0m     log_normalization = tf.constant(\n\u001b[1;32m    197\u001b[0m         0.5 * np.log(2. * np.pi), dtype=self.dtype) + tf.math.log(scale)\n",
+            "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/tensorflow/python/ops/math_ops.py\u001b[0m in \u001b[0;36mbinary_op_wrapper\u001b[0;34m(x, y)\u001b[0m\n\u001b[1;32m    982\u001b[0m     \u001b[0;32mwith\u001b[0m \u001b[0mops\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mname_scope\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mop_name\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0mname\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    983\u001b[0m       \u001b[0;32mif\u001b[0m \u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mops\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mTensor\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mops\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mTensor\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 984\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mfunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mname\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mname\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    985\u001b[0m       \u001b[0;32melif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msparse_tensor\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mSparseTensor\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    986\u001b[0m         \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/tensorflow/python/ops/math_ops.py\u001b[0m in \u001b[0;36m_truediv_python3\u001b[0;34m(x, y, name)\u001b[0m\n\u001b[1;32m   1088\u001b[0m       \u001b[0mx\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcast\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdtype\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1089\u001b[0m       \u001b[0my\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcast\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdtype\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1090\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0mgen_math_ops\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mreal_div\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mname\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mname\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1091\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1092\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/tensorflow/python/ops/gen_math_ops.py\u001b[0m in \u001b[0;36mreal_div\u001b[0;34m(x, y, name)\u001b[0m\n\u001b[1;32m   7266\u001b[0m   \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   7267\u001b[0m     _, _, _op, _outputs = _op_def_library._apply_op_helper(\n\u001b[0;32m-> 7268\u001b[0;31m         \"RealDiv\", x=x, y=y, name=name)\n\u001b[0m\u001b[1;32m   7269\u001b[0m   \u001b[0;32mexcept\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mTypeError\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mValueError\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   7270\u001b[0m     result = _dispatch.dispatch(\n",
+            "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/tensorflow/python/framework/op_def_library.py\u001b[0m in \u001b[0;36m_apply_op_helper\u001b[0;34m(op_type_name, name, **keywords)\u001b[0m\n\u001b[1;32m    742\u001b[0m       op = g._create_op_internal(op_type_name, inputs, dtypes=None,\n\u001b[1;32m    743\u001b[0m                                  \u001b[0mname\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mscope\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minput_types\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0minput_types\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 744\u001b[0;31m                                  attrs=attr_protos, op_def=op_def)\n\u001b[0m\u001b[1;32m    745\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    746\u001b[0m     \u001b[0;31m# `outputs` is returned as a separate return value so that the output\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/tensorflow/python/framework/ops.py\u001b[0m in \u001b[0;36m_create_op_internal\u001b[0;34m(self, op_type, inputs, dtypes, input_types, name, attrs, op_def, compute_device)\u001b[0m\n\u001b[1;32m   3325\u001b[0m           \u001b[0minput_types\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0minput_types\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   3326\u001b[0m           \u001b[0moriginal_op\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_default_original_op\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 3327\u001b[0;31m           op_def=op_def)\n\u001b[0m\u001b[1;32m   3328\u001b[0m       \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_create_op_helper\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mret\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcompute_device\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mcompute_device\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   3329\u001b[0m     \u001b[0;32mreturn\u001b[0m \u001b[0mret\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/tensorflow/python/framework/ops.py\u001b[0m in \u001b[0;36m__init__\u001b[0;34m(self, node_def, g, inputs, output_types, control_inputs, input_types, original_op, op_def)\u001b[0m\n\u001b[1;32m   1815\u001b[0m         \u001b[0mop_def\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_graph\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_get_op_def\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnode_def\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mop\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1816\u001b[0m       self._c_op = _create_c_op(self._graph, node_def, inputs,\n\u001b[0;32m-> 1817\u001b[0;31m                                 control_input_ops, op_def)\n\u001b[0m\u001b[1;32m   1818\u001b[0m       \u001b[0mname\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcompat\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mas_str\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnode_def\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mname\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1819\u001b[0m     \u001b[0;31m# pylint: enable=protected-access\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/tensorflow/python/framework/ops.py\u001b[0m in \u001b[0;36m_create_c_op\u001b[0;34m(graph, node_def, inputs, control_inputs, op_def)\u001b[0m\n\u001b[1;32m   1655\u001b[0m   \u001b[0;32mexcept\u001b[0m \u001b[0merrors\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mInvalidArgumentError\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1656\u001b[0m     \u001b[0;31m# Convert to ValueError for backwards compatibility.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1657\u001b[0;31m     \u001b[0;32mraise\u001b[0m \u001b[0mValueError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mstr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0me\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1658\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1659\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mc_op\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;31mValueError\u001b[0m: Dimensions must be equal, but are 150 and 10 for '{{node mcmc_sample_chain_2/trace_scan/while/smart_for_loop/while/dual_averaging_step_size_adaptation___init___2/_one_step/transformed_kernel_one_step/NoUTurnSampler_2/.one_step/while/loop_tree_doubling/build_sub_tree/while/loop_build_sub_tree/leapfrog_integrate/while/leapfrog_integrate_one_step/maybe_call_fn_and_grads/value_and_gradients/JointDistributionCoroutine/log_prob/mcmc_sample_chain_2_trace_scan_while_smart_for_loop_while_dual_averaging_step_size_adaptation___init___2__one_step_transformed_kernel_one_step_NoUTurnSampler_2_one_step_while_loop_tree_doubling_build_sub_tree_while_loop_build_sub_tree_leapfrog_integrate_while_leapfrog_integrate_one_step_maybe_call_fn_and_grads_value_and_gradients_JointDistributionCoroutine_log_prob_Normal_3/prob/truediv}} = RealDiv[T=DT_FLOAT](mcmc_sample_chain_2/trace_scan/while/smart_for_loop/while/dual_averaging_step_size_adaptation___init___2/_one_step/transformed_kernel_one_step/NoUTurnSampler_2/.one_step/while/loop_tree_doubling/build_sub_tree/while/loop_build_sub_tree/leapfrog_integrate/while/leapfrog_integrate_one_step/maybe_call_fn_and_grads/value_and_gradients/JointDistributionCoroutine/log_prob/Cast, mcmc_sample_chain_2/trace_scan/while/smart_for_loop/while/dual_averaging_step_size_adaptation___init___2/_one_step/transformed_kernel_one_step/NoUTurnSampler_2/.one_step/while/loop_tree_doubling/build_sub_tree/while/loop_build_sub_tree/leapfrog_integrate/whil..."
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "18VfYeU78W2d",
+        "colab_type": "code",
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 883
+        },
+        "outputId": "5468d902-26ad-443f-d729-9e17664b6831"
+      },
+      "source": [
+        "\n",
+        "trace1 = az.from_tfp(res.trace, var_names=[\"amplitude\", \"mu\", \"sigma\"])\n",
+        "t = tfp_trace_to_arviz(res, var_names=[\"amplitude\", \"mu\", \"sigma\"])\n",
+        "az.plot_trace(t)\n",
+        "# az.summary(trace1)\n",
+        "# res.all_states\n",
+        "# res.trace"
+      ],
+      "execution_count": 101,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "text": [
+            "(1, 500, 1)\n"
+          ],
+          "name": "stdout"
+        },
+        {
+          "output_type": "error",
+          "ename": "IndexError",
+          "evalue": "ignored",
+          "traceback": [
+            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+            "\u001b[0;31mIndexError\u001b[0m                                Traceback (most recent call last)",
+            "\u001b[0;32m<ipython-input-101-7934768f4198>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0mtrace1\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0maz\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfrom_tfp\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mres\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvar_names\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"amplitude\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"sigma\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"mu\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0mt\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtfp_trace_to_arviz\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mres\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvar_names\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"amplitude\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"sigma\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"mu\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0maz\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mplot_trace\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mt\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      5\u001b[0m \u001b[0;31m# az.summary(trace1)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      6\u001b[0m \u001b[0;31m# res.all_states\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/arviz/plots/traceplot.py\u001b[0m in \u001b[0;36mplot_trace\u001b[0;34m(data, var_names, filter_vars, transform, coords, divergences, kind, figsize, rug, lines, compact, compact_prop, combined, chain_prop, legend, plot_kwargs, fill_kwargs, rug_kwargs, hist_kwargs, trace_kwargs, rank_kwargs, ax, backend, backend_config, backend_kwargs, show)\u001b[0m\n\u001b[1;32m    314\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    315\u001b[0m     \u001b[0mplot\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mget_plotting_function\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"plot_trace\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"traceplot\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbackend\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 316\u001b[0;31m     \u001b[0maxes\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mplot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m**\u001b[0m\u001b[0mtrace_plot_args\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    317\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    318\u001b[0m     \u001b[0;32mreturn\u001b[0m \u001b[0maxes\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/arviz/plots/backends/matplotlib/traceplot.py\u001b[0m in \u001b[0;36mplot_trace\u001b[0;34m(data, var_names, divergences, kind, figsize, rug, lines, compact_prop, combined, chain_prop, legend, plot_kwargs, fill_kwargs, rug_kwargs, hist_kwargs, trace_kwargs, rank_kwargs, plotters, divergence_data, axes, backend_kwargs, show)\u001b[0m\n\u001b[1;32m    248\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    249\u001b[0m             \u001b[0;32mfor\u001b[0m \u001b[0mchain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mchain_divs\u001b[0m \u001b[0;32min\u001b[0m \u001b[0menumerate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdivs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 250\u001b[0;31m                 \u001b[0mdiv_draws\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdata\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdraw\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvalues\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mchain_divs\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    251\u001b[0m                 \u001b[0mdiv_idxs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0marange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mchain_divs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mchain_divs\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    252\u001b[0m                 \u001b[0;32mif\u001b[0m \u001b[0mdiv_idxs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msize\u001b[0m \u001b[0;34m>\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;31mIndexError\u001b[0m: too many indices for array"
+          ]
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "image/png": "iVBORw0KGgoAAAANSUhEUgAABtAAAANwCAYAAAC25S5EAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAAWJQAAFiUBSVIk8AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOzdd5wcd33/8fd395q6LVnFtmwVWzYWpppiBwgmBBJ+JCGhBozBhIQQeiAmAQzY9AA/SmgmENNbKCFAHPgBwcQGGxsXbFmSrXI6demk0/WtM9/fH9tmZmd2Z/f2dvfuXs/HQ9o2O/Od2dnZm+9nPp+vsdYKAAAAAAAAAAAAQEGi0w0AAAAAAAAAAAAAugkBNAAAAAAAAAAAAMCDABoAAAAAAAAAAADgQQANAAAAAAAAAAAA8CCABgAAAAAAAAAAAHgQQAMAAAAAAAAAAAA8CKABAAAAAAAAAAAAHgTQAAAAAAAAAAAAAA8CaAAAAAAAAAAAAIAHATQAAAAAAAAAAADAgwAaAAAAAAAAAAAA4EEADQAAAAAAAAAAAPAggAYAAAAAAAAAAAB4EEADACxYxpibjDHWGHN54Plri89f25mWhevWdgEAAABAK3COBgDoJj2dbgAAAHOFMWajpKskjVprP9bRxgAAAADAAsc5GgBgNpGBBgBAtROSHijeem2U9E5Jb2h3gwAAAABgAeMcDQDQdmSgAQAQYK39pKRPdrodAAAAAADO0QAAnUEGGgAAAAAAAAAAAOBBAA0A0DBjzMXGmHcaY24xxhw0xmSNMSeMMf/PGPOciPfsKw0GbYzZaoz5d2PMcWPMlDHmDmPMn3umPdsYc70x5oAxJm2M2WmMeU3EfK8qzvcmY0yPMeafjDHbjTGp4vy/YYw5v8H1qxoI2hhzk6RfFB9uKL5e/lfrvSHz970n8NpyY8yHi9srY4zZb4z5lDFmVYx2n2GMeZ8x5j5jzGRx295jjHmLMWZxzNUHAAAAMMdwjsY5GgCg9SjhCABoxsckPVXSuKQjxX9nSnqapKcZYz5srb064r2PVaFGvSNplwo16x8j6XvGmBdKulvSTZJOk7Rdhd+qCyV9whizzFr7/oj5GknflfRnkgYl3S/poZL+UtIzjTFPtdbeMYN1vk/SKkkXS8pI+u0M5hWqeAL2SxXabVVYf1fSKyU9Q9KParz3ccXXV0vKStorKVls7yMkPa+4DU61ut0AAAAAOo5zNM7RAAAtRgYaAKAZ10t6lLV2hbX2Idbax1pr10u6RNKDkv7BGPN7Ee99r6QbJK211j5G0lpJn1Ph5OpDkr4q6RZJZ1prH2OtPVPStcX3vt0YsyJivpdJ+gNJz7DWbi7O+yxJN0paJumbxpiBZlfYWvtaSa8tPjxqrX2i91+z8w34hAonZnskXWytvdha+3BJF6lwwvXKsDcZY9ZI+oEKJ2YflnSGtfYia+0Fks6X9GtJjyrOHwAAAMD8wzka52gAgBYjgAYAaJi19jvW2ntCnr9L0quLD6+MePt2SW+w1qaL73EkvVlSWtI5xX8vs9aOed7zXkmHJS2S9JSI+fZKus5a+2NPe05JepEKV2FulvT8WCvYAcaYTSpciSlJf22t3V56zVr7oKSrVFjHMG9S4ST3y9baq621E5737pP0PEmTkl5ojFnf+tYDAAAA6CTO0VqPczQAAAE0AEBTjDHrjDF/b4z5ujHmZ8Va+7dIKpXveFTEW2+w1rreJ6y1oyqU9JCkb1hrpwKv5yXdW3x4XsR8c5L+Nfhk8STvK8WHz6i5Up31Rypc4bnNWntT8EVr7W2Sbo9473OLt1XrX3zvYUl3qPC7//szbikAAACArsM5WstxjgYACxxjoAEAGmaMeYGkf5O0pMZkUQMq74l4fliFMhhRrx8v3i6NeP2AtXY84rXSlYIXRrzeDR5SvN1eY5rtkh7nfcIYs0SFKzcl6f8aY/IR772geMvVjQAAAMA8wznarOAcDQAWOAJoAICGFMtYfFlSn6RPSfqSCgNNT1hrHWPMZhVOsKJKWUxFPG9jvm4iXj8e8bwkHSveLqsxTaeVTjrjrIfXaZ77j4+xnMWxWwQAAACg63GONms4RwOABY4AGgCgUS9Q4cTsO9ba14S8HnVV42xbU+O1tcXbiRrTtErNk8ji1YhhJou3cdYj7H2StMZaO1y7eQAAAADmGc7RauMcDQDQFMZAAwA0alPx9n8jXr+0XQ0JWG+Mibp68aLi7QMzXIatP0n56sywEympUqYjaGfxdmuNeVe9Vhw/4GDx4cV1WwcAAABgvuEcrTbO0QAATSGABgBo1HTx9szgC8aYAUmvbW9zyvok/U3wSWPMckkvKT788QyXkSreLqoxza7ibdRJ6qsinv+JCid/FxtjqgaRNsY8ToHa+h7fLt6+sUa7AAAAAMxPnKNxjgYAmAUE0AAAjSpd1fgqY8xjS08aY9ZI+o6kczrSKikn6VpjzNM9bTpd0lclLZc0KOlbM1zG3uLtGmPMRRHT/EKFE9hHGGOu9rQlaYx5raQXh73JWjuoyknW540xD/G8d4ukL6qwjmH+WYXa+39ijPmSMcZ34myM6TPGPN0Y8+3wtwMAAACYwzhH4xwNADALCKABABr1A0k3S1oh6TfGmAeMMXepUKLiaZJe16F23arCidFPjDF7jDG/lXRI0p+qUIP+Rdba9EwWYK09IemnxYd3GWPuMMbcZIy5yTPNuKRrig8/aIw5boy5Q4WBpz8m6dU1FvFqFcqEbJG03RhznzHm3uJzA5Kuj2jXMUnPUOEzeImkg8aYncaYW40x21UYV+Ankp7bzHoDAAAA6GqcoxVwjgYAaCkCaACAhlhrHRVOBD4s6YAK9fbPkvRDSZepcvLS9qZJeo6kt0jKSHqoClcZfkvSJdba21q0nCskfV7SsKRHSnpy8V+lIdZ+VNKVku6UtEyFk627JT3dWntD5AoUTv4ulfQRFbbtBZJOk/RZSY+VNFLjvXerUF//LZJuV6G+/2MlrSsu+92SHt3oygIAAADobpyjcY4GAJgdxto4Y20CANCdjDFXSfqCpF9aay/vbGsAAAAAYGHjHA0AMF+QgQYAAAAAAAAAAAB4EEADAAAAAAAAAAAAPAigAQAAAAAAAAAAAB4E0AAAAAAAAAAAAAAPY63tdBsAAAAAAAAAAACArkEGGgAAAAAAAAAAAOBBAA0AAAAAAAAAAADwIIAGAAAAAAAAAAAAeBBAAwAAAAAAAAAAADwIoAEAIMkY8xRjzI+MMcPGmJQxZqcx5t3GmCWdbhsAAAAALCScnwEAuoGx1na6DQAAdJQx5rWSPi7JSDooaVjSVkn9knZIeqK1dqRzLQQAAACAhYHzMwBAtyADDQCwoBljLpH0seLDv5V0rrX20ZI2S7pT0kWSPteh5gEAAADAgsH5GQCgm5CBBgBY0Iwx35f0LElftta+NPDaFkk7Vbjg5BHW2ns70EQAAAAAWBA4PwMAdBMy0AAAC5YxZqmkPy4+/Nfg69baXZL+p/jwee1qFwAAAAAsNJyfAQC6DQE0AMBC9igV6uhnJN0eMc3NxdtL29IiAAAAAFiYOD8DAHQVAmgAgIXsguLtfmttLmKaPcXbC9vQHgAAAABYqDg/AwB0FQJoAICFbGXxdqTGNKXXTp/ltgAAAADAQsb5GQCgqxBAAwAsZAPF22yNaTLF20Wz3BYAAAAAWMg4PwMAdBUCaACAhSxdvO2rMU1/8TY1y20BAAAAgIWM8zMAQFchgAYAWMhOFW9X1pim9NqpGtMAAAAAAGaG8zMAQFchgAYAWMgeLN6ea4zpjZjmvMC0AAAAAIDW4/wMANBVCKABABayu1Wor98v6XER0zypeHtrW1oEAAAAAAsT52cAgK5CAA0AsGBZayck/aT48BXB140xWyT9QfHhd9rVLgAAAABYaDg/AwB0GwJoAICF7t2SrKQrjTGvMMYYSTLGnCnpGyr8Vn7fWvu7DrYRAAAAABYCzs8AAF3DWGs73QYAADrKGPMGSR+RZCQdkHRC0lYVSoc8IOmJ1toTnWshAAAAACwMnJ8BALoFATQAACQZY54q6U2SHi9piaQhFcqCvN9aO9nJtgEAAADAQsL5GQCgGxBAAwAAAAAAAAAAADwYAw0AAAAAAAAAAADwIIAGAAAAAAAAAAAAeBBAAwAAAAAAAAAAADwIoAEAAAAAAAAAAAAeBNAAAAAAAAAAAAAADwJoAAAAAAAAAAAAgEdPpxswFxhjBiUtl7Svw00BAAAA0BobJY1bazd1uiFoHOdoAAAAwLyyUV14fkYALZ7lixYtWnnRRRet7HRDAAAAAMzcjh07lEqlOt0MNI9zNAAAAGCe6NbzMwJo8ey76KKLVt55552dbgcAAACAFrjkkkt011137et0O9A0ztEAAACAeaJbz88YAw0AAAAAAAAAAADwIIAGAAAAAAAAAAAAeBBAAwAAAAAAAAAAADwIoAEAAAAAAAAAAAAeBNAAAAAAAAAAAAAADwJoAIA5x1ora22nmwEAAAAAAABgnurpdAMAAAgzlXa053BKg0dT2nc0rYPDGY1N5zUx7WhiOi/HlZIJqSdp1JtMaNnipFYs6dFpS3u0+rRenbN6QOes6dc5qwe0clmPjDGdXiUAAAAAANCAdNbV3bsntG5lnzatW9Tp5gBYYAigAQC6guNY3bdvUvfsLvzbdWhabp0kM8eVHNcqk3M0mXZ0ZCQbOt3i/oTOWT2g9av7tenMAW05e7HOP3uRFvcnZ2FNAAAAAABAK+w9klIm62roaJoAGoC2I4AGAOiog8MZ/fTOEf3srhGNTOR9ry0dSGrjmQPatHZA564d0OnLerV8cVLLFiXVk0zIca3yjlU272p8ytHYVF6jU3kdHcnowHBGB4czGp3Mazrj6oGD03rg4LR0d2Hexkjrz+jXlrMX64L1i7Rl/WJtPnNAA30E1QAAAAAA6AZOvStrAWAWEUADAHTEtn2T+urPjul3eybLz/X3JvTI85fqkecV/m1YOzDj0osT03kdGM7owHBa+49ntOdwSrsOTms64xafz+h/7jklqRBUW3d6nzauG9CmdYuKtwM6c1W/kglKQAIAAKC1HNfydyYA1MDw5wA6iQAaAKCtHjgwra/89Kju3DVRfm7rhsV6+mNW6kkPO63lZRWXLe7R1g092rphSfk517U6MpLVroPTevDgtHYdSmn34ZTSWVdHRrI6MpLVrdvHy9P39RitX92v9asHtP6Mfp19Rr/OWNGrVcsL/wb6Ei1tMwAAAOa/E2M5bRuc1OazFuncNQOdbg4AdCWXCBqADiKABgBoi9HJnD5/4xH9/O5T5eee9LAVetEfrNXGNtcxTySMzi4Gwi5/5OmSCkG1oyNZDR5Nad/RtAaPprXvaEqHR7LK5q32Hklr75F06PyWDiS1akWvVi3v0elLCwG1Rf0JDfQm1O+5P9CX0EBfsnib0KLibX/xlquPAQAAFo5t+wqVGPYeThFAA4AIxM8AdBIBNADArHJdqx/fMaIv/PiIJtOOJOnxFy3XlX+4Tued1T0DACcSRmed0a+zzujXEy6uPJ/OOho6ltHB4bQOniiMq3Z0JKuT4zmNTuVlrTSZdjSZdjR0bGZt6OsxxeBbUquW92jt6X1ae3qfzlzZr3PX9OucNQNaMsAYbQAAAPMCncIAUBcBNACdRAANADBrjoxk9OF/36/tQ9OSpDNX9unVz1qvSy5Y1uGWxTfQl9SF5yzWhecsrnot71iNTOR0ciynE+M5nRjLaWwqr3TWVSbnKp11lcoWbqv/Ocrk/GcC2bxVNu9ofNrRsVPZ8nbzOmNFry5cv1gXbVisrRuW6PyzFqm3hxKSAAAAAID5xxJBA9BBBNAAAC1nrdXP7jqlz/zwkFIZVz1JoxdcvkbPf/Ia9fXOn2BPT9JozWl9WnNaX1Pvd1xbDrR5/02nHQ2P5XTsVFbHTmV16ERGB4YzSmddnRjL6cTYmH51/5gkaVFfQpdcsEyXbV2hx164TMsW89MOAAAAAJgfXOJnADqIXjYAQEtNphx94j8O6H/vKwR4Nq0b0JtfcG7bxzmbC5IJo8X9SS3ur1+W0XWthsdyGjyS0s4D09o+NKUHD04rlXV1y7Yx3bJtTImE9PiHLNfTH7NSj71guZJJxlQDAAAAAMxdJKAB6CQCaACAltl9aFrv/fqQjo5kJUnPfuJqvfSP1qmPEoMzlkiY8phol25dIUnK5V3dNzil27aP6bYd4xoey+nW7eO6dfu4Vi7r0f95/Cr9+RNWM24aAAAAAGBOIoAGoJMIoAEAZsxaq/++fUTX/+iQcnmr05b26Ornn6tHb5k7Y53NRb09CT16yzI9essy/d2fWe3YP62f/HZEv/zdqEYm8vrqz47pB78+oedfvkZ/cukZ6p9H5TMBAAAAAPMfY6AB6CQCaACAGcnkXH3iPw7q53efkiRdvHGJ/umFG7RqeW+HW7awGGO0dcMSbd2wRK945ln6xd2n9M2bjuvkeE6fv/GI/uOWE7rqj9bpDx55uhIJSjsCAAAAALofY6AB6CQCaACApg2PZfXur+zTrkMpSdLznrxaL33amYy91WFLBpL6k8vO0NMes1I/uu2E/r0YSPu/3z6g/7rtpF75p2frwnMWd7qZAAAAAADURPwMQCdRywkA0JT7903p9Z/cpV2HUhroS+iaKzbor/74LIJnXaS/N6HnPGmNbrj6Ij3391erJ2m088C03vDpXfr49w5oMuV0uokAAAAAAESihCOATiKABgBo2E/vHNE/fX6PTk3mtW5lnz76d+frCRef1ulmIcKSgaRe/oyz9JnXX6jHXVgYl+7Hd4zolR/bqd/sGO9w6wAAAAAACEf8DEAnEUADAMRmrdVXfnpUH/nOAeUdq0eet1T/8uot2rhuUaebhhjWr+7XdVdt1juv3KhVy3t0cjyva788qA9+a0gTqXynmwcAAAAAgI9LBA1ABzEGGgAglmze1b9876B+fvcpSdIfP3alXv2s9eqhZOOcc+nWFbp401J9/sbD+slvR/SLe0a1fWhab33RBl2wnrHRAAAAAADdgfgZgE4iAw0AUNdEKq9rbthbDp697I/P1Ov+guDZXLZ0UVJveM45es/LNun0pT06diqrN12/Wz+89QQ15gEAAAAA3YHTUzRpeCyr27aPaXQy1+mmYA4jgAYAqOnISEZv/Mxu3Tc4pd4eo3964bl6/pPXyBiCZ/PBJRcs1ydfe4EevnmJ8o7Vp39wSB/45n6ls26nmwYAAADMayfGcrp957jGpyinDgCtdmIsp3TW1cgEx1g0jwAaACDSzv1T+vtP79bB4YyWL07q/S8/T09++OmdbhZabOXyXr3vr87TC5+yRsZI/3vvqK7+7G4Nj2Y73TQAAABg3hoezWo67ejkONkRANByxexFxtHDTBBAAwCEumXbqP7xc3s0NpXX2av69NG/26KHblzS6WZhliSTRi95+pl6x5Ubtagvod2HU3r9p3Zpx9BUp5sGAAAAzEtusU93LnbtTqUd3bt3UmNkzwHoUrbqDtA4AmgAAB9rrb5783G97+tDyuatHrpxiT7yd1t01hn9nW4a2uDSi1boo6/aonUr+3RqMq83f26PfnnvqU43CwAAAJh3SmMPz8XsiOOjWY2M53TkZKbTTcECwnjdaISdwxcpoHsQQAMAlDmO1af+85A+f+MRWStd/ojT9L6/2qzlS3o63TS00Ya1A/r4q7aUx0X752/u1/d/NdzpZgEAAADzylzOjnCLQyYTzwDQrWzx4MpxCjNBAA0AIEmazji67iuD+q/fnJQk/eVT1ujq55+rvl5+Khai5Ut69J6XbdbljzhN1kqf/dFh/dt/H5br8pcnAAAA0ArlIFRnm9GUUsc0pweYTcGMs24PhOQdq12HpjU6ybiG3aCcgdYl+0027+rwyYxyebfTTUED6BUFAOjEWE5Xf3a37nhgQsmE9IbnrNdLn36mEgnT6aahg3p7Err6+efq2U9cLUn6zv8O6yPfOSDH6ZK/PgEAAIA5bE5nR5RLo83FxmOuCAZou31v23skpUPDGd2ze7LTTYG679h6cDijBw9M6/DJbKebggZQkwsAFri9R1J6xxcHdXI8p8X9CV3z4o161PnLOt0sdIlEwuhvnnmWVi7v0edvPKKf331KmZyrN7/gXPX2cB0OAAAA0Kxuy45oxFwuP4m5o6oCSpfvb1Npp9NNQIhuGTsvkytknmXJQJtTCKABwAJ2+85xfeCbQ0plXK1e0at3XbVJG9ct6nSz0IWe86Q1WrooqY9/76Bu2TambG6f3nbFRkp8AgAAAE2qjCPWHZ27jSgH/zrbDMxzwa9Gt+9vhiI+XaXbjlOlY75L/GxOodcLABYga62+87/Hde2XB5XKuNpy9iJ97FVbCJ6hpj96zCq9+QXnKpGQbn9gQu/40qDSWa6wAwAAaNRcDJig9Ur7wVzcG+Zy9hzmjqoEtC7f4YyIoHUTq+6KoLldvv8iHAE0AFhgsnlXH/3uAf3bfx+RtdITL16hD77iPK1c3tvppmEOuPwRp+uaKzaqJ2n0uz2Tuu7L+8plCAAAABCPr1OY/tYFq7wfzOE+VfqDMZvmWsCBDLTu0m0ZaE7xoD/X9uuFjgAaACwgo5M5veXze/TTO09Jkq546lq95YUbNNCX7HDLMJdctnWF3nFlIYh2z55Jveer+6jhDQAA0ABv3xkdrgtXt3XuNqKSPTcXW4+5IljqLpu3OnQiw/knYum2TNlK2d7OtgONIYAGAAvE4JGUXv+pXdo+NK2+HqO3vHCDXvyH65RIcMaOxj32wuV624s2KJmQfvvghN7/9SHlOIkBAACIxXv1OSW/Fq5yEGoOdqaWk+fmYNsxdwRLNu7cP6VdB6e1bXCqQy2qjQsiukvlIoXuOFC5ZKDNSQTQAGABuHX7mN54/W4dH81p1fIefehvz9fvP/y0TjcLc9ylW1foH/9ygxIJ6bYd4/rnb+2X4/CHIAAAQD1koEGqlHCcSeeu49rOXMjGn/1oAyewa09MF8bgHp/Kd6A19XE47zbdlebrdllGHOIhgAYA85jjWH3xJ0f0rq/sUzrr6oL1i/TxV1+gC9Yv7nTTME886WGn6R+ed64SRvrVtjF9+Nv7y3W9AQAAEM6bVUEAbeFqRQbanQ9O6Dc7x9t+IRsZaGiHYAYa0IhuK5Nb6itht55bejrdAADA7Dg5ntMHvjlULm1w+SNO0xuec476e7l2Aq31lEeerrxj9dHvHtBNvxtVb4/RG559DuVBAQAAInivN+IvpoVrpkEo17WaThcyctI5V0uS7RvbujK2ED3B7ZbOOurtSSg5j8+3XNcqkTCac9dmzt+PZE7qtkC/SwBtTiKABgDz0F27JvTBb+3X2FRePUmjv/2Ts/TMx6+S4fJWzJKnXbJSecfqX/7joH565yn1JI1e++fr2ecAAABCeDvP6EdbuNwZVl707kftz0CjI7gTptKO7tg5rpXLe/XwzUs73ZxZMTKe0337JnXemYvV3ze3zifn8piWjmOVTM7d9oexXVYysRQQZgy0uYUAGgDMI45r9fWfH9M3fnFM1krrVvbpbS/aoPPPpmQjZt8zHrdKecfq0z84pP++fUSL+pP662ecSRANAAAggM4zSDMPQnn3o7aXUe+y0mitls25kpH6erqrgstUMeNwOuN0uCWzZ2w6L+tKY1N5ndHT63stmTRdPe72XD31PTic1u7DKT1s01KtWt5b/w1zzEzGmWwlSjjOTQTQAGCeGJnI6YPf2q/f7ZmUJD3hoSv09889R0sG2lfGA/jTy85QJufq3/77iL5387CWLUrqL5+yttPNAgAA6CrWk3lER9rCVdoPmu3c9WWgzTCbreFlh7RhvnBcq9sfGFfCGF22dXlXXRBY6oCfafZiVysHZ23VxQbJRCWAVirz2E26qzXxjU05kpUmpvPzKoDmtmCcyVZxXVvZt7uhQYiNABoAzAO/2zOpf/7WkE5NFEo2/vUzztSf/d4ZXfWHPhaO5/7+Gk2mHH3rpuP60v87qqWLkvqTS8/odLMAAECX2n14WsdO5fSYC5bN6fF6846V49pY6zDnxvVBy7menaD5DLTK/XZnoM3n/t+8Y5XPW0lWeceqt6d7zqudYuLZfO6AL+/K1n+xgST1JI2yucL9nGPV32UBNG8ErRsDfFHK2bAdbkfLddEKeQ/R/A0wtxBAA4A5zHWtvnXTcX31Z0flWmnNab1664s26sJzKNmIznrp09dpIuXoxt+c1Kd/cEhLB5K6/JGnd7pZAACgC50cyyuXczU+nddkqnAV/KYzF3W6WQ27e/eEpjOOLtu6om7ZN2/n9zzuB0cNvnHwmtwHbCdLOBbNx3Kkvu9nB9sRppyB1m0Na6HS9req3r+81wjn8lb9XZYs5Q2Xzamvhg3cRsjmXeUdq8X9c6PSUTdlyrbiogl0BgE0AJijRifz+tC/D+muXYWSjY+/aLne9NxztGwxh3Z0njFGr/qzszWVcvTLe0f14W/v1+KBpB73kOWdbhoAAOgypSvf0xlXQ0fTkqQzV/VroG9uZaNNZxxZV8pk3RgBNM/9ruuiRzu4LQii+jIa2l3CMWaHe2uXadtSZaUVwc2SVo+l5pYDaPP3uFHar62tDhR6VzuXdyV1VyDHu3+61io5R4o6ljZrvcDsPbsnNZ1x9HtbV6hvDmSMW+u/7SSHANqc1f17OgCgyrZ9k3rNJx7UXbsmlUhIf/1/ztQ7r9xI8AxdJZkw+ofnn6vHXrhMjiu992v7tG1wstPNAgAAXabUkZR3Kj1Kc7FzuNTkOJkhbgs76DE32RqP4nJjZKBZazWVdpqafy3tLvm2+/C0fnX/mKYzrV+XIO86zeT76bpWdzwwrjsemPBln8xEvjgf687fMo7e1QpuN+9r3t+MbtTdrfMrB5rqtDqVLWSJZ/JzYxC+Wrmkh05k9KttoxqfyrelLf7f/bm0d4AAGgDMIa5r9e+/PK5//NwenRzP6YwVvfrQK87Xc560hvHO0JV6kkZvfdFGPXTjEmXzVu/80qB2H57udLMAAOgIa63u3j2hbfu4oMSr1I/keFD57zQAACAASURBVDqU5uRftuUr3et3jNF5Nv80+pm2pISjpw87KkCz61BKd+wc1+GTmeYWErXsNmd2HDyeUT5vta+YpTqbbIs6unOOVS5vlcu5LSux6fguNGjJLLtOuYSjrd6/vJ9HLl97A0ylHd29e0Inx3Mtb2MUb7fMbH83ZuV3pM4sO5F5OiOefSlo18Fp5fJWDxxsT/+E9xg9X7+78xUBNACYI8an8rruy4P6wo+PyHWlx1ywTJ987QXaumFJp5sG1DTQl9C1L9mkzWcOaDrj6pobBnVwePZPfAEA6DbprKuxybxOjOY6Nl5RNyp1AnpL0M21a8Ma7RjzTcOuMOedmsjp5vvGdOhE/CBVK8bZ8u5HUceUw8U2PXhgdjqJ2x0MbsexwZcBNYPVa2UpyBLHc5ycr3F4bzaUE1hJ7+eRq5OBdmIsp7HJvI6MtDZ4XIs/gDZ7H5C1VnftmtDtO8dbkt1Y2eb1JvRP3wnHTmV1xwPjsTJr48T72vXnhv+7O0+/vPMUATQAmAN27J/Saz7xoG5/YEIJI131R+t03Us3acUSSjZibli6KKn3vGyzzl7Vp7GpvN76b3s1PJrtdLMAAGgryvaFK22KuTw+iLe5ccaiCnae0Zk2t907OCnXtdrVQCZDK44H3v3G6dAYaO3ecxPtGAOtRWvViiBpkPc42aqykN2mHPSol4FWZ6e3NbKP2mE2P568YzUx7Wg67Wh0cuYlCMslWWu0eTb252YcO5XVVMrRSIzMwjiZsr0tGp+wHrdLth8aRwANALqYtVbfu3lYV392t4bHclq5rEcf+Jvz9ILL1yqRmGOX5WLBO31Zr9778vO0anmvhsdyeusNe1vyxz4AAHMRAZOK8thh3quzO9OUpjVa8m2e9nsvWLaJ4FVLSjjGyECbLZ0KTiTa0ZPpy0BrfgVn46IJZwGUgfNu8+AFCb4MtDolHNtdZjRq+bM971aMcRhnW3XLRUCl/SNOE6La6S2F2tvTnr61uXyR0EJHAA0AutRU2tF7vjakz914WI4rPer8pfrU6y7QwzYt7XTTgKatPb1P73v5Zi1fktTB4Yze/oW9szKoOQAA3ch39TGdJ2XlANoc3j7eoFmcTu3qrIoWNwhdz5+N0NwO4C1vFxVA6/F0DrcyY6lT+2yyDReS+gIFLcrsa9VFE/5ysfPzwOEN5gT3We8q1w2ghbxnts1G2c4w3s3SyvPpmvupjXzge/90ZnbP7xsJjEZl1mXylS92T7I9ATRvMHi+fnfnKwJoANCFBo+k9LpPPqhf3z8mY6QXP3Wt3v2yzTptaW+nmwbM2LlrBvSel23Wov6Edh9O6dovDyqTa3PNGQAAOmAuZ1jNplJHUr7OeDbdzNvyOB3lVSUcW9wedI/JlKNtg5OaSPkrL/gCM7OYgdbfW+n6S2Vb9zd3aWmt7AgeGc/p/n1TygbODbzr1u4x0KLWbmQ8pwcOTNc8bs1GybaZjoE2Mp7T3iMp7T+e7tpjbiVAYqsuSPBu03rtD7s4o51mewy0kqn0zL/XcUqyxrnIZd+xtG7fMa5jp2ZvuAbv/hF72sCaeY8x7do9fNuP7o85hQAaAHSZn981or//zC4dPpnV8iWFcaOu+MN1bbnSDmiXLWcv1rUv2aTeHqNtg1N639eHuvYEDgCAVmm0zN+CUS7hOJcz0Cr34yT5VE0zx9YX8d29e0InxnLaMeQfH82X5dTkvH0BtBhJH63MDJmN8nj37p3U8GhWuw6lfM97A2jtGAPN+4lEHavv3TupIycz2nskFfp6YDYt207ec6ZGMwod1+q+fZPafyytvYdTsYIcjmt1cjzX1hKh3n2ravs3lIHW/jKjjf4WNCuYgTbTvynKb4+ZgBY1WSrjlts0W0r7faw1jlivTK7+d7zVguVI+Ttw7iCABgBdIpt39YnvH9SHv31AmZzVhecs1idfc4EevWVZp5sGzIqHb16qt75wgxIJ6fad4/rId/bP24GwAQCQGi/ztxBYXzaB5/kujiiF/b3SaNmuGn3CmEesteWxdqYDHcq2RjbHZMqJ1QHtzWiICnB45z3dgkyV6gW0fpbprH/dvR3PyTb0ZDYSBKkVlOy2MdBc1/oyX+JcwHjgeFr37Z3UweFMYwubAe8YV7XWMefU2Z8byFQqOXQio8GjNYKiDWjXGGiuazWdmel3u35Qyrc+EROWPrvZDLi65c+19nS+Y2zgtY5koAW2CX8Hzh0E0ACgCxw7ldXVn92tG39zUpL0p5et0odecZ5Wn9bX4ZYBs+vSrSv0xuecI0n6xT2juv5Hh7gSCwDmAWPMKmPMXxtj/sMYs9sYkzLGjBljbjHGvNwYsyDPRds1Nspc4u1AclqRkjPLtg9N6dbtY1Ul5vzBkPqNZ/yT1uj2vxu9pdUG+vyHvaiMVMe1unv3hO7aNVH34jIbY0wd7/OpWchAK9xv9efgzzLzd8bPfgZanEBB6LRVr3k78FuzjXwBtAZ74KsSX2N8bqVMnWy+/TXnChlo0a/XCwDGDbRUlme169C0ho6mq4K4cTX6W9Cs4Gc/mZrZdztORmmc0qalF5xZrC4TN/u11t9c3jHQnDb9jgSDil3+8wWPnk43AAAWurt3T+j9Xx/SRMpRf29Cr3/2ej3lkad3ullA2zz10Ss1mXJ0/Y8O64e3ntTSRT16ydPWdbpZAICZeZ6kz0g6IukXkvZLWivp2ZI+L+kZxpjn2W7v/W6x2chGmOuixnDqxu1jrdXxYsmz46NZrV89UHnNM129pIjCvKrn3Y7AQCuks67GpvJac1qvTFvK6YVzXavfPjih3h6jR53f/qodrmuVqFNm/9RErnw/2HkaFS/OO5Wstbxr1VdjGf4AdPg03n2ttWOg+b+vrdwVEoFLLNodcPYurV6MKm7AoRXxM8e1MyoL2Uzma+lnupFlnZrIKZEwWrGkuW5n/3ihtTZwoX1Rx6HKGGgxl2tV3ij5JuNRvo98Fnfb4DqlZ/jdtuXb6EbXypoNtivO72BJ3rFKGNU9ngbbUS8oXevrl83VX5dWCx/Pb2787i90BNAAoEOstfrRbSd1/Y8OyXWl9av7dc0VG7Vh7UD9NwPzzLOesFqTKUdf/fkxfeN/jmnZoqT+4omrO90sAEDzHpT0Z5L+y9pKjoQx5q2Sbpf0HBWCad/tTPM6YzayEea6YOZN+flONKYO75gpvT3xsomiBAMC3bi+UXYdmtbJsZwSiSVavaJzFTPSObdcFtFxbdNjRtfqgI9y+ERGuw5P62Ebl2rl8t7I6U5N5sv3c3nrC7pFdUbH6aQOmzYqG8n7tLfTeMbamDDqH99t9r8tjXyf4wbQGi3XNjqZV3+v0aL+ZPm5YBC20cyZqsljvL3Rse6yeVe/2zupZMLoCQ9dETso4l9mJWhXb7mulZJ1FhG37d7vUNMlCGfwmTe0mOBvSIvGQKu5P3vuO67V7TvHtWxRUhdtWFI1bdztl3esbt0+psX9CV1ywfJY74lfwjHqgZTpghKOc+qHf4FbkGUzAKDT8o7VJ//zkD79g0Lw7HEPWa6PvWoLwTMsaC966lo96/fOkCT9638d1k/vHOlwiwAAzbLW/o+19ofe4Fnx+aOSri8+vLztDeswX8ZJ+6thdaWoDI1uzEDzlvQKBmtmOgZaJzrSXNdqdDLfcMdrqXxlrpXBmCa0oiTqyERON983pkMnGhvfaXQqL+tKY1P5mtONT/tfz+brB4m9x4l6Jfp8GWiODf0sZytwP5uZNolAQNO7HdpxbIgaO2lkPKdfbRvV8Fg2dNqgZrOOUxlH9+ye0H2DU/75zbgEXOOB+0aDQNlcIUvOcWzTQahygES2sSBJ1WvxMpXC5tWKMbxm80KZ6izm2Zlv1GvDY1lNpx0dO5X1TdPoGGiprCPHsZpooARl3KzI2mOgeS4+aFsJR//jZnexXYemdc+e+iV+0ToE0ACgzSZTjq65YW95vLPnPXm13nHlRi0ZSNZ5JzC/GWP0imeepac+qlDC9GPfPaBbto12uFUAgFlQqmlWu+d5HvJli9DvIalWB273baDpjOeK9aqO6MY+W7cLAqhDx9K6Z/eEDp/M1p/Yo7R+nd6HvZ2HzXYkjk3m5bpWpyZz9Sf2Lrv4Xa632ODnHJX1EHW/7vwDHb9h+5WvHF4rE9AazLpsRDAhsF1jFJVEBQdHJnLK5a1GxvOh01bPxxv4i78OUeOOVXXANzoGWhNBl0aDQHlPI2d8jIiVgVbjV6TB7Dl/8Dree6qWGbL8Rk2mHA0dS9ccR6zVyUxNXfhRfr46wB133yxv5wZWIHYGmvd+YFrvd6uVv8eZnKvxiAsrqgPgzX1qh4YzGp3Ia3issd8tNI8SjgDQRsNjWb3jC4PadyytnqTRG569Xk999MpONwvoGomE0d8/5xxNpR3dtmNcH/jGkN52hdFlW1d0umkAgBYwxvRIeknx4Y9jTH9nxEsPaVmj2sjfd9J9AaJOiO6Qa2874vCNMRPsvPQFKeo3vqr81kwa1qRSQDCVbWywn0qndGtbPZHKa+hYWpvWLYp1caE3mDDTamuNdqB6t0GtjuJy574pLCybc6tfUzDQEvL+Ou0ocVyrZKCenXcerQx62oj7rRAMoLkt+KwbEfUZuCH7ftyMnUaaHZVhkw8EVBreb6sexzlW+dtUT87TxuYz0EqZY5X/o8QpORi3GVElhRvRiszY3z4wLqmQ6bx+dX/EcgL7wkxLOCp8nwubRpKMZ+yusDKaccdAC5ahjVPyM/Y+GfFZOJ5xJmPNJ8REKq9790wqV8wq7u0xevjmpXrgwLQmU44ed9FyLe73/44FLwSY6bEsl++CK3EWCDLQAKBN9h1N6Y2f2a19x9JaOpDU+1++meAZECKZNHrLCzfoki3L5LjS+74+pN/sGO90swAArfEBSRdLutFa+5NON6bdZjIeTpjDJzP6zY5xTaUbC4B0k6iOqy6Mn2k6U9nO1R3RFXE+29kqv9WIUgdxo8uOm33VqCMnszoxmtORkXjlFH0BqCY3YCn41Wjnc7kDV4GOduOdxpZ3jIG+Qvebdxw9X9A1IgBbr9RrsN3BTn9vG3wNb4Vmo0MxBLvQa2XizLawgEjczRhVorbu+8Ler+rPt9HvYDvGQMu3IIDmXWbdDLQay2g0+Ocridps233ZyI3Pw5ulms5F/7ZXZaC16CtSK6jqPR55g9zebVUK6sbdfr4yp7HeEQywRvN//aL3y2Y+6lMT+XLwTCqMcTkykS9/fpls9cE7GPCO+5lNppzy3x/efTnXwePiQkMADQDaYNu+SV392T06MZbT6hW9+vArz9fFm5Z2ullA1+rrTejtV27Uo85fqrxj9Z6v7StfiQcAmJuMMa+T9CZJOyVdGec91tpLwv4V5zHn2BZ3OD94YFqpjKMdQ1P1J+5SkR1XXdgvlM6El98rPI6XkVJSvd7tX+FSJ2KjWSyl6VudgeY22J5WZCWVy1E2mYHmuv5MC+/YeN429fcWut98ZcMi2uwrI1cvwSLwer1O9W7OQPPuTyY4BlqbI8xuxPe51Eb/Z1QrgOMNpjTQgHKANkaAdAbivNsbLI7DG+xsugyiZ5n1lltru8bJqvLPq7m2u67V7TvHdd/gZGTWU1wnxytl+QZ6o7vtg/vdTL8icQKl3pe831D/ewoPYgfQGiwx670ooP4YaBH3a7QhrtL8Vi7v1crlveW21SpxXPWZxfhW5R2rO3eN6+5dE7LWPyZgJy8sWGgIoAHALLtr14SuuWGvJtOONq4b0Ef+bos2rB3odLOArtffm9A7rtykR5xXCKK966v7dNeuiU43CwDQBGPMayR9XNJ2SU+x1o50uEkd0UjHeCOyxaugMzlXg0dT/lKDLTaVdrR9aErbBic1PNrY2FmN6PT4WmFSWW8ALbrzMk5nf633t0vz2VeNdUrHnm/xNvbYOb7gxMwyXRodS6qcAWFtZEext0mVDLRa+1D1dq23XsGO32CH6mxlqQTn1Yr5+hL5apSDm2m2YRyRHe9hga0as/Vn18RfftQYT8HPu9HjZDNBF7fB73srSjiWP+NAwCB82lovxpjGO7ln+zbS9lTW1XTa0cnAmFQzDaDVDGY1mc0UOb84AbSIF30ZaLb6udrLbew47oZ8H+PMu1Zgs5ljSqmtPUmj3mL9Su9cwo43VRloMf5Uy+ZdWbeQ4eZaf9vJQGsfAmgAMItu2z6md35pUJmc1UXnLtaHXnG+zljR2+lmAXPGQF9C175kox62aYlyeavrvjyou3cTRAOAucQY8wZJn5C0TYXg2dEON6ljwjIZWqHUUXXoREZDR9M6eCLdsnkHHRzO6PiprE6M5bTrUGrG84vqMGuks7kdsjnXn1kR7IDz3o9zFX2dx+3glDPJGntfuYO0xRG0RkvFeTso43REhi+zFERs9H2VW187IoJfpQBaNhe9DzU6vlZwWimsNFnjGQ/NaMXxzLsdgyUcfdu4iXkfH83q5m2jOnYqZtA/4lgdFtiqGb/xHRjiLbowaTlS51MdIG10xw08nIXdoRUlHF3P6jf6HfC9Vp5f3KC8937996Szjsam8pHlmRv9Xjiu1amJfOi8gqqD4/WC7bZmxlLpldoBtOrpq54vfXZuvKC12+B3xN+G2m+IerV6/Lj6y42auTGVgL+1tUscN1M60rdvuf41JgOtfQigAcAsuel3p/Tur+1T3rF6xHlL9d6/2qyli+oPhg3Ab6AvqeteukkXb1yibDGIdu/eyU43CwAQgzHmHyV9VNI9KgTPjne4SR3lKws2C/MtjcfhzOKQaN7O0XwrOm8ie7hmPutWSgWz+mp0RMe6in72kgRjq5RwbGxjNxroanS+cQNz/hKOM+uob3wbFKa38n8PvN2bjWaghWXL1GtX8GWnTlZKs4HGMHGDSM3MrzoDbWYLG53My7qF21ht8dwPyyKLCphUzSfmdLUa4N1Pqjrgmyw92ohyydaYGz7vGRdqpse5QrW+2ssN7vPB9xfuxFueW2Nbh7lte6G03kSqsl9FZS86jq07Xmkm5wYC8jUCXg1mE96zZ1K37hiL/t2OsbH83wvv5xz+njjb0J9JXHvaQonE8GNs+PTV75dCLmCJ+cWw1urgcFoj47lyWxPGlEvOup6MybDfpOox0OovN7g/eeeb78ZU/XmKABoAzIKb7xvVh761X64rPe7CZbrupZu0qJ/gGdCsRf1JXXfVJm3dsFiZnNU7vkgQDQC6nTHm7ZI+IOlOSU+11p7ocJM6rtUlz8rzCoxJ1WgwoKFlxeg0a0TULLqtWyh4pXd1B1z4/SitHr+mGeUAWoPLbnSssrgaLQ3ZipKopc+h0Viwt5PUV14wYjyfgZAx0CLiZw2tV3A/ijNGVquyX6OChc3yrktwDLRaQZJY826wXGnUNgrtHG8gyBFXVJm6ehmGQXnH6jc7xrVjf2GczGYCB5VyinUnLSzT08bmM9DiB0xrB5k884zRFn/Aq+7kZd7AbFRA6P6hKd2xc1wjE/4yj1HLD3vsVSsLOsz4dF75vFUqW3vFgss8OpIpl2uODA76Sjh6P/86jVLwmBm9FqOTed2ybUyHTmQi21p3WdZ/WxJ3Nz10IqPdh1K6d+9kua3BDLTSBxH2+9jM7773OOt65i/5g9WYXQTQAKDFbt0+pn/+5pBcK122dbmuefHG8qDRAJq3uD+pd121WQ85Z7EyOVfv+OJexkQDgC5ljHmppHdJciTdLOl1xphrA/+u6mgjO6AVYzbVUuncbfmsy6ozXma2sKjN0ImAUi31ymX5A4vtaNHMlT67Rra1v7xgdNbBkZGML9sq1ryLt3G3n3ffa3p/KXd2NjYDbym/qKCV9zveVzwf9HZ4RgUz/IGp2u0KvhynRFirjg+t/o7W6mz3fdZNzLuSaRhv+qiMUhsyn1rtiVMScHQyp12HpiMzg7zPBjNO6q3PZMpRKuNoeLQQtIkK2tZiA7f1eNej2YssrKe8bL051Cw52GCQt5HfaO930/ieD59mpDi22QMHpmMtv/A43vLD3lv9huJ0EftM2OecyjjauX9a9++bkuNGZ3/FDfiGiZuZf9/gpBzHauhopUR1wxloEc/H/Xts0LPsSgZaJYDm1gkGBr8PsUo4BubpfQ8ZaO3T0+kGAMB88tsHxvW+rw/JcaXHXrhM//TCDertIXgGtMqSgaTe81eb9Y4v7tX2oWm980uDetsVG3TpRSs63TQAgN+m4m1S0hsipvmlpC+2pTVdYrYy0ErCxlBqtWCHmONaJRPBEYvia7StY1N5DY9ltXHtIvUkm19uo+qVy/I+jFfCsfEr0VvJdW25Y66RYK4bkWHlNXgkpYPDGQ30JXTp1vh/o9UqfRU+/cw76svjuc2gjGVY0CppPNvHyPcdKX1nqvaBwLyl+gGSqo7gGPtVy/a1GMGhhmZXYxZR48zFVXp/7FJtEQ/K4xs10Z7I78vRtMYm81q2KKl1K/ur2lkrK6ruuFee9lpvekx5BvHbHXc9c54gcTOZg751l5Vrax/na5V8DQZCk1Wj60VPX++Y4A0UejMm641hmMm6stZWZVkW3hBsT7x1C3uvl3d/jTpWhn3O/pKzivzOR13MEOu3MObfRWHjfdUfAy38eFj1fIz9dCrt+NrgPb6XPknvtg3b96tK7Mb4AgYzkhOe9zAGWvvQqwsALXLv3km9+6uFMc8eed5SXXPFRvURPANabslAUu952WY94rylyjtW7/nqPt1832inmwUA8LDWXmutNXX+Xd7pdrZbnODDTFQyX1o/78oy/I9nWsYx6t1RHYd375rQweMZHRxOh74+W4KrWZ2RFn4/7vzazVdyq4FO7jjj1Rw9VSj3lQ6OG1dHWHZPeVmu1WTKHz1oZQlH2caCud5yk1FBq9JtwhglPaeF5cy/qnn6bwvtq92O6hKOtV/3tn0mwsZvm+l8a4395CuT2UQOWiVQGm/64GdQCcD55xectnq53gnDpykFYrLescN8848OftTbP7zf87xjq9oaZ0s2+rHONAOtatuWGhAR+4odwIwzjfdzr7OvePclbywsari+pOeCj7Gp8LH4qr+/NZbfSLaa937EdKHHn8A4k1HzcV3p2Kms0lnXN02cAM9MLiyqO31EQDIsYFZvXz1e/F0rT1+cV8IYJYo7gPczCR0DrficSZTaU3ORpVZX7ln/KuUIoLUNPbsA0AK7D03r2i8PKpu3unjjEr3zJRvLZToAtN6i/qSue+kmPeaCZXJc6QPfGNKNvznZ6WYBAFBTvSvTZ8oN6QBr+TKqMtBmNr/IzryQ57ydwZlcd3UcxSlt6J/e/3g642j/8bRvjKzZ5NQpNRUlqjxZ1DSNKGfLhMxgx/5p/faBcR3zdGLWCrjE5c84if++cklAa6tK7x06kdFt28c0kSp0kptABlrUGHJhGXgzLeFY7ij2dPC34vgQnMfQsbRu2TZWFeRsRFTgofBa/UBUoV1W9+6d1P37pnzPV8b7i7fy3u0+nXH0q/vH9ODBaU+Q1/MZ1WxQ/WaX2ubbjyLeVyrZ1tNT+EDrrY93H3Pc6pbG2RzBsQnzjtXgkVTkZ+1dj2ZK/Pra5AkYJAIZW3GCEI0GZ7ztrdf2qNejMrC8idrDY1HjoAW+vzHXrR7fcS7quF1cdtWYW555RAXXBo+ktGNoSnc+OB4I+NZvWyuO45HzjggYhy2l3q4aLElcWjfjy0DzLCsseFd8rqe4MzR6sY21tur7kWvT3wwLHb27ADBDB4czuuYLg0plXJ131iJd+9JNGuhLdrpZwLzX35vQ26/cqCdcvEKulT7x/YP62s+OzmrZKgAAZiJO8KEV859JObX9x9O6e/eE9hxOKRsyhlXVGGhOqXPVNrVO9a6G9/J22A70tbc7I7hNq8efCb8fJbh+ew+ntPdwSr/eNqbpTPNBiLh8GWgNfGxx1nOm5fzCshyHRwuBs8MnM+XnvQGvZsed83cINxBI9Lw/GHg7PlrIxDhZHPMoYaREotLLWpq++vviD1RI/m08nXG0Y/+UptKV/aPU5t5iQMVbPs/7fm8ArxVHnuA8Tozl5DhWO/ZPhU4fR60gma90Wo15pLOuRsZzGh7N+jqWS/tH7DHQPPfHpwul20Yn8+XPzBfrqtGgqEwy3zTFNuWixsfz7gPpwsRLBpK+90bxZ6CFdOo3UEKuNO3xU1kNHUtr39FU9bSurVvGrp6ocrnBioflrJ8a39tGL1pp5HjgRGTaRQXtvLMr/ZY5rtWOoanyhQH1xtr0Kn32iUT9YKovc7jeZxKxzwZ/4733S9nGubw/wBNnjK6ZZBI3WuK2tG6lthvPnxF1x7wLPC7tdwljKmOgxcwWjfOZlZcb2D7Bt5CF1h4E0ABgBk6M5fS2G/ZobCqvs1b16d1XbSr/MQtg9vX1JPSWF27QMx+/SpL01Z8f0ye/f6ipqx0BAJhtrSg5F8VxbLkzZibxi6FjhfF4DhxPa39ImcTqknGFTrXfPjihOx+caDiIFjl9yNMT05WyV+2+YCZY8imqYy70tRDB7egtd7j7UHXHdKv5xsRpYFu6MTqk44wnE/q+UgA48OUYmah87ssWV8614pSTrKfZ7VDJyrGh4wIW5l14XBrrqBTECpYDrMxTVc9723Tv3kkdG8nqrl0TntcLt6XqJ8FsuFI7E4nwMZqaFjGLsKB7XP5ycf7X4gZivOvv7Viuld0YyjNZ5SKBiH20xixrBXCm0o5v/8n7xleqDqa5rlUqWwi8LF1UDKA1kIEWVsIx1hhogfaXsmTDOu6D+18zJRyrAuilfTgYQIuRxdPoRSveaertc1EXIURlYHkXP50pvDA6mdexU1ntO5qumibscVhbk3HKAUYcU8KW5X01+DdLnL9hfNlusQJojQU5A0tr6PXgvuy7sKCxWZXXzZjKMd6f8Rl4u+f9peXG+a0M7sPB/TiXtzo4nNYdD4xXxR6NZAAAIABJREFUZcmhdQigAUCTptKO3v6FvTo+mtOq5T1638vP0+nLejvdLGDBSSaMXv2ss3XlH66TJN14+0m97+tDMzqBBwBgNsxm0CfvWk+WRXPLcV3ru6o+mM1SmCbw2EqprKuplKPJlNP4uFcNPD825cm8maVNOZV2QjuhokpBhT2O00kf/Iy8AY5Gt2Ezmh0DLSq4IxWCJzO5iClqDL9S9pkkGXlLIVa/txbXrQ52eR82ki1Tyfas7iQufYcqGQqF50ufcaWcYGCe5XmHdyini53uvmysUgCtJyqAVrhN+jItaqxYTFGzCDtmxJ6nL2gU/JzidbJ7l5/NVe/jzWSgVQKe1jOWWrz1jApGHD6R0R07x7X/eKY8r5xnBwwL/KSybmGGRlrSn6yaLkywJGFwu8ZZi6jx6MKWHQyqlZY/MZ3XiciyhYHlBR8HAtEllcBR9FpEbf8o/qzW2m/I+46h4cE0L+8+nMu5yjve4KlbNU29NgeDQLEzIaO+A6UAmveYGDzW+PbLqNk09tvS6HHc9946k0depFB8nGzgwoLgstzA8d37XNj8vI9L72n0+xeagZa32n0opamUo10Hp2PMEc0ggAYATcg7Vu/92j7tO5bW0oGk3vOyzVp7el+nmwUsWMYYveipa/W6v1ivhJF+ff+Y3nbD3hmNwwAAQKs1GmSpOa/A+wvZBeEd83EFyy2FdX6FZaAZ3+uNLTOyEy7keW8GWrNBwloyOVd3PDCu3+2ZDGuR71Gtko5xOg2DwZqoEmCzpdkx0KICGcdOZfXr7WMR2y6eSlDK3wl5Yjznexx2v35HqtVtO8Z16/axyG3dTCaeDQugFbdtKZhVyUDzvx5Vqs7XpjorVmpHX2+phGNgnJ7i2xOegXpakoA2w5nkHau7dk1o6Fgly9W3qoHZOzG/HzlfBpqnhGODGWhh0/k6r2u0z/eeiGPBRPEcZTLllOeVjyjhWFpmqXTn4v6kkkl/NmMU73rkHVvV7jibI7hflvbrsGVXZaAVH9754IS2DU5qfCpf9Z7q5YU3qioDrZT1EyPIFLwfZ9n1gqRRGZP+45L3Bf/7U1nHEzytHE+i2lO1/NJ3uxxAqxFIjGpTyOveV/1ZdjZyPf3zqtwP7g/12hY1ddR+Xu8zDVlT3/u84+rVu4AiGHx2PIHdRLmEY+X16nKclful72+sCz8C+3BwvnlPw8en6fuYLQTQAKBB1lp96j8P6u7dk+pJGl3z4o3auG5Rp5sFQNIzHrdK17x4o/p6jLbtm9LVn90d+2pHAABmm68zdYad2NWdKJXOrWb7tqs7P0M6kQPjrjiuv1Ot0cBWdAeS//ls3vVlZjUztk496WKGR1gGWNVq1egci5sNFSXs/Y5rtf942jf+1Uw0PQZaSIbGyHhOO4amJKtYHeSR8y4F0DzLyOX9WZFRGWP1AiO5vFU25yqft75t2Gi2RPl9nu9aVVZmsZHeEl9SJdshMgOtHED0zKtuYLBwG52BVmlDqbO4JQG0Gb5/fCqv8am8jvjGtIvuSI+b8eXNQPPedyO2eaSQ6aytzuAKzr/mLL0ZSMVAZ9YT8MyHZBZ6mzJdCqANJEI77MP4MtCcOCOehbXbf1trWzohGWjebXNyvP55WdQ6RWWg1T6Weu7HWHt/QL32tN51jS7nWN3G0m9nKuNWjh22+PkEjwk121p4NU4JR39QLGxe1fMtTBs8Psb43fBtw8YDRGGaHucr4hhbujWmMg5a3aYGXi8f31XZN/3bK/j3VOV+uZxvg6vlBtMAFcy6rf8jNj6V1+5D01UXW6A2AmgA0KBv//K4fnzHiCTpdX+xXo84b2mHWwTA67KtK/Tel2/W0oGk9h1L642f2aXBI7M/lggAAPW0YsymkmBnj7fzrdnskHyg/FqtDLTenmKHkdP4Fef++YU/H1amKKwdrVTJ4Au5br1Ox2YjQY/6WSPVz50Yy2nv4ZT2HknJcaxGJnJ15zMxXRhfJ9ipLVVnFsQVlvU1dLx6rLyZ8GXNBNYxKmOs3ip4Z+PtiA8LCNZjrS3vAGFjoJWUOqoTEQG06n2q9Hzj69VfykCLyABKmEogr7kwSkCtzvoGOs2jOs+DHfo2ZsakNxvDF0ALCWTUEjZVWPm0SpvCn4/aR0ufky/gFzUGWvHuVLqwbkv6k+V9uO7+4RuTKSRAE2NzVNahcFv6ToYdN6pKODrW95uQilGeNqpNJpiBFmcMNM8nGWe8KccbPKrzW5avCi6pqj3lTFXP+xb3F7riCwE0/7EuuG/XCupXZaDVaGu9TFsbMW0wU7nRC0UaHQMt6rco6u+KumMARvxuh19YUHteVb/5pQBaorJv1s5AqzyRiBu0U/UxJDjf4HcubD1c12p4LKu8Y7XvWFoHhzMt/92e7wigAUADfrVtVF/4yVFJ0ov+YK2edsnKDrcIQJiLNy7Vh195vs5Y0avhsZzedP1u3b5zvNPNAgCgbKYl0IIdRzlPCcdmL9auKuFoQzpmik/1JD0ZaIFOwIZEdUgHHlddzT0LF0+XFxHSpqqxaWosv95H6+1UNCG9MmH7RqmjPZcvdIDdu2dSR0ayVdN5bds3pR1DU7p526hGJvyZH44nkS1Ox3JJMOCRzbsam0HWmX/epahUZRsEg7pRpTLrBUa87/N2xDdSBrLyHm+bozt3Sx3wpeUlyhkzpfeG9+765h9zvfp6E+Vl+sdjKrXBVAJoLfju1GpVnHHQSu32f561A5FxRJVwdGoEfcLbF/5c1McRNd+wTDKpso28GWjezy4soDGdKWWgJT37Uu31ceocm2MFUwP7ZXlbFpueyxdK3w4eSYWWcPQuN5Wpn0Eb9REFSzgGs3iOj2a1c/+Udh+armTi1AhoxFl2rQBQ1EUIYWUbvZ/TkoHC+HWpjOP/fBwbEvCJXn5pOfHGQPMHYapEvDeYWdfIhSKS/3cmiq89EfOMzJaq04aqMf8qPzGSCtljcbM5q/eNwm3Cc2wNO/ZWHlcWWik/GuNYGQzOBt6Sd6y8dbSnM9Xbas+RlO4fnNKew5Xv6LGR7KyUwp6vCKABQEyDR1P68LcPSJKe8sjT9OI/XNvhFgGoZcPaAX3sVVu05exFSmVdXfflQf3nr4c73SwAwDwzlXaUiVE2R/J3rsy02yIsA61SwrG5uVd1ftYIWpUy0ArjooQHNeKIm4EW7MicjQy0mgGZup1r0R1nVcvxvNwT7BWOWFQ5O8615RKTtTqjrbXKZCudyMcCwbaq7RmzI80NZCScHM9JVurva0H3UkjnbHVQ13s/fvArcj/zThM7A83//ujxrwrPlzJEghloUfP1taneehU/j76eyn7kKwVYHqenknnXij7TWrt4JkZpsLAMtKhstODnUmvZ+ZASjr6MQTfe8TFsEtfayIVHBfmisupKAYFggLi0v/v3scLFEZUAWqWEY72LJYIlHKsviqj9/rDxqUqB4dJrE9OOplKOjp3Klve9np7Kvu5dx8m001Cw2ytYwrES+CgEHnfsn9LRkawODmfKFxf4A5H1P/fg71fNAJq3tGxEeebyb7Ln5cWlAFrW9e3z+bASjjWaXHotVjZTje9TsH2+DLSIsqJ1l1djWdXTeO5HBtAijrH1Zl/n7wvfcbHufhlYdikDzZPdW2usxvLn5Qm41fu7wnFt4PegOsgabHfYGPCHhgulco+czFTG3cvbWCVVUUAADQBimJjO611f2ad01tWWsxfp9c8+p+oPOADdZ9XyXn3wFefpsq3L5Vrp+h8e1se/d8B3tScAAM3atm9Sd+wc19E6mUAl/k7hmS072BnozUBrNrYU7MwNdgp7y1v1FgdeCY6B1mgJx6gepHqlrGYjA61W6bxa5Ziqpre1O2vDxsPxvx7yHk/AoZxpWGMbBMs6pQNB3kaCEv7p/EGrk8WxZlev6FUyObPzI18wpfggWEYt6jtUr/1uoGPz4HBGY1P5WJ231e30zsvG3herxkALfgYh868fjC283tuTKGcheD/7SglH40lSaEEErcY8Mtk4AariNohYV2+3cdzxz6RABlq+tJ3908TLRAqZyDaTgWar7ltrIwMClaCff7k5p1LGsr83EbvsnHfdwwI09YQFNfOO/zWn/FlW9mnv70MwoDtVJwstahsnEsHHpcBHMdAQWFdvm6V4e30jJRTjjMFYDop7Xl48EF7C0XEaLOFYfK2SgVbjN8cbFAsdA83/3RudzOnA8XRVll0jx6bCsmIE0GLMJ2oMtEbjZ5XPoxT8MrHLKUZlA3rLQNYKVIaVjay1ebbtm9Sv7x/zXaAVdgFA3rW+5QYDaN5+j77ehO8zqZfFjgoCaABQh+NYvf8bQzo6ktVpS3v09hdvVH8vh09grhjoS+qaKzbqub+/WpL04ztG9ObP7tHwGH8wAgBmZtmiHkmqKo8XpZXVcoLz8gayms3OKmU/mIgOJe/jcglHp7qTthFxMoOkNmWgeTu/ivPfdzSl3YenIwNmqYyjQycyNTOlgkodmN6xU3zzDumoc8ud1JXPuda2DnbQpwNjDwW3pxNzewa30chEoXzjGSt61dtgAG10Mq9dh6bL2TjeFpSWU2t8F3/mY+32ezuNj49mtfvQtO7eNeGbR70xjypt8N+vF8QodZbWHQMtpLO9dgZKpeM0YVTe/t7PvtS2RCJ+qbI4arUrGyMjt5yZExEE9QVKg9upxnxzIRlowX07TlZM1BTR2Yb151O6X6vEZTnw4x27y/q3R9KY8jE6bLkT0/nyfKpKONY4poe2P+T1YDlMb+ZkafKeZKV9wWPjxHTtAFpUm4LHSm/gKBgUCisRGitjKuR3NYovuBS1X4S0Y3F/YeNkc27VGHjVx4To5ZdeC5ayrDVt1Dx9+6mV7tk9qT2HUzoxlvM9H7pD1xCn/Kr/ux4+08jvTJ0PtWp7lsaZLD6OG8yqtahExIX1wXWvXMzgGY+yRvvHJvNyHOsLiIV8hav+DphK+79fpyYqJZb7exO+do1M5Kr+NkA4eoABoI4bfnJEd++eVE/S6G1XbNDq0/o63SQADUokjF7+jLP0j395rvp7E3rg4LRe98ld/5+9N4+2LCvrBH/7nHOHN794MUdGZkRkREbkwJB0Aqag5bBai6YsXZaWSCm6sNUGRFC6UGmHknJoh1ImoaCkdAlSWHZBi610y6oqqhZjASkImSQZEZkRkTHPb37vTuf0H+fus7/97W+fc27k8GLYv7Uy77tn2Ps7ezo3vt/+fR+++sTyRpsWEBAQEHADY246J9AWVvq1iKM6jqJTFzt46PBipROa394n4bmuNceRfoZmYtQDFNRJWIRwTO1d86OoRYAS/9fw+MJKH2dI2CHJlqcLPE9Mr5/i+Ll1nLrQwcq63aj6ysfPruHIqVVcmLdJ1DK/nrY9jhSoLqi4V1QI6HtNG5e1NXc4dnop6ye5/CrwvtbP0m7GogKtzEH4laNLOH2xg5PD8FKSk5eTWpJKjR+XQK+1HPg15qS2Y2mt79oghNTi8OdAs68zYTrr2UTvV0rlKjTYDlV9DQ1VVrevL8x38eWjS/jy0SVcYaG+yoooC+H48PFlfPWJZTFEI1cJapSpEDnos+scaNemQPOdkA/71iOJFPSpaQBZOUVVpwB3+ttlXV3q4aHDS/j7I0tDu8y5wcCvyPFBIqAKAjjVCsysuKDIyxWb9wNfi1bXB1jvpri40JXJHI9RnKigyiFnQ4CbAq3Wpgs3b1V1X+XXVZVr/m6TzdgdngOPlVNWbkHI6HYoqb+MkHZuLuGqRn3t1lKg0Xk/bI5uP7WIHd/vq5F/BuihaoW2HR4bkYzTyOdj9fVF+TRnWo3+tcNCuiQrn198zFISlL6z41gBGXDuSsdvRECBQKAFBAQElOC/fvkqPvqpPGfSa//pbXjO3skNtiggIOCp4Nufvwlve+0B7JhrYn65j7f8+8fxV5+5WPmDOSAgICAgQMJkO0ajEQEZcHW5WoVmvW88r56jp1extDrA42fWvOWsCHlk+gM7hNW1EEycQHPCSRXbtomaJntqIRx972B99NEnV3D45CoWVuxd1XV2to8KSw3D6vAp4LTzqsdDJJYSH/k5KxcKv8ZTH3WglRJoQ+OL3GQZ0On5ic66v4WssInk7ygyqkTbbhS5m3zQjlKLNBmWzdUrPkdwluW54Xzjvo7CzjemOr0UXzy8iIceW8L8cs8hFaqcxNq5WqlAE+7V7S0TDXYduv175EEyYazV/dl7/Nw6Fpb7WFju47FTq16Ci6PjUTR0eikuzfdwZbFnqSrMeIZzDHDnki+UGmA/exHCsUSB9tUnlvHQ4UWvwrQufNdzUj63y794SQQaYK+xUaSMw56Ra5rIXx2+IywFmhjCsT5poHOxDRhxRMPL6uJobke+GWSQAl/4xiIeObaC81fdiCA+i3wKtAEl8Qq73Xas06f8mkHJ0mXll6tQJhblKlgbDbpkTe6TzSh1wuHqMnU7lD2gRFhb5ytry8dy2dyTUC+Eo21HlmV46PASvvjYYjEfyuZMednyvDbdoWorc70EWvG/8rplBZq/vmKjDJtvTgjHig0GS6tGgZamZv7umMuFAeeuyER2gI1AoAUEBAR4cOT0Kt7x0ZMAgJe/eDNe/k2bN9iigICApwP7do7hna+/Cy88OIU0Bd73N2fw+3/5ZAhfEBAQEBAwMpRSmJschnFc7FdczZUr5df6VBznr3bxxW8s4vGzNsFW5USpA11Gq6Ed/fb5Ql0QKRM2KmWOxFEJNN/xwtmc/1G8pwtn19Pv8OGEjOj8I45raidHuQIt/+Q5fcruLxRomXGAlpGVpi8jJEO1IP2t41NsVME3buNIiSEcj55ewxceXcTFedtRTvO6jDU1YWvO67/1cxQh6zxqx4XVAT7/9QV85fFl0RlYJ0+ZNKayLMM/PL6M9U5ewPxy3x6zhDSQ8tkBRvnlEmgyg8ZzrHH7pbZQhEDrWyEczfm6SgsN2r6dborz8/XCn3c94da8JEMmtQdxGvO+8865zHr2wSAnVnwKtMEgw5XFHpZWB1hj/w4YmSjwbQRgawpQHsJRyoGWZTYBA9hjjT7fRDsu/l5aGwjzZbT3BB/rzjuBta++npLpHSH/ol7DuHK3zCZOoFHeyN0Q4N5/LQRa2UYU611XMiYBe9MEYAgyqkakBGeR3y3LcP5qFyfOrztl8zLrqJl819Vqm3T03xV1CDQ+R9IsX28Gg6zI3+V711UrKNl3dlwpu60rShOPKqXEMI7O2KF1VuQwTEmsRv67hBdb9duPnqbjbedcC1D574LVTvCDVCEQaAEBAQEC5pd7+I0PHke3n+HePeN4zT/dtdEmBQQEPI2YGkvw1h/fh1d+53YAwCe/Mo///b1HcOZyCGEQEBAQEDAa5qYbAEZXoFU5sX0731eH+S1WeKL4GgqoQZrhq08s48kL61ha6+N/PLqITz88j6+fWAFgHDE6FJyr3Mg/I2XIn0FqqxqerhCO2oGty9OOtEZsiLunG3Z+LdsBpu0o8u4I91CUOl5T2/Ep3u9pe5rrrk4Ix0aiipBh1JEtOZz1mJBUIeY6uc5IyaoJrTTiDrpVkqclKtqUkiY2SdiIbZKN5v8CjAJwcaWP4yXO5jJIY2p5fWDZurKeesesTzViFGh2PR7/qqjEo/0VCaEYo0gVYVWl0HKRMsFC605R3Qczw00CJy+Y38llzekLP2uFphTUbLaj2PztI6fWuylOXVw3KhXByd4buOokPRb6wvw2BohVeuHNgSY8UymBNtBqTNI+5F7d93Tp4ESqxvxy3yK8JAVaJWXA7JDWDUoS6XaILQLNvmdgrbOuBb656oZwNPPAl29KIqPL4G4sKFvHK4szY5qQJ4B5j1BlVZ+EcIwJOfjoiRUcO7uG+WV7k05xbeSuBxx0bZWfqcb6mF0LgVZ9DVdpSmuDL+xp5brOxzt9f4BtLKiw1TcUqKKs7Ho97uuogem9A94evNySPKH8O7221TCbXkaNHHArIhBoAQEBAQz9QYbf+tAJXFzoYfN0A7/8I3sLJ0JAQMDNgyhS+LHv2oFfe9VejLUiPHF2HW/4o8P4zCMLG21aQEBAQMANhKnxfMf/escfPk6Dhyoqv1a+YiA4fwHXwSSZsrjSx5XFHk5e7ODyQg9rnQH6/QwXrnbR66eOAg3MmaX/Vsoo0AbMQc3tqoLXAabrZk5nH7l3Yb6LxZVqFWC5LaT6TA7RxaNl+R63jhogjmTHG+COj+J5iV1lar+ivWKF9lDhZSnQBKfbw8dWsNYZ4NEhoVpmO0UUKSilxBCO2lY+N2hOOSl3H1UJASbnnqTI4jhxfl1Qvfiv53aU3beyPvCO2djzT8YiB5oqV6CZMeU6kCWnN70/UoZc7loKNOoorg4LR6Gd33dsawPISU9NjpWHUZTPUSctfZ6C7KCOYnIf7wN97sT5dRw9vYazww1wtHyt0uv1M6e/UoGUdOaD+AR++MYEJ6AAsxlAQhHCkRlD+xEAYtKXXKGisbDSdzYBFF9rhvPkayJ3tNMcgBahq1TRB3ouJkXeTLtMjvoKNKMc8oXYpWWVrcm9foqrSz1XgVZyzyjvOhq+D6BhF801g4EJ4RgxtSoArHftTTPmWl2U3x6JyPWd95chhQAtR5pmWF4b4KHDS1YuLusa1kcSke4lnUfjz4ojdBrUUfBRWzhUJEZwdNeE4Vc7h6FcprR5R18/qp2+d188fG/z+gJkBI9wQEBAAMO//3/P4OHjK2gkCr/6o3sxN9XYaJMCAgKeQXzzvTN4588cxN7tbaysp/jNPz+OP/7bM2EnVkBAQEBALbQa5p/VZY5RoNqJReHb+V7wKKwqN4yPe792+A0GmeP8S4lztEk2j0nOrCii4ejYbulR358lfjHaBoUCTXDCnr7UwdePr+Brx/3ETx1Qh1eaZegTf6UmEyK229/L/5U0Q0HGRUp0vEn30++6n8p29/eK9oqKPGh2CEdukz93FYVEFGjiSCLQClvZfTQvGlWx8Hp6jEAriLVyuQXWmOKtVi4e4fG5Y3G1Myh1SEooQjjGtrPSET0RkpQfk/qaOpUpgSkr0IyjvY4aL8sMMa4JWOveMmLBswbYhLQ5rsv0KtA84fk0MaM/dXskiSrWsG4/dUM4CgQ0b9/RiQLPcYkMKAu92nfblzrN9RCjZBJXzmosrPTtZ6QETU0y1XpnwZ0P+fpvbDZhBc180Gt3U9j8IObj8jQPtzmOdRklIRxZ+2dZhhPn17Ew3GzR7aXo9lN8/tFF/MPjy84mjMEgw8JKHycvrLtrVJ01pSDy8k8TztW9tkcVaAKB5hujhQKtZPm2iESpzf23mvuEdboKg0GGo2dWsbTax8PHluVyLYVV5nz32cyvkc/J3/VnHn5xaMeok36IXFHmzqc85KW8Fht75Dp9oYozIkHzKZ55U0nPpaL890cRiju4PSoRCLSAgIAAgk8/PI+/+swlAMDrv283Dt0+vsEWBQQEPBvYvbWFt73uLnzXA5sAAB/99EW8+X1HQ0jHgICAgIBKxJEiOaZkL8SZyx08emJFDE3kg48c8TlqOXElOUSK0HFp5oSIHKRZ4dhtElLQ2glNnK8xCeFIHTR9T+hJH3zNkGXsGYZ/J5yESDMcObUKwITxu1ZYzmLmlNX1UdUD/XTL8ndwEebMQ7hI91sOtYF5dl89msRI4rohHOt50KTLNKko5UAzCjT7OCXQ8uewzxcqIUbqFiqtiq52lDK1CDT3Gn2o1RzKDLJchSbB15+auDJhT/NPj0DBJqQ1YcjWjsOnVvHQ4SUARm2l1Zk9snhQR3FxrI4aj1yTxKqQWOiiy5qTq1I1fAq0MuUdt8WqZ1iGLpeOeT0We/3MIVtToU37gwzHz63hymLPqb8OfPPHJqCywiYf9Bqcsvs4AUNzoNF3hUU8CkRdkVOwpgLNOp9lYr4lcWMIUdloUrDZcDc/SO+5umsRzSPF32dp5q6NWQacutjBsbNr+PKRJZy90sFnH1nA576+4N34kWYZDp9axeNn7BCKeZ3VdpqxnX8WCkLPWkk3qQBMletR2dF1J8sy9PopTl6wVbicyDlxft3KS1lbgVZ9mQM63qsI0wyuIg0oX2/Kbc/Eb5Iyd6S5QEDDQHJI6lBK2vmqtOY0U2ZzkrXc5kysRN+r7Q4KtGoEAi0gICBgiNOXOvjD/3QSAPDdL5zDd79wboMtCggIeDbRbkZ40w/egZ//gdvRTBS+cXIVP/POw/i7L10eebddQEBAQMCtBa1C8ynQjp9bd/JKVe12TtNsmNx94ByvA6l46vDjtqapOV+EcGR20hxoZueyTX74wlrNL/dx9PSqS/SV5A6SVEOUpBmkGc5d8efrGhVWuEpWv7Y7ivg9nrLKCAYSDrKO4w3wO+98ah+q3JIUaHwclalibLvc6/RYEJ3COiQdu23VCuHo+vj0by89nkwIR78dFD3mma8zbSRVm26nJFYYb+WSl+W10Qg0nveoIBU1IV2iajQKNDo2M5y5ZDZ5aSKhUKD17WvzawjhIFppg7YFvVcKjSdBGk8DD4EmlWnlwxOIEIAQZ4xIa8RRQSb2B5kzR01+PXPs4kIXx8+t46tPLA+JgtF++/s2PEjkkkSg6fGtz1n1E6c5HWJ83OR/l9ut28g48Muvp+czuOt7mtpkaRHmF+58aA37RCJPrTIlk/haqUCUQ+67Ik0l9VGGq4QEW1rNB4BEKJsQiiYkKh3TdXNw8vCWfC2g6BOFoHTelJVfp+2marYsA85c7uLxM2s4fm7duRfIQ7EeO7uGR0ZUbHOytC6oSl/afFCeAy2zPn121T6XWR/DEI6uHWJZnrlCy+DgvykAm7Tz/36Q66J9ICm+9TW8To7inR2VXxdgEAi0gICAAOS7MX/rQ8ex1kmxb0cbr/ve2zbapICAgA3Cd79wDu98/UHcubON9W6Kt3/kFH7zQyeKUB8JCc57AAAgAElEQVQBAQEBAQEc2kHkC4EnkRzaybG8NihUDxSDQYaHDi/iocNLRTg+wHV0KM+/6iUHjBUSkam1+gOTw007c/N73DKjSFk5WiyVmoeI+crRJZy62MET59Zkg6VnEJozIbalaYaFVfv9/FR2Utu3yiqaSHGyw+fo8tthKweqnWDSdw2f497kjJMVaNwRTkkhX2gonx3aeehz6AF2v/QHmTX+JMesvtyQIobAOXWxg689Ue787TOSIhUIG9dG4RghLsbbeTtKBJoqyWcXFWHbWL4ZXTYnZQXS2iIImPm6/QsShsxB6rg3qqPqOULbK46UCf9YtJEwNyKT90pa86ScgoAhMFLPM/J5qB3ZXIHWI2FeI49CFpAVaOsk5OdqJx09hKNvHYDbF9JGC/0OKdqNNYWkJJTUI1Vm9woFml8Cc/ZKB198bBFrnYFFLuXkhn0tzYGWfzd28jCFjYYUYlQwQDjEVT5cOVS0ARnjvJg0k9VQrWaE8XZsXavXskFqlGbU7tr5z4bPZ4hsey2gyAk0eM93+yn+/sgS/vtX5/Hph03ObqpGzDKzecAaZ08DQTLI6udAo+8Q2m4LK0IeN2v8ZKKiUl8SCe2ytDbAZeE3VF6e/F1eF+Vn4bZwG6JI+V7jIoEeWQq0+u+i/Hg5yZrX445xDn2vlGsvQEYg0AICAgIAvOevT+PYuXWMtSL88o/stXbJBAQE3HrYs72Nt7/uLvzzb9sKpYDPPrKA177jMTx0eHGjTQsICAgIuA7REggKDb5DX0P7OL702CK++sSy6JTv9XPn3Yql1rHLSjxOFMkBQ51+XUYwdHrmexJHhWPF2h1e5AEzO5fzUIe0Xn9YQQC4usQIrxICSlag2fnZnFB9T8EPxHduSyRAEVqrcIzKZdVSoEWqRIFmF+BzcNHjK+uDYod/QSbEJgfaYJCPp24vLfpSky50/NFcSY5dwrjSzlLfWARsRdM6I5pTkeSwndYNEsLx6OlVrHXKY4VyBRQfo6KNwnHaV5NtvwKNOkU5dB/TEI7UfhOe0q2/CBVaonjRRILOVdbppkW76fuVUrUdxdrG/MYhYU7C5fnKiKJ87QBgkf4adP2xiXn3GC3eN5c0scEJjiQ29ubrL382+z5u28Jyf3QC7RoUaHTzg56j/WEjpOw+04/muFmj5foo9MaDQoGm1zHh2seeXMXK2gDfOLnqtL203lobKFJjJycaWgkjCSHPRam/Fex8kQokd1Vq3hWGaJcfzgrbOfx71+YW5qYS6zqqCKThgqVyyuBXoLnX9q0caO75q0v9PEdbZo9dK4QjUISztMhCj7ll89m9th75DthkOiXyFp0NL7wSu45CcazVdsImjYePL+NrTyw7an0JmrCihHTENzb47i0INPt4rkDz/A6znoXM4Yq12GcLVWv7Nqz41gM6H/WfZp2U7QgwCB7igICAWx6f+NIVfOJLVwAAb/rB23HbltYGWxQQEHA9oJFE+ImX7cLv/OR+bJtt4OpSH7/yp8fwb//6tOggDQgICAi4daFDHlISSsMXYo87ohZLlM7UMcQdLonkaRuW3+2lePj4cqFwo04//i4rFEEqd965ihN7Fz112vFweb5nzq81zu5LCz2vIzKD7ESiIRzT1M3J85QUaCy0mKTu0s8thdujePLCOi4uyOElU0JE+gg0HlbMV0+fkAh/f2QJXz66ZOWzayTKarNOPy3CmLWbEdrNnBRaYo5Nbw4+wZAihGDieRhmP1c/Ss7uIqTo8HgzsQkcH2KS+8ouTyZveJ22zYZ8iZQqcgPKykR4VQiSAm1xGD5urBWb8JSSHUOHclm+JT2GxppR0Qe6P43qgSiWakwR/YxGqWDbJhWhFMk9VhHCUQ7TBnLMtYU7nU3oxuF15FkLezO3v/T9vvVwYfUaCDQf4UyfCTbRRzft6r97AnmdEeWPRaAJoefE+Rmpwtmu5wVX0krI28ReE9311qeycR38ev5Y40CoX5rjis0vxfpYz2n9PqSko6krE8MwxpFLzGhS284baRTXdQk0/p7QfeYLd6ufXVJa+Qgi+hMgVwTa4yyv3zM+i/lc/TxpWl/IRsM8d8nvooWVvq2QEtShkqJR2ydt0tBq467w+8t57sw+rpQdCrQM+jRXfvne4YC8UcAKge3N7+izgagUbdGkCelKjtFnovNRjz8TwvHafzfdKggEWkBAwC2NJ86u4d0fOwUA+P6XbsG3PGd2gy0KCAi43vC8Oyfx7jccwnfcn68Pf/25S/jZdx3GYydXN9iygICAgIDrBVo9IG2w8IV6ymA7dwYlyi3qOOOOuyTmV+dIM+DCfA+X5ns4cSHPhTKg/jdWlbY9idUwyb27K3tQkAm2E4mTFWXORa2wePLCOh4+toxL83LoJfgIrNiES5IVaE+BQLMcd7KTlCs3fPXNL/XxyDE5zCAnJ6psAfwOUG1jp59iMMjQ72dY6xhPZx7OThUkTbeXYX5IoM1OJsXz8D70E7/uMV1GmQKNOgo7TJ0khVvLssyaO9r+KienVmFxUndQQTLw4187tozPP7pYlBNH5f1FVVocUt6jq0v5uJ+eMBNYk6a8r1OBDKDQoWOVUpgay5U0mqDT7a6U0fDQ8s9e6eDvjyw5qkCqvAMM4VK0ozQOlOmnTjfFxYWurfihOdCEMJOWWsOyJf9MWP5D3V56TaE2Wwo0h5zNrOsBm7DmTv468Co4mJqGhrzVYxUgZNpw3bNIKVKMlQNNIsE885Pn3yuJ4FhgkLoEoEtGZtbcMm2qMDtpq7pobk0NaVyLCjRhapkQjkSBlph+d9cUM1YAo5KMInuTAWAIezoveoMUX3xsEV94bNEJEeuDye+n271crdtjCkH7AeQ6LLItM2PRCuXqsa9sPjvVZ/VDOCoIIWuRrwtfO7ZC8kDyOjzkupDvjUMaS84YYJ88FGgZCnKTDcYy9bFELtMwrF5i06vMN+f4GCqiAgiqN4ARaMN7lfA7L0BGINACAgJuWaysD/DbHzqObj/DPXeM4yf+l10bbVJAQMB1ismxGL/wij34xVfcgYl2hJMXO3jTe4/gzz5xVgxRExAQEBBwa6El7FbX8ClHMrbTeiA4ejVWSQhH7lfx5avKMmOP3pldRmxp9Zx2stDd/aZM4qAm3gROtvRLIilpRxh32DvXwaemII65zFWg+XZu1wEPHSX1XUycbTx/S1WZGnQnet376oaxA2zCVTuGtfqj209xdTknbzZNNbykj49Ak/pE90dpDjRyH1cKpJn7vIOU2KBsZUkZxjSB5ijQ5L9911xe7KHTTbE0JKLyUF/+enmOJopCdUI6XJOYM+OJQ2ZIhE+ZqpNietxWFBrVqLGDlvTYk6tYXOnj8TN2bsKUOawLpUKpAs2Mt6Nn1vDIsRWcHJL3gH8zgXbi2znQXMKTEkZSKD6q7NT2DlLXOay/+uxZ76To1CRINM5f7eLI6VUcO7tmhawrC4HYJgo0Sqb1+ikL/WaH4tSQcqAR/qpAHJnwh87aUzKhqAJUX8rbLJ+75HtB2AJzUw3rWkktnaX1wiHmAjT72alySJeRlIRwTLPMIkp1GOM4Us57tCCCyTt9vZMW/611ar5oMmOjthuQFWaAWbfKyHoOei1tC/pvVH+oQNu+MmRZ9fqroZhKHQC2zDQABVxZ7OHSQm9YpkvIcgWalY9xxPycfAxwRaACGUfXGsJR2fOSQsq9qTxrse8++7i5iede022TsfbLK7XfzxFf1wN/VolAoAUEBNySyLIMb//ISZy+3MX0RIy3vHJP6T/4AgICAgDg2+/fhH/7c4fwwF1TSFPgLz55AT/3niN44uxa9c0BAQEBATctqAKNO4SkUGaA64zijkgKSohwx4o3B1qWFaHytENXclRqp4u+JmGKE8k5Gyk7d0hd9dIo13AneWFvZHZ7DwZuOU8lEhH338sKNOOkquN0kgg93aZSDjQpDJOuT4IJY2cu0M7dJFGFY0+HJFtc7WN9eH52MvGSPv1hvrSvHVvGmUsdAPkGRIl80v1RSqAJ4fJU4bxzyePLi71C7Z+rIt1yANcR3S5ySXFHv+vIdGzMCBmpSZaBdmgb8lRCpMoUaHpOmWOaQJ6eSIgyTC677lgDgKlxW4FWOIpJuFCpHpeIth35PCeiqERUJlSgbr/ldZpbT7bZKNDIMXLekHmEQKPqmtRWdsU0rxFTSOXl6X6W7QGA3ojh2tM0w+mLHZw4v17MF20rfQ7dzioypLZ+Nr0WO2tjZjYe0CEmOb91fZSci5RylCaF6qbimaxxl7mbCvJ2J/cQkmByzJZH+wjoWipiZa+VijwDVQs3ChLBVaBx4l6/8+JIOe9RnXORPi8N0bw+wvjI84IWj1HUKaFHbPKBr3mWAI2EcERm2raO6rYKaWZCKVZBKVctdtuWFjZP56Sq/m0iKdD4e5d+q/uOke7l9eSGyrkEy8D7pm4uU6oirVK9eTd5kHdl3sauqsz+XTn8rcEIzaBAGx2BQAsICLgl8bHPXsKnH16AUsAv/NAebJ1tbrRJAQEBNwi2zjTxG6/eh5/9/t0Ya0Z44uw63vjuI/jwJ8+X5qcICAgICLh5QcNvOeEMS3Kg2eERM68za72bekMe5Wow13uTpiZU3mCQOxglQkjvtC92vju5MWiZtvNVX1OVh4zX2+unlaqDPFyYezwmz5umbm6op5QDjZEsEvllQjjWC2clPacJhaksVQUtnz+7b2xoEoAqQzThSp2NzWH4tAtX853/4+0YrUbkVcEN0gwXFrq4vNDD4VOrePzMGr74jcUinx6FHjNKuUoOU575WztP243cwc7zKAF5TkCdFzApcVByJ237KSnQ8nso6a3LqVKglQlG9KkoUgVpCOTtNtGOyLPJzm6qKqmCVqB1eynWu4bQt0gUj7KT16nvA6jaSVvqlqGUmwevQ5SmVWFBJWczPW76OnOUUIOBIcoiQrKnqdvf+rq6bToqKNFit1NWECRJHDGHtpmveR40c1dq+FyLpOWkJmAUPa0mJeeootgQXPn15c/CN4TwdqfqOG0rLb/BSEIJEmHIocBSDJL5mKVmHUxIqFf+bFz1TMMCcmKmIeRzpMrC2go0wArXXORDZKGXnfdwyYJCiUkV2YRaBpsYLkJWVhA1dd5lo4RwBFyiLybruB4nTt5JuHOffi8NEyzYxu01+Rbpumif85ev1xdycHivn0Bz71ck5OOoxCbdeEWVbIAZw3TN0WOcqnIBM76oUjegHIFACwgIuOXw6IkVvP/jZwAA/+I7t+OBg1MbbFFAQMCNBqUUXv7izXjPGw/iufsm0B9k+MAnzuFN7z2CJ0momoCAgICAWwNJbIgDHsbRp0DL8xqZ74NBiXMqM84/7liRdnoDuTOI7rjv9lJRcaGVSV228107v6iTWf+p66NEFsXZK12sleRt6/Rc4st9AJ8CzDghqUMTFQ6pOqC3+kKL0TBydeqSyqCOOEeBplwnGOAnfXT5VgjHoepH9y1gSF5NXk0NnbCOgqtlFFzUWX+y5PcNvc6nEKBNpQkGTXbVyTflU3fx+dXy5UCj49gXSjB1rx0pB5rHw6YExyUATI3HeW4yRmbw5kiz8vkyQ3JNNRtR0QbLawOmGh1eJBTF21fXpx39Rt2gjZTKABpsMVojpIWPsCpUbaTLaBsUajiaA421ByWdImWTS04IR6Gfnw7MaXUNDZ1nqbPMeG3EriIkIQo0e06Y75YKS48bod1ahLii4UULh3rdvE/sO3+HUHWV/k7L37+zDSAfoz6SwSG7JQKNMWgKNnnQJ+2al+HmFF3zhA2mba9B104NK5xjt0S+yEAVpJICTQlrSxlZP9E2BFoxb8kaQt9LvUKBJpdl5kb1XChTyXPwPKlAPn8LZTsjskwd9nzNUvt5fKEvaZkUTojI4nj+ScdR1XJg1hdCYusNBj6bhLlpzUdPnT5CKyPj2qcq42tOXqd8rUTCB8gIBFpAQMAthYWVPn77wycwSIEXHJjEK79z+0abFBAQcANjx1wLv/OT+/Ga79mFZqJw+NQaXv+uw/jIpy48Y7taAwICAgKuT2iHJd/l7lWgwXbuDNJyIkGTIpxIiZRHgZbZDr9uv1yB1h86MYscaEVon9yu+eVeQb5Exe5l2W10cb6LbwzD7+VlcAItdRxE/Bl47hONmBAVVOmhHZ4+oqkOLMcdZMVMoXqo6UwUCTQWHo9CCsOUf/eRPvlxmndudaiO0KozAGgyRcX40AlrObWVGcf9gV8R6dps/tbOXa5Es3KgDQkGTaClFWTkejf1Ot+533esmdfPCdCycaFtLRRoxKGv54VP6alRngONOMvJ39tm8igonNeSw5rJZT/3zkk8d9+kdUz3YW+QEqetchzFmeWYtsvlIRy12WWCFqVUQWBo9Psmf5tXgSaQ1ZRAlkI48jyLWmWbP4uy1i+pPcvsGQWacJ6ZTLB1NifQ9Phx8zsRoidRlgopipS1FltkPiFg6BDkZARg+oUSaIMUjtK1JBqpYzNFnw1Evk7zebxjroXn7Z/EfXsmvO8Lp++FtUApm6Tgeae0XUWuxNQdo76wnHHsKmf5epkXav7U73lVw6tOVVTa5ISRGW5YxpoKNGVfz0Mg9j1jkdqm75Mw1ooxO5UU19TZ7KDtcgi0iOT+GhbjrGuZPV85aVcWwjETupdby/l/Oo4q33d6DpI+5+3PkWYZLs538dUnlgs1Lt3M4CU2vf1FbIf9u4napfuJ5sCkY7zYBKXtCAq0SgQCLSAg4JbBIM3we//xBC4t9LB5uoFfeMWekZKzBgQEBEiIIoXve+lWvPsNB3H37ePo9TO8/+Nn8Yt//DjOXO5UFxAQEBAQcFNgbOhIXWWhnXjIK40ss/PLDHi+mSG0g0SXKynQJOdNr2+rVrqesIl8p73ZmWzsvLzYx1eOLuPSQq+oEyh3Zi2tUgWafa7TTZ12kXbciyEUSa6pIl9MbBQEPN+RhJX1gaggsHMJucoVXb8+X8eZKKn+ihCOwjNTgs5nG4UhJ4jSZ3iM9i3NtwQA4+38Ox07jdgQIP2BHEJTAnXi3bdnAi+6exrT44l1jW7LLMtcAi1FqQBi99ZWbYd/m4Suo0RYmXOUjuNBmsnEqSoP0xhHbjhODWo7deJv2zRMIzA8v7o+wMX5rtP5NMcTx6bJRFDP5N+7vcxyoFKVCmATSHocXF3q4aHDS5gfhs8sQs45yhH5OaXQd5ps8CvQJMKYnC+IseE5oSw6XiMWsrAIPVuER82sz6eCTZMNvOjuaTz/zklHzSsVTzcqlIZwJPfkmy3yvylpVOSCFHKQ8THt5lrUZZe3AZ83mrj05S80CjdzbG6qgWZJuFg3B5p7jUMAgs0rQkwW5dRdv5QbGlAaxxR6bZGUahyUeNLzySI+lHJU5JHyk3NUgaZRKJpY6GPdtr5eLsh04VyzEeGb7pnGtmG6Ex5OsQxKeKY8hGOVAo1tZGHv2dIcaJl9X/7JLio2Dxg7fe9c6zZyMhbmoE+ClmXAI8dXcGWxR34/mXbwVepbK0tDONJQnuw5fWq1oECrj0CgBQQE3DL4i0+ex98fWUYUAW955R7MTibVNwUEBATUxO6tbfyb1xzAq1+2E0ms8MjxFbzuHYfx8f9xufZuvYCAgICAGxfaqbWybjMmZXl/rFBL/VT0pRiSQTt97fN5uDL3Pq6E6/VcJ7wScr9oVYR29A3SzHkmfY7fe+euMWyaylUY1LnJVXidXuo4r/nGNl+IRJrPRyvQklg5O9t96PVTPHR4CQ8dWRYVIhq+vFOFCgbVIZ8A2UlfKNCUm9uLqkro2PGHehoSaCI5WqJAa+kQjuZYEkeGiExlAlGC5ZiLFSbasfNcuqjeICuc7DSEo1RVkih80z3TuHPnWKkiw7onNnnGaBjHsmehbdMfyGRVFKnSzZdlBJtkOiV9NTlw7koXjxxfEfO3iQ5VJYc0aySSAs0mfwG7TO3s/ofHl7G02sflobPXDdcqPyOQly85uNe6A2QlYShFsprNxdwWqkBjxA4Zr9RZnJKNCVqdpEl2rmIDXOVkFaIoX/ujSBXjqOg/hwQ3czqJlaNC0uEvab/p57WI0CEU609aJx1zeThWZnfNEI59J7zi0H7SF6LzXWhGpZRICvHx7iNnKXkIZRMZ+rmpArL2+hXXC+EogSsuJVikR1GnOR9F7jxWZKOIfQKYaBvb9HiiITqtELR9+XeDxqCEQdMm0XdrXc5ZKXcuUfU4J3g0sszeBMNDXZetwXq5P35uDZ99ZAEr6wO3/KIec4KqVX2g5dC+0mOyLJcoB/3N5g/VKB+31Yy2cpL+ra+hOQ+lHGh1nj0gRyDQAgICbgl8+egSPvRfzgMA/teX7cJ9eyc22KKAgICbEXGk8EPftg3vev1d2L9rDJ1einf91Sn8+geO4+pSb6PNCwgICAh4BnEtBFpm7RSXnSY0zF3+yUgwJTv2eS42SYFGHVoa2jFKHV2cjNOOGO50nByLcXD3GICcNNMOTF7vejd1nOkOgQbZ4U6JDJq3zZePjaPbz+3qCWEk7R3sMin1dIRw1I8VRa5mSZd/9nIXn/7aPE5f6ji2WWUNCyvLbwfYCjQVAeNDxST10TYSOw+TNn3LbAMvvmdarJ/abB1zCLS8MJ2XT0VAaxhicuBpy2YSYayVkxOiLzkC7to97hzXRAR1/vsclUBOOEVkTHGHfv48VSEcZRv1vRp7treRJAovOGDycFdxgz7yyedMbhAih+bA4aIHiUBybGfrgU85oq9pSLmjuu5co6C5waz7eilW1gdiyFOHQCPjNSKh4gaEUCjyY5XkQKtLnGjQHtDtrsNJOnM2y9cfbYsdfo3MPSeEoxsCML9HnzfHpFCPg0Fmk0+0nIo1rOvJT0bXW5k/k8emRArVCeEolS/NG668qwMphGIcl893Da7slUA3CEjhj+PIJcusnIW0viSy5xgj5ng4XF8OVmObVYwFPWYK1ZinPbdvauLAbWNFWOD8HjfPG13HiznIN7HAHU/Fd89mIXNdfuHlxR56/QwLQxWtVJYu0g6n6G8reoYSUUUKOl8IR2HdU8r8zko9G1V8hBYPo2nlHyXtzZXCPCedJtvMZqQUJ86v48ylTtj460Eg0AICAm56XFro4Xf/4klkGfCS+2bw/d+yZaNNCggIuMmxd8cY3vbaA/jh79iGSAFf+MYiXvOOx/C5ry9stGkBAQEBAc8QdEi81c7Azm3mcWDx0Ff9QSo6LnQumyKUEbvEp0BbY6Ek17upkyMkFlQ1fGfyIDUh9zS0s4jfyxUo/YJAs+td7biee+6r9O12z52N+d+ajGkkhgis2klNHe/cwUrvTdNMzKlCVTB1wh6V50ADS+xj2n1x6Pw7cmpV7HdTfv4pEbXUudsiTtexZmz6kDrgSC6gPiFAY6VKiQWJyOEOxWyYS0/n0WslkaWgkcY+DaPGq2g0Inzrc2Zx25aW9z7qPC4jVpUyKjRJqQnYpIyEiCtkWPka+3aO4aX3zdh5jPzF5rZ75oLPHk0U9fqmXSPl5lqjY8bXPD6lguxwl0PfrXXT0nxjaZZhcTUf71RF8blHFvDFbywWBD4dZ7w/+XgtFGiEfKLHAA+B1qjqDRu0zxvEs97rC0QAYCvQWE4iSl7T0IoZsdkO4WjW6C8fXcKjJ1bEUI/5d9sW6ninc4+3K1/79bW6LQepPLd8Y1MipbRSdGm1j8dOruL8fNe5hucYVEouK6EhHGvyAD4iuo4asY4CrT9w1zdapxTC0VHcDdHyjE8aGtHemJMVxyWY0LpSmdq+4bWejQ6TYzF2b23b6kh4QgZWhILNMvYeJvOXhyHk0Nfpd2JO7nKD7XptZa63aOucRQyy9zeH1O5cOSZt1CkNdzv8m//2o/NBX2PC39ptp+/Tx9a7KY6dXcORM6ve99itjkCgBQQE3NToDzL8nx8+joWVPnbONfGmH7w9vBACAgKeFTSSCD/+3Tvxez99ADvmmlhcGeBff/A43v6Rk6LjMCAgICDgxsZ4KwZUThTQPGjeHeDCTnHuM7GIoUwmh/hOb431nv2uWeu6N0s737VjJyb1dti92iYn/CMLCamdd5ICjWNsGFKQhvhyFHPFrun8Uzt38xCOtmPOB1omd+pnrD8kFOGsUC9HmKS8GRCnFoXykKFljmCTA01S09g7znX7jZMQYJYCjYSV6w+yQh2g1TG0b6gDUFKVSH7ONAM6wz5rNiJbzSc8W4uq5pSyHJSxx4EOwFLyANVKFEr89AaZFfqxqE+rVEqIAb8CjddXTm5w+EI4+p5fE6c0LKyKbCc7YJfpmza6jwxB7Xe4cwK9PVQ5rnfl/Iu07vmlnEDbVJJmISbjhTudB4OMKDuJqoQq0BLbUS5tbqjKfcVB+46qlnqD1BnTaUYJtAhjrQjtZoTZqQRKKWsMWu1LiAvbYZ5/rqynWFju4/zVriHakOcOBHLS1h2DpHhSF+8mKZwoQDcSyOFXffNE4pv6/QynL3Xw0OElnL3cETcuKE+RPCRkHQWaL+wdRx1yrFFCuGoyb72bWupIAA6ZIb0LpJJ9ijfdn3xMFznQPNNvvZvi0SdXML/sRkrRJilCMEkbHSQVli9kIFfBygSavS7pOjmJyjFg69oglcunnzQHWtkmC0v1xchP6W+Nbs8dzJGyx5a0DvlssdWo9u83OvZNCEd9LRv3BaFp18dzAQYYBAItICDgpsaf/t1ZfP3EKhqJwi//yF4x4WpAQEDAM4n79k7g3W84iH/8wjkAwN996Qp+5p2H8cjxlQ22LCAgICDg6UQcKYw189+aqySMo0+BBjAHX+Y6K5uNyHI48XBHgD9XinZCamcPV6Rpm+PYPUbvS9PMCQfpy4GWh4kzRM3AQ6BJIfK2b2riBXdN4cCuPCQf34me12t/6vITokorCxVH79HPRkG/SjYCpl20oopjatxuUFflZgIvw6oAACAASURBVNiinI8hTkdP4LMy8qHIgVahQANMeLoJK9SWqbGRkL4jodm0g5Gq0Gx1gWuXRO6kaVaoBpsNZSlo5BCOfqJJJI+UeQ7AkKBVYT0jpYq26vZSMRymrs6ngChTqFVt4PSd132RZZnYv768cFSBZnJnuXkCbQXa0EnN+tJRpJbEfNNkvu6bXZtzAmetU61Au7o8JNCGORQlmPyDbnv0qAKNhnQlDme9XqWpJx+bslVkdcC7gCoZnfUhy9AfLlCNJFeEfNM907h/fx7O01YOkttg1kJana67L+T6UxGwf9cYXnT3NPZsbztjjI5VaiXfgMAJgKKNY329vGlhFAVaP81wVSBwKHiIVKOOssurkwONEvNlYRrL1E6mPv94GWsaApmH4OTkkkSyS9X7lMDFWHDetXn/+Qi04+fWcf5KF6cudrxlmo0OHrIUyrpO3xtZ7wh7HfGpQLMsYznQSPhL5V/zADc0a67kZNcUy5chmo2a0n04PYfpmUgYh/xvDZ2nlYL/TpIUaL5XFlW+uySlfR39jJQdrpv/ztNIRlz/biWElgkICLhp8ZmH5/HRT10EALzue2/D/l1jG2xRQEDArYrxVoyf+4Hb8as/uhfTEzHOXeniF/7dUXz4k+drJ7gOCAgICLj+MTFU9tA8aJJzRIMTRDxcVrsZkfBCMsngC+GooUPFSTuh49h1SGkns/ar9AeZQybpc5xA48o0TmCU5YuJFDAzkRT3ZpmgQPM5fRLjMK/K30H7gzvhqSPY5/CnVUtde+fOMdx/YBJbZnMiwCHQyNc4cp3CEpkikp8k3JtUD+ASUHp8zowblQ/1lyWxsskXTcIObWoIO9gB2QktORPTDEVemolWbOVhkpzwPJ8WHatS+cZOo8DS9ZZBEUVAty8r0CLP2KNl+Iiwa93Ur9u4TwifpuX8l+/TBGK3b8K5UfWGpMAqSCZvSFf7OqlJdfs/eM80XnzPNGYn8nHW6ZUr0FbW0mJ92jRVpkDTRhjbNeE3GGSgYQ5pSFddd1KQw/K6nMRuTsgq8K6l5C2vIoNZE/V4o2PGDuFokJIQp/R6HX6VqmUHhGhTShVkOR+a1lilZB2zmedAK+omGywkxZhPgibNhTz8pni5KY3bL5SXq0CNUta3mYISaBZfwOrg7zcJZSE/28MNNes9E55Zz5F8jBriiSvheEjY8XaMRqKwZUYmmPXWC07+9woF2uj/3tT1WyEcxevsz9weN88bLcunQONhIm0FWvn8LFRXhEjzPXZxnPx+4uPl2Lk1fPrhBcwv960HtxVo5ri0/PPfdPS6Yn0X5pg/hKOdD9EiKS0Fmt3vPFIB7w+NJOgNvAgEWkBAwE2JUxc7+IP/dBIA8D//T5sK5UdAQEDARuIl983gvW88hBcdmkKaAR/4xDn8yp8+IYbNCAgICAi48aCdlU9e6OCxk6sA/EQM4FdmNRsRDtw2hv27xkiCe3lHvU+BpkFzLXEkUUkONK1cE8It6nMOgcaINaNAy4+3myUuCOcRMud5qcPReo5YWU6+MlAHY2+Q4cT5dSwN8y/ZuWNk7yt1WElOrjhSmJ1sFCSOqEAjZdHHzvOxuHWurLmSKO0E7vZTUaFESUWNu++YwAvumsLctHHC2gq0yFKgmfwp+XlK3lBHm6TU8DnK54nSiI5byYHO8/1YCjQpbCQjcPvXokDrVynQ5DJiJasHc7vLHfG+07pdaQhVSz3jU6Alhtww19qh2ACWIy7TJBMjLYsQjrpMWGVIz9FsRBhvxUWbDgauipXi6lL+O3hyLC4Nm1co8mAIMN0evUFGVLdE6ULGsS47zew8d7rcRAhpWwXet5r07fZSp42yzKzxEjmj73VyZmVUSWIO6z6R8jqWKc7ye63iiY1MgSYQAICdA02CN5wpMaRRjI96YVbpS0IKG6iHLu17CfQ9JJEKGnUItFIFGglhyhVoAAmXLLzDueJu22wDL33OLDYP124p5CPgtqPJgVb5KA54G+e5OIXfIMUn7R+WAy22yzLrCFeg2e+CXHGV/12tQMvnje73QWrnEqT10flEyWCKE+fWMRhk+MrRJav9bKWdEv/W4OGv8+vyz6RMgeaZVxkJS6mUbQttb13igKyJUg40Po7q5P27VREItICAgJsO690BfutDx7HWSXHnzjZ+5vt2h7xnAQEB1w02TTXw1h/fh598+U7EEfDlo8v4mXcexlefWN5o0wICAgICniK2zDaQJAppmuHs5Q7Wu4Py0GWp7KxMYoXdW9sYb8VWgnvJCZY7gPw2lRFoeagzdizW5eb1SvnKfOHseGjHXj/D8pppg1aFAg2wVTLcOaufM+ZOa5J7qIosoQ7GC1e7OHZ2DUdOrzn3eXOgkUfw5aQDTDtyMmbASA3rXsiO5+V1l9EZb+m4WrlKhDtOpVBfSawwM2ErfGh9jcSTA00I2RkJzji7XPdBri71kKYZ4lhhZiK2nl9U0LHxQsssq5M7Juso0IrQe/1MJE8L8tbz70ql3PCH9FxV/RL0eNdhwOJYWTm6/Ao094QiBJ8my3iuIVqnscEmrY1S0G1UPp6pAlJSUXJMjsWl/26nOfM0Oa/JkB4heiLmvNfjwIRwNOMtjk3etvhaFGieZ+72XfVLmhklYSLkWrNCTNK+gZ3LiNdtheLUpDcvnhNopCBKYjhzxTN3YoG8s8uX76Pt2yBkfdl7UsNuaz0fXZtMOF+5TKoas0gFZnMlgabKr9Fjc61DcqBJhJ/wHuabKTjRwTejSGMB8IcirgNtK92cUpbvjo9NKQeaKcveXKPI3KZqZMrZ5aQcsY+1Scp+MwwEyVyxelFVGzHcN2YuLXSdZ9HPWfwt3NcRCGi+0Uga+2W5XM0cV9ZvoUipwgij8DPX0rHK13WNOqTxrYpAoAUEBNxUyLIM7/joKRw/v46JdoRf/pG95TtdAwICAjYASin8wLduw+//bwewbbaBK0t9vOX9j+M//JfzlTswAwICAgKuX0yNJXjJvTOFc3R1PfU6IAGXINL5oSQnaZ5/RNj9HblEFsVEO/ZF08oddzyEI3OsSLmCDFHBjw/LGDphnrywji89toiTF9YB5ASNP+eMIv/XTmPj5Nb20k+NOK6fA406q1aHTn2qEJCuo6hytum28e1qL74qHXLMvlciEFYEAo2qxdY6qdNPDcFBL4GOnSS289dpglA7LalzzSLTJDWYUP3FhVxptGkqcRQWEvHJSUDLoVxS5+gKNFs51JcUaJq89fzTUppLkt0SfKd1X2gSu5HYbeab9zQHWFGHQPBRklhSyOS228ShbksxnCwn1CNVqIykMcyRxH4VH0BzoKHoI6PEpMpOu821Mq1Q5hEiKyIq3FzJOpoDmXeBHke9fuqqX8jaJCrQaAg2psIpcjZxhzlgvWOK9a+EMMvLIeVTG2v+M0TPA++/W3zvHFKxJrIGhDAsI6EV+w5wIn/4DtFjVTAtIZsE8udw7y/OVYSza8RynjINnQOtQ0I4WuWTdy3vn1wxSr/b5+/bO4GJsRj37Jkorgfc95ZRoI3+70tXgVZ+nRXOECy8oO4bQpTln5l1nirItN0055ddpm1Hyu4dDISfX0W9xnZajqRMBYBTl0yOOF8oYfr8eq2RwpvyjR7Sb6yykKa2Gs5uj4j1le85eU46DR7CN8AgeJUDAgJuKvzt5y/jv/3DPADgX/7zO4rExQEBAQHXI+65YwJ/9LMH8eA900gz4IP/+Rx+9U+fKELZBAQEBATceIgiVTh1q5zG3PmoFWiR4JRJM9mpkieH9zs9Wo2oCC0J2MRKHLtOQu1YcUI7xq7jyg33ZjuGuHotjpR3h3NRHdlBrdtH2+zP21E/Bxptc21ft58WaisNKS8JtQGoUKAVIc4YgZbaDkN+r6SAkcZRFBkVwio5r/upTO0n2Qvk7Uyd+FrVwx1+3H6JVJLG5MIwfKMUhkwiPnkON8tZKdXpcUxWh4dTlnJIVKBpIskz17jDm5dfVb8ETSBqBWIzibwOWw46zxuJQjOJCAmWHx8IIRx5UxmVzPAeHXpNfA7pGfKDi6vVBFocKS/xAtjOXq0qa5PQm7QcqZ+0orHfz/CVo3nkhzyMbX4+qSBEZNg3NIX8cxKkUJVxLD8/VeFI7wYKqk6xrHQINVoBub8m0VKtQPPME0uBZsLc6nE10ZJZK6quAeS8W1xVI837JFbetYvbXBaeMS8r8hJ+gAnhmIcwdZWBhfIxckMpK/Ze5+vdRDvGiw5NY/umZnE9YJ6ZKrLzkKCljyKCq8JTzyYemtfN2C+/L2hO17xM+3wG+11gK9DKVXk8b6qUA43rZznRp9fGlOSdBGwlX+QbM+TP8baffa2jQCt7ZxV9zEgxuiFHty9VkbcaEeamG9i+qUnGnl12UKD5EQi0gICAmwaPPrmC9/3tGQDAK759Gx68d2aDLQoICAioxtR4gl971V789D/ZZUI6vuswHjm+stGmBQQEBARcIxwCzeOT8OVAk/Jq5LlBJMWT7QThDr1mojA1Rgk0ksdKUM0Uai9m89Q4cQgVDiD7Gn2PL49RHPmVUdpuqkHRziztyPTl7aBKAJ/fqdtPsbw2sEkDfXGG0hxNFNR5JivQ8s/CwcyuMTlJBKcjZBJCIvO0QwywQzxqUo2TT3XQYM5lPR6N+kom0CSyoowzmhw6F6tCOPKxQseq5KB32n7YLGW7+bUdhXJokIrhO2OhDbhtvkeuVKB5zuswnb3h2Gwm9nwtI85p//Owndq5SscmVyxoFIR6oeopUaAJD1LkKBs+w5iHIAHytcfbhlStSRRkunxKVnHHssb0eIJNUw3rWJpldg403qYVfecq0PIDy2sDMbcRMHxOr1rRPZ5lGSERyHoxQkpJKcdWUT45XjVXivI8GwSqQEPOaQVaf2D6s4x4kEAd/rrtOVFM0SAqW0DOCyWdk95buWLSP0AaSURyieaLkZ2zzbxrpRCOPlsk8BCO7SapuzO4JgJNP1pRdSYrqjQsBZqyyWgTGjr/1MNmwDaUpJm9tnDyWFK1aVAiVn+X8hDSTyibuNf2cFKrUMFF/DnN33SOjZesc1ylfq0hHKH4O9EOgU0/lcrrfd6dk4VqkdsMBAKtDIFACwgIuCkwv9zHb/+HE+gPMty/fxKv+q4dG21SQEBAQG0opfD937IV/2YY0vHqUh+/9P7H8Tefv1S5kz4gICAg4PqDIdCGodc8TgkeuscofswxuvtbeiUo5kSxQvINQyZOjhkHOlUmOTvflbmfO3inx00ZEXMAGVuGx70Eml+Bph2R1m73oaNIO1q189XN21adA+0L31jElx5bxPxKXzwv5XoTn4G0ixhSU1+nc0bxMJ19/5jg+VjKECmXqKXqRykPlgTqvEviyOo7TSRpmxqW4xnkb9fmOuooRVQl2nE5ORajkSjMTTecMehToO0cRh05sGts+BzaMZm3NVcXcihlCKcshSiv4vmAnDIiNmc8TlbxXs/xdsvuw0YSVSqQ6LUamkDT1+vHk3Jn8TFtiF59nb/OMgWaxnjbPy6TSHnbKopMO6VkM0GL54KKSChUZR9PYoXn75/EN90zXRyna2CSuPVXERe885okFOhXH5fzG5eFV5WIvwymX+z+95dTOebIeZuwqPfvjrLwc2X1UwKkWE9If054CDSl5Pfi/p1j2Lm5hZ2bW9i3s22dk0l5NofIl73b8/s1yUr7iedj1OfL2lnBbGjQmyBo3VqhNtaKhXepS47UASWkdPmrHTmEZBUkZZkESQ2oFFet22XlxFiGS8OwvkWuVqZyy8ljs7GomShMjceYmUyc3xKiAo2HUYW9AYD/ltF1800UmjhUsMlvX9NMlKxzxUajpIRAK1lni004ys6dl28yMEQkLceX25FvGAgEmh+BQAsICLjhMUgz/N5/PIFLCz1smWngF394T/UP3YCAgIDrEHffMYF3vf4gXnBgEv1Bhnd/7DTe/tFT6NbcFR8QEBAQcH2gNSR8NLGRxBHu25vv+j1w2xghDez7tNNGchRmmUwExMyJQnNYaGfuJFGgJSRMWB7qDPY5XS7zFoy1ItyzZwL7d40VTk6fs8WvQFN+BZp2wg2/07bZPN1AHCvMTuVEwKbJBsbbMeJYYWYywUQrNqoDj59QOzA7HqLMd9wiA5kTt04ONO4c02NCEwm8r+v+KyaKVOGc1WXGscLuLS1snmkUob2qQB11RVgn5hwvFGh0fLBrOcqcrjT0p8kVl39vJBG++d4ZPO/OSec+H3lw6PZxvOS+GcwNQ0MWBJomhSp+Rik1HJclja8djWUKNCk8my6/3ADhUGTCE2o0G7bztkyBRu0sFGhkLQF4CMfhJ2srE8JRO74z65NCMoeHEh1r+d2QVcosiRjR5Dq9zthu/qZjbqwV44FDU5iZTLBne7tYr5pJ5PRvlVtBUupyUo/3b1meIfH5aRg7y2Hut6s0ZKPz3R0HVaiIbuhtN2ozz3EIGNUlh4LdjHrDxfREgkO3j+PQ7eOYGrOJYmkzhRPCkfB1W2ebeNHd03juvvxdTfN2WUq34ZhO4goCTRkCrThGvt65cwwvuGsK22YbTl/S8Z6XVT4Q9bjvkzVbz7W1zqDoV60klwhByf687IrrBBtzZTyZf0RtB+RE1aWFHjrdFHGssHOuOTwOlgPNjEmtonrg4DRecGDKafs05TnQMktpBsDkQNM5BYeHC0XlULXc84RwdsJIekjORhIV40QqA/Cr1PWz+KDPKWW/A+zfD/Y6XTc/p+99HgAk1ZcEBAQEXN/48/98Dl8+uowkVvg//sUezE6GpS0gIODGxfREgt949Z34s0+cxf/13y/iE1+6guPn1vArP7oXW2fqOcMCAgICAjYW2oFqdtVH2DrbxLc+NyeCnji7LucTYbui6d9Zlnlzbtm5Uoijb0hW0RCO3X6KOFIYDPLQZb6wfNxRv3mq4TjdfE49rwItVt68MkVR2klOnPtbZxrYOdcs6ms3I7z47mnrfm36qCHFNHwKtCRWhS1cBVEnB1p/kOHM5Q7mphK0m3FBdpUpLeogUnZOJyB3Us5NNwoiqQ6s0JwwttP216q7TZOGiKlUZPmeQ3FyKf8ceJyCdpl0TNrn6NjU5WepDutVPiYipUm0qAg1KF2T10tsj4wyIWIe/iRS6MNVnUiQTkdKOc73ZhKhPxiQa/xl0vGsCXSzluTH5RCOdlvxvFL9NMPRM6tFPjvrOYRO52tGWWizYv1RcFSAVn40co6vJ9ZaqADdWpy0mhpL8IIDUwC06jHCzrkmFphCNS/PP374MzeSCA/eM42vHVvBlcVeYbs1n0qc1BIploEoSYR3Qx27+HfaTrTL64ZwrN6w7CdCNaTNFN4QjsolaHww4SXdczRfJuA+B12XtXqSEqsqyo/3etU585RSDoHMCV5NbsdOfzGipoLv0rdrAi2O1HCu9bDWSYs+vmN7G9PjCS4t9HDk1GppmUaBVl637mouwJV+W1Al66lLHQDAjrkmEq0AzgDabXYIR7eNKNIMLISj/SxpZvRoNLQhAMQK6MEo0Hy5/VTJOOT2jLciLAjvE55T1AkXWfM3jII7nor2zezPUkUoWeLKyP1bHUGBFhAQcEPjMw/P4y8+eQEA8NP/ZBfuuWOi4o6AgICA6x9xpPATL9uFt7xyD1qNCIdPreENf3QEXzsmh4IJCAgICLi+wJ1mE0MHtnacloWYoufp32kmqz6UUkxpYf7WO/ypw3atk5IE8n4Cjfqld21p1tqxLtlAEZXlQGOf1IkUR35lCi0bkHMz1UEZgVbUoWw7RAVaYU/+V7eX4vDJVRw9vQYAWFnL69F5wBwFWk0GLQ/XaF/Lc9LVwcxEgufdOYkX3W2HtbPryj+bjQgP3juDl9w3Uzh3fY5033GuTtTPSwk0H+i5MvKA9tlgIBPPkg0+5SRg+tMKmcVIZvrIsUASVtXP0WqQuIXIHff00jISg6pOeRhGvY7YCjQdwtEup3huTb6lwKkLHSytDnM60fyLgjlUIUZDjErQa44swpIndhzZNtAujKx10VstJtox9u8aQ7MRuUSTJoq9pK50TFlKKkflUdJv0rhOrTB29FpvMRWKM5veoi1bKFYqHOlVBFodBVocuznnxrh6bwiea6zOOiGF2G0kylKdla0j0xMJ9u0cw6Hd4ybMZ2TCEOfrRXk78Pedn8hg39m7oCq0L/9NQRVoq4RAU8jnYBUhR8usGgu6b+hlPJyz+e2jibKsWEO2zTbN+gJ7w4Nv7Of12QfSjN2bZk4IQyk3GH1GfX9PYl8BJ08ptcHuL/9Y1u3kC4NadxNQ/tvPLrcwoSDQyhVo/FwI4ehHINACAgJuWDxxdg2//5cnAQDfef8mfM+DmzfYooCAgICnF//oebN42+sOYOdcE/PLfbzl/Y/jY5+9GPKiBQQEBFzn4E7iSbarvnB2DSBCItCyTFYHRMp2XFHHJnVe6539W2cb2DzdQKMRYXqoPtLOI4t8I89wx9a2bKgHpSEcK0L+OX4eVe3AA8w1a90Ujz65gnlBIVMGH4FGHaDaNu2wL1WgMYf9WjfFIM2w1tUhHIcEGn0GVe4U5/XwcZZUxVXzYG66YSkveDHUwdZuRmgmhmgYhViQbNTDoQ6BZhNW/utoFb1B5nWGmnLzTys/ICVOvSSzPTaU5IisQYqKhFHmEk55/qZ6xNy+HW3s2tLCAwenzPXDT+2flRVodjm6LX1DyxcyUaNFwvS1m1Hp+NZtJpJIqUuiAHnb0jFlK9Bof9SbGw6RIYQvter3lEPVg3yOlJFPopk0jB2tu5RFqvGdvFs0dD08dx1H5ZrsI4oYyRCXEGpcTcgVTl7bNCmvlcOkjkbs33AiYc/2NuamG2YexKogRtqtkvHMSJIqu6V8ojZZXmqmqEAba+Zr+lp3UBDQhZK2xkYNc229uunDccVuxNYRGqqR5pKTclDqMVllR5q65JN5r2jiblgPi+3Ic5ZqVbez4UcpRhTKf0PloWIl6PGoxwbPt1ZXRE/V2jr3Iw9lndVoOzq2AoHmRyDQAgICbkjML/fw1g8cQ6eX4tDucbzxn+2uvVszICAg4EbCvh1jeMfr78ILD05hkALv/X/O4D1/fdqbtDsgICAgYOPhU6BpcNUNd0ZKYbrykI9uXSriDn5zjuaYuX//JO7aPY59O8ZwcPc4XnLvdEGSGSe5KafViHD/gUm88ND0SOozwO+sjiNVhGriMFXXdzbb9w+dUb0U56908ZWjS8W5OhtP1j2h+6RcVtqRXycHmkavn2G1MwCyvM8KhYp1mau087V9LKh5qpzedcHJAslZbhRochl+As11FAOGTJZIEqnMqvB1NI9btzd0KvtIkOEz7N3RLvLW2AouWi88x5kCjSm3yiBdoZUDlIjJc6C5dUhoNiIc3D2OqXGT3qBwIiMfuxkZ8ibklz2mC6LU8xxlIcy0HRrtpqvwoigLbZhmmUftZYcd8/UPJ7R94M9ZqEVqhBWloHnQeJllTmpprmWgihl5rXfKYXW6ud3k/F16rfQphYvyKtrTTxTZNklE9f0HJrF/1xi2zpBQtFWEIIF+VEO8mIsbLM9dHSUWYMZmEins3zWG+/ZNYPts02uH8owbb44/SsYLSsy6KjAaBlq/Y/p9swYaxVVpcbrQUpvZZfaYG/6pbdChW816b9aZSPlX/TQlBC+7iDeJFOZak1POtawM3b5Lq308fGwZV5byDTgNlqdPwW4P3/oXKVchTs8BZk7yf9P7Qji6vxOH7weFgiw1zzdUFKfatvL3pUbIgeZHINACAgJuOPT6KX7zQydwYb6HzdMJfu1Ve0f+R31AQEDAjYSpsQS//uP78EPftg0A8Defv4xf/8CxIo9KQEBAQMD1hSQ2jsEoUk4oH+2i0I6Ssl3qlgJNIIIi5Q/DSJ2gzUaE27a0irp4jjPAdYrOTjYsIqEufOHScgWaj3EZfnAnWV0CreSfA3WE23rHOQe1V1tSFiLM5zjt9lOsrA3VZ61YdGgp5Tr6LFLMctDlbdOgSsHtoykFffCFcKTQBIEvJJ+PcOGOeV12QSbXcIxXXQeQ/DJphl4/9yI2k3JbZyYSfPM903jOvkncu2eicGT7VFZOyFNik5ln5XZ6rxkOrTZp36ajQBvN2WnWksxx2mY6VJpnrvjmYZUijo7fKgUaz5NE4QtrFil7vfEp0LzrjmMDK1+vjV4FnnzcVqCV12GXJxBoGRwFETB6/1MoGNJFUqBFjNziqA7hWD1eooi/u/LP2ckGbt/WdhRn1nuxlGjPz6XCBpWkJO9nGZLiHZnnStw60xyGbfUQq0P7+IYRb2hLRr7Qz7L7fOfjOH/n6z5MmcKX51yTy3RJPRHCu1v/ed/eCTxwaKpQOEvVRpF/LBfrEoQxxb7mOdDsdaI/VB/TtS//tG3W4+DUxQ4uLfRwdSnPX8jfb/wd7dvUoQC0m+W/nfS7sK4CzVk3VG7fiw5N4/79k0Mb8lP6+UwIR78doygyb2UEj3NAQMANhSzL8O6PncYjx1fQTBR+7VX7RkqSHRAQEHCjIo4UXv2ynfi5H9iNOAK+dHgJb37fUVyc7260aQEBAQEBArTjZaIt5dXJPwc+Ak0gCmjIo4SFFeR5ZbgNVaD5XZ4O+BRoUcRyikW2wwkQHIE1vRZlptcNiSTBzoGWf+r+kUJwFs8hbHlfWMlvoOESqSNYKdtRqSK7ryU13L4dbWyZaeDBe6etcp8KJLUKx9xUnjvt4O5xsYy6CrRifEsx6pxCyX0VY5Xml9EOylbT4+xm5W6ZaaDVMEoVS2nmIWho+CyAKtBKzdR3e8+0hwqOKMpzL/kUVnVAnaurHVuqkWX2PNk01bD6dhTHv3U+UoWjeKwZlTri9foj8ompPKbcEI4Q/66rQONrdeFgp3OPPoOnXejay536ZcSU1Kc0fK+q2f+8v5z+I99pfjkT8k2VOtMriSff4uBXxQAAIABJREFUeGFqTlqHFMbQ+ttDXDh1sPcrfYw876f5Xvedp/vMyeFYcV/Zu90qn74LBUJq1JCZmiCjufjyMt01zVtkxdzmVUvkfjOJMDVmVLDSY8SR8q4vee5X1568XsWuzRz1llbZmhxrw+NM0elrD67qVqpeuygFzE4m2L2thX07x6xzRr2tF2Q4uduAaiW4rnuiHReCArrhin6WrbvRNcyHWxGBQAsICLih8LHPXsLffekKAODnf+B27z/YAgICAm5W/OMXbsZvvPpOTLQjHDu3jp97zxEcOb260WYFBAQEBDDo/GMSqWFCOObffWHtrL+zrHCGcFLHp5CpG9KvcOg8TbuPYw/hkBBnOsCfQ3sNuW11n8F/naQUqws5hKO/XLOj3S1rYSUPC2URaMwpzPsyYe2noZ1euza38Jx9k5W73UeBmwPNvUYphbnphjcSiBXOkLQhV6A54UxL+rFu/i/Azi+jw5e1PAo0X1miEsRDynDHqj5XRyVUdolWMum5rDxzvQ5oHqCzlzt5+UMHe0rWFwC4545x7NrSKr77c91V94nOBTTRjkv7txgndZVVxbplDvnWwrqO4YiRY7o8ca2Cn1ikasceU7eW2SI9ekYoLlWjbn6d+J3WRczTCh2lytUooyqiiuPWGjZaPjJrs0HZdQWBpr/bdSiljLq0pld822wTW2eb2M3ygfqGqj7uEG4+ZV7FZpKqKeGEHh3ezEMQFiELR1SglY8110bvmioUFEeqtEOlUJySTZmQA82xRxNLqKfI4+83BeV9D0n9dWDXOPZsb9v9K6wpfaJC0+M2ikhOQFWvz8wan1mf5e9Vob4AB4FACwgIuGHw0OEl/PHfngEAvOLbt+Hb79+0wRYFBAQEbAxecGAKf/Cau7B9UxNXlvp48/sex+e+vrDRZgUEBAQEEMxM5LuupWgJ2pfhC+Eo5VxKM2AwdIYkzBlDCQ/qJ+HOMx9ofpdRIe1spk7C6QmaS0pZDsVG4jqi+K7yuiaVOX7K+LPS0FSwHaDFYzHSx1xASDbBYbU6DL1Mw7vRqxQUc8jZKpDY48R/ulEnB1oV6PPTNvSN9YGcgo6VSWyssInml+nqEI4jhpvUZfC8TdJ9cWT3pZ5LdZqurCs3TSZoJLkqjpc3arfQdefCQh7B4I4hIZClNiEs2SSNA58DmeLQ7eM4dMc4Nk0lfgUOnWc++z11N3wKNHKDTxXLYY2FDNi9pYXNMw1sm22SOuxZW4XBILMuKxu7kiM/y6gj3GMrAz/Fq6SEL10fC+d9CYGmhkrisrXTSxQxUibyzC3+DE5xJc2u+0fKJaXDfY41Y0BVh9nTaDcj3Ld3ArOTiXW8ahl21lIfsWQ9qyFNinJGXO/1cOcEni6zzpquJJvkK/Mya6wFzrgs1kn5hpSEcKwzBng4RGPPkFgafs/Y+8bXHiMp0EraKxbWpSQ2xKFNoBnlJCUnq+a0vg4wpCOdzz6YEN6BPCtDINACAgJuCJy62MHvfPgE0gx48J5p/Nh37dhokwICAgI2FHu2t/G21x7AodvH0eml+I0/P47/+9MXN9qsgICAgAJKqd1KqT9RSp1RSnWUUseVUm9XSt0Su6D27RjDN983YzleNbgjpCzME1WN6DBebghH852SOvUVaEMn1jUQJTQ8E8U9eyawe2sLu7eYHftxZDuNqEpD2sU+ik3XmgOt3YjLw8oJJJ8JO2hfW9fHaYXWZE5iWgQPeSnlC3omwInUa9mU7gsryh26euyZfEUlZdZURNB6un2T76vV8BACPlKnUKn4SDP7OFe65GWP5qjmaDdjvOS+GRy4LY+8QsfqqPPV4oZSYLwdY27azF9KOMjhGN0ybfJetmeiHWPnXMsJc2mX484zikYjEhzI2vFLyrHUgrQ/xGod8Cadm27gufsmLdJbcoZXwVYn+m/y9akUiq1s3FSTDWarAl0eDVnhD+GYE/0qJ6HkC7zg4VAlVW1RDCNkLJLJX4XTJ+PtCLNTCeamGwVh9vz9k3jg4JTVr9cCHlrSHM8/nXe7L5ceUWEVinCP8lW+XygPEoGnxOvFMmsQYgDtJ3qRfAOf/3ou+cYyDS3rhiV1b+r7CLTIlJdldJ2z7eBwFGjKP0fL3k+RZ30rcnUSu68u5/nXxtuxpRh0SXDXDkdpl/mv5XaH8I3lCARaQEDAdY+l1T7e+sFjWF4fYO/2Nt78ijuCtDggICAAeX6K3/2p/fiW58wgy4B/97dn8McfPyPuuAwICAh4NqGU2g/gIQCvBvAFAG8D8ASANwL4nFJq8waa96zBl4OM/5ItyzlldhT7QjjaYbA2TzfQaESYmUxq/2beNJVfy3fX18G9eyawdbaJ+w9MWce3b2riwG3j2DydYMtsA7u3DR3okcKBXWPYva2FiTYl0DxOqdo50PzPykMtNki/JLHCeMtWyVnXSjnQht+5Ao2r53zwOW3zXeasbz3qrTrEzLUiYp7qa/m3F+2PpEyBxp2CJWVaDvUqBdqwnrWuSVTHnaGbZxqYGIsxPS6Pe12GL4RjxMiMVkNhajzB7FRSqD/rdFPVJXxMmL+ry6ZwyaHEKpuqACW7JSK6bkjBqmvssW2ONxoRtsw08Pw7J8FbqiApWFhAqa7aCjSfc9wizcrJPgl0bShToHlzoAmh2MrmAD8jKdC08bRfixxokd+hrk0oW8d84AS0tb5xBZr3S/n6J4WrvH//FJ5352RxrNWIvJs/RoVkij7k5kzz263HBVegqah6vff9pvBtzqmnYK73vtFn6oSc9G2Q8ZVOc6DVeb36CLRCbQk7VK0+7puTjgKN/WFtIBAvdMuX3o0DYvflhTzU85aZBlG0C+NaHHf5wbQg0Ko3puhnqLvJ4FbF07NaBAQEBDxD6PZSvPWDx3HqYgfT4zF+7cf2Wv/ADQgICLjV0WpEeMsr9+BP/r+z+MinLuKjn7qI+aU+fv4Hb6/MJRAQEBDwDOI9ALYBeEOWZe/SB5VSfwjg5wH8FoDXbJBtGw7uCHHyQpG/C78LSTTfbkZIEjUkz/LTcawwGGRoJAoP3jM9knP9jm1t3L61dU2kjA5t5YNSCs/ZO2kd03lkHj+zJlxvf6+dA405iKhjljv+G7FCf5CrcBqJQhJHWFnLiZY4spVltgLNdnByYq4WWRLZSih6i4LthIxZyEvLCfcMbof2OftGgUWCWAQa39Ffn0EbJXyh/g201sk7k6tdAODOnWNijkJTx5BA85AnMSNulFJ44GBOJC8O893VUbiMMu9GIRGFu61v7UZslUeduFLZA8E5XT/Mm3s9FAqlhO2INhdNj8d4zr58/ej0bMmnvirxhXB8GhRo5jjtd2JDyTNvnW3i4nwXrWZkOfbLuDxpvmVZVoSc46qsuuVwO4ngCVSDNiBEXeQTmA1vHG9FuFKjbgo9L6WwwY4yj44tqNK1wa6fG1zvvmuFgiJZ6vRB867Q72ZyWEQU5ddxkmuU3FemrPzTIdDY+TLUIcTouTrqSJ+KzK+8zIr3LA9jKdXB8w3yepDZiktVUb+kQNPl5XYp55xVX/Fdtlu/Q/rD33Yr6wOsdfLfIlumG3jy/Hp+D8oVmu6xvDyfes++R5OtQWNVhtA6AQEB1y3SNMPv/+WTeOT4CpqJwr/6sX3YOdeqvjEgICDgFkMUKfzky3fhp16+CwDwX79yFb/+Z8eKH+ABAQEBzyaG6rPvBnAcwLvZ6X8FYAXAq5RSftblJgd3fJTnfjFfNIHWiCO8+NA0Xnhoqji/e2ueq2eyHSOO1EhOeV7PswUxhwe/5hoVaLRsTnQlsbJ26FMShfeFnW/O/uR5VHgT7tnRRqMRYfOMyYPXakRWW/O/bYIEjgJtvB2j0Yi86sanA1ZIvGusxlb/uDvupevy7/5x6Gs3Cbqe1eFvoWainP6pGvJFCEdKnpC28eXbAoDpiQQPHJzCPXeMl1cyIvj4GAXcxlbTDqmo15eqvIB2mbIDuc71nICUyrH+5oUVjl+5fNo+T1WB5rum7JkP3T6OfTvH8Pz9k2LYNrls9xgVulr8o/KTSu5GBH4BWccEBZpSJTnQhjf68oeVtclEO8JtW1vYv3MstyuSx0Nuot3O9rP76+B9WFcZfK0oU6ABfEOCvxzd3IXSmX0fxQZNNjmqvlFIubqhShnhJ9lj1W8RSG45FFmJAk0k0Lw50IblwR7vughvCEcnDLYm3Oxyc3v8jWTlLxXGvF57Ly3k4RunJxI0yW8F/tuA2k5RPOfwGVMSktVrW7EJy3tJAAKBFhAQcB3jjz9+Bp9+eAFKAb/ww3tw755b1scSEBAQUAv/7Fu34s0/dAfiCHjoyBJ+6f2PY365v9FmBQQE3Hr4juHnJ7LMphiyLFsC8BkA4wAefLYNu17AfRlOmCfqBCantIohUvnOaJpDbN+OMTx33+SGEGHXivId1Dn4rnMfuIOPOp050RUTNVISK0yO+UM4xrEqHIk+U7RzjLf9vh1jeOl9M1aIwDJFEg/TRO3MbQNeeHAKD949XRoG7qnCzkd1bfVI+cAAV23pOLvLHOM+x6sA3W667xuJlEOrvAzdDpUKNCW309S4CeVYhlGa2MqLNDJJbn9vNyJ7fUmN+qguykjEKhuq8p45tnj6z3ZOk/KtMVhtWxm4MrQwqeSZk1hhz/Y2xlsxy21YQqAJBVJFrLM+VYRZNAf4VzkHmq4rUiUhHIef4616IYptuxTuum0cu7bkG6N9OR7za+0yfcSqW4f9/ZnO/lF3HQHK19MinCEjzuqQus4zD+9xc6BpmyqLZISY3waJoCxbQ3xhSKVbKIHmqird63v9fADz56a5ZDOBQfO1cSOJrAGt1xd9yKe6c8egeVdQ6LGh593Sav7v9rmpxK5P5RunxDIphodMCEfbbgm6bXj5ATZC6wQEBFyX+MinLuCvPnMJAPCa77kNL71vZoMtCggICLgx8J0v2IS3/vidaDcjHD61hn/53iM4d6Wz0WYFBATcWjg0/DzsOX9k+HmwqiCl1EPSfwDufjoM3Shwx4fPyQXAcriYMFA3DklWBplcKCdYfODXUR8ZTw0ax+b6BlOg8XCPcWRUOubTvca13KBJQja2PSGh9P0Rc9bRsaFUbrcT6uxpBiftrgW+MeySxfZ95c53Un7FuOBtlPeB7FT1QdfhU00p4di1YJS7bQJqxHrY87aaNqmYCmECR7FnVPUWz+UolVlKlAw/G55yytRNo8KXW61uqXQNKlOgSX1Kcy06vJhUlHL7WiQfBAbN5ExSVvhau6z8c8xDoI0ygOjz8mdX3i/l7f5sh3CUntc3T0sVaAVZoqzPWmox9l2HCebrbZFXrUS9WFwqEEdl19WdYr48krbSd0gsZVkxJt13hcS45R/ORo3hV0vRRuqM2aR+0d3TePDeaceu4hKhb8pCDEtqZnpcz3GtoNObo6gakf6O0HY6dkEThTqEY/WmiNnJBFDAzESQoJUhEGgBAQHXHT7xpSt4/8fPAgB+8B9txfe+ZMsGWxQQEBBwY+GBg1P4nZ/cj+mJGKcvd/Gm9x7FE2fdPDMBAQEBzxD0zqcFz3l9fPZZsOW6BHeglivQzN8DrQ64Sf4lv2OuiZnJBHdsbxfH3J3011Y2DduYMVZsrBkXfZDEylKFrffs8Md5OEzbNm6jLsvnQKQ7u7kCzeKZlL2jPVbKSw48k7DJgmurs5FE2LapiS2zDYuQqwrhWKp0qBEirKhfmGNOXeVFYGo8dyhOWQpFya6KgipgheirGO++taEO+OXNJLIc6ddC0I8awhEwz+gjFmgxVvm8HO38tlRMcplPNS+wjyis21Z0PSoj86Ty6L1eZYtVhlSucEw728kxK4Sjz87hYZ+adhSu0hfGk9aTl6nsAyV1OGRhfXOuCVWhiPkmCG85TIGmiuPVNjjk+HCjhrs5h86V8pbxEdm+Naru+sxV1tI9xVjI/Hm8ysxvss05uryMZauT2riRRJhox0WIUqkdqDLMKQwCgc36lh/XBJqOMqDJa0rUOc8kPD8NVQlAzJ3IsX1TE9/63FnsCOlySnGT/OwOCAi4WfCZRxbwjo+eBAB81wOb8BMv27nBFgUEBATcmDh0+zj+8DV3YcemJq4u9fHm9x3Fw8eWN9qsgICAgJGQZdkD0n8AvrHRtj0ViGHsPLuXqeNDh1h7JsP3PZuII4UXHJjCncN8OEBNhUUdkFBN2incakZ43v5J7N3RxvR4DKg8zJ51Gw33qJ1lynZ+cedY4bT32ErzqJSHcLRzUnG12bMlPHw6cqABwL17JvCcvZMWQcSd5NcawrGKPHIVaJHj+K1qz12bW3jJfTNFuDler6RQuxZQguT5d05hYizGfXvl9AW2QnG0en2qQG3/oAjheG1l1m2HQsnpIU+8jntPCDdLMSn0TxyPnhOSwyJEaoZwpKDrStmcEnOg0RCOjmNeKEMi1fh3ZWyX1LqRUl7S0ayH8vlRWprneCwrx1brlpCQzjx/ZhdOsXTPvCgN4ciVzh7Vknyv+buRqGLsO23q+Z0hgbYxVWn7Qin6freU2eojyNtEbVXkZhxBrsxzl9GxbkVwHB6n4V755otIGHfFHLCuk58FIOGAlXzcIdCKsNDGTv67URpL9DlT8uIdJcxogIxAoAUEBFw3+MrjS/idD59AmgHffO803vj9t9804WkCAgICNgK3bWnhD157AHfubGO1k+KX/+QJfOEbixttVkBAwM0PrTDzxeDWx+efBVuuS0gOGh5CiJ7TSAtH0jNp3QaDO5iewsNq/5H+jCOFuakG4kjhwG3jeMl9M3n4IgAzw8+56UZxPw/ZqJ1n3KQ4tp1qHFYIR65AK3m8OLLJgTT1X/t0olQVcg1IeQxNAldR4y+nbkgxAJhsx5bDsRErx+le59+aTRZyM4kVtm1qYtNUA7dtaWHLTAN7iILyWkD7dWYixosOTWPrbFO8VnkUVnVAn7dFnku35aBifeEOXF5m3alq8jD5SDPlXAv4CRUrFKQQHu6pqs/ysuQ6rmV5qkOiUND5U0eBJpbLiWryN9Xk0HB5vhCOVRjFh0PHgJsDzR4fyjrnL7NOrqynEyKRAfpc9WyJmappbqqB2akEu7dWK4NouXTNKiMlq9Z2enrzVMN7nb6sNsFJTtltY07QjS2+3z1l1vPw0PRZMkHR6Qsty+3Sf26daaDVjDA9YewsG59GsabE4/odoAm0BvtNoWCr6qpUgFnGlM039Y/GZweBQAsICLgu8LVjy3jrB46jP8jw/Dsn8Us/vOcZj+0fEBAQcCtgbqqB3/2pA7h3zzi6/Qz/+oPH8N++cnWjzQoICLi58djw05fj7K7hpy9H2k0Px0ET+fNnSCHWnq1QfhsB/mRPhcDRjjdfDhXqkHrO3gkcumMcB3cTNVyx+1vePa7hDXU2ROP/Z+++wyS5ynuP/07H6clhd2dm42yUVlpJq4AkFJCEyMZgGzA2JggwNrZBBsO1rzEWAhsbDNhkjBMiGmSC4ZpkARISKACrlYRQ2l1t0Eqb06Sd1H3uH52qOlan6fT9PM88Pd1VXX26qrq6+rz1vieQzn6KhDPHGXF3zmVmGDl/E8UyB2irkXwZPeVaubRDgYDR6FB2R3D28gt1vHpvl99vtHlNOosrFPRld8CW+dbOWtOl89Z3y+8z2rK2WyuWVFb6yt2hW7hRyW3j85mKPhuuztjEay7ECh9fzt/Yo7GRDi3pS3emhwLx45M/R4nMfHJ9nvKPgZY/gpa86w6gZQdkqhJAc3X6O9pa8ZIzXqdIL62XjM1iJQXjz0uXpk1m6x49NZ8ag8ln8h/XnA9vWdutns6Alg2kA76lfK4Cecpv5mp/gV3BPW+VPude5Vq+ybO/FPqMpDNa4/dDQZ+2ru/R8EDuYHrGK6b+cwbHM7dhKeV5nZOTF5hI6fOQ9Hwma/6C7zNHlmjm83s709+T0TxlCJ2tyOw77M0Yz8sZWLI5HndmXRcqM5xsw9rRiJ5+Vp9rXRfKlvWSgWatTa3b7Aw048qqyxegTGegWdf5AglmlQsUnwUAauu+XRO68bN7NDsf0xkrO3XDq8eyrvQDAJSvO+LXe1+3Xu/94h794rEJ/cPN+zR5OqoXPp0xJgHUxK2J2+cYY3zWpotXGWN6JF0uaVrS3fVoXCPIHuDeyO8zmlfuUkU+Y9ydIS18qpz93stfls3IQCu0rGDAp9HBsKtzMJV5lnGb2fGY7ATL1x/p9xltXt2laMy6Otwyn+Mz2dk3zs7X+mSgVb68jpBPl53VlzPgkz0GWv7llFJ+TIpfRLR5TZeOnprXUG9QcwvuFdgofYrRErZrJOzX2tFIwVKgXjizIpPrMpoY/i/fNugM+zU2EtFj+6dTjwUDPm0Z61aghDKJqW3nChYXmVfZ28vZuez3G0Wj1vXZHOgOaEl/UMvyZPOVIl9WXLUvZiiUcZsr6yT3GGi5Hsu+74if6bH9p3Xg2KxrGfkCj85lLekLaklfUE8cntHhMq7PcwbNssfrynhN52SPAZois1ZFsV3A65h5qeNuGQ12rivnd0yhi9KLlefNN1ZZ9nzZ8xd6D/kyiRcc3725MtCy9nVHJCyQ+PwnDfUENdgb1PHx+cRzE09xlnDM8zkuNCZt4cBt7mCg8/XzBdZiMaWC18n3IznKePrc543ukdycbYjfHj45rwPH5xyv3yjfds2rhU+7ATSDbY9N6F037dbsfEybV3fqva9fp86sqzIBAJXqCPl0w6vG9Ixz+2Wt9IlvPan//NEh11XPAFAN1tpdkv5X0pikP8mY/G5JXZI+b62dWuSmNYyAP7u8kPvKcPf85ZbtakbZpY+8v9dz1nVrZDDdWZ4MnKUz0IovK9dV5JmdX5mL6UyMD1MoqLGsP6TRwSKZSiZ/potUuBRiNbnK4FVpX8u3HfONa5VzGY7Ai9f9YnggpLPHuuIBHo9tWmyjQyEFAyZv2cZMa4Y7PGal5OfOQIvfxjyOgZZZenFJXzBVCtWL9Ocqd4ezl/+dy5HSncsBR1dCMrhXjQCalA5g5cuaqYZCAetcWSe55s+dlZYdVEpnq8gVPEsuN38ArXCArpSPVeESjvlfs9BLZL1+jT/mxRbv99i9VcqYZ4Ua4QyOF7JqWTybNN/F65nrcUWeUpLJ2fJl0Wcv17HNHf87A2AdjjblKy3r/DrM3HfiZZrT2eTp4JNNBdBc7XCWcMwzflr8Tvb7yTVf5mz5LrJJngpGY9YVQAzkKAvt3E42z0UXydnn5mOu9dnCp4yLhgw0AHVzz8Pjeu+X9mh+werssS6957q1BM8AoIaCAZ/+/OWr1R3x6zv3HNPnbjmoiekF/f4LljdMJxKAlvHHku6U9FFjzLWSHpZ0iaRrFC/d+Fd1bFvd5RpjI6tso4PPSFHHfa8dcs0oO8jh/blDvUEN9QZ1MHHldTJrL9nR5qUTKVcg05fR+ZW5nP7ugC7Y2KNIuPRrlJ2L8jnLqik7wBNdpIte3Bk9tX2t0jLQsjsVS+E1Q2KxhQI+PT1Phl6tOIO9yfWZ7KguOjaSc9yiMl471+co7Azoucqa5n8F56RNKzp1ampBfV216+b0GaOobN6x26r1Gnmnec5Ay54v6zHH/enZqDLFj0VGQ31BTc1EFQr4ND61kHf5UnnrJOA3CgZ9isWsK6iba+nl7BfKeF4tFAsoFsrecspX5s+LfBlohQwPhDQ8ENLPHx3XXDxRS8aXDs5kZjyuH40o4Dfq7wro/l2T6QkZF5i4HszVVtc4hfmCtOn/831/O7OwsrL6ffGM2Qs29mjBEZyKl3DMDsg525RrjNr0/wXeV4Hv7szynJnLi8asFhbi7fI7snmdWe9e9qN8+zq/8ytHAA1AXfxo+wl96Kv7FItJ567r0o2vXptjPAAAQLX5fUZvevEK9UT8+spth/WNnx7V5ExUf/qbqxh7EkDVWGt3GWMukvQeSc+T9AJJByR9RNK7rbVtPRhjdgnHwhlo8V6UdGeR1w65ZlSNbLtkJ6BNZaCVt6zsTqzE4xnz+Yy75FRpL+L+1z0+jHvWro7F+73k8yUCaDXe17LLthXvoCy3rGShbKZ6W6wOzhVLwzoxseAaty25LvKNNZTJdfypoLPfZ+JZIicmF7Q8R3uc88Yfz58ZMtgbL9lWSyODIY1PLag7kv4cei1b6VWh/SDXlJwZaDnmzA4qpdt+5OR83vnPWdsta60eeHwqa5qrHQW2UyHGGF24sUcxa3NkvLn3M6+LzcwgqvVHK2fA0vG/13KrwwMhTc1EtTzHWJHF25B+Ra8BtKTMAFE0GWDK2I98PqO1I5GsTOjkXF6Pr+7gYvb0jpDP9TnIO/Zrngy0+HiX8fu9iYD6kZNzqafYHMc5VwZaRqO8lnBMRxKzpyQ/p1klHBP7fMwR5HMG8HwZ5yDFtPCpYd0RQAOw6L750yP65/95SpJ08Rk9+stXjFVcwx0A4J0xRtc9d1Q9nX7923cO6JZtJzQ1E9NfvHw1Y1ACqBpr7ROSXlvvdjSirCucfcad1ZEVRHLfb+0AWvaV5KVKdgImM9DSJRxLbUt6efEH5L5NzVf+9si8aD9Xp97WDT06PjGv1cs6yn6dUvl90rxqP95eZjC5kIoz0Bz/t3IZ1EI2rujMeiw1Blq+sYYyVJqB5czoXLm0QyuXuqcXKt0nx7UEtc4sypRcd8mMrVpceOZ67z53qTYvY5vlf8y4150j23V6JjsDLXMbuJM3C0eMSt0n8vUFFQrIFHqNYGZUph4BNMdjIwMhnZxYKHqRRVeHX+es7a64DVkBNPf1Nzmem/vznG8dZ2+L7CCP1xKOzv8jYb9Oz0a1cmlHznYXiJ+5Xq+3K8eFJonp8Qw010OS3Me0XNlsmcvJJet8wWGwJ6ieTr9GB93lZJPLjjrGQHMGkvNlvedvhMf5UDICaAAWjbVWn7/loP7z1sOSpGduHdBbX7oqb21tAEBtveRXgP78AAAgAElEQVTKZeqO+PXRr+/Xnb86pRs+u1s3vGqMcroAUGPZJRwLd0pndsi0cPwsi7/U3lil118s0fkcS2WglbYcX0bnVXI7ZI0nVKXtYZSZiRj/v787UNIYU9WQLidW250ts/O80DZK9ouX+/uxkTPQ6inZAZ7MgCi2bqpVwjHftnYHOosvZ7F1hv1aM9KhSA0uAi50cUSuSV5LOCYftx7L2RY67noN2lUq49qCgmNMOWVeoFLr3aTYezfGaPOarpq2wTl+VuYYaP5ENnE+2QHrwmMh5huPzpe5wfJwjfPp2FZbN3RrfHpBS/tCiflM6iKYXO2xruBaemJvjkClM+ibel7WxTpGsVh2JqQ7MFj8c5FrlnDQpws39WY9nvy8OzPQnBmUmecgmUH1TO16Ychi4BJjAItibj6mf/jKvlTw7MWXLdHbXkbwDADq7bkXDekdr1ijgN/o/l2T+st/25Ua4wAAUBtZ42MYd8dHoVJlUmtnoElyjb1SVoZL4kk2lYGWXFZpC0tlPKXKLyVus16v9DamXiPH6yUfrHX2VyHJ32m1bkPObIk8+rsDWj3coQ3LI2W9lvdSXO0lHXD2FkBzB/tLX5PpsmTFI2iZ4zB5zXKptbUjEY0Mll5qr+j4cgUDhtkTcwfV8i3bvf97LbOXeT93CcfswH/FsgI7hduQ5PebjO+Q2u4ouYOYi7tzzi84AmgZY8kVO1/I95kq+B5yBMuMx33APV/68XDQlwqeZbYr+0XdATRXBlquAJpJPyd5XpC5WpKBx+yLOrxty5KzxRzLjjoDaM4SjhkXsmSWl8TiYc0DqLkTE/P6i3/dpdvuPylJeu1zR/SHL1zOQJYA0CAu39Kv91y3Vh0hnx7bf1r/51926uip7PEQAAC1YYy7hGPmaXJmWa9WP492Xi1ezntNPiWZeRbL02FWdDmJbZLMzE7eZmUIVrA9cpXPSnaW1TNQulgZaH6fcZXMKtbxum40UvZYVwVLA7YxZyeu834+le6XxTPQ8u8PrvKBTbgJiwWkC46BlitwlSyH6SFglBkEK1QCM1+WUb52FGtnObLbm69F2bLKONZQIxxKIuH877fY5zVf8NNr9qfJ8Vjh1/PWtuzS1e771hFBOz2XTsvq6cyupJJclJXNWcJRks4e69LZY11ZY416zVxOXRiQf5Ys/sRLxaw0nxiE0rnvJrMpk9+RmdmV2W3Ifmyor7ZjQ7YLAmgAamrXU6f1lk/u0CNPTCscNHrn763Rb189zA8WAGgw52/o0d+/fp26I37tOzyrt/3zDj11dLbezQKA1pUZhCmQgea1w6lVuK6IL6PXIrn+kiUcvZYty9eOtSMduuiMXg0PhFzLz5yvUsnFdIR8ksmRnbWIBroD8vmM+nKNJ1Nlziv+a7l3lxIEaCfOcXgkLxlo6f/LyxAt/NxCWWbujvvm2YjJUnXODJtcnO/X2vzTMh8LeBiXzmR8xxS6ECDrtYqsd3fmUu7XL1WhjLlirxHMUQavVnItfrGPL0v7gtqwIqLzN/ZkTSv2HZpvvRZOQMve37weXz1/v2elQbrvOj8ek6fT4/jlPEdKR9Bc4wA69UQCWtqf/fn0vE5SxzXvGz918ULUaiGRReh3fOWODoW1aVWn1iTGPy02ZmjmS5+/sUdbxmpbPrRdEEADUBPWWn3nZ8f01k/t0OGT8xrqDegDf7hBl2/pr3fTAAB5nLm6Sx/4g/Ua7Ano8Ml5vf3TO/X4gdP1bhYAtKTMTp5CndJeSyO1onLeb7pcU7xDKpmBVupFfM5Sc92R/IGkSrZJrqyo89Z368JNPVmlpBbTqmUdumJLn/q7a3/1ujNQWMvdu5QO+HaSWcKxlAy0clZj8rPUlecz5e6I956hUjU1WO5Fm3q0fnmkaPnRwhlo2dP8qQyV4p8hk/WPmyuQnVVZtUhAKkdGUlUZ95KLvYazDF6tP+vJ7ZK5zhaTMUYrl3aoryu7fGFNSjhmvHb8uV6z17ydz2QuI3NeZ6bYyqXxcqr5spOd8bNYiRfUZAZy80lOK2V/c26buUQAzZmBFvAbLR8KK5T4jly5JP4+8x47M148HPSRvFAlizsKLYC2cHo2qo/9937del+8ZONZazr1l787piWkDgNAwxsbiehDb9ygd/z74zpwfE5//i879e7XrNPZXL0GAFXl9xlFo9Z1P6nQ+DPtkIHmVE4lruRzkh1lyUyOUrPZ8vU7ZS6nkv6pXFfth4O+umafJS1WqVBXx31NA2gmvsJtc2Uv1VpWmcQiq8a1X5SxGsdGIhodCufdxz1noNVoE3aG/ZqeiRafsQSRsF+rllWWzZnr+DU6GNb8glVvp1+P7JuWlH/fzhrLMWO2cNCXet8F94mcCT7Vj6BlZhsWa4OTO1Ontp91Z+ndqLyNI7iYSinhmKukcC6pac5zE79RV8SvhajNGofN9Xo+93OKvkae+yuXhBWNWvV3B9TbFVBPp18DeS74SF9UI0cRR2+8BhVTgdSSAmjp/2fn4ynAgQLrZGl/SBds9Kmzo/jFB5nLR2VYlQCq6rH907r+EztSwbOXPmOp3v+GDQTPAKCJjAyG9cE3btDakQ5NzcT0V/+xS794dLzezQKAlpLZqVWofJazg6sdOkRijtpl5WWgxZ+TykDzWJouU4+HDJmOsK9qQc0G6nNdVO4MtMXp7G6kDu56yyrlV2TduI5BpfVFpxQKEHvvxK/NRjx7rEv9PQGdu767Jsv3LGPd5nq7HSGfNq3sdGWk5M9AMxm3buFg/u8g591cx2Tn/NXKks68uCDXxQb5OLN4ap6Blrh1x5Ub5wCzYUVEfr/R6uGOnNPzlVT0MgZa5rq9cGOPLj6z1/NYfoVeI3M/yjov8hmtHY1ooCcov89oaV8ob/DJeU6QuqDG4ybyejxKXghSSua489zBSwBNknq7AvnfZ8ZLt9sFV7XUBqfeABZDNGr1nz86pD/71A7tPzKr7ohf73r1mF7//OVFvwAAAI1nsCeo9//Bep21plOz81Y3fm63fvzAiXo3CwBaRmYgrNBVzq4MtDY4t3aO/VNOFlS6JF1yed5K0yVt3dCt1cMdWr0sd4ejs290KE/JKM8WL1GiYS3WGGjx5ZeeJdDqsjqqS8hYiZUZQPMq61hY25eTFC8Nt3V9jwZ7Gusi4EJBGS/l87KCHhnzhQoFsout+OonoBVcZrHXCDky0Gp+TEmt18Y8qHR1+HXFlj6tG81dPtSXK0BkvL2fzH3S5zNFgzZ+577qMdAWv1/++k32SS7EbMljojqDioWe0h3x66IzenX2Gu9VW3y+dGR4IVXCsfz36dqWvsXLIm8HlHAEULH9R2b1T1/bp4f2xksGbF3frT972aqiA+QCABpbTySg975unf72C3u1bceE3v/lfZo6HdMLLhmqd9MAoOllBsKcHR2FMkLa4opiZwCtjLebXEeZJRy9dpj1dwc9j/1VaQCt6NhCbcCVgVbjy7zT5dZq+zrNpFiptEzOY5AzW7QW7cnaTsYoeYAotSRrsyv0fl3rKc/2y84qcwcynBc+F8xAy9EO9wUg+dtZCmf7jHE3olgwxXURd60z0JJjgBUYx7TeCpceTP+fHvezyPJyPNd7W9L/FzqfyfnRL1PydWxMqdLZnsd4K6ENhcZKLdQ2ZznvaiUgtMW54iIigAagbHMLMf3Xjw/ry7ce1kLUKhgweu1zR/Xiy5ZwpQMAtIiOUDyj+IM379Ptvzylj/33fk2cXtBvX7WsYa+0BIBm0BHy6ZTjvrt0UmYGmsk5XzuoJAMtVcIxVbKpOt9b41Pp8ZH6uyrrVjEldAq3KmcGWrS6Q09lSa/i9lzXuRQqGZtzfscxKJnlWU2uz0TmeIN5/m8HhbaL6zsiz3yZGWiZpfucHfeFsn/yLD3nvJXIHO+ulKU6x0CrddeUcwy0ZpRrXMGi78URyC799bxtm2pmnzqzuuajpY1T5764qfrb2JcZQAuU/xpeg5MoHQE0AGX55e5Jfey/9+uJw7OSpDNXdeotL1mlNXnqKgMAmlcw4NOf/84adUX267s/O66bvn9QE9NRvf75o23b2QcAlVo/GtHMXEzDA/GqDX6vGWgcd4tKlXBMZaAlSzhWZ/n93QGNTy0oGDAVXzjI1nR3dgcr6Dz0wiQ6ftstEF1IoZKxxea3tchAc/yffTFB7na0g1Aw//t1j7+VW3J9pW5dz8/IQCtYWi97Wi02RWb4xOtYVJIU8C/euIrJVVWLLLzFkCuAVssMtNR6MoX3s8xjdCUBSr8/EYG10vxCaVH/Wm9Lv0+ad9yvpIQjAbTaIYAGoCRPHp3Vf3zvgO78Vfx62UjYp9c9d1TPv2SIAzQAtDC/z+jNv7FSPZGAbv7xYX3tjiMan17Q9b+5irEuAaAMoaBP52/oSd0vNIaNO1OAY24xyXUZy8hAq1ZH2OplHQoFjJb2V7dkfbtuWmOMtm7o0fxCTF0dpZfAKum1arr05pSdgVbKc2sbOSm0+GYKUlRDKJA/6psrCJJvnlxJmD6fXJ+9Qt9BuZbvy1hWVRTIQCu26WsdiHdJBZ2KZek1Judn2J8RZM0na18q5fUSO0ux/sNSS8sWE/QbzS9YzS+UNiaql/EFK+FcD4GAUbDA57wYZ9nTzHF2URkCaAA8OTExr6/cdlj/c/dRRRMXbDzjnD694ddWaElfYw2uCwCoDWOMXvu8UfV0+vXv3z2gW7ad0PHxBb3j99aoM1zbDi8AaHXu8VMysy4cnSIcbotK9kclk2OSgbRqZSIE/EYrl1ap8kYpvcItrL97cbqnmr3cWi0UKteXz4YVEZ2cXNDIYPXHPfd6MUG7bcJCQSEvZeYyx7fKzEDr6vBr85ouBfwmx3dQ7v/TD+b8tyJZh8YSjpWLGUDr7wrqgH9Og70BTUwvxB9son0zdwnHIs/J9eQSX6/YxUAmYyVWevGQPxlAK7GEY62POc4AWkewsqiXO5DdRDthEyCABqCg4xPz+trtR/Tte45qdj7+RXPmqk694deW66w1XXVuHQCgHl76jGXq7w7ow197Qtt2TOj/fHqn3nPdOg31ckEFAJQr1bmZo/+EsjylSXb+JgNntsoZaNXk7hNuwAa2GK8lytpJqSUcJWnl0g6tXFqj9rjakr8x7bYJCwbQyshAyzUWVbKkcNZz8/yffn7xAF6pCgUuih0rndUxorHqlxl1WtIX1BVb+jQzF9PegzM1fa1acG677ohfPp9RT6TIlTqVZKAlnlSsgEmhsRDLEUi8cLKEo+cx0FzzVf+o47x4qiNc2RvlXLF2CKAByGn/kVl9664j+t9fHE8FzlYuDeuVzxrWM87pb7t64wAAt2ddMKih3qD+9gt79PiBGb31kzv0nuvWamwkUu+mAUBTSnaO5ur0cF1VzHl4UckOqViickYygNaIHUqu8pyN17yWk5mFg8pKONaEx8BJW/RJGEmJ41fhEo7Fy8ylZskx3V80mpH7tQq+TsXc29qdMVf4mc5xpKLR2gbQpET7XFl4zbNvOtsdDvn09LN6i5bnT76/crZ1cv8pliHlq/L6DCTOseYSJRy9LrGUsffK4TwviYQqKzFAAK12CKABSInFrO7dMaFv3nlUv3hsIvX4qqVh/e4zh/WMc/s5CAMAUs7f0KMPvnGDbrhpt46cmtfbP71T73zlmLau7yn+ZACAS1eHX2tHI+rMcQWyq4Qj5+NFJYMkqRKOsdJKNtVNo7evhbCq0wqVjK2HzNKCrmk1LqfWcByxn1CRsoTGJ9mY8u7c6Qy07OBHsXXpDlzmX7aXZXmVuUzXcotmL6VnWFiEAFriVR2vv0gvWQWZpxRexuCqJJO3O+KX8Um9nYWDRdUOXCWDgrNz8StrvI415g6MVp87gFZpBprzXLGiRSEDATQAOnh8VrdsO6Ef3Htch0/Opx4/e6xLL75siS47u48f6gCAnNaORPRPf7RRN9z0uHYfnNFff2a33vqSVXrm+QP1bhoANJ01w7nH1XKeijMGWnHJ9ZUs4Rhr4BKOrk7XOraiXaQ7flnbSY2WgeYlm6rYtGY2MhjSweNzWjPcob2H0iUBi3X4+4xRVDZvlnLWGGglZKsUy5T11SDIkLkcV0DFw/P9fqNo1GpwkUrM1zrQUivu9Vpay8vJDOvq8Ovys/uLZrl5KUtaikDGjhsKeluoqx01CEo5l19xCUfH/0WzSlESAmhAmzo1taCfPHhSt91/Ug/unko9HgoYXXlOv158+RJtXNFZxxYCAJrFkr6gPvCHG/TeL+7R9p2T+sDN+3Tw+Jx+95nL6KACgCqgLE9pkusrmYGWGgOtAbs13VkWjde+VuPLETxod5kdrY20H2aVcHTdb5x2VtOmlZ1asSSs7ojfFUDzEnCIqsAYaMlb477vfCwfU+Be5mOLMgaah5e4ZHOvZudj6oksTtd3s+6a7oxPj8+p8DhabF+WpMHeoA6dmJNUuHyp59fMyOAMe85Aq+1FLs7ld1SageZ4embAEJUhgAa0kSMn5/SzR8d190Pj2r5zQtFYetqmlRE956JBXXXugLqLDRgKAECGrg6/3nPdOn30G0/olm0n9PkfHNQTR2b0lpesUjhIDQkAqAQlHEuTXF/J0o02EUHzNeDXUSmd2KiG7PJ17S7z93+9PyepQ5wpHIxp1W3o8xn1dJbeXRtfVzZvJ39yzKnUdOeFGSVE0IpmoNUgBc3VZo8VGUMBX1UCL541awaacxV5DaDVpCVuwwMhDfYEdHJyQV1V6KPMDCgFy8lAq8FBZ34h3THbUeFvZudFQsXGmENpCKABLSwas3rsiWnd88i4fvbIuHYfnHFNHxkI6arz+nX1ef0aG4nUqZUAgFYR8Bu99SWrtGJJWDd9/6Buu/+knjo2q3e9au2ilU8BgFbkKuHYgEGgRpNcR8nSjcnbRuxPatayX80qGRzKV+auHXWGfalyd1L9PyfJTZNrGxFwzi+dXemtHGMpne1Fs6tqUsLRmdWWvo1fD9F4G7/xWuSNr4wMq0oz0LwKBnxa2h+qyrICGSdP5WSg1cLcQjoiXGnQi2oFtUMADWgxB4/P6v7HJ3X/rklt2zGh8amoa/qa4Q5dfGaPLjurT2es6myo8gwAgOZnjNHLrx7WqqUd+sDN+/TY/tO6/hM7dOOrx7SB0sAAUBYy0EqTXF/pEo7W9XhDqfH4KkAxxhj1dQV0fHw+db/OLUq0I8eUWmQ6NQEv4xklt1u+r4h0ZmH2+i2WdVhsXDqTZ95K5Cpva2RkZRty27tK/TViA/Mor6kZ2YxNIJCRxBbymO3l3N9rcfpVzUotpXymURoCaECTO3RiTg88Ppn6O3xy3jU94Dfaur5bF5/Zq4vP7NXwQHWu3gAAoJDLzu7Th964QTd+dreOnJrX2z+9U2972WpdeU5/vZsGAE3H1YFDAK2oZCdSLBE4a+QMNKdGHKOt1aSym+hcdOnt9KcCaPX+nKQz0HJOTf3XTlmEQU8BNPdtsenusa+8r8tcwSFXFlMNNkvmIuu9j+bSgE3ypJyg9GJloFVTZgZaKOCt8a73WIP3u2FFRFZWy4fCFS/LXa2giTZOEyCABjSZI6fm9MCuST2we0oP7JrUwcSgmk5rhjt07tounb+xR1vXdysSZkwzAMDiWzca0Uf+ZKP+5gt79PC+af3dl/bqlc+a0SueOdxUV2YCQL05h3yhhGNxyY6jWGJokWQmWiN+9+QqU4ba8aUyWeDU2+XoHqx3AC15m6uEY5tuuICHAFryuyHfcS6176dWsGNaCd8rORdfixKOOQIXwYDR7Jz1tD4WXZNmR/rKiBCln9I8b9SZgRYMGM8XI7kyC2vwfsNBn7aMdVdpaYUzRVE+AmhAg5uejeqXj0/p3h0TunfnhPYfmc2aZ9XSsM5d153461J/N+PMAAAaw0BPUO/7/fX66Df264fbT+gLPzik3Qdn9NaXrFJXBxd4AIAX1hFBa6cMtHJLGib7u2wqA826Hm8kjdimtsB6d+ntTHcP1j2zq0CWoKtEWRttw6CH8ZpMkeBw5uOlZKD5igTIXNOrdJFHrrDO2Wu6NDMfa8iLxN1lLOvWjJJVUha1md6nMwPNy+cpqdYlHKvJ9Tlspo3TBAigAQ0mFrPa8eRp3btzQvfumNDDe6cUjbnnWbEkrHPXdaWCZoM9BMwAAI0rFPTpbS9bpdXDHbrp+wf00wdP6fGnTusdr1jDuGgA4IF1RNDaqSxPuR356RKOiXXXJCUcG719rSC5juseJGowAb/RGas7NTsXq/sFTsbrNmqjTegl4yoS8ml8SuoI5w4OZJVwdI2tWXjZucYjc093ZulUR64xxXq7Auqt0vKrrVkPKeUEiJqzhGP6/1LGHXMFhBv9/TIGWs0QQAMawMxcVPfumNTdD5/Szx+d0MnJBdf03i6/LtjQows29mjrhm4t7WMcMwBAczHG6LevWqb1oxF94OZ9OnB8Tm/91E794a8t169dOsRVcgBQQMyRgdZOAbRyvxr8iSfGrHVl7zX6d02DN681NGHH72IZHax8DJ5qyCo1WGS+VtbXHdCpyQWtWlp822xa1alVyzrUHckdAE0e/3Ktt+Lr0kOpWSPJVu84686mqcoia6oWQcTFUM72asbxOp0ZaKGg9/b7mmi7OtvaRqeKi4IAGlAnR07O6Z5HxnXPw+O6//FJzS+kf9kF/EZnr+nSBRu7dcHGHq0bjbRVqRYAQOu6cFOPPnH9Jr3vy3v14O4pfeJbT+qXe6Z0/W+urPsVzwDQqJwZaO1g+ZKwnjo6q41lZimnSzi6g4+N+JOqWGYHqiuY6EQNNuIYSpCU/pzmuljA9XlZpPbU03nrujW3YNURKp5O4veZvMEzKfv45yqHWekYaInHra1esCsU9GnNSIf8PtM8F44kgojNtHO6Vm0Ll3B0ZlmWlIHWRIFcZ/NKKVOJ4gigAYvo8Mk53fHLk7rjgVN6dP+0a1pvl18Xn9GrSzb36oKNPepswJrOAABUw1BvUO97/Xp9/gcH9ZXbDuv2B05q15PT+stXjGn98ki9mwcADafN4mfatLJTa4Y7SurkcjKpDLT0+Gfxx6vSvKqqoO8SZRgbiWfoDA9Q1aVRDfYGtXJZWEt6s4eqMF4yoVqIz2fUEarOGx3sDerQibnUvu8aA61IgMpL4NJnjKKyVT2OrR1prt8FqSBiMx3NXdvWW7tTJRyb6H0aYxQIGC0sWIUC5WWgNfq3tN9vtGllp6Ixy4WpVUYADaixIyfn9JMHT+n2B07qkSfcQbPVy8K6dHOfLtncqzNWdTbPVTUAAFTI7ze67rmj2jLWpQ/cvE9PHpvTWz+1Q294wXK9kJKOAOCyfElY+4/OaqC7fX7Clxs8k9JXmtuMEo6NWPKtifrmWkI46NOKJY1RqhC5+X1GG5bnzj5tpmyQRtPV4ddFZ6RHEHNloBVZma7DVLF523jDGBlZ2abaN10lClt4DDRJCviMFmQVKuH8opwx4uppOd9vNdE+Z9/AIjo1taDbHzip2+4/oYf2uoNm60Y7dOU5/brynH5O3AEAbe+iM3r18es36X3/uVcP7Z3WJ7/1pO566JTe+tJVjPkJAAnhoE+Xnd3HBXcepTLQYu7yl43Z2dc846sAjaSdAzXV4RgvqVg8wUPg0mekaIHp7SCdmdU8ytlezfT+nEaHwjpyck79JVyMRNAeEgE0oGrm5mO655Fx/XD7Cf3i0XFFY+lpYyMdesY5/brynD6tXNpRv0YCANCAlvaF9P43bNCXbz2k/7z1kLbvnNQfffhR/fGLVuqarf10kACAco8HhNySXxsxa91joDX4OuT7Diis3cZAq6WSMtC8ZOGY+ABg7XwYS733JloHlXwtNtu2XjPcoTXDpfXJ+jjoQATQgIrEYla/2julH20/oTt+eVJTM+mo2chgSM/cOqCrz+vXqmUEzQAAKCTgN3rls0Z08Zm9+uDN+/TEkVl94OZ9+vH9J/Sm31ippf1kowEAvEl1CNp4FpokmfIrQtZUOGjU0+mX328U8NM7B3jVqJ/pZuE82viLrEuT905awGc0r/a+2KM533n5KWjN+X5LU0qgGa2LABpQhicOz+iH20/o1vtO6PDJ+dTj3RG/nnFuv649f0CbV3dyBSEAACXatLJTH3vzJn32+wf033ce1c8endAffvhRve55o3rBxUMNnz0AAKg/53dFNJGC1qgdX8YYXbipt/iMANxjcbVF930NOQMDRc6vnX1b+Y6lG1dGNDEdVW+nvyrNa0rJLLx6t6MEzs3pHDO04HPaKILWoKcOWGQE0ACPJqYX9OP7T+qWe4/rsf2nU48H/EaXnNmrZ54/oIvO6FEowGVQAABUIhz06Q9euEJXntuvj3x9v/YemtEnvvmkfrT9hP7kxSu1fnmk3k0EADQwZ4dXMoBGJxjQAhiPqCaqsS4He4Ia7AlWvqAmlqrg2EQ7p7OlVt4iaMm316gXplSTMUb9PQHNzMbUEaK/t10RQAMKiEattu2Y0A/uPa67HhrXQjT9ZXLWmk5de/6grjynTz2dfJQAAKi2zau79LE3bdTNtx3Wl287rIf3Tev6jz+mF166RK9+zoi6Otr4ClcAQF5+R6fe/EIygNb6HX1Aq3NmnfGRrowz26hY2UVD4NKTZlw3fkfp4HDQW4CoCYd6q8jW9T2y1nIe0cbo9Qdy2HtoRj+497h+uP2ETkwspB4fHgjpWRcM6JnnD2j5ULiOLQQAoD0EAz793rNGdNV5A/rkt/Zr+85Jfeuuo7r9lyf1e9cO63lPG2LMGACAi99v1BHyaWYuponp+O85KgADzc8VyKlfM1qCdUTQisUFnJM5lubXjKvG7zO66IxexWLWe0WtdougiYtw2h0BNCBhYnpBt91/UrdsO64dT6ZLNIaDPl15Tp+efeGgtox1MfYKAAB1sHJpWO993Tr95MFT+vT/PKVj4/P6xCFCoYwAACAASURBVDef1DfvPKrXPW9Ul27u5YcNACClO+LXzFxMJybjATS+IoDWwnlfZWIlZKC5S2ey3vNKlTasbzNK1R0prapHG8bP0OYIoKGtJUs03rLtuO5+2F2i8Zy1XXr2hYO6fEufOsOUiAIAoN6MMbrynH497Yweff2Oo/qv2w9r/5FZvefze3Tmqk698lnDumBjDz/sAQDq6Qzo6Kl5TZ2OSiq9gxBA43Ge4XG6VxlnCcfi8TNH6cwatacVmDZZO8nfWvzmQrsggIa2Y63VrqdO69b7TurW+7NLND77ggFde8GARgYp0QgAQCPqCPn1imuH9fyLB/WFHx7S935+TI88Ma13fma3zlzVqVdcO6yLNhFIA4B2lhkwG+wJ1qklAKqGsbiqJuYq4cgYaNWQXDesI6C1EEBD23jq2KxuSwTN9h+ZTT3eEYqXaHzWBZRoBACgmQz0BPXm31ipl1y5VF++9ZB+uP2EHnliWjfctFtjwx36rSuX6urz+hX0Ws8fANAyegigAS3H5PkfpXNmoBXjzvxjzRfX2uuIQCHaDQE0tLQTE/O6/Zcndet9J/XoE9Opx31G2rqhW1efN6ArtvQpQolGAACa1vKhsP7spav1O9cM68u3HtKt953UnkMz+sevPqHP/u8BPf/iIT3vaUMa6qXzFADaRSjoUyjo09x8TF0RvzpCXEwBNDtn8MZH731FYmVG0Fjt+bVLYCn5fcr3KtoFATS0nOnZqO761Sndet9Jbd81oVgsPe2MlZ26emu/nnFuP1cgAgDQYpKBtNc8Z1TfuvOovn3PUR0bX9AXfnBIX/rRIT39rD49/2lD2rqhu/hg6QCAptfb6dfRUzEuoABaEadyi4bMP29Mxm2rWrkkrL6uQFamN9CqCKChJUzNRPXzR8Z1x4On9ItHxzW3kL6SZsVQSNdsHdDVWwe0YgnjmgEA0OqGeoN67fNG9fJrlumH957Qt+85pr2HZvTTB0/ppw+e0lBvQFefN6Brzx/Q2EgHpWgAoEWtWx5RV4dfq5Z11LspAKrAecrGtVCVWb20Q4dPzGtpf/ELDBgDzZt2WTc+n1FfFyEFtA/2djStqZmo7n7olH7y4Clt2zGheUfQbKAnoKvO7dc1Wwe0cUWEjjEAANpQZ9ivX3/6Er3w0iH9as+Uvn3PMd310CkdG1/Q1+44oq/dcUTLh0K69Kw+Pf2sXm1e3UVmGgC0kM6wX2tHI/VuBoAaoJ+nMqGgT5ed3edxbpO6Yb0XYlw3AFoDATQ0lePj87r7kXHd/dApbd85qYWoO2h2xdl9uuKcfp09RgcYAACIM8Zoy9pubVnbramZqO781Sn9cPsJPfD4pJ46Nqev33FEX7/jiPq6Arr4zB5ddlaftm7ooa4/AABAAzHtUiOvwbTL2F6V8iV+OtAfCbQWAmhoaNZa7Tk0o7sfHtc9D43r0f3TrulDvQFdsaVfV2zp0+Y1BM0AAEBhXR1+PfvCQT37wkGdmJjXPY+M666HxrV954ROTS3olm0ndMu2EwoFjM5a06Vz13fr3LXd2rQyomCAgBoAAEC9JHt8fERyFlU6bsl6L2TNcIcOh+Y02EN3O9BK+ESj4SxErX65e1L3PDyuux8e16ETc67pK5eGdenmXl26uU+bV3fKR9AMAACUYaAnqOc9bUjPe9qQTs9Gde+OCd310LjueWRck6ejum/XpO7bNSlJCgd9OmtNp85b361z1nZrw/KIQkECagAAAIuGTKi6CAbiKzwUZMUXMtgT1GBP8THlADQXAmhoCCcn53Xvjkn9/NFx/fzRcU3NxFLTfEbavKYrETTr1cqlDAANAACqKxL26/It/bp8S7+iUatHnpjWA7sn9cvHJ/XQ3inNzse0feektu+MB9T8vvhVpptWdmrTyk5tXBnR2HBEAT8dCwAAALWQzIAigLa4ImG/zlnXrTAXjwFoQwTQUBcLUatH9k3pF49N6N4dE9rx5GnX9I6QTxdu7NElm3v1tDN61d/NrgoAABaH32909liXzh7r0u9eM6y5hZge2z+tB3ZN6YHdk3pk35Rm560ePzCjxw/M6Hs/Py5JCgWM1o1GtHFlJBVYW7EkTIlpAACAKkiNxVXfZrSloV4yqwC0J6ISWBTWWj1xZFYP7JrU9l2Tum/nhKZnY655hgdCunBTjy45s1db13dTFgkAADSEUMCnLWPd2jLWrVdoWNGo1b4jM3ps/7Qe239aO/ZPa/fBGc0txDPXHnliWtIxSfHSj2PDHVo72qF1oxGtHe3Q2pGIujr89X1TAAAATcqQggYAWCQE0FAT1lodOD6n+3dN6oHHJ3X/45M6MbHgmiccNDp3Xbcu3NSjCzf2asWSECdBAACg4fn9RmtHIlo7EtFzL4o/NrcQ056DyaDatHY8eVr7Ds1odj6mR/dP69H9065ljAyEtG55ROtGOrR2NKKxkQ4N94fkpwQkWoAxZqOk35L0XEkbJQ1LOiHpbkkfttbeWsfmAQCaVPIsia4jAMBiIYCGqliIWj1+4LQe3julh/dN66G9Uzpyat41jzHShuWRVNDs7DVdZJkBAICWEAr4UmUbk2bmYtp7aEaPHzid+tt9cEanZ2M6eGJOB0/M6c5fnUrNH/AbDQ+EtGIopNGhsFYsCWv5UFjLl4S0rD9EKUg0k7+R9HJJD0n6jqTjks6Q9CJJLzLG/Km19qN1bB8AoBklSzhySgQAWCQE0FCyWMzq0Mk5PX5gRo/sm9Ij+6a148lpzc7brHnHRjp03rpunbe+W1vWdqknwi4HAADaQ0fIpzNWdeqMVemgmvM8ancqsDajQyfmtBC1evLorJ48OitpwrWsgN9oZDCk5YMhLekPabAnoKHeoAZ7ghrsDWiwJ6i+rkBDBNmstVqIWs0tWM3OxzS/YDW/YBWNWcVi8duRwbC6I5SxbGHfk/R+a+1254PGmKsk3SLpA8aY/7LWHqhL6wAATSmVgcYoaACARUI0A3lZa3VyckF7D89oz8HE36EZ7Ts0o9Nzsaz5A36jjSsi2ry6S2eu7tQ5a7vU380gowAAAEk+n9HoYFijg2FdfnZf6vGZuagOHJvTU8dm9eSxOT11dFZPHYv/HRtf0ELUav+RWe0/Mpt/2Ubq6vCrK+JXV4df3an/feoM+xUMGPl96b+AP94ev88oGosHvaJRq/modd1fSP0fL1U5Nx/T7IKN387HNJf6P3G7EFMs+1TR5Z2vHHO9f7QWa+1NeR7/sTHmNknPlnSZpK8tYrMAAE0uOewHGWgAgMVCAK2NRWNWE9MLOjGxoEOJMkIHj8dvDyVuZ3IEypKGB0LatDIdMFu/PKJQgJKMAAAApeoI+bV2NKK1o5Gsacng2pPHZvXUsTkdH5/X8Yl5HRuf1/GJBR0fn9fcglXMShOno5o4Ha3DOyjO71MqeEe/V1tL1nlfKDhXgjFmW55JZ1anOQCAZkMADQCwWAigNZHZ+ZiOnpqXtVbWSjGr1P9W8ZJAM/MxTc/EdHouqumZmKZn07enphZ0cnJBJybjt+NTC4plV13M0tvl19rh+OD2a4Y7UredYcruAAAA1Fqh4JoUPx+cmonp+MS8pk5HNTkT1VTy73RUUzMxTc1E01llsXhmWTQWv6AqGrOJjLT4X/J/v98o4DMKBOK3fr9RMGAUDvgUDhmFAj6Fgz6FgiZ+G/ApHDQKBROPB9L/+33pq8bRvowxayRdK2la0u11bg4AoElxRgEAWCwE0JrIzidP6+2f3ln15Qb8Rkv6ghodDGl4IBS/HQxpZCCskcGQejv9dHgAAAA0KGOMuiN+xhRDQzPGhCV9UVJY0p9ba094eZ619sI8y9sm6YLqtRAA0OiSXVP0UQEAFgsBtCaSPlFI/Cl+0uAz8Vtj4oPVR0I+dXb41RmO30ZC8XEv+rr86usOaKA7qP7ugAa6A+rvDqg7QoAMAAAAQJoxZo+kNSU85YvW2lfmWZZf0uclXS7pK5I+WHEDAQBtJ9lz5WP0EADAIiGA1kQ2r+7Ud/7uXIJdAAAAAGptl6SZEuZ/KteDieDZFyS9TNLNkl5prfVQSB4AADe6wwAAi40AWhMhcAYAAABgMVhrr610GcaYoOJlG18m6UuSXm2tjVa6XABAu4r3i9E9BgBYLATQAAAAAABVZYwJKZ5x9mJJn5P0WmttrL6tAgA0s3DQJG6p4QgAWBwE0AAAAAAAVWOMCUv6uqQXSPp3SX9A8AwAUKklfUGdt75b3RF/vZsCAGgTBNAAAAAAANX0z4oHz45KelLSDTnK0d9mrb1tkdsFAGhixhgN9ATr3QwAQBshgAYAAAAAqKa1idslkm4oMN9ttW8KAAAAAJSHABoAAAAAoGqstVfXuw0AAAAAUClG3QQAAAAAAAAAAAAcCKABAAAAAAAAAAAADgTQAAAAAAAAAAAAAAcCaAAAAAAAAAAAAICDsdbWuw0NzxhzLBKJDG7evLneTQEAAABQBQ8//LBOnz593Fo7VO+2oHT8RgMAAABaR6P+PiOA5oExZrekXkl76tyUajkzcftIXVuBWmDbtia2a2tiu7YmtmtrYru2pjFJ49batfVuCErXQL/ROD7AK/YVeMW+Ai/YT+AV+wq8aIT9ZEwN+PuMAFobMsZskyRr7YX1bguqi23bmtiurYnt2prYrq2J7QogH44P8Ip9BV6xr8AL9hN4xb4CL9hP8mMMNAAAAAAAAAAAAMCBABoAAAAAAAAAAADgQAANAAAAAAAAAAAAcCCABgAAAAAAAAAAADgQQAMAAAAAAAAAAAAcjLW23m0AAAAAAAAAAAAAGgYZaAAAAAAAAAAAAIADATQAAAAAAAAAAADAgQAaAAAAAAAAAAAA4EAADQAAAAAAAAAAAHAggAYAAAAAAAAAAAA4EEADAAAAAAAAAAAAHAigAQAAAAAAAAAAAA4E0AAAAAAAAAAAAAAHAmiQMWajMeYvjDE/MsY8YYyZM8YcMsZ80xhzTb3bh/IYY4LGmD81xnzGGHNfYrtaY8zv17tt8MYYs9IY8x/GmKeMMbPGmD3GmA8bYwbq3TaUxxjzUmPMx4wxdxhjxhOfyS/Uu10onzFmyBjz+8aYbxhjdhpjThtjThljfmKMeb0xhnOtJmaMeb8x5oeJ86PTxpjjxpjtxph3GWOG6t0+APXDeVr7Kec8zhhzmTHmO4nvj9PGmAeMMW8xxvgLPOeFxpjbEucTk8aYe4wxr6n+O0ItlHtuyL7Sfso5z2Q/gSQZY16Z+A7K28dXznY3xrzGGPOzxPynEs9/YW3eBWohcT5q8/wdzPMcjitFGGttvduAOjPGfFnSyyU9JOknko5LOkPSiyT5Jf2ptfaj9WshymGM6Zd0InH3kKQ5SaskvcFa+291axg8Mcasl3SnpGWSvinpEUkXS7pG0qOSLrfWHqtfC1EOY8x9ks6TNClpv6QzJX3RWvvKujYMZTPGvFHSpyQdkHSrpH2ShiX9lqQ+SV+T9DLLCVdTMsbMSbpX8XOkw5K6JF0q6SJJT0m61Fr7RP1aCKAeOE9rT6WexxljXqz4ecCMpK8o/jv71xX/rf1Va+3LcjznTZI+JulY4jlzkl4qaaWkD1lr317lt4UqK+fckH2lPZV6nsl+AkkyxqyS9EvF+2u7laOPr5ztboz5oKS3Kf799lVJIUm/I2lQ0puttR+v1XtC9Rhj9kjql/ThHJMnrbUfzJif44oHBNAgY8x1ku631m7PePwqSbdIspLGrLUH6tA8lMkYE5J0raT7rLUHjDE3SnqXCKA1BWPM9yU9R9L11tqPOR7/R0lvlfRpa+0b69U+lMfEs3r3S9op6SrFf1QTQGtixphnKv5j99vW2pjj8RFJP1P8woWXWmu/VqcmogLGmA5r7UyOx98r6R2SPmWt/ePFbxmAeuI8rT2Vch5njOlNzNeneED1F4nHOyT9SNLTJf2utfbLjueMKR6MnZJ0obV2T+LxAUk/l7Re0mXW2rtq8w5RDaWeG7KvtK9SzjPZTyBJxhijeD/tWklfl/R2ZfTxlbPdjTGXSfqppF2SnmatPeFY1jbFj2lnJpeFxpUIoMlaO+ZhXo4rHlFWCLLW3pQZPEs8/mNJtyl+1cFli90uVMZaO2et/S6Bz+aTuKr5OZL2SPpExuR3Kf5F9SpjTNciNw0Vstbeaq3dQTZS67DW/sha+/+cHSSJxw9K+ufE3asXvWGoilydGgk3J243LlZbADQGztPaV4nncS+VtFTSl5MdUollzEh6Z+LuH2U853WSwpI+7uykTHRk/l3iLoHZBlfGuSH7Spsq8TyT/QSSdL2kZ0p6reLnG7mUs92T99+bDJ4lnrNH8XOdcOI10Vo4rnhEAA3FzCduF+raCqC9JMce/N8cP7wmFL8yqFPx8g4AGhffoa3r1xO3D9S1FQDqgfM0ePHMxO33cky7XdK0pMuMMWGPz/luxjxoTrnODdlXkCnXeSb7SZszxmyW9D5JH7HW3l5g1nK2O/tKawknxsl7hzHmT40x1+QZz4zjikeBejcAjcsYs0bxEoDTin9wACyOMxK3j+WZvkPxK583SfrhorQIQEmMMQFJr07czXVyiSZijHm74mMM9Ck+LsUVindqvK+e7QJQF5ynwYu8+4m1dsEYs1vS2ZLWSXrYw3MOGGOmJK00xnRaa6dr0GbUUIFzQ/aVNufxPJP9pI0ljh+fV3xMxXcUmb2k7Z7ImF+h+PhYuSpY7Ujcbiqv9aiDEcX3F6fdxpjXJqrNJXFc8YgAGnJKRJe/qHha5p87U3gB1Fxf4vZUnunJx/sXoS0AyvM+SVskfcda+/16NwYVe7ukYcf970m6zlp7pE7tAVA/nKfBi3L2Ey/P6UrM1zKdUm0k37kh+wq8nGeyn7S3GySdL+kKa+3pIvOWut05r2ktn5F0h6RfSZpQPPj1Jkl/IOm7xpinW2vvT8zLccUjSji2CGPMHmOMLeHvCwWW5Vc8Un25pK9I+uBivQ+4VXO7AgAWhzHmeklvU3xw3VfVuTmoAmvtiLXWKH41328p/kNkuzHmgvq2DAAANDrODVEI55koxBhzieJZZx+y1t5V7/agsVlr350Yi/OQtXbaWvugtfaNkv5RUkTSjfVtYXMiA6117JKUbwDSXJ7K9WAiePYFSS9TfODSV3ocJBm1UZXtiqaTvJKjL8/05OMnF6EtAEpgjHmTpI9IekjStdba43VuEqrIWntI0jeMMfcqXrbic4pfTQ6gfXCeBi/K2U9OSVqSmHaswHPyXfWNBuTh3JB9BZKKnmeyn7ShROnGzym+P/y1x6eVut05r2kP/6z4hRzPcDzGccUjAmgtwlp7baXLMMYEFS/b+DJJX5L0amtttNLlonzV2K5oSo8mbvPVmN6YuM039gaAOjDGvEXSP0l6UPEOksN1bhJqxFq71xjzkKStxpgl1tqj9W4TgEXDeRq8eFTxsYw2SdrmnJDoEF0raUHS4xnPWZJ4zl0ZzxlVvCTS/lYaU6TVeTw3ZF+BS57zTPaT9tSt9PnGjDEm1zz/aoz5V0kfsda+RSVud2vtlDHmSUkrjDGjOcZB47ymNSRLwnY5HuO44hElHCFJMsaEJP2X4sGzz0l6FcEzoG5uTdw+xxjjOk4bY3oUL686LenuxW4YgNyMMX+heAfJfZKuIXjWFpYnbjlfAtoL52nw4keJ2+flmPYMSZ2S7rTWznp8zvMz5kGDK+HckH0FuWSeZ7KftKdZSf+e5297Yp6fJO4ngxnlbHf2ldZ3aeLWGQzjuOIRATTIGBOW9A1JL1b8oPtaa22svq0C2pe1dpek/5U0JulPMia/W/ErOj5vrZ1a5KYByMEY89eKDwy/TfGri8lGagHGmE3GmKxyFsYYnzHmvZKWKf6D4sTitw5AvXCeBo++KumopN8xxlyUfNAY0yHpbxN3P5XxnM8o3ln6JmPMmOM5A4qPfyPFSzChwZV4bsi+0obKOM9kP2lD1trT1trfz/Un6VuJ2T6beOwrifvlbPfk/b9KzJd8zpji5zqzieWigRljNhtjunI8Pibp44m7X3BM4rjikWF4KxhjPiPpOsU/NJ+UlGunuM1ae9siNgtVYIz5v5LOTNzdKuk8SXdK2pF47CfW2n+rR9tQmDFmveLbapmkb0p6WNIlkq5RPHX+MmttrnrDaGDGmN+Q9BuJuyOSnqv4FUB3JB47aq19ez3ahvIYY14j6SbFrw79mHLX+t5jrb1pEZuFKkiUXfp7xa/q3K14jfdhSVcpPrj7QcU7xR6qWyMB1AXnae2p1PO4xPxfVXxM6y9LOi7pRZLOSDz+25njjRtj3izpo4p/53xF0pykl0paKelDnCc2vnLODdlX2k8555nsJ3Ayxtwo6V2S3pDZr1fOdjfGfEjSn0nar/j+FJL0cklDkt5srf145nPQWBL7xNsk3S5pr6QJSesl/ZqkDknfkfSb1to5x3M4rnhAAA0yxtym+Jd0Ie+21t5Y+9agmjxs289aa69bnNagVMaYVZLeo3hq9JCkA4pni76bjIfm5DjJzWevtXZscVqDavCwTSXpx9baq2vfGlSTMWaLpDdKukLxHwP9kqYU7xz/tqSPWmuP16+FAOqJ87T2U855nDHmckl/Jenpinde7ZT0H4p/h+QsAWyM+XVJb5d0geJVgx6S9HFr7WcrfAtYBOWeG7KvtJdyzzPZT5BUKICWmF7ydjfGXKd4xtlZkmKS7pX0AWvt/1S7/ag+Y8xVih9Xzlf8Qp8uSScVLyX8ecUrJGQFgjiuFEcADQAAAAAAAAAAAHBgDDQAAAAAAAAAAADAgQAaAAAAAAAAAAAA4EAADQAAAAAAAAAAAHAggAYAAAAAAAAAAAA4EEADAAAAAAAAAAAAHAigAQAAAAAAAAAAAA4E0AAAAAAAAAAAAAAHAmgAAAAAAAAAAACAAwE0AAAAAAAAAAAAwIEAGgAAAAAAAAAAAOBAAA0AAAAAAAAAAABwIIAGAAAAAAAAAAAAOBBAAwAAAAAAAAAAABwIoAEAAAAAAAAAAAAOBNAAAAAAAAAAAAAABwJoAAAAAAAAAAAAgAMBNAAAAAAAAAAAAMCBABoAAAAAAAAAAADgQAANAAAAAAAAAAAAcCCABgAAAAAAAAAAADgQQAMAAAAAAAAAAAAcAtVakDGmV9L5ki5K/F0oaYMkI0nWWlOt13K85iWS3ijpKkmjkiYl7ZD0VUmfstaervZrAgAAAECj4/cZAAAAAFTGWGursyBjtkvamm96tX+gGWP+RtI7lD+L7jFJL7LWPlrN1wUAAACARsfvMwAAAACoTDVLODp/gJ2SdJukg1VcfvqFjHmbpHcq3v79kv5E0iWSnifpS4nZNkn6rjFmqBZtAAAAAIAGxu8zAAAAAKhANTPQrpd0RNIvJO201lpjzG2Kl++o2hWOxpiVipcB6VD8B+AF1toDGfO8R9JfJ+5+zFp7fTVeGwAAAACaAb/PAAAAAKAyVQug5Vx4bX6gfVDS2xJ3r7PWfjbHPH5Jj0paL2lO0oi19kQ1Xh8AAAAAmhG/zwAAAADAu2qWcFwsL0ncTkr6Sq4ZrLVRSckfbiFJL1qEdgEAAABAu+H3GQAAAICW1FQBNGPMakljibt3W2tnCsx+q+P/q2rWKAAAAABoQ/w+AwAAANDKmiqAJulsx/8PFZnXOf2sGrQFAAAAANoZv88AAAAAtKxmC6Ctdvz/RKEZrbXHJU3neB4AAAAAoHL8PgMAAADQsgL1bkCJehz/T3qYf1JSZ8bz8jLGbMszaUtiWXu8LAcAAABAwxuTNG6tXVvvhjSxmv4+k/iNBgAAALSJMTXg77NmC6BFHP/PeZh/NsfzyuGPRCKDmzdvHqxwOQAAAAAawMMPP6zTp0/XuxnNrl6/zyR+owEAAAAto1F/nzVbAM05KHXIw/zhxK2nNW+tvTDX48aYbZs3b75g27Z8Fz8CAAAAaCYXXnih7r333j31bkeTq+nvM4nfaAAAAEA7aNTfZ802BtqE4/9uD/Mn55koOBcAAAAAoFT8PgMAAADQspotgLbP8f+qQjMaYwYVr6+f+TwAAAAAQOX4fQYAAACgZTVbAO1Xjv/PKjKvc/pDNWgLAAAAALQzfp8BAAAAaFlNFUCz1u6VtDdx91JjTLjA7Nc4/r+9dq0CAAAAgPbD7zMAAAAAraypAmgJX0vcdkv6nVwzGGP8kl6TuDsv6VuL0C4AAAAAaDf8PgMAAADQkhoqgGaMudEYYxN/N+aZ7cOSZhL//70xZjTHPDdIWp/4/1+stcer3FQAAAAAaGn8PgMAAADQzgLVWpAxZoOkKzIeHnFMvy5j2kFr7fdKfR1r7RPGmBsk/YOkUUk/M8b8naRtkvolvVrS7yVm3yvpxlJfAwAAAACaGb/PAAAAAKAyVQugKf7j7DMFpmdO+7Gkkn+gSZK19gPGmEFJfyFppaRP5phtp6QXWWuPlvMaAAAAANDE+H0GAAAAABVoqBKOpbDW/qWkyyV9TtIeSbOSjku6W9LbJZ1nrX24bg0EAAAAgDbB7zMAAAAAraZqGWjW2psk3VThMm5UCSU9rLV3SbqrktcEAAAAgFbD7zMAAAAAqEzTZqABAAAAAAAAAAAAtUAADQAAAAAAAAAAAHAggAYAAAAAAAAAAAA4EEADAAAAAAAAAAAAHAigAQAAAAAAAAAAAA4E0AAAAAAAAAAAAAAHAmgAAAAAAAAAAACAAwE0AAAAAAAAAAAAwIEAGgAAAAAAAAAAAOBAAA0AAAAAAAAAAABwIIAGAAAAAADw/9m7/7BZ6/o+8O9PYEEoKJJEIYpiJF4BtCooJkQUsk1rYjTdjXvFNRs5Rpofa+Kq0RoTzZK4TTY1bdxIiK1QMdnVRsV2q1GzdvVobFAs6FaFitggaIqSSICDwEH57h9zn4tvjs88v2bumWee83pd1/ea+37mO/dnnuHLPPM575l7AACggC1dyAAAIABJREFUI0ADAAAAAACAjgANAAAAAAAAOgI0AAAAAAAA6AjQAAAAAAAAoCNAAwAAAAAAgI4ADQAAAAAAADoCNAAAAAAAAOgI0AAAAAAAAKAjQAMAAAAAAICOAA0AAAAAAAA6AjQAAAAAAADoCNAAAAAAAACgI0ADAAAAAACAjgANAAAAAAAAOgI0AAAAAAAA6AjQAAAAAAAAoCNAAwAAAAAAgI4ADQAAAAAAADoCNAAAAAAAAOgI0AAAAAAAAKAjQAMAAAAAAICOAA0AAAAAAAA6AjQAAAAAAADoCNAAAAAAAACgI0ADAAAAAACAjgANAAAAAAAAOgI0AAAAAAAA6AjQAAAAAAAAoCNAAwAAAAAAgI4ADQAAAAAAADoCNAAAAAAAAOgI0AAAAAAAAKAjQAMAAAAAAICOAA0AAAAAAAA6AjQAAAAAAADoCNAAAAAAAACgI0ADAAAAAACAjgANAAAAAAAAOgI0AAAAAAAA6AjQAAAAAAAAoCNAAwAAAAAAgI4ADQAAAAAAADoCNAAAAAAAAOgI0AAAAAAAAKAjQAMAAAAAAICOAA0AAAAAAAA6AjQAAAAAAADoCNAAAAAAAACgI0ADAAAAAACAjgANAAAAAAAAOgI0AAAAAAAA6AjQAAAAAAAAoCNAAwAAAAAAgI4ADQAAAAAAADoCNAAAAAAAAOgI0AAAAAAAAKAjQAMAAAAAAICOAA0AAAAAAAA6AjQAAAAAAADoCNAAAAAAAACgI0ADAAAAAACAjgANAAAAAAAAOgI0AAAAAAAA6AjQAAAAAAAAoCNAAwAAAAAAgI4ADQAAAAAAADoCNAAAAAAAAOgI0AAAAAAAAKAjQAMAAAAAAICOAA0AAAAAAAA6AjQAAAAAAADozD1Aq6rjq+o1VXV1Vd1aVXdW1eeq6qKqOnUOx99TVW2T41Pz+J0AAABWlR4NAABg6w6f58Gq6uwklyc54aCrHjOMC6rqJa21N86zLgAAAN9KjwYAALA9cwvQquqUJO9J8uAk9yW5OMm7ktyd5Jwkvzxcd3FV3dJau3wOZX86ySfWuf6uOdQAAABYOXo0AACA7ZvnJ9Ben0nzlSQvbK1d1l13RVW9N8nHkxyd5KKqen9r7c4Za/5Fa+0zMx4DAABgN9KjAQAAbNNcvgOtqh6b5JnD7t6DGrMkydBEvW7YPSHJnnnUBgAA4G/TowEAAMxmLgFakud025esM+/SKbcBAABgfvRoAAAAM5hXgPa0bnvvtEmttZuSfGHYPbuqZj6FZFUdW1XfU1UnVdUDZj0eAADALqBHAwAAmMG8ArTTh8vbW2tf3mDuNcPlEUlOmbHuW5PcluS6JDcmuaOqPlZVP69RAwAADmF6NAAAgBnMHKBV1ZFJHjLs3rSJm/RzHjFj+ROTVLd/eJKnJLk4yZVVNWvzBwAAsFL0aAAAALOb+fQcSY7ttvdtYn4/59ips6a7L8mfJnlnkiuS3JDk3iTfleSHkrwyyaOTPC7JB6rqrNbaLZs5cFVdNeWq793G/QQAAFgGPRoAAMCM5nEKx6O67f2bmH/PlNtu1h+11p7RWruktfbZ1tqdrbX9rbUbWmtvSvKEJB8e5p6c5LXbqAEAALCq9GgAAAAzmscn0O7uto/YxPwju+27tlqstdY2uH5fVT0vyfWZNH/nV9VLW2sb1mqtnbnWz4d3PZ6x1fsKAACwBHo0AACAGc3jE2h3dNvHbGJ+P+eOqbNm0Fr7y0xOIZIkD0jy5DHqAAAA7EB6NAAAgBnNHKC11u5OcuD89Q/fxE1O6rZvnLX+Oq7rtk8YsQ4AAMCOoUcDAACY3Tw+gZYknx0uH1RVD9tg7mnD5f5MTuExlsO67W+MWAcAAGCn0aMBAADMYF4B2oe77XOnTaqqk5I8eti9orU2ZtP0+G77yyPWAQAA2Gn0aAAAADOYV4B2ebd9wTrzXthtv3NOtb9FVZ2W5Lxh97YkV41VCwAAYAfSowEAAMxgLgFaa+3TSd477J5bVXsOnlNVpyd5xbD7lSSXrTHnsqpqw1jrGI+qqrPWuy9V9chMmsUDpwd5w8jvogQAANhR9GgAAACzOXyOx3ppkrOTHJfk0qo6I8m7ktyd5Jwkr0pydJKW5MWttX3bqPHIJB+qqquSvDvJJ5PcnOTeJN+V5O9l8g7KY4f5Vyb5re3+QgAAACtMjwYAALBNcwvQWmvXVdWzMjntx0OT/OIwevuTvKy19vYZy505jPW8I8nPtNa+PmMtAACAlaNHAwAA2L55fgItrbWPDqcB+YUk/zDJo5IckckXRH8gyUWttWtmKHFVkucleUqSJ2XyjsZvz+Rdk7cn+Yskf57kLa0159QHAAAOaXo0AACA7ZlrgJYkrbW/TvLrw9jqbfck2bPO9XckedswAAAA2IAeDQAAYOu+bdl3AAAAAAAAAHYSARoAAAAAAAB0BGgAAAAAAADQEaABAAAAAABAR4AGAAAAAAAAHQEaAAAAAAAAdARoAAAAAAAA0BGgAQAAAAAAQEeABgAAAAAAAB0BGgAAAAAAAHQEaAAAAAAAANARoAEAAAAAAEBHgAYAAAAAAAAdARoAAAAAAAB0BGgAAAAAAADQEaABAAAAAABAR4AGAAAAAAAAHQEaAAAAAAAAdARoAAAAAAAA0BGgAQAAAAAAQEeABgAAAAAAAB0BGgAAAAAAAHQEaAAAAAAAANARoAEAAAAAAEBHgAYAAAAAAAAdARoAAAAAAAB0BGgAAAAAAADQEaABAAAAAABAR4AGAAAAAAAAHQEaAAAAAAAAdARoAAAAAAAA0BGgAQAAAAAAQEeABgAAAAAAAB0BGgAAAAAAAHQEaAAAAAAAANARoAEAAAAAAEBHgAYAAAAAAAAdARoAAAAAAAB0BGgAAAAAAADQEaABAAAAAABAR4AGAAAAAAAAHQEaAAAAAAAAdARoAAAAAAAA0BGgAQAAAAAAQEeABgAAAAAAAB0BGgAAAAAAAHQEaAAAAAAAANARoAEAAAAAAEBHgAYAAAAAAAAdARoAAAAAAAB0BGgAAAAAAADQEaABAAAAAABAR4AGAAAAAAAAHQEaAAAAAAAAdARoAAAAAAAA0BGgAQAAAAAAQEeABgAAAAAAAB0BGgAAAAAAAHQEaAAAAAAAANARoAEAAAAAAEBHgAYAAAAAAAAdARoAAAAAAAB0BGgAAAAAAADQEaABAAAAAABAR4AGAAAAAAAAHQEaAAAAAAAAdARoAAAAAAAA0BGgAQAAAAAAQEeABgAAAAAAAB0BGgAAAAAAAHQEaAAAAAAAANARoAEAAAAAAEBHgAYAAAAAAAAdARoAAAAAAAB0BGgAAAAAAADQEaABAAAAAABAR4AGAAAAAAAAHQEaAAAAAAAAdARoAAAAAAAA0BGgAQAAAAAAQEeABgAAAAAAAB0BGgAAAAAAAHTmHqBV1fFV9Zqqurqqbq2qO6vqc1V1UVWdOudaf7+q3l5VN1bV3VV1c1V9sKouqKrD5lkLAABgFenRAAAAtu7weR6sqs5OcnmSEw666jHDuKCqXtJae+OMdQ5L8qYkLzjoqocO47wk/6iqnt1a+8ostQAAAFaVHg0AAGB75vYJtKo6Jcl7MmnM7ktyUZIfTHJ2klcmuTXJkUkurqofn7Hc63N/Y3Ztkj1JzkryY0neP/z8rCTvqaojZ6wFAACwcvRoAAAA2zfPT6C9PsmDh+0XttYu6667oqrem+TjSY5OclFVvb+1dudWi1TVk5O8aNj9TJKzW2t3dNe/O8mbk5yf5EnD3H++1ToAAAArTo8GAACwTXP5BFpVPTbJM4fdvQc1ZkmS1tpnkrxu2D0hk3ckbscrk9Sw/Qt9YzbUaUlenOTAz/9xVc39u94AAAB2Kj0aAADAbObVtDyn275knXmXTrnNplTV0Ul+eNi9vrX24bXmtdZuT/KOYfehSc7Zai0AAIAVpkcDAACYwbwCtKd123unTWqt3ZTkC8Pu2VW11VNIPimT04usW2fwoW776VusAwAAsMr0aAAAADOYV4B2+nB5e2vtyxvMvWa4PCLJKdus0x9nozpJctoW6wAAAKwyPRoAAMAMZg7QqurIJA8Zdm/axE36OY/YYrl+/ka1ZqkDAACwkvRoAAAAs9vq6TnWcmy3vW8T8/s5x06dNXutLdepqqumXPX4a6+9NmeeeeZmDgMAAOxw1157bZKcvOS7MRY9GgAAsDJ2an82jwDtqG57/ybm3zPltvOuNUudg33bXXfd9c2rr776/5vxOLCW7x0u//NS7wW7lfXF2KwxxmR9MabHJzlm2XdiJHo0mI2/P4zJ+mJM1hdjsr4Y047sz+YRoN3dbR+xiflHdtt3jVhry3Vaa2u+ffHAux6nXQ+zsL4Yk/XF2KwxxmR9MaZ1Ptm0G+jRYAbWF2OyvhiT9cWYrC/GtFP7s5m/Ay3JHd32ZhLCfs4dU2fNXmuWOgAAAKtKjwYAADCjmQO01trdSW4Zdh++iZuc1G3fuMVy/fyTps6avQ4AAMBK0qMBAADMbh6fQEuSzw6XD6qqh20w97Thcn+S67dZpz/ORnWS5Jot1gEAAFhlejQAAIAZzCtA+3C3fe60SVV1UpJHD7tXtNa+scU6n8j958qfWmdwXrf9kS3WAQAAWGV6NAAAgBnMK0C7vNu+YJ15L+y237nVIq21ryd537B7SlU9fa15VfXAJM8Zdr+a5M+2WgsAAGCF6dEAAABmUK21+Ryo6k+S/Miw+4LW2mUHXX96kiuTHJ3kK0lOaa3tO2jOZUnOn3aMYc5ZST4+7H46yQ+01u7orq8kb+6O84rW2u9s+xcDAABYQXo0AACA7ZvXJ9CS5KVJ/mbYvrSqfq+qzq2q76uqV2TyDsOjk7QkLz64Mdus1tqVSS4edh+X5ONV9fyqelJVPSvJn+T+xuzqJBdt8/cBAABYZXo0AACAbZrbJ9CSpKqemslpPx46Zcr+JC9rrf3+lNtflg3e3TjMOyzJv0ry/HXuzn9M8qzW2s0b33MAAIDdR48GAACwPfP8BFpaax9NcnqSC5N8KsltmXyh9PVJ/iDJE6c1Zlus883W2vlJfjiTc/t/KZPG75Yke5P8bJLv15gBAACHMj0aAADA9sz1E2gAAAAAAACw6ub6CTQAAAAAAABYdQI0AAAAAAAA6AjQAAAAAAAAoHNIBGhVdXxVvaaqrq6qW6vqzqr6XFVdVFWnzrnW36+qt1fVjVV1d1XdXFUfrKoLquqwedZiZxh7fVXVkVX1I1X1z6rqz6rqq1W1v6pur6prq+rSqnrqPH4Xdp5FPn+tUfvfVFXrxrlj1mM5Fr3GquqMqvrdqvp0VX1t+Ft50/D89k+q6ox512R5FrW+quohVfWrwzr6q6q6t6ruqKprquqSqjp7XrVYrqp6YFU9vap+qareVlXXVdV9B/5WjVTzKVX15qr6L1V1V1XdUlV/XlUvq6qjxqh5KNCjMSY9GmPSozEm/Rlj0p8xht3eo1Vro/wOO8bwP+TlSU6YMuWeJC9prb1xxjqHJXlTkhesM+3KJM9urX1lllrsHGOvr6r6u0k+muTYTUz/4yQ/3Vr7+nZqsfMs6vlrSu3nJnnbQT8+r7W2d961WJ5FrrGqekCS30tyQZJaZ+pbWmt7Zq3H8i3wNdiPJbksyXEbTL0kyc+11r45Sz2Wq6o+meQJ065vra33/LKdeq9N8iuZ/sbD6zJ5ff+5edbd7fRojEmPxpj0aIxJf8aY9GeMZbf3aLv6E2hVdUqS92TyxHBfkouS/GCSs5O8MsmtSY5McnFV/fiM5V6f+xuza5PsSXJWkh9L8v7h52cleU9VHTljLXaABa2vB+b+xuyTSV6b5JlJnpTknEyeLL46XP8TSS6vqrk+KbEcC37+Orj2dyZ5w7DrH5N2qUWuseHdP+9O8o8yac72JvnZTJ7HzkjyQ0n+cZL/kMSL511gUeurqp6U5J25vzn70yTPTfKUJP8gya8NtZLJPw68bru12DH61zm3ZfJ8cvMohap+KcmrM+mZvpTkRZmsrWckeesw7TFJ3ldV3z7GfdiN9GiMSY/GmPRojEl/xpj0Z4xsd/dorbVdOzJ5YmjD2LPG9Y9Ncudw/X9N8ne2WefJmTz5tCSfTnLsQddXJsn7gfvysmU/NsbsYxHrK5M/ZJcneeI6c05I8vnuvvzEsh8bY/axqOevKbX/9XDc9x303HXush8XY35jkWssk3c2tiT3JnnBBnOPWPZjY8w+Fvga7P/u6rx2ypyHZ/IPmQfW4Hcs+/Extj+SvDjJ/5jke3L/2TT2HlgHc6zz8CR3dWv0xDXm/Ea3/n5v2Y/Nqgw9mjHm0KMZYw49mjHm0J8ZYw79mTHm2O092tIf4BH/wz22e7A+tM68C7t5L9pmrXd2x3j6lDkPTHL7MOfmJN+27MfI2P5Y5Pra5P15dlfnXct+fIyZ/3subX1l8o7slmRfkkdqznbnWPDfyDNz/z9g/vqyf3dj/LHg9fXXw+3vWa/JS/KbXa0fXfZjZMx3jNSc/U63Zs6fMuewJNd3a/DBy34sdvrQoxljDj2aMebQoxljDv2ZMebQnxnLGLupR9vNp3B8Trd9yTrzLp1ym02pqqOT/PCwe31r7cNrzWut3Z7kHcPuQzP5WDSrayHraws+2G0/ZsQ6LMZS1ldVHZfkD4bdV7fWvjjrMdmxFrnGfjGTd/nvi9MzHCoWub4OnELrr1prd64z74Zu22na2IwDp67Zl8l3GH2LNvm+hrcMu0dk8o/lrE+Pxpj0aIxJj8aY9GeMSX/GbrGUHm03B2hP67b3TpvUWrspyReG3bOr6vAt1nlSkqM3qjP4ULf99C3WYWdZ1PrarCO6beenXn3LWl+/m+TEJJ/I5JQO7F4LWWPD/AMvvP99a23f8POqqhOq6pSqeuBWjslKWORz2HXD5XdU1d9ZZ94ju+25fJEwu1dVPSLJycPux1prd68z3ev7rdGjMSY9GmPSozEm/Rlj0p+x8pbZo+3mAO304fL21tqXN5h7zXB5RJJTtlmnP85GdZLktC3WYWdZ1PrarPPWqMfqWvj6qqp/kGRPkm8kuaC1dt92j8VKWNQa+7tJDrxo/lRVHV1V/yTJX2ZyvurPJ7mtqj5TVS+tKu882x0W+Rz2L7rb//JaE6rqYZl8QXqSfKS19plt1OHQ4vX9ePRojEmPxpj0aIxJf8aY9GfsBkt7fb8rA7ThCf4hw+5Nm7hJP+cRWyzXz9+o1ix12CEWvL42c38OS/Kq7kdvnXcNFmcZ66uqjk3yL4fd17XW/tN2jsNqWPAae+xB+1cm+ZUkJxz089OT/PMkH6mq79xiDXaQJTyH/X6SNw7br66q91XVT1TVWVX1Q1X16iSfTvKdmZwH/ae3UYNDz6Zf37fWvpbk62vcjoPo0RiTHo0x6dEYk/6MMenP2EWW1qPtygAt959vNZmcE3Mj/Zxjp86avdYsddg5Frm+NuNXM/kS2GTyzo13j1CDxVnG+vrtTP6gfD7Jb2zzGKyORa6x47vtX86kEftYkv82k3c+HpvkmUkO/IPAWUn+uKpqi3XYORb6HNZau6+19vOZrKO9SZ6R5F8n+XiS/yfJazP5jodXJXlya+0LUw4Fve2uY6/v16dHY0x6NMakR2NM+jPGpD9jt1haj7ZbA7Sjuu39m5h/z5TbzrvWLHXYORa5vtZVVf99kguH3VuT/NQ8j89SLHR9VdXTk/zcsPszG5xDmN1hkWvsmG77AZk0Z+e21j7YWvt6a21fa+29SZ6a5Nph3nlJfmyLddg5Fv43sqq+O5PTG33/lCnHJfmfkjxrO8fnkLTddez1/fr0aIxJj8aY9GiMSX/GmPRn7BZL69F2a4DWv7g4Yuqs+/Xn9L1rxFqz1GHnWOT6mqqqzk3yf2Xyzo17kjyntXbjvI7P0ixsfVXVUUkuyWQNXdpa27uV27OylvU3Mkle3lq75+BJrbU7Mjl1yAE/ucU67BwL/RtZVWcn+USS/2G4/UuSPGqofXySH83k3Y6nJ/nDqnrdVmtwSNruOvb6fn16NMakR2NMejTGpD9jTPozdoul9Wi7NUC7o9s+ZuqstefcMXXW7LVmqcPOscj1tabhD9K7M3nH0P4kP95a++A8js3SLXJ9/W+ZfCnszUlevsXbsrqW9Tfyb5L8+Tpz/zSTL0hPJqcKYTUtbH1V1RGZnA7k+ExeTD+ttfZ/tNZuaK3d21q7tbX2J0nOSfKR4WYvr6of2UodDknbXcde369Pj8aY9GiMSY/GmPRnjEl/xm6xtB7t8FkPsBO11u6uqlsy+ULCh2/iJid121t9d1g//6Sps2avww6x4PX1LarqrCTvy+SJ4BtJnjv8AWIXWNT6qqpjMnknUJJ8IMkzppzW/FHd9g9W1YEvF35/a+1vNluPnWPBz2Ff7LZvaq21de7XXVX1V5l8gfVDps1jZ1vw+npGd/v/s7X26Sn36d6q+tUkfzb86IIk791iLQ4tm359X1XHJzl6jdtxED0aY9KjMSY9GmPSnzEm/Rm7yNJ6tF0ZoA0+m+TcJA+qqoe11r68ztzThsv9Sa7fRp2Dj7NRnSS5Zot12FkWtb7+lqo6M5N3AT0wyTeTPK+19m9mOSY70iLW1+G5/1PIP5XNfTfDa7rtJyb51BbqsbMs6jnsM932YZuYf2DON9adxU63qPXVv666aoO5/fWnbrEOhx6v78ejR2NMejTGpEdjTPozxqQ/YzdY2uv73XoKxyT5cLd97rRJVXVSkkcPu1e01rb6R+ETuf9cmlPrDM7rtj8ydRarYFHrqz/WEzJ5F9pxmTRmP9Vae8d2j8eOtvD1xSFnIWustfal3P+i++SqmvrGnao6Lsl3DLvrvaBn51vUc1g//7/ZYG5//b1brMMhprX2xdz/Du3vq6oj15nu9f3W6NEYkx6NMenRGJP+jDHpz1h5y+zRdnOAdnm3fcE6817Ybb9zq0Vaa1/P5FQNSXJKVT19rXlV9cAkzxl2v5r7P6bKalrI+jqgqh6X5N8neXCS+5Kc31p723aPx443+vpqrf1Na602Gkne0t3svO4672xcbYt8Dnv7cHl0Jl8YPM1zMvmy9CTZu81a7AyLWl//pdte8/VX59wpt4NpDqzjY5I8d60JVXVYkvOH3XuT/LsF3K9Vp0djTHo0xqRHY0z6M8akP2O3WE6P1lrbtSPJnyRpw9izxvWnJ7lzuP7mJMesMeey9Y4xzDmrm/Ofkhx70PV10HFevuzHxlip9XVaJg19y+Rdjc9f9u9ujD8Wtb42cT/6Y5y77MfFmN9Y4HPYQ5LcPsz5QpKHrDHn5CRfGebcl+Rxy358jJ2/vpI8KJMvBD7w9/FHp9yX70jyn7tjvWDZj48x9/W298B/303Ov7BbDxdOmXNSJp9gakn+MsmJa8z59e44Fy37cViVscC/P3q0Q3AscH3p0Q7Bsaj1tYn70R/j3GU/LsZ8xgKfv/Rnh+BYxPqK/sz42/+d9x74b7zJ+Rd2a+LCKXOW0qPt5u9AS5KXJjk7k9MpXFpVZyR5V5K7k5yT5FWZvOOiJXlxa23fdoq01q6sqouT/M9JHpfk41X1v2dyjs0Tk/x8kh8epl+d5KJt/0bsJKOvr6r67iT/byZf9pkkv5vk6qp67Do3299au26rtdhxFvL8xSFtUX8jv1pVL0vypiTfneSqqnpdko9l8kn4c5K8Ivc/z/12m/Jlw6yU0ddXa+22qvqNJP80k7X0b6vqzUn+bSanmTkmyQ8k+V8yeT2WTL4X5I9m+L1Ysqo6JclTD/rxCd31ew667ubW2vu3Wqe1dlNV/Vom6+vEJFdW1W9m8n0NxyV5fpKfHKZ/MZOGj83RozEmPRpj0qMxJv0ZY9KfMZpd36MtO41cQNr51EyS8zZl3JPkRevc/rJu7p515h2Wycfop9VpmZyL/4RlPybG6qyvJHs2WFNrjRuW/bgYq7G+Nnkf+mOcu+zHxJjvWOQaS/KS4XjTat2X5LeTfNuyHxdjtdZXJu8w+8Ym/j7+B6/DVn9s47XR3jWOcWF3/YUb1Put4flp2vE/n+TUZT8uqzYW+PygRzsEx9jraxvPQ3q0XTQW9fy1wX3oj3Hush8TY35jkesr+rNDbizw9Zf+7BAb23httHeNY1zYXX/hBvUW2qPt5u9AS5K01j6aycdQL8wk1b4tk4/6XZ/kD5I8sbX2+3Oo883W2vmZvIvx8iRfSrI/yS2ZfGTxZ5N8f2vt5llrsXMsan1xaLK+GNsi11hr7fVJnpDkDUk+l2RfV+uSJGe21l7ZWrtvHvVYvgW+BvtfM/l0yT/L5B/Cb82kYbtzqPXHSf67JOd4HcZWtdZelck7Zf8wyQ2Z/MPC1zJ5l/bLkzy+tXbt0u7gitKjMSavoRmT9cWY9GeMSX/GbrHoHq2G1A4AAAAAAABIdv8n0AAAAAAAAGArBGgAAAAAAADQEaABAAAAAABAR4AGAAAAAAAAHQEaAAAAAAAAdARoAAAAAAAA0BGgAQAAAAAAQEeABgAAAAAAAB0BGgAAAAAAAHQEaAAAAAAAANARoAEAAAAAAEBHgAYAAAAAAAAdARoAAAAAAAB0BGgAAAAAAADQEaABAAAAAABAR4AGAAAAAAAAHQEaAAAAAAAAdARoAAAAAAAA0BGgAQAAAAAAQEeABgAAAAAAAB0BGgAAAAAAAHQEaAAAAAAAANARoAEAAAAAAEBHgAYAAAAAAACdw+d1oKp6YJInJnnSMM5MckqSSpLWWs2rVlfzKUl+LsnTk5yYZF+Szyd5Z5I/aK3dNe+aAAAAO53+DAAAYDbVWpvPgao+meQJ066fd4NWVa9N8iuZ/im665I8u7X2uXnWBQAA2On0ZwAAALOZ5ykc+wbstiR7k9w8x+PfX6jql5K8OpP7/6UkL0rylCTPSPLWYdpjkryvqr59jPsAAACwg+nPAAAAZjBfsdh3AAAgAElEQVTPT6C9OMktSf5jkutba62q9mZy+o65vcOxqh6eyWlAHpBJA3hGa+2/HjTnN5K8Zth9Q2vtxfOoDQAAsAr0ZwAAALOZW4C25sHHadB+J8kvDbt7WmtvWWPOYUk+l+TRSfYnOaG1dus86gMAAKwi/RkAAMDmzfMUjovy48PlviR/vNaE1to3kxxo3I5I8uwF3C8AAIBDjf4MAADYlVYqQKuqRyQ5edj9WGvt7nWmf6jbfvpodwoAAOAQpD8DAAB2s5UK0JKc3m1fs8Hc/vrTRrgvAAAAhzL9GQAAsGsdvuw7sEWP6LZvWm9ia+1rVfX1JEcfdLupquqqKVc9NpNTktywmeMAAAA73slJbm+tPWrZd2SFjdqfJXo0AAA4RJycHdifrVqAdmy3vW8T8/dl0qAdu9HEDRx21FFHHX/qqaceP+NxAACAHeDaa6/NXXfdtey7seqW1Z8lejQAANg1dmp/tmoB2lHd9v5NzL9njdtN1Vo7c62fV9VVp5566hlXXTXtzY8AAMAqOfPMM3P11VffsOz7seJG7c8SPRoAABwKdmp/tmrfgdZ/KfURm5h/5HC586JLAACA1aY/AwAAdq1VC9Du6LaP2cT8A3PuWHcWAAAAW6U/AwAAdq1VC9Bu7LZPWm9iVR2fyfn1D74dAAAAs9OfAQAAu9aqBWif7bZP22Buf/01I9wXAACAQ5n+DAAA2LVWKkBrrX0xyReH3e+rqiPXmX5et/2R8e4VAADAoUd/BgAA7GYrFaANLh8uj0ny3LUmVNVhSc4fdu9N8u8WcL8AAAAONfozAABgV9pRAVpVXVhVbRgXTpn2+iR3D9u/VVUnrjHn15I8etj+l621r835rgIAAOxq+jMAAOBQdvi8DlRVpyR56kE/PqG7fs9B193cWnv/Vuu01m6qql9L8k+TnJjkyqr6zSRXJTkuyfOT/OQw/YtJLtxqDQAAgFWmPwMAAJjN3AK0TJqzN69z/cHXfTjJlhu0JGmtva6qjk/yyiQPT3LxGtOuT/Ls1tpfbacGAADACtOfAQAAzGBHncJxK1prr0ryA0n+MMkNSe5J8rUkH0vy8iSPb61du7Q7CAAAcIjQnwEAALvN3D6B1lq7LMllMx7jwmzhlB6ttSuSXDFLTQAAgN1GfwYAADCblf0EGgAAAAAAAIxBgAYAAAAAAAAdARoAAAAAAAB0BGgAAAAAAADQEaABAAAAAABAR4AGAAAAAAAAHQEaAAAAAAAAdARoAAAAAAAA0BGgAQAAAAAAQEeABgAAAAAAAB0BGgAAAAAAAHQEaAAAAAAAANARoAEAAAAAAEBHgAYAAAAAAAAdARoAAAAAAAB0BGgAAAAAAADQEaABAAAAAABAR4AGAAAAAAAAHQEaAAAAAAAAdARoAAAAAAAA0BGgAQAAAAAAQEeABgAAAAAAAB0BGgAAAAAAAHQEaAAAAAAAANARoAEAAAAAAEBHgAYAAAAAAAAdARoAAAAAAAB0BGgAAAAAAADQEaABAAAAAABAR4AGAAAAAAAAHQEaAAAAAAAAdARoAAAAAAAA0BGgAQAAAAAAQEeABgAAAAAAAB0BGgAAAAAAAHQEaAAAAAAAANARoAEAAAAAAEBHgAYAAAAAAAAdARoAAAAAAAB0BGgAAAAAAADQEaABAAAAAABAR4AGAAAAAAAAHQEaAAAAAAAAdARoAAAAAAAA0BGgAQAAAAAAQEeABgAAAAAAAB0BGgAAAAAAAHQEaAAAAAAAANARoAEAAAAAAEBHgAYAAAAAAAAdARoAAAAAAAB0BGgAAAAAAADQEaABAAAAAABAR4AGAAAAAAAAHQEaAAAAAAAAdARoAAAAAAAA0BGgAQAAAAAAQEeABgAAAAAAAB0BGgAAAAAAAHQEaAAAAAAAANARoAEAAAAAAEBHgAYAAAAAAAAdARoAAAAAAAB0BGgAAAAAAADQEaABAAAAAABAR4AGAAAAAAAAHQEaAAAAAAAAdARoAAAAAAAA0BGgAQAAAAAAQEeABgAAAAAAAB0BGgAAAAAAAHQEaAAAAAAAANARoAEAAAAAAEBHgAYAAAAAAAAdARoAAAAAAAB0BGgAAAAAAADQEaABAAAAAABAR4AGAAAAAAAAHQEaAAAAAAAAdARoAAAAAAAA0BGgAQAAAAAAQEeABgAAAAAAAJ25B2hVdXxVvaaqrq6qW6vqzqr6XFVdVFWnzuH4e6qqbXJ8ah6/EwAAwKrSowEAAGzd4fM8WFWdneTyJCccdNVjhnFBVb2ktfbGedYFAADgW+nRAAAAtmduAVpVnZLkPUkenOS+JBcneVeSu5Ock+SXh+surqpbWmuXz6HsTyf5xDrX3zWHGgAAACtHjwYAALB98/wE2uszab6S5IWttcu6666oqvcm+XiSo5NcVFXvb63dOWPNv2itfWbGYwAAAOxGejQAAIBtmst3oFXVY5M8c9jde1BjliQZmqjXDbsnJNkzj9oAAAD8bXo0AACA2cwlQEvynG77knXmXTrlNgAAAMyPHg0AAGAG8wrQntZt7502qbV2U5IvDLtnV9XMp5CsqmOr6nuq6qSqesCsxwMAANgF9GgAAAAzmFeAdvpweXtr7csbzL1muDwiySkz1n1rktuSXJfkxiR3VNXHqurnNWoAAMAhTI8GAAAwg5kDtKo6MslDht2bNnGTfs4jZix/YpLq9g9P8pQkFye5sqpmbf4AAABWih4NAABgdjOfniPJsd32vk3M7+ccO3XWdPcl+dMk70xyRZIbktyb5LuS/FCSVyZ5dJLHJflAVZ3VWrtlMweuqqumXPW927ifAAAAy6BHAwAAmNE8TuF4VLe9fxPz75ly2836o9baM1prl7TWPttau7O1tr+1dkNr7U1JnpDkw8Pck5O8dhs1AAAAVpUeDQAAYEbz+ATa3d32EZuYf2S3fddWi7XW2gbX76uq5yW5PpPm7/yqemlrbcNarbUz1/r58K7HM7Z6XwEAAJZAjwYAADCjeXwC7Y5u+5hNzO/n3DF11gxaa3+ZySlEkuQBSZ48Rh0AAIAdSI8GAAAwo5kDtNba3UkOnL/+4Zu4yUnd9o2z1l/Hdd32CSPWAQAA2DH0aAAAALObxyfQkuSzw+WDquphG8w9bbjcn8kpPMZyWLf9jRHrAAAA7DR6NAAAgBnMK0D7cLd97rRJVXVSkkcPu1e01sZsmh7fbX95xDoAAAA7jR4NAABgBvMK0C7vti9YZ94Lu+13zqn2t6iq05KcN+zeluSqsWoBAADsQHo0AACAGcwlQGutfTrJe4fdc6tqz8Fzqur0JK8Ydr+S5LI15lxWVW0Yax3jUVV11nr3paoemUmzeOD0IG8Y+V2UAAAAO4oeDQAAYDaHz/FYL01ydpLjklxaVWckeVeSu5Ock+RVSY5O0pK8uLW2bxs1HpnkQ1V1VZJ3J/lkkpuT3Jvku5L8vUzeQXnsMP/KJL+13V8IAABghenRAAAAtmluAVpr7bqqelYmp/14aJJfHEZvf5KXtdbePmO5M4exnnck+ZnW2tdnrAUAALBy9GgAAADbN89PoKW19tHhNCC/kOQfJnlUkiMy+YLoDyS5qLV2zQwlrkryvCRPSfKkTN7R+O2ZvGvy9iR/keTPk7ylteac+gAAwCFNjwYAALA9cw3QkqS19tdJfn0YW73tniR71rn+jiRvGwYAAAAb0KMB8P+3d/fRst1lfcC/D6GJxCSEFEJYEERMWYWAvCREiYTc0KXyzmpJF7QWEiQWLS0FBBEBG6HaUlQohpeWpATbirxEbXm1tXB5USCUSAWJQHABARteSiAv5A3y6x977ro/r2fOPXNm9sw5cz+ftX5r9j7zm/3MmfvcPfs5z549AMDsbrPqJwAAAAAAAAA7iQYaAAAAAAAAdDTQAAAAAAAAoKOBBgAAAAAAAB0NNAAAAAAAAOhooAEAAAAAAEBHAw0AAAAAAAA6GmgAAAAAAADQ0UADAAAAAACAjgYaAAAAAAAAdDTQAAAAAAAAoKOBBgAAAAAAAB0NNAAAAAAAAOhooAEAAAAAAEBHAw0AAAAAAAA6GmgAAAAAAADQ0UADAAAAAACAjgYaAAAAAAAAdDTQAAAAAAAAoKOBBgAAAAAAAB0NNAAAAAAAAOhooAEAAAAAAEBHAw0AAAAAAAA6GmgAAAAAAADQ0UADAAAAAACAjgYaAAAAAAAAdDTQAAAAAAAAoKOBBgAAAAAAAB0NNAAAAAAAAOhooAEAAAAAAEBHAw0AAAAAAAA6GmgAAAAAAADQ0UADAAAAAACAjgYaAAAAAAAAdDTQAAAAAAAAoKOBBgAAAAAAAB0NNAAAAAAAAOhooAEAAAAAAEBHAw0AAAAAAAA6GmgAAAAAAADQ0UADAAAAAACAjgYaAAAAAAAAdDTQAAAAAAAAoKOBBgAAAAAAAB0NNAAAAAAAAOhooAEAAAAAAEBHAw0AAAAAAAA6GmgAAAAAAADQ0UADAAAAAACAjgYaAAAAAAAAdDTQAAAAAAAAoKOBBgAAAAAAAB0NNAAAAAAAAOhooAEAAAAAAEBHAw0AAAAAAAA6GmgAAAAAAADQ0UADAAAAAACAjgYaAAAAAAAAdDTQAAAAAAAAoKOBBgAAAAAAAB0NNAAAAAAAAOhooAEAAAAAAEBHAw0AAAAAAAA6GmgAAAAAAADQ0UADAAAAAACAjgYaAAAAAAAAdDTQAAAAAAAAoKOBBgAAAAAAAB0NNAAAAAAAAOhooAEAAAAAAEBHAw0AAAAAAAA6GmgAAAAAAADQ0UADAAAAAACAjgYaAAAAAAAAdDTQAAAAAAAAoKOBBgAAAAAAAB0NNAAAAAAAAOhooAEAAAAAAEBHAw0AAAAAAAA6GmgAAAAAAADQ0UADAAAAAACAjgYaAAAAAAAAdBbeQKuq46rqxVV1WVVdXVXXV9VnquqCqrr3gmP9RFW9paq+VFU3VtVVVfXeqjqvqg5bZCwAAIDdSI0GAAAwu9sucmNVdXqSS5KccMBd95qM86rqWa21180Z57Akr0/y1APuuvNknJXkZ6rqca21r84TCwAAYLdSowEAAGzPwj6BVlUnJXlHhsLs1iQXJHl4ktOTPD/J1UmOSPKaqnrCnOFemf2F2eVJzk1yWpLHJ3nP5OenJXlHVR0xZywAAIBdR40GAACwfYv8BNork9xhsvy01trF3X0frqp3JflokiOTXFBV72mtXT9rkKp6cJJnTFY/leT01tq13f1vT/KGJOckOXUy9zdnjQMAALDLqdEAAAC2aSGfQKuq+yZ59GR17wGFWZKktfapJC+frJ6Q4YzE7Xh+kpos//O+MJvEaUmemWTfz3+hqhb+XW8AAAA7lRoNAABgPosqWs7uli/cZN5FUx6zJVV1ZJJHTlavaK29f6N5rbVrkrx1snrnJGfMGgsAAGAXU6MBAADMYVENtId1y3unTWqtXZnk85PV06tq1ktInprh8iKbxpl4X7d85oxxAAAAdjM1GgAAwBwW1UA7eXJ7TWvtKweZ++nJ7eFJTtpmnH47B4uTJPeZMQ4AAMBupkYDAACYw9wNtKo6Isnxk9Urt/CQfs7dZwzXzz9YrHniAAAA7EpqNAAAgPnNenmOjRzdLV+3hfn9nKOnzpo/1sxxqurjU+66/+WXX55TTjllK5sBAAB2uMsvvzxJ7rHipzEWNRoAALBr7NT6bBENtNt1yzdvYf5NUx676FjzxDnQbW644YbvXXbZZf9nzu3ARv7u5PYvVvosWFfyi7HJMcYkvxjT/ZMcteonMRI1GszH+w9jkl+MSX4xJvnFmHZkfbaIBtqN3fLhW5h/RLd8w4ixZo7TWtvw9MV9Zz1Oux/mIb8Yk/xibHKMMckvxrTJJ5vWgRoN5iC/GJP8YkzyizHJL8a0U+uzub8DLcm13fJWOoT9nGunzpo/1jxxAAAAdis1GgAAwJzmbqC11m5M8vXJ6t228JATu+UvzRiun3/i1FnzxwEAANiV1GgAAADzW8Qn0JLkzye3t6+qux5k7n0mtzcnuWKbcfrtHCxOknx6xjgAAAC7mRoNAABgDotqoL2/W94zbVJVnZjkhyarH26tfXfGOB/L/mvlT40zcVa3/IEZ4wAAAOxmajQAAIA5LKqBdkm3fN4m857WLb9t1iCtte8kefdk9aSqOnOjeVV1TJKzJ6tfS/LBWWMBAADsYmo0AACAOVRrbTEbqnpnkkdNVp/aWrv4gPtPTnJpkiOTfDXJSa216w6Yc3GSc6ZtYzLntCQfnax+MsmPtdau7e6vJG/otvO81tqvb/sXAwAA2IXUaAAAANu3qE+gJcmzk3xrsnxRVb2qqvZU1Y9W1fMynGF4ZJKW5JkHFmZb1Vq7NMlrJqv3S/LRqnpKVZ1aVY9N8s7sL8wuS3LBNn8fAACA3UyNBgAAsE0L+wRaklTVQzNc9uPOU6bcnOQ5rbVXT3n8xTnI2Y2TeYcl+U9JnrLJ0/nfSR7bWrvq4M8cAABg/ajRAAAAtmeRn0BLa+1DSU5Ocn6STyT5doYvlL4iyWuTPHBaYTZjnO+11s5J8sgM1/b/cobC7+tJ9iZ5epKHKMwAAIBDmRoNAABgexb6CTQAAAAAAADY7Rb6CTQAAAAAAADY7TTQAAAAAAAAoKOBBgAAAAAAAJ1DooFWVcdV1Yur6rKqurqqrq+qz1TVBVV17wXH+omqektVfamqbqyqq6rqvVV1XlUdtshY7Axj51dVHVFVj6qq36iqD1bV16rq5qq6pqour6qLquqhi/hd2HmWuf/aIPbvV1Xrxp4x47Eay86xqnpQVb2iqj5ZVd+cvFdeOdm//WpVPWjRMVmdZeVXVR1fVS+c5NE3quqWqrq2qj5dVRdW1emLisVqVdUxVXVmVf18Vb2pqj5bVbfue68aKeaPVNUbquovq+qGqvp6Vf1JVT2nqm43RsxDgRqNManRGJMajTGpzxiT+owxrHuNVq2N8jvsGJP/kJckOWHKlJuSPKu19ro54xyW5PVJnrrJtEuTPK619tV5YrFzjJ1fVfXDST6U5OgtTH9zkp9urX1nO7HYeZa1/5oS+0lJ3nTAj89qre1ddCxWZ5k5VlXfl+RVSc5LUptMfWNr7dx547F6SzwGe3ySi5Mce5CpFyb52dba9+aJx2pV1Z8mecC0+1trm+1fthPvpUl+KdNPPPxshuP7zywy7rpTozEmNRpjUqMxJvUZY1KfMZZ1r9HW+hNoVXVSkndk2DHcmuSCJA9PcnqS5ye5OskRSV5TVU+YM9wrs78wuzzJuUlOS/L4JO+Z/Py0JO+oqiPmjMUOsKT8Oib7C7M/TfLSJI9OcmqSMzLsLL42uf+JSS6pqoXulFiNJe+/Dox9pyS/NVn1x6Q1tcwcm5z98/YkP5OhONub5OkZ9mMPSvLjSX4hyR8ncfC8BpaVX1V1apK3ZX9x9odJnpTkR5L8ZJJfnsRKhj8OvHy7sdgx+uOcb2fYn1w1SqCqn0/yogw105eTPCNDbj0iye9Mpt0rybur6m+P8RzWkRqNManRGJMajTGpzxiT+oyRrXeN1lpb25Fhx9Am49wN7r9vkusn9//fJN+/zTgPzrDzaUk+meToA+6vDJ33fc/lOat+bYz5xzLyK8Mb2SVJHrjJnBOSfK57Lk9c9WtjzD+Wtf+aEvt3J9t99wH7rj2rfl2MxY1l5liGMxtbkluSPPUgcw9f9WtjzD+WeAz237o4L50y524Z/pC5LwfvuOrXx9j+SPLMJP8oyd/J/qtp7N2XBwuMc7ckN3Q5epcN5ryky79Xrfq12S1DjWaMOdRoxphDjWaMOdRnxphDfWaMOda9Rlv5CzziP9x9uxfrfZvMO7+b94xtxnpbt40zp8w5Jsk1kzlXJbnNql8jY/tjmfm1xefzuC7O76369THm/vdcWX5lOCO7JbkuyQ8oztZzLPk98pTs/wPmr6z6dzfGH0vOr/83efxNmxV5SX6ti/WYVb9GxmLHSMXZr3c5c86UOYcluaLLwTus+rXY6UONZow51GjGmEONZow51GfGmEN9ZqxirFONts6XcDy7W75wk3kXTXnMllTVkUkeOVm9orX2/o3mtdauSfLWyeqdM3wsmt1rKfk1g/d2y/caMQ7LsZL8qqpjk7x2svqi1toX590mO9Yyc+xfZDjL/7q4PMOhYpn5te8SWt9orV2/ybwvdMsu08ZW7Lt0zXUZvsPob2jD9zW8cbJ6eIY/lrM5NRpjUqMxJjUaY1KfMSb1GetiJTXaOjfQHtYt7502qbV2ZZLPT1ZPr6rbzhjn1CRHHizOxPu65TNnjMPOsqz82qrDu2XXp979VpVfr0hylyQfy3BJB9bXUnJsMn/fgfcftdaum/y8quqEqjqpqo6ZZZvsCsvch312cnvHqvr+Teb9QLe8kC8SZn1V1d2T3GOy+pHW2o2bTHd8Pxs1GmNSozEmNRpjUp8xJvUZu94qa7R1bqCdPLm9prX2lYPM/fTk9vAkJ20zTr+dg8VJkvvMGIedZVn5tVVnbRCP3Wvp+VVVP5nk3CTfTXJea+3W7W6LXWFZOfbDSfYdNH+iqo6sql9N8lcZrlf9uSTfrqpPVdWzq8qZZ+thmfuw/9A9/hc3mlBVd83wBelJ8oHW2qe2EYdDi+P78ajRGJMajTGp0RiT+owxqc9YBys7vl/LBtpkB3/8ZPXKLTykn3P3GcP18w8Wa5447BBLzq+tPJ/Dkryg+9HvLDoGy7OK/Kqqo5P8x8nqy1trf7ad7bA7LDnH7nvA+qVJfinJCQf8/OQkv5nkA1V1pxljsIOsYB/26iSvmyy/qKreXVVPrKrTqurHq+pFST6Z5E4ZroP+09uIwaFny8f3rbVvJvnOBo/jAGo0xqRGY0xqNMakPmNM6jPWyMpqtLVsoGX/9VaT4ZqYB9PPOXrqrPljzROHnWOZ+bUVL8zwJbDJcObG20eIwfKsIr9eluEN5XNJXrLNbbB7LDPHjuuWfzFDIfaRJH8vw5mPRyd5dJJ9fxA4Lcmbq6pmjMPOsdR9WGvt1tbaz2XIo71JHpHkd5N8NMn/SPLSDN/x8IIkD26tfX7KpqC33Tx2fL85NRpjUqMxJjUaY1KfMSb1GetiZTXaujbQbtct37yF+TdNeeyiY80Th51jmfm1qar6B0nOn6xeneTJi9w+K7HU/KqqM5P87GT1nx7kGsKsh2Xm2FHd8vdlKM72tNbe21r7Tmvtutbau5I8NMnlk3lnJXn8jHHYOZb+HllV98xweaOHTJlybJJ/kuSx29k+h6Tt5rHj+82p0RiTGo0xqdEYk/qMManPWBcrq9HWtYHWH1wcPnXWfv01fW8YMdY8cdg5lplfU1XVniT/NcOZGzclObu19qVFbZ+VWVp+VdXtklyYIYcuaq3tneXx7Fqreo9Mkue21m46cFJr7doMlw7Z56dmjMPOsdT3yKo6PcnHkvzDyeOfleQHJ7GPS/KYDGc7npzkt6vq5bPG4JC03Tx2fL85NRpjUqMxJjUaY1KfMSb1GetiZTXaujbQru2Wj5o6a+M5106dNX+seeKwcywzvzY0eUN6e4Yzhm5O8oTW2nsXsW1Wbpn59a8zfCnsVUmeO+Nj2b1W9R75rSR/ssncP8zwBenJcKkQdqel5VdVHZ7hciDHZTiYflhr7d+31r7QWrultXZ1a+2dSc5I8oHJw55bVY+aJQ6HpO3mseP7zanRGJMajTGp0RiT+owxqc9YFyur0W477wZ2otbajVX19QxfSHi3LTzkxG551rPD+vknTp01fxx2iCXn199QVacleXeGHcF3kzxp8gbEGlhWflXVURnOBEqS/5nkEVMua/6D3fLDq2rflwu/p7X2ra3GY+dY8j7si93yla21tsnzuqGqvpHhC6yPnzaPnW3J+fWI7vH/pbX2ySnP6ZaqemGSD05+dF6Sd80Yi0PLlo/vq+q4JEdu8DgOoEZjTGo0xqRGY0zqM8akPmONrKxGW8sG2sSfJ9mT5PZVddfW2lc2mXufye3NSa7YRpwDt3OwOEny6RnjsLMsK7/+mqo6JcNZQMck+V6Sf9xa+/15tsmOtIz8um32fwr5ydnadzO8uFt+YJJPzBCPnWVZ+7BPdcuHbWH+vjnf3XQWO92y8qs/rvr4Qeb29997xjgcehzfj0eNxpjUaIxJjcaY1GeMSX3GOljZ8f26XsIxSd7fLe+ZNqmqTkzyQ5PVD7fWZn1T+Fj2X0tzapyJs7rlD0ydxW6wrPzqt/WADGehHZuhMHtya+2t290eO9rS84tDzlJyrLX25ew/6L5HVU09caeqjk1yx8nqZgf07HzL2of18//WQeb2998yYxwOMa21L2b/Gdo/WlVHbDLd8f1s1GiMSY3GmNRojEl9xpjUZ+x6q6zR1rmBdkm3fN4m857WLb9t1iCtte9kuFRDkpxUVWduNK+qjkly9mT1a9n/MVV2p6Xk1z5Vdb8kf5TkDkluTXJOa+1N290eO97o+dVa+1ZrrQ42kryxe9hZ3X3ObNzdlrkPe8vk9sgMXxg8zdkZviw9SfZuMxY7w7Ly6y+75Q2Pvzp7pjwOptmXx0cledJGE6rqsCTnTFZvSfLfl/C8djs1GmNSozEmNRpjUp8xJvUZ62I1NVprbW1HkncmaZNx7gb3n5zk+sn9VyU5aoM5F2+2jcmc07o5f5bk6APurwO289xVvzbGrsqv+2Qo6FuGsxqfsurf3Rh/LCu/tvA8+m3sWfXrYixuLHEfdnySayZzPp/k+A3m3CPJVydzbk1yv1W/PsbOz68kt8/whcD73h8fM+W53DHJX3TbeuqqXx9j4fm2d9+/7xbnn9/lw/lT5pyY4RNMLclfJbnLBnN+pdvOBat+HXbLWOL7jxrtEBxLzC812iE4lpVfW3ge/Tb2rPp1MRYzlrj/Up8dgmMZ+RX1mfHX/5337vs33uL887ucOH/KnJXUaOv8HTvd9HQAAANeSURBVGhJ8uwkp2e4nMJFVfWgJL+X5MYkZyR5QYYzLlqSZ7bWrttOkNbapVX1miT/LMn9kny0qv5thmts3iXJzyV55GT6ZUku2PZvxE4yen5V1T2T/K8MX/aZJK9IcllV3XeTh93cWvvsrLHYcZay/+KQtqz3yK9V1XOSvD7JPZN8vKpenuQjGT4Jf0aS52X/fu5lbcqXDbOrjJ5frbVvV9VLkvy7DLn0B1X1hiR/kOEyM0cl+bEk/zLD8VgyfC/If57j92LFquqkJA894McndPefe8B9V7XW3jNrnNbalVX1yxny6y5JLq2qX8vwfQ3HJnlKkp+aTP9ihoKPrVGjMSY1GmNSozEm9RljUp8xmrWv0VbdjVxCt/OhGTrnbcq4KckzNnn8xd3cczeZd1iGj9FPi9MyXIv/hFW/Jsbuya8k5x4kpzYaX1j162Lsjvza4nPot7Fn1a+JsdixzBxL8qzJ9qbFujXJy5LcZtWvi7G78ivDGWbf3cL74x87Dtv9YxvHRns32Mb53f3nHyTev5nsn6Zt/3NJ7r3q12W3jSXuH9Roh+AYO7+2sR9So63RWNb+6yDPod/GnlW/JsbixjLzK+qzQ24s8fhLfXaIjW0cG+3dYBvnd/eff5B4S63R1vk70JIkrbUPZfgY6vkZutrfzvBRvyuSvDbJA1trr15AnO+11s7JcBbjJUm+nOTmJF/P8JHFpyd5SGvtqnljsXMsK784NMkvxrbMHGutvTLJA5L8VpLPJLmui3VhklNaa89vrd26iHis3hKPwf5Vhk+X/EaGP4RfnaFgu34S681J/n6SMxyHMavW2gsynCn720m+kOEPC9/McJb2c5Pcv7V2+cqe4C6lRmNMjqEZk/xiTOozxqQ+Y10su0arSdcOAAAAAAAASNb/E2gAAAAAAAAwCw00AAAAAAAA6GigAQAAAAAAQEcDDQAAAAAAADoaaAAAAAAAANDRQAMAAAAAAICOBhoAAAAAAAB0NNAAAAAAAACgo4EGAAAAAAAAHQ00AAAAAAAA6GigAQAAAAAAQEcDDQAAAAAAADoaaAAAAAAAANDRQAMAAAAAAICOBhoAAAAAAAB0NNAAAAAAAACgo4EGAAAAAAAAHQ00AAAAAAAA6GigAQAAAAAAQOf/AzBZV3tYGeGSAAAAAElFTkSuQmCC\n",
+            "text/plain": [
+              "<Figure size 864x432 with 6 Axes>"
+            ]
+          },
+          "metadata": {
+            "tags": [],
+            "image/png": {
+              "width": 872,
+              "height": 440
+            },
+            "needs_background": "light"
+          }
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "5IvUIewy-v1E",
+        "colab_type": "code",
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 191
+        },
+        "outputId": "ca96e3b2-822d-437c-fb31-129584e09ae5"
+      },
+      "source": [
+        "az.summary(t)\n"
+      ],
+      "execution_count": 103,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "text": [
+            "arviz.stats.stats_utils - WARNING - Shape validation failed: input_shape: (1, 500), minimum_shape: (chains=2, draws=4)\n",
+            "arviz.stats.stats_utils - WARNING - Shape validation failed: input_shape: (1, 500), minimum_shape: (chains=2, draws=4)\n",
+            "arviz.stats.stats_utils - WARNING - Shape validation failed: input_shape: (1, 500), minimum_shape: (chains=2, draws=4)\n"
+          ],
+          "name": "stderr"
+        },
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/html": [
+              "<div>\n",
+              "<style scoped>\n",
+              "    .dataframe tbody tr th:only-of-type {\n",
+              "        vertical-align: middle;\n",
+              "    }\n",
+              "\n",
+              "    .dataframe tbody tr th {\n",
+              "        vertical-align: top;\n",
+              "    }\n",
+              "\n",
+              "    .dataframe thead th {\n",
+              "        text-align: right;\n",
+              "    }\n",
+              "</style>\n",
+              "<table border=\"1\" class=\"dataframe\">\n",
+              "  <thead>\n",
+              "    <tr style=\"text-align: right;\">\n",
+              "      <th></th>\n",
+              "      <th>mean</th>\n",
+              "      <th>sd</th>\n",
+              "      <th>hdi_3%</th>\n",
+              "      <th>hdi_97%</th>\n",
+              "      <th>mcse_mean</th>\n",
+              "      <th>mcse_sd</th>\n",
+              "      <th>ess_mean</th>\n",
+              "      <th>ess_sd</th>\n",
+              "      <th>ess_bulk</th>\n",
+              "      <th>ess_tail</th>\n",
+              "      <th>r_hat</th>\n",
+              "    </tr>\n",
+              "  </thead>\n",
+              "  <tbody>\n",
+              "    <tr>\n",
+              "      <th>amplitude[0]</th>\n",
+              "      <td>0.771</td>\n",
+              "      <td>0.968</td>\n",
+              "      <td>-1.115</td>\n",
+              "      <td>2.487</td>\n",
+              "      <td>0.036</td>\n",
+              "      <td>0.030</td>\n",
+              "      <td>718.0</td>\n",
+              "      <td>505.0</td>\n",
+              "      <td>728.0</td>\n",
+              "      <td>450.0</td>\n",
+              "      <td>NaN</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>sigma[0]</th>\n",
+              "      <td>77.531</td>\n",
+              "      <td>9.679</td>\n",
+              "      <td>60.331</td>\n",
+              "      <td>97.149</td>\n",
+              "      <td>0.996</td>\n",
+              "      <td>0.706</td>\n",
+              "      <td>94.0</td>\n",
+              "      <td>94.0</td>\n",
+              "      <td>105.0</td>\n",
+              "      <td>70.0</td>\n",
+              "      <td>NaN</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>mu[0]</th>\n",
+              "      <td>9.089</td>\n",
+              "      <td>1.005</td>\n",
+              "      <td>7.189</td>\n",
+              "      <td>10.855</td>\n",
+              "      <td>0.035</td>\n",
+              "      <td>0.025</td>\n",
+              "      <td>837.0</td>\n",
+              "      <td>837.0</td>\n",
+              "      <td>950.0</td>\n",
+              "      <td>291.0</td>\n",
+              "      <td>NaN</td>\n",
+              "    </tr>\n",
+              "  </tbody>\n",
+              "</table>\n",
+              "</div>"
+            ],
+            "text/plain": [
+              "                mean     sd  hdi_3%  hdi_97%  ...  ess_sd  ess_bulk  ess_tail  r_hat\n",
+              "amplitude[0]   0.771  0.968  -1.115    2.487  ...   505.0     728.0     450.0    NaN\n",
+              "sigma[0]      77.531  9.679  60.331   97.149  ...    94.0     105.0      70.0    NaN\n",
+              "mu[0]          9.089  1.005   7.189   10.855  ...   837.0     950.0     291.0    NaN\n",
+              "\n",
+              "[3 rows x 11 columns]"
+            ]
+          },
+          "metadata": {
+            "tags": []
+          },
+          "execution_count": 103
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "9-PD2K2kEQ1L",
+        "colab_type": "code",
+        "colab": {}
+      },
+      "source": [
+        ""
+      ],
+      "execution_count": null,
+      "outputs": []
+    }
+  ]
+}
\ No newline at end of file