diff --git a/Chapter1_Introduction/Ch1_Introduction_Gen.ipynb b/Chapter1_Introduction/Ch1_Introduction_Gen.ipynb new file mode 100644 index 00000000..0ab99643 --- /dev/null +++ b/Chapter1_Introduction/Ch1_Introduction_Gen.ipynb @@ -0,0 +1,1146 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Probabilistic Programming\n", + "=====\n", + "and Bayesian Methods for Hackers \n", + "========\n", + "\n", + "\n", + "Original content ([this Jupyter notebook](https://nbviewer.jupyter.org/github/CamDavidsonPilon/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers/blob/master/Chapter1_Introduction/Ch1_Introduction_PyMC2.ipynb)) created by Cam Davidson-Pilon ([`@Cmrn_DP`](https://twitter.com/Cmrn_DP))\n", + "\n", + "Ported to [Gen](https://probcomp.github.io/Gen/) by Sergey Kojoian ([`@heckeop`](https://github.com/heckeop)).\n", + "___\n", + "\n", + "\n", + "Welcome to *Bayesian Methods for Hackers*. The full Github repository is available at [github/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers](https://github.com/CamDavidsonPilon/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers). The other chapters can be found on the project's [homepage](https://camdavidsonpilon.github.io/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers/). We hope you enjoy the book, and we encourage any contributions!\n", + "\n", + "---\n", + "### Table of Contents\n", + "- Dependencies & Prerequisites\n", + "- The Philosophy of Bayesian Inference\n", + "- The Bayesian state of mind\n", + "- Bayesian Inference in Practice\n", + "- Are frequentist methods incorrect then?\n", + "- Our Bayesian framework\n", + "- Example: Mandatory coin-flip example\n", + "- Example: Bug, or just sweet, unintended feature?\n", + "- Probability Distributions\n", + " - Discrete Case\n", + "- Continuous Case\n", + "- But what is $\\lambda \\;$?\n", + " - Example: Inferring behaviour from text-message data\n", + "- Introducing our first hammer: Gen\n", + "- Specify the model\n", + "- Specify the inference algorithm\n", + "- Sample from the posterior\n", + "- Plot the Results\n", + "- Interpretation\n", + "- Exercises\n", + "- References" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "YcJ8nEDVH30J" + }, + "source": [ + "### Dependencies & Prerequisites\n", + "\n", + "
\n", + " If you're running this notebook in Jupyter on your own machine (and you have already installed Julia), you can use the following\n", + "
\n", + " \n", + "
" + ] + }, + { + "cell_type": "code", + "execution_count": 163, + "metadata": {}, + "outputs": [], + "source": [ + "using Gen;\n", + "using Gen: bernoulli, logpdf, beta, poisson, exponential, uniform_discrete;\n", + "using Gen: Trace;\n", + "using PyPlot;\n", + "using DelimitedFiles;\n", + "using Statistics: mean;" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Chapter 1\n", + "======\n", + "***" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The Philosophy of Bayesian Inference\n", + "------\n", + " \n", + "> You are a skilled programmer, but bugs still slip into your code. After a particularly difficult implementation of an algorithm, you decide to test your code on a trivial example. It passes. You test the code on a harder problem. It passes once again. And it passes the next, *even more difficult*, test too! You are starting to believe that there may be no bugs in this code...\n", + "\n", + "If you think this way, then congratulations, you already are thinking Bayesian! Bayesian inference is simply updating your beliefs after considering new evidence. A Bayesian can rarely be certain about a result, but he or she can be very confident. Just like in the example above, we can never be 100% sure that our code is bug-free unless we test it on every possible problem; something rarely possible in practice. Instead, we can test it on a large number of problems, and if it succeeds we can feel more *confident* about our code, but still not certain. Bayesian inference works identically: we update our beliefs about an outcome; rarely can we be absolutely sure unless we rule out all other alternatives. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "### The Bayesian state of mind\n", + "\n", + "\n", + "Bayesian inference differs from more traditional statistical inference by preserving *uncertainty*. At first, this sounds like a bad statistical technique. Isn't statistics all about deriving *certainty* from randomness? To reconcile this, we need to start thinking like Bayesians. \n", + "\n", + "The Bayesian world-view interprets probability as measure of *believability in an event*, that is, how confident we are in an event occurring. In fact, we will see in a moment that this is the natural interpretation of probability. \n", + "\n", + "For this to be clearer, we consider an alternative interpretation of probability: *Frequentist*, known as the more *classical* version of statistics, assume that probability is the long-run frequency of events (hence the bestowed title). For example, the *probability of plane accidents* under a frequentist philosophy is interpreted as the *long-term frequency of plane accidents*. This makes logical sense for many probabilities of events, but becomes more difficult to understand when events have no long-term frequency of occurrences. Consider: we often assign probabilities to outcomes of presidential elections, but the election itself only happens once! Frequentists get around this by invoking alternative realities and saying across all these realities, the frequency of occurrences defines the probability. \n", + "\n", + "Bayesians, on the other hand, have a more intuitive approach. Bayesians interpret a probability as measure of *belief*, or confidence, of an event occurring. Simply, a probability is a summary of an opinion. An individual who assigns a belief of 0 to an event has no confidence that the event will occur; conversely, assigning a belief of 1 implies that the individual is absolutely certain of an event occurring. Beliefs between 0 and 1 allow for weightings of other outcomes. This definition agrees with the probability of a plane accident example, for having observed the frequency of plane accidents, an individual's belief should be equal to that frequency, excluding any outside information. Similarly, under this definition of probability being equal to beliefs, it is meaningful to speak about probabilities (beliefs) of presidential election outcomes: how confident are you candidate *A* will win?\n", + "\n", + "Notice in the paragraph above, I assigned the belief (probability) measure to an *individual*, not to Nature. This is very interesting, as this definition leaves room for conflicting beliefs between individuals. Again, this is appropriate for what naturally occurs: different individuals have different beliefs of events occurring, because they possess different *information* about the world. The existence of different beliefs does not imply that anyone is wrong. Consider the following examples demonstrating the relationship between individual beliefs and probabilities:\n", + "\n", + "- I flip a coin, and we both guess the result. We would both agree, assuming the coin is fair, that the probability of Heads is 1/2. Assume, then, that I peek at the coin. Now I know for certain what the result is: I assign probability 1.0 to either Heads or Tails (whichever it is). Now what is *your* belief that the coin is Heads? My knowledge of the outcome has not changed the coin's results. Thus we assign different probabilities to the result. \n", + "\n", + "- Your code either has a bug in it or not, but we do not know for certain which is true, though we have a belief about the presence or absence of a bug. \n", + "\n", + "- A medical patient is exhibiting symptoms $x$, $y$ and $z$. There are a number of diseases that could be causing all of them, but only a single disease is present. A doctor has beliefs about which disease, but a second doctor may have slightly different beliefs. \n", + "\n", + "\n", + "This philosophy of treating beliefs as probability is natural to humans. We employ it constantly as we interact with the world and only see partial truths, but gather evidence to form beliefs. Alternatively, you have to be *trained* to think like a frequentist. \n", + "\n", + "To align ourselves with traditional probability notation, we denote our belief about event $A$ as $P(A)$. We call this quantity the *prior probability*.\n", + "\n", + "John Maynard Keynes, a great economist and thinker, said \"When the facts change, I change my mind. What do you do, sir?\" This quote reflects the way a Bayesian updates his or her beliefs after seeing evidence. Even — especially — if the evidence is counter to what was initially believed, the evidence cannot be ignored. We denote our updated belief as $P(A |X )$, interpreted as the probability of $A$ given the evidence $X$. We call the updated belief the *posterior probability* so as to contrast it with the prior probability. For example, consider the posterior probabilities (read: posterior beliefs) of the above examples, after observing some evidence $X$:\n", + "\n", + "1\\. $P(A): \\;\\;$ the coin has a 50 percent chance of being Heads. $P(A | X):\\;\\;$ You look at the coin, observe a Heads has landed, denote this information $X$, and trivially assign probability 1.0 to Heads and 0.0 to Tails.\n", + "\n", + "2\\. $P(A): \\;\\;$ This big, complex code likely has a bug in it. $P(A | X): \\;\\;$ The code passed all $X$ tests; there still might be a bug, but its presence is less likely now.\n", + "\n", + "3\\. $P(A):\\;\\;$ The patient could have any number of diseases. $P(A | X):\\;\\;$ Performing a blood test generated evidence $X$, ruling out some of the possible diseases from consideration.\n", + "\n", + "\n", + "It's clear that in each example we did not completely discard the prior belief after seeing new evidence $X$, but we *re-weighted the prior* to incorporate the new evidence (i.e. we put more weight, or confidence, on some beliefs versus others). \n", + "\n", + "By introducing prior uncertainty about events, we are already admitting that any guess we make is potentially very wrong. After observing data, evidence, or other information, we update our beliefs, and our guess becomes *less wrong*. This is the alternative side of the prediction coin, where typically we try to be *more right*. \n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "### Bayesian Inference in Practice\n", + "\n", + " If frequentist and Bayesian inference were programming functions, with inputs being statistical problems, then the two would be different in what they return to the user. The frequentist inference function would return a number, representing an estimate (typically a summary statistic like the sample average etc.), whereas the Bayesian function would return *probabilities*.\n", + "\n", + "For example, in our debugging problem above, calling the frequentist function with the argument \"My code passed all $X$ tests; is my code bug-free?\" would return a *YES*. On the other hand, asking our Bayesian function \"Often my code has bugs. My code passed all $X$ tests; is my code bug-free?\" would return something very different: probabilities of *YES* and *NO*. The function might return:\n", + "\n", + "\n", + "> *YES*, with probability 0.8; *NO*, with probability 0.2\n", + "\n", + "\n", + "\n", + "This is very different from the answer the frequentist function returned. Notice that the Bayesian function accepted an additional argument: *\"Often my code has bugs\"*. This parameter is the *prior*. By including the prior parameter, we are telling the Bayesian function to include our belief about the situation. Technically this parameter in the Bayesian function is optional, but we will see excluding it has its own consequences. \n", + "\n", + "\n", + "#### Incorporating evidence\n", + "\n", + "As we acquire more and more instances of evidence, our prior belief is *washed out* by the new evidence. This is to be expected. For example, if your prior belief is something ridiculous, like \"I expect the sun to explode today\", and each day you are proved wrong, you would hope that any inference would correct you, or at least align your beliefs better. Bayesian inference will correct this belief.\n", + "\n", + "\n", + "Denote $N$ as the number of instances of evidence we possess. As we gather an *infinite* amount of evidence, say as $N \\rightarrow \\infty$, our Bayesian results (often) align with frequentist results. Hence for large $N$, statistical inference is more or less objective. On the other hand, for small $N$, inference is much more *unstable*: frequentist estimates have more variance and larger confidence intervals. This is where Bayesian analysis excels. By introducing a prior, and returning probabilities (instead of a scalar estimate), we *preserve the uncertainty* that reflects the instability of statistical inference of a small $N$ dataset. \n", + "\n", + "One may think that for large $N$, one can be indifferent between the two techniques since they offer similar inference, and might lean towards the computationally-simpler, frequentist methods. An individual in this position should consider the following quote by Andrew Gelman (2005)[1], before making such a decision:\n", + "\n", + "> Sample sizes are never large. If $N$ is too small to get a sufficiently-precise estimate, you need to get more data (or make more assumptions). But once $N$ is \"large enough,\" you can start subdividing the data to learn more (for example, in a public opinion poll, once you have a good estimate for the entire country, you can estimate among men and women, northerners and southerners, different age groups, etc.). $N$ is never enough because if it were \"enough\" you'd already be on to the next problem for which you need more data.\n", + "\n", + "### Are frequentist methods incorrect then? \n", + "\n", + "**No.**\n", + "\n", + "Frequentist methods are still useful or state-of-the-art in many areas. Tools such as least squares linear regression, LASSO regression, and expectation-maximization algorithms are all powerful and fast. Bayesian methods complement these techniques by solving problems that these approaches cannot, or by illuminating the underlying system with more flexible modeling.\n", + "\n", + "\n", + "#### A note on *Big Data*\n", + "Paradoxically, big data's predictive analytic problems are actually solved by relatively simple algorithms [2]. Thus we can argue that big data's prediction difficulty does not lie in the algorithm used, but instead on the computational difficulties of storage and execution on big data. (One should also consider Gelman's quote from above and ask \"Do I really have big data?\")\n", + "\n", + "The much more difficult analytic problems involve *medium data* and, especially troublesome, *really small data*. Using a similar argument as Gelman's above, if big data problems are *big enough* to be readily solved, then we should be more interested in the *not-quite-big enough* datasets. \n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Our Bayesian framework\n", + "\n", + "We are interested in beliefs, which can be interpreted as probabilities by thinking Bayesian. We have a *prior* belief in event $A$, beliefs formed by previous information, e.g., our prior belief about bugs being in our code before performing tests.\n", + "\n", + "Secondly, we observe our evidence. To continue our buggy-code example: if our code passes $X$ tests, we want to update our belief to incorporate this. We call this new belief the *posterior* probability. Updating our belief is done via the following equation, known as Bayes' Theorem, after its discoverer Thomas Bayes:\n", + "\n", + "\\begin{align}\n", + " P( A | X ) = & \\frac{ P(X | A) P(A) } {P(X) } \\\\\\\\[5pt]\n", + "& \\propto P(X | A) P(A)\\;\\; (\\propto \\text{is proportional to })\n", + "\\end{align}\n", + "\n", + "The above formula is not unique to Bayesian inference: it is a mathematical fact with uses outside Bayesian inference. Bayesian inference merely uses it to connect prior probabilities $P(A)$ with an updated posterior probabilities $P(A | X )$." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### Example: Mandatory coin-flip example\n", + "\n", + "Every statistics text must contain a coin-flipping example, I'll use it here to get it out of the way. Suppose, naively, that you are unsure about the probability of heads in a coin flip (spoiler alert: it's 50%). You believe there is some true underlying ratio, call it $p$, but have no prior opinion on what $p$ might be. \n", + "\n", + "We begin to flip a coin, and record the observations: either $H$ or $T$. This is our observed data. An interesting question to ask is how our inference changes as we observe more and more data? More specifically, what do our posterior probabilities look like when we have little data, versus when we have lots of data. \n", + "\n", + "Below we plot a sequence of updating posterior probabilities as we observe increasing amounts of data (coin flips)." + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [], + "source": [ + "probs_of_heads = range(0., stop=1., length=100)\n", + "\n", + "@gen function binomial_conjugate_model(n::Int64)\n", + " # Flip a fair coin $n times\n", + " flips = map(i -> @trace(bernoulli(0.5), (:flip, i)), 1:n)\n", + " heads = sum(flips)\n", + " \n", + " # Get probabilities of the bernoulli parameter from a beta distribution\n", + " betalogpdf = x -> logpdf(beta, x, 1 + heads, 1 + n - heads)\n", + " log_observed_probs_heads = betalogpdf.(probs_of_heads)\n", + " observed_probs_heads = exp.(log_observed_probs_heads)\n", + " return observed_probs_heads\n", + "end;" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "\"\"\"\n", + "The book uses a custom matplotlibrc file, which provides the unique styles for\n", + "matplotlib plots. If executing this book, and you wish to use the book's\n", + "styling, provided are two options:\n", + " 1. Overwrite your own matplotlibrc file with the rc-file provided in the\n", + " book's styles/ dir. See http://matplotlib.org/users/customizing.html\n", + " 2. Also in the styles is bmh_matplotlibrc.json file. This can be used to\n", + " update the styles in only this notebook. Try running the following code:\n", + "\n", + " import JSON\n", + " using PyCall\n", + " s = open(\"../styles/bmh_matplotlibrc.json\") do file\n", + " read(file, String)\n", + " end\n", + " rcParams = PyCall.PyDict(matplotlib.\"rcParams\")\n", + " merge!(rcParams, JSON.parse(s))\n", + "\n", + "\"\"\"\n", + "\n", + "function render_trace(trace) \n", + " # Pull out xs from the trace\n", + " n = get_args(trace)[1]\n", + " heads = sum(trace[(:flip, i)] for i=1:n)\n", + " \n", + " # Pull out observed probabilities\n", + " observed_probs_heads = Gen.get_retval(trace)\n", + " \n", + " # Draw distribution\n", + " ax = gca()\n", + " setp(ax.get_yticklabels(), visible=false)\n", + " plot(probs_of_heads, observed_probs_heads, label=\"observe $n tosses,\\n $heads heads\")\n", + " fill_between(probs_of_heads, 0, observed_probs_heads, color=\"#348ABD\", alpha=0.4)\n", + " vlines(0.5, 0, 4, color=\"k\", linestyles=\"--\", lw=1)\n", + " leg = legend()\n", + " leg.get_frame().set_alpha(0.4)\n", + " autoscale(tight=true)\n", + "end;" + ] + }, + { + "cell_type": "code", + "execution_count": 82, + "metadata": {}, + "outputs": [], + "source": [ + "function grid(renderer::Function, traces; ncols=2)\n", + " figure(figsize=(11, 9))\n", + " nrows = length(traces)/2\n", + " for (i, trace) in enumerate(traces)\n", + " subplot(nrows, ncols, i)\n", + " xlabel(if i in [1, length(traces)] \"\\$p\\$, probability of heads\" else nothing end)\n", + " renderer(trace)\n", + " end\n", + " suptitle(\"Bayesian updating of posterior probabilities\",\n", + " y=1.02,\n", + " fontsize=14)\n", + " tight_layout()\n", + "end;" + ] + }, + { + "cell_type": "code", + "execution_count": 83, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "Figure(PyObject
)" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "n_trials = [1, 2, 3, 4, 5, 6, 8, 15, 50, 500]\n", + "traces = [Gen.simulate(binomial_conjugate_model, (n,)) for n in n_trials]\n", + "grid(render_trace, traces)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The posterior probabilities are represented by the curves, and our uncertainty is proportional to the width of the curve. As the plot above shows, as we start to observe data our posterior probabilities start to shift and move around. Eventually, as we observe more and more data (coin-flips), our probabilities will tighten closer and closer around the true value of $p=0.5$ (marked by a dashed line). \n", + "\n", + "Notice that the plots are not always *peaked* at 0.5. There is no reason it should be: recall we assumed we did not have a prior opinion of what $p$ is. In fact, if we observe quite extreme data, say 8 flips and only 1 observed heads, our distribution would look very biased *away* from lumping around 0.5 (with no prior opinion, how confident would you feel betting on a fair coin after observing 8 tails and 1 head?). As more data accumulates, we would see more and more probability being assigned at $p=0.5$, though never all of it.\n", + "\n", + "The next example is a simple demonstration of the mathematics of Bayesian inference. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### Example: Bug, or just sweet, unintended feature?\n", + "\n", + "\n", + "Let $A$ denote the event that our code has **no bugs** in it. Let $X$ denote the event that the code passes all debugging tests. For now, we will leave the prior probability of no bugs as a variable, i.e. $P(A) = p$. \n", + "\n", + "We are interested in $P(A|X)$, i.e. the probability of no bugs, given our debugging tests $X$. To use the formula above, we need to compute some quantities.\n", + "\n", + "What is $P(X | A)$, i.e., the probability that the code passes $X$ tests *given* there are no bugs? Well, it is equal to 1, for a code with no bugs will pass all tests. \n", + "\n", + "$P(X)$ is a little bit trickier: The event $X$ can be divided into two possibilities, event $X$ occurring even though our code *indeed has* bugs (denoted $\\sim A\\;$, spoken *not $A$*), or event $X$ without bugs ($A$). $P(X)$ can be represented as:" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\\begin{align}\n", + "P(X ) & = P(X \\text{ and } A) + P(X \\text{ and } \\sim A) \\\\\\\\[5pt]\n", + " & = P(X|A)P(A) + P(X | \\sim A)P(\\sim A)\\\\\\\\[5pt]\n", + "& = P(X|A)p + P(X | \\sim A)(1-p)\n", + "\\end{align}" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We have already computed $P(X|A)$ above. On the other hand, $P(X | \\sim A)$ is subjective: our code can pass tests but still have a bug in it, though the probability there is a bug present is reduced. Note this is dependent on the number of tests performed, the degree of complication in the tests, etc. Let's be conservative and assign $P(X|\\sim A) = 0.5$. Then\n", + "\n", + "\\begin{align}\n", + "P(A | X) & = \\frac{1\\cdot p}{ 1\\cdot p +0.5 (1-p) } \\\\\\\\\n", + "& = \\frac{ 2 p}{1+p}\n", + "\\end{align}\n", + "This is the posterior probability. What does it look like as a function of our prior, $p \\in [0,1]$? " + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "Figure(PyObject
)" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "figure(figsize=(12.5, 4))\n", + "p = range(0, stop=1, length=50)\n", + "plot(p, 2 .* p ./ (1 .+ p), color=\"#348ABD\", lw=3)\n", + "scatter(0.2, 2*(0.2)/1.2, s=140, c=\"#348ABD\")\n", + "xlim(0, 1)\n", + "ylim(0, 1)\n", + "xlabel(\"Prior, \\$P(A) = p\\$\")\n", + "ylabel(\"Posterior, \\$P(A|X)\\$, with \\$P(A) = p\\$\")\n", + "title(\"Are there bugs in my code?\");" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can see the biggest gains if we observe the $X$ tests passed when the prior probability, $p$, is low. Let's settle on a specific value for the prior. I'm a strong programmer (I think), so I'm going to give myself a realistic prior of 0.20, that is, there is a 20% chance that I write code bug-free. To be more realistic, this prior should be a function of how complicated and large the code is, but let's pin it at 0.20. Then my updated belief that my code is bug-free is 0.33. \n", + "\n", + "Recall that the prior is a probability: $p$ is the prior probability that there *are no bugs*, so $1-p$ is the prior probability that there *are bugs*.\n", + "\n", + "Similarly, our posterior is also a probability, with $P(A | X)$ the probability there is no bug *given we saw all tests pass*, hence $1-P(A|X)$ is the probability there is a bug *given all tests passed*. What does our posterior probability look like? Below is a chart of both the prior and the posterior probabilities. \n" + ] + }, + { + "cell_type": "code", + "execution_count": 69, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABBAAAAF2CAYAAADX8GsQAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAAPYQAAD2EBqD+naQAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nOzdeVhU1f8H8PdlmWGTRXYQARVNKMUfhiKmppjirmUuFUiKaeISWkolmym5Yy65JKhlaZllqeFCYmUq7pmaioobAq7gCjKc3x8+c78O2wyIDur79TzzPN17zz33M2dmyPu5Z5GEEAJERERERERERBUw0HcARERERERERFTzMYFARERERERERFoxgUBEREREREREWjGBQERERERERERaMYFARERERERERFoxgUBEREREREREWjGBQERERERERERaMYFARERERERERFoxgUBEREREREREWjGBQET0jFi2bBkkSUJmZqa+Q6lWkiQhNjZW32E8cbGxsZAkSd9hVLu0tDRIkoQ1a9ZUW52DBg2ChYWFTmVLfp/K+t20a9cO7dq1q7b4qsOePXvQqlUrmJubQ5IkHDx4sMxy6vezd+/eJxwhERE9D5hAICKqAdT/6Fe/TExM0LBhQ0RERCAnJ0ff4dV4mZmZGu1naGiIunXronfv3uXeaD2qrKwsxMbGPrb6qebQ92d9//599O3bF9euXcPs2bPx9ddfw93dXS+xUNV9++23SExM1HcYRESPxEjfARAR0f/Ex8fD09MT9+7dw19//YUvv/wSGzduxL///gszM7MKz33nnXfQv39/KJXKJxRtzTNgwAB06dIFKpUKx44dw5dffonffvsNu3btgq+vb7VeKysrC3FxcfDw8Kj2ugHg008/xYQJE6q93ufd3bt3YWRU8T9/Nm/erLH9uD9rbU6dOoWzZ89iyZIlGDJkyBO/PlWPb7/9Fv/++y/GjBmj71CIiKqMCQQiohokODgYzZs3BwAMGTIEtra2mDVrFtatW4cBAwaUec7t27dhbm4OQ0NDGBoaVlssd+7c0Zq0qGn+7//+D2+//ba8HRgYiB49euDLL7/EokWL9BiZ7tSfp5GRkdYbXV0JIXDv3j2YmppWS30Pu3fvHhQKBQwMno5OjSYmJlrLKBSKJxCJ7nJzcwEA1tbWeo6kZlL/ZoiI6PF7Ov5vT0T0nGrfvj0A4MyZMwD+N9Rh+/bteP/99+Hg4IA6depoHCs5B8KCBQvg4+MDpVIJFxcXjBgxAjdu3NAo065dO7z44ovYt28f2rRpAzMzM3z88cflxvXPP/9g0KBBqFevHkxMTODk5IR3330XV69e1SinHsefkZGBQYMGwdraGlZWVggLC8OdO3c0yhYUFOCDDz6Avb09atWqhR49euDChQtVaje1ku0HPLjZGDt2LNzc3KBUKtGoUSPMmDEDQgiNc7ds2YLWrVvD2toaFhYWaNSokdwmaWlpePnllwEAYWFh8tCJZcuWyefv3r0bnTt3hpWVFczMzNC2bVvs2LGjzPY5evQoBg4cCBsbG7Ru3Vrj2MOKioowadIk1K9fH0qlEh4eHvj4449RUFCgUc7DwwPdunXDpk2b0Lx5c5iamlaYQHn482/VqhVMTU3h6emJhQsXapRTz1+watUqfPrpp3B1dYWZmRny8/MBAKdPn0bfvn1Ru3ZtmJmZoWXLltiwYUOZ11SpVPj444/h5OQEc3Nz9OjRA+fPn9co8+eff6Jv376oW7culEol3Nzc8MEHH+Du3btl1nn69Gl06tQJ5ubmcHFxQXx8fKnPVZc5NR6eA6GizzomJgbGxsa4fPlyqTqGDh0Ka2tr3Lt3r8Jr/f7773jllVdgbm4Oa2tr9OzZE8eOHZOPDxo0CG3btgUA9O3bF5Ik6TQ/w507d/Dee+/B1tYWlpaWCAkJwfXr1zXKlNcWHh4eGDRokMa+f/75B23btoWpqSnq1KmDzz77DMnJyaX+5uzduxedOnWCnZ2d/D169913tcar/s5u3rwZvr6+MDExgbe3N9auXatRrqK/gQBw8eJFvPvuu3B0dIRSqYSPjw+SkpJKXW/u3Lnw8fGBmZkZbGxs0Lx5c3z77bcaZXSpS/2b+P777zF58mTUqVMHJiYm6NChAzIyMuRy7dq1w4YNG3D27Fn5O+Th4aG1XYiIahr2QCAiqsFOnToFALC1tdXY//7778Pe3h7R0dG4fft2uefHxsYiLi4OQUFBGD58OI4fP44vv/wSe/bswY4dO2BsbCyXvXr1KoKDg9G/f3+8/fbbcHR0LLfeLVu24PTp0wgLC4OTkxOOHDmCxYsX48iRI9i1a1epG98333wTnp6eSEhIwP79+/HVV1/BwcEBU6dOlcsMGTIE33zzDQYOHIhWrVrh999/R9euXSvVXiWVbD8hBHr06IFt27Zh8ODB8PX1xaZNm/Dhhx/i4sWLmD17NgDgyJEj6NatG5o0aYL4+HgolUpkZGTICYDGjRsjPj4e0dHRGDp0KF555RUAQKtWrQA8uCkMDg6Gn58fYmJiYGBggOTkZLRv3x5//vkn/P39NeLs27cvvLy8MGXKlFI3vA8bMmQIli9fjjfeeANjx47F7t27kZCQgGPHjuGnn37SKHv8+HEMGDAA7733HsLDw9GoUaMK2+r69evo0qUL3nzzTQwYMADff/89hg8fDoVCUeoGcNKkSVAoFBg3bhwKCgqgUCiQk5ODVq1a4c6dOxg1ahRsbW2xfPly9OjRA2vWrEHv3r016pg8eTIkScL48eORm5uLxMREBAUF4eDBg3JPiR9++AF37tzB8OHDYWtri/T0dMydOxcXLlzADz/8oFGfSqVC586d0bJlS0ybNg0pKSmIiYlBUVER4uPjK3zvFanos27dujXi4+OxevVqREREyOcUFhZizZo1eP311yvs8bB161YEBwejXr16iI2Nxd27dzF37lwEBgZi//798PDwwHvvvQdXV1dMmTIFo0aNwssvv1zhb1MtIiIC1tbWiI2NlX/3Z8+elW94K+PixYt49dVXIUkSoqKiYG5ujq+++qrUcKnc3Fy89tprsLe3x4QJE2BtbY3MzMxSSYDynDx5Ev369cOwYcMQGhqK5ORk9O3bFykpKejYsaNG2bL+Bubk5KBly5aQJAkRERGwt7fHb7/9hsGDByM/P18eOrBkyRKMGjUKb7zxBkaPHo179+7hn3/+we7duzFw4MBK1aX2+eefw8DAAOPGjUNeXh6mTZuGt956C7t37wYAfPLJJ8jLy8OFCxfkvzO6TvxJRFSjCCIi0rvk5GQBQGzdulVcvnxZnD9/XqxatUrY2toKU1NTceHCBY1yrVu3FkVFRWXWcebMGSGEELm5uUKhUIjXXntNqFQqudy8efMEAJGUlCTva9u2rQAgFi5cqFO8d+7cKbXvu+++EwDEH3/8Ie+LiYkRAMS7776rUbZ3797C1tZW3j548KAAIN5//32NcgMHDhQARExMTIXxnDlzRgAQcXFx4vLlyyI7O1ukpaWJZs2aCQDixx9/FEII8fPPPwsA4rPPPtM4/4033hCSJImMjAwhhBCzZ88WAMTly5fLveaePXsEAJGcnKyxv7i4WHh5eYlOnTqJ4uJief+dO3eEp6en6NixY6n2GTBgQKn61cdKttGQIUM0yo0bN04AEL///ru8z93dXQAQKSkp5cb/MPXnP3PmTHlfQUGB8PX1FQ4ODqKwsFAIIcS2bdsEAFGvXr1S34ExY8YIAOLPP/+U9928eVN4enoKDw8P+TuorsPV1VXk5+fLZb///nsBQMyZM0ejzUpKSEgQkiSJs2fPyvtCQ0MFADFy5Eh5X3FxsejatatQKBQan2PJ71PJ3426Pdq2bStvl/dZCyFEQECAaNGihca+tWvXCgBi27Ztpco/TN2+V69elfcdOnRIGBgYiJCQEHmfus1++OGHCut7+P34+fnJn5sQQkybNk0AEOvWrZP3lffbcnd3F6GhofL2yJEjhSRJ4sCBA/K+q1evitq1a2u03U8//SQAiD179miNs6xrPvxbFUKIvLw84ezsLJo1a1bq/ZX1N3Dw4MHC2dlZXLlyRWN///79hZWVlfx96tmzp/Dx8akwHl3rUn82jRs3FgUFBXK5OXPmCADi8OHD8r6uXbsKd3d3HVqDiKjm4hAGIqIaJCgoCPb29nBzc0P//v1hYWGBn376Ca6urhrlwsPDtc53sHXrVhQWFmLMmDEa49PDw8NhaWlZqmu5UqlEWFiYTnE+PJb+3r17uHLlClq2bAkA2L9/f6nyw4YN09h+5ZVXcPXqVbnr+8aNGwEAo0aN0ihX2cnGYmJiYG9vDycnJ7Rr1w6nTp3C1KlT0adPH/k6hoaGpa4zduxYCCHw22+/AfjfWPN169ahuLi4UjEcPHgQJ0+exMCBA3H16lVcuXIFV65cwe3bt9GhQwf88ccfpeos2T5lUbdRZGRkqdgBlPo8PT090alTJ53jNjIywnvvvSdvKxQKvPfee8jNzcW+ffs0yoaGhpaaT2Hjxo3w9/eXh2AAD56wDh06FJmZmTh69KhG+ZCQENSqVUvefuONN+Ds7Cy/T0Dze3b79m1cuXIFrVq1ghACBw4cKPUeHu4FoH5yXFhYiK1bt+raDJUWEhKC3bt3y71dAGDlypVwc3OThx6U5dKlSzh48CAGDRqE2rVry/ubNGmCjh07arRDVQwdOlSjh9Hw4cNhZGRUpXpTUlIQEBCgMYFk7dq18dZbb2mUU/9u1q9fj/v371f6Oi4uLho9VdRDLw4cOIDs7GyNsiX/Bgoh8OOPP6J79+4QQsi/uytXrqBTp07Iy8uT/zZZW1vjwoUL2LNnT5lxVKYutbCwMI25M9Q9VU6fPl3pdiAiqsmYQCAiqkHmz5+PLVu2YNu2bTh69Kg8prskT09PrXWdPXsWAEp1XVcoFKhXr558XM3V1VXnyeOuXbuG0aNHw9HREaamprC3t5djysvLK1W+bt26Gts2NjYAII/JPnv2LAwMDFC/fn2Nctq63Zc0dOhQbNmyBampqdi3bx9yc3Px0UcfycfPnj0LFxcXjRtX4EE3dfVxAOjXrx8CAwMxZMgQODo6on///vj+++91SiacPHkSwIObbHt7e43XV199hYKCglJtpOvnaWBggAYNGmjsd3JygrW1danPU5c6H+bi4lJqIrqGDRsCQKl5Ncqq++zZs2V+XiXbVs3Ly0tjW5IkNGjQQONa586dk2+wLSwsYG9vL9+Ul2xDAwMD1KtXT6f4q1O/fv2gVCqxcuVKOa7169fjrbfeqnCoQHm/T+BBm6mTTlVVsn0tLCzg7OxcpbY4e/Zsqe8dgFL72rZti9dffx1xcXGws7NDz549kZycXGqOjvI0aNCgVJvp+h28fPkybty4gcWLF5f63akTo+rJKMePHw8LCwv4+/vDy8sLI0aM0JifpDJ1qWn7G0dE9KzgHAhERDWIv7+/vApDRR7HbPqVqfPNN9/E33//jQ8//BC+vr6wsLBAcXExOnfuXOZNdnm9JUQF4/2rwsvLC0FBQY9cj6mpKf744w9s27YNGzZsQEpKClavXo327dtj8+bNFfb+UL//6dOnl7vkX8mxz5Vpe13Hrz+O78iTqFtNpVKhY8eOuHbtGsaPH48XXngB5ubmuHjxIgYNGlTpniGPi42NDbp164aVK1ciOjoaa9asQUFBgcZqIE8blUpVpfMkScKaNWuwa9cu/Prrr9i0aRPeffddzJw5E7t27arWMf8lv4Pq78Pbb7+N0NDQMs9p0qQJgAcJmuPHj2P9+vVISUnBjz/+iAULFiA6OhpxcXGVqkvtSf2NIyLSNyYQiIieUe7u7gAeTKb38JPZwsJCnDlzpso32tevX0dqairi4uIQHR0t71c/ea9qrMXFxTh16pTGE9njx49Xuc7yrrN161bcvHlToxfCf//9Jx9XMzAwQIcOHdChQwfMmjULU6ZMwSeffIJt27YhKCio3Bt5dS8KS0vLaklmPBx7cXExTp48KT/VBx5M9nbjxg2N2KsiKyur1HJ4J06cAACdZot3d3cv8/Mqq22B0t8XIQQyMjLkG7PDhw/jxIkTWL58OUJCQuRyW7ZsKfP6xcXFOH36tPzEurLxV0Rb0iYkJAQ9e/bEnj17sHLlSjRr1gw+Pj4VnvPw77Ok//77D3Z2do+0NOHJkyfx6quvytu3bt3CpUuX0KVLF3mfjY1NqRVZCgsLcenSpVKxPryigFpZ+wCgZcuWaNmyJSZPnoxvv/0Wb731FlatWoUhQ4ZUGHNGRgaEEBrtretnqF69RaVS6fS7Mzc3R79+/dCvXz8UFhaiT58+mDx5MqKioipdl64qO3klEVFNxCEMRETPqKCgICgUCnzxxRcaT8GWLl2KvLy8Kq9woH7SVvLJWmJiYpVjDQ4OBgB88cUX1VZnWbp06QKVSoV58+Zp7J89ezYkSZLjuHbtWqlz1b0J1N2x1Td3JW/A/Pz8UL9+fcyYMQO3bt0qVU9ZS/7pGjtQuk1mzZoFAI+8YkVRUZHGUo+FhYVYtGgR7O3t4efnp1N86enp2Llzp7zv9u3bWLx4MTw8PODt7a1RfsWKFbh586a8vWbNGly6dEn+DMr6ngkhMGfOnHJjePhzFUJg3rx5MDY2RocOHbTGX5HyPmu14OBg2NnZYerUqdi+fbtOvQ+cnZ3h6+uL5cuXa9T777//YvPmzRo3+lWxePFijXkIvvzySxQVFcntCzxIdv3xxx+lzivZA6FTp07YuXMnDh48KO+7du2aPGxD7fr166X+LpT83VQkKytLYzWR/Px8rFixAr6+vnBycqrwXENDQ7z++uv48ccf8e+//5Y6/vDvruRyswqFAt7e3hBC4P79+5WqqzLMzc3LHOJFRPQ0YQ8EIqJnlL29PaKiohAXF4fOnTujR48eOH78OBYsWICXX365yl2sLS0t0aZNG0ybNg3379+Hq6srNm/ejDNnzlQ5Vl9fXwwYMAALFixAXl4eWrVqhdTU1HKfcFZV9+7d8eqrr+KTTz5BZmYmmjZtis2bN2PdunUYM2aM3HsgPj4ef/zxB7p27Qp3d3fk5uZiwYIFqFOnjjxJYP369WFtbY2FCxeiVq1aMDc3R4sWLeDp6YmvvvoKwcHB8PHxQVhYGFxdXXHx4kVs27YNlpaW+PXXXysde9OmTREaGorFixfjxo0baNu2LdLT07F8+XL06tVL42lzVbi4uGDq1KnIzMxEw4YNsXr1ahw8eBCLFy/WmIyvPBMmTMB3332H4OBgjBo1CrVr18by5ctx5swZ/PjjjxoTeQIPJuFr3bo1wsLCkJOTg8TERDRo0ADh4eEAgBdeeAH169fHuHHjcPHiRVhaWuLHH38sd0y5iYkJUlJSEBoaihYtWuC3337Dhg0b8PHHH8Pe3v6R2qaizxoAjI2N0b9/f8ybNw+GhoYYMGCATvVOnz4dwcHBCAgIwODBg+VlHK2srBAbG/tIMRcWFqJDhw5488035d9969at0aNHD7nMkCFDMGzYMLz++uvo2LEjDh06hE2bNsHOzk6jro8++gjffPMNOnbsiJEjR8rLONatWxfXrl2Tn6wvX74cCxYsQO/evVG/fn3cvHkTS5YsgaWlpU4JkYYNG2Lw4MHYs2cPHB0dkZSUhJycHCQnJ+v0nj///HNs27YNLVq0QHh4OLy9vXHt2jXs378fW7dulRODr732GpycnBAYGAhHR0ccO3YM8+bNQ9euXeWeSbrWVRl+fn5YvXo1IiMj8fLLL8PCwgLdu3evdD1ERHr1xNd9ICKiUtRLk2lb/qyicmUtRyfEg2UbX3jhBWFsbCwcHR3F8OHDxfXr1zXKtG3bVuuyZg+7cOGC6N27t7C2thZWVlaib9++Iisrq9SycOqlCEsuh1hWrHfv3hWjRo0Stra2wtzcXHTv3l2cP3++Uss4Tp8+XWvsN2/eFB988IFwcXERxsbGwsvLS0yfPl1jycXU1FTRs2dP4eLiIhQKhXBxcREDBgwQJ06c0Khr3bp1wtvbWxgZGZVa5u/AgQOiT58+wtbWViiVSuHu7i7efPNNkZqaqrV9Hj72sPv374u4uDjh6ekpjI2NhZubm4iKihL37t3TKOfu7i66du2qtS3U1J//3r17RUBAgDAxMRHu7u5i3rx5GuW0LSd46tQp8cYbbwhra2thYmIi/P39xfr168us47vvvhNRUVHCwcFBmJqaiq5du2oszSiEEEePHhVBQUHCwsJC2NnZifDwcHHo0KFSbR0aGirMzc3FqVOnxGuvvSbMzMyEo6OjiImJ0VjCVIiqLeMoRMWftRBCpKenCwDitddeK7NtyrN161YRGBgoTE1NhaWlpejevbs4evRomW1WmWUct2/fLoYOHSpsbGyEhYWFeOuttzSWixRCCJVKJcaPHy/s7OyEmZmZ6NSpk8jIyCi1jKMQD77Pr7zyilAqlaJOnToiISFBfPHFFwKAyM7OFkIIsX//fjFgwABRt25doVQqhYODg+jWrZvYu3ev1rjV39lNmzaJJk2aCKVSKV544YVS71nb38qcnBwxYsQI4ebmJoyNjYWTk5Po0KGDWLx4sVxm0aJFok2bNvJvs379+uLDDz8UeXl5la6rvM9G/Tfp4e/JrVu3xMCBA4W1tbUAwCUdieipJAnB2V2IiIieZ+3atcOVK1fK7K5Nujl06BB8fX2xYsUKvPPOO/oO54kYM2YMFi1ahFu3bmldVlYbDw8PvPjii1i/fn01RUdERI8D50AgIiIiekRLliyBhYUF+vTpo+9QHou7d+9qbF+9ehVff/01Wrdu/cjJAyIienpwDgQiIiKiKvr1119x9OhRLF68GBEREY+0ckJNFhAQgHbt2qFx48bIycnB0qVLkZ+fj4kTJ+o7NCIieoKYQCAiIiKqopEjRyInJwddunRBXFycvsN5bLp06YI1a9Zg8eLFkCQJ//d//4elS5eiTZs2+g6NiIieIM6BQERERERERERacQ4EIiIiIiIiItKKCQQiIiIiIiIi0uq5mwOhuLgYWVlZqFWrFiRJ0nc4RERERERERHojhMDNmzfh4uICA4OK+xg8dwmErKwsuLm56TsMIiIiIiIiohrj/PnzqFOnToVlnrsEQq1atQA8aBxLS0s9R0NERERERESkP/n5+XBzc5PvlSvy3CUQ1MMWLC0tmUAgIiIiIiIiAnQa4s9JFImIiIiIiIhIKyYQiIiIiIiIiEgrJhCIiIiIiIiISKvnbg4EXalUKty/f1/fYRDphbGxMQwNDfUdBhERERER1SBMIJQghEB2djZu3Lih71CI9Mra2hpOTk46TaZCRERERETPPiYQSlAnDxwcHGBmZsabJ3ruCCFw584d5ObmAgCcnZ31HBEREREREdUETCA8RKVSyckDW1tbfYdDpDempqYAgNzcXDg4OHA4AxERERER6X8Sxfnz58PDwwMmJiZo0aIF0tPTKyyfmJiIRo0awdTUFG5ubvjggw9w7969aolFPeeBmZlZtdRH9DRT/w44FwgREREREQF67oGwevVqREZGYuHChWjRogUSExPRqVMnHD9+HA4ODqXKf/vtt5gwYQKSkpLQqlUrnDhxAoMGDYIkSZg1a1a1xaUetiCEwO1CVbXVWxXmCkMOoyC94PeOiIiIiIgeptcEwqxZsxAeHo6wsDAAwMKFC7FhwwYkJSVhwoQJpcr//fffCAwMxMCBAwEAHh4eGDBgAHbv3v1Y4rtdqMLEDUceS926mtTVBxZKjjQhIiJ6ntSEhxhETxIfmhE9HfR2Z1pYWIh9+/YhKipK3mdgYICgoCDs3LmzzHNatWqFb775Bunp6fD398fp06exceNGvPPOO08q7GdOZmYmPD09ceDAAfj6+j726w0aNAg3btzAzz//DABo164dfH19kZiYWK3XiY2Nxc8//4yDBw+Wed3HeS0iIqJHVRMeYhA9SXxoRvR00Nuv9MqVK1CpVHB0dNTY7+joiP/++6/McwYOHIgrV66gdevWEEKgqKgIw4YNw8cff1zudQoKClBQUCBv5+fnVyneI5eqdl5V+ThbPpHruLm54dKlS7Czs3si1ytp7dq1MDY21qlsZZIN48aNw8iRIx81vFIkScJPP/2EXr16PfZrERERERER1SRPVZovLS0NU6ZMwYIFC9CiRQtkZGRg9OjRmDRpEiZOnFjmOQkJCYiLi3vCkT4dCgsLoVAo4OTkVC31VEXt2rUf6dolCSGgUqlgYWEBCwuLaq27PE/yWkRE9Px50g8xiJ6kJ/XQjIiqh95WYbCzs4OhoSFycnI09ufk5JR7Qztx4kS88847GDJkCF566SX07t0bU6ZMQUJCAoqLi8s8JyoqCnl5efLr/PnzjxR3A3tzNHKweCyvBvbmVY6rXbt2iIiIQEREBKysrGBnZ4eJEydCCCGX8fDwwKRJkxASEgJLS0sMHToUmZmZkCRJo/v99u3b4e/vD6VSCWdnZ0yYMAFFRUWlrjVmzBjY2dmhU6dOZcakUqkQGRkJa2tr2Nra4qOPPtKIR13XmDFj5O0FCxbAy8sLJiYmcHR0xBtvvAHgwRCE7du3Y86cOZAkCZIkITMzE2lpaZAkCb/99hv8/PygVCrx119/ITY2tswhGXFxcbC3t4elpSWGDRuGwsJCjfYp2bvB19cXsbGx8nEA6N27NyRJkrdLXqu4uBjx8fGoU6cOlEolfH19kZKSIh9Xt/natWvx6quvwszMDE2bNi136A4REREREVFNoLceCAqFAn5+fkhNTZW7gxcXFyM1NRURERFlnnPnzh0YGGjmPNTr05e8MVVTKpVQKpXVFrehJMHI8DHlXVRlJ0F0tXz5cgwePBjp6enYu3cvhg4dirp16yI8PFwuM2PGDERHRyMmJqbMOi5evIguXbpg0KBBWLFiBf777z+Eh4fDxMREvpFWX2v48OHYsWNHufHMnDkTy5YtQ1JSEho3boyZM2fip59+Qvv27cssv3fvXowaNQpff/01WrVqhWvXruHPP/8EAMyZMwcnTpzAiy++iPj4eACAvb09MjMzAQATJkzAjBkzUK9ePdjY2CAtLa1U/ampqTAxMVrkpmkAACAASURBVEFaWhoyMzMRFhYGW1tbTJ48uaJmle3ZswcODg5ITk5G586d5e9eSXPmzMHMmTOxaNEiNGvWDElJSejRoweOHDkCLy8vudwnn3yCGTNmwMvLC5988gkGDBiAjIwMGBk9VR2DiIjoCWlgbw5DTjJHzwCVEMi4fFvfYRBRFej1TiUyMhKhoaFo3rw5/P39kZiYiNu3b8urMoSEhMDV1RUJCQkAgO7du2PWrFlo1qyZPIRh4sSJ6N69e7k3c88TNzc3zJ49G5IkoVGjRjh8+DBmz56tkUBo3749xo4dK2+rb8DVFixYADc3N8ybNw+SJOGFF15AVlYWxo8fj+joaDmB4+XlhWnTplUYT2JiIqKiotCnTx8AD1bZ2LRpU7nlz507B3Nzc3Tr1g21atWCu7s7mjVrBgCwsrKCQqGAmZlZmT1U4uPj0bFjxwrjUSgUSEpKgpmZGXx8fBAfH48PP/wQkyZNKpWYKou9vT0AwNrausJhHzNmzMD48ePRv39/AMDUqVOxbds2JCYmYv78+XK5cePGoWvXrgAe9Izw8fFBRkYGXnjhBa2xEBHR8+exPsQgepIe8aEZEemPXhMI/fr1w+XLlxEdHY3s7Gy5q7d6YsVz585p3Nh9+umnkCQJn376KS5evAh7e3t0795d5yfIz7qWLVtqLH8TEBCAmTNnQqVSyQmW5s2bV1jHsWPHEBAQoFFPYGAgbt26hQsXLqBu3boAAD8/vwrrycvLw6VLl9CiRQt5n5GREZo3b15ub5GOHTvC3d0d9erVQ+fOndG5c2f07t0bZmZmFb9xHd4XADRt2lSjroCAANy6dQvnz5+Hu7u71vN1kZ+fj6ysLAQGBmrsDwwMxKFDhzT2NWnSRP5vZ2dnAEBubi4TCEREREREVCPpva+0etx+WUp2QzcyMkJMTEy53e9JO3Pzqs+z8DjqeVitWrWwf/9+pKWlYfPmzYiOjkZsbCz27NkDa2vrxx6PgYFBqeTG/fv3H7ne8jy8+oQ6YVPeXB5ERERERET6xn5wlaQSAkWq4sfyUpXzZF5Xu3fv1tjetWsXvLy8KjW8o3Hjxti5c6fGjfSOHTtQq1Yt1KlTR+d6rKys4OzsrBFTUVER9u3bV+F5RkZGCAoKwrRp0/DPP/8gMzMTv//+O4AHQxBUKpXOMZR06NAh3L17V97etWsXLCws4ObmBuDBEIVLly7Jx/Pz83HmzBmNOoyNjSuMwdLSEi4uLqXmhtixYwe8vb2rHDsREREREZG+6b0HwtOmJk/4cu7cOURGRuK9997D/v37MXfuXMycObNSdbz//vtITEzEyJEjERERgePHjyMmJgaRkZE6zRPwsNGjR+Pzzz+Hl5cXXnjhBcyaNQs3btwot/z69etx+vRptGnTBjY2Nti4cSOKi4vRqFEjAA9WQdi9ezcyMzNhYWFR6SUgCwsLMXjwYHz66afIzMxETEwMIiIi5PfVvn17LFu2DN27d4e1tTWio6NLJV88PDyQmpqKwMBAKJVK2NjYlLrOhx9+iJiYGNSvXx++vr5ITk7GwYMHsXLlykrFS0REREREVJMwgfAMCQkJwd27d+Hv7w9DQ0OMHj0aQ4cOrVQdrq6u2LhxIz788EM0bdoUtWvXlm+6K2vs2LG4dOkSQkNDYWBggHfffRe9e/dGXl5emeWtra2xdu1axMbG4t69e/Dy8sJ3330HHx8fAA8mHQwNDYW3tzfu3r1bqneANh06dICXlxfatGmDgoICDBgwQGNliaioKJw5cwbdunWDlZUVJk2aVOoaM2fORGRkJJYsWQJXV9dSk1ACwKhRo5CXl4exY8ciNzcX3t7e+OWXXzRWYCAiIiIiInraSKK8Ge2eUfn5+bCyskJeXh4sLS01jt27dw9nzpyBp6cnTExMcKugCBM3HNFTpA9M6uoDC6X2PE+7du3g6+uLxMTEJxAVPQ9K/h6IiOjJefjfIEcu5QMAGjlYcBUGeiYUqYpxPPcWAMDH+cG/x3X9Ny8RVb+K7pFL4v+FiIiIiIiIiEgrpvkqYK4wxKSuPnqPgYiIiIiIiEjfmECogCRJT01XqpJLXhIRERERERFVJw5hICIiIiIiIiKtmEAgIiIiIiIiIq2YQCAiIiIiIiIirZhAICIiIiIiIiKtno4ZAvVECIH7+bf0GoOxpQUkSdJrDERERERERERMIFTgfv4t7Bz0kV5jCFg2DQqrWnqNgYiIiIiIiIhDGEgvYmNj4evr+8SuJ0kSfv75ZwBAZmYmJEnCwYMHq/06Hh4eSExMLPO6j/taREREREREjxN7IOjo6t7DT/R6ts1feqLX0yYtLQ2vvvoqrl+/Dmtr60eub9y4cRg5cmQ1RFZ5bm5uuHTpEuzs7LSWzczMhKenJw4cOKBTwmPPnj0wNzevjjBly5Ytw5gxY3Djxo3Hfi0iIiIiIqLyMIFAT5QQAiqVChYWFrCwsHikuu7fvw9jY+NKn2doaAgnJ6dHunZJhYWFUCgUsLe3r9Z6K/Ikr0VERERERMQhDJVk7eMFm6aNH8vL2serynG1a9cOERERiIiIgJWVFezs7DBx4kQIIeQy169fR0hICGxsbGBmZobg4GCcPHlSPn727Fl0794dNjY2MDc3h4+PDzZu3IjMzEy8+uqrAAAbGxtIkoRBgwYBAIqLi5GQkABPT0+YmpqiadOmWLNmjVxnWloaJEnCb7/9Bj8/PyiVSvz111+lhjAUFxcjPj4ederUgVKphK+vL1JSUuTj6mEHq1evRtu2bWFiYoKVK1eW2RYnT55EmzZtYGJiAm9vb2zZskXjeMkhDNevX8dbb70Fe3t7mJqawsvLC8nJyQAAT09PAECzZs0gSRLatWsHABg0aBB69eqFyZMnw8XFBY0aNQJQ9rCCS5cuITg4GKampqhXr16Z7fNw74KDBw9CkiRkZmYiLS0NYWFhyMvLgyRJkCQJsbGxZV7r3Llz6NmzJywsLGBpaYk333wTOTk58nF1m3/99dfw8PCAlZUV+vfvj5s3b5bZjkRERERERA9jD4RKkoyMYGD8eJqt+BHPX758OQYPHoz09HTs3bsXQ4cORd26dREeHg7gwU3vyZMn8csvv8DS0hLjx49Hly5dcPToURgbG2PEiBEoLCzEH3/8AXNzcxw9ehQWFhZwc3PDjz/+iNdffx3Hjx+HpaUlTE1NAQAJCQn45ptvsHDhQnh5eeGPP/7A22+/DXt7e7Rt21aObcKECZgxYwbq1asHGxsbpKWlacQ+Z84czJw5E4sWLUKzZs2QlJSEHj164MiRI/Dy8tKoZ+bMmWjWrBlMTExKt2FxMfr06QNHR0fs3r0beXl5GDNmTIXtNnHiRBw9ehS//fYb7OzskJGRgbt37wIA0tPT4e/vj61bt8LHxwcKhUI+LzU1FZaWlqUSFGXV//nnn2POnDn4+uuv0b9/fxw+fBiNGzeu8DwAaNWqFRITExEdHY3jx48DQJk9N4qLi+Xkwfbt21FUVIQRI0agX79+Gm196tQp/Pzzz1i/fj2uX7+ON998E59//jkmT56sNRYiIiIiInq+MYHwDHFzc8Ps2bMhSRIaNWqEw4cPY/bs2QgPD5cTBzt27ECrVq0AACtXroSbmxt+/vln9O3bF+fOncPrr7+Ol156MP9CvXr15Lpr164NAHBwcJDnQCgoKMCUKVOwdetWBAQEyOf89ddfWLRokUYCIT4+Hh07diw39hkzZmD8+PHo378/AGDq1KnYtm0bEhMTMX/+fLncmDFj0KdPn3Lr2bp1K/777z9s2rQJLi4uAIApU6YgODi43HPOnTuHZs2aoXnz5gAePNlXUw8TsLW1LTXswdzcHF999ZVGUqEsffv2xZAhQwAAkyZNwpYtWzB37lwsWLCgwvMAQKFQwMrKCpIkVTjsIjU1FYcPH8aZM2fg5uYGAFixYgV8fHywZ88evPzyywAeJBqWLVuGWrUerOzxzjvvIDU1lQkEIiIiIiLSikMYniEtW7aEJEnydkBAAE6ePAmVSoVjx47ByMgILVq0kI/b2tqiUaNGOHbsGABg1KhR+OyzzxAYGIiYmBj8888/FV4vIyMDd+7cQceOHeU5DSwsLLBixQqcOnVKo6z65rws+fn5yMrKQmBgoMb+wMBAOTZd6gGAY8eOwc3NTU4eqNuhIsOHD8eqVavg6+uLjz76CH///XeF5dVeeuklrcmDsq4fEBBQ6n09KvX7VicPAMDb2xvW1tYa1/Lw8JCTBwDg7OyM3Nzcao2FiIiIiIieTUwgkGzIkCE4ffo03nnnHRw+fBjNmzfH3Llzyy1/69YtAMCGDRtw8OBB+XX06FGNcf4Aqm21gMex6kBwcDDOnj2LDz74AFlZWejQoQPGjRv3RGIxMHjwE3x4ror79+8/cr3lKTnppCRJKC5+1MEzRERERET0PGACoZJEURGK7z+elygqeqTYdu/erbG9a9cueHl5wdDQEI0bN0ZRUZFGmatXr+L48ePw9vaW97m5uWHYsGFYu3Ytxo4diyVLlgCA/KRdpVLJZb29vaFUKnHu3Dk0aNBA4/Xwk3BtLC0t4eLigh07dmjs37Fjh0ZsumjcuDHOnz+PS5cuabSDNvb29ggNDcU333yDxMRELF68GEDZ77uySl5/165d8vwH6iESD8erntxRTaFQaL2++n2fP39e3nf06FHcuHGj0m1IRERERERUFs6BUEk3jpzUXkhPzp07h8jISLz33nvYv38/5s6di5kzZwIAvLy80LNnT4SHh2PRokWoVasWJkyYAFdXV/Ts2RPAg/kFgoOD0bBhQ1y/fh3btm2Tb3Td3d0hSRLWr1+PLl26wNTUFLVq1cK4cePwwQcfoLi4GK1bt0ZeXh527NgBS0tLhIaG6hz7hx9+iJiYGNSvXx++vr5ITk7GwYMHy11poTxBQUFo2LAhQkNDMX36dOTn5+OTTz6p8Jzo6Gj4+fnBx8cHBQUFWL9+vfy+HRwcYGpqipSUFNSpUwcmJiawsrKqVEw//PADmjdvjtatW2PlypVIT0/H0qVLAUBOtsTGxmLy5Mk4ceKE/JmpeXh44NatW0hNTUXTpk1hZmYGMzOzUu/7pZdewltvvYXExEQUFRXh/fffR9u2bbUO+yAiIiIiItIFeyA8Q0JCQnD37l34+/tjxIgRGD16NIYOHSofT05Ohp+fH7p164aAgAAIIbBx40a5W7tKpcKIESPQuHFjdO7cGQ0bNpQn+nN1dUVcXBwmTJgAR0dHREREAHgwKeDEiRORkJAgn7dhwwZ5+UNdjRo1CpGRkRg7dixeeuklpKSk4JdfftFYgUEXBgYG+Omnn+R2GDJkiNYJAhUKBaKiotCkSRO0adMGhoaGWLVqFQDAyMgIX3zxBRYtWgQXFxc52VIZcXFxWLVqFZo0aYIVK1bgu+++k3sFGBsb47vvvsN///2HJk2aYOrUqfjss880zm/VqhWGDRuGfv36wd7eHtOmTSt1DUmSsG7dOtjY2KBNmzYICgpCvXr1sHr16krHS0REREREVBZJPDz4+jmQn58PKysr5OXlwdLSUuPYvXv3cObMGXh6esLExASFeTexc9BHeor0gYBl06CwqqW1XLt27eDr64vExMQnEBU9D0r+HoiI6Mm5VVCEiRuOAACOXMoHADRysICRIZ/90NOvSFWM47kP5tLycX7w7/FJXX1goWTnaCJ9qOgeuST+X4iIiIiIiIiItKoRab758+dj+vTpyM7ORtOmTTF37lz4+/uXWbZdu3bYvn17qf1dunTBhg0bqjUuY0sLBCwr3V38STK2tNDr9YmIiIiIiIiAGpBAWL16NSIjI7Fw4UK0aNECiYmJ6NSpE44fPw4HB4dS5deuXYvCwkJ5++rVq2jatCn69u1b7bFJkqTT8IGaIC0tTd8hEBERERER0TNM70MYZs2ahfDwcISFhcHb2xsLFy6EmZkZkpKSyixfu3ZtODk5ya8tW7bAzMzssSQQiIiIiIiIiOgBvSYQCgsLsW/fPgQFBcn7DAwMEBQUhJ07d+pUx9KlS9G/f3+Ym5s/rjCJiIiIiIiInnt6HcJw5coVqFQqODo6aux3dHTEf//9p/X89PR0/Pvvv1i6dGm5ZQoKClBQUCBv5+fna623uLhYaxmiZx1/B0RERERE9DC9z4HwKJYuXYqXXnqp3AkXASAhIQFxcXE61adQKGBgYICsrCzY29tDoVBAkqTqCpfoqSCEQGFhIS5fvgwDAwMoFAp9h0RERERERDWAXhMIdnZ2MDQ0RE5Ojsb+nJwcODk5VXju7du3sWrVKsTHx1dYLioqCpGRkfJ2fn4+3NzcyixrYGAAT09PXLp0CVlZWTq+C6Jnk5mZGerWrQsDA71PlUJERERERDWAXhMICoUCfn5+SE1NRa9evQA86DadmpqKiIiICs/94YcfUFBQgLfffrvCckqlEkqlslIx1a1bF0VFRVCpVDqfR/QsMTQ0hJGREXvgEBERERGRTO9DGCIjIxEaGormzZvD398fiYmJuH37NsLCwgAAISEhcHV1RUJCgsZ5S5cuRa9evWBra1vtMUmSBGNjYxgbG1d73URERERERERPI70nEPr164fLly8jOjoa2dnZ8PX1RUpKijyx4rlz50p1oT5+/Dj++usvbN68WR8hExERERERET139J5AAICIiIhyhyykpaWV2teoUSMIIR5zVERERERERESkxtnRiIiIiIiIiEgrJhCIiIiIiIiISCsmEIiIiIiIiIhIqxoxBwIRERERET0nhIDx3TsAAMM7D25H7ufdRKGStyb07DG2tHimlkbnr5SIiIiIiJ4Yw7t30WZlEgCglsmD25EDP9SCocGzc5NFpBawbBoUVrX0HUa14RAGIiIiIiIiItKKPRCIiIiIiEgvzDMyAADXzxs9U928iWybv6TvEB4L9kAgIiIiIiIiIq3YA4GIiIiIiPTK0tsLRgpjfYdB9EhEURFuHDmp7zAeKyYQiIiIiIhIryQjIxgY89aEnm7F+g7gCeAQBiIiIiIiIiLSigkEIiIiIiIiItKKCQQiIiIiIiIi0ooJBCIiIiIiIiLSigkEIiIiIiIiItKKCQQiIiIiIiIi0ooJBCIiIiIiIiLSigkEIiIiIiIiItKKCQQiIiIiIiIi0ooJBCIiIiIiIiLSigkEIiIiIiIiItKKCQQiIiIiIiIi0ooJBCIiIiIiIiLSigkEIiIiIiIiItKKCQQiIiIiIiIi0ooJBCIiIiIiIiLSSu8JhPnz58PDwwMmJiZo0aIF0tPTKyx/48YNjBgxAs7OzlAqlWjYsCE2btz4hKIlIiIiIiIiej4Z6fPiq1evRmRkJBYuXIgWLVogMTERnTp1wvHjx+Hg4FCqfGFhITp27AgHBwesWbMGrq6uOHv2LKytrfUQPREREREREdHzQ68JhFmzZiE8PBxhYWEAgIULF2LDhg1ISkrChAkTSpVPSkrCtWvX8Pfff8PY2BgA4OHh8SRDJiIiIiIiInou6W0IQ2FhIfbt24egoKD/BWNggKCgIOzcubPMc3755RcEBARgxIgRcHR0xIsvvogpU6ZApVKVe52CggLk5+drvIiIiIiIiIiocvSWQLhy5QpUKhUcHR019js6OiI7O7vMc06fPo01a9ZApVJh48aNmDhxImbOnInPPvus3OskJCTAyspKfrm5uVXr+yAiIiIiIiJ6Huh9EsXKKC4uhoODAxYvXgw/Pz/069cPn3zyCRYuXFjuOVFRUcjLy5Nf58+ff4IRExERERERET0b9DYHgp2dHQwNDZGTk6OxPycnB05OTmWe4+zsDGNjYxgaGsr7GjdujOzsbBQWFkKhUJQ6R6lUQqlUVm/wRERERERERM8ZvfVAUCgU8PPzQ2pqqryvuLgYqampCAgIKPOcwMBAZGRkoLi4WN534sQJODs7l5k8ICIiIiIiIqLqodchDJGRkViyZAmWL1+OY8eOYfjw4bh9+7a8KkNISAiioqLk8sOHD8e1a9cwevRonDhxAhs2bMCUKVMwYsQIfb0FIiIiIiIioueCXpdx7NevHy5fvozo6GhkZ2fD19cXKSkp8sSK586dg4HB/3Icbm5u2LRpEz744AM0adIErq6uGD16NMaPH6+vt0BERERERET0XNBrAgEAIiIiEBERUeaxtLS0UvsCAgKwa9euxxwVERERERERET3sqVqFgYiIiIiIiIj0gwkEIiIiIiIiItKKCQQiIiIiIiIi0ooJBCIiIiIiIiLSigkEIiIiIiIiItKKCQQiIiIiIiIi0ooJBCIiIiIiIiLSigkEIiIiIiIiItKKCQQiIiIiIiIi0ooJBCIiIiIiIiLSigkEIiIiIiIiItKKCQQiIiIiIiIi0ooJBCIiIiIiIiLSigkEIiIiIiIiItKKCQQiIiIiIiIi0ooJBCIiIiIiIiLSigkEIiIiIiIiItKKCQQiIiIiIiIi0ooJBCIiIiIiIiLSigkEIiIiIiIiItKKCQQiIiIiIiIi0ooJBCIiIiIiIiLSigkEIiIiIiIiItKKCQQiIiIiIiIi0ooJBCIiIiIiIiLSqkYkEObPnw8PDw+YmJigRYsWSE9PL7fssmXLIEmSxsvExOQJRktERERERET0/KlSAqFt27ZYsWIF7t69+8gBrF69GpGRkYiJicH+/fvRtGlTdOrUCbm5ueWeY2lpiUuXLsmvs2fPPnIcRERERERERFS+KiUQmjVrhnHjxsHJyQnh4eHYtWtXlQOYNWsWwsPDERYWBm9vbyxcuBBmZmZISkoq9xxJkuDk5CS/HB0dq3x9IiIiIiIiItKuSgmExMREZGVlITk5Gbm5uWjTpg28vb0xY8YM5OTk6FxPYWEh9u3bh6CgoP8FZGCAoKAg7Ny5s9zzbt26BXd3d7i5uaFnz544cuRIVd4GEREREREREemoynMgGBkZoU+fPli3bh0uXLiAgQMHYuLEiXBzc0OvXr3w+++/a63jypUrUKlUpXoQODo6Ijs7u8xzGjVqhKSkJKxbtw7ffPMNiouL0apVK1y4cKHM8gUFBcjPz9d4EREREREREVHlPPIkiunp6YiJicHMmTPh4OCAqKgo2NnZoVu3bhg3blx1xKghICAAISEh8PX1Rdu2bbF27VrY29tj0aJFZZZPSEiAlZWV/HJzc6v2mIiIiIiIiIiedVVKIOTm5mLmzJl48cUX8corr+Dy5cv47rvvkJmZibi4OHz11VfYvHkzFi5cWGE9dnZ2MDQ0LDXsIScnB05OTjrFYmxsjGbNmiEjI6PM41FRUcjLy5Nf58+f1+1NEhEREREREZGsSgmEOnXq4KuvvkJoaCguXLiANWvWoHPnzpAkSS7TpEkTvPzyyxXWo1Ao4Ofnh9TUVHlfcXExUlNTERAQoFMsKpUKhw8fhrOzc5nHlUolLC0tNV5EREREREREVDlGVTkpNTUVr7zySoVlLC0tsW3bNq11RUZGIjQ0FM2bN4e/vz8SExNx+/ZthIWFAQBCQkLg6uqKhIQEAEB8fDxatmyJBg0a4MaNG5g+fTrOnj2LIUOGVOWtEBEREREREZEOqpRAiImJwdq1a2Ftba2xPz8/X+cJFNX69euHy5cvIzo6GtnZ2fD19UVKSoo8seK5c+dgYPC/jhLXr19HeHg4srOzYWNjAz8/P/z999/w9vauylshIiIiIiIiIh1UKYGwfft2FBYWltp/7949/Pnnn5WuLyIiAhEREWUeS0tL09iePXs2Zs+eXelrEBEREREREVHVVSqB8M8//wAAhBA4evSoxlKLKpUKKSkpcHV1rd4IiYiIiIiIiEjvKpVA8PX1hSRJkCQJ7du3L3Xc1NQUc+fOrbbgiIiIiIiIiKhmqFQC4cyZMxBCoF69ekhPT4e9vb18TKFQwMHBAYaGhtUeJBERERERERHpV6USCO7u7gAeLLVIRERERERERM8PnRMIv/zyC4KDg2FsbIxffvmlwrI9evR45MCIiIiIiIiIqObQOYHQq1cvZGdnw8HBAb169Sq3nCRJUKlU1RIcEREREREREdUMOicQHh62wCEMRERERERERM8XA30HQEREREREREQ1n849EL744gudKx01alSVgiEiIiIiIiKimknnBMLs2bN1KidJEhMIRERERERERM8YnRMIZ86ceZxxEBEREREREVENxjkQiIiIiIiIiEgrnXsgREZGYtKkSTA3N0dkZGSFZWfNmvXIgRERERERERFRzaFzAuHAgQO4f/++/N/lkSTp0aMiIiIiIiIiohpF5wTCtm3byvxvIiIiIiIiInr2PfIcCOfPn8f58+erIxYiIiIiIiIiqqGqlEAoKirCxIkTYWVlBQ8PD3h4eMDKygqffvqpPMyBiIiIiIiIiJ4dOg9heNjIkSOxdu1aTJs2DQEBAQCAnTt3IjY2FlevXsWXX35ZrUESERERERERkX5VKYHw7bffYtWqVQgODpb3NWnSBG5ubhgwYAATCERERERERETPmCoNYVAqlfDw8Ci139PTEwqF4lFjIiIiIiIiIqIapkoJhIiICEyaNAkFBQXyvoKCAkyePBkRERHVFhwRERERERER1Qw6D2Ho06ePxvbWrVtRp04dNG3aFABw6NAhFBYWokOHDtUbIRERERERERHpnc4JBCsrK43t119/XWPbzc2teiIiIiIiIiIiohpH5wRCcnLy44yDiIiIiIiIiGqwKs2BQERERERERETPlyot4wgAa9aswffff49z586hsLBQ49j+/fsfOTAiIiIiIiIiqjmq1APhiy++QFhYGBwdHXHgwAH4+/vD1tYWp0+fRnBwcKXrmz9/Pjw8PGBiYoIWLVogPT1dp/NWrVoFSZLQq1evSl+TiIiIiIiIiHRXpQTCggULsHjxYsydOxcKhQIfffQRtmzZglGjRiEvL69Sda1evRqRkZGIiYnB/v370bRpU3Tq1Am5niPS1gAAIABJREFUubkVnpeZmYlx48bhlVdeqcpbICIiIiIiIqJK+P/27j2qqjr///jrHJCL4N0EJZKlZGZeUBHTJrXCtMzSmUZ0HEGmKCdRkzWl9HVATEPLHJzGNK/dxnS6jqViDiNdMRVDHS+MmQoVoKYJonNQ+Pz+8NepE+gBRA7C87HWWbE/+7P3fu+zbO3Ni8/+7GoFCDk5Oerfv78kydvbW0VFRZKkcePG6Y033qjSvhYsWKCYmBhFR0erS5cuWrJkiRo3bqyVK1decpvS0lKNHTtWSUlJ6tChQ3VOAQAAAAAAVEG1AgR/f3+dPHlSknTDDTdo69atkqTDhw/LGFPp/ZSUlCgzM1Ph4eE/FWS1Kjw8XBkZGZfcbtasWWrTpo0eeuih6pQPAAAAAACqqFqTKN55551at26devbsqejoaE2dOlVvvfWWduzYoV//+teV3s+JEydUWloqPz8/h3Y/Pz8dOHCgwm0+/fRTrVixQllZWZU6hs1mk81msy8XFhZWuj4AAAAAAHBRtQKEpUuXqqysTJI0ceJEtWrVSp9//rnuv/9+PfroozVa4M8VFRVp3LhxWrZsmVq3bl2pbZKTk5WUlHTVagIAAAAAoCGoVoBgtVpltf709MPo0aM1evToKu+ndevWcnNzU0FBgUN7QUGB/P39y/U/dOiQjhw5ouHDh9vbfgwy3N3dlZ2drY4dOzpsEx8fr7i4OPtyYWGhAgMDq1wrAAAAAAANWbUCBEk6deqUVqxYof3790uSunTpoujoaLVs2bLS+/Dw8FDv3r2VlpZmfxVjWVmZ0tLSFBsbW65/586dtWfPHoe2GTNmqKioSAsXLqwwGPD09JSnp2dVTg0AAAAAAPxCtQKEjz/+WPfff7+aNm2q0NBQSdJf//pXzZo1S++//74GDBhQ6X3FxcUpKipKoaGhCgsLU0pKioqLixUdHS1JioyMVEBAgJKTk+Xl5aWuXbs6bN+8eXNJKtcOAAAAAABqTrUChIkTJ2rUqFFavHix3NzcJF18teJjjz2miRMnlhslcDkRERE6fvy4EhISlJ+fr5CQEKWmptonVszJyXF4XAIAAAAAANS+agUIX331ld566y17eCBJbm5uiouL06uvvlrl/cXGxlb4yIIkpaenX3bbl19+ucrHAwAAAAAAVVOtP+336tXLPvfBz+3fv189evS44qIAAAAAAEDdUukRCLt377b/PHnyZE2ZMkVfffWVbr31VknS1q1btWjRIs2dO7fmqwQAAAAAAC5V6QAhJCREFotFxhh725NPPlmu3+9+9ztFRETUTHUAAAAAAKBOqHSAcPjw4atZBwAAAAAAqMMqHSC0b9/+atYBAAAAAADqsGq9hUGSDh06pJSUFPtkil26dNGUKVPUsWPHGisOAAAAAADUDdV6C8OmTZvUpUsXbdu2Td27d1f37t31xRdf6JZbbtHmzZtrukYAAAAAAOBi1RqBMH36dE2dOrXcGxemT5+uadOmafDgwTVSHAAAAAAAqBuqNQJh//79euihh8q1/+EPf9C+ffuuuCgAAAAAAFC3VCtAuO6665SVlVWuPSsrS23atLniogAAAAAAQN1SrUcYYmJi9Mgjj+jrr79W//79JUmfffaZ5s2bp7i4uBotEAAAAAAAuF61AoQ///nPatKkiZ5//nnFx8dLktq1a6eZM2dq8uTJNVogAAAAAABwvSoHCMYY5ebm6o9//KOmTp2qoqIiSVKTJk1qvDgAAAAAAFA3VHkOBGOMgoODlZubK+licEB4AAAAAABA/VblAMFqterGG2/U999/fzXqAQAAAAAAdVC15kCYO3eunnjiCS1evFhdu3at6ZoA1HPGGJ0vPOPqMoBa0aiprywWi6vLAAAAuGLVChAiIyN19uxZ9ejRQx4eHvL29nZYf/LkyRopDkD9dL7wjDLGP+nqMoBa0e/lZ+XRjEf9AADAta9aAUJKSkpN1wEAAAAAAOqwKgUIZWVleu6557Ru3TqVlJTorrvuUmJiYrkRCABQWd/v2OPqEoCrolVoN1eXAAAAUKOqNIninDlz9NRTT8nX11cBAQFauHChJk6ceLVqAwAAAAAAdUSVRiC8+uqrevHFF/Xoo49Kkv71r39p2LBhWr58uazWKr/QAQDsmt9yoyzu1XqqCqgzzIUL+mHvQVeXAQAAcFVU6W49JydH9957r305PDxcFotF3333na6//voaLw5Aw2Fxd5e1EQECrm1lri4AAADgKqrSsIELFy7Iy8vLoa1Ro0Y6f/58jRYFAAAAAADqlir9uc8Yo/Hjx8vT09Pe9r///U8TJkyQj4+Pve2dd96puQoBAAAAAIDLVSlAiIqKKtf2+9//vsaKAQAAAAAAdVOVAoRVq1ZdrToAAAAAAEAdVidenbBo0SIFBQXJy8tLffv21bZt2y7Z95133lFoaKiaN28uHx8fhYSE6LXXXqvFagEAAAAAaHhcHiCsXbtWcXFxSkxM1M6dO9WjRw8NGTJEx44dq7B/y5Yt9X//93/KyMjQ7t27FR0drejoaG3atKmWKwcAAAAAoOFweYCwYMECxcTEKDo6Wl26dNGSJUvUuHFjrVy5ssL+gwYN0siRI3XzzTerY8eOmjJlirp3765PP/20lisHAAAAAKDhcGmAUFJSoszMTIWHh9vbrFarwsPDlZGR4XR7Y4zS0tKUnZ2tAQMGVNjHZrOpsLDQ4QMAAAAAAKrGpQHCiRMnVFpaKj8/P4d2Pz8/5efnX3K706dPy9fXVx4eHho2bJheeOEFDR48uMK+ycnJatasmf0TGBhYo+cAAAAAAEBD4PJHGKqjSZMmysrK0vbt2zVnzhzFxcUpPT29wr7x8fE6ffq0/ZObm1u7xQIAAAAAUA9U6TWONa1169Zyc3NTQUGBQ3tBQYH8/f0vuZ3ValVwcLAkKSQkRPv371dycrIGDRpUrq+np6c8PT1rtG4AAAAAABoal45A8PDwUO/evZWWlmZvKysrU1pamvr161fp/ZSVlclms12NEgEAAAAAgFw8AkGS4uLiFBUVpdDQUIWFhSklJUXFxcWKjo6WJEVGRiogIEDJycmSLs5pEBoaqo4dO8pms2nDhg167bXXtHjxYleeBgAAAAAA9ZrLA4SIiAgdP35cCQkJys/PV0hIiFJTU+0TK+bk5Mhq/WmgRHFxsR577DF988038vb2VufOnfX6668rIiLCVacAAAAAAEC95/IAQZJiY2MVGxtb4bpfTo44e/ZszZ49uxaqAgAAAAAAP7om38IAAAAAAABqFwECAAAAAABwigABAAAAAAA4RYAAAAAAAACcIkAAAAAAAABOESAAAAAAAACnCBAAAAAAAIBTBAgAAAAAAMApAgQAAAAAAOAUAQIAAAAAAHCKAAEAAAAAADhFgAAAAAAAAJwiQAAAAAAAAE4RIAAAAAAAAKcIEAAAAAAAgFMECAAAAAAAwCkCBAAAAAAA4BQBAgAAAAAAcIoAAQAAAAAAOEWAAAAAAAAAnCJAAAAAAAAAThEgAAAAAAAApwgQAAAAAACAUwQIAAAAAADAKQIEAAAAAADgVJ0IEBYtWqSgoCB5eXmpb9++2rZt2yX7Llu2TLfffrtatGihFi1aKDw8/LL9AQAAAADAlXN5gLB27VrFxcUpMTFRO3fuVI8ePTRkyBAdO3aswv7p6ekaM2aMtmzZooyMDAUGBuruu+/Wt99+W8uVAwAAAADQcLi7uoAFCxYoJiZG0dHRkqQlS5Zo/fr1WrlypaZPn16u/9///neH5eXLl+vtt99WWlqaIiMja6Xm2mCMUXFJqavLAK6K87YLKi0zki7+WwcAAABQ97k0QCgpKVFmZqbi4+PtbVarVeHh4crIyKjUPs6ePavz58+rZcuWV6tMlyguKdWf1+91dRnAVeF29qw6HCuSJPnYLkiSmpUZ1w+JAgAAAHBJLg0QTpw4odLSUvn5+Tm0+/n56cCBA5Xax7Rp09SuXTuFh4dXuN5ms8lms9mXCwsLq18wAAAAAAANlMsfYbgSc+fO1Zo1a5Seni4vL68K+yQnJyspKamWK6tZe/MIPVC/NDp3Vtf97+LIAx8X1wIAAACgclw6Yrh169Zyc3NTQUGBQ3tBQYH8/f0vu+38+fM1d+5cffjhh+revfsl+8XHx+v06dP2T25ubo3UDgAAAABAQ+LSEQgeHh7q3bu30tLSNGLECElSWVmZ0tLSFBsbe8ntnn32Wc2ZM0ebNm1SaGjoZY/h6ekpT0/PGq3bVYKv85GbxeLqMoArV8y/YwAAAOBa4/JHGOLi4hQVFaXQ0FCFhYUpJSVFxcXF9rcyREZGKiAgQMnJyZKkefPmKSEhQatXr1ZQUJDy8/MlSb6+vvL19XXZedQGN4tF7m5MM4drnyEIAwAAAK45Lg8QIiIidPz4cSUkJCg/P18hISFKTU21T6yYk5Mjq/WnX5oXL16skpISPfjggw77SUxM1MyZM2uzdAAAAAAAGgyXBwiSFBsbe8lHFtLT0x2Wjxw5cvULAgAAAAAADhgPDwAAAAAAnCJAAAAAAAAAThEgAAAAAAAApwgQAAAAAACAUwQIAAAAAADAKQIEAAAAAADgFAECAAAAAABwigABAAAAAAA4RYAAAAAAAACcIkAAAAAAAABOESAAAAAAAACnCBAAAAAAAIBTBAgAAAAAAMApAgQAAAAAAOAUAQIAAAAAAHCKAAEAAAAAADhFgAAAAAAAAJwiQAAAAAAAAE4RIAAAAAAAAKcIEAAAAAAAgFMECAAAAAAAwCkCBAAAAAAA4BQBAgAAAAAAcIoAAQAAAAAAOEWAAAAAAAAAnCJAAAAAAAAATrk8QFi0aJGCgoLk5eWlvn37atu2bZfsu3fvXv3mN79RUFCQLBaLUlJSarFSAAAAAAAaLpcGCGvXrlVcXJwSExO1c+dO9ejRQ0OGDNGxY8cq7H/27Fl16NBBc+fOlb+/fy1XCwAAAABAw+XSAGHBggWKiYlRdHS0unTpoiVLlqhx48ZauXJlhf379Omj5557TqNHj5anp2ctVwsAAAAAQMPlsgChpKREmZmZCg8P/6kYq1Xh4eHKyMhwVVkAAAAAAKAC7q468IkTJ1RaWio/Pz+Hdj8/Px04cKDGjmOz2WSz2ezLhYWFNbZvAAAAAAAaCpdPoni1JScnq1mzZvZPYGCgq0sCAAAAAOCa47IAoXXr1nJzc1NBQYFDe0FBQY1OkBgfH6/Tp0/bP7m5uTW2bwAAAAAAGgqXBQgeHh7q3bu30tLS7G1lZWVKS0tTv379auw4np6eatq0qcMHAAAAAABUjcvmQJCkuLg4RUVFKTQ0VGFhYUpJSVFxcbGio6MlSZGRkQoICFBycrKkixMv7tu3z/7zt99+q6ysLPn6+io4ONhl5wEAAAAAQH3n0gAhIiJCx48fV0JCgvLz8xUSEqLU1FT7xIo5OTmyWn8aJPHdd9+pZ8+e9uX58+dr/vz5GjhwoNLT02u7fAAAAAAAGgyXBgiSFBsbq9jY2ArX/TIUCAoKkjGmFqoCAAAAAAA/V+/fwgAAAAAAAK4cAQIAAAAAAHCKAAEAAAAAADhFgAAAAAAAAJwiQAAAAAAAAE4RIAAAAAAAAKcIEAAAAAAAgFMECAAAAAAAwCkCBAAAAAAA4BQBAgAAAAAAcIoAAQAAAAAAOEWAAAAAAAAAnCJAAAAAAAAAThEgAAAAAAAApwgQAAAAAACAUwQIAAAAAADAKQIEAAAAAADgFAECAAAAAABwigABAAAAAAA4RYAAAAAAAACcIkAAAAAAAABOESAAAAAAAACnCBAAAAAAAIBTBAgAAAAAAMApAgQAAAAAAOAUAQIAAAAAAHCqTgQIixYtUlBQkLy8vNS3b19t27btsv3ffPNNde7cWV5eXurWrZs2bNhQS5UCAAAAANAwubu6gLVr1youLk5LlixR3759lZKSoiFDhig7O1tt2rQp1//zzz/XmDFjlJycrPvuu0+rV6/WiBEjtHPnTnXt2tUFZ1B7So2RSstcXQZw5Ywp33ThgsqsFhcUA9Qcc+GCq0tAPcZ9AOoN7gNQTzWE+wCXBwgLFixQTEyMoqOjJUlLlizR+vXrtXLlSk2fPr1c/4ULF2ro0KF64oknJElPP/20Nm/erL/97W9asmRJrdZe2746XuzqEoAa0ejcWV3/i7bCfQdlsXDjAACXwn0A6gvuA4Brl0sDhJKSEmVmZio+Pt7eZrVaFR4eroyMjAq3ycjIUFxcnEPbkCFD9N5771XY32azyWaz2ZdPnz4tSSosLLzS8q+qM7YLsp09I0m6cI4bBtQz/zur/5WelySdKyuVJFnLxI0D6hWv8yWSLl5vPCzl/9oGXA73AajXuA9AA3At3Qf8+LuxqWB00C+5NEA4ceKESktL5efn59Du5+enAwcOVLhNfn5+hf3z8/Mr7J+cnKykpKRy7YGBgdWsGkBN2OzqAoCr7bsvLv73hpWurQMA6iDuA1DvXYP3AUVFRWrWrNll+7j8EYarLT4+3mHEQllZmU6ePKlWrVqRcgIuVlhYqMDAQOXm5qpp06auLgcAANQi7gOAusEYo6KiIrVr185pX5cGCK1bt5abm5sKCgoc2gsKCuTv71/hNv7+/lXq7+npKU9PT4e25s2bX0HVAGpa06ZNuXEAAKCB4j4AcD1nIw9+5NLXOHp4eKh3795KS0uzt5WVlSktLU39+vWrcJt+/fo59JekzZs3X7I/AAAAAAC4ci5/hCEuLk5RUVEKDQ1VWFiYUlJSVFxcbH8rQ2RkpAICApScnCxJmjJligYOHKjnn39ew4YN05o1a7Rjxw4tXbrUlacBAAAAAEC95vIAISIiQsePH1dCQoLy8/MVEhKi1NRU+0SJOTk5slp/GijRv39/rV69WjNmzNBTTz2lG2+8Ue+99566du3qqlMAUE2enp5KTEws95gRAACo/7gPAK49FlOZdzUAAAAAAIAGzaVzIAAAAAAAgGsDAQIAAAAAAHCKAAEAAAAAADhFgACgzpk5c6ZCQkJcXQYAAACAnyFAAOqh8ePHy2Kx2D+tWrXS0KFDtXv3bleXZpecnCw3Nzc999xzri6lQunp6bJYLPrhhx9cXQoAAJVSl6//QUFB9rp8fHzUq1cvvfnmm64uq1IsFovee+89V5cB1AkECEA9NXToUOXl5SkvL09paWlyd3fXfffd5+qy7FauXKknn3xSK1eudHUpAADUG3X5+j9r1izl5eXpyy+/VJ8+fRQREaHPP/+8wr4lJSW1XB2AyiBAAOopT09P+fv7y9/fXyEhIZo+fbpyc3N1/PhxSRX/hT0rK0sWi0VHjhyxty1btkyBgYFq3LixRo4cqQULFqh58+b29bt27dIdd9yhJk2aqGnTpurdu7d27Nhx2do++ugjnTt3TrNmzVJhYeElbx5eeukl+7FHjRql06dP29elp6crLCxMPj4+at68uW677TYdPXrUvv6f//ynevXqJS8vL3Xo0EFJSUm6cOGCfb3FYtHy5cs1cuRINW7cWDfeeKPWrVsnSTpy5IjuuOMOSVKLFi1ksVg0fvx4J984AACuV5ev/02aNJG/v786deqkRYsWydvbW++//76ki6MnRowYoTlz5qhdu3a66aabJEk2m01/+tOfFBAQIB8fH/Xt21fp6en2fR49elTDhw9XixYt5OPjo1tuuUUbNmywr//Pf/6je+65R76+vvLz89O4ceN04sQJ+/pBgwZp8uTJevLJJ9WyZUv5+/tr5syZ9vVBQUGSpJEjR8pisdiXgYaKAAFoAM6cOaPXX39dwcHBatWqVaW3++yzzzRhwgRNmTJFWVlZGjx4sObMmePQZ+zYsbr++uu1fft2ZWZmavr06WrUqNFl97tixQqNGTNGjRo10pgxY7RixYpyfb766iv94x//0Pvvv6/U1FR9+eWXeuyxxyRJFy5c0IgRIzRw4EDt3r1bGRkZeuSRR2SxWCRJn3zyiSIjIzVlyhTt27dPL730kl5++eVytSclJWnUqFHavXu37r33Xo0dO1YnT55UYGCg3n77bUlSdna28vLytHDhwkp/bwAA1AV17fr/c+7u7mrUqJHDSIO0tDRlZ2dr8+bN+uCDDyRJsbGxysjI0Jo1a7R792799re/1dChQ3Xw4EFJ0sSJE2Wz2fTxxx9rz549mjdvnnx9fSVJP/zwg+6880717NlTO3bsUGpqqgoKCjRq1CiHWl555RX5+Pjoiy++0LPPPqtZs2Zp8+bNkqTt27dLklatWqW8vDz7MtBgGQD1TlRUlHFzczM+Pj7Gx8fHSDJt27Y1mZmZ9j5btmwxksypU6fsbV9++aWRZA4fPmyMMSYiIsIMGzbMYd9jx441zZo1sy83adLEvPzyy5Wu7fTp08bb29tkZWXZj+nr62uKiorsfRITE42bm5v55ptv7G0bN240VqvV5OXlme+//95IMunp6RUe46677jLPPPOMQ9trr71m2rZta1+WZGbMmGFfPnPmjJFkNm7caIyp+PsBAKAuq8vX//bt25u//OUvxhhjbDabeeaZZ4wk88EHH9hr9/PzMzabzb7N0aNHjZubm/n2228d9nXXXXeZ+Ph4Y4wx3bp1MzNnzqzwmE8//bS5++67Hdpyc3ONJJOdnW2MMWbgwIHmV7/6lUOfPn36mGnTptmXJZl333230ucK1GeMQADqqTvuuENZWVnKysrStm3bNGTIEN1zzz0Ow/ydyc7OVlhYmEPbL5fj4uL08MMPKzw8XHPnztWhQ4cuu8833nhDHTt2VI8ePSRJISEhat++vdauXevQ74YbblBAQIB9uV+/fiorK1N2drZatmyp8ePHa8iQIRo+fLgWLlyovLw8e99du3Zp1qxZ8vX1tX9iYmKUl5ens2fP2vt1797d/rOPj4+aNm2qY8eOVfLbAQCg7qmr139JmjZtmnx9fdW4cWPNmzdPc+fO1bBhw+zru3XrJg8PD/vynj17VFpaqk6dOjlc0z/66CP78SZPnqzZs2frtttuU2JiosOEkbt27dKWLVsctu3cubMkOdT78/sBSWrbti33A8AlECAA9ZSPj4+Cg4MVHBysPn36aPny5SouLtayZcskSVbrxf/9jTH2bc6fP1/l48ycOVN79+7VsGHD9O9//1tdunTRu+++e8n+K1as0N69e+Xu7m7/7Nu3r8qTKa5atUoZGRnq37+/1q5dq06dOmnr1q2SLg7ZTEpKst9AZWVlac+ePTp48KC8vLzs+/jlUEuLxaKysrIq1QEAQF1SV6//kvTEE08oKytL33zzjU6dOqVp06aVq/3nzpw5Izc3N2VmZjpc0/fv329/tPDhhx/W119/rXHjxmnPnj0KDQ3VCy+8YN9++PDhDttmZWXp4MGDGjBggP043A8Alefu6gIA1A6LxSKr1apz585Jkq677jpJUl5enlq0aCHp4iRKP3fTTTeVe9avomf/OnXqpE6dOmnq1KkaM2aMVq1apZEjR5brt2fPHu3YsUPp6elq2bKlvf3kyZMaNGiQDhw4YP/LQE5Ojr777ju1a9dOkrR161ZZrVb7pEqS1LNnT/Xs2VPx8fHq16+fVq9erVtvvVW9evVSdna2goODq/w9/ejHv4CUlpZWex8AALhaXbj+/6h169ZVujb37NlTpaWlOnbsmG6//fZL9gsMDNSECRM0YcIExcfHa9myZZo0aZJ69eqlt99+W0FBQXJ3r/6vPY0aNeJ+APj/GIEA1FM2m035+fnKz8/X/v37NWnSJHsSL0nBwcEKDAzUzJkzdfDgQa1fv17PP/+8wz4mTZqkDRs2aMGCBTp48KBeeuklbdy40T5Z4blz5xQbG6v09HQdPXpUn332mbZv366bb765wppWrFihsLAwDRgwQF27drV/BgwYoD59+jhMpujl5aWoqCjt2rVLn3zyiSZPnqxRo0bJ399fhw8fVnx8vDIyMnT06FF9+OGHOnjwoP24CQkJevXVV5WUlKS9e/dq//79WrNmjWbMmFHp7699+/ayWCz64IMPdPz4cZ05c6ZK3z8AAK5QF6//1dWpUyeNHTtWkZGReuedd3T48GFt27ZNycnJWr9+vSTp8ccf16ZNm3T48GHt3LlTW7ZssdcxceJEnTx5UmPGjNH27dt16NAhbdq0SdHR0VUKBIKCgpSWlqb8/HydOnWqRs8RuOa4ehIGADUvKirKSLJ/mjRpYvr06WPeeusth36ffvqp6datm/Hy8jK33367efPNNx0mUTLGmKVLl5qAgADj7e1tRowYYWbPnm38/f2NMRcnQRo9erQJDAw0Hh4epl27diY2NtacO3euXE02m820atXKPPvssxXWPG/ePNOmTRtTUlJiEhMTTY8ePcyLL75o2rVrZ7y8vMyDDz5oTp48aYwxJj8/34wYMcK0bdvWeHh4mPbt25uEhARTWlpq319qaqrp37+/8fb2Nk2bNjVhYWFm6dKl9vWqYEKkZs2amVWrVtmXZ82aZfz9/Y3FYjFRUVGV+u4BAHCVunj9/9HPJ1G8VO0PPPBAufaSkhKTkJBggoKCTKNGjUzbtm3NyJEjze7du40xxsTGxpqOHTsaT09Pc91115lx48aZEydO2Lf/73//a0aOHGmaN29uvL29TefOnc3jjz9uysrKjDEXJ1GcMmWKwzEfeOABh+v+unXrTHBwsHF3dzft27e/5DkADYHFmJ89AAUATsTExOjAgQP65JNPXF0KAACoJVz/AUjMgQDAifnz52vw4MHy8fHRxo0b9corr+jFF190dVkAAOAq4voPoCKMQABwWaNGjVJ6erqKiorUoUMHTZo0SRMmTHB1WQAA4Cri+g+gIgQIAAAAAADAKd7CAAAAAAAAnCJAAAAAAAAAThEgAAAAAAAApwgQAAAAAACAUwQIAAAAAADAKQIEAAAAAADgFAECAAAAAABwigC2AEvgAAAAFklEQVQBAAAAAAA4RYAAAAAAAACc+n80M+pKWbxgwwAAAABJRU5ErkJggg==", + "text/plain": [ + "Figure(PyObject
)" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "figure(figsize=(12.5, 4))\n", + "colours = [\"#348ABD\", \"#A60628\"]\n", + "\n", + "prior = [0.20, 0.80]\n", + "posterior = [1. / 3, 2. / 3]\n", + "bar([0, .7], prior, alpha=0.70, width=0.25,\n", + " color=colours[1], label=\"prior distribution\",\n", + " lw=\"3\", edgecolor=colours[1])\n", + "\n", + "bar([0+0.25, .7+0.25], posterior, alpha=0.7,\n", + " width=0.25, color=colours[2],\n", + " label=\"posterior distribution\",\n", + " lw=\"3\", edgecolor=colours[2])\n", + "\n", + "xticks([0.125, .825], [\"Bugs Absent\", \"Bugs Present\"])\n", + "title(\"Prior and Posterior probability of bugs present\")\n", + "ylabel(\"Probability\")\n", + "legend(loc=\"upper left\");" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Notice that after we observed $X$ occur, the probability of bugs being absent increased. By increasing the number of tests, we can approach confidence (probability 1) that there are no bugs present.\n", + "\n", + "This was a very simple example of Bayesian inference and Bayes rule. Unfortunately, the mathematics necessary to perform more complicated Bayesian inference only becomes more difficult, except for artificially constructed cases. We will later see that this type of mathematical analysis is actually unnecessary. First we must broaden our modeling tools. The next section deals with *probability distributions*. If you are already familiar, feel free to skip (or at least skim), but for the less familiar the next section is essential." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "_______\n", + "\n", + "## Probability Distributions\n", + "\n", + "\n", + "**Let's quickly recall what a probability distribution is:** Let $Z$ be some random variable. Then associated with $Z$ is a *probability distribution function* that assigns probabilities to the different outcomes $Z$ can take. Graphically, a probability distribution is a curve where the probability of an outcome is proportional to the height of the curve. You can see examples in the first figure of this chapter. \n", + "\n", + "We can divide random variables into three classifications:\n", + "\n", + "- **$Z$ is discrete**: Discrete random variables may only assume values on a specified list. Things like populations, movie ratings, and number of votes are all discrete random variables. Discrete random variables become more clear when we contrast them with...\n", + "\n", + "- **$Z$ is continuous**: Continuous random variable can take on arbitrarily exact values. For example, temperature, speed, time, color are all modeled as continuous variables because you can progressively make the values more and more precise.\n", + "\n", + "- **$Z$ is mixed**: Mixed random variables assign probabilities to both discrete and continuous random variables, i.e. it is a combination of the above two categories. \n", + "\n", + "### Discrete Case\n", + "If $Z$ is discrete, then its distribution is called a *probability mass function*, which measures the probability $Z$ takes on the value $k$, denoted $P(Z=k)$. Note that the probability mass function completely describes the random variable $Z$, that is, if we know the mass function, we know how $Z$ should behave. There are popular probability mass functions that consistently appear: we will introduce them as needed, but let's introduce the first very useful probability mass function. We say $Z$ is *Poisson*-distributed if:\n", + "\n", + "$$P(Z = k) =\\frac{ \\lambda^k e^{-\\lambda} }{k!}, \\; \\; k=0,1,2, \\dots $$\n", + "\n", + "$\\lambda$ is called a parameter of the distribution, and it controls the distribution's shape. For the Poisson distribution, $\\lambda$ can be any positive number. By increasing $\\lambda$, we add more probability to larger values, and conversely by decreasing $\\lambda$ we add more probability to smaller values. One can describe $\\lambda$ as the *intensity* of the Poisson distribution. \n", + "\n", + "Unlike $\\lambda$, which can be any positive number, the value $k$ in the above formula must be a non-negative integer, i.e., $k$ must take on values 0,1,2, and so on. This is very important, because if you wanted to model a population you could not make sense of populations with 4.25 or 5.612 members. \n", + "\n", + "If a random variable $Z$ has a Poisson mass distribution, we denote this by writing\n", + "\n", + "$$Z \\sim \\text{Poi}(\\lambda) $$\n", + "\n", + "One useful property of the Poisson distribution is that its expected value is equal to its parameter, i.e.:\n", + "\n", + "$$E\\large[ \\;Z\\; | \\; \\lambda \\;\\large] = \\lambda $$\n", + "\n", + "We will use this property often, so it's useful to remember. Below, we plot the probability mass distribution for different $\\lambda$ values. The first thing to notice is that by increasing $\\lambda$, we add more probability of larger values occurring. Second, notice that although the graph ends at 15, the distributions do not. They assign positive probability to every non-negative integer." + ] + }, + { + "cell_type": "code", + "execution_count": 72, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "Figure(PyObject
)" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "figure(figsize=(12.5, 4))\n", + "\n", + "a = 0:16\n", + "lambda_ = [1.5, 4.25]\n", + "colours = [\"#348ABD\", \"#A60628\"]\n", + "\n", + "poisson_pdf = (x, λ) -> exp(logpdf(poisson, x, λ))\n", + "\n", + "bar(a, poisson_pdf.(a, lambda_[1]), color=colours[1],\n", + " label=\"λ = $(lambda_[1])\", alpha=0.60,\n", + " edgecolor=colours[1], lw=\"3\")\n", + "\n", + "\n", + "bar(a, poisson_pdf.(a, lambda_[2]), color=colours[2],\n", + " label=\"λ = $(lambda_[2])\", alpha=0.60,\n", + " edgecolor=colours[2], lw=\"3\")\n", + "\n", + "xticks(a, a)\n", + "legend(loc=\"upper right\");\n", + "ylabel(\"probability of \\$k\\$\")\n", + "xlabel(\"\\$k\\$\")\n", + "title(\"Probability mass function of a Poisson random variable; differing λ values\");" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Continuous Case\n", + "Instead of a probability mass function, a continuous random variable has a *probability density function*. This might seem like unnecessary nomenclature, but the density function and the mass function are very different creatures. An example of continuous random variable is a random variable with *exponential density*. The density function for an exponential random variable looks like this:\n", + "\n", + "$$f_Z(z | \\lambda) = \\lambda e^{-\\lambda z }, \\;\\; z\\ge 0$$\n", + "\n", + "Like a Poisson random variable, an exponential random variable can take on only non-negative values. But unlike a Poisson variable, the exponential can take on *any* non-negative values, including non-integral values such as 4.25 or 5.612401. This property makes it a poor choice for count data, which must be an integer, but a great choice for time data, temperature data (measured in Kelvins, of course), or any other precise *and positive* variable. The graph below shows two probability density functions with different $\\lambda$ values. \n", + "\n", + "When a random variable $Z$ has an exponential distribution with parameter $\\lambda$, we say *$Z$ is exponential* and write\n", + "\n", + "$$Z \\sim \\text{Exp}(\\lambda)$$\n", + "\n", + "Given a specific $\\lambda$, the expected value of an exponential random variable is equal to the inverse of $\\lambda$, that is:\n", + "\n", + "$$E[\\; Z \\;|\\; \\lambda \\;] = \\frac{1}{\\lambda}$$" + ] + }, + { + "cell_type": "code", + "execution_count": 86, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "Figure(PyObject
)" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "figure(figsize=(12, 4))\n", + "a = range(0, stop=4, length=100)\n", + "lambda_ = [0.5, 1]\n", + "\n", + "exponential_pdf = (x, λ) -> exp(logpdf(exponential, x, λ))\n", + "\n", + "for (l, c) in zip(lambda_, colours)\n", + " plot(a, exponential_pdf.(a, l), lw=3,\n", + " color=c, label=\"λ=$l\")\n", + " fill_between(a, exponential_pdf.(a, l), color=c, alpha=.33)\n", + "end\n", + "autoscale(tight=true)\n", + "legend(loc=\"upper right\")\n", + "ylabel(\"PDF at \\$z\\$\")\n", + "xlabel(\"\\$z\\$\")\n", + "ylim(0,1.2)\n", + "title(\"Probability density function of an Exponential random variable; differing λ\");" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "### But what is $\\lambda \\;$?\n", + "\n", + "\n", + "**This question is what motivates statistics**. In the real world, $\\lambda$ is hidden from us. We see only $Z$, and must go backwards to try and determine $\\lambda$. The problem is difficult because there is no one-to-one mapping from $Z$ to $\\lambda$. Many different methods have been created to solve the problem of estimating $\\lambda$, but since $\\lambda$ is never actually observed, no one can say for certain which method is best! \n", + "\n", + "Bayesian inference is concerned with *beliefs* about what $\\lambda$ might be. Rather than try to guess $\\lambda$ exactly, we can only talk about what $\\lambda$ is likely to be by assigning a probability distribution to $\\lambda$.\n", + "\n", + "This might seem odd at first. After all, $\\lambda$ is fixed; it is not (necessarily) random! How can we assign probabilities to values of a non-random variable? Ah, we have fallen for our old, frequentist way of thinking. Recall that under Bayesian philosophy, we *can* assign probabilities if we interpret them as beliefs. And it is entirely acceptable to have *beliefs* about the parameter $\\lambda$. \n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "##### Example: Inferring behaviour from text-message data\n", + "\n", + "Let's try to model a more interesting example, one that concerns the rate at which a user sends and receives text messages:\n", + "\n", + "> You are given a series of daily text-message counts from a user of your system. The data, plotted over time, appears in the chart below. You are curious to know if the user's text-messaging habits have changed over time, either gradually or suddenly. How can you model this? (This is in fact my own text-message data. Judge my popularity as you wish.)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 477, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABAsAAAFjCAYAAABbpYInAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAAPYQAAD2EBqD+naQAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nOzdeXhM5///8ddEZZHVlsQSQSyx01CNfIimVFFKUmsXW+tTDVrpolotUbXW0lYoqqkWrSLVRS0laPmgqrZqLVU7CUUSQRKS8/ujv8zXNAlzyKI8H9c115W5zz33eZ8zZw7znnuxGIZhCAAAAAAA4P9zKOoAAAAAAADA7YVkAQAAAAAAsEGyAAAAAAAA2CBZAAAAAAAAbJAsAAAAAAAANkgWAAAAAAAAGyQLAAAAAACADZIFAAAAAADABskCAAAAAABgg2QBANxGRo4cKYvFYlddi8WikSNH3vS+WrZsqbp1697063F7MHPN5Lf8voYOHz4si8Wid95554Z1i/K4r/Xxxx/LYrHo559/LupQcB3r1q2TxWLRunXrijoUAPjXIFkAAAUk+0tE9sPZ2Vnly5dXmzZt9N577+nChQsFHsPJkyc1cuRI7dixo8D39W+R/aXh8OHDt9zWggULNHXq1FsP6gYuXbqkkSNH8kXnBsaMGaOlS5cWdRgoQtOnT9fHH39c1GHYOH36tIYPH666devK1dVVAQEBGj16tK5evVrUoQHAdZEsAIACNmrUKH366aeaMWOGBg0aJEl64YUXVK9ePe3atcum7vDhw3X58uV82/fJkycVHR1NsqCAFGayIDo6OtdkQX5fM/8WuR03yQLklSxo0aKFLl++rBYtWhRJTHPnzlWnTp00depUNW7cWG+88YZGjx5d6LEAgBn3FHUAAHCna9u2rRo3bmx9PmzYMMXHx+uRRx5Rx44d9fvvv8vFxUWSdM899+iee7g1F4S0tDQ5OjoWdRj57m69Zu7W477bZWVlKSMjQ87OzqZe5+DgYPo1+aVz58569dVXrft/5plndOzYMc2fP/+WhpIBQEGjZwEAFIGwsDC98cYbOnLkiObNm2ctz20cdnp6uoYMGaKyZcvK3d1dHTt21PHjx2+4j3Xr1qlJkyaSpD59+liHQ/zzV7fffvtNDzzwgEqUKKEKFSpowoQJOdpKT0/XiBEjVK1aNTk5OcnPz0+vvPKK0tPTbxhH5cqV1bt37xzlLVu2VMuWLW3K3n//fdWpU0clSpRQyZIl1bhxYy1YsMCmzokTJ9S3b1/5+PjIyclJderU0UcffZTj2C0Wiz7//HMNHz5cFSpUUIkSJZSSkpJrjAcOHFBERIR8fX3l7OysihUrqnv37kpOTs7zuFq2bKlly5bpyJEj1nNbuXJl63Z7zllsbKwsFkuO+MeMGSOLxaLvvvtOhw8fVtmyZSVJ0dHR1n1lf8nI7ZqxWCwaOHCgli5dqrp161rP04oVK3Icx7p169S4cWM5OzsrICBAM2fOND0fwI2uoYyMDL355psKCgqSp6enXF1d1bx5c61duzbPNqdMmSJ/f3+5uLgoNDRUv/76q832f8ZosVh08eJFzZ0713qOsq+7Cxcu6IUXXlDlypXl5OQkb29vtW7dWr/88ssNj+3EiRPq16+fypcvLycnJ1WpUkUDBgxQRkaGTb309HRFRUWpbNmycnV1VefOnXXmzBmbOl999ZXat29vbSsgIEBvvfWWMjMzbeplzwVhz2fzyJEj6tixo1xdXeXt7a0hQ4Zo5cqVuY7P37Jlix5++GF5enqqRIkSCg0N1caNG294DqS/u9L369dPPj4+cnZ2VoMGDTR37lzr9itXrqhUqVLq06dPjtempKTI2dlZL730ks35sueekn0tz58/X3Xq1JGTk1Ou17H0971mz549Wr9+vfUayL7H5DZnQfZ53rVrl0JDQ1WiRAlVq1ZNixcvliStX79eTZs2lYuLi2rWrKnVq1fn2Kc996MGDRrkSFQ4OzvnuIYA4HZDSh4AisiTTz6p1157TatWrdIzzzyTZ72nn35a8+bNU8+ePdWsWTPFx8erffv2N2y/Vq1aGjVqlN588031799fzZs3lyQ1a9bMWuf8+fN6+OGHFR4erq5du2rx4sUaOnSo6tWrp7Zt20r6+5e8jh07asOGDerfv79q1aql3bt3a8qUKdq/f3++dfuePXu2Bg8erMcee0zPP/+80tLStGvXLm3ZskU9e/aUJCUmJur++++3foEoW7asli9frn79+iklJUUvvPCCTZtvvfWWHB0d9dJLLyk9PT3XngUZGRlq06aN0tPTNWjQIPn6+urEiRP69ttvlZSUJE9Pz1zjff3115WcnKzjx49rypQpkiQ3NzdT56xPnz6Ki4tTVFSUWrduLT8/P+3evVvR0dHq16+f2rVrp4sXL2rGjBkaMGCAOnfurPDwcElS/fr1r3s+N2zYoLi4OD333HNyd3fXe++9p4iICB09elSlS5eWJG3fvl0PP/ywypUrp+joaGVmZmrUqFHW5IQ97LmGUlJS9OGHH6pHjx565plndOHCBc2ZM0dt2rTRTz/9pIYNG9q0+cknn+jChQuKjIxUWlqa3n33XYWFhWn37t3y8fHJNY5PP/1UTz/9tO677z71799fkhQQECBJevbZZ7V48WINHDhQtWvX1tmzZ7Vhwwb9/vvvuvfee/M8tpMnT+q+++5TUlKS+vfvr8DAQJ04cUKLFy/WpUuXbK6nQYMGqWTJkhoxYoQOHz6sqVOnauDAgVq4cKG1zscffyw3NzdFRUXJzc1N8fHxevPNN5WSkqKJEyeaPq8XL15UWFiYTp06peeff16+vr5asGBBrkmY+Ph4tW3bVkFBQRoxYoQcHBwUGxursLAw/fjjj7rvvvvyPA+XL19Wy5Yt9ccff2jgwIGqUqWKFi1apN69eyspKUnPP/+8ihcvrs6dOysuLk4zZ860OTdLly5Venq6unfvLsn8PSU+Pl5ffPGFBg4cqDJlytgk5a41depUDRo0SG5ubnr99dclKc/r5drz/Mgjj6h79+7q0qWLZsyYoe7du2v+/Pl64YUX9Oyzz6pnz56aOHGiHnvsMR07dkzu7u6SzN+Psn399ddat26dRowYcd3YAKDIGQCAAhEbG2tIMrZu3ZpnHU9PT6NRo0bW5yNGjDCuvTXv2LHDkGQ899xzNq/r2bOnIckYMWLEdWPYunWrIcmIjY3NsS00NNSQZHzyySfWsvT0dMPX19eIiIiwln366aeGg4OD8eOPP9q8/oMPPjAkGRs3brxuDP7+/kavXr1y3X9oaKj1+aOPPmrUqVPnum3169fPKFeunPHXX3/ZlHfv3t3w9PQ0Ll26ZBiGYaxdu9aQZFStWtValpft27cbkoxFixZdt15u2rdvb/j7++coN3POTp06ZZQqVcpo3bq1kZ6ebjRq1MioVKmSkZycbK1z5syZPN/vf14zhmEYkgxHR0fjjz/+sJbt3LnTkGS8//771rIOHToYJUqUME6cOGEtO3DggHHPPffkaDM39l5DV69eNdLT021ee/78ecPHx8fo27evtezQoUOGJMPFxcU4fvy4tXzLli2GJGPIkCHXPW5XV9dcrzVPT08jMjLyhsfzT0899ZTh4OCQ62c4KyvLMIz/+5y3atXKWmYYhjFkyBCjWLFiRlJSkrUst2vxv//9r1GiRAkjLS3NWmbveZ00aZIhyVi6dKm17PLly0ZgYKAhyVi7dq011urVqxtt2rSxifHSpUtGlSpVjNatW1/3PEydOtWQZMybN89alpGRYQQHBxtubm5GSkqKYRiGsXLlSkOS8c0339i8vl27dkbVqlWtz818PiQZDg4Oxp49e64bY7Y6derY3FeyZd8Tss+JYfzfeV6wYIG1bO/evdZ9bt682VqefWzX3kvtvR9dKz4+3nBycjLat29vXL161a5jAoCiwjAEAChCbm5u110V4bvvvpMkDR482KY8r1+sbmb/TzzxhPW5o6Oj7rvvPv3555/WskWLFqlWrVoKDAzUX3/9ZX2EhYVJ0nW7kpvh5eWl48ePa+vWrbluNwxDS5YsUYcOHWQYhk0sbdq0UXJyco5u5b169bLOB5GX7J4DK1eu1KVLl/LlWMycM19fX8XExOj7779X8+bNtWPHDn300Ufy8PC4pRhatWpl/WVd+rsngoeHh/W9zczM1OrVq9WpUyeVL1/eWq9atWrWX67tYc81VKxYMesvzVlZWTp37pyuXr2qxo0b5zoUoFOnTqpQoYL1+X333aemTZtaPw9meXl5acuWLTp58qTdr8nKytLSpUvVoUMHmzlHsv1zmEb//v1typo3b67MzEwdOXLEWnbttXjhwgX99ddfat68uS5duqS9e/fatGfPeV2xYoUqVKigjh07WsucnZ1z9FTasWOHDhw4oJ49e+rs2bPW6/HixYt68MEH9cMPPygrKyvPc/Hdd9/J19dXPXr0sJYVL15cgwcPVmpqqtavXy/p7+FVZcqUselNcf78eX3//ffq1q2btczsPSU0NFS1a9fOM75b4ebmZu3xIEk1a9aUl5eXatWqpaZNm1rLs//OPv83cz86c+aMIiIi1LBhQy1atEjFihUrkGMCgPzCMAQAKEKpqany9vbOc/uRI0fk4OBg86VP+vs/tPmhYsWKOb70lCxZ0maVhgMHDuj333/Ps2v66dOn8yWWoUOHavXq1brvvvtUrVo1PfTQQ+rZs6dCQkIk/f0f7aSkJM2aNUuzZs2yK5YqVarccL9VqlRRVFSUJk+erPnz56t58+bq2LGjnnjiiTyHINyI2XPWvXt3zZs3T8uWLVP//v314IMP3tR+r1WpUqUcZSVLltT58+etMVy+fFnVqlXLUS+3srzYcw1J0ty5czVp0iTt3btXV65csZbn9h5Vr149R1mNGjX0xRdf2B3XtSZMmKBevXrJz89PQUFBateunZ566ilVrVo1z9ecOXNGKSkpqlu3rl37+Of5LlmypCRZz7ck7dmzR8OHD1d8fHyO+TP+OT+GPef1yJEjCggIyFHvn+/fgQMHJP2dPMtLcnKyNeZ/OnLkiKpXry4HB9vfmGrVqmXdLv096WRERIQWLFig9PR0OTk5KS4uTleuXLFJFpj9fNjzOb5ZuZ1nT09P+fn55SiT/u/9vJn70bJly3T+/HlNmTLlhklMALgdkCwAgCJy/PhxJScnm/pilt/y+mXLMAzr31lZWapXr54mT56ca91//qf6n/KaKC8zM9Nm/7Vq1dK+ffv07bffasWKFVqyZImmT5+uN998U9HR0dZfPp944ok8v/T8cxy/vf8hnzRpknr37q2vvvpKq1at0uDBgzV27Fht3rxZFStWtKuNa5k9Z2fPntXPP/8s6e/JArOysnJ8MTPLnvc2P9izn3nz5ql3797q1KmTXn75ZXl7e6tYsWIaO3asDh48mK/x5KZr165q3ry5vvzyS61atUoTJ07U+PHjFRcXZ6oXxfXc6DwkJSUpNDRUHh4eGjVqlAICAuTs7KxffvlFQ4cOzfHLfn6+f9ltT5w4Mcf8ENmy59u4Vd27d9fMmTO1fPlyderUSV988YUCAwPVoEEDm3jMfD4K8ot1Xuf5Ruf/Zu5HZ8+elSSVK1fupmIFgMJGsgAAisinn34qSWrTpk2edfz9/ZWVlaWDBw/a9CbYt2+fXfswM6N9XgICArRz5049+OCDN9VeyZIllZSUlKP8yJEjOX7ZdXV1Vbdu3dStWzdlZGQoPDxcb7/9toYNG2ZdDSIzM1OtWrW66ePJS7169VSvXj0NHz5c//vf/xQSEqIPPvjgumuh53U+zJ6zyMhIXbhwQWPHjtWwYcM0depURUVF3XA/t8Lb21vOzs76448/cmzLrexWLF68WFWrVlVcXJzNseQ1wVv2L+HX2r9/f54T22W73nkqV66cnnvuOT333HM6ffq07r33Xr399tt5JgvKli0rDw+PHKsw3Kx169bp7NmziouLU4sWLazlhw4duuk2/f399dtvv8kwDJtj/+f7l90zycPD46Y+O/7+/tq1a1eOJFb20Al/f39rWYsWLVSuXDktXLhQ//nPfxQfH2+dbPDaeG7lnnI9BfFZyc3N3I8aNmyoyMjIWx5iBACFhTkLAKAIxMfH66233lKVKlX0+OOP51kv+4vMe++9Z1M+depUu/bj6uoqSbl+WbdX165ddeLECc2ePTvHtsuXL+vixYvXfX1AQIA2b95ss0zYt99+q2PHjtnUy/7VLZujo6Nq164twzB05coVFStWTBEREVqyZEmuX+D+uUydvVJSUnT16lWbsnr16snBweGGS0O6urrmuryimXO2ePFiLVy4UOPGjdOrr76q7t27a/jw4dq/f7+1TokSJSTd2vv4T8WKFVOrVq20dOlSm7H8f/zxh5YvX55v+8nel2T7q/iWLVu0adOmXOsvXbpUJ06csD7/6aeftGXLlhv2AnB1dc1xjjIzM3O8R97e3ipfvvx1318HBwd16tRJ33zzjbXXx7XM/sKf2znIyMjQ9OnTTbVzrTZt2ujEiRP6+uuvrWVpaWk5rrugoCAFBATonXfeUWpqao52bvTZadeunRISEmzmIrh69aref/99ubm5KTQ01Fru4OCgxx57TN98840+/fRTXb161WYIgnTr95Trye0aKAg3cz9q0KCBBg4caF1NAQBud/QsAIACtnz5cu3du1dXr15VYmKi4uPj9f3338vf319ff/11jvW3r9WwYUP16NFD06dPV3Jyspo1a6Y1a9bY/ctvQECAvLy89MEHH8jd3V2urq5q2rSpqTHATz75pL744gs9++yzWrt2rUJCQpSZmam9e/fqiy++0MqVK3OdAC7b008/rcWLF+vhhx9W165ddfDgQc2bNy/HPAwPPfSQfH19FRISIh8fH/3++++aNm2a2rdvb/3P9bhx47R27Vo1bdpUzzzzjGrXrq1z587pl19+0erVq3Xu3Dm7jytbfHy8Bg4cqC5duqhGjRq6evWqPv30U+uXgesJCgrSwoULFRUVpSZNmsjNzU0dOnSw+5ydPn1aAwYM0AMPPKCBAwdKkqZNm6a1a9eqd+/e2rBhgxwcHOTi4qLatWtr4cKFqlGjhkqVKqW6devaPZ4+LyNHjtSqVasUEhKiAQMGKDMzU9OmTVPdunW1Y8eOW2r7Wo888oji4uLUuXNntW/fXocOHdIHH3yg2rVr5/rltVq1avrPf/6jAQMGKD09XVOnTlXp0qX1yiuvXHc/QUFBWr16tSZPnqzy5curSpUqqlmzpipWrKjHHntMDRo0kJubm1avXq2tW7dq0qRJ121vzJgxWrVqlUJDQ61L/J06dUqLFi3Shg0b5OXlZfc5aNasmUqWLKlevXpp8ODBslgs+vTTT29pWMh///tfTZs2TT169NDzzz+vcuXKaf78+dZ7Svav7A4ODvrwww/Vtm1b1alTR3369FGFChV04sQJrV27Vh4eHvrmm2/y3E///v01c+ZM9e7dW9u2bVPlypW1ePFibdy4UVOnTs3x5bdbt256//33NWLECNWrV886t0G2W72nXE9QUJBmzJih0aNHq1q1avL29rZOnJjfzN6Ppk2bpujoaB06dOiGvWQA4LZQ+AswAMDdIXtJteyHo6Oj4evra7Ru3dp49913rcuNXSu35eAuX75sDB482ChdurTh6upqdOjQwTh27JhdSycahmF89dVXRu3ata3L4WUv/RUaGprrUoW9evXKsRxgRkaGMX78eKNOnTqGk5OTUbJkSSMoKMiIjo62WeIvL5MmTTIqVKhgODk5GSEhIcbPP/+cY+nEmTNnGi1atDBKly5tODk5GQEBAcbLL7+co/3ExEQjMjLS8PPzM4oXL274+voaDz74oDFr1ixrnexl0uxZDvHPP/80+vbtawQEBBjOzs5GqVKljAceeMBYvXr1DV+bmppq9OzZ0/Dy8jIk2Zw3e85ZeHi44e7ubhw+fNim3a+++sqQZIwfP95a9r///c8ICgoyHB0dbd77vJZOzG2pwNyWsVyzZo3RqFEjw9HR0QgICDA+/PBD48UXXzScnZ1vePz2XkNZWVnGmDFjDH9/f8PJyclo1KiR8e233+aol7104sSJE41JkyYZfn5+hpOTk9G8eXNj586dNvvI7bj37t1rtGjRwnBxcTEkGb169TLS09ONl19+2WjQoIHh7u5uuLq6Gg0aNDCmT59+w+MzDMM4cuSI8dRTTxlly5Y1nJycjKpVqxqRkZHWpSDzWiI1t6X6Nm7caNx///2Gi4uLUb58eeOVV16xLsn3zyX97P1s/vnnn0b79u0NFxcXo2zZssaLL75oLFmyxJBks/SfYfy9TGh4eLj1M+bv72907drVWLNmzQ3PQ2JiotGnTx+jTJkyhqOjo1GvXr1cl2Q1jL/fbz8/P0OSMXr06Fzr2HtPyetazktCQoLRvn17w93d3ZBkvcfktXRibufZ39/faN++fY7y3GKx536ULfuaPXTokN3HAwBFyWIY+TzTEQAA+Ffr1KmT9uzZk+vcAbj9TZ06VUOGDNHx48dtlqAEAMAM5iwAAOAudvnyZZvnBw4c0HfffaeWLVsWTUAw5Z/vX1pammbOnKnq1auTKAAA3BLmLAAA4C5WtWpV9e7dW1WrVtWRI0c0Y8YMOTo63nB+ANwewsPDValSJTVs2FDJycmaN2+e9u7dq/nz5xd1aACAfzmSBQAA3MUefvhhffbZZ0pISJCTk5OCg4M1ZswYVa9evahDgx3atGmjDz/8UPPnz1dmZqZq166tzz//PMcKBAAAmMWcBQAAAAAAwAZzFgAAAAAAABskCwAAAAAAgI07fs6CrKwsnTx5Uu7u7rJYLEUdDgAAAAAARcYwDF24cEHly5eXg0Pe/Qfu+GTByZMn5efnV9RhAAAAAABw2zh27JgqVqyY5/Y7Plng7u4u6e8T4eHhUcTRAIB9Wr673q56654PLeBIAAAAcCdJSUmRn5+f9btyXu74ZEH20AMPDw+SBQD+NYo5u9pVj/saAAAAbsaNhukX6QSHlStXlsViyfGIjIyUJKWlpSkyMlKlS5eWm5ubIiIilJiYWJQhAwAAAABwxyvSZMHWrVt16tQp6+P777+XJHXp0kWSNGTIEH3zzTdatGiR1q9fr5MnTyo8PLwoQwYAAAAA4I5XpMMQypYta/N83LhxCggIUGhoqJKTkzVnzhwtWLBAYWFhkqTY2FjVqlVLmzdv1v33318UIQMAAAAAcMcr0p4F18rIyNC8efPUt29fWSwWbdu2TVeuXFGrVq2sdQIDA1WpUiVt2rSpCCMFAAAAAODOdttMcLh06VIlJSWpd+/ekqSEhAQ5OjrKy8vLpp6Pj48SEhLybCc9PV3p6enW5ykpKQUSLwAAAAAAd6rbJlkwZ84ctW3bVuXLl7+ldsaOHavo6Oh8igoAAODu02RivF31tr4cVsCRAACKym0xDOHIkSNavXq1nn76aWuZr6+vMjIylJSUZFM3MTFRvr6+ebY1bNgwJScnWx/Hjh0rsLgBAAAAALgT3RbJgtjYWHl7e6t9+/bWsqCgIBUvXlxr1qyxlu3bt09Hjx5VcHBwnm05OTnJw8PD5gEAAAAAAOxX5MMQsrKyFBsbq169eumee/4vHE9PT/Xr109RUVEqVaqUPDw8NGjQIAUHB7MSAgAAAAAABajIkwWrV6/W0aNH1bdv3xzbpkyZIgcHB0VERCg9PV1t2rTR9OnTiyBKAAAAAADuHkWeLHjooYdkGEau25ydnRUTE6OYmJhCjgoAAAAAgLvXbTFnAQAAAAAAuH2QLAAAAAAAADZIFgAAAAAAABskCwAAAAAAgA2SBQAAAAAAwAbJAgAAAAAAYINkAQAAAAAAsEGyAAAAAAAA2CBZAAAAAAAAbJAsAAAAAAAANkgWAAAAAAAAGyQLAAAAAACADZIFAAAAAADABskCAAAAAABgg2QBAAAAAACwQbIAAAAAAADYIFkAAAAAAABskCwAAAAAAAA2SBYAAAAAAAAbJAsAAAAAAIANkgUAAAAAAMAGyQIAAAAAAGCDZAEAAAAAALBBsgAAAAAAANggWQAAAAAAAGyQLAAAAAAAADbusadSVFSU3Q1Onjz5poMBAAAAAABFz65kwfbt222e//LLL7p69apq1qwpSdq/f7+KFSumoKAg0wGcOHFCQ4cO1fLly3Xp0iVVq1ZNsbGxaty4sSTJMAyNGDFCs2fPVlJSkkJCQjRjxgxVr17d9L4AAAAAAMCN2ZUsWLt2rfXvyZMny93dXXPnzlXJkiUlSefPn1efPn3UvHlzUzs/f/68QkJC9MADD2j58uUqW7asDhw4YG1XkiZMmKD33ntPc+fOVZUqVfTGG2+oTZs2+u233+Ts7GxqfwAAAAAA4MbsShZca9KkSVq1apXNF/qSJUtq9OjReuihh/Tiiy/a3db48ePl5+en2NhYa1mVKlWsfxuGoalTp2r48OF69NFHJUmffPKJfHx8tHTpUnXv3t1s+AAAAAAA4AZMT3CYkpKiM2fO5Cg/c+aMLly4YKqtr7/+Wo0bN1aXLl3k7e2tRo0aafbs2dbthw4dUkJCglq1amUt8/T0VNOmTbVp06Zc20xPT1dKSorNAwAAAAAA2M90sqBz587q06eP4uLidPz4cR0/flxLlixRv379FB4ebqqtP//80zr/wMqVKzVgwAANHjxYc+fOlSQlJCRIknx8fGxe5+PjY932T2PHjpWnp6f14efnZ/YQAQAAAAC4q5kehvDBBx/opZdeUs+ePXXlypW/G7nnHvXr108TJ0401VZWVpYaN26sMWPGSJIaNWqkX3/9VR988IF69eplNjRJ0rBhw2xWb0hJSSFhAAAAAACACaaTBSVKlND06dM1ceJEHTx4UJIUEBAgV1dX0zsvV66cateubVNWq1YtLVmyRJLk6+srSUpMTFS5cuWsdRITE9WwYcNc23RycpKTk5PpWAAAAAAAwN9MD0PIdurUKZ06dUrVq1eXq6urDMMw3UZISIj27dtnU7Z//375+/tL+nuyQ19fX61Zs8a6PSUlRVu2bFFwcPDNhg4AAAAAADi2JTAAACAASURBVK7DdLLg7NmzevDBB1WjRg21a9dOp06dkiT169fP1EoIkjRkyBBt3rxZY8aM0R9//KEFCxZo1qxZioyMlCRZLBa98MILGj16tL7++mvt3r1bTz31lMqXL69OnTqZDR0AAAAAANjBdLJgyJAhKl68uI4ePaoSJUpYy7t166YVK1aYaqtJkyb68ssv9dlnn6lu3bp66623NHXqVD3++OPWOq+88ooGDRqk/v37q0mTJkpNTdWKFSvk7OxsNnQAAAAAAGAH03MWrFq1SitXrlTFihVtyqtXr64jR46YDuCRRx7RI488kud2i8WiUaNGadSoUabbBgAAAAAA5pnuWXDx4kWbHgXZzp07x8SCAAAAAADcAUwnC5o3b65PPvnE+txisSgrK0sTJkzQAw88kK/BAQAAAACAwmd6GMKECRP04IMP6ueff1ZGRoZeeeUV7dmzR+fOndPGjRsLIkYAAAAAAFCITPcsqFu3rvbv36///Oc/evTRR3Xx4kWFh4dr+/btCggIKIgYAQAAAABAITLds0CSPD099frrr+d3LMBdr8nEeLvqbX05rIAjAQAAAHA3M92zoFq1aho5cqQOHDhQEPEAAAAAAIAiZjpZEBkZqWXLlqlmzZpq0qSJ3n33XSUkJBREbAAAAAAAoAiYThYMGTJEW7du1d69e9WuXTvFxMTIz89PDz30kM0qCQAAAAAA4N/JdLIgW40aNRQdHa39+/frxx9/1JkzZ9SnT5/8jA0AAAAAABSBm5rgMNtPP/2kBQsWaOHChUpJSVGXLl3yKy4AAAAAAFBETCcL9u/fr/nz5+uzzz7ToUOHFBYWpvHjxys8PFxubm4FESMAAAAAAChEppMFgYGBatKkiSIjI9W9e3f5+PgURFwAAAAAAKCImE4W7Nu3T9WrVy+IWAAAAAAAwG3A9ASHJAoAAAAAALiz2dWzoFSpUtq/f7/KlCmjkiVLymKx5Fn33Llz+RYcAAAAAAAofHYlC6ZMmSJ3d3dJ0tSpUws0IAAAAAAAULTsShb06tUr178BAAAAAMCdx/ScBZJ08OBBDR8+XD169NDp06clScuXL9eePXvyNTgAAAAAAFD4TCcL1q9fr3r16mnLli2Ki4tTamqqJGnnzp0aMWJEvgcIAAAAAAAKl+mlE1999VWNHj1aUVFR1nkMJCksLEzTpk3L1+AAAACAazWZGG9Xva0vhxVwJABwZzPds2D37t3q3LlzjnJvb2/99ddf+RIUAAAAAAAoOqaTBV5eXjp16lSO8u3bt6tChQr5EhQAAAAAACg6ppMF3bt319ChQ5WQkCCLxaKsrCxt3LhRL730kp566qmCiBEAAAAAABQi08mCMWPGKDAwUH5+fkpNTVXt2rXVokULNWvWTMOHDy+IGAEAAAAAQCEyPcGho6OjZs+erTfffFO7d+9WamqqGjVqpOrVqxdEfAAAAAAAoJCZThZk8/Pzk5+fX37GAgAAAAAAbgOmhyFERERo/PjxOconTJigLl26mGpr5MiRslgsNo/AwEDr9rS0NEVGRqp06dJyc3NTRESEEhMTzYYMAAAAAABMMJ0s+OGHH9SuXbsc5W3bttUPP/xgOoA6dero1KlT1seGDRus24YMGaJvvvlGixYt0vr163Xy5EmFh4eb3gcAAAAAALCf6WEIqampcnR0zFFevHhxpaSkmA/gnnvk6+ubozw5OVlz5szRggULFBYWJkmKjY1VrVq1tHnzZt1///2m9wUAAAAAAG7MdM+CevXqaeHChTnKP//8c9WuXdt0AAcOHFD58uVVtWpVPf744zp69Kgkadu2bbpy5YpatWplrRsYGKhKlSpp06ZNpvcDAAAAAADsY7pnwRtvvKHw8HAdPHjQ+ov/mjVr9Nlnn2nRokWm2mratKk+/vhj1axZU6dOnVJ0dLSaN2+uX3/9VQkJCXJ0dJSXl5fNa3x8fJSQkJBnm+np6UpPT7c+v5neDgAAAAAA3M1MJws6dOigpUuXasyYMVq8eLFcXFxUv359rV69WqGhoabaatu2rfXv+vXrq2nTpvL399cXX3whFxcXs6FJksaOHavo6Oibei0AAAAAALiJYQiS1L59e23cuFEXL17UX3/9pfj4eNOJgtx4eXmpRo0a+uOPP+Tr66uMjAwlJSXZ1ElMTMx1joNsw4YNU3JysvVx7NixW44LAAAAAIC7yU0lC5KSkvThhx/qtdde07lz5yRJv/zyi06cOHFLwaSmpurgwYMqV66cgoKCVLx4ca1Zs8a6fd++fTp69KiCg4PzbMPJyUkeHh42DwAAAAAAYD/TwxB27dqlVq1aydPTU4cPH9bTTz+tUqVKKS4uTkePHtUnn3xid1svvfSSOnToIH9/f508eVIjRoxQsWLF1KNHD3l6eqpfv36KiopSqVKl5OHhoUGDBik4OJiVEAAAAG4zTSbG21Vv68thBRwJACA/mO5ZEBUVpd69e+vAgQNydna2lrdr104//PCDqbaOHz+uHj16qGbNmuratatKly6tzZs3q2zZspKkKVOm6JFHHlFERIRatGghX19fxcXFmQ0ZAAAAAACYYLpnwdatWzVz5swc5RUqVLjuKgW5+fzzz6+73dnZWTExMYqJiTHVLgAAAAAAuHmmexY4OTnluhzh/v37rT0CAAAAAADAv5fpZEHHjh01atQoXblyRZJksVh09OhRDR06VBEREfkeIAAAAAAAKFymkwWTJk1SamqqvL29dfnyZYWGhqpatWpyd3fX22+/XRAxAgAAAACAQmR6zgJPT099//332rhxo3bu3KnU1FTde++9atWqVUHEBwAAAAAACpmpZMGVK1f08MMP64MPPlBISIhCQkIKKi4AAAAAAFBETA1DKF68uHbt2lVQsQAAAAAAgNuA6TkLnnjiCc2ZM6cgYgEAAAAAALcB03MWXL16VR999JFWr16toKAgubq62myfPHlyvgUHAAAAAAAKn+lkwa+//qp7771XkrR//36bbRaLJX+iAgAAAAAARcZ0smDt2rUFEQcAAAAAALhNmJ6zAAAAAAAA3NlIFgAAAAAAABskCwAAAAAAgA2SBQAAAAAAwAbJAgAAAAAAYMN0smDu3LlatmyZ9fkrr7wiLy8vNWvWTEeOHMnX4AAAAAAAQOEznSwYM2aMXFxcJEmbNm1STEyMJkyYoDJlymjIkCH5HiAAAAAAAChc95h9wbFjx1StWjVJ0tKlSxUREaH+/fsrJCRELVu2zO/4AAAAAABAITPds8DNzU1nz56VJK1atUqtW7eWJDk7O+vy5cv5Gx0AAAAAACh0pnsWtG7dWk8//bQaNWqk/fv3q127dpKkPXv2qHLlyvkdHwAAAAAAKGSmexbExMQoODhYZ86c0ZIlS1S6dGlJ0rZt29SjR498DxAAAAAAABQu0z0LvLy8NG3atBzl0dHR+RIQAAAAAAAoWqaTBbt27cq13GKxyNnZWZUqVZKTk9MtBwYAAAAAAIqG6WRBw4YNZbFY8txevHhxdevWTTNnzpSzs/MtBQcAAAAAAAqf6TkLvvzyS1WvXl2zZs3Sjh07tGPHDs2aNUs1a9bUggULNGfOHMXHx2v48OEFES8AAAAAAChgpnsWvP3223r33XfVpk0ba1m9evVUsWJFvfHGG/rpp5/k6uqqF198Ue+8806+BgsAAAAAAAqe6Z4Fu3fvlr+/f45yf39/7d69W9LfQxVOnTp169EBAAAAAIBCZzpZEBgYqHHjxikjI8NaduXKFY0bN06BgYGSpBMnTsjHx8dUu+PGjZPFYtELL7xgLUtLS1NkZKRKly4tNzc3RUREKDEx0WzIAAAAAADABNPDEGJiYtSxY0dVrFhR9evXl/R3b4PMzEx9++23kqQ///xTzz33nN1tbt26VTNnzrS2l23IkCFatmyZFi1aJE9PTw0cOFDh4eHauHGj2bABAAAAAICdTCcLmjVrpkOHDmn+/Pnav3+/JKlLly7q2bOn3N3dJUlPPvmk3e2lpqbq8ccf1+zZszV69GhreXJysubMmaMFCxYoLCxMkhQbG6tatWpp8+bNuv/++82GDgAAAAAA7GA6WSBJ7u7uevbZZ/MlgMjISLVv316tWrWySRZs27ZNV65cUatWraxlgYGBqlSpkjZt2pRnsiA9PV3p6enW5ykpKfkSJwAAAAAAdwvTcxbMnTtXy5Ytsz5/5ZVX5OXlpWbNmunIkSOm2vr888/1yy+/aOzYsTm2JSQkyNHRUV5eXjblPj4+SkhIyLPNsWPHytPT0/rw8/MzFRMAAAAAAHc708mCMWPGyMXFRZK0adMmTZs2TRMmTFCZMmU0ZMgQu9s5duyYnn/+ec2fP1/Ozs5mw8jTsGHDlJycbH0cO3Ys39oGAAAAAOBuYHoYwrFjx1StWjVJ0tKlS/XYY4+pf//+CgkJUcuWLe1uZ9u2bTp9+rTuvfdea1lmZqZ++OEHTZs2TStXrlRGRoaSkpJsehckJibK19c3z3adnJzk5ORk9rAAAAAAAMD/Z7pngZubm86ePStJWrVqlVq3bi1JcnZ21uXLl+1u58EHH9Tu3bu1Y8cO66Nx48Z6/PHHrX8XL15ca9assb5m3759Onr0qIKDg82GDQAAAAAA7GS6Z0Hr1q319NNPq1GjRtq/f7/atWsnSdqzZ48qV65sdzvu7u6qW7euTZmrq6tKly5tLe/Xr5+ioqJUqlQpeXh4aNCgQQoODmYlBAAAAACAVZOJ8XbV2/pyWAFHcucw3bMgJiZGwcHBOnPmjJYsWaLSpUtL+ntYQY8ePfI1uClTpuiRRx5RRESEWrRoIV9fX8XFxeXrPgAAAAAAgC3TPQu8vLw0bdq0HOXR0dG3HMy6detsnjs7OysmJkYxMTG33DYAAAAAALCP6WSBJKWlpWnXrl06ffq0srKyrOUWi0UdOnTIt+AAAAAAAEDhM50sWLFihZ588knrJIfXslgsyszMzJfAAAAAAABA0TA9Z8GgQYPUtWtXnTp1SllZWTYPEgUAAAAAAPz7mU4WJCYmKioqSj4+PgURDwAAAAAAKGKmhyE89thjWrdunQICAgoiHgAAAAAAChzLLV6f6WTBtGnT1KVLF/3444+qV6+eihcvbrN98ODB+RYcAAAAAAAofKaTBZ999plWrVolZ2dnrVu3ThaLxbrNYrGQLAAAAAAA4F/OdLLg9ddfV3R0tF599VU5OJie8gAAAAAAANzmTH/bz8jIULdu3UgUAAAAAABwhzL9jb9Xr15auHBhQcQCAAAAAABuA6aHIWRmZmrChAlauXKl6tevn2OCw8mTJ+dbcAAAAAAAoPCZThbs3r1bjRo1kiT9+uuvNtuunewQAAAAAAD8O5lOFqxdu7Yg4kAhYB1RAAAA3I7s/X+qxP9VgcJyS7MUfvbZZ7p48WJ+xQIAAAAAAG4Dt5Qs+O9//6vExMT8igUAAAAAANwGbilZYBhGfsUBAAAAAABuE7eULAAAAAAAAHeeW0oWLF++XBUqVMivWAAAAAAAwG3AdLIgLCxMSUlJkqT//Oc/cnJykiSlpKQoLIyZSQEAAAAA+LcznSxYt26dMjIycpSnpaXpxx9/zJegAAAAAABA0bnH3oq7du2y/v3bb78pISHB+jwzM1MrVqxgSAIAAAAAAHcAu5MFDRs2lMVikcViyXW4gYuLi95///18DQ4AAAAAABQ+u5MFhw4dkmEYqlq1qn766SeVLVvWus3R0VHe3t4qVqxYgQQJAAAAAAAKj93JAn9/f0lSVlZWnnUMw5DFYrn1qAAApjWZGG9Xva0vMxktAAAArs/0BIe9e/fWxYsXc5QfPnxYLVq0yJegAAAAAABA0TGdLNi5c6fq16+vTZs2Wcvmzp2rBg0aqEyZMvkaHAAAAAAAKHymkwU//fSTwsPD1bJlS7322mvq2rWrBg4cqHfeeUdffvmlqbZmzJih+vXry8PDQx4eHgoODtby5cut29PS0hQZGanSpUvLzc1NERERSkxMNBsyAAAAAAAwwe45C7IVL15cEydOVIkSJfTWW2/pnnvu0fr16xUcHGx65xUrVtS4ceNUvXp1GYahuXPn6tFHH9X27dtVp04dDRkyRMuWLdOiRYvk6empgQMHKjw8XBs3bjS9LwAAAKAg2Tt3jMT8Mcg/zFmEgmK6Z8GVK1f04osvavz48Ro2bJiCg4MVHh6u7777zvTOO3TooHbt2ql69eqqUaOG3n77bbm5uWnz5s1KTk7WnDlzNHnyZIWFhSkoKEixsbH63//+p82bN5veFwAAAAAAsI/pngWNGzfWpUuXtG7dOt1///0yDEMTJkxQeHi4+vbtq+nTp99UIJmZmVq0aJEuXryo4OBgbdu2TVeuXFGrVq2sdQIDA1WpUiVt2rRJ999/f67tpKenKz093fo8JSXlpuIBAAAAAOBudVPJgvfee0+urq6SJIvFoqFDh+qhhx7Sk08+aTqA3bt3Kzg4WGlpaXJzc9OXX36p2rVra8eOHXJ0dJSXl5dNfR8fHyUkJOTZ3tixYxUdHW06DgAAAAC4GzBkBvYwPQxhzpw51kTBtRo1aqRt27aZDqBmzZrasWOHtmzZogEDBqhXr1767bffTLeTbdiwYUpOTrY+jh07dtNtAQAAAABwNzLds0CSDh48qNjYWB08eFDvvvuuvL29tXz5clWqVEl16tQx1Zajo6OqVasmSQoKCtLWrVv17rvvqlu3bsrIyFBSUpJN74LExET5+vrm2Z6Tk5OcnJxu5rAAAAAAAIBuomfB+vXrVa9ePW3ZskVxcXFKTU2VJO3cuVMjRoy45YCysrKUnp6uoKAgFS9eXGvWrLFu27dvn44ePXpTKy8AAAAAAAD7mO5Z8Oqrr2r06NGKioqSu7u7tTwsLEzTpk0z1dawYcPUtm1bVapUSRcuXNCCBQu0bt06rVy5Up6enurXr5+ioqJUqlQpeXh4aNCgQQoODs5zckMABYdleQAAAIC7h+lkwe7du7VgwYIc5d7e3vrrr79MtXX69Gk99dRTOnXqlDw9PVW/fn2tXLlSrVu3liRNmTJFDg4OioiIUHp6utq0aXPTqy0AAAAAAAD7mE4WeHl56dSpU6pSpYpN+fbt21WhQgVTbc2ZM+e6252dnRUTE6OYmBizYQIAAAAAgJtkes6C7t27a+jQoUpISJDFYlFWVpY2btyol156SU899VRBxAgAAAAAAAqR6WTBmDFjFBgYKD8/P6Wmpqp27dpq0aKFmjVrpuHDhxdEjAAAAAAAoBCZHobg6Oio2bNn680339Tu3buVmpqqRo0aqXr16gURHwAAAAAAKGSmexaMGjVKly5dkp+fn9q1a6euXbuqevXqunz5skaNGlUQMQIAAAAAgEJkOlkQHR2t1NTUHOWXLl1SdHR0vgQFAAAAAACKjulhCIZhyGKx5CjfuXOnSpUqlS9BAQBQmJpMjLer3taXwwo4EgAA7hz2/vsq8W/s7cjuZEHJkiVlsVhksVhUo0YNm4RBZmamUlNT9eyzzxZIkAAAAAAAoPDYnSyYOnWqDMNQ3759FR0dLU9PT+s2R0dHVa5cWcHBwQUSJAAAAAAAKDx2Jwt69eolSapSpYpCQkJ0zz2mRzAAAAAAAIB/AdPf+ENDQwsiDgAAAAAAcJswvRoCAAAAAAC4s5EsAAAAAAAANuxKFuzatUtZWVkFHQsAAAAAALgN2JUsaNSokf766y9JUtWqVXX27NkCDQoAAAAAABQdu5IFXl5eOnTokCTp8OHD9DIAAAAAAOAOZtdqCBEREQoNDVW5cuVksVjUuHFjFStWLNe6f/75Z74GCAAAAAAACpddyYJZs2YpPDxcf/zxhwYPHqxnnnlG7u7uBR1bkWoyMd7uultfDrvt9wMAAAAAgL3sShZI0sMPPyxJ2rZtm55//vk7PlkAAAAAAMDdyu5kQbbY2Fjr38ePH5ckVaxYMf8iAgAAAAAARcquCQ6vlZWVpVGjRsnT01P+/v7y9/eXl5eX3nrrLSY+BAAAAADgDmC6Z8Hrr7+uOXPmaNy4cQoJCZEkbdiwQSNHjlRaWprefvvtfA8SAAB72TsXDPPAAMDdh/nCAPuZThbMnTtXH374oTp27Ggtq1+/vipUqKDnnnuOZAEAAAAAAP9ypochnDt3ToGBgTnKAwMDde7cuXwJCgAAAAAAFB3TPQsaNGigadOm6b333rMpnzZtmho0aJBvgQEF4Wa6ntFd7c7E+woAdw/u+QDuBvbe6zLTLtpVz3SyYMKECWrfvr1Wr16t4OBgSdKmTZt07Ngxfffdd2abAwAAAAAAtxnTwxBCQ0O1f/9+de7cWUlJSUpKSlJ4eLj27dun5s2bF0SMAAAAAACgEJnuWSBJ5cuXz5eJDMeOHau4uDjt3btXLi4uatasmcaPH6+aNWta66SlpenFF1/U559/rvT0dLVp00bTp0+Xj4/PLe8fAAAAAADkdFPJgvyyfv16RUZGqkmTJrp69apee+01PfTQQ/rtt9/k6uoqSRoyZIiWLVumRYsWydPTUwMHDlR4eLg2btxYlKEDAADgDsY8BwDudkWaLFixYoXN848//lje3t7atm2bWrRooeTkZM2ZM0cLFixQWNjfN+HY2FjVqlVLmzdv1v33318UYQMAAAAAcEczPWdBQUpOTpYklSpVSpK0bds2XblyRa1atbLWCQwMVKVKlbRp06YiiREAAAAAgDtdkfYsuFZWVpZeeOEFhYSEqG7dupKkhIQEOTo6ysvLy6auj4+PEhIScm0nPT1d6enp1ucpKSkFFzQAAAAAAHcg08mCsLAwxcXF5fgCn5KSok6dOik+3v7xXdeKjIzUr7/+qg0bNtzU67ONHTtW0dHRt9QGAAA3Yu94ZsYyA/g3414H3L1MD0NYt26dMjIycpSnpaXpxx9/vKkgBg4cqG+//VZr165VxYoVreW+vr7KyMhQUlKSTf3ExET5+vrm2tawYcOUnJxsfRw7duymYgIAAAAA4G5ld8+CXbt2Wf/+7bffbIYBZGZmasWKFapQoYKpnRuGoUGDBunLL7/UunXrVKVKFZvtQUFBKl68uNasWaOIiAhJ0r59+3T06FEFBwfn2qaTk5OcnJxMxQEAAAAAAP6P3cmChg0bymKxyGKxWFcmuJaLi4vef/99UzuPjIzUggUL9NVXX8nd3d2agPD09JSLi4s8PT3Vr18/RUVFqVSpUvLw8NCgQYMUHBzMSggAAAAAABQQu5MFhw4dkmEYqlq1qn766SeVLVvWus3R0VHe3t4qVqyYqZ3PmDFDktSyZUub8tjYWPXu3VuSNGXKFDk4OCgiIkLp6elq06aNpk+fbmo/AGzdzuMPWdca2bgWgFvH5+j2x3sE4HZld7LA399f0t+rFuQXwzBuWMfZ2VkxMTGKiYnJt/0CAAAAAIC83dTSiQcOHNDatWt1+vTpHMmDN998M18CAwAAAAAARcN0smD27NkaMGCAypQpI19fX1ksFus2i8VCsgAA/uF2HvYBALh78O8RADNMJwtGjx6tt99+W0OHDi2IeAAAAAAAQBFzMPuC8+fPq0uXLgURCwAAAAAAuA2YThZ06dJFq1atKohYAAAAAADAbcD0MIRq1arpjTfe0ObNm1WvXj0VL17cZvvgwYPzLTgAAO52LKsGALkrzPsj8z3gbmQ6WTBr1iy5ublp/fr1Wr9+vc02i8VCsgAAAAAAgH8508mCQ4cOFUQcAAAAAADgNmF6zgIAAAAAAHBnM92zoG/fvtfd/tFHH910MAAAALlhvDAAAIXLdLLg/PnzNs+vXLmiX3/9VUlJSQoL4x9oAAAAAAD+7UwnC7788sscZVlZWRowYIACAgLyJSgAAAAAAFB08mXOAgcHB0VFRWnKlCn50RwAAAAAAChCpnsW5OXgwYO6evVqfjWHuwxjUQEA+e12/rflZtaHL8w15QEAMJ0siIqKsnluGIZOnTqlZcuWqVevXvkWGAAAAAAAKBqmkwXbt2+3ee7g4KCyZctq0qRJN1wpAQAAAAAA3P5MJwvWrl1bEHHgNnU7d+EEABQtusUDAHBj/9bvVDc9Z8GZM2e0b98+SVLNmjVVtmzZfAsKAAAAAAAUHdOrIVy8eFF9+/ZVuXLl1KJFC7Vo0ULly5dXv379dOnSpYKIEQAAAAAAFCLTyYKoqCitX79e33zzjZKSkpSUlKSvvvpK69ev14svvlgQMQIAAAAAgEJkehjCkiVLtHjx/2vv3oOiOs84jv+2IBdFQFEW0IgkwbuikUjRODGRhOKlISaGOrYSUTpNMN4lceIFU0dNOnbUToqa6mptUpo4o22ciDFUMSoSLzXxFqPGqK1cTLxwUdHC6R8OW05Q47bArrvfz8zOuO/7PrvPLI+H5Zn3nLNegwYNso8NGTJE/v7+euGFF5Sdnd2Q+TWYQUvz5eXX4q5rXO0cEQBwF5zb3rT4vAEADY3fLU3LFT5vh3cWXL16VVartd54aGgopyEAAAAAAOAGHG4WxMfHa+7cubp+/bp97Nq1a5o3b57i4+MbNDkAAAAAAND0HD4NYenSpUpMTFT79u0VExMjSfr888/l5+enLVu2NHiCAAAAAACgaTncLOjRo4dOnDihd999V19++aUkadSoURo9erT8/f0bPEEA+CFNeU7X/XqfXAAAmgq/KwH34HCzQJKaN2+u9PT0hs4FAAAAAAC4AIevWbBw4UKtXr263vjq1av15ptvNkhSAAAAAADAeRxuFqxYsUJdunSpN969e3ctX77codfasWOHhg8froiICFksFm3cuNE0bxiG5syZo/DwcPn7+yshIUEnTpxwNGUAAAAAAOAAh09DKC4uVnh4eL3xtm3bqqioyKHXqqysVExMjNLS0jRixIh682+99ZaWLVumtWvXKioqSrNnz1ZiYqKOHj0qPz8/R1NHE2mq89Rc4d6jd8I59AAAZg3ZigAAFC9JREFUoDHx+x9AY3O4WfDAAw9o165dioqKMo3v2rVLERERDr1WUlKSkpKSbjtnGIaWLFmiWbNm6ZlnnpEk/fGPf5TVatXGjRv1s5/9zNHUAQAAAADAPXC4WZCenq7Jkyfr5s2bevLJW53KvLw8ZWZmatq0aQ2W2OnTp1VcXKyEhAT7WFBQkOLi4lRQUHDHZkFVVZWqqqrsz8vKyhosJwAAAAAAPIHDzYIZM2bou+++08svv6wbN25Ikvz8/PTqq69q5syZDZZYcXGxJMlqtZrGrVarfe52Fi5cqHnz5jVYHgAAeAJXPrULAAA0PYcvcGixWPTmm2/qwoUL2rNnjz7//HNdvHhRc+bMaYz8HDZz5kxduXLF/jh37pyzUwIAAAAA4L7i8M6CWgEBAXr00UcbMheTsLAwSVJJSYnpgoolJSXq3bv3HeN8fX3l6+vbaHkBAAAAAODuHN5Z0FSioqIUFhamvLw8+1hZWZkKCwsVHx/vxMwAAAAAAHBv//POgoZQUVGhkydP2p+fPn1aBw8eVOvWrdWhQwdNnjxZ8+fPV3R0tP3WiREREUpOTnZi1gDgPjhPHQAAALfj1GbBvn379MQTT9ifT506VZKUmpqqNWvWKDMzU5WVlfrlL3+py5cv67HHHlNubq78/PyclTIAAAAAAG7Pqc2CQYMGyTCMO85bLBa98cYbeuONN5owKwAAAAAAPJvLXrMAAAAAAAA4h1N3Frgbzv0FAAAAALgDdhYAAAAAAAATmgUAAAAAAMCEZgEAAAAAADDhmgX3Ia6NAMCZOAbBnd1rfVPbDYPPGwBcFzsLAAAAAACACc0CAAAAAABgwmkIABoN29UBM7Zc38LnAACA62NnAQAAAAAAMKFZAAAAAAAATGgWAAAAAAAAE65ZAAAAAADAPfCk6+6wswAAAAAAAJjQLAAAAAAAACY0CwAAAAAAgAnXLAAAAACABuZJ57bDPbGzAAAAAAAAmNAsAAAAAAAAJjQLAAAAAACACc0CAAAAAABgQrMAAAAAAACY0CwAAAAAAAAm3DoRAADg/3Cvt0eTuEUagLvjdotwJewsAAAAAAAAJjQLAAAAAACAyX3RLHj77bfVsWNH+fn5KS4uTp999pmzUwIAAAAAwG25fLPgL3/5i6ZOnaq5c+fqwIEDiomJUWJiokpLS52dGgAAAAAAbsnlmwW//e1vlZ6errFjx6pbt25avny5mjdvrtWrVzs7NQAAAAAA3JJLNwtu3Lih/fv3KyEhwT72ox/9SAkJCSooKHBiZgAAAAAAuC+XvnXit99+q+rqalmtVtO41WrVl19+eduYqqoqVVVV2Z9fuXJFklR9/eoPvl9ZWZn939XXK+85z9o4V45xJM7dYurGuXKMI3HuFlM3zpVjHIlzt5i6ca4c40icu8XUjXPlGEfi3C2mbpwrxzgS524xdeNcOcaROHeLqRvH5934MXXjmvLz/l+42mfnyj+j2r+NDcO46zqL8UMrnOj8+fNq166ddu/erfj4ePt4Zmam8vPzVVhYWC8mKytL8+bNa8o0AQAAAAC4r5w7d07t27e/47xL7yxo06aNvLy8VFJSYhovKSlRWFjYbWNmzpypqVOn2p/X1NTo4sWLCgkJkcViadR84VxlZWV64IEHdO7cOQUGBjo7HTgZ9YBa1AJqUQuoRS2gLuoBtTylFgzDUHl5uSIiIu66zqWbBT4+Purbt6/y8vKUnJws6dYf/3l5eZowYcJtY3x9feXr62saCw4ObvRc4ToCAwPd+j83HEM9oBa1gFrUAmpRC6iLekAtT6iFoKCgH1zj0s0CSZo6dapSU1MVGxurfv36acmSJaqsrNTYsWOdnRoAAAAAAG7J5ZsFKSkpunDhgubMmaPi4mL17t1bubm59S56CAAAAAAAGoZXVlZWlrOT+CH9+vXTlClTNHv2bKWnp9/1IgzwbF5eXho0aJC8vV2+D4YmQD2gFrWAWtQCalELqIt6QC1q4b9c+m4IAAAAAACg6f3I2QkAAAAAAADXQrMAAAAAAACY0CwAAAAAAAAmNAsAAAAAAIAJzQLcd3bs2KHhw4crIiJCFotFGzduNM0bhqE5c+YoPDxc/v7+SkhI0IkTJ5yULRrTwoUL9eijj6ply5YKDQ1VcnKyjh8/blpz/fp1ZWRkKCQkRAEBAXruuedUUlLipIzRWLKzs9WrVy8FBgYqMDBQ8fHx2rx5s32eOvBcixYtksVi0eTJk+1j1IPnyMrKksViMT26dOlin6cWPMu//vUv/fznP1dISIj8/f3Vs2dP7du3zz7Pd0jP0LFjx3rHBYvFooyMDEkcF+qiWYD7TmVlpWJiYvT222/fdv6tt97SsmXLtHz5chUWFqpFixZKTEzU9evXmzhTNLb8/HxlZGRoz5492rp1q27evKmnn35alZWV9jVTpkzRhx9+qA8++ED5+fk6f/68RowY4cSs0Rjat2+vRYsWaf/+/dq3b5+efPJJPfPMMzpy5Igk6sBT7d27VytWrFCvXr1M49SDZ+nevbuKiorsj507d9rnqAXPcenSJQ0YMEDNmjXT5s2bdfToUS1evFitWrWyr+E7pGfYu3ev6ZiwdetWSdLIkSMlcVwwMYD7mCRjw4YN9uc1NTVGWFiY8Zvf/MY+dvnyZcPX19f485//7IwU0YRKS0sNSUZ+fr5hGLd+9s2aNTM++OAD+5pjx44ZkoyCggJnpYkm0qpVK+MPf/gDdeChysvLjejoaGPr1q3G448/bkyaNMkwDI4Lnmbu3LlGTEzMbeeoBc/y6quvGo899tgd5/kO6bkmTZpkPPTQQ0ZNTQ3Hhe9hZwHcyunTp1VcXKyEhAT7WFBQkOLi4lRQUODEzNAUrly5Iklq3bq1JGn//v26efOmqR66dOmiDh06UA9urLq6Wjk5OaqsrFR8fDx14KEyMjI0dOhQ089d4rjgiU6cOKGIiAg9+OCDGj16tM6ePSuJWvA0f/vb3xQbG6uRI0cqNDRUffr00TvvvGOf5zukZ7px44b+9Kc/KS0tTRaLhePC99AsgFspLi6WJFmtVtO41Wq1z8E91dTUaPLkyRowYIB69Ogh6VY9+Pj4KDg42LSWenBPhw4dUkBAgHx9ffWrX/1KGzZsULdu3agDD5STk6MDBw5o4cKF9eaoB88SFxenNWvWKDc3V9nZ2Tp9+rQGDhyo8vJyasHDfP3118rOzlZ0dLS2bNmil156SRMnTtTatWsl8R3SU23cuFGXL1/Wiy++KInfEd/n7ewEAKAhZGRk6PDhw6ZzUeFZOnfurIMHD+rKlStav369UlNTlZ+f7+y00MTOnTunSZMmaevWrfLz83N2OnCypKQk+7979eqluLg4RUZG6v3335e/v78TM0NTq6mpUWxsrBYsWCBJ6tOnjw4fPqzly5crNTXVydnBWVatWqWkpCRFREQ4OxWXxM4CuJWwsDBJqnfF0pKSEvsc3M+ECRO0adMmbdu2Te3bt7ePh4WF6caNG7p8+bJpPfXgnnx8fPTwww+rb9++WrhwoWJiYrR06VLqwMPs379fpaWleuSRR+Tt7S1vb2/l5+dr2bJl8vb2ltVqpR48WHBwsDp16qSTJ09ybPAw4eHh6tatm2msa9eu9tNS+A7pec6cOaNPPvlE48ePt49xXDCjWQC3EhUVpbCwMOXl5dnHysrKVFhYqPj4eCdmhsZgGIYmTJigDRs26O9//7uioqJM83379lWzZs1M9XD8+HGdPXuWevAANTU1qqqqog48zODBg3Xo0CEdPHjQ/oiNjdXo0aPt/6YePFdFRYVOnTql8PBwjg0eZsCAAfVur/zVV18pMjJSEt8hPZHNZlNoaKiGDh1qH+O4YMZpCLjvVFRU6OTJk/bnp0+f1sGDB9W6dWt16NBBkydP1vz58xUdHa2oqCjNnj1bERERSk5OdmLWaAwZGRl677339Ne//lUtW7a0n0sWFBQkf39/BQUFady4cZo6dapat26twMBAvfLKK4qPj9ePf/xjJ2ePhjRz5kwlJSWpQ4cOKi8v13vvvaft27dry5Yt1IGHadmypf26JbVatGihkJAQ+zj14DmmT5+u4cOHKzIyUufPn9fcuXPl5eWlUaNGcWzwMFOmTFH//v21YMECvfDCC/rss8+0cuVKrVy5UpJksVj4DulBampqZLPZlJqaKm/v//5JzHHhe5x9OwbAUdu2bTMk1XukpqYahnHr1jezZ882rFar4evrawwePNg4fvy4c5NGo7hdHUgybDabfc21a9eMl19+2WjVqpXRvHlz49lnnzWKioqclzQaRVpamhEZGWn4+PgYbdu2NQYPHmx8/PHH9nnqwLPVvXWiYVAPniQlJcUIDw83fHx8jHbt2hkpKSnGyZMn7fPUgmf58MMPjR49ehi+vr5Gly5djJUrV5rm+Q7pObZs2WJIuu3Pl+PCf1kMwzCc06YAAAAAAACuiGsWAAAAAAAAE5oFAAAAAADAhGYBAAAAAAAwoVkAAAAAAABMaBYAAAAAAAATmgUAAAAAAMCEZgEAAAAAADChWQAAgIfYvn27LBaLLl++7JT3z8vLU9euXVVdXX3HNVlZWerdu3eT5fTaa6/plVdeabL3AwDgfkGzAAAAN2CxWO76yMrKUv/+/VVUVKSgoCCn5JiZmalZs2bJy8vLKe9/O9OnT9fatWv19ddfOzsVAABcCs0CAADcQFFRkf2xZMkSBQYGmsamT58uHx8fhYWFyWKxNHl+O3fu1KlTp/Tcc881+XvfTZs2bZSYmKjs7GxnpwIAgEuhWQAAgBsICwuzP4KCgmSxWExjAQEB9U5DWLNmjYKDg7Vp0yZ17txZzZs31/PPP6+rV69q7dq16tixo1q1aqWJEyeaTh2oqqrS9OnT1a5dO7Vo0UJxcXHavn37XfPLycnRU089JT8/P9P4okWLZLVa1bJlS40bN07Xr183ze/du1dPPfWU2rRpo6CgID3++OM6cOCAfT4tLU3Dhg0zxdy8eVOhoaFatWqVJGn9+vXq2bOn/P39FRISooSEBFVWVtrXDx8+XDk5Off+YQMA4AFoFgAA4MGuXr2qZcuWKScnR7m5udq+fbueffZZffTRR/roo4+0bt06rVixQuvXr7fHTJgwQQUFBcrJydEXX3yhkSNH6ic/+YlOnDhxx/f59NNPFRsbaxp7//33lZWVpQULFmjfvn0KDw/X73//e9Oa8vJypaamaufOndqzZ4+io6M1ZMgQlZeXS5LGjx+v3NxcFRUV2WM2bdqkq1evKiUlRUVFRRo1apTS0tJ07Ngxbd++XSNGjJBhGPb1/fr10z//+U998803/89HCQCAW/F2dgIAAMB5bt68qezsbD300EOSpOeff17r1q1TSUmJAgIC1K1bNz3xxBPatm2bUlJSdPbsWdlsNp09e1YRERGSbp33n5ubK5vNpgULFtz2fc6cOWNfX2vJkiUaN26cxo0bJ0maP3++PvnkE9PugieffNIUs3LlSgUHBys/P1/Dhg1T//791blzZ61bt06ZmZmSJJvNppEjRyogIEBfffWV/v3vf2vEiBGKjIyUJPXs2dP0mrV5nTlzRh07dvxfPkYAANwOOwsAAPBgzZs3tzcKJMlqtapjx44KCAgwjZWWlkqSDh06pOrqanXq1EkBAQH2R35+vk6dOnXH97l27Vq9UxCOHTumuLg401h8fLzpeUlJidLT0xUdHa2goCAFBgaqoqJCZ8+eta8ZP368bDabff3mzZuVlpYmSYqJidHgwYPVs2dPjRw5Uu+8844uXbpkeg9/f39Jt3ZZAACAW9hZAACAB2vWrJnpucViue1YTU2NJKmiokJeXl7av39/vbsa1G0wfF+bNm3q/ZF+L1JTU/Xdd99p6dKlioyMlK+vr+Lj43Xjxg37mjFjxui1115TQUGBdu/eraioKA0cOFCS5OXlpa1bt2r37t36+OOP9bvf/U6vv/66CgsLFRUVJUm6ePGiJKlt27YO5wcAgLtiZwEAALhnffr0UXV1tUpLS/Xwww+bHmFhYXeNO3r0qGmsa9euKiwsNI3t2bPH9HzXrl2aOHGihgwZou7du8vX11fffvutaU1ISIiSk5Nls9m0Zs0ajR071jRvsVg0YMAAzZs3T//4xz/k4+OjDRs22OcPHz6sZs2aqXv37g59FgAAuDN2FgAAgHvWqVMnjR49WmPGjNHixYvVp08fXbhwQXl5eerVq5eGDh1627jExEStXbvWNDZp0iS9+OKLio2N1YABA/Tuu+/qyJEjevDBB+1roqOjtW7dOsXGxqqsrEwzZsywnzZQ1/jx4zVs2DBVV1crNTXVPl5YWKi8vDw9/fTTCg0NVWFhoS5cuKCuXbva13z66acaOHDgbV8XAABPxc4CAADgEJvNpjFjxmjatGnq3LmzkpOTtXfvXnXo0OGOMaNHj9aRI0d0/Phx+1hKSopmz56tzMxM9e3bV2fOnNFLL71kilu1apUuXbqkRx55RL/4xS80ceJEhYaG1nv9hIQEhYeHKzEx0XQhxcDAQO3YsUNDhgxRp06dNGvWLC1evFhJSUn2NTk5OUpPT/9/PhIAANyOxah77yAAAIBGMmPGDJWVlWnFihUN/toVFRVq166dbDabRowYcc9xmzdv1rRp0/TFF1/I25sNlwAA1GJnAQAAaBKvv/66IiMj7RdLbAg1NTUqLS3Vr3/9awUHB+unP/2pQ/GVlZWy2Ww0CgAA+B52FgAAgPvWN998o6ioKLVv315r1qzR4MGDnZ0SAABugWYBAAAAAAAw4TQEAAAAAABgQrMAAAAAAACY0CwAAAAAAAAmNAsAAAAAAIAJzQIAAAAAAGBCswAAAAAAAJjQLAAAAAAAACY0CwAAAAAAgAnNAgAAAAAAYPIfLFeg7gfnO5oAAAAASUVORK5CYII=", + "text/plain": [ + "Figure(PyObject
)" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "figure(figsize=(12.5, 3.5))\n", + "count_data_matrix = round.(Int64, readdlm(\"data/txtdata.csv\"))\n", + "# Convert 1xn matrix to n-vector\n", + "count_data = [(count_data_matrix...,) ...]\n", + "n_count_data = length(count_data)\n", + "days = 1:n_count_data\n", + "bar(days, count_data, color=\"#348ABD\")\n", + "xlabel(\"Time (days)\")\n", + "ylabel(\"count of text-msgs received\")\n", + "title(\"Did the user's texting habits change over time?\")\n", + "xlim(0, n_count_data);\n", + "autoscale(tight=true);" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Before we start modeling, see what you can figure out just by looking at the chart above. Would you say there was a change in behaviour during this time period? \n", + "\n", + "How can we start to model this? Well, as we have conveniently already seen, a Poisson random variable is a very appropriate model for this type of *count* data. Denoting day $i$'s text-message count by $C_i$, \n", + "\n", + "$$ C_i \\sim \\text{Poisson}(\\lambda) $$\n", + "\n", + "We are not sure what the value of the $\\lambda$ parameter really is, however. Looking at the chart above, it appears that the rate might become higher late in the observation period, which is equivalent to saying that $\\lambda$ increases at some point during the observations. (Recall that a higher value of $\\lambda$ assigns more probability to larger outcomes. That is, there is a higher probability of many text messages having been sent on a given day.)\n", + "\n", + "How can we represent this observation mathematically? Let's assume that on some day during the observation period (call it $\\tau$), the parameter $\\lambda$ suddenly jumps to a higher value. So we really have two $\\lambda$ parameters: one for the period before $\\tau$, and one for the rest of the observation period. In the literature, a sudden transition like this would be called a *switchpoint*:\n", + "\n", + "$$\n", + "\\lambda = \n", + "\\begin{cases}\n", + "\\lambda_1 & \\text{if } t \\lt \\tau \\cr\n", + "\\lambda_2 & \\text{if } t \\ge \\tau\n", + "\\end{cases}\n", + "$$\n", + "\n", + "\n", + "If, in reality, no sudden change occurred and indeed $\\lambda_1 = \\lambda_2$, then the $\\lambda$s posterior distributions should look about equal.\n", + "\n", + "We are interested in inferring the unknown $\\lambda$s. To use Bayesian inference, we need to assign prior probabilities to the different possible values of $\\lambda$. What would be good prior probability distributions for $\\lambda_1$ and $\\lambda_2$? Recall that $\\lambda$ can be any positive number. As we saw earlier, the *exponential* distribution provides a continuous density function for positive numbers, so it might be a good choice for modeling $\\lambda_i$. But recall that the exponential distribution takes a parameter of its own, so we'll need to include that parameter in our model. Let's call that parameter $\\alpha$.\n", + "\n", + "\\begin{align}\n", + "&\\lambda_1 \\sim \\text{Exp}( \\alpha ) \\\\\\\n", + "&\\lambda_2 \\sim \\text{Exp}( \\alpha )\n", + "\\end{align}\n", + "\n", + "$\\alpha$ is called a *hyper-parameter* or *parent variable*. In literal terms, it is a parameter that influences other parameters. Our initial guess at $\\alpha$ does not influence the model too strongly, so we have some flexibility in our choice. A good rule of thumb is to set the exponential parameter equal to the inverse of the average of the count data. Since we're modeling $\\lambda$ using an exponential distribution, we can use the expected value identity shown earlier to get:\n", + "\n", + "$$\\frac{1}{N}\\sum_{i=0}^N \\;C_i \\approx E[\\; \\lambda \\; |\\; \\alpha ] = \\frac{1}{\\alpha}$$ \n", + "\n", + "An alternative, and something I encourage the reader to try, would be to have two priors: one for each $\\lambda_i$. Creating two exponential distributions with different $\\alpha$ values reflects our prior belief that the rate changed at some point during the observations.\n", + "\n", + "What about $\\tau$? Because of the noisiness of the data, it's difficult to pick out a priori when $\\tau$ might have occurred. Instead, we can assign a *uniform prior belief* to every possible day. This is equivalent to saying\n", + "\n", + "\\begin{align}\n", + "& \\tau \\sim \\text{DiscreteUniform(1,70) }\\\\\\\\\n", + "& \\Rightarrow P( \\tau = k ) = \\frac{1}{70}\n", + "\\end{align}\n", + "\n", + "So after all this, what does our overall prior distribution for the unknown variables look like? Frankly, *it doesn't matter*. What we should understand is that it's an ugly, complicated mess involving symbols only a mathematician could love. And things will only get uglier the more complicated our models become. Regardless, all we really care about is the posterior distribution.\n", + "\n", + "We next turn to [Gen](https://probcomp.github.io/Gen/), a Julia library for performing Bayesian analysis that is undaunted by the mathematical monster we have created. \n", + "\n", + "\n", + "Introducing our first hammer: Gen\n", + "-----\n", + "\n", + "Gen is a rapidly evolving, general-purpose probabilistic programming system developed by the [Probabilistic Computing Lab](http://probcomp.csail.mit.edu/) at MIT.\n", + "\n", + "Since Gen is relatively new, documentation is lacking in certain areas, especially those that bridge the gap between beginner and hacker. One of this book's main goals is to solve that problem, and also to demonstrate why Gen is so cool.\n", + "\n", + "We will model the problem above using Gen. This type of programming is called *probabilistic programming*, an unfortunate misnomer that invokes ideas of randomly-generated code and has likely confused and frightened users away from this field. The code is not random; it is probabilistic in the sense that we create probability models using programming variables as the model's components.\n", + "\n", + "B. Cronin [5] has a very motivating description of probabilistic programming:\n", + "\n", + "> Another way of thinking about this: unlike a traditional program, which only runs in the forward directions, a probabilistic program is run in both the forward and backward direction. It runs forward to compute the consequences of the assumptions it contains about the world (i.e., the model space it represents), but it also runs backward from the data to constrain the possible explanations. In practice, many probabilistic programming systems will cleverly interleave these forward and backward operations to efficiently home in on the best explanations.\n", + "\n", + "Because of the confusion engendered by the term *probabilistic programming*, I'll refrain from using it. Instead, I'll simply say *programming*, since that's what it really is. \n", + "\n", + "Gen code is easy to read. The only novel thing should be the syntax. Simply remember that we are representing the model's components ($\\tau, \\lambda_1, \\lambda_2$ ) as variables." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "gYVjgZQ3hOw-" + }, + "source": [ + "### Specify the model\n", + "We'll assume the data is a consequence of the following generative model:\n", + "\n", + "$$\\begin{align*}\n", + "\\lambda_{1} &\\sim \\text{Exponential}(\\text{rate}=\\alpha) \\\\\n", + "\\lambda_{2} &\\sim \\text{Exponential}(\\text{rate}=\\alpha) \\\\\n", + "\\tau &\\sim \\text{Uniform}(\\text{low}=1,\\text{high}=70) \\\\\n", + "\\text{for } i &= 1\\ldots N: \\\\\n", + "\\lambda_i &= \\begin{cases} \\lambda_{1}, & \\tau > i \\\\ \\lambda_{2}, & \\text{otherwise}\\end{cases}\\\\\n", + " C_i &\\sim \\text{Poisson}(\\text{rate}=\\lambda_i)\n", + "\\end{align*}$$\n", + "\n", + "Happily, this model can be easily implemented using Gen and Gen's distributions:\n", + "\n", + "\n", + "This code creates a new function `λ`, but really we can think of it as a random variable: the random variable $\\lambda$ from above. We assign `λ_1` or `λ_2` as the value of `λ`, depending on what side of `τ` we are on. The values of `λ` up until `τ` are `λ_1` and the values afterwards are `λ_2`.\n", + "\n", + "Note that because `λ_1`, `λ_2` and `τ` are random, `λ` will be random. We are **not** fixing any variables yet.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 698, + "metadata": {}, + "outputs": [], + "source": [ + "@gen function model(ys::Vector{Int64})\n", + " # hyperparameter for the exponential distribution\n", + " α = 1.0 / mean(ys)\n", + " # average text message rate during the 'low' period\n", + " λ_1 = @trace(exponential(α), :λ_1)\n", + " # average text message rate during the 'high' period\n", + " λ_2 = @trace(exponential(α), :λ_2)\n", + " # increase in message counts after this day\n", + " τ = @trace(uniform_discrete(1, length(ys)), :τ)\n", + " # a day's message count is Poisson distributed\n", + " for i in 1:length(ys)\n", + " # According to the data, average number of messages seems to change\n", + " λ = τ > i ? λ_1 : λ_2\n", + " @trace(poisson(λ), \"y-$i\")\n", + " end\n", + "end;" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "t7Vvrj68jsr7" + }, + "source": [ + "Notice that the implementation is arguably very close to being a 1:1 translation of the mathematical model." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "KnyDyY8Tjyiy" + }, + "source": [ + "### Specify the inference algorithm" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "CGreTr4ljwuF" + }, + "source": [ + "The code below will be explained in Chapter 3, but we show it here so you can see where our results come from. One can think of it as a *learning* step. The machinery being employed is called *Markov Chain Monte Carlo* (MCMC), which we also delay explaining until Chapter 3. This technique returns thousands of random variables from the posterior distributions of $\\lambda_1, \\lambda_2$ and $\\tau$. We can plot a histogram of the random variables to see what the posterior distributions look like. Below, we collect the samples (called *traces* in the MCMC literature) into histograms." + ] + }, + { + "cell_type": "code", + "execution_count": 699, + "metadata": {}, + "outputs": [], + "source": [ + "function inference(ys::Vector{Int64}, num_iters::Int)\n", + " # Create a set of constraints fixing the \n", + " # y coordinates to the observed y values\n", + " constraints = choicemap()\n", + " for (i, y) in enumerate(ys)\n", + " constraints[\"y-$i\"] = y\n", + " end\n", + " \n", + " # Run the model, constrained by `constraints`,\n", + " # to get an initial execution trace\n", + " (trace, _) = generate(model, (count_data,), constraints)\n", + " \n", + " traces = Trace[]\n", + " # Iteratively update parameters,\n", + " # using Gen's metropolis_hastings operator.\n", + " for iter=1:num_iters\n", + " (trace, _) = metropolis_hastings(trace, select(:λ_1))\n", + " (trace, _) = metropolis_hastings(trace, select(:λ_2))\n", + " (trace, _) = metropolis_hastings(trace, select(:τ))\n", + " push!(traces, trace) \n", + " end \n", + "\n", + " # Return all of the history of the inference\n", + " return traces\n", + "end;" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "N1mb2NDUkJLU" + }, + "source": [ + "### Sample from the posterior" + ] + }, + { + "cell_type": "code", + "execution_count": 714, + "metadata": {}, + "outputs": [], + "source": [ + "traces = inference(count_data, 100000)\n", + "λ_1s = Float64[]\n", + "λ_2s = Float64[]\n", + "τ_s = Int64[]\n", + "\n", + "for trace in traces\n", + " # Read out parameters and store for rendering\n", + " (λ_1, λ_2, τ) = (trace[:λ_1], trace[:λ_2], trace[:τ])\n", + " push!(λ_1s, λ_1)\n", + " push!(λ_2s, λ_2)\n", + " push!(τ_s, τ)\n", + "end;" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "vIxEqx9qkhWr" + }, + "source": [ + "## Plot the Results" + ] + }, + { + "cell_type": "code", + "execution_count": 716, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "Figure(PyObject
)" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "figure(figsize=(12.5, 10))\n", + "#histogram of the samples:\n", + "\n", + "ax = subplot(311)\n", + "ax.set_autoscaley_on(false)\n", + "hist(λ_1s, histtype=\"stepfilled\", bins=500, alpha=0.85,\n", + " label=\"posterior of \\$λ_{1}\\$\", color=\"#A60628\", normed=true)\n", + "legend(loc=\"upper left\")\n", + "title(\"Posterior distributions of the variables\n", + " \\$λ_{1}\\$, \\$λ_{2}\\$, \\$τ\\$\")\n", + "xlim([15, 30])\n", + "xlabel(\"\\$λ_{1}\\$ value\")\n", + "\n", + "ax = subplot(312)\n", + "ax.set_autoscaley_on(false)\n", + "hist(λ_2s, histtype=\"stepfilled\", bins=100, alpha=0.85,\n", + " label=\"posterior of \\$λ_{2}\\$\", color=\"#7A68A6\", normed=true)\n", + "legend(loc=\"upper left\")\n", + "xlim([15, 30])\n", + "xlabel(\"\\$λ_{2}\\$ value\")\n", + "\n", + "subplot(313)\n", + "w = 1.0 ./ (length(τ_s) .* ones(Float64, length(τ_s)))\n", + "hist(τ_s, bins=n_count_data, alpha=1,\n", + " label=\"posterior of τ\",\n", + " color=\"#467821\", weights=w, rwidth=0.15)\n", + "xticks(1:n_count_data)\n", + "\n", + "legend(loc=\"upper left\")\n", + "ylim([0, 0.75])\n", + "xlim([36, length(count_data)-19])\n", + "xlabel(\"τ (in days)\")\n", + "ylabel(\"probability\");" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Interpretation\n", + "\n", + "Recall that Bayesian methodology returns a *distribution*. Hence we now have distributions to describe the unknown $\\lambda$s and $\\tau$. What have we gained? Immediately, we can see the uncertainty in our estimates: the wider the distribution, the less certain our posterior belief should be. We can also see what the plausible values for the parameters are: $\\lambda_1$ is around 18 and $\\lambda_2$ is around 23. The posterior distributions of the two $\\lambda$s are clearly distinct, indicating that it is indeed likely that there was a change in the user's text-message behaviour.\n", + "\n", + "What other observations can you make? If you look at the original data again, do these results seem reasonable? \n", + "\n", + "Notice also that the posterior distributions for the $\\lambda$s do not look like exponential distributions, even though our priors for these variables were exponential. In fact, the posterior distributions are not really of any form that we recognize from the original model. But that's OK! This is one of the benefits of taking a computational point of view. If we had instead done this analysis using mathematical approaches, we would have been stuck with an analytically intractable (and messy) distribution. Our use of a computational approach makes us indifferent to mathematical tractability.\n", + "\n", + "Our analysis also returned a distribution for $\\tau$. Its posterior distribution looks a little different from the other two because it is a discrete random variable, so it doesn't assign probabilities to intervals. We can see that near day 46, there was a 50% chance that the user's behaviour changed. Had no change occurred, or had the change been gradual over time, the posterior distribution of $\\tau$ would have been more spread out, reflecting that many days were plausible candidates for $\\tau$. By contrast, in the actual results we see that only three or four days make any sense as potential transition points. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Why would I want samples from the posterior, anyways?\n", + "\n", + "\n", + "We will deal with this question for the remainder of the book, and it is an understatement to say that it will lead us to some amazing results. For now, let's end this chapter with one more example.\n", + "\n", + "We'll use the posterior samples to answer the following question: what is the expected number of texts at day $t, \\; 1 \\le t \\le 70$ ? Recall that the expected value of a Poisson variable is equal to its parameter $\\lambda$. Therefore, the question is equivalent to *what is the expected value of $\\lambda$ at time $t$*?\n", + "\n", + "In the code below, let $i$ index samples from the posterior distributions. Given a day $t$, we average over all possible $\\lambda_i$ for that day $t$, using $\\lambda_i = \\lambda_{1,i}$ if $t \\lt \\tau_i$ (that is, if the behaviour change has not yet occurred), else we use $\\lambda_i = \\lambda_{2,i}$. " + ] + }, + { + "cell_type": "code", + "execution_count": 732, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "Figure(PyObject
)" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "figure(figsize=(12.5, 5))\n", + "# τ_s, λ_1s, λ_2s contain\n", + "# N samples from the corresponding posterior distribution\n", + "N = length(τ_s)\n", + "expected_texts_per_day = zeros(n_count_data)\n", + "for day in 1:n_count_data\n", + " # ix is a bool index of all τ samples corresponding to\n", + " # the switchpoint occurring prior to value of 'day'\n", + " ix = day .< τ_s\n", + " # Each posterior sample corresponds to a value for τ.\n", + " # for each day, that value of τ indicates whether we're \"before\"\n", + " # (in the λ_1 \"regime\") or\n", + " # \"after\" (in the λ_2 \"regime\") the switchpoint.\n", + " # by taking the posterior sample of λ1/2 accordingly, we can average\n", + " # over all samples to get an expected value for λ on that day.\n", + " # As explained, the \"message count\" random variable is Poisson distributed,\n", + " # and therefore lambda (the poisson parameter) is the expected value of\n", + " # \"message count\".\n", + " expected_texts_per_day[day] = (sum(λ_1s[ix]) + sum(λ_2s[.!ix])) / N\n", + "end\n", + "\n", + "plot(1:n_count_data, expected_texts_per_day, lw=4, color=\"#E24A33\",\n", + " label=\"expected number of text-messages received\")\n", + "xlim(1, n_count_data)\n", + "xlabel(\"Day\")\n", + "ylabel(\"Expected # text-messages\")\n", + "title(\"Expected number of text-messages received\")\n", + "ylim(0, 60)\n", + "bar(1:n_count_data, count_data, color=\"#348ABD\", alpha=0.65,\n", + " label=\"observed texts per day\")\n", + "legend(loc=\"upper left\");" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "cgCrDy8M3IZT" + }, + "source": [ + "Our analysis shows strong support for believing the user's behavior did change ($\\lambda_{1}$ would have been close in value to $\\lambda_2$ had this not been true), and that the change was sudden rather than gradual (as demonstrated by $\\tau$'s strongly peaked posterior distribution). We can speculate what might have caused this: a cheaper text-message rate, a recent weather-to-text subscription, or perhaps a new relationship. (In fact, the 45th day corresponds to Christmas, and I moved away to Toronto the next month, leaving a girlfriend behind.)\n", + "\n", + "\n", + "## Exercises\n", + " \n", + "1. Using `λ_1s` and `λ_2s`, what is the mean of the posterior distributions of $\\lambda_1$ and $\\lambda_2$?\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": {}, + "colab_type": "code", + "id": "ddpQzca9ACJF" + }, + "outputs": [], + "source": [ + "#type your code here." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "p4krLq5J_356" + }, + "source": [ + "2. What is the expected percentage increase in text-message rates? `hint:` compute the mean of `λ_1s/λ_2s`. Note that this quantity is very different from `mean(λ_1s) / mean(λ_2s)`" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": {}, + "colab_type": "code", + "id": "qWoCGbmEAEvb" + }, + "outputs": [], + "source": [ + "#type your code here." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "vGHVkSlp_9zf" + }, + "source": [ + "3. What is the mean of $\\lambda_1$ **given** that we know $\\tau$ is less than 46? That is, suppose we have been given new information that the change in behaviour occurred prior to day 46. What is the expected value of $\\lambda_1$ now? (You do not need to redo the Gen part. Just consider all instances where `τ_s < 46`.)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": {}, + "colab_type": "code", + "id": "worLRhcVAFeK" + }, + "outputs": [], + "source": [ + "#type your code here." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "nDdph0r1ABCn" + }, + "source": [ + "## References\n", + "\n", + "[1] Gelman, Andrew. N.p.. Web. 22 Jan 2013. [N is never large enough](http://andrewgelman.com/2005/07/31/n_is_never_larg)\n", + " \n", + "[2] Norvig, Peter. 2009. [The Unreasonable Effectiveness of Data](http://static.googleusercontent.com/media/research.google.com/en//pubs/archive/35179.pdf).\n", + "\n", + "[3] Jimmy Lin and Alek Kolcz. Large-Scale Machine Learning at Twitter. Proceedings of the 2012 ACM SIGMOD International Conference on Management of Data (SIGMOD 2012), pages 793-804, May 2012, Scottsdale, Arizona." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Julia 1.0.4", + "language": "julia", + "name": "julia-1.0" + }, + "language_info": { + "file_extension": ".jl", + "mimetype": "application/julia", + "name": "julia", + "version": "1.0.4" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +}