Progression_Exercises_with_answers.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 254,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Progression"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An important consideration when making a game is how quickly players will progress through the game. If your game is too easy, players may run out of levels too quickly or get bored. If your game is too hard players may get stuck making many attempts on a single level and get fed up and quit. Modelling the progression speed of players will help you understand how players experience the game.\n",
    "\n",
    "In the following exercises we will simulate progression data for a fictional game. By the end of the exercises you will have written a function that simulates the progression of multiple players over multiple different levels."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The cell below will output 1 (win) or 0 (loss) for a single game round - you saw this function earlier. Edit the cell to define a function, called *progression*, that takes a variable *pass_rate* and outputs the result of the game round (1 or 0)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.random.binomial(1\n",
    "                   , 0.6 #probability of success\n",
    "                   , 1 #number of experiments\n",
    "                  )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Test your code to make sure it's working as you expect."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pass_rate = 0.6\n",
    "\n",
    "progression(pass_rate)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 256,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 256,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#answer:\n",
    "\n",
    "def progression(pass_rate):\n",
    "    result = np.random.binomial(1, pass_rate, 1)\n",
    "    return result[0]\n",
    "\n",
    "progression(0.6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The function you wrote is a good start, but knowing the result of a single game round isn't very useful in helping us understand how players progress through our game. Firstly, most players will play more than one game round in a session, so we need to edit the function to allow for multiple attempts. Your function should now take two variables, *pass_rate* and *num_game_rounds*, and the output of the function should be an array of 1s and 0s. Make sure you test your function to ensure it's working as you expect!\n",
    "\n",
    "**Hint:** A for-loop could be useful here."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def progression(pass_rate, num_game_rounds):\n",
    "    # Your code here\n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 230,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 0, 1, 1, 0, 1, 0, 1, 0, 1]"
      ]
     },
     "execution_count": 230,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#answer:\n",
    "\n",
    "def progression(pass_rate, num_game_rounds):\n",
    "    player_results = []\n",
    "    for attempt in range(num_game_rounds):\n",
    "        result = np.random.binomial(1, pass_rate, 1)\n",
    "        player_results.extend(result)\n",
    "    return player_results\n",
    "\n",
    "progression(0.6, 10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the previous function we used the same pass rate for each level, however in reality each level will have a different pass rate. Let's assume there are 10 levels in our game. The cell below will create a dataframe *levels_pass_rates* which tells us the pass rates for each level.\n",
    "\n",
    "**Note:** The index of *levels_pass_rates* is the level number."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 278,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>level_pass_rate</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.90</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.75</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0.60</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0.80</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>0.10</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>0.55</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>0.80</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>0.50</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>0.70</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>10</th>\n",
       "      <td>0.60</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "    level_pass_rate\n",
       "1              0.90\n",
       "2              0.75\n",
       "3              0.60\n",
       "4              0.80\n",
       "5              0.10\n",
       "6              0.55\n",
       "7              0.80\n",
       "8              0.50\n",
       "9              0.70\n",
       "10             0.60"
      ]
     },
     "execution_count": 278,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "levels_pass_rates = pd.DataFrame(data={'level_pass_rate':[0.90,0.75,0.60,0.80,0.10,0.55,0.80,0.50,0.70,0.60]}\n",
    "                                 , index=[1,2,3,4,5,6,7,8,9,10])\n",
    "levels_pass_rates"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Edit your function so that, instead of taking a single number for *pass_rate*, it takes the dataframe *levels_pass_rates*.\n",
    "\n",
    "\n",
    "**Hint:** A player will keep playing the same level until they win a game round on that level."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def progression(pass_rate, num_game_rounds):\n",
    "    # Your code here\n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Test your function\n",
    "\n",
    "pass_rates = levels_pass_rates\n",
    "num_game_rounds = 10\n",
    "\n",
    "progression(pass_rates, num_game_rounds)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 273,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 1, 0, 0, 1, 1, 1, 1, 1, 1]"
      ]
     },
     "execution_count": 273,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#answer:\n",
    "\n",
    "def progression(pass_rates, num_game_rounds):\n",
    "    player_results = []\n",
    "    level = 1\n",
    "    for attempt in range(num_game_rounds):\n",
    "        result = np.random.binomial(1, levels_pass_rates.loc[level], 1)\n",
    "        player_results.extend(result)\n",
    "        if result == 1:\n",
    "            level += 1\n",
    "    return player_results\n",
    "\n",
    "pass_rates = levels_pass_rates\n",
    "num_game_rounds = 10\n",
    "\n",
    "progression(pass_rates, num_game_rounds)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We now have a function that outputs the realistic progression of a player through 10 game rounds, however we are more interested in how many levels the player passed than in the results of each game round. Edit your progression function to output the total number of levels the player has passed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def progression(pass_rate, num_game_rounds):\n",
    "    # Your code here\n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 274,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 274,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#answer:\n",
    "\n",
    "def progression(pass_rates, num_game_rounds):\n",
    "    player_results = []\n",
    "    level = 1\n",
    "    for attempt in range(num_game_rounds):\n",
    "        result = np.random.binomial(1, pass_rates.loc[level], 1)\n",
    "        player_results.extend(result)\n",
    "        if result == 1:\n",
    "            level += 1\n",
    "    return sum(player_results)\n",
    "\n",
    "pass_rates = levels_pass_rates\n",
    "num_game_rounds = 10\n",
    "\n",
    "progression(pass_rates, num_game_rounds)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One player's progression through the game is interesting, but it doesn't tell us too much about the game overall. We could be looking at a player who is exceptionally good (or bad!) at the game. What we really want to look at is the progression of a number of players, so we can get an idea of how most people will interact with the game.\n",
    "\n",
    "Edit your progression function to take another variable *num_players* and output an array of the total number of levels passed by each player."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def progression(pass_rate, num_game_rounds, num_players):\n",
    "    # Your code here\n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 279,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[7,\n",
       " 6,\n",
       " 9,\n",
       " 4,\n",
       " 4,\n",
       " 4,\n",
       " 4,\n",
       " 4,\n",
       " 5,\n",
       " 6,\n",
       " 4,\n",
       " 6,\n",
       " 5,\n",
       " 4,\n",
       " 4,\n",
       " 4,\n",
       " 4,\n",
       " 4,\n",
       " 8,\n",
       " 5,\n",
       " 7,\n",
       " 4,\n",
       " 4,\n",
       " 4,\n",
       " 4,\n",
       " 4,\n",
       " 7,\n",
       " 9,\n",
       " 7,\n",
       " 2,\n",
       " 7,\n",
       " 4,\n",
       " 8,\n",
       " 4,\n",
       " 4,\n",
       " 4,\n",
       " 4,\n",
       " 4,\n",
       " 4,\n",
       " 4,\n",
       " 4,\n",
       " 4,\n",
       " 4,\n",
       " 7,\n",
       " 4,\n",
       " 8,\n",
       " 4,\n",
       " 6,\n",
       " 4,\n",
       " 9,\n",
       " 9,\n",
       " 4,\n",
       " 4,\n",
       " 7,\n",
       " 4,\n",
       " 7,\n",
       " 4,\n",
       " 4,\n",
       " 8,\n",
       " 4,\n",
       " 7,\n",
       " 4,\n",
       " 4,\n",
       " 4,\n",
       " 4,\n",
       " 7,\n",
       " 7,\n",
       " 9,\n",
       " 7,\n",
       " 4,\n",
       " 6,\n",
       " 4,\n",
       " 4,\n",
       " 4,\n",
       " 4,\n",
       " 5,\n",
       " 5,\n",
       " 7,\n",
       " 4,\n",
       " 4,\n",
       " 4,\n",
       " 4,\n",
       " 4,\n",
       " 4,\n",
       " 4,\n",
       " 4,\n",
       " 4,\n",
       " 4,\n",
       " 4,\n",
       " 4,\n",
       " 4,\n",
       " 6,\n",
       " 4,\n",
       " 5,\n",
       " 4,\n",
       " 4,\n",
       " 7,\n",
       " 4,\n",
       " 4,\n",
       " 6]"
      ]
     },
     "execution_count": 279,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#answer:\n",
    "\n",
    "def progression(pass_rates, num_game_rounds, num_players):\n",
    "    progress = []\n",
    "    for player in range(num_players):\n",
    "        player_results = []\n",
    "        level = 1\n",
    "        for attempt in range(num_game_rounds):\n",
    "            result = np.random.binomial(1, pass_rates.loc[level], 1)\n",
    "            player_results.extend(result)\n",
    "            if result == 1:\n",
    "                level += 1\n",
    "        progress.append(sum(player_results))\n",
    "    return progress\n",
    "\n",
    "pass_rates = levels_pass_rates\n",
    "num_game_rounds = 10\n",
    "num_players = 100\n",
    "\n",
    "progression(pass_rates, num_game_rounds, num_players)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 6"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we have our simulated progression data, but what does it mean? How do we interpret an array of numbers? One of the best ways to see what's going on with data is to visualise it."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Histogram\n",
    "\n",
    "A simple way to visualise an array of numbers is to create a histogram:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 291,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'Number of Players')"
      ]
     },
     "execution_count": 291,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAp4AAAF8CAYAAABmEruHAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAIABJREFUeJzt3X+Q3HV9x/HX/rrb2927vbuES5BAKMXQAh2KHQpqjAgtLXUUySniNekAoYBRKtCSqgg6IjVRSxKsEMQgtTWCEAIznXEUBKYlTbEaBMSRIE3qHBByl+zt7Y/bu/3VP467QvieXjC7n/fe5/mY6UzvErLv7zyz5zu73/1+Q/V6vS4AAACgwcKuBwAAAIAfWDwBAADQFCyeAAAAaAoWTwAAADQFiycAAACagsUTAAAATcHiaVClUnE9AgLQxSa62EUbm+hiky9dWDwN2rt3r+sREIAuNtHFLtrYRBebfOnC4mlQMpl0PQIC0MUmuthFG5voYpMvXVg8DYrFYq5HQAC62EQXu2hjE11s8qULi6dBIyMjrkdAALrYRBe7aGMTXWzypQuLJwAAAJqCxdOgjo4O1yMgAF1sootdtLGJLjb50oXF06B4PO56BASgi010sYs2NtHFJl+6sHgalMlkXI+AAHSxiS520cYmutjkSxcWTwAAADQFi6dBvrzc3mroYhNd7KKNTXSxyZcuLJ4GJRIJ1yMgAF1sootdtLGJLjb50oXF0yBfzvNoNXSxiS520cYmutjkSxcWT4Pq9brrERCALjbRxS7a2EQXm3zpwuJpUHt7u+sREIAuNtHFLtrYRBebfOkSdT1AK6mtDjXlcToiKdWq+YY+RvhWP/5ldTj5cv5Nq6GLXbSxiS42+dKFVzwNysbmux4BAbLZrOsREIAudtHGJrrY5EsXFk+DqiFeiLaoVqu5HgEB6GIXbWyii02+dGHxNKitVnI9AgLEYjHXIyAAXeyijU10scmXLiyeBqUqI65HQIBUKuV6BASgi120sYkuNvnShcXToNHYPNcjIEAul3M9AgLQxS7a2EQXm3zpwuJpUCXkx8vtraZSqbgeAQHoYhdtbKKLTb50YfE0KFovux4BAaJRPvRlEV3soo1NdLHJly4sngZ1lfe7HgEBOjs7XY+AAHSxizY20cUmX7qweBqUj3a7HgEB8vnGXtQfbw5d7KKNTXSxyZcuLJ4GTYTjrkdAgHKZUyAsootdtLGJLjb50oXF06BI3Y8TjFtNOMzTxSK62EUbm+hiky9d/DjKFpMuD7seAQHS6bTrERCALnbRxia62ORLFxZPgwpRP/7ytZpiseh6BASgi120sYkuNvnShcXToPFwh+sREGB8fNz1CAhAF7toYxNdbPKlC4unQSHVXI+AAKFQyPUICEAXu2hjE11s8qULi6dBPRP7XI+AAD09Pa5HQAC62EUbm+hiky9dWDwNKkb8uIhsq/Hl/JtWQxe7aGMTXWzypQuLp0GlSNL1CAhQKpVcj4AAdLGLNjbRxSZfurB4AgAAoClYPA3qndjregQE8OX8m1ZDF7toYxNdbPKlC4unQbzVbpMvb4O0GrrYRRub6GKTL11YPA3iw0U2jY2NuR4BAehiF21sootNvnRh8QQAAEBTsHga1M11PE3q7u52PQIC0MUu2thEF5t86RJ19cArVqxQrTZ5h57+/n6dc845uvbaazU0NKQFCxZo3bp16uz08y3ncjguVUddj4GDlMtl1yMgAF3soo1NdLHJly7OXvHs6OjQli1btGXLFvX392vDhg0aGBjQ1q1bNTAwoI0bN7oazblCtMv1CAhQKBRcj4AAdLGLNjbRxSZfujhbPPfu3asVK1bokksu0XPPPac9e/Zo2bJlkqSlS5dq9+7drkYDAABAAzh7q/22227TokWLtG/fPl199dVKJBKv+/Vw+NB24sHBQfX09KhUKk1/Mqy7u1vlcnn6XxHpdFrValX5fF6S1NU1+cri6Ojk29qpVEqRSETZbFaSlEwmFYvFNDIyIkmKty1QvFrQgbaFk19XC0pUc8q09amusNprY0pWssrG5qsaiqqtVlKqMqLR2DxVQjFF62V1lfcrH+3WRDiuSL2idHlYhWha4+EOhVRTz8Q+1UJhDXYcL2nymp6lSHL6k+7dE/tUDsenXxVNl4dVC0WUi05e/6urfGDymGK9kqTOSkbhelXZ2PzJY6qMKlYraXRwUNLkK8/xeFyZTGbymOJxJRIJZTIZ1et1tbe3K5FIKJvNqlarKRaLKZVKKZfLqVKpKBqNqrOzU/l8XuVyWeFwWOl0WsViUePj4wqFQurp6VGxWJy+VESjOzXqmCqVigYHB+fUMc2FTuVyWYODg3PqmOZKp2KxqL17986pY5oLnYrFol555ZU5dUxzoVOxWNTQ0NCcOaaD97opoXq9Xg/8lSZas2aN9u/fr82bN09/b9WqVa/72oLa6lBTHicbm6d0eX9DHyN8q/PsLWdkZMSbk79bCV3soo1NdLHJly5O3mq/6667tGvXLkmTG/Xu3bt1zDHHaPv27ZKkHTt2aPHixS5GM2Hq1UvYMvWvQdhCF7toYxNdbPKli5O32s855xxdf/31KhaLqlQquuaaa3TSSSdpzZo1Wr9+vfr6+rR27VoXowEAAKBBTLzV3iqa9Vb7aLRXXZUDDX0M3mo/dKOjo9PnvsAOuthFG5voYpMvXbiAPAAAAJqCxdOgqU+kw5apT/jBFrrYRRub6GKTL11YPAEAANAULJ4GdVYyrkdAgFQq5XoEBKCLXbSxiS42+dKFxdOgcL3qegQEiEQirkdAALrYRRub6GKTL11YPA2aussQbJm6awNsoYtdtLGJLjb50oXFEwAAAE3B4mlQsuLHJ9taTTKZdD0CAtDFLtrYRBebfOnC4mlQrFZyPQICxGIx1yMgAF3soo1NdLHJly4sngaNtPW5HgEBRkZGXI+AAHSxizY20cUmX7qweAIAAKApWDwNSlRzrkdAgI6ODtcjIABd7KKNTXSxyZcuLJ4GxasF1yMgQDwedz0CAtDFLtrYRBebfOnC4mnQgbaFrkdAgEyGO0pZRBe7aGMTXWzypQuLJwAAAJqCxdMg3mq3yZe3QVoNXeyijU10scmXLiyeBvHhIpsSiYTrERCALnbRxia62ORLFxZPgzJcx9MkX86/aTV0sYs2NtHFJl+6sHgaVCeLSfV63fUICEAXu2hjE11s8qULG45B7bUx1yMgQHt7u+sREIAudtHGJrrY5EsXFk+DkpWs6xEQwJfzb1oNXeyijU10scmXLiyeBmVj812PgADZLP8gsIgudtHGJrrY5EsXFk+DqqGo6xEQoFaruR4BAehiF21sootNvnRh8TSorVZyPQICxGIx1yMgAF3soo1NdLHJly4sngalKiOuR0CAVCrlegQEoItdtLGJLjb50oXF06DR2DzXIyBALseF/S2ii120sYkuNvnShcXToErIj5fbW02lUnE9AgLQxS7a2EQXm3zpwuJpULRedj0CAkSjfOjLIrrYRRub6GKTL11YPA3qKu93PQICdHZ2uh4BAehiF21sootNvnRh8TQoH+12PQIC5PN51yMgAF3soo1NdLHJly4sngZNhOOuR0CAcplTICyii120sYkuNvnShcXToEjdjxOMW004zNPFIrrYRRub6GKTL138OMoWky4Pux4BAdLptOsREIAudtHGJrrY5EsXFk+DClE//vK1mmKx6HoEBKCLXbSxiS42+dKFxdOg8XCH6xEQYHx83PUICEAXu2hjE11s8qULi6dBIdVcj4AAoVDI9QgIQBe7aGMTXWzypQuLp0E9E/tcj4AAPT09rkdAALrYRRub6GKTL11YPA0qRvy4iGyr8eX8m1ZDF7toYxNdbPKlC4unQaVI0vUICFAqlVyPgAB0sYs2NtHFJl+6sHgCAACgKVg8Deqd2Ot6BATw5fybVkMXu2hjE11s8qULi6dBvNVuky9vg7QauthFG5voYpMvXVg8DeLDRTaNjY25HgEB6GIXbWyii02+dGHxBAAAQFOweBrUzXU8Teru7nY9AgLQxS7a2EQXm3zpwuJpUDkcdz0CApTLZdcjIABd7KKNTXSxyZcuLJ4GFaJdrkdAgEKh4HoEBKCLXbSxiS42+dKFxRMAAABNweJpULo87HoEBEin065HQAC62EUbm+hiky9dnC+eV155pb73ve8pl8vpiiuuUH9/v1avXq1cLud6NGdqoYjrERCgWq26HgEB6GIXbWyii02+dHG6eD7xxBN6+eWXJUkbNmzQwMCAtm7dqoGBAW3cuNHlaE7lon7cvaDV5PN51yMgAF3soo1NdLHJly7OFs9araZ7771XF1xwgSRpz549WrZsmSRp6dKl2r17t6vRAAAA0ABRVw98zz33qL+/Xy+99JIkKRx+/Q588Ne/yeDgoHp6elQqlaav/t/d3a1yuTz9SbF0Oq1qtTr9r4qurslPj4+OjkqSUqmUIpGIstmsJCmZTCoWi2lkZESSFG9boHi1oANtCye/rhaUqOaUaetTXWG118aUrGSVjc1XNRRVW62kVGVEo7F5qoRiitbL6irvVz7arYlwXJF6RenysArRtMbDHQqppp6JfaqGohrsOF7S5H3bS5Hk9N2Muif2qRyOT3/yPV0eVi0UmX6VtKt8YPKYYr2SpM5KRuF6VdnY/MljqowqVitpdHBQktTR0aF4PK5MJjN5TPG4EomEMpmM6vW62tvblUgklM1mVavVFIvFlEqllMvlVKlUFI1G1dnZqXw+r3K5rHA4rHQ6rWKxqPHxcYVCIfX09KhYLE7fDqzRnRp1TOVyWYODg3PqmOZCp4mJCQ0ODs6pY5ornQqFgvbu3TunjmkudCoUCnrllVfm1DHNhU6FQkFDQ0Nz5pgSiYSChOr1ej3wVxpodHRU69at00033aStW7cqkUjovvvu0+bNm6d/z6pVq173tQW11aGmPM5otFddlQMNfYzwrU3P3vJGR0enn5Cwgy520cYmutjkSxcnr3jefffd+vnPf66BgQENDw8rHA5rwYIF2r59u975zndqx44dWrx4sYvRTBiNNX7xxKHz5YdCq6GLXbSxiS42+dLFyeJ52WWX6bLLLpOk6Vc83/nOd2rNmjVav369+vr6tHbtWhejAQAAoEGcneM5pb+/f/r/37Rpk8NJ7OisZFyPgACpVMr1CAhAF7toYxNdbPKli/PreOKNwnU/ruXVaiIRrq9qEV3soo1NdLHJly4sngZNfQIdtkx9og+20MUu2thEF5t86cLiCQAAgKZg8TQoWRl1PQICJJNJ1yMgAF3soo1NdLHJly4sngbFaiXXIyBALBZzPQIC0MUu2thEF5t86cLiadBIW5/rERBg6i4NsIUudtHGJrrY5EsXFk8AAAA0BYunQYlqzvUICNDR0eF6BASgi120sYkuNvnShcXToHi14HoEBIjH465HQAC62EUbm+hiky9dWDwNOtC20PUICJDJcEcpi+hiF21sootNvnRh8QQAAEBTsHgaxFvtNvnyNkiroYtdtLGJLjb50oXF0yA+XGRTIpFwPQIC0MUu2thEF5t86cLiaVCG63ia5Mv5N62GLnbRxia62ORLFxZPg+pkMaler7seAQHoYhdtbKKLTb50YcMxqL025noEBGhvb3c9AgLQxS7a2EQXm3zpwuJpULKSdT0CAvhy/k2roYtdtLGJLjb50mXWi+fGjRuVy+V033336V3vepe+8IUvNHIur2Vj812PgADZLP8gsIgudtHGJrrY5EuXWS+e//7v/654PK5vfvObeuihh/STn/ykkXN5rRqKuh4BAWq1musREIAudtHGJrrY5EuXWS+ebW1tuuiii/ThD39YBw4c0MTERCPn8lpbreR6BASIxWKuR0AAuthFG5voYpMvXUL1WX6MqlgsanBwUEuWLNHu3buVzWb1h3/4h42ez5Ta6lBTHqcYSSlRzTf0McK3+vHpucOpUCgomUy6HgMHoYtdtLGJLjb50mXWr3jecccdWrJkiSTpd37nd7xbOptpNDbP9QgIkMtxYX+L6GIXbWyii02+dJn1yYQ/+tGPtGnTJh199NHT33vve9/bkKF8Vwn58XJ7q6lUKq5HQAC62EUbm+hiky9dZr14nn766ZqYmNALL7wgSQqFmvO2s4+i9bLrERAgGuVDXxbRxS7a2EQXm3zpMuuj/Ju/+RtJ0t69e7Vw4cKGDQSpq7zf9QgI0NnZ6XoEBKCLXbSxiS42+dJl1ud4PvPMM3r/+9+vlStX6mc/+5nuv//+Rs7ltXy02/UICJDPN/YDX3hz6GIXbWyii02+dJn14vkP//AP2rx5s9LptJYsWaLvfve7jZzLaxPhuOsREKBc5hQIi+hiF21sootNvnSZ9eI5Pj6uI444QqFQSG1tbapWq42cy2uRuh8nGLeacJg7zFpEF7toYxNdbPKly6yP8pRTTtHnPvc55fN53XHHHTrxxBMbOZfX0uVh1yMgQDqddj0CAtDFLtrYRBebfOky68Xz+uuv10knnaQzzjhD3d3d+uxnP9vIubxWiPrxl6/VFItF1yMgAF3soo1NdLHJly6z/lT7ddddp5UrV+pDH/pQI+eBpPFwh+sREGB8fNz1CAhAF7toYxNdbPKly6xf8Vy+fLluv/12DQwM6N/+7d+8udCpCyHVXI+AAFy71ia62EUbm+hiky9dZn2vdkmq1Wq688479dWvflXHHHOMzj77bF144YXeXNeTe7X7rVgsKpFIuB4DB6GLXbSxiS42+dJl1q943nPPPVq+fLmy2aweffRRbdu2Tb/7u7+ra665ppHzeakY8eMisq3Gl/NvWg1d7KKNTXSxyZcusz7Hc+/evfrnf/7n133q6n3ve5/e9773NWQwn5UiSdcjIECpVHI9AgLQxS7a2EQXm3zpMuvF8+ijj9Yjjzzyuu+df/75h30gAAAAzE2zXjwffvhhHThwQGeccYaeeOIJ9fb2sng2SO/EXtcjIEBPT4/rERCALnbRxia62ORLl1kvnrlcTv/yL/+iWCymcrmsVatWNXIur5UiyYZ/uAiHrlQqKZnkNAhr6GIXbWyii02+dJn1h4tyuZxisZgkKRqNamRkpGFD+Y4PF9k0NjbmegQEoItdtLGJLjb50mXWr3i++93v1urVq3XWWWfpkUce0bJlyxo5FwAAAOaYQ7qO5+OPP65f/OIXOuGEE/Sud72rkXOZ1KzreOYjXUpVRxv6GFzH89Dl83mlUinXY+AgdLGLNjbRxSZfusz4iudTTz31hu91dnbqtNNOm/71U045pXGTeawcjksNXjxx6MrlsusREIAudtHGJrrY5EuXGRfPLVu2/Nr/MBQKsXg2SCHapZ7yPtdj4CCFQsGbTx22ErrYRRub6GKTL11mXDzXrVsnafKm9e3t7U0bCAAAAHPTjIvn008/rU9/+tOKxWKKx+O65ZZbdMQRRzRzNm+ly8OuR0CA1961C3bQxS7a2EQXm3zpMuPllNatW6dvfOMb2rZtm6644gp97Wtfa+ZcXquFIq5HQIBqtep6BASgi120sYkuNvnSZcbFs1wua+HChZKkpUuXateuXU0byne56Nw/x6MV5fNc1N8iuthFG5voYpMvXWZ8q33v3r36+te/Lkmq1+saHByc/nrKZZdd1tjpAAAAMGfMuHheddVVv/br38aGDRv0X//1X5Kkq6++WqeeeqpuuOEGPf/880omk/rSl740/Wqrj7rKB1yPgABdXV2uR0AAuthFG5voYpMvXWZcPJcvX96QBywWi1q4cKHuvvtu5fN5XXXVVXrHO96hU045RWvXrtWuXbt000036atf/WpDHh8AAABuzPpe7YdLIpHQhRdeKEl64YUXlEgktGPHDl1wwQWSpCVLlmh8fFyVSqXZo5kxGut1PQICjI5yUX+L6GIXbWyii02+dJn1vdoPt29/+9u6/fbb9fd///d64IEHFIn8/ye558+fr0wmc0iXbxocHFRPT49KpZLGxsYkSd3d3SqXyyoUCpImL1VQrVanT+Cdell7KnYqlVIkElE2m5UkJZNJxWIxjYyMSJLibQsUrxZ0oG3yNIB4taBENadMW5/qCqu9NqZkJatsbL6qoajaaiWlKiMajc1TJRRTtF5WV3m/8tFuTYTjitQrSpeHVYimNR7uUEg19UzsUzY2b/q4eif2qhRJqhjpnDymiX0qh+MqRCdnT5eHVQtFpj+QNPU2/dTy2lnJKFyvKhubP3lMlVHFaiWNDg5Kkjo6OhSPx5XJZCaPKR5XIpFQJpNRvV5Xe3u7EomEstmsarWaYrGYUqmUcrmcKpWKotGoOjs7lc/nVS6XFQ6HlU6nVSwWNT4+rlAopJ6eHhWLRZVKJUlqeKdGHdPUnz+XjmkudJr67+fSMc2VTkNDQ3PumOZCp6GhoTl3THOh09DQ0Jw6pkQioSAz3qt9586detvb3jbj14dDtVrVxz72MU1MTOgb3/iGwuHJF2Avv/xyfe1rX1M06mwvDtSse7VnY/OULu9v6GNwr/ZDNzIyou7ubtdj4CB0sYs2NtHFJl+6zPhW+9/+7d9qz5492r9/v4aHh3XjjTdq//79r/u/N+PBBx/Uj3/848kHD4dVrVZ1+umn695775U0+fZ7LBYzt3Q2U7jux7W8Ws1rX5WHHXSxizY20cUmX7rM+IrnD3/4Q919990aGxtTvV7Xs88+q5NPPllTvz0UCulf//VfD/kBM5mMrr/+eu3fv1/1el3nnXeeli9frhtuuEEvvPCCksmk1q5dqyOPPPK3O7IGaNYrnoMdx2vR2C8b+hi84nnoBgcHtWjRItdj4CB0sYs2NtHFJl+6zPiy4tlnn62zzz57+uuHHnpIf/qnf/pbP2BPT4/+6Z/+6Q3fn7o3PAAAAOamWb+fvWzZMt1yyy169tlnddJJJ+nyyy9Xe3t7I2fzVrLixyfbWk0ymXQ9AgLQxS7a2EQXm3zpMuvLKV133XVKJBK67rrr1NXVpeuuu66Rc3ktViu5HgEBYrGY6xEQgC520cYmutjkS5dZL567d+/WpZdeqmOOOUYXXXSRfvWrXzVyLq+NtPW5HgEBpi4dAVvoYhdtbKKLTb50mfXiGQqF9NJLL0mSXnnllelLHwEAAACzMetzPD/1qU/p4osvVm9vr0ZGRvTFL36xkXN5LVHNuR4BATo6OlyPgAB0sYs2NtHFJl+6zHrx/KM/+iN9//vf14EDB9Tbyy0dGyleLbgeAQHi8bjrERCALnbRxia62ORLl0N+v5yls/GmbskJW6ZuBwZb6GIXbWyii02+dOFETQAAADTFrBfPSqXSyDnwGrzVbpMvb4O0GrrYRRub6GKTL11mvXj+1V/9VSPnwGvw4SKbEomE6xEQgC520cYmutjkS5dZf7hoaGhI5557rt7ylreoXq8rFApp8+bNjZzNW5m2PiXG8q7HwEEymYw3PxhaCV3soo1NdLHJly6zXjzvuuuuBo6B16pz6q1J9Xrd9QgIQBe7aGMTXWzypcusN5yjjjpKv/rVr/SDH/xARxxxhObNm9fIubzWXhtzPQICtLe3ux4BAehiF21sootNvnSZ9eJ522236d5779X999+vXbt26bOf/Wwj5/JaspJ1PQIC+PAWSCuii120sYkuNvnSZdaL58MPP6ybb75Z7e3tOvnkk7Vnz54GjuW3bGy+6xEQIJvlHwQW0cUu2thEF5t86TLrxbNWq2lkZEShUEgTExOqVquNnMtr1dCsT71FE9VqNdcjIABd7KKNTXSxyZcus95wrrzySl144YU6cOCALrroIq1evbqRc3mtrVZyPQICxGIx1yMgAF3soo1NdLHJly6zXjzPOussnXbaafrf//1fLV68WJ2dnY2cy2upyojrERAglUq5HgEB6GIXbWyii02+dJn1W+3FYlGbN2/WLbfcos2bN6tQ4O46jTIa44oBFuVyXNjfIrrYRRub6GKTL11mvXh+8pOfVFdXl6677jp1dnbq2muvbeRcXquE/Hi5vdVw21ib6GIXbWyii02+dJn14vniiy/qkksu0eLFi7Vq1Sq98sorjZzLa9F62fUICBCN8qEvi+hiF21sootNvnSZ9eK5YMECDQ8PS5KGh4e1YMGChg3lu67yftcjIADnNdtEF7toYxNdbPKly4zr9SWXXKJQKDT99fDwsP78z/9cJ5xwgn7xi1/o6KOPbsqAPspHu5Wocq92a/L5vJLJpOsxcBC62EUbm+hiky9dZlw8b7zxxmbOgdeYCMddj4AA5TKnQFhEF7toYxNdbPKly4yL51FHHfWG7z3//PMqFou/9vfgtxep+3GCcasJh2d9ZgqaiC520cYmutjkS5dZn8n68Y9/XGNjY5o/f/J2jqFQSKecckrDBvNZujzsegQESKfTrkdAALrYRRub6GKTL11mvXi+8soruvfeexs5C15ViKY5x9OgYrHoxfk3rYYudtHGJrrY5EuXWS+ep512mjZs2KC3vvWt099773vf25ChfDce7nA9AgKMj4+7HgEB6GIXbWyii02+dJn14vmTn/xEJ5xwgl544YVGzgNJIdVcj4AAr73KA+ygi120sYkuNvnSZdaLZzgc1uc///lGzoJX9Uzscz0CAvT09LgeAQHoYhdtbKKLTb50mfXiGYvFdNVVV+nEE0+c/t5ll13WkKF8V4x0co6nQcViUYlEwvUYOAhd7KKNTXSxyZcus148P/CBDzRyDrxGKTL3Ty5uRaVSyfUICEAXu2hjE11s8qXLrBfP5cuXN3IOAAAAzHGzXjz/7M/+TJJUr9dVLpfV1tam73//+w0bzGe9E3tdj4AAvpx/02roYhdtbKKLTb50mfXi+dol85lnntF3vvOdhgyEybfaOcfTnlKp5MU11loNXeyijU10scmXLm/q/kx/8Ad/oOeff/5wz4JXFSOdrkdAgLGxMdcjIABd7KKNTXSxyZcus37F84Ybbpj+/1988UUtXLiwIQMBAABgbpr14vnauxSl02n93u/9XkMGgtTNdTxN6u7udj0CAtDFLtrYRBebfOky68Xz9NNPb+QceI1yOC5VR12PgYOUy2XXIyAAXeyijU10scmVhp3FAAAZV0lEQVSXLjMunlOfYg+SyWQ0Pj6up556qiFD+a4Q7VJPmVc9rSkUCt586rCV0MUu2thEF5t86TLj4hl0qaR6va7bb79d27Zt0xe/+MWGDgYAAIC5ZdZvtQ8ODuraa6/Vcccdp23btnlxWydX0uVh1yMgQDqddj0CAtDFLtrYRBebfOkyq8Xzu9/9rr7+9a/rU5/6lM4+++xGz+S9WijiegQEqFarrkdAALrYRRub6GKTL11+7XU8Dxw4oMsvv1yPPfaYvvvd77J0NkkuOvfP8WhF+TwX9beILnbRxia62ORLlxkXz4cfflgf+tCHdM455+jWW29Vb29vM+cCAADAHBOq1+v1oF94z3veo3A4rGh05nfjfbtXe211qCmPMxrtVVflQEMfI3xrYHb8GqOjo+rq6nI9Bg5CF7toYxNdbPKly4xb5aOPPtrMOQAAADDHval7taOxRmOc1mDR6CgX9beILnbRxia62ORLFxZPAAAANMWsr+N5uH35y1/Wk08+qWq1qksuuUTveMc7dO2112poaEgLFizQunXr1NnZ6Wo8pzorGdcjIEAqlXI9AgLQxS7a2EQXm3zp4mTxfPTRR1WtVrVlyxZNTExoxYoV+s///E8NDAxo2bJlevzxx7Vx40Z95jOfcTGec+G6H9fyajWRCNdXtYgudtHGJrrY5EsXJ2+1v/vd79bf/d3fSZJisZjS6bQGBwe1bNkySdLSpUu1e/duF6OZkI3Ndz0CAmSzWdcjIABd7KKNTXSxyZcuTl7xDIfDCofDyuVyWrdunQYGBrRly5Y3/J5DMTg4qJ6eHpVKJY2NjUmSuru7VS6XVSgUJE3ejqparU5fpHXqsgVTJ/SmUilFIpHp+MlkUrFYTCMjI5KkeNsCxasFHWhbOPl1taBENadMW5/qCqu9NqZkJatsbL6qoajaaiWlKiMajc1TJRRTtF5WV3m/8tFuTYTjitQrSpeHVYimNR7uUEg19UzsUzY2b/q4eif2qhRJqhiZPO2ge2KfyuG4CtHJ2dPlYdVCkemLzneVJy/DNPUBpc5KRuF6dXqZTVZGFauVNDo4KEnq6OhQPB5XJjP59n48HlcikVAmk1G9Xld7e7sSiYSy2axqtZpisZhSqZRyuZwqlYqi0ag6OzuVz+dVLpcVDoeVTqdVLBY1Pj6uUCiknp4eFYtFlUolSWp4p0Yd09SfP5eOaS50mvrv59IxzZVOQ0NDc+6Y5kKnoaGhOXdMc6HT0NDQnDqmmW6tPuN1PBvtv//7v7VlyxZ94hOf0LHHHqtVq1Zp8+bN079+8NcWNOs6nplYn3rK+xr6GFzH89BlMhn19HBXKWvoYhdtbKKLTb50cfJW+9DQkO655x595Stf0bHHHitJOuaYY7R9+3ZJ0o4dO7R48WIXo5kQq5Vcj4AAsVjM9QgIQBe7aGMTXWzypYuTt9qfeeYZ/fSnP9XKlSslSfPnz9cXvvAFrVmzRuvXr1dfX5/Wrl3rYjQTRtr6lBrz43perWRkZMSbTx22ErrYRRub6GKTL12cLJ5nnXWWzjrrrDd8f9OmTQ6mAQAAQDNwAXmDEtWc6xEQoKOjw/UICEAXu2hjE11s8qULi6dB8WrB9QgIEI/HXY+AAHSxizY20cUmX7qweBo0dbkm2DJ1qQjYQhe7aGMTXWzypQuLJwAAAJqCxdMg3mq3yZe3QVoNXeyijU10scmXLiyeBvHhIptmugsD3KKLXbSxiS42+dKFxdOgTFuf6xEQwJfzb1oNXeyijU10scmXLiyeBtXJYpKju8viN6CLXbSxiS42+dKFDceg9tqY6xEQoL293fUICEAXu2hjE11s8qULi6dByUrW9QgI4Mv5N62GLnbRxia62ORLFxZPg7Kx+a5HQIBsln8QWEQXu2hjE11s8qULi6dB1VDU9QgIUKvVXI+AAHSxizY20cUmX7qw4RjUViu5HqHl1FaHGv4Y0fZFqo0PNvxxwrf6cYL54RKLxVyPgBnQxia62ORLF17xNChVGXE9AgLQxaZUKuV6BMyANjbRxSZfurB4GjQam+d6BASgi025HDdcsIo2NtHFJl+6sHgaVAn58XJ7q6GLTZVKxfUImAFtbKKLTb50YfE0KFovux4BAehiUzTKqepW0cYmutjkSxcWT4O6yvtdj4AAdLGps7PT9QiYAW1sootNvnRh8TQoH+12PQIC0MWmfD7vegTMgDY20cUmX7qweBo0EY67HgEB6GJTucwpEFbRxia62ORLFxZPgyJ1P04wbjV0sSkc5seYVbSxiS42+dLFj6NsMenysOsREIAuNqXTadcjYAa0sYkuNvnShcXToELUj798rYYuNhWLRdcjYAa0sYkuNvnShcXToPFwh+sREIAuNo2Pj7seATOgjU10scmXLiyeBoVUcz0CAtDFplAo5HoEzIA2NtHFJl+6sHga1DOxz/UICEAXm3p6elyPgBnQxia62ORLFxZPg4oRPy4i22roYpMv50W1ItrYRBebfOnC4mlQKZJ0PQIC0MWmUqnkegTMgDY20cUmX7qweAIAAKApWDwN6p3Y63oEBKCLTb6cF9WKaGMTXWzypQuLp0G8pWsTXWzy5e2pVkQbm+hiky9dWDwN4kMsNtHFprGxMdcjYAa0sYkuNvnShcUTAAAATcHiaVA314s0iS42dXd3ux4BM6CNTXSxyZcuLJ4GlcNx1yMgAF1sKpfLrkfADGhjE11s8qULi6dBhWiX6xEQgC42FQoF1yNgBrSxiS42+dKFxRMAAABNweJpULo87HoEBKCLTel02vUImAFtbKKLTb50YfE0qBaKuB4BAehiU7VadT0CZkAbm+hiky9dWDwNykX9uHtBq6GLTfl83vUImAFtbKKLTb50iboeAADQXLXVoeY8Tsfxqo39sqGPEb613tA/H8DhxSueBnWVD7geAQHoYlNXF1cbsIrnjE08Z2zypQuLJwAAAJqCxdOg0Viv6xEQgC42jY6Ouh4BM+A5YxPPGZt86cLiCQAAgKZg8TSos5JxPQIC0MWmVCrlegTMgOeMTTxnbPKlC4unQeG6H9fyajV0sSkS4fqqVvGcsYnnjE2+dGHxNCgbm+96BASgi03ZbNb1CJgBzxmbeM7Y5EsXZ4tnrVbTfffdp+eff16SlMvldMUVV6i/v1+rV69WLpdzNRoAAAAawMniWSqVdNlll+mxxx7TL385eXHhDRs2aGBgQFu3btXAwIA2btzoYjQTkhU/PtnWauhiUzKZdD0CZsBzxiaeMzb50sXJ4hkOh3XzzTfrPe95z/T39uzZo2XLlkmSli5dqt27d7sYzYRYreR6BASgi02xWMz1CJgBzxmbeM7Y5EsXJ7fMbGtrU1tb2+u+Fw6Hf+3Xv8ng4KB6enpUKpU0NjYmSeru7la5XFahUJAkpdNpVavV6fuhTt0lYOraWalUSpFIZPo8i2QyqVgsppGREUlSvG2B4tWCDrQtnPy6WlCimlOmrU91hdVeG1OyklU2Nl/VUFRttZJSlRGNxuapEoopWi+rq7xf+Wi3JsJxReoVpcvDKkTTGg93KKSaeib26X+Tv690eb8kqXdir0qRpIqRzsljmtincjiuQnRy9nR5WLVQZPo+4lN3Cpm6fl5nJaNwvTp9rlWyMqpYraTRwUFJUkdHh+LxuDKZyU+fxuNxJRIJZTIZ1et1tbe3K5FIKJvNqlarKRaLKZVKKZfLqVKpKBqNqrOzU/l8XuVyWeFwWOl0WsViUePj4wqFQurp6VGxWFSpNPk/Qo3oFIl0aaStT5KUqOYa0mlP8kR1l4enOxUjnSpFkoe9U3hw8A1/9+ZKp0Yc0+7du9XT0zOnjqnRnWrR3t/4M+JwPJ9ejh+rI0t7ZvVz780+n8KDg3O2U6OO6ZVXXtFb3vKWOXVMc6HTvn37tGjRojlzTIlEQkFC9Xrd2Y1ut27dqkQioXPPPVerVq3S5s2bp3/t4K8taNb9jQc7jtci7m98SJrRphldpLnXptEGBwe1aNEi12O0FH6W+Y3njE2+dDHzqfZjjjlG27dvlyTt2LFDixcvdjyRO4kqH6yyiC42dXR0uB4BM+A5YxPPGZt86eLkrXZJ+tjHPqaXXnpJkUhEO3fu1NVXX601a9Zo/fr16uvr09q1a12N5ly8WnA9AgLQxaZ4PO56BMyA54xNPGds8qWLs8Xza1/72hu+t2nTJgeT2HOgbaESTXhLF4eGLjZlMhlvPg3aanjO2MRzxiZfuph5qx0AAABzG4unQbw9ZRNdbPLl7alWxHPGJp4zNvnShcXTIE7It4kuNs10yQ64x3PGJp4zNvnShcXToMyr18+DLXSxaeracbCH54xNPGds8qULi6dBdbKYRBebHF6KGL8BzxmbeM7Y5EsXfioY1F4bcz0CAtDFpvb2dtcjYAY8Z2ziOWOTL11YPA1KVrKuR0AAutjky3lRrYjnjE08Z2zypYuz63hiZtnYfCWqeddj4CB0OXTNuDXjSPxYdZT2NPxxuDXjoeM5Y1M2m/XiepGtxpcuvOJpUDXEvwcsootNdLGLNjbVajXXIyCAL11YPA1qq5Vcj4AAdLGJLnbRxqZYLOZ6BATwpQuLp0GpyojrERCALjbRxS7a2JRKpVyPgAC+dGHxNGg0Ns/1CAhAF5voYhdtbMrluLC/Rb50YfE0qBLy4+X2VkMXm+hiF21sqlQqrkdAAF+6sHgaFK2XXY+AAHSxiS520camaJQPfVnkSxcWT4O6yvtdj4AAdLGJLnbRxqbOzk7XIyCAL11YPA3KR7tdj4AAdLGJLnbRxqZ8nmurWuRLFxZPgybCcdcjIABdbKKLXbSxqVzmFAiLfOnC4mlQpO7HCcathi420cUu2tgUDvM//Rb50sWPM1lbTLo87HoEBKCLTXSxizaHphm3mJWkrkhKtSbcypTbzB6adDrteoSm8GO9bjGFqB9/+VoNXWyii120sYkuNhWLRdcjNAWLp0Hj4Q7XIyAAXWyii120sYkuNo2Pj7seoSlYPA0KqeZ6BASgi010sYs2NtHFplCoOadauMbiaVDPxD7XIyAAXWyii120sYkuNvX09LgeoSlYPA0qRvy4iGyroYtNdLGLNjbRxSbO8YQzpUjS9QgIQBeb6GIXbWyii02lUsn1CE3B4gkAAICmYPE0qHdir+sREIAuNtHFLtrYRBebOMcTzvA2iE10sYkudtHGJrrYxFvtcIYTv22ii010sYs2NtHFprGxMdcjNAWLJwAAAJqCxdOgbq6xZhJdbKKLXbSxiS42dXd3ux6hKVg8DSqH465HQAC62EQXu2hjE11sKpfLrkdoChZPgwrRLtcjIABdbKKLXbSxiS42FQoF1yM0BYsnAAAAmoLF06B0edj1CAhAF5voYhdtbKKLTel02vUITcHiaVAtFHE9AgLQxSa62EUbm+hiU7VadT1CU7B4GpSL+nH3glZDF5voYhdtbKKLTfl83vUITcHiCQAAgKZg8TSoq3zA9QgIQBeb6GIXbWyii01dXX5cbYDFEwAAAE3B4mnQaKzX9QgIQBeb6GIXbWyii02jo6OuR2iKqOsBAAAALKutDjX+MTqOV23slw1/nPCt9YY/xq99fKePjkCdlYzrERCALjbRxS7a2EQXm3zpwuJpULjux7W8Wg1dbKKLXbSxiS42+dKFxdOgbGy+6xEQgC420cUu2thEF5t86cLiCQAAgKZg8TQoWfHjk22thi420cUu2thEF5t86cLiaVCsVnI9AgLQxSa62EUbm+hiky9dWDwNGmnrcz0CAtDFJrrYRRub6GKTL11MLZ7f/OY3df755+v888/Xj370I9fjAAAA4DAys3g+++yzeuaZZ3T//ffrW9/6ljZu3Kjx8XHXYzmRqOZcj4AAdLGJLnbRxia62ORLFzOL50MPPaSLLrpIoVBInZ2dOvPMM/Xkk0+6HsuJeLXgegQEoItNdLGLNjbRxSZfupi5Zeb+/fvV1/f/5zf09fVpeHjY4URv1KzbTKWa8ihzSzPa0OXQ0cUmfpbZRBe7+Fl2+Jh5xXPevHkaGhqa/nrfvn2aN2+ew4kAAABwOJlZPP/kT/5Ed911lySpUCjoscce09ve9ja3QwEAAOCwMfNW+8knn6wTTzxRy5cvVygU0rXXXqv29nbXYwEAAOAwCdXr9eacVAIAAACvmXmrHQAAAHMbiycAAACagsUTAAAATcHiCQAAgKZg8QQAAEBTmLmcEv7flVdeqb/4i7/Queee63oUvGrFihWq1WqSpP7+fvX39zueCK/1wAMP6Oyzz1ZnZ6frUby3detWbd26dfrrkZER3XnnnVq4cKHDqTDlK1/5inbu3KlaraZrrrlGf/zHf+x6JK/VajXdf//9OuWUU/TWt75VuVxO1157rYaGhrRgwQKtW7duzv1cY/E05oknntDLL7/segwcpKOjQ3fccYfrMRDg29/+to477rg598O5Vb32H2a1Wk0f/ehHtWDBAsdTQZJ27dqlXC6nLVu2qFAo6Morr2TxdKhUKunjH/+44vG4ksmk3vrWt2rDhg0aGBjQsmXL9Pjjj2vjxo36zGc+43rUw4q32g2p1Wq69957dcEFF7geBQfZu3evVqxYoUsuuUTPPfec63Hwqm9961u68847tWnTJu3cudP1ODjID3/4Q5155pkKhUKuR4Gk3t5evfzyy8rlctqzZ4+6urpcj+S1cDism2++We95z3umv7dnzx4tW7ZMkrR06VLt3r3b1XgNwyuehtxzzz3q7+/XSy+95HoUHOS2227TokWLtG/fPl199dX69re/7Xok7+3cuVNDQ0N6+OGHdeDAAX384x/XnXfeqY6ODtej4VX333+/1q9f73oMvKqzs1O5XE4rVqzQyMiI/vqv/9r1SF5ra2tTW1vb674XDod/7ddzwdw7ohY1Ojqqn/3sZ3r729/uehQEWLRokSSpr69PRx11lEZGRhxPhO9973v68Ic/rFAopHnz5un000/XCy+84HosvOrpp5/W8ccfr3g87noUvGrz5s269NJL9eCDD+qxxx7Tzp07NTg46HosvMbUZwlm+nouYPE04u6779bPf/5zDQwM6Pbbb9fGjRv1/PPPux4Lku666y7t2rVL0uQ/EHbv3q3u7m7HU2HevHl65JFHJEnj4+N68skntXjxYsdTYcq3vvUtrVixwvUYeI2xsbHpRaZer2t8fNzxRDjYMccco+3bt0uSduzYMSd/pnGvdoO2bt2qRCLBp9qNeOmll3T99derWCyqUqnommuu4ZVpA8bGxnTdddfp5ZdfVq1W02WXXaazzz7b9VjQ5HNmw4YN+tKXvuR6FLxGNpvVJz/5SY2MjGhiYkIf+MAHtHLlStdjee1jH/uYXnrpJUUiEZ166qm68sortWbNGg0PD6uvr09r166dc+fisngCAACgKXirHQAAAE3B4gkAAICmYPEEAABAU7B4AgAAoClYPAEAANAULJ4AAABoChZPAAAANAWLJwAAAJqCxRMAAABNweIJAACApmDxBAAAQFOweALAITrzzDP19NNPv+H7O3fu1Jlnnvlb/dmDg4O6+OKLf6s/I8g555xz2P9MADhULJ4A8CasX7/+Dd/buHGjg0kAoHWweALAIWpra1MkEtGPf/zj6e898cQTisfjamtrczgZANjG4gkAb8JVV12lDRs2TH+9ceNGXXXVVQ4nAgD7WDwB4E04+eST1dXVpR07dmj79u2aN2+efv/3f/91v2f9+vU677zz9Jd/+Zf66Ec/qq1bt2rXrl1avny5xsfHtXz5cu3ates3Pla1WtXnPvc5feADH9CFF16op556Svv379d55503/XsuvfRS7dq1S//zP/+jFStWqL+/X9dcc42KxeJhP3YAeLOirgcAgFZ11VVX6YYbblC9XtdNN930ul/7j//4Dz333HPatm2bKpWKVq5cKUlasmSJzjjjDA0MDOiMM87QkiVLfuPjbN26VbVaTQ888ID27dunVatW6cEHH9SRRx6pZ599VgsXLtTIyIiWLFmij3zkI1qzZo1OPfVUfec739GmTZt0zTXXNOT4AeBQsXgCwJu0ZMkSHXnkkQqHwzr++ONf92u/+MUvdNZZZykcDqutrU1vf/vbp3/t/PPP19e//nWtW7duVo/z85//XE888YT6+/slSYVCQXv37lV/f7+2bdumxYsX6/3vf78k6fnnn9cXvvAFSVKtVtNRRx11OA4VAA4LFk8A+C184hOfCPz+CSecoO985zv64Ac/qGq1qieeeEJHH320JOnLX/6yPvKRj+jLX/6ybr/99t/4GCeeeKKOPPJIXX755RofH9dzzz2nt7zlLTriiCP0j//4j3rmmWd02223SZo8BeDGG2/U0UcfrT179iiVSh2+gwWA3xLneALAb+HYY4/Vscce+4bvL1u2TMcdd5zOO+88XXzxxeru7pYk/eAHP5Ak3XjjjarX63rooYfe8N/+9Kc/VX9/v/r7+3XHHXeov79fL774oj74wQ9q5cqV0+eFxmIxLV26VL29vert7ZUk3XDDDfr0pz+tCy64QJ///OeVz+cbdOQAcOhC9Xq97noIAAAAzH284gkAAICmYPEEAABAU7B4AgAAoClYPAEAANAULJ4AAABoChZPAAAANAWLJwAAAJqCxRMAAABN8X/oNZVdphA3+gAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 792x432 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "progress = pd.DataFrame(progression(pass_rates, num_game_rounds, num_players), columns=['max_level'])\n",
    "\n",
    "#This line creates the plot\n",
    "progress.groupby('max_level')['max_level'].count().plot(kind='bar')\n",
    "\n",
    "#These lines change the axis labels and improve readability of the xtick labels\n",
    "plt.xlabel('Max Level')\n",
    "plt.xticks(rotation=0)\n",
    "plt.ylabel('Number of Players')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What does this tell you about how players progress through the game? Are there any levels where players seem to get stuck and fail to progress? Do most of the players get through all 10 levels in 10 game rounds? Both of these could produce a negative experience for the player.\n",
    "\n",
    "Try changing the pass rates in levels_pass_rates, or num_game_rounds to see how that affects progression. What pass rates for each level would you recommend?"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.8"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}