{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Chapter 5: Continuous Random Variables\n", " \n", "This Jupyter notebook is the Python equivalent of the R code in section 5.9 R, pp. 253 - 255, [Introduction to Probability, Second Edition](https://www.crcpress.com/Introduction-to-Probability-Second-Edition/Blitzstein-Hwang/p/book/9781138369917), Blitzstein & Hwang.\n", "\n", "----" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "import numpy as np" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Python, SciPy and Matplotlib\n", "\n", "In this section we will introduce continuous distributions in Python and SciPy, learn how to make basic plots, demonstrate the universality of the Uniform by simulation, and simulate arrival times in a Poisson process." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Uniform, Normal, and Exponential distributions \n", "\n", "For [continuous distributions in scipy.stats](https://docs.scipy.org/doc/scipy/reference/tutorial/stats/continuous.html), the pdf function gives the PDF, the cdf function gives the CDF, and the rvs function generates random numbers from the continuous distribution. This is in keeping with the application programming interface of the [discrete statistical distributions in scipy.stats](https://docs.scipy.org/doc/scipy/reference/tutorial/stats/discrete.html). Thus, we have the following functions: \n", "\n", "### Uniform\n", "[scipy.stats.uniform](https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.uniform.html#scipy.stats.uniform) provides functions for Uniform continuous random variables. \n", "* To evaluate the $Unif(a, b)$ PDF at $x$, we use uniform.pdf(x, a, b). \n", "* For the CDF, we use uniform.cdf(x, a, b). \n", "* To generate $n$ realizations from the $Unif(a, b)$ distribution, we use uniform.rvs(a, b, size=n). " ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "PDF of Unif(0, 4) evaluated at 3 is 0.25\n", "\n", "CDF of Unif(0, 4) evaluated at 3 is 0.75\n", "\n", "Generating 10 realizations from Unif(0, 4):\n", "[3.24085002 2.48793265 0.69337744 3.98212677 3.53906749 0.19890551\n", " 3.30252222 2.37991343 1.42342695 1.92222338]\n" ] } ], "source": [ "# seed the random number generator\n", "np.random.seed(1597)\n", "\n", "from scipy.stats import uniform\n", "\n", "# to learn more about scipy.stats,uniform un-comment ouf the following line\n", "#print(uniform.__doc__)\n", "\n", "a = 0\n", "b = 4\n", "x = 3\n", "n = 10\n", "\n", "print('PDF of Unif({}, {}) evaluated at {} is {}\\n'.format(a, b, x, uniform.pdf(x, a, b)))\n", "\n", "print('CDF of Unif({}, {}) evaluated at {} is {}\\n'.format(a, b, x, uniform.cdf(x, a, b)))\n", "\n", "print('Generating {} realizations from Unif({}, {}):\\n{}'.format(n, a, b, uniform.rvs(a, b, size=n)))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Normal\n", "[scipy.stats.norm](https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.norm.html#scipy.stats.norm) provides functions for normal continuous random variables. \n", "\n", "* To evaluate the $N(\\mu, \\sigma^2)$ PDF at $x$, we use norm.pdf(x, loc, scale), where the parameter loc corresponds to $\\mu$ and scale corresponds to standard deviation $\\sigma$ (and **not** variance $\\sigma^2$).\n", "* For the CDF, we use norm.cdf(x, loc, scale). \n", "* To generate $n$ realizations from the $N(\\mu, \\sigma^2)$ distribution, we use norm.rvs(loc, scale, size=n). " ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "PDF of N(0.0, 2.0) evaluated at 1.5 is 0.15056871607740221\n", "\n", "CDF of N(0.0, 2.0) evaluated at 1.5 is 0.7733726476231317\n", "\n", "Generating 10 realizations from N(0.0, 2.0):\n", "[-4.56890553 1.4163793 -0.72812069 1.80610792 -1.5542524 0.4551897\n", " -1.82794816 1.58959742 -3.26902153 -2.71002864]\n" ] } ], "source": [ "np.random.seed(2584)\n", "\n", "from scipy.stats import norm\n", "\n", "# to learn more about scipy.stats,norm un-comment ouf the following line\n", "#print(norm.__doc__)\n", "\n", "mu = 0.0\n", "sigma = 2.0\n", "x = 1.5\n", "\n", "print('PDF of N({}, {}) evaluated at {} is {}\\n'.format(mu, sigma, x, norm.pdf(x, mu, sigma)))\n", "\n", "print('CDF of N({}, {}) evaluated at {} is {}\\n'.format(mu, sigma, x, norm.cdf(x, mu, sigma)))\n", "\n", "print('Generating {} realizations from N({}, {}):\\n{}'.format(n, mu, sigma, norm.rvs(mu, sigma, size=n)))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "☣ 5.9.1 (Normal parameters in scipy.stats.norm). Note that we have to input the standard deviation for the scale parameter value, not the variance! For example, to get the $N(10, 3)$ CDF at 12, we usenorm.cdf(12, 10, np.sqrt(3)). Ignoring this is a common, disastrous coding error." ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "N(10, 1.7320508075688772) CDF at 12 is 0.8758934605050381\n" ] } ], "source": [ "loc = 10\n", "var = 3\n", "scale = np.sqrt(var)\n", "x = 12\n", "\n", "ans = norm.cdf(x, loc, scale)\n", "\n", "print('N({}, {}) CDF at {} is {}'.format(loc, scale, x, ans))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Exponential\n", "[scipy.stats.expon](https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.expon.html#scipy.stats.expon) provides functions for exponential continuous random variables. The probability density function for $Expo(\\lambda)$ is:\n", "\n", "\\begin{align}\n", " f(x) &= e^{-x}\n", "\\end{align}\n", "\n", "\n", "The probability density is defined in the “standardized” form. To shift and/or scale the distribution use the loc and scale parameters. Specifically, expon.pdf(x, loc, scale) is identically equivalent to expon.pdf(y) / scale with y = (x - loc) / scale.\n", "\n", "* To evaluate the $Expo(\\lambda)$ PDF at $x$, we use expon.pdf(x, scale=1/lambda), where the $\\lambda$ corresponds to scale=1/lambd.\n", "* For the CDF, we use expon.cdf(x, scale=1/lambd). \n", "* To generate $n$ realizations from the $Expo(\\lambda)$ distribution, we use expon.rvs(scale=1/lambd, size=n)." ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "PDF of Expo(2.1) evaluated at 5 is 5.782654363446904e-05\n", "\n", "CDF of Expo(2.1) evaluated at 5 is 0.9999724635506503\n", "\n", "Generating 10 realizations from Expo(2.1):\n", "[0.44907946 0.77554149 1.469014 0.15728342 0.92258566 0.54294386\n", " 0.80347768 0.23157762 0.34759354 1.03891708]\n", "\n" ] } ], "source": [ "np.random.seed(4181)\n", "\n", "from scipy.stats import expon\n", "\n", "# to learn more about scipy.stats,expon un-comment ouf the following line\n", "#print(expon.__doc__)\n", "\n", "lambd = 2.1\n", "x = 5\n", "\n", "expon.pdf(x, scale=1/lambd)\n", "\n", "print('PDF of Expo({}) evaluated at {} is {}\\n'.format(lambd, x, expon.pdf(x, scale=1/lambd)))\n", "\n", "print('CDF of Expo({}) evaluated at {} is {}\\n'.format(lambd, x, expon.cdf(x, scale=1/lambd)))\n", "\n", "print('Generating {} realizations from Expo({}):\\n{}\\n'.format(n, lambd, expon.rvs(scale=1/lambd, size=n)))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Due to the importance of location-scale transformations for continuous distributions, SciPy has default parameter settings for each of these three families. The default for the Uniform [scipy.stats.uniform](https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.uniform.html#scipy.stats.uniform) is loc=0, scale=1, the default for the Normal [scipy.stats.norm](https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.norm.html#scipy.stats.norm) is loc=0, scale=1, and the default for the Exponential [scipy.stats.expon](https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.expon.html#scipy.stats.expon) is loc=0, scale=1.\n", "\n", "For example, uniform.pdf(0.5), with no additional inputs, evaluates the $Unif(0, 1)$ PDF at 0.5." ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "1.0" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "uniform.pdf(0.5)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "norm.rvs(size=10), with no additional inputs, generates 10 realizations from the $N (0, 1)$ distribution." ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([ 0.79839927, -0.69769073, 0.34055804, -0.22043838, 0.79782274,\n", " -2.60292799, -1.53866926, 0.93084378, 0.81590117, -0.42043989])" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "norm.rvs(size=10)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "This means there are two ways to generate a $N(\\mu, \\sigma^2)$ random variable in SciPy. After choosing our values of $\\mu$ and $\\sigma$," ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [], "source": [ "mu = 1\n", "sigma = 2" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "we can do either of the following:" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "norm.rvs(mu, sigma, size=1) = [1.99342831]\n", "mu + sigma * norm.rvs(size=1) = [1.99342831]\n" ] } ], "source": [ "ans1 = norm.rvs(mu, sigma, size=1, random_state=42)\n", "ans2 = mu + sigma * norm.rvs(size=1, random_state=42)\n", "\n", "print('norm.rvs(mu, sigma, size=1) = {}'.format(ans1))\n", "print('mu + sigma * norm.rvs(size=1) = {}'.format(ans2))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Either way, we end up generating a draw from the $N(\\mu, \\sigma^2)$ distribution." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Plots in Matplotlib\n", "\n", "Plotting in Python within a Jupyter notebook is done in [Matplotlib](https://matplotlib.org/). \n", "\n", "First, we import matplotlib.pyplot module. To cut down on typing, we can alias that imported matplotlib.pyplot module reference as plt for short. We then invoke the %matplotlib inline% Jupyter notebook magic command in order to create Matplotlib graphs right in your notebook." ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [], "source": [ "import matplotlib.pyplot as plt\n", "\n", "%matplotlib inline" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Here is how we can create a plot of the standard Normal PDF from −3 to 3 using Matplotlib in Jupyter notebook.\n", "\n", "[numpy.linspace](https://docs.scipy.org/doc/numpy-1.15.0/reference/generated/numpy.linspace.html) creates an evenly-spaced numerical sequence, ranging from start to stop. The third function parameter num lets you specify how many numbers in the sequence to generate. \n", "\n", "We use numpy.linspace(-3, 3, 1000) to generate 1000 numbers ranging from -3 to 3 as our x values in the graph; with 1000 values in the sequence, the curve looks very smooth. If we were to choose num=20, the piecewise linearity would become very apparent." ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [], "source": [ "x = np.linspace(-3, 3, 1000)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We can then call norm.pdf(x) to generate the y values in the graph, and pass both the x and y values to [matplotlib.pyplot.plot](https://matplotlib.org/api/_as_gen/matplotlib.pyplot.plot.html). This will render a graph of $N(0,1)$ from -3 to 3. pyplot.show will display the graph." ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAX0AAAD8CAYAAACb4nSYAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\nAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4wLCBo\ndHRwOi8vbWF0cGxvdGxpYi5vcmcvqOYd8AAAIABJREFUeJzt3Xl8VfWZx/HPkx0SCAHClpVAQHaQ\nyC7iUgVtQccNlAJ1rzJanc6oY1unamda6bRqS1upqGCliGupUlFRFGQNCChLIISEhCUkJCSQfXnm\nj1ycNAZzyXbu8rxfr7yae+45yffU5MvJWX4/UVWMMcb4hwCnAxhjjGk/VvrGGONHrPSNMcaPWOkb\nY4wfsdI3xhg/YqVvjDF+xErfGGP8iJW+Mcb4ESt9Y4zxI0FOB2ioe/fumpiY6HQMY4zxKtu2bctX\n1eim1vO40k9MTCQ1NdXpGMYY41VEJMud9ez0jjHG+BErfWOM8SNW+sYY40es9I0xxo+4VfoiMlVE\n0kQkXUQe+Zb1bhARFZGUessedW2XJiJXtUZoY4wxzdPk3TsiEggsBL4D5ABbRWSlqu5psF4n4H5g\nc71lg4GZwBCgD/CRiAxQ1ZrW2wVjjDHucudIfwyQrqoZqloJLAdmNLLek8DTQHm9ZTOA5apaoaqH\ngHTX1zPGGOMAd+7TjwGy673OAcbWX0FERgFxqvquiPy4wbabGmwb08ysxrS7gpJKdmafIruwlKLS\nKgIChOiIUJKiwxkaE0lYcKDTEY05L+6UvjSy7OuJdUUkAPgtMO98t633Ne4C7gKIj493I5Ixbaeo\nrIq3tufw1vYjfHW0iHNNIx0WHMDEft25+aI4Lh/Uk8CAxn7cjfEs7pR+DhBX73UscLTe607AUGCt\niAD0AlaKyHQ3tgVAVRcBiwBSUlJspnbjiJKKahZ9lsGf12VQWlnD8NhIHrpiAGOTupHYrSNdOoZQ\nq8qJ4gr2555mfXo+q3cf565XtpHQrSP/ftVArhnWG9fvgTEeSfRchzFnVxAJAvYDlwNHgK3ALaq6\n+xzrrwV+rKqpIjIEWEbdefw+wBog+dsu5KakpKgNw2Da29q0Ezz85i5yiyu4elgv7p3Sn6ExkU1u\nV11Tywd7cnluzQH2HT/N2L5d+fWNI4jr2rEdUhvz/0Rkm6qmNLVek0f6qlotIvOB1UAg8KKq7haR\nJ4BUVV35LdvuFpEVwB6gGrjP7twxnqSqppan3t3Dko1ZJPeI4A+3jmZ0QpTb2wcFBnD1sN5cNaQX\nr23N5n9W7WXas+v4738ZxvQRfdowuTHN0+SRfnuzI33TXk6VVnLvq9vZcPAkt03sy39MHdjiC7PZ\nBaU8+NoOUrMKuf+y/jz4nQF2use0i1Y70jfGFx0rKuPWP28mp7CM/71xBNePjm2VrxvXtSPL7hzH\nT975kuc+TudwQSkLbhxBcKA9/G48g5W+8Ts5haXc8ufNFJRU8uqdY7kosWurfv2QoAB+df1wErqF\ns2B1GlW1yrM3jyTIit94ACt941dyi8uZuWgTRWVV/OWOsYyM69Im30dEuO/S/oQEBvCLVXsR4NmZ\no+y2TuM4K33jN06XVzHvpa0UllSy7M5xjGijwq/vzslJ1KryP//YR3SnUB7/3pA2/57GfBsrfeMX\nqmpquffV7ezPPc2L8y5ql8I/6+5L+pFbXMGLnx8iLqojt03q227f25iGrPSNX/ifVftYdyCfp68f\nziUDmpxGtNU9ds0gjpwq5cn39pAUHc6UgT3aPYMxYOPpGz+wcudRXvz8EPMmJHLTRXFNb9AGAgOE\nZ24excCenfjRazs4cqrMkRzGWOkbn7Y/9zQPv7GLlIQo/vPqQY5m6RASyB9nj6a6Rrn31e1UVNtz\niqb9Wekbn1VeVcP8ZdsJDw1i4a0XEhLk/I973+7h/PrG4ezMPsUv/7HP6TjGDzn/W2BMG1mwOo39\nuWf49Y3D6dk5zOk4X5s6tDfzJiTy0ueZfJ6e73Qc42es9I1P+jw9n8XrDzFnfIJHXjR9eOoFJEWH\n8+PXd1JUVuV0HONHrPSNzykur+LHr+8kKTqcR6c5ex7/XDqEBPLbm0Zy4nQFP1/Z6IC1xrQJK33j\ncxa8n8bx4nJ+c9NIOoR47sxWI+K6cN+l/XnriyN8su+E03GMn7DSNz5lW1Yhf9mcxdzxiW02xEJr\nmn9pf/r3iOCnf/uKskq7m8e0PSt94zOqamr5z7e+pFfnMH581UCn47glJCiAX1w7lJzCMp5dc8Dp\nOMYPWOkbn7HoswzSck/zxIyhRIR6z8PmY5O6cVNKLC+sy2Df8WKn4xgf51bpi8hUEUkTkXQReaSR\n9+8RkS9FZIeIrBeRwa7liSJS5lq+Q0T+1No7YAzA0VNl/O7jA1w1pCffGdzT6Tjn7dFpg+jcIZjH\n3v4KT5vYyPiWJktfRAKBhcA0YDAw62yp17NMVYep6kjgaeA39d47qKojXR/3tFZwY+p7+v191Cr8\n5JqGP5reISo8hIenDmRbViF/33XM6TjGh7lzpD8GSFfVDFWtBJYDM+qvoKr1/yYNB+xQxbSb7YcL\neWfHUe68uK9XT0h+w+g4BvfuzC9X7aW8yi7qmrbhTunHANn1Xue4lv0TEblPRA5Sd6R/f723+orI\nFyLyqYhc3KK0xjRQW6v8/O976NEplHun9Hc6TosEBgg//e5gjhaV88K6DKfjGB/lTuk3NtXPN47k\nVXWhqvYDHgZ+4lp8DIhX1VHAQ8AyEen8jW8gcpeIpIpIal5envvpjd97Z8cRdmaf4uGpFxDuRRdv\nz2V8v25MHdKLP6w9SG5xudNxjA9yp/RzgPrj0cYCR79l/eXAtQCqWqGqJ12fbwMOAgMabqCqi1Q1\nRVVToqPbf6xz453Kq2p4+v00RsRGct2ob/zx6bUevfoCqmuUBavTnI5ifJA7pb8VSBaRviISAswE\nVtZfQUSS6728BjjgWh7tuhCMiCQByYD93WpaxdKNmRwvLufRqwcR4ENzzyZ0C2fexETe3J7D/tzT\nTscxPqbJ0lfVamA+sBrYC6xQ1d0i8oSITHetNl9EdovIDupO48x1LZ8M7BKRncAbwD2qWtDqe2H8\nTnF5FX9Ye5DJA6IZl9TN6Tit7oeX9CMiJIj//cCO9k3rcuskqKquAlY1WPazep8/cI7t3gTebElA\nYxrzwmcZnCqt4j+85Mnb8xUVHsKdk5P4zYf72Zl9ql3n9DW+zZ7INV4n/0wFL6w/xDXDejM0JtLp\nOG3mtkl96Roewq/taN+0Iit943UWfpJORXUtD135jXsCfEpEaBD3TunHugP5bDx40uk4xkdY6Ruv\ncvRUGa9uOswNF8bSLzrC6Thtbva4BHpHhvHrD9JseAbTKqz0jVf549qDKMr9VyQ3vbIPCAsO5P7L\nk9mWVcja/fYMi2k5K33jNY4XlfPa1mxuGB1LTJcOTsdpN2f393drDtjRvmkxK33jNZ7/7CA1ql4/\n3ML5Cg4M4J4p/dh++BQb7Ny+aSErfeMV8k5XsGzzYa4bFePVg6o1142jY+nZOZTffWwTrZiWsdI3\nXuGFdRlU1dRy36X+dZR/VlhwIHdN7semjAK2Ztrzjab5rPSNxysoqeSVTVlMH9GHvt3DnY7jmFvG\nxNM9IoTnbFpF0wJW+sbjLV6fQVlVDfMv88+j/LM6hARyx8VJrDuQz47sU07HMV7KSt94tNPlVSzd\nkMXVQ3vTv0cnp+M4bva4BLp0DOZ3drRvmslK33i0v245zOmKau65pJ/TUTxCRGgQ8yYksmbfCRuB\n0zSLlb7xWJXVtSxef4gJ/boxLNZ3x9g5X3PGJxIWHMCiz2yUcnP+rPSNx/rbjiPkFldwtx3l/5Ou\n4SHclBLH33Yc4XiRza5lzo+VvvFItbXKn9dlcEGvTkxO7u50HI9zx6QkamqVlzYccjqK8TJW+sYj\nrd1/gv25Z7jnkn6I+M6sWK0lvltHpg3rzbJNhzldXuV0HONF3Cp9EZkqImkiki4ijzTy/j0i8qWI\n7BCR9SIyuN57j7q2SxORq1ozvPFdf/o0gz6RYVwzvLfTUTzW3ZOTOF1RzfIt2U5HMV6kydJ3zXG7\nEJgGDAZm1S91l2WqOkxVRwJPA79xbTuYujl1hwBTgT+cnTPXmHP54nAhWw4VcPvFSQQH2h+j5zI8\ntgvjkrry4ueHqKqpdTqO8RLu/EaNAdJVNUNVK4HlwIz6K6hqcb2X4cDZoQBnAMtVtUJVDwHprq9n\nzDkt+iyDyA7BzLwozukoHu/uyf04VlTO33cedTqK8RLulH4MUP/vxxzXsn8iIveJyEHqjvTvP59t\njTkr62QJ7+8+zuxx8YSHujWFs1+bMjCagT07seizDBt22bjFndJv7CraN366VHWhqvYDHgZ+cj7b\nishdIpIqIql5eTZRhD9bujGLQBHmjE90OopXEBHunJzEvuOnWZ+e73Qc4wXcKf0coP7f2bHAt/0t\nuRy49ny2VdVFqpqiqinR0dFuRDK+qKSimhWp2Uwb1puencOcjuM1vjeiN90jQnnp80ynoxgv4E7p\nbwWSRaSviIRQd2F2Zf0VRKT+3HXXAGcHBlkJzBSRUBHpCyQDW1oe2/iit784wunyauZNSHA6ilcJ\nDQpk9rh4Pt53goy8M07HMR6uydJX1WpgPrAa2AusUNXdIvKEiEx3rTZfRHaLyA7gIWCua9vdwApg\nD/A+cJ+q1rTBfhgvp6os3ZjJ0JjOXBgf5XQcr3Pr2ARCAgNYsiHT6SjGw7l1pUxVVwGrGiz7Wb3P\nH/iWbX8B/KK5AY1/2Jhxkv25Z3j6huH2MFYzRHcK5bsjevP6thweunIgkR2CnY5kPJTdBG08wpIN\nmUR1DGb6iD5OR/Fat03sS2llDa+n2sNa5tys9I3jcgpL+XBPLjPHxBMWbM/uNdfQmEjGJHbl5Q2Z\n1NTa7ZumcVb6xnF/2XQYqJsgxLTMbZMSySks48M9uU5HMR7KSt84qryqhuVbD3Pl4F7EdOngdByv\n9x3X/48vfW6jb5rGWekbR63ccZRTpVXMnZDodBSfEBggzJ2QwOZDBew+WuR0HOOBrPSNY1SVlzdk\nMrBnJ8YldXU6js+4OSWejiGB9rCWaZSVvnHMtqxC9hwrZs6EBLtNsxVFdgzm+gtjWbnjKHmnK5yO\nYzyMlb5xzMsbMukcFsR1o2wMvtY2b2IilTW1LN9y2OkoxsNY6RtH5BaX8/5Xx7kpJY6OITaaZmvr\nFx3BxcndeXXzYaptrH1Tj5W+ccSrm7KoUbXRNNvQnPGJHC8ut9s3zT+x0jftrqK6hmVbDnPZwB7E\nd+vodByfddkFPYjp0oElGzOdjmI8iJW+aXervjxG/plKu02zjQUGCN8fn8CmjALSjp92Oo7xEFb6\npt0t2ZBFUnQ4k/p3dzqKz7spJY6QoABe2ZTpdBTjIaz0TbvamX2KHdmnmDMugYAAu02zrXUND2H6\niD68tf0IxeVVTscxHsBK37SrJRsyCQ8J5PrRsU5H8RtzxydSWlnDm9tynI5iPICVvmk3+WcqeHfX\nMW4YHUunMBvvvb0Mi41kVHwXXtmYRa2Nvun33Cp9EZkqImkiki4ijzTy/kMiskdEdonIGhFJqPde\njYjscH2sbLit8R9/3XyYyppa5tgF3HY3Z3wCGfklfH7QJk/3d02WvogEAguBacBgYJaIDG6w2hdA\niqoOB94Anq73XpmqjnR9TMf4paqaWv6yOYuLk7vTLzrC6Th+5+phvekWHsKSDVlORzEOc+dIfwyQ\nrqoZqloJLAdm1F9BVT9R1VLXy02AnbA1/2T17uPkFlcwz47yHREaFMisMfGs2ZdLdkFp0xsYn+VO\n6ccA9edfy3EtO5fbgX/Uex0mIqkisklErm1GRuMDlmzIJL5rR6YM7OF0FL91y9h4BPjLZjva92fu\nlH5j99U1ejVIRGYDKcCCeovjVTUFuAV4RkT6NbLdXa5/GFLz8vLciGS8ye6jRWzNLOT74xIItNs0\nHdOnSweuHNyLFVuzKa+qcTqOcYg7pZ8DxNV7HQscbbiSiFwBPAZMV9Wvx3NV1aOu/80A1gKjGm6r\nqotUNUVVU6Kjo89rB4znW7ohiw7BgdyUEtf0yqZNzZmQQGFpFX/f+Y1fYeMn3Cn9rUCyiPQVkRBg\nJvBPd+GIyCjgeeoK/0S95VEiEur6vDswEdjTWuGN5yssqeSdHUe4dlQMkR3tNk2njU/qRnKPCJZu\nzELVbt/0R02WvqpWA/OB1cBeYIWq7haRJ0Tk7N04C4AI4PUGt2YOAlJFZCfwCfBLVbXS9yOvpWZT\nUV3L3Ak26bknEBHmjE/gyyNF7Mg+5XQc4wC3BjJX1VXAqgbLflbv8yvOsd0GYFhLAhrvVVOrvLIx\ni3FJXbmgV2en4xiX6y6M5Vfvp7F0Yxaj4qOcjmPamT2Ra9rMR3tzOXKqzG7T9DARoUHcMDqW93Yd\ns+kU/ZCVvmkzSzZk0icyjCsG9XQ6imlg9rgEKmtqeW2rTafob6z0TZs4kHuaDQdPcuu4BIIC7cfM\n0/TvEcGk/jadoj+y30bTJpZszCQkKIBZY+KdjmLOYc74BI4VlfOBTafoV6z0TasrLq/ire1HmD6i\nD13DQ5yOY87h8kE9iY3qwJINmU5HMe3ISt+0utdTcyitrLELuB4uMED4/rgENh8qYO+xYqfjmHZi\npW9aVW2t8srGTEYnRDE0JtLpOKYJN6XEERoUwNKNmU5HMe3ESt+0qk/355F5stQmPfcSUeEhXDsy\nhre/OEJRqU2n6A+s9E2renlDJj06hTJ1SC+noxg3zZ2QSHlVLStSs5te2Xg9K33Tag7ll/Dp/jxu\nGRtPSJD9aHmLwX06MyaxK0s3ZVJj0yn6PPvNNK1m6cZMggOFW8babZreZs6EBLILylibdqLplY1X\ns9I3reJMRTVvpOZw9bDe9OgU5nQcc56uGtKLXp3DeNlu3/R5VvqmVby1PYfTFdV2m6aXCg4M4Nax\n8aw7kM/BvDNOxzFtyErftFhtrfLyhkxGxHWxURu92Mwx8YQEBvDKRptO0ZdZ6ZsWW5eeT0ZeCT+w\no3yvFt0plGuG9+aNbTmcqah2Oo5pI1b6psVe/vwQ0Z1CuXpYb6ejmBaaOyGRMxXVvLktx+kopo24\nVfoiMlVE0kQkXUQeaeT9h0Rkj4jsEpE1IpJQ7725InLA9TG3NcMb5x3KL+GTtDxutds0fcLIuC6M\niOvCko2ZNp2ij2ryt1REAoGFwDRgMDBLRAY3WO0LIEVVhwNvAE+7tu0KPA6MBcYAj4uInfT1IUs2\n2G2avmbu+AQy8kpYn57vdBTTBtw5NBsDpKtqhqpWAsuBGfVXUNVPVLXU9XITEOv6/CrgQ1UtUNVC\n4ENgautEN047XV7FG9ty+O7wPnabpg+5ZnhvukeE2OibPsqd0o8B6j+fneNadi63A/9o5rbGi7zp\nuuBnt2n6ltCgQGaNiWfNvhNkF5Q2vYHxKu6UvjSyrNGTfSIyG0gBFpzPtiJyl4ikikhqXl6eG5GM\n02prlSUbsxgVX3cO2PiWW8bGEyDCK5vs9k1f407p5wBx9V7HAkcbriQiVwCPAdNVteJ8tlXVRaqa\noqop0dHR7mY3Dvr0QB6H8kvsKN9H9Y7swNQhvXhtazZllTVOxzGtyJ3S3woki0hfEQkBZgIr668g\nIqOA56kr/PqDd6wGrhSRKNcF3Ctdy4yXW+IaTXPaULtN01fNnZBIUVkVb39xxOkophU1WfqqWg3M\np66s9wIrVHW3iDwhItNdqy0AIoDXRWSHiKx0bVsAPEndPxxbgSdcy4wXy8g7w9q0PGaPS7DbNH3Y\nRYlRDI3pzIufH6LWRt/0GUHurKSqq4BVDZb9rN7nV3zLti8CLzY3oPE8SzdmERJok577OhHh9kl9\nefC1nXx6II9LB/ZwOpJpBXaYZs5LUVkVr6dm893hvYnuFOp0HNPGrhnWh56dQ3lx/SGno5hWYqVv\nzsvyLYcpqazh9ov7Oh3FtIOQoADmTkhk3YF89h23ydN9gZW+cVtVTS0vb8hkQr9uDOljk577i1vG\nxNMhONCO9n2Elb5x26ovj3GsqJw7L05yOoppR106hnDD6Fje+eIoeacrmt7AeDQrfeMWVeXP6zLo\nFx3OJQPsWQp/84OJiVTV1trDWj7ASt+4ZVNGAV8dKeaOi5MICGjsQWvjy5KiI7j8gh68uimL8ip7\nWMubWekbt7ywLoNu4SFcN8qGTvJXt09K4mRJJe/Yw1pezUrfNOlg3hnW7DvB7HEJhAUHOh3HOGRc\nUleG9OnM4vWHbKx9L2alb5q0eP0hQoIC+P74hKZXNj7r7MNaB06c4bMDNta+t7LSN9/q5JkK3tyW\nw7+MiqF7hD2M5e/q5k4I5YV1GU5HMc1kpW++1aubD1NRXcsd9jCWoe5hrXkT6x7W+upIkdNxTDNY\n6ZtzKqusYcmGTC4dGE3/Hp2cjmM8xOxxCXQKDeJPnx50OoppBit9c06vb8vmZEklP5zS3+koxoN0\nDgvm1nEJrPryGFknS5yOY86Tlb5pVFVNLc9/msHohCguSrS57M0/u21iIkGBASz6zM7texsrfdOo\nd3cd5cipMn54ST9E7GEs8896dA7jhtGxvL4thxOny52OY86Dlb75htpa5Y9rDzKwZycuu8DGUDeN\nu+viJKprannp80yno5jz4Fbpi8hUEUkTkXQReaSR9yeLyHYRqRaRGxq8V+OaTevrGbWMZ/t43wn2\n557hnik25II5t8Tu4Uwb1pu/bMyiuLzK6TjGTU2WvogEAguBacBgYJaIDG6w2mFgHrCskS9Rpqoj\nXR/TG3nfeBBV5Q9r04mN6sD3hvdxOo7xcD+8pB+nK6p5ddNhp6MYN7lzpD8GSFfVDFWtBJYDM+qv\noKqZqroLqG2DjKYdbTlUwPbDp7hrchJBgXb2z3y7oTGRXJzcncXrD9lAbF7Cnd/qGCC73usc1zJ3\nhYlIqohsEpFrzyudaXd/WHuQbuEh3Dg6zukoxkv8cEo/8s9U8Ma2HKejGDe4U/qNndQ9n9GW4lU1\nBbgFeEZE+n3jG4jc5fqHITUvL+88vrRpTV/mFPHp/jxum9SXDiE2sJpxz/ikblwY34U/rj1IZbX9\nse/p3Cn9HKD+YV8scNTdb6CqR13/mwGsBUY1ss4iVU1R1ZToaJugwynPrtlPZIdgG1jNnBcR4YEr\nBnDkVJkd7XsBd0p/K5AsIn1FJASYCbh1F46IRIlIqOvz7sBEYE9zw5q289WRIj7ae4LbJ/Wlc1iw\n03GMl5mc3J2RcV1Y+Em6He17uCZLX1WrgfnAamAvsEJVd4vIEyIyHUBELhKRHOBG4HkR2e3afBCQ\nKiI7gU+AX6qqlb4HeuajA3QOC2LexESnoxgvVHe0n8yRU2W8td2O9j1ZkDsrqeoqYFWDZT+r9/lW\n6k77NNxuAzCshRlNG6s7ys/lwSsG2FG+abYpA6IZERvJ7z9J5/rRsQTb3V8eyf6rGJ5bY0f5puXO\nHu3nFJbx9nabUtFTWen7ud1Hi/hgTy63TepLZAc7yjctc+nAHgx3He1X1di5fU9kpe/nnltzgE5h\nQfxgok2SYlpORHjg8mQOF5TaBOoeykrfj32ZU8Tq3bncNtGO8k3rueyCHgyLieS5jw/YnTweyErf\njz29eh9RHYO53aZCNK1IRPjxVQPJLihj+VYbk8fTWOn7qQ0H81l3IJ97p/S3O3ZMq5uc3J1xSV15\nbk06JRXVTscx9Vjp+yFV5en30+gdGWZP35o2ISL8x9QLyD9TwUufH3I6jqnHSt8Pfbgnlx3Zp3jg\n8mTCgm2MHdM2LoyP4juDe/L8pxkUllQ6Hce4WOn7mZpaZcHqNJK6h3PD6G88T2dMq/r3qwZyprKa\nP3560OkoxsVK38+888URDpw4w79dOdDGyzdtbkDPTlw3KoYlGzI5VlTmdByDlb5fKaus4X8/SGNY\nTCTThvZyOo7xEw9eMYBaVZ758IDTUQxW+n5l8foMjhaV89g1g2zuW9Nu4rp2ZM74RFZsy2b30SKn\n4/g9K30/caK4nD+sPchVQ3oyLqmb03GMn7n/smS6dAjmqXf3ono+czCZ1mal7yf+94P9VNXU8ui0\nQU5HMX4osmMwP7piABszTvLhnlyn4/g1K30/sOdoMSu2ZTN3fCKJ3cOdjmP81C1j4+nfI4L/XrXX\nhmdwkJW+j1NVnnpvD106BPOvlyU7Hcf4seDAAB67ZhCZJ0tZujHT6Th+y63SF5GpIpImIuki8kgj\n708Wke0iUi0iNzR4b66IHHB9zG2t4MY9H+zJZcPBk/zoigFEdrThFoyzLh3Yg8kDonl2zQEK7IEt\nRzRZ+iISCCwEpgGDgVkiMrjBaoeBecCyBtt2BR4HxgJjgMdFJKrlsY07yipreOLvexjQM4JbxsY7\nHccYAH56zSBKK2t4+v19TkfxS+4c6Y8B0lU1Q1UrgeXAjPorqGqmqu4CGp6ouwr4UFULVLUQ+BCY\n2gq5jRt+/8kBjpwq48kZQ23qOuMxknt24vZJfVm+NZttWYVOx/E77jRBDJBd73WOa5k7WrKtaYGD\neWdY9FkG/zIqhrF2i6bxMA9cnkyvzmH85J2vqLYZttqVO6Xf2FM87t5o69a2InKXiKSKSGpeXp6b\nX9qci6ry+N92ExYUyCNXX+B0HGO+ITw0iMe/N5i9x4pZujHL6Th+xZ3SzwHi6r2OBY66+fXd2lZV\nF6lqiqqmREdHu/mlzbm89+Ux1qfn829XDqBHpzCn4xjTqKlDe3HJgGh+8+F+covLnY7jN9wp/a1A\nsoj0FZEQYCaw0s2vvxq4UkSiXBdwr3QtM22kqLSKn/99D0P6dGb2OBsr33guEeHn04dQWVPLk+/u\ncTqO32iy9FW1GphPXVnvBVao6m4ReUJEpgOIyEUikgPcCDwvIrtd2xYAT1L3D8dW4AnXMtNGnnpv\nDwUllfzq+uE2iqbxeIndw5l/aX/e3XWMj+xJ3XYhnjYORkpKiqampjodwyutO5DH9xdv4d4p/fiP\nqXYu33iHyupapv9+PYWllXzw4CVEdrDnSZpDRLapakpT69mhoI8oqajmkTe/JCk6nPsvtydvjfcI\nCQpgwQ0jyD9TyVN2mqfNWelQg/aQAAAPM0lEQVT7iAWr0zhaVMbT1w+3KRCN1xkWG8ndk5N4fVsO\na9NOOB3Hp1np+4ANB/NZsjGTOeMSSEns6nQcY5rl/suT6d8jgkff+pLT5VVOx/FZVvperqi0in9b\nsZO+3cJ5eJqdxzfeKyw4kAU3DCe3uJzHV+52Oo7PstL3cj/921fkna7gmZkj6RgS5HQcY1pkVHwU\n/3pZMm9tP8LKne4+DmTOh5W+F3vni7pfjB9dkczw2C5OxzGmVfzrZf25ML4Lj739JTmFpU7H8TlW\n+l4qp7CUn77zFSkJUfxwSn+n4xjTaoICA3h25ihU4cHXdlBT61m3lXs7K30vVFFdw33LvgDgtzeP\nJNAmOTc+Jq5rR568dghbMwv5/cfpTsfxKVb6Xui/39vLzuxTLLhxOHFdOzodx5g2cd2oWK4bFcMz\na/az7oANxNharPS9zMqdR1myMYs7JvVl6tDeTscxpk394rqhDOjRifv/+gVHTpU5HccnWOl7kfQT\np3nkzV2MToiy2zONX+gYEsQfZ19IdY1y71+2UVFd43Qkr2el7yWKyqq4+5VtdAgOZOEtF9pMWMZv\nJEVHsODGEezMKeLnf7dhGlrKmsMLVNfUMn/Zdg4XlLLw1gvpFWlj5Bv/MnVoL+65pB/LNh9m6cZM\np+N4NXuaxws89d5e1h3I51fXD2OcTX1o/NS/XzWQ9BOn+a+Vu4nv2pEpA3s4Hckr2ZG+h3tlUxYv\nb8jkzov7cvNF8U7HMcYxgQHCszNHcUGvzsxf9gX7jhc7HckrWel7sI/25PJfK3dz2QU9eGTaIKfj\nGOO48NAgFs9LITw0kNtfTuWETbN43twqfRGZKiJpIpIuIo808n6oiLzmen+ziCS6lieKSJmI7HB9\n/Kl14/uuLYcKuG/Zdob06cxzs0bZA1jGuPSO7MDiuRdRWFrJ9xdv4VRppdORvEqTpS8igcBCYBow\nGJglIoMbrHY7UKiq/YHfAr+q995BVR3p+rinlXL7tL3Hirl9yVZiojrw0ryLiAi1Sy/G1Dc0JpI/\nz0nhUH4J817aSklFtdORvIY7R/pjgHRVzVDVSmA5MKPBOjOAJa7P3wAuFxE7NG2GjLwzzHlxC+Eh\nQbxy+1i6RYQ6HckYjzSxf3eemzWKL48UcdcrqZRX2T387nCn9GOA7Hqvc1zLGl3HNZF6EXD2NpO+\nIvKFiHwqIhe3MK9PO5h3hpmLNlFbq7xy+xhiunRwOpIxHm3q0F48ff1wPk8/yX2vbrfid4M7pd/Y\nEXvDYe/Otc4xIF5VRwEPActEpPM3voHIXSKSKiKpeXn+OcbGwbwzzFq0iVpV/nrXOJJ7dnI6kjFe\n4frRsTx17VDW7DvBnUtTKau04v827pR+DhBX73Us0HB2g6/XEZEgIBIoUNUKVT0JoKrbgIPAgIbf\nQFUXqWqKqqZER0ef/154uX3Hi+uO8FX5653jGGCFb8x5mT0ugadvGM769Hx+8PIWztg5/nNyp/S3\nAski0ldEQoCZwMoG66wE5ro+vwH4WFVVRKJdF4IRkSQgGchonei+YcuhAm7800YCBP56px3hG9Nc\nN6XE8czNI9maWcj3F2+msMTu6mlMk6XvOkc/H1gN7AVWqOpuEXlCRKa7VlsMdBORdOpO45y9rXMy\nsEtEdlJ3gfceVS1o7Z3wVqt3H2f24s1EdwrlzR9OsMI3poVmjIxh4S0XsvtoMf/yxw1k5pc4Hcnj\niKpnzUqTkpKiqampTsdoU6rK4vWH+O9VexkR14UX515EVHiI07GM8RmpmQXcuTQVEeHPc1IYnRDl\ndKQ2JyLbVDWlqfXsidx2Vl5Vw7+t2MlT7+3lqiG9ePWOsVb4xrSylMSuvH3vRDqHBTHrz5t4+4sc\npyN5DCv9dnS8qJybn9/IW18c4aHvDGDhLRfSMcQevDKmLSR2D+eteycyKq4LD762k5++85WNx4+V\nfrv5aE8u0579jAMnzvCn2aO5//JkAmxoBWPaVNfwEF69Yyx3T07ilU1Z3PT8Jr+fgctKv42VV9Xw\nXyt3c8fSVHpHdmDl/ElMHdrL6VjG+I2gwAAevXoQf5o9mowTZ5j2zGf8bccRPO16ZnuxcwttaGf2\nKR5+cxf7jp/mtol9eXjaQEKDAp2OZYxfmjq0F4N6d+KhFTt5YPkOPtidy1PXDvW7a2pW+m2gtLKa\n33ywnxc/P0R0p1BemncRl15gEz4Y47SEbuGsuHs8z392kN9+uJ/Nhwr42fcG873hvfGX4cLsls1W\npKp8uCeXJ9/bQ3ZBGbeMjeeRaRfQOSzY6WjGmAb2HC3mkbd2sSuniAn9uvHEjKH07xHhdKxmc/eW\nTSv9VrLnaDFPvruHjRkn6d8jgqeuHWpTGxrj4WpqlWVbDrPg/X2UVdUwd3wi913a3ytP+Vjpt5ND\n+SX8/uN03voihy4dgnnwOwOYNSae4EC7Rm6Mt8g/U8HT7+/jjW05hIcEcfclSdw2qa9X3VJtpd/G\nDuad4fcfp/O3HUcICQrg++MSmH9pMpEd7VSOMd5qf+5pFqxO48M9uXQLD2HuhETmjE+gS0fPP/K3\n0m8Dqsrn6Sd5eUMma/blEhYUyOxx8dw1uR/RnWyyE2N8xbasQhZ+ks7H+07QMSSQmRfF84OJicR1\n7eh0tHOy0m9FBSWV/H3nUV7ZlEX6iTN0Cw9h1ph45k1MpLvNbGWMz9p3vJhFn2bwt51HqVXl4uRo\nbhkTx+WDenrcKVwr/RYqr6rh430neGv7EdamnaC6VhkeG8nc8YlcM7w3YcF2v70x/uJYURmvbc3m\nta3ZHCsqp3tEKNcM68V3R/RhdHyURzxdb6XfDAUllXyy7wQf7c3ls/15lFTW0KNTKNeOiuG6UTEM\n6v2NSb+MMX6kuqaWT/fn8XpqDp+knaCiupbekWFMG9qbyy7owUV9oxx7ANNK3w1llTVsP1zI5oyT\nbDh4ku2HC6lV6NEplMsH9eTqYb2Y0K87gR7wr7gxxrOcqajmoz25vLvrKJ/tz6eyppYOwYGM79eN\nKQOjGdu3G8k9ItrtrwAr/QZqa5XMkyV8dbSYr44UsS2rkF05p6iqUQIEhsZEMmVgD64Y1IOhfSI9\n4s81Y4x3KK2sZlPGSdam5bE2LY/DBaUAdAoL4sL4KFISorgwIYpBvTvTtY2eAWjV0heRqcCzQCDw\ngqr+ssH7ocBSYDRwErhZVTNd7z0K3A7UAPer6upv+14tLf3aWuXIqTIy8kvIyDtDRl4Jabmn2XO0\n+Ot5M0MCAxgS05mxfbsxNqkrKQlRdLKnZo0xreTwyVK2ZhaQmlXItqwC9uee+fq9np1DuaBXZwb1\n7szAXhEkdgunb/fwFt8W6m7pN/nkgWuO24XAd6ibAH2riKxU1T31VrsdKFTV/iIyE/gVcLOIDKZu\nTt0hQB/gIxEZoKqtPqh1bnE5c1/cwqH8Eiqqa79e3ik0iH49IrhuVAxDYzozNCaSAT07edyVd2OM\n74jv1pH4bh25fnQsAEWlVXx5pIi9x4rZe7yYvcdOs+FgBlU1/3/QHdUxmEnJ0fxu1qg2zebO42Zj\ngHRVzQAQkeXADKB+6c8A/sv1+RvA76Vu9KIZwHJVrQAOuebQHQNsbJ34/y+qYwixUR24OLk7SdER\n9O0eTlJ0ONERoX4zkJIxxjNFdgxmUnJ3JiV3/3pZZXUthwtKOZRfQmZ+CYdOlhDVDg93ulP6MUB2\nvdc5wNhzraOq1SJSBHRzLd/UYNuYZqf9FiFBAbww96K2+NLGGNPqQoIC6N8jot0HeXPnHEdjh8kN\nLwScax13tkVE7hKRVBFJzcvLcyOSMcaY5nCn9HOAuHqvY4Gj51pHRIKASKDAzW1R1UWqmqKqKdHR\n0e6nN8YYc17cKf2tQLKI9BWREOouzK5ssM5KYK7r8xuAj7XutqCVwEwRCRWRvkAysKV1ohtjjDlf\nTZ7Td52jnw+spu6WzRdVdbeIPAGkqupKYDHwiutCbQF1/zDgWm8FdRd9q4H72uLOHWOMMe7xm4ez\njDHGl7l7n77drG6MMX7ESt8YY/yIlb4xxvgRjzunLyJ5QFYLvkR3IL+V4jjJV/YDbF88la/si6/s\nB7RsXxJUtcl73j2u9FtKRFLduZjh6XxlP8D2xVP5yr74yn5A++yLnd4xxhg/YqVvjDF+xBdLf5HT\nAVqJr+wH2L54Kl/ZF1/ZD2iHffG5c/rGGGPOzReP9I0xxpyDz5W+iDwpIrtEZIeIfCAifZzO1Fwi\nskBE9rn2520R6eJ0puYSkRtFZLeI1IqI191pISJTRSRNRNJF5BGn87SEiLwoIidE5Cuns7SEiMSJ\nyCcistf1s/WA05maS0TCRGSLiOx07cvP2+x7+drpHRHprKrFrs/vBwar6j0Ox2oWEbmSuhFLq0Xk\nVwCq+rDDsZpFRAYBtcDzwI9V1WsGWHJNGbqfelOGArMaTBnqNURkMnAGWKqqQ53O01wi0hvorarb\nRaQTsA241hv/u7hmGgxX1TMiEgysBx5Q1U1NbHrefO5I/2zhu4TTyKQt3kJVP1DVatfLTdTNR+CV\nVHWvqqY5naOZvp4yVFUrgbNThnolVf2MutFwvZqqHlPV7a7PTwN7aaOZ+dqa1jk7e3qw66NNusvn\nSh9ARH4hItnArcDPnM7TSm4D/uF0CD/V2JShXlkuvkpEEoFRwGZnkzSfiASKyA7gBPChqrbJvnhl\n6YvIRyLyVSMfMwBU9TFVjQNeBeY7m/bbNbUvrnUeo24+gledS9o0d/bFS7k17adxhohEAG8CP2rw\nl75XUdUaVR1J3V/0Y0SkTU69uTMxusdR1SvcXHUZ8B7weBvGaZGm9kVE5gLfBS5XD78Acx7/XbyN\nW9N+mvbnOv/9JvCqqr7ldJ7WoKqnRGQtMBVo9YvtXnmk/21EJLney+nAPqeytJSITAUeBqaraqnT\nefyYO1OGmnbmuvi5GNirqr9xOk9LiEj02bvzRKQDcAVt1F2+ePfOm8BA6u4UyQLuUdUjzqZqHtf0\nk6HASdeiTV58J9J1wO+AaOAUsENVr3I2lftE5GrgGf5/ytBfOByp2UTkr8AU6kZ0zAUeV9XFjoZq\nBhGZBKwDvqTu9x3gP1V1lXOpmkdEhgNLqPv5CgBWqOoTbfK9fK30jTHGnJvPnd4xxhhzblb6xhjj\nR6z0jTHGj1jpG2OMH7HSN8YYP2Klb4wxfsRK3xhj/IiVvjHG+JH/A9FjUJ6qS+cYAAAAAElFTkSu\nQmCC\n", "text/plain": [ "