mas_covid_network.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Modélisation de la propagation de l'épidémie du Covid : Simulation multi-agents"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Auteur : Maxime Gatineau, Élève Ingénieur de l'[École Centrale de Lille](https://ecole.centralelille.fr/) <br/>\n",
    "Tuteur : Philippe Mathieu, [CRIStAL Lab](https://www.cristal.univ-lille.fr/), [SMAC Team](https://www.cristal.univ-lille.fr/gt/i2c/) <br/>\n",
    "Création : Septembre 2020"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Objectifs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nous souhaitons modéliser à l’échelle microscopique l’évolution de l’épidémie du covid en France. <br/>\n",
    "Notre but est de pouvoir faire des prévisions à court termes sur la propagation de l'épidémie et de sortir les paramètres qui impactent la force et la vitesse de la propagation."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Principes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Un système multi-agents est un système dans lequel des entités dotées de leur propre comportement, intéragissent entre-elles. <br/>\n",
    "Nos agents doivent représenter la population française, ils auront différentes caractéristiques, par exemple l'âge et le sexe. <br/>\n",
    "Les agents seront reliés entre eux selon un modèle de Barabási-Albert, qui génére aléatoirement un réseau invariant d'échelle et qui permet de représenter un réseau social pour des interactions humaines. <br/>\n",
    "Ensuite, sur un principe de tour de parole, nous allons interroger chaque agents, regarder leurs connexions et dire s'ils peuvent être contaminés par les agents qui les entourent. <br/>\n",
    "Enfin, l'utilisation d'un algorithme génétique permettra d'accorder les paramètres avec les données que nous avons en France."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Table des matières <a class=\"anchor\" id=\"tdm\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* [Chapitre 1 : Simulation](#c1)\n",
    "    * [Partie 1 : Caractéristiques de la population française](#c1-p1)\n",
    "    * [Partie 2 : Simulation multi-agents](#c1-p2)\n",
    "    * [Partie 3 : Facteurs de contagion](#c1-p3)\n",
    "    * [Partie 4 : Simulation avec une contagion aléatoire V1](#c1-p4)\n",
    "    * [Partie 5 : Simulation avec une contagion aléatoire V2 (dépendance de l'âge)](#c1-p5)\n",
    "    * [Partie 6 : Algorithme génétique](#c1-p6)\n",
    "* [Chapitre 2 : Graphes](#c2)\n",
    "    * [Partie 1 : Graphe de l'évolution du Covid en France](#c2-p1)\n",
    "    * [Partie 2 : Répartion de la population française](#c2-p2)\n",
    "    * [Partie 3 : Création d'une animation sur notre graphe social](#c2-p3)\n",
    "* [Sources](#s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Librairies :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import csv \n",
    "import random\n",
    "import pandas as pd\n",
    "import networkx as nx\n",
    "import matplotlib.pyplot as plt\n",
    "import sys\n",
    "import time \n",
    "import glob\n",
    "from datetime import date\n",
    "from PIL import Image\n",
    "import os"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Chapitre 1 : Simulation <a class=\"anchor\" id=\"c1\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Partie 1 : Caractéristiques de la population française <a class=\"anchor\" id=\"c1-p1\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Explications : "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Table des matières](#tdm)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pour notre étude, les paramètres se basent sur les sources et s'implémentent de la manière suivante : \n",
    "* Pour l'âge : \n",
    "     * 0 = < 15 ans\n",
    "     * 1 = entre 15 et 30 ans\n",
    "     * 2 = entre 30 et 55 ans\n",
    "     * 3 = > 55 ans\n",
    "     \n",
    "     \n",
    "* Pour le sexe :\n",
    "    * 0 = homme\n",
    "    * 1 = femme\n",
    "\n",
    "\n",
    "* Pour le poids :\n",
    "    * 0 = Dénutrition (IMC < 18.5)\n",
    "    * 1 = Normal (18.5 > IMC > 25)\n",
    "    * 2 = Surpoids (25 > IMC > 30)\n",
    "    * 3 = Obésité (IMC > 30)\n",
    "\n",
    "\n",
    "* Pour le groupe sanguin : \n",
    "    * 0 = A+\n",
    "    * 1 = O+\n",
    "    * 2 = B+ \n",
    "    * 3 = AB+\n",
    "    * 4 = A-\n",
    "    * 5 = O-\n",
    "    * 6 = B-\n",
    "    * 7 = AB-"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Implémentation des paramètres sur une population\n",
    "\n",
    "nb_agents = 7000\n",
    "agentList = []\n",
    "age=[]\n",
    "sexe=[]\n",
    "poids = []\n",
    "groupe_sanguin = []\n",
    "\n",
    "# Proportions cumulatives pour l'âge:\n",
    "prop_age = [17.8/100, 35.1242921972263/100, 66.8828069335807/100, 1]\n",
    "\n",
    "# Par tranches d'âges les proportions normalisées sont :\n",
    "prop_homme = [0.527541666807402, 0.521707530462693, 0.506880352191682, 0.467120912994188]\n",
    "prop_femme = [0.472458333192598, 0.478292469537307, 0.493119647808318, 0.532879087005812]\n",
    "\n",
    "# Proportions cumulatives pour le poids :\n",
    "prop_poids = [0.035,0.492,0.323,0.15]\n",
    "\n",
    "# Proportions pour le groupe sanguin : \n",
    "prop_groupe_sanguin = [0.38,0.36,0.08,0.03,0.07,0.06,0.01,0.01]\n",
    "\n",
    "graph = nx.barabasi_albert_graph(nb_agents,1)\n",
    "# Avec numpy array :\n",
    "matrix = nx.to_numpy_array(graph, nodelist=range(nb_agents))\n",
    "\n",
    "class Agent:\n",
    "    def __init__(self, id_number, accointances) :\n",
    "        self.id_number = id_number\n",
    "        self.accointances = accointances\n",
    "        self.has_it = False\n",
    "\n",
    "# Initialize accointances based on the matrix\n",
    "for i in range(nb_agents):\n",
    "    agentList.append(Agent(i,np.nonzero(matrix[i])[0]))\n",
    "    \n",
    "for i in range(nb_agents):\n",
    "    if 0 <= i <= int(nb_agents*prop_age[0]):\n",
    "        age.append(0)\n",
    "        sexe.append(np.random.choice([0,1], 1, p=[prop_homme[0],prop_femme[0]])[0])\n",
    "    if int(nb_agents*prop_age[0]) < i <= int(nb_agents*prop_age[1]):\n",
    "        age.append(1)\n",
    "        sexe.append(np.random.choice([0,1], 1, p=[prop_homme[1],prop_femme[1]])[0])\n",
    "    if int(nb_agents*prop_age[1]) < i <= int(nb_agents*prop_age[2]):\n",
    "        age.append(2)\n",
    "        sexe.append(np.random.choice([0,1], 1, p=[prop_homme[2],prop_femme[2]])[0])\n",
    "    if int(nb_agents*prop_age[2]) < i <= int(nb_agents*prop_age[3]):   \n",
    "        age.append(3)\n",
    "        sexe.append(np.random.choice([0,1], 1, p=[prop_homme[3],prop_femme[3]])[0])\n",
    "    poids.append(np.random.choice([0,1,2,3], 1, p=[prop_poids[0],prop_poids[1],prop_poids[2],prop_poids[3]])[0])\n",
    "    groupe_sanguin.append(np.random.choice([0,1,2,3,4,5,6,7], 1, p=[prop_groupe_sanguin[0],prop_groupe_sanguin[1],prop_groupe_sanguin[2],prop_groupe_sanguin[3],prop_groupe_sanguin[4],prop_groupe_sanguin[5],prop_groupe_sanguin[6],prop_groupe_sanguin[7]])[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Implémentation des paramètres\n",
      "\n",
      "Il y a 7000 agents.\n",
      "Les tableaux sont de la même taille que le nombre d'agents : True\n",
      "\n",
      "La proportion par tranches d'âge (simulation - réelle) est :\n",
      "[[0.         0.17814286 0.178     ]\n",
      " [1.         0.17314286 0.17324292]\n",
      " [2.         0.31757143 0.31758515]\n",
      " [3.         0.33114286 0.33117193]]\n",
      "\n",
      "La proportion H/F (simulation - réelle) est :\n",
      "[[0.         0.50185714]\n",
      " [1.         0.49814286]]\n",
      "\n",
      "La proportion du poids (simulation - réelle) est de :\n",
      "[[0.         0.03171429 0.035     ]\n",
      " [1.         0.49342857 0.492     ]\n",
      " [2.         0.32485714 0.323     ]\n",
      " [3.         0.15       0.15      ]]\n",
      "\n",
      "La proportion pour les groupes sanguins (simulation - réelle) est de :\n",
      "[[0.         0.37842857 0.38      ]\n",
      " [1.         0.35885714 0.36      ]\n",
      " [2.         0.08028571 0.08      ]\n",
      " [3.         0.02857143 0.03      ]\n",
      " [4.         0.07171429 0.07      ]\n",
      " [5.         0.06       0.06      ]\n",
      " [6.         0.01185714 0.01      ]\n",
      " [7.         0.01028571 0.01      ]]\n"
     ]
    }
   ],
   "source": [
    "# Analyse de nos valeurs :\n",
    "\n",
    "print(\"Implémentation des paramètres\\n\")\n",
    "print(f\"Il y a {nb_agents} agents.\")\n",
    "# On regarde que les tableaux aient la même taille :\n",
    "print(f\"Les tableaux sont de la même taille que le nombre d'agents : {len(age) == len(poids) == len(sexe) == nb_agents}\\n\")\n",
    "# On compare avec les valeurs réelles : \n",
    "y = np.bincount(age)/nb_agents\n",
    "ii = np.nonzero(y)[0]\n",
    "# On prends la proportion d'âge non-cumulative :\n",
    "prop_age_nc = np.array(prop_age)\n",
    "for i in range(0,len(prop_age)):\n",
    "    if i == 0:\n",
    "        prop_age_nc[i] = prop_age[i]\n",
    "    else:\n",
    "        prop_age_nc[i] = prop_age[i] - prop_age[i-1]\n",
    "print(f\"La proportion par tranches d'âge (simulation - réelle) est :\\n{np.vstack((ii,y[ii],prop_age_nc[ii])).T}\\n\")\n",
    "\n",
    "y = np.bincount(sexe)/nb_agents\n",
    "ii = np.nonzero(y)[0]\n",
    "print(f\"La proportion H/F (simulation - réelle) est :\\n{np.vstack((ii,y[ii])).T}\\n\")\n",
    "\n",
    "y = np.bincount(poids)/nb_agents\n",
    "ii = np.nonzero(y)[0]\n",
    "prop_poids = np.array(prop_poids)\n",
    "print(f\"La proportion du poids (simulation - réelle) est de :\\n{np.vstack((ii,y[ii],prop_poids[ii])).T}\\n\")\n",
    "\n",
    "y = np.bincount(groupe_sanguin)/nb_agents\n",
    "ii = np.nonzero(y)[0]\n",
    "prop_groupe_sanguin = np.array(prop_groupe_sanguin)\n",
    "print(f\"La proportion pour les groupes sanguins (simulation - réelle) est de :\\n{np.vstack((ii,y[ii],prop_groupe_sanguin[ii])).T}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En comparant les données obtenues avec celles des sources, on observe que les proportions obtenues sont correctes."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Partie 2 : Simulation multi-agents <a class=\"anchor\" id=\"c1-p2\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Explications :"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Table des matières](#tdm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Création de la classe multi-agents\n",
    "\n",
    "class SMA:\n",
    "    def __init__(self, nb_agents, adjacency_matrix):\n",
    "        self.tick = 0\n",
    "        self.agentList = []\n",
    "        self.n_steps = 0\n",
    "        self.age = []\n",
    "        self.poids = []\n",
    "        self.sexe = []\n",
    "        self.groupe_sanguin = []\n",
    "        self.vivant = [] # 1 = Oui, 0 = Non\n",
    "        self.malade = [] # 1 = Oui, 0 = Non\n",
    "\n",
    "        # Initialize accointances based on the matrix\n",
    "        for i in range(nb_agents):\n",
    "            self.agentList.append(Agent(i, np.nonzero(adjacency_matrix[i])[0]))\n",
    "            self.vivant.append(1)\n",
    "            # Une probabilité d'être malade pour commencer à tracer les graphes\n",
    "            self.malade.append(np.random.choice([0,1], 1, p=[0.90,0.10])[0])\n",
    "\n",
    "        # Initialisation des paramètres se basant sur les sources :\n",
    "\n",
    "        # Proportions cumulatives pour l'âge :\n",
    "        prop_age = [17.8/100, 35.1242921972263/100, 66.8828069335807/100, 1]\n",
    "\n",
    "        # Par tranches d'âges les proportions normalisées sont :\n",
    "        prop_homme = [0.527541666807402, 0.521707530462693, 0.506880352191682, 0.467120912994188]\n",
    "        prop_femme = [0.472458333192598, 0.478292469537307, 0.493119647808318, 0.532879087005812]\n",
    "\n",
    "        # Proportions pour le poids :\n",
    "        prop_poids = [0.035,0.492,0.323,0.15]\n",
    "\n",
    "        # Proportions pour le groupe sanguin : \n",
    "        prop_groupe_sanguin = [0.38,0.36,0.08,0.03,0.07,0.06,0.01,0.01]\n",
    "\n",
    "        for i in range(nb_agents):\n",
    "            if 0 <= i <= int(nb_agents*prop_age[0]):\n",
    "                self.age.append(0)\n",
    "                self.sexe.append(np.random.choice([0,1], 1, p=[prop_homme[0],prop_femme[0]])[0])\n",
    "            if int(nb_agents*prop_age[0]) < i <= int(nb_agents*prop_age[1]):\n",
    "                self.age.append(1)\n",
    "                self.sexe.append(np.random.choice([0,1], 1, p=[prop_homme[1],prop_femme[1]])[0])\n",
    "            if int(nb_agents*prop_age[1]) < i <= int(nb_agents*prop_age[2]):\n",
    "                self.age.append(2)\n",
    "                self.sexe.append(np.random.choice([0,1], 1, p=[prop_homme[2],prop_femme[2]])[0])\n",
    "            if int(nb_agents*prop_age[2]) < i <= int(nb_agents*prop_age[3]):   \n",
    "                self.age.append(3)\n",
    "                self.sexe.append(np.random.choice([0,1], 1, p=[prop_homme[3],prop_femme[3]])[0])\n",
    "            self.poids.append(np.random.choice([0,1,2,3], 1, p=[prop_poids[0],prop_poids[1],prop_poids[2],prop_poids[3]])[0])\n",
    "            self.groupe_sanguin.append(np.random.choice([0,1,2,3,4,5,6,7], 1, p=[prop_groupe_sanguin[0],prop_groupe_sanguin[1],prop_groupe_sanguin[2],prop_groupe_sanguin[3],prop_groupe_sanguin[4],prop_groupe_sanguin[5],prop_groupe_sanguin[6],prop_groupe_sanguin[7]])[0])\n",
    "\n",
    "    def run(self, rounds):        \n",
    "        for i in range(0,rounds):\n",
    "            self.runOnce()\n",
    "            \n",
    "    def runOnce(self):\n",
    "        self.tick += 1\n",
    "        for agent in self.agentList:\n",
    "            agent.decide(self.tick) \n",
    "        #print(\"\\ntick \" + str(self.tick) + \" ended.\\n\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Création de la classe Agent\n",
    "\n",
    "class Agent:\n",
    "    def __init__(self, id_number, accointances) :\n",
    "        self.id_number = id_number\n",
    "        self.accointances = accointances\n",
    "        self.has_it = False\n",
    "\n",
    "    def decide(self, tick) :\n",
    "        if self.has_it:\n",
    "            chosen = random.randint(0,len(sma.agentList)-1)\n",
    "\n",
    "            self.has_it = False\n",
    "            sma.agentList[random.randint(0,len(sma.agentList)-1)].has_it = parole\n",
    "\n",
    "            print(f\"L'agent {self.id_number} ({sma.sexe[self.id_number]}) pèse {sma.poids[self.id_number]} et est de groupe sanguin {sma.groupe_sanguin[self.id_number]} ! Il parle à l'agent {chosen}.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Il y a 7000 agents et 5 tours.\n",
      "L'agent 4464 (1) pèse 1 et est de groupe sanguin 0 ! Il parle à l'agent 4055.\n",
      "L'agent 997 (1) pèse 2 et est de groupe sanguin 2 ! Il parle à l'agent 4541.\n",
      "L'agent 6441 (1) pèse 2 et est de groupe sanguin 0 ! Il parle à l'agent 916.\n",
      "L'agent 89 (0) pèse 3 et est de groupe sanguin 0 ! Il parle à l'agent 2519.\n",
      "L'agent 4262 (0) pèse 1 et est de groupe sanguin 0 ! Il parle à l'agent 6049.\n",
      "L'agent 965 (1) pèse 3 et est de groupe sanguin 2 ! Il parle à l'agent 3537.\n",
      "L'agent 2229 (0) pèse 3 et est de groupe sanguin 1 ! Il parle à l'agent 695.\n",
      "L'agent 477 (1) pèse 3 et est de groupe sanguin 0 ! Il parle à l'agent 907.\n",
      "L'agent 1434 (1) pèse 2 et est de groupe sanguin 3 ! Il parle à l'agent 5000.\n",
      "L'agent 2154 (1) pèse 1 et est de groupe sanguin 1 ! Il parle à l'agent 2068.\n",
      "L'agent 5030 (1) pèse 3 et est de groupe sanguin 1 ! Il parle à l'agent 118.\n",
      "\n",
      "Le temps d'exécution est de 1.7051s.\n"
     ]
    }
   ],
   "source": [
    "# Exécution de la simulation\n",
    "nb_agents = 7_000\n",
    "nb_rounds = 5\n",
    "temps_debut = time.time()\n",
    "\n",
    "# Choix du type de graphe : \n",
    "\n",
    "graph = nx.barabasi_albert_graph(nb_agents, 1)\n",
    "#graph = nx.complete_graph(nb_agents)\n",
    "#graph = nx.erdos_renyi_graph(nb_agents,0.1)\n",
    "#graph = nx.cycle_graph(nb_agents)\n",
    "#graph = nx.random_regular_graph(3,nb_agents)\n",
    "\n",
    "matrix = nx.to_numpy_array(graph, nodelist=range(nb_agents))\n",
    "sma = SMA(nb_agents, matrix)\n",
    "\n",
    "# On donne la parole\n",
    "parole = \"J'ai la parole.\"\n",
    "an_agent = np.random.choice(sma.agentList)\n",
    "an_agent.has_it = parole\n",
    "print(f\"Il y a {nb_agents} agents et {nb_rounds} tours.\")\n",
    "\n",
    "# On lance le jeu\n",
    "sma.run(nb_rounds)\n",
    "\n",
    "temps_fin = time.time()\n",
    "print(f\"\\nLe temps d'exécution est de {round(temps_fin-temps_debut,4)}s.\")\n",
    "\n",
    "# On reprend la balle, pour une éventuelle réexécution.\n",
    "for agent in sma.agentList:\n",
    "    if agent.has_it:\n",
    "        agent.has_it = False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAb4AAAEuCAYAAADx63eqAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8vihELAAAACXBIWXMAAAsTAAALEwEAmpwYAACBH0lEQVR4nO3ddVhU2f8H8PcwdAkSgpRgByiIgCC2gq2oKHZjC+aaa6+9KLp2C4LdImGgEgoGoKigUiIKiDRMnd8f/pzvsjRMAef1PDzr3rn3nM8dcT5zzj3BIIQQUBRFUVQDISXuACiKoihKlGjioyiKohoUmvgoiqKoBoUmPoqiKKpBoYmPoiiKalBo4qMoiqIaFJr4KIqiqAaFJj6KoiiqQaGJj6IoimpQaOKjKIqiGhSa+CiKoqgGhSY+iqIoqkGhiY+iKIpqUGjioyiKohoUmvgoiqKoBoUmPoqi/ichAQgIAL5/F3ckFCU0NPFRFAVwucD48UDbtsDo0YCREbBhg7ijoiihYNAd2CmKwuHDwOLFQEHB/44pKgJ+foC9vfjioighoC0+iqKAU6dKJj0AKCwEfH3FEg5FCRNNfBRFASoqpY8xmYCysuhjoSgho4mPoijA3f1X1+a/ycoC06aJJx6KEiKa+CiKAgYMQNry5fgBgDCZgL4+cPky0KqVuCOjKIGTFncAFEVJhqVxcbjfpAlS4+J+dXEyGOIOiaKEgrb4KIoCj8fD9evXMXbcuF/P+2jSo+oxmvgoikJAQACKioqwYMECcYdCUUJH5/FRFIU+ffogLi4OSUlJ4g6FooSOtvgoqoHLysrCkydPMHnyZHGHQlEiQRMfRTVwXl5ekJKSwsSJE8UdCkWJBO3qpKgGrnXr1iguLkZCQoK4Q6EokaAtPopqwF69eoWvX79i0qRJ4g6FokSGJj6KasBOnDgBKSkpjB49WtyhUJTI0K5OimqgiouLoaOjAzU1NXz69AkMOnePaiBoi4+iGqgbN26gUaNGcHFxoUmPalBo4qOoBurEiRMoKirCyJEjxR0KRYkU7eqkqAYoOTkZHTp0gJqaGhISEmiLj2pQ6CLVFNUAnTlzBi1btkSPHj1o0qMaHJr4KKqB4fF4OHHiBADQbk6qQaLP+CiqgXn8+DGYTCYKCwthY2Mj7nAoSuRoi4+iGpgTJ06gZcuWMDY2hpQU/e5LNTz0t56iGpDs7Gxcv34dycnJGDVqlLjDoSixoImPohoQX19f2NjYIC0tDfb29uIOh6LEgnZ1UlQDcuLECbRv3x6GhoZgMpniDoeixIK2+CiqgXjz5g2Sk5Px5s0bOpqTatDoBHaKaiCWLl2KoqIinD9/Hl+/foWsrKy4Q6IosaAtPopqANhsNs6ePQt1dXUMHjyYJj2qQaOJj6IagNu3b6N169Z4/Pgx7eakGjya+CiqAThx4gRGjhyJV69eoX///uIOh6LEiiY+iqrnvn79isePHwMABgwYAHl5eTFHRFHiRRMfRdVzZ8+exciRI3H79m3azUlRoKM6KapeI4Sgbdu28PDwwJgxY5CamgolJSVxh0VRYkVbfBRVj4WGhgL41d3Zp08fmvQoCjTxUVS9duLECUybNg1Xrlyh3ZwU9f9oVydF1VN5eXkwMDBAeHg4LC0tkZycjEaNGok7LIoSO9rio6h66uLFi7C3t0dERAS6d+9Okx5F/T+a+CiqnvrdzXn58mXazUlR/0K7OimqHvrw4QO6d++Od+/ewcjICJ8+fYKGhoa4w6IoiUC3JaKoeoDFZcErygv7nu3D97zvkMqWgs0UGwQGBsLKyoomPYr6F5r4KKqOK2QXoufpnnjz/Q3y2fm/DjKBTOVMvAx9iT+c/hBrfBQlaWjio6g6bsOjDYj6FoUiTlGJ44XcQiTJJ4F0oE8zKOrf6DM+iqrDuDwuGu9ojJzinHLP6dikI17NfiW6oMSogF0AnxgfXH93HQwGA05tneDc3hny0nR9Uup/aOKjqDossyATenv0UMwtLvccaa40pnydAmVlZaioqJT537KO1bU9+z5kfoD9CXvks/P5Xb7KsspQkVXBk2lPYKJuIuYIKUlBEx9F1WHFnGKoblMFi8sq9xx1pjq2aW9DXl4ecnNzy/zvf4/l5uZCSkqqWomyssSqrKwMKSnhzKDi8rgw3muMlJwUEJT8SJNiSMFYzRhxC+LAYDCEUj9Vt9BnfBRVh8lJy2FQy0G4/v46eIRX6nV5pjzc7N0wq8esapVLCAGLxapyoszMzKw0sebn50NBQaHKibIqx+Tl5cFgMOAX74efRT9LJT0A4BEevuV/w4OEB+ht3LvG7zVVf9AWH0XVcfE/4tFhXwcUk+ISS1JIQQr6jfTxevZrqMmriS2+33g8HgoKCspNnhUl1vKOcTgcKCsrg9udizyLPKCcBh2TwcSmXpuw0n6laG+akki0xUdRdVzUwyioX1ZHa7fWCPsaBhmmDPIK8jCwxUCcGHVCIpIeAEhJSfFbboLCZrORl5eHbU+3YfeL3eASbpnnSUtJQ0FGQWD1UnUbbfFRVB0WExODXr164e7du7C0tMSPwh+4+/Autq/bjqjnUeIOT2Ref3kNy6OW4DA4Zb4uLy2Pt3PfwljdWMSRUZKIrtVJNShsLhunXp3C0PNDMe/2PLzPeC/ukGosKysLI0aMwO7du2FpaQkAaKzQGGF3wjBm+BgxRyc6jx8/xpg+Y6CdrQ15ZulpCwrSChjZdiRNehQfbfFRDQYhBAO8BuBJ0hPks/PBZDAhJy2HoElBsNG3EXd41cLlcjF48GC0bt0aHh4e/OM8Hg8GBgYICgpCmzZtxBegCOTk5GDlypW4du0aPD09MXjYYMy5NQfeMd6Q4kmhmFUMGXkZTO00FXsd90KGKSPukCkJQVt8VIMRkhzCT3oAwCVcFLAL4H7PXcyRVd+aNWtQXFyMnTt3ljgeHh4ONTW1ep/0bt++jQ4dOqC4uBgxMTFwcnKCLFMWx4cdR7J7MtaarkXzqOb4svgL/hn0D016VAl0cAvVYER9iypzyP+b72/EEE3NXbhwAefPn8fz588hI1PyA72+b0GUnp6ORYsWITw8HKdOnULv3qWnJ2gqamJoq6E4/eE0Gis0FkOUlKSjLT6qwTBtYgopRulf+XZa7cQQTc1ERUVh3rx5uHr1KrS0tEq8Rgipt4mPEIJz587B1NQUenp6iI6OLjPp/aampoafP3+KLkCqTqEtPqrBsDOwg62BLR4nPkYRtwhSkAKPzcPidovFHVqVZGZmYvjw4di7dy/Mzc1Lvf7y5UswmUyYmZmJITrhSUxMxJw5c/DlyxfcunWLP5CnIjTxURWhLT5K6ArZhXjx9QW+5X0TaxwMBgO3x92Gk4ITDAoNMLPzTGxougHrpq1DVlaWWGOrDIfDgYuLC0aOHIlx48aVec7v1l59WZaLx+PB09MTnTt3hp2dHSIiIqqU9ABAQUEBXC4XRUVFlZ9MNTi0xUcJ1dmos5hzaw6kGFJgcVlwbu+ME8NOQFpKPL96MkwZSL2Swp89/8T0wdMBAFlxWXB2dsadO3dKPTOTFCtXrgQhBH/99VeZrxNCcOnSJZw7d07EkQlHbGwsZsyYAQaDgSdPnlR7sA6DwYCamhqys7MhL093ZqBKoi0+SmjiMuPgetMV+ex85LJyUcwtxuXYy9gbvlescYWFhcHG5n/TF3bu3AkZGRm4u0vm6E5vb29cvnwZPj4+kJYu+wvDmzdvUFRUVOUWkaRisVjYtGkTunfvjvHjxyM4OLjGI1RpdydVHpr4KKG59PYSOLySK2kUsAtw7MUxMUUEZGRk4Pv372jbti3/mLS0NM6fP48HDx7gwIEDYoutLC9fvsSiRYtw7do1aGholHve5cuX4eTkVKe7OZ89ewZLS0uEhYUhMjISc+fOrdVuDjTxUeWhXZ2U0EhLSZf5QUy44lszITw8HFZWVqU+UBs1aoSbN2/Czs4OLVu2RP/+/cUU4f+kp6djxIgROHDgQKUDVi5fvox//vlHRJEJVn5+PtauXQtvb2/s2bMHLi4uAkngNPFR5aEtPkpoxnQYA2lGye9WMkQGyZeSsWTJEmRmZoo8pv92c/6biYkJLly4gIkTJ+Ldu3cijqwkDoeDMWPGwMXFBc7OzhWeGxcXh/T0dNja2oooOsEJDAyEqakpvn//jpiYGIwbN05grVaa+Kjy0MRHCY1hI0NcdL4ILUUtyEnJgcFlwM3ODXE+cSgsLETr1q2xZcsW5Ofniyym0NDQchMfANjb22P79u0YMmSIWBLzb8uWLYOcnBw2b95c6bmXL1/GiBEjhLbJqzBkZWVh2rRpmD59Og4cOIBz585BU1NToHXQxEeVp+78S6HqpIEtB+Lrkq+Ido2G/F55rLVZi6ZNm+Kff/5BWFgYoqOj0bJlSxw8eBBsNluosXC5XDx//hzW1tYVnjdlyhSMGDECo0aNAotV/s7mwnLmzBncunUL3t7eYDKZlZ5/6dKlOjVp/fLly2jfvj2UlJQQExODAQMGCKUemvio8tDERwkdU4qJltotYdnREiEhIfzjLVq0gI+PD27evImrV6+iXbt28PX1BY9XelkxQYiNjUWTJk2q1LL466+/oKKigvnz50OU67hHRERgyZIluHbtGtTV1Ss9PyEhAYmJiejRo4cIoqud1NRUODk5Yc2aNbh48SI8PT2hoqIitPpo4qPKQxNfGbg8LjIKMsDllb2pJVUzPXr0QHBwcKnjnTt3hr+/Pw4dOoRdu3ahS5cuCAgIEHj9FT3f+y8mkwkvLy+Eh4dj717RTL/49u0bRo4cicOHD6N9+/ZVuubKlSsYNmxYudMcJAEhBMeOHUOnTp3Qvn17vHz5EnZ2dkKvV11dnSY+qkw08f2Hd7Q3dHbpQH+PPjR3auL4y+PiDqne6N69Ox49elTu63369MGzZ8/wxx9/YN68eejbty8iIiIEVn91Eh8AqKio4MaNG9ixYwfu3LkjsDjKwmazMXr0aEyaNAlOTk5Vvk7S1+aMj49Hnz59cOTIEQQGBmLTpk0im1BOW3xUeWji+5dnX55h5o2ZyCjMQDG3GD+LfmLh3YV4lFD+hzVVdba2tnj58iUKCwvLPYfBYGD06NF48+YNRo8ejWHDhsHZ2RlxcXG1rr+6iQ8AjIyMcPnyZUyZMgVv3ghvFwd3d3c0atQIGzZsqPI1qampiI2NRZ8+fYQWV01xOBzs3LkTNjY2GDx4MEJDQ0W+hihNfFR5aOL7l8MRh1HIKfmhXMAuwIHnkjWpua5SUlKCqakpwsLCKj1XRkYGrq6uiIuLg7m5OWxtbTF79mx8/fq1RnVnZ2cjISEBpqam1b62a9eu2LNnD4YMGYL09PQa1V+REydOIDAwEOfOnavWyMyrV69i0KBBkJWVFXhMtfHq1SvY2Njg3r17ePbsGRYvXlylQTqCRhMfVR6a+P6lkFMIgtIDGQrYBWKIpn4q7zlfeRQVFbFy5Uq8e/cOKioq6NChA1atWlXtD7Tnz5/DwsKixmtxTpgwAS4uLnByckJxcXGNyihLeHg4/vjjD1y7dg2NGjWq1rWS1s1ZVFSE1atXo3///pg3bx4CAgJgYmIitnho4qPKQxPfv0w0mwglGaWSB1lAbnAu/QckIJU95yuPhoYGdu7ciVevXuHbt29o1aoVdu3aVeXV92vSzflfmzZtgra2NmbPni2QkZ5paWkYNWoUjh07Vu31KNPT0xEZGQkHB4daxyEIjx8/RqdOnfD+/XtERUVh6tSpYl8+jSY+qjw08f2LYwtHLLJeBHlpeTSSawQ5phwsYIFXPq/QunVrXL16Vdwh1nndunXDs2fPajw/zsDAAMePH8fDhw/x9OlTtGrVCidOnACHw6nwOkEkPikpKZw5cwavX7/Grl27alUWi8XCyJEjMXPmTAwdOrTa11+7dg2Ojo5QUFCoVRy1lZOTg7lz52Ls2LH466+/cOnSJejo6Ig1pt9o4qPKRahSvud9J48SHpGvuV8JIYQcPHiQaGhoEENDQ+Lk5ERSU1PFHGHdZm5uTp48eSKQskJCQkj37t1J27ZtydWrVwmPxyt1Do/HIxoaGuTLly8CqTM5OZno6emR69ev17gMV1dXMnz4cMLlcmt0vYODA/H19a1x/YJw8+ZNYmBgQGbMmEGysrLEGktZeDwekZWVJYWFheIOhZIwNPFV0bVr14iWlhYZM2YM0dTUJEePHi3zQ5aqnJubG9m6davAyuPxeOT27dvE1NSUdO3alTx69KjE63FxccTAwEBg9RFCSHh4ONHS0iKvXr2q9rWHDx8mbdu2JdnZ2TWq+8ePH0RFRYXk5ubW6Pra+vbtGxk7dixp3rw5CQoKEksMVaWtrU3S0tLEHQYlYWhXZxUNGzYM165dw8OHD7FgwQIcOnQIffr0QXx8vLhDq3O6d+9erQEulWEwGBg4cCBevnyJuXPnYvLkyRg8eDCio6MBCKab87+srKzg6emJoUOHIi0trcrXhYSEYM2aNbh27RpUVVVrVPfNmzfRu3dvKCsr1+j6miKE4OzZszA1NYW+vj6ioqLQu3dvkcZQXWpqasjKyhJ3GJSEkdzlHiSQra0tHj16BEdHR0ybNg2KioqwsbHB8uXLsXjxYolePUOS2NvbY8qUKeBwOAJ9z5hMJiZMmIDRo0fj8OHD6NevH397IUEnPgAYM2YM3r17hxEjRuDBgweVTsxOTU3F6NGjcerUKbRq1arG9V6+fBmjRo2q8fU1kZiYiNmzZyM1NRW3b9+uMxve0ud8VFloi6+aWrdujZCQEFy5cgXx8fEIDQ1FQEAArKys8PLlS3GHVydoamrCwMAAr169Ekr5cnJyWLhwIeLi4mBiYgJvb2+EhYUJZQ7eunXrYGRkhBkzZlQ40rO4uBhOTk6YN28eBg4cWOP6cnNz8eDBAwwZMqTGZVQHj8eDp6cnOnfuDHt7e0RERNSZpAfQxEeVjSa+GtDV1cWjR48QHx+PZcuW4dq1a1i4cCEcHBywYsWKClcmoX6p6bSG6lBRUcHy5cshKysLDQ0NtG3bFhs3bkReXp7A6mAwGDh58iQ+fPiAv/76q8xzCCGYO3cuDAwMsHLlylrVd/v2bdjZ2UFNTa1W5VTF27dv0a1bN1y4cAFPnjzBqlWrajwPUlxo4qPKQhNfDamqquL27dtQUVFBv379MGTIEERHRyMhIQFmZmZ48OCBuEOUaNWdyF5TL168QIcOHXDw4EE8e/YM79+/R8uWLbF//36BbTmkoKCAa9eu4dChQ7h8+XKp13/XffLkyVrPbRNFNyeLxcKmTZvQo0cPTJgwAY8ePar2PENJQRMfVSYxD66p87hcLlmxYgVp3bo1+fz5MyGEkOvXrxN9fX0yY8YM8uPHD/EGKKFSU1OJurp6jYfzV9XOnTvJggULShx7+fIlcXR0JCYmJsTLy0tgMURGRhJNTU0SGRnJPxYcHEy0tbVJfHx8rcvPz88nqqqqJD09vdZllSc8PJx06NCBDBo0iCQlJQmtHlFZvnw5+euvv8QdBiVhaIuvlqSkpLBt2zbMmzcPdnZ2ePnyJYYOHYqYmBjIyMigQ4cOZbYCGjpdXV1oamoiJiZGqPWUNaKzU6dOuHv3Lo4fP469e/eic+fO8PPzq/VqLBYWFjh8+DCGDRuG1NRUJCcnY8yYMThz5gyaN29eq7IB4N69e7C0tBT4TuUAkJ+fj8WLF2Po0KFYtWoVbt68CQMDA4HXI2q0xUeVSdyZtz65dOkS0dLSIv7+/vxjwcHBpHXr1mTEiBECm0BdX0yfPp3s27dPqHXo6emRjx8/lvs6j8cjly9fJq1btyY9e/YkYWFhta5zy5YtxMLCglhYWJDt27fXurzfxo8fTw4cOCCw8n4LCAggxsbGZMKECUJtTYrDP//8Q1xdXcUdBiVhaOITsN9dW2fPnuUfKywsJKtXryaamprkyJEjdOL7/ztz5gwZNWqU0MpPTk4mWlpaVXq/2Ww2OXr0KNHX1ydOTk4kNja2xvVyuVxiYmJCDAwMCIfDqXE5/1ZUVETU1NQEumrQjx8/yNSpU4mRkRG5c+eOwMqVJN7e3mTMmDHiDoOSMLSrU8Ds7e3x4MEDrF69Gjt27AAhBPLy8ti8eTOCgoJw9OhR9O7dWyD7y9V1vyeyEwEs+FyW392cVRlQIi0tjRkzZuDDhw+wtraGvb09Zs6ciS9fvlS73v3790NZWRk6OjrYtGlTTUIvJTAwEO3bt4eurm6tyyKE4NKlS2jfvj2UlJQQHR2NAQMGCCBKyUO7Oqmy0MQnBO3atUNISAjOnTuHRYsWgcvlAgDMzMwQGhqKoUOHomvXrti+fTvYbLaYoxUfIyMjKCgo4P3790IpvyYrtigoKGD58uX48OEDNDQ0YGZmhhUrVlR59Y8HDx5g69atuHbtGm7evIlTp07Bx8enJuGXIKgtiFJTU+Hk5IS1a9fi0qVL8PT0hIqKSq3LlVQ08VFloYlPSPT09PD48WPExMRgzJgx/O1zmEwm3N3d8fz5cwQFBcHKygovXrwQc7TiI8z5fLVZqkxdXR3btm1DVFQUsrKy0KpVK2zfvr3COZqJiYkYN24cvLy8YGxsjCZNmuDGjRtYuHAhnj17VtPbAJvNxo0bN2qV+AghOHr0KDp16gRTU1O8evUKtra2NS6vrqCJjyqTeHta67+ioiIyduxYYm9vTzIzM0u8xuPxyKlTp4iWlhZZtmwZyc/PF1OU4nPs2DEybtw4gZdbXFxMlJSUSE5OjkDKi42NJSNHjiR6enrkyJEjhM1ml3g9Pz+fmJubkz179pS69vr160RPT48kJyeXXXh+PiGPHhGyZw8hY8YQ4uBAyMCBhLi6EnLqFAk5epR0sbSscexxcXGkZ8+epEuXLiQqKqrG5dRFX79+JU2aNBF3GJSEoYlPBLhcLlmyZAlp27YtSUxMLPV6WloaGTNmTJ1Y7V7QPnz4QPT09AQ+4Of58+fE1NRUoGUS8mueW69evUjr1q3JpUuXCI/HIzwej4wbN46MHz++3PvYsWMHMTc3J3l5ef87GBv7K7kpKhKiqkqInBwhQMkfZWVSJC1NfqqpEbJ/PyHVSORsNpvs2LGDaGhokD179ghsoE1dUlhYSOTk5MQdBlUBNpdNLr25RJb7LyenXp4iBawCoddJE58I7dmzh+jr65PXr1+X+fqNGzeIgYEBmT59eoOZ+M7j8Yiurm6FUw5qwtPTk8ycOVOgZf7G4/GIn58f6dSpE7GysiJz5swhFhYWpKCg/H+wPB6PTJ06lYwYMYJw8/IIWbCAEAUFQqSlSye78n6UlAhRVyfk5s1KY3z58iXp3Lkz6du3r8Df27pGTk6O7sknoYo5xcTmmA1R3qpMsB5EeYsyab63OflRINzPP/qMT4Tc3d2xa9cu9O3bt8wlzYYMGYKYmBjIycnxJ74TIY14lBQMBkPg2xQBwtmK6DcGgwEHBwdERkaiT58+OHLkCJSVlSscpMNgMHDw4EEoJiUhR1cXOHYMKCwEKtk5voT8fCArCxgzBhg/HihjYFRRURFWrVqF/v37Y968efD394eJiUlNbrPeoM/5JJdvjC+iv0Ujj/Vr/dw8dh6+5H7B32F/C7VemvhEbMyYMbhw4QLGjh1b5mg/VVVVHDhwAL6+vlizZg2cnJyQmpoqhkhFRxgDXISZ+H5LTEzEiRMncPfuXTg7O2PAgAEYN24cPn78WOb5cvHxOBMXB5Xc3F9Jr6YKCoBr14ABA4B/rTf6+PFjdOzYEXFxcYiKisLUqVNrvTZofUATn+QoLi7Gs2fPcODAAcyePRvLDy1HPju/xDlFnCIEfAoQbiBCbU9S5YqKiiIGBgZk9+7d5Z5TWFhI1q5dSzQ1Ncnhw4eFvq6luMTExBATExOBlfft2zfSqFEjob5feXl5xMzMrMTKM7m5uWTjxo1EQ0ODzJs3r+TO39++EdK4MSEMRtW7Niv7UVQkZNw4kp2dTWbPnk2aNm1Krly5IrR7rqusra1JaGiouMNoEPLy8sjz58/JP//8Q2bPnk369OlDWrVqRdTV1Ym0tDQBQKSkpIiysjIxMjIiBuMMCHMdk2A9+D/MDUwy5eoUocbJIKSe96VJsOTkZAwYMAD9+/fHrl27ICVVdgM8OjoaM2bMgIKCAo4cOVKrTUwlEY/Hg7a2Nl69egV9ff1al3fz5k14enrC399fANGVRgjB2LFjoaioiBMnTpRqVaWnp2Pr1q04c+YM5s+fjyVLlkDVxQUICCize7I2OHJymKWiAubw4di5c6dItiuqaxwdHeHm5gZHR0dxh1KnEULw8+dPxMfH48WLF3j9+jXi4uKQlJSE9PR05ObmgsPhgMFgQFFREY0bN0bTpk1hYmKCdu3aoXPnzrC2tkbjxo35Zabnp6Ptgbb4WfQTXMIFAwwoySjh+aznaKMpvB1BaOITs6ysLAwfPhw6Ojo4c+YM5OTkyjyPy+XC09MTmzdvxtKlS7FkyZI6tzdaRZycnDBq1CiMGzeu1mWtXr0a0tLS2LBhgwAiK2379u24fPkygoODK9x1PSEhAevWrYP0jRs4XFgIGQFtg/RfbBUVyHz5AtTjiei1MXbsWAwfPhxjx44VdygSjRCCb9++ISEhAVFRUYiKisL79++RnJyMb9++ITc3FzweDwAgLy8PdXX1EonNwsICnTt3hq6ubrW62BN/JmL9w/V4mvwUHbQ7YGOvjeig3UFYtwmAJj6JUFRUhIkTJyIjIwNXr16t8Ft7QkICXF1d8f37dxw7dgydO3cWXaBC5OHhgdjYWBw+fLjWZfXp0wdLly4VyjJcfn5+mDZtGp49e1bl1mmRiQnkP38WeCx8SkrAtm3A/PnCq6MOmz17Njp16oTZs2eLOxSx4nA4SE1NRUJCAt69e4fXr1/jw4cPSEpKwvfv35GTkwMGgwEejwdZWVmoq6tDV1cXJiYmaNu2LSwsLGBqagojI6M6/6WbJj4JweVysXjxYty/fx93797934cqmw1kZPz6Nq+sDODXN7Nz585h6dKlmDRpEjZs2ABFRUUxRl97L1++xLhx4xAbG1urcrhcLtTV1fH582doaGgIKLpf4uPjYWdnh8uXL6Nbt25VuygiAujR49eAFGEyNAQSEgA6mKWUP/74A2pqavjjjz9EVmf8j3jsDduLx0mPoSSrhKmdpmKc6Tgoygjv32lxcTGSkpKQmJiIjx8/8ltsiYmJ+P79O3JzcyEtLQ3yaxobGjduDB0dHRgbG6Ndu3YwNzdH27ZtYWxsDOX//6ypr6TFHQD1C5PJhIeHB3bt2gU7OzvcvXIF7Xx8gMOHfw1553CAXr2APXvAaN8eEydOhIODA9zc3GBqaoojR46gT58+4r6NGjMzM8PXr1/x7ds3NGnSpMblvH37Frq6ugJPenl5eRg+fDjWr19f9aQHAF5ewP8vVydUmZnAmzdAB+F2EdVFoh7VeeHNBUy5NgUcHgds3q9nuq/TXmPr460InR6KJso1+/3Ozc1FYmIiEhMT8fnzZ7x9+xbv379HQkICvn//joKCAsjKyoIQAjabDVVVVejq6qJVq1YYOnQozM3N0bJlSxgbG0NLS6tBj/iliU+CMBgMLFu2DAZNmqDQxgZcKSkw//1cKCAA6NoVePoUMDWFtrY2vL29cevWLUydOhV9+/bF7t27oa6uLr6bqCEmk4lu3brh8ePHGDVqVI3LEcY0BkIIJk+ejK5du1a/uyw4GPj/5yJCxWAAkZE08ZVBTU0NCQkJIqkrOTsZU65NQSGn5HSVfHY+UnJSMP7KeAROCix1HSEEP378QGJiIhISEpCYmIj379/zW2xpaWlgsVj8Z8pFRUVQUFCArq4umjdvjkGDBsHU1BQtWrSAsbEx9PX1IS1NP97LQ98ZCTQWAEdaGsz/thQIAXJzgTlzgCdP+IcHDx6MHj16YOXKlWjfvj327t2LUaNG1blvdL/n80la4tu6dStSU1Ph7e1dvfeUEKCWXbdVlpcHhIQAkyeLpr46RJQtvoMRB8EjZX/RYfPYeJz4GJ5nPVGQWoD4+Hh+i+3bt28Afu0OAoC/qL2Ojg6aNWuG/v37o127djAxMYGJiQmaNWtW5x9viBN9xieJrKyA58/LfZnIyuLL06fgaWuXWNmFEIKIiAisXLkSxsbGWL9+PXR0dPiv/fu/ZR2r6DVhn08IQUxMDLZu3QovL68alzVhwgSsW7cOLVu2FEisYWFh8PDwgKenJ7/7tKplMVgsOIwYAYaI/omlmJkhaPFi/jMccf3weDyxx/Dvn0/pn/Dh6wfYdbSDAltBqPf4qtMrZKtnl/+XVAyo+KuAvCcoKiqClpYWjIyM0LZtW7Ru3RrGxsYwNjaGiYkJGjduXOe+vNYVNPFJombNgMTEcl/OZTAwQlsbH2RlAaDEPw4GgwFCCLKzs5Gbmwt1dXWoqKiAwWDwz/vv+WX9t6rHBH3+q1evYGpqyh81Vp2yOBwOIiMjYW1tXeb9VjfWgoICvHjxAmZmZvyRttUpS47LxeXAQDBF9E8sSlcXu/r25d+7OH6kpKTEWv+/f75zvuNExgnEF8aDx+aBKceEsZwxZunMgr68fq3vEfj17Pf3s+m0tDTcULiBb42/lft3JM+Qx/aO2zHcfDj09PTAZDJF8rtBlUQTnyRycAAqmnwtLw98/QpUMlk5JiYGM2bMgJycHI4cOYLWrVsLNk4h6N+/P+bPn4+hQ4dW+9qAgABs3rxZIMuf5eTkwNraGosXL8bMmTNrVgiPB8jIiOYZHwCMHg1cuCCauiRcSk4KOh7qiJ9FP0t0PTLAgKqcKl64voCJeuVrmBYUFCAhIQGfPn3C58+f8fnz5xJ/lpKSgomJCZo2bYofP37gVf4rFA8tBk+67L9zDQUNpC1Ng7QUfcokTnStTkm0ZMmvuVllkZEBBg+uNOkBQIcOHfD06VM4OTnBzs4OW7dulfgd32uzYLWgnu/xeDxMmjQJPXv2rHnSAwApKcDAoNbxVImsLGBtLZq66oDNwZuRU5xT6nkbAUEuKxd/PvwTwK+5bQkJCbh//z6OHz+ONWvWYPz48ejatSt0dHTQuHFjODk54cCBA4iNjYWuri4mTpyIkydPIjExEQ8ePICZmRmePn0KMzMzhHuHw6qZFeSZpRc2UJRRhIejB016EoC2+CQRIcDs2SBeXmDk/2sBV3l5oEmTX8//tLSqVWRCQgJmz56Nr1+/4vjx47C0tBRw0IIRHByMJUuW4HkFzzjLM2jQIMyYMQMjRoyoVQwbNmxAQEAA7t+/D9n/706usTFjRNMKa9To18LVPXsKv646QPUvVeSycst9ncFjwOisEVK/pEJbWxsmJib852u/n7EZGxtDV1e31FKCXC4XN27cgIeHBz5+/Ij58+dj5syZ/GfA+ax8zL8zHz5vfCDHlAOXcKEiq4LdDrvh0sFFqPdNVQ1NfJKKELzeuBGMnTthJiv764Nt5kxg3rxff65RkQReXl5YsmQJJk6ciA0bNkCpvJalmBQVFUFTUxNfv36FSjWW4CKEQFNTE9HR0WjatGmN679+/Trmz5+P58+f8wcG1YqXFzB79q9Rl8KkoACkp5ffU9BAEELw8eNHtPZqDR7K72JmgIG3Y9/CuJlxucsE/ld2djaOHz8OT09P6OjowM3NDU5OTuWuYvKz6Cdi02OhKKMI0yamkGLQDjZJQf8mJBWDAc/kZARs2AD8+AF8/gysWlXjpPerSAYmTJiAmJgYfP36FWZmZggMLD2nSJzk5eXRuXNnPH36tFrXxcfHQ1lZuVZJLzY2FjNnzsTly5cFk/QAYORIwZRTEWlpYNy4Bpn0srKycO/ePWzcuBGDBg2ClpYWevfuDcXiiof666vqo03rNlVKenFxcVi4cCGMjY0REREBHx8fhIaGYsyYMRUu3aUmr4auBl3RUacjTXoShv5tSCgWi4WrV6/C2dlZ4GVraWnBy8sLnp6emD59OqZNm4YfP34IvJ6a6tGjR7Wf89X2+d7Pnz8xfPhwbN++HVZWVjUupxR5eXCmTwdbmJOJZWSAxYuFV76EYLPZePHiBf755x9MnjwZbdq0gaGhIbZt24aCggLMmDEDUVFRSEpKwr7R+6AkU/YXAUUZRSy3W15hXYQQBAUFYciQIbC1tYWysjKioqLg7e0Na/ostc6jT1kllL+/P9q1awcDIQ6OGDhwIGJiYrB69Wp06NABHh4eGD16tNjnDnXv3h1//vlnta6pTeLj8XiYMGEC+vfvj6lTp9aojPLcu3cPK27exEMmE2rV2W29qhQUgGnTgHbtBF+2GBFCkJycjPDwcISHhyMsLAyvXr1Cs2bNYG1tjW7dumHJkiVo165dmSuUTO40GYGfA3H93fUSG50qyyijX/N+mGM5p8x6CwsL4eXlhb1794LH48HNzQ2+vr50snh9QyiJNGHCBLJ//36R1ff06VPStm1bMnToUJKcnCyyesuSl5dHFBUVSX5+fpWvsbCwICEhITWqb82aNaR79+6ExWLV6PqypKSkkFGjRhETExNy+/ZtQoKCfm0cK6hNaIFfm9rq6RFSjfdJUuXm5pIHDx6Qv/76iwwfPpzo6uoSbW1tMnToULJlyxYSGBhIsrOzq1Umj8cj9+LvkQHnBpDWnq1J/zP9ya33twiXV3qD4i9fvpDVq1cTLS0tMmjQIOLv7094PJ6gbo+SMDTxSaCCggKipqZWcgdvESgqKiJ//vkn0dTUJAcPHhTrju82NjYkKCioSufm5+cTRUVFUlhYWO16Ll26RAwNDcm3b9+qfW1ZWCwW2b17N9HQ0CDr1q0jBQUF/3tx2zbCkpERXOJTVSXkzRuBxC1KHA6HREdHk2PHjpGZM2cSU1NToqioSLp27Urc3NyIj48P+fz5s0gSz7Nnz8i4ceOImpoamTdvHnn37p3Q66TEj3Z1SqA7d+7A0tKyVrsU1IScnBzWr1+P0aNHY8aMGfD29sbRo0fFMvH993O+3r17V3puZGQkOnToUOGmsGWJiYnB7Nmz4efnB21t7ZqGyvf06VPMmTMHTZo0QUhICFq1alXidW8DAyQqKGAFkwmp2uzYICPza4uqR4/qRBdnWloav8syPDycP2LW2toa1tbWmDlzJjp27Fj7qSNVxOFwcPXqVXh4eODLly9YsGABDhw4QHevb0jEnXmp0kaNGkWOHTsm1hg4HA7Zt28f0dDQIJs3bxZoN2BV3L59m/Ts2bNK5+7YsYMsXLiwWuX/+PGDNG/enJw5c6Ym4ZXw/ft3MnXqVKKnp0d8fX3LbKncuXOHaGtrk+joaEICAwnR1iZEXr7arbw8gOR260aIiHsDqqqwsJA8ffqU7Nmzhzg7OxMjIyOirq5OHBwcyJ9//knu3LlDMjIyxBJbZmYm2b59OzEwMCDdunUjly5dImw2WyyxUOJFE5+EycnJIaqqqiQzM1PcoRBCCElISCCOjo7E1NSUPHv2TGT1/vz5kygpKZGioqJKz3VyciLe3t5VLpvD4RAHBwfi7u5emxAJl8slhw8fJlpaWsTd3b3cZ1AhISFES0ur5DPInBxCliwhRFmZcJWUKk54UlKEKCkR0qoVuTl5Munbp49EPH/i8Xjkw4cP5MyZM2TevHnE0tKSKCoqks6dO5O5c+eS06dPk3fv3om1y5wQQt6+fUtmz55N1NTUyMSJE0lERIRY46HEjyY+CXPu3DkyaNAgcYdRAo/HI+fOnSNNmjQhixcvJnl5eSKp18LCgjx58qTS2HR1dcmnT5+qXO6KFStI7969a/Vt/8WLF8Ta2pp07dqVvHr1qtzzoqOjiba2Nrl7927ZJxQWkqCpU0mooSEhRkaEMJmESEv/+q+8PCGdOhEyfz4h4eGEkF/PENu3b08uXbpU49hrKjMzk9y9e5esX7+eODo6ksaNGxNDQ0MyevRosnv3bvLkyZOSzzTFiMfjET8/P+Lo6Ei0tbXJ2rVrSWpqqrjDoiQETXwSZvDgweTs2bPiDqNM379/J+PHjyfGxsbE399f6PW5u7uTLVu2VHhOUlIS0dbWrnILyNfXlzRr1oykp6fXKKafP3+ShQsXEm1tbXLs2LEKWzOfP38m+vr6xMvLq8IynZyc/tflyuEQkpdHSGEhIeXc04MHD4ihoWG1Rr1WF4vFIhEREWT//v1k4sSJpFWrVkRFRYX06tWL/PHHH+Tq1asSmUjy8vLIwYMHSZs2bYiZmRk5ceJEjQY9UfUbTXwSJDMzk6iqqlZ72Lao3blzhxgZGZHJkycL9XnN1atXiYODA+FwOeTt97fEL86PXI29Sq7FXiP34u+Rjz8+El9fXzJ06NAqlffq1SuiqalJXr58We1YeDwe8fb2Jk2bNiUzZsyoNHF++/aNtGzZkuzbt6/C89hsdo1G8I4dO5asWbOmWteUh8fjkYSEBOLr60sWL15MbG1tiZKSEunQoQOZPn06OXr0KImKiiIcDkcg9QlDUlISWbFiBdHQ0CDDhg0jDx48kIjuYEoy0VGdEuTq1avo168fVFVVxR1KhQYMGIDo6GisWbOGP/Hd2dlZoBPfX6e9xm3ebQS0CIDiVkXIMmXBZDBBQMDAr3rYPDZYLBaadG6ClYErMcNiBpo3bl5meZmZmRgxYgQ8PT3RqVOnasXy/v17zJs3DxkZGbh06RK6du1a4fk5OTlwdHSEi4sLFixYUOG54eHhaNasWbVH8O7cuROdOnXC5MmT0aJFi2pdm5ubi+fPn5eYHA4ANjY2sLa2xqZNm2BpaSnxv4eEEP5GwQEBAZg0aRLCw8PRvHnZvwMU9RtdpFqC9OvXD66urhg1apS4Q6my0NBQzJgxA82bN8c///wDfX39GpfF4rJw6e0lbH+yHfFZ8SjmFINLuFW6VkZKBkwpJro07YLldssxsOVA/vqIHA4HAwYMgLm5OXbs2FHleAoKCrB161YcOnQIa9aswfz588tcJeTfioqK4OjoiPbt22P//v2VfhlYt24dWCwWtm3bVuW4ftuxYweCg4Nx69atcs/hcrl4+/YtP8GFh4fj8+fP6NixIz/RWVtbw9DQUOwr9lQVi8XCpUuX4OHhgczMTCxcuBBTp06V+ERNSQ6a+CTEt2/f0Lp1a6Smpta55ZFYLBb++usveHp6YuPGjZg9e3aprVwq8+LrC4y+OBrf874jj127nQyUZZXRVrMtfEb5wETdBEuXLkV0dDTu3LlT5R2vb926hQULFsDa2hq7d++Gnp5epddwOByMHj0acnJy8PLyqlJd1tbW2LZtG3r16lWluP6NxWLBzMwMO3fuxJAhQwAAX79+LTFnLiIiArq6uvwEZ2NjAzMzswoXV5ZUGRkZOHLkCA4cOIDWrVtj0aJFGDx4MN3FnKo2mvgkxIEDBxAaGopz586JO5Qae/v2LWbMmAEmk4mjR4+iTZs2lV7D4rKw7sE67Avfh0JOocBiYTKYkJOWw8hGI/FkzxNEPI9A48aNK70uMTERixYtwtu3b3HgwAH069evSvURQjBjxgykpKTg5s2bVZqMnZmZCRMTE6Snp9do8nZhYSEOHTqEzZs3o2fPnoiIiEBeXh6srKz4rTkrK6sq3bcki4mJwd69e3Hp0iWMGDECixYtQseOHcUdFlWH0Wd8EsLHxwcrVqwQdxi10q5dOzx+/BgHDx5Et27d4ObmhuXLl5f7oZ5bnIu+Z/si5luMQJMeAHAJFwXsApz9ehZ9VvSBSqOK9/ZjsVj4+++/sXPnTv7CxFXdpw0A/vjjD7x58waBgYFVTmKBgYHo3r17lc7n8XiIi4sr8Vzu3bt3aNeuHX/FkcDAQLRo0aLOdFlWhMfj4c6dO9i7dy9iYmIwd+5cvH//XiAr7FAUbfFJgOTkZHTq1Alfv34V2bJNwpaUlITZs2cjJSUFx44dK7XVT25xLmxP2CIuMw7F3GKhxqIoowg7AzvcHncbMszSXXwPHz7E3LlzYWxsDE9PT5iYmFSr/F27duHEiRN4/Pgxfxfuqpg2bRosLCwwf/78Uq9lZmbi2bNn/Odyz549g6qqaonncubm5lBQUEBiYiIsLCwQGRmJZs2aVSt2SZOXl4dTp05h3759UFFRgZubG5ydnav1JYSiKkMTnwTYvXs3YmNjcezYMXGHIlCEEPj4+MDd3R3jxo3Dpk2boKSkBDaXDfuT9niV9kroSe83RRlFDGo5CL6jfPktorS0NCxbtgyPHj3C3r17MXz48Gq3lk6dOoX169fjyZMn1RrYQwiBvr4+Hj58CCMjI7x+/bpEa+779++wtLTkP5eztraucOTn5s2bERkZiatXr1Yrfknx+fNn7N+/H6dOnUKvXr3g5uYGOzu7etF6pSQP3YhWAvj4+GDs2LHiDkPgGAwGXFxcEBMTg/T0dHTo0AH+/v7Y+Ggjor9HiyzpAUABuwB34u7gXNQ5cLlcHDhwAKampmjatCnevn2LESNGVPtD9vr161i5ciXu3btX5aRHCEFCQgJ2796NvLw8TJ48Gerq6pg+fTqioqLQs2dPXL16FT9+/EBQUBC2bt2KoUOHVjrd4fcAHj8/v2rdgzgRQhAcHIyRI0fC0tISUlJSiIyMxKVLl9CtWzea9CihqRctPkIIwr+E48HnB9BT1cPItiOhJFv27suSJj4+HnZ2dvjy5UulQ+XrOj8/P0xbOQ3fh34HV6pq0xQETYGpgJZ3W0JNWg3//PMP2rdvX6NyHj16hNGjR/N30ihPTk4Of87c725LJpMJDQ0NKCkpYdu2bbC0tISysnJNb4nv9u3bcHd3R3R0tER3DRYXF8PX1xceHh7Iz8/HwoULMXnyZIG8BxRVFfUi8bnecoVXlBeKOEVQkFaAkqwSns98DoNGwtu9XFC2bNmCr1+/Yv/+/eIOReg4PA7aeLbBx6yPgLi+zHOB9krtEb08usYtipcvX8LBwQE+Pj4ltk3icrl48+YNP8GFh4cjISEBnTp14ndX2tjYQF9fH/3798e8efMwfPhwAd3YL0OHDoWtrS3++OMPgZYrCN++fcOhQ4dw6NAhmJqaws3NDY6OjtWe+kJRtVXnE19EagR6nOqBAnYB/xiTwcTodqNxftR5MUZWNaampvxRkPXd1dirmHRtEvJYtZunV1uKMop4MvUJzHXNq31tXFwcevToAU9PT3Tt2rXEc7nIyEjo6emVeC5nampaas5cQUEBmjRpgi9fvgh80vWnT59gZWWFly9fwsBAMr74vXr1Cnv37sW1a9fg7OyMhQsX1rilTVGCUOf71h4lPAKHxylxjEu4uPLqClwDXKGmpoZGjRqV+PnvMVVVVbF864yJicHPnz9ha2sr8rrFYdvTbWJPegBQzCnGnrA9ODvibJWvKSgogL+/P6ZPn45mzZrB3d0d+fn5/AS3cuVKWFlZQV1dvdKyHj16BHNzc6GsNGJiYoJ58+Zh6dKl8PX1FXj5VcXlcnHz5k14eHggPj4e8+bNQ1xcHDQ1NcUWE0X9VucTn0EjA8gx5cDiskocZ2eycfv2bRgbG6Np06ZQVVVFQUEBsrOzkZ2djZ8/f/L/nJeXB2Vl5UoTZEXHlJWVq9115uvrC2dn5wbR1fMu4x2iv0WLOwwAv74YXXp7CZ4DPKEmr1bqdR6Phw8fPpRozb1//x6EEHTs2BHz58+HtbU1mjdvXqPu0nv37sHR0VEAd1K2FStWoH379ggKCkKfPn2EVk9ZcnJycOLECezbtw/a2tpwc3PDyJEj6+RKMVT9VecT37DWw7BMYRkKOYX8lp+ijCJ8F/lCa4oWAgMDERAQgDt37qBz587o27cv+vXrh86dO/MHk/B4POTm5pZIhv9NkFlZWUhISCj3nKKiIqioqFQ5aaqqquL06dPYtWsXUlNT0ahRIygqKtbbkWxnXp8Bm8cWdxh80gxpXI29iqnmU5GRkVFima9nz55BTU2N35pzdnbGypUr0bVrV+zevbvWf0f37t0T6go9ioqK+Pvvv7FgwQK8fv1aJEknPj4enp6eOHv2LBwcHODt7Q0bGxuh10tRNVHnn/EBwLe8b1h1fxXuxd+DnqoeNvTcAMcWJb9R5+fnIzg4GAEBAQgMDERycjJ69erFT4S1XfGCw+EgJyenzBZlWceSk5Px8uVLGBkZ8a9js9lQVVWtVkvzv/8vLy9f27dTKGyP2yI0JVTcYZRgnG0MqRtSSE9PR5cuXUos8/V7+gCbzcawYcOgqamJU6dO1bp1npSUBEtLS6SlpQm1pU8IwYABA9C/f38sXrxYaHU8ePAAHh4e/MXK586dKzHPFimqPPUi8dVEWloagoKCEBAQgICAAEhLS6Nfv37o27cv+vTpAy0tLaHWv3z5csjIyGDLli38YywWq1SyrEoS/ff/A6hxd+3vPwt69RhCCFS3qUrE871/ayLdBPdH3EebNm3KTEI8Hg+TJk1CdnY2rly5IpCW09GjR/Hw4UN4eXnVuqzKfPjwAba2toiOjoaurq7Ayi0qKoK3tzc8PDzA4XDg5uaGCRMm1LnF1amGq8Emvn8jhODdu3f81uCjR4/QvHlzfmuwW7duUFBQEFh9PB4PxsbGuHXrFkxNTQVWLvDrQ6k6CbOsY9LS0jVOmr9//j0nMSk7CW32txH4epy1JSMlg/xV+WUuY0YIgZubG168eAF/f3+B/f2PGjUKQ4cOxaRJkwRSXmVWrlyJlJQUnD1b9YE85UlNTcXBgwdx5MgRdO7cGW5ubujXr1+97Z6n6i+a+MrAZrPx7NkzfiJ8/fo1rK2t+YnQ3Ny8Vt1UISEhmDlzJmJiYiTuQ4MQUmIQUE2SaE5ODhQUFPhJUMpICu8t34Mjzak8ABFSkFbAx4UfoatSujW0efNmXLx4EY8ePeIvAl1bHA4H2traePv2LXR0dARSZmXy8vLQtm1beHt7w97evkZlREREwMPDA7dv38a4ceOwcOFCtG7dWsCRUpTo0MRXBTk5OXj06BG/WzQ9PR29e/fmd40aGxtXq7yFCxdCS0sLa9euFVLE4kUIQV5eHj8RBn0OwurXq5HPzRd3aCUoyyrj9ezXMFEvuSj1oUOHsHPnTjx58kSgXYQhISGYO3cuXr16JbAyq+LChQvYsmULIiMjq7w6EIfDwbVr1+Dh4YHk5GTMnz8fM2bMqNJ0DYqSdHV+VKcoqKqqYsiQIfzNPlNSUhAYGIjAwECsXbsWysrK/NZgr169Ktz/jMvl8lsS9RWDwYCKigpUVFSgr6+PdKV0SL+RBsSzSlm5eDweGKRki/vixYvYtGkTgoODBZr0gF+jOR0cHARaZkWSs5NxPuY8kpWTkdM5B6s8V2GHe8U70GdlZeHYsWPYv38/DA0N4ebmhuHDh9f75fSohoW2+GqJEIKYmBh+t+iTJ0/Qpk0bfiK0tbUtsW7i/fv3sWzZMkRGRooxatEKSwmD4zlHZBdnizuUkjgA05MJTXlNaGtrg8lkIjY2Fk5OTmjbti20tLSgra0NLS0t/p/V1NRq3M1tY2ODrVu3lljmTBhyinMw8cpE3Pt4DwQELC4LDDBA2ARtmrTBNZdraK1Zsqvy/fv32LdvH7y9vTF48GAsWrSowjVIKaouo4lPwIqLixEaGsqfP/j27VvY2dnxu0X379+PVq1aYdmyZeIOVWQyCzLRdHdTsHisyk8WIQVpBWQtzUJmZibu37+P+fPnY+HChdDQ0EB6ejq+f/9e4r/p6enIy8uDpqZmiWRY0Z9/J8ofP36gWbNmSE9PF+oC0vmsfFgfs0b8j/iyd78gQCP5Rng+8zlaNG6BgIAAeHh4IDIyErNmzcKcOXPQtGlTocVHUZKAJj4hy8rKwoMHDxAYGAh/f398+vQJQ4YMwfDhw9G3b98GM+dJa6cWMgoyxB1GCRa6FoicFYnY2Fj06tULx44dw+DBgyu8hsViISMjo1RCLO/PvxOlrKws8vPz0a9fvyolyppa/3A9tj/djiJOUbnnMMCAsYwx5L3kwWQy4ebmhnHjxknsHFCKEjSa+ETozp07WLt2LebMmYPAwEAEBQVBQ0OD3y3as2dPNGrUSNxhCoXDWQf4f/IXdxh8DDCw0HohFrdbDHt7e2zatEkoUwx+J8q5c+dCT08PdnZ25bYmv3//joKCAmhoaFSpNfnfRMnhcdBkVxP8KPxRaVxSPCmcsjqFCQMnSNzIYooSNvrEWoR8fHwwZcoUzJgxAzNmzACPx8OrV68QGBiI/fv3Y8KECTA1NeUnQhsbm3qzxqFDCwc8TnosMXP5lGWVYdHYAg4ODnBzcxPavDpZWVno6uoiIiICO3bsQKtWrSo8/3eiLKsFGRkZWWGiVDBSQI55DsCsPC6mFBN52nk06VENEm3xiUhhYSGaNm2K2NjYcudwFRYW4unTp/zng/Hx8bC3t+c/H2zXrl31PqgIAeLigLw8oGVLQEVFQHdTfen56TD0MKywC06UVGVV0fJaS/Tv0x9bt24Val1v3rzBoEGDEB0djcLCQhQUFAjsJz8/H/n5+b/+X70AZAIBqtJjyQE29tiItX3r55QaiqoITXwicuXKFRw4cABBQUFVviYjIwP379/nzx9ksVj81mCfPn0qHoRw+zawYAHw7RsgLQ2w2cD48cDevYAYlpYKDw+Hk68TUlVSATFvRiHHlINOgg76S/XHoUOHwGazK00utUlOubm54HA4UFRUFOrPT+5PtPmnDYq4lX+5kOHJoEd2DwR4BIjgHacoyUITn4g4Ozujb9++mDVrVo2uJ4Tg48eP/NbggwcP0LRpU34i7NGjB5SVlX+dfP064OICFP6nW1FeHujYEXj6FGBWoT+slng8Hu7cuYMdO3YgKSkJIxaOwJGiIyU2DRYLDiB7SBayRbIoKCiAtLS0UBPSmDFjMHfuXDg5OQn91rqd6IanyU8rPU9JRglKB5Rw+/ptOm2BanBo4hOB3Nxc6Ovr4+PHjwLbiJPL5SIyMpKfCJ8/fw4LCwv069MHKzw9IZuZWfaFysrAuXPAsGE1rpsQgqKionJbONnZ2QgICMDNmzfBZDJhb2+P5s2bo7CoEBdlLiJFNgU8Bq/G9dcGk8eEVpIWwjeEQ11dHQoKCkKdnF1YWAhtbW2kpKSIZOBS0KcgDPUZWuGXC0UZRSy2WQzjBGMcOXIEISEhDWJPSIr6jSY+EfD29sa5c+dw584dodWRn5+Px48f493Zs5jp4wMlXvmJJbljR9xyda1x111hYSHk5ORKtWxkZWXx48cPJCcnQ11dHZ06dULz5s2hpKTEP4crz8WGrA0oIuJ51idTKIMvK75AS124u2/85ufnhy1btuDx48ciqQ8A9j/bjxWBK1DILgTBf/55swEHYwfcmXYHIICtrS1cXV0xdepUkcVHUeJGR3WKgI+PD8aOHSvUOpSUlODo6AhHaelfz/eyy18lpfjLF0RFRfGTkaqqKnR0dKrcdaegoFCihZCSkgIPDw+cOHECgwYNwqVLl9CxY8dy6zd5Y4Kp16eKvMuTwWHg+vjrIkt6gOiXKQOA+Vbz0Vm3M/568hfufbwHaSlpsLlsmGqbwrLYEs8OPANnIgeysrLYv38/Bg8ejOHDh9N1OKkGg7b4hCwrKwtGRkZITk4WzRy9lJRfIziLymlRycgArq6Ap2etq4qOjsauXbtw8+ZNTJkyBW5ubjA0NKz0OkIIFtxdgJOvToos+THYDKy1W4sNAzaIpL7f2rVrh9OnT6NLly4irfe3AnYBMgsyoSKnAjV5NRBCMGTIEFhYWGDjxo0AgNmzZ0NWVhb79u0TS4wUJWo08QnZiRMncOvWLVy5ckV0lTo4AA8e/BrJ+V8KCsDr17+SYw0QQvDw4UPs2LEDr169wsKFCzF79uxqtxYIIZh6fSouvr0o/OTHBuZ3mg/PUbVP9tWRnJwMc3NzfPv2DUwRDCaqqrS0NHTq1AnXr1+HtbU1MjMz0a5dO/j7+1fYUqeo+oI+0RYyX19foXdzlnLmDNC0aYlpCzwm81fS27u3RkmPw+HA19cXXbp0wZw5czBy5Eh8/vwZK1eurFEXGYPBwMlhJzHTYiZkIMRJ+mzA3dRd5EkP+NXN2a9fP4lKegCgo6OD/fv3Y+LEifwJ8Bs3bsT8+fNBvwdTDQFNfEL0/ft3hIeHY9CgQaKtuEkT4M0bYNcuoHNnpCgpIaV7dyAsDJg5s1pF5efn8xfW9vT0xNq1a/H27VvMmDGj1ms7MhgMjNcYD6mLUpBmSUNeWnBrRcoz5SGVIwVPC0/sGbNHYOVWhzie71XVqFGjYGVlhRUrVgAAZsyYgYKCAnh5eYk5MooSPtrVKUQHDx7E48eP4e3tLdY4Fi1aBCMjIyxevLjK16Snp2P//v04ePAg7OzssGzZMtja2go0ruzsbHTo0AHZ2dl4/Pwxdr3ZhUuxl8AjPLC4NdvJQY4ph+LiYijGKOKw82FMcJkg0Jir6vdu6zExMRK728HPnz9hZmaG48ePo1+/fggLC8PIkSMRGxsLVVVVcYdHUUJDW3xCJIrRnFXRvHlzxMfHV+nc+Ph4zJ07F61bt0ZaWhoeP36Mq1evCjzpEUIwc+ZMFBYWwsPDAx1bd8RZp7OInReLBVYLoCKrAhVZFTBQ+RJtUpCCNFcamgqaWGSxCCrHVGD100psSQ8Anj9/Dn19fYlNegCgpqaG48ePY9q0acjKyoKNjQ0cHBywYYNoBwBRlKjRxCckKSkpiI6OloiurubNm+Pjx48VnvPs2TOMHj0aXbt2RePGjREbG4vDhw+jdevWFV5XU8ePH8fDhw9hbW1dYg5ZM7Vm2NV/F9KXpePMiDNYarsUbZTbQIorBWkpacgx5SDHlAOTwUQjuUbobtQdiy0XQ/aaLKImReHeqnuYPXE2oqKikJycLJTYq0KSuzn/rV+/fhg+fDgWLFgAANi2bRvOnDmDN2/eiDkyihIiQgnFnj17yNSpU8UdBiGEkNjYWNK8efNSx7lcLrl16xbp3r07MTIyIh4eHiQ3N1fo8cTExBA1NTWiqalJ0tLSKj3f09OTzHKdRXKLc0l6fjrJyM8g+az8EufY2NiQDh06kPnz5xMej0dWrlxJZs2aJaxbqJSNjQ0JCAgQW/3VkZ+fT1q1akUuXLhACCFk3759pFevXoTH44k5MooSDpr4hMTKyorcu3dP3GEQQggpKioisrKyhM1mE0IIKS4uJidPniTt2rUjnTp1Il5eXoTFYokklvz8fNK2bVuipaVFrl69WqVrFi5cSHbt2lXu62w2m7Rt25a0atWKcLlcQgghmZmZRENDg8THxwsi7Gr58eMHUVFRIYWFhSKvu6bCw8OJtrY2SU1NJWw2m5iZmRFfX19xh0VRQkG7OoXg06dP+Pz5M3r37i3uUAAAcnJy0NHRwZs3b7Bjxw6YmJjA29sbHh4eePHiBcaNGyeyff/c3NzAZrMxcOBADB8+vErXxMXFoWU5UzDI/z8rbNy4MVgsFn/bpsaNG2PBggX8SdqiFBgYCHt7+zq1o7mVlRVcXV0xY8YMMJlM7N+/H0uWLEFeXp64Q6MogaOJTwh8fX0xatQooS5+XB0pKSkghMDe3h5RUVG4desW/P390a9fP5FuROrr64vbt2+juLgYe/furfJ1FSW+5cuX4/379/Dz8wOPx0NsbCz/NTc3N9y9e7fEMVGoK8/3/mvt2rVIS0vD0aNHYW9vj549e2LLli3iDouiBE/cTc76yMzMjDx8+FDcYZDo6GgyefJkoq6uTjp06EA2bdoktlg+fvxINDU1iaamJnnw4EGVr2OxWERWVpYUFRWVem379u2kffv2JDMzkxBCyNy5c8n27dtLnLNt2zbi7Oxcq9irg8fjEX19ffLu3TuR1SlIb9684XcRp6amEg0NDfL+/Xtxh0VRAkVbfAL29u1bZGRkoFu3bmKpn/z/kmKDBg1Cv3790KpVK8THx2P8+PH4+fOnWGJisVgYO3Ys9PT0MGnSJPTs2bPK137+/Bl6enqQk5Mrcfz48eM4ePAg7t27h8aNGwMABg8ejFu3bpU4b/78+QgODkZUVFSt76MqYmNjwWQy0apVK5HUJ2jt2rXD6tWrMXnyZGhra2PlypVYuHAhXdGFqldo4hMwX19fODs7i3yZKi6Xi4sXL8La2hqurq4YPnw4Pn/+jFWrVqFx48ZVmtIgLKtWrQKHwwGLxap211lZ3ZxXr17F2rVr4e/vDz09Pf7xXr164dWrV/jx4wf/mJKSEv744w+sW7eudjdRRb+7OUXZhSxoixYtgoyMDHbt2oWFCxciKSkJ169fF3dYFCU44m5y1ic8Ho+0atWKhIWFiazO/Px8cuDAAWJiYkJsbW3J1atX+SMb/+3FixfE1NRUZHH9dvv2bdK0aVOioaFBXrx4UbWLCgsJOXuWkFGjyKe2bUmQmRkhsbGEEEIePHhAtLS0SGRkZJmXDh06lHh5ef2nuEKir69Pnj17Vqt7qQoHBwdy+fJlodcjbAkJCURTU5O8fv2aBAUFkWbNmpH8/PzKL6SoOoAmPgF68eIFadasmUjmP6Wnp5P169cTbW1tMmzYMPLkyZMKz8/OziaKiooinZv15csXoqOjQywsLMjmzZurdtHVq4SoqBCirEwIQAhAOFJShCgokJ82NsRYQ6PCZ4RHjhwhLi4upY4fPHiQODg41OxGqqigoICoqKiQnz9/CrUeUTl58iQxMzMjRUVFxNnZmaxbt07cIVGUQNDEJ0DLly8nf/zxh1DriI+PJ3PnziXq6upk5syZ1RpEoampSVJTU4UY3f9wOBzSq1cvMnDgQGJjY8OfQ1ihGzcIUVDgJ7z//hQCJMvYmJAyBrr8lpKSQtTV1UvVV1xcTJo1a0aCg4Nre2vlunfvHrGzsxNa+aLG4/HI8OHDyYoVK0hSUpLY5kVSlKDRZ3wCQggR6tqcz58/h7OzM6ytraGmpoa3b9/iyJEj1VpSTJTP+bZu3YqCggKEh4fjzJkzlU/t4HCAKVOAwsJyT5EHoPbtG3D6dLnn6OnpwdjYGCEhISWOy8rK4s8//8SaNWuENlCjrk5jKA+DwcDhw4dx+vRpJCYmYunSpXB3dxd3WBRVazTxCUhYWBgUFRVhZmYmsDIJIbhz5w569eqFkSNHwtbWFp8/f8aWLVugo6NT7fJElfiCg4Pxzz//oLCwEJs2bSp3Dl4JN2+WvXHufxUUANu3/2oDlmPw4MG4fft2qeMTJkxAWloagoKCKq+nBupb4gMAbW1tHDp0CJMnT8bMmTPx7t27Mt9biqpLaOITkN+tPUGM5mOxWDh9+jTMzMywatUqzJgxAx8/foSbmxtUVFRqXK4oEl9mZibGjx+P3r17Q1dXF7Nnz67ahUFBQG5u1c5NSgIqWFGkrGkNACAtLY0NGzZg7dq1Am/1JScnIy0tDZ07dxZouZJg2LBh6NGjB1avXg1PT08sWrQIRUVF4g6LomqMJj4B4HK5uHDhAsaMGVOrcnJycrBr1y6YmJjg3Llz2L17N16+fInx48cLZEmxFi1aCDXxEUIwZcoU9OjRA4GBgThx4kSZXwQKCgoQGxuLe/fu4ciRI1i9ejUe+PlVvSImE2CVv19f586dkZmZiU+fPpV6zdnZGXl5ebhz507V66sCf39/9O3bV+J2WxcUDw8P+Pn5gcvlwtTUFLt27RJ3SBRVY5KxplYdFxwcDB0dHbRp06ZG16empmLv3r04duwYHBwccPPmTZibmws4SuG3+Pbt24fU1FTExsbC3d0dz549Q2JiYqmfvLw8GBgYwMjIiP+jZG0NbkoKmMXFlVckIwOoqZX7spSUFAYNGoTbt2/zt9v592sbN27E2rVrMWDAAEhJCea737179zBgwACBlCWJVFVVcerUKYwfPx63bt1C3759MXHiRBgZGYk7NIqqNroDuwC4urrCxMQEK1asqNZ1b968wa5du3D9+nVMnDgR7u7uaNasmXCCBJCWloYOHTogIyOjxmXweDx8/fq1VDKLiopCeHg4GAwGGAwG2rZty09qhoaGJZKctrZ26YSTkQHo6wOVJT4ZGWDuXMDDo8LTrl69ikOHDuHevXulXiOEwNLSEqtWrcLIkSOr+Q6UxuVyoaWlhejo6BIT6uujJUuWIDk5Ge3bt0dUVBQuX74s7pAoqtpo4quBb3nfkJSdBB7hQUdRB5atLfH8+fMqJS1CCB4/fowdO3YgIiICCxYswJw5c/jLbgkTIQQqKir48uULGjVqVOY5xcXFSE5OLpXYkpKSkJiYiJSUFDRu3LhEMmvSpAn27NmDQYMG4c6dO4iOjq7Z/cyfD5w8+WsASzm4iopgxsYChoYVFpWbmws9PT18+fKlzOeid+/exdKlSxEVFVXr7smwsDDMnDkT0dHRtSqnLigqKkLnzp2xbNkybNq0CQcPHkT//v3FHRZFVQvt6qwiQgj8P/pjR8gOhCSFQE7619qRhaxCyI6Xxeui1zAkhpBilN11xuVycfXqVezcuRNZWVlYunQpLl26JNKtaxgMBpo1awY/Pz8oKSmVSGi/fzIzM9G0adMSLTR7e3v+nw0MDErETAjBhAkT0L9/f9y7dw8nT56seRL38ADS0gA/PyA/v+Rr8vJgMxgYIS+P7bm5aF9JUSoqKrCxsUFgYCBGjBhR6nVHR0ds3rwZPj4+GD9+fM3i/X/1cTRneeTl5XH27Fk4Ojpi+/btWLhwIaKioiArKyvu0CiqymiLrwo4PA4mX52M6++vI5+dX+Y5yjLKsDeyx5UxVyAv/b/EUFhYiFOnTmH37t3Q1tbGsmXLMHToUKEMgiCE4Pv376WS2b9/cnNzoaOjA1NT0xLJ7fePrq5utWI7efIkdu/ejQ4dOkBTUxP79++v7U38Snw7dwKPHwNcLqChAcyZA8ydC6+gICxfvhwPHz6sdJrEvn378Pr1axw/frzM1x88eIBZs2bh7du3tRo8ZGtriw0bNqBfv341LqOu2bx5M4KDgyEjI4MePXpg+fLl4g6JoqqMJr5KEEIw+dpkXI69jAJ2+V1wAKAgrYBexr1w0+Umsn5k4cCBAzhw4ABsbGywfPly2NnZ1SoWDoeDL1++lJvUkpKSoKSkVGZC+901uW3bNmhqauKPP/6oVSzAr50IunfvjpUrV+LQoUN4+fIllJSUal1uCTwe8J/ngUePHuV/8FY0uOLjx4+ws7NDampquYNY+vTpg3HjxmH69Ok1Ci8rKwuGhoZIT0+vUxvP1haHw0G3bt3g6OiI/fv34/Xr1/X++SZVf9DEV4nQ5FD0Pdu30qT3m6K0Inpn9sbTU0/h5OSEJUuWoG3btlW6tqCgoMLWWlpaGpo0aVLuoBFDQ0MoKytXWMehQ4cQGRmJo0ePVimm8hQWFsLa2hqTJk3Czp07cePGDVhbW9eqzOrYu3cvPD098fjxY+jq6pZ7Xrt27XD69Gl06dKlzNdDQkIwbtw4vH//vtTWR1Vx6dIlHD9+HHfv3q32tXXdhw8fYGdnh1GjRuHnz584f/68uEOiqCqhz/gqsStkFwrZ5S+j9V8FnAK8Vn6NN2/elPhAJoQgKyur3Jba725IAwODEgmtX79+/D/r6+vXej5f8+bN4evrW6sygF+j+9q1a4egoCC4urqKNOkBv7bOyc/PR9++ffHw4UNoaWmVed7vyezlJT5bW1u0a9cOx48fx9y5c6sdR0N6vvdfrVq1wvr163H69GmkpaXh4cOH1dprkaLEhbb4KlDALoD6dnWwuOVPli6LNEMaK2RX4EfSjxIJTkpKqsxuyAqH+QvYp0+f0LNnTyQlJdW4jMuXL2P58uVYsGABzp49i7CwMIFMsK+J1atX4+7du7h//z7UypjbFxwcDHd3d0RGRpZbRmRkJIYOHYr4+HgoKChUuW5CCIyMjHDv3r0qt+rrGx6PB0dHR2hoaCA6OhovX74U2+8CRVUVTXwVSPyZiPb/tC93QEt5pLnScCl2gZWBVYluyLI+mEWNw+FASUkJOTk5NeraS0hIgJWVFQ4dOoRZs2YhODgY7dq1E0KkVUMIgbu7O8LDw+Hv719q6gKHw4G2tnalc+ycnJzQrVs3LF68uMp1x8bGwsHBAYmJiXV649naSklJgYWFBUxMTDB27Fi4ubmJOySKqhBNfBVIzk5GmwNtqvx87zdVOVUETwlGR52OQoqsdlq2bImbN29We6UZNpuN7t27Y+TIkbh69SpGjx4tER9yhBC4uroiLi4Od+7cKdVqGzduHHr16oWZM2eWW0Z0dDT69euH+Pj4Sp+T/ubh4YE3b97U+nlpfeDt7Y1169bh58+fiImJqdEi6hQlKnStzgpoK2mDR3jVvq6YUwyDRgZCiEgwarp02dq1a9G4cWMUFxdDTk4OCxcuFEJ01cdgMHDw4EHo6enByckJxf9Z/aW8Rav/zdTUFL1798a+ffsqrY8QgrS8NNwOvN1gn+/9l4uLCywsLGBsbFztFYwoStRo4quAnLQcXDq4QFqq6mOAGGCgX/N+aKwg/JVYaqp58+aIj4+v1jX37t3DuXPnsGTJEnh4eODUqVNCfx5ZHUwmE6dOnYKCggJcXFzA4XD4rzk6OuLBgwcorGCvPwBYv349/v77b/z8+bPcc6K+RaHNgTZo5tEMgeaBOM8+jyIO3ang95ePL1++4M6dO3j69Km4Q6KocknOJ5eEcrdxh4xU1R/WK8ooYpntMiFGVHvVbfF9/foVU6ZMwYkTJ7Bo0SLs3r0bhpUsGSYO0tLSOH/+PAoLCzF58mRwuVwAQOPGjdGpUyc8fPiwwutbtWqFwYMH4++//y7z9WJOMXqf7o0PmR9QzC0GpIE7n+7A3Y9uzgoAGhoaOHbsGBgMBmbPns1//ylK0tDEVwnTJqZwt3GHPLPyyckykMF40/GwN7QXQWQ1V53Ex+VyMXHiRMyaNQsBAQFo1aoVJk6cKOQIa05OTg5XrlxBamoq5syZw993ryrdnQCwbt067N+/v8yFvO9/vg82t+RmuUWcIpyJOiOY4OuBgQMHYvjw4cjIyMChQ4fEHQ5FlYkmvipY3Gkx5F7IQZYhC2lG6W5PJoMJeaY8pGOk4STvJPEj/KqT+LZv384f1OLl5YVDhw5J/P0pKCjgxo0biI6Ohru7Owgh/F3ZKxvLZWxsDGdnZ+zcubPUa58SP5W5ASuXR1s2/7Znzx5IS0tj5cqVSE9PF3c4FFUKTXyV4PF4mDhxIqYbT8fLOS8xzXwaFKQVIC8tz/+vi6kLQqaH4O78u5g0YVK1n5+JmomJCRISEirtinr69Cn27duHQ4cOYcaMGThy5Ei5E8UljYqKCu7evYvg4GCsWbMGbdu2hZSUFN68eVPptatXr8axY8eQlpaGoqIieHl5oUePHtg4dSPwn5wvy5SFU1snId1F3aSsrAwfHx9wuVyJGPVLUf9FpzNUYsOGDQgKCkJQUBB/Yi6by0ZWURZ4hIfGCo0hy/zfyvSHDx/G3r17ERoaWu7WP5JAT08PoaGh5T6r+/HjB8zNzXHgwAFcvXoVUlJSdXLYfkZGBnr06IHx48cjLS0NTZs2rdI6pZMnT0Z0dDSSk5Nhbm6OWbNmYdiwYQhNDYWTrxNYXBY4PA4sm1rihssNqMmrCf9m6hh3d3ccPHgQDx8+RJFOEcJTwsElXLTRbIMhrYZAhkknulPiQRNfBe7cuYNZs2YhIiKiWvOS5s+fj4SEBFy/fl0ouzAIQvfu3bF+/Xr07t271GuEEDg5OaFZs2bo2bMn3N3d8fr16zL3tasLvn79iu7du6NPnz6IiYnBkydPyjyvuLgYV69exeHDhxETE4O8vDz4+/vD3r7kM1sOj4Oob1FQk1eDibqJKG6hTiouLoZBTwP86PYDCo0VUMguBCEESrJKkGJIYXPvzZhvNV/cYVINEO3qLMfnz58xdepU+Pj4VHsy7t9//42CggKsXr1aSNHVXkXP+Q4cOIDk5GQsXrwYs2fPxunTp+ts0gMAXV1dBAYG4u7du4iMjCw1cCUuLg7Lly+HoaEhjh49ijlz5uDLly9YtGgRzp07V6o8aSlpWOha0KRXCf8Ef+QOygVXmYs8Vh64hAseeMhl5SK7OBsrAlfgzwd/ijtMqgGiia8MhYWFGDlyJFavXo1u3bpV+3oZGRlcvHgRly5dKvODUxKUl/hevnyJDRs24Pz581i4cCEmTZpUqsVTFxkZGSEoKAjAr4n4LBYLFy5cQJ8+fWBnZwdCCJ48eYKgoCA4OztDVlYWy5Ytw+XLl/Hp0ycxR1/35LPy4XLZBUXc8uc4FrALsDNkJ6K+RYkwMoqiia8UQgjmzp2LNm3aYMGCBTUuR0NDA9evX8fixYvx7NkzAUYoGC1atCiV+HJzczFmzBjs27cPT58+xcePH7Fx40YxRSh4LVq0gKurK44ePYomTZrg4MGDmDlzJpKTk7Fz585SG9tqaGhg/vz59eo9EBXvaG8w/jsSqAwsLgt7QveIICKK+h+6LdF/HD16FM+fP0dYWFith+23b98ex48fh5OTE549e4amTZsKKMraK6vFN3/+fNjb26Nr167o0qULAgMDa7SQtaRhs9m4ceMGDh8+jMjISEhJSUFKSgrLly/HgAEDKrzW3d0dLVq0wLt376q9tmlD5vPGB3nsvErP4xIubr6/KYKIKOp/aIvvX54/f441a9bgypUrVV6ouDJDhgzBvHnzMHz48EqXzBIVDo+Dt+QtoltGw+WyC7yjvXH89HE8f/4cHh4emDJlCpYuXYqOHSVzke2q+vz5M1atWgVDQ0Ps3bsXkydPxpcvX9CxY0ds3LgRkydPrnQ1l0aNGmHJkiVYv369SGKuL3KLc6t8bkXdoRQlDHRU5//LyMhA586d4eHhgREjRgi0bEIIxo8fDykpKZw9e1asE8C/5HyB/Ul7pBekI4/16xu5krQSCrILcHPETbwPfY8rV67g0aNHEjsitSIcDgc3b97E4cOHERERgQkTJmDWrFkltk7asGEDcnNzMXjwYDg7O+P69evo2rVruWXm5+ejefPm8Pf3h5mZmShuo07jcrnofag3gtODS817LIuBqgGS3Gu+PyRFVRdNfPj1D9XR0RGdO3fGtm3bhFJHYWEh7O3t4ezsjOXLlwuljsoQQtDxUEe8TX8LLik5eZ0BBpooNAFrJwvPwp6hefPmYomxphITE3Hs2DGcOHECxsbGmDVrFkaPHl3mxrKRkZEYP3483r17h7t372Ly5Mnw8/ODhYVFueV7eHjg4cOHuHbtmhDvou4ihOD58+c4f/48Lly4AIV2CkjulgwWKt7EWUFaAet6rMMf3SqfW0lRgkK7OvFrfUYej4fNmzcLrQ4FBQVcu3YNe/furdKakcIQlhKGT1mfSiU9ACAg+J7zHePWjaszSY/D4eDGjRsYNGgQLCwskJ2djXv37uHJkyeYNGlSubupm5ubIycnB3FxcRgwYAAOHTqEgQMHVriqy+zZsxEREYHnz58L63bqpOjoaKxevRotWrTAxIkT0ahRIwQGBiLOPw7NNJqByai410BaShozLGaIKFqK+qXBD265fv06zp49i4iICEhLC/ft0NfXx+XLlzF06FA8fPhQ5DuXhySHgM1jl/s6T4YHxTaKIoyoZpKTk3H8+HEcP34c+vr6cHV1xcWLF6GoWLXYpaSkMGjQINy+fRtubm5wcnJCYWEh+vfvj0ePHqFFixalrpGXl8fq1auxbt063L17V9C3VKfEx8fDx8cHPj4+yMnJwdixY3Hx4kWYm5uX6MYPmBgAm2M2yCzMBItbsuXHZDAhLy2P2+NuQ1NRU9S3QDVwDbrFFxcXh5kzZ+LixYvQ1tYWSZ02NjbYtWsXhg4dih8/foikzt/kpOUgxajgr5wH+N3yw6FDhxAVFSVR28pwuVzcunULQ4YMQceOHZGeno7bt28jNDQUU6ZMqXLS++2/uzWMHz8e69evR9++fZGYmFjmNdOnT8e7d+/KXfmlPvvy5Qv27NkDKysr2NnZIS0tDYcOHUJCQgJ27NgBCwuLUs+uDRsZImpOFNys3aAqpwplWWUw2AzIMeXgYuqCF64vYG9U9+eIUnVPg33Gl5+fj65du2LOnDmYM2eOyOtftmwZXr58CT8/P6G3NH9L+JmAtgfalrtxqjxTHssaL0Py82SEhIQgLS0N1tbWsLW1ha2tLaytrUW+/uiXL19w/PhxHDt2DLq6unB1dcWYMWOgpKRUq3Lz8vKgq6uLL1++QFVVlX9879692L9/P4KDg6Grq1vqupMnT+L06dN48OCBxO9SUVsZGRm4dOkSfHx8EBUVheHDh8PFxQW9evWq9u8si8tCws8EjJ84Huvd12NQv0FCipqiKtcgEx8hBBMmTIC0tDROnTollg8wLpeLIUOGoEWLFti3b5/I6h1/eTyuvruKQk7JqRXy0vLoZtgNARMD+MfS09MRFhaGkJAQhISEIDIyEiYmJrC1tYWdnR1sbW1hYmIi8PePy+XC398fhw8fRnBwMMaMGQNXV1d06tRJoPUMGDAA06dPx6hRo0oc37p1K7y8vPDw4cNSu1FwOBy0a9cOBw8eRJ8+fQQajyTIycnBtWvXcP78eYSEhGDAgAFwcXGBo6OjQOZ0jh8/Ho6OjhK9pyPVAJAGyNPTk3Ts2JHk5+eLNY6fP3+S1q1bkyNHjoiszmJOMZl6bSqR3yxPFDYqEMYqBpHbJEdG+Y4i+ayK34/i4mLy7Nkz4uHhQZydnYmenh7R1tYmw4cPJzt27CBPnjwhhYWFNY4tNTWVbNq0iRgZGZHOnTuTI0eOkNzc3BqXV5n9+/eTyZMnl/naqlWriLm5OcnKyir1mre3N7GxsSE8Hk9osYlSQUEBuXjxInFyciKqqqpkyJAhxNvbWyjv/bJly8hff/0l8HIpqjoaXOJ7+vQp0dbWJvHx8eIOhRBCyPv374m2tjYJDg4Wab2xSbFE3V6drPReSZKzk2tcTlJSEvHx8SELFy4klpaWRFFRkdjY2JDFixeTS5cukdTU1Aqv53K5xM/Pj4wYMYKoqamRWbNmkYiIiBrHUx2fP38mWlpahMvllnqNx+ORRYsWERsbG5KTk1Mq5g4dOpBbt26JJE5hYLFY5NatW2TChAlETU2N9O3blxw7doz8+PFDqPV6eHiQ+fPnC7UOiqpMg0p8aWlpRF9fn9y8eVPcoZRw7949oqOjQxISEkRW55gxY8iiRYsEXm5eXh55+PAh2bp1Kxk8eDBp3LgxadasGRk3bhzZv38/efHiBWGz2eTr169k69atxNjYmJibm5NDhw6VSjCi0KFDBxIWFlbmazwej8yYMYP07NmTFBQUlHjt8uXLxNzcvE61+jgcDrl//z6ZNWsW0dDQILa2tsTT05N8/fpVZDFcvHiRjBgxQmT1UVRZGkziY7PZpEePHmTt2rXiDqVMHh4exMzMTKhde795e3uTNm3alPowFwYej0fevXtHTpw4QaZNm0YMDQ2JtLQ0kZaWJp06dSIeHh4kMzNT6HGU548//iBr1qwp93UOh0PGjRtHHB0dSVFREf84j8cj5ubm5PLly6IIs8Z4PB4JCwsjixYtIrq6uqRTp05k+/btIv2S9W8hISHEyspKLHVT1G8NZnDLsmXLEB0djdu3b0vkUlyEEMyYMQPZ2dm4cOECpKSEM9MkJSUFFhYWuHPnDiwtLYVSx399//4dJ0+exNGjR6GkpIQJEyagWbNmeP36NUJCQvD8+XMYGhryR4/a2tqiVatWIhl09PTpU8yfPx8vX74s9xwOhwNnZ2cwGAz4+vryRzTeuXMHy5cvx+vXryXqd4oQgpiYGJw/fx4+Pj6QkZGBi4sLxo4dK/aFtpOTk9G1a1ekpKSINQ6qgRNv3hWNS5cukWbNmpGMjAxxh1KhoqIiYmtrS/7880+hlM/lckm/fv3Ihg0bhFL+v/F4PBIUFEScnZ1Jo0aNyJQpU0hoaGiZXYNsNptERkYST09P4uLiQoyMjIiGhgYZPHgw2bp1K3n48KHQBiJxOByioaFBkpMrfs5ZVFREHB0dyfjx4wmHw+HfY9euXYmXl5dQYquuuLg4smnTJtKuXTtiYGBAli1bRl68eCFR3bEsFovIyMgQNpst7lCoBqzeJ77Y2FiiqakpsgETtZWWlkYMDQ3JxYsXBV72/v37iZWVlVA/dNLT08nOnTtJy5YtSYcOHYinp2eZIyMrk5KSQi5evEjc3d2JtbU1UVRUJJaWlmThwoXE19e30kRVHRMmTCCHDh2q9LyCggLSs2dPMnPmTH4yCQoKIi1atBDbB3lycjLZvXs3sbS0JNra2mTevHnkyZMnZQ7YkRQ6OjokJSVF3GFQDVi9Tnw5OTmkbdu25NixY+IOpVpevHhBtLS0yMuXLwVW5rt374iGhgZ59+6dwMr8jcfjkYcPHxIXFxfSqFEjMmnSJPL06VOBtjQKCgrI48ePyfbt28mwYcOIlpYWMTAwIGPGjCF79+4lz58/JywWq0Zl+/j4kMGDB1fp3JycHGJjY0MWLVrEv79evXqR48eP88/hcDkkpyiHcHnCST7fv38n//zzD+nevTtRV1cn06ZNI/7+/nWmFdW5c2cSHh4u7jCoBqzeJj4ej0dGjx5NZsyYIe5QauTChQvEyMiIfPv2rdZlsdlsYmVlRTw9PQUQ2f9kZGSQPXv2kDZt2pC2bduKdKAKj8cjcXFx5PTp08TV1ZWYmpoSZWVl0qNHD7Jy5Upy8+bNKndtZ2VlERUVlSp3p2ZlZZFOnTqRVatWEUIIefLkCdFvqU+2PdpG9HbrEcZ6BpHeKE2k1kuRVp6tyLHIY5XOkazMz58/yalTp4ijoyNp1KgRGTt2LLl+/XqJATd1xdChQ8mVK1fEHQbVgNXbwS1///03vLy88OTJE8jLy4s7nBpZt24dHjx4gKCgIMjKyta4nE2bNuHx48fw8/Or9aAZQgiePHmCw4cP49atWxg8eDBcXV3RrVs3sS/hlZ2djfDwcP5KM+Hh4dDV1S0xaKZNmzZlvgc9e/bEsmXLMGhQ1ZbSSk9PR8+ePeEyzgX51vnY8XgHpKWky9yGR1lWGTzCw85+OzG3y9wq309hYSFu3bqF8+fPIygo6Fd9Li4YMmRIrZdsE6e5c+eiXbt2mD9/vrhDoRqoepn4goOD4ezsjLCwMDRr1kzc4dQYj8fDqFGj0LhxYxw9erRGiSUyMhIDBgzAixcvoK+vX+NYsrKycObMGRw5cgRcLheurq6YNGkSNDQ0alymsHG5XLx584afCENCQvDjxw/Y2NjwE6GVlRWUlZWxa9cufPz4EQcPHqxy+V9Sv6D16tZgN2NXuu8cACjKKMLN2g1b+mwp9xwWi4WAgACcP38et27dQpcuXeDi4oIRI0ZAXV29yrFJsi1btiAvLw9//fWXuEOhGqh6l/hSU1NhaWmJkydPwsHBQdzh1FpeXh5sbW0xc+ZMLFiwoFrXFhYWwsLCAmvXrsW4ceOqXTchBKGhoTh8+DCuX7+OgQMHwtXVFd27dxd7666mvn37htDQUH4ifPnyJVq3bo22bdvCz88PERERaNasWZXub0XACng+8yy17mlFFGUUsW/APkw3n84/xuVyERwcjPPnz+PKlSto06YNxo4di9GjR6NJkyY1uk9Jdvr0aQQGBuLs2bPiDoVqoOpV4mOz2ejVqxccHR2xZs0acYcjMAkJCejatSvOnj2Lvn37Vvk6Nzc3fP36FT4+PtVKVD9//sTZs2dx5MgRFBcXY9asWZgyZQo0NevfvmnFxcV4+fIlnj59ij///BMKCgqQlZUt0T1qbm5eqqs5syAT+n/rl7vTRUXU5dXxbek3RD6PhI+PDy5cuAAdHR2MHTsWY8aMgZGRkaBuTyIFBgZi69atuH//vrhDoRqoerUR7bJly6Curo5Vq1aJOxSBatasGXx9fTF69Gg8efIELVu2rPSa+/fv4+LFi4iKiqpS0iOEIDw8HIcPH8bVq1fh6OiIffv2oWfPnnW2dVcVcnJysLGxgY2NDZKTk6GpqYkJEybwW4RnzpxBXFwczM3N+Ymwa9euOBV3CgzU7H3JL8yHXm89NP7WGC4uLrh//77YJ5aLkp6eHr58+SLuMKgGrN60+M6fP481a9YgIiKi3jwL+a8jR47Aw8MDoaGhFe6L9/PnT3Ts2BGHDh3CgAEDKiwzOzsbXl5eOHz4MPLz8/mtO1FtzCtJAgMDsXbtWoSGhpY4npubi2fPnvGTYVhYGHJn5YKrWPONes3UzfBqwat6/aWiPDk5OWjatClyc3Mb5P1T4lcvEl9MTAx69eqFwMBAdOzYUdzhCNX8+fPx+fNn3LhxAwwpBu5/vo/Y9FgwpZiw0rOCZVNLTJo0CUpKSuUO1CCE4Pnz5zhy5AguX76Mvn37wtXVFb179xbaUml1AYvFgra2Nj58+FBh4i9iF0FpqxJ44NW4LnV5dfxY8aPG19d1KioqSElJEfnGxhQF1IOuzuzsbDg5OWH37t31PukBv6ZpODg4YPja4YjQiEA+Kx8sLgsMBgNSDCmoM9SBeOB9wPtS1+bm5vJbd9nZ2Zg5cyZiY2Oho6MjhjuRPLKysujbty/u3r2LyZMnl3teAacA0kxpsLiVj+QsT3UGxNRHv7s7aeKjxKFOf70nhGDKlCno27cvJk2aJO5wREJGRga9V/fGbeZtpOWlIZeVi2JuMYo4RShgF+AL6wsyBmTgadpT/jWRkZGYNWsWDA0N4e/vj23btiE+Ph4rV66kSe8/Bg8ejFu3blV4joqsCthcdq3qUZRRrNX1dR19zkeJU51u8e3YsYM/arGheJ/xHlvDtoJIl99DXcwrxkjfkfhL4y+cOnoKGRkZmDlzJt6+fQtdXV0RRlv3DBgwAG5ubmCxWOUuGiDDlIFhI0MkZifWuJ5OTTrV+Nr6QF9fn+7QQIlNnW3xBQUFwcPDA5cuXYKcnJy4wxGZveF7weFxKj0vLz8Px8OPY9OmTfj48SNWr15Nk14VNGnSBG3atMHjx48rPG+p7VIoydRs9RRlWWUss1tWo2vrC9rio8SpTia+5ORkTJgwAV5eXrVajaQuuvT2Eti8KnSzyQJqPdQwYMAAidorri6oSnfnpI6TwCM1G9zCKeCgk0qnGl1bX9DER4lTnUt8xcXFGDVqFNzc3NC7d29xhyNyBeyCKp+bXZQtxEjqr8GDB+P27dsVnqMqp4qNvTZW+1mdgrQCHDgO6GjWEadOnUI9GFRdIzTxUeJU5xKfu7s79PT0sHz5cnGHIlI/f/7E5cuXgWoMBtRT1RNeQPVYx44dUVBQgA8fPlR43pKuSzDTYmaVk5+CtAK299uOa39dg5+fHzw9PdGvXz/Ex8cLIuw6hSY+SpzqVOI7ffo0goKCcPLkyXo/8ZXH4yEiIgKbN29Gt27dYGhoiOPHj6OHcg/IMSt/pqkiq4LZnWeLINL6h8FgVKm7k8FgwMPRA9v6bIOqnCqkeWWPFVORVYGWohbOjjiLBVa/1ls1NzdHeHg4BgwYABsbG2zbtg1sdu1GitYlNPFR4lRnJrC/evUK/fr1w8OHD9G+fXtxhyMU379/h7+/P/z8/ODv7w8tLS04ODjA0dER9vb2UFBQwPf872i+tzny2HnllsMAA/qq+vi86DOYUvT5Xk3cunULe/bsqfJ6klk5WdDvrw+TCSZIyE1AMacYCjIK6NikI1bYrYBjC8dy/y4+f/6MOXPmIC0tDUePHkWXLl0EeSsSicvlQkFBAXl5ebXacouiaqJOJL6srCxYWlpiy5YtGDt2rLjDERg2m42wsDD4+fnBz88PHz9+RJ8+feDo6AgHBwcYGhqWeV3QpyAM8xmGAnYBCEr+9UkzpKEqr4rQ6aFopdFKFLdRLxUUFEBHRwdJSUlQU1Or9HxfX18cP34c/v7+NaqPEAJvb28sWbIELi4u2LRpE5SVlWtUVl2hr6+Pp0+f1vtFuSnJI/FdnTweDxMnTsSQIUPqRdJLSkrC0aNHMXLkSGhra8PNzQ0A4OHhgfT0dFy+fBkzZ84sN+kBQB+TPgidHoohrYdAXloejeQaQVVOFQrSCphqPhVRs6No0qslRUVF2NvbVzmReXl5YcKECTWuj8FgYPz48YiJicGPHz/QoUMH3Llzp8bl1QX6+vq0u5MSC4lv8W3atAn37t3DgwcPICMjI+5wqq2oqAjBwcG4d+8e/Pz88P37d373Zb9+/Wq931pGQQY+/vgIphQTbTTbQFm2frcSROngwYMIDQ3FmTNnKjwvIyMDzZs3R0pKClRUVARSd0BAAGbPng0rKyt4eHjUy335Ro4cyd93kKJESaJXbvHz88OhQ4cQERFRZ5IeIQRxcXH87ssnT57AzMwMjo6OOH36NCwsLAS6ELSmoiY0FevfPnmSYNCgQVi3bh24XG6FcyEvXLiAgQMHCizpAUC/fv0QHR2NDRs2wMzMDNu2bcOUKVPq1aAuOsCFEheJ7epMSEjA5MmT4ePjI/ErjuTm5uLGjRuYO3cumjdvjt69eyM6OhrTpk1DYmIinjx5gjVr1sDS0rJB735Q1xgaGqJp06YIDw+v8LzadnOWR1FREdu3b4efnx8OHDiAvn371qupDzTxUeIikZ/CRUVFGDlyJP744w/Y29uLO5xSCCF4/fo1tm/fjl69eqFp06bw9PRE8+bNcfPmTSQnJ+Po0aMYNWpUvd0bsKGobFrDp0+fEBcXh/79+wstBnNzc4SFhWHQoEGwsbHBX3/9VS+mPtDER4mLRCa++fPno0WLFvyBH5IgMzMTvr6+mDp1KvT09DBq1CikpKRg6dKlSEtLQ0BAAJYsWYL27dvXq+6ohq6yxOfl5QVnZ2ehd8VLS0tj8eLFiIiIQHBwMCwtLfHs2TOh1ilsenp6dKFqSiwk7hnfsWPHEBISgmfPnok1gXC5XDx//pz/rC42NhY9evSAo6Mj1qxZg+bNm4stNkp0rKys8PXrVyQmJpYadk8IgZeXF06dOiWyeJo1a4Y7d+7g/PnzGDZsGMaMGYPNmzfXyakPtMVHiYtEjeqMiIjAgAED8PjxY7Rp00bk9X/9+pU/+jIgIAB6enpwdHSEo6Mj7OzsGtQuENT/TJ48GdbW1pg7d26J4xERERg7dizi4uLE8iUtMzMTS5YswcOHD/HPP/9g4MCBIo+hNvLz86GpqYmCggLaS0KJlMQkvoyMDFhaWmL37t0YOXKkSOpksVh4+vQpP9klJSWhX79+cHBwgIODA/T06FqXFHDx4kWcPHmy1Lw6Nzc3NGrUCBs2bBBTZL8EBgZi9uzZsLS0xN69e+vU1Ad1dXXEx8dDQ0ND3KFQDYhEJD4ul4uBAweiY8eO2LFjh1Dr+vz5M7/78uHDh2jTpg2/VdelSxdIS0tc7y8lZtnZ2TAwMMDXr1+hpPRrDz4OhwN9fX0EBwejVSvxLxZQUFCAjRs34sSJE9i2bRumTp1aJ1pRHTp0gLe3N8zMzMQdCtWASMTglvXr14PFYmHr1q0CL7ugoAB3797FokWL0Lp1a3Tt2hVhYWEYO3YsPn78iPDwcGzYsAFdu3alSY8qU6NGjdClSxcEBQXxjwUFBcHIyEgikh7wa+rDtm3b4O/vj4MHD6JPnz6Ii4sTd1iVos/5KHEQ+yf9zZs3cerUKURERAgk8RBCEBsby2/VhYaGonPnznB0dISvry/MzMzoXDqq2n6P7hw6dCgA4Ny5cxg/fryYoyqtU6dOCAsLw759+9C1a1csXrwYy5Ytk9gFIGjio8RBrF2d8fHxsLW1xfXr19G1a9cal5OdnY2goCB+spOSkuJ3X/bu3RuqqqoCjJpqiOLi4tCzZ0+kpKSgoKAAenp6eP/+vUQ/T0tISMCcOXPw5csXHD16FNbW1uIOqZS1a9eCyWRi/fr14g6FakDE1uIrKCjAyJEj8eeff1Y76fF4PLx8+ZKf6F6/fg07Ozs4OjpiyZIlaNWqVZ14vkHVHS1btoSysjJevXqF2NhY2NraSnTSA/439cHHxwfDhw+Hs7MzNm/eLNCl1WpLT08PkZGR4g6DamDE0udHCIGrqytMTU1LDREvT3p6Ory8vDBx4kTo6OhgwoQJyMjIwJo1a/Dt27cSz/Fo0qMELbc4FyojVdD7Rm/MeTUHLYe1FHdIVcJgMODi4oKYmBjk5OSgQ4cOlW6wK0p0hwZKHMTS1fnPP//g0KFDCA0N5Y+S+y8Oh4OwsDD+VIO4uDj07t2bP9WgWbNmog2aarAIIehytAui0qLAJr+WClOUVoTnQE9MM58m5uiqJygoCK6urujcuTP27t0LHR0dscbz8uVLTJkyBa9fvxZrHFTDIpLEl1Ocg0cJj9BIvhGkU6UxfNhwhISEoEWLFiXOS05O5ie6oKAgGBsb85/Vde3aVWIf0FP1W0hyCBzOOSCPVXLX+6YqTfFlcd1rrRQWFmLjxo04fvw4/vrrL0ybNk1svSTfv39Hu3btkJGRIZb6qYZJ6Inv2rtrGH9lPKSlpMHj8VCYWYijXY9i6qipKCoqwpMnT/jP6tLS0tC/f384Ojqif//+Yv82SlEA4BPjg1k3ZyGXlVviuLSUNNhr6+5i0a9fv8bMmTOhpKSEw4cPi2VqBo/Hg4KCArKzsyEvLy/y+qmGSaiJL6c4B7q7dFHAKfhXhQy0lmkNkxATPH78GKampvxWnYWFRYX7nlGUOCRlJ6GVZysUc4tLHLfRt0Ho9FAxRSUYXC4Xnp6e2Lx5M9zd3bFs2TLIysqKNIZmzZohKCiIrn9LiYxQB7c8+PwA0sySA0cJg+A9+z0mT56MxMREPH36FGvXrkWXLl1o0qMkkmEjQ6zsthIK0gpgMphQlFFEI7lGODL4iLhDqzUmkwk3NzdERkYiJCQEnTt3rnT/QUGjc/koURPqdIZG8o1QVoNSUVYRzs7OwqyaogTqz55/YlibYbgTdweNFRpjTPsxUFeoP3stGhkZ4datW/D19cXw4cMxevRobNmyRSRTH2jio0RNqC0+e0N7NFZoDCbjfy05RRlFzO1StSkMFCVJOul0wir7VZhtObteJb3fGAwGxo4dizdv3iAvL09kUx9o4qNETaiJjynFxOOpj9HLuBekGFJQklHCvC7zsLWP4NfkpChKMBo3bowTJ07g5MmTcHd3h7OzM9LS0oRWH53LR4ma0CewGzQyQMDEALDXspG7Mhc7+u2AtJTYlwilKKoSvXv3RlRUFFq0aAEzMzMcO3aszEcXtUVbfJSoiWzlFimGFF1RhaLqGAUFBWzduhWBgYE4cuQIevXqhQ8fPgi0Dpr4KFGj2xRQFFUpMzMzhIaGYsSIEbC1tcWWLVvAYrEEUraenh5SUlIEUhZFVYVEbERLUVTdkZiYiLlz5yIpKQlHjx6FjY1NrcorKiqCqqoqioqK6JZhlEjQ3zKKoqrl99SHNWvWwMnJCQsWLEBubm7lF5ZDXl4eqqqqSE9PF2CUFFU+mvgoiqo2BoOBMWPGICYmBgUFBWjfvj1u3rxZ4/Locz5KlGjioyiqxho3bozjx4/j9OnTWLx4MZydnfH169dql0OnNFCiRBMfRVG11qtXL0RFRaFly5bo2LEjjh49Ch6PV+XraYuPEiWa+CiKEggFBQVs2bIFgYGBOHbsGHr16oX3799X6Vqa+ChRoomPoiiBMjMzQ0hICEaOHAk7Ozts2rSp0qkPdEoDJUo08VEUJXBMJhMLFy7EixcvEB4eDgsLC4SGlr+FE23xUaJEEx9FUUJjaGiImzdvYt26dRg5ciTmz5+PnJycUufRxEeJEk18FEUJFYPBgLOzM968eYOioiJ06NABN27cKHEOTXyUKNHER1GUSKirq+PYsWM4c+YMli5dilGjRvGnPmQzspHfIR//hP2Dn0U/xRsoVe/RJcsoihK5oqIibN68GUeOHIHjSkdcKriEwqJCKMgpQIYpg/uT76Nz087iDpOqp2jioyhKbJ5GPoX9dXsQZsmPofZa7REzN0ZMUVH1He3qpChKbPLV8qGiqFLq+LuMdyhkF4ohIqohoImPoiix0VPRA4fHKXVcQUYBctJyYoiIagho4qMoSmzaa7eHpa4l5Jj/S3KKMopYarsUUgz68UQJB33GR1GUWOWx8rDuwTr4xPhASVYJ7jbumGM5BwwGQ9yhUfUUTXwURVFUg0L7EiiKoqgGhSY+iqIoqkGhiY+iKIpqUGjioyiKohoUmvgoiqKoBoUmPoqiKKpBoYmPoiiKalBo4qMoiqIaFJr4KIqiqAaFJj6KoiiqQaGJj6IoimpQaOKjKIqiGhSa+CiKoqgGhSY+iqIoqkGhiY+iKIpqUGjioyiKohqU/wPhQ0t+YaO65wAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Tracé des graphes sociaux sur une population plus petite\n",
    "nb_agents = 25 # 50 est optimal pour le graphe, sinon les tailles sont trop disproportionné\n",
    "\n",
    "# Choix du type de graphe : \n",
    "for i in range(1,4):\n",
    "    \n",
    "    graph = nx.barabasi_albert_graph(nb_agents, i)\n",
    "\n",
    "    matrix = nx.to_numpy_array(graph, nodelist=range(nb_agents))\n",
    "    sma = SMA(nb_agents, matrix)\n",
    "\n",
    "    color_map = []\n",
    "    for node in graph:\n",
    "        if sma.malade[node] == 1:\n",
    "            color_map.append('red')\n",
    "        else: \n",
    "            color_map.append('green')  \n",
    "\n",
    "    size =  []\n",
    "    for node in graph:\n",
    "        size.append(graph.degree(node))\n",
    "\n",
    "    max_value = np.max(size)\n",
    "    iterator = 0\n",
    "    for value in size:\n",
    "        size[iterator] = (value**2/max_value)*100\n",
    "        iterator += 1\n",
    "\n",
    "    my_pos = nx.spring_layout(graph, seed = 100)\n",
    "\n",
    "    plt.figure()\n",
    "    nx.draw(graph, pos=my_pos, node_color=color_map, node_size=size)\n",
    "    plt.axis('off')\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Partie 3 : Facteurs de contagion <a class=\"anchor\" id=\"c1-p3\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Explications :"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Table des matières](#tdm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Utilisation du graphe dans la classe Agent avec import dans la classe SMA :\n",
    "class SMA:\n",
    "    def __init__(self, nb_agents, adjacency_matrix, graphe):\n",
    "        self.tick = 0\n",
    "        self.agentList = []\n",
    "        self.n_steps = 0\n",
    "        self.age = []\n",
    "        self.poids = []\n",
    "        self.sexe = []\n",
    "        self.groupe_sanguin = []\n",
    "        self.vivant = [] # 1 = Oui, 0 = Non\n",
    "        self.malade = [] # 1 = Oui, 0 = Non\n",
    "        # On récupère le graphe pour travailler dessus dans le modèle de contagion\n",
    "        self.graphe = graphe\n",
    "\n",
    "        # Initialize accointances based on the matrix\n",
    "        for i in range(nb_agents):\n",
    "            self.agentList.append(Agent(i, np.nonzero(adjacency_matrix[i])[0]))\n",
    "            self.vivant.append(1)\n",
    "            # Une probabilité d'être malade pour commencer à tracer les graphes\n",
    "            self.malade.append(np.random.choice([0,1], 1, p=[0.90,0.10])[0])\n",
    "\n",
    "        prop_age = [17.8/100, 35.1242921972263/100, 66.8828069335807/100, 1]\n",
    "\n",
    "        prop_homme = [0.527541666807402, 0.521707530462693, 0.506880352191682, 0.467120912994188]\n",
    "        prop_femme = [0.472458333192598, 0.478292469537307, 0.493119647808318, 0.532879087005812]\n",
    "\n",
    "        prop_poids = [0.035,0.492,0.323,0.15] \n",
    "        prop_groupe_sanguin = [0.38,0.36,0.08,0.03,0.07,0.06,0.01,0.01]\n",
    "\n",
    "        for i in range(nb_agents):\n",
    "            if 0 <= i <= int(nb_agents*prop_age[0]):\n",
    "                self.age.append(0)\n",
    "                self.sexe.append(np.random.choice([0,1], 1, p=[prop_homme[0],prop_femme[0]])[0])\n",
    "            if int(nb_agents*prop_age[0]) < i <= int(nb_agents*prop_age[1]):\n",
    "                self.age.append(1)\n",
    "                self.sexe.append(np.random.choice([0,1], 1, p=[prop_homme[1],prop_femme[1]])[0])\n",
    "            if int(nb_agents*prop_age[1]) < i <= int(nb_agents*prop_age[2]):\n",
    "                self.age.append(2)\n",
    "                self.sexe.append(np.random.choice([0,1], 1, p=[prop_homme[2],prop_femme[2]])[0])\n",
    "            if int(nb_agents*prop_age[2]) < i <= int(nb_agents*prop_age[3]):   \n",
    "                self.age.append(3)\n",
    "                self.sexe.append(np.random.choice([0,1], 1, p=[prop_homme[3],prop_femme[3]])[0])\n",
    "            self.poids.append(np.random.choice([0,1,2,3], 1, p=[prop_poids[0],prop_poids[1],prop_poids[2],prop_poids[3]])[0])\n",
    "            self.groupe_sanguin.append(np.random.choice([0,1,2,3,4,5,6,7], 1, p=[prop_groupe_sanguin[0],prop_groupe_sanguin[1],prop_groupe_sanguin[2],prop_groupe_sanguin[3],prop_groupe_sanguin[4],prop_groupe_sanguin[5],prop_groupe_sanguin[6],prop_groupe_sanguin[7]])[0])\n",
    "\n",
    "    def run(self, rounds):        \n",
    "        for i in range(0,rounds):\n",
    "            self.runOnce()\n",
    "            \n",
    "    def runOnce(self):\n",
    "        self.tick += 1\n",
    "        for agent in self.agentList:\n",
    "            agent.decide(self.tick) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Explications sur la manière de récupèrer les alpha-contacts dans la classe Agent\n",
    "class Agent:\n",
    "    def __init__(self, id_number, accointances) :\n",
    "        self.id_number = id_number\n",
    "        self.accointances = accointances\n",
    "        self.has_it = False\n",
    "\n",
    "    def decide(self, tick) :\n",
    "        alpha = 0.8\n",
    "        if self.has_it:\n",
    "            # Pour chaque agents j \n",
    "            for j in range(0,len(sma.agentList)):\n",
    "                liens = []\n",
    "                contact = []\n",
    "                for i in range(0,len(list(graph.edges(j)))):\n",
    "                    # print(list(graph.edges(j))[i][1])\n",
    "                    # On récupère les agents en lien avec notre agent\n",
    "                    # On les met dans un tableau\n",
    "                    liens.append(list(graph.edges(j))[i][1])\n",
    "                print(f\"L'agent {j} a {len(liens)} liens\")\n",
    "                print(f\"Les liens de l'agent {j} sont : {list(sma.graphe.edges(j))}\")\n",
    "                # On récupère aléatoirement alpha % de ces personnes\n",
    "                for k in range(int(alpha*len(liens))):\n",
    "                    print(f\"On garde {alpha} % de liens donc : {int(alpha*len(liens))} contact\")\n",
    "                    valeur_contact = random.randint(0,int(alpha*len(liens)))\n",
    "                    print(f\"On récupère la personne {valeur_contact} dans la liste\")\n",
    "                    contact.append(liens.pop(valeur_contact))\n",
    "                    print(f\"Liens après {k} itérations : {liens}\")\n",
    "                    print(f\"Contact à {k} itérations : {contact}\")\n",
    "                # On fait en sorte que chaque j agents aient au moins 1 contact :\n",
    "                if (contact == []):\n",
    "                    print(f\"Comme garder {alpha} % de liens équivaut à {int(alpha*len(liens))} contact, l'agent {j} garde son unique lien.\")\n",
    "                    contact.append(liens[len(liens)-1])\n",
    "                print(f\"Au final, les alpha-contacts de {j} sont : {contact}\\n\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Il y a 5 agents et 1 tours.\n",
      "\n",
      "L'agent 0 a 2 liens\n",
      "Les liens de l'agent 0 sont : [(0, 1), (0, 3)]\n",
      "On garde 0.8 % de liens donc : 1 contact\n",
      "On récupère la personne 0 dans la liste\n",
      "Liens après 0 itérations : [3]\n",
      "Contact à 0 itérations : [1]\n",
      "Au final, les alpha-contacts de 0 sont : [1]\n",
      "\n",
      "L'agent 1 a 2 liens\n",
      "Les liens de l'agent 1 sont : [(1, 0), (1, 2)]\n",
      "On garde 0.8 % de liens donc : 1 contact\n",
      "On récupère la personne 1 dans la liste\n",
      "Liens après 0 itérations : [0]\n",
      "Contact à 0 itérations : [2]\n",
      "Au final, les alpha-contacts de 1 sont : [2]\n",
      "\n",
      "L'agent 2 a 2 liens\n",
      "Les liens de l'agent 2 sont : [(2, 1), (2, 4)]\n",
      "On garde 0.8 % de liens donc : 1 contact\n",
      "On récupère la personne 0 dans la liste\n",
      "Liens après 0 itérations : [4]\n",
      "Contact à 0 itérations : [1]\n",
      "Au final, les alpha-contacts de 2 sont : [1]\n",
      "\n",
      "L'agent 3 a 1 liens\n",
      "Les liens de l'agent 3 sont : [(3, 0)]\n",
      "Comme garder 0.8 % de liens équivaut à 0 contact, l'agent 3 garde son unique lien.\n",
      "Au final, les alpha-contacts de 3 sont : [0]\n",
      "\n",
      "L'agent 4 a 1 liens\n",
      "Les liens de l'agent 4 sont : [(4, 2)]\n",
      "Comme garder 0.8 % de liens équivaut à 0 contact, l'agent 4 garde son unique lien.\n",
      "Au final, les alpha-contacts de 4 sont : [2]\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# On relance notre expérience \n",
    "nb_agents = 5\n",
    "nb_rounds = 1\n",
    "\n",
    "# Choix du type de graphe : \n",
    "graph = nx.barabasi_albert_graph(nb_agents, 1) \n",
    "\n",
    "matrix = nx.to_numpy_array(graph, nodelist=range(nb_agents))\n",
    "sma = SMA(nb_agents, matrix, graph)\n",
    "\n",
    "# On donne la parole\n",
    "parole = \"J'ai la parole.\"\n",
    "an_agent = np.random.choice(sma.agentList)\n",
    "an_agent.has_it = parole\n",
    "print(f\"Il y a {nb_agents} agents et {nb_rounds} tours.\\n\")\n",
    "\n",
    "# On lance le jeu\n",
    "sma.run(nb_rounds)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Partie 4 : Simulation avec une contagion aléatoire V1 <a class=\"anchor\" id=\"c1-p4\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Explications : "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Table des matières](#tdm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "class SMA:\n",
    "    def __init__(self, nb_agents, adjacency_matrix, graphe, depart, taux_contact, contamination, deces, guerison, periode_contagion, taux_grave):\n",
    "        self.tick = 0\n",
    "        self.agentList = []\n",
    "        self.n_steps = 0\n",
    "        self.age = []\n",
    "        self.poids = []\n",
    "        self.sexe = []\n",
    "        self.groupe_sanguin = []\n",
    "        self.vivant = [] # 1 = Oui, 0 = Non\n",
    "        self.malade = [] # 1 = Oui, 0 = Non\n",
    "        self.cas_grave = [] # 1 = Oui, 0 = Non\n",
    "        \n",
    "        # On récupère le graphe pour travailler dessus dans le modèle de contagion\n",
    "        self.graphe = graphe\n",
    "        self.immunise = [] # 1 = Oui, 0 = Non\n",
    "        self.jour_malade = []\n",
    "        \n",
    "        self.taux_contact = taux_contact # contact\n",
    "        self.contamination = contamination # contamination\n",
    "        self.deces = deces # décès\n",
    "        self.guerison = guerison # guérison\n",
    "        self.periode_contagion = periode_contagion # période pendant laquelle le patient est malade\n",
    "        self.taux_grave = taux_grave # selon la gravité, réanimation ou hospitalisation\n",
    "\n",
    "        # Pour récupérer le nombre de personnes malades par jours \n",
    "        self.plot_malade = []\n",
    "        self.plot_vivant = []\n",
    "        self.plot_immunise = []\n",
    "        self.plot_grave = []\n",
    "\n",
    "        # Initialize accointances based on the matrix\n",
    "        for i in range(nb_agents):\n",
    "            self.agentList.append(Agent(i, np.nonzero(adjacency_matrix[i])[0]))\n",
    "            self.vivant.append(1)\n",
    "            self.cas_grave.append(0)\n",
    "            # Une probabilité d'être malade pour commencer à tracer les graphes\n",
    "            self.malade.append(np.random.choice([0,1], 1, p=[1-depart,depart])[0])\n",
    "            if self.malade[i] == 1:\n",
    "                self.immunise.append(1)\n",
    "            else:\n",
    "                self.immunise.append(0)\n",
    "            self.jour_malade.append(0)\n",
    "\n",
    "        # Initialisation des paramètres se basant sur les sources :\n",
    "        # Proportions cumulatives pour l'âge :\n",
    "        prop_age = [17.8/100, 35.1242921972263/100, 66.8828069335807/100, 1]\n",
    "\n",
    "        # Par tranches d'âges les proportions normalisées sont :\n",
    "        prop_homme = [0.527541666807402, 0.521707530462693, 0.506880352191682, 0.467120912994188]\n",
    "        prop_femme = [0.472458333192598, 0.478292469537307, 0.493119647808318, 0.532879087005812]\n",
    "\n",
    "        # Proportions pour le poids :\n",
    "        prop_poids = [0.035,0.492,0.323,0.15]\n",
    "\n",
    "        # Proportions pour le groupe sanguin : \n",
    "        prop_groupe_sanguin = [0.38,0.36,0.08,0.03,0.07,0.06,0.01,0.01]\n",
    "\n",
    "        for i in range(nb_agents):\n",
    "            if 0 <= i <= int(nb_agents*prop_age[0]):\n",
    "                self.age.append(0)\n",
    "                self.sexe.append(np.random.choice([0,1], 1, p=[prop_homme[0],prop_femme[0]])[0])\n",
    "            if int(nb_agents*prop_age[0]) < i <= int(nb_agents*prop_age[1]):\n",
    "                self.age.append(1)\n",
    "                self.sexe.append(np.random.choice([0,1], 1, p=[prop_homme[1],prop_femme[1]])[0])\n",
    "            if int(nb_agents*prop_age[1]) < i <= int(nb_agents*prop_age[2]):\n",
    "                self.age.append(2)\n",
    "                self.sexe.append(np.random.choice([0,1], 1, p=[prop_homme[2],prop_femme[2]])[0])\n",
    "            if int(nb_agents*prop_age[2]) < i <= int(nb_agents*prop_age[3]):   \n",
    "                self.age.append(3)\n",
    "                self.sexe.append(np.random.choice([0,1], 1, p=[prop_homme[3],prop_femme[3]])[0])\n",
    "            self.poids.append(np.random.choice([0,1,2,3], 1, p=[prop_poids[0],prop_poids[1],prop_poids[2],prop_poids[3]])[0])\n",
    "            self.groupe_sanguin.append(np.random.choice([0,1,2,3,4,5,6,7], 1, p=[prop_groupe_sanguin[0],prop_groupe_sanguin[1],prop_groupe_sanguin[2],prop_groupe_sanguin[3],prop_groupe_sanguin[4],prop_groupe_sanguin[5],prop_groupe_sanguin[6],prop_groupe_sanguin[7]])[0])\n",
    "\n",
    "        # On compte le nombre de cas :\n",
    "        self.plot_malade.append(self.malade.count(1))\n",
    "        self.plot_immunise.append(self.immunise.count(1))\n",
    "        self.plot_vivant.append(self.vivant.count(0))\n",
    "        self.plot_grave.append(self.cas_grave.count(1))\n",
    "\n",
    "\n",
    "    def run(self, rounds):        \n",
    "        for i in range(0,rounds):\n",
    "            self.runOnce()\n",
    "            self.plot_malade.append(self.malade.count(1))\n",
    "            self.plot_immunise.append(self.immunise.count(1))\n",
    "            self.plot_vivant.append(self.vivant.count(0))\n",
    "            self.plot_grave.append(self.cas_grave.count(1))\n",
    "\n",
    "    def runOnce(self):\n",
    "        self.tick += 1\n",
    "        for agent in self.agentList:\n",
    "            agent.decide(self.tick) \n",
    "        #print(\"\\ntick \" + str(self.tick) + \" ended.\\n\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Agent:\n",
    "    def __init__(self, id_number, accointances) :\n",
    "        self.id_number = id_number\n",
    "        self.accointances = accointances\n",
    "        self.has_it = False\n",
    "\n",
    "    def decide(self, tick) :\n",
    "        j = self.id_number\n",
    "\n",
    "        # On regarde si l'agent malade va guérir ou mourir\n",
    "        if sma.malade[j] == 1 and sma.vivant[j] == 1:\n",
    "            if sma.jour_malade[j] <= sma.periode_contagion:\n",
    "                # Tous les jours, l'agent malade (non cas-grave) peut devenir un cas grave :\n",
    "                if sma.cas_grave[j] == 0:\n",
    "                    sma.cas_grave[j] = np.random.choice([0,1], 1, p=[1-sma.taux_grave,sma.taux_grave])[0]\n",
    "\n",
    "                # Si c'est un cas grave, il peut décéder : \n",
    "                if sma.cas_grave[j] == 1:\n",
    "                    sma.vivant[j] = np.random.choice([0,1], 1, p=[sma.deces,1-sma.deces])[0]\n",
    "\n",
    "                # Sinon, il peut guérir :\n",
    "                else: \n",
    "                    sma.malade[j] = np.random.choice([0,1], 1, p=[sma.guerison,1-sma.guerison])[0]\n",
    "\n",
    "                # S'il meurt, il n'est plus malade\n",
    "                if sma.vivant[j] == 0:\n",
    "                    sma.malade[j] = 0\n",
    "                    sma.jour_malade[j] += sma.periode_contagion\n",
    "\n",
    "                # Quand notre agent n'est plus malade, il est immunisé  \n",
    "                if sma.malade[j] == 0:\n",
    "                    sma.jour_malade[j] += sma.periode_contagion\n",
    "                    sma.immunise[j] = 1\n",
    "                # Puis, pour chaque malade on compte 1 jour de plus pour ce tour\n",
    "                sma.jour_malade[j] += 1\n",
    "        \n",
    "        # Après la période d'periode_contagion, l'agent n'est plus malade\n",
    "        if sma.jour_malade[j] > sma.periode_contagion:\n",
    "            sma.malade[j] = 0\n",
    "            sma.immunise[j] = 1\n",
    "\n",
    "        # Si l'agent j est vivant, on regarde s'il peut être contaminé :\n",
    "        # Donc il faut qu'il soit sain et non immunisé\n",
    "        if sma.vivant[j] == 1 and sma.immunise[j] == 0 and sma.malade[j] == 0:\n",
    "            # On regarde tous ces liens et on garde uniquement les contacts\n",
    "            liens = []\n",
    "            contact = []\n",
    "            for i in range(0,len(list(graph.edges(j)))):\n",
    "                # On récupère les agents en lien avec notre agent\n",
    "                # On les met dans un tableau\n",
    "                liens.append(list(graph.edges(j))[i][1])\n",
    "                # On récupère aléatoirement taux_contact % de ces personnes\n",
    "            for k in range(int(sma.taux_contact*len(liens))):\n",
    "                valeur_contact = random.randint(0,int(sma.taux_contact*len(liens)))\n",
    "                contact.append(liens.pop(valeur_contact))\n",
    "            # On fait en sorte que chaque j agents aient au moins 1 contact :\n",
    "            if (contact == []):\n",
    "                contact.append(liens[len(liens)-1])\n",
    "            \n",
    "            # Pour chaque personnes restantes dans les contacts, on regarde si elles sont malades\n",
    "            for i in range(0,len(contact)):\n",
    "                if sma.malade[contact[i]] == 1:\n",
    "                    # Si un contact est malade, il y a contamination % chances de contamination pour notre agent j\n",
    "                    # La contamination est calculée avec le R0\n",
    "                    # R0 correspond au nombre de personnes contaminées sur la période de contagion\n",
    "                    contamination = sma.contamination / (len(contact) * sma.periode_contagion)\n",
    "                    sma.malade[j] = np.random.choice([0,1], 1, p=[1-contamination,contamination])[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Propagation du virus pour 700 agents et 60 jours.\n",
      "\n",
      "Le temps d'exécution de la simulation est de 1.3258s.\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "nb_agents = 700\n",
    "nb_rounds = 60\n",
    "print(f\"Propagation du virus pour {nb_agents} agents et {nb_rounds} jours.\")\n",
    "\n",
    "# Choix du type de graphe : \n",
    "\n",
    "graph = nx.barabasi_albert_graph(nb_agents, 1) \n",
    "#graph = nx.complete_graph(nb_agents)\n",
    "#graph = nx.erdos_renyi_graph(nb_agents,0.1)\n",
    "#graph = nx.cycle_graph(nb_agents)\n",
    "#graph = nx.random_regular_graph(3,nb_agents)\n",
    "\n",
    "# Pour tester dans une boucle for : \n",
    "graphs = [nx.barabasi_albert_graph(nb_agents, 1), nx.erdos_renyi_graph(nb_agents,0.1), nx.cycle_graph(nb_agents), nx.random_regular_graph(3,nb_agents)]\n",
    "departs = [0.01, 0.05, 0.1, 0.2, 0.5]\n",
    "taux_contacts = [0.2, 0.4, 0.6, 0.8]\n",
    "contaminations = [2,4,8]\n",
    "decess = [0.001, 0.005, 0.01, 0.05, 0.1, 0.5]\n",
    "guerisons = [0.001, 0.005, 0.01, 0.05, 0.1, 0.5]\n",
    "periode_contagions = [2,4,6,8,10,12,14,15]\n",
    "\n",
    "\n",
    "depart = 0.05 # Proportion de personnes contaminées au départ\n",
    "taux_contact = 0.6 # Taux de contact d'une personne sur tous ces liens\n",
    "contamination = 2 # R0 : nombre de personnes que contamine un agent\n",
    "deces = 0.2 # Taux de décès pour la maladie quand une personne est un cas grave\n",
    "guerison = 0.3 # Taux de guérison de la maladie\n",
    "periode_contagion = 18 # Période pendant laquelle l'agent est malade\n",
    "taux_grave = 0.1 # Taux pour lequel une personne malade devient un cas grave\n",
    "\n",
    "matrix = nx.to_numpy_array(graph, nodelist=range(nb_agents))\n",
    "sma = SMA(nb_agents, matrix, graph, depart, taux_contact, contamination, deces, guerison, periode_contagion, taux_grave)\n",
    "\n",
    "temps_debut = time.time()\n",
    "# On lance le jeu\n",
    "sma.run(nb_rounds)\n",
    "\n",
    "temps_fin = time.time()\n",
    "print(f\"\\nLe temps d'exécution de la simulation est de {round(temps_fin-temps_debut,4)}s.\")\n",
    "\n",
    "# Tracé de graphes :\n",
    "x = []\n",
    "for i in range(0,len(sma.plot_vivant)):\n",
    "    x.append(i)\n",
    "\n",
    "y = [sma.plot_vivant, sma.plot_malade, sma.plot_immunise, sma.plot_grave]\n",
    "labels = ['Décès', 'Malade', 'Immunisé', 'Cas Grave']\n",
    "\n",
    "for y_arr, label in zip(y, labels):\n",
    "    plt.plot(x, y_arr, label=label)\n",
    "plt.xlabel('Nombre de jours')\n",
    "plt.ylabel('Nombre de personnes')\n",
    "plt.legend(loc=\"upper right\")\n",
    "#plt.axhline(y=nb_agents,c='black',ls='-')\n",
    "plt.savefig('./plot/simulation_v1.pdf')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Partie 5 : Simulation avec une contagion aléatoire V2 (dépendance de l'âge) <a class=\"anchor\" id=\"c1-p5\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Explications : La différence avec la V1 la différenciation entre le taux de gravité et de décès selon l'âge.\n",
    "\n",
    "Pour l'instant, si la tranche d'âge est 3, le taux de gravité est de 75% et de décès 89%. \n",
    "\n",
    "TO DO : rajouter des tranches d'âge pour être fiable sur nos données de sources."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Table des matières](#tdm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [],
   "source": [
    "class SMA:\n",
    "    def __init__(self, nb_agents, adjacency_matrix, graphe, depart, taux_contact, contamination, guerison, periode_contagion):\n",
    "        self.tick = 0\n",
    "        self.agentList = []\n",
    "        self.n_steps = 0\n",
    "        self.age = []\n",
    "        self.poids = []\n",
    "        self.sexe = []\n",
    "        self.groupe_sanguin = []\n",
    "        self.vivant = [] # 1 = Oui, 0 = Non\n",
    "        self.malade = [] # 1 = Oui, 0 = Non\n",
    "        self.cas_grave = [] # 1 = Oui, 0 = Non\n",
    "        \n",
    "        # On récupère le graphe pour travailler dessus dans le modèle de contagion\n",
    "        self.graphe = graphe\n",
    "        self.immunise = [] # 1 = Oui, 0 = Non\n",
    "        self.jour_malade = []\n",
    "        \n",
    "        self.taux_contact = taux_contact # contact\n",
    "        self.contamination = contamination # contamination\n",
    "        self.guerison = guerison # guérison\n",
    "        self.periode_contagion = periode_contagion # période pendant laquelle le patient est malade\n",
    "\n",
    "        # Les taux de gravité et décès différent selon la classe d'âge\n",
    "        self.taux_grave = [] # selon la gravité, réanimation ou hospitalisation\n",
    "        self.deces = [] # taux décès\n",
    "\n",
    "\n",
    "        # Pour récupérer le nombre de personnes malades par jours \n",
    "        self.plot_malade = []\n",
    "        self.plot_vivant = []\n",
    "        self.plot_immunise = []\n",
    "        self.plot_grave = []\n",
    "\n",
    "        # Initialize accointances based on the matrix\n",
    "        for i in range(nb_agents):\n",
    "            self.agentList.append(Agent(i, np.nonzero(adjacency_matrix[i])[0]))\n",
    "            self.vivant.append(1)\n",
    "            self.cas_grave.append(0)\n",
    "            # Une probabilité d'être malade pour commencer à tracer les graphes\n",
    "            self.malade.append(np.random.choice([0,1], 1, p=[1-depart,depart])[0])\n",
    "            if self.malade[i] == 1:\n",
    "                self.immunise.append(1)\n",
    "            else:\n",
    "                self.immunise.append(0)\n",
    "            self.jour_malade.append(0)\n",
    "\n",
    "        # Initialisation des paramètres se basant sur les sources :\n",
    "        # Proportions cumulatives pour l'âge :\n",
    "        prop_age = [17.8/100, 35.1242921972263/100, 66.8828069335807/100, 1]\n",
    "\n",
    "        # Par tranches d'âges les proportions normalisées sont :\n",
    "        prop_homme = [0.527541666807402, 0.521707530462693, 0.506880352191682, 0.467120912994188]\n",
    "        prop_femme = [0.472458333192598, 0.478292469537307, 0.493119647808318, 0.532879087005812]\n",
    "\n",
    "        # Proportions pour le poids :\n",
    "        prop_poids = [0.035,0.492,0.323,0.15]\n",
    "\n",
    "        # Proportions pour le groupe sanguin : \n",
    "        prop_groupe_sanguin = [0.38,0.36,0.08,0.03,0.07,0.06,0.01,0.01]\n",
    "\n",
    "        for i in range(nb_agents):\n",
    "            if 0 <= i <= int(nb_agents*prop_age[0]):\n",
    "                self.age.append(0)\n",
    "                self.sexe.append(np.random.choice([0,1], 1, p=[prop_homme[0],prop_femme[0]])[0])\n",
    "            if int(nb_agents*prop_age[0]) < i <= int(nb_agents*prop_age[1]):\n",
    "                self.age.append(1)\n",
    "                self.sexe.append(np.random.choice([0,1], 1, p=[prop_homme[1],prop_femme[1]])[0])\n",
    "            if int(nb_agents*prop_age[1]) < i <= int(nb_agents*prop_age[2]):\n",
    "                self.age.append(2)\n",
    "                self.sexe.append(np.random.choice([0,1], 1, p=[prop_homme[2],prop_femme[2]])[0])\n",
    "            if int(nb_agents*prop_age[2]) < i <= int(nb_agents*prop_age[3]):   \n",
    "                self.age.append(3)\n",
    "                self.sexe.append(np.random.choice([0,1], 1, p=[prop_homme[3],prop_femme[3]])[0])\n",
    "            self.poids.append(np.random.choice([0,1,2,3], 1, p=[prop_poids[0],prop_poids[1],prop_poids[2],prop_poids[3]])[0])\n",
    "            self.groupe_sanguin.append(np.random.choice([0,1,2,3,4,5,6,7], 1, p=[prop_groupe_sanguin[0],prop_groupe_sanguin[1],prop_groupe_sanguin[2],prop_groupe_sanguin[3],prop_groupe_sanguin[4],prop_groupe_sanguin[5],prop_groupe_sanguin[6],prop_groupe_sanguin[7]])[0])\n",
    "\n",
    "            \n",
    "            # On remplit selon l'âge\n",
    "            # Données démographiques en source :\n",
    "\n",
    "            hospi_3 = 65/100\n",
    "            hospi_2 = 30/100\n",
    "            hospi_1 = 4/100\n",
    "            hospi_0 = 1/100\n",
    "            if self.age[i] == 3:\n",
    "                self.taux_grave.append(hospi_3)\n",
    "                self.deces.append(0.89)\n",
    "            if self.age[i] == 2:\n",
    "                self.taux_grave.append(hospi_2)\n",
    "                self.deces.append(((1-0.89)*hospi_2)/hospi_3)\n",
    "            if self.age[i] == 1:\n",
    "                self.taux_grave.append(hospi_1)\n",
    "                self.deces.append(((1-0.89)*hospi_1)/hospi_3)\n",
    "            else:\n",
    "                self.taux_grave.append(hospi_0)\n",
    "                self.deces.append(((1-0.89)*hospi_0)/hospi_3)\n",
    "\n",
    "\n",
    "        # On compte le nombre de cas :\n",
    "        self.plot_malade.append(self.malade.count(1))\n",
    "        self.plot_immunise.append(self.immunise.count(1))\n",
    "        self.plot_vivant.append(self.vivant.count(0))\n",
    "        self.plot_grave.append(self.cas_grave.count(1))\n",
    "\n",
    "\n",
    "    def run(self, rounds):        \n",
    "        for i in range(0,rounds):\n",
    "            self.runOnce()\n",
    "            self.plot_malade.append(self.malade.count(1))\n",
    "            self.plot_immunise.append(self.immunise.count(1))\n",
    "            self.plot_vivant.append(self.vivant.count(0))\n",
    "            self.plot_grave.append(self.cas_grave.count(1))\n",
    "\n",
    "    def runOnce(self):\n",
    "        self.tick += 1\n",
    "        for agent in self.agentList:\n",
    "            agent.decide(self.tick) \n",
    "        #print(\"\\ntick \" + str(self.tick) + \" ended.\\n\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Agent:\n",
    "    def __init__(self, id_number, accointances) :\n",
    "        self.id_number = id_number\n",
    "        self.accointances = accointances\n",
    "        self.has_it = False\n",
    "\n",
    "    def decide(self, tick) :\n",
    "        j = self.id_number\n",
    "\n",
    "        # On regarde si l'agent malade va guérir ou mourir\n",
    "        if sma.malade[j] == 1 and sma.vivant[j] == 1:\n",
    "            if sma.jour_malade[j] <= sma.periode_contagion:\n",
    "                # Tous les jours, l'agent malade (non cas-grave) peut devenir un cas grave :\n",
    "                if sma.cas_grave[j] == 0:\n",
    "                    sma.cas_grave[j] = np.random.choice([0,1], 1, p=[1-sma.taux_grave[j],sma.taux_grave[j]])[0]\n",
    "\n",
    "                # Si c'est un cas grave, il peut décéder : \n",
    "                if sma.cas_grave[j] == 1:\n",
    "                    sma.vivant[j] = np.random.choice([0,1], 1, p=[sma.deces[j],1-sma.deces[j]])[0]\n",
    "\n",
    "                # Sinon, il peut guérir :\n",
    "                else: \n",
    "                    sma.malade[j] = np.random.choice([0,1], 1, p=[sma.guerison,1-sma.guerison])[0]\n",
    "\n",
    "                # S'il meurt, il n'est plus malade\n",
    "                if sma.vivant[j] == 0:\n",
    "                    sma.malade[j] = 0\n",
    "                    sma.jour_malade[j] += sma.periode_contagion\n",
    "\n",
    "                # Quand notre agent n'est plus malade, il est immunisé  \n",
    "                if sma.malade[j] == 0:\n",
    "                    sma.jour_malade[j] += sma.periode_contagion\n",
    "                    sma.immunise[j] = 1\n",
    "                # Puis, pour chaque malade on compte 1 jour de plus pour ce tour\n",
    "                sma.jour_malade[j] += 1\n",
    "        \n",
    "        # Après la période d'periode_contagion, l'agent n'est plus malade\n",
    "        if sma.jour_malade[j] > sma.periode_contagion:\n",
    "            sma.malade[j] = 0\n",
    "            sma.immunise[j] = 1\n",
    "\n",
    "        # Si l'agent j est vivant, on regarde s'il peut être contaminé :\n",
    "        # Donc il faut qu'il soit sain et non immunisé\n",
    "        if sma.vivant[j] == 1 and sma.immunise[j] == 0 and sma.malade[j] == 0:\n",
    "            # On regarde tous ces liens et on garde uniquement les contacts\n",
    "            liens = []\n",
    "            contact = []\n",
    "            for i in range(0,len(list(graph.edges(j)))):\n",
    "                # On récupère les agents en lien avec notre agent\n",
    "                # On les met dans un tableau\n",
    "                liens.append(list(graph.edges(j))[i][1])\n",
    "                # On récupère aléatoirement taux_contact % de ces personnes\n",
    "            for k in range(int(sma.taux_contact*len(liens))):\n",
    "                valeur_contact = random.randint(0,int(sma.taux_contact*len(liens)))\n",
    "                contact.append(liens.pop(valeur_contact))\n",
    "            # On fait en sorte que chaque j agents aient au moins 1 contact :\n",
    "            if (contact == []):\n",
    "                contact.append(liens[len(liens)-1])\n",
    "            \n",
    "            # Pour chaque personnes restantes dans les contacts, on regarde si elles sont malades\n",
    "            for i in range(0,len(contact)):\n",
    "                if sma.malade[contact[i]] == 1:\n",
    "                    # Si un contact est malade, il y a contamination % chances de contamination pour notre agent j\n",
    "                    # La contamination est calculée avec le R0\n",
    "                    # R0 correspond au nombre de personnes contaminées sur la période de contagion\n",
    "                    contamination = sma.contamination / (len(contact) * sma.periode_contagion)\n",
    "                    sma.malade[j] = np.random.choice([0,1], 1, p=[1-contamination,contamination])[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Propagation du virus pour 200 agents et 120 jours.\n",
      "\n",
      "Le temps d'exécution de la simulation est de 0.7385s.\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "nb_agents = 200\n",
    "nb_rounds = 120\n",
    "print(f\"Propagation du virus pour {nb_agents} agents et {nb_rounds} jours.\")\n",
    "\n",
    "# Choix du type de graphe : \n",
    "\n",
    "graph = nx.barabasi_albert_graph(nb_agents, 1) \n",
    "#graph = nx.complete_graph(nb_agents)\n",
    "#graph = nx.erdos_renyi_graph(nb_agents,0.1)\n",
    "#graph = nx.cycle_graph(nb_agents)\n",
    "#graph = nx.random_regular_graph(3,nb_agents)\n",
    "\n",
    "# Pour tester dans une boucle for : \n",
    "graphs = [nx.barabasi_albert_graph(nb_agents, 1), nx.erdos_renyi_graph(nb_agents,0.1), nx.cycle_graph(nb_agents), nx.random_regular_graph(3,nb_agents)]\n",
    "departs = [0.01, 0.05, 0.1, 0.2, 0.5]\n",
    "taux_contacts = [0.2, 0.4, 0.6, 0.8]\n",
    "contaminations = [1,2,4]\n",
    "guerisons = [0.001, 0.005, 0.01, 0.05, 0.1, 0.5]\n",
    "periode_contagions = [2,4,6,8,10,12,14,15]\n",
    "\n",
    "\n",
    "depart = 0.05 # Proportion de personnes contaminées au départ\n",
    "taux_contact = 0.6 # Taux de contact d'une personne sur tous ces liens\n",
    "contamination = 2 # R0 : nombre de personnes que contamine un agent\n",
    "guerison = 0.01 # Taux de guérison de la maladie\n",
    "periode_contagion = 14 # Période pendant laquelle l'agent est malade\n",
    "\n",
    "matrix = nx.to_numpy_array(graph, nodelist=range(nb_agents))\n",
    "sma = SMA(nb_agents, matrix, graph, depart, taux_contact, contamination, guerison, periode_contagion)\n",
    "\n",
    "temps_debut = time.time()\n",
    "# On lance le jeu\n",
    "sma.run(nb_rounds)\n",
    "\n",
    "temps_fin = time.time()\n",
    "print(f\"\\nLe temps d'exécution de la simulation est de {round(temps_fin-temps_debut,4)}s.\")\n",
    "\n",
    "# Tracé de graphes :\n",
    "x = []\n",
    "for i in range(0,len(sma.plot_vivant)):\n",
    "    x.append(i)\n",
    "\n",
    "y = [sma.plot_vivant, sma.plot_malade, sma.plot_immunise, sma.plot_grave]\n",
    "labels = ['Décès', 'Malade', 'Immunisé', 'Cas Grave']\n",
    "\n",
    "for y_arr, label in zip(y, labels):\n",
    "    plt.plot(x, y_arr, label=label)\n",
    "plt.xlabel('Nombre de jours')\n",
    "plt.ylabel('Nombre de personnes')\n",
    "plt.legend(loc=\"upper right\")\n",
    "#plt.axhline(y=nb_agents,c='black',ls='-')\n",
    "plt.savefig('./plot/simulation_v2.pdf')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Partie 6 : Algorithme génétique <a class=\"anchor\" id=\"c1-p6\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Table des matières](#tdm)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Chapitre 2 : Graphes <a class=\"anchor\" id=\"c2\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Partie 1 : Graphe de l'évolution du Covid en France <a class=\"anchor\" id=\"c2-p1\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Table des matières](#tdm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Création d'un csv avec les dates de 2020\n",
    "with open('dates.csv', 'w', newline='') as file:\n",
    "    writer = csv.writer(file,delimiter=',')\n",
    "    writer.writerow([\"date\"])\n",
    "    mois = [1,2,3,4,5,6,7,8,9,10,11,12]\n",
    "    for m in mois:\n",
    "        if m < 8:\n",
    "            if m == 2:\n",
    "                for j in range(1,30):\n",
    "                    writer.writerow([f\"{date(2020,m,j)}\"])\n",
    "            else:\n",
    "                if m % 2 == 0:\n",
    "                    for j in range(1,31):\n",
    "                        writer.writerow([f\"{date(2020,m,j)}\"])\n",
    "                if m % 2 != 0:\n",
    "                    for j in range(1,32):\n",
    "                        writer.writerow([f\"{date(2020,m,j)}\"])\n",
    "        else:\n",
    "            if m % 2 == 0:\n",
    "                for j in range(1,32):\n",
    "                    writer.writerow([f\"{date(2020,m,j)}\"])\n",
    "            if m % 2 != 0:\n",
    "                for j in range(1,31):\n",
    "                    writer.writerow([f\"{date(2020,m,j)}\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Collecte des données sur le site du gouvernement pour l'année 2020\n",
    "def collecte_donnees(granularite='national'):\n",
    "    print(\"Collecte des données du gouvernement\")\n",
    "    data_brute = pd.read_csv('https://raw.githubusercontent.com/opencovid19-fr/data/master/dist/chiffres-cles.csv',low_memory=False)\n",
    "    dates = pd.read_csv('dates.csv')\n",
    "\n",
    "    # National\n",
    "    if granularite == \"national\":\n",
    "        data_brute = data_brute.loc[data_brute['source_type'] == \"ministere-sante\"]\n",
    "        data_brute = data_brute.loc[data_brute['granularite'] == \"pays\"].reset_index()\n",
    "        data_brute = data_brute[['date','cas_confirmes', 'deces', 'deces_ehpad', 'reanimation', 'hospitalises', 'gueris']]\n",
    "        data_brute = dates.set_index('date').join(data_brute.set_index('date'))\n",
    "        data = data_brute.interpolate(limit_area='inside')\n",
    "        data = data.dropna(how='all')\n",
    "        data['reanimation'][0:3] = 0\n",
    "        data['gueris'][0:3] = 0\n",
    "\n",
    "    # Regional\n",
    "    if granularite == \"regional\":\n",
    "        data_brute = data_brute.loc[data_brute['source_type'] == \"opencovid19-fr\"]\n",
    "        data_brute = data_brute.loc[data_brute['maille_code'] == \"REG-32\"].reset_index()\n",
    "        data_brute = data_brute[['date','cas_confirmes', 'deces','deces_ehpad', 'reanimation', 'hospitalises', 'gueris']]\n",
    "        data_brute = dates.set_index('date').join(data_brute.set_index('date'))\n",
    "        data = data_brute.interpolate(limit_area='inside')\n",
    "        data = data.dropna(how='all')\n",
    "        data = data.loc['2020-03-18':]\n",
    "\n",
    "    # Departemental\n",
    "    if granularite == \"departemental\":\n",
    "        data_brute = pd.read_csv(glob.glob('donnees-hospitalieres-covid19-*')[-1], sep=\";\")\n",
    "        data_brute = data_brute.loc[data_brute['dep'] == \"59\"]\n",
    "        data_brute[data_brute['sexe']==0].groupby(['jour']).sum()\n",
    "        data = data.drop(columns=['sexe'])\n",
    "\n",
    "    return data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Collecte des données du gouvernement\n"
     ]
    }
   ],
   "source": [
    "data = collecte_donnees()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Collecte des données du gouvernement\n",
      "Création du graphe\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Création du graphe de l'évolution du Covid en France\n",
    "\n",
    "# date du jour :\n",
    "today = date.today()\n",
    "\n",
    "# Pour avoir toutes les données :\n",
    "data = collecte_donnees()\n",
    "\n",
    "# Pour plotter à l'échelle régionale ou départementale :\n",
    "#data = collecte_donnees('regional')\n",
    "#data = collecte_donnees('departemental')\n",
    "\n",
    "print(\"Création du graphe\")\n",
    "# Plot de la figure : \n",
    "fig, ax1 = plt.subplots(1, 1)\n",
    "ax1.plot(data['reanimation'])\n",
    "ax1.plot(data['deces'])\n",
    "ax1.plot(data['hospitalises'])\n",
    "\n",
    "x_axis = ax1.axes.get_xaxis()\n",
    "x_axis.set_visible(False)\n",
    "\n",
    "# Dates importantes :\n",
    "# début-fin du premier confinement, début-fin été 2020, début du deuxième confinement : \n",
    "xcoords = ['2020-03-17','2020-05-11','2020-11-01']\n",
    "\n",
    "for xc in xcoords:\n",
    "    plt.axvline(x=xc,ls='--',c='black')\n",
    "    ax1.text(xc, -0.02, f\"{xc}\", color='black', transform=ax1.get_xaxis_transform(),\n",
    "                ha='center', va='top', fontsize=8)\n",
    "\n",
    "# Nombre de lits en réanimation :\n",
    "plt.axhline(y=5000,c='tab:purple',ls='-')\n",
    "plt.title(f\"Évolution de la covid en France : {today}\")\n",
    "plt.legend([\"Réanimation\",\"Décès à l'hôpital\",\"Hospitalisations\"])\n",
    "plt.savefig(f'./plot/graph_covid.png')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Collecte des données du gouvernement\n",
      "Création du graphe\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Création du graphe de l'évolution du Covid en France\n",
    "# UNIQUEMENT POUR LE CONFINEMENT\n",
    "\n",
    "# Pour avoir toutes les données :\n",
    "data = collecte_donnees()\n",
    "\n",
    "# Pour plotter à l'échelle régionale ou départementale :\n",
    "#data = collecte_donnees('regional')\n",
    "#data = collecte_donnees('departemental')\n",
    "\n",
    "print(\"Création du graphe\")\n",
    "# Plot de la figure : \n",
    "fig, ax1 = plt.subplots(1, 1)\n",
    "ax1.plot(data['reanimation']['2020-02-24':'2020-06-24'])\n",
    "ax1.plot(data['deces']['2020-02-24':'2020-06-24'])\n",
    "ax1.plot(data['hospitalises']['2020-02-24':'2020-06-24'])\n",
    "\n",
    "x_axis = ax1.axes.get_xaxis()\n",
    "x_axis.set_visible(False)\n",
    "\n",
    "# Dates importantes :\n",
    "# début-fin du premier confinement, début-fin été 2020, début du deuxième confinement : \n",
    "xcoords = ['2020-03-17','2020-05-11']\n",
    "\n",
    "for xc in xcoords:\n",
    "    plt.axvline(x=xc,ls='--',c='black')\n",
    "    ax1.text(xc, -0.02, f\"{xc}\", color='black', transform=ax1.get_xaxis_transform(),\n",
    "                ha='center', va='top', fontsize=8)\n",
    "\n",
    "# Nombre de lits en réanimation :\n",
    "plt.axhline(y=5000,c='tab:purple',ls='-')\n",
    "plt.title(f\"Graphe sur la période du 1er confinement\")\n",
    "plt.legend([\"Réanimation\",\"Décès à l'hôpital\",\"Hospitalisations\"])\n",
    "plt.savefig(f'./plot/graph_covid_lockdown.png')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Partie 2 : Répartition de la population française <a class=\"anchor\" id=\"c2-p2\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Table des matières](#tdm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Répartition de la population française selon les proportions des sources\n",
      "Création des graphes\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZEAAAEICAYAAACeSMncAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8vihELAAAACXBIWXMAAAsTAAALEwEAmpwYAAAYz0lEQVR4nO3debQtZXnn8e9PUElQZoJMerFFIuKEtwFR2ylBtI0YJVGSFkQU04pDdHW3yVoRlbiSdNRENGqjoOAEJmpARZGgaJSAXECZlHBFDCAzynWKij79R70Htscz1K1799lnc76ftWrtqremp+qcs59T71v1VqoKSZKGuMekA5AkTS+TiCRpMJOIJGkwk4gkaTCTiCRpsE0nHcBS22677WrVqlWTDkOSpsoFF1xwS1VtP7t8xSWRVatWsWbNmkmHIUlTJcl35iq3OkuSNJhJRJI0mElEkjSYSUSSNJhJRJI0mElEkjSYSUSSNJhJRJI0mElEkjTYintiXdLdw/6PfwLfvf6GSYcxNXba8X6c869f3OjbNYlImkrfvf4GVu3/3EmHMTWuPueUsWzX6ixJ0mAmEUnSYCYRSdJgJhFJ0mAmEUnSYCYRSdJg3uIrLRM+97B+br3lFlZNOgiZRKTlwuce1s9Nn3j7pEMQVmdJkjaASUSSNJhJRJI0mElEkjSYSUSSNJhJRJI0mElEkjTY2JJIkl2TfCHJ5UkuS/LKVr5NkjOTXNk+t27lSXJskrVJLk6y98i2DmvLX5nksJHyRye5pK1zbJKM63gkSb9unFcidwCvqao9gf2AlyXZE3gtcFZV7Q6c1aYBngbs3oYjgXdBl3SAo4F9gX2Ao2cST1vmxSPrHTjG45EkzTK2JFJV11fVhW38B8A3gJ2Bg4AT22InAs9q4wcBJ1XnXGCrJDsCTwXOrKrbqup7wJnAgW3eFlV1blUVcNLItiRJS2BJ2kSSrAIeBZwH7FBV17dZNwA7tPGdgWtGVru2lS1Ufu0c5XPt/8gka5KsufnmmzfsYCRJdxp7EklyH+BjwKuqat3ovHYFUeOOoaqOq6rVVbV6++23H/fuJGnFGGsSSXJPugTyoar6eCu+sVVF0T5vauXXAbuOrL5LK1uofJc5yiVJS2Scd2cFOB74RlW9dWTWacDMHVaHAaeOlB/a7tLaD7i9VXudARyQZOvWoH4AcEabty7Jfm1fh45sS5K0BMbZFfxjgecDlyT5Wiv7c+CvgY8mOQL4DvCHbd7pwNOBtcCPgcMBquq2JMcA57fl3lhVt7XxlwLvB34D+EwbJElLZGxJpKq+DMz33MZT5li+gJfNs60TgBPmKF8D7LUBYUqSNoBPrEuSBjOJSJIGM4lIkgYziUiSBjOJSJIGM4lIkgYziUiSBjOJSJIGM4lIkgYziUiSBjOJSJIGM4lIkgYziUiSBjOJSJIGM4lIkgYziUiSBjOJSJIGM4lIkgYziUiSBjOJSJIGW68kkmTrJA8fVzCSpOmyaBJJcnaSLZJsA1wIvCfJW8cfmiRpuetzJbJlVa0Dng2cVFX7Ar8z3rAkSdOgTxLZNMmOwB8CnxpzPJKkKdInibwBOANYW1XnJ3kgcOV4w5IkTYNNF5qZZBNg16q6szG9qq4CnjPuwCRJy9+CVyJV9QvgkCWKRZI0ZRa8Emm+kuQdwCnAj2YKq+rCsUUlSZoKfZLII9vnG0fKCnjyRo9GkjRVFk0iVfWkpQhEkjR9+jxsuEOS45N8pk3vmeSI8YcmSVru+tzi+366W3x3atP/DrxqTPFIkqZInySyXVV9FPglQFXdAfxirFFJkqZCnyTyoyTb0jWmk2Q/4PaxRiVJmgp97s56NXAa8F+SfAXYHjh4rFFJkqZCn7uzLkzyBGAPIMAVVfXzsUcmSVr25k0iSZ5cVZ9P8uxZsx6chKr6+JhjkyQtcwtdiTwB+Dzwe3PMK8AkIkkr3LwN61V1dPs8fI7hhYttOMkJSW5KculI2euTXJfka214+si8P0uyNskVSZ46Un5gK1ub5LUj5bslOa+Vn5LkXkNOgCRpuIWqs1690IpVtdjbDd8PvAM4aVb531XVm2fta0/gecBD6Z5H+ZckD26z/wH4XeBa4Pwkp1XV5cDftG2dnOTdwBHAuxaJSZK0ES10i+99FxkWVFVfAm7rGcdBwMlV9dOq+jawFtinDWur6qqq+hlwMnBQktD13fVPbf0TgWf13JckaSOZ90qkqt4wpn0eleRQYA3wmqr6HrAzcO7IMte2MoBrZpXvC2wLfL89+Dh7+V+T5EjgSID73//+G+MYJEksXJ117EIrVtUrBuzvXcAxdA3zxwBvARZtX9lQVXUccBzA6tWra9z7k6SVYqG7sy7Y2DurqhtnxpO8h7ve2X4dsOvIoru0MuYpvxXYKsmm7WpkdHlJ0hJZqDrrxI29syQ7VtX1bfL3gZk7t04DPpzkrXQN67sDX6V7uHH3JLvRJYnnAX9UVZXkC3RPzp8MHAacurHjlSQtbKHqrL+vqlcl+SSt36xRVfXMhTac5CPAE4HtklwLHA08Mckj2/auBl7StnVZko8ClwN3AC9rr+YlyVF0vQhvApxQVZe1Xfwf4OQkfwlcBBzf85glSRvJQtVZH2ifb15gmXlV1VzvZp/3i76q3gS8aY7y04HT5yi/iu7uLUnShCxUnXVB+/zi0oUjSZomfd5s+IwkFyW5Lcm6JD9Ism4pgpMkLW99uoL/e+DZwCVV5e2xkqQ79Xkp1TXApSYQSdJsfa5E/jdwepIvAj+dKezRd5Yk6W6uTxJ5E/BDYDPAnnIlSXfqk0R2qqq9xh6JJGnq9GkTOT3JAWOPRJI0dfokkf8JfDbJT7zFV5I0atHqrKpa9N0hkqSVqc+ViCRJczKJSJIGM4lIkgbrc4svSTYBdhhdvqr+Y1xBSZKmw6JJJMnL6d4FciPwy1ZcwMPHGJckaQr0uRJ5JbBHVd067mAkSdOlbweMt487EEnS9OlzJXIVcHaST2MHjJKkEX2SyH+04V7YAaMkaUSfJ9bfAJDkN6vqx+MPSZI0Lfq8HvcxSS4HvtmmH5HknWOPTJK07PVpWP974KnArQBV9XXgv40xJknSlOj1sGFVXZNktOgX4wlnedv/8U/gu9ffMOkwpsZOO96Pc/71i5MOQ9IY9Uki1yTZH6gk96R7buQb4w1refru9Tewav/nTjqMqXH1OadMOgRJY9anOutPgJcBOwPXAY9s05KkFa7P3Vm3AH+8BLHobubmm25i1YP2mHQYU+PWW25h1aSDkNZTrzYRaYgqrP5bDzd94u2TDkFab3YFL0kazCQiSRqsT1fw9waeA6ziV98n8sbxhSVJmgZ92kROpevF9wJGOmCUJKlPEtmlqg4ceySSpKnTp03knCQPG3skkqSp0+dK5HHAC5J8m646K0BVla/HlaQVrk8SedrYo5AkTaVFq7Oq6jvAVsDvtWGrViZJWuH6vE/klcCHgN9qwweTvHzcgUmSlr8+DetHAPtW1euq6nXAfsCLF1spyQlJbkpy6UjZNknOTHJl+9y6lSfJsUnWJrk4yd4j6xzWlr8yyWEj5Y9Ocklb59jM6qtekjR+fZJI+NX3h/yilS3m/cDsW4NfC5xVVbsDZ7Vp6Npddm/DkcC7oEs6wNHAvsA+wNEziact8+KR9bwNWZKWWJ8k8j7gvCSvT/J64Fzg+MVWqqovAbfNKj4IOLGNnwg8a6T8pOqcC2yVZEe6NyqeWVW3VdX3gDOBA9u8Larq3Koq4KSRbUmSlkifruDfmuRsult9AQ6vqosG7m+Hqrq+jd8A7NDGdwauGVnu2la2UPm1c5TPKcmRdFc43P/+9x8YuiRptnmTSJItqmpdq1K6ug0z87apqtlXGeulqipJbcg21mNfxwHHAaxevXpJ9ilJK8FCVyIfBp5B12fW6Bdv2vQDB+zvxiQ7VtX1rUrqplZ+HbDryHK7tLLrgCfOKj+7le8yx/KSpCU0b5tIVT2jfe5WVQ8cGXarqiEJBOA0YOYOq8PoOnecKT+03aW1H3B7q/Y6AzggydatQf0A4Iw2b12S/dpdWYeObEuStET6PCdyVp+yOZb5CPBvwB5Jrk1yBPDXwO8muRL4nTYNcDpwFbAWeA/wUoBWZXYMcH4b3jhSjfZS4L1tnW8Bn1ksJknSxrVQm8hmwG8C27WrgJnberdggUbsGVV1yDyznjLHsgW8bJ7tnACcMEf5GmCvxeKQJI3PQm0iLwFeBexE1y4yk0TWAe8Yb1iSpGkwbxKpqrcBb0vy8qp6+xLGJEmaEn2eE3l7kr2APYHNRspPGmdgkqTlr8871o+mu812T7oG8KcBX6Z7SlyStIL16fbkYLrG8Buq6nDgEcCWY41KkjQV+iSRn1TVL4E7kmxB94DgrousI0laAfq82XBNkq3ont+4APgh3fMfkqQVrk/D+kvb6LuTfJau99yLxxuWJGkaLPSw4d4LzauqC8cTkiRpWix0JfKWBeYV8OSNHIskacos9LDhk5YyEEnS9OnznMihc5X7sKEkqc/dWf91ZHwzumdGLsSHDSVpxetzd9bLR6fb7b4njysgSdL06POw4Ww/Anbb2IFIkqZPnzaRT3LX63E3AR4CfHScQUmSpkOfNpE3j4zfAXynqq4dUzySpCmyaHVWVX0RuIKu08Vt6BKJJEm93rH+IuCrwLPpevQ9N8kLxx2YJGn561Od9b+AR1XVrQBJtgXOYY73nkuSVpY+d2fdCvxgZPoHrUyStML1uRJZC5yX5FS6u7QOAi5O8mqAqnrrGOOTJC1jfZLIt9ow49T2ed+NH44kaZr0eWL9DQBJ7tOmfzjuoCRJ06HP3Vl7JbkIuAy4LMkFSR46/tAkSctdn4b144BXV9UDquoBwGvoXpUrSVrh+iSRzavqCzMTVXU2sPnYIpIkTY0+DetXJfkL4ANt+n8AV40vJEnStOhzJfJCYHvg48DHgO1amSRphZv3SiTJZsCfAA8CLgFeU1U/X6rAJEnL30JXIicCq+kSyNOAv12SiCRJU2OhNpE9q+phAEmOp+uEUZKkOy10JXJn1VVV2f27JOnXLHQl8ogk69p4gN9o0wGqqrYYe3SSpGVt3iRSVZssZSCSpOnT5xZfSZLmZBKRJA1mEpEkDTaRJJLk6iSXJPlakjWtbJskZya5sn1u3cqT5Ngka5NcnGTvke0c1pa/MslhkzgWSVrJJnkl8qSqemRVrW7TrwXOqqrdgbPaNHQPOu7ehiOBd0GXdICjgX2BfYCjZxKPJGlpLKfqrIPonpKnfT5rpPyk6pwLbJVkR+CpwJlVdVtVfQ84EzhwiWOWpBVtUkmkgM+1F1wd2cp2qKrr2/gNwA5tfGfgmpF1r21l85X/miRHJlmTZM3NN9+8sY5Bkla8Pl3Bj8Pjquq6JL8FnJnkm6Mzq6qS1MbaWVUdR/dyLVavXr3RtitJK91ErkSq6rr2eRPwCbo2jRtbNRXt86a2+HXAriOr79LK5iuXJC2RJU8iSTZPct+ZceAA4FLgNGDmDqvDgFPb+GnAoe0urf2A21u11xnAAUm2bg3qB7QySdISmUR11g7AJ5LM7P/DVfXZJOcDH01yBPAd4A/b8qcDTwfWAj8GDgeoqtuSHAOc35Z7Y1XdtnSHIUla8iRSVVcBj5ij/FbgKXOUF/CyebZ1AnDCxo5RktTPcrrFV5I0ZUwikqTBTCKSpMFMIpKkwUwikqTBTCKSpMFMIpKkwUwikqTBTCKSpMFMIpKkwUwikqTBTCKSpMFMIpKkwUwikqTBTCKSpMFMIpKkwUwikqTBTCKSpMFMIpKkwUwikqTBTCKSpMFMIpKkwUwikqTBTCKSpMFMIpKkwUwikqTBTCKSpMFMIpKkwUwikqTBTCKSpMFMIpKkwUwikqTBTCKSpMFMIpKkwUwikqTBTCKSpMFMIpKkwUwikqTBpj6JJDkwyRVJ1iZ57aTjkaSVZKqTSJJNgH8AngbsCRySZM/JRiVJK8dUJxFgH2BtVV1VVT8DTgYOmnBMkrRipKomHcNgSQ4GDqyqF7Xp5wP7VtVRs5Y7EjiyTe4BXLGkgY7fdsAtkw5iini+1o/na/3cXc/XA6pq+9mFm04ikqVWVccBx006jnFJsqaqVk86jmnh+Vo/nq/1s9LO17RXZ10H7DoyvUsrkyQtgWlPIucDuyfZLcm9gOcBp004JklaMaa6Oquq7khyFHAGsAlwQlVdNuGwJuFuW1U3Jp6v9eP5Wj8r6nxNdcO6JGmypr06S5I0QSYRSdJgJpEpluSo1t1LJdlupPyJSW5P8rU2vG6ScW4MG3qsSTZL8s9JLk1yUZIHbkAsxyS5uO3vc0l2auVJcmyL8+Ikew/dx4ZKcnySr7c4/inJfVr5vZOc0mI8L8mqedbfPclX2/r/soGxnN26Jpr5Gf1WK39BkptHyl+0IftZDpK8P8m3R47pka38bvc3eaeqcpiiAbgXsHkbfxSwCrga2G5kmScCn5p0rOt5XFsvMn+DjhV4PnDizL6ArdYzvnsAW7bxLUbKXwG8u40/HfgMEGA/4LwJnq/RGN8KvLaNv3Qk3ucBp8yz/vHA4W18twHxbQ7cq42fDayeY5kXAO+Y9O/eRj7v7wcOnqN86v4m+w5eiUyJJA9J8ha6p+0fDFBVF1XV1RMNbONZk+RDSZ6cJLNnboRj/Rmwc5JU1feq6vt9VkrygCSvpzvvj2uxrBtZZHNg5u6Ug4CTqnMusFWSHTcg5oUsdr7WtfgD/MasGE9s4/8EPGWu9enO1y5tW9/uG1SSfZL8P+AyumR9d7PgeV+JTCLLWJLNkxye5MvAe4DLgYdX1UU9Vn9Mq874TJKHjjfSjeLBwEeAo4DLk/z5TDVRD32O9Spgb+CvFttYknsl+YMkZwD/DHwfeExVfXpkmTcluQb4Y2CmamJn4JqRTV3bysZh0fOV5H3ADcBvA2+fHWNV3QHcDmw7x/a/BbwiyTMWCyTJNklekeQi4Bjg88AeVXXjyGLva9U4fzHry/c5I1Vuu7L89fk9fVM7pr9Lcu+R8mn7m+xn0pdCDvMPwDrgy8BvL7Lc1fxqFc8WwH3a+NOBKyd9LOt53NsD7wXuAPbZ0GOl+0/80rbdzwKvauWfBvaaY/mL6RL2vj1i/TPgDW38U8DjRuadxRzVOEt8vjYB3sldVVOXAruMzP/W6PlsZXsDn6O7EvkGsD9dFd1VtMcCRpbdCfhP4BPArvPEt3P7vG/b7qFtelvg3m38JcDnJ/27t6HnHdixnat7013xva7v7+m0Dl6JLG8H03Xj8vEkr0vygD4rVdW6qvphGz8duGdGGqOXqyRbJnkJXa8DuwMvpPtCn1fPY30YcEtV3Qw8B3huklcA29BVu8z2YuDfgA8m+b9JHrJACB9q24Ql7oanz/mqql/Q9W79azEm2RTYErh11qZ/Bzinqq4Ffp+unv9PgdOrfQuOuBH4I7q2utOS/OlMw/lIDNe1zx8AH6brfZuqurWqftoWey/w6PU8BROx0Hmvquur81Pgfdx1rFP5N9mHSWQZq6rPVdVzgcfTVTucmuRf5rujZkaS+81UGSTZh+7nPPuLYllJ8kHgQmA3uv9Un1BVJ1XVfy6yXp9jvRL47SQPraofAUcAbwZOneNLkao6r6qOoGvMvwI4Psm5aXdbJdl9ZPGDgG+28dOAQ9PZD7i9qq5fn/PQ10Lnq+3/QW25AM+cFeNhbfxguv/+Z5+Di4CDkmxZVd8E/hZ4C/DB2XFU1S+q6uNV9d+BZ9C1EX0p3Z1wWybZdObLMsk92zKXtunR9qJn0l31LGuL/Z7OHFM778/irmOdur/J3iZ9KeSwfgPdfza7tvFX0NW73wF8F3hvKz+K7j/srwPnAvtPOu4ex/VMYNMF5m/QsQJPpfvjv4jubqE/ANb2PTfAQ4CHtPGP0X05XAx8kruqa0L3krRvAZcwxqqshc4X3RfUV1oMl9JdLW3R5m0G/GM79q8CD5xnG6+h+1K/gK4B/gV0iWj7HrEFeDLdVc7mbRsXt5/T24BN2nJ/NfKz+wKLVNsuh6HH7+nnR877B7mrCmvq/ib7DnZ7IkkazOosSdJgJhFJ0mAmEUnSYCYRSdJgJhFJ0mAmEWmJJDkiXc+5+086FmljMYlIS+fHwGMZX39a0pKb6nesS1PmJ8DP6R5clO4WvBKRls4hdB1qHjLpQKSNxSQiLYF0bxZ8HF2/Xc9rZfdI8s4k30xyZpLTkxzc5j06yReTXJDkjIzvvSTSBjGJSEvjIOCzVfXvwK1JHg08m+5tjXvSvXnxMXBnR4Vvp3tD3qOBE4A3TSJoaTG2iUhL4xC6zgeh65r9ELq/v3+sql8CNyT5Qpu/B7AXcGbr+HUTYCy9AUsbyiQijVmSbeh6tX1YkqJLCkX3Iqc5VwEuq6rHLFGI0mBWZ0njdzDwgap6QFWtqqpdgW8Dt9G9HvYeSXYAntiWvwLYPsmd1Vt3q9ep6m7FJCKN3yH8+lXHx4D70b0j5XK6d09cSPciq5/RJZ6/SfJ14Gt0r6iVlh3fJyJNUJL7VNUPk2xL95Kox1bVDZOOS+rLNhFpsj6VZCu6d5QfYwLRtPFKRJI0mG0ikqTBTCKSpMFMIpKkwUwikqTBTCKSpMH+PyaRmpw0qwpxAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "nb_agents = 67_000\n",
    "age=[]\n",
    "agentList = []\n",
    "sexe=[]\n",
    "poids = []\n",
    "groupe_sanguin = []\n",
    "\n",
    "# Proportions cumulatives pour l'âge:\n",
    "prop_age = [17.8/100, 35.1242921972263/100, 66.8828069335807/100, 1]\n",
    "\n",
    "# Par tranches d'âges les proportions normalisées sont :\n",
    "prop_homme = [0.527541666807402, 0.521707530462693, 0.506880352191682, 0.467120912994188]\n",
    "prop_femme = [0.472458333192598, 0.478292469537307, 0.493119647808318, 0.532879087005812]\n",
    "\n",
    "# Proportions pour le poids :\n",
    "prop_poids = [0.035,0.492,0.323,0.15]\n",
    "\n",
    "# Proportions pour le groupe sanguin : \n",
    "prop_groupe_sanguin = [0.38,0.36,0.08,0.03,0.07,0.06,0.01,0.01]\n",
    "\n",
    "print(\"Répartition de la population française selon les proportions des sources\")\n",
    "# Initialize accointances based on the matrix\n",
    "for i in range(nb_agents):\n",
    "    agentList.append(i)\n",
    "\n",
    "\n",
    "for i in range(nb_agents):\n",
    "    if 0 <= i <= int(nb_agents*prop_age[0]):\n",
    "        age.append('<15')\n",
    "        sexe.append(np.random.choice(['Homme','Femme'], 1, p=[prop_homme[0],prop_femme[0]])[0])\n",
    "    if int(nb_agents*prop_age[0]) < i <= int(nb_agents*prop_age[1]):\n",
    "        age.append('>15 & <30')\n",
    "        sexe.append(np.random.choice(['Homme','Femme'], 1, p=[prop_homme[0],prop_femme[0]])[0])\n",
    "    if int(nb_agents*prop_age[1]) < i <= int(nb_agents*prop_age[2]):\n",
    "        age.append('>30 & <55')\n",
    "        sexe.append(np.random.choice(['Homme','Femme'], 1, p=[prop_homme[0],prop_femme[0]])[0])\n",
    "    if int(nb_agents*prop_age[2]) < i <= int(nb_agents*prop_age[3]):   \n",
    "        age.append('>55')\n",
    "        sexe.append(np.random.choice(['Homme','Femme'], 1, p=[prop_homme[0],prop_femme[0]])[0])\n",
    "    poids.append(np.random.choice(['Dénutrition','Normal','Surpoids','Obésité'], 1, p=[prop_poids[0],prop_poids[1],prop_poids[2],prop_poids[3]])[0])\n",
    "    groupe_sanguin.append(np.random.choice(['A+','O+','B+','AB+','A-','O-','B-','AB-'], 1, p=[prop_groupe_sanguin[0],prop_groupe_sanguin[1],prop_groupe_sanguin[2],prop_groupe_sanguin[3],prop_groupe_sanguin[4],prop_groupe_sanguin[5],prop_groupe_sanguin[6],prop_groupe_sanguin[7]])[0])\n",
    "\n",
    "print(\"Création des graphes\")\n",
    "\n",
    "plt.hist(groupe_sanguin, color=\"#3F5D7D\", align='left', bins=range(0,9),edgecolor='black', linewidth=0.8)\n",
    "plt.xlabel(\"Groupe Sanguin\")\n",
    "plt.ylabel(\"Population en milliers\")\n",
    "plt.savefig('./plot/groupe_sanguin.pdf')\n",
    "plt.show()\n",
    "\n",
    "plt.hist(poids,color=\"#3F5D7D\", align='left', bins=range(0,5),edgecolor='black', linewidth=0.8)\n",
    "plt.xlabel(\"Poids\")\n",
    "plt.ylabel(\"Population en milliers\")\n",
    "plt.savefig('./plot/poids.pdf')\n",
    "plt.show()\n",
    "\n",
    "plt.hist(age,color=\"#3F5D7D\", align='left', bins=range(0,5),edgecolor='black', linewidth=0.8)\n",
    "plt.xlabel(\"Âge\")\n",
    "plt.ylabel(\"Population en milliers\")\n",
    "plt.savefig('./plot/age.pdf')\n",
    "plt.show()\n",
    "\n",
    "plt.hist(sexe,color=\"#3F5D7D\", align='mid',edgecolor='black', linewidth=0.8)\n",
    "plt.xlabel(\"Sexe\")\n",
    "plt.ylabel(\"Population en milliers\")\n",
    "plt.savefig('./plot/sexe.pdf')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Partie 3 : Création d'une animation sur notre graphe social <a class=\"anchor\" id=\"c2-p3\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Table des matières](#tdm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "class SMA:\n",
    "    def __init__(self, nb_agents, adjacency_matrix, graphe, depart, taux_contact, contamination, guerison, periode_contagion):\n",
    "        self.tick = 0\n",
    "        self.agentList = []\n",
    "        self.n_steps = 0\n",
    "        self.age = []\n",
    "        self.poids = []\n",
    "        self.sexe = []\n",
    "        self.groupe_sanguin = []\n",
    "        self.vivant = [] # 1 = Oui, 0 = Non\n",
    "        self.malade = [] # 1 = Oui, 0 = Non\n",
    "        self.cas_grave = [] # 1 = Oui, 0 = Non\n",
    "        \n",
    "        # On récupère le graphe pour travailler dessus dans le modèle de contagion\n",
    "        self.graphe = graphe\n",
    "        self.immunise = [] # 1 = Oui, 0 = Non\n",
    "        self.jour_malade = []\n",
    "        \n",
    "        self.taux_contact = taux_contact # contact\n",
    "        self.contamination = contamination # contamination\n",
    "        self.guerison = guerison # guérison\n",
    "        self.periode_contagion = periode_contagion # période pendant laquelle le patient est malade\n",
    "\n",
    "        # Les taux de gravité et décès différent selon la classe d'âge\n",
    "        self.taux_grave = [] # selon la gravité, réanimation ou hospitalisation\n",
    "        self.deces = [] # décès\n",
    "\n",
    "\n",
    "        # Pour récupérer le nombre de personnes malades par jours \n",
    "        self.plot_malade = []\n",
    "        self.plot_vivant = []\n",
    "        self.plot_immunise = []\n",
    "        self.plot_grave = []\n",
    "\n",
    "        self.nx_animation = [] # Pour récupérer nos graphes sociaux au jour i\n",
    "\n",
    "        \n",
    "        # Initialize accointances based on the matrix\n",
    "        for i in range(nb_agents):\n",
    "            self.agentList.append(Agent(i, np.nonzero(adjacency_matrix[i])[0]))\n",
    "            self.vivant.append(1)\n",
    "            self.cas_grave.append(0)\n",
    "            # Une probabilité d'être malade pour commencer à tracer les graphes\n",
    "            self.malade.append(np.random.choice([0,1], 1, p=[1-depart,depart])[0])\n",
    "            self.immunise.append(0)\n",
    "            self.jour_malade.append(0)\n",
    "\n",
    "        # Initialisation des paramètres se basant sur les sources :\n",
    "        # Proportions cumulatives pour l'âge :\n",
    "        prop_age = [17.8/100, 35.1242921972263/100, 66.8828069335807/100, 1]\n",
    "\n",
    "        # Par tranches d'âges les proportions normalisées sont :\n",
    "        prop_homme = [0.527541666807402, 0.521707530462693, 0.506880352191682, 0.467120912994188]\n",
    "        prop_femme = [0.472458333192598, 0.478292469537307, 0.493119647808318, 0.532879087005812]\n",
    "\n",
    "        # Proportions pour le poids :\n",
    "        prop_poids = [0.035,0.492,0.323,0.15]\n",
    "\n",
    "        # Proportions pour le groupe sanguin : \n",
    "        prop_groupe_sanguin = [0.38,0.36,0.08,0.03,0.07,0.06,0.01,0.01]\n",
    "\n",
    "        for i in range(nb_agents):\n",
    "            if 0 <= i <= int(nb_agents*prop_age[0]):\n",
    "                self.age.append(0)\n",
    "                self.sexe.append(np.random.choice([0,1], 1, p=[prop_homme[0],prop_femme[0]])[0])\n",
    "            if int(nb_agents*prop_age[0]) < i <= int(nb_agents*prop_age[1]):\n",
    "                self.age.append(1)\n",
    "                self.sexe.append(np.random.choice([0,1], 1, p=[prop_homme[1],prop_femme[1]])[0])\n",
    "            if int(nb_agents*prop_age[1]) < i <= int(nb_agents*prop_age[2]):\n",
    "                self.age.append(2)\n",
    "                self.sexe.append(np.random.choice([0,1], 1, p=[prop_homme[2],prop_femme[2]])[0])\n",
    "            if int(nb_agents*prop_age[2]) < i <= int(nb_agents*prop_age[3]):   \n",
    "                self.age.append(3)\n",
    "                self.sexe.append(np.random.choice([0,1], 1, p=[prop_homme[3],prop_femme[3]])[0])\n",
    "            self.poids.append(np.random.choice([0,1,2,3], 1, p=[prop_poids[0],prop_poids[1],prop_poids[2],prop_poids[3]])[0])\n",
    "            self.groupe_sanguin.append(np.random.choice([0,1,2,3,4,5,6,7], 1, p=[prop_groupe_sanguin[0],prop_groupe_sanguin[1],prop_groupe_sanguin[2],prop_groupe_sanguin[3],prop_groupe_sanguin[4],prop_groupe_sanguin[5],prop_groupe_sanguin[6],prop_groupe_sanguin[7]])[0])\n",
    "\n",
    "            # On remplit selon l'âge\n",
    "            # Données démographiques en source :\n",
    "\n",
    "            hospi_3 = 65/100\n",
    "            hospi_2 = 30/100\n",
    "            hospi_1 = 4/100\n",
    "            hospi_0 = 1/100\n",
    "            if self.age[i] == 3:\n",
    "                self.taux_grave.append(hospi_3)\n",
    "                self.deces.append(0.89)\n",
    "            if self.age[i] == 2:\n",
    "                self.taux_grave.append(hospi_2)\n",
    "                self.deces.append(((1-0.89)*hospi_2)/hospi_3)\n",
    "            if self.age[i] == 1:\n",
    "                self.taux_grave.append(hospi_1)\n",
    "                self.deces.append(((1-0.89)*hospi_1)/hospi_3)\n",
    "            else:\n",
    "                self.taux_grave.append(hospi_0)\n",
    "                self.deces.append(((1-0.89)*hospi_0)/hospi_3)\n",
    "\n",
    "        # On compte le nombre de cas :\n",
    "        self.plot_malade.append(self.malade.count(1))\n",
    "        self.plot_immunise.append(self.immunise.count(1))\n",
    "        self.plot_vivant.append(self.vivant.count(0))\n",
    "        self.plot_grave.append(self.cas_grave.count(1))\n",
    "\n",
    "\n",
    "    def run(self, rounds):        \n",
    "        for i in range(0,rounds):\n",
    "            self.runOnce()\n",
    "            self.plot_malade.append(self.malade.count(1))\n",
    "            self.plot_immunise.append(self.immunise.count(1))\n",
    "            self.plot_vivant.append(self.vivant.count(0))\n",
    "            self.plot_grave.append(self.cas_grave.count(1))\n",
    "\n",
    "    def runOnce(self):\n",
    "        self.tick += 1\n",
    "        for agent in self.agentList:\n",
    "            agent.decide(self.tick) \n",
    "        #print(\"\\ntick \" + str(self.tick) + \" ended.\\n\")\n",
    "        self.nx_animation.append(self.draw_graph(\"Jour_\" + str(self.tick)))\n",
    "\n",
    "    def draw_graph(self,titre):\n",
    "        color_map = []\n",
    "        for node in self.graphe:\n",
    "            if self.malade[node] == 1:\n",
    "                color_map.append('red')\n",
    "            else:\n",
    "                if self.vivant[node] == 0: \n",
    "                    color_map.append('grey')  \n",
    "                else:\n",
    "                    if self.immunise[node] == 1: \n",
    "                        color_map.append('blue')  \n",
    "                    else:\n",
    "                        color_map.append('green')\n",
    "\n",
    "        size = []\n",
    "        for node in self.graphe:\n",
    "            size.append(self.graphe.degree(node))\n",
    "\n",
    "        max_value = np.max(size)\n",
    "        iterator = 0\n",
    "        for value in size:\n",
    "            size[iterator] = (value/max_value)*400\n",
    "            iterator += 1\n",
    "\n",
    "        my_pos = nx.spring_layout(graph, seed = 100)\n",
    "        fig = plt.figure()\n",
    "        plt.axis('off')\n",
    "        nx.draw(self.graphe,pos=my_pos, node_color=color_map, node_size=size)\n",
    "        plt.title(str(titre))\n",
    "        plt.savefig(f'./plot/{titre}.png')\n",
    "        # print(f\"{titre} sauvegardé\")\n",
    "        plt.close(fig)\n",
    "        return fig"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Agent:\n",
    "    def __init__(self, id_number, accointances) :\n",
    "        self.id_number = id_number\n",
    "        self.accointances = accointances\n",
    "        self.has_it = False\n",
    "\n",
    "    def decide(self, tick) :\n",
    "        j = self.id_number\n",
    "\n",
    "        # On regarde si l'agent malade va guérir ou mourir\n",
    "        if sma.malade[j] == 1 and sma.vivant[j] == 1:\n",
    "            if sma.jour_malade[j] <= sma.periode_contagion:\n",
    "                # Tous les jours, l'agent malade (non cas-grave) peut devenir un cas grave :\n",
    "                if sma.cas_grave[j] == 0:\n",
    "                    sma.cas_grave[j] = np.random.choice([0,1], 1, p=[1-sma.taux_grave[j],sma.taux_grave[j]])[0]\n",
    "\n",
    "                # Si c'est un cas grave, il peut décéder : \n",
    "                if sma.cas_grave[j] == 1:\n",
    "                    sma.vivant[j] = np.random.choice([0,1], 1, p=[sma.deces[j],1-sma.deces[j]])[0]\n",
    "\n",
    "                # Sinon, il peut guérir :\n",
    "                else: \n",
    "                    sma.malade[j] = np.random.choice([0,1], 1, p=[sma.guerison,1-sma.guerison])[0]\n",
    "\n",
    "                # S'il meurt, il n'est plus malade\n",
    "                if sma.vivant[j] == 0:\n",
    "                    sma.malade[j] = 0\n",
    "                    sma.jour_malade[j] += sma.periode_contagion\n",
    "\n",
    "                # Quand notre agent n'est plus malade, il est immunisé  \n",
    "                if sma.malade[j] == 0:\n",
    "                    sma.jour_malade[j] += sma.periode_contagion\n",
    "                    sma.immunise[j] = 1\n",
    "                # Puis, pour chaque malade on compte 1 jour de plus pour ce tour\n",
    "                sma.jour_malade[j] += 1\n",
    "        \n",
    "        # Après la période d'periode_contagion, l'agent n'est plus malade\n",
    "        if sma.jour_malade[j] > sma.periode_contagion:\n",
    "            sma.malade[j] = 0\n",
    "            sma.immunise[j] = 1\n",
    "\n",
    "        # Si l'agent j est vivant, on regarde s'il peut être contaminé :\n",
    "        # Donc il faut qu'il soit sain et non immunisé\n",
    "        if sma.vivant[j] == 1 and sma.immunise[j] == 0 and sma.malade[j] == 0:\n",
    "            # On regarde tous ces liens et on garde uniquement les contacts\n",
    "            liens = []\n",
    "            contact = []\n",
    "            for i in range(0,len(list(graph.edges(j)))):\n",
    "                # On récupère les agents en lien avec notre agent\n",
    "                # On les met dans un tableau\n",
    "                liens.append(list(graph.edges(j))[i][1])\n",
    "                # On récupère aléatoirement taux_contact % de ces personnes\n",
    "            for k in range(int(sma.taux_contact*len(liens))):\n",
    "                valeur_contact = random.randint(0,int(sma.taux_contact*len(liens)))\n",
    "                contact.append(liens.pop(valeur_contact))\n",
    "            # On fait en sorte que chaque j agents aient au moins 1 contact :\n",
    "            if (contact == []):\n",
    "                contact.append(liens[len(liens)-1])\n",
    "            \n",
    "            # Pour chaque personnes restantes dans les contacts, on regarde si elles sont malades\n",
    "            for i in range(0,len(contact)):\n",
    "                if sma.malade[contact[i]] == 1:\n",
    "                    # Si un contact est malade, il y a contamination % chances de contamination pour notre agent j\n",
    "                    # La contamination est calculée avec le R0\n",
    "                    # R0 correspond au nombre de personnes contaminées sur la période de contagion\n",
    "                    contamination = sma.contamination / (len(contact) * sma.periode_contagion)\n",
    "                    sma.malade[j] = np.random.choice([0,1], 1, p=[1-contamination,contamination])[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Suppression des graphes déjà existant\n",
      "Propagation du virus pour 300 agents et 60 jours.\n",
      "Création des plots pour les graphes sociaux\n",
      "\n",
      "Le temps d'exécution de la simulation est de 21.9598s.\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Pour la création de graphe sociaux il faut prendre un nombre d'agents et de jours plus faible\n",
    "nb_agents = 300\n",
    "nb_rounds = 60\n",
    "\n",
    "# Choix du type de graphe : \n",
    "graph = nx.barabasi_albert_graph(nb_agents, 1) \n",
    "#graph = nx.complete_graph(nb_agents)\n",
    "#graph = nx.erdos_renyi_graph(nb_agents,0.1)\n",
    "#graph = nx.cycle_graph(nb_agents)\n",
    "#graph = nx.random_regular_graph(3,nb_agents)\n",
    "\n",
    "depart = 0.33 # Proportion de personnes contaminées au départ\n",
    "taux_contact = 0.4 # Taux de contact d'une personne sur tous ces liens\n",
    "contamination = 2 # R0 : nombre de personnes que contamine un agent\n",
    "guerison = 0.1 # Taux de guérison de la maladie\n",
    "periode_contagion = 14 # Période pendant laquelle l'agent est malade\n",
    "\n",
    "matrix = nx.to_numpy_array(graph, nodelist=range(nb_agents))\n",
    "sma = SMA(nb_agents, matrix, graph, depart, taux_contact, contamination, guerison, periode_contagion)\n",
    "\n",
    "# On regarde si des fichiers existe déjà \n",
    "if os.path.exists(\"./plot/Jour_0.png\"):\n",
    "    print(\"Suppression des graphes déjà existant\")\n",
    "    iterator = 0\n",
    "    while (os.path.exists(f\"./plot/Jour_{iterator}.png\")):\n",
    "        os.remove(f\"./plot/Jour_{iterator}.png\")\n",
    "        iterator += 1\n",
    "\n",
    "temps_debut = time.time()\n",
    "print(f\"Propagation du virus pour {nb_agents} agents et {nb_rounds} jours.\")\n",
    "print(\"Création des plots pour les graphes sociaux\")\n",
    "sma.nx_animation.append(sma.draw_graph(\"Jour_0\"))\n",
    "# On lance le jeu\n",
    "sma.run(nb_rounds)\n",
    "\n",
    "temps_fin = time.time()\n",
    "print(f\"\\nLe temps d'exécution de la simulation est de {round(temps_fin-temps_debut,4)}s.\")\n",
    "\n",
    "# Tracé de graphes :\n",
    "x = []\n",
    "for i in range(0,len(sma.plot_vivant)):\n",
    "    x.append(i)\n",
    "\n",
    "y = [sma.plot_vivant, sma.plot_malade, sma.plot_immunise, sma.plot_grave]\n",
    "labels = ['Décès', 'Malade', 'Immunisé', 'Cas Grave']\n",
    "\n",
    "for y_arr, label in zip(y, labels):\n",
    "    plt.plot(x, y_arr, label=label)\n",
    "plt.xlabel('Nombre de jours')\n",
    "plt.ylabel('Nombre de personnes')\n",
    "plt.legend(loc=\"upper right\")\n",
    "#plt.axhline(y=nb_agents,c='black',ls='-')\n",
    "plt.savefig('./plot/simulation_gif.png')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Création du gif :\n",
    "frames = []\n",
    "duration = 0.5*nb_agents\n",
    "imgs = glob.glob(\"./plot/J*.png\")\n",
    "for i in range(0,len(imgs)):\n",
    "    new_frame = Image.open(f\"./plot/Jour_{i}.png\")\n",
    "    frames.append(new_frame)\n",
    "\n",
    "frames[0].save('./plot/networkx.gif', format='GIF',\n",
    "               append_images=frames[1:],\n",
    "               save_all=True,\n",
    "               duration=600, loop=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sources <a class=\"anchor\" id=\"s\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Table des matières](#tdm)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Utilisation de la mémoire dans une classe en Python :\n",
    "https://habr.com/en/post/458518/ \n",
    "\n",
    "Réduction de la mémoire dans un dataset :\n",
    "https://www.kaggle.com/gemartin/load-data-reduce-memory-usage\n",
    "\n",
    "Réduction de la mémoire dans un array numpy : https://pythonspeed.com/articles/numpy-memory-footprint/\n",
    "\n",
    "Population française selon l'age et le sexe en 2020 : https://www.insee.fr/fr/statistiques/2381474\n",
    "\n",
    "Obésite en France en 2012 : https://www.roche.fr/fr/innovation-recherche-medicale/decouverte-scientifique-medicale/cardio-metabolisme/enquete-nationale-obepi-2012.html\n",
    "\n",
    "Groupes sanguins en France : https://www.ints.fr/SangTransfGrSanguin.aspx\n",
    "\n",
    "Gravité des cas selon les tranches d'âges et le sexe : https://www.hcsp.fr/Explore.cgi/avisrapportsdomaine?clefr=904\n",
    "\n",
    "Données démographique covid-19 France : https://dc-covid.site.ined.fr/fr/donnees/france/"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}