{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", " \n", "
\n", "\n", "# Ctypes Example\n", "Author(s): Paul Miles, Joel Kulesza | Date Created: June 28, 2018\n", "\n", "**Note, this tutorial is useful for illustrative purposes. However, compiling the C++ code in Binder is non-trivial, so this is recommended as a Read-Only example.**\n", "\n", "In this example, we demonstrate how to use a model written in C++ within the context of using [pymcmcstat](https://github.com/prmiles/pymcmcstat/wiki). In this case we consider a linear model.\n", "\n", "$$y(x;q) = m x + b + \\epsilon, \\quad \\epsilon\\sim N(0,\\sigma^2), \\quad q = [m, b]$$\n", "\n", "but note that the model can be arbitrarily complex. Similar work can be performed with Fortran using the `iso_c_binding` module." ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "1.9.0\n" ] }, { "data": { "text/plain": [ "{'divide': 'warn', 'over': 'warn', 'under': 'ignore', 'invalid': 'warn'}" ] }, "execution_count": 1, "metadata": {}, "output_type": "execute_result" } ], "source": [ "import numpy as np\n", "from pymcmcstat.MCMC import MCMC\n", "import matplotlib.pyplot as plt\n", "import ctypes\n", "from numpy.ctypeslib import ndpointer\n", "import pymcmcstat\n", "print(pymcmcstat.__version__)\n", "np.seterr(over='ignore')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Define data set\n", "To define our data set, we generate a set of points along the line, $y = 2x - 3$, and add some random noise to the response. We have plotted the data with and without the random noise added to it." ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "# Define data set\n", "nds = 100\n", "x = np.linspace(2, 3, num=nds)\n", "x = x.reshape(nds, 1)\n", "m = 2 # slope\n", "b = -3 # offset\n", "noise = 0.1*np.random.standard_normal(x.shape)\n", "y = m*x + b + noise\n", "\n", "# plot data\n", "plt.figure(dpi=100, figsize=(4, 4))\n", "plt.plot(x, y, '.k', label='With noise');\n", "plt.plot(x, m*x + b, '-r', label='Without noise');\n", "plt.legend();" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Define C++ Model\n", "We define our C++ model in the file `linear_model.cpp`.\n", "```cpp\n", "#include \n", "#include \n", "\n", "extern \"C\" {\n", " double* linear_model(float slope, float offset, double *x, int nx) {\n", " double* y = new double[nx];\n", " for (int ii = 0; ii < nx; ii++) {\n", " y[ii] = slope*x[ii] + offset;\n", " }\n", " return y;\n", " }\n", "}```\n", "You must compile the code in your terminal in order to generate an object to be called within Python. In this case, we output the compiled program to `linear_model.so`.\n", "```bash\n", "g++ -fPIC -shared -o linear_model.so linear_model.cpp\n", "```\n", "Note that `.so` is a common Linux convention for \"shared object\". On macOS this might be referred to as a dynamic library (`.dylib`) and on Windows this is usually called a dynamic-link library (`.dll`). Such objects can be inspected with the `nm` command on the macOS or Linux command line.\n", "\n", "Within our Python script, we now utilize the `ctypes` package to make the C++ program callable within our routine. The compiled library is loaded, and the `linear_model` is assigned to the variable `cpplm`. The `restype` tells Python what type of variable to expect from the C++ code, and the `artypes` tells Python what data types to send to the C++ code. For more details, see the `ctypes` documentation: https://docs.python.org/3/library/ctypes.html" ] }, { "cell_type": "code", "execution_count": 36, "metadata": {}, "outputs": [], "source": [ "lib = ctypes.cdll.LoadLibrary('resources/linear_model.so')\n", "cpp_linear_model = lib.linear_model\n", "cpp_linear_model.restype = ndpointer(dtype = ctypes.c_double, shape=(nds,))\n", "cpp_linear_model.argtypes = [ctypes.c_float, ctypes.c_float, ndpointer(ctypes.c_double), ctypes.c_int]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Define Python Model" ] }, { "cell_type": "code", "execution_count": 37, "metadata": {}, "outputs": [], "source": [ "def py_linear_model(q, x):\n", " m, b = q\n", " return m*x + b" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Compare Model Outputs" ] }, { "cell_type": "code", "execution_count": 44, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "ycpptest = cpp_linear_model(3, 2, x, nds)\n", "ypytest = py_linear_model([3, 2], x)\n", "import matplotlib.pyplot as plt\n", "fig, ax = plt.subplots()\n", "ax.plot(x, ycpptest, ':', label='C++')\n", "ax.plot(x, ypytest, '--', label='Python')\n", "tmp = ax.legend()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Both models output the same thing!" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Define Sum-of-Squares Function\n", "At this point we can define our sum-of-squares function and access the C++ code for model evaluation. We setup our evaluation such that we can easily compare a Python and C++ implementation. Note, the model type is inputted to the function by including it in the `user_defined_object` of the `data` structure." ] }, { "cell_type": "code", "execution_count": 54, "metadata": {}, "outputs": [], "source": [ "def test_ssfun(theta, data):\n", " xdata = data.xdata[0]\n", " ydata = data.ydata[0]\n", " model_type = data.user_defined_object[0]\n", " nx = len(xdata)\n", " if model_type == 'cpp':\n", " # eval model c++ model\n", " ymodel = cpp_linear_model(theta[0], theta[1], xdata, nx).reshape(ydata.shape)\n", " else:\n", " ymodel = py_linear_model(theta, xdata).reshape(ydata.shape)\n", " # calc sos\n", " ss = ((ymodel - ydata)**2).sum()\n", " return ss" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Setup MCMC Simulation\n", "We can now setup our MCMC simulation as we would for any other problem. Note, the C++ model has been added to the `data` structure." ] }, { "cell_type": "code", "execution_count": 69, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Running MCMC using model type: py\n", "\n", "Sampling these parameters:\n", " name start [ min, max] N( mu, sigma^2)\n", " m: 1.70 [ -10.00, 10.00] N( 0.00e+00, inf)\n", " b: 2.50 [ -10.00, 100.00] N( 0.00e+00, inf)\n", " [-----------------100%-----------------] 10000 of 10000 complete in 2.4 sec\n", "\n", "Running MCMC using model type: cpp\n", "\n", "Sampling these parameters:\n", " name start [ min, max] N( mu, sigma^2)\n", " m: 1.70 [ -10.00, 10.00] N( 0.00e+00, inf)\n", " b: 2.50 [ -10.00, 100.00] N( 0.00e+00, inf)\n", " [-----------------100%-----------------] 10000 of 10000 complete in 3.1 sec\n", "\n" ] } ], "source": [ "model_types = ['py', 'cpp']\n", "results = {}\n", "for model_type in model_types:\n", " print('Running MCMC using model type: {}'.format(model_type))\n", " # Initialize MCMC object\n", " mcstat = MCMC()\n", " # Add data\n", " mcstat.data.add_data_set(x, y, user_defined_object=model_type)\n", " # initialize parameter array\n", " mcstat.parameters.add_model_parameter(\n", " name='m',\n", " theta0=1.7,\n", " minimum=-10,\n", " maximum=10)\n", " mcstat.parameters.add_model_parameter(\n", " name='b',\n", " theta0=2.5,\n", " minimum=-10,\n", " maximum=100)\n", " # update simulation options\n", " mcstat.simulation_options.define_simulation_options(\n", " nsimu=int(10.0e3),\n", " updatesigma=True,\n", " method='dram',\n", " adaptint=100,\n", " verbosity=1,\n", " waitbar=True)\n", " # update model settings\n", " mcstat.model_settings.define_model_settings(sos_function=test_ssfun)\n", " # Run mcmcrun\n", " mcstat.run_simulation()\n", " results[model_type] = mcstat.simulation_results.results.copy()\n", " print('\\n')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The Python model runs slightly faster, but we are dealing with a very simple model. For many problems, the existing models in C++ will provide the optimal approach." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Extract Results and Display Chain Statistics/Plots\n", "We take the results of the MCMC simulation, remove the first half of the chain to account for burnin, and perform our analysis on the remaining part of the chain.\n", "\n", "Plots:\n", "- Marginal posterior densities\n", "- Sampling chains\n", "- Pairwise correlation" ] }, { "cell_type": "code", "execution_count": 70, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "******************************\n", "Results using model type: py\n", "\n", "\n", "------------------------------\n", "name : mean std MC_err tau geweke\n", "m : 2.0137 0.0335 0.0023 23.2615 0.9888\n", "b : -3.0263 0.0844 0.0057 22.9083 0.9822\n", "------------------------------\n", "==============================\n", "Acceptance rate information\n", "---------------\n", "Results dictionary:\n", "Stage 1: 0.69%\n", "Stage 2: 5.74%\n", "Net : 6.43% -> 643/10000\n", "---------------\n", "Chain provided:\n", "Net : 7.46% -> 373/5000\n", "---------------\n", "Note, the net acceptance rate from the results dictionary\n", "may be different if you only provided a subset of the chain,\n", "e.g., removed the first part for burnin-in.\n", "------------------------------\n", "******************************\n", "Results using model type: cpp\n", "\n", "\n", "------------------------------\n", "name : mean std MC_err tau geweke\n", "m : 2.0128 0.0320 0.0021 25.2899 0.9993\n", "b : -3.0253 0.0805 0.0052 24.5392 0.9982\n", "------------------------------\n", "==============================\n", "Acceptance rate information\n", "---------------\n", "Results dictionary:\n", "Stage 1: 0.89%\n", "Stage 2: 7.17%\n", "Net : 8.06% -> 806/10000\n", "---------------\n", "Chain provided:\n", "Net : 9.88% -> 494/5000\n", "---------------\n", "Note, the net acceptance rate from the results dictionary\n", "may be different if you only provided a subset of the chain,\n", "e.g., removed the first part for burnin-in.\n", "------------------------------\n" ] } ], "source": [ "for model_type in model_types:\n", " print(30*'*')\n", " print('Results using model type: {}'.format(model_type))\n", " # Extract results\n", " result = results[model_type]\n", " chain = result['chain']\n", " s2chain = result['s2chain']\n", " sschain = result['sschain']\n", " names = result['names']\n", " # define burnin\n", " burnin = int(result['nsimu']/2)\n", " # display chain statistics\n", " mcstat.chainstats(chain[burnin:,:], result)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Both approaches yield similar statistics and acceptance rates." ] }, { "cell_type": "code", "execution_count": 71, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "******************************\n", "Results using model type: py\n", "******************************\n", "Results using model type: cpp\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYYAAAF8CAYAAADLiRyaAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAAPYQAAD2EBqD+naQAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nO29e7xeRX3o/f3tCN4gsVYEYRtQiWi91FeRWy0glKKI1waiooYSBLG1yDECwotae7iYVPC0mpSYVI+tteS89bWNVjm1bFoVyo5aqxwPGo4G9/YGFUkQCwiZ88c8q3uetWdmzbo9z1p7/76fz3yS/TzrWWtmrVnzu86MGGNQFEVRlIyJcVdAURRF6RYqGBRFUZQhVDAoiqIoQ6hgUBRFUYZQwaAoiqIMoYJBURRFGUIFg6IoijKECgZFURRlCBUMiqIoyhAqGBRFUZQhVDAoiqIoQ6hgUBRFUYZQwaAoiqIMoYJBURpERA4SkS0i8kMReUBEviciG0VkbxE5U0SMiBwrIteKyE9FZLeIfFxEfiV3np0i8hkR+W0R+bqI3C8i3xKR14yrbcriQXTZbUVpBhE5ENgOPA7YBNwGHASsBI4BXgV8FPgmcA/wP4DDgPOALwHHm8ELKSI7gQeAJwJ/BtwJ/C7wLOAlxph/GFW7lMXHI8ZdAUVZQFwJHAAcaYz5ivP5u0VEnL8fBE40xvwSQETuANYBLwf+zjnu6cDvGGM+NThuC1bYvB9QwaC0hrqSFKUBRGQCaxFsywkFAMywab4pEwoDNgIPAafkfvZD4P93zrEb+Djw/4jIAU3VXVHyqGBQlGbYD1gK3Jpw7A73D2PMz4EfAYfkjrvdzPf1fmfwb/5YRWkMFQyKoijKECoYFKUZ7gJ2A89OOHaF+4eI7AM8CdiZO+7QXGwCbNwBz7GK0hgqGBSlAYwxe4BPAy8XkcPz3+cG+HNEZC/n7/OwiSCfy/3sQODVzjmWAm8Cvm6M+XFTdVeUPJqVpCjNcQnw28A/icgm4H9jLYHTgBc5x+0N/KOIbMWmq74Vm676d8On4zvAFhF5IfAT4Cxgf2zaqqK0hgoGRWkIY8wPRORI4I+AM7DB6B9gLYFfOIf+/uD79wF7AZ8E/sATaN4BvA1YjxUg3wNWGWOub7MdiqIT3BRlRIjImdgJbi/0pbTmjt0J3GqMOXUEVVOUITTGoCiKogyhgkFRFEUZQgWDoiiKMoTGGBRFUZQh1GJQFEVRhlDBoCiKogyh8xgKGMxYPRC4d9x1URRFKcm+wA89c2SiqGAo5kBgdtyVUBRFqcgkdqJlMioYirkXYGZmhqVLl467LoqiKEns3r2bJz/5yVDB26GCIZGlS5eqYFAUZVGgweeWmJ2FqSn7r6KMA+2DSlVUMLTAli1w8MFwwgn23y1bxl0jZbGhfVCpg05wK2CwBv6uXbt2JbmSZmfti7hnz9xnS5bAzp0wOdlaNRXlP9E+qICNMSxbtgxg2WC/8GTUYmiYHTuGX0iAhx+G228fT32UxYf2QaUuKhgaZsUKmMjd1SVL4NBDx1MfZfGhfVCpiwqGhpmchE2b7IsI9t9rr1UTXhkd2geVumiMoYCyMYaM2Vlruh96qL6QynjQPri4qRNj0HkMLTE5qS+jMl60DypVUVeS0nk0H19RRktvBIOIvEtEtovIvSJyp4h8WkQOK/jNs0Tkb0Rkp4gYEXn7qOqrNIPm4yvK6OmNYACOAz4MHAWcBOwF/E8ReWzkN48BvgtcDPy49RoqjTI7C+ecM5d6uWcPnHuuWg6K0ja9iTEYY17i/i0iZwJ3Ai8A/jnwm+3A9sHxV7VcRaVhYvn46jtXlPbojWDwsGzw791NnlREHgk80vlo3ybPr6ST5ePnZ/BqPr7Sd2ZnreKzYkU3lZw+uZL+ExGZAD4IfNkYc2vDp38XsMsp6rgYE5qPryxE+hA36+U8BhHZCLwUeJExJmngFpGdwAeNMR8sOM5nMcyWncfQJbqunRSh+fjKQmGU61gtqrWSRORDwKnAi1OFQhmMMQ8YY3ZnhZ5v6dkH7aSIyUk4/ngVCkr/6cs6Vr0RDGL5EPBq4ARjzPfGXaeuo1k9itIt+rKOVW8EAzZV9Q3A64F7ReSAQXl0doCIfFxErnT+3ltEnicizwP2Bg4a/N2xx9AOfdFOFGWx0Je4WW9iDCISqujvGmM+NjjmRmCnMebMwd+HAD7L4p+MMccnXrfSWkldoO/r8s/Owk032f8fc0w/6qwoKYwibrYo1koyxkjCMcfn/t4JFP5uoZJpJ+eeay2FrmonPrZsgTe/GTK9RQQ+8hFYs2a89VKUJuj6Ola9sRjGRZ8thozZWbj5ZjvI9kHznp2F5cvnhEJGn6ydJlCLSanDospKUspz/fXw2tfCqlX9yEzasWO+UIDFFR/ZssUKx1WrbFm+vPvPTVk4qMVQQN8thqpxhnHOfVjsFsNib7/SDGoxKEGqZCaNe+7D5KSNJ4gTHZqY6E98pC5qMSnjpjfBZ6UavvWGJibgzjutZpofaENzH04+ebSD8po19po332z/PvroxSEUZmfhttv833Ux332UaMxldKhg6BllXTz5zCQRq42uWmUFxKZNw5k+XVrRdHISTjtttNccJ/lMLJfFZDG5ZMLghhtsX03JUuv7EjCdwBijJVKApYDZtWuXGTebNxszMWEM2H83b07/7cyMMVu3zv0+K0uW2O/c44qOaZOZGWOuu86WUV2zC8zMGCMyfN+z8oY3+O/FzIwxN9zQ3n1q+/xFbN4cviehflnnHSlDH/rprl27DGCApabsuFf2B4utdEUwNDFg33CD/wWbmho+bvNme+7sGm29XHnyA4HI8LXHPVC1SejZZAPcqAfAUQ2wIWKCMtR3R6XUFPXTrqCCYREIhtRBPUaZF2dmxp57lJaCbyDI6jfugaptigbCUQ6A47YajYkLylCd1q6t/44UUdRPu0QdwaBZST3Bt/iWG0ROocw6LaNe0TSWiXPzzQt/McAsE8tHPujc9hpYVc8/OwtTU808lxUrhrPS8uRjLrOz8IEPzD+u6YD9YskYU8HQE/KDuhtELpNSumaNzYWfmrL/dmWJidBAsGSJbediWQwwfw98wrvtFTqrnL/pFGdfyrKIVQi2boU77pifNOEbsC+4oFnlJtZPF1TGWFkTY7EVOuJKykgNIveRvO82cxl1wbXRNr42TkwYMz3tP77tOFDo/L44T9nnUyZWlPX3rVvjx4fuXxt9JNRPu4bGGBaRYDCmmXhDVwkNBOMKiI+KKs+07ThQ/vyhOE+ZurcVK5qeNubUU+fO3VYfyYTa9HSawBonKhgWmWBYDBq0j1EHxEdJ159prH6pdQ8dNz1dL9ts9er5QmndutpNnkffEiBUMCwywWBMeQ26D3nXi53YMx13qm6RVZDSH0PnqDPYTk+Hz9nkveq64PahgmERCgZj0jXovuRd94U2B2nfM+2CppoyMBb1R985yqZ95u/9Bz4QPleTrtU+um9VMCxSwZBCn/Ku+8CoB+kuaapNxHncc4SERGiw9d37kMUgohaDzmNQgrSVd91kznpf8C0weM45sH17e9dsY85C1WeXkuq8fTtcfXX4nrjn+Jd/mZ8WC7Bhg7/OvrksT3oSrF7tv9b11yc0KpEm92ruxbtTVpIstsICtRhiqZBFjEJrnp425rLLjNmwoTtaWcxH3uaaPE1qqm0+u3wQePXq4t9ccon/nub7ZpErZ9u2+f28DY2+bgLEKC1OdSWpYIgSWoysSscchUmdH2C6EhOJ+cibuAeh2EVTqbpNPjs3bfO664y58MK0AT5PKEZwzTXFdQdj1q+33/chBjBqd5QKBhUMhczMGLNxY32tqu0XcFRZJlVZt85fv7r3oEiTbCJVN/XZTU/bATs2ua4oiBwa4POEnrfv2r57XzZldpyMWnipYGixLBTBYEz5julqhZkm2/YLOKosk6rE3ElVNe/rrhvNoJby7HzuINeSScksKmMxhK7po4mU2XGiFsMCKgtJMJTpmD6tMNNk23wBu24xFLk03OOKUlqLNO82BGHs2cXuffZvaAVTX0mJMbjXvuaaYUGSv4dNpMyWqU8bMa5RCi8VDCoYkinqmNPTxpx1VngJaNd0b2sWct0YQ5ErpC75lMv8LNuUAGOR5t2mJhl6djFrzRUSRRaDiA0Gl6lPXoiG7mGZgbVqP/DNpF67trnnMaoZ/CoYFrBgaGMyVahj+l6IUWmyeaanjXnPe2xcpEzbq2TGVCF0D1Otsth+A22v8xO6nyGLwTdIZoOzTyiUWY7CJwCK7mHKwFq1H8TuQR+WwXBRwdBiGadgaCq1LUW4pA4KXQvouZQJZLZFaMC/+ur5Lg+fq66tRdlCk8PyGrXPWotZjNlicm94w9yxqX01JACuu85/D4tiYdl9C/WDbduK34Miq6nL/T+PCoYWy7gEQ1MLjqUKlxQ3QhcDei6pqY91KFpzKuYiyt//UfmbUwLGrkbt+vtT6lg1qBoSomWWlff171A/SBFcKQpSF5IgUlDB0GIZl2BoYsGxMi9s0Quxdas9ZsMGY84/fy4oNzMz/zMfTfn9s4F5w4b5g3NMU2yC1DWn3MG0SOMchb85ZZtMCD+bojqGAtJ5Kyk7V0qGWx2BtG1bcVtjgivmUlWLQYu9QR2yGMp20rLpqb4XIhv8Nm8uftlCg2VTfv/QRD3Xp+1rQxO+4dAM8tie2VdfXe7+t0VqimkVyyp0X3z33qfdF60oGxNIMZdTSrws9hyyGNcb3tDtFNgYKhhaLOOOMVRdcMyYdIvB1eKmp4254AJjzj57LvA7M1P8kuUHgyJ/b1nLoWgActNF21geIaZ1b90arnNXJl25fSl0H6tYcynWSOYCje3nUNZqCikq+b53zTW2P9R5DqPKImoaFQwtli5kJU1NGfOyl8VfghBFJnlKDCLVFeETWE35/Yvq4N6LNmaYxgRTzCKpEkdoOhMtO9/09NwAF7Liyl471Rpp0nqKPYvQqqp5997rX9+/gb4sKhhaLOMWDMbElxZOHWjqpFaO22KYmTHm8suLr7txY7l2FV3Tl1tfNL8jdK4ijTO73vr1/vTNqoIiJvhdjXrDBmNe9KLymUXZNVzL1metffSjzVlxRUpCSNicdlq19yeVLN522WWjzYQLoYKhxdKEYMg6zFln2SCtr9P4Xv7ss8suC78E+fzuogHEPabsXr0pQqHpGEPqdfPnrpPxExtMZ2aMefe7yw1IZa7nu59uXdatK+5Lbl2LBGTs/paZbe4Kv/y9P+YY/7lTkid8/TlmMZRNrmhqRr3vPrY1hyYVFQwtlrqCIfTirVw5fEz2AmcThMosVLZ1qzHnnlus7a1fP3zMunXlNOuZGauVn3SS/8U844x4VlJ+yYMiYpbKUUeFv3Mzpsr6hlMG0yZjB6mumBRhmCcm+LPsrpS+VYXs3ocyhIo20ilycfqst6rp2HWTAWL9dJyWgwqGFksdwVDkgrn00vDAEAu0phyXH6h8K1NOTFhhUXbv6DaXnnaJuQxe+cr4fUl1heTXxInl1rvUnYMwPW01/te8Ju05F5WPfnR+OnBIgLnuqjYEg6vpxwbkd797frrxZZdZt2Gqi3PrVqusFE0MbNNiiPXTJufQlEUFQ4uljmAo8oWKpGltscEv9n2mCcUEVPZCpWrWVf27VYjV+6MfLb4/RYLKN8vXZ0VlJb/UQ9VsldSlR3z++pTiWhB5ARZrn69/ZpZXbFKfS17TD23E415j8+b66aV58vMlbrih+RhDdl82bAjXuarF0EQCggqGFkubFkM2MFd5+a+5Ji5UUrJ0suuXbdOoLAZj4r7bOoNJTIOMadT5VVTLUjSRMBu8ff76MiVvOWTnK5NhtnnzsPuxaDANWSj5AdknHIrqUqZv5V2zrvv0kkuqrcHlu0ZRvevM12liKZxeCAbgUcARwKnAK9wyqjpUrHcrMQZ3oPG5eUTis2eznbNC533LW+bqEArWVd0w3TdY1Z38E9NKs9jGBRdYN4N7jDvvoozfv8jnHNIC67oeYtfN9j7w3ZupKdtXUgf1Vav81/cN3hMTxlxxhb2H7vyV0KZEofsai2lMTxvzpjel1z/Wt2LadFHMpo7y4qb9hnZEvOIKK3iqzNPJzt1U/KrzggF4CXAnsMdTHh5FHWrUvZGspI0bjTniiHBHdbXU7EVwBwTXHbB6dbzz+wb82HIOVdLssrq5ufFVSVlqIvWYMksyxwb+mNCt4y6ru3pn1pfOPtsKxJBLLSbAUpebiGnEoeUuilZFDSkooX6cjx0UadMpFlGV55e3QmLnLuN6Sz13lTr3QTDsAD4M7D+K6zVc98bmMRSlh8Z81u5AnH/53JTGzBXh65hZsM592cadZhcaLFIGlFBAMlVQxfZ9CLkBm3CXNb0Wz2//dvnBpOg+pQywoWyhogmV7rPMzpGyB0fVjLGq9zfT4n0zp0PnLuN6S6lvnT7XB8GwG3jaKK7VQt0rCYZMC88vOFc2PTRvMseyZqamjHnb24pfMPf8oc44qjS72ACUDWwpx1Qltu9DaBCrS9Y3Tjkl3KYywccm02dj50wdtIqEjk9BMaZ4D47UeTf55T/ylngKKeni+b6xbl359bRSVjWuqqj1QTD8ObBmFNdqoe6lBYNPCxexDzh1oAmZzLFBYOXK9JfXmPbT7FJM6qYthlhdqmR5uCmRqa6BGKHAaF7rLBt8bGMJ77wW/9zn+vvKqBYFLCMAXeFUNnssRShOTMztRZEJuDIKTJl5SgvZYngM8FngY8A7gD9wyyjqUKPupQRDSiaS27lSA2hu5/ANAkXZLr6XNxRchPoWQ+oS1b5jUyY0lV2yoU6WR1NZIr7n6iYZhNJJUweG6Wnr+2/C2vO5LCcmxr8oYBsCME+KGy3k6kpRYGKCp8pimSH6IBjWAL8E7gV2At9zyndHUYcadS8lGMouOOd74Ckmc6bJXn558USpkLkfW4ahboZRKGsjtsGNz71Q9hjfb+qurBn7fZl9JorcgDGts2hgaEp4ZecKBUHdbT1TAvzu5MGmcONtZdxtdVxzqe9VigITesZZNtNiykr6MXAJMDGK6zVc99YsBrBphfk1b1IGszprFxlTLMCqLDp33XVWUL30pfFzN+WrT6HuSqux35ddA6pq8LToWTQZY4gNimWWyU4JJtehjCCsIjRT54/4+lGRAhO6xyJW8JZdjSBEHwTD3Ysp+JwaY8iX2IzVfB53ilA49ti49p06c9qYuGacMtmnruCpSlsWQ2gNoCLLIcUVUtZd0uQy47GdA904V0z7bnvBurKxhtCx7hIcofkz7r7WZftRtuzJqlV20cMLL7T/nnWWXVcs5k5yJzlWpQ+C4RrgklFcq4W6V85KyiZluRveFA2goRmrLkXa/u/9XpprI6YVuZ0+phmntKmMttUG+UDf618/N0Ew5trKBj/fQJ2yz0RoAE3RuMsETNu2GLJAqzFp2nebC9YZE3fJpWbxnXzy/M+KrJoyAjt12ZNQaUKI9kEw/AlwD/BPwJ8CV7tlFHWoUffW5zGEBpYQMYsh61BZSmTRpLVsAAqZr0X7KVTZxKfOwFWFIrdbfkDwDX75gbrovjTp809toyvkf+M3qvv23XNl2qsx6QJoHBZDfnnyWBZfTJFJcdsVCeyiRJDUsnZtvfvUB8EwFSk3JJ7jXcD2QQD7TuDTwGEJvzsNuA24H/gmcErJujcmGMpaDDFC7qrNm6tPWvN1+iLNuIrFMMoYQ6rbzfWfp67smdc63V3QxpG941uTqKpv35cyW8ZllRpjKBMUdskLr9gmQHlN//TT432hrlWTMjchRVDV7TOdFwxNFODzwJnAs4BfH6S/3gE8NvKbY4CHgHcCzwT+CHgQeHaJ6za6g1vMH192IkvIXVVX6Lik7MBWJsbguiVGQRmLZutW6xMuGizyrqnTTx9uUxtbi4bI/OQXXhi/52UTCXyCrWzGjG/CWt5F59PyU7OZMkUmtHxJPosvU3piGn0TAryMxZC9DyFhVafPLArBMK/isN+g0cdGjrkO+Ezus38B/qzEdRrf2jPLWsgWLrvgguYGyzYmraVk3+TbdMQRfi0uvz6TOzO8DVIthlT3QluZRVUoWrW06gATE2x15hGkTO6rsjR22fsd8v+nWrJZBl4oPlUlY7CNPrNYBcOhg0YHtX/g+8Dbc5/9IfBvkd88ciAMsnJQ04KhTZq2GDKq7sDmLrSX5Z37VgltOp3RJfVFDZVsqe3paWPOO89/zBvfOD/rJGUArepKKdrnID/gNWExuMKxiZ3xmqx/qsAKafNXXDFnTcTmpRRN3Ay183WvM+aii+avYFulDaksOsEATACfAb5UcNyDwOtyn70V+EnkN+8d3MyhMmrBUHXAMGb8C+OF6pS6zEDdDUryZBrea15TLYPKN2chtZx7brgtVQPUqVZQHYHb9CCVOps49gzy98C3R3qRwIrFzIos41A8zRWaVdyIrgXSxGrFGYtRMGzEzqCeLDiuimAYu8XQREZLFn+osjZ805TRFpvO5CmzJk2oPqE5C6nFt7lPHddB0SAb00rLkJpWmyLIi/rAxER4UUERO9cgy7Cr836ELIaPftT/eUrsyB34yz7XMkvHlGVRCQbgQ8AM8JSEY0u7kjznaDzGEGNcGS1tMq6U1jICKbRPQGzOwjHHpJ3b5wqpE6AOtatNd5yPlAHa1YZjO+O56aZln1XZfuKzDFLnpaSshZRqbaWeryqLQjAAMhAKPwBWJP7mOmBb7rObxh18jjHKjJZRMapJcHmTvEza4Nq1/iwvY8IWQ0jLTGlHXQUgP2/hjDNGqzyk1N+nDZ9zTrV+UOb+ulZMyKLJx8xClsSllw7/LnUxxxRrq63NoDIWi2DYgJ0kdxxwgFMe7RzzceBK5+9jsIv3vQN4xiB+MNZ01SKathjqxCqaPFdoJdfM5VF38bAqy3K4L3dKHMAtZfadDrWjrh+/ShC4KWIKTCagQwsphj73zbhOeX75OQu+zKdsHaLYvfItWy8yf5JoloFXZjHHPLGECLUYylSU+QHhQTnTOeZG4GO5350GfBt4ALiVMU5wS6WpwF/TK27WPZdv+9L8Naq0O9UiyZa1Tl0h1CekRawF4ZLl6593nr8evhiDe422B/eYQC+zOmz+nD5BHnMXZWXtWr/WnX/+sWXhff0oxXUY67tFLk93AmMdZSvWXzXG0JMyKsGQ72x1B4yUlMPUeQShc23bVn5QKWpXlXanLjUSymDx3fsbbkibOJVSj7I7sjVJTKCXXR3Wd+6ivSRC2nDmtnv3u+Prg4Uy7Hz9JDWWVWbBvXy59NL6ClKsnlu3lj9fCBUMLZZRCIam19WZmQn717NJSmU0lZQXbpzpsEUWQ1FWiHvvV68unoQVE2pFWvSolwOJrSzqu1dVLIeivSSy4ra9TJ9PzbArk2yQj0lkSpI7/8RX6ga+s+uFgs5FizuWQQVDi6VtwZCi2V93ne24KZ0llp6ZdbzYi1tVk6oyqDRJfhN2t81lXEW+gaCMeytFix5VllnMgknJwimL735OTNhB3fXHt5l5595/n2DPXyvk6z/jjOL+npWNG61Qye+rUlTPvDstvyx/XbeSCoYWS9uCoWj5gXzHjnWW2ECXDWpFWl3ITZJ/4aoOKm7mUFODY14YnnFG2kShVNeDu8NaCiladJMug1g9QgNw1f0kikiJE5XJvKvignPvf15hyK+8GnrmExPzl+dYuTJNQUq1nt0g9vR086mrKhhaLOOyGEIdJeu0voE19MK5/vWilyHvh3etlWywrbNJTdOTeULCMBbwLfqt78WsGiOIublG4VK69NK562cDdVGmVV1S4kgpFkNdF2vIgsmuk6Ik5dNaUxSkKgI2Vperr64mHFQwtFjqCoaUAcWnZaVos/mXpcwLlz+Xb0+CmLVSZVvLNibzxHYcSzlv/t6vXj28nHO21WLVASomiEXmB7ybdDHln9HKlf60YF+mVZP42lZkWTThbiqyTMooSfm6TU3ZNNbQ78u65IriZFUEowqGFksdwZCq8WTLDOeXJ05NwSzzwmVkAb38ZK6ia7vXK7OwXkzQbdxYLWWyqK6pk4TyGu7MjBUIMbdc6gBVJODXrm0++cCYcCyp7r0qS6xtMcuiiYmeKcKlbCKGSyxeV6UvF83FKSsYVTC0WKoKhlSNJ6Z5p07a8s2qrZPqWjUOESNV0FVxZ/jy3Yuyh2LaeYqLqYzQiZ3HN7GriUBsmVnfKdfzuRWLYkV1tP4mLIYys5RDSlIRvgmOqZtihbZ93brVpvHWffdUMLRYqgqGFI0nJWUw6ygbN9oyigyXVIuhLKmCroq2VTR5zq1DkXZeJBirDFCpg3Qd4euSullMioWS8tzqBplD16060bMovtAk09NWqKTuq5K6xlTd+qtgaLG0aTFUSRlsejnk2HXyg0FTcyyyTIyQj7ZqymRTQc+U7K4qdbviCv89LapT1fiDb3vN/LWLBrJUS8+Nl7i/ravIVLV+u7rmWFVPQnaPy/Q9FQwtlroxhtggXnWSUV1XUSqutVJnXZgQTU2yKiIbWMvMZPbNR2jinvv6RKyf1Ik/zMxY1082MayKUlF2a9SU9o6CJoRSG9TxJJRtgwqGFksTWUmxASWvGZxySvnJMn0kG6zzueJNz6AOLaqW8qK1JYB95w19VnVwCwmUsm1KtRhCgqHKNZsiJJTayABLpY4noazVo4Khw4IhhSy752Uvm98JVq5s7bJjIz9oXXJJ+W1DU/C9hKGZzFlwtcmJd3Wp6g5pWltOiTG05b+vS14otZEBVpaqnoSyFrUKhp4LBmPinSG/JnyfGaWJH5t1nB8s2tpFqwx5TbbqvWrDv553K7qLyY3SRVSHLrmXynoS1GLoWBmVYIiZj77AXl8ZVVAwswBSArtt7qKVSkiTreKjH9UAOC4XUVVSJryNy8XkY9u2eov2qWBYAIKhyHwcdzZFU8QGraZezHxcIabZpuzj2zZFA3mVAXhcQd8uE7vPXXAx+ajzHFUwLADBYEzYfOxCNkWThDJzyryYsQlCvvzvUFbVKCyGIoHXlhXVN41+FPj6XpdcTD6qPkcVDF+KMuQAACAASURBVAtEMBhjLYeTTpq/8NlCw+3sZV/MmBCpMsimzpCtQtXJTF0amBYa+YG2q3Me6lJHMIixg58SQESWArt27drF0qVLR3bd2Vm4/XY49FCYnBzZZUfO7Cxs3QrveMf876am4Pjj5x9/8MGwZ8/cZ0uWwM6d9j4VfR+rx8032/8ffXQz97xMXbZsgXPPhYcftsdcey2sWVO/DkoxVftM19m9ezfLli0DWGaM2V3mt49op0pKXSYn+90pU9iyBc45Z/iFzFiyxArFPDt2zD/+4YetEM3u2aZN8wfZons5OQmnnVa9LT6K6uqyZg2cfPLiUAa6RtU+s5BRi6GAcVkMCx2flpYR05hDv1u/HtauHT5u3IPsQtVEFypd6DNNUsdimGinSooSx6dNA1xzjXXpPPWp9kXNMzkJV101//OLLx4+fnLSuqHG+YJnmuiSJfbvcWuis7PWPee7r0o3+kxXUMGgjIUVK2Ai1/uWLIGHHoKjjoITTrDa9pYt8397+OHzP8tcNF1jzRprIUxN2X/HFTfYssXez9h9VZQMdSUVoK6k9sgHXK+80mr+Ra6Xxeqi2b4dvvhF+M3fhBe+MP13i/V+LXbUlaT0krw2ffjh4WCtS9dcNKPgzDPhiCNs9tYRR9i/U4kFwRXFh1oMBajFUJ/ZWTs4rVhRnDJaRrPtQ7Awte2x32/bBm996/zvpqfTLAe1GBYnajEonaWMb7usJdD1YGFdv372e59QAPjyl9POsxgtLKUeajEUoBZDdepMNuu6JVBEXS09ls6bkWoxuOfs+31V0tEJbkonKTPBy2UhTO6r2vbY711Wry4nFGBh3NcuU9dt2CXUlaS0Rigl1TejuS3Glbtft+2+34vAe95jLYWPfax63RbCfIautaGJdOBOtans4kqLrTDiRfQWGuNc/nncSynXbXuT9y5b4XX9+m4uL12GcT/XPE0sgthGm3QRvRbRGEN9xuHb7komTt22N3Hvitak6lN20riea8xNNDVlLYU8vkUgQ+duo02alaR0mnFkD3Uld79u27PfQzU3w+xsWChA/+YzjOO5FrmJ6roNu9JXXVQwKAuSFSusT95lYmK08Y2mqOO/LgpijzrmU5dRx63ygnXPHjtbP78uV5104C7E4vKoYFAWDePwmtYNKKYMTDF8g05GH+czjHpORqo2X2dNrC7OM9F0VWVBsmPHfEFgTHq6aBO4vv2JCfvyl11Er27aq2+vgSuvtKmufZ3PMMq9KzLL0+1LIcuzTjpw1/bj0OBzARp87ifjDj43df0mz9OVQadPzM7C8uXDgkEEvv/97t9HDT4rSo5xm+dNBRSbakfXlw/pKjHLcyGjFkMBajH0m3Fpyk1bLKrxj4dxW551UItBUQKMS1Nu2mKp245OzartEeO2PMeFWgwFqMWg1KELmn4TQfDFTheeY1nqWAwqGApQwaD0mT67QpR6qCtJURQvXZxVq3QfFQyKsoDp4qxapfuoYFCUBcxiDZ4q9dAYQwEaY1AWAn0Mnir10B3cRsDu3aXuq6J0iqVL4fnPt//Xrrw4qDNmqcVQgIgcBGj2t6IofWXSGPODMj9QwVCAiAhwIHBvyZ/uixUokxV+23W0bf1kIbcNFnb7qrZtX+CHpuRAr66kAgY3tJS0BZC5zQDuLevf6zratn6ykNsGC7t9NdpW6T5oVpKiKIoyhAoGRVEUZQgVDO3xAPCHg38XGtq2frKQ2wYLu30jbZsGnxVFUZQh1GJQFEVRhlDBoCiKogyhgkFRFEUZQgWDoiiKMoQKhhYQkd8TkZ0icr+I3CIiR4y7TnlE5FgR2SYiPxQRIyKvyn0vIvI+EfmRiPyHiHxBRFbkjnm8iHxCRHaLyD0iskVE9skd81wR+eLgXsyIyIUjaNu7RGS7iNwrIneKyKdF5LDcMY8SkQ+LyE9F5Oci8jcisn/umOUi8lkR+cXgPOtF5BG5Y44Xka+JyAMicruInNly284TkW8M7vluEblZRF7a93b5EJGLB33zg85nvW2fiLx30B633NbJthljtDRYgFXYlLLfBX4N2AT8DHjiuOuWq+dLgf8KvBowwKty318E3AO8Engu8LfAd4FHOcd8Dvg6cCTwImAH8FfO90uBHwN/CTwLeC3wC+Ccltv2eeDMwTV/HfgscAfwWOeYjcD3gROAFwA3A192vl8CfBP4B+B5g/t1F3CFc8xTgPuADwDPBH4feAg4ucW2vRw4BVgBPB24HHgQeFaf2+Vp5wuB7wH/Bnyw789tcN33ArcCBzjlCV1s20ge8mIqwC3Ah5y/J7BLalw87rpF6jwkGAABfgSsdT5bBtwPvHbw9zMHvzvcOeYlwB7gwMHf5wF3A3s7x1wF3Dbi9u03qOuxTlseBFY6xzxjcMxRg79fCjwM7O8c8xZgV9Ye4P3Arblr/TXw+RG3725gzUJpF7AP8B3gt4AbGQiGvrcPKxi+HviuU21TV1KDiMjeWEn/hewzY8yewd9Hj6teFXgKVptx27ELK/SydhwN3GOM+Yrzuy9gBcORzjH/bIx50DnmeuAwEfmVluruY9ng37sH/74A2Ivh9t2G1dbc9n3TGPMT5zzXY62gZznHfIFhrmdEz1pElojIa4HHYrXLBdEu4MPAZ40x+ToshPatGLhvvztwwy4ffN6ptqlgaJYnYM29n+Q+/wl2oO0LWV1j7TgAuNP90hjzEHbwdY/xncO9RquIyATwQaxJfqtz7QeNMfd46lam7qFjlorIo+vWPYSIPEdEfo51Wf4Z8GpjzLfoebsABoLu+cC7PF/3vX23YF2cL8Fa008Bvigi+9KxtunqqspC58PAs7ExkIXCt7E+5mXASuC/i8hx461SfUTkycB/A04yxtw/7vo0jTHmc86f3xCRW7Cxr9OB/xhPrfyoxdAs/87AB5j7fH9sELYvZHWNtePHwBPdLwfZEY/PHeM7h3uN1hCRDwGnAi82xribLf0Y2FtEHuepW5m6h47ZbYxp7UU3xjxojLndGPNVY8y7sAHa8+l5u7DulCcCXxORh0TkIeA44A8G//8J/W7fEAPr4DvAoXTs2algaJCBL/2rwInZZwNXxolYH3Bf+B62g7ntWIqNHWTtuBl4nIi8wPndCdg+dYtzzLEispdzzEnAt40xP2up7lmq7YewGVcnGGO+lzvkq8AvGW7fYcByhtv3HBFxhd9J2PXtv+UccyLDnMTon/UE8Ej6365/BJ6DtYay8hXgE87/+9y+IcSmdj8Nm+jRrWc3iiyDxVSw6ar3A6uxmTvXYtNV9x933XL13Ie5l88AFwz+v3zw/UWDer8C+7J+Gn+66teAI4DfwGo/brrqMqyA+Tg2OLYKm0rXdrrqBmyq7XEMpwY+2jlmI9aMfzFWU70JuMn5PksNvB6b8noyNqbiSw1ch80geSvtp6teCRwLHDJ4LldiA/4n9bldkfbeyPx01V62D/jjQZ88BDgGm3Z6F7Bf19o20oe8WAo2d/gObHDwFuDIcdfJU8fjsQIhXz42+F6A92EH9vuxmQ5Pz53j8cBfYbca3AX8ObBP7pjnAl8cnGMWuGgEbfO1ywBnOsc8Cht/uHvwIn0KOCB3noOBv8fOvbhr8GI/wnMf/3XwrP+Pe42W2rYF2Dm43p2D53JS39sVae+NDAuG3rYPmzb6w8E1Zwd/P62LbdNltxVFUZQhNMagKIqiDKGCQVEURRlCBYOiKIoyhAoGRVEUZQgVDIqiKMoQKhgURVGUIVQwKIqiKEOoYFAURVGGUMGgKIqiDKGCQVEURRlCBYOiKIoyhAoGRVEUZQgVDIqiKMoQKhgURVGUIVQwKIqiKEM8YtwV6DoiIsCB2M1oFEVR+sS+wA9NyY13VDAUcyB2tyVFUZQ+Mgn8oMwPeiEYROQQ4DLsZvMHYLfH+0vgcmPMg5HfHQCsx26GvS/w7cFv/qbE5e8FmJmZYenSpVWqryiKMnJ2797Nk5/8ZKjg7eiFYMBuaj0BnAvcDjwb+AjwWGBt5HcfBx6H3dD+34HXA1tF5HBjzL+WqcDSpUtVMCiKsijo7Z7PIvJO4DxjzFMjx/x8cMxfOJ/9FLsh/ebE6ywFdu3atUsFg9JbZmdhxw5YsQImJ8ddG2UU7N69m2XLlgEsM8bsLvPbPmclLQPuLjjmJmCViDxeRCZE5LXAo4AbQz8QkUeKyNKsYF1QilKJ2VmYmrL/jostW+Dgg+GEE+y/W7aMry5KP+ilYBCRQ4G3AdcWHHo6sBfwU+CBwfGvNsbcHvnNu4BdTtHAc48Z58DchQF5dhbOOQf27LF/79kD5547XkGldJ+xCgYRuUpETEF5Ru43BwGfB/6HMeYjBZf4I2yM4beAw4GrsTGG50R+cyXWGsmKGt49ZZwDc1cG5B075uqQ8fDDcHtMNVLm0QXLb5SMNcYgIvsBv1pw2HezzCMRORDrBvoX4ExjzJ7Qj0TkaQwC1caY/+V8/gXgdmPMWxLrqDGGHjI7a4WBOyguWQI7d47Gxz41ZQWS7/Pjj2//+hnjvg8LgS1b4M1vBmNABD7yEVizZty1Kqa3MQZjzF3GmNsKSiYUDsIKha8CvxsTCgMeM/g3f9zD9NSFpqQzbk15xQqYyPWyJUvg0ENHc/2MyUnYtMleO6vDlVfa+7NYtN86zM7OCQWw/775zQv/3vVigHSEwvex6an7icgBg3kK/3mMiNwmIkcMProNazFcKyJHiMjTROQd2DkNnx5tC5RRM+6B2TcgX3ttdS29jitjzRprIUxNwVVXwcUXayA6lZtumhMKGcbAzTePpz6joheCATuYHwqciA0G/8gpGXsBhzGwFIwxvwROAe4CtgHfAN4ErDbG/P3Iaq6MhaYH5iq4A/LOndXcD7Oz8M53NhMrufNOuOii8cc9lO7T23kMo0JjDP1mdta6jw49tH8+dde37VI2RrBly3AgPM+o4x5NMKp5GbOzsHz58DOYmIA77uh+f+ptjEFRRkEfdZ8sq8lX9zKxknx2VJ5xxD3qMspss8lJG2x2Lc9Nm/xCYSFlLqlgUBYsXZhHUBVf8DyjzGBedJ5Ru9fqMo404BSXYJ/7mg91JRWgrqR+0vc0TV/9wboxrrrKxh2qnmdiAv76r+Hoo/txL1y6kgbs0tW+pq4kRckx7nTVuuSD5yL23z17bAA5VSP1BeE3bYLTTuufUIDxZ5v56Htf86GCQWmdcfheuziAlCVzYWzdOvx52Vz6JrKjukIXss3yNNXXuhSjUMGgtMq4fK9dGUDqvuyTk1YQ1M2ln5y0rpY+Wgl5uibomuhrXYtRaIyhAI0xVKcLvtdxpqu6aaITE3bwqDKIbd0Kq1b5Pz/ttPr1VJqhal9r6z3RGIPSSar6XlO17JTjxqUpN5k9c8wxczGGjIkJGzxWukPVvtbFGIUKBqU1Unyv+cE91aTumumdp8mXvUwuvdI/OhkPM8ZoiRRgKWB27dpllPJs3mzMkiXWS75kif3b/W5iwn43MWHMunVzf2dlyRJjZmaGzzkzk3bcOGmjjjMzxkxNdaudSjPE3pOq7Nq1ywAGWGpKjnsaYyhAYwz18fleQ/n1vslY+Rz1Luay+9iyxbqPHn64/PwDZfHRdDysTozhEfUvryhxJifnd3SfqyUL0uaDcHmTOjO9Y8d1YY/jNWvgZz+bW7ju4ovh8Y8ffxaN0k1878m40BiDMhZCftX3v7847W9y0h6X/T5/XFfiD7Oz3VrNtEt58kq3UcGgjIXQBjIveIHNzy9alyYbcEXs77LjurKlJnQr26QrwlLpBxpjKEBjDO2QuXr22Qfuuw++8pW5wT6W81+U892l+EPZ/PS23F9dmE+ijB6dx6D0Cld7Peoo2L493eVSpIV3KfWvzIzYNjX6LlkuXUZdbXOoxVDAqC2G7dvhE5+w/z/jDHjhC1u/5Eipk40U+n1e+3WzgbLBeJwB36Jsk7Y1erUYhvFZZk3NUq9Thzzbt8O2bfCkJ8HLX17+WdWxGMY+T6DrhRHOY1i9ejjvHexnC4kbbpjfxmweQ2rOf0rOd59y/kP3ZGqquWs0nSc/M2PMddfZ0od7nJGfO7N58+jnxfjqkMc3FpR9ZnXmMYx94O16GZVgmJ72Dw5gv1sohF7C9evLDVxlBv6ZGTv4xo4d50BXNDCl1D/1Ok0Iy82bjRGZq6tIMxOy2iZ0n6+7rn3BXFQH95mExgKRcs9OBcMCEAwf+EBYMKxa1eqlR05Ie21Dyw9piO5A24WBLnRPUrTLMtQVMjMzw/eqqzPPfYQss61bR2cxpFiHsbFg69b0a6lgWACCIWYxTEx0/6UrSxtCID/o+bQzkfnLcIx6oPMNzpnFsnVrvP5l6uUTgHWFTGhga0vDbpLY/WxjSYqydciIjQVveUv6tVQwdFgwlNHQfH7Fvrx048Y36MUGMVfoptzzptw5vnqGBuw6sYeq61AVUcViaOreNUFMAIwqLpUihFau9D/7Ms9MBUNHBUMVDW3btvkv3rjM9EyL3bCh20HGkBY2PR0f+F0rIvYCNuXO8dVzYiI8YFe1GELXaUrh2Lx5/nlCSRJNu8LKErLOxp2YkFKHM86o98xUMLRYqgqGMi/19LT1K2ZB5lGZtTHyfvdsAG0jmyXf/rLENGv3Xk5M+IXu+vXDn7sDWJMZKykWTP7lr9IXmsj8yuMqCRs29GMVXFcoiVirqU/4rLMyAWgVDC2WqoIh1Q2Qdx9lmlcdraatAGP+xS47oPuCvMcc429/2foWZfVk9zIW+N66db6PPxQIrKJpl7UY3N+V6Qu+64Axhx8+LCTXrk07p09JSLkno0jDDRG6B+vXN3+t6Wljzj/fliYzCH3vYZl4owqGFkubFkMoyFTUuWIDf9sBxuzFDgm0WJ1TBpeU9vsoo1mnDLTufYwJxybq2YaFeMkl/rpv22YFQmofSX1uXbMYYlZTk9dvc+5RXcGqgqHFUjfGEHvhQ9roNdfEzxl6qZt6EYsshm3b/N/FBvQybpRY+4vq3YTvOKRt1hm4Z2asC+b88425/PJhy6TJumeE+tZ73lOuj6Q8t9g9qSv0qlq/sT7clMXS9tyjuu+zCoYWSxNZSaEXvqzFUNRRmjTdfe6DTBBVEWhtWwxNErqP11xTbeD2BWvbnisR6ltlA5qx5zYxMV/Ahc5RRejVtX7XrZtf5yYtlth8g6rKTZ46glUFQ4ul7XkMZVwyRQN/06Z75nffuHF4AKjqAssLm4mJZmIMTdPkfZyZCQ8ebc9P8aU8psQ08sSUBB9NpKc29QzWr587T2z5lMya27Ah/Rp1LQZfIkbosyqCVQVDi2UUE9ymp62G4etMZbNBUjWMqi9DRtkYg3vdfJA31v5xUUdTcwfGlHhNW4SuvXZt+baFlIQ8ZbT8mABp0vqNDaw+ay67RynvRNUYgy8RY/XqZmfgq2DouWDwMTNjO6fPjE/RgGIaRlOujS4N6PlBJjTolNFmq2hqvoll47IYYlp30zGNouvlKRIgowhcx6y5rF6XXFKceTc9bcwFF9iSaimkulXrtFkFwwITDEXpgam+XR/jdG2k1q+sGyKfQXTssf5BJ1WbrRPw9KWj+p7lqNZjGuWcmFQtP3XQb7vuZRIiyljFTV+3qlWpgqHFMmrBEMuIqdJZ8oPcOF0bRVQJNqbcr9AsaFd7zu5RnYBnmRe+zGJodSlKgKgzuTB/nZQBv4ybKHNhXX65MZddlq6R+2Y7+z4rM0BDc/dJLYael1EJhqzjhpYArtJZQiuLhs5bZDE0EVSMnbuK6yB1ML76av/nbk6/SHw5kqJBNCSkurLESZ6qcaIYeS1/3Tp/MLWMyyl/P2P1LLMWVej8sZJlptV9D3yJGPkYQ90lRFQwtFhGIRjyU/eL3EhVNWl3JUnf4BU7b9tr3lQNNqZoXyGLoeheZ2XrVmNOPnn4s5Ur/YODL6YgMv4lTvJUzSxLIbNQ8kuNuH0sxU0UU2JCiRopz9g3s3zjRmN+7deK+8Kllzb3HvgSMXyfVaWOYNCtPQtoe2tP37aLInZ7wYcftv+++c3wvOfBr/4qHH102hZ/U1N2/2Df58cfb6/7mc/Ad74DT386nHpq+LxNbg2ZbWm4zz7wla/At78Nhx0Ghx9u93+uco316+HCC/3fuVt7ult+ithXvYii4yYm4OKL7XUeeAC++U343OfmH7d1K+y3X3h7z1Fz9dXwjnfM//yaa+Dtb08/T2iLytlZWL58/r2bmIBPfhKe8hT7/H/8Y9v3si1s3fPt2OHvwwDveQ8cd9zwdUN93kd+29jt2+GII+K/WbkSPvWp/myRqlt7tlho2WKIbR5SJ2ukyayOplIH3Zxyn1a9enV1zdqnnWYph67pPzNjzLnnhjVCV7sPBY7Llq64jlyasBhiVmSZeEtmSeSTCF71qvBvfNdNjc/5nkdostoFF8xl3rW19lNbLtpF4UoC/g74PnA/8CPgL4ADC37zKODDwE+BnwN/A+xf8rqtCoY20/Kayupooo6xtE33ZZ+errd4YN4M96WPhgZ7ETsz+KyzjHn72+38jrpCAeILt7UZtymiToyhqE+UCbBmzyZlUM+eU/637vPO+nzoOr73IEVQtvGutumiXSyC4QLgKOBg4BjgJuCmgt9sHAiTE4AXADcDXy553ZHEGNryQTeVr153wlfqINFkVlQofbTMoN6ExRBqUxuDQrbS51lnpU1crDoXJUV7Tl2VNeUZXHGFXecpJKzXrp27bqYg+J591k5fIkGKoGzyXQ31z6b2PlkUgmFexeEVwB5gr8D3y4AHgZXOZ88Y3KijSlxnZFlJ4948pIiqdUx1KzQ9jyJ03TKDletaEjHm9NNtADKmlaa0qQ3t0zcLt635Eqn1zwbpjRvjQrlIYLvLvqTuIBcaxGMCIEVQTk8b8+53xwVviiUYey+aUBQWnWAAHg9cB3wpcswJg5vyuNzndwAXRH73yIEwyMpBTQuGmRmrFVx+udXsml7HPbvGhg3pud9NXM9t06pVc1pryk5qbQxgKT7niQljzjknfowv3pMJydNOq9amJvzV2TM+/3xjLrww3sY2FI6y2nPIzZNtohNaKjxf/7Vr0+9dXpmpG1vxLWWRb3c+VnL44fZduPBC+2/qe1FXUVg0ggF4P3DfoLE3A78aOfb1wAOez6eB90d+997B+YdKU4IhZl43NbOybO53E9eLaeG+DXlOOcVqkRdcYP9ty1KKxTZE7MtZdzb49LR1c1x0kTFnn21LUZvqWgxl8+/LuuhSYx9lrcjs+Olpu7F91m8yDTkvaH0Db517Fwoyv+lNaW0tslZSA+BZOe64Zp+bS28FA3CVbxDOlWc4xz8BeDpwEvAl4LNgU249564qGFqzGFJ87XW1+7K533UpG2RsShtKJXWmd2igbXM7yKr+6rIzdstaDPl5NW3cg9jgngnamHCteu9iK6IWWa2xvpT1o7LLXbT5jvRZMOw38PvHyt6B304OGn104PtKriTPeRqLMYRMYLeUWcfddSVk/s5Yx2xqjXiXOi/CqLZ4jNXB9RNnE51OOmm+Jttm/crGbaqkgpapj0/jvfTS0k2LWh1NudKqxLxOOaXaYJxqMTQhFJpwrfZWMNQpwPJBo48PfJ8Fn3/H+eywcQWfUzXrVK1+/Xp/Z4q5TupsGRpaDqLrFoMxxW4X9yUMabJZHnu+zk2uNeQSexZFg0+qO8tHTOiU2S85717MWx1tpmkXEdtgJyacUvelCMVKypQm4kILXjAARwK/DzwPm656AvBl4HbgkYNjDgJuA45wfrdxYCG8GJuuWpji6rl25T2fXW0+ZQ2k1DhA0ZyAU09NP3cWNH71q8NaclEaX9m0xHEsC5FZA2efHa5TzOLypZW2sdaQMWlprG3tChcT9KmDVegcecHSdJp2alwk5k4KCSefIMtiVD5iSQmp5eqrF6krKbmS8BzgBuxEtfuB7w0G/YOcYw7JWxDMTXC7Gxu0/hRwQMlrlxYMIQ3V97K87nXp67gbU05DP+oo66sNnTs2oLv+Xt/3Psth61abb/6618XrNcqVRd36FS1SmLklUlZrTdn3usrktTKadCbsmg7gxxSP7B7F2hW6xz7B0uQ8mzJzQnypvfnfZe3MrMLQ/QiR7dPwutdZhcRNTnjDG9JSnuu4Mhe8YBhnKSsYYmZ+E4uplfXpx1YCLRIwU1PV9nc2Jiwcx7E8RD6YWlQvV5MNCYnzzovfl6o7mdXxvVcRRCEuvdTff1MWkSsSvk2TIkx99yYLcl9xxfxF6/Ipp230ZTdDy91Vr6nrqGBosZQVDEUDd7ZkQ9XZjWXT4d7znmr1FClnMYTq+pa3zNV3XC6kohU3QzuIZS+tb9CJWQxltH7fkh1VfO9tzKLOrz+VOmiFlKO2lIIiYVr23qRajW3MuwktD19FoKpgaLE0aTFMTAwvJFdGk3TJTxR65jPD1wz5nYssBjcLpa4vvSl3QRViixSmLm9cdgZt0UDluih8QmD9+nKWZZVAbop1keq29A1avv0G2lIKfO3PlpaIbdAUIkVpaiuNucmg/FgFAyChuQQLoTQVY8g6U1VNsoxGG9PU3AEhFGNYuXJ+ffJLBTTptkglC5SXsbbqvmjuIO4Tbr4lFGLXTHFrZddJFaZl3U+pGnSK27IovbPM3gLT03amfsoaT742uUuXZPc2do9DpFoMsXaX7aehttSxTMYiGIA1wK3AA4NyK3B21fN1tdTJSsoHBmMvsDvQxjSgfEdLjTlMTYV3dMuCxrFAtUvbm/aErlm0FEHst6EXLTYY1Wmn75p1B5wQPs0+cwX6ji1aFdXth0UWQ1OZWHnrq0qGVdaXm7jHRau0wpxL2H0vq/bTvKLVhJU9csEAvA+7jPWV2MXsXjH4/73A+6qcs6ulyQluoZcy716KTYTzZU6kvAhVTOoybahrOcS0rNAAFfJv+ywZ34sWG4yaaGf+5Fs/1gAAGXhJREFUmkWpsFW1Q9/9CaWWxpQTnyAsijM08exDcazYAoRlJ865JXU+Rvb8tm0rjlNlHoHUfurSlqI1DsFwF/A6z+evA/69yjm7WpoUDMbM1yR97qWitenzHc0VLKHAapmFx2LEfPZ17klMy0pZiiA7T+oLVjQYtbEpS0yIn3xy2gA7M2OtG3fxxTJ1DQm80Nan7me++TG+65R1M8YmnOXPneJiTV2ptQwpmWqx64au2ZaiZcx4BMM9wArP508H7qlyzq6WpgVDphlnftfQSx1LX4O5yS++OMG6dcO+3VhAvOyM3dCLV1XTSbEGUo8p84IVDUahdpaZ/esjNiu2KH4TSgFeubJc231urhRN26ew5K+TIpzz1mFISIsMW5CpzzjmBqoz6GYWRCwdt6zFEFO06sbwxiEY/hS42vP5HwMfrnLOrpYmBUPIxx9bTOzd7w5rIik5+caka9yphNwLVV66MtZA3hJat656/n+K+2Llymba6BITSNdcEx5YY8Ld1y9SMpkyATgzY5dLT8lAchWWvOurqC9fdpndIc9nHYb2knDvQ1nLaGpqfobXJZdUD3C75w71//y7kZJ5GLPUOj/BDbjaKX8C7B4EnDcPyjeBXcCflq1El0sTgiH04rmZKvmXLZ+9UmbuQv5lKdK4y5j+RRN/qizvXCZ+kFlC+bhMlfz/ohhDlYyWImLLMVx+ebgNTU1szBNbRyrUX0OB0VAdTz45Xtf8qqpXXJHu7koR1Fl9U5b0TiWkqGTL4PgmzcXO5bqpQve9LKMSDFOJ5YaylehyqSsYihZwc3PbsywH3wswMWGth5RBIWRe+zSZsjN0y8Q+ytyjmJaV+dWzTYdC9Xjb2+bHb4oEXmiJ5zLLOoTuVejaMe3YV7J+UUYwpKykW2SFvOxl9edTVNnStShA3uRy26nPM9ReV1HJn7vsHtoxN5VOcOtYqSMYil48t1Om5Lf7UvFC2RGh+uRjD2U0sJjWWncmaL5uGT7B+tznhuuxcuWcC6FOqmnoGaTEGFKEbbaOztlnx4Wtay2WWagwZc2mlIlcofkbsba72m8oYB3rc0X9MmSxxCgT4C5L2zG8TlsMi7XUEQxFL96qVfa4lEyKbBmG00+fn944M+PfDatq/WJ+eV++/Jo16ZvPl6GMX90tvvTC1JcrFlxft244cOpbirtJYetzK0xMWDfF2WfPLb4Ym5keE1Ip97dqDCrV9RnqqymWQfYsstWLfa7H7Pm0YTFkNL0HSq8nuC2W0qbFkGkTKfnt+a0xjz22ekaOW7/U3xW5xFxB0VQedtVNgHxB49RBLpYlErIk3MEt9PvQEsq+ZzAxEXcf+dpRdgZ2Ruy5NjXPxVfOPbfYBx+zDELPInsOPoHYxCS6UD2L3vEq5+zdBLfFVNqKMbhaXegFzsz40IJt2XpGqWvzhF6wfNbG+ecPWwBlNfcmtLCs3lUEQ51BLvYsUiZ6xQbGstpxXbdCqkU4M2NjLL/5m3NtbHr1340bi7frTCWWGJC5v0LPcMOGdvYZ973nbe6znoIKhhZLU1lJ2SYxob0XYuZjyD+aLXsQG0BS88p9WRvZNVK2JC0afKqSaqkUCaq6y1mkWC/uap5l8+hDGmIdt0IVwVJXU02JD9TNzy96FqEkjTZmF7tk73nq0jJto4KhxdL0BLcYoZcyluLoG4xia/OEBoaiTdLLDsS+NlTdAjN74V7+cn9dTjzRCtzzz/fXJ7T0eNE13WcR01J993VmprkllOsM1kXrRDW1Lak74IeuGZujUUZYFD2LjRvTYnZNWgxdRAVDi2WUgiFGymSr/ABSJrhctA+uz2rIxz0yIZLXxprcAjPLXtq4cb6Pus7eESnEspV8bWoyw6QOPsHS5DPJZ9RlQfq8YPXdi6rZYyFLMlNKUpawKNp9LZsIF9rvu+uoYGixjFswuNrUpZeW8wE3ZTFkL5vPVM4+C/lt2x6s87S1D3NG1t7USUhNZZg0SZPPJBRTyaf1FiVYVBGcWTZePkvP/T622VLoOr55JmUFVxdQwdBiGadgCC2hUTWv3HUx+TSg0AtRZ1OSqluD1sGXodMkZdN8Y8/MfRZN+N9TaPKZxAb8ojTeKpq8j9D9TXFv5YkpSOOy+KqigmEBCoYm3RDui1MUjM4mXrkZKlkAusq1R20xjIKmnk3eBVN2HkpVYtuSppINurFsLd/KqEUrC9cNVGe/8bmoUpSqIpdqFcE1LlQwLEDBMKpln0NrEoUmeVUZsNp274yDui6ionz/tjTT0FpXsWeSH6DzAu2oo/xtOO00/7ncwblsoLpK28rcT7UYVDCk3aAFYDFkpAqboqUvqrg9yrp36mzzOCrqZAuVSX9titCeC9u2zT8uy1bKD9A+LT9WUp53aqC6KM22qF6p9zPkUu1KjCgVFQwtlnHHGJoMXNa1GLKydm27OeFtzVDtEqO2GGIZVe6A6bv3easxVShAetzCFUZVrOUiQVv2frqLK5ZdL6qIUcWSVDC0WLqQldRkp0wVNiGzfGKi3RTMNte06Rrus3AXy2taM40JIffZFblRqgiHFIshL4zKbjyU0sauKBZVXGRVUcHQYhm3YGiDVGEzMzN/Y5amtggN0eYqmE3RpMbnPoumlYCMWOZQygz7/CCbukheSiwpJIwuvTS+IVD+/k9P25VcXeG6bl0797Mqo57XooJBBUOr5AevxWwxjFLja4pQqmhem4/d+/wAnSkNPvfU6aenx5JiqbM+QZmyOB7US7GOUUcpaCOhJIYKhkUqGMp00pmZ4X1269D2pK2uxhjGOZO5rpWS+sx8GWRF8zBCM9FTCO2B7RMsvvsfipu0oUjUVQrUYlhApauCoUwnzQcemxho23J7ZIR2Vhsno9b4MpqyUlKfWdsTBN36+FxSvjRXY8ov5tjkc2ly7sqoZsLXEQxi7OCnBBCRpcCuXbt2sXTp0nFXB4DZWTj4YNizZ+6zJUtg506YnJx/7PLltiu7hI5Xwvju+8QE3HFHe/exzLMeBbOzsGMHrFjh72uh73zH3XUXrFo1//upKTj++Pm/8fVjkfmfZZ9///vN3aOpKTjhhLS6FjE7C7ffDoce2u4z3L17N8uWLQNYZozZXea3E+1USWmTHTuGBwqAhx+2nc13rO/FCR2vhJmchE2b7KCTYQxcf31714w969lZOzDNzrZ3fZctW6yQOuEE+++WLWnfhc7x2tcO30uwQu/QQ+f/LtSP3/EOWL3af60mn8uKFVYJcAnVtYjJSStMOq2UlTUxFluhg66kMmbtzIzfD9unGZxdYlR+YnfJiSZXJa1Tn1C768yPEUlzrYQC6Nk1tm1LX9iwKl1cEDFGHVeSWgw9JNNclyyxfy9ZAtde69dAJifhIx8Z1swmJsLHK3HKWGtVmJ2Fd75zTqs+6ih44xuHn/WVV8JFF83VY88eOPfcdi2HWLtT74nvOGPgk5+0ls/OnbBmjf/6vj6/adNcH37sY+dbFE1bxWvW2DoW1XUhoDGGAroYY8go46ucnYWbb7b/P/poFQpVadPnv2ULvPnN/njQzTfDfffZZ71jR3P+7lRi7Ya0e9LEvQv1+VHHYmZn4aab7P+POaab71OdGMPYXTVdL3TQlVSXUU3Jb5qu1LsNl0LREhluhs2o3VlFC94VfefSpjtmVK6eNrL82kDTVVUwJNPHCVrGdK/eTafrpixc6NL2IBjbhjM2pyF1Rn1bqc5tp1H3KWan6aot0mVXUlm6lvrow2ei96Heddm+HY44wv/d+vWwdu38z9tKe+zy/U5NiW2LUNpq9l1brrwq1HElPaKdKiltUefFiAUJx/3Cw3wfu4gNnD/1qd2udxP8/Ofh7w4/3P/55GQ77e9SP3EVhW98wwbe9+yxCRSbNo0+ALxihX/uRNXU1c5S1sQYVwH+Dvg+cD/wI+AvgAMjxz8e+FPg28B/DH77J1jp2UtXUt+m5JetW8hEL7tnbx/pkouiK/0ktlT4OPtAvl5dcG36WCzpqlPA6cBhwO8ATwP+v8jxBw7KWuDZwJnAS4DA1JtuMzsL55xTL0WxTJrrqCdPxSbi3Xdfer37SpfSisv0k7aYnfVnaLmE0lHb7rtr1thZ1Vu32nLHHQswdbWsJOlKAV4B7AH2KvGb04AHgEeU+E0nLIa66/S4GSZFAbpxBHpTNOa2A4tdIFuUrsqCdG3UZVz3O2WHO99CeV1LUhgniy4rCesmug74UsnfnQ3cVXDMIwfCICsHdUEw1DHvy7ws43Qj9MVEV9onpCi4Zf36+b/pggusKywWVxIi8n4RuQ/4KbAceGWJ3z4BuAzYVHDou4BdThmRMyVOVfO+rAuq7Zm9MRaFia4k4XOtZUxMwLp18zO1xtl3FxpjTVcVkauAiwoOe6Yx5rbB8U/AWgsHA+/BDtynmoJGDFJO/wG4G3iFMeaXkWMfibUaMvYFZruSrlo2RbHsqpBdTlVcbPRhdm3buDP2DzlkbvZ3KC6mfXeOOumq4xYM+wG/WnDYd40xD3p+OwnMAMcYY26OXGNf4HrgF1ghcn/JOvZ6HkOVl2XLFmtVPPzwnGUyDs19MQ+ModRdtaDidKXvdoHeCoY6iMhy4A7gxcaYGwPHLMUKhQeAU4wxv6hwnV4LhvwAk5r/Pao140Ms5oFR99Cox7j7bldY8IJBRI4EXgh8CfgZNlX1j4D9gWcZYx4QkYOAfwTeZIyZHgzo/xN4DPBq4D7nlHcZYx5OvHZvBcM4NpZpgsU+MPZpdq3SXRbDRj2/AF6DHfi/jZ2L8A3gOGPMA4Nj9sLOcXjM4O/nA0cCzwFux06Ky8qTR1bzMeILxu3Z0/1g3GLfXCibXZtnwc2uVTpLL5bEMMZ8EwjoUP95zE5AnL9vdP9ejGS7TuXjC10fXBbNsgMBsoycvAtwoU3qU7pLXywGpQJdmMFahS7NAh4XmrqrjJNexBjGSZ9jDBl9Dcbp5kKKUp0FH3weJwtBMCiKsvhYDMFnRVEUZUSoYFAURRkxo169uCwqGBRFUUbIli12ftEJJ9h/t3RwIwCNMRSgMQZFUZpilOs5aYxBWdB03exWlFT6sgKsCgal0/TB7FaUVLJJpy5dnLipgkHpLE1sZ6ooXaIvk057sSSGsjiJmd1de5G6yOysvYcrVuj96hJr1sDJJ3d70qlaDEpn6YvZ3UXUBddtJiftKrldFAqggqE1NGBan76Y3V1DXXBKXVQwtIBqa82xZo1N5Zuasv/qQnLF9CXzRekuOo+hgLLzGHTfWWXcaB9UQOcxdArV1pRxoy44pS6aldQwfd0cR1lY9CHzRekuajE0jGprSlfoeuaL0l00xlBA1bWS+ro5jqIoC4M6MQZ1JbXE5KQKBEVR+okKhkR27y4lcBVFUcZKnTFLXUkFiMhBgE4NUhSlr0waY35Q5gcqGAoQEQEOBO4t+dN9sQJlssJvu462rZ8s5LbBwm5f1bbtC/zQlBzo1ZVUwOCGlpK2AFaeAHBv2cBP19G29ZOF3DZY2O2r0bZK90HTVRVFUZQhVDAoiqIoQ6hgaI8HgD8c/LvQ0Lb1k4XcNljY7Rtp2zT4rCiKogyhFoOiKIoyhAoGRVEUZQgVDIqiKMoQKhgURVGUIVQwtICI/J6I7BSR+0XkFhE5Ytx1yiMix4rINhH5oYgYEXlV7nsRkfeJyI9E5D9E5AsisiJ3zONF5BMisltE7hGRLSKyT+6Y54rIFwf3YkZELhxB294lIttF5F4RuVNEPi0ih+WOeZSIfFhEfioiPxeRvxGR/XPHLBeRz4rILwbnWS8ij8gdc7yIfE1EHhCR20XkzJbbdp6IfGNwz3eLyM0i8tK+t8uHiFw86JsfdD7rbftE5L2D9rjltk62zRijpcECrMKmlP0u8GvAJuBnwBPHXbdcPV8K/Ffg1YABXpX7/iLgHuCVwHOBvwW+CzzKOeZzwNeBI4EXATuAv3K+Xwr8GPhL4FnAa4FfAOe03LbPA2cOrvnrwGeBO4DHOsdsBL4PnAC8ALgZ+LLz/RLgm8A/AM8b3K+7gCucY54C3Ad8AHgm8PvAQ8DJLbbt5cApwArg6cDlwIPAs/rcLk87Xwh8D/g34IN9f26D674XuBU4wClP6GLbRvKQF1MBbgE+5Pw9gV1S4+Jx1y1S5yHBAAjwI2Ct89ky4H7gtYO/nzn43eHOMS8B9gAHDv4+D7gb2Ns55irgthG3b79BXY912vIgsNI55hmDY44a/P1S4GFgf+eYtwC7svYA7wduzV3rr4HPj7h9dwNrFkq7gH2A7wC/BdzIQDD0vX1YwfD1wHedapu6khpERPbGSvovZJ8ZY/YM/j56XPWqwFOw2ozbjl1YoZe142jgHmPMV5zffQErGI50jvlnY8yDzjHXA4eJyK+0VHcfywb/3j349wXAXgy37zastua275vGmJ8457keawU9yznmCwxzPSN61iKyREReCzwWq10uiHYBHwY+a4zJ12EhtG/FwH373YEbdvng8061TQVDszwBa+79JPf5T7ADbV/I6hprxwHAne6XxpiHsIOve4zvHO41WkVEJoAPYk3yW51rP2iMucdTtzJ1Dx2zVEQeXbfuIUTkOSLyc6zL8s+AVxtjvkXP2wUwEHTPB97l+brv7bsF6+J8CdaafgrwRRHZl461TVdXVRY6HwaejY2BLBS+jfUxLwNWAv9dRI4bb5XqIyJPBv4bcJIx5v5x16dpjDGfc/78hojcgo19nQ78x3hq5Ucthmb5dwY+wNzn+2ODsH0hq2usHT8Gnuh+OciOeHzuGN853Gu0hoh8CDgVeLExxt1s6cfA3iLyOE/dytQ9dMxuY0xrL7ox5kFjzO3GmK8aY96FDdCeT8/bhXWnPBH4mog8JCIPAccBfzD4/0/od/uGGFgH3wEOpWPPTgVDgwx86V8FTsw+G7gyTsT6gPvC97AdzG3HUmzsIGvHzcDjROQFzu9OwPapW5xjjhWRvZxjTgK+bYz5WUt1z1JtP4TNuDrBGPO93CFfBX7JcPsOA5Yz3L7niIgr/E7Crm//LeeYExnmJEb/rCeAR9L/dv0j8BysNZSVrwCfcP7f5/YNITa1+2nYRI9uPbtRZBkspoJNV70fWI3N3LkWm666/7jrlqvnPsy9fAa4YPD/5YPvLxrU+xXYl/XT+NNVvwYcAfwGVvtx01WXYQXMx7HBsVXYVLq201U3YFNtj2M4NfDRzjEbsWb8i7Ga6k3ATc73WWrg9diU15OxMRVfauA6bAbJW2k/XfVK4FjgkMFzuRIb8D+pz+2KtPdG5qer9rJ9wB8P+uQhwDHYtNO7gP261raRPuTFUrC5w3dgg4O3AEeOu06eOh6PFQj58rHB9wK8Dzuw34/NdHh67hyPB/4Ku9XgLuDPgX1yxzwX+OLgHLPARSNom69dBjjTOeZR2PjD3YMX6VPAAbnzHAz8PXbuxV2DF/sRnvv4r4Nn/X/ca7TUti3AzsH17hw8l5P63q5Ie29kWDD0tn3YtNEfDq45O/j7aV1smy67rSiKogyhMQZFURRlCBUMiqIoyhAqGBRFUZQhVDAoiqIoQ6hgUBRFUYZQwaAoiqIMoYJBURRFGUIFg6J0HLG7Ab593PVQFg8qGBTFQUQ+JiKfHvz/RndbyRFc+0wRyS+7DHY3s02jqoei6LLbitIyIrK3Gd6sqBTGmLuarI+iFKEWg6J4EJGPYRc8O9/ZuP2QwXfPFpHPDTZs/4mI/IWIPMH57Y0i8iER+aCI/Dt20TNE5L+IyDdF5D4RmRGRDYMVNhGR44GPAsuc67138N2QK2mwIfzfDq6/W0S2upvGDzad/7qIvHHw210i8teDDWEUpRAVDIri53zsUsUfAZ40KDOD9fJvwC5Sdjh2N679ga2536/G7uH7G9h9ecGugvoH2JVmV2OXKV83+O4m4O3YJZSz6/1xvlKDZdz/FruA4XHYJZWfClyXO/RpwKuw+1GcOjj24lJ3QFm0qCtJUTwYY3aJyIPAL4wx/7mpkIj8PvCvxphLnM/OwgqNpxtjvjP4eIcx5sLcOd14xU4R+X+xW3O+1RjzoIjssofNXc/Didjltp9ijJkZXP9NwP8SkRcaY7YPjpvArqp57+CYvxj89tKy90JZfKhgUJRy/Drw4sGey3meht2TAuzGK0OIyG9h9zJ+BnYD90cAjxKRxxhjfpF4/WcCM5lQADDGfGsQtH4mkAmGnZlQGPAjcjvuKUoIFQyKUo59gG3YjYzy/Mj5/33uF4P4xGewm7Fcil1z/0XY/RX2xq6v3yS/zP1tUNexkogKBkUJ8yB21yyXrwG/g9XIHypxrhdgB+Z3GGP2AIjI6QnXy/O/gSeLyJMdV9KvAY9jbntHRamFahCKEmYncKSIHCIiTxgEfj+MDfx+UkReKCJPE5GTReSjIhIb1G8H9gLeJiJPFZE3MheUdq+3j4icOLjeYzzn+QJ2e8dPiMjzReQI7Nap/2SM+Uqt1irKABUMihLmj4GHsZr4Xdj9sH+IzTRaAvxP7CD9Qewe03tCJzLG/BvwX7AuqFuBM7DxBveYm7DB6OsG17swdxqM3XLxldj9uP8ZKyi+i91PW1EaQbf2VBRFUYZQi0FRFEUZQgWDoiiKMoQKBkVRFGUIFQyKoijKECoYFEVRlCFUMCiKoihDqGBQFEVRhlDBoCiKogyhgkFRFEUZQgWDoiiKMoQKBkVRFGUIFQyKoijKEP8XeGmsFwC+RDgAAAAASUVORK5CYII=\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "from pymcmcstat import mcmcplot as mcp\n", "# generate mcmc plots\n", "settings = dict(\n", " fig=dict(figsize=(4,4)))\n", "for model_type in model_types:\n", " print(30*'*')\n", " print('Results using model type: {}'.format(model_type))\n", " # Extract results\n", " result = results[model_type]\n", " chain = result['chain']\n", " s2chain = result['s2chain']\n", " sschain = result['sschain']\n", " names = result['names']\n", " # define burnin\n", " burnin = int(result['nsimu']/2)\n", " # plot density panel\n", " f = mcp.plot_density_panel(chain[burnin:, :], names,\n", " settings=settings)\n", " ax = f.axes[0]\n", " ax.set_title(model_type)\n", " # plot chain panel\n", " f= mcp.plot_chain_panel(chain[burnin:, :], names,\n", " settings=settings)\n", " ax = f.axes[0]\n", " ax.set_title(model_type)\n", " # plot pairwise correlation panel\n", " f = mcp.plot_pairwise_correlation_panel(chain[burnin:, :], names,\n", " settings=settings)\n", " ax = f.axes[0]\n", " ax.set_title(model_type)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Generate/Plot Prediction Intervals\n", "The C++ model can also be used in generating credible/prediction intervals." ] }, { "cell_type": "code", "execution_count": 74, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Generating credible/prediction intervals:\n", "\n", "\n", "Interval generation complete\n", "\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "# generate prediction intervals\n", "def pred_modelfun(preddata, theta):\n", " return cpplm(theta[0], theta[1], preddata.xdata[0], nds).reshape(nds,)\n", "mcstat.PI.setup_prediction_interval_calculation(\n", " results=results['cpp'],\n", " data=mcstat.data,\n", " modelfunction=pred_modelfun)\n", "mcstat.PI.generate_prediction_intervals()\n", "mcstat.PI.plot_prediction_intervals(adddata=True, figsizeinches=(6, 6));" ] } ], "metadata": { "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.6.8" }, "latex_envs": { "LaTeX_envs_menu_present": true, "autoclose": false, "autocomplete": true, "bibliofile": "biblio.bib", "cite_by": "apalike", "current_citInitial": 1, "eqLabelWithNumbers": true, "eqNumInitial": 1, "hotkeys": { "equation": "Ctrl-E", "itemize": "Ctrl-I" }, "labels_anchors": false, "latex_user_defs": false, "report_style_numbering": true, "user_envs_cfg": false }, "toc": { "base_numbering": 1, "nav_menu": {}, "number_sections": true, "sideBar": true, "skip_h1_title": false, "title_cell": "Table of Contents", "title_sidebar": "Contents", "toc_cell": false, "toc_position": {}, "toc_section_display": true, "toc_window_display": true } }, "nbformat": 4, "nbformat_minor": 2 }