From 5d08dfbc7674bd8f9dcf0a2f5b7ae5e10040c41f Mon Sep 17 00:00:00 2001
From: Miguel Moraes <miguelmoraes94@gmail.com>
Date: Mon, 13 Nov 2023 12:59:51 +0000
Subject: [PATCH] Solved lab

---
 {data => your-code}/ages_population.csv       |    0
 {data => your-code}/ages_population2.csv      |    0
 {data => your-code}/ages_population3.csv      |    0
 your-code/main.ipynb                          | 1256 +++++++++++++++--
 {data => your-code}/roll_the_dice_hundred.csv |    0
 .../roll_the_dice_thousand.csv                |    0
 6 files changed, 1170 insertions(+), 86 deletions(-)
 rename {data => your-code}/ages_population.csv (100%)
 rename {data => your-code}/ages_population2.csv (100%)
 rename {data => your-code}/ages_population3.csv (100%)
 rename {data => your-code}/roll_the_dice_hundred.csv (100%)
 rename {data => your-code}/roll_the_dice_thousand.csv (100%)

diff --git a/data/ages_population.csv b/your-code/ages_population.csv
similarity index 100%
rename from data/ages_population.csv
rename to your-code/ages_population.csv
diff --git a/data/ages_population2.csv b/your-code/ages_population2.csv
similarity index 100%
rename from data/ages_population2.csv
rename to your-code/ages_population2.csv
diff --git a/data/ages_population3.csv b/your-code/ages_population3.csv
similarity index 100%
rename from data/ages_population3.csv
rename to your-code/ages_population3.csv
diff --git a/your-code/main.ipynb b/your-code/main.ipynb
index a0a5b66..606c6d2 100644
--- a/your-code/main.ipynb
+++ b/your-code/main.ipynb
@@ -11,11 +11,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 12,
    "metadata": {},
    "outputs": [],
    "source": [
-    "# Libraries"
+    "import pandas as pd\n",
+    "import random\n",
+    "import matplotlib.pyplot as plt\n",
+    "import numpy as np"
    ]
   },
   {
@@ -29,11 +32,27 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 13,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([1, 5, 2, 5, 5, 4, 2, 2, 1, 2])"
+      ]
+     },
+     "execution_count": 13,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
-    "# your code here"
+    "def game_dice():\n",
+    "    data = np.random.randint(1,6,size = 10)\n",
+    "    return data \n",
+    "\n",
+    "numbers =game_dice()\n",
+    "numbers"
    ]
   },
   {
@@ -45,11 +64,30 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 19,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAioAAAHFCAYAAADcytJ5AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAs1ElEQVR4nO3de3zO9eP/8eeFuYYdyjCGzaIhtsqhcsiQQ0jo07eDMOkkx1l9MBXxwaLoJJUORAc+fUqREiUk5rPM4oNQGYuhlA1lmb1+f3Rz/bqawy62vV+2x/12e99uvV/v1/v9fl6XyvP2vt7v63IZY4wAAAAsVMbpAAAAAGdCUQEAANaiqAAAAGtRVAAAgLUoKgAAwFoUFQAAYC2KCgAAsBZFBQAAWIuiAgAArEVRASyxfv169erVS+Hh4XK73QoNDVWLFi300EMPFfq5Zs6cqTlz5hT6cSXJ5XLp8ccfP+uc9PR0uVwuz+Ln56eQkBA1b95cI0aM0JYtW/Lts3LlSrlcLq1cubJIcp9JnTp1vLJWqlRJTZo00YwZM3S+X+xdp04d9e/f37N+6v0oqj8T4GJGUQEssGTJErVs2VLZ2dmaOnWqli1bpmeffVatWrXSggULCv18RVlUfDF06FCtW7dOq1at0rx589SzZ08tWrRIV155pZ588kmvuU2aNNG6devUpEmTYs/ZqlUrrVu3TuvWrdO8efNUsWJFDR06VElJScWeBShtyjkdAIA0depURUZG6tNPP1W5cv//P8s77rhDU6dOLbTz/Pbbb6pYsWKhHe9ChYeH67rrrvOsd+3aVQkJCbrllls0cuRINW7cWF26dJEkBQUFec0tTpdcconXuTt06KDw8HC9/PLLGjNmjCOZgNKCKyqABQ4dOqQqVap4lZRTypTx/s80Ly9PU6dOVYMGDeR2u1WtWjX169dPP/74o9e8tm3bqnHjxlq9erVatmypihUrasCAAapTp462bNmiVatWeT7OqFOnjme/7OxsPfzww4qMjFT58uVVs2ZNxcfH69ixY17Hz87O1n333aeQkBAFBAToxhtv1I4dOy74vahQoYJee+01+fn5eV1VOdNHP+vXr1f37t0VEhIif39/1a1bV/Hx8V5zdu7cqd69e6tatWpyu91q2LChXnjhhfPOGBQUpKioKB04cMBr/JdfftGgQYNUs2ZNlS9fXpdddpkeeeQR5eTk+HyOn376Sffff79q164tt9utqlWrqlWrVvrss8/OOzdwMeKKCmCBFi1a6NVXX9WwYcN01113qUmTJvLz8zvt3AcffFCzZs3SkCFDdNNNNyk9PV2PPfaYVq5cqdTUVFWpUsUzNzMzU3369NHIkSM1efJklSlTRqNGjdKtt96q4OBgzZw5U5Lkdrsl/XnFJTY2Vj/++KPGjBmjmJgYbdmyRWPHjtXmzZv12WefyeVyyRijnj17au3atRo7dqyaN2+ur776ynP140KFhYWpadOmWrt2rXJzc09b4CTp008/Vffu3dWwYUNNnz5d4eHhSk9P17Jlyzxztm7dqpYtWyo8PFzTpk1T9erV9emnn2rYsGH6+eefNW7cOJ/z5ebmKiMjQ1FRUZ6x48ePq127dvr+++81fvx4xcTE6Msvv1RSUpLS0tK0ZMkSn87Rt29fpaamatKkSYqKitLhw4eVmpqqQ4cO+ZwXuKgZAI77+eefTevWrY0kI8n4+fmZli1bmqSkJHPkyBHPvG3bthlJZtCgQV77r1+/3kgyY8aM8YzFxsYaSebzzz/Pd75GjRqZ2NjYfONJSUmmTJkyJiUlxWv8P//5j5FkPv74Y2OMMZ988omRZJ599lmveZMmTTKSzLhx4876enft2mUkmSeffPKMc26//XYjyRw4cMAYY8wXX3xhJJkvvvjCM6du3bqmbt265vfffz/jcTp37mxq1aplsrKyvMaHDBli/P39zS+//HLWrBEREaZr167mxIkT5sSJE2b37t3mvvvuM35+fuajjz7yzHvppZeMJPPvf//ba/8pU6YYSWbZsmVex4yLi8v3fsyePdszFhAQYOLj48+aDSgN+OgHsEBISIi+/PJLpaSk6IknnlCPHj20Y8cOJSYmKjo6Wj///LMk6YsvvpAkrydGJOmaa65Rw4YN9fnnn3uNX3rppWrfvn2Bc3z00Udq3LixrrrqKuXm5nqWzp07e33scirHXXfd5bV/7969fXnZZ2XO8UTNjh079P333+uee+6Rv7//aeccP35cn3/+uXr16qWKFSt6vaauXbvq+PHjSk5OPmeWjz/+WH5+fvLz81NERIReeeUVPf/88+rWrZtnzooVK1SpUiXdeuutXvue+rP6+5/NuVxzzTWaM2eOJk6cqOTkZJ04ccKn/YGSgqICWKRZs2YaNWqU3n33Xe3bt08jRoxQenq654baU5f9a9SokW/fsLCwfB8LnG7e2Rw4cECbNm3y/KV8agkMDJQxxlOYDh06pHLlyikkJMRr/+rVq/t0vrPZvXu33G63KleufNrtP/30kySpVq1aZzzGoUOHlJubq+effz7fa+rataskeV7T2bRu3VopKSlKTk7WvHnzVKdOHQ0ZMkRr1qzxOlf16tXlcrm89q1WrZrKlSvn80c2CxYsUFxcnF599VW1aNFClStXVr9+/bR//36fjgNc7LhHBbCUn5+fxo0bp6efflr/+9//JMlTDDIzM/P9Bb1v3z6v+1Mk5ftL81yqVKmiChUq6PXXXz/j9lM5cnNzdejQIa+yUlh/ie7du1cbNmxQbGzsGe9PqVq1qiTlu4n4ry699FKVLVtWffv21eDBg087JzIy8px5goOD1axZM0nStddeq2uvvVZXXnmlBg0apLS0NJUpU0YhISFav369jDFe7/vBgweVm5ub78/mXKpUqaJnnnlGzzzzjPbs2aNFixZp9OjROnjwoJYuXerTsYCLGVdUAAtkZmaednzbtm2S/rxaIsnzMc6bb77pNS8lJUXbtm3TDTfcUKDzud1u/f777/nGb7rpJn3//fcKCQlRs2bN8i2nng5q166dJOmtt97y2v/tt98u0PnP5vfff9e9996r3NxcjRw58ozzoqKiVLduXb3++utnfKqmYsWKateunTZu3KiYmJjTvqa/XxUqiMsvv1wjR47U5s2bPd9zc8MNN+jo0aP64IMPvObOnTvXs/18hYeHa8iQIerYsaNSU1PP+zjAxYgrKoAFOnfurFq1aql79+5q0KCB8vLylJaWpmnTpikgIEDDhw+XJNWvX1/333+/nn/+eZUpU0ZdunTxPPVTu3ZtjRgxokDni46O1vz587VgwQJddtll8vf3V3R0tOLj4/Xee++pTZs2GjFihGJiYpSXl6c9e/Zo2bJleuihh3TttdeqU6dOatOmjUaOHKljx46pWbNm+uqrrzRv3jyfXveePXuUnJysvLw8ZWVlaePGjXr99de1e/duTZs2TZ06dTrr/i+88IK6d++u6667TiNGjFB4eLj27NmjTz/91FOinn32WbVu3VrXX3+9HnzwQdWpU0dHjhzRd999p8WLF2vFihU+ZT7l4Ycf1ksvvaTx48frtttuU79+/fTCCy8oLi5O6enpio6O1po1azR58mR17dpVHTp0KPCxs7Ky1K5dO/Xu3VsNGjRQYGCgUlJStHTpUt1yyy3nlRe4aDl8My8AY8yCBQtM7969zeWXX24CAgKMn5+fCQ8PN3379jVbt271mnvy5EkzZcoUExUVZfz8/EyVKlVMnz59TEZGhte82NhY06hRo9OeLz093XTq1MkEBgYaSSYiIsKz7ejRo+bRRx819evXN+XLlzfBwcEmOjrajBgxwuzfv98z7/Dhw2bAgAHmkksuMRUrVjQdO3Y03377rU9P/ZxaypYtay699FLTtGlTEx8fb7Zs2ZJvn9M99WOMMevWrTNdunQxwcHBxu12m7p165oRI0bkO9+AAQNMzZo1jZ+fn6latapp2bKlmThx4llzGvPnEzrdunU77bYXXnjBSDJvvPGGMcaYQ4cOmYEDB5oaNWqYcuXKmYiICJOYmGiOHz+e75hne+rn+PHjZuDAgSYmJsYEBQWZChUqmPr165tx48aZY8eOnTMzUJK4jDnPH6sAAAAoYtyjAgAArEVRAQAA1qKoAAAAa1FUAACAtSgqAADAWhQVAABgrYv6C9/y8vK0b98+BQYG+vxV4QAAwBnGGB05ckRhYWEqU+bs10wu6qKyb98+1a5d2+kYAADgPGRkZJz1h0Wli7yoBAYGSvrzhQYFBTmcBgAAFER2drZq167t+Xv8bC7qonLq456goCCKCgAAF5mC3LbBzbQAAMBaFBUAAGAtigoAALAWRQUAAFiLogIAAKxFUQEAANaiqAAAAGtRVAAAgLUoKgAAwFoUFQAAYC1Hi8rjjz8ul8vltVSvXt3JSAAAwCKO/9ZPo0aN9Nlnn3nWy5Yt62AaAABgE8eLSrly5biKAgAATsvxe1R27typsLAwRUZG6o477tAPP/zgdCQAAGAJR6+oXHvttZo7d66ioqJ04MABTZw4US1bttSWLVsUEhKSb35OTo5ycnI869nZ2cUZFwAAFDOXMcY4HeKUY8eOqW7duho5cqQSEhLybX/88cc1fvz4fONZWVkKCgoqjogAUKrUGb3E6Qj5pD/R7ZxzyF14CpLbV9nZ2QoODi7Q39+Of/TzV5UqVVJ0dLR27tx52u2JiYnKysryLBkZGcWcEAAAFCfHb6b9q5ycHG3btk3XX3/9abe73W653e5iTgUAAJzi6BWVhx9+WKtWrdKuXbu0fv163XrrrcrOzlZcXJyTsQAAgCUcvaLy448/6s4779TPP/+sqlWr6rrrrlNycrIiIiKcjAUAACzhaFGZP3++k6cHAACWs+pmWgAAgL+iqAAAAGtRVAAAgLUoKgAAwFoUFQAAYC2KCgAAsBZFBQAAWIuiAgAArEVRAQAA1qKoAAAAa1FUAACAtSgqAADAWhQVAABgLYoKAACwFkUFAABYi6ICAACsRVEBAADWoqgAAABrUVQAAIC1KCoAAMBaFBUAAGAtigoAALAWRQUAAFiLogIAAKxFUQEAANaiqAAAAGtRVAAAgLUoKgAAwFoUFQAAYC2KCgAAsBZFBQAAWIuiAgAArEVRAQAA1qKoAAAAa1FUAACAtSgqAADAWhQVAABgLYoKAACwFkUFAABYi6ICAACsRVEBAADWoqgAAABrUVQAAIC1KCoAAMBaFBUAAGAtigoAALAWRQUAAFiLogIAAKxFUQEAANaiqAAAAGtRVAAAgLUoKgAAwFoUFQAAYC2KCgAAsBZFBQAAWIuiAgAArEVRAQAA1qKoAAAAa1FUAACAtSgqAADAWtYUlaSkJLlcLsXHxzsdBQAAWMKKopKSkqJZs2YpJibG6SgAAMAijheVo0eP6q677tIrr7yiSy+91Ok4AADAIo4XlcGDB6tbt27q0KHDOefm5OQoOzvbawEAACVXOSdPPn/+fKWmpiolJaVA85OSkjR+/PgiTgUAha/O6CVOR8gn/YluTkcAzsmxKyoZGRkaPny43nzzTfn7+xdon8TERGVlZXmWjIyMIk4JAACc5NgVlQ0bNujgwYNq2rSpZ+zkyZNavXq1ZsyYoZycHJUtW9ZrH7fbLbfbXdxRAQCAQxwrKjfccIM2b97sNXb33XerQYMGGjVqVL6SAgAASh/HikpgYKAaN27sNVapUiWFhITkGwcAAKWT40/9AAAAnImjT/383cqVK52OAAAALMIVFQAAYC2KCgAAsBZFBQAAWIuiAgAArEVRAQAA1qKoAAAAa1FUAACAtSgqAADAWhQVAABgLYoKAACwFkUFAABYi6ICAACsRVEBAADWoqgAAABrUVQAAIC1KCoAAMBaFBUAAGAtigoAALAWRQUAAFiLogIAAKxFUQEAANaiqAAAAGtRVAAAgLUoKgAAwFoUFQAAYC2KCgAAsBZFBQAAWIuiAgAArEVRAQAA1qKoAAAAa1FUAACAtSgqAADAWhQVAABgLYoKAACwFkUFAABYi6ICAACsRVEBAADWoqgAAABrUVQAAIC1KCoAAMBaFBUAAGAtigoAALAWRQUAAFiLogIAAKxFUQEAANaiqAAAAGtRVAAAgLUoKgAAwFoUFQAAYC2KCgAAsBZFBQAAWIuiAgAArEVRAQAA1qKoAAAAa1FUAACAtc6rqBw+fFivvvqqEhMT9csvv0iSUlNTtXfv3kINBwAASrdyvu6wadMmdejQQcHBwUpPT9d9992nypUra+HChdq9e7fmzp1bFDkBAEAp5PMVlYSEBPXv3187d+6Uv7+/Z7xLly5avXp1oYYDAAClm89FJSUlRQ888EC+8Zo1a2r//v2FEgoAAEA6j6Li7++v7OzsfOPbt29X1apVfTrWiy++qJiYGAUFBSkoKEgtWrTQJ5984mskAABQQvlcVHr06KEJEyboxIkTkiSXy6U9e/Zo9OjR+sc//uHTsWrVqqUnnnhCX3/9tb7++mu1b99ePXr00JYtW3yNBQAASiCfi8pTTz2ln376SdWqVdPvv/+u2NhY1atXT4GBgZo0aZJPx+revbu6du2qqKgoRUVFadKkSQoICFBycrKvsQAAQAnk81M/QUFBWrNmjVasWKHU1FTl5eWpSZMm6tChwwUFOXnypN59910dO3ZMLVq0uKBjAQCAksHnonJK+/bt1b59+wsOsHnzZrVo0ULHjx9XQECAFi5cqCuuuOK0c3NycpSTk+NZP929MgAAoOTwuahMmDDhrNvHjh3r0/Hq16+vtLQ0HT58WO+9957i4uK0atWq05aVpKQkjR8/3qfjAwCAi5fPRWXhwoVe6ydOnNCuXbtUrlw51a1b1+eiUr58edWrV0+S1KxZM6WkpOjZZ5/Vyy+/nG9uYmKiEhISPOvZ2dmqXbu2ry8BAABcJHwuKhs3bsw3lp2drf79+6tXr14XHMgY4/Xxzl+53W653e4LPgcAALg4nPc9Kn8VFBSkCRMm6KabblLfvn0LvN+YMWPUpUsX1a5dW0eOHNH8+fO1cuVKLV26tDBiAQCAi1yhFBXpzx8qzMrK8mmfAwcOqG/fvsrMzFRwcLBiYmK0dOlSdezYsbBiAQCAi5jPReW5557zWjfGKDMzU/PmzdONN97o07Fee+01X08PAABKEZ+LytNPP+21XqZMGVWtWlVxcXFKTEwstGAAAAA+F5Vdu3YVRQ4AAIB8fP4KfQAAgOJSoCsqt9xyS4EP+P777593GAAAgL8qUFEJDg4u6hwAAAD5FKiozJ49u6hzAAAA5MM9KgAAwFrn9YVv//nPf/Tvf/9be/bs0R9//OG1LTU1tVCCAQAA+HxF5bnnntPdd9+tatWqaePGjbrmmmsUEhKiH374QV26dCmKjAAAoJTyuajMnDlTs2bN0owZM1S+fHmNHDlSy5cv17Bhw3z+Cn0AAICz8bmo7NmzRy1btpQkVahQQUeOHJEk9e3bV++8807hpgMAAKWaz0WlevXqOnTokCQpIiJCycnJkv78xlpjTOGmAwAApZrPRaV9+/ZavHixJOmee+7RiBEj1LFjR91+++3q1atXoQcEAAClV4Gf+vnggw/UvXt3zZo1S3l5eZKkgQMHqnLlylqzZo26d++ugQMHFllQAABQ+hS4qNx6662qUqWK4uLiNGDAANWvX1+SdNttt+m2224rsoAAAKD0KvBHP3v27NHQoUO1cOFCXXHFFWrdurVmz56tY8eOFWU+AABQihW4qISFhemRRx7Rjh07tGLFCtWtW1fDhg1TjRo1dO+992rdunVFmRMAAJRC5/UV+rGxsXrjjTeUmZmp6dOna9u2bWrdurUaNWpU2PkAAEApdl5foX9KQECA2rVrp/T0dH377bfasWNHYeUCAAA4vysqv/32m9544w3FxsYqKipKCxYsUEJCgtLT0ws5HgAAKM18uqLy1Vdf6fXXX9e7776r3Nxc3XLLLfrss8/Url27osoHAABKsQIXlaioKH3//fe6+uqrNWXKFPXu3VvBwcFFmQ0AAJRyBS4qN954o+655x5deeWVRZkHAADAo8BF5bnnnivKHAAAAPmc1820AAAAxYGiAgAArEVRAQAA1rqgonL8+PHCygEAAJCPz0UlLy9P//rXv1SzZk0FBATohx9+kCQ99thjeu211wo9IAAAKL18LioTJ07UnDlzNHXqVJUvX94zHh0drVdffbVQwwEAgNLN56Iyd+5czZo1S3fddZfKli3rGY+JidG3335bqOEAAEDp5nNR2bt3r+rVq5dvPC8vTydOnCiUUAAAANJ5FJVGjRrpyy+/zDf+7rvv6uqrry6UUAAAAJKPP0ooSePGjVPfvn21d+9e5eXl6f3339f27ds1d+5cffTRR0WREQAAlFI+X1Hp3r27FixYoI8//lgul0tjx47Vtm3btHjxYnXs2LEoMgIAgFLK5ysqktS5c2d17ty5sLMAAAB48fmKSkpKitavX59vfP369fr6668LJRQAAIB0HkVl8ODBysjIyDe+d+9eDR48uFBCAQAASOdRVLZu3aomTZrkG7/66qu1devWQgkFAAAgnUdRcbvdOnDgQL7xzMxMlSt3Xre8AAAAnJbPRaVjx45KTExUVlaWZ+zw4cMaM2YMT/0AAIBC5fMlkGnTpqlNmzaKiIjwfMFbWlqaQkNDNW/evEIPCAAASi+fi0rNmjW1adMmvfXWW/rmm29UoUIF3X333brzzjvl5+dXFBkBAEApdV43lVSqVEn3339/YWcBAADwUqCismjRInXp0kV+fn5atGjRWefefPPNhRIMAACgQEWlZ8+e2r9/v6pVq6aePXuecZ7L5dLJkycLKxsAACjlClRU8vLyTvvPAAAARcnnx5MBAACKi0830+bl5WnOnDl6//33lZ6eLpfLpcjISN16663q27evXC5XUeUEAAClUIGvqBhjdPPNN+vee+/V3r17FR0drUaNGmn37t3q37+/evXqVZQ5AQBAKVTgKypz5szR6tWr9fnnn6tdu3Ze21asWKGePXtq7ty56tevX6GHBAAApVOBr6i88847GjNmTL6SIknt27fX6NGj9dZbbxVqOAAAULoVuKhs2rRJN9544xm3d+nSRd98802hhAIAAJB8KCq//PKLQkNDz7g9NDRUv/76a6GEAgAAkHwoKidPnlS5cme+paVs2bLKzc0tlFAAAACSDzfTGmPUv39/ud3u027PyckptFAAAACSD0UlLi7unHN44gcAABSmAheV2bNnF2UOAACAfPgKfQAAYC2KCgAAsJajRSUpKUnNmzdXYGCgqlWrpp49e2r79u1ORgIAABZxtKisWrVKgwcPVnJyspYvX67c3Fx16tRJx44dczIWAACwhE+/nlzYli5d6rU+e/ZsVatWTRs2bFCbNm0cSgUAAGzhaFH5u6ysLElS5cqVT7s9JyfH6/tasrOziyUXAABwhjVFxRijhIQEtW7dWo0bNz7tnKSkJI0fP76Yk6G41Bm9xOkI+aQ/0e2cc8hdeEpybgDnx5qnfoYMGaJNmzbpnXfeOeOcxMREZWVleZaMjIxiTAgAAIqbFVdUhg4dqkWLFmn16tWqVavWGee53e4zfoU/AAAoeRwtKsYYDR06VAsXLtTKlSsVGRnpZBwAAGAZR4vK4MGD9fbbb+vDDz9UYGCg9u/fL0kKDg5WhQoVnIwGAAAs4Og9Ki+++KKysrLUtm1b1ahRw7MsWLDAyVgAAMASjn/0AwAAcCbWPPUDAADwdxQVAABgLYoKAACwFkUFAABYi6ICAACsRVEBAADWoqgAAABrUVQAAIC1KCoAAMBaFBUAAGAtigoAALAWRQUAAFiLogIAAKxFUQEAANaiqAAAAGtRVAAAgLUoKgAAwFoUFQAAYC2KCgAAsBZFBQAAWIuiAgAArEVRAQAA1qKoAAAAa1FUAACAtSgqAADAWhQVAABgLYoKAACwFkUFAABYi6ICAACsRVEBAADWoqgAAABrUVQAAIC1KCoAAMBaFBUAAGAtigoAALAWRQUAAFiLogIAAKxFUQEAANaiqAAAAGtRVAAAgLUoKgAAwFoUFQAAYC2KCgAAsBZFBQAAWIuiAgAArEVRAQAA1qKoAAAAa1FUAACAtSgqAADAWhQVAABgLYoKAACwFkUFAABYi6ICAACsRVEBAADWoqgAAABrUVQAAIC1KCoAAMBaFBUAAGAtigoAALCWo0Vl9erV6t69u8LCwuRyufTBBx84GQcAAFjG0aJy7NgxXXnllZoxY4aTMQAAgKXKOXnyLl26qEuXLk5GAAAAFnO0qPgqJydHOTk5nvXs7GwH0wAAgKJ2URWVpKQkjR8/vtjOV2f0kmI7V0GlP9HtnHMu1twAAPzdRfXUT2JiorKysjxLRkaG05EAAEARuqiuqLjdbrndbqdjAACAYnJRXVEBAACli6NXVI4eParvvvvOs75r1y6lpaWpcuXKCg8PdzAZAACwgaNF5euvv1a7du086wkJCZKkuLg4zZkzx6FUAADAFo4WlbZt28oY42QEAABgMe5RAQAA1qKoAAAAa1FUAACAtSgqAADAWhQVAABgLYoKAACwFkUFAABYi6ICAACsRVEBAADWoqgAAABrUVQAAIC1KCoAAMBaFBUAAGAtigoAALAWRQUAAFiLogIAAKxFUQEAANaiqAAAAGtRVAAAgLUoKgAAwFoUFQAAYC2KCgAAsBZFBQAAWIuiAgAArEVRAQAA1qKoAAAAa1FUAACAtSgqAADAWhQVAABgLYoKAACwFkUFAABYi6ICAACsRVEBAADWoqgAAABrUVQAAIC1KCoAAMBaFBUAAGAtigoAALAWRQUAAFiLogIAAKxFUQEAANaiqAAAAGtRVAAAgLUoKgAAwFoUFQAAYC2KCgAAsBZFBQAAWIuiAgAArEVRAQAA1qKoAAAAa1FUAACAtSgqAADAWhQVAABgLYoKAACwFkUFAABYi6ICAACsRVEBAADWoqgAAABrUVQAAIC1HC8qM2fOVGRkpPz9/dW0aVN9+eWXTkcCAACWcLSoLFiwQPHx8XrkkUe0ceNGXX/99erSpYv27NnjZCwAAGAJR4vK9OnTdc899+jee+9Vw4YN9cwzz6h27dp68cUXnYwFAAAs4VhR+eOPP7RhwwZ16tTJa7xTp05au3atQ6kAAIBNyjl14p9//lknT55UaGio13hoaKj2799/2n1ycnKUk5PjWc/KypIkZWdnF0nGvJzfiuS4F6Igr5XchYfcxYvcxYvcxask5z7fYxpjzj3ZOGTv3r1Gklm7dq3X+MSJE039+vVPu8+4ceOMJBYWFhYWFpYSsGRkZJyzLzh2RaVKlSoqW7ZsvqsnBw8ezHeV5ZTExEQlJCR41vPy8vTLL78oJCRELperSPOWNtnZ2apdu7YyMjIUFBTkdJwSj/e7ePF+Fy/e7+J1MbzfxhgdOXJEYWFh55zrWFEpX768mjZtquXLl6tXr16e8eXLl6tHjx6n3cftdsvtdnuNXXLJJUUZs9QLCgqy9l/0koj3u3jxfhcv3u/iZfv7HRwcXKB5jhUVSUpISFDfvn3VrFkztWjRQrNmzdKePXs0cOBAJ2MBAABLOFpUbr/9dh06dEgTJkxQZmamGjdurI8//lgRERFOxgIAAJZwtKhI0qBBgzRo0CCnY+Bv3G63xo0bl++jNhQN3u/ixftdvHi/i1dJe79dxhTk2SAAAIDi5/hv/QAAAJwJRQUAAFiLogIAAKxFUQEAANaiqMBLUlKSmjdvrsDAQFWrVk09e/bU9u3bnY5VKiQlJcnlcik+Pt7pKCXa3r171adPH4WEhKhixYq66qqrtGHDBqdjlUi5ubl69NFHFRkZqQoVKuiyyy7ThAkTlJeX53S0EmH16tXq3r27wsLC5HK59MEHH3htN8bo8ccfV1hYmCpUqKC2bdtqy5YtzoS9ABQVeFm1apUGDx6s5ORkLV++XLm5uerUqZOOHTvmdLQSLSUlRbNmzVJMTIzTUUq0X3/9Va1atZKfn58++eQTbd26VdOmTeMbrovIlClT9NJLL2nGjBnatm2bpk6dqieffFLPP/+809FKhGPHjunKK6/UjBkzTrt96tSpmj59umbMmKGUlBRVr15dHTt21JEjR4o56YXh8WSc1U8//aRq1app1apVatOmjdNxSqSjR4+qSZMmmjlzpiZOnKirrrpKzzzzjNOxSqTRo0frq6++0pdfful0lFLhpptuUmhoqF577TXP2D/+8Q9VrFhR8+bNczBZyeNyubRw4UL17NlT0p9XU8LCwhQfH69Ro0ZJknJychQaGqopU6bogQcecDCtb7iigrPKysqSJFWuXNnhJCXX4MGD1a1bN3Xo0MHpKCXeokWL1KxZM/3f//2fqlWrpquvvlqvvPKK07FKrNatW+vzzz/Xjh07JEnffPON1qxZo65duzqcrOTbtWuX9u/fr06dOnnG3G63YmNjtXbtWgeT+c7xb6aFvYwxSkhIUOvWrdW4cWOn45RI8+fPV2pqqlJSUpyOUir88MMPevHFF5WQkKAxY8bov//9r4YNGya3261+/fo5Ha/EGTVqlLKystSgQQOVLVtWJ0+e1KRJk3TnnXc6Ha3E279/vyQpNDTUazw0NFS7d+92ItJ5o6jgjIYMGaJNmzZpzZo1TkcpkTIyMjR8+HAtW7ZM/v7+TscpFfLy8tSsWTNNnjxZknT11Vdry5YtevHFFykqRWDBggV688039fbbb6tRo0ZKS0tTfHy8wsLCFBcX53S8UsHlcnmtG2PyjdmOooLTGjp0qBYtWqTVq1erVq1aTscpkTZs2KCDBw+qadOmnrGTJ09q9erVmjFjhnJyclS2bFkHE5Y8NWrU0BVXXOE11rBhQ7333nsOJSrZ/vnPf2r06NG64447JEnR0dHavXu3kpKSKCpFrHr16pL+vLJSo0YNz/jBgwfzXWWxHfeowIsxRkOGDNH777+vFStWKDIy0ulIJdYNN9ygzZs3Ky0tzbM0a9ZMd911l9LS0igpRaBVq1b5HrffsWMHv9heRH777TeVKeP910zZsmV5PLkYREZGqnr16lq+fLln7I8//tCqVavUsmVLB5P5jisq8DJ48GC9/fbb+vDDDxUYGOj5nDM4OFgVKlRwOF3JEhgYmO/en0qVKikkJIR7gorIiBEj1LJlS02ePFm33Xab/vvf/2rWrFmaNWuW09FKpO7du2vSpEkKDw9Xo0aNtHHjRk2fPl0DBgxwOlqJcPToUX333Xee9V27diktLU2VK1dWeHi44uPjNXnyZF1++eW6/PLLNXnyZFWsWFG9e/d2MPV5MMBfSDrtMnv2bKejlQqxsbFm+PDhTsco0RYvXmwaN25s3G63adCggZk1a5bTkUqs7OxsM3z4cBMeHm78/f3NZZddZh555BGTk5PjdLQS4Ysvvjjt/6/j4uKMMcbk5eWZcePGmerVqxu3223atGljNm/e7Gzo88D3qAAAAGtxjwoAALAWRQUAAFiLogIAAKxFUQEAANaiqAAAAGtRVAAAgLUoKgAAwFoUFQDnJT09XS6XS2lpaZKklStXyuVy6fDhw47mOps5c+bokksucToGAB9QVIBSqH///nK5XHK5XCpXrpzCw8P14IMP6tdffy3S89apU0cul0vJycle4/Hx8Wrbtm2RnhvAxYmiApRSN954ozIzM5Wenq5XX31Vixcv1qBBg4r8vP7+/ho1alSRn6c4nThxwukIQIlFUQFKKbfbrerVq6tWrVrq1KmTbr/9di1btsyzPS8vTxMmTFCtWrXkdrt11VVXaenSpRd83gceeEDJycn6+OOPzzinbdu2io+P9xrr2bOn+vfv71mvU6eOJk6cqH79+ikgIEARERH68MMP9dNPP6lHjx4KCAhQdHS0vv7663zH/+CDDxQVFSV/f3917NhRGRkZXtsXL16spk2byt/fX5dddpnGjx+v3Nxcz3aXy6WXXnpJPXr0UKVKlTRx4sTzezMAnBNFBYB++OEHLV26VH5+fp6xZ599VtOmTdNTTz2lTZs2qXPnzrr55pu1c+fOCzpXnTp1NHDgQCUmJiovL++CjvX000+rVatW2rhxo7p166a+ffuqX79+6tOnj1JTU1WvXj3169dPf/1Js99++02TJk3SG2+8oa+++krZ2dm64447PNs//fRT9enTR8OGDdPWrVv18ssva86cOZo0aZLXuceNG6cePXpo8+bN/BowUJQc/lFEAA6Ii4szZcuWNZUqVTL+/v6eX12dPn26Z05YWJiZNGmS137Nmzc3gwYNMsYYs2vXLiPJbNy40Rjz/3/J9ddffz3jeSMiIszTTz9tDh48aAIDA83cuXONMcYMHz7cxMbGeuad7leke/To4flV2FPH6tOnj2c9MzPTSDKPPfaYZ2zdunVGksnMzDTGGDN79mwjySQnJ3vmbNu2zUgy69evN8YYc/3115vJkyd7nXvevHmmRo0annVJJj4+/oyvE0Dh4YoKUEq1a9dOaWlpWr9+vYYOHarOnTtr6NChkqTs7Gzt27dPrVq18tqnVatW2rZt2wWfu2rVqnr44Yc1duxY/fHHH+d9nJiYGM8/h4aGSpKio6PzjR08eNAzVq5cOTVr1syz3qBBA11yySWe17VhwwZNmDBBAQEBnuW+++5TZmamfvvtN89+fz0GgKJDUQFKqUqVKqlevXqKiYnRc889p5ycHI0fP95rjsvl8lo3xuQbO18JCQn6/fffNXPmzHzbypQp4/VxjXT6G1b/+lHVqVynG/v7R0ynew1/nTt+/HilpaV5ls2bN2vnzp3y9/f3zK9UqdI5XyOAC0dRASDpz3sunnrqKe3bt09BQUEKCwvTmjVrvOasXbtWDRs2LJTzBQQE6LHHHtOkSZOUnZ3tta1q1arKzMz0rJ88eVL/+9//CuW8ubm5XjfYbt++XYcPH1aDBg0kSU2aNNH27dtVr169fEuZMvwvEyhu/FcHQNKfT9o0atRIkydPliT985//1JQpU7RgwQJt375do0ePVlpamoYPH15o57z//vsVHBysd955x2u8ffv2WrJkiZYsWaJvv/1WgwYNKrQvkvPz89PQoUO1fv16paam6u6779Z1112na665RpI0duxYzZ07V48//ri2bNmibdu2acGCBXr00UcL5fwAfENRAeCRkJCgV155RRkZGRo2bJgeeughPfTQQ4qOjtbSpUu1aNEiXX755YV2Pj8/P/3rX//S8ePHvcYHDBiguLg49evXT7GxsYqMjFS7du0K5ZwVK1bUqFGj1Lt3b7Vo0UIVKlTQ/PnzPds7d+6sjz76SMuXL1fz5s113XXXafr06YqIiCiU8wPwjcv8/YNgAAAAS3BFBQAAWIuiAgAArEVRAQAA1qKoAAAAa1FUAACAtSgqAADAWhQVAABgLYoKAACwFkUFAABYi6ICAACsRVEBAADWoqgAAABr/T9WKlOdsYK5LQAAAABJRU5ErkJggg==",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
-    "# your code here"
+    "sorted_numbers = np.sort(numbers)\n",
+    "\n",
+    "plt.bar(np.arange(1, 11), sorted_numbers)\n",
+    "\n",
+    "plt.xlabel('Roll Number')\n",
+    "plt.ylabel('Dice Value')\n",
+    "plt.title('Sorted Dice Rolls')\n",
+    "\n",
+    "plt.show()\n"
    ]
   },
   {
@@ -61,11 +99,30 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 18,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
-    "# your code here"
+    "plt.hist(numbers, bins=np.arange(0.5, 7.5, 1), edgecolor='black')\n",
+    "\n",
+    "# Set labels and title\n",
+    "plt.xlabel('Dice Value')\n",
+    "plt.ylabel('Frequency')\n",
+    "plt.title('Dice Roll Frequency')\n",
+    "\n",
+    "# Show the plot\n",
+    "plt.show()"
    ]
   },
   {
@@ -74,9 +131,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "\"\"\"\n",
-    "your comments here\n",
-    "\"\"\""
+    "#I dont see any relation between them except that they are both related to the same 10 rolls of a dice"
    ]
   },
   {
@@ -91,11 +146,23 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 20,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "2.9"
+      ]
+     },
+     "execution_count": 20,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
-    "# your code here"
+    "mean = numbers.sum()/len(numbers)\n",
+    "mean\n"
    ]
   },
   {
@@ -107,11 +174,37 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 21,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "2.9"
+      ]
+     },
+     "execution_count": 21,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
-    "# your code here"
+    "def mean(numbers):\n",
+    "    numbers_frequency = {}\n",
+    "    for value in numbers:\n",
+    "        if value in numbers_frequency:\n",
+    "            numbers_frequency[value] += 1\n",
+    "        else:\n",
+    "            numbers_frequency[value] = 1\n",
+    "    sum_numbers = 0\n",
+    "    total_frequency = 0\n",
+    "    for value, frequency in numbers_frequency.items():\n",
+    "        sum_numbers += value * frequency\n",
+    "        total_frequency += frequency\n",
+    "    mean = sum_numbers / total_frequency\n",
+    "    return mean\n",
+    "\n",
+    "mean(numbers)"
    ]
   },
   {
@@ -124,11 +217,35 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 22,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "2.0"
+      ]
+     },
+     "execution_count": 22,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
-    "# your code here"
+    "def median(numbers):\n",
+    "    sorted_numbers = np.sort(numbers)\n",
+    "    size = len(sorted_numbers)\n",
+    "    \n",
+    "    if size % 2 == 0:\n",
+    "        middle1 = sorted_numbers[size // 2 - 1]\n",
+    "        middle2 = sorted_numbers[size // 2]\n",
+    "        median_value = (middle1 + middle2) / 2\n",
+    "    else:\n",
+    "        median_value = sorted_numbers[size // 2]\n",
+    "\n",
+    "    return median_value\n",
+    "\n",
+    "median(numbers)"
    ]
   },
   {
@@ -140,11 +257,41 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 23,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(2, 2.0, 5)"
+      ]
+     },
+     "execution_count": 23,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
-    "# your code here"
+    "def quartiles(numbers):\n",
+    "    sorted_numbers = np.sort(numbers)\n",
+    "    size = len(numbers)\n",
+    "    q2 = median(numbers)\n",
+    "\n",
+    "    if size % 2 == 0:\n",
+    "        first_half = sorted_numbers[:size // 2]\n",
+    "        second_half = sorted_numbers[size // 2:]\n",
+    "        q1 = median(first_half)\n",
+    "        q3 = median(second_half)\n",
+    "        \n",
+    "    else:\n",
+    "        first_half = sorted_numbers[:size // 2]\n",
+    "        second_half = sorted_numbers[size // 2 + 1:]\n",
+    "        q1 = median(first_half)\n",
+    "        q3 = median(second_half)\n",
+    "\n",
+    "    return q1, q2, q3\n",
+    "\n",
+    "quartiles(numbers)"
    ]
   },
   {
@@ -158,11 +305,132 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 24,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>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",
+       "    <tr>\n",
+       "      <th>...</th>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>95</th>\n",
+       "      <td>95</td>\n",
+       "      <td>95</td>\n",
+       "      <td>4</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>96</th>\n",
+       "      <td>96</td>\n",
+       "      <td>96</td>\n",
+       "      <td>6</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>97</th>\n",
+       "      <td>97</td>\n",
+       "      <td>97</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>98</th>\n",
+       "      <td>98</td>\n",
+       "      <td>98</td>\n",
+       "      <td>3</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>99</th>\n",
+       "      <td>99</td>\n",
+       "      <td>99</td>\n",
+       "      <td>6</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "<p>100 rows × 3 columns</p>\n",
+       "</div>"
+      ],
+      "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\n",
+       "..         ...   ...    ...\n",
+       "95          95    95      4\n",
+       "96          96    96      6\n",
+       "97          97    97      1\n",
+       "98          98    98      3\n",
+       "99          99    99      6\n",
+       "\n",
+       "[100 rows x 3 columns]"
+      ]
+     },
+     "execution_count": 24,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
-    "# your code here"
+    "roll_dice = pd.read_csv('roll_the_dice_hundred.csv')\n",
+    "roll_dice"
    ]
   },
   {
@@ -171,9 +439,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "\"\"\"\n",
-    "your comments here\n",
-    "\"\"\""
+    "# I see two columns with the rolls and one with the roll value"
    ]
   },
   {
@@ -185,11 +451,22 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 25,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "3.74"
+      ]
+     },
+     "execution_count": 25,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
-    "# your code here"
+    "mean(roll_dice[\"value\"])"
    ]
   },
   {
@@ -201,11 +478,37 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 26,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "6    23\n",
+       "4    22\n",
+       "2    17\n",
+       "3    14\n",
+       "1    12\n",
+       "5    12\n",
+       "Name: value, dtype: int64"
+      ]
+     },
+     "execution_count": 26,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
-    "# your code here"
+    "numbers_frequency = roll_dice[\"value\"].value_counts()\n",
+    "frequency_numbers = {}\n",
+    "\n",
+    "for value in numbers:\n",
+    "    if value in frequency_numbers:\n",
+    "        frequency_numbers[value] += 1\n",
+    "    else:\n",
+    "        frequency_numbers[value] = 1\n",
+    "\n",
+    "numbers_frequency"
    ]
   },
   {
@@ -217,11 +520,26 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 27,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
-    "# your code here"
+    "plt.bar(numbers_frequency.index, numbers_frequency.values)\n",
+    "plt.xlabel('Value')\n",
+    "plt.ylabel('Frequency')\n",
+    "plt.title('Frequency Distribution')\n",
+    "plt.show()"
    ]
   },
   {
@@ -230,9 +548,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "\"\"\"\n",
-    "your comments here\n",
-    "\"\"\""
+    "# I dont really have input to give regarding this"
    ]
   },
   {
@@ -244,11 +560,191 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 30,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>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>5</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>1</td>\n",
+       "      <td>1</td>\n",
+       "      <td>6</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>2</td>\n",
+       "      <td>2</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>3</td>\n",
+       "      <td>3</td>\n",
+       "      <td>6</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>4</td>\n",
+       "      <td>4</td>\n",
+       "      <td>5</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>...</th>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>995</th>\n",
+       "      <td>995</td>\n",
+       "      <td>995</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>996</th>\n",
+       "      <td>996</td>\n",
+       "      <td>996</td>\n",
+       "      <td>4</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>997</th>\n",
+       "      <td>997</td>\n",
+       "      <td>997</td>\n",
+       "      <td>4</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>998</th>\n",
+       "      <td>998</td>\n",
+       "      <td>998</td>\n",
+       "      <td>3</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>999</th>\n",
+       "      <td>999</td>\n",
+       "      <td>999</td>\n",
+       "      <td>6</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "<p>1000 rows × 3 columns</p>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "     Unnamed: 0  roll  value\n",
+       "0             0     0      5\n",
+       "1             1     1      6\n",
+       "2             2     2      1\n",
+       "3             3     3      6\n",
+       "4             4     4      5\n",
+       "..          ...   ...    ...\n",
+       "995         995   995      1\n",
+       "996         996   996      4\n",
+       "997         997   997      4\n",
+       "998         998   998      3\n",
+       "999         999   999      6\n",
+       "\n",
+       "[1000 rows x 3 columns]"
+      ]
+     },
+     "execution_count": 30,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
-    "# your code here"
+    "roll_thousand = pd.read_csv('roll_the_dice_thousand.csv')\n",
+    "roll_thousand"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "1    175\n",
+       "3    175\n",
+       "4    168\n",
+       "2    167\n",
+       "6    166\n",
+       "5    149\n",
+       "Name: value, dtype: int64"
+      ]
+     },
+     "execution_count": 31,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "numbers_frequency = roll_thousand[\"value\"].value_counts()\n",
+    "frequency_numbers = {}\n",
+    "\n",
+    "for value in numbers:\n",
+    "    if value in frequency_numbers:\n",
+    "        frequency_numbers[value] += 1\n",
+    "    else:\n",
+    "        frequency_numbers[value] = 1\n",
+    "\n",
+    "numbers_frequency"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.bar(numbers_frequency.index, numbers_frequency.values)\n",
+    "plt.xlabel('Value')\n",
+    "plt.ylabel('Frequency')\n",
+    "plt.title('Frequency Distribution')\n",
+    "plt.show()"
    ]
   },
   {
@@ -257,9 +753,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "\"\"\"\n",
-    "your comments here\n",
-    "\"\"\""
+    "# The values look more even, as we have an universe 10x bigger its expectable to get more even results"
    ]
   },
   {
@@ -274,11 +768,172 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 33,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>observation</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>68.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>12.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>45.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>38.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>49.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>...</th>\n",
+       "      <td>...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>995</th>\n",
+       "      <td>27.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>996</th>\n",
+       "      <td>47.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>997</th>\n",
+       "      <td>53.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>998</th>\n",
+       "      <td>33.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>999</th>\n",
+       "      <td>31.0</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "<p>1000 rows × 1 columns</p>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "     observation\n",
+       "0           68.0\n",
+       "1           12.0\n",
+       "2           45.0\n",
+       "3           38.0\n",
+       "4           49.0\n",
+       "..           ...\n",
+       "995         27.0\n",
+       "996         47.0\n",
+       "997         53.0\n",
+       "998         33.0\n",
+       "999         31.0\n",
+       "\n",
+       "[1000 rows x 1 columns]"
+      ]
+     },
+     "execution_count": 33,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
-    "# your code here"
+    "age_population = pd.read_csv('ages_population.csv')\n",
+    "age_population"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 34,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "39.0    45\n",
+       "41.0    36\n",
+       "30.0    34\n",
+       "35.0    33\n",
+       "43.0    32\n",
+       "        ..\n",
+       "73.0     1\n",
+       "82.0     1\n",
+       "70.0     1\n",
+       "71.0     1\n",
+       "69.0     1\n",
+       "Name: observation, Length: 72, dtype: int64"
+      ]
+     },
+     "execution_count": 34,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "numbers_frequency = age_population[\"observation\"].value_counts()\n",
+    "frequency_numbers = {}\n",
+    "\n",
+    "for value in numbers:\n",
+    "    if value in frequency_numbers:\n",
+    "        frequency_numbers[value] += 1\n",
+    "    else:\n",
+    "        frequency_numbers[value] = 1\n",
+    "\n",
+    "numbers_frequency"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 35,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjMAAAHFCAYAAAAHcXhbAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAzMklEQVR4nO3deXRUVb7+/6cEUiSQhEkSIlOEMA8iIILIIBCBiApyLzQiINCNghIErop0N8FWRslFpRlUDCAyOICiKE2YpcFrGMLYC1FDQAGDgCQGCJDs3x/+Ul8qAyRFoGrH92uts5a1z65zPjtlyLP2OWeXwxhjBAAAYKnbvF0AAADAjSDMAAAAqxFmAACA1QgzAADAaoQZAABgNcIMAACwGmEGAABYjTADAACsRpgBAABWI8wARWjBggVyOBx5bmPHjvV2ecVKzp916dKlFRoaqo4dO2ry5MlKSUnJ9Z6YmBg5HI5Cnef8+fOKiYnRpk2bCvW+vM5Vs2ZNPfTQQ4U6zvUsWbJEM2fOzHOfw+FQTExMkZ4P8EUlvV0AUBzFxcWpXr16bm1hYWFeqqZ4y/5ZX758WSkpKdq6daumTp2q1157TcuXL1fnzp1dfYcOHaquXbsW6vjnz5/XxIkTJUkdOnQo8Ps8OZcnlixZov3792vUqFG59m3fvl1Vq1a96TUA3kaYAW6CRo0aqUWLFgXqe/nyZTkcDpUsya+jJ3L+rB977DE999xzatu2rXr16qXDhw8rJCREklS1atWb/sf9/PnzCggIuCXnup57773Xq+cHbhUuMwG30KZNm+RwOPTee+9pzJgxuuOOO+R0OvXdd99JktatW6dOnTopKChIAQEBuu+++7R+/fpcx1m9erXuuusuOZ1OhYeH67XXXst1WePIkSNyOBxasGBBrvfndfnh8OHD6tevnypXriyn06n69evrn//8Z571L126VOPHj1dYWJiCgoLUuXNnHTp0KNd51qxZo06dOik4OFgBAQGqX7++Jk+eLEl677335HA4tH379lzve/nll1WqVCkdP378uj/TvFSvXl0zZsxQWlqa5s2b52rP69LPhg0b1KFDB1WsWFH+/v6qXr26HnvsMZ0/f15HjhzR7bffLkmaOHGi65LWoEGD3I63a9cu9e7dW+XLl1etWrXyPVe2lStXqkmTJipdurTuvPNOvfHGG277sy+hHTlyxK09++effcmrQ4cOWr16tZKTk90uuWXL63Pev3+/HnnkEZUvX16lS5fWXXfdpYULF+Z5noJ+zoC3EWaAmyAzM1NXrlxx2642btw4HT16VHPnztVnn32mypUra/HixYqMjFRQUJAWLlyoDz74QBUqVNCDDz7oFmjWr1+vRx55RIGBgVq2bJmmT5+uDz74QHFxcR7Xe/DgQbVs2VL79+/XjBkz9PnnnysqKkojR450XWK52ksvvaTk5GS98847euutt3T48GH16NFDmZmZrj7z589X9+7dlZWV5RrnyJEj9eOPP0qS+vTpo9DQ0FyB6cqVK5o3b5569ux5Q5fmunfvrhIlSmjLli359jly5IiioqLk5+end999V2vWrNGUKVNUpkwZXbp0SVWqVNGaNWskSUOGDNH27du1fft2/e1vf3M7Tq9evVS7dm19+OGHmjt37jXrSkxM1KhRo/Tcc89p5cqVatOmjaKjo/Xaa68VeoyzZ8/Wfffdp9DQUFdteYXDbIcOHVKbNm104MABvfHGG1qxYoUaNGigQYMGadq0abn6F+RzBnyCAVBk4uLijKQ8t8uXL5uNGzcaSaZdu3Zu70tPTzcVKlQwPXr0cGvPzMw0TZs2Nffcc4+rrVWrViYsLMxcuHDB1ZaammoqVKhgrv6VTkpKMpJMXFxcrjolmQkTJrheP/jgg6Zq1arm3Llzbv2eeeYZU7p0aXPmzBljjHHV3717d7d+H3zwgZFktm/fbowxJi0tzQQFBZm2bduarKysfH9eEyZMMH5+fubnn392tS1fvtxIMps3b873fcb8v591QkJCvn1CQkJM/fr13c539c/oo48+MpJMYmJivsc4depUrp9XzuP9/e9/z3ff1WrUqGEcDkeu83Xp0sUEBQWZ9PR0t7ElJSW59cv++W/cuNHVFhUVZWrUqJFn7Tnr7tu3r3E6nebo0aNu/bp162YCAgLMr7/+6nae633OgK9gZga4CRYtWqSEhAS37ep7Yh577DG3/tu2bdOZM2c0cOBAt9mcrKwsde3aVQkJCUpPT1d6eroSEhLUq1cvlS5d2vX+wMBA9ejRw6NaL168qPXr16tnz54KCAhwO3/37t118eJFff31127vefjhh91eN2nSRJKUnJzsGk9qaqqGDx9+zaeHnn76aUnS22+/7WqbNWuWGjdurHbt2nk0nqsZY665/6677pKfn5/+8pe/aOHChfrhhx88Ok/Oz/NaGjZsqKZNm7q19evXT6mpqdq1a5dH5y+oDRs2qFOnTqpWrZpb+6BBg3T+/PlcszrX+5wBX0GYAW6C+vXrq0WLFm7b1apUqeL2+ueff5Yk9e7dW6VKlXLbpk6dKmOMzpw5o7NnzyorK0uhoaG5zplXW0GcPn1aV65c0Ztvvpnr3N27d5ck/fLLL27vqVixottrp9MpSbpw4YIk6dSpU5J03RtgQ0JC1KdPH82bN0+ZmZnau3evvvrqKz3zzDMejeVq6enpOn369DUvVdWqVUvr1q1T5cqVNWLECNWqVUu1atXS66+/Xqhz5fw8r+Van93p06cLdd7COn36dJ61Zv+Mcp7/ep8z4Ct4fALwgpyzFZUqVZIkvfnmm/k+gRISEuJ68unkyZO59udsy565ycjIcGvP+QerfPnyKlGihJ544gmNGDEiz3OHh4dfYzS5Zd80m31/zLVER0frvffe06effqo1a9aoXLlyevzxxwt1vrysXr1amZmZ132c+v7779f999+vzMxM7dixQ2+++aZGjRqlkJAQ9e3bt0DnKszaNdf67LLDQ36fXc5QWVgVK1bUiRMncrVn32id/f8hYBvCDOAD7rvvPpUrV04HDx685qyEn5+f7rnnHq1YsULTp093/dFLS0vTZ5995tY3JCREpUuX1t69e93aP/30U7fXAQEB6tixo3bv3q0mTZrIz8/vhsfTpk0bBQcHa+7cuerbt+81/9g3b95cbdq00dSpU7V//3795S9/UZkyZW7o/EePHtXYsWMVHBysYcOGFeg9JUqUUKtWrVSvXj29//772rVrl/r27VvksxEHDhzQnj173C41LVmyRIGBgbr77rsl/b64niTt3btXdevWdfVbtWpVruM5nc4C19apUyetXLlSx48fd5uxWrRokQICAniUG9YizAA+oGzZsnrzzTc1cOBAnTlzRr1791blypV16tQp7dmzR6dOndKcOXMkSf/4xz/UtWtXdenSRWPGjFFmZqamTp2qMmXK6MyZM65jOhwO9e/fX++++65q1aqlpk2b6ptvvtGSJUtynf/1119X27Ztdf/99+vpp59WzZo1lZaWpu+++06fffaZNmzYUOjxzJgxQ0OHDlXnzp315z//WSEhIfruu++0Z88ezZo1y61/dHS0+vTpI4fDoeHDhxfqXPv373fd45OSkqKvvvpKcXFxKlGihFauXOmaJcrL3LlztWHDBkVFRal69eq6ePGi3n33XUlyLbYXGBioGjVq6NNPP1WnTp1UoUIFVapUyRU4CissLEwPP/ywYmJiVKVKFS1evFjx8fGaOnWqAgICJEktW7ZU3bp1NXbsWF25ckXly5fXypUrtXXr1lzHa9y4sVasWKE5c+aoefPmuu222/Jd42jChAn6/PPP1bFjR/39739XhQoV9P7772v16tWaNm2agoODPRoT4HXevgMZKE6u94RN9lMiH374YZ77N2/ebKKiokyFChVMqVKlzB133GGioqJy9V+1apVp0qSJ8fPzM9WrVzdTpkzJ8+mZc+fOmaFDh5qQkBBTpkwZ06NHD3PkyJE8n85JSkoygwcPNnfccYcpVaqUuf32202bNm3MK6+8ct3683ty6osvvjDt27c3ZcqUMQEBAaZBgwZm6tSpucadkZFhnE6n6dq1a54/l7zkfHLMz8/PVK5c2bRv395MmjTJpKSk5HpPzp/R9u3bTc+ePU2NGjWM0+k0FStWNO3btzerVq1ye9+6detMs2bNjNPpNJLMwIED3Y536tSp657LmN+fZoqKijIfffSRadiwofHz8zM1a9Y0sbGxud7/7bffmsjISBMUFGRuv/128+yzz5rVq1fneprpzJkzpnfv3qZcuXLG4XC4nTOvz3nfvn2mR48eJjg42Pj5+ZmmTZvm+twK+zkD3uYw5jq3+wOwQkxMjCZOnHjdJ3h80WeffaaHH35Yq1evdt10DAAFxWUmAF5z8OBBJScna8yYMbrrrrvUrVs3b5cEwEI8mg3Aa4YPH66HH35Y5cuX19KlSwv9jdYAIElcZgIAAFZjZgYAAFiNMAMAAKxGmAEAAFYr9k8zZWVl6fjx4woMDOTmQgAALGGMUVpamsLCwnTbbdeeeyn2Yeb48eO5viEWAADY4dixY9f90tpiH2YCAwMl/f7DCAoK8nI1AACgIFJTU1WtWjXX3/FrKfZhJvvSUlBQEGEGAADLFOQWEW4ABgAAViPMAAAAqxFmAACA1QgzAADAaoQZAABgNcIMAACwGmEGAABYjTADAACsRpgBAABWI8wAAACrEWYAAIDVCDMAAMBqhBkAAGA1wgwAALAaYQYAAFitpLcLAPDHVvPF1W6vj0yJ8lIlAGzFzAwAALAaYQYAAFiNMAMAAKxGmAEAAFYjzAAAAKsRZgAAgNUIMwAAwGqEGQAAYDXCDAAAsBphBgAAWI0wAwAArEaYAQAAViPMAAAAqxFmAACA1QgzAADAaoQZAABgNcIMAACwGmEGAABYjTADAACsRpgBAABWI8wAAACrEWYAAIDVCDMAAMBqhBkAAGA1wgwAALAaYQYAAFiNMAMAAKxGmAEAAFYjzAAAAKsRZgAAgNUIMwAAwGqEGQAAYDXCDAAAsBphBgAAWM1nwszkyZPlcDg0atQoV5sxRjExMQoLC5O/v786dOigAwcOeK9IAADgc3wizCQkJOitt95SkyZN3NqnTZum2NhYzZo1SwkJCQoNDVWXLl2UlpbmpUoBAICv8XqY+e233/T444/r7bffVvny5V3txhjNnDlT48ePV69evdSoUSMtXLhQ58+f15IlS7xYMQAA8CVeDzMjRoxQVFSUOnfu7NaelJSkkydPKjIy0tXmdDrVvn17bdu2Ld/jZWRkKDU11W0DAADFV0lvnnzZsmXatWuXEhIScu07efKkJCkkJMStPSQkRMnJyfkec/LkyZo4cWLRFgoAAHyW12Zmjh07pujoaC1evFilS5fOt5/D4XB7bYzJ1Xa1cePG6dy5c67t2LFjRVYzAADwPV6bmdm5c6dSUlLUvHlzV1tmZqa2bNmiWbNm6dChQ5J+n6GpUqWKq09KSkqu2ZqrOZ1OOZ3Om1c4AADwKV6bmenUqZP27dunxMRE19aiRQs9/vjjSkxM1J133qnQ0FDFx8e73nPp0iVt3rxZbdq08VbZAADAx3htZiYwMFCNGjVyaytTpowqVqzoah81apQmTZqkiIgIRUREaNKkSQoICFC/fv28UTIAAPBBXr0B+Hqef/55XbhwQcOHD9fZs2fVqlUrrV27VoGBgd4uDQAA+AiHMcZ4u4ibKTU1VcHBwTp37pyCgoK8XQ6AHGq+uNrt9ZEpUV6qBIAvKczfb6+vMwMAAHAjCDMAAMBqhBkAAGA1wgwAALAaYQYAAFiNMAMAAKxGmAEAAFYjzAAAAKsRZgAAgNUIMwAAwGqEGQAAYDXCDAAAsBphBgAAWI0wAwAArEaYAQAAViPMAAAAqxFmAACA1QgzAADAaoQZAABgNcIMAACwGmEGAABYjTADAACsRpgBAABWI8wAAACrlfR2AQBQUDVfXO32+siUKC9VAsCXMDMDAACsRpgBAABWI8wAAACrEWYAAIDVCDMAAMBqhBkAAGA1wgwAALAaYQYAAFiNMAMAAKxGmAEAAFYjzAAAAKsRZgAAgNUIMwAAwGqEGQAAYDXCDAAAsFpJbxcAwDM1X1ydq+3IlCgvVAIA3sXMDAAAsBphBgAAWI0wAwAArEaYAQAAViPMAAAAqxFmAACA1QgzAADAaqwzA6BAcq5rw5o2AHwFMzMAAMBqhBkAAGA1wgwAALAaYQYAAFiNMAMAAKxGmAEAAFbj0WwA1svrsfGcbdntAIofZmYAAIDVCDMAAMBqhBkAAGA1wgwAALAaYQYAAFiNMAMAAKxGmAEAAFZjnRkANySvNV4A4FZiZgYAAFiNMAMAAKxGmAEAAFbzapiZM2eOmjRpoqCgIAUFBal169b68ssvXfuNMYqJiVFYWJj8/f3VoUMHHThwwIsVAwAAX+PVMFO1alVNmTJFO3bs0I4dO/TAAw/okUcecQWWadOmKTY2VrNmzVJCQoJCQ0PVpUsXpaWlebNsAADgQ7waZnr06KHu3burTp06qlOnjl599VWVLVtWX3/9tYwxmjlzpsaPH69evXqpUaNGWrhwoc6fP68lS5Z4s2wAAOBDfOaemczMTC1btkzp6elq3bq1kpKSdPLkSUVGRrr6OJ1OtW/fXtu2bcv3OBkZGUpNTXXbAABA8eX1dWb27dun1q1b6+LFiypbtqxWrlypBg0auAJLSEiIW/+QkBAlJyfne7zJkydr4sSJN7VmwDY514KRbu56MPmtPcOaNABuBq/PzNStW1eJiYn6+uuv9fTTT2vgwIE6ePCga7/D4XDrb4zJ1Xa1cePG6dy5c67t2LFjN612AADgfV6fmfHz81Pt2rUlSS1atFBCQoJef/11vfDCC5KkkydPqkqVKq7+KSkpuWZrruZ0OuV0Om9u0QAAwGd4fWYmJ2OMMjIyFB4ertDQUMXHx7v2Xbp0SZs3b1abNm28WCEAAPAlXp2Zeemll9StWzdVq1ZNaWlpWrZsmTZt2qQ1a9bI4XBo1KhRmjRpkiIiIhQREaFJkyYpICBA/fr182bZAADAh3g1zPz888964okndOLECQUHB6tJkyZas2aNunTpIkl6/vnndeHCBQ0fPlxnz55Vq1attHbtWgUGBnqzbAAA4EO8Gmbmz59/zf0Oh0MxMTGKiYm5NQUBAADr+Nw9MwAAAIXh9aeZAPiWW70mjS/4I44ZKE6YmQEAAFYjzAAAAKsRZgAAgNUIMwAAwGqEGQAAYDXCDAAAsBphBgAAWI0wAwAArOZRmElKSirqOgAAADziUZipXbu2OnbsqMWLF+vixYtFXRMAAECBeRRm9uzZo2bNmmnMmDEKDQ3VsGHD9M033xR1bQAAANflUZhp1KiRYmNj9dNPPykuLk4nT55U27Zt1bBhQ8XGxurUqVNFXScAAECebugG4JIlS6pnz5764IMPNHXqVH3//fcaO3asqlatqgEDBujEiRNFVScAAECebijM7NixQ8OHD1eVKlUUGxursWPH6vvvv9eGDRv0008/6ZFHHimqOgEAAPJU0pM3xcbGKi4uTocOHVL37t21aNEide/eXbfd9ns2Cg8P17x581SvXr0iLRYAACAnj8LMnDlzNHjwYD355JMKDQ3Ns0/16tU1f/78GyoOwB9XzRdXu70+MiXKS5UA8HUehZnDhw9ft4+fn58GDhzoyeEBAAAKzKN7ZuLi4vThhx/mav/www+1cOHCGy4KAACgoDwKM1OmTFGlSpVytVeuXFmTJk264aIAAAAKyqMwk5ycrPDw8FztNWrU0NGjR2+4KAAAgILyKMxUrlxZe/fuzdW+Z88eVaxY8YaLAgAAKCiPwkzfvn01cuRIbdy4UZmZmcrMzNSGDRsUHR2tvn37FnWNAAAA+fLoaaZXXnlFycnJ6tSpk0qW/P0QWVlZGjBgAPfMADcBjykDQP48CjN+fn5avny5/vGPf2jPnj3y9/dX48aNVaNGjaKuDwAA4Jo8CjPZ6tSpozp16hRVLQAAAIXmUZjJzMzUggULtH79eqWkpCgrK8tt/4YNG4qkOAAAgOvxKMxER0drwYIFioqKUqNGjeRwOIq6LgAAgALxKMwsW7ZMH3zwgbp3717U9QAAABSKR49m+/n5qXbt2kVdCwAAQKF5FGbGjBmj119/XcaYoq4HAACgUDy6zLR161Zt3LhRX375pRo2bKhSpUq57V+xYkWRFAcUZ6wdAwBFw6MwU65cOfXs2bOoawEAACg0j8JMXFxcUdcBAADgEY/umZGkK1euaN26dZo3b57S0tIkScePH9dvv/1WZMUBAABcj0czM8nJyeratauOHj2qjIwMdenSRYGBgZo2bZouXryouXPnFnWdAAAAefJoZiY6OlotWrTQ2bNn5e/v72rv2bOn1q9fX2TFAQAAXI/HTzP9+9//lp+fn1t7jRo19NNPPxVJYQAAAAXh0cxMVlaWMjMzc7X/+OOPCgwMvOGiAAAACsqjmZkuXbpo5syZeuuttyRJDodDv/32myZMmMBXHABexvo1AP5oPAoz//u//6uOHTuqQYMGunjxovr166fDhw+rUqVKWrp0aVHXCAAAkC+PwkxYWJgSExO1dOlS7dq1S1lZWRoyZIgef/xxtxuCAQAAbjaPwowk+fv7a/DgwRo8eHBR1gMAAFAoHoWZRYsWXXP/gAEDPCoGAACgsDwKM9HR0W6vL1++rPPnz8vPz08BAQGEGQAAcMt49Gj22bNn3bbffvtNhw4dUtu2bbkBGAAA3FIefzdTThEREZoyZUquWRsAAICbyeMbgPNSokQJHT9+vCgPCVgv57ovEmu/eFNh1uFhzR7ADh6FmVWrVrm9NsboxIkTmjVrlu67774iKQwAAKAgPAozjz76qNtrh8Oh22+/XQ888IBmzJhRFHUBAAAUiEdhJisrq6jrAAAA8EiR3QAMAADgDR7NzIwePbrAfWNjYz05BQAAQIF4FGZ2796tXbt26cqVK6pbt64k6dtvv1WJEiV09913u/o5HI6iqRIAACAfHoWZHj16KDAwUAsXLlT58uUl/b6Q3pNPPqn7779fY8aMKdIiAQAA8uNRmJkxY4bWrl3rCjKSVL58eb3yyiuKjIwkzACWYB0VAMWBRzcAp6am6ueff87VnpKSorS0tBsuCgAAoKA8CjM9e/bUk08+qY8++kg//vijfvzxR3300UcaMmSIevXqVdQ1AgAA5Mujy0xz587V2LFj1b9/f12+fPn3A5UsqSFDhmj69OlFWiAAAMC1eBRmAgICNHv2bE2fPl3ff/+9jDGqXbu2ypQpU9T1AQAAXNMNLZp34sQJnThxQnXq1FGZMmVkjCmqugAAAArEozBz+vRpderUSXXq1FH37t114sQJSdLQoUN5kgkAANxSHoWZ5557TqVKldLRo0cVEBDgau/Tp4/WrFlTZMUBAABcj0f3zKxdu1b/+te/VLVqVbf2iIgIJScnF0lhAAAABeHRzEx6errbjEy2X375RU6n84aLAgAAKCiPwky7du20aNEi12uHw6GsrCxNnz5dHTt2LLLiAAAArsejMDN9+nTNmzdP3bp106VLl/T888+rUaNG2rJli6ZOnVrg40yePFktW7ZUYGCgKleurEcffVSHDh1y62OMUUxMjMLCwuTv768OHTrowIEDnpQNAACKIY/CTIMGDbR3717dc8896tKli9LT09WrVy/t3r1btWrVKvBxNm/erBEjRujrr79WfHy8rly5osjISKWnp7v6TJs2TbGxsZo1a5YSEhIUGhqqLl268LUJAABAkgc3AF++fFmRkZGaN2+eJk6ceEMnz/nkU1xcnCpXrqydO3eqXbt2MsZo5syZGj9+vOtrEhYuXKiQkBAtWbJEw4YNu6HzAwAA+xV6ZqZUqVLav3+/HA5HkRdz7tw5SVKFChUkSUlJSTp58qQiIyNdfZxOp9q3b69t27bleYyMjAylpqa6bQAAoPjy6NHsAQMGaP78+ZoyZUqRFWKM0ejRo9W2bVs1atRIknTy5ElJUkhIiFvfkJCQfB8Bnzx58g3PGAHeUvPF1bnajkyJ8kIlAGAPj8LMpUuX9M477yg+Pl4tWrTI9Z1MsbGxhT7mM888o71792rr1q259uWcBTLG5DszNG7cOI0ePdr1OjU1VdWqVSt0PQAAwA6FCjM//PCDatasqf379+vuu++WJH377bdufTy5/PTss89q1apV2rJli9tCfKGhoZJ+n6GpUqWKqz0lJSXXbE02p9PJWjcAAPyBFCrMRERE6MSJE9q4caOk37++4I033sg3WFyPMUbPPvusVq5cqU2bNik8PNxtf3h4uEJDQxUfH69mzZpJ+n1WaPPmzYV6BBwAABRfhQozOb8V+8svv3R7jLqwRowYoSVLlujTTz9VYGCg6x6Z4OBg+fv7y+FwaNSoUZo0aZIiIiIUERGhSZMmKSAgQP369fP4vAAAoPjw6J6ZbDnDTWHNmTNHktShQwe39ri4OA0aNEiS9Pzzz+vChQsaPny4zp49q1atWmnt2rUKDAy8oXMDAIDioVBhxuFw5Lon5kYe0S5IGHI4HIqJiVFMTIzH5wEAAMVXoS8zDRo0yHWD7cWLF/XUU0/lepppxYoVRVchAADANRQqzAwcONDtdf/+/Yu0GMB2OdeJYY2YP468PnvWDQJujUKFmbi4uJtVBwAAgEc8+qJJAAAAX0GYAQAAViPMAAAAqxFmAACA1QgzAADAaoQZAABgtRv6OgPgj4r1QwDAdzAzAwAArEaYAQAAViPMAAAAqxFmAACA1QgzAADAaoQZAABgNcIMAACwGuvMANeRc00Z1pP5Y2ONIcD3MDMDAACsRpgBAABWI8wAAACrEWYAAIDVCDMAAMBqhBkAAGA1wgwAALAa68wA/z/WD8GtwtpFQNFiZgYAAFiNMAMAAKxGmAEAAFYjzAAAAKsRZgAAgNUIMwAAwGo8mg0Af0A8Ho7ihJkZAABgNcIMAACwGmEGAABYjTADAACsRpgBAABWI8wAAACrEWYAAIDVWGcGf0issQFb8P8qcH3MzAAAAKsRZgAAgNUIMwAAwGqEGQAAYDXCDAAAsBphBgAAWI0wAwAArMY6MyjWcq7RIbFOB4qvvNak4XcAfwTMzAAAAKsRZgAAgNUIMwAAwGqEGQAAYDXCDAAAsBphBgAAWI0wAwAArMY6MwBgGdaOAdwxMwMAAKxGmAEAAFYjzAAAAKsRZgAAgNUIMwAAwGqEGQAAYDXCDAAAsBrrzKBQfHl9i5y1+UpdAICbi5kZAABgNcIMAACwmlfDzJYtW9SjRw+FhYXJ4XDok08+cdtvjFFMTIzCwsLk7++vDh066MCBA94pFgAA+CSvhpn09HQ1bdpUs2bNynP/tGnTFBsbq1mzZikhIUGhoaHq0qWL0tLSbnGlAADAV3n1BuBu3bqpW7duee4zxmjmzJkaP368evXqJUlauHChQkJCtGTJEg0bNuxWlgoAAHyUz94zk5SUpJMnTyoyMtLV5nQ61b59e23bts2LlQEAAF/is49mnzx5UpIUEhLi1h4SEqLk5OR835eRkaGMjAzX69TU1JtTIAAA8Ak+G2ayORwOt9fGmFxtV5s8ebImTpx4s8tCARTFmjSsHQMAuB6fvcwUGhoq6f/N0GRLSUnJNVtztXHjxuncuXOu7dixYze1TgAA4F0+G2bCw8MVGhqq+Ph4V9ulS5e0efNmtWnTJt/3OZ1OBQUFuW0AAKD48uplpt9++03fffed63VSUpISExNVoUIFVa9eXaNGjdKkSZMUERGhiIgITZo0SQEBAerXr58XqwYAAL7Eq2Fmx44d6tixo+v16NGjJUkDBw7UggUL9Pzzz+vChQsaPny4zp49q1atWmnt2rUKDAz0VskAAMDHeDXMdOjQQcaYfPc7HA7FxMQoJibm1hUFAACs4rP3zAAAABSEzz+aDQB/BEWxlAHwR8XMDAAAsBphBgAAWI0wAwAArEaYAQAAViPMAAAAqxFmAACA1QgzAADAaqwzg1su53oaR6ZEscYGYBl+Z+FLmJkBAABWI8wAAACrEWYAAIDVCDMAAMBqhBkAAGA1wgwAALAaYQYAAFiNdWZgHda3AG6O/H638lob6lbXAFwLMzMAAMBqhBkAAGA1wgwAALAaYQYAAFiNMAMAAKxGmAEAAFYjzAAAAKuxzgyKxK1chwIAgKsxMwMAAKxGmAEAAFYjzAAAAKsRZgAAgNUIMwAAwGqEGQAAYDXCDAAAsBrrzBRTOdd9kVj7BQBQPDEzAwAArEaYAQAAViPMAAAAqxFmAACA1QgzAADAaoQZAABgNR7NBgAUmZzLQlxrSYjC9L1RLFdRvDEzAwAArEaYAQAAViPMAAAAqxFmAACA1QgzAADAaoQZAABgNcIMAACwGuvMIN/1F27lGhAAUFR8da0b3DzMzAAAAKsRZgAAgNUIMwAAwGqEGQAAYDXCDAAAsBphBgAAWI0wAwAArMY6MzcorzUKimLdgoIc15Njs6YCgFvtZv3bVRTHRfHAzAwAALAaYQYAAFiNMAMAAKxGmAEAAFYjzAAAAKsRZgAAgNUIMwAAwGqsM+NlrB0DAL4lv3+Xb3Stm+KyLo4v/s1hZgYAAFiNMAMAAKxmRZiZPXu2wsPDVbp0aTVv3lxfffWVt0sCAAA+wufDzPLlyzVq1CiNHz9eu3fv1v33369u3brp6NGj3i4NAAD4AJ8PM7GxsRoyZIiGDh2q+vXra+bMmapWrZrmzJnj7dIAAIAP8Okwc+nSJe3cuVORkZFu7ZGRkdq2bZuXqgIAAL7Epx/N/uWXX5SZmamQkBC39pCQEJ08eTLP92RkZCgjI8P1+ty5c5Kk1NTUm1JjVsZ5t9epqal5thX0/dc6Bn3p62t9pcL9Dniz77WOQV/6FnXfvBSmry8rzN+4G5F9XGPM9TsbH/bTTz8ZSWbbtm1u7a+88oqpW7dunu+ZMGGCkcTGxsbGxsZWDLZjx45dNy/49MxMpUqVVKJEiVyzMCkpKblma7KNGzdOo0ePdr3OysrSmTNnVLFiRTkcjhuqJzU1VdWqVdOxY8cUFBR0Q8fyNcV5bFLxHh9jsxNjsxNju3WMMUpLS1NYWNh1+/p0mPHz81Pz5s0VHx+vnj17utrj4+P1yCOP5Pkep9Mpp9Pp1lauXLkirSsoKMgnPuiboTiPTSre42NsdmJsdmJst0ZwcHCB+vl0mJGk0aNH64knnlCLFi3UunVrvfXWWzp69Kieeuopb5cGAAB8gM+HmT59+uj06dN6+eWXdeLECTVq1EhffPGFatSo4e3SAACAD/D5MCNJw4cP1/Dhw71dhpxOpyZMmJDrMlZxUJzHJhXv8TE2OzE2OzE23+QwpiDPPAEAAPgmn140DwAA4HoIMwAAwGqEGQAAYDXCDAAAsBphphBmz56t8PBwlS5dWs2bN9dXX33l7ZIKbcuWLerRo4fCwsLkcDj0ySefuO03xigmJkZhYWHy9/dXhw4ddODAAe8UW0iTJ09Wy5YtFRgYqMqVK+vRRx/VoUOH3PrYOr45c+aoSZMmrsWsWrdurS+//NK139Zx5WXy5MlyOBwaNWqUq83W8cXExMjhcLhtoaGhrv22jivbTz/9pP79+6tixYoKCAjQXXfdpZ07d7r22zq+mjVr5vrcHA6HRowYIcnecUnSlStX9Ne//lXh4eHy9/fXnXfeqZdffllZWVmuPlaOz/NvTvpjWbZsmSlVqpR5++23zcGDB010dLQpU6aMSU5O9nZphfLFF1+Y8ePHm48//thIMitXrnTbP2XKFBMYGGg+/vhjs2/fPtOnTx9TpUoVk5qa6p2CC+HBBx80cXFxZv/+/SYxMdFERUWZ6tWrm99++83Vx9bxrVq1yqxevdocOnTIHDp0yLz00kumVKlSZv/+/cYYe8eV0zfffGNq1qxpmjRpYqKjo13tto5vwoQJpmHDhubEiROuLSUlxbXf1nEZY8yZM2dMjRo1zKBBg8z//d//maSkJLNu3Trz3XffufrYOr6UlBS3zyw+Pt5IMhs3bjTG2DsuY37/bsOKFSuazz//3CQlJZkPP/zQlC1b1sycOdPVx8bxEWYK6J577jFPPfWUW1u9evXMiy++6KWKblzOMJOVlWVCQ0PNlClTXG0XL140wcHBZu7cuV6o8MakpKQYSWbz5s3GmOI3vvLly5t33nmn2IwrLS3NREREmPj4eNO+fXtXmLF5fBMmTDBNmzbNc5/N4zLGmBdeeMG0bds23/22j+9q0dHRplatWiYrK8v6cUVFRZnBgwe7tfXq1cv079/fGGPv58ZlpgK4dOmSdu7cqcjISLf2yMhIbdu2zUtVFb2kpCSdPHnSbZxOp1Pt27e3cpznzp2TJFWoUEFS8RlfZmamli1bpvT0dLVu3brYjGvEiBGKiopS586d3dptH9/hw4cVFham8PBw9e3bVz/88IMk+8e1atUqtWjRQv/1X/+lypUrq1mzZnr77bdd+20fX7ZLly5p8eLFGjx4sBwOh/Xjatu2rdavX69vv/1WkrRnzx5t3bpV3bt3l2Tv52bFCsDe9ssvvygzMzPXN3WHhITk+kZvm2WPJa9xJicne6MkjxljNHr0aLVt21aNGjWSZP/49u3bp9atW+vixYsqW7asVq5cqQYNGrj+gbF1XJK0bNky7dq1SwkJCbn22fy5tWrVSosWLVKdOnX0888/65VXXlGbNm104MABq8clST/88IPmzJmj0aNH66WXXtI333yjkSNHyul0asCAAdaPL9snn3yiX3/9VYMGDZJk9/+PkvTCCy/o3LlzqlevnkqUKKHMzEy9+uqr+tOf/iTJ3vERZgrB4XC4vTbG5GorDorDOJ955hnt3btXW7duzbXP1vHVrVtXiYmJ+vXXX/Xxxx9r4MCB2rx5s2u/reM6duyYoqOjtXbtWpUuXTrffjaOr1u3bq7/bty4sVq3bq1atWpp4cKFuvfeeyXZOS5JysrKUosWLTRp0iRJUrNmzXTgwAHNmTNHAwYMcPWzdXzZ5s+fr27duiksLMyt3dZxLV++XIsXL9aSJUvUsGFDJSYmatSoUQoLC9PAgQNd/WwbH5eZCqBSpUoqUaJErlmYlJSUXOnVZtlPWdg+zmeffVarVq3Sxo0bVbVqVVe77ePz8/NT7dq11aJFC02ePFlNmzbV66+/bv24du7cqZSUFDVv3lwlS5ZUyZIltXnzZr3xxhsqWbKkawy2ju9qZcqUUePGjXX48GHrP7cqVaqoQYMGbm3169fX0aNHJdn/+yZJycnJWrdunYYOHepqs31c//M//6MXX3xRffv2VePGjfXEE0/oueee0+TJkyXZOz7CTAH4+fmpefPmio+Pd2uPj49XmzZtvFRV0QsPD1doaKjbOC9duqTNmzdbMU5jjJ555hmtWLFCGzZsUHh4uNt+28eXkzFGGRkZ1o+rU6dO2rdvnxITE11bixYt9PjjjysxMVF33nmn1eO7WkZGhv7zn/+oSpUq1n9u9913X66lD7799lvVqFFDUvH4fYuLi1PlypUVFRXlarN9XOfPn9dtt7n/6S9RooTr0Wxrx+ed+47tk/1o9vz5883BgwfNqFGjTJkyZcyRI0e8XVqhpKWlmd27d5vdu3cbSSY2Ntbs3r3b9Yj5lClTTHBwsFmxYoXZt2+f+dOf/uTzj+Rle/rpp01wcLDZtGmT22OV58+fd/WxdXzjxo0zW7ZsMUlJSWbv3r3mpZdeMrfddptZu3atMcbeceXn6qeZjLF3fGPGjDGbNm0yP/zwg/n666/NQw89ZAIDA13/btg6LmN+f4y+ZMmS5tVXXzWHDx8277//vgkICDCLFy929bF5fJmZmaZ69ermhRdeyLXP5nENHDjQ3HHHHa5Hs1esWGEqVapknn/+eVcfG8dHmCmEf/7zn6ZGjRrGz8/P3H333a5Hfm2yceNGIynXNnDgQGPM74/lTZgwwYSGhhqn02natWtn9u3b592iCyivcUkycXFxrj62jm/w4MGu//duv/1206lTJ1eQMcbeceUnZ5ixdXzZ63OUKlXKhIWFmV69epkDBw649ts6rmyfffaZadSokXE6naZevXrmrbfecttv8/j+9a9/GUnm0KFDufbZPK7U1FQTHR1tqlevbkqXLm3uvPNOM378eJORkeHqY+P4HMYY45UpIQAAgCLAPTMAAMBqhBkAAGA1wgwAALAaYQYAAFiNMAMAAKxGmAEAAFYjzAAAAKsRZgAAgNUIMwB8wrZt21SiRAl17drV26UAsAwrAAPwCUOHDlXZsmX1zjvv6ODBg6pevbq3SwJgCWZmAHhdenq6PvjgAz399NN66KGHtGDBArf9q1atUkREhPz9/dWxY0ctXLhQDodDv/76q6vPtm3b1K5dO/n7+6tatWoaOXKk0tPTXftnz56tiIgIlS5dWiEhIerdu/ctGh2Am40wA8Drli9frrp166pu3brq37+/4uLilD1pfOTIEfXu3VuPPvqoEhMTNWzYMI0fP97t/fv27dODDz6oXr16ae/evVq+fLm2bt2qZ555RpK0Y8cOjRw5Ui+//LIOHTqkNWvWqF27drd8nABuDi4zAfC6++67T//93/+t6OhoXblyRVWqVNHSpUvVuXNnvfjii1q9erX27dvn6v/Xv/5Vr776qs6ePaty5cppwIAB8vf317x581x9tm7dqvbt2ys9PV1ffPGFnnzySf34448KDAz0xhAB3ETMzADwqkOHDumbb75R3759JUklS5ZUnz599O6777r2t2zZ0u0999xzj9vrnTt3asGCBSpbtqxre/DBB5WVlaWkpCR16dJFNWrU0J133qknnnhC77//vs6fP39rBgjgpivp7QIA/LHNnz9fV65c0R133OFqM8aoVKlSOnv2rIwxcjgcbu/JOaGclZWlYcOGaeTIkbmOX716dfn5+WnXrl3atGmT1q5dq7///e+KiYlRQkKCypUrd1PGBeDWIcwA8JorV65o0aJFmjFjhiIjI932PfbYY3r//fdVr149ffHFF277duzY4fb67rvv1oEDB1S7du18z1WyZEl17txZnTt31oQJE1SuXDlt2LBBvXr1KroBAfAKwgwAr/n888919uxZDRkyRMHBwW77evfurfnz52vFihWKjY3VCy+8oCFDhigxMdH1tFP2jM0LL7yge++9VyNGjNCf//xnlSlTRv/5z38UHx+vN998U59//rl++OEHtWvXTuXLl9cXX3yhrKws1a1b91YPGcBNwD0zALxm/vz56ty5c64gI/0+M5OYmKizZ8/qo48+0ooVK9SkSRPNmTPH9TST0+mUJDVp0kSbN2/W4cOHdf/996tZs2b629/+pipVqkiSypUrpxUrVuiBBx5Q/fr1NXfuXC1dulQNGza8dYMFcNPwNBMA67z66quaO3eujh075u1SAPgALjMB8HmzZ89Wy5YtVbFiRf373//W9OnTXWvIAABhBoDPO3z4sF555RWdOXNG1atX15gxYzRu3DhvlwXAR3CZCQAAWI0bgAEAgNUIMwAAwGqEGQAAYDXCDAAAsBphBgAAWI0wAwAArEaYAQAAViPMAAAAqxFmAACA1f4/juoZb1H1joEAAAAASUVORK5CYII=",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.bar(numbers_frequency.index, numbers_frequency.values)\n",
+    "plt.xlabel('Ages')\n",
+    "plt.ylabel('Frequency')\n",
+    "plt.title('Frequency Distribution')\n",
+    "plt.show()"
    ]
   },
   {
@@ -290,11 +945,42 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 36,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "36.56"
+      ]
+     },
+     "execution_count": 36,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
-    "# your code here"
+    "age_population[\"observation\"].mean()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 37,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "12.816499625976762"
+      ]
+     },
+     "execution_count": 37,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "age_population[\"observation\"].std()"
    ]
   },
   {
@@ -303,9 +989,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "\"\"\"\n",
-    "your comments here\n",
-    "\"\"\""
+    "#I had the impression that the mean would be between 30 and 40 and that the std would be around 10 years"
    ]
   },
   {
@@ -317,11 +1001,179 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 38,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>observation</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>25.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>31.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>29.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>31.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>29.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>...</th>\n",
+       "      <td>...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>995</th>\n",
+       "      <td>26.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>996</th>\n",
+       "      <td>22.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>997</th>\n",
+       "      <td>21.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>998</th>\n",
+       "      <td>19.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>999</th>\n",
+       "      <td>28.0</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "<p>1000 rows × 1 columns</p>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "     observation\n",
+       "0           25.0\n",
+       "1           31.0\n",
+       "2           29.0\n",
+       "3           31.0\n",
+       "4           29.0\n",
+       "..           ...\n",
+       "995         26.0\n",
+       "996         22.0\n",
+       "997         21.0\n",
+       "998         19.0\n",
+       "999         28.0\n",
+       "\n",
+       "[1000 rows x 1 columns]"
+      ]
+     },
+     "execution_count": 38,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
-    "# your code here"
+    "age_population2 = pd.read_csv('ages_population2.csv')\n",
+    "age_population2"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 39,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "28.0    139\n",
+       "27.0    125\n",
+       "26.0    120\n",
+       "29.0    115\n",
+       "25.0     98\n",
+       "30.0     90\n",
+       "24.0     78\n",
+       "31.0     61\n",
+       "23.0     41\n",
+       "22.0     35\n",
+       "32.0     31\n",
+       "33.0     22\n",
+       "21.0     17\n",
+       "20.0     13\n",
+       "34.0      7\n",
+       "19.0      3\n",
+       "35.0      3\n",
+       "36.0      2\n",
+       "Name: observation, dtype: int64"
+      ]
+     },
+     "execution_count": 39,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "numbers_frequency = age_population2[\"observation\"].value_counts()\n",
+    "frequency_numbers = {}\n",
+    "\n",
+    "for value in numbers:\n",
+    "    if value in frequency_numbers:\n",
+    "        frequency_numbers[value] += 1\n",
+    "    else:\n",
+    "        frequency_numbers[value] = 1\n",
+    "\n",
+    "numbers_frequency"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 40,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.bar(numbers_frequency.index, numbers_frequency.values)\n",
+    "plt.xlabel('Ages')\n",
+    "plt.ylabel('Frequency')\n",
+    "plt.title('Frequency Distribution')\n",
+    "plt.show()"
    ]
   },
   {
@@ -337,9 +1189,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "\"\"\"\n",
-    "your comments here\n",
-    "\"\"\""
+    "#the interval is smaller"
    ]
   },
   {
@@ -351,11 +1201,42 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 41,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "27.155"
+      ]
+     },
+     "execution_count": 41,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
-    "# your code here"
+    "age_population2[\"observation\"].mean()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 42,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "2.969813932689186"
+      ]
+     },
+     "execution_count": 42,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "age_population2[\"observation\"].std()"
    ]
   },
   {
@@ -364,9 +1245,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "\"\"\"\n",
-    "your comments here\n",
-    "\"\"\""
+    "#it makes sense. the interval is smaller so the std is smaller as well"
    ]
   },
   {
@@ -381,11 +1260,172 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 43,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>observation</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>21.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>21.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>24.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>31.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>54.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>...</th>\n",
+       "      <td>...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>995</th>\n",
+       "      <td>16.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>996</th>\n",
+       "      <td>55.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>997</th>\n",
+       "      <td>30.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>998</th>\n",
+       "      <td>35.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>999</th>\n",
+       "      <td>43.0</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "<p>1000 rows × 1 columns</p>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "     observation\n",
+       "0           21.0\n",
+       "1           21.0\n",
+       "2           24.0\n",
+       "3           31.0\n",
+       "4           54.0\n",
+       "..           ...\n",
+       "995         16.0\n",
+       "996         55.0\n",
+       "997         30.0\n",
+       "998         35.0\n",
+       "999         43.0\n",
+       "\n",
+       "[1000 rows x 1 columns]"
+      ]
+     },
+     "execution_count": 43,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
-    "# your code here"
+    "age_population3 = pd.read_csv('ages_population3.csv.')\n",
+    "age_population3"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 44,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "32.0    37\n",
+       "35.0    31\n",
+       "37.0    31\n",
+       "39.0    29\n",
+       "36.0    26\n",
+       "        ..\n",
+       "76.0     1\n",
+       "8.0      1\n",
+       "9.0      1\n",
+       "1.0      1\n",
+       "7.0      1\n",
+       "Name: observation, Length: 75, dtype: int64"
+      ]
+     },
+     "execution_count": 44,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "numbers_frequency = age_population3[\"observation\"].value_counts()\n",
+    "frequency_numbers = {}\n",
+    "\n",
+    "for value in numbers:\n",
+    "    if value in frequency_numbers:\n",
+    "        frequency_numbers[value] += 1\n",
+    "    else:\n",
+    "        frequency_numbers[value] = 1\n",
+    "\n",
+    "numbers_frequency"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 45,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.bar(numbers_frequency.index, numbers_frequency.values)\n",
+    "plt.xlabel('Ages')\n",
+    "plt.ylabel('Frequency')\n",
+    "plt.title('Frequency Distribution')\n",
+    "plt.show()"
    ]
   },
   {
@@ -397,11 +1437,42 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 46,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "41.989"
+      ]
+     },
+     "execution_count": 46,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
-    "# your code here"
+    "age_population3[\"observation\"].mean()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 47,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "16.144705959865934"
+      ]
+     },
+     "execution_count": 47,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "age_population3[\"observation\"].std()"
    ]
   },
   {
@@ -410,9 +1481,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "\"\"\"\n",
-    "your comments here\n",
-    "\"\"\""
+    "#std is bigger as the values are more distributed"
    ]
   },
   {
@@ -424,11 +1493,28 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 48,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "the first quartile is 30.0\n",
+      "the second quartile is 40.0\n",
+      "the third quartile is 53.0\n"
+     ]
+    }
+   ],
    "source": [
-    "# your code here"
+    "q1 = np.quantile(age_population3,0.25)\n",
+    "print(f\"the first quartile is {q1}\")\n",
+    "\n",
+    "q2 = np.quantile(age_population3,0.50)\n",
+    "print(f\"the second quartile is {q2}\")\n",
+    "\n",
+    "q3 = np.quantile(age_population3,0.75)\n",
+    "print(f\"the third quartile is {q3}\")\n"
    ]
   },
   {
@@ -437,9 +1523,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "\"\"\"\n",
-    "your comments here\n",
-    "\"\"\""
+    "#they are very close"
    ]
   },
   {
diff --git a/data/roll_the_dice_hundred.csv b/your-code/roll_the_dice_hundred.csv
similarity index 100%
rename from data/roll_the_dice_hundred.csv
rename to your-code/roll_the_dice_hundred.csv
diff --git a/data/roll_the_dice_thousand.csv b/your-code/roll_the_dice_thousand.csv
similarity index 100%
rename from data/roll_the_dice_thousand.csv
rename to your-code/roll_the_dice_thousand.csv