day-3-data-mining/03 - The Bootstrap.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-07-03T12:18:46.976709Z",
     "start_time": "2019-07-03T12:18:46.963000Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<style>\n",
       "    @font-face {\n",
       "        font-family: \"Computer Modern\";\n",
       "        src: url('http://9dbb143991406a7c655e-aa5fcb0a5a4ec34cff238a2d56ca4144.r56.cf5.rackcdn.com/cmunss.otf');\n",
       "    }\n",
       "    @font-face {\n",
       "        font-family: \"Computer Modern\";\n",
       "        font-weight: bold;\n",
       "        src: url('http://9dbb143991406a7c655e-aa5fcb0a5a4ec34cff238a2d56ca4144.r56.cf5.rackcdn.com/cmunsx.otf');\n",
       "    }\n",
       "    @font-face {\n",
       "        font-family: \"Computer Modern\";\n",
       "        font-style: oblique;\n",
       "        src: url('http://9dbb143991406a7c655e-aa5fcb0a5a4ec34cff238a2d56ca4144.r56.cf5.rackcdn.com/cmunsi.otf');\n",
       "    }\n",
       "    @font-face {\n",
       "        font-family: \"Computer Modern\";\n",
       "        font-weight: bold;\n",
       "        font-style: oblique;\n",
       "        src: url('http://9dbb143991406a7c655e-aa5fcb0a5a4ec34cff238a2d56ca4144.r56.cf5.rackcdn.com/cmunso.otf');\n",
       "    }\n",
       "    h1 {\n",
       "        font-family: Helvetica, serif;\n",
       "    }\n",
       "    h4{\n",
       "        margin-top:12px;\n",
       "        margin-bottom: 3px;\n",
       "       }\n",
       "    div.text_cell_render{\n",
       "        font-family: Computer Modern, \"Helvetica Neue\", Arial, Helvetica, Geneva, sans-serif;\n",
       "        line-height: 145%;\n",
       "        font-size: 130%;\n",
       "        margin-left:auto;\n",
       "        margin-right:auto;\n",
       "    }\n",
       "    .CodeMirror{\n",
       "            font-family: \"Source Code Pro\", source-code-pro,Consolas, monospace;\n",
       "    }\n",
       "    .text_cell_render h5 {\n",
       "        font-weight: 300;\n",
       "        font-size: 22pt;\n",
       "        color: #4057A1;\n",
       "        font-style: italic;\n",
       "        margin-bottom: .5em;\n",
       "        margin-top: 0.5em;\n",
       "        display: block;\n",
       "    }\n",
       "    \n",
       "    .warning{\n",
       "        color: rgb( 240, 20, 20 )\n",
       "        }  \n",
       "</style>\n",
       "<script>\n",
       "    MathJax.Hub.Config({\n",
       "                        TeX: {\n",
       "                           extensions: [\"AMSmath.js\"]\n",
       "                           },\n",
       "                tex2jax: {\n",
       "                    inlineMath: [ ['$','$'], [\"\\\\(\",\"\\\\)\"] ],\n",
       "                    displayMath: [ ['$$','$$'], [\"\\\\[\",\"\\\\]\"] ]\n",
       "                },\n",
       "                displayAlign: 'center', // Change this to 'center' to center equations.\n",
       "                \"HTML-CSS\": {\n",
       "                    styles: {'.MathJax_Display': {\"margin\": 4}}\n",
       "                }\n",
       "        });\n",
       "</script>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.core.display import HTML\n",
    "def css_styling():\n",
    "    styles = open(\"../Data/www/styles/custom.css\", \"r\").read()\n",
    "    return HTML(styles)\n",
    "css_styling()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-07-03T12:18:49.320080Z",
     "start_time": "2019-07-03T12:18:47.566603Z"
    }
   },
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "\n",
    "import json\n",
    "import scipy.stats as stat\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import math\n",
    "from scipy.optimize import curve_fit\n",
    "from scipy.special import erf\n",
    "from collections import Counter"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Synopsis\n",
    "\n",
    "In this unit we will discuss how to randomly generate possible data sets from a set of sample data (known as bootstrapping). To do that we will cover:\n",
    "\n",
    "* Why/when you would need to bootstrap data\n",
    "* How to bootstrap data\n",
    "* How to statistically evaluate bootstrapped data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Bootstrap methods\n",
    "\n",
    "When doing science, ideally, one would have many replicates of an experiment.  The replicates would enable us to calculate both an expected outcome and the variability in outcomes.  Those quantities would then enable us, under certain assumptions, to estimate the chance that some observed difference from a null model could be explained by chance or not.\n",
    "\n",
    "But what can we do when we only have one replicate?  This is frequently the case with observational studies, but it can occur in other contexts too.\n",
    "\n",
    "However, there are other areas where Bootstrapping Monte Carlo chains is a useful computational approach.\n",
    "\n",
    "One area, that you might not have though of, is estimating a value.\n",
    "\n",
    "A classic example is trying to calculate what is the value of $pi$. $pi$ isn't an actual numerical number, it's the ratio of a circle's circumference to its diameter.\n",
    "\n",
    "While your calculator now knows what that approximation is a number---how would you calculate it?\n",
    "\n",
    ".\n",
    "\n",
    ".\n",
    "\n",
    ".\n",
    "\n",
    ".\n",
    "\n",
    "Well one way is to numerically approximate it using a bootstrap.\n",
    "\n",
    "The procedure is actually pretty simple. All we would do is randomly select points in the unit-square and then check to see if it's inside the circle or not.\n",
    "\n",
    "Our overall estimate of the value of $pi$ would then just be the number of points successfully within the circle divided by the number of points we randomly picked."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-07-03T12:18:56.220470Z",
     "start_time": "2019-07-03T12:18:56.210653Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.7853981633974483\n",
      "0.5\n"
     ]
    }
   ],
   "source": [
    "# Calculate pi by calculating area of quarter circle\n",
    "\n",
    "def estimate_pi(n_attempts = 10000):\n",
    "    \"\"\" Estimate pi from area of quarter circle \"\"\" \n",
    "    count_successes = 0\n",
    "    for i in range(n_attempts):\n",
    "        x_rand = np.random.random()\n",
    "        y_rand = np.random.random()\n",
    "        dist = math.sqrt( x_rand **2 + y_rand**2 )\n",
    "        if dist <= 1.:\n",
    "            count_successes += 1\n",
    "    return float(count_successes) / n_attempts\n",
    "\n",
    "\n",
    "print( math.pi / 4. )\n",
    "print( estimate_pi(10) )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What you'll see, is that our estimate of $pi$ gets increasingly better the more points that we choose."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-07-03T12:19:05.574788Z",
     "start_time": "2019-07-03T12:19:05.445115Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.7853981633974483\n",
      "0.78521\n"
     ]
    }
   ],
   "source": [
    "print( math.pi / 4. )\n",
    "print( estimate_pi(100000) )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And with enough random points our answer will converge to the exact answer that the computer already returns.\n",
    "\n",
    "This may seem like a pretty simple example (because you were taught what the value of $pi$ is), but this is actually a very real problem --- a lot of the time we don't know what the value of some distribution is and we **don't** know an equation to calculate it so we need to numerically approximate it using a Monte Carlo Bootstrap."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also use this method to easily estimate probabilities --- like what is the probability that the sum of the dots on two die will equal a certain value?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-07-03T12:19:15.508771Z",
     "start_time": "2019-07-03T12:19:12.225094Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.0\n",
      "0.07\n",
      "0.052\n",
      "0.056057\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "def prob_of_outcome_tossing_n_dice(sum_dots, n, n_attempts = 1000):\n",
    "    \"\"\" Probability of the sum of the dots in n dice being sum_dots\"\"\"\n",
    "    count_successes = 0\n",
    "    for a in range(n_attempts):\n",
    "        # Toss dice\n",
    "        sum_temp = 0\n",
    "        for i in range(n):\n",
    "            sum_temp += np.random.randint(6) + 1\n",
    "        if sum_temp == sum_dots:\n",
    "            count_successes += 1\n",
    "    \n",
    "    return float(count_successes) / n_attempts\n",
    "\n",
    "print( prob_of_outcome_tossing_n_dice(3, 2, 10) )\n",
    "print( prob_of_outcome_tossing_n_dice(3, 2, 100) )\n",
    "print( prob_of_outcome_tossing_n_dice(3, 2) )\n",
    "print( prob_of_outcome_tossing_n_dice(3, 2, 1000000) )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Bootstrapping data\n",
    "\n",
    "Back when we first analyzed text, I asked the question of whether the play 'Othello' should have been named 'Iago'. That question came from the fact, that at a rudimentary analysis, Iago seems to be the main speaker from a data analysis perspective. \n",
    "\n",
    "However, in the exercises we switched to a more complex metric, the entropy, evaluate who was the more articulate speaker (with our idea being that the more articulate speaker may be the main character). When we calculated the entropy Iago had a slightly higher measure than Othello's. The problem is we didn't know how to answer if the **difference was significant**.\n",
    "\n",
    "This is a common situation - you use all of your available data points to calculate a single metric that encodes some measure or performance of the data. However, this leaves you with only one number for each category (which is essentially just **one observation**) --- there's no way that you can run a t-test with just one observation (at least I hope you would never try)!\n",
    "\n",
    "What do you do?\n",
    "\n",
    "## The bootstrap -- or creating ensembles of data\n",
    "\n",
    "The answer is to bootstrap your data. What this means seems complicated but it actually is very simple, the procedure is as follows:\n",
    "\n",
    "1. Randomly select individual data points from our source data to create a new synthetic dataset\n",
    "2. Calculate our metric of interest on the synthetic dataset\n",
    "3. Repeat steps 1-2 $10^3$ - $10^6$ times (depending on data/metric)\n",
    "4. Evaluate the distribution of synthetic results to the real value from the data\n",
    "\n",
    "Put simply, we create lots of *possible* datasets from our observed data and see how our value compares to the *possible* data (or how one set of *possible* data compares to another set of *possible* data).\n",
    "\n",
    "There are only two ways to sample data to generate synthetic datasets -- **with or without** replacement. \n",
    "\n",
    "* **with replacement** when we select a data point to put in our synthetic dataset, we leave it in the original dataset so it could be drawn again\n",
    "* **without replacement** when we select a data point to put in our synthetic dataset, we remove it from the original dataset so it cannot be drawn again\n",
    "\n",
    "## What's the difference between these two methods?\n",
    "\n",
    "Well, it's somewhat hard to give a definition that is both concrete/understandable and general --- but as a guideline:\n",
    "\n",
    "If you are interested in calculating the difference between two metrics or an observed value against a probable process, you are most likely interested in sampling **with replacement**. To do this you typically keep the synthetic dataset size **fixed** and **equal to the original number of observations**. If you sampled without replacement then you would generate synthetic datasets that are identical to each other and the original dataset.\n",
    "\n",
    "If you are interested in calculating the relationship between datapoints in time (i.e. one value following another in time), you are more likely intersted in sampling **without replacement**. You're interested not in observing different values, which 'with replacement' would give, but instead if there is a difference in how one data point follows another in time. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# The entropy of Othello and Iago\n",
    "\n",
    "To make this concrete, let's recap the entropy of Othello and Iago's dialogue. \n",
    "\n",
    "First we have to read in the dialogue and calculate the entropy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-07-03T12:19:27.869503Z",
     "start_time": "2019-07-03T12:19:27.864343Z"
    }
   },
   "outputs": [],
   "source": [
    "def extract_othello_play():\n",
    "    '''\n",
    "    Extracts the othello play from the Shakespeare.txt file\n",
    "    '''\n",
    "    complete_works = open('../Data/Day5-Text-Analysis/Shakespeare.txt').read()\n",
    "    #Cut off the beginning plays\n",
    "    othello_full = complete_works.split('OTHELLO, MOOR OF VENICE\\n\\nby William Shakespeare\\n\\n\\n\\n')[1]\n",
    "    #Cut off the plays after\n",
    "    othello_text = othello_full.split('\\n\\n\\nTHE END')[0]\n",
    "    #Clean out the electronic message\n",
    "    emessage = '''<<THIS ELECTRONIC VERSION OF THE COMPLETE WORKS OF WILLIAM\\nSHAKESPEARE IS COPYRIGHT 1990-1993 BY WORLD LIBRARY, INC., AND IS\\nPROVIDED BY PROJECT GUTENBERG ETEXT OF ILLINOIS BENEDICTINE COLLEGE\\nWITH PERMISSION.  ELECTRONIC AND MACHINE READABLE COPIES MAY BE\\nDISTRIBUTED SO LONG AS SUCH COPIES (1) ARE FOR YOUR OR OTHERS\\nPERSONAL USE ONLY, AND (2) ARE NOT DISTRIBUTED OR USED\\nCOMMERCIALLY.  PROHIBITED COMMERCIAL DISTRIBUTION INCLUDES BY ANY\\nSERVICE THAT CHARGES FOR DOWNLOAD TIME OR FOR MEMBERSHIP.>>'''\n",
    "    emessage_split = othello_text.split(emessage)\n",
    "    #Preamble is the first part\n",
    "    othello_preamble = emessage_split[0]\n",
    "    #Text is the other part\n",
    "    othello_clean_text = ''.join(emessage_split[1:])\n",
    "    othello_lines = othello_clean_text.split('\\n')\n",
    "    return othello_lines"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-07-03T12:19:28.791366Z",
     "start_time": "2019-07-03T12:19:28.672119Z"
    }
   },
   "outputs": [],
   "source": [
    "def strip_punctuation(word):\n",
    "    punc = ',.:;\"\\'?![]{}-'\n",
    "    return word.lstrip(punc).strip(punc).lower()\n",
    "\n",
    "def find_character_dialogue(character_name, text):\n",
    "    '''\n",
    "    Finds all dialogue lines for a given character name\n",
    "    input:\n",
    "        character_name: name of character, all caps including period. \n",
    "        text: text to find character name in\n",
    "    output:\n",
    "        dialogue: list of words character uses\n",
    "    '''\n",
    "    dialogue = []\n",
    "\n",
    "    #I create a variable to track if othello was the last character speaking\n",
    "    preceding_character = False\n",
    "    for line in text:\n",
    "        #First check is if we are in a correct character block of dialogue or not\n",
    "        if preceding_character == True:\n",
    "            #Check to make sure that another character isn't speaking\n",
    "            #Continued text starts with four spaces\n",
    "            if '    ' == line[:4]:\n",
    "                dialogue += [w for w in line.split(' ') if w != '' and w != ' ']\n",
    "            else:\n",
    "                #Character isn't speaking, flip the preceding_othello flag\n",
    "                preceding_character = False\n",
    "        else:\n",
    "            #lets check to see if character is speaking\n",
    "            if character_name in line:\n",
    "                #append the line to othellos dialogue\n",
    "                dialogue += [w for w in line.split(character_name)[1].split(' ') if w != '' and w != ' ']\n",
    "                #Switch our preceding check to true\n",
    "                preceding_character = True\n",
    "            else:\n",
    "                #I am explicitly accounting for the character not speaking, but not using this for anything\n",
    "                pass\n",
    "    return dialogue\n",
    "\n",
    "othellos_dialogue = [strip_punctuation(w) for w in find_character_dialogue('OTHELLO.', extract_othello_play())]\n",
    "iagos_dialogue = [strip_punctuation(w) for w in find_character_dialogue('IAGO.', extract_othello_play())]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-07-03T12:19:29.421353Z",
     "start_time": "2019-07-03T12:19:29.409620Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Othello  6.126593244621015\n",
      "Iago  6.139003713381113\n"
     ]
    }
   ],
   "source": [
    "def calc_entropy(words):\n",
    "    '''\n",
    "    input:\n",
    "        words: list of all words uttered\n",
    "    output:\n",
    "        entropy: float\n",
    "    '''\n",
    "    total_words = len(words)\n",
    "    counted_words = Counter(words)  \n",
    "    #Start the calculation\n",
    "    entropy = 0\n",
    "    for word, value in counted_words.items():\n",
    "        entropy += value/total_words * np.log(value/total_words)\n",
    "    return -1 * entropy\n",
    "\n",
    "print('Othello ', calc_entropy(othellos_dialogue))\n",
    "print('Iago ', calc_entropy(iagos_dialogue))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## So now the question is....are these different?\n",
    "\n",
    "Well, to be facetious we can run a t-test on the two values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-07-03T12:21:46.179682Z",
     "start_time": "2019-07-03T12:21:46.162307Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Ttest_indResult(statistic=nan, pvalue=nan)"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import scipy.stats as stats\n",
    "\n",
    "othello_entropy = calc_entropy(othellos_dialogue)\n",
    "iago_entropy = calc_entropy(iagos_dialogue)\n",
    "\n",
    "stats.ttest_ind([othello_entropy], [iago_entropy] )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Yup, doesn't work because we only have one value! So we need to bootstrap, so how can we set this problem up?\n",
    "\n",
    "Well, let's break this down further.\n",
    "\n",
    "We have two individual metrics that summarize a dataset and we want to know if they significantly differ.\n",
    "\n",
    "To bootstrap, we really need to calculate if one observed value is different than a synthetic distribution of data. Anything more and it becomes hard to really interpret the comparisons.\n",
    "\n",
    "So what's the answer to make this doable? \n",
    "\n",
    "Well we can actually bootstrap the **difference** in entropy between Othello's and Iago's dialogue! That's a single metric that we can easily compare.\n",
    "\n",
    "So what do we care about? \n",
    "\n",
    "Well the dialogue size of both Iago and Othello should be fixed to account for that difference. This suggests that we should sample each individual's dialogue with replacement from their original dialogue. Then we record the difference between the two synthetic dialogues.\n",
    "\n",
    "If the the real difference is significantly larger than the synthetically generated dialogues' differences then we would conclude that the entropy of one character is significantly different than random language usage.\n",
    "\n",
    "So how do we do this? Well first we should write a function to generate synthetic dialogue for a single character"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-07-03T12:26:35.716515Z",
     "start_time": "2019-07-03T12:26:35.713248Z"
    }
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import random "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-07-03T12:29:27.092132Z",
     "start_time": "2019-07-03T12:29:27.085091Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3, 4, 3, 5, 3])"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x=[1,2,3,4,5]\n",
    "np.random.choice(x,len(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-07-03T12:28:05.808237Z",
     "start_time": "2019-07-03T12:28:05.797827Z"
    }
   },
   "outputs": [],
   "source": [
    "#Your code here\n",
    "othellos_dialogue_synthetic=np.random.choice(othellos_dialogue,len(othellos_dialogue))\n",
    "iagos_dialogue_synthetic=np.random.choice(iagos_dialogue,len(iagos_dialogue))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-07-03T12:28:24.510297Z",
     "start_time": "2019-07-03T12:28:24.495824Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Othello  5.936396277817935\n",
      "Iago  5.993587100912084\n"
     ]
    }
   ],
   "source": [
    "print('Othello ', calc_entropy(othellos_dialogue_synthetic))\n",
    "print('Iago ', calc_entropy(iagos_dialogue_synthetic))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-07-03T12:29:44.733398Z",
     "start_time": "2019-07-03T12:29:44.720697Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6284\n",
      "['at', 'of', 'will', 'not', 'heaven', 'cassio', 'so', 'voices', 'to', 'and']\n"
     ]
    }
   ],
   "source": [
    "def synthetic_dialogue_generator(dialogue):\n",
    "    import random\n",
    "    new_dialogue = []\n",
    "    for i in range(len(dialogue)):\n",
    "        new_dialogue.append( random.choice(dialogue) )\n",
    "    return new_dialogue\n",
    "\n",
    "synthetic_dialogue = synthetic_dialogue_generator(othellos_dialogue)\n",
    "print( len(synthetic_dialogue) )\n",
    "print(synthetic_dialogue[:10])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we should write a function that generates synthetic dialogues for each character and calculates the difference in entropy. This function should generate 1000 synthetic dialogues"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-07-03T12:32:34.858895Z",
     "start_time": "2019-07-03T12:32:23.112863Z"
    }
   },
   "outputs": [],
   "source": [
    "#Your code here\n",
    "othellos_entropy=[]\n",
    "iagos_entropy=[]\n",
    "for i in range(0,1000):\n",
    "    othellos_dialogue_synthetic=np.random.choice(othellos_dialogue,len(othellos_dialogue))\n",
    "    iagos_dialogue_synthetic=np.random.choice(iagos_dialogue,len(iagos_dialogue))\n",
    "    othellos_entropy.append(calc_entropy(othellos_dialogue_synthetic))\n",
    "    iagos_entropy.append(calc_entropy(iagos_dialogue_synthetic))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-07-03T12:32:34.867374Z",
     "start_time": "2019-07-03T12:32:34.861472Z"
    }
   },
   "outputs": [],
   "source": [
    "import seaborn as sns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-07-03T12:34:46.941772Z",
     "start_time": "2019-07-03T12:34:46.934247Z"
    }
   },
   "outputs": [],
   "source": [
    "def half_frame(sub, xaxis_label, yaxis_label, font_size = 15, padding = -0.02):\n",
    "    \"\"\"Formats frame, axes, and ticks for matplotlib made graphic with half frame.\"\"\"\n",
    "\n",
    "    # Format graph frame and tick marks\n",
    "    sub.yaxis.set_ticks_position('left')\n",
    "    sub.xaxis.set_ticks_position('bottom')\n",
    "    sub.tick_params(axis = 'both', which = 'major', length = 7, width = 2, direction = 'out', pad = 10,\n",
    "                    labelsize = font_size)\n",
    "    sub.tick_params(axis = 'both', which = 'minor', length = 5, width = 2, direction = 'out', labelsize = 10)\n",
    "    for axis in ['bottom','left']:\n",
    "        sub.spines[axis].set_linewidth(2)\n",
    "        sub.spines[axis].set_position((\"axes\", padding))\n",
    "    for axis in ['top','right']:\n",
    "        sub.spines[axis].set_visible(False)\n",
    "\n",
    "    # Format axes\n",
    "    sub.set_xlabel(xaxis_label, fontsize = 1.6 * font_size)\n",
    "    sub.set_ylabel(yaxis_label, fontsize = 1.6 * font_size)\n",
    "    \n",
    "    return"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-07-03T12:35:59.617505Z",
     "start_time": "2019-07-03T12:35:59.381707Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x1a1bd15cf8>"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAaoAAAE0CAYAAAB943fFAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAIABJREFUeJzt3Xd4HdWZ+PHvq967ZNlyt1xwwaYaY4ppCRASyBJKWCCQvptN2002m2wCS7KbZLMhIUt+G5JQQw8ECDV0MMbGBmyMca+SLVuSJavLqvf9/TEjkGW1ke7V3PJ+nmee6zv3zMyr8UjvPWfOnCOqijHGGBOu4vwOwBhjjBmMJSpjjDFhzRKVMcaYsGaJyhhjTFizRGWMMSasWaIyxhgT1ixRGWOMCWuWqIwxxoQ1S1TGGGPCmiUqY4wxYc0SlTHGmLBmicoYY0xYs0Q1ABFREbERe40xxmcJfgcQwSyJGWOMd+J1A081KhG5T0TO8noQY4wxZqTEy3xUIhLAqUmUAXcBd6vq3hDF5queZj9VHSj7W43KGGO881yj8pqo7gEuBdJw/lAr8BJwJ/CEqnZ4DSBcWaIyxpiQCG2iAhCRDOBK4PPAKe5qBeqB+4G7VHWd10DCjSUqY4wJidAnqiM2FpkFfAG4GhjPR3+81wN3AA+oat2ID+AjS1TGGBMSY5uoPtyJSBxwIU4t6xNAIs4f8g7gCZxa1gujPtAYskRljDEh4U+iOmKHIhOBB4Gl7qqeA5QBvwF+Fwn3sixRGWNMSPiXqETkeOB64LNArhtMO/A6zr2sLJw/7luBj4d7b0FLVMYYExKhfY7qqKOJFIjIt0RkPfA28DUgD9gIfAuYoKrn49y/+hJQAcwGfjma4xpjjIkdI+n113M/6no+uh8lQDPwMHC7qq4eYNupwA6gTlULRxz1GLAalTHGhETIn6P6BU4Pv3G9DrYGuB14UFVbhrGPvTg1rXivwY4lS1QmFj2wunxY5a5aPDnEkZgo5jlReR3r7zvu6yHgPpza0wce9/EmTqIzxhhjhuQ1Ub0G/BH4y0h77qnqlSPZzhhjTGzylKhU9exQBWKMMcb0x+vo6a+IyCMeyj8oIi97D8sYY4xxeG36WwZUeih/CmB3XY0xxoxYqGf4jcd6xxljjBmFkCUqEUkGioDGUB3DGGNM9Bu06U9EJgNT+6xOEpHTGbgvvAA5OEMpJQErRxmjMcaYGDbUParrgRv6rMvF6aY+lJ5EdovHmIwxxpgPDZWo6oHej6pPAQLAvkG2CeA0920E7lDVV0cVoTHGmJg2aKJS1d/gTM0BgIgEgIOqOi3UgRljjDHgvXv6TTiDzxpjjDFjwuvIFDeFKhBjjDGmP15rVMaYCNfZHaCmuZ3a5g46uwNkpSaSn55ETlqS36EZ068BE5WI3On+84Cq/nufdV6oqn5hJMEZY4Jj76FWHl9XwcqdNawtq6ejO3BUmZKcVHLTk5g9LoP5E7JJTgzrmXhMDBlwPiq34wTAFlWd22ud4m0+EQ33uaf6Y/NRmWiwpbKR//fqTp55fz8KzB2fxakz8plWkEF+RhJJ8XE0HO6kuqmN9/c18Mb2GhoOd5IUH8exE7M5e05RvzUtm4/KjEJQ56PquR9V0886Y0wY6+oO8LvXdvKbl7eTkhjPl06fzvVLp1GcnTLodve/VUb5oVbeLavjvb31vLe3nqWlBZw1u4ikhFCPuGZM/zxPRR8rrEZlIlV1Yxtfve9d1pbX86mFE/jxxfOGff+p9wy/9a0dvLCpivf21lOUmcxViydTlOkkOqtRmVHwXKOyr0jGRJEDDYe54g9vsaWyid9cuYj//exxI+4kkZOWxOUnTuLzS6fR0t7F/722kw8qGoIcsTFDC3qiEpFUEckO9n6NMYPbe6iVy3+/ipqmdu79wslcvKgkKPstLcrgn86eSXFWCg+uKee9vXVB2a8xw+Wp6U9EJgEXAJWq+mSfzxYAtwMn4FTt1gBfVNWNwQt37FjTn4kkze1dXPzbFRxsaufeLyxm4aScIz7v3aQ3Uh1dAf60ag+7a1q45cpFQUuEJuaEvOnvi8DvcJLRR0d1alAvASe6+xRgMfCyiBR4DcoYM3yqyncfWc/umhZuu+aEo5JUsCQlxHHtkqlMLUjn2w+/x/JtB0NyHGP68lqjehNn1t4Fqrqp1/rvAL8AyoCvAIeB3wLzgZ+p6g+DGfRYsBqViQQPrC5n+baD/G1jJRfML+b0mYUhP2Z7VzcPv72XysY2nvqn05iUlxbyY5qoEvIa1SScP9Db+6z/tLv+e6r6gqq+AXzJDegTXoMyxgzP/vrDvLCpkvkl2ZxWOjaNF8kJ8dx29Ql0B5R/vH8tbZ3dY3JcE7u8JqpCoF5VO3tWiEgKcBLQCTzVs15V17jrZgQhTmNMH90B5fF1FaQlJfDpRSWIeP6iOmJTC9L51eWL2FDRwE+f3TxmxzWxyWui6gay+qw7BefB4XdV9XCfz5qAxBHGZowZxL2r9lBRf5hPHDue1KSxH/zlvLnjuO7Uqdz7Vhnvlh0a8+Ob2OF1UNrdwFwROVVVe6aY/wxOs9/y3gVFJBHIBipGHaUxMWiwnnoNhzu55aVtzCzK4NgS/54G+c7HZ/PCxkq+/9gGnv766TZ6hQkJr1fV33DuO90lIpeJyDdwegICPN6n7EIgniNnCDbGBMFLm6roDigXj3GTX18ZyQn8+OL5bKtq5g/Ld/oWh4luXhPVL4BKYCbwEPBrIAl40r0n1VtPB4vleCQipSLyexFZLyLdIvJaP2X2iIj2WSq9HsuYSFPT3M66vXUsnpZHXrr/U3OcO3ccn1gwnv99ZQcHGvq2/hszep4SlaoexLkndTewBeeh3huBK3qXc5v9LgMagedHENc84EJgm7sM5AFgSa/lwhEcy5iI8sqWauLjhDNnF/kdyoe+f+EcVJX/fXmH36GYKOR54kRVLQc+P0SZTmDWSIMCnlLVvwKIyKPAQP1uD6jqW6M4jjERpaqxjfV76zl9ZiEZyeEz7+nE3DSuOnky960u5ytnTGdqQTowvBExbIBbM5SwvPOpqkfP6maM4eUt1SQlxHHGzPAb8OVrZ5eSGC/8+qXBGkGM8S4sE5UHnxeRDhFpEJFHRWSK3wEZEyqHWjrYWNHAKdPzSQuj2lSPoswUrl86jSfX72fzgUa/wzFRZERXu4gcA1yKM0RSLoM/K6Wqes5IjjOEvwJvAfuAY3Dulb0hIgtUddhzEfQMlWRMuHtrVy0icMr0fL9DGdBXzpjOn1bu4Y/Ld/GrKxb5HY6JEp4TlYj8CvgGTjf14fSLDUkiUNVv9nr7hoisBN4DrgduCcUxjfFLe1c375QdYt6EbLJTw/cZ+py0JC47cRL3ry7j3y6Y43c4Jkp4SlQi8jXgW+7bDTi1mgqgLchxeaaqH4jIVuB4j9v1m2ytpmXCybryeto6AyydEb61qR7XnTqVe1bt4b63yijOTvU7HBMFvNaovoRTQ7pVVb81VGGfWIIxUSWgyqqdtUzMTQ2bkcqH6s03Z1wmt6/YzffOn0NifKTfCjd+83oF9XQ5vyHYgYyWiMwHZgPv+h2LMcG062ALB5vbWTI939dRKLw4tbSA1o5u1u+t9zsUEwW81qhagDZVDWmXHhFJ46OHd0uALBH5jPv+WeAs4GrgaWA/MAf4Ic5wTXeHMjZjxtra8jpSEuOY7+OYfl5NL0hnfHYKq3bVcuLUPL/DMRHOa6JaDZwvIoXuKBWhUgQ80mddz/tpwF63zC1ADlCLMw7hD0KdRI0ZS22d3Wzc38Dxk3MjqglNRDhpah5Prt/P/vrDTMixe1Vm5Lxe+T/DuQf07yGI5UOqukdVZYBlj6q+r6rnqGqhqiaqarGqXqeq+0MZlzFjbUNFA53dyvGTc/0OxbNjJ2YTHyesLa/zOxQT4byO9fcmzmjpXxGR20RkaiiCMsY41pbVUZiZzMTcyKuRpCUlcMz4LN7bW09XwAabMSPntXv6Lvef3Tg9AL8kIodwJkgciKqqzfJrjEc1ze2UHWrl/HnFEdOJoq8TJufyQUUDWyubmDchcu6xmfDi9R7V1H7W5bvLQKy7uDEjsLa8DgEWTcrxO5QRKy3KIDMlgbVldZaozIh5TVRnhSQKY8wRVJX39zUwozCDrDAeiWIo8XHCcZNyWLGjhub2rrAa8d1EDk9Xjaq+HqpAjDEf2bi/kUMtHZw5q9DvUEZt0aRclm+v4QN3QF1jvIqc/q7GxJBnNhwgTmDu+Cy/Qxm1cVnJFGQk88H+YY8VbcwRRpyoRCRBRBaLyGdE5NpgBmVMLFNVnt1wgBmFGaRHQVOZiLCgJIvdB1tobu/yOxwTgUaUqETke0AlsBJ4GLirz+c5IrJRRHaISPjN8GZMGNu4v5Gy2taIGoliKPNLslFgo9WqzAh4TlQicj/wU5x5qHYBR31FUtV64DWcUSQ+PboQjYktz2w4QHycMC8Kmv16FGelkJ+exMYKGzjGeOcpUYnIlcBngQPAElWdCRwaoPgDOPNVXTyqCI2JIarKM+8f4NQZ4TmL70g5zX/Z7KpppsWa/4xHXmtUX8B5LuqbqrpmiLLvAAHg2JEEZkws2nygifJDrVy4YLzfoQTd/JJsAgqb9lutynjjNVEdh5N8nhqqoKq2Aw1A5PevNWaMvLS5ChE495hxfocSdOOzU8hLT2LTAUtUxhuviSoDaFHVjmGWT8YZbskYMwwvbqpi0aQcCjOT/Q4l6ESEOcWZ7DzYTEeXjf1nhs9rojoIZIrIkHd5RWQekAbsG0lgxsSaAw2H2VDRwHlzo6821WNOcRZdAWXnwWa/QzERxGuietN9vXIYZW/AuZ/1qsdjGBOTXtpUBcDHojhRTS1IIzkhji2V1vxnhs9roroVpyffj0XkhP4KiEiuiNwOXIaTqH47uhCNiQ0vbq5mWkE6Mwoz/A4lZBLi4phZlMGWyiZUbbxqMzwjmY/qf3Bm110pIi8DWQAi8ksReRanqe96d5MbVHVjEOM1Jio1tXWyamcN580dF7FTegzXnPFZNLV1sb+hze9QTITw/KCGqn5PRPYDP+HI0dS/jVPbAmgBvq+qVpsyZhhe33aQzm6Nyt5+fc0al4kAWw40UmJT1JthGNEThar6GxG5G7gUOBUYj1M7qwJWAY+o6kAPAhtj+nhlSzU5aYmcMCXyppz3KiM5gUl5aWypbOKcGEjMZvRG/Oi7qjYAd7qLMWaEAgFl+baDnDGzkPi46G726zG7OJMXN1XR1NbpdygmAtg0H8b47IP9DdQ0d3DWnNh5Nn5WUSYAO6qtm7oZmiUqY3z26paDiMAZM2MnUY3PSSEtKd4SlRmWAZv+ROSVIB1DVfWcIO3LmKjz6tZqFk7MIT8j+kajGEicCKVFGWyvbiYQUOJipMnTjMxg96iWDbGt8lEvv/4+w/3cHpYwZgC1ze2s31fPt86Z5XcoY25WUSbv72tgc2Uj8yZEz9xbJvgGS1TXD7A+D2fUiWxgOfA6UIGTlMYDZwJn4AxI+2OgLljBGhNt3thegyoxdX+qR+k458HmN7bXWKIygxowUanqPX3XiUg28DbQDpyhqiv621ZETgX+AnwVODk4oRoTfV7dWk1BRhLzY/APdVZKIsVZKSzfdpCvnjnD73BMGPPaPf0GYAbwqYGSFICqrhSRL+JMB/Ij4LsjD9GY6PLA6nIAAqq8sLGKOcWZPPT2Xp+j8sfMogxW7z5Ea0cXaUnRM1GkCS6vvf4uAQ6r6jPDKPsscBibit6Yfu071Mrhzm5mF2f6HYpvZo7LpKM7wFu7av0OxYQxr4lqAs7EiUNSZ8TJbncbY0wfW6uaEGBmUewmqin5zmjqK7ZbojID85qoaoF0EVk6VEG3TAZgQykZ04+tVU1Mzk8jNSne71B8kxgfx0lT81i5s8bvUEwY85qonsXp3XeXiJQOVEhEZgB34XRNH04zoTExpamtk/31bcweF7u1qR6nluazpbKJg03tfodiwpTXRHUjUIPToWKDiNwvIl8WkYvc5csich+wASjFmRH4xuCGbEzk21bljMgwyxIVp5UWAFitygzIUzcbVT0gImcCjwLH4Mz0299svwJsAi5T1cpRR2lMlNla1URmSgLjs1P8DsV38yZkk5WSwModtVy8qMTvcEwY8jzWn6puBhYC1+J0P68AOtylwl13DbDILWuM6aU7oOyobmL2uMyonyRxOOLjhCUz8lmxo8Zm/TX9Gul8VF3Afe5ijPGg/FArbZ0Ba/br5bTSAp7fWEX5oVam5Kf7HY4JMzZ6ujFjbGtlI/HuoKzGcap7n+rNHdZN3RzNEpUxY2xLZRNTCtJISYzdbul9TS9IpzgrhTetQ4XphyUqY8bQvrpWqpvamWPNfkcQEZaWFrByRw2BgN2nMkeyRGXMGHp160EAZsXwsEkDWVqaT11rJ5srG/0OxYQZS1TGjKFXt1STl55EYQxNkjhcS3uep7L7VKYPG67YmDHS1tnNyp01HDcp17ql99IzmjxAYWYyj7y7l/Tko/80XbV48liGZcKI1aiMGSOrdtbS1hmI6dHShzKjMIPdNS10BYY19rWJEZaojBkjr2ypJjUxnmkF9pzQQEoLM+jsVvYeOux3KCaMeEpUImJfBY0ZAVXl1a3VLC0tIDHevh8OZFpBOgLsPNjsdygmjHj9jTkgIveIyLJQBGNMtNpR3cy+usOcNafQ71DCWmpSPCW5qeystkRlPuI1UaUBVwMvi8gOEfl3EZkYgriMiSqvbKkG4KzZRT5HEv5KCzPYW9dKe2e336GYMOE1UZ0NPIAzxfx04MfAbhF5VkQ+IyKJwQhKREpF5Pcisl5EukXktX7KiIj8QET2ishhEVkuIouCcXxjgu2VLdXMKc5kQk6q36GEvRlFGQQUdte2+B2KCROeEpWqvqaq1wDjga8Ca4B44HzgYWC/iNwiIgtHGdc84EJgm7v059+AHwH/DXwSaAZeEpHiUR7bmKBqONzJO2V1nD3HalPDMTkvjYQ4seY/86ER3dVV1SZV/YOqLgHmAjcDVUA+8HVgrYi8IyL/ICLZIzjEU6o6SVUvAzb2/VBEUnAS1c9U9beq+hJwGc6Mwv80kp/JmFBZsb2G7oBaohqmxPg4puans/Og1aiMY9Tdj1R1i6p+F5gEXAL8FegCjgN+i9MB434vHTBUdaiHKE4FsoA/99qmBWcurAs8/QDGhNgrW6rJSUvkuMm5focSMWYUplPZ2EZze5ffoZgwELR+sqraDTwHPASsc1cLkAJ8FqcDxloROSsIh5sDdAPb+6zf7H5mTFgIBJTXt1VzxsxC4uNsNIrhmuFOgWLd1A0EKVGJyHEi8r/AAeBB4GSgE2fK+quAO4AWYBHwooh8cpSHzAWa3eTYWx2QJiJJHmLX/pZRxmcMAOv21lHT3ME5x1iznxcTclJJSYyz+1QGGEWiEpF8EfmmiLwHvAN8DcgDtgLfASaq6uWq+pCqfgmYCNzlHvOG0YdOf8lEBvnMmDH3/MYqEuOFs+z+lCdxIkwvyLAalQE8DkorInE494CuBy4CEnGSQyvwCHC7qr7Z37aq2igiXwUux+nVNxp1QKaIxPepVeUAraraOdwdqWq/7TFWqzKjpao8v7GSJTMKyEoJypMbMWVGUQabDjRyqKWDvPRhN5KYKOR19PS9QDEf1VzWArcD96tq01Abq2qniNTidLwYjS043eJLcWpwPea4nxkz5nqPAg5Q2dhGWW0riyblHPWZGVppoXOfakd1MydPy/M5GuMnr01/44FG4HfA8ap6oqreNpwk1cu/AJ/3eNy+VrpxXNazQkTScJ6nem6U+zYmKDbtb0CAueOz/A4lIhVkJJGVkmDNf8ZzjepzwCOq2jbSA6rqX4Yq4yadC923JUCWiHzGff+sqraKyM+BH4lIHU4t6p9xEu+tI43NmGDadKCRSXlpZFqz34iICDMKM9ha1URArSU+lnlNVK/jPNRbMZzCIjIBSFBVr+0eRTj3vHrreT8N2AP8HCcxfd+N6R3gPFWt8ngsY4KurrWD/fVtnD/PBkoZjdKiDNbtraeyYcTfjU0U8Jqo9uB0QS8ZZvk3ce5HeTqOqu7ho/tgA5VR4L/cxZiwsml/IwBzJ1iz32jMKLTnqczIuqd7fWrRnnI0MWdDRQPjs1MoyEj2O5SIlpWaSGFGsiWqGBfqGdzScIZTMiZm1Ld2UH6olQUlIxnm0vQ1o8iZnr6jy6anj1UhS1QiUgoUAJWhOoYx4WhDRQOAJaogKS1Mp7NbeW9vvd+hGJ8Meu9IRC4GLu6zOltE7hxsM5wHb09z37868vCMiTwbKhooyUkl35r9gmJaQQYCvLmjxp6nilFDdXJYBFzXZ11qP+sGshNnzihjYsKhlg721R223n5B1DM9/Zs7avj2ebP8Dsf4YKhE9Vqf9zfiTFB48yDbBHAext0IvKaqdo/KxAxr9guNGYUZvLmjhpb2LtKTvXZWNpFu0P9xVX0d59kpAETkRpxRy28KdWDGRKL399UzMTeVXBubLqhKizJ4fdtB1uw+ZAP8xiCvnSmm4UzhYYzpo7KxjQMNbSyalON3KFFncl4ayQlxrNhR43coxgdeH8QtC1UgxkS698rriBM4dqIlqmBLjI/jxKm5vGmJKiaF+jkqY2JCd8DpPj1rXCYZdg8lJJaWFrClsoma5na/QzFjbMBEJSLd7rKxn3VeFutMYaLeyp01NLZ1cdzkXL9DiVpLZxQAsHJnrc+RmLE2WI1Kei39rRvuYrU2E/UeX1tBSmIcc4oz/Q4las0vySYrJYGV1vwXcwZro5jmvnb2s84Y42pp7+K5DypZUJJDYrx9LwuV+DhhyYx83txpiSrWDJio+us4YZ0pjDnaM+8f4HBnN8dPtk4Uoba0tIDnN1ZRXtvK5Pw0v8MxY8S+/hkzSg++XU5pUQaT8+wPZ6gtLXXuUy3fftDnSMxYskRlzChsrWxiXXk9V540CRGb0SbUphekMykvlde2VvsdihlDAzb9ici1wTqIqv4pWPsyJpw8uKacpPg4/u74ifztA5soINREhLNnF/HwO3tp6+wmJTHe75DMGBisM8XdgAbpOJaoTNRp6+zm8XUVfGzeOPJsyKQxc/Yx47hnVRmrdtVy1mwbTikWDJaolhO8RGVM1Hl+YyUNhzv57MmT/Q4lpiyelkdqYjyvbqm2RBUjBuv1t2wM4zAm4tz3VhmT89JYMj3f71BiSkpiPEtLC3h5czU3fUrt3mAMsM4UxozAxv0NvL2njmuXTCEuzv5QjrWz5xRRUX+Y7dXNfodixoAlKmNG4E8ry0hNjOeyEyb5HUpMOtud6uPlzdb7LxZYojLGo7qWDp54r4JLjishOy3R73BiUnF2CnPHZ/HKliq/QzFjYLDu6a+4/yxT1ev7rPNCVfWckQRnTDj68zt7ae8K8LlTp/gdSkz72Lxx/Obl7VQ3tVGUmeJ3OCaEBuv1t8x93dLPOi+s56CJGt0B5d63ylg8LY85xVl+hxPTzp9fzC0vbefFTVX8/WL70hDNBktU17uvDf2sMyYmvbKlmn11h/nBhcf4HUrMmz0uk2kF6fztg0pLVFFusO7p9wxnnTHR7oHV5R/++84Vu8lOTaS2ueOI9WbsiQgfn1fM7W/soqG10+4XRjHrTGHMMFU3trHjYDMnT8sj3rqkh4Xz5xfTFVBe2mydKqKZJSpjhumt3bXExwknTc3zOxTjWjgxm/HZKfxto42zGM1GlKhEJF5ErhKRx0Rkj4i0uMsed92VImKjRZqo0dbZzdryeo4tySYjebBbu2Ys9TT/Ld92kJb2Lr/DMSHiOVGJyGxgHXAvcAkwGUh1l8nuuvuBtW5ZYyLe2vI6OroCLJlhwyWFmwsXjKe9K8CLm6z5L1p5+mooIsU4g9UWAh3Ao8DrQAUgwHjgTOAzwALgNRE5TlWtXm4iVkCVt3bVMik3lYm5NjliuDlxSi4lOak8vs55CNtEH681qptwktQu4FhVvVpV/6iqz6rqM6p6u6peAxwL7ASKgBuDG7IxY2tndTM1zR2cYoPPhqW4OOGS4yawYkcNB5va/Q7HhIDXRHUhzgO816vqtoEKqep24PM4tayLRh6eMf5btauW9OQEFpRk+x2KGcAli0roDihPv7/f71BMCHhNVAVAi6q+MVRBt0yzu40xEam8tpWtlU2cPDWXhHjrJBuuZo7LZH5JFk+sq/A7FBMCXn/z9nvcJt7dxpiIdO9bexCBk6dZs1+4u2RRCev3NbDzoE39EW289rN9EviGiFygqs8NVlBELsDpCfjESIMzxk9tnd38+Z19zB2fRXaqjXrgt6FGAukKKAI8tnYf3/34nLEJyoyJkXSm2A3cKSKnDlRIRE4B7gR2AD8eeXjG+Oep9ftpONzJYutEERGyUhKZXZzJn9/ZR2d3wO9wTBANNs3HtQN89H/Aj4DlIvIG8BpO93SACTjd088EGoFfABcDfwpSvMaMmftXlzOjMJ3pBel+h2KG6eRpefxpVRkvbqriwgXj/Q7HBImo9j8Lh4gEGHiKjt4DnfUtI33Xq2rEjVIhIgqgqgMN6mbTl0SxDyoauOjWFdxw0VxSEiPu8o1ZAVV+99pOphakcf8XT/E7HNM/zwNlDnaPajn2x9jEqPtXl5GSGMelJ0zkmfcP+B2OGaY4Ea5aPJn/eX4ruw42M70ww++QTBAMNs3HsjGMw5iw0djWyRPr9vOphROsE0UEuvzESfz6xW3cv7qcH1001+9wTBDY6JomZg3Ui2zVzhoOd3ZTkJFsc05FoMLMZD4+v5hH3tnLP583i3QbRDji2ROMxvSiqqzefYiSHBvXL5J94bRpNLZ18dDbe/0OxQSBJSpjetlT20p1UzuLp9mcU5Hs+Mm5nDwtjzve2GVd1aPASOejOklE7hCRLSLSKCLdgyw2SYyJGKt315KSGMexE3P8DsWM0j+cOYP9DW08+Z4NjhPpRjIf1b8Bq4DrgVlABk53w4GWkNTaROQ6EdF+lq+G4ngm+jW3d7GxopHjJueSlGCNDZFu2exC5hRn8vvlOwkErANzJPP02ygiZwE/xem2fgNwvPvRQaAUWIozrUdQFBizAAAdQ0lEQVSNu1wMTAtWsAM4G1jSa3ksxMczUerdPYfoVmWxTTUfFUSEr5w5nW1Vzby8pdrvcMwoeP3a+HWcJHWjqv6nqr7nru9W1V2qukpVfwIsBOqAO4BQN/29rapv9VrsijSeqSpvl9UxNT+doqwUv8MxQXLRsROYmp/GzS9stVpVBPOaqBa7r38YbD+qegD4R5wpPn4wstCMGTu7a1o41NLBSVNz/Q7FBFFifBzfPm8WWyqbeMrmqopYXh8w6JmPqqbXui6gv368rwCHgQtGGNtw7RSRfJwZhX+lqr8P8fFMFHqnrI6UxDjmTbDJESNd32ffAqoUZ6Xw46c20Xi4i/g4ZwSfqxZP9iM8MwJea1R1HJ3c6oB0ETniN1ydQQQDQKhGhjyAMzjuNcAngdXAbSLybS87GaBDhrURxJDDHd18UNHAwok51okiCsWJcN7ccdS2dPBuWZ3f4ZgR8PpbuQ9IFpHCXus2ua/LehcUkYVAOtAy4ugGoarPu/fJXlDV51T1WuDPwA9FxP7amGF7b189XQHlROtEEbXmFGcyOS+NlzdX0d7Z7Xc4xiOvf9DfdF9P7LXuSZxu6L90n69KFJHjgXtwOl68Pvowh+1RIA+YOtwNVFX6W0IWoQk77+45xITsFEpyUv0OxYSIiPCJBeNpau/i1a3W3yrSeE1Uj+Mkpc/1Wvc7YDswA3gLaAPeBo7FuUf1H6OO0jtrujPDUlF/mP0NbZxgtamoNykvjRMm5/Lmjlpqmtr9Dsd44DVRLQcW4NwbAkBV23AmSnwE6OCjuUZWAWer6oYgxDlcl+I8v1U2hsc0EeydPYdIiBMW2UgUMeFj88aREC88s8Gmbokknnr9qWoA2NjP+krgChFJxOkZ2KiqIbk31UNE/gKsAd4H4oEr3OUbbpzGDKqjK8D6ffXML8kmNckmR4wFmSmJnDOniGc/qOSVLVWcPWec3yGZYQhqpwNV7VTVA6FOUq6twOeBv+DU5uYC16rqrWNwbBMFNu5voK0zwIlT7NmpWHLKjHwKMpL58VObaO+yjhWRIGJ7x6nqD1R1tqqmqWqqqp6gqvf6HZeJHO+U1ZGfnsS0gnS/QzFjKCEujouOHc+e2lbuXLHH73DMMIx09PR4EblKRB4TkT0i0uIue9x1V4qItaWYsLW7poXdNS2cOCUXEevkGWtmjcvk3GPGcesr26lqbPM7HDOEkYyePhtYB9wLXAJMBlLdZbK77n5grVvWmLDz0NvlxAkcZ81+MetHFx1DV0D56bOb/Q7FDMHr6OnFOD3/5gOdwAPAV4CLcEaH+DJOkurA6R34mruNMWGjoyvAo+/sY05xFlkpiX6HY3wyJT+dr5wxnb++t5+3dtX6HY4ZhNca1U1AIbALOFZVr1bVP6rqs6r6jKrerqrX4DxDtRMowpn2w5iw8cKmSmpbOjjZZvGNef+4rJSSnFRu/OtGmwk4jHlNVBfiPEx7vapuG6iQqm7H6ZEnOLUtY8LGA6vLKclJpbQow+9QjM9Sk+K54ZNz2VrVxJ9W2eOX4cprouoZPf2NoQq6ZZrdbYwJC7trWli5s5bPnjyJOOtEYYCPzR3HmbMKueXFbVRbx4qw5HWaj/2Alyfk4t1tjAkLD60pJz5OuPzESby02cZ8i2W9pwM5YUouK3bU8OV73+XyEycdUc6mA/Gf1xrVk0CqiAw5x5RbJhV4YiSBGRNs7V3dPPLuPs49pshm8TVHKMhI5vTSAt7bW8/umrEYr8B4MZLOFLuBO0Xk1IEKicgpwJ3ADuDHIw/PmOB5YWMVh1o6uGrxFL9DMWFo2ewiclITeWr9frpt2vqwMmDTn4hcO8BH/4czKO1yEXkDeA2ocD+bgDNA7ZlAI/AL4GLgT0GK15gRe3BNORNzUzm91G6bmqMlJcRx4YLxPLCmnDW7a1kyw66TcDHYPaq7GXi6jJ670GcCZwzwWTbwS/fflqiMr3o6UXz347OJi7NOFKZ/8yZkMaMwnZc2V7NwUg5pSV5v45tQGOx/YTk2r5OJEg+uKSchTrjshIl+h2LCmDPB4gRufWU7L2+u5pMLJ/gdkmGQRKWqy8YwDmNCpr2rm0ff3ce5x4yzThRmSMXZKZw0LY/Vu2tZbA+Fh4WIHT3dmOF6ev0BtxOFdTM2w3PuMeNISojj2Q9sgsVwYInKRDVV5Y4Vu5lZlMHpM+3muBmejOQEzp4zjm1Vzby6xZ6389uI7xSKyHTgM8DxOOP/ARwE1gKPququ0YdnzOi8tesQmw408rO/W2DTeRhPTpmex5rdtfzkmU2cNrOAxHj7Xu+XkUzzkSoifwC2AT8DLgfOcpfL3XXbROQ2EUkNZrDGeHXHit3kpSfx6eNK/A7FRJiEOKe7+q6DLTYOoM881ahEJA74K3AOTjf0CpznqPa5RSYCy4AS4EvANBE5X1Wt96AZc3tqWnh5SxX/dFYpKYk2j6fxbva4TE6fWcBvXtrGp48rIS89ye+QYpLXGtX1wLlAO848VJNV9RpV/b67XIMzeeJXceakOtfdxpgxd8eK3STECdecYiNRmJEREW64aC4tHd386sWtfocTs7wmqmtxnq36hjsP1VE1JXX8AfgGTq3rc6MP0xhvqhrbePidvVx6/ETrkm5GZea4TK5ePJkHVpeztbLJ73BiktdEtQBnZt97hlH2HrfsAq9BGTNav399F90B5R+XlfodiokC3zp3Fpkpifzk6U3YnYyx5zVRpQKtqto5VEFV7QBa3G2MGTM1ze08sKaMSxaVMDk/ze9wTBTITU/i2+fOZMWOGpsexgcjmY9qqoiUquqOwQqKyCwgB2e0dWPGzB/f2EV7Z4ApeWlHzDlkzGj8/SlTuG91Of/1zCbOmFVAcoJ10BkrXmtUL+Hcd/q9iAzY8O9+dhvO/awXRx6eMd5UN7Vx76oyFkzMpiAz2e9wTBRJjI/jh584hj21rdyzco/f4cQUr4nqv4E2nC7o74vIV0VkjohkikiBiJwgIt8BtuOMrN6GM9WHMWPi1y9up6MrwLnHeJmI2pjhWTa7iLNmF3LryzuoaW73O5yY4SlRuaNNXA60AqXA/wM2AvVAFbAGJ5mVuGWusBEqzFjZVtXEw2+Xc82SKRRkWG3KhMYPL5rL4c5ubn7BuquPFc8jU6jq08BC4C6cyRGlz9KAM7vvQresMWPip89uJj05gW+cPdPvUEwUm1GYwedOncpDb+9lbXmd3+HEhBENXqWqu1T1C6qai1OzWuIupaqap6pftJqUGUuvbzvIa1sP8vWzS8m10QNMiH37vFmMy0zhB49toLM74Hc4Uc9TohKRT7nLh8NQu0lrtbtYcjJjrqW9i39/fAPTC9K5dslUv8MxMSAjOYGbLp7Hlsom7lhhHZtDzWuN6gngUZxOEsaEhZtf2Ma+usP8/NJjbUw/M2Y+Pq+Y8+aO45aXtlFe2+p3OFHN63NUhwBUtTkEsRjj2bryOu5auZurT5nMyTYbqwmBwZ7FO25SDsu3HeRfHnmPh768hPg4m0omFLzWqDYC2SKSFYpgjPGipb2Lf3lkPcVZKXzv/Dl+h2NiUE5aEp9cOIG399TxxzfszkeoeE1UfwDiga+HIBZjhk1V+cHjG9hT08LNly8kMyXR75BMjDpuUg4XzC/m5he2sml/o9/hRCWvz1HdD9wK3CQiPxERa2sxvrh/dTl/fW8//3zeLE6dYVPMG/+ICP/16QXkpCXx9QfX0tze5XdIUUe8jAQsIq+4/zwRSAe6gR04U9B3D7CZquo5ownSDyKiAKo6UKOzDaHskzW7D3H17atZMiOfu647ibh+7gvYGH9mLF21eDKrdtZy9R2rOfeYIn739yf0e10awHne1hOvnSmW9bP9HHcZiP1BN0GztbKJL97zNhPzUrnlikX2x8CEjSUz8vn+BXP4z2c287vXd/K1s2yKmWDxmqhstl7jm311rVx220oALj1+Is99UOlzRMYc6QunTWNDRQO/fGErk/LS+NTCCX6HFBU8JSpVHc6EicYE3Y7qZq69YzUd3QG+fPoMctNs9AkTfkSE/770WA40tPHPD79HRnI8Z8+xAZJHa0RDKBkzltbvreey21bS0R3gi6dNpzjbppY34SslMZ47Pncix4zP4h/uW8ubO2r8DiniDStRiUiyiFwhIr8QkdtE5Oci8mkR8dp0aMywqSp/fmcvV/xhFenJCTz61VOZkGMTRpvwl5mSyD2fP5mp+elcd9canlhX4XdIEW3IXn8icirwCFDcz8d7gEtUdUPwQ/OX9frzV1NbJzc+uZHH1lawZHo+v/nsIooyU6w3n4kohzu6uW91GbtrWjj3mHH84RrrDcgIev0NmqhEpATYAGS7Ow8ANUBhr4NVAPNVtcHrwcOZJSp/BALKY+sq+PlzW6htaeeb58zk62fP/HBoGktUJtJ0dQd4bF0F7+2tZ2lpPjdftijWm689J6qhmv6+CeTgTIx4LZCmqsU4z1B9AzgMTAC+4PXAxvTW0RXgsbX7uOjWFXznkfVMykvlr19byrfOnWXjp5mIlhAfx2UnTOTTx5Wwtqye83+znPtXl9Fl04MM21A1qnXAscC17qgUfT//Ds5U8y+o6vkhi9IHVqMKvca2Tt7Zc4iXNlfzwsYqaprbKS3K4B/OnMGnjyuxB3lN1Dlleh7f+8v7vL2njtnjMvnX82dz1uyiWGsODHrTXwNO7SlDVY+a2kNEpgC7gR2qOsvrwcOZJarBPbC6nIAqTW1d1Ld20NbZTWe30tkdoKM7QFe30h1QFkzMpjugdAWU9q5uDjV3cLC5nR3VzeyrOwxAelI8Z8wq5IqTJnHGzMJBf2ktUZlIdtXiyagqz31Qyc+e28zeQ4eZWZTBF06bxkULJ5CRHBP904KeqAJAlaqOH6LMAVUt8XrwcGaJ6khd3QE2HWhkze5DvL+vgdW7a6lp6qDbwxBcSfFx5KUnkZ+RxNSCdOaOz2JBSTaLp+fxl3etV5SJflctnvzhvzu6AjyzYT9/WL6bzQcaSU2M5/z5xVwwv5ilpQWkR2/SCkmiqlTVAR+vHk6ZUBGRuTiD5C7BuY92O3CTqg407qCXfcd0ouroCrChop63dh1ize5DvFtW9+FgmyU5qWSmJFCUmUJueiI5qYmkJiWQGC8kxceR6C7xccJnF08iIS6OOHEehhyI1ZRMLOidqHqoKu+W1fHYugqeXr+fxrYuEuOFk6flcdbsIpbNLmRGYcagvz8RJnYSlYjk4syPtQn4b2AGcDPwa1X9YRD2H1OJqr61g7XldfxpVRnlta3srWuls9v5EYsyk5lWkM7UgnSm5aeTlWpTahgTCl2BAOW1rWytamJrZRPVTe2A0zw+OT+dKXlpTMlPoyQnlYT4uH4TXwQISaLqAFYOso9lQ5QJyejpIvJ94F+BKara6K77V+A/gOKedaPYf1Qmqs7uAGW1Leyobv5w2VDRwM6DLQDECYzPTmVyfhrT8p3kFCPt5saEnbrWDnZUNVN2qIWy2lZqWzoAiBdhXFYyp80sYN6EbOaXZDG7OCtSfldDkqhGS1U1Pgj7OYKILAf2q+qVvdZNBsqAT6nqU6Pcf8QkqkDA6dTQ2NZJw+FOals6qGps42BTO1WNbVQ3tlPV1Mbugy00tnUS6BV5dmoixVkpTMlPY3JeGhNz00hKsJG1jAlHTW2dlB9qZe+hwxxoOExtSweH3OQFMC7Laf2YXpjB9IJ0JuamMi4rhXFZKRRmJpMYHxa/20Gf5iOcB6GdA7zSe4WqlotIq/vZsBJVT0IaKyu217CrppnugBJQJ8kEVOlWRd333aoEAkp7d4D2zgCHO7pp6+qmrbObts4AbZ3dNLe7iam1k6b2Lgb6vpGdmkhRZjLjslKYVuA02xVlJlPoLskJQf8OYYwJkcyUROZNyGbehGwAPnvyJCob29hY0ci26iZ2HWxh18FmnttwgLrWziO2FYH89CSyUxPJTEkkMyWBrJREMpITSEpw7y0nfHSfOcG95ywizj1mIC5OEODj84opyhq7h5Y9TZwYTkSkE/iuqt7SZ/0+4E+q+oNh7mfQEzBIjcoYY8wYiIgGzUH0l2RkgPX978ASkTHGhLWwaLAcoTqc4Z36ysbpqm6MMSYKRHKi2oJzL+pDIjIJZySNLb5EZIwxJugiuenvOeC7IpKpqk3uuitwBsp9PZQHHusOGMYYE0283nKJ5M4UuTgP+36A88DvdOBXwC3BeOB3iGNH5kkzxpgwEDOJCj4cQum3HDmE0n8EYwilWDGM58XMMNh5DA47j8ERbecxohOVGb1ou6D9YucxOOw8Bke0ncdI7kxhjDEmBliiMsYYE9YsURljjAlrlqiMMcaENetMYYwxJqxZjcoYY0xYs0RljDEmrFmiMsYYE9YsURljjAlrlqiMMcaENUtUxhhjwpolKmOMMWHNEpUxxpiwZonKGGNMWLNEFSVE5DoR0X6Wrw6x3TwReUFEWkWkRkR+JyIZ/ZS7WEQ2iEibiGwSkStC99P4J5TnUUTuHmDfc0L7U409EUkQkX8Tke0i0i4i+0Tk18PYLltE7hKROhFpEJH7RSS/n3Kxcj2G7DxG0vUYyVPRm/6dDRzu9X7XQAVFJBt4BdgGXAHkA78AxgOX9Cp3GvAX4P+AbwAXAg+KSJ2qvhDsHyBMBP08urYA1/dZt2eUsYaju4BzgJtwfuZJwNxhbPcwMBv4IhDAmb37CeD0ngIxdj2G7Dy6IuN6VFVbomABrgMUyPCwzfeBRiCn17pPufs5sde654FX+mz7LLDC7587ws7j3cA7fv+MY3AOzwc6gbket1vinrMzeq072V13bq91MXE9jsF5jJjr0Zr+YtsinAu1vte6F3Au6E8AiEgycBbw5z7bPgQscWsTsW7I8xhjPo+TSDZ53O4CoEpVl/esUNU1wG73s1i7HkN2HiONJaros1NEukRkq4h8ZYiyKUBHn3VdOE0Fx7jvZwCJOE0EvW3GuX5mjTLecBXs89hjrog0uvcbVojImcEKOIwsBraJyG/dn7VVRB4TkQlDbDeHo68zcK61nvsmsXQ9hvI89oiI69ESVfQ4APwIuAb4JLAauE1Evj3INjuAhSKS2GvdCUA8kOe+z3Vfe9cWAOr6fB4tQnUeAdYB/+Lu9+/dz18UkZODF35YKMZpQl0EXIlzD+QE4HERkUG2y+Xo6wycay23Vxn6KReN12MozyNE0vXod9ujLaFbcG6o1gJxA3w+B+eb/204vxTzgHfddc+5ZZbiNGEt7LPtTHf9eX7/nJFwHgfYLhWnOeYJv3/GIJ+vDqAZyO+17gz3ejlnkO1eBB7vZ/39wJvuv2PmegzleRxgu7C9Hq1GFd0exflGP7W/D1V1C/Bl4LM4NYn3gTXAe0CVW6znm2pOn8173vf3zS3aBOM89rfdYZxOAMcHN1zf1QEbVLW217oVOH94B+uxVsfR1xnuuvpeZeinXDRej6E8j0cJ5+vRElVsGHAaZ1W9ExgHHAtMAP4JKAXecovsxOl51Ldtew7OPZhtwQ42jI3mPI5ovxFq8wDrBeeaGcgWjr7O4Mh7LrF0PYbyPA4m7K5HS1TR7VKgBigbrJCqtqnqBlWtAq7GuS7+7H7WDrwKXNZnsyuAVaraEPSow8+oz2N/RCQVpxfWu0GMNRw8DRwrIgW91p2B0wli/SDbPQcUu89JASAiJwLT3c9i7XoM2XnsT1hfj363PdoSnAXnAcjv4VxoFwH34nwz+nqvMjuAO3q9z8J5EPATwMeBn+N8W72uz75Pw7nfcguwDOdh1gDwMb9/7kg5j0A28AbwFZwHOK/AqW210+tZq2hY3PNRDqzCuVF/FbAXeLFPuSPOo7vubzgPV/8dzsPSW4E3YvF6DOV5jLTr0fcAbAnSfyT81L0YW3FGVHgXuKZPmT3A3b3ep+M873PI3eZt4JIB9n8J8IF7IW8BrvT7Z46k84jThf0x9w9NO9Dg/jE5xe+fOUTnsRTnfkcLzj2Tu4Hcwc6juy4HZzSGepyHqB8ACmL4egzJeYy061HcoI0xxpiwZPeojDHGhDVLVMYYY8KaJSpjjDFhzRKVMcaYsGaJyhhjTFizRGWMMSasWaIyxhgT1ixRGTMEEblbRHSYy7eCdMxlIvIfItJ3KntjYk6C3wEYE0E6cUafGExLkI61DLgRuAd4Ikj7NCYiWaIyZvhWquoyv4MwJtZY058xxpiwZonKmBARkdfc+1bXiUiqe89pq4gcFpFqEXlIRGb22WaqiChOsx/A5/q5Dza1d1m3PCJyiog8KiIHRKRbRG7ps+8sN4b1ItLsLu+LyE0ikj3Az/Af7jHuFpE4Efm2u32LiNSKyJP9TV0uIje4270zxDm63i23V0Ts75Hpl10YxoReFvAmTvKZgjNtSCHu1AoiMqNX2W6cWYF77nW1ue97L919DyAil+NM23ApzpTi3X0+L8WZefhGnMkdxV0WADcA7/dNmn0PATwC/ApndtlOnFmPPwmsFJEr+pS/E2fqjRNEZMEg+/28+3qPqg42GaCJYZaojAm9m4Bc4HycKUEycCbA24fzx/5nPQVVda+qFgO/dFc9rKrFfZa9/RzjDuCvwDRVzQHScOZrQkSScObZmoIzrcPH3BgygHNx5jyaDDwuIskD/AwXu8s/A1nuMUqBF4F44K7eCVdV9wHPu2+v72+HbvI8DSdx3zXAcY2xRGWMB6eKSOUQS1Y/2yUD56nq86raraoBVX0D6OnK/ik3mYzGeuByVd0DoKpdPf/GqbkdizPZ4IWq+qJ+5GXgQpwa0jzg7wfYfzZwo6r+WlUPu8fYCXwKZ/6uVOD7fbb5o/t6tYgk9rPPntrUcndfxvTLEpUxw5cIjBti6e936lFV3dHP+idxahPJOLWT0bh5kKazz7ivT6jqB30/VNWNwKPu28sH2Ecrbg2tz7ZtwM3u20tFRHp9/BROU2UhzmzJH3LvR13rvr1zgGMaA1iiMsaL11VVhljq+9nu7f52pqqdQLX7NneUsa0a5LPj3ddXBynzSp+yfb2jqgM9I/a6+5oDTOtZqapdOM+BwdHNfx8HSnBmn30UYwZhicqY0Gsa5LM297W/pjEvDg7yWaH7WjFImX3ua36fWlGPwbbt/Vlhn89ud18vEJFxvdb3NPs9pKqtg+zbGEtUxkQDVT2qJ2A/BuooMVr9JTYAVHU7To0rAbgGQETycO5tgTX7mWGwRGVM9OupbU0ZpMxE97VWVbWfzycMsu34fo7VW0+tqqf572ogCdikqqsH2a8xgCUqY8JVT8eIAWsrHqx1X88apMzZfcr2dZKIpA3w2Znuaz2wu5/PH3U/mysii/koYVltygyLJSpjwlOj+5oThH31dFa4QESO6/uhiMzjo56Bfx5gH2nAN/vZNhnn2SpwejceVRtzewbe5769GViE0x3+3uH+ACa2WaIyJjxtdF9PG2LEiOF4GGdUCoAnROTcng4TInIO8CxOZ46NwP0D7KMB+ImIfFNEUt1tp+M8ZHwMTqeQnw8SQ88zVUvd16dVtXqgwsb0ZqOnGzN8p4pI5RBlHlbVo2oeI/AasBOYAWwVkRqcZ5kATnNHfhgWVe0QkUuBl3DuU70ItLq5qqc5rxz4O1VtH2A3fwUycZ6l+h8RaeGj2l43cP1gD+2q6vvuuH8nuqus2c8Mm9WojBm+4Tzw2+/grl65z1idg9M8VoHznNUUd/H8BdN94Hgh8GOg90O/HwA/AY5V1W2D7QK4DKeZbzNOZ4g64GngVFV9aBhhPOa+HgCe8/QDmJgm/XfwMcYYZ/R03AkcVfW6Ue7rRZyxBf9bVf9t9NGZWGE1KmNMyLkD0J6DUzO7fYjixhzBEpUxJqREJAO4Faer/dMDjHtozIAsURljQkJEviUie4AanClO2gBr8jOeWaIyxoRKDk7nj25gJfAxVd3kb0gmEllnCmOMMWHNalTGGGPCmiUqY4wxYc0SlTHGmLBmicoYY0xYs0RljDEmrFmiMsYYE9b+P04Wr5E7FgIbAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x648 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.figure( figsize = (6,9) )\n",
    "ax = fig.add_subplot(2,1,1)\n",
    "my_font_size = 15\n",
    "half_frame(ax, \"Entropy\", \"Probability density\", font_size = my_font_size)\n",
    "sns.distplot(othellos_entropy,ax=ax)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-07-03T12:33:19.505180Z",
     "start_time": "2019-07-03T12:32:58.424224Z"
    }
   },
   "outputs": [],
   "source": [
    "def generate_synthetic_entropies_difference(dialogue1, dialogue2, n=1000):\n",
    "    synthetic_entropies = []\n",
    "    for i in range(n):\n",
    "        ent1 = calc_entropy( synthetic_dialogue_generator(dialogue1) )\n",
    "        ent2 = calc_entropy( synthetic_dialogue_generator(dialogue2) )\n",
    "        synthetic_entropies.append(ent1 - ent2)\n",
    "    return synthetic_entropies\n",
    "\n",
    " = generate_synthetic_entropies_difference(othellos_dialogue, iagos_dialogue)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-07-03T12:38:02.571201Z",
     "start_time": "2019-07-03T12:38:02.319469Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x1a1bd40940>"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAbkAAAE0CAYAAACxek0uAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAIABJREFUeJzs3Xd4HOW1+PHvUZcsq7lKlm0ZF4x7w8ZgwAQCGAiEkmBIQiCQnstNbtov94aEkNy0m5DeKYaETgihmG6wabaxMe7GXS6Si2wVq5c9vz9mhNfr3ZV2tastOp/nmUfSzDuzZ9TOvu+8RVQVY4wxJhmlxDoAY4wxJlosyRljjElaluSMMcYkLUtyxhhjkpYlOWOMMUnLkpwxxpikZUnOGGNM0rIkZ4wxJmlZkjPGGJO0LMkZY4xJWpbkjDHGJC1LcsYYY5KWJbkoEBEVEZv52hhjYiwt1gH0QZb8jDEmdBLOSSHV5ETkHyJyXjgvZIwxxvQ2CWU9ORHx4NREyoF7gUWqujdKsSWszqZKVfX3zsNqcsYYE7qwanKhJrn7gKuBHJx/1gq8DNwDPKmqreEEkWwsyRljTMRFP8kBiEgusBD4DHCGu1uBGuAB4F5VXRNOMMnCkpwxxkRc7yS5E04WGQfcDHwSKOb4P/C1wN3Ag6paHfYLJChLcsYYE3G9n+Q+uIhICnAJTu3uUiAd5595K/AkTu3uxR6/UIKwJGeMMREXuyR3wgVFSoGHgLPcXZ0vUA78BvhTsj+7syRnjDERF9skJyIzgJuA64BCN6AWYCnOs7s8nH/w7wMXJXOvTEtyxhgTcdEfJ3fSK4oMFJGvisha4B3gy0ARsBH4KlCiqhfjPK/7LLAfOBX4RU9e1xhjjOmOcHpXdj5/u4njz98EqAceAe5S1RUBzi0DtgPVqjoo7KjjnNXkjDEm4nplnNzPcXpSDvF6wZXAXcBDqtrQjWvsxanhpYYebmKwJGcS1YMr9nSr3PVzRkQ5EmNOElaSC3Xuym+4H48C/8CptW0I8Rpv4iRJY4wxJqpCTXKvAX8D/hluD0lVXRjOecYYY0yoQkpyqvqhaAVijDHGRFqoqxAsEZHHQij/kIi8EnpYxhhjTM+F2lw5HzgQQvkzAHtCbYwxJiaivTJ4Ktab0BhjTIxELcmJSCYwGKiL1msYY4wxwQRtrhSREUCZz+4METmbwGMWBCjAmd4rA3irhzEaY4wxYenqmdxNwPd89hXiDCXoSmcS/HWIMRljjDER0VWSqwG8p0AYCXiAfUHO8eA0UW4E7lbVV3sUoTHGGBOmoElOVX+DszwOACLiAQ6r6qhoB2aMMcb0VKhDCH6AMxGzMcYYE/dCnfHkB9EKxBhjjIm0aI+TM8YYY2ImYE1ORO5xP61U1f/x2RcKVdWbwwnOGNO7VJWWdg8t7R5SU4TczFCfaBgTXwKuJ+d2MgHYoqoTvPYpoa3ro8m8dpw/tp6cSTRtHR4eW7WPnz2/hdqmNsD5Ix87JJfZZQMYX9yfFDn+62zryZkYiPh6cp3P36r87IsqERkDfBNn7stJwOuqOt/reDHwX8CFwGigGlgCfEdVK7q49u3A9/0cWqCqz0cifmMSycaKWr78wLvsPtLIiKIczhw9gKy0VGqaWlldXs0/VpQzfmh/Pj5rOFnpfer9qkkCAZOcv04mvdjxZCJwCbAcZ9YUXzOBK3FWJF+Bswjr7cBbIjJJVbvqAVoLXOyzb3NPAjYmEa3ZU82n71lJbmYa99w4i8qaZsSrxvah8UNYsesIi9dX8uelO7hhbhlF/fz9SRoTnwI2V8aSiKSoqsf9/HFgoE9NrgCoV9V2r33jgPeBG1X1viDXvh34iqoOjFL41lxpEsI7u49y4z0rGdg/kwdumUNpYQ4Prtjjt+z2Q/U8tHIP6anCl+aP4QvzR/dytMaE11wZ8d6VIpItIvk9uUZnggtyvMY7wbn7tgKNOJNCG2OCOFjXzOf/vpoh+Vk8+vm5lBbmBC0/ZnAut5w9iuZ2D39fXk5Ta0cvRWpMz4S6aOpwEfmciFzu59hkEVkBHAOOisjbIjIxUoF2I7YpQA6wqRvFC0SkSkTaRGSNiFwV5muqvy2caxnTWzo8ylcffo+m1g7++qlZDMnL6tZ5xfnZLJw1nIqaJr72yHt4PParbuJfqP2DbwG+C/wIeKpzp1tzexkYyPEq5RzgFfcZWZXvhSJJRFJwph/bBrzYRfHtwLeA94Bc4PPAP0XkalV9IppxGhMPfr9kO2/vPMIvPjaVMYNzQzp3fHEeCyYXs3h9JV95aA3zxgRv9bdemCbWQm2uvMD9+IjP/s8Cg3Amc74YOBdY7+77ak8C7KafAHOBT6lqW7CCqvoPVb1TVZeo6lPAZTgdXHxXW+iSqoq/Law7MKYXbKyo5TevbOWq6cO4ZmZpWNc4a/QAThvanxc3HuBAXXOEIzQmskJNcsNxOk5s89l/pbv/26r6oqq+jpP4BLi0x1EGISJfwhlu8GlVXRHq+er0vHkCmCIi1j/aJC1V5fv/3khhTgbfvzz8JwkiwpUzSslMT+WxVXtp7wj6CN2YmAo1yQ0CarxrSyKSBZwOtAFPd+5X1ZXuvqh1wxKRq4HfAd9SVd/aZajsAYNJak++t59V5dV8++Lx5Gen9+hauZlpXD19GJW1zbyy5VCEIjQm8kJNch1Ans++M3Ce7a1W1SafY8eAnv01BSAi84EHgN+r6i96cB3BqYmuVVXrMmaS0rHmNn68eAtThxeE3Uzpa3xxHjNHFPL6tsNU1vr+6RsTH0JNcruAVBE502vfNTi1oGXeBUUkHcgHDoYalIjkiMg1InINMAwY1Pm1e+w04ElgC/CIiJzhtY32us65ItIuIud67VsqIreKyIUiciXwLE6ivj3UOI1JFH9euoPDx1r4weUTSUmJ3GPjBZOGkpWeypNr9uOJwzG3xoTau/J5nNlI7hWR7wLFOD0uAf7lU3YqkMqJK4t312DgMZ99nV+Pwum5me++xps+5e4DbnQ/FzcG77/q7TidYYpxVjF/F7hUVZ8LI05j4t7Rhlb+tmwXk4fls6mijk0VdRG7dk5mGpdOLuax1ftYsesoc08ZELFrGxMJoSa5nwOfAMYCD7v7BPi3+wzOW2dnlGWESFV3E3x0+yJ36+o6r/lex1ZEMH3NX5btoK3Dw/njozNPwrThBazZW8OLGw8woTivx8/7jImkkJorVfUwTtPeIpymwpU4kx1f613Obar8GFAHvBCJQI0xoTt8rIX73ypn6vACBndz0HeoRIQrppbQ4VGeWRd0fnRjel3Ii0Wp6h7gM12UaQPGhRuUMSYy/rJ0B60dHj4UpVpcpwG5mZw/fjAvbDrIpoo6JpT49k8zJjZsZXBjklR1Qyv/WFHOFdNKGJibGfXXmzd2EEPzsnh6XQUtbdZR2cQHS3LGJKm/Ly+nuc3DF87tnRUDUlOEj04fRl1TGy9uDrlTtTFREdba9m4X/qtxFjQtJPhYOFXV88N5HWNMeJrbOrjvrd2cd+ogxg3pz6rd1b3yuiOKcpg9qojlO44wfXhBr7ymMcGEnORE5E7gVpxei90ZcGODZ4zpZU+8u58jDa187pzeX/ftoolD2VxZx7/W7Oe/PjyOtFRrMDKxE1KSE5Evc3zC5fXAv4H9gM3Sakyc8HiUu17fyZTSfM44pajXXz8rPZXLppTw4Mo93PPmrpgkWmM6hVqT+yxOzex3qtobqwsYY0K0ZMshdlY18LvrpuPMWtf7JpbkcdrQ/tz50lYWTCpmeFHwRVmNiZZQ2xE6hwWEvCyNMaZ33Pf2borzs1gwaWjMYhARPjK1hFQRvvvkBtSm/DIxIqH88onIYSBVVXu/DSSBdK4OHmBtOftrNxHx4IqTZ8w7fKyFX728lQ9PGMJ5p0Z3bFx3NLd1cMczm/jtddO5fGpJrMMxiS2sZolQa3IrgDwRGRTOixljomv5riOkijBrZGGsQwHg02eWMaU0nzue3khtY9D1jI2JilCT3E9waiL/E4VYjDE90NLewbvl1Uwuzad/VnzMH5maIvzkqslUN7bx0+c3xzoc0weFOnflmzirDnxeRP4sImXRCMoYE7r39tbQ0u7hjDhbCWBiST43zxvFQyv3snLX0ViHY/qYkJKciOzEmZC5A6en5Q4ROSwiO4NsO6IRuDHmOFVl5a6jlORnMbwwO9bhnOSrF4xlWEE233liHS3tNuWX6T2hNleWuVsOxweDD/DaH2gzxkRRRU0zlbXNzCoritmwgWByMtL40ZWT2HG4gT+/tjPW4Zg+JNRxcudFJQpjTI+sKj9KWoowtTR+p9I679TBXDalmD+8tp0rppVQNrBfrEMyfUBISU5Vl0YrEGNMeNo6PKzdV8OkYflkZ6TGOpygbrtsAkvfP8xt/97A/Z+ZHZe1TpNcbFI5YxLchv21NLd54mbYQDBD8rL4+oXjeH1bFc+sq4x1OKYPCDvJiUiaiMwRkWtE5IZIBmWM6b5V5dUU9ctgVII0/31qbhmTh+Xzw2c2Ud/SHutwTJILK8mJyLeBA8BbwCPAvT7HC0Rko4hsF5GBPQ/TGOPPkfoWdlU1MGtkYcI0/aWmCHdcMZFDx1r4y1LrfG2iK5yldh4AFrpf7gRG+F5HVWtE5DXgC8CVwN96FqYxxp9V5dUIMH1EfDZV+pt6rNOU0nz+9NoOstNT+dJ5Y3oxKtOXhDpObiFwHVAJzFXVsUCg0Z0P4gwxuKJHERpj/OrwKO/uqWbckP7kZ8fHDCehuHiiM4H0i5tsFXETPaE2V96MM63Xf6rqyi7KrgI8wJRwAjPGBLft4DGONbczqyw+a3FdKcjJYN6Ygby3t4a1e2tiHY5JUqEmuek4ievprgqqagtQC9hkzsZEwaryavplpjF+aF6sQwnbueMGkZORyp0vbY11KCZJhZrkcoEGVW3tZvlMnCnAQiIiY0TkLyKyVkQ63Od7vmVERP5bRPaKSJOILBORad28/hUisl5EmkVkk4hcG2qMxsTS4WMtbDlQx4wRBaSmJEaHE38y01M5Z+wglm49zLt7qmMdjklCoSa5w0B/EenyraOITMSZ/mtfGHFNBC4BtrqbP/8PuA34GfARoB54WUSCrhQpIvOAfwKvAguAZ4GHROTCMOI0Jib+tWYfHoWZCTA2ritzTimiqF8Gv355W6xDMUko1CT3pvtxYdBSju/hPL97NcTXAHhaVYer6seAjb4HRSQLJ8n9RFV/r6ovAx9zX+8rXVz7NmCZqt6qqq+q6jeB57HVzk0C+deaCkoLsxncPyvWofRYZloqnz/nFJZtPczqcqvNmcgKNcn9DqfH5B0iMtNfAREpFJG7OJ50fh9qUKrq6aLImUAe8KjXOQ04zwoXBDpJRDJx5t981OfQw8BcEckPNVZjetvWg8fYXFnHtOHxO09lqD41dyRF/TL47StWmzORFerclW+KyP8B3wTeEpE3cJINIvILYAJwLtD59vJ7qnpSTSwCxuM86/P9i9gMBHu+NhpIB7b4OS8FGAe8E6EYjQlLsLFlAC9sPECKwORhyfOe7Mk1FcwcWchLmw7yq5e2MiTPfw31+jkjejkyk+hCnvFEVb8NfA1owakVZePU7r4GXOx+3Qjcqqo/jlyoJygE6lXVt1NLNZAjIhlBzgPw7a9c7XO8W0RE/W2hXMOYUHhUWbuvhjGDc+Nm9e9ImV1WRFqK8NaOI7EOxSSRkGc8AVDV34jIIuBqnKbDYpyEeRB4G3hMVaO9BLC/ZCJBjgU7t7vnGRNTe440UtPYxodPGxLrUCKuX2Ya00cUsmZPNRdOGEK/zLD+PRlzgrB/i1S1FrjH3XpbNU4vz1Sf2lwB0KiqbUHO6yznrfPrkEakqqrfvttWmzPR8t7eGtJThQkliTs2LpgzRw/gnd1HWbn7KOedOjjW4ZgkkKhL7WwBUgHfCe/Gc/LzNm87gDa3nO95HgIPVzAm5to9Htbvr+W04jwy0+J73bhwDcnLYuzgXJbvPEK7p6v+Z8Z0LVGT3FtAHU4PTgBEJAdnvNxzgU5yZ2F51fs817XA227t1Ji4tO1gPU1tHUxPol6V/pw5eiDHmtvZXHks1qGYJBCwuVJElkToNVRVzw/lBDdhXeJ+OQzIE5Fr3K8Xq2qjiPwUuE1EqnFqb/+Fk7R/53WdG3CaU0erarm7+4fAayLya+BJ93Uuwek0Y0zcem9vDTkZqYwZ3D/WoUTV2CG5FGSn887uo0nVg9TERrBncvO7OFc53mHD3zHc4+E8nxoMPOazr/PrUcBu4Kc4Se07wACcCaE/rKreU5qn4DRrfhCnqr7hJswfAV8EdgHXq+qLYcRpTK9obutgc2Uds8oKE3oar+5IEWFmWSGvbD7E0YZWivoF6ixtTNeCJbmbAuwvwpkdJB9YBiwF9uMkkmKccXLn4EzOfAfHO3t0m6ruJnAC7SyjwP+6W6Ayi4BFfvY/iVOLMyYhbKyoo92jTCtN7qbKTjNHFLJk8yFWl1fz4QnJ15PU9J6ASU5V7/Pd584I8g7OGLlzVPUNf+eKyJk480N+AZgdmVCN6bvW7q2hqF8Gw4tyYh1KryjIyWDskFxWlx/lQ+MHJ33t1URPqB1Pvocza8jNgRIcgKq+BdyCM4PIbeGHZ4ypa25jx+F6ppYWINJ3/tmfXlZEXXM72w5ZBxQTvlCT3EeBJlV9thtlFwNNwJUhR2WM+cCG/bUoMLW0b3XCGD80j36ZaTZps+mRUJNcCc54si65z8w63HOMMWHasL+Wwf0zGRxgPsdklZoiTC3N5/0Dx2hqDXlZSmOA0JPcEaCfiJzVVUG3TC4Q7em9jEladc1tlB9p7LNd6acNL6Ddo2yssCGsJjyhJrnFOL0e7xUR39lGPiAio4F7cYYPdKdp0xjjx8aKOhSY1EeT3LCCbAbmZrBmb0gz7hnzgVDnrvw+znO50cB6EXkCZwhBhXu8BGf4wFU4y+0ccs8xxoShs6ky0NIzyU5EmDq8gCWbD1HT2BrrcEwCCnU9uUoRORd4HDgNZ4Vwf6uEC7AJ+JiqHuhxlMb0Qcea29hd1cB54/v2RMXTSgt4ZfMh1u2zJksTupBXIVDVzSIyFSe5XQPMAAa5hw8D7+LMTvKIqrZHKlBj+pq+3lTZaUBuJsMLs3nPmixNGMJdT64d+Ie7GWOiYMP+WgblZjKkf2asQ4m5qcMLeGZdJdsPHUv6uTtNZCXqKgTGJLX6lnZ2VTUwaVh+nxoAHsikknwEeHadPf0wobEkZ0wc2lhR6zZVJufiqKHKy05n5IAcFq+vjHUoJsFYkjMmDm3YX8vA3AyG9tFelf5MGpbP+wePsd2m+TIhsCRnTJypb2ln52FrqvQ1qSQfEWuyNKGxJGdMnNnk9qrsq7OcBJKXnc7pI4usydKExJKcMXFmw/5aBvSzpkp/Lpk81G2yrI91KCZBWJIzJo4cbWhlZ1W9NVUGsGByMSJYbc50myU5Y+LIixsP4FFrqgxkSF4Ws0YWWpIz3RZSkhMRG4VpTBQ9u76Son4ZFOdbU2Ugl0wuZssBa7I03RNqTa5SRO4TkfnRCMaYvqy6oZW3dhxxexFaU2UgCyZZk6XpvlCTXA7wSeAVEdkuIv8jIqVRiMuYPuelTQfp8Kg1VXZhaL41WZruCzXJfQh4EGgCTgHuAHaJyGIRuUZE0iMdoDF9xbPrKxlelE1JgTVVdqWzyXLHYWuyNMGFlORU9TVV/RRQDHwBWAmkAhcDjwAVIvJrd5UCY0w31TS28ub2Ki6ZXGxNld2wYFIxAIvXWW3OBBdW70pVPaaqf1XVucAE4JfAQWAA8B/AuyKySkS+KCLW9mJMF17adJB2j3KJ+8/bBNfZZPmsNVmaLvR4CIGqblHVbwLDcVYN/zfQDkwHfo/TWeUB66xiTGCL11dSWpjNlFJ7T9hdnU2WO63J0gQRsXFyqtoBPAc8DKxxdwuQBVyH01nlXRE5LxKvJyKviYgG2OYGOKcsQPmHIxGTMeGobWrjDWuqDNmCyUMB62Vpggtr0VRfIjIduAm4HijESW6twFPAE8D5wLXANOAlEblSVZ/u4ct+CfBdh+QOnBrkO12c+w3gTa+vq3oYizFhe2nTQdo6lEsmW1NlKIrzs5k5spDF6w/wlQ+NjXU4Jk6FneREZADOcIKbgMmdu4EtwF3A/aramTweFpGvA79yy38P6FGSU9VNPvFkALOAR9yVy4N5X1WX9+T1jYmU59ZXMqwgm6nWVBmyBZOG8qNnN7O7qoGygf1iHY6JQ6HOeJIiIpeKyOPAfuBOYArOkIL7gbNVdYKq3umV4ABQ1TqcHpkNwMSIRH+ii3FqkQ9F4drGREVdcxuvb6tiwaSh1lQZhgVu7dc6oJhAQn0mtxenCfIqIAPn2duXgGJVvUlV3wx2sqq2AUeAzDBi7cpCnMT7ejfK3isiHSJSKSJ3ikh2FOIxpksvbzpIa4eHS6ZYU2U4hhVkM214Ac9tsCRn/Au1ubIYqMUZEP43VX0vjNf8OpAbxnkBiUgO8BHgr6qqQYq2AH8AXgTqgPnAt4HRwBVhvG6w1zKmS4vXV1KSn8X04QWxDiUhPLhiz0n7ivOzeG7DAX6/ZDtF/TIAuH7OiN4OzcSpUJPcp4HHVLU53BdU1X+Ge24QH8FJnEGbKlW1EviK167XROQg8EcRmRZm0jYmLLVNbSzbWsUnzxhpTZU9MGlYPs9tOMD6/bWcO25QrMMxcSbU5sqlOAO+u0VESkSkN95SLQS2q+qqMM593P04I9QTVVX8bWHEYPqgl9ymysumWlNlTxTmZFBamM2G/bWxDsXEoVCT3G6cqby6601gZ4ivERJ3RpUFhN/hRH0+GtMrnl1XwbCCbGuqjIBJJfnsr2niaENrrEMxcSacweCh1lSiXbO5EqcjS7hJ7hr34+rIhGNM12oaW3l9WxWXTbEB4JEwyV25wWpzxldEBoMHkYMzxVc0LQTWqupm3wMish1Yqqo3u1/fDvTHqWHWAecA3wSeUNV1UY7TmA+8sPEA7R7lUutVGRFF/TIYVpDNhopazrHncsZLxKb18iUiY4CBwIEovsZAnNlUAk3LlYazSkKnLcC5wL3AYpwZWv7P/WhMr3lmXSUjinJs7bgImjQsn33VTVQ3WpOlOS5oTU5EruDkrvX5InJPsNOAAmCe+/Wr4YcXnDvgPOAadqpa5vP1wwROiMb0iiP1Lby14wifP+cUa6qMoEklebyw8YA1WZoTdNVcOQ240Wdftp99gewAbgstJGOS2/MbD9DhUS6bUhLrUJLKgNxMhhVks26fJTlzXFdJ7jWfr78P1OOsHxeIB+d510bgtW7MI2lMn9A5kPnu13cxMDeDNXuqeW9vTYyjSi5TS/NZvOEAOw/Xc8qgiM45YRJU0CSnqktxxsYBICLfB+pV9QfRDsyYZHSsuY1dVQ3MP3WwNVVGweTSAp7bcICn1lbw1QvGxTocEwdC7XgyCpgdjUCM6Qs2VNShYIujRkl+djqjBvbjqfcqCD7Dn+krQkpyqlquqvuiFYwxyW79vhoG989kSF5WrENJWlOHF7CzqoEN++tiHYqJA1EbQmCMOVFtUxvlRxqZbLW4qJpUkk96qvDU2v2xDsXEgYBJzl2KpkNENvrZF8pmHU+MwZmNQ8HGxkVZdkYq544bzFNrK+jwWJNlXxesJidem7993d2stmgMsHZfDcX5WQzub02V0XbFtBIO1rWwctfRWIdiYixY78pR7sc2P/uMMSHYcbiefdVNLJg0NNah9AkXnDaEnIxUnlq7n7mju71wiklCAZOcqpZ3Z58xpmv/XrMfAaaW2ooDvSE7I5WLJg5l8foD3H75RDLTUrs+ySQla0o0JspUlX+9t5/Rg3LJyw44C52JsMunlXywMK3puyzJGRNlq8ur2Xu0iWkjrBbXm+aNGUhRvwyeWlsR61BMDAVsrhSRGyL1Iqp6f6SuZUyieWLNfrLTU5lYkhfrUPqU9NQULp1czGOr99LQ0k6/zGivLGbiUbCf+iIit1q2JTnTJ7W0d/DsukounDjEngvFwBXTSvj78nJe2HiAq2aUxjocEwPBktwyIpfkjOmTXt1ymNqmNq6cPoyKmuZYh9PnzBxZyIiiHB5fvc+SXB8VrHfl/F6Mw5ik9K81+xiYm8m8MQN5dJXNiNfbRIRrZpZy50tb2VfdSGlhTqxDMr3MOp4YEyU1ja28uuUwl08tIS3V/tRi5aoZwxCBJ961ab76IvvLMyZKnl1fSWuHh6tmDIt1KH1aaWEOZ44ewOOr99nKBH2QJTljouTJNfsZMzjXelXGgWtmlrLnaKNN89UHBRtCsMT9tFxVb/LZFwpV1fPDCc6YRLX3aCPv7K7mmxedaoujxoGLJxZzW+ZGHl+9jzmn2DRffUmw3pXz3Y9b/OwLhbUPmD6n8/nPFdNKYhyJAWear8umFPPU2gpuv3yijZnrQ4L9pG9yP9b62WeMCcDjUR5bvZd5YwZab744cs3MUh5+Zy/PbTjANTNtOEFfEWwIwX3d2WeMOdHynUfYV93ENy86NdahGC8zRxZSNiCHx1fvtSTXh1jHE2Mi7JFVe8nLSuOiibasTjzpHDO3fOdR9h5tjHU4ppdYw7QxPfTgij0ffN7U6kzjNXNkoY3LiiHvn4m3FBEE+P5TG7ngtCEAXD9nRC9GZnpbWDU5EUkVketF5AkR2S0iDe622923UESiOlGfiNwoIupn+0IX5+WLyL0iUi0itSLygIhYdysTEWv31dDuUWaVFcU6FONHQU4GowfnsmZPNR4bM9cnhFyTE5FTgceAiYBv3+gR7nYF8B0R+biqvt/jKIP7ENDk9fXOLso/ApwK3AJ4gJ8BTwJnRyU606esLq+mOD+LkvysWIdiApgxopBHV+1l5+EGxgzOjXU4JspCSnIiMhRn4uZBQCvwOLAU2I+T8IqBc4FrgMnAayIyXVUPRDJoH++oan13CorIXOAi4FxVXebu2w+sEJELVPXlKMZpklxlbRP7a5q4bEqxjY2LYxNL8shOT2VV+VFLcn1AqDW5H+AkuJ3AJaq61U+Zu0TkDmAxcArwfeCLPYoychYABzsTHICqrhSRXe4xS3IZG2CYAAAgAElEQVQmbKvLq0lNEaaV2uKo8Sw9NYVpIwpYuesojS3tsQ7HRFmoz+QuwRncfVOABAeAqm4DPoNTu7ss/PC6ZYeItIvI+yLy+S7KjufEwe2dNrvHjAlLe4eH9/bWMKE4jxwbaBz3Th9ZRIdHWbO3JtahmCgL9a9xINCgqq93VVBVXxeRevecaKgEbgNWAqnAdcCfRSRHVX8V4JxCwN9vdTVOrTMkImJPrg0Amw8co7G1g5kjC2MdiumGoflZDC/M5p3dR1FVa15OYqHW5CpCPCfVPSfiVPUFVf2Rqr6oqs+p6g3Ao8B3RSRYjP4SkwTYb0y3rC4/Sn52uj3jSSCzyoo4dKyFd/dYbS6ZhZrkngKyRWRBVwXdMtk4PRd7y+NAEVAW4Hg14O+BSQH+a3hBqar420K9jklstU1tbDtYz4wRhaRYjSBhTCnNJyMthYdX+h9TZ5JDqEnuB8Au4B4ROTNQIRE5A7gH2A7cEX54YQtUK9uC/2dvgZ7VGdOlVeVHUbCmygSTmZbKlGH5PLOukmPNbbEOx0RJsKV2bghw6I84z8KWicjrwGs4QwgASnCGEJwL1AE/xxkzd3+E4u3K1UAVUB7g+HPAbSIyT1XfABCRWTjP457rnRBNMunwKKt2VzN2cC5F/TJiHY4J0ellRawqr+aptRV8Ys7IWIdjokACrZQrIh4C14i822R8y4jvflWN+OwnIvJPnE4n63Ce/V0LfBK4VVV/55bZDixV1Zu9znseGAd8g+ODwQ+pasQGg3d2SAnQdGnP/pLIki0H+cyiVVw/ewSThuXHOhwTIlXl78vLyUhL4amvzIt1OCa4sJ4FBOtduYz4/of8Ps4wheE4N78JuEFV/+5VJg0nAXpbCPwKpzk1BXgGuDXq0Zqk9OCKveRmpnFasa3+nYhEhIWnD+f2pzexsaKWiSX2RiXZBKzJmfBZTa5vqKxt4qyfLuHssYNsxYEE1tjazk+f28KsskIunzosYDmbyDnmwqrJ2VI7xoTp0Xf24VHnuY5JXDkZaUwals97e2tobffEOhwTYZbkjAlDh0d55J09nD12oHU4SQKzRhbS3OZhY0VtrEMxEWZJzpgwLN16iIraZq6fbU1YyWDUwH4M6JfBO7uPxjoUE2Hhrid3uojcLSJbRKRORDqCbDYDqkk6D67Yy8DcTC6YMCTWoZgIEBFmlRWx+0gjh441xzocE0EhJzkR+X/A28BNOF3xc3EeCAbarLZokkplbRNLthzk47NKSU+1X+9kMWNEASkCq3dXxzoUE0Eh/YWKyHnAj3F6CH4PmOEeOgyMAc7CWVqnyt2uAEZFKlhj4kFnh5OFp1tTZTLpn5XOacV5vLunmnaPdUBJFqG+Df0PnAT3fXdy5Pfc/R2qulNV31bVHwJTceaJvBuw5kqTNNo7PB90OBkxICfW4ZgImzWyiIbWDjZXHot1KCZCQk1yc9yPfw12HVWtBL6Es8zOf4cXmjHx55UtToeTT9iYqaQ0dkguBdnprNx1JNahmAgJNcl1ridX5bWvHfD3lnYJ0ISz4rYxSeG+t3ZTkp/FBadZh5NklOJ2QNlxuIGq+pZYh2MiINQkV83JU4FVA/1E5IT5cNSZSsUDFIcfnjHxY9vBY7y14wifnDuSNOtwkrRmlRWSIvDOLhtOkAxC/UvdB2SKyCCvfZvcj/O9C4rIVKAf0BB2dMbEkfve3k1GWop1OElyeW4HlNV7qmnvsA4oiS7UJPem+3GW176ncIYK/MIdP5cuIjOA+3A6qSzteZjGxFZdcxtPvLufy6eW2AwnfcDssiIaWzvYWFEX61BMD4Wa5P6Fk9A+7bXvT8A2YDSwHGgG3gGm4DyTu73HURoTY4+v2kdjawefnlsW61BMLxjtrg+4wposE16oSW4ZMBln0VQAVLUZZ5HUx4BWjs8U/TbwIVVdH4E4jYkZj8dZc2zGiAIml9pSLH1BiginlxWx+0gDh+psBpREFlKSU1WPqm5U1W0++w+o6rVAHjAMyFPVs1R1ZQRjNSYmlm07zK6qBj59ZlmsQzG9aObIQlJFWGnzWSa0iHYRU9U2Va1UVetsYpLG/W+XM6h/JgsmWUfhviQ3M40JJc4MKG3WASVhWT9oY4IoP9LAq+8f4vrZI8hIsz+Xvmb2qCKa2zys329L8CSqcFchSBWR60XkCRHZLSIN7rbb3bdQRFIjHawxve3+t8tJFbFVofuoUwb2Y2BuBiutA0rCCmcVglOBNcDfgY8CI4Bsdxvh7nsAeNcta0xCOtbcxqPv7GXB5GKG5GXFOhwTAyLC7LIi9hxtZJMNJ0hIoa5CMBSnh+UkoA14EPg8cBnwEeBzOAmuFacX5mvuOcYknIdW7uFYSzufO/uUWIdiYmjGyELSU4X7394d61BMGMSZfaubhUX+AnwW2AlcoqpbA5QbCywGTgH+qqpfjECsCUNEFEBVxc/h7n/DTcy0tnuY9aOXGNg/k1vmWZLr6554dx8bKmpZ/p3zKcixyQBixN//0y6F2lx5Cc4/6ZsCJTgAd4jBZ9ygLgsnMGNi6em1FdQ1t3PO2EFdFzZJb+7oATS3eXh01d5Yh2JCFO4qBK93VdAtU++eY0zCUFX+umwnQ/OyGDs4N9bhmDhQnJ/N7LIi/r68nA6PNcYkklCTXEWI56S65xiTMJZsOcT7B48xb+xARMJqITFJ6NNnlrH3aBOvbjkU61BMCEJNck8B2SLS5Rpxbpls4MlwAjMmFlSV3y7ZzvCibKaWFsQ6HBNHLpw4hOL8LO5+Y1esQzEhCDXJ/QDYBdwjImcGKiQiZwD3ANuBO8IPLzAR+ZiIPCUi+0WkXkRWi8h13ThP/WzLoxGjSTzLtlWxdm8NX54/htQUq8WZ49JTU7jxzDLe3nmEDTY4PGH4LoD6ARG5IcChP+JM0LxMRF4HXgP2u8dKcCZrPheoA34OXAHcH6F4vf0XTsL9GlCF0ynmQREZqKq/6+LcXwKPe319LArxmQSjqvzm5a0MK8jmqhmlPL56X6xDMnHmujkj+N2S7fzt9Z38ZuH0WIdjuiFgkgMWEbi7e+db3HOBcwIcywd+4X4ejST3EVWt8vp6iYiU4CS/rpLcblW12ps5wVs7jvDunhp++NFJNoWX8SsvK52Fpw/n3rd28+2Lx1NSkB3rkEwXgiW5ZcTxmC6fBNdpDU7N0ZiQqCq/fPF9huZl8fFZpbEOx8Sxm+aN4t63dnPvm7v4n0snxDoc04WASU5V5/diHJFyJrCpG+VuF5FfAzU4nWm+oao2OV0f9uKmg7y7p4afXjWZzDSbdtUENqwgm0snF/PQyr18+bwxNjg8ziVNm4yInI9Ti/tDF0Xvw5mK7EPAj4ErgZfCmVA6QCeWuK39Gv/aOzz83wvvM3pQP66ZabU407UvnTea+pZ27rGelnEvKZKciJThzKP5b1VdFKysqt6oqv9U1WWqeidwPTADZ+5N0wf98919bD9UzzcvGk9aalL8SZgoGz80jwWThnLvm7upbWqLdTgmiLD/okXkFBH5log8LCKvuNvD7r5em+xPRIqA54A9wCfDuMTzODOzzAj1RFUVf1sYMZgYaWxt51cvbWP6iAIumjgk1uGYBPIfHxrLsZZ27n3TanPxLFjHE79EJBv4DcfnpvT9p/4x4McichfwNVVt6nGUgWPJAZ4BMoBLw1mRXFXVndXCmhn7iAdX7Png8xc3HeBAXTNXTCvhoZU2L6HpvgkleVw4YQj3vLGLz8wbRV5WeqxDMn6EutROCvBv4Gb33AqcpXV+5m4PcHzqr88CT0qU5kUSkTTgMWAssEBVw5prR0QuBnKB1REMzySAI/UtvL6tiunDCxg5oF+swzEJ6Nbzx1LX3M5flu6IdSgmgFBrcjcBFwDNwH8Cd6nPWj1uUvssTm3vAvece3oe6kn+iDMA/D+BIneWlU5rVLVFRF4BUNXz3dg+B8wCXsYZQD4D+C6wEng2CjGaOPbMukrSUoSLJtmShyY8k4blc8W0Eu56fRefmDPSxs3FoVCfyd2A06x3q6r+zTfBgdP8p6p/BW7Facr8dM/D9OtC9+NvgLd9tmL3WKq7ddoBTAT+BLyAkyDvBy5U1Y4oxWni0KaKOt4/eIzzxw+2ZibTI9+86FQU+MUL78c6FONHqEluMs6K4Pd1o+x9btnJoQbVHapaFqjjh6rudsvM9x7vp6qvqOpZqjpAVdNVdbiq3qqqNhFdH9LU2sG/1+5naF4Wc0fbSlCmZ0oLc7h53iieWLOf9fvsX0m8CTXJZQONqtpln1lVbQUa3HOMiRvPrq+goaWdq2eW2iTMJiK+NH80A/plcPvTG/HYenNxJZz15PJFZExXBUVkHFCArSdn4siSLc7MJueOG8Qwe35iIqR/Vjr/fclprC6v5u/Ly2MdjvESaseTl3E6lfxFRC5V1WZ/hUQkC/gzzvO7l3oWojGRcfhYC9/+53qG5GVy3qmDYx2OSTDeQ0/8UVXGDs7l589v4fzTBlNamNNLkZlgQq3J/QynZ+V8YJ2IfEFExotIfxEZKCIzReQbwDacFQqacZbbMSamOjzK1x55j7qmNq6dNcJmNjERJyJ8dPowFPiff23AT788EwMS6g9CRC4DHgL6EXwpngbgOlV9pkcRJqDO+SsDzH5iv/kx8NtXtnHnS1v56VWTsUcmJpraOjx8/6mNfO+yCXxm3qhYh5NMwnqAHvLbWTdpTQXuxVkYVXy2WpxxcVP7YoIz8Wfp1sP8+uWtfHRaCdeePjzW4Zgkd8PckVw4YQg/XryZ1eW2uEmshVyTO+kCzjyVg9wvD6vqzh5HleCsJhc/th48xtV/fIvSohwe/8Jc+mWmdflsxZieuH7OCGqb2vjI796gtd3DM7fOY2BuZqzDSgbRr8mJyOXu9sHgIlXdqaor3K3PJzgTP6rqW/jMonfIykjl7k/Pol9myFO1GhOW/Ox0/viJGRxtbOWz96+isbU91iH1WaE2Vz4JPI7TocSYuFXb1MaN966kqr6Fu26YZdMtmV43aVg+v104nbV7a/jCP96ltd0T65D6pFCT3FGgTlXroxGMMZHQ0NLOTfeu5P0Dx/jTJ2YydXhBrEMyfdTFk4byk6sms2zrYb726Hu0dVii622htt9sBM4UkTxVrYtGQMb0RH1LOzcveoe1+2r5w/XTOW+8jYczsXXt6SOoa2rnfxdvpqGlnT9+YgY5GdZ03ltCrcn9FWfC4/+IQizG9MiR+hau++tyVpVXc+fHp3LxpOKuTzKmF3z2nFP4qVuj+8RdKzhS3xLrkPqMcMbJ/Qb4MvAT4Feqan1kfVjvyt73+yXbWfTWLmqb2rhu9gjGD82LdUimj7p+zoiAx17YeIBbH1pDUb8M/vTJmUyzpvRQhNW7MqQkJyJL3E9n4QwG7wC2A4fdz/3RzvXc+gpLcr3rze1V3HLfKsAZo2QLoJp4VlHTxAMrymlo6eC/LxnPDXPLSLGJwrujV5JcOE9NVVVTuy6WPCzJ9Q6PR7n7jV389PktDOiXwafOGMkAG49kEkBjaztvbq/i1fcPc9aYAfzs6ik212XXeiXJhbUAqqp2Z/25pGFJLvoO1TXz9cfW8vq2Ki6eOJQ5o4rITO9T76VMglNV3tldzeINlQhwyeRiZo0sROTEfxvBmj/7mOgnOdM9luSiR1V58r393PH0JpraOrjtsglcP3sED63cG+vQjAlLdUMrj7+7j11VDYwbksuV00vJzz6+Wr0luQ9YkosXluSiY+fher737428sb2K6SMK+L9rpjBmcH+g62VQjIlnHlVW7DzC8xsPICJ8+LQhnHHKAFJTxJLccWEluW4N1hCRTOCjwEwgD6gBVgBPq6rNV2Oi6mhDK799ZRv/WF5OVnoqP7xiItfPGWmrepukkSLC3NEDOXVoHk+t3c+z6ytZs6eaK6YNi3VoCa/LmpyInAk8Bgz1c3g38FFVXR/50BKX1eQi49CxZu5+YxcPLN9DY2s7C2eP4KsXjGVw/6yTylpNziQLVWVDRR3PrqvgWHM7n5o7kq9/+FTyc9K7Pjm5Rb65UkSGAeuBfPcFPEAVzqoDnS+4H5ikqrXhBJCMLMn1TPmRBv6ybCePr95He4eHSyYXc+v5Yxk3pH/AcyzJmWTT3NbBS5sPsmLnEfKy0/mvD4/j+tl9esHfqCS5nwPfAKqB/wQeVdVWEckCbsFZKTwL+Kaq3hlOAMnIklzoPB7lzR1VPLRyD89vOEBaSgpXzyylJD/LhgWYPm3a8ALueGYjy3ceZezgXG67bALnjBvU9YnJJypJbg0wBbhBVR/wc/wbwM+BF1X14nACSEaW5LrvYF0zj63ayyOr9rL3aBMFOel8fNZwbp43iiF5WVZDM33e9XNGoKq8uOkgP168mfIjjZx36iC+fuGpTBqWH+vwelNUklwtzswmuap60vI6IjIS2AVsV9Vx4QSQjCzJBVfX3MYdT21i3f4ath+qx6MwamA/ZpcVMaEkj/S+2xxjzEm8e1e2tHew6M3d/OHV7dQ1t/PhCUP44vzRzBhRGMMIe01UkpwHOKiqAWe6dctUqqp1A3JZkjtZbWMbr209xNNrK1m29TCtHR4KctKZMqyAWWWFtnKyMQH4G0JQ29TGojd3c/cbO6lrbmfq8AJuOGMkF08amsyLA0ctyR1Q1ZKelIkWEZkA/A6YizOs4S7gB6oaaB7NzvPygV/jDItIAZ4BblXVIxGKq88nufYOD2v31bB0axXLth5m3b4aPApD87K4dEoxGakplBZmnzS7gzGm+1raO3h3Tw1v76iiqr6VnIxULpwwhAsnDuXssQPpn5VUPTL7VpITkUKc9e024XSAGQ38EmdlhO92ce7zwKk4nWo87vkHVfXsCMXWp5KcqrKvuol1+2pZt6+GdftqWb+/lvqWdlIEpg4v4Oyxgzh33CCmDy8gJUXsWZsxEeRRZdyQ/vxrzX4Wr6+ktqmNtBRhSmk+U4cXMM3dRhTlJPIby6gluVbgrSDXmN9FmaisQiAi3wG+BYzsXMBVRL4F3A4MDbSoq4jMdWM9V1WXuftm4wxu/7CqvhyB2JIuyd331m7qmtqoa26nprGVqvpWjjS0cMT92NzmzN2dkZrCacX9mVyaz9xTBnLWmAEU5GScdD1LcsZER4dH2XO0kfcPHKP8aAMVNU20dTj/dnIyUhncP5M5owZQNrAfo9xt5IAcsuJ/7teoJbmeisoqBCKyDKhQ1YVe+0YA5cDlqvp0gPPuAD6nqkN99u8E/qWqX49AbAmR5No6PNQ0tlHT2EpNUxtHG1o5VNfMwboWDtQ1c7CumUPu57VNbSecK0BBTjoDczMZkJvB0LxshhVmMyQvk7QU6zhiTLzo8CgH65rZV93EvupGDte30NDSQZXXwq0iUJKfTWlhNsX5WQzN7/yY9cHHgf0yY70kUFSm9Yrn1QPGA0u8d6jqHhFpdI/5TXLusS1+9m92j3VbZzLrDZW1Tby06SAej+JRp3nCo0qHx/3ca39bh4emtg6a2zw0t3XQ3NZBU1sHTa0dNLZ2UN3YSm1jG8da/M/IlpoiDO6fyeC8LEYOyGHOKUUcqG2mf1Y6edlp5GenU9Qvw5KZMQkgNUUoKcimpCCb2aOKAKczy7HmNnZXNbKzqp7dVY3sqqqnoqaZ1XuqOVBb+UHtr5MI5GenU5CdTn5OBgXZ6fTLTCUzLZXMtBRnSz/+eVpqCqkiiDjTlqUIjBvanzNHD+zV+w+a5FT1pt4KJAyFOJ1NfFW7x8I575QIxNWVsN6NFOdnc8PcsgiHYozpq/pnpTO5NJ/Jpck91i7R+5r6q0lJgP2ROO/Ei/hvjjTGGBMnErm9qRoo8LM/H/81ta7OK+jiPGOMMQkmkZPcFnyeoYnIcJwZWvw9cwt4nivQszpjjDEJKpGbK58Dviki/VX1mLvvWqAJWNrFebeJyDxVfQNARGbhPI97LpoB92ZHFWOMSTbhPCJK2JXB3cHgm4ANOIO5TwHuBH7tPRhcRLYDS1X1Zq99zwPjOHEw+KFIDQYPEnNifrONMSYOhJPkErYmp6rVInI+8Huc4QI1wK9wBoN7SwN8x+ktdMveg9e0XtGMF3q3o0oXY/WSmt273XusY+ltffneu5KwNTkTXF/+pbd7t3uPdSy9rS/fe1cSueOJMcYYE5QlOWOMMUnLkpwxxpikZUnOGGNM0rKOJ8YYY5KW1eSMMcYkLUtyxhhjkpYlOWOMMUnLkpwxxpikZUnOGGNM0rIkZ4wxJmlZkjPGGJO0LMkZY4xJWpbkjDHGJC1LcglMRD4rIttEpFlEVrvr63V1ziwRWSQi74uIR0QWBSinfrblEb+JMEX53jNF5JcickhEGkTkWREpi/AthCWc+3bPO0tEVohIk4jsEpGT1k+Ml5+5iEwQkVdEpFFEKkTkDhHxXRPS33n5InKviFSLSK2IPCAiA/yUu0JE1rvfw00icm107iR00bx393ff3894fPTuKPYsySUoEVkI/Bm4H1gAbASeEZFJXZx6FjAPeAc40EXZXwJzvbabgxfvHb1w778FbsRZOf4aYCDwkohk9Szyngn3vkVkDPACsAu4FPgLcKeI3OKneEx/5iJSCLwMKHAFcAfwdeAH3Tj9EWA+cAvOz+904Emf688D/gm8ivM9fBZ4SEQujMgN9EC07921hRN/vnOB3T0KPN6pqm0JuAHvA/d4fZ0CrAf+0cV5KV6frwIWBSinwFdifZ+9fe9AKdAO3OC1bxjQCtySoPf9F2ArkOa174/AXtz5a+PlZw58B6gG8rz2fQto9N7n57y5bvzneO2b7e67wGvfC8ASn3MXA2/E8r576d4XAatifZ+9vVlNLgGJyCnAOODRzn2q6gEew3l3GpBbLmH1wr13vqN/wuu8/cAbXV0/mnpy3+7xJ1S13WvfwzgJvavab29bALygqnVe+x4GsoFzuzjvoKou69yhqitxaq8LwGmGBs7D63vodf25IpLf8/B7JGr33pdZkktMnW3oW3z2bwaKRGRQhF7ndhFpF5EqEblHRIoidN2eiPa9jwf2qWq9n+vH8tlFWPctIv2A4QHO875up1j/zMfjE6uq7sGpzQT7/p90nsv75zYaSPdTbjPO/8JxYcQbSdG8904TRKRORFpE5A0RCZY8k0JarAMwYSl0P9b47K/2On64h69xH/C0e51ZwG3AVBGZraodPbx2T0T73gv9XLvz+oV+9veWcO+7oBvndYqHn3m43/9g553iVQY/5fx9L2IhmvcOsAZYAWwCBuE873tJROa5Nb+kZEkuTrhNJcVdlVNV73dsvosBSoD9IVPVG72+XCYim3GeXXwE/w+0wxZv9x7gGhKhax+/YO/ed6DjH+zvzZ95F8L9/nf3vGj+7vRU1O5dVX9zwkGRZ3ES3n8DHw0tzMRhSS5+fAz4WzfKCcffeRYAtV7HAr1rj4TngXpgBpH/hxdP917tdS1vBRG4tq/euO8an3KdAtVqvEXzZx5IoO9/PsFjrcapnfjy/rl5fw99y9DF9XtDNO/9JKraJCKdb2KSlj2TixOqepeqSlebW7zznb1ve/t44Kiq9rSp0l98ne8II/5uN87ufQsw3H2W5Xt9f889wtYb962qDTi9KP2d531df+dG7WcexBZ8YhWR4UA/gn//TzrP5f1z2wG0+Sk3HvDg9ECNpWjeezDxUIONGktyCUhVd+L8QX6sc5+IpLhfPxeN1xSRi4FcYHU0rt9dvXDvL7ofr/S6fglwdoSuH5Ye3vdzwJU+g4qvxUl+GwKdFKOf+XPARSLS32vftUATsLSL84a64+AAZ/A/zjOp5wBUtQVnfNzHfM69FnhbVWuJrajduz8iko3T+zKmf9NRF+sxDLaFtwHXAR3Ad3G6RS/C+WOY5FXmXJwxX+d67RuEM8D5Gpx3tq92fu1V5nPAX4GPAx/CGRRdg/PQOjWZ790t9xegCvgUcDGwHNgGZCXofY/BaXZ80D3vWzg1mlu8ysTFzxynGbUSeAm4wI2rHviRT7ntwN0++54HdgJX4Txjeh943afMPPf782ucwdM/x6nFXRgHv9dRu3ecJs/Xgc8D5+Mkz+VACzAr1vce1e9rrAOwrQc/PPis+wvfArwLnO9zfD5OU8R8P/tO2rzKnA+8CRxx/xnuxZkFJD/W9xzte3fLZQJ34vQybMDpfDEq1vcc7n27++cBK4FmnBkubvU5Hjc/c2ACsAQngVcCP8Qn0br3sMhnXwFwL05yrsNJ6gP9XP+jODXYFpzmvIWx/rlG+96BLJyxn3vd+67FSYxnxPqeo72J+w0wxhhjko49kzPGGJO0LMkZY4xJWpbkjDHGJC1LcsYYY5KWJTljjDFJy5KcMcaYpGVJzpgIEZH5IqIisjvA8QwRuU1ENotIs1tWfcpcKCKviEiNiHjcMjf2RvzGJCOboNkYQEQWAZ/22d2OM7C2Gmfw8ErgIVXdFebL/AG4xf28AZ/Jc0Wkc+qwFJyZTQ7jDOxuCvP1jOnzrCZnzInagIPudhTIwVls8wrgf4EdIvJYgEVKG3GmU9rhe8BdVudG98urVTVXVYeq6lCvYrfi/E0+CvRX1SFumUcic2vG9D2W5Iw50VudycdNMtk4cwouAB7BqVldA6wRkWHeJ6rqSlUdr6rn+7nuqTgtJ0dU9YkArz3R/fh3VbXamzERYEnOmC6oao2qPq+qC4FLceZ/HAb8M4TLZLsf63tYxhgTAktyxoRAVZ/HmaEfYI6IfLDgpL+OJyJyo9u55DV318jODiednUq8OqCUuWVe9TreeR5e15wnIg+LyD4RaRGRIyLysohcJyLip/wJcYnIAhF5TkQOuZ1bvupTPkNEviIir4vIUfc1ykXkHhE5zd/3RUQWua9xu4ikishXRWStiDS613jGXf4lIBHpJyLfEJG33HOaRWSniDwlIp8QkXQ/56SIyKdE5BbdGusAAAZ3SURBVCUROSwirSJSISKPiMicIK91rog87n4PW0WkVkS2iciTIvJ5dxkjkwxiPUO0bbbFw4azbI0Cr3WjbAZwwC3/kNf++e6+3V77rnXLHnWPdbhfd27Xen3e4ZY56rXvCZ/X/hknrqBQ53WeAg8BKT7nfBAX8HX3cw9Oh5p24KteZYuB97yu1+G+RufXTcBVQb5/P8LpPKNAK3DM59y5Ab6nE4BdXmXb3Pi877XM55z+OMvSdB734Myu7x37V/y81ud8rtuAU3v23hfTZZVsi9wW8wBssy0etlCSnFv+Qbf8Pq99JyW57hzzKrMbP8vkeB3/T/f4IeCLQIG7PwtnIdAK9/h3Arx2k5vU/gAM8Tq31P08HacHqeIs0nk2kOEeGwL8wispjA7w/avGWa7n417nTgHWu8dX+rmvImCPe3wnTiefznP74ywTdE9nnF7n/cs9Zy1wCZDt7i8AvoOzpEwHcJbXOTkcT7x3A8N94rjY/dlmxPp30rbIbDEPwDbb4mELI8l9x+tdf7q7L2pJzv3HfQynhjM7wPln4NRmjnr/k+bEdfQeDPL6t3QmIiAzQJk/umV+H+D7p8A8P+fN9Do+0ufYz939h4Fh3fz+X+CeswsoClDmW26ZZ7z2zXb31RMHCwDbFv3N2p2NCU+11+dFvfB6VwO5wBuqutJfAVVdjlMTKsRJKv78X5DX6Bwn+AdVbQlQ5kH344cDHH9dVd/wE9tqYJ/75USfw59yP/5CVfcHic9frItU9WgXsZ4nIqnu53Xux3RgQDdfyyQwGwxuTM/1xsrDZ7of54jIgSDlOhPucOBtn2NNOE17JxGRNJxaDsCdIvKzANfvTBbDAxx/J0hs+4FSnCTc+bplQOdYwcX/v737CY2jDOM4/v0d1DZWY4JWFKGo6EEtggiKHkJBKK1g1OLFSkUhoKgU8SIeCoogXqygXgQlGIv/UKxaQZAqFIlCT3pRFA0qqMX1D1IrhPp4eGbczbKZ7L9s0+H3gWEmybzvOzMheXZmn/fZirbtyuvxoKR7V9h3jAxoR4Cvi+USYF7Ss+R7iF9FxCh+jzZiDnJm/Zlo2f592b2G57xivZ7mVIMqYx2+14iIf5fZf5JMqCm3V7LcMfxV0eafYt2aJXluy/b3XYxbKq/HeLGsZAwgIo5Luh14G7gIeKpYfpN0EJgD3nXAqw8/rjTrz+Zi/WNELI5gvPJvdW9EqItltkMfx7voH+DKbsYY0nn12095vNNdXo+FsmFEHCbv5O4AXiIf8U6Sk/z3AwdaHm/aSc5BzqxHkk4Fyqomh0Y07C/F+rJV6r9BMwiu1hidtD563dRDu4GuR0Qci4h9EXFnRFxM3tU9QT563gbc00+/tvY4yJn1bgbYWGzvG9GY5ftrU5KGnjBR3I0eLr68ddj9V4y7QDPQbe+haXk9dgzpOL6LiEfI0m0AU8Po1048BzmzHkjaSjNDcT4iDoxo6DfI+WnrqM6QRNJE1c8rzBbrHZK2rNIYncwV64fa64FWmC3WV0vaVbVj67EWd+FVypqhp3V5HLbGOciZrUDSuKStkl4hMwDXAz+Q7+GMREQ0yLl5AHdJel3SFS3HuK4o9/Uc8Emfw7wAfEr+X3hP0m5J/yehSNpYlA77mJyYPixPkpmXZwOHJN1UBiNJG4qyZK9KuqBsEFlerSx0/aKkRyWVyShImpA0LWk/mVhS2i5pXtKMpE0t+49JmgF2Ft/6YIjnZyeQsyvNlrquLUX/DJZmKgb5UTj3RcSvozywiHhG+ZE9j5EVTm6T9DdZ2WOc5ovWhT77X5Q0TQaP64Gngb2S/iAzIje07P5RXyfRedyGpG3kC4gLyeSPRUlHyUnwpYfbmu4iz/lmYA+wR9KfZDLLmS37zba1u7ZYkHSMzPo8i2YSzPvA84Odla0VDnJmS51CM629rNv4M/mhqZ8x2IemDiwiHi/uTu4HtpDzzk4HfgI+B96heYfTT/9HJE2RNTV3kpPKJ8k6lF+Sd4lvAh8OcBqdxv1C0uXAA2TQupR8NPsteV6v0ZxMXrY5Ctwi6UbgbuAa4Byy6ss3ZOWWt1g6/+4gOfn8BuAq4HzyBUKDrNk5B7xcMdXCTjLydBAzM6srvydnZma15SBnZma15SBnZma15SBnZma15SBnZma15SBnZma15SBnZma15SBnZma15SBnZma15SBnZma15SBnZma19R87LqjC+xJtSQAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x648 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.figure( figsize = (6,9 ) )\n",
    "ax = fig.add_subplot(2,1,1)\n",
    "my_font_size = 15\n",
    "half_frame(ax, \"Differences\", \"Probability density\", font_size = my_font_size)\n",
    "sns.distplot(synth_diffs,ax=ax)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Great! So now we can see that the difference in entropy of the dialogue between the two characters is not distinct.\n",
    "\n",
    "If we had approached this problem in a different manner, say looking at a single individual's dialogue and comparing it to the synthetic distribution it would have been much more complicated. \n",
    "\n",
    "Framing the problem is one of the most important parts of properly bootstrapping data to understand significance! "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.8"
  },
  "latex_envs": {
   "LaTeX_envs_menu_present": true,
   "autoclose": false,
   "autocomplete": true,
   "bibliofile": "biblio.bib",
   "cite_by": "apalike",
   "current_citInitial": 1,
   "eqLabelWithNumbers": true,
   "eqNumInitial": 1,
   "hotkeys": {
    "equation": "Ctrl-E",
    "itemize": "Ctrl-I"
   },
   "labels_anchors": false,
   "latex_user_defs": false,
   "report_style_numbering": false,
   "user_envs_cfg": false
  },
  "toc": {
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}