From 13150ab8ae8c685087fe9e57f48096b4ab168602 Mon Sep 17 00:00:00 2001
From: adris <ninasoaresborges@gmail.com>
Date: Sun, 12 Nov 2023 09:57:46 +0000
Subject: [PATCH] Lab Done

---
 04_lab_Descriptive_Stats.ipynb.ipynb | 1739 ++++++++++++++++++++++++++
 README.md => data/README.md          |    0
 2 files changed, 1739 insertions(+)
 create mode 100644 04_lab_Descriptive_Stats.ipynb.ipynb
 rename README.md => data/README.md (100%)

diff --git a/04_lab_Descriptive_Stats.ipynb.ipynb b/04_lab_Descriptive_Stats.ipynb.ipynb
new file mode 100644
index 0000000..c751b35
--- /dev/null
+++ b/04_lab_Descriptive_Stats.ipynb.ipynb
@@ -0,0 +1,1739 @@
+{
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "0ox4s6gpBZKn"
+      },
+      "source": [
+        "# Understanding Descriptive Statistics\n",
+        "\n",
+        "Import the necessary libraries here:"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 1,
+      "metadata": {
+        "id": "-VTs7tbyBZKp"
+      },
+      "outputs": [],
+      "source": [
+        "import numpy as np\n",
+        "import matplotlib.pyplot as plt\n",
+        "from scipy.stats import pearsonr, spearmanr\n",
+        "from scipy import stats\n",
+        "import pandas as pd\n",
+        "import seaborn as sns\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "R-M0iGxnBZKp"
+      },
+      "source": [
+        "## Challenge 1\n",
+        "#### 1.- Define a function that simulates rolling a dice 10 times. Save the information in a dataframe.\n",
+        "**Hint**: you can use the *choices* function from module *random* to help you with the simulation."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "rKC1XN44BZKq"
+      },
+      "outputs": [],
+      "source": [
+        "import random\n",
+        "# used in class: np.random.randint(1, 7, size = 10)\n",
+        "\n",
+        "def dice_rolls():\n",
+        "  rand_dice_roll = random.choices(range(1, 7), k = 10)\n",
+        "  return rand_dice_roll\n",
+        "\n",
+        "dr = pd.DataFrame(dice_rolls())\n",
+        "dr = dr.rename(columns = {0: \"Dice_number\"})\n",
+        "dr"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "AZ2ecwB4BZKq"
+      },
+      "source": [
+        "#### 2.- Plot the results sorted by value."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "sorted_dr = dr.sort_values(by = \"Dice_number\")\n",
+        "sorted_dr\n",
+        "# hope the question is asking to order (ASC) by the value, and not by the order of the roll"
+      ],
+      "metadata": {
+        "id": "TRtxUmUoM3YV",
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 363
+        },
+        "outputId": "d623e7ea-9472-4b00-cf6a-dd6704cd78b3"
+      },
+      "execution_count": 3,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "   Dice_number\n",
+              "3            1\n",
+              "1            2\n",
+              "5            3\n",
+              "8            3\n",
+              "4            4\n",
+              "6            4\n",
+              "9            4\n",
+              "0            5\n",
+              "2            6\n",
+              "7            6"
+            ],
+            "text/html": [
+              "\n",
+              "  <div id=\"df-3f11b843-7189-47e7-8cf1-0c16237460f4\" class=\"colab-df-container\">\n",
+              "    <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>Dice_number</th>\n",
+              "    </tr>\n",
+              "  </thead>\n",
+              "  <tbody>\n",
+              "    <tr>\n",
+              "      <th>3</th>\n",
+              "      <td>1</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>1</th>\n",
+              "      <td>2</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>5</th>\n",
+              "      <td>3</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>8</th>\n",
+              "      <td>3</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>4</th>\n",
+              "      <td>4</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>6</th>\n",
+              "      <td>4</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>9</th>\n",
+              "      <td>4</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>0</th>\n",
+              "      <td>5</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>2</th>\n",
+              "      <td>6</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>7</th>\n",
+              "      <td>6</td>\n",
+              "    </tr>\n",
+              "  </tbody>\n",
+              "</table>\n",
+              "</div>\n",
+              "    <div class=\"colab-df-buttons\">\n",
+              "\n",
+              "  <div class=\"colab-df-container\">\n",
+              "    <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-3f11b843-7189-47e7-8cf1-0c16237460f4')\"\n",
+              "            title=\"Convert this dataframe to an interactive table.\"\n",
+              "            style=\"display:none;\">\n",
+              "\n",
+              "  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\" viewBox=\"0 -960 960 960\">\n",
+              "    <path d=\"M120-120v-720h720v720H120Zm60-500h600v-160H180v160Zm220 220h160v-160H400v160Zm0 220h160v-160H400v160ZM180-400h160v-160H180v160Zm440 0h160v-160H620v160ZM180-180h160v-160H180v160Zm440 0h160v-160H620v160Z\"/>\n",
+              "  </svg>\n",
+              "    </button>\n",
+              "\n",
+              "  <style>\n",
+              "    .colab-df-container {\n",
+              "      display:flex;\n",
+              "      gap: 12px;\n",
+              "    }\n",
+              "\n",
+              "    .colab-df-convert {\n",
+              "      background-color: #E8F0FE;\n",
+              "      border: none;\n",
+              "      border-radius: 50%;\n",
+              "      cursor: pointer;\n",
+              "      display: none;\n",
+              "      fill: #1967D2;\n",
+              "      height: 32px;\n",
+              "      padding: 0 0 0 0;\n",
+              "      width: 32px;\n",
+              "    }\n",
+              "\n",
+              "    .colab-df-convert:hover {\n",
+              "      background-color: #E2EBFA;\n",
+              "      box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
+              "      fill: #174EA6;\n",
+              "    }\n",
+              "\n",
+              "    .colab-df-buttons div {\n",
+              "      margin-bottom: 4px;\n",
+              "    }\n",
+              "\n",
+              "    [theme=dark] .colab-df-convert {\n",
+              "      background-color: #3B4455;\n",
+              "      fill: #D2E3FC;\n",
+              "    }\n",
+              "\n",
+              "    [theme=dark] .colab-df-convert:hover {\n",
+              "      background-color: #434B5C;\n",
+              "      box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
+              "      filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
+              "      fill: #FFFFFF;\n",
+              "    }\n",
+              "  </style>\n",
+              "\n",
+              "    <script>\n",
+              "      const buttonEl =\n",
+              "        document.querySelector('#df-3f11b843-7189-47e7-8cf1-0c16237460f4 button.colab-df-convert');\n",
+              "      buttonEl.style.display =\n",
+              "        google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
+              "\n",
+              "      async function convertToInteractive(key) {\n",
+              "        const element = document.querySelector('#df-3f11b843-7189-47e7-8cf1-0c16237460f4');\n",
+              "        const dataTable =\n",
+              "          await google.colab.kernel.invokeFunction('convertToInteractive',\n",
+              "                                                    [key], {});\n",
+              "        if (!dataTable) return;\n",
+              "\n",
+              "        const docLinkHtml = 'Like what you see? Visit the ' +\n",
+              "          '<a target=\"_blank\" href=https://colab.research.google.com/notebooks/data_table.ipynb>data table notebook</a>'\n",
+              "          + ' to learn more about interactive tables.';\n",
+              "        element.innerHTML = '';\n",
+              "        dataTable['output_type'] = 'display_data';\n",
+              "        await google.colab.output.renderOutput(dataTable, element);\n",
+              "        const docLink = document.createElement('div');\n",
+              "        docLink.innerHTML = docLinkHtml;\n",
+              "        element.appendChild(docLink);\n",
+              "      }\n",
+              "    </script>\n",
+              "  </div>\n",
+              "\n",
+              "\n",
+              "<div id=\"df-51f933ad-b5e6-4207-b672-9480561af23f\">\n",
+              "  <button class=\"colab-df-quickchart\" onclick=\"quickchart('df-51f933ad-b5e6-4207-b672-9480561af23f')\"\n",
+              "            title=\"Suggest charts\"\n",
+              "            style=\"display:none;\">\n",
+              "\n",
+              "<svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n",
+              "     width=\"24px\">\n",
+              "    <g>\n",
+              "        <path d=\"M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zM9 17H7v-7h2v7zm4 0h-2V7h2v10zm4 0h-2v-4h2v4z\"/>\n",
+              "    </g>\n",
+              "</svg>\n",
+              "  </button>\n",
+              "\n",
+              "<style>\n",
+              "  .colab-df-quickchart {\n",
+              "      --bg-color: #E8F0FE;\n",
+              "      --fill-color: #1967D2;\n",
+              "      --hover-bg-color: #E2EBFA;\n",
+              "      --hover-fill-color: #174EA6;\n",
+              "      --disabled-fill-color: #AAA;\n",
+              "      --disabled-bg-color: #DDD;\n",
+              "  }\n",
+              "\n",
+              "  [theme=dark] .colab-df-quickchart {\n",
+              "      --bg-color: #3B4455;\n",
+              "      --fill-color: #D2E3FC;\n",
+              "      --hover-bg-color: #434B5C;\n",
+              "      --hover-fill-color: #FFFFFF;\n",
+              "      --disabled-bg-color: #3B4455;\n",
+              "      --disabled-fill-color: #666;\n",
+              "  }\n",
+              "\n",
+              "  .colab-df-quickchart {\n",
+              "    background-color: var(--bg-color);\n",
+              "    border: none;\n",
+              "    border-radius: 50%;\n",
+              "    cursor: pointer;\n",
+              "    display: none;\n",
+              "    fill: var(--fill-color);\n",
+              "    height: 32px;\n",
+              "    padding: 0;\n",
+              "    width: 32px;\n",
+              "  }\n",
+              "\n",
+              "  .colab-df-quickchart:hover {\n",
+              "    background-color: var(--hover-bg-color);\n",
+              "    box-shadow: 0 1px 2px rgba(60, 64, 67, 0.3), 0 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
+              "    fill: var(--button-hover-fill-color);\n",
+              "  }\n",
+              "\n",
+              "  .colab-df-quickchart-complete:disabled,\n",
+              "  .colab-df-quickchart-complete:disabled:hover {\n",
+              "    background-color: var(--disabled-bg-color);\n",
+              "    fill: var(--disabled-fill-color);\n",
+              "    box-shadow: none;\n",
+              "  }\n",
+              "\n",
+              "  .colab-df-spinner {\n",
+              "    border: 2px solid var(--fill-color);\n",
+              "    border-color: transparent;\n",
+              "    border-bottom-color: var(--fill-color);\n",
+              "    animation:\n",
+              "      spin 1s steps(1) infinite;\n",
+              "  }\n",
+              "\n",
+              "  @keyframes spin {\n",
+              "    0% {\n",
+              "      border-color: transparent;\n",
+              "      border-bottom-color: var(--fill-color);\n",
+              "      border-left-color: var(--fill-color);\n",
+              "    }\n",
+              "    20% {\n",
+              "      border-color: transparent;\n",
+              "      border-left-color: var(--fill-color);\n",
+              "      border-top-color: var(--fill-color);\n",
+              "    }\n",
+              "    30% {\n",
+              "      border-color: transparent;\n",
+              "      border-left-color: var(--fill-color);\n",
+              "      border-top-color: var(--fill-color);\n",
+              "      border-right-color: var(--fill-color);\n",
+              "    }\n",
+              "    40% {\n",
+              "      border-color: transparent;\n",
+              "      border-right-color: var(--fill-color);\n",
+              "      border-top-color: var(--fill-color);\n",
+              "    }\n",
+              "    60% {\n",
+              "      border-color: transparent;\n",
+              "      border-right-color: var(--fill-color);\n",
+              "    }\n",
+              "    80% {\n",
+              "      border-color: transparent;\n",
+              "      border-right-color: var(--fill-color);\n",
+              "      border-bottom-color: var(--fill-color);\n",
+              "    }\n",
+              "    90% {\n",
+              "      border-color: transparent;\n",
+              "      border-bottom-color: var(--fill-color);\n",
+              "    }\n",
+              "  }\n",
+              "</style>\n",
+              "\n",
+              "  <script>\n",
+              "    async function quickchart(key) {\n",
+              "      const quickchartButtonEl =\n",
+              "        document.querySelector('#' + key + ' button');\n",
+              "      quickchartButtonEl.disabled = true;  // To prevent multiple clicks.\n",
+              "      quickchartButtonEl.classList.add('colab-df-spinner');\n",
+              "      try {\n",
+              "        const charts = await google.colab.kernel.invokeFunction(\n",
+              "            'suggestCharts', [key], {});\n",
+              "      } catch (error) {\n",
+              "        console.error('Error during call to suggestCharts:', error);\n",
+              "      }\n",
+              "      quickchartButtonEl.classList.remove('colab-df-spinner');\n",
+              "      quickchartButtonEl.classList.add('colab-df-quickchart-complete');\n",
+              "    }\n",
+              "    (() => {\n",
+              "      let quickchartButtonEl =\n",
+              "        document.querySelector('#df-51f933ad-b5e6-4207-b672-9480561af23f button');\n",
+              "      quickchartButtonEl.style.display =\n",
+              "        google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
+              "    })();\n",
+              "  </script>\n",
+              "</div>\n",
+              "    </div>\n",
+              "  </div>\n"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 3
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "plt.plot(sorted_dr[\"Dice_number\"].values)\n",
+        "plt.show()"
+      ],
+      "metadata": {
+        "id": "fNqInSPYOtDR",
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 430
+        },
+        "outputId": "7da9c211-8f24-4765-ffac-ad4eddc646cf"
+      },
+      "execution_count": 4,
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 640x480 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "xX_cYa02BZKq"
+      },
+      "source": [
+        "#### 3.- Calculate the frequency distribution and plot it. What is the relation between this plot and the plot above? Describe it with words."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 5,
+      "metadata": {
+        "id": "907PSs_KBZKr",
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 449
+        },
+        "outputId": "a4ba3d86-2220-4f9f-d726-4e3194b3431d"
+      },
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 640x480 with 1 Axes>"
+            ],
+            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAioAAAGwCAYAAACHJU4LAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABlyElEQVR4nO3dd3iUZboG8Pubmt4L6YXeCSABXQvqilixF9zFtnvcxcrqrrhHXY+rqKuudVl1rXvEckREsa0VsCT03kkghfSemWTqd/6Y+SYJBJJJZvKVuX/XlescwjDzrITJk/e93+cVRFEUQURERKRAOrkLICIiIjoeNipERESkWGxUiIiISLHYqBAREZFisVEhIiIixWKjQkRERIrFRoWIiIgUyyB3AYPhdrtx5MgRREdHQxAEucshIiKifhBFEW1tbUhPT4dOd+I1E1U3KkeOHEFWVpbcZRAREdEAlJeXIzMz84SPUXWjEh0dDcDzPzQmJkbmaoiIiKg/WltbkZWV5fs+fiKqblSk7Z6YmBg2KkRERCrTn9gGw7RERESkWGxUiIiISLHYqBAREZFisVEhIiIixWKjQkRERIrFRoWIiIgUi40KERERKRYbFSIiIlIsNipERESkWGxUiIiISLFkb1QqKytx3XXXITExEeHh4Zg4cSI2bNggd1lERESkALLe9dPU1IRTTjkFs2fPxueff47k5GTs378f8fHxcpZFRERECiFro/L4448jKysLr7/+uu9zeXl5MlZEStXpcMGo10Gv6/sCKyJSJ1EU4XCJMBlkX+wnBZH1q+Hjjz/G9OnTccUVVyAlJQUFBQV45ZVXjvt4m82G1tbWHh+kfW2dDvzi8e9wzStFcpdCREH08poSjL7/c/x4oF7uUkhBZG1USkpKsHTpUowcORJffvklfve73+H222/Hm2++2evjlyxZgtjYWN9HVlbWEFdMcthS3oz6dhvWlTbCanfKXQ4RBYHD5cYra0sgisCKzZVyl0MKImuj4na7MXXqVDz66KMoKCjAb3/7W/zmN7/BP//5z14fv3jxYrS0tPg+ysvLh7hiksOuI10rZ6X1FhkrIaJgWbOvDvXtdgBAUUmDzNWQksjaqKSlpWHcuHE9Pjd27FiUlZX1+niz2YyYmJgeH6R9u6rYqBBp3fJNFb7/v6KpAxVNVhmrISWRtVE55ZRTsHfv3h6f27dvH3JycmSqiJSox4pKHRsVIq1pttrx9a5aAEBytBkAUFzSKGdJpCCyNip33XUXioqK8Oijj+LAgQNYtmwZXn75ZSxcuFDOskhBOh0ulHRbReGKCpH2fLL1COwuN8alxeCyqZkAuP1DXWRtVE466SSsWLEC77zzDiZMmICHH34YzzzzDObPny9nWaQg+2ra4HKLvl+XsFEh0pwPNnq2fS6blomZ+QkAgOJSrqiQh6xzVADgggsuwAUXXCB3GaRQ0rZPSrQZtW02lNS1QxRFCALnqRBpwf6aNmytaIFBJ+DiKekIM+qh1wkoa7SisrkDGXHhcpdIMuNUHVK03d4g7ZzxwwAArZ1ONFrscpZERAH0gTdEe8boFCRFmRFlNmBCRiwAoJjbPwQ2KqRw0omfqTlxvp+smFMh0gaXW8RH3pkpl0/L8H1+Zp53+4eBWgIbFVIwt1vE7qo2AMC4tFjkJ0cCYE6FSCvW7q9DTasN8RFGnDkm1ff5mfmJAICiUq6oEBsVUrDyJivabU6YDDrkJ0ciL8nTqHBFhUgblm/yrKZcNDm9x/0+03PjoROAww1WVLV0yFUeKQQbFVIsKZ8yKjUKRr2uq1HhLBUi1WvpcOA/O6sBAJdP63kdSnSYsVtOhds/oY6NCimWdOJnXJpnArHUqJTUt8tWExEFxqfbqmBzujEqNQoTMo6dMu7b/mGgNuSxUSHFkoK0UqOSnxQFADjUYO0xW4WI1EcamX/Z1Mxexw0U5nGeCnmwUSHFkoK0Y72NSkZ8OEx6HexON440c9+aSK1K6tqx8XATdAJwSUFGr4+ZnpsAneDJpFW3dA5xhaQkbFRIkZqtdlR6m5Gx6Z5GRa8TkJMYAYCBWiI1+9Aboj1tVDJSYsJ6fUxsuBHj0705FZ7+CWlsVEiRpG2frIRwxIQZfZ/nyR8idXO7RXzo3fa5fFrmCR8rbf8UMVAb0tiokCIdHaSV5CWzUSFSs59LGnCkpRMxYQacPTb1hI+VArWcUBva2KiQIh2dT5Hke1dUDtbx5A+RGi33XkB44WTPvT4nclJeAgTBM+SxtpU5lVDFRoUU6egTP5I878kfrqgQqU+7zYnPd3hmp1zWx7YP4MmpSO8BRTz9E7LYqJDi2J1uHKj1js5PP2pFxbv1U9ncgU6Ha8hrI6KB+2x7FTocLuQnRaIgK65ff4bzVIiNCinOgdp2OFwiYsIMx1zxnhhpQnSYAaIIlDVaZaqQiAbiA++2z2XTep+d0hvfPBU2KiGLjQopjrTtMzYt5pg3M0EQfDmVEo7SJ1KNsgYr1pU2QhCAS6f2PjulNzO8OZWDdRbUtjGnEorYqJDi+E78pB87VhvgEWUiNZIm0f5iRBLSYsP7eHSXuAgTxg7zvBfw3p/QxEaFFGdXVQuAY4O0EilQW8KTP0Sq4HaL+HBz18h8fxXmS+P0uf0TitiokKKIonjco8kSzlIhUpf1hxpR3tiBKLMBc8YP8/vPdwVquaISitiokKIcaelES4cDBp2AkalRvT4mn1s/RKoihWjPn5iGcNOJZ6f0ptCbUzlQ2466NlugyyOFY6NCiiLlU0akRMFs6P0NTcqoNFjsaLE6hqw2IvKf1e7EZ9urAPRvdkpv4iJMGJ0aDQBYx3kqIYeNCinK7uMMeusu0mxAaowZAFDawFUVIiX7Ykc1LHYXshMicFJu/ICfh/NUQhcbFVKUvk78SPJ8R5QZqCVSMum0z2VT+z87pTczGagNWWxUSFGONzr/aBylT6R8lc0d+Omgp7HwZ3ZKb2bkeVZU9tW0o76dOZVQwkaFFKOt0+GbNnu8Ez+S4d6TPyVsVIgUa8WmCoiiZzUkKyFiUM+VEGnCmGHMqYQiNiqkGHuqPceS02LDEB9pOuFjfUPfOJ2WSJFEUcTyTZUAgMunZQXkOTlOPzSxUSHF8OVT+lhNAXpOpxVFMah1EZH/NpU1obTeggiTHnMn+D87pTecpxKa2KiQYvQ3SAsAWQkR0OsEdDhcqGnlfjWR0nyw0bOacu6EYYg0GwLynDO8Kyp7a9rQaLEH5DlJ+diokGLsru66jLAvRr0O2d49b578IVKWTocLq7YeAQBcPsDZKb1JjDJjlHcQ5Dqe/gkZbFRIEZwuty+j0p+tH6DbEWUGaokU5T+7atBmcyIjLhwzvad1AoXbP6GHjQopQkm9BXanG5EmvW+lpC8cpU+kTNLI/MumZkCnG/jslN4U5nHwW6hho0KKIOVTxqbF9PuNjZcTEilPdUsnfthfBwC4dAA3JfdFukl5T3UbmphTCQlsVEgRpNH5/cmnSPK4okKkOCs2V8ItAiflxiPX+280kJKizBiZ4smpFHOeSkhgo0KK4JtI248TP5J873TaskYrHC53UOoiov7zzE7pGpkfLIUcpx9S2KiQ7ERR9GuGiiQ1xoxwox4ut+ibaEtE8tlW0YIDte0wG3Q4b1Ja0F6HgdrQwkaFZFfXZkODxQ6dAIz2jsjuD0EQOKGWSEGkEO25E4YhJswYtNeR5qnsqW5Fs5U5Fa1jo0Ky2+nd9slPjkKYUe/Xn81noJZIEWxOFz72zk4J5rYPAKREh2F4ciREkff+hAI2KiS7gWz7SPI5S4VIEb7ZXYuWDgeGxYThlBFJQX89bv+EDjYqJLuBBGklXUeUOZ2WSE7Lvds+l0zNgD7As1N6U+htVBio1T42KiS7gRxNluR5T/5w64dIPnVtNny/zzM7JdjbPpKZ3pzKrqpWtFgdQ/KaJA82KiQrq93pazIGsvWTl+hZUalptaHd5gxobUTUPyu3VMLlFjElKw4jvDNOgi0lJgz5Uk7lELd/tIyNCslqT3UbRBFIjjYjOdrs95+PjTAiMdIEADjEVRWiISeKYtfI/ABeQNgf0jj9Yo7T1zQ2KiSrwWz7SKSTPwzUEg29nUdasae6DSa9DhdNSh/S157pHfxWxJyKprFRIVkN5sSPhLNUiOQjTaL95bhUxEYEb3ZKb6STP7uOtKKlgzkVrWKjQrIazIkfSVeglid/iIaS3enGyi2e2SmXD/G2DwCkxoQhLykSbhHYwJyKZrFRIdm43CL2VLUBCNCKCrd+iIbU93tr0WixIznajFNHBn92Sm982z/MqWgWGxWSzeEGCzocLoQZdb5mYyB8GZU6C0RRDFR5RNQHKUR7SUEGDHp5vp34ArWcUKtZbFRINtK2z+hhMYMaEJWTGAFBANpsTtS3894PoqHQaLHju721AIZudkpvpJuUd1S2oLWTORUtYqNCsglEkBYAzAY9MuPDAXD7h2iofLylEg6XiAkZMX5dJhpoabHhyEmMgFsENh5qkq0OCh42KiQb6WjyuLTBv8kxUEs0tD7wnva5XMbVFMnMPOneH+ZUtIiNCskmECd+JLyckGjo7KluxY7KVhj1Ai6akiF3OZg5nIFaLWOjQrKob7ehptUGQfBkVAZLCuOWcJYKUdBJFxCeOSYFCd7J0HKSArU7jrSijTkVzWGjQrKQtn1yEyMRZTYM+vl4RJloaDhdbqzY7JmdImeItrv0uHBkJ0TA5Rax4TBzKlrDRoVk0TU6PzAhPOmI8uEGC1xuHlEmCpY1++tQ325DYqQJs8ekyF2OD+epaBcbFZJFoE78SNJjw2Ey6OBwiahs6gjIcxLRsZZvrAQAXDQlHUaZZqf0puuCQs5T0RrlfJVRSAlkkBYAdDoBeYlSoJYnf4iCocXqwFe7agAoZ9tHIs1T2V7ZgnabU+ZqKJDYqNCQ63S4cNAbeh3MrclHY06FKLg+3nYEdpcbY4ZFY3yAfsgIlMz4CGTGh8PlFrGRORVNkbVR+ctf/gJBEHp8jBkzRs6SaAjsr2mHyy0iPsKIYTFhAXvevGSe/CEKJum0z+XTMiEIA58mHSzSbcrMqWjL4I9bDNL48ePx9ddf+35tMMheEgBAFEV0OFyIMCmjHi3ZVdUCwLPtE8g3O66oEAXPgdp2bClvhl4n4GIFzE7pzcz8RHywsYKNisbI/l3YYDBg2LBh/XqszWaDzWbz/bq1tTUoNa3cUom/frobs0cn44nLJwflNUJZoIO0kuHJbFSIgmW5dxLtGaOSkRxtlrma3hXmeXMqFS2w2JyIDMDoA5Kf7BmV/fv3Iz09Hfn5+Zg/fz7KysqO+9glS5YgNjbW95GVlRWUmmLDjahrs6GI6fGg2F3VBiCw+RSga4x+ZXMHOh2ugD43UShzuUV8uKlr20epshIikBEXDidzKpoia6NSWFiIN954A1988QWWLl2K0tJSnHrqqWhra+v18YsXL0ZLS4vvo7y8PCh1Tc9NgF4noKzRiiPNPOoaSG63GPATP5L4CCNiw40AgEMNXFUhCpQfD9SjptWG2HAjzhyrnNkpvWFORXtkbVTmzp2LK664ApMmTcKcOXPw2Wefobm5Ge+//36vjzebzYiJienxEQxRZgMmZMQCAIpL+cUeSBVNHWi3OWHS6zA8OSqgzy0IQldOhYFaooD5wBuivWhyOswGvczVnJh0TLm4lCviWiH71k93cXFxGDVqFA4cOCB3KZjp3essOsgv9kCSVlNGpkYFZVgULyckCqzWTge+3FkNQNnbPpJZ3hWVreXNsNo5T0ULFNWotLe34+DBg0hLS5O7lK7lQ66oBJRv2yfA+RQJLyckCqzPtlXB5nRjREoUJmXGyl1OnzLjw5EeGwanW8Smw81yl0MBIGujcvfdd2P16tU4dOgQfvrpJ1xyySXQ6/W45ppr5CwLADA9Nx46ATjcYEVVC3MqgeI78ROkYVH53u2kUk6nJQqIDxQ+O+VogiAwp6IxsjYqFRUVuOaaazB69GhceeWVSExMRFFREZKTk+UsCwAQHWbsyqnw9E/A7B6iFRUeUSYavEP1Fmw43ASdAFxSoMzZKb1ho6Itsh4yf/fdd+V8+T7NzE/EtooWFJc2YJ6K/pEqVYvVgUrvKaoxQWpUcpMiAABNVgeaLHbER5qC8jpEoUCanXLqyGSkBnCKdLBJgdqtFc3osLsQblJ2AJhOTFEZFaXpujacKyqBIOVTMuPDfceIAy3CZEBarOcNtZRHlIkGzO0W8eEmz03Jl6kgRNtddkIE0mLD4HCJ2FTGeSpqx0blBKbnJkAneLYRalo75S5H9YIdpJUwUEs0eEUlDahs7kB0mAHnjEuVuxy/CILgm1LL7R/1Y6NyAjFhRoxP9+RU+MU+eFI+JdATaY+W7xulz0At0UB94N32uWBSOsKM6ts6kXIqzBiqHxuVPnR15fxiH6xgn/iRSKP0GaglGhiLzYkvdkizU9SZz5MalS3lzbxSQ+XYqPShqyvnispg2J1u7K/1XI0Q7K2ffG79EA3KZ9urYLW7kJcUianZ8XKXMyA5iRFIjTHD7nIzp6JybFT6cFJeAgTBM+m0ljmVATtQ2w6HS0R0mAGZ8eFBfS0po3KowQK3WwzqaxFpkXTa57KpGaqYndKbnvNUuCKuZmxU+hAbbvStABTx7ogB655PCfYbX2Z8OAw6AZ0ON6rYXBL5pbzRiqKSRggCcMlUdZ32ORrnqWgDG5V+4PbP4A3ViR8AMOh1yE70zFPh5YRE/pGOJJ88PBEZccFd/Qw2KWPInIq6sVHpB3blgzdUQVpJfhJH6RP5SxTFbts+6l5NATzbwCnRZtidbmwua5a7HBogNir9MCPXk1M5WGdBbRu3EvwliiJ2Vw/digrQdUSZtygT9d/6Q00oa7Qi0qTHuROGyV3OoAmCgEJpRZwXzKoWG5V+iI0wYuwwzzfYdcyp+K2qpRPNVgcMOgEjUqKG5DV55w+R/5Z7LyA8b2IaIkyy3rASMF0TxtmoqBUblX4q5Bf7gEnbPiNSooZscBQbFSL/dNhd+HR7FQDPTclaIW3dbypjTkWt2Kj0E6ccDtxQBmkl0iyV8kYrbE6+ORH15cud1Wi3OZGVEI6TchPkLidg8pMikRTlyalsLW+WuxwaADYq/VTonaeyv7Yd9e02uctRlaEand9dcrQZkSY93KKnWSGiE/tgY1eIVqdT5+yU3njmqXDCuJqxUemnuAgTRqdGA+Cqir98KypDdOIH8Lw55Sd78jCcUEt0YkeaO/DjwXoA2jjtczSe3FQ3Nip+mMn0uN/aOh043OBZ0RjKFRWAORWi/lqxuRKiCMzIS0BWQoTc5QSctKKyqayJW8EqxEbFD+zK/be32nO/z7CYMCREmob0tdmoEPVNFEXfaR8thWi7G54chaQoE2xON7aWt8hdDvmJjYofZninHO6raUcDcyr9Ise2j4SzVIj6trm8GSX1FoQb9ThvYprc5QSFIAgozOOEcbVio+KHhEgTxgzz5FQ4T6V/fBNph3jbB+haUWFGhej4pBDt3AnDEGXWxuyU3vgCtdy6Vx02Kn6S7o7g9k//yLmiIjUq9e02tHY6hvz1iZSu0+HCJ1uPAAAu0+i2j0Taut94uAl2p1vmasgfbFT81BWo5YpKX5wuty+jMtRBWgCIDjMiOdoMADjE7R+iY3y1qwZtnU6kx4Zhlve9TatGpEQhMdKETocb2yqa5S6H/MBGxU9STmVPdRsaLXaZq1G20noLbE43Ikx65Mh0koCBWqLjky4gvFRjs1N647n3hyviasRGxU+JUWaMSvXM51jHvc4T2tVt0Jtcb4L5zKkQ9aqmtRNr9tUBAC6dmiFzNUOj6+QmV8TVhI3KAPCLvX+6GpVo2WrgigpR7z7aXAm3CEzLifcNR9Q66eQPcyrqwkZlAKQvdi4fnljXiZ9Y2Wrwnfypb5etBiKlEUXRt+2jxUm0xzMyJQoJkSZ0OFzYXtksdznUT2xUBkDa59xT3YYm5lR6JYpiV6Miw4kfifSTYmmdBaIoylYHkZJsr2zBvpp2mA06nD9Jm7NTeqPTCZiRy3t/1IaNygAkRZkxMsWbUznEL/be1LXZ0GCxQyfAd0eSHLITIqATAIvdhbo2DukjAuCbRHvO+GGIDTfKXM3QmslAreqwURkgpsdPTMqn5CVFItykl60Ok0Hnu7uEE2qJAJvThZXe2SlaHZl/IjOHd+VUHC7mVNSAjcoA+eapcPmwV12D3uTLp0gYqCXq8t2eWjRbHUiNMeMXI5LkLmfIjUqJRlyEEVa7C9sree+PGrBRGSApULu7uhXNVuZUjibn6PyjdY3SZ6CWSBqZP68gA3qNz07pjU4ncMK4yrBRGaDkaDOGJ0dCFHnvT292K+BosiSfKypEADzZse/2emanXB5Cp32O1nVBId+71YCNyiBwnH7vrHanLw8i54kfiXTyhxkVCnUrt1TC5RYxOTMWI2UMuctNeu/ecKiRORUVYKMyCIX5nKfSm73VbRBFz+molOgwucvxbf2UNVjh5JsShbDlmyoBhGaItrsxw6IRG26Exe7CDuZUFI+NyiDM9O5z7qpqRUsHb+eVyHljcm+GxYQhzKiD0y2ioqlD7nKIZLHzSAt2V7XCpNfhwsnpcpcjK51O8N3bxhVx5WOjMggpMWHI9+ZU1vOL3UdJ+RTA86aUm8icCoW25Rs9qylnj0tBXIRJ5mrkN5Mr4qrBRmWQOE7/WEo68SPJT/Y0Kgd58odCkMPlxsotnkYllEbmn4g0+G19aSO3hBXOr0bF6XTirbfeQk1NTbDqUR3pi53Lhx5ut4g91W0AgPEK2foBOEuFQtv3e+vQYLEjKcqE00Yly12OIowZFoOYMAMsdhd2en+4ImXyq1ExGAy45ZZb0NnZGax6VEdaPtx5pIU5FQCHG62w2l0wG3S+7RYlyE/y3vnDRoVCkDQyf96UDBj1XEgHAL1OwAyuiKuC31+xM2bMwJYtW4JQijqlxoQhLykSbtFz1C3USds+Y4ZFw6CgN8S8ZK6oUGhqstjxzR7PKvhlIX7a52hcEVcHg79/4Pe//z0WLVqE8vJyTJs2DZGRPX9qnjRpUsCKU4uZ+QkorbeguLQRZ41NlbscWe2q8hz1U8qJH4k09K2qpRNWuxMRJr+/9IlU6eOtR+BwiRifHoOxCsqNKYG0Ii7lVJT0wxV18fvd+uqrrwYA3H777b7PCYIAURQhCAJcLlfgqlOJwrxEvLOunMuHUGaQFgDiIkyIjzCiyerAoXqr4hopomBZvsmz7cMQ7bHGpsUgOsyAtk4ndlW1YlJmnNwlUS/8blRKS0uDUYeqSTcp76hsQVunA9FhoXVtene7qzxBWiX+5JaXFImmsmaU1LezUaGQsK+mDdsqWmDQCbh4SmjPTumNXidgRm4CvtlTi+KSRjYqCuV3o5KTkxOMOlQtLTYcuYkRONRgxYZDTZg9JkXukmTR0G5DdasnaD1GkY1KFDaVNaO0jjkVCg1SiHb2mBQkRpllrkaZZuYn4ps9tSgqacBvTsuXuxzqxYA25P7973/jlFNOQXp6Og4fPgwAeOaZZ7By5cqAFqcmnKfStZqSmxiBKLPyMiD5DNRSCHG63PhwM2en9EXKqawrbYTLLcpcDfXG70Zl6dKlWLRoEc477zw0Nzf7MilxcXF45plnAl2faswc7r02PITT41KQVonbPkBXoJaXE1IoWHugHnVtNsRHGHFmiK7y9se49BhEmw1oszl9U7VJWfxuVJ5//nm88sor+POf/wy9Xu/7/PTp07F9+/aAFqcm0oqKlFMJRdKKitKCtBLpiHJJXTtEkT85kbZ94N32uXhKBkwGnmY5Hr1OwEnee39CeUVcyfz+6i0tLUVBQcExnzebzbBYQvcn1fS4cGQnRMDlFrHhcJPc5cjCd+JHoUFVaQBda6cTTdbQbCYpNLRYHfhql2d2SqjflNwfhb5GJXRXxJXM70YlLy+v14FvX3zxBcaOHRuImlTLNzwoBL/YOx0uHPDeo6PUrZ8wox4ZceEAPKsqRFq1avsR2J1ujE6NVtRVFkrVlVNpYE5FgfxuVBYtWoSFCxfivffegyiKWLduHR555BEsXrwYf/zjH4NRo2qEcqD2QG07XG4RcRFGpMWGyV3OcUmBWuZUSMukbZ/Lp2VCEASZq1G+8ekxiDIb0NrJnIoS+X004+abb0Z4eDj++7//G1arFddeey3S09Px7LPP+obBhSppnsr2yhZYbE5EKvDkS7B0H/Sm5DfGvKRIrN1fz5M/pFkH69qxuawZep2Aiws4O6U/DHodpufG4/u9dSgubcSEjFi5S6JuBpSwmj9/Pvbv34/29nZUV1ejoqICN910U6BrU53M+AhkJYSHZE5lV5UyJ9IezXeLMmepkEZJs1NOG5mElGjlrm4qjbT9E4or4ko34Ch4bW0tNm7ciL1796Kuri6QNalaqG7/SCsqSs2nSHyNCldUSINcbhErvLNTLp+WJXM16iIFateVNsLNnIqi+N2otLW14Ve/+hXS09Nx+umn4/TTT0d6ejquu+46tLS0BKNGVZG68uIQalREUfTt6yr1xI8kPykKAFDaYGFojjTnp4P1qGrpREyYAWeN5ewUf0zIiEWkSY+WDgf2VLfJXQ5143ejcvPNN6O4uBiffvopmpub0dzcjFWrVmHDhg34r//6r2DUqCpSV76togVWu1PmaoZGRVMH2mxOmPQ6DE+OkrucE8qID4dJr4Pd6caR5g65yyEKKGnb56Ip6Qgz6vt4NHVn1OswPZfzVJTI70Zl1apVeO211zBnzhzExMQgJiYGc+bMwSuvvIJPPvkkGDWqSlZCBDLiwuF0i9gYIjmVnd5tnxEpUYofLKXXCchJjADA7R/SlrZOB77YWQ2AI/MHSjoQUVzKRkVJ/P6ukpiYiNjYYxPRsbGxiI+PD0hRahdqoSy1bPtImFMhLfpsexU6HW4MT47ElKw4uctRJd/WPXMqiuJ3o/Lf//3fWLRoEaqrq32fq66uxj333IP7779/wIU89thjEAQBd95554CfQymkrjxUphyq5cSPJI+XE5IGLd/ovYCQs1MGbGJGLCJMejRbHdhbw5yKUvRr0EdBQUGPL/z9+/cjOzsb2dnZAICysjKYzWbU1dUNKKeyfv16vPTSS5g0aZLff1aJZnm78m0VzbDanYgwaXueitJH5x+NlxOS1hxusGDdoUYIAnBJQYbc5aiWUa/DtJx4rN1fj+KSBsWfYhwKDpcbRr28W/r9+g46b968oBXQ3t6O+fPn45VXXsFf//rXEz7WZrPBZrP5ft3aqswJgpnx4ciIC0dlcwc2HW7GL0YmyV1S0LRYHaj0hlLHDlPHP+o878kfjtEfuHfXlaG03oK754yW/U2MuibR/mJEEtJiw2WuRt1m5idi7f56FJU04vpT8uQuR1aH6i2Y/69i3H/BOJw7YZhsdfSrUXnwwQeDVsDChQtx/vnn4+yzz+6zUVmyZAkeeuihoNUSKIIgoDAvAR9urkRRSYOmG5Xd1Z5mMSMuHLERRpmr6R8po1LZ3IFOh4unI/xktTtx/8odcLhEQAAWzw3tO77ktre6Da+sLQEAXDGds1MGS7qzbd0hT05FpwvNbTSb04Vb39mEyuYOvPZDKc4Zlyrbf4tB/SjU3t6O1tbWHh/+ePfdd7Fp0yYsWbKkX49fvHgxWlpafB/l5eUDKXtIdIWytB2oVdu2DwAkRZkQHWaAKAJljVa5y1GdjYebPE0KgJdWl+C7PbUyVxS6rHYnFi7bhE6HG6eNSsYFE9PkLkn1JmbEIdyoR6PFjv21obvq+uinu7GjshXxEUY8e80UWRs2vxuV0tJSnH/++YiMjPSd9ImPj0dcXJxfp37Ky8txxx134O2330ZYWP/GPJvNZt+RaOlDqaRA7ZbyZnTYXTJXEzxSkFZNe7mCIHTlVDhK32/S7eBhRs/bx6L3t6CqhTNp5PDAyp04UNuOlGgznr5ycsj+9B9IJoPn3h8gdE5uHu3z7VV48+fDAICnr5wi+3ai3ynP6667DqIo4rXXXkNqauqA0+UbN25EbW0tpk6d6vucy+XCmjVr8MILL8Bms0GvV++SfHZCBNJiw1DV0onNZU04eYQ2t392q+zEjyQvKRJbK1p48mcApDfvP583Fu+uL8fOI624450tWPabQhiYVxkyyzdW4IONFdAJwHPXFCApyix3SZpRmJfgCdSWNmDByblylzOkyhqs+OPybQCA/zotH7PHyD/h2O9GZevWrdi4cSNGjx49qBc+66yzsH379h6fu+GGGzBmzBj86U9/UnWTAnh+ap+Zn4gV3pyKFhsVu9ON/TWepdHxKtr6AboCtaX1obu0OxAddhe2VjQDAE4blYxTRybjgud/wLpDjXjm6/24e87g3heofw7UtuG/P9oBALjz7FG+rWYKjK5ZWI0QRTFkjnvbnW7c9s4mtHU6MTU7TjH/nv3+8eekk04KSDYkOjoaEyZM6PERGRmJxMRETJgwYdDPrwTSOH2tzlM5WNcOu8uNaLMBmfHqOmkgzVLh1o9/NpV58ilpsWHITohAblIkHr10IgDgxe8PYO1+XlAabB12Fxa+vRkdDhdOHp6IhbNHyF2S5kzKjEOYURdyOZXHPt+DrRUtiA034vlrpyrmRJ/fKyr/+te/cMstt6CyshITJkyA0djzpIdWZqEEgtSVbylv1uTpku43JqvtJ458TqcdEGnbpzAvwfd3ftHkdPx8sAHvrCvDne9uwed3nIqUmP7lzsh/D32yE3tr2pAUZcYzV0+BnrmUgDMZPPNUfjzQgOKSBoxKjZa7pKD7alcNXvuxFADw5BWTkRGnnB8+/W5U6urqcPDgQdxwww2+zwmC4Fsec7kGHhz9/vvvB/xnlSgnMQLDYsJQ3dqJTWVNOHm4trZ/1DY6vzvpiHKDxY4Wq0M1R6vlJgVpj95qePDCcdhc1oQ91W24490t+N+bC/kNNAhWbqnEu+vLIQjAs1dPQUo0G8JgmZmXiB8PNKCopBG/mpUrdzlBVdFkxd3/txUAcNMv8vDLcakyV9ST3+s6N954IwoKCvDzzz+jpKQEpaWlPf4vdREEQdPj9NU2Or+7SLMBqTGe8GFpA1dV+qPD7sKW8mYAxzYqYUY9Xpw/FREmPX4uacBz3+yXoUJtK6lrx30fenJ9t80egVM0mHtTksJuIyZEUbv3/jhcbtz2zma0dDgwOTMWfzp3jNwlHcPvRuXw4cN4/PHHUVhYiNzcXOTk5PT4oJ5881Q0dsxNFEVVHk3urutywtDZgx6MzWVNsLvcSI0x+26g7m54chQeucSTL3vu2/346UD9UJeoWZ0OFxYu2wyL3YXCvATccfYouUvSvMlZsTAbdKhvt+OghqdYP/nlXmwua0Z0mAEvXDsVJoMycind+V3RmWeeia1btwajFk2SArWbvTkVrahu7USz1QG9TsDI1Ci5yxkQ38kfBmr7pai0a9vneJmkSwoyceX0TIgicMd7W1DXZuv1ceSfv366C7urWpEYacJz1xRwW20ImA16TMvxzFP5WYMr4gDw7Z4avLTGsxPyt8snISvh2B9AlMDvjMqFF16Iu+66C9u3b8fEiROPCdNedNFFAStOC/KSIpESbUZtmw1byps1c4xQCtKOSI5SbUhYCtQeZKC2X7qCtCf+Gn7oognYXNaM/bXtWPT+Frx5wwwOIhuEVduO4H+LygAAT181BakMKg+ZwrxE/HTQE6j91Uxt7RhUtXTgD+97Fh0WzMrBuROUO9XY70bllltuAQD8z//8zzG/N9gwrRZJ81Q+3noERSUNmmtU1BikleR7jyhzRaVvnY7u+ZSEEz423OTJq1z0wg9Yu78e//j+AG49c+QQVKk9hxssuHe5J5fyuzOG4/RRyTJXFFpmdssYammeitPlxu3vbEaT1YEJGTG473xl39fl99aP2+0+7geblN51BWq1k1Ppyqeo99heXrcjyloOywXC5rJm2J1upESbff/dTmRUajT+52JPXuXpr/ZpLqM1FGxOFxYu24R2mxPTc+Lxh18ylzLUJmfFwWTQob7dhoMa+oHm71/vw/pDTYgyG/DCNVNhNih7VVx5qRkNklZRNpdpJ6fSNTo/VuZKBi4rIQJ6nYAOhws1rcxSnIhv2+cE+ZSjXTEtE5cWZMAtAre/uxkN7fxv7I8ln+3BjspWxEUY8dw1BbyeQAZhRj2mZscB0M4Fs2v21eEf3x8EADx22UTk9uMHD7n5vfXT25ZPdw888MCAi9Gq/KRIJEWZUd9uw9byZt+xN7VqtzlxqMFz67CaV1SMeh2yEyJQWm9BSX07hsVy7/94pDfpvrZ9uhMEAQ/Pm4CtFc04WGfBove34vXrT2JepR++2FGNN346BAB4+srJSFfQ8K1QMzM/EUUljSgqacT8QnXnVGpaO3HXe1sgisD8wmxcMCld7pL6xe9GZcWKFT1+7XA4UFpaCoPBgOHDh7NR6YUnp5KAVduqUFTSqPpGZY93NSU1xoxElV+ElpcU6WlU6iyaG8gXKJ0OFzaVNQM4dn5KXyLNBrw4fyoufuFHrN5Xh5fXluCW04cHoUrtKG+04o8feEKOvz0tH2eOUdbwrVDjCY/vR3FJg6pzKi63iDve3YwGix1jhkXj/gvGyV1Sv/ndqGzevPmYz7W2tuL666/HJZdcEpCitGhmfiJWbavy/mSq7mChWm9M7k0eR+n3aUu5J5+SFGX2nZTyx5hhMfjLReOx+MPt+NuXe3FSbjym5fR/ZSaU2J1u3PrOZrR2OlGQHYd7FHIpXCgryPbkVGrbbCittyA/WZ3jGJ79Zj+KShoR4Q27q+m0ZkA2PWNiYvDQQw/h/vvvD8TTaZK0ZL7xcBNsTnXnVHapeHT+0Xwnf9ioHFfX2PyEAf80efVJWbhocjpcbhG3LduMJos9kCVqxhNf7MHW8mbPpXDXFCjmUrhQFmbUoyArDoB6J4z/eKAez3/rmRb96CUTMVxlzVbA/hW0tLSgpaUlUE+nOcOTo5AUZYLN6ca2CnX/d/IdTVZxkFbCFZW+dQ/SDpQgCHj00onITYzAkZZO3PPBVp60OsrXu2rwrx88l8L97fJJyIxX5vCtUNR9nL7a1LXZcMe7nlzKVdOzMK8gQ+6S/Ob31s9zzz3X49eiKKKqqgr//ve/MXfu3IAVpjWee38S8em2KhQdbMBJuepc+na63NhT3QZA3UFaSb53Om1ZoxUOl5s/wR7F5nRhU1kTAGCWH0Ha3kSZPSO6L/3HT/h6dy1e/aEUN5+aH4gyVa+yuQN/8F4Kd8MpuThn/DCZK6LuZuYn4LlvPE27mnIqLreIu97bgvp2G0anRuMvF42Xu6QB8btR+fvf/97j1zqdDsnJyViwYAEWL14csMK0aGZegqdRKW3AbSrNqRxqsMDmdCPCpEdOovKPtfUlNcaMcKMeHQ4Xyhutqt1/Dpat5S2wOd1IijIFZLl4QkYs7r9gLO5fuROPfb4H03LiUZAdH4BK1cvhcuO2ZZvQ0uHApMxYLJ6r7OFboWhqdjxMeh1qWm041GDt1ywhJfjHdwfww4F6hBv1eHF+AcJN6smldOd3o1JaWhqMOkKCdGJi4+Em2J1uRV7+1Jed3m2fMcOiNXHfiCAIyEuKxK6qVpTUqTcoFyzdx+YH6qfI62bm4OeSBny2vRq3LtuMz24/FbERxr7/oEY99Z992FTWjGjv8C01vi9oXZhRjylZcVh3qBHFJQ2qaFSKShrw96/3AQAenjcBI1LUuwLOfxFDaERKFBIjTeh0uLGtolnucgZE7Tcm9yaPgdrjGsj8lL4IgoDHLpuE7IQIVDZ34I/LQzev8t3eWvxztWf41hOXT0J2L7dSkzLMVNGE8YZ2G+54dzPcInDZ1ExcPi1T7pIGxe9GxWKx4P7778fJJ5+MESNGID8/v8cHHZ8np+L5Yi8uVWd6fHeVJ5+ihRM/kuHen45K2Kj0YHe6sfGwJ58S6DuqYsKMeOHaAhj1Ar7cWYM3vcPNQkl1S6fvUrhfz8rB3InKvRSOugdqGxXdWLvdIu56fytqWm0YnhyJh+epM5fSnd9bPzfffDNWr16NX/3qV0hLS1NNqEgpZuYn4rPt1SgqacDC2SPkLsdvXSd+tNOodK2otMtcibJsq2hGp8ONxEgTRqQEfktsUmYc7jtvLB76ZBce/WwPpuUkYGKm+k+S9Yd0KVyjxY7x6TG47zzmUpRuanY8jHoBVS2dKGu0Kjaj99KaEqzZVwezQYcX509FhMnvb/OK4/f/gs8//xyffvopTjnllGDUo3meKYfAhkNNqjtlUtvWifp2G3SCZ4iXVuR5T/5w66enrmPJA5+f0pfrT87Fzwcb8J9dNVi4bBNW3f4LxIRpP6/yzNf7se5QI6LMBrx4rbqGb4WqcJMnp7L+UBOKShoU2ahsONSIJ/+zFwDw0EXjNfM+7fd3yfj4eCQkqPNorRKMTIlCQqQJHQ6X6uapSKspuUmRqk2P9ybP+4ZT02qDxeaUuRrlkIZbSc11MAiCgL9dPhkZceEoa7Ri8fLtil5WD4S1++vw4vcHAMAzW0YFwUzykP4tFCtw8FuTxY7b3tkMl1vExVPScdVJWXKXFDB+NyoPP/wwHnjgAVit1mDUo3k6nYDCPPWEsrrz5VM0tO0DALERRiRGmgBwVUUSzHzK0WIjPHkVg07Ap9ur8L/FZUF9PTnVtnbiTu/wrWtmZOOiyeq4FI48pH8L0jwVpRBFEXf/31ZUtXQiPykSj1wyUVOxDL8blaeeegpffvklUlNTMXHiREydOrXHB/VNrY2KlkbnH00apc9Arcf2ymZ0OFxIiDRhZBDyKUcryI7Hn84dAwB4eNUu7DyirtXG/vBcCrfFdyncgxeq51I48piaEweDTsCRlk5UNHXIXY7Pv9aW4ps9tTAZdHjh2qmIMqs/l9Kd3/9r5s2bF4QyQsvM4V3zVNSUU9nl/eahpaPJkrykSKw/1ITSOjYqQNe2z4zcBOiGaF7OzafmoaikAd/sqcWtyzbjk9t+oak33Oe/3Y+fSxpUeSkceUSYDJicFYeNh5vwc0kDshLkP06+qawJj3+xBwDwwAXjNPmDpN/vAg8++GAw6ggpo1KiERdhRLPVge2VLZiqgsmcHXaXb1tkvCYbFSlQy5M/QNdqXyDnp/RFEAQ8ecVknP/cWpTWW/DnFdvxzFVTNLGE/dPBejz7jedSuEcumaC6S+Goy8z8BGw87AnUXjld3hxIi9WB25ZthtMt4vxJaZhfmC1rPcGijh/lNaZ7TkWJoaze7K1pg1sEkqJMSI42y11OwPFywi4OV7d8yvDg5lOOFh9pwvPXFkCvE7ByyxG8t758SF8/GLpfCnfl9ExcUqDu4VuhTimBWlEUcc8HW1HZ3IGcxAg8dqm2cindsVGRSfdQlhpIJ37GpsVo8h9D94yKkkJycthe2QKr3YW4CCNGyTB2e1pOAu4+ZzQA4MGPd2JPdeuQ1xAobreIRe9vQV2bDSNTovDQRRPkLokGaVpOPAw6AZXNHShvlO9QyRs/HcJ/dtXApNfhhWumIlrDx/rZqMika55KI5wut8zV9G1XlSeforUTP5LshAgIAtDW6UR9u13ucmTVdb/P0OVTjvZfp+Xj9FHJsDndWPj2JtUeG//H9wewdn89woye4VtaOtYfqiLNBt9gQrl+0NxW0YxHP9sNALjvvDGaH5TIRkUmY4ZFIzbcCIvdhR1HlP8ToxZH53cXZtQjMz4cALd/hmJ+Sl90OgFPXzkZqTFmHKyz4P6VO2SrZaCKSxrw9FeeS+H+5+IJGJWq3kvhqKeZ3cbpD7XWTgduXbYZDpeIc8cPw4KTc4e8hqHGRkUmOp2AGSo5pux2i9hdpb3R+UdjoNabTznkefMN9vyUviRGmfHc1QXQCcCHmyrxwcYKWevxR0O7Dbd7L4W7tCADV6j8UjjqSa6te1EUce/ybShrtCIzPhyPXz5Jk1vxR+vXqZ9Fixb1+wmffvrpARcTambmJ+KrXTUoKmnALacPl7uc4zrcaIXV7oLJoFPF9eYDlZ8UiTX76kJ6lsqOyhZY7C7EhhsxZpj8KwCF+Ym46+xReOqrfbj/ox2YnBmLkQpfmXC7Rfzh/7pfCjchJL6ZhJJpOfHQ6wRUNHWgosmKzPihOab8v0WH8dn2ahj1Al64dipiw7WbS+muX43K5s2b+/Vk/MfoH+no54ZDTXC63DAodJ6KtJoyZli0YmsMBN/JnxCepSItZc+QMZ9ytN/PHoHi0kb8cKAeC5dtwsqFv1B01uPltSX4fm/XpXCRGpoFQx5RZgMmZsRiS3kziksakTkt+I3KziMteHiVJ5fyp3PHYEpWXNBfUyn69S/ou+++C3YdIWnMsBjEhBnQ2unEziOtmKzQLzwt3pjcG6lRCeUVla75KfJu+3Sn1wn4+1VTcN5za7Gvph1/+XgnHr98ktxl9Wrj4Ub87UvPpXB/0dClcHSsmfmJ2FLejKKSBlwW5K29dpsTty7bDLvLjbPHpuKmX+QF9fWURrs/HquAXidghnQmv1S5ORUtj87vTmpUDjdY4HKH3hFlp8uN9aVSPkVZF48mR5vx7FVTIAjAexvK8dHmSrlLOkaTxY7blnkuhbtocjqu1tClcHSsQu+/kWAHakVRxH0fbkdpvQXpsWF48orQyKV0168VlUsvvbTfT/jhhx8OuJhQNDM/AV/vrkFRSSN+e5oycyrdZ6hoWUZcOEwGHexONyqbOpCdKP947KG080grLHYXYsIMilwJOHlEEm4/cySe/WY/7luxHRMzYxUz4VUavnWkpRO5iRF4VMPDt8hjujenUtZoRWVzBzLiwoPyOu+uL8fHW49ArxPw/LUFiIswBeV1lKxfKyqxsbH9/iD/SEvs60sbFflTfKPFjurWTgBQRLgymHQ6AXmJ0vZP6J38kbZ9ZuQlQq+QfMrRbj9rJGbmJ8Bqd2Hh25vQ6XDJXRIA4NUfSvH17lrP8C0NXgpHx4oOM2KCd5W5OEinf3ZXteIvH+8EANwzZzSm5ShrpXOo9Otf0+uvvx7sOkLW2LQYRIcZ0NbpxK4jrYob3CMFaXMSIzQ9+VCSlxSJvTVtKK234IzRclcztOS438dfep2AZ68uwHnPrsWe6jY8vGoXHrlkoqw1bSlvxmOfey6Fu/+CsZiQoax/wxQ8M/MTsbWiBcUljbh0amBzKhabEwuXbYLN6cYZo5Px21PzA/r8ajLgjEpdXR1++OEH/PDDD6irqwtkTSFFrxMwI1e581R82z4K3AoIhrzk0Lzzx+lyY8Mh7/0+CgrS9iY1Jgx/9+ZV3i4uw6ptR2SrpaXDgVuXbYLTLeK8icNw3cwc2WqhoeebpxKEjOH9K3egpM6CYTFhePrKKYo5hScHvxsVi8WCG2+8EWlpaTjttNNw2mmnIT09HTfddBOsVvnuPVCzrimHymtUdodIkFbiO/kTYkeUd1W1os3mRHSYQRVZpNNGJeP3Z3gyXfcu345DMjSWoijijx9sRUVTB7ITIvDYZaEXcgx103PjoROAww1WVLV0BOx5/29DOT7cVAm9TsBz1xQgITL0cind+d2oLFq0CKtXr8Ynn3yC5uZmNDc3Y+XKlVi9ejX+8Ic/BKNGzes+jllpOZVdITCRtrv8EL1FWboJdkZugmLzKUe76+xRmJGb4Dm6+c4m2JxDm1d586dD+HJnjXf4VgFiQmBrlHqKDjP6tvoCdZvy/po2PLDSk0tZ9MtRvgnmoczvRmX58uV49dVXMXfuXMTExCAmJgbnnXceXnnlFXzwwQfBqFHzxqXHINrsyalIKxhK0Olw4UCtJ1QaKisq+d5TJJXNHYoJag4FJc5P6YtBr8Oz10xBfIQROypb8einu4fstbdXtODRzzy5lPvOG4tJmXFD9tqkLIEcp99hd2Hhsk3ocLhw6sgk/E7BE8uHkt+NitVqRWpq6jGfT0lJ4dbPAOl1Ak5S4L0/B2rb4XSLiA03Ii02TO5yhkR8hNE3lvpQQ2isqrjcItZ5Z0EUKjhI25u02HA8feUUAMCbPx/G59urgv6arZ0OLFy2CXaXG+eMS8X1IXApHB1fYV7g5qk8+PEO7KtpR3K0OeRzKd353ajMmjULDz74IDo7O32f6+jowEMPPYRZs2YFtLhQIp20KArQ8mEgdN/2CZW9d0EQQm6U/m4pn2I2qHKLb/aYFPzXaZ4TEX9cvg1lDcH7gUkURSxevh1ljVZkxIXjb5dPDpl/G9S76bkJ0Ame7eKa1s6+/8BxrNhcgfc3VEAnAM9ePQXJ0eYAVqlufjcqzzzzDH788UdkZmbirLPOwllnnYWsrCz89NNPePbZZ4NRY0go9E6oXVfaoJicim90fohs+0jyQ2yUvrSKd1Jegmrvcrp7zmhMzY5DW6cTt72zCXanOyiv83ZxGT7dXgWDzpNLiY1gLiXUxYYbfe+RA10RP1Dbjj+v2AHAMyvo5OFJAatPC/x+V5o4cSL279+PJUuWYMqUKZgyZQoee+wx7N+/H+PHjw9GjSFhfHoMosyee3/2VCsjpyKtqKjhFEgghdrJH2kVr1DFoT2jXofnvbfJbq1oweNf7An4a+w80oL/WbULgOdSuILs+IC/BqnTzDwpp+L/ininw4Vbl22C1e7CycMTcduZIwNdnur5NT7R4XBgzJgxWLVqFX7zm98Eq6aQZNDrMD03Ht/vrUNRSSPGp8s7NEoUxa6jySHWqEiB2tIQmE7ryaeoL0jbm4y4cDx5xWT85q0NePWHUszMT8Qvxx2bpxsI36VwTjfOGpOCm08NrUvh6MRm5ifiXz+UDmhC7f+s2oU91W1IijLhmaunqObU3VDya0XFaDT2yKZQYPmOKSsgUFvR1IG2TieMegEjUpRxn8pQyQuhI8q7q1rR2ulElNmA8RrY4vvluK6bZe/+v62oaBp8XkUURfx5RfdL4ZhLoZ5OykuAIHi2i2v9yKl8svUIlhWXQRCAZ64qQEp0aBxa8JffWz8LFy7E448/DqfTGYx6Qlr3eSpumXMq0rbPyJRomAzqzC0MVG6S5zLCJqsDTRa7zNUEl3RSYXpuvGrzKUf707ljMDkrDi0dDtz2zmY4XIPLq7y3vhwrt3RdChcf4sO36Fix4UbfynNRP0//HKq3YPGH2wEAt84egV+MZC7lePx+Z1q/fj0+/PBDZGdnY86cObj00kt7fNDATUiPQaRJj5YOB/ZUt8laS6jcmNybCJPBdxy7VONHlNU4P6UvJoMOL1xTgOgwAzaXNePJL/cO+Ln2VLfiQe+lcHefE7qXwlHfCvP6P0+l0+GZl9Juc2JGXgLuOIu5lBPxu1GJi4vDZZddhjlz5iA9PZ23JweQJ6cincmXd/sn1EbnHy0Ujii7u89PUXGQtjdZCRH42+WTAAAvrSnBt3tq/H4Oi82JhW97LoU7fVSy7wg0UW+kERP92bp/9LPd2HmkFQmRJjx3dYFmVjODxe+7yHmTcnDNzE/E6n11KCppwA2nyBfYC7XR+UfLS4rETwcbUKLhQO2e6ja0dDgQadJr8sbfcyekYcGsHLz582H84f2t+OyOU5EWG97vP//Ayp04WGdBaowZT185mcO36IRmeHMqB+ssqG3rPG7e5PPtVXjr58MAgKevnIxhITJMczDYximMNBlUzpxKS4cDFU2eC7ZCtVHpOvmj3RUVaYl6em4CjBr9ie6+88diQkYMmqwO3P7OZjj7mVf5YGMFlm/yDN967uoCJEZx+BadWFyECWO8t8yvO05OpazBij8u3wYAuOX04ThjdMqQ1adm2nx3UrGJGbGIMOnRbHVgX608OZU93tWUjLjwkB1olR8Cs1Sk7UW1jc33h9mgxwvXTEWU2YD1h5rw96/39fln9te04f6PPMO37jp7FAo1lN+h4OqaMH7s9o/d6cZt72xCW6cT03Li8YdzRg11earFRkVhjHodpuV4BkkVHZQnpxKqg966kzIqhxossp/ACga3W/Sd+NFSkLY3uUmReOyyiQCAf3x/EGv21R33sd0vhfvFiCT8fvaIoSqTNKDrgsJjV1Qe+3wPtla0IC7CiOevKdDsKmYw8L+UAnU/piyHUB2d311mfDgMOgGdDjeqB3F/h1LtrWlDs9WBCJMeEzWYTznaBZPSMb8wG6II3PXeluPeyfKXj3f6LoX7+1UcvkX+meE9DHGgth317Tbf5/+zsxqv/VgKAHjqislIj+t/VooG2ahw+FtwyD1PpStIGz3kr60UBr0O2YmeeSpazKlIJxOm5cSHzE92918wDmPTYtBgseOOdzcfc6fWR5sr8d6GcggC8OxVvBSO/BcfacKYYZ73zWLvqkpFkxV3/99WAMBvTs3DWWMDMy05lPj9DuV2u/Hwww8jIyMDUVFRKCkpAQDcf//9ePXVVwNeYCialBmLcKMejRY79tcO7akTh8uN/TWe1xyXpv2ftE+kK6eivZM/0tK01rd9ugsz6vHitQWIMOlRVNKIZ7/Z7/u9g3XtuG+FZ/jW7WeOxMkjOHyLBqZr+6cBDpcbt72zGa2dTkzJisM9c8bIXJ06+d2o/PWvf8Ubb7yBJ554AiZT14TGCRMm4F//+pdfz7V06VJMmjQJMTExiImJwaxZs/D555/7W5LmGL33/gBDP0/lYF077C43os0GZMaH9vKkdPJHa7coe/Ip0qA37QZpe5OfHIVHL/HkVZ7/dj9+OlDvGb71tudSuJn5Cbidw7doEHzzVEob8OSXe7G5rBkxYQY8f01ByE35DhS//6u99dZbePnllzF//nzo9Xrf5ydPnow9e/y7sTQzMxOPPfYYNm7ciA0bNuDMM8/ExRdfjJ07d/pbluZIA7gGem34QEn5lDFp0SE/N0Krd/7sr21Hk9WBcKMeEzPi5C5nyM0ryMBV07MgisDt727Bn5Zvw57qNiRGmvDs1QXMpdCgzPBOqN1X046X1nh2HP52xWRkJUTIWZaq+d2oVFZWYsSIY5PwbrcbDofDr+e68MILcd5552HkyJEYNWoUHnnkEURFRaGoqMjfsjSn64LCRoji0OVUQvXG5N5otVHpmp8SH7I/4f3lovEYnRqN+nYbVm45AkEA/n7VFKTGcPgWDU5CpAmjU7vyfdefnIs544fJWJH6+f0uNW7cOKxdu/aYz3/wwQcoKCgYcCEulwvvvvsuLBYLZs2a1etjbDYbWltbe3xo1aTMOIQZdWiw2HFgCHMqu0J8dH53UkalvNEKu3NwF9spiW9+isbG5vsj3KTHi/MLEG70rAr//ozhOG1UssxVkVacPMLzg+bEjFgsPo+5lMHye4T+Aw88gAULFqCyshJutxsffvgh9u7di7feegurVq3yu4Dt27dj1qxZ6OzsRFRUFFasWIFx48b1+tglS5bgoYce8vs11Mhk8MxT+fFAA4pKGjAyNfgncERR7DqaHOJBWgBIjjYj0qSHxe5CWaMFI1LUfwpKFMWQDNL2ZkRKNN77r5nYeaQVV0zLlLsc0pBbZ49AcrQZl0/LhNmg7/sP0An5vaJy8cUX45NPPsHXX3+NyMhIPPDAA9i9ezc++eQT/PKXv/S7gNGjR2PLli0oLi7G7373OyxYsAC7du3q9bGLFy9GS0uL76O8vNzv11OTmdJtnEM0T6W6tRNNVgf0OgEjU6OG5DWVTBAE5CVra0Lt/tp2NFrsCDPqMCkzTu5yZDcpMw7XzMjmpXAUUIlRZvz+jBHHve+H/OP3igoAnHrqqfjqq68CUoDJZPJlXqZNm4b169fj2WefxUsvvXTMY81mM8zm0JltMHN4IvCVZ+aFKIoQhOCG/KR8yvDkSIQZ+VMAAOQnRWFHZatmcird56eEaj6FiNTF73eq9evXo7i4+JjPFxcXY8OGDYMuyO12w2az9f3AEDApMxZmgw717XYcHIJZHl3bPsynSLQWqPVt++SF9rYPEamH343KwoULe91yqaysxMKFC/16rsWLF2PNmjU4dOgQtm/fjsWLF+P777/H/Pnz/S1Lk8wGfde9P73cHRFovOPnWPnS1o8GGhVRFLtdRMhGhYjUwe9GZdeuXZg6deoxny8oKDhutuR4amtr8etf/xqjR4/GWWedhfXr1+PLL78cUNZFqwrzuqYcBtvuKs9tzTzx00VLKyoH69pR326H2aDD5CyGpYlIHfzOqJjNZtTU1CA/P7/H56uqqmAw+Pd0HLnft64ph41Bzam025w41OD5ZswVlS5So1LXZkNbpwPRYUaZKxq4n72rctNy4nkSgYhUw+8VlXPOOcd3+kbS3NyM++67jyshQTA5Kw5mgw51bbagbj/srW6FKAKpMWYkRYVOYLkv0WFG3+V0al9VkYK0hcynEJGK+N2oPPnkkygvL0dOTg5mz56N2bNnIy8vD9XV1XjqqaeCUWNICzPqUZAdByC42z9SkJarKcfSwvZPz/kpoTvojYjUx+9GJSMjA9u2bcMTTzyBcePGYdq0aXj22Wexfft2ZGVlBaPGkNd9nH6w7JLyKWxUjtF1i7J6G5WDdRbUt9u8+ZQ4ucshIuq3Ac1RiYyMxG9/+9tA10LH4WlU9qMoiPNUODr/+LSwoiKd9inIjuOMHCJSlX41Kh9//DHmzp0Lo9GIjz/++ISPveiiiwJSGHWZkhUHk0GH2jYbSustyE8O7NRYl1vE3mpu/RyPFhoVjs0nIrXqV6Myb948VFdXIyUlBfPmzTvu4wRBgMvlClRt5BVm1KMgKw7FpY0oLm0MeKNSWm9Bp8ONcKMeuYmRAX1uLfDNUqlrH5IJwYEmiiKDtESkWv3KqLjdbqSkpPj+/+N9sEkJHmlAVzACtdK2z5i0aOh16vomPBSyEyKhEwCL3YW6NvVNTS6tt6C2zQaTQecLZhMRqQUv+1AJ3zyVEs88lUDi6PwTMxl0yEqIAKDOCbXStk9BFvMpRKQ+fjUqbrcbr732Gi644AJMmDABEydOxEUXXYS33nor4N88qaep2fEw6XWobu3E4QZrQJ+bo/P7puacCsfmE5Ga9btREUURF110EW6++WZUVlZi4sSJGD9+PA4fPozrr78el1xySTDrDHlhRj2meI+VBnr7ZzdP/PRJrY2KZ36K5+uF81OISI36fTz5jTfewJo1a/DNN99g9uzZPX7v22+/xbx58/DWW2/h17/+dcCLJI+Z+QlYd8gTqL16RnZAnrO2rRN1bTYIAjBmWHRAnlOL1DpL5XCDFTWtNpj0OkzNjpe7HCIiv/V7ReWdd97Bfffdd0yTAgBnnnkm7r33Xrz99tsBLY566h6oDdRWm3QRYV5iJCJMAxqrExLykjwnrUrq22WuxD/SasoU5lOISKX63ahs27YN55577nF/f+7cudi6dWtAiqLeTc2Oh1EvoKqlE2WNgcmpSNs+Y7ntc0LSEeWyBiucLrfM1fQft32ISO363ag0NjYiNTX1uL+fmpqKpqamgBRFvQs3deVUAjVOnyd++mdYTBjCjDo43SIqmjrkLqdfRFFEcann64RBWiJSq343Ki6XCwbD8bcG9Ho9nE5nQIqi45MGdgUqUMvR+f2j0wm+YXhqCdSWNVpR1dIJo15gPoWIVKvfoQRRFHH99dfDbDb3+vs2m/oGYanRzPxEvPDdARSXNg56Smqnw4WSOk/mgisqfctPjsSe6jaU1FtwbFJLebrnU8JNzKcQkTr1u1FZsGBBn4/hiZ/gm5oTB6NeQGVzByqaOnyDyAZib3Ub3CKQGGlCSnTvDSh1yUvqGqWvBtL2IMfmE5Ga9btRef3114NZB/VThMmASZlx2Hi4CT+XNAyqUem+7aO2+2vkIJ38UcPWT8/5KWxUiEi9OEJfhbqP0x8MKUjLibT9I538UUOjUtHUgSMtnTDoBEzNiZO7HCKiAWOjokKBCtT6VlTYqPSLNPStqqUTVruyg+M/e782JmfFcT4OEakaGxUVmpYTD4POk1MpH+A8FbdbxB6e+PFLXIQJ8RFGAMCh+sDetxRonJ9CRFrBRkWFIs0GTMqMBQDfnAx/lTVaYbG7YDLofCsF1De13PnDIC0RaQUbFZXqPk5/IKRtn9Gp0TDo+WXQX75R+go++VPeaEVlcwcMOgHTcjg/hYjUjd+hVEo6yVFcOrBGZTfzKQOihkCttMo2KTMWkWbmU4hI3dioqNT0nHjodQLKGztQ0eR/XsI3Op/5FL/4blFWcKMirbJxbD4RaQEbFZWKNBswMcObUxnAMWVp64dHk/2Tl9w19C1QN1gHGuenEJGWsFFRsYFu/zRZ7Khq6QQAjEmLDnhdWibd99Pa6UST1SFzNceqaLKioqkDeuZTiEgj2KioWKH36GmRnysqUj4lOyECMWHGgNelZWFGPTLiwgEApfXKC9RKq2sTM2IRxXwKEWkAGxUVk3IqZY1WHGnu6Pef69r24WrKQEhHlA/WKS+nwm0fItIaNioqFh1mxAQpp+LH9o8vSJsWG5S6tE7JJ3+kEz+FHPRGRBrBRkXlZuZ5t38O9n/7Zxcn0g6Kb+ibwlZUjjR3oKzRCr1OwHTmU4hII9ioqJy/gVqb04UDtZ5sBRuVgVHqdFrpa2BCRiyimT0iIo1go6Jy03PjoROAQw1WVLX0nVPZX9MOp1tETJgB6bFhQ1Ch9uR7p9OWNljgdivniLK0qiatshERaQEbFZXrkVPpx+mf7ts+giAEtTatyogPh1EvwO5040g/msOhUlTKIC0RaQ8bFQ3wZ/una3Q+g7QDpdcJyEmUBr8pY/unqqUDhxus0AmeVTYiIq1go6IBhXn9n6cinfjh0eTByVdYTkVaTWM+hYi0ho2KBkzPTYBO8HzTrGntPO7jRFHkiZ8AyVPYEWXOTyEirWKjogGx4UaMT/ds5UjfsHpT2dyBtk4njHoBI1O4ojIYSruc0Dc/hUFaItIYNioa0Z/tH2nbZ0RKNEwG/tUPRp508kcBY/RrWjtRWm/x5lPYqBCRtvC7lUb0J1DL0fmBI81SqWjqQKfDJWst0irauPQYxIYzn0JE2sJGRSNOykuAIHhOodQeJ6fSNTqf+ZTBSooyITrMAFEEyhqtstYiraLNzGM+hYi0h42KRsSGG30NSFFp79s/u6sZpA0UQRC6cioyH1EuZpCWiDSMjYqG+LZ/egnUtnQ4UN7oGU7GFZXAUMIo/drWTpTUWyAInlU1IiKtYaOiIV2B2mMblT3efEp6bBjiIkxDWpdWKSFQK62ejUtjPoWItImNiobM8OZUDtZZUNdm6/F7uzk/JeCUMEuF2z5EpHVsVDQkLsKEscM8jcjRp398g9647RMwSsioSKtnnJ9CRFrFRkVjCvN73/7pOprMRiVQpIxKg8WOFqtjyF+/tq0TB+s8+ZQZbFSISKPYqGhMV6C26+SPw+XGvmpPjoJbP4ETaTYgNcYMAChtGPpVlXXefMqYYTHMHRGRZrFR0ZgZ3smk+2vbUd/uyamU1Flgd7kRZTYgKz5CzvI0p+vkz9AHarvu9+FqChFpFxsVjYmPNGHMMM/kWekn7l1VLQCAMcOiodMJstWmRb6TPzLkVHyD3hikJSINY6OiQdI3Luknbt9EWm77BJxclxPWt9twoNazijOD9/sQkYaxUdGgmUcFandXtQHgiZ9gyJPp5I+UQRozLBrxkcynEJF2sVHRoBneO1/21bSjod3WdTSZKyoBl99tloooikP2utLxc277EJHWsVHRoIRuOZWPtx5Bo8UOnQCMSuWtyYGWlRABvU5Ah8OFmlZb338gQBikJaJQwUZFo6QBYG/8dAgAMDw5CmFGvYwVaZNRr0N2guckVckQnfxpaLdhX403n8Ibk4lI49ioaJS0JXC4wQqA2z7BNNSXE0qnuUanRiOB+RQi0jhZG5UlS5bgpJNOQnR0NFJSUjBv3jzs3btXzpI04+hJpZxIGzy+RmWIArXc9iGiUCJro7J69WosXLgQRUVF+Oqrr+BwOHDOOefAYpHv7hStSIwyY1RqlO/XPPETPHlDfES5uJTzU4godBjkfPEvvviix6/feOMNpKSkYOPGjTjttNNkqko7ZuYn+rIMXFEJnvwhvEW50WLHnmrPcXPe70NEoUBRGZWWFs8E1YSE3t+AbTYbWltbe3zQ8RV6g5Yp0WYkR5tlrka78r3TacsarXC43EF9rXXeY8mjUqOQGMW/UyLSPsU0Km63G3feeSdOOeUUTJgwodfHLFmyBLGxsb6PrKysIa5SXX45LhXXzczG/ReMk7sUTUuNMSPcqIfLLaK80RrU1+LYfCIKNYppVBYuXIgdO3bg3XffPe5jFi9ejJaWFt9HeXn5EFaoPiaDDn+dNxEXTk6XuxRNEwRhyE7+SEHaQh5LJqIQoYhG5dZbb8WqVavw3XffITMz87iPM5vNiImJ6fFBpAR5ycEfpd/ULZ9SyBM/RBQiZA3TiqKI2267DStWrMD333+PvLw8OcshGrDhQ3DyZ90hz7bPiJQoJDGfQkQhQtZGZeHChVi2bBlWrlyJ6OhoVFdXAwBiY2MRHh4uZ2lEfsnznfwJ3nRazk8holAk69bP0qVL0dLSgjPOOANpaWm+j/fee0/Osoj8luc9+RPMjEoxg7REFIJk3/oh0oK8RM+KSk2rDRabE5HmwP7Tarbasbvacxyf81OIKJQoIkxLpHaxEUYkeu/dCcaqyrrSRogiMDw5EinRYQF/fiIipWKjQhQgwRylz7H5RBSq2KgQBYhvlH4Qjij75qewUSGiEMNGhShAugK1gT3502J1YFeVJ58yk/kUIgoxbFSIAiRY02nXH/LkU/KTIpESw3wKEYUWNipEASJt/ZTUWwJ6oo3bPkQUytioEAVIdkIEBAFo63SiwWIP2PN2BWm57UNEoYeNClGAhBn1yIjzTFQO1J0/LR0O7DzSAoAnfogoNLFRIQqg/OTABmo3HGqEW/TkX1KZTyGiEMRGhSiA8gM8S0Xa9inkaR8iClFsVIgCyHfyJ0BbP10XEXLbh4hCExsVogAK5BHltk4HdlR68imFDNISUYhio0IUQFKjcrjBCpd7cEeUNxxqglsEchIjkBYbHojyiIhUh40KUQClx4XDZNDB7nKjsqljUM/l2/bJ47YPEYUuNipEAaTXCchLlAK1gzv5UyTNTxnObR8iCl1sVIgCLBA5lR75FK6oEFEIY6NCFGB5yYNvVDYcboLLLSI7IQLpccynEFHoYqNCFGCBWFEpLuH8FCIigI0KUcD5hr4NYpYK56cQEXmwUSEKMGmMfmVzBzodLr//vMXmxHbOTyEiAsBGhSjg4iOMiA03AgAONfi/qiLlUzLjw5EZHxHo8oiIVIWNClGACYIwqFH63PYhIurCRoUoCAZzOWExGxUiIh82KkRBMNCTP1a7E9sqpPkpzKcQEbFRIQoCaZZKSZ1/02k3Hm6C0y0iIy4cWQnMpxARsVEhCoL8JM/JH39XVKR8Ck/7EBF5sFEhCoLcJM9qSJPVgSaLvd9/rsg76I35FCIiDzYqREEQYTIgLTYMAFDazyPKnnxKMwBgFhsVIiIAbFSIgsbfI8qbDjfD4RKRHhuGzHje70NEBLBRIQoaf0/+dJ+fIghC0OoiIlITNipEQZLnm6XSv5M/xaWcn0JEdDQ2KkRBMtx7509/LifssLuwpbwZAE/8EBF1x0aFKEikFZVDDRa43eIJH7u5rAkOl4i02DBkc34KEZEPGxWiIMmMD4dBJ6DT4UZ1a+cJH+ubn5KXwHwKEVE3bFSIgsSg1yE70bM60leglvNTiIh6x0aFKIj6czlhp6Mrn8JGhYioJzYqREHkO/lzgjt/NpU1we5yIzXGjJxE5lOIiLpjo0IURPnJfd/5U9xt24f5FCKintioEAVRf4a+dR/0RkREPbFRIQoiKaNS3miF3ek+5vc7HS5sluan5HF+ChHR0dioEAVRcrQZkSY93CJQ1mg95ve3lDfD7nQjJdrsW30hIqIubFSIgkgQBOQlH3/7xzc/hfkUIqJesVEhCrL8JGmU/rEnf7ryKdz2ISLqDRsVoiA7XqC20+HC5rJmAAzSEhEdDxsVoiDLT+596NvW8mbYnG4kRZl9oVsiIuqJjQpRkB1vRaW4VJqfwvt9iIiOh40KUZDlehuVujYb2jodvs93D9ISEVHv2KgQBVlMmBFJUWYAXasqNqcLGw83AQBmMUhLRHRcbFSIhkD+UUeUt1W0ePMpJgz3jtknIqJjsVEhGgK+W5TrPI1K0UHvtk8e56cQEZ0IGxWiIXB0oLaolPNTiIj6g40K0RDo3qjYnW5fPoXzU4iIToyNCtEQ6J5R2VbRjE6HG4mRJoxIYT6FiOhE2KgQDYGshAjoBKDd5sQnW48AAAo5P4WIqE9sVIiGgNmgR1ZCBADgw82VADxBWiIiOjE2KkRDRMqptHU6ATCfQkTUH7I2KmvWrMGFF16I9PR0CIKAjz76SM5yiIIqr9t9PgmRJoxkPoWIqE+yNioWiwWTJ0/Giy++KGcZREOi+8WDM3IToNMxn0JE1BeDnC8+d+5czJ07V84SiIZMXlLXCgrnpxAR9Y+sjYq/bDYbbDab79etra0yVkPkn7zkrhWVmcOZTyEi6g9VhWmXLFmC2NhY30dWVpbcJRH1W3psGM6flIa5E4ZhVEq03OUQEamCIIqiKHcRACAIAlasWIF58+Yd9zG9rahkZWWhpaUFMTExQ1AlERERDVZraytiY2P79f1bVVs/ZrMZZrNZ7jKIiIhoiKhq64eIiIhCi6wrKu3t7Thw4IDv16WlpdiyZQsSEhKQnZ0tY2VERESkBLI2Khs2bMDs2bN9v160aBEAYMGCBXjjjTdkqoqIiIiUQtZG5YwzzoBCsrxERESkQMyoEBERkWKxUSEiIiLFYqNCREREisVGhYiIiBSLjQoREREpFhsVIiIiUiw2KkRERKRYbFSIiIhIsdioEBERkWKp6vbko0lTbVtbW2WuhIiIiPpL+r7dn+n0qm5U2traAABZWVkyV0JERET+amtrQ2xs7AkfI4gqvmzH7XbjyJEjiI6OhiAIAX3u1tZWZGVloby8HDExMQF9bvIf/z6UhX8fysK/D+Xh38mJiaKItrY2pKenQ6c7cQpF1SsqOp0OmZmZQX2NmJgYfpEpCP8+lIV/H8rCvw/l4d/J8fW1kiJhmJaIiIgUi40KERERKRYbleMwm8148MEHYTab5S6FwL8PpeHfh7Lw70N5+HcSOKoO0xIREZG2cUWFiIiIFIuNChERESkWGxUiIiJSLDYqREREpFhsVHrx4osvIjc3F2FhYSgsLMS6devkLilkLVmyBCeddBKio6ORkpKCefPmYe/evXKXRQAee+wxCIKAO++8U+5SQlplZSWuu+46JCYmIjw8HBMnTsSGDRvkLiskuVwu3H///cjLy0N4eDiGDx+Ohx9+uF/32dDxsVE5ynvvvYdFixbhwQcfxKZNmzB58mTMmTMHtbW1cpcWklavXo2FCxeiqKgIX331FRwOB8455xxYLBa5Swtp69evx0svvYRJkybJXUpIa2pqwimnnAKj0YjPP/8cu3btwlNPPYX4+Hi5SwtJjz/+OJYuXYoXXngBu3fvxuOPP44nnngCzz//vNylqRqPJx+lsLAQJ510El544QUAnvuEsrKycNttt+Hee++VuTqqq6tDSkoKVq9ejdNOO03uckJSe3s7pk6din/84x/461//iilTpuCZZ56Ru6yQdO+99+LHH3/E2rVr5S6FAFxwwQVITU3Fq6++6vvcZZddhvDwcPzv//6vjJWpG1dUurHb7di4cSPOPvts3+d0Oh3OPvts/PzzzzJWRpKWlhYAQEJCgsyVhK6FCxfi/PPP7/HvhOTx8ccfY/r06bjiiiuQkpKCgoICvPLKK3KXFbJOPvlkfPPNN9i3bx8AYOvWrfjhhx8wd+5cmStTN1VfShho9fX1cLlcSE1N7fH51NRU7NmzR6aqSOJ2u3HnnXfilFNOwYQJE+QuJyS9++672LRpE9avXy93KQSgpKQES5cuxaJFi3Dfffdh/fr1uP3222EymbBgwQK5yws59957L1pbWzFmzBjo9Xq4XC488sgjmD9/vtylqRobFVKNhQsXYseOHfjhhx/kLiUklZeX44477sBXX32FsLAwucsheJr36dOn49FHHwUAFBQUYMeOHfjnP//JRkUG77//Pt5++20sW7YM48ePx5YtW3DnnXciPT2dfx+DwEalm6SkJOj1etTU1PT4fE1NDYYNGyZTVQQAt956K1atWoU1a9YgMzNT7nJC0saNG1FbW4upU6f6PudyubBmzRq88MILsNls0Ov1MlYYetLS0jBu3Lgenxs7diyWL18uU0Wh7Z577sG9996Lq6++GgAwceJEHD58GEuWLGGjMgjMqHRjMpkwbdo0fPPNN77Pud1ufPPNN5g1a5aMlYUuURRx6623YsWKFfj222+Rl5cnd0kh66yzzsL27duxZcsW38f06dMxf/58bNmyhU2KDE455ZRjjuvv27cPOTk5MlUU2qxWK3S6nt9W9Xo93G63TBVpA1dUjrJo0SIsWLAA06dPx4wZM/DMM8/AYrHghhtukLu0kLRw4UIsW7YMK1euRHR0NKqrqwEAsbGxCA8Pl7m60BIdHX1MNigyMhKJiYnMDMnkrrvuwsknn4xHH30UV155JdatW4eXX34ZL7/8stylhaQLL7wQjzzyCLKzszF+/Hhs3rwZTz/9NG688Ua5S1M3kY7x/PPPi9nZ2aLJZBJnzJghFhUVyV1SyALQ68frr78ud2kkiuLpp58u3nHHHXKXEdI++eQTccKECaLZbBbHjBkjvvzyy3KXFLJaW1vFO+64Q8zOzhbDwsLE/Px88c9//rNos9nkLk3VOEeFiIiIFIsZFSIiIlIsNipERESkWGxUiIiISLHYqBAREZFisVEhIiIixWKjQkRERIrFRoWIiIgUi40KERERKRYbFSIiIlIsNipEdIzrr78egiAc83HgwAG5SyOiEMNLCYmoV+eeey5ef/31Hp9LTk7u8Wu73Q6TyTSUZRFRiOGKChH1ymw2Y9iwYT0+zjrrLNx666248847kZSUhDlz5gAAduzYgblz5yIqKgqpqan41a9+hfr6et9zWSwW/PrXv0ZUVBTS0tLw1FNP4YwzzsCdd97pe4wgCPjoo4961BAXF4c33njD9+vy8nJceeWViIuLQ0JCAi6++GIcOnTI9/vXX3895s2bhyeffBJpaWlITEzEwoUL4XA4fI+x2Wz405/+hKysLJjNZowYMQKvvvoqRFHEiBEj8OSTT/aoYcuWLVxNIpIRGxUi8subb74Jk8mEH3/8Ef/85z/R3NyMM888EwUFBdiwYQO++OIL1NTU4Morr/T9mXvuuQerV6/GypUr8Z///Afff/89Nm3a5NfrOhwOzJkzB9HR0Vi7di1+/PFHREVF4dxzz4Xdbvc97rvvvsPBgwfx3Xff4c0338Qbb7zRo9n59a9/jXfeeQfPPfccdu/ejZdeeglRUVEQBAE33njjMatIr7/+Ok477TSMGDFiYP/BiGhwZL69mYgUaMGCBaJerxcjIyN9H5dffrl4+umniwUFBT0e+/DDD4vnnHNOj8+Vl5eLAMS9e/eKbW1toslkEt9//33f7zc0NIjh4eHiHXfc4fscAHHFihU9nic2NlZ8/fXXRVEUxX//+9/i6NGjRbfb7ft9m80mhoeHi19++aWv7pycHNHpdPoec8UVV4hXXXWVKIqiuHfvXhGA+NVXX/X6v7uyslLU6/VicXGxKIqiaLfbxaSkJPGNN97ox381IgoGZlSIqFezZ8/G0qVLfb+OjIzENddcg2nTpvV43NatW/Hdd98hKirqmOc4ePAgOjo6YLfbUVhY6Pt8QkICRo8e7Vc9W7duxYEDBxAdHd3j852dnTh48KDv1+PHj4der/f9Oi0tDdu3bwfg2cbR6/U4/fTTe32N9PR0nH/++XjttdcwY8YMfPLJJ7DZbLjiiiv8qpWIAoeNChH1KjIystftjsjIyB6/bm9vx4UXXojHH3/8mMempaX1O9shCAJEUezxue7Zkvb2dkybNg1vv/32MX+2e8jXaDQe87xutxsAEB4e3mcdN998M371q1/h73//O15//XVcddVViIiI6Nf/BiIKPDYqRDQoU6dOxfLly5GbmwuD4di3lOHDh8NoNKK4uBjZ2dkAgKamJuzbt6/HykZycjKqqqp8v96/fz+sVmuP13nvvfeQkpKCmJiYAdU6ceJEuN1urF69GmeffXavjznvvPMQGRmJpUuX4osvvsCaNWsG9FpEFBgM0xLRoCxcuBCNjY245pprsH79ehw8eBBffvklbrjhBrhcLkRFReGmm27CPffcg2+//RY7duzA9ddfD52u59vPmWeeiRdeeAGbN2/Ghg0bcMstt/RYHZk/fz6SkpJw8cUXY+3atSgtLcX333+P22+/HRUVFf2qNTc3FwsWLMCNN96Ijz76yPcc77//vu8xer0e119/PRYvXoyRI0di1qxZgfkPRUQDwkaFiAYlPT0dP/74I1wuF8455xxMnDgRd955J+Li4nzNyN/+9jeceuqpuPDCC3H22WfjF7/4xTFZl6eeegpZWVk49dRTce211+Luu+/useUSERGBNWvWIDs7G5deeinGjh2Lm266CZ2dnX6tsCxduhSXX345fv/732PMmDH4zW9+A4vF0uMxN910E+x2O2644YZB/JchokAQxKM3hYmIhsAZZ5yBKVOm4JlnnpG7lGOsXbsWZ511FsrLy5Gamip3OUQhjRkVIiIvm82Guro6/OUvf8EVV1zBJoVIAbj1Q0Tk9c477yAnJwfNzc144okn5C6HiMCtHyIiIlIwrqgQERGRYrFRISIiIsVio0JERESKxUaFiIiIFIuNChERESkWGxUiIiJSLDYqREREpFhsVIiIiEix/h8DaBYrU0l6+gAAAABJRU5ErkJggg==\n"
+          },
+          "metadata": {}
+        }
+      ],
+      "source": [
+        "plt.plot(dr[\"Dice_number\"].values)\n",
+        "plt.xlabel(\"Frequency\")\n",
+        "plt.ylabel(\"Dice roll number\")\n",
+        "plt.show()"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "05_6LcBVBZKr"
+      },
+      "outputs": [],
+      "source": [
+        "#Not sure about this one, but still:\n",
+        "\"\"\" The difference between the two plots (even with the same dataset) relies on the sorted func.\n",
+        "The first plot illustrates the ordered sequence of dice numbers, while the second plot shows the actual individual observations in their original random way.\n",
+        "Maybe in this case (and in luck/bad luck games) we see there is no pattern what so ever\"\"\""
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "iKbfrFQGBZKr"
+      },
+      "source": [
+        "## Challenge 2\n",
+        "Now, using the dice results obtained in *challenge 1*, your are going to define some functions that will help you calculate the mean of your data in two different ways, the median and the four quartiles.\n",
+        "\n",
+        "#### 1.- Define a function that computes the mean by summing all the observations and dividing by the total number of observations. You are not allowed to use any methods or functions that directly calculate the mean value."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 6,
+      "metadata": {
+        "id": "ADmdb4H_BZKr",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "outputId": "d44840f0-3818-4674-8356-bf6deda358d1"
+      },
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "Dice_number    4.0\n",
+              "dtype: float64"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 6
+        }
+      ],
+      "source": [
+        "# Just checking\n",
+        "round(dr.mean())"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "def manual_mean():\n",
+        "  total_sum = 0\n",
+        "  total_count = 0\n",
+        "  for value in dr[\"Dice_number\"]:\n",
+        "    total_sum += value\n",
+        "    total_count += 1\n",
+        "\n",
+        "  mean = total_sum/total_count\n",
+        "  return mean\n",
+        "\n",
+        "round(manual_mean())"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "ufS8cp2ZtrL9",
+        "outputId": "6032ce6e-f3da-41bd-b64e-488dd79ec88d"
+      },
+      "execution_count": 7,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "4"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 7
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "Iv7ZVO9pBZKr"
+      },
+      "source": [
+        "#### 2.- First, calculate the frequency distribution. Then, calculate the mean using the values of the frequency distribution you've just computed. You are not allowed to use any methods or functions that directly calculate the mean value."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 8,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "0kb8gmloBZKs",
+        "outputId": "42dc2dc9-ae5b-405c-a378-c93b8a23ae28"
+      },
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "4"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 8
+        }
+      ],
+      "source": [
+        "freq = {}\n",
+        "for value in dr[\"Dice_number\"]:\n",
+        "    if value in freq:\n",
+        "        freq[value] += 1\n",
+        "    else:\n",
+        "        freq[value] = 1\n",
+        "#print(\"Frequency is: \", freq)\n",
+        "\n",
+        "sum_values = 0\n",
+        "total_count = 0\n",
+        "\n",
+        "for value, count in freq.items():\n",
+        "  sum_values += value * count\n",
+        "  total_count += count\n",
+        "mean = sum_values/total_count\n",
+        "round(mean)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "A2vIAOPVBZKs"
+      },
+      "source": [
+        "#### 3.- Define a function to calculate the median. You are not allowed to use any methods or functions that directly calculate the median value.\n",
+        "**Hint**: you might need to define two computation cases depending on the number of observations used to calculate the median."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "92hUMlGiBZKs"
+      },
+      "outputs": [],
+      "source": [
+        "sorted_dr = dr.sort_values(by = \"Dice_number\")\n",
+        "sorted_dr"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "def manual_median(sorted_dr):\n",
+        "  total_count = 0\n",
+        "  for value in sorted_dr:\n",
+        "    total_count += 1\n",
+        "    if total_count % 2 == 0:\n",
+        "      median = (sorted_dr[total_count // 2 - 1] + sorted_dr[total_count // 2]) / 2\n",
+        "    else:\n",
+        "      median = (sorted_dr[total_count // 2])\n",
+        "\n",
+        "  return median\n",
+        "\n",
+        "print((manual_median(sorted_dr[\"Dice_number\"])))\n",
+        "# wrong, and brain melting :)"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "KHV_oMU43RCu",
+        "outputId": "d9560eb1-4b7a-40a1-f894-89814cd14246"
+      },
+      "execution_count": 10,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "3.5\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "sorted_dr_array = sorted_dr.values\n",
+        "def manual_median(sorted_dr_array):\n",
+        "  median = (sorted_dr_array[4] + sorted_dr_array[5])/2\n",
+        "  return median\n",
+        "manual_median(sorted_dr_array)"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "v_ZNaZpazDFO",
+        "outputId": "40350215-51a2-4c64-c01b-3cdad16d2290"
+      },
+      "execution_count": 11,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "array([4.])"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 11
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "print(\"Manual median is: \", (sorted_dr_array[4] + sorted_dr_array[5])/2)\n",
+        "print(\"Method median is:\", np.median(sorted_dr))\n",
+        "# because dice have integers, i think this should be rounded"
+      ],
+      "metadata": {
+        "id": "EypN3Rx77lhB",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "outputId": "23ba9987-83eb-4f0b-de13-0ae615925c53"
+      },
+      "execution_count": 12,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Manual median is:  [4.]\n",
+            "Method median is: 4.0\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "Wf9BpuqEBZKs"
+      },
+      "source": [
+        "#### 4.- Define a function to calculate the four quartiles. You can use the function you defined above to compute the median but you are not allowed to use any methods or functions that directly calculate the quartiles."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 13,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "v7w3MoXuBZKs",
+        "outputId": "cc44746f-0f43-4bbd-9d0a-c68fd408285c"
+      },
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "(array([4.]), array([4.]))"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 13
+        }
+      ],
+      "source": [
+        "def manual_quartiles(sorted_dr_array):\n",
+        "    q2 = manual_median(sorted_dr_array)\n",
+        "    for_q1 = sorted_dr_array[:6]\n",
+        "    for_q3 = sorted_dr_array[:6:]\n",
+        "    q1 = manual_median(for_q1)\n",
+        "    q3 = manual_median(for_q3)\n",
+        "    return q1, q3\n",
+        "\n",
+        "manual_quartiles(sorted_dr_array)\n",
+        "# died. so easy and wrong, but died."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "zPiSR-ZJBZKs"
+      },
+      "source": [
+        "## Challenge 3\n",
+        "Read the csv `roll_the_dice_hundred.csv` from the `data` folder.\n",
+        "#### 1.- Sort the values and plot them. What do you see?"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 15,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 206
+        },
+        "id": "JzQQsaOVBZKs",
+        "outputId": "98d2de22-32b0-4af0-fdd7-93fc40d5ddb0"
+      },
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "   Unnamed: 0  roll  value\n",
+              "0           0     0      1\n",
+              "1           1     1      2\n",
+              "2           2     2      6\n",
+              "3           3     3      1\n",
+              "4           4     4      6"
+            ],
+            "text/html": [
+              "\n",
+              "  <div id=\"df-a03f6b55-3fa5-463b-a2a1-bb89496b4f28\" class=\"colab-df-container\">\n",
+              "    <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>Unnamed: 0</th>\n",
+              "      <th>roll</th>\n",
+              "      <th>value</th>\n",
+              "    </tr>\n",
+              "  </thead>\n",
+              "  <tbody>\n",
+              "    <tr>\n",
+              "      <th>0</th>\n",
+              "      <td>0</td>\n",
+              "      <td>0</td>\n",
+              "      <td>1</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>1</th>\n",
+              "      <td>1</td>\n",
+              "      <td>1</td>\n",
+              "      <td>2</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>2</th>\n",
+              "      <td>2</td>\n",
+              "      <td>2</td>\n",
+              "      <td>6</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>3</th>\n",
+              "      <td>3</td>\n",
+              "      <td>3</td>\n",
+              "      <td>1</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>4</th>\n",
+              "      <td>4</td>\n",
+              "      <td>4</td>\n",
+              "      <td>6</td>\n",
+              "    </tr>\n",
+              "  </tbody>\n",
+              "</table>\n",
+              "</div>\n",
+              "    <div class=\"colab-df-buttons\">\n",
+              "\n",
+              "  <div class=\"colab-df-container\">\n",
+              "    <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-a03f6b55-3fa5-463b-a2a1-bb89496b4f28')\"\n",
+              "            title=\"Convert this dataframe to an interactive table.\"\n",
+              "            style=\"display:none;\">\n",
+              "\n",
+              "  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\" viewBox=\"0 -960 960 960\">\n",
+              "    <path d=\"M120-120v-720h720v720H120Zm60-500h600v-160H180v160Zm220 220h160v-160H400v160Zm0 220h160v-160H400v160ZM180-400h160v-160H180v160Zm440 0h160v-160H620v160ZM180-180h160v-160H180v160Zm440 0h160v-160H620v160Z\"/>\n",
+              "  </svg>\n",
+              "    </button>\n",
+              "\n",
+              "  <style>\n",
+              "    .colab-df-container {\n",
+              "      display:flex;\n",
+              "      gap: 12px;\n",
+              "    }\n",
+              "\n",
+              "    .colab-df-convert {\n",
+              "      background-color: #E8F0FE;\n",
+              "      border: none;\n",
+              "      border-radius: 50%;\n",
+              "      cursor: pointer;\n",
+              "      display: none;\n",
+              "      fill: #1967D2;\n",
+              "      height: 32px;\n",
+              "      padding: 0 0 0 0;\n",
+              "      width: 32px;\n",
+              "    }\n",
+              "\n",
+              "    .colab-df-convert:hover {\n",
+              "      background-color: #E2EBFA;\n",
+              "      box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
+              "      fill: #174EA6;\n",
+              "    }\n",
+              "\n",
+              "    .colab-df-buttons div {\n",
+              "      margin-bottom: 4px;\n",
+              "    }\n",
+              "\n",
+              "    [theme=dark] .colab-df-convert {\n",
+              "      background-color: #3B4455;\n",
+              "      fill: #D2E3FC;\n",
+              "    }\n",
+              "\n",
+              "    [theme=dark] .colab-df-convert:hover {\n",
+              "      background-color: #434B5C;\n",
+              "      box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
+              "      filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
+              "      fill: #FFFFFF;\n",
+              "    }\n",
+              "  </style>\n",
+              "\n",
+              "    <script>\n",
+              "      const buttonEl =\n",
+              "        document.querySelector('#df-a03f6b55-3fa5-463b-a2a1-bb89496b4f28 button.colab-df-convert');\n",
+              "      buttonEl.style.display =\n",
+              "        google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
+              "\n",
+              "      async function convertToInteractive(key) {\n",
+              "        const element = document.querySelector('#df-a03f6b55-3fa5-463b-a2a1-bb89496b4f28');\n",
+              "        const dataTable =\n",
+              "          await google.colab.kernel.invokeFunction('convertToInteractive',\n",
+              "                                                    [key], {});\n",
+              "        if (!dataTable) return;\n",
+              "\n",
+              "        const docLinkHtml = 'Like what you see? Visit the ' +\n",
+              "          '<a target=\"_blank\" href=https://colab.research.google.com/notebooks/data_table.ipynb>data table notebook</a>'\n",
+              "          + ' to learn more about interactive tables.';\n",
+              "        element.innerHTML = '';\n",
+              "        dataTable['output_type'] = 'display_data';\n",
+              "        await google.colab.output.renderOutput(dataTable, element);\n",
+              "        const docLink = document.createElement('div');\n",
+              "        docLink.innerHTML = docLinkHtml;\n",
+              "        element.appendChild(docLink);\n",
+              "      }\n",
+              "    </script>\n",
+              "  </div>\n",
+              "\n",
+              "\n",
+              "<div id=\"df-ae249da1-b7b9-409c-a508-9fabcca338d6\">\n",
+              "  <button class=\"colab-df-quickchart\" onclick=\"quickchart('df-ae249da1-b7b9-409c-a508-9fabcca338d6')\"\n",
+              "            title=\"Suggest charts\"\n",
+              "            style=\"display:none;\">\n",
+              "\n",
+              "<svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n",
+              "     width=\"24px\">\n",
+              "    <g>\n",
+              "        <path d=\"M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zM9 17H7v-7h2v7zm4 0h-2V7h2v10zm4 0h-2v-4h2v4z\"/>\n",
+              "    </g>\n",
+              "</svg>\n",
+              "  </button>\n",
+              "\n",
+              "<style>\n",
+              "  .colab-df-quickchart {\n",
+              "      --bg-color: #E8F0FE;\n",
+              "      --fill-color: #1967D2;\n",
+              "      --hover-bg-color: #E2EBFA;\n",
+              "      --hover-fill-color: #174EA6;\n",
+              "      --disabled-fill-color: #AAA;\n",
+              "      --disabled-bg-color: #DDD;\n",
+              "  }\n",
+              "\n",
+              "  [theme=dark] .colab-df-quickchart {\n",
+              "      --bg-color: #3B4455;\n",
+              "      --fill-color: #D2E3FC;\n",
+              "      --hover-bg-color: #434B5C;\n",
+              "      --hover-fill-color: #FFFFFF;\n",
+              "      --disabled-bg-color: #3B4455;\n",
+              "      --disabled-fill-color: #666;\n",
+              "  }\n",
+              "\n",
+              "  .colab-df-quickchart {\n",
+              "    background-color: var(--bg-color);\n",
+              "    border: none;\n",
+              "    border-radius: 50%;\n",
+              "    cursor: pointer;\n",
+              "    display: none;\n",
+              "    fill: var(--fill-color);\n",
+              "    height: 32px;\n",
+              "    padding: 0;\n",
+              "    width: 32px;\n",
+              "  }\n",
+              "\n",
+              "  .colab-df-quickchart:hover {\n",
+              "    background-color: var(--hover-bg-color);\n",
+              "    box-shadow: 0 1px 2px rgba(60, 64, 67, 0.3), 0 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
+              "    fill: var(--button-hover-fill-color);\n",
+              "  }\n",
+              "\n",
+              "  .colab-df-quickchart-complete:disabled,\n",
+              "  .colab-df-quickchart-complete:disabled:hover {\n",
+              "    background-color: var(--disabled-bg-color);\n",
+              "    fill: var(--disabled-fill-color);\n",
+              "    box-shadow: none;\n",
+              "  }\n",
+              "\n",
+              "  .colab-df-spinner {\n",
+              "    border: 2px solid var(--fill-color);\n",
+              "    border-color: transparent;\n",
+              "    border-bottom-color: var(--fill-color);\n",
+              "    animation:\n",
+              "      spin 1s steps(1) infinite;\n",
+              "  }\n",
+              "\n",
+              "  @keyframes spin {\n",
+              "    0% {\n",
+              "      border-color: transparent;\n",
+              "      border-bottom-color: var(--fill-color);\n",
+              "      border-left-color: var(--fill-color);\n",
+              "    }\n",
+              "    20% {\n",
+              "      border-color: transparent;\n",
+              "      border-left-color: var(--fill-color);\n",
+              "      border-top-color: var(--fill-color);\n",
+              "    }\n",
+              "    30% {\n",
+              "      border-color: transparent;\n",
+              "      border-left-color: var(--fill-color);\n",
+              "      border-top-color: var(--fill-color);\n",
+              "      border-right-color: var(--fill-color);\n",
+              "    }\n",
+              "    40% {\n",
+              "      border-color: transparent;\n",
+              "      border-right-color: var(--fill-color);\n",
+              "      border-top-color: var(--fill-color);\n",
+              "    }\n",
+              "    60% {\n",
+              "      border-color: transparent;\n",
+              "      border-right-color: var(--fill-color);\n",
+              "    }\n",
+              "    80% {\n",
+              "      border-color: transparent;\n",
+              "      border-right-color: var(--fill-color);\n",
+              "      border-bottom-color: var(--fill-color);\n",
+              "    }\n",
+              "    90% {\n",
+              "      border-color: transparent;\n",
+              "      border-bottom-color: var(--fill-color);\n",
+              "    }\n",
+              "  }\n",
+              "</style>\n",
+              "\n",
+              "  <script>\n",
+              "    async function quickchart(key) {\n",
+              "      const quickchartButtonEl =\n",
+              "        document.querySelector('#' + key + ' button');\n",
+              "      quickchartButtonEl.disabled = true;  // To prevent multiple clicks.\n",
+              "      quickchartButtonEl.classList.add('colab-df-spinner');\n",
+              "      try {\n",
+              "        const charts = await google.colab.kernel.invokeFunction(\n",
+              "            'suggestCharts', [key], {});\n",
+              "      } catch (error) {\n",
+              "        console.error('Error during call to suggestCharts:', error);\n",
+              "      }\n",
+              "      quickchartButtonEl.classList.remove('colab-df-spinner');\n",
+              "      quickchartButtonEl.classList.add('colab-df-quickchart-complete');\n",
+              "    }\n",
+              "    (() => {\n",
+              "      let quickchartButtonEl =\n",
+              "        document.querySelector('#df-ae249da1-b7b9-409c-a508-9fabcca338d6 button');\n",
+              "      quickchartButtonEl.style.display =\n",
+              "        google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
+              "    })();\n",
+              "  </script>\n",
+              "</div>\n",
+              "    </div>\n",
+              "  </div>\n"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 15
+        }
+      ],
+      "source": [
+        "data = pd.read_csv(\"/content/roll_the_dice_hundred.csv\")\n",
+        "data.head()\n",
+        "#data.shape"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "sorted_data = data.sort_values(by = \"value\")\n",
+        "data_plot = plt.scatter( x = sorted_data[\"roll\"], y = sorted_data[\"value\"])\n",
+        "data_plot"
+      ],
+      "metadata": {
+        "id": "_zHeXuHOCQCW",
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 447
+        },
+        "outputId": "2ff66afb-8d4e-495d-9de7-9f1f3c1e1630"
+      },
+      "execution_count": 16,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "<matplotlib.collections.PathCollection at 0x792ebebea440>"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 16
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 640x480 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "h3Pu6S2oBZKt"
+      },
+      "outputs": [],
+      "source": [
+        "\n",
+        "\"\"\"The distribution of observations throughout 100 rolls: I would expect a uniform distribution of values for frequency.\n",
+        "But somehow it looks that odd numbers occur a litlle less than even :/ But still, looks just like a pretty random set, just like a expected roll dice\"\"\""
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "HEQiE_usBZKt"
+      },
+      "source": [
+        "#### 2.- Using the functions you defined in *challenge 2*, calculate the mean value of the hundred dice rolls."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 17,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "QpPmR2_vBZKt",
+        "outputId": "66157be3-06f4-47c4-d685-6af3a4b0eb90"
+      },
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "4"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 17
+        }
+      ],
+      "source": [
+        "def manual_mean():\n",
+        "  total_sum = 0\n",
+        "  total_count = 0\n",
+        "  for value in data[\"value\"]:\n",
+        "    total_sum += value\n",
+        "    total_count += 1\n",
+        "\n",
+        "  mean = total_sum/total_count\n",
+        "  return mean\n",
+        "\n",
+        "round(manual_mean())"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "2IAom45eBZKt"
+      },
+      "source": [
+        "#### 3.- Now, calculate the frequency distribution.\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 18,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "r2Q9yIn7BZKt",
+        "outputId": "6088d991-758e-481a-b008-3b2eb4f9e47e"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Frequency is:  {1: 12, 2: 17, 6: 23, 5: 12, 4: 22, 3: 14}\n"
+          ]
+        }
+      ],
+      "source": [
+        "freq = {}\n",
+        "for value in data[\"value\"]:\n",
+        "    if value in freq:\n",
+        "        freq[value] += 1\n",
+        "    else:\n",
+        "        freq[value] = 1\n",
+        "print(\"Frequency is: \", freq)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "S_nVoYamBZKt"
+      },
+      "source": [
+        "#### 4.- Plot the histogram. What do you see (shape, values...) ? How can you connect the mean value to the histogram?"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 19,
+      "metadata": {
+        "id": "KZRPHNxmBZKt",
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 449
+        },
+        "outputId": "33fb7f8e-ce9d-48dc-e080-ffe942413acd"
+      },
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 640x480 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
+      ],
+      "source": [
+        "plt.hist(data[\"value\"])\n",
+        "plt.xlabel(\"value\")\n",
+        "plt.ylabel(\"roll\")\n",
+        "plt.show()"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "3At6Y7XvBZKt"
+      },
+      "outputs": [],
+      "source": [
+        "\"\"\" Because the mean will be the most observed event, it makes sense that the bar corresponding to 4 (it's the mean as well) will be the one with > frequency.\"\"\""
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "qHuESBLKBZKt"
+      },
+      "source": [
+        "#### 5.- Read the `roll_the_dice_thousand.csv` from the `data` folder. Plot the frequency distribution as you did before. Has anything changed? Why do you think it changed?"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 21,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 449
+        },
+        "id": "fsPf8hu0BZKt",
+        "outputId": "c37dc9c8-1728-4aca-d2c5-c117821230ee"
+      },
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 640x480 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
+      ],
+      "source": [
+        "data_2 = pd.read_csv(\"/content/roll_the_dice_thousand.csv\")\n",
+        "\n",
+        "plt.hist(data_2[\"value\"])\n",
+        "plt.xlabel(\"value\")\n",
+        "plt.ylabel(\"roll\")\n",
+        "plt.show()"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "f-vbkyQqBZKu"
+      },
+      "outputs": [],
+      "source": [
+        "\"\"\"A think because now we have a larger dataset, the frequency distribution will behave more evenly and more consistently. Also, this provides more~\n",
+        "confidence in the \"random\" of the dice, instead of looking like some bias in some numbers.\"\"\""
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "t1Ch6llDBZKu"
+      },
+      "source": [
+        "## Challenge 4\n",
+        "In the `data` folder of this repository you will find three different files with the prefix `ages_population`. These files contain information about a poll answered by a thousand people regarding their age. Each file corresponds to the poll answers in different neighbourhoods of Barcelona.\n",
+        "\n",
+        "#### 1.- Read the file `ages_population.csv`. Calculate the frequency distribution and plot it as we did during the lesson. Try to guess the range in which the mean and the standard deviation will be by looking at the plot."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 22,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 449
+        },
+        "id": "RLrX1_qbBZKu",
+        "outputId": "0d1f2070-9b7b-499e-890f-f38ed96ce5bd"
+      },
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 640x480 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
+      ],
+      "source": [
+        "ages_pop = pd.read_csv(\"/content/ages_population.csv\")\n",
+        "plt.hist(ages_pop[\"observation\"], bins = 30)\n",
+        "plt.xlabel(\"age\")\n",
+        "plt.ylabel(\"freq\")\n",
+        "plt.show()\n",
+        "# mean around 40 years old\n",
+        "# std around 14"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "dYE5FTAHBZKu"
+      },
+      "source": [
+        "#### 2.- Calculate the exact mean and standard deviation and compare them with your guesses. Do they fall inside the ranges you guessed?"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "print(\"Mean is: \", ages_pop[\"observation\"].mean())\n",
+        "print(\"Std is: \",ages_pop[\"observation\"].std())"
+      ],
+      "metadata": {
+        "id": "JFIswRfFf7wg",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "outputId": "77939674-3a14-4ca5-de11-e5b4432a444b"
+      },
+      "execution_count": 23,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Mean is:  36.56\n",
+            "Std is:  12.81649962597677\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "a36614wIBZKu"
+      },
+      "outputs": [],
+      "source": [
+        "\"\"\"I think i got wrong in mean because of a \"litlle skeweness\" and it might have led to an overestimation of the mean. \"\"\""
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "gUuY2biqBZKu"
+      },
+      "source": [
+        "#### 3.- Now read the file `ages_population2.csv` . Calculate the frequency distribution and plot it."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 24,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 449
+        },
+        "id": "5L6bIUCyBZKu",
+        "outputId": "2cf255f9-d214-43d4-f244-c47968cf452c"
+      },
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 640x480 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
+      ],
+      "source": [
+        "ages_pop_2 = pd.read_csv(\"/content/ages_population2.csv\")\n",
+        "plt.hist(ages_pop_2[\"observation\"], bins = 30)\n",
+        "plt.xlabel(\"age\")\n",
+        "plt.ylabel(\"freq\")\n",
+        "plt.show()"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "0_JLjo7BBZKu"
+      },
+      "source": [
+        "####  4.- What do you see? Is there any difference with the frequency distribution in step 1?"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "9vGCy2k3BZKu"
+      },
+      "outputs": [],
+      "source": [
+        "\"\"\"Very different, even according to the range of ages (suggesting less variability). Now we will have a lower mean age,\n",
+        " so the central tendency of this dataset is lower than the one before. \"\"\""
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "xU0oEWASBZKx"
+      },
+      "source": [
+        "#### 5.- Calculate the mean and standard deviation. Compare the results with the mean and standard deviation in step 2. What do you think?"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 25,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "_DQMDZeDBZKx",
+        "outputId": "b9724ec3-aba9-4462-b083-881d9b97190d"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Mean is:  27.155\n",
+            "Std is:  2.9698139326891835\n"
+          ]
+        }
+      ],
+      "source": [
+        "print(\"Mean is: \", ages_pop_2[\"observation\"].mean())\n",
+        "print(\"Std is: \",ages_pop_2[\"observation\"].std())"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "sPsGm1k5BZKx"
+      },
+      "outputs": [],
+      "source": [
+        "\"\"\" The mean age of  27.155 indicates that the central tendency of the dataset is lower than that of the previous dataset.\n",
+        "Also suggests a younger population compared to the first dataset.\n",
+        "\n",
+        "A really lower std of around 2.97 indicates that the ages in this dataset are more tightly clustered around the mean.\n",
+        "The previous set had a bigger range -> where the values were more spread out.\"\"\""
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "ds7BMS7iBZKx"
+      },
+      "source": [
+        "## Challenge 5\n",
+        "Now is the turn of `ages_population3.csv`.\n",
+        "\n",
+        "#### 1.- Read the file `ages_population3.csv`. Calculate the frequency distribution and plot it."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 26,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 451
+        },
+        "id": "Cws5mdz7BZKx",
+        "outputId": "41de8175-c0a7-464e-fe5c-db9303f299d5"
+      },
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 640x480 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
+      ],
+      "source": [
+        "ages_pop_3 = pd.read_csv(\"/content/ages_population3.csv\")\n",
+        "plt.hist(ages_pop_3[\"observation\"], bins = 30)\n",
+        "plt.xlabel(\"age\")\n",
+        "plt.ylabel(\"freq\")\n",
+        "plt.show()"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "y56wcwUhBZKx"
+      },
+      "source": [
+        "#### 2.- Calculate the mean and standard deviation. Compare the results with the plot in step 1. What is happening?"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 27,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "rQHmqxWpBZKy",
+        "outputId": "4eb41147-38d9-4914-b2bf-ed6b2d744b0d"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Mean is:  41.989\n",
+            "Std is:  16.14470595986593\n"
+          ]
+        }
+      ],
+      "source": [
+        "print(\"Mean is: \", ages_pop_3[\"observation\"].mean())\n",
+        "print(\"Std is: \",ages_pop_3[\"observation\"].std())"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "cUitqZDpBZKy"
+      },
+      "outputs": [],
+      "source": [
+        "\"\"\" Now with a mean age of 41.989, this indicates indicates that the central tendency of this dataset is more similar with the one in Step 1.\n",
+        "And also sugests a similar population as in Step 1.\n",
+        "\n",
+        "With a std of  16.144, this surelly puts us in a population with the age range really similar to step 1, a dataset not so tightly clustered around the mean.\n",
+        "Now we have values more spread out.\"\"\""
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "6MKfWfxOBZKy"
+      },
+      "source": [
+        "#### 3.- Calculate the four quartiles. Use the results to explain your reasoning for question in step 2. How much of a difference is there between the median and the mean?"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 28,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "nvQBXcemBZKy",
+        "outputId": "25e2ee09-9d63-401d-9a71-2c36e6aa455f"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "the first quartile is:  30.0\n",
+            "the second quartile is:  40.0\n",
+            "the third quartile is:  53.0\n",
+            "the fourth quartile is:  77.0\n"
+          ]
+        }
+      ],
+      "source": [
+        "q1 = np.quantile(ages_pop_3, 0.25)\n",
+        "q2 = np.quantile(ages_pop_3, 0.50)\n",
+        "q3 = np.quantile(ages_pop_3, 0.75)\n",
+        "q4 = np.quantile(ages_pop_3, 1)\n",
+        "\n",
+        "print(\"the first quartile is: \", q1)\n",
+        "print(\"the second quartile is: \", q2)\n",
+        "print(\"the third quartile is: \", q3)\n",
+        "print(\"the fourth quartile is: \", q4)\n",
+        "# the median and mean are really similar, not equal, probably because of some outliers/skewness - lot of observations between q3 and q4"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "djzBikVyBZKy"
+      },
+      "source": [
+        "#### 4.- Calculate other percentiles that might be useful to give more arguments to your reasoning."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "UxbbqjQQBZKy"
+      },
+      "outputs": [],
+      "source": [
+        "p10 = np.quantile(ages_pop_3, 0.10)\n",
+        "p15 = np.quantile(ages_pop_3, 0.15)\n",
+        "p85 = np.quantile(ages_pop_3, 0.85)\n",
+        "p90 = np.quantile(ages_pop_3, 0.90)\n",
+        "\n",
+        "\n",
+        "print(\"The percentile 10 is: \", p10)\n",
+        "print(\"The percentile 15 is: \", p15)\n",
+        "print(\"The percentile 85 is: \", p85)\n",
+        "print(\"The percentile 90 is: \", p90)\n",
+        "\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "oGUqhYo_BZKy"
+      },
+      "outputs": [],
+      "source": [
+        "\"\"\" maybe if we had younger ages in p10 and p15, we could get a sample with a younger mean.\n",
+        "p10 is 22 years away from the mean, as for p90 is 27 years away, pushing the mean value a litlle up \"\"\""
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "G9XIzF3aBZKz"
+      },
+      "source": [
+        "## Bonus challenge\n",
+        "Compare the information about the three neighbourhoods. Prepare a report about the three of them. Remember to find out which are their similarities and their differences backing your arguments in basic statistics."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "yuUGzv0uBZKz"
+      },
+      "outputs": [],
+      "source": [
+        "# your code here"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "QNsG6UMqBZKz"
+      },
+      "outputs": [],
+      "source": [
+        "\"\"\"\n",
+        "your comments here\n",
+        "\"\"\""
+      ]
+    }
+  ],
+  "metadata": {
+    "kernelspec": {
+      "display_name": "ironhack-3.7",
+      "language": "python",
+      "name": "ironhack-3.7"
+    },
+    "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.7.3"
+    },
+    "colab": {
+      "provenance": []
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 0
+}
\ No newline at end of file
diff --git a/README.md b/data/README.md
similarity index 100%
rename from README.md
rename to data/README.md