geneticAlgorithm.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Evolution of a Salesman - Genetic Algorithm for TSP\n",
    "\n",
    "#### I have used Genetic Algorithm (GA) to find the solution to the TSP.\n",
    "#### TSP can be described as:\n",
    "\n",
    "*Given a list of cities and the distances between each pair of cities, what is the shortest possible route that visits each city and returns to the origin city?* \n",
    "\n",
    "<img src=\"TSP.png\" width = \"450\" height = \"400\" />\n",
    "\n",
    "\n",
    "#### There are two important rules to keep in mind:\n",
    "*1. Each city needs to be visited exactly one time*  \n",
    "\n",
    "*2. We must return to the starting city, so our total distance needs to be calculated accordingly*\n",
    "\n",
    "</br>\n",
    "\n",
    "#### Approach\n",
    "#### Let’s start with a few definitions, rephrased in the context of the TSP:\n",
    "\n",
    "\n",
    "| Defination | Comment |\n",
    "| -- | -- |\n",
    "| *Gene* | A city (represented as (x, y) coordinates) |\n",
    "| *Population* | A collection of possible routes (i.e., collection of individuals) |\n",
    "| *Parents* | Two routes that are combined to create a new route |\n",
    "| *Mating Pool* | A collection of parents that are used to create our next population (thus creating the next generation of routes) |\n",
    "| *Fitness* | A function that tells us how good each route is (in our case, how short the distance is) |\n",
    "| *Mutation* | A way to introduce variation in our population by randomly swapping two cities in a route |\n",
    "| *Elitism* | A way to carry the best individuals into the next generation |\n",
    "\n",
    "\n",
    "#### Five phases are considered in a genetic algorithm:\n",
    "*1. Initial population*  \n",
    "\n",
    "*2. Fitness function*  \n",
    "\n",
    "*3. Selection*  \n",
    "\n",
    "*4. Crossover*  \n",
    "\n",
    "*5. Mutation*\n",
    "\n",
    "*REPEAT*"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Import all the libraries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import random\n",
    "import pandas as pd\n",
    "import operator\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Create necessary classes and functions"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create class to handle \"cities\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "class City:\n",
    "    \"\"\"\n",
    "    Represents a city with coordinates (x, y) and provides methods to calculate the distance to another city.\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, x, y):\n",
    "        \"\"\"\n",
    "        Initialize a city with the given x and y coordinates.\n",
    "        \n",
    "        :param x: The x-coordinate of the city.\n",
    "        :param y: The y-coordinate of the city.\n",
    "        \"\"\"\n",
    "        self.x = x\n",
    "        self.y = y\n",
    "    \n",
    "    def distance(self, city):\n",
    "        \"\"\"\n",
    "        Calculate the Euclidean distance between this city and another city.\n",
    "\n",
    "        :param city: The other city.\n",
    "        :return: The distance between the two cities.\n",
    "        \"\"\"\n",
    "        xDistance = abs(self.x - city.x)\n",
    "        yDistance = abs(self.y - city.y)\n",
    "        distance = np.sqrt(xDistance ** 2 + yDistance ** 2)\n",
    "        return distance\n",
    "    \n",
    "    def __repr__(self):\n",
    "        \"\"\"\n",
    "        Return a string representation of the city in the format (x, y).\n",
    "\n",
    "        :return: The string representation of the city.\n",
    "        \"\"\"\n",
    "        return \"(\" + str(self.x) + \",\" + str(self.y) + \")\""
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create a fitness function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Fitness:\n",
    "    \"\"\"\n",
    "    Represents the fitness of a route, including its distance and fitness value.\n",
    "    \"\"\"\n",
    "    def __init__(self, route):\n",
    "        \"\"\"\n",
    "        Initialize the Fitness object with the given route.\n",
    "        \n",
    "        :param route: The route to evaluate the fitness for.\n",
    "        \"\"\"\n",
    "        self.route = route\n",
    "        self.distance = 0\n",
    "        self.fitness = 0.0\n",
    "\n",
    "    def routeDistance(self):\n",
    "        \"\"\"\n",
    "        Calculate the total distance of the route by summing the distances between consecutive cities.\n",
    "\n",
    "        :return: The total distance of the route.\n",
    "        \"\"\"\n",
    "        if(self.distance == 0):\n",
    "            pathDistance = 0\n",
    "            for i in range(0, len(self.route)):\n",
    "                fromCity = self.route[i]\n",
    "                toCity = None\n",
    "                if(i + 1 < len(self.route)):\n",
    "                    toCity = self.route[i+1]\n",
    "                else:\n",
    "                    toCity = self.route[0]\n",
    "                pathDistance += fromCity.distance(toCity)\n",
    "            self.distance = pathDistance\n",
    "        return self.distance\n",
    "    \n",
    "    def routeFitness(self):\n",
    "        \"\"\"\n",
    "        Calculate the fitness value of the route as the reciprocal of the route distance.\n",
    "        We maximize fitness by minimizing distance. This is why we use the reciprocal of the distance.\n",
    "\n",
    "        :return: The fitness value of the route.\n",
    "        \"\"\"\n",
    "        if(self.fitness == 0):\n",
    "            self.fitness = 1/float(self.routeDistance())\n",
    "        return self.fitness"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Create our Initial Population\n",
    "\n",
    "*- The process begins with a set of individuals which is called a Population. Each individual is a solution to the problem you want to solve.*\n",
    "\n",
    "*- An individual is characterized by a set of parameters (variables) known as Genes. Genes are joined into a string to form a Chromosome (solution).*\n",
    "\n",
    "*- In a genetic algorithm, the set of genes of an individual is represented using a string, in terms of an alphabet. Usually, binary values are used (string of 1s and 0s). We say that we encode the genes in a chromosome.*\n",
    "\n",
    "<img src = \"Initial Population.png\" width = \"450\" height = \"350\" />"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Route generator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def createRoute(cityList):\n",
    "    \"\"\"\n",
    "    Creates a random route by shuffling the given city list.\n",
    "    \n",
    "    :param cityList: The list of cities to create the route from.\n",
    "    :return: A randomly generated route.\n",
    "    \"\"\"\n",
    "    route = random.sample(cityList, len(cityList))\n",
    "    return route"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create first \"population\" (list of routes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def initialPopulation(popuSize, cityList):\n",
    "    \"\"\"\n",
    "    Initializes the population with a specified size by generating random routes.\n",
    "    \n",
    "    :param popuSize: The desired size of the population.\n",
    "    :param cityList: The list of cities to create the routes from.\n",
    "    :return: The initial population consisting of randomly generated routes.\n",
    "    \"\"\"\n",
    "    population = []\n",
    "\n",
    "    for i in range(0, popuSize):\n",
    "        population.append(createRoute(cityList))\n",
    "    return population"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Rank individuals"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def rankRoutes(population):\n",
    "    \"\"\"\n",
    "    Ranks the routes in the population based on their fitness values.\n",
    "    \n",
    "    :param population: The population of routes to be ranked.\n",
    "    :return: A sorted list of tuples containing the route indices and their corresponding fitness values,\n",
    "             sorted in descending order of fitness.\n",
    "    \"\"\"\n",
    "    fitnessResults = {}\n",
    "    \n",
    "    for i in range(0, len(population)):\n",
    "        fitnessResults[i] = Fitness(population[i]).routeFitness()\n",
    "    return sorted(fitnessResults.items(), key = operator.itemgetter(1), reverse = True)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create a Selection function that will be used to make the list of parent routes"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*The idea of Selection phase is to select the fittest individuals and let them pass their genes to the next generation.*\n",
    "\n",
    "*Two pairs of individuals (parents) are selected based on their fitness scores. Individuals with high fitness have more chance to be selected for reproduction.*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def selection(popuRanked, eliteSize):\n",
    "    \"\"\"\n",
    "    Performs selection of individuals from the ranked population for the next generation.\n",
    "    \n",
    "    :param popuRanked: The ranked population, a list of tuples containing the individual indices and their fitness values.\n",
    "    :param eliteSize: The number of top-ranked individuals to include in the selection.\n",
    "    :return: A list of selected individual indices for the next generation.\n",
    "    \"\"\"\n",
    "    selectionResults = []\n",
    "    df = pd.DataFrame(np.array(popuRanked), columns=[\"Index\", \"Fitness\"])  # Remove np.array() around popuRanked\n",
    "    df['cum_sum'] = df.Fitness.cumsum()\n",
    "    df['cum_prec'] = 100 * df.cum_sum / df.Fitness.sum()\n",
    "\n",
    "    for i in range(0, eliteSize):\n",
    "        selectionResults.append(popuRanked[i][0])  # Append the index only\n",
    "    \n",
    "    for i in range(0, len(popuRanked) - eliteSize):\n",
    "        pick = 100 * random.random()\n",
    "        for i in range(0, len(popuRanked)):\n",
    "            if pick <= df.iat[i, 3]:\n",
    "                selectionResults.append(popuRanked[i][0])  # Append the index only\n",
    "                break\n",
    "    return selectionResults\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create Mating pool"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def mating(population, selectionResults):\n",
    "    \"\"\"\n",
    "    Creates a mating pool by selecting individuals from the population based on the selection results.\n",
    "    \n",
    "    :param population: The population of individuals.\n",
    "    :param selectionResults: The selected individual indices from the selection process.\n",
    "    :return: The mating pool containing the selected individuals.\n",
    "    \"\"\"\n",
    "    matingPool = []\n",
    "    \n",
    "    for i in range(0, len(selectionResults)):\n",
    "        index = selectionResults[i]\n",
    "        matingPool.append(population[index])\n",
    "    return matingPool"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create a Crossover function for two parents to create one child\n",
    "\n",
    "*Crossover is the most significant phase in a genetic algorithm. For each pair of parents to be mated, a crossover point is chosen at random from within the genes.*\n",
    "\n",
    "</br>\n",
    "\n",
    "*For example, consider the crossover point to be 3 as shown below.*\n",
    "\n",
    "<img src = \"Crossover 1.png\" width = \"450\" height = \"350\" />\n",
    "\n",
    "</br>\n",
    "</br>\n",
    "</br>\n",
    "\n",
    "*Offspring are created by exchanging the genes of parents among themselves until the crossover point is reached.*\n",
    "\n",
    "<img src = \"Crossover 2.png\" width = \"450\" height = \"350\" />\n",
    "\n",
    "</br>\n",
    "</br>\n",
    "</br>\n",
    "\n",
    "*The new offspring are added to the population.*\n",
    "\n",
    "<img src = \"Crossover 3.png\" width = \"450\" height = \"350\" />"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def breed(parent1, parent2):\n",
    "    \"\"\"\n",
    "    Performs crossover between two parents to create a child individual.\n",
    "    \n",
    "    :param parent1: The first parent individual.\n",
    "    :param parent2: The second parent individual.\n",
    "    :return: The child individual created through crossover.\n",
    "    \"\"\"\n",
    "    child = []\n",
    "    childP1 = []\n",
    "    childP2 = []\n",
    "    geneA = int(random.random() * len(parent1))\n",
    "    geneB = int(random.random() * len(parent1))\n",
    "    startGene = min(geneA, geneB)\n",
    "    endGene = max(geneA, geneB)\n",
    "    \n",
    "    for i in range(startGene, endGene):\n",
    "        childP1.append(parent1[i])\n",
    "    childP2 = [item for item in parent2 if item not in childP1]\n",
    "    child = childP1 + childP2\n",
    "    return child"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### A diagram clearly illustrating the Crossover and Mutation\n",
    "\n",
    "<img src = \"CAM.png\" width = \"1000\" height = \"350\" />"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create function to run crossover over full mating pool"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def breedPopulation(matingPool, eliteSize):\n",
    "    \"\"\"\n",
    "    Performs breeding (crossover) among individuals in the mating pool to create a new generation.\n",
    "    \n",
    "    :param matingPool: The pool of individuals selected for breeding.\n",
    "    :param eliteSize: The number of top individuals to preserve as elites.\n",
    "    :return: The new generation of individuals created through breeding.\n",
    "    \"\"\"\n",
    "    children = []\n",
    "    length = len(matingPool) - eliteSize\n",
    "    pool = random.sample(matingPool, len(matingPool))\n",
    "\n",
    "    for i in range(0, eliteSize):\n",
    "        children.append(matingPool[i])\n",
    "\n",
    "    for i in range(0, length):\n",
    "        child = breed(pool[i], pool[len(matingPool) - i - 1])\n",
    "        children.append(child)\n",
    "    return children"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create function to mutate a single route\n",
    "\n",
    "*In certain new offspring formed, some of their genes can be subjected to a mutation with a low random probability. This implies that some of the bits in the bit string can be flipped.*\n",
    "\n",
    "</br>\n",
    "\n",
    "<img src = \"Mutation.png\" width = \"450\" height = \"350\" />"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def mutate(individual, mutationRate):\n",
    "    \"\"\"\n",
    "    Applies mutation to an individual by swapping cities with a certain probability.\n",
    "    \n",
    "    :param individual: The individual (route) to be mutated.\n",
    "    :param mutationRate: The probability of mutation for each city in the individual.\n",
    "    :return: The mutated individual.\n",
    "    \"\"\"\n",
    "    for swapped in range(len(individual)):\n",
    "        if(random.random() < mutationRate):\n",
    "            swapWith = int(random.random() * len(individual))\n",
    "            city1 = individual[swapped]\n",
    "            city2 = individual[swapWith]\n",
    "            individual[swapped] = city2\n",
    "            individual[swapWith] = city1\n",
    "    return individual"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create function to run mutation over entire population"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def mutatePopulation(population, mutationRate):\n",
    "    \"\"\"\n",
    "    Applies mutation to a population by mutating each individual in the population.\n",
    "    \n",
    "    :param population: The population of individuals (routes) to be mutated.\n",
    "    :param mutationRate: The probability of mutation for each city in an individual.\n",
    "    :return: The mutated population.\n",
    "    \"\"\"\n",
    "    mutatedPopulation = []\n",
    "\n",
    "    for i in range(0, len(population)):\n",
    "        mutatedIndex = mutate(population[i], mutationRate)\n",
    "        mutatedPopulation.append(mutatedIndex)\n",
    "    return mutatedPopulation"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Put all steps together to create the next generation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def nextGeneration(currGeneration, eliteSize, mutationRate):\n",
    "    \"\"\"\n",
    "    Generates the next generation of the population by performing selection, mating, breeding, and mutation.\n",
    "    \n",
    "    :param currGeneration: The current generation of the population.\n",
    "    :param eliteSize: The number of top individuals to be preserved as elite.\n",
    "    :param mutationRate: The probability of mutation for each city in an individual.\n",
    "    :return: The next generation of the population.\n",
    "    \"\"\"\n",
    "    populationRanked = rankRoutes(currGeneration)\n",
    "    selectionResults = selection(populationRanked, eliteSize)\n",
    "    matingPool = mating(currGeneration, selectionResults)\n",
    "    children = breedPopulation(matingPool, eliteSize)\n",
    "    nextGen = mutatePopulation(children, mutationRate)\n",
    "    return nextGen"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Final step: create the genetic algorithm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def geneticAlgorithm(population, populationSize, eliteSize, mutationRate, generations):\n",
    "    \"\"\"\n",
    "    Implements a genetic algorithm to solve the Traveling Salesman Problem (TSP).\n",
    "    \n",
    "    :param population: The list of cities representing the initial population.\n",
    "    :param populationSize: The size of the population.\n",
    "    :param eliteSize: The number of top individuals to be preserved as elite in each generation.\n",
    "    :param mutationRate: The probability of mutation for each city in an individual.\n",
    "    :param generations: The number of generations to run the algorithm.\n",
    "    :return: The best route found by the genetic algorithm.\n",
    "    \"\"\"\n",
    "    pop = initialPopulation(populationSize, population)\n",
    "    print(\"Initial Distance: \" + str(1/rankRoutes(pop)[0][1]))\n",
    "\n",
    "    for i in range(0, generations):\n",
    "        pop = nextGeneration(pop, eliteSize, mutationRate)\n",
    "\n",
    "    print(\"Final distance: \" + str(1/rankRoutes(pop)[0][1]))\n",
    "    bestRouteIndex = rankRoutes(pop)[0][0]\n",
    "    bestRoute = pop[bestRouteIndex]\n",
    "    return bestRoute"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Running the genetic algorithm"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create list of cities"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(30,89), (17,18), (50,82), (70,63), (85,8), (2,46), (95,25), (90,86), (77,72), (6,98), (34,23), (89,65), (0,52), (77,37), (91,81), (8,19), (30,62), (88,86), (55,47), (52,52), (56,83), (48,43), (55,55), (27,49), (51,59), (84,55), (13,60), (78,51), (88,8), (35,66), (74,93), (66,5), (3,34), (70,94), (50,14), (26,80), (67,40), (69,39), (68,26), (6,25)]\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Empty list 'cityList' is created to store the cities.\n",
    "Generates a list of 40 City objects with randomly generated coordinates within the range of (0, 0) to (99, 99) on a two-dimensional plane.\n",
    "\"\"\"\n",
    "cityList = []\n",
    "\n",
    "for i in range(0, 40):\n",
    "    cityList.append(City(x = int(random.random() * 100), y = int(random.random() * 100)))\n",
    "\n",
    "print(cityList)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Run the Genetic Algorithm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Initial Distance: 1628.9894823268066\n",
      "Final distance: 774.5422624100981\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[(50,82),\n",
       " (30,89),\n",
       " (6,98),\n",
       " (30,62),\n",
       " (13,60),\n",
       " (0,52),\n",
       " (2,46),\n",
       " (3,34),\n",
       " (6,25),\n",
       " (8,19),\n",
       " (17,18),\n",
       " (34,23),\n",
       " (50,14),\n",
       " (66,5),\n",
       " (68,26),\n",
       " (85,8),\n",
       " (88,8),\n",
       " (95,25),\n",
       " (90,86),\n",
       " (88,86),\n",
       " (91,81),\n",
       " (70,63),\n",
       " (51,59),\n",
       " (52,52),\n",
       " (55,47),\n",
       " (69,39),\n",
       " (77,37),\n",
       " (78,51),\n",
       " (77,72),\n",
       " (56,83),\n",
       " (55,55),\n",
       " (27,49),\n",
       " (70,94),\n",
       " (74,93),\n",
       " (89,65),\n",
       " (84,55),\n",
       " (67,40),\n",
       " (48,43),\n",
       " (35,66),\n",
       " (26,80)]"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"\n",
    "Runs the genetic algorithm to solve the traveling salesman problem (TSP) using a given population of cities.\n",
    "\"\"\"\n",
    "geneticAlgorithm(population = cityList, populationSize = 250, eliteSize = 20, mutationRate = 0.01, generations = 500)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Plot the progress"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Note, this will win run a separate GA"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "def geneticAlgorithmPlot(population, populationSize, eliteSize, mutationRate, generations):\n",
    "    \"\"\"\n",
    "    Allows visualizing the improvement in the best route's distance over generations, \n",
    "    providing insights into the convergence and effectiveness of the genetic algorithm in solving the TSP.\n",
    "    \"\"\"\n",
    "    pop = initialPopulation(populationSize, population)\n",
    "    progress = []\n",
    "    # we are saving the distance of the best route in each generation\n",
    "    # by taking the reciprocal of the fitness value\n",
    "    progress.append(1 / rankRoutes(pop)[0][1])\n",
    "    \n",
    "    for i in range(0, generations):\n",
    "        pop = nextGeneration(pop, eliteSize, mutationRate)\n",
    "        progress.append(1 / rankRoutes(pop)[0][1])\n",
    "    \n",
    "    plt.plot(progress)\n",
    "    plt.ylabel('Distance')\n",
    "    plt.xlabel('Generation')\n",
    "    plt.show()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Run the function with our assumptions to see how distance has improved in each generation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkQAAAGwCAYAAABIC3rIAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABlI0lEQVR4nO3deXzT9f0H8FfSHG3TJul9QC9oue9DKCAeVC7H5YkyRWTiFLxl6CaIzg1l/lB0CnNOUYfXHDBBQZAb5JZy3xRaekLbND1zfn9/JPk2oS2kpWnS5vV8PPpY8/1+8+0nXxh9+f5cEkEQBBARERH5Mam3G0BERETkbQxERERE5PcYiIiIiMjvMRARERGR32MgIiIiIr/HQERERER+j4GIiIiI/J7M2w1oLaxWK/Ly8hAaGgqJROLt5hAREZEbBEFAeXk54uPjIZU2XAdiIHJTXl4eEhISvN0MIiIiaoKcnBy0b9++wfMMRG4KDQ0FYHugarXay60hIiIid+j1eiQkJIi/xxvCQOQmRzeZWq1mICIiImplrjfchYOqiYiIyO8xEBEREZHfYyAiIiIiv8dARERERH6PgYiIiIj8HgMRERER+T0GIiIiIvJ7DERERETk9xiIiIiIyO8xEBEREZHfYyAiIiIiv8dARERERH6PgcjLqo0WHMrRebsZREREfo2ByItKK43oOf8nTPpwJ8prTN5uDhERkd9iIPKiMJUCcdpAWAXgYLbO280hIiLyWwxEXjYgKRwAcOBiqZdbQkRE5L8YiLysX1IYAAYiIiIib2Ig8rIB9kB0MLsUVqvg5dYQERH5JwYiL0uJVAEAKo0WVBjNXm4NERGRf2Ig8rJAeQAUMtsfg76aM82IiIi8gYHIB2iC5ACAMgYiIiIir2Ag8gHqQBkAQF/NLjMiIiJvYCDyAawQEREReRcDkQ9Q2wORnqtVExEReQUDkQ9QB9oDEStEREREXsFA5AMcXWYMRERERN7BQOQD1EH2QdU1HFRNRETkDQxEPoBdZkRERN7FQOQDOMuMiIjIuxiIfABnmREREXkXA5EPqO0y4xgiIiIib2Ag8gHsMiMiIvIuBiIfUDvLjIGIiIjIGxiIfICjQlRltMBksXq5NURERP6HgcgHhChl4vecek9ERNTyGIh8gCxAKoYiLs5IRETU8hiIfAQHVhMREXkPA5GPCA20V4gYiIiIiFqcVwPRtm3bMG7cOMTHx0MikWDVqlV1rjlx4gTGjx8PjUYDlUqFgQMHIjs7WzxfU1ODmTNnIiIiAiEhIbj77rtRWFjoco/s7GzceeedCA4ORnR0NGbPng2z2be6prg4IxERkfd4NRBVVlaid+/e+OCDD+o9f+7cOQwbNgxdunTBli1bcPjwYcydOxeBgYHiNc899xxWr16N//znP9i6dSvy8vJw1113iectFgvuvPNOGI1G/PLLL/jss8+wbNkyzJs3z+OfrzHYZUZEROQ9EkEQBG83AgAkEglWrlyJiRMniscmT54MuVyOL774ot73lJWVISoqCl9++SXuueceAMDJkyfRtWtX7Nq1C4MHD8batWvxm9/8Bnl5eYiJiQEALF26FHPmzMHly5ehUCjcap9er4dGo0FZWRnUavWNfdh6vPDtIfz310uYM7oLnri1Y7Pfn4iIyB+5+/vbZ8cQWa1W/PDDD+jUqRNGjRqF6OhoDBo0yKVb7cCBAzCZTMjIyBCPdenSBYmJidi1axcAYNeuXejZs6cYhgBg1KhR0Ov1OHbsWIM/32AwQK/Xu3x5kmNxRlaIiIiIWp7PBqKioiJUVFTgzTffxOjRo7F+/XpMmjQJd911F7Zu3QoAKCgogEKhgFardXlvTEwMCgoKxGucw5DjvONcQxYsWACNRiN+JSQkNOOnq0vDMURERERe47OByGq1rdg8YcIEPPfcc+jTpw9eeukl/OY3v8HSpUs9/vNffvlllJWViV85OTke/Xm1G7wyEBEREbU0nw1EkZGRkMlk6Natm8vxrl27irPMYmNjYTQaodPpXK4pLCxEbGyseM3Vs84crx3X1EepVEKtVrt8eRIHVRMREXmPzwYihUKBgQMH4tSpUy7HT58+jaSkJABA//79IZfLsXHjRvH8qVOnkJ2djfT0dABAeno6jhw5gqKiIvGaDRs2QK1W1wlb3iROu2cgIiIianGy61/iORUVFTh79qz4OisrC5mZmQgPD0diYiJmz56N+++/H8OHD8dtt92GdevWYfXq1diyZQsAQKPRYPr06Xj++ecRHh4OtVqNp556Cunp6Rg8eDAAYOTIkejWrRseeughLFy4EAUFBXjllVcwc+ZMKJVKb3zserXTBgEAzhZVwGSxQh7gs1mViIio7RG8aPPmzQKAOl9Tp04Vr/nXv/4lpKamCoGBgULv3r2FVatWudyjurpaePLJJ4WwsDAhODhYmDRpkpCfn+9yzYULF4QxY8YIQUFBQmRkpPDCCy8IJpOpUW0tKysTAAhlZWVN/rzXYrFYhT6v/SQkzVkj7Msq9sjPICIi8jfu/v72mXWIfJ2n1yECgJlf/oofDufj2Yw0PJvRySM/g4iIyJ+0+nWI/NGQjhEAgH0XSrzcEiIiIv/CQORDusdrAABnCiu83BIiIiL/wkDkQ1KjQwAAReUGlFVxthkREVFLYSDyISFKGeI1to1rz14u93JriIiI/AcDkY9JjQkFwG4zIiKilsRA5GPS7N1mpxmIiIiIWgwDkY9xLNB4ucLg5ZYQERH5DwYiHxMaaFs8vJy73hMREbUYBiIf4whEFTVmL7eEiIjIfzAQ+ZjQQNsmr+UMRERERC2GgcjHhCjtFSIDAxEREVFLYSDyMY4uMz3HEBEREbUYBiIfExJYWyHivrtEREQtg4HIx6jtY4gEAag0WrzcGiIiIv/AQORjlDIpZFIJAM40IyIiaikMRD5GIpFwLSIiIqIWxkDkgxzjiMo504yIiKhFMBD5oFAl1yIiIiJqSQxEPijEqcuM0++JiIg8j4HIB6ntgWjWlwfR/88bcLJA7+UWERERtW0MRD7IsVo1AJgsAv6XmefF1hAREbV9DEQ+yLGfmUNieLCXWkJEROQfGIh8UK/2Gm83gYiIyK8wEPmg8X3iXV6bLFYvtYSIiMg/MBD5IKUsAB9O6Se+NpoZiIiIiDyJgchHje0Zh/sGtAcAGFkhIiIi8igGIh8mD7D98bBCRERE5FkMRD5MIWMgIiIiagkMRD5MYa8QcVA1ERGRZzEQ+TBWiIiIiFoGA5EPE8cQWQQvt4SIiKhtYyDyYawQERERtQwGIh8m5xgiIiKiFsFA5MNYISIiImoZDEQ+TBEgAcAKERERkacxEPkwsULEQERERORRDEQ+jCtVExERtQwGIh+mCGCFiIiIqCUwEPkwuYyzzIiIiFoCA5EPU7LLjIiIqEUwEPmw2goRV6omIiLyJAYiH6ZghYiIiKhFMBD5ME67JyIiahkMRD6M0+6JiIhaBgORD1NylhkREVGLYCDyYawQERERtQwGIh/mGENktgqwWjnTjIiIyFMYiHyY3L65K8CB1URERJ7EQOTDHBUigIGIiIjIkxiIfJhcWvvHY+I4IiIiIo9hIPJhUqlE7DZjhYiIiMhzGIh8nGOmmcnMQdVERESewkDk42pXq7Z4uSVERERtFwORj6tdi4gVIiIiIk9hIPJxcqltDNFdS3bCzHFEREREHsFA5OOSIlQAgBqTFdklVV5uDRERUdvEQOTj3nugr/g9Z5oRERF5BgORj4sKVaKdNggA9zQjIiLyFK8Gom3btmHcuHGIj4+HRCLBqlWrGrz297//PSQSCd59912X4yUlJZgyZQrUajW0Wi2mT5+OiooKl2sOHz6Mm2++GYGBgUhISMDChQs98Gk8xzHTzMBARERE5BFeDUSVlZXo3bs3Pvjgg2tet3LlSuzevRvx8fF1zk2ZMgXHjh3Dhg0bsGbNGmzbtg0zZswQz+v1eowcORJJSUk4cOAA/va3v2H+/Pn46KOPmv3zeIrSEYhMDERERESeIPPmDx8zZgzGjBlzzWtyc3Px1FNP4aeffsKdd97pcu7EiRNYt24d9u3bhwEDBgAA3n//fYwdOxZvv/024uPjsXz5chiNRnzyySdQKBTo3r07MjMzsWjRIpfg5Mu4FhEREZFn+fQYIqvVioceegizZ89G9+7d65zftWsXtFqtGIYAICMjA1KpFHv27BGvGT58OBQKhXjNqFGjcOrUKZSWljb4sw0GA/R6vcuXt7BCRERE5Fk+HYjeeustyGQyPP300/WeLygoQHR0tMsxmUyG8PBwFBQUiNfExMS4XON47bimPgsWLIBGoxG/EhISbuSj3BClLAAAZ5kRERF5is8GogMHDmDx4sVYtmwZJBJJi//8l19+GWVlZeJXTk5Oi7fBQcEKERERkUf5bCDavn07ioqKkJiYCJlMBplMhosXL+KFF15AcnIyACA2NhZFRUUu7zObzSgpKUFsbKx4TWFhocs1jteOa+qjVCqhVqtdvrxF7DIzcwwRERGRJ/hsIHrooYdw+PBhZGZmil/x8fGYPXs2fvrpJwBAeno6dDodDhw4IL5v06ZNsFqtGDRokHjNtm3bYDKZxGs2bNiAzp07IywsrGU/VBNx2j0REZFneXWWWUVFBc6ePSu+zsrKQmZmJsLDw5GYmIiIiAiX6+VyOWJjY9G5c2cAQNeuXTF69Gg89thjWLp0KUwmE2bNmoXJkyeLU/QffPBBvPbaa5g+fTrmzJmDo0ePYvHixXjnnXda7oPeICUDERERkUd5NRDt378ft912m/j6+eefBwBMnToVy5Ytc+sey5cvx6xZszBixAhIpVLcfffdeO+998TzGo0G69evx8yZM9G/f39ERkZi3rx5rWbKPeA0qJqBiIiIyCO8GohuvfVWCILg9vUXLlyocyw8PBxffvnlNd/Xq1cvbN++vbHN8xnsMiMiIvIsnx1DRLU4qJqIiMizGIhaAXGlalaIiIiIPIKBqBVwjCFilxkREZFnMBC1AkpWiIiIiDyKgagVUHAMERERkUcxELUCXIeIiIjIsxiIWgEOqiYiIvIsBqJWgIOqiYiIPIuBqBVQylkhIiIi8iQGolZAGcBB1URERJ7EQNQKsEJERETkWQxErYAioOExRCcL9Fiy5RyrR0RERDfAq5u7knscFaL6AtHod22b1potVjw1Iq1F20VERNRWsELUCrizUnVmjq6FWkNERNT2MBC1Au6sVC20VGOIiIjaIHaZtQKOdYhMFgF/XHkEcqkE9w9MRLd4tXiNVWAkIiIiaioGolYgWBEApUwKg9mKL/dkAwAullRh2bSbxGuYh4iIiJqOgagVCJQH4F9TB+LAxVJkXanAqsw8lFaZXK5hHiIiImo6jiFqJYalReKZjDTcNyABAFBtNLucF1giIiIiajIGolYmSGEbT1RltLiEIOYhIiKipmMgamWCFbZeziqjxWVdIoGdZkRERE3GQNTKBIsVIjNqTLXT8K3c1YOIiKjJGIhaGUcgqjFZUWWsDUQmCxMRERFRUzEQtTKOLjMAKK0yit87hyMiIiJqHAaiViZQLoVEYvu+tLJ26r1z9xkRERE1DgNRKyORSBAkt3WbFVcaxOOsEBERETUdA1Er5BhHVFJZ22VWzQoRERFRkzEQtUKOtYhKnQMRK0RERERNxkDUCgXLbQOri50CkdFihZkzzYiIiJqEgagVEitETrPMAHabERERNRUDUSukUtoHVVdcFYjYbUZERNQkDEStUJC9y8x5UDXAChEREVFTMRC1QsENdJlx6j0REVHTMBC1Qo5AVHxVheixz/fDYuUmr0RERI3FQNQKOQZVC1dln0ul1Tiep/dCi4iIiFo3BqJWyFEhcpgxvIP4/cWSypZuDhERUavHQNQKOW/wCgDaYDnu6tsOAHCxuMobTSIiImrVZNe/5NpqamoQGBjYHG0hN3WJDXV53Sk6FEazbVHGnBIGIiIiosZqUiCyWq34y1/+gqVLl6KwsBCnT59Ghw4dMHfuXCQnJ2P69OnN3U5yMqJrDLbOvhW6KhO0wXIkRahQbjABYIWIiIioKZrUZfbGG29g2bJlWLhwIRQKhXi8R48e+Pjjj5utcdSwpAgVeidokRShAgAkhgcDAHadL0aV0ezNphEREbU6TQpEn3/+OT766CNMmTIFAQG1A3x79+6NkydPNlvjyH2J4Srx+4kf7PRiS4iIiFqfJgWi3NxcpKam1jlutVphMpluuFHUeJEhCkzoEw8AOF1YgdKr1igiIiKihjUpEHXr1g3bt2+vc/y7775D3759b7hR1HgSiQSLJ/dFO20QAODs5Qovt4iIiKj1aNKg6nnz5mHq1KnIzc2F1WrFihUrcOrUKXz++edYs2ZNc7eRGiE1OgS5umqcKazAwORwbzeHiIioVWhShWjChAlYvXo1fv75Z6hUKsybNw8nTpzA6tWrcccddzR3G6kR0qJDAABni1ghIiIicleT1yG6+eabsWHDhuZsCzWDVHsgOlNU7uWWEBERtR5NqhDt27cPe/bsqXN8z5492L9//w03iprOEYjOsUJERETktiYFopkzZyInJ6fO8dzcXMycOfOGG0VN5whEeWU1qDBwPSIiIiJ3NCkQHT9+HP369atzvG/fvjh+/PgNN4qaThusQGSIEgCrRERERO5qUiBSKpUoLCysczw/Px8y2Q1vj0Y3KDXatkgjB1YTERG5p0mBaOTIkXj55ZdRVlYmHtPpdPjjH//IWWY+wNFtdrJAj2qjBdVGC8wWq5dbRURE5LuaVM55++23MXz4cCQlJYkLMWZmZiImJgZffPFFszaQGi8tOhQA8M/tWfjn9iwAQKhShu+eGILOsaHebBoREZFPalIgateuHQ4fPozly5fj0KFDCAoKwrRp0/DAAw9ALpc3dxupkYZ3ioI6UAZ9Te2g6nKDGVtOFTEQERER1aPJA35UKhVmzJjRnG2hZpISqcKvc++A0d5N9vdNZ/HhlnM4f7nSyy0jIiLyTU0ORGfOnMHmzZtRVFQEq9V1fMq8efNuuGF0Y2QBUsgCbEPEHFWh81dqB1kLgoD/ZeahpNKI3/SOQ3RooFfaSURE5AuaFIj++c9/4oknnkBkZCRiY2MhkUjEcxKJhIHIx3SMsg2ydq4Q7Th7Bc9+kwkAOJanx//d19sbTSMiIvIJTQpEb7zxBv7yl79gzpw5zd0e8oCUSNs0/OJKI3RVRmiDFThVULu1x6XSKm81jYiIyCc0adp9aWkp7r333uZuC3mISilDnMbWJXbusq3b7GJxbQjSVZm80i4iIiJf0aRAdO+992L9+vU3/MO3bduGcePGIT4+HhKJBKtWrRLPmUwmzJkzBz179oRKpUJ8fDwefvhh5OXludyjpKQEU6ZMgVqthlarxfTp01FR4bog4eHDh3HzzTcjMDAQCQkJWLhw4Q23vbVxjCM6mqsHAFwsqQ1EpVVGr7SJiIjIVzSpyyw1NRVz587F7t270bNnzzpT7Z9++mm37lNZWYnevXvj0UcfxV133eVyrqqqCr/++ivmzp2L3r17o7S0FM888wzGjx/vsoHslClTkJ+fjw0bNsBkMmHatGmYMWMGvvzySwCAXq/HyJEjkZGRgaVLl+LIkSN49NFHodVq/WqWXO/2Wmw5dRmHLukAANnFteOJdFUmCILgMhaMiIjIn0gEQRAa+6aUlJSGbyiR4Pz5841viESClStXYuLEiQ1es2/fPtx00024ePEiEhMTceLECXTr1g379u3DgAEDAADr1q3D2LFjcenSJcTHx2PJkiX405/+hIKCAigUCgDASy+9hFWrVuHkyZNut0+v10Oj0aCsrAxqtbrRn8/bNp0sxKPL9iM1OgTrnrkZXeaug9la+0d//PVRCFZw2xUiImpb3P393aTfgFlZWU1u2I0oKyuDRCKBVqsFAOzatQtarVYMQwCQkZEBqVSKPXv2YNKkSdi1axeGDx8uhiEAGDVqFN566y2UlpYiLCys3p9lMBhgMBjE13q93jMfqoX0aq8FYBtD9N6mszBbBSgCpLAIAixWAaVVJgYiIiLyW00aQ+QNNTU1mDNnDh544AEx4RUUFCA6OtrlOplMhvDwcBQUFIjXxMTEuFzjeO24pj4LFiyARqMRvxISEprz47S4yBAl0qJDIAjAexvPAAB6ttcgXGULiqWVHEdERET+q8klgUuXLuH7779HdnY2jEbXX6aLFi264YY5M5lMuO+++yAIApYsWdKs927Iyy+/jOeff158rdfrW30oem18dzz48R4AwCNDkvFcRifc+49fcLncwJlmRETk15oUiDZu3Ijx48ejQ4cOOHnyJHr06IELFy5AEAT069evWRvoCEMXL17Epk2bXPr/YmNjUVRU5HK92WxGSUkJYmNjxWsKCwtdrnG8dlxTH6VSCaVS2VwfwycMSY3EPx8egGqTBeN6xdm6H4PtFSLONCMiIj/WpC6zl19+GS+++CKOHDmCwMBA/Pe//0VOTg5uueWWZl2fyBGGzpw5g59//hkREREu59PT06HT6XDgwAHx2KZNm2C1WjFo0CDxmm3btsFkqq2AbNiwAZ07d25w/FBbdke3GIzvHS/OKAsLts0Q1DEQERGRH2tSIDpx4gQefvhhALYxO9XV1QgJCcHrr7+Ot956y+37VFRUIDMzE5mZmQBsg7UzMzORnZ0Nk8mEe+65B/v378fy5cthsVhQUFCAgoICsYuua9euGD16NB577DHs3bsXO3fuxKxZszB58mTEx8cDAB588EEoFApMnz4dx44dwzfffIPFixe7dIf5szB7hehYnh6nC8uvczUREVHb1KRApFKpxFASFxeHc+fOieeuXLni9n3279+Pvn37om/fvgCA559/Hn379sW8efOQm5uL77//HpcuXUKfPn0QFxcnfv3yyy/iPZYvX44uXbpgxIgRGDt2LIYNG4aPPvpIPK/RaLB+/XpkZWWhf//+eOGFFzBv3jy/WoPoWsLsg6q/3peDke9sw6aThdd5BxERUdvTpDFEgwcPxo4dO9C1a1eMHTsWL7zwAo4cOYIVK1Zg8ODBbt/n1ltvxbWWQXJniaTw8HBxEcaG9OrVC9u3b3e7Xf5kXK94/HL2CnJ11bhSYcSqg3m4vUtMnetySqrw8fbzqDZZEKMOxNMj0iAPaDWTFImIiK6pSYFo0aJF4vYYr732GioqKvDNN98gLS2t2WeYkWd1i1fjf7OG4cDFEty9ZBe+P5SHqUOSEaKU4fzlCvRPDkN0aCA+2nYeX+y+KL6vZzsNRnZveFA6ERFRa9KkQNShQwfxe5VKhaVLlzZbg8g7+iSEITJEiSsVBty9pLZLslucGj8+czOy7XufSSWAVQAuOG39QURE1No1qc+jQ4cOKC4urnNcp9O5hCVqPQKkErw6rhtCla4Z+WSBHgazBXm6agBAT/uK19lOm8MSERG1dk0KRBcuXIDFYqlz3GAwIDc394YbRd4xrnc89v4pA73ba9AhUgXAVg3KKakWA9HgDuEAbMeIiIjaikZ1mX3//ffi9z/99BM0Go342mKxYOPGjUhOTm62xlHLC1IE4H+zhgEAxizejhP5ehzJ1aHSaAvAg1Mi8I+t55HDChEREbUhjQpEjp3oJRIJpk6d6nJOLpcjOTkZ//d//9dsjSPvSo4Ixol8PXads3WPRqgUSI0OAQBcKq2G1SpAKpV4s4lERETNolGByGq1AgBSUlKwb98+REZGeqRR5BuSImzdZr/YA1G8NghxmkDIpBIYLVYUltcgThPkzSYSERE1iyaNIcrKyqoThnQ6XXO0h3xIckQwAFs1CADitYGQBUgRqwkEAOTparzWNiIioubUpED01ltv4ZtvvhFf33vvvQgPD0e7du1w6NChZmsceVf/pDBInHrE+iba9n6LCLFteltSyf3PiIiobWjSOkRLly7F8uXLAdg2Sv3555+xbt06fPvtt5g9ezbWr1/frI0k70iLCcUvL92Oy+UGBMoDkGYfPxRu3xC2pNLgzeYRERE1myYFooKCAiQkJAAA1qxZg/vuuw8jR45EcnKyuMs8tQ1xmqA644TCVY4KkckbTSIiImp2TeoyCwsLQ05ODgBg3bp1yMjIAGDbe6y+9YmobYkIsW0IywoRERG1FU2qEN1111148MEHkZaWhuLiYowZMwYAcPDgQaSmpjZrA8n3hAXbAlExxxAREVEb0aRA9M477yA5ORk5OTlYuHAhQkJsY0vy8/Px5JNPNmsDyfdEqGyBqJSBiIiI2ogmBSK5XI4XX3yxzvHnnnvuhhtEvi9M5egyYyAiIqK2we1A9P3332PMmDGQy+UuW3jUZ/z48TfcMPJd4Sp2mRERUdvidiCaOHEiCgoKEB0dLW7hUR+JRMKB1W0cu8yIiKitcTsQObbtuPp78j+OLrNKowWvrz6OAClwZ6949EnQerdhRERETdToMURWqxXLli3DihUrcOHCBUgkEnTo0AF33303HnroIUgk3OyzrVMHyhCqlKHcYMYnO7MAAGsO52P7H26DLKBJKzkQERF5VaMCkSAIGD9+PH788Uf07t0bPXv2hCAIOHHiBB555BGsWLECq1at8lBTyVdIJBIsfag/tp+5AgD4Zl828stq8N7GM+gYHQJ1kBzD06IQIGU4JiKi1qFRgWjZsmXYtm0bNm7ciNtuu83l3KZNmzBx4kR8/vnnePjhh5u1keR7hqZGYmhq7Qa/S7eew3ubzoqvF93XG3f1a++NphERETVao/o3vvrqK/zxj3+sE4YA4Pbbb8dLL70k7nFG/mPG8A64s1cchqVGokOUCgCww149IiIiag0aFYgOHz6M0aNHN3h+zJgx3O3eD4WrFPjgwX749+8G4dVx3QEA+y+WerlVRERE7mtUICopKUFMTEyD52NiYlBayl+E/qxvohYSCZBdUoUlW85h51lWioiIyPc1KhBZLBbIZA0POwoICIDZbL7hRlHrpQ6Uo2usGgDw1rqTePiTvSjU13i5VURERNfW6FlmjzzyCJRKZb3nDQbufk7AaxO646s92dhy+jJKKo04lleGGHWgt5tFRETUoEYFoqlTp173Gs4wo4HJ4RiYHI6nvzqI7w/l4VRBBW7v0nBXKxERkbc1KhB9+umnnmoHtUGdY0OBQ8DpwnJvN4WIiOiauKwweUznmFAAwMkCBiIiIvJtjd66g8hdnWNtgehcUQUsVsGtlatzSqow+7tDMFkE/G5YCjK6xUDO7UCIiMjDGIjIY+I0toHURosVuiojIkLqH4zv7Ot92dh9vgQAcOBiKUKVMqycOQSp0aEebSsREfk3/qc3eYwsQAptsBwAUFJpdOs9v17UubwuN5jrHCMiImpuDETkUeHBCgDuBSKLVcChSzoAwLpnb8aYHrEAgAoD17YiIiLPYiAijwpXuR+IThWUo8poQYhShrToULG6VMlAREREHsZARB4V5ghEVW4EokI9AKB7vBoBUglUCtsQtwojAxEREXkWAxF5VIQjEFVcPxAV6m0rnbfTBgEAgpW2QMQKEREReRoDEXlUYypERfZAFKW2zUYLUQYAACoNFg+1joiIyIaBiDyqMYOqC8ttm8DGhNqm66tYISIiohbCQEQe1ZhB1ZftFaJosUJkD0QcQ0RERB7GQEQe1ZhA5KgQRTsqRI5B1ewyIyIiD2MgIo9yBKJjeXp0mbsWvV9bj9WH8upcJwiCOIYoxl4hYpcZERG1FAYi8qiO0SGIDLGFohqTFWXVpnoDUbnBjGqTrRLkqBCFMBAREVEL4V5m5FEhShl2zLkdl8sN+OXcFcz57xFsOlmEmV/+CqPZKl5XYw9DoYEyBClss8tU9llm11qpusZkwfnLlegaFwqJ5PqbxxIREdWHgYg8LlAegITwYHStUgMAzFYBPxzOr/fajlEh4vfOXWaCINQbeF78zyGsOZyPDx7shzt7xXmg9URE5A8YiKjFxKoDXV5PH5biEoAkEuDmtEjxtSMQWQXboo2Bcik0QXKXYLTGHqz+b8MpBiIiImoyBiJqMREhSkgltoADAA8NTkJypKrB64PlAeL3gxdsBAD0SdDiwyn9oAmSi4EJqJ2yT0RE1BQMRNRiAqQSCE6v24cFXfN6qbRuF1lmjg5D3twEiQT409iu4vFyDrwmIqIbwFlm1KIEp0QkC3D/r586UIa1z9yMhPAg8T4bjhe6XLM3qwRF9rWMiIiIGoMVImoVbu8Sja5xamybfRt+OVeMKR/vwfF8vcs19/1jF6QSIDlCBXmAFDOGd8Dd/dt7qcVERNSasEJELap3ghYA0D1e7db1L47shJ7tNHjlN90AABKJROxqK6+p7SZrHxaEGLUSVgE4f6USpwrL8dmuC83adiIiartYIaIW9fcH+uKTnVmYPizFretn3Z6GWbenuRyLuWq2WscoFTa+cCsA4GJxJTYcL8QbP5wQ1zYiIiK6HgYialEJ4cF4dVz3G7pHoDwAESoFiu37o0WolOK5pAgV+tirUM4LPxIREV0Lu8yoVYrT1laJwlRyl3MKme2vtYGBiIiI3MRARK1SnKZ2yn64U4UIAJQy2/pFrBAREZG7GIioVYrX1FaIIlQKl3OsEBERUWMxEFGrdFuXaATKpQhWBGCY03YfAKC0ByJWiIiIyF0cVE2t0q2do3F0/igAdRd4dFSIjBYrrFah3hWviYiInLFCRK2WLEBa72rXjgoRYAtFRERE1+PVQLRt2zaMGzcO8fHxkEgkWLVqlct5QRAwb948xMXFISgoCBkZGThz5ozLNSUlJZgyZQrUajW0Wi2mT5+OiooKl2sOHz6Mm2++GYGBgUhISMDChQs9/dHIixROgYjjiIiIyB1eDUSVlZXo3bs3Pvjgg3rPL1y4EO+99x6WLl2KPXv2QKVSYdSoUaipqd2vasqUKTh27Bg2bNiANWvWYNu2bZgxY4Z4Xq/XY+TIkUhKSsKBAwfwt7/9DfPnz8dHH33k8c9H3qFwqhpxHBEREblF8BEAhJUrV4qvrVarEBsbK/ztb38Tj+l0OkGpVApfffWVIAiCcPz4cQGAsG/fPvGatWvXChKJRMjNzRUEQRA+/PBDISwsTDAYDOI1c+bMETp37tyo9pWVlQkAhLKysqZ8PGphaX/6UUias0bIKamsc67KYBZqTGaXY5UGU0s1jYiIWpC7v799dgxRVlYWCgoKkJGRIR7TaDQYNGgQdu3aBQDYtWsXtFotBgwYIF6TkZEBqVSKPXv2iNcMHz4cCkXt1OxRo0bh1KlTKC0tbfDnGwwG6PV6ly9qPRqaabZg7Qn0fn09Rr2zDaX2la7f/fk0us37CTO//BUVBnOde13LZ79cwLqjBc3TaCIi8hqfnWVWUGD7JRMTE+NyPCYmRjxXUFCA6Ohol/MymQzh4eEu16SkpNS5h+NcWFhYvT9/wYIFeO211278g5BXKGVSlMN1UHWlwYx/bD0PALhQXIVHPt2LKxVG5OqqAQA/HM5HoCwAT92eKr6nXVgQ5E5dcBarAKPZiiBFAE4W6PHq98cAADvm3Ib2YcEt8MmIiMgTfDYQedvLL7+M559/Xnyt1+uRkJDgxRZRYzhWq157pABP/PtXvH1vL5dgAwCHLpWJ3/dop8bRXD3+++sl/PfXS+Lxfola/PeJIZBIbFP3X1t9DF/vzcHKmUNwLLe2ajjl4z2IDrWtmK0JkmNAcjg2nSzCxeJKdIoJxWfTbuL0fyIiH+azgSg2NhYAUFhYiLi4OPF4YWEh+vTpI15TVFTk8j6z2YySkhLx/bGxsSgsLHS5xvHacU19lEollEplg+fJtzlmmi3eaJuVePeSXfi/e3sDALrGqXEivzbM3N4lGp88MhDvbDiNT3dmQRBsx8sNZvyarcOZogp0iglFldGMz3ddBAD8fdNZRIXW/v24WFyFi8VV4uufT9T+vSzUG1BcaXS5noiIfIvPjiFKSUlBbGwsNm7cKB7T6/XYs2cP0tPTAQDp6enQ6XQ4cOCAeM2mTZtgtVoxaNAg8Zpt27bBZDKJ12zYsAGdO3dusLuMWj/ntYgczhTZlmPon6RFgFO1pnu8GgDw3B2dcHj+KBx5zfZ1exdbd+zSreew+lAePtx8TnzPqcJyHLZXmKYNTcbS3/bD0t/2wx3dXLt4HXRVxub5YERE5BFerRBVVFTg7Nmz4uusrCxkZmYiPDwciYmJePbZZ/HGG28gLS0NKSkpmDt3LuLj4zFx4kQAQNeuXTF69Gg89thjWLp0KUwmE2bNmoXJkycjPj4eAPDggw/itddew/Tp0zFnzhwcPXoUixcvxjvvvOONj0wtRFFPINp2+jIAoFNMKMKCFbhSYQBQdy80h9E9YrHpZBFW/JqLFb/mupw7f7lS/H7KoCSkRocAAM4WVWDD8dqKpEoRgEqjBbpqE4iIyHd5NRDt378ft912m/jaMWZn6tSpWLZsGf7whz+gsrISM2bMgE6nw7Bhw7Bu3ToEBtZu7Ll8+XLMmjULI0aMgFQqxd1334333ntPPK/RaLB+/XrMnDkT/fv3R2RkJObNm+eyVhG1PfVViI7bu8lSo0IQGVIbiMJD6u/KGt87HrvPFyNfV7vuVWigDDVmqxiu+iVq0SFSJZ7XBruGq6QIFY7n66GrYiAiIvJlXg1Et956KwTHgI16SCQSvP7663j99dcbvCY8PBxffvnlNX9Or169sH379ia3k1qf+ipEAJAQHoR+SWEId6oKNVQhCpQHYNF9feo9ZzBbIAi24OUYcA0A2mC5+L1KEWAbN5TPLjMiIl/ns4OqiW6EY5aZw03J4cjXV2PJlP4IlAe4BqKQ+gNRY+7vEOZUIdIGK8SAVMYuMyIin8ZARG2S4qop9v93X2+0DwsSqznOwSW8gQpRU2iCaitE2mC5+HPYZUZE5Nt8dpYZ0Y1Qyl3/aocoZS5dW86zzMKCmy8QhamcK0RyMSCVssuMiMinMRBRm3R1hSgksOFi6NULNt4IrVOFSCkLELvM6ptlZjRbcShHh4KymjrniIioZbHLjNok5wpRoFxaJ/QEK+ofA3Sjrr6vOIaoni6zp786iHXHCqCUSfHz87cgIZxbfxAReQsrRNQmKQJqg0looLzO+UeHpSA5IhjPZqQ168917pYDAG2QfQxRdd0usyO5toUdDWYr/m/9KVisDc+4JCIiz2KFiNok5wpRaD3dZZEhSmyZfVud483NUSE6W1QBQRDEwCQIgrgOEgCsysxDVnEVVj05pE6oIiIiz2MgojbJeQxRqNI7f80Tw4PFAds1Jiue+ToT7z3QFwBQabTAYLYCAPokaJGZo8OhHB1yddVoH9Zw11l2cRVySqvqHI8OVSItJtQDn4KIyD8wEFGb5Fohqttl5knLpg3Ef3/NxXMZnaAOkmFc73isPpSH1Yfz8MqdXRGtDkSxvToUJA/AqplDMf7vO3D4UhkOZusaDET5ZdUYsWgLTJb6u9a+nzUUvdprPfWx3LL5VBFeWXkUSpkUSx/qj04MaUTUSnAMEbVJzhWikBauEN3aORrvP9AXmmA5JBIJ3n+gL/omaiEIwJPLf0VZlQlXKmxjihyLQvZN0AIADmbrGrzvwWwdTBYBwYoAdIkNFb/U9i7BAxdLPfq53LH6UB5yddU4f6USD/5zDw7l6LzdJCIitzAQUZuklDsPqvZ+IfQ3vWybDe+/WIq//HhcrBBF2PdR65sYBgD4NbvhUHO6sBwAMLZnHNY9O1z8enBQEgAg60plg+9tKfpqs/j9lQoDJnywE4s2nPZii4iI3MNARG1SeodwRIcqEaqUYUTXGG83B5MHJiDRPq1+/4VSFFfaKkRR9gpRlzhb19KF4oZDzZnCCgBAp5gQl+Mdomyby56/7PlAZLEKOHKpDAezS3EwuxSllbWz547mlqFQb1tT6Y5uMejZTgMAeH/TGVwuN9R7PyIiX+H9/3Qm8oDU6FDs/VOGt5shUillWPnkEPR/42ecv1IpBp8Ila1CFBMaCMC2xYfBbKl3rzRHhejqwdMdIm2BqCUqRK9+fxT/3p0tvo5QKbBjzu347kAO5v7vmHj8ocFJGN4pCkMWbEReWQ1ySqtsG90SEfkoVoiIWkhEiBJxGlvw2X76iv2YrUKkDZZDHmCbbl9fNcVotoqB5+qByh2ibBWjXF01qo0WzzTe7lieHoBt2QJFgBTFlUYczCl1CUMAoLav2B2vDQIA5OmqPdouIqIbxUBE1IK6x9u6kY7n24KFYwyRRCJBlP37onoC0ckCPcxWAepAGeLtocohzGnPtGN5ZR5rO1C74vYHD/bF6B6xAGwDqa/mGOjdLoyBiIhaBwYiohaU3jHC5bXzeKAotS3oFOnrBiLHDLJ+SWF1Fm6USCQY0SUaAPC3n07h37sv4tzlimZtt4Njk9owlQIDk20Dwb/am1PnuroVIu7XRkS+jWOIiFrQ1PQkdIkNRaXBjIgQJfolasVz0fYxNisPXsIL32ai0mhBVKgS79zXRwxEA5LC6r3vE7d2xIqDudiTVYI9WSVopw3Cjjm3Neuq11argDL7JrXaIDkGJIc3eK1jZp8jEOWyQkREPo6BiKgFyQKkGJoaWe85RyD66ViheOxyuQEPfbJHfN0/qf4QkhYTijcm9sD2M5fx84ki5OqqkV9WIwaS5lBeY4ZjuzVNsLzegd8OjnPttLaqF7vMiMjXMRAR+YjoUNexQZ88MgD/3p2NTSeLAADttEHo61RRutpvByfht4OTMGbxdpzI1+PwpbJmDUSO7rJgRQCUsgDIpNfvcXf8/GN5enR+Za14PDRQhg+n9MdPxwqwfM9FCPagJZVI8NjNKXh+ZOdmazcRkTsYiIh8RLS6dlp6qFKG4WlRuK1zNAr1BlgEAZEhimtWZRx6t9fYA5FOHPjcHMTxQ/b92QKkEoQoZagwmBt8T3KECu20QcjVVYt7twGAocKIDccL8J/9OagxWV3e8+kvF/BMRicESLnJLRG1HAYiIh/RMap2gPUtnaMgs28/EnvVrLLr6dleg6/35eDDLecQFarEtKEpzdI+nWP8UHDt3nDqwGsHokB5ADa9eIu4VQkAfLsvB4s3nsH5y5XQ19jeu+G54QiUB2Ds4u0orzHjRL4ePewLOxIRtQQGIiIfMTA5DB8/PADFlQbc0a3plZ1bOkWJ368/VohpQ1NgtQ/+kUhQ70Brq1Vo8JyDzl4hcg5EoYFyoOzaM8iUsgC0c+q6S7PPrMu073OmUgSIi00OTAnHppNFePX7Y/hi+k0IVtj+icoursK2M5ex9mg+kiJUeHVcN7eqZURE7uK0eyIfIZFIkNEtBvcPTES4StHk+7QPC8YHD/YDAFSZLPh2Xw46z12LDn/8EcPe2izuo+bw07ECdJ23Dj3nr7/mBrG6KkeFqLZt6qDG/zeVY3FKx/YlzhWw9A62ZQkOXCzF4o1nxOMP/HM3Xll1FDvPFuPLPdkY+MbPWHnwUqN/dmuXU1KFonIuYUDkCQxERG2Qo4pTbTTj5xOFMFlsFaJcXTU2nihyufabfTkwmK2oMJjxv8zcBu9Zag9EYS5dZvI6111v6E+M2rULME5TWz26d0B78ftzRba1lIxmqzht31Fp0teY8fH2rGv/oDamrMqEEYu2Ythbm2FxTPcjombDQETUBgUrbN1JVUYLKo22cTpJEbbNZXecvSJeZ7JYsft8sfh6/4X6K0TH8srwnr1iow2qrRA51hsCgFfu7IpBKeH49vH0a7YtOjQQzj1zzgFJG6zAPx8eAKB2xe7yGpN4fuvsW/Hz88MB2Da7NZpdB2S3ZWeKymE0W2E0W3Ewu+FKHhE1DQMRURvkGHtTZbSg0mDb32xktxgAwOZTRXh5xRG8vOIInv0mE1VO+58dz9cjp6Sqzv2+3Ve7GnWn2Nq91BwrUgPATSnh+Obx9Gsu2AgACplU3NQWqO1Cc3Csx+TY082xGGSIUgZZgBQdo0IQGiiD0WLF2SLPrMjti644dXXO/d8xVF5jMDsRNR4DEVEbVFshMou/OIelRSE0UIbyGjO+2puNr/Zm44fD+QCACX3ikRhuqyDdvHCzOODZ4UKxLST9dnAixvWKE487V4hClO6PJ3IOQTFXBaIop0BktQriTDTHfm0SiQTd4tQAaveE8wcFToPXT+TrcceirVh1MBc1Js9u6EvkLzjLjKgNCrIHohqTVZwWrw2SY9m0m/CLU5cZYKvYTOrbDj8cycdrq48DAB7+1x7EqG1dW/cPTMTF4koAwJ09411mooUoaytEIYHu/3OSFBGMI7m2jWiT7V15DpH2TW7NVgG6ahP09gqRc/jqFq/GnqwS7M0qxj3928MfFDjtcSeVAHllNXj2m0zM1nXGzNtSvdgyoraBgYioDVIpav+v7ehqUSllSI0OQf8G9kObNjQFk/q2w9jF25FXVgN9ja07auG6k+KiismRruFF5jSCOlRZd4B1Q+aM7oJOMaEIVykwtKPrViYKmRRhwXKUVplQVF4DvX0MkXP33IguMfh05wX858AlXLhSBVw1kFsCYEKfdnhwUKLbbfJ1hXpbheilMV0wunssbn17CwDU28VJRI3HQETUBgXKpZBIAEGAOMNMpbz+uj3aYAXWPH0zThWUAwCeWH5AnG6vkEkRc9X2Is6DowPl7vfAJ4QH4+kRaQ2ejw4NRGmVCZfLDdBX2ypczjPahqVF4u5+7fHfXy9h74WSeu+xJ6sEBWXVmH5zB7G7rTVzBKIYtRLJkba1mF5bfRzlHEtE1CwYiIjaIIlEgiB5gMuAaZWbY3zCVQqkd7StBzQ4JQLrjhUAAJLCgyG9ak69c/fZtRZ1bKxotRKnCstRpDeIg6qvDjV/vasHRveIrXem2cqDl/DziSK8t+kssoqr8P4DfZutbd5SIAYiWyh1/HlycDVR82AgImqjghUyl0AULG/8ys5DU2sDUXKkqs75rnGhdY41hyj7OKIX/nMII7pEA6i7CKRSFoA77DPnrjakYwSeWH4Au8+XYO2RfPwyMKFOIOwUEyqOtWqM85crkJmjw6S+7Zo1BF5PoX1Qdaw9EIXaP09FDQMRUXNgICJqo4KdftkHyqXi3miNMbFvOxy4WIryGjOeuLVjnfNDOkbi3fv7IDU6pJ53N93AlHCsOGhbJHLjSdtCkvUtAtmQMJUCX89Ix71Lf8G+C6V48OM9da7pEhuKdc8Ob3Tb7nhnGyz2rU4m9W2ZAd2Xyw2oNFogkdSu7O0IeNfaS46I3MdARNRGOQci50HWjREaKMe7k6/d3TSxb7sm3ftaHrgpEdklVViy5Zx4rCnjgF4c2Rl/XHkENababjWrICC/rAYnC8phsQoIuN7S2ldxrBK96eTlJgUis8WKC8VV6BilcrvC9Kt9IcZO0aHiGlOOWX0MRETNg4GIqI1y7g5yd/yQL7m9S7RLIFI3IRAN6hCBjS/c6nKsxmRBl7nrAACVRnOjKk/OHMsBNEZBWQ0e/OdunL9SiTcm9sBvBye59T5HIOqXpBWPhXAMEVGz4sKMRG2Uc1UouAljZbyta5zaZRabuhHrHF1LoDwACnv3YXkjx9847yGmr2l8IPr0lyycv2Jb08ndRSV/OJyPf2w9DwDom1i7ZEJtIOLCjETNofX9ZyMRucW5QtSYVaR9RYhShuQIFbLsAaIpFaKGhAbKUFxptO+TFnTd6x2cq0JNqRAdzNaJ3zu2JnF2qqAcv/t8H3SVtnsLqO0Sk0iAQSm126I4qn5GixUGswVKWesLvUS+pPX9K0lEbnGuCgW3wkAEAI8OS8GSzWfRPjwYfRK0zXbf2kDUuAqRzikE5elqIAiC2+OAzBYrjlwqE187B6LVh/Kw/0IJdpy9gpySapf3SSXAvf0TMKZnLJIiamf6OYfcSgMDEdGNap3/ShLRdQU7dZmFuLEooy96aHASHnJznE1jhNrHDZU3sttLV2UUv682WfDIp/vE1bplARLMGN4B/ZPqbm5rtQqY/d1hVDvtO+a8ee2z32SK3XGaIDmW/26QWAHSBMkRrlLUuWeA1LbWVLXJgooac73XEJH7GIiI2iiXClETZ5m1VY7qyrUqROuOFuBIrg5SiQTjesejU0yoS4UIALaevuzy2mIV8PHUuoFo6+nLWGlfRqBDpArnr1TicoUBgiDg3OUKWKwCNEFyTB2SjBFdotGjnca9zxEoswUiDqwmumH8V5KojQpu5WOIPMmxUWxZtQm7zxejZzuNy0y8kkojnlx+AI4x1DvOXsHKJ4eKFaLkiGA8eVuqbZAPgCO5Zfhi90VxmxEAKK4w4O+bz0Iqkbjs+bbkt/0x6t1tMJqt0NeYcf6ybYxU93g1nr+jU6M+R4hShsvlBjzy6V70TdSKxyWQYGLfdhjdI7ZR9yPyZ/xXkqiNcu5CYXeKK0eX2Yebz6FAX4OMrtH4eOpA8XyhvgZWAeJ+cMfy9DBZrOK+bt3baXDfgATx+ii1El/svogqky0QCYKAqZ/uxdFc15lkC+/phc6xoQgNlKG8xozL5QZkXbFtoptSz0rg1+MIukXlBvx0rNDl3JHcMgYiokZgICJqo+7q1x66KhOsgoApbWjX9+bgqBA59gf7+USRy3lH8EmJUOFyuQHlBjPOXa4Qj2uvmvHmWOKgyj4Ffte54jphCAAGJNmmzUeFKsVA5KgQdYhq/GrfzssAzP1NNwTKpdBVmfC3n07hir1LriW3FyFqzRiIiNooTZAczzWyC8ZfXG9No7JqW9dYmEqByBAl9l4owfE8vbjRbFiwa8XN0T1ZabRViL7alwMAuLVzFLaevgxBsO1B5qgCRYUocf5yJT7YfBYn7OsRdYhqfIXIeS2j6cNSANim6f/tp1MwmK2oNlk4fozITfx/ChH5nZDrBCLnSlBCeDD2XijBog2nYTDbtgDRBrtWiByByLGZ7rkiWzfY1PRk/P6WjjiWp8fQ1AixWpMUEYw9WbZp9oCta65zTOM3ylUpAlBptCDCqUtUpbAtPGm0WFFaZWIgInIT/59CRH4ntJ7tOpy7lxyzyTTBctyUEo5lv1zApdLa9YGuHu/jGJBdZbRAEASUG2zvVwfJ0T8pDIM7RLhc/+LIzkiNDoHRHrC6xKoRr3V/gUiHD3/bH4s2nMZbd/cUj0kkEoSp5CjUG1BaaUS7JtyXyB8xEBGR3wmtp0Lk3L1UWyFSYHT3WCz/3SCU2meYhasUGJziGnAcq4JbrAKMFqs4nb+hrrlodSBmDO94w5/jlk5RuKVTVJ3jYcEKFOoNKKk01vMusloFSCTg+CpywUBERH6nvgpRSaVRDESOMUTaYDmkUgmGpkZe837B8tolDioNFjEQ1fdzWoJjVmFpFQPR1SxWARM/2IlAuRTfPp7OUEQibu5KRH6nnTawzrHSytpFF8UKUbB7gUYWIIVSZvvntLjCIM7+Ugd55785w+yBiBWiugr0NTiSW4Z9F0rFWYZEAAMREfmh1OhQfPzwALw6rpvYrVXiVE1xBCJNIzaUdQysdvySdWyt4Q3h9llwpQxEdThvv+JY8oAIYCAiIj+V0S0G04amiNtkOIcHXQPT66/F0d1WUGYLRKGBMq91x4gVInaZ1eFcNTt/ucKLLSFfw0BERH6tvu6lsqraMUTuclSIiuybttY3cLulhNnbXVrVuM1rAeCNNccxdvF2XC43YMIHOzHvf0eb3I5nvj6I5Jd+wF0f7oTJYm3yfZqT85/zOVaIyAkHVRORX3N0L72+5jhMFis2nSxCoT3UaIMaUSFSXlUhUnpnQDVQO6i6pKLxFaKPd2QBAB7+ZC9O5OtxKEeH18Z3b3S1y2yxYvWhPADAr9k6rD1agPG94xvdnubmUiG6wkBEtVghIiK/lhpdu2XGgrUnsSerBBargBClDFGhSrfvo7pqDJG3BlQDQGSIrd17L5Tg0WX78LvP9iGnpOq67xOE2q1ATjitgt2USlNRuQFOO4vg6a8O4q11Jxt9n+ZWyi4zagADERH5tQcHJWJgcpjLsT9P6I7vZw0V1xdyh6PLrFDvGEPkvQpRrMY2i85iFbDpZBF+PlGElQdzr/u+GlP93Vp5uup6j19LfpntPcFOz/CzXy647L/mDcVOgahIb3AJgeTfGIiIyK/JA6QuO9cDwL0DEhq92Wp9g6q9JU5Td1kBxz5s19LQNflljZ+enqezvadHvAZH5o8EYFvJ+3RheaPv1Zycu8yMFivKDWYvtoZ8CQMREfk9520zwoLlCGzCdHmV0nVQtdqLFaJghazOkgHlNTcSiJpeIYrTBiI0UI6hqbbVvQ9m68RrKgzmFu+2unptpuImjLOitomDqonI7zlXVOI0Tdv7K0ju+s9pQ9t2tJQ4TaBLwHGsnn0t+gZCk6Pa47DuaD6+O3AJzr1NUqkEDw1OwnD7ViKO9zi67/omhGHn2WIs/OkkPtmZBXWgDMfy9DCYrfjh6WHoHq9p1OdrqrqByFBnb7rWyGC2uPx5BMoDYLEK4uw+mVSCAKmEK3Nfg08HIovFgvnz5+Pf//43CgoKEB8fj0ceeQSvvPKK+IcqCAJeffVV/POf/4ROp8PQoUOxZMkSpKWlifcpKSnBU089hdWrV0MqleLuu+/G4sWLERLSuJI4EbVNziEoRNm0fxYdFSIHb44hAlzH7gDuBaIy++Dp3u01+ObxdHz2ywUsWHuyToXojR9OuGx263AwuxSbX7wVKoVMfE+8/dne0jkKf998Froqk7jwpcMPh/NbJBB9sesCzhTZKlLBigBUGS240gYqRO9sOI3FG8+4HOsQpcLlcoPLn3u4SoFvH093mUhAtXw6EL311ltYsmQJPvvsM3Tv3h379+/HtGnToNFo8PTTTwMAFi5ciPfeew+fffYZUlJSMHfuXIwaNQrHjx9HYKDtv0ymTJmC/Px8bNiwASaTCdOmTcOMGTPw5ZdfevPjEZGPaMzg6YakxYS6vO4cG9rAlS3DfNXgZXfGyjgqSuogW7dhnL0r0XlQtdUqiOOkXrmzq9g1+MGWs7hYXIWe89e73NNRfRuYHI6fnx+OKxVGrPj1Er7df6mJn8x9VquAkwXl6BwbCgmAhetOied6tddg9/kSFFcaPN4OT1tzOK/OsfpW4S6pNOLfuy9i/vjuLdGsVsenA9Evv/yCCRMm4M477wQAJCcn46uvvsLevXsB2KpD7777Ll555RVMmDABAPD5558jJiYGq1atwuTJk3HixAmsW7cO+/btw4ABAwAA77//PsaOHYu3334b8fHeXxeDiFq/8b3j0TU2FPoaE8KCFY0elN3cTJarApEbY4gcXWZq+/ijxPBgAEDWldop+6VVRjFsPZyeDIV9D7dwlQKP//uAyyyysGA5+ibWzuBLjQ5FarTtl7VzILo6vDWXNUfy8fRXB3FP//b4/S0dxVC45cVbsXTrOew+X9KktZp8icUqIKfEFljXPzcccZpATP5oN47l2ZZN+PPEHpjQJx47z1zBE8t/xepDefjTnV0hD+AQ4qv5dCAaMmQIPvroI5w+fRqdOnXCoUOHsGPHDixatAgAkJWVhYKCAmRkZIjv0Wg0GDRoEHbt2oXJkydj165d0Gq1YhgCgIyMDEilUuzZsweTJk2q92cbDAYYDLX/5aDX6+u9jojahh7t1Diaq8c9/ds3+R5XV4m8aeZtHTHry4NIiw7BmaIK97rMql33cEuzd61cqTCguMKAiBClOGg8XKUQwxBg2wrlyPyRMDhN3VcpZS7XOMRqXNd3ulLumSrNv7afBwB8d+ASBqWEAwAGJIUhOVKFiBDb4pXFHtjv7V87svDuz6dhtQe93gla/P3BfuKCmc0pT1cNo8UKRYAUHaNCECCVoE+CVgxEt3WOgjpQjju6xSAyRCFW6O4fmNjsbWntfDoivvTSS5g8eTK6dOkCuVyOvn374tlnn8WUKVMAAAUFBQCAmJgYl/fFxMSI5woKChAdHe1yXiaTITw8XLymPgsWLIBGoxG/EhISGryWiFq/Lx4dhM8evemGApEvubNnHNY/NxxLH+oPoHGzzByBSKWUISHc1m12utA29sYRiKLrWbQyWCFDmEohftUXhmzvdV0WoMhDgaib07ikf2yzhaPeCVoAQITK1v4rFc37sysMZry74TTKa8yoNFpQabTgl3PFeHL5gWb9OQ4Xim1dYwnhQQiQ2sbWjuhq+50nlQDtw2xVPlmAFI8P7wjA1nVYbbS43CdXV41/bD3X4MB6f+DTFaJvv/0Wy5cvx5dffonu3bsjMzMTzz77LOLj4zF16lSP/uyXX34Zzz//vPhar9czFBG1YWEqBW6xz5BqCyQSCTrFhIq7u9eYrDBZrNfsKtFX26pIzksGdI4JRU5JNc4UlSO9YwSK7AtPRqvrrnXkrhj11YGo8escucNorq1WnbUPpu6bqAUAsUK05nA+nh5RDqVMii/3ZsNotuJ0YTmy7GNwxvdph5fGdKlz77/+eAJrDtUdu+NY26hDlAqfPjIQ+WU1mPzRbuw+XwKj2dpgSGyqC8W27kznmXK3d4nBBw/2Q6cY127bR4YmY+nWcyiuNOJUYTn62MMhADzw0W5kl1ThdGEF/u++3s3axtbCpwPR7NmzxSoRAPTs2RMXL17EggULMHXqVMTGxgIACgsLERcXJ76vsLAQffr0AQDExsaiqKjI5b5msxklJSXi++ujVCqhVLq/bD8RkS9ynjVXXmMWu22uVBiwaMNpXCk3YMbwDhiQHF6nQgQAnWJC8fOJIpwqsC2oeK0Kkbsiruo68lSFqMJg+zyBcinu6d8eUSGBGNXd9u9++7DamYXzvz8GbbAcPx6p22vwrx3nMWd0Z5fp6qWVRvxz+3lca5HrJ27piKQIFRLCgiGTSmC2CiiuNDR5WYf6nC2qwNxVts13kyJclw64s1dcnevl9m614soSXCyudAlE2fatXTadLGy29rU2Ph2IqqqqIJW6pumAgABYrbbUn5KSgtjYWGzcuFEMQHq9Hnv27METTzwBAEhPT4dOp8OBAwfQv7+tdLxp0yZYrVYMGjSo5T4MEZEXyAKk4hTz8hoTwlUKVBstuO8fu8SZSBUGM758bDD0DQQiAOJ0dbFCdAOBSCp1XQtHV2XCfUt3oWtcKF6b0KPJ971apcHWLbTgrp6Y1Ne1K7RfYhgeGZKMZb9cQGaODip7cLxvQHukRYeib6IW9yzdBZNFQFm1Cdrg2hC389wVCALQMUqFd+/vW+fnBisD0MFesZFKJQhXKVBUbkBxhbFZA9Hnuy6I3/dop3brPYkRwdh7ocStve38jU8HonHjxuEvf/kLEhMT0b17dxw8eBCLFi3Co48+CsBWEn722WfxxhtvIC0tTZx2Hx8fj4kTJwIAunbtitGjR+Oxxx7D0qVLYTKZMGvWLEyePJkzzIjIL4QoZfZAZOsS237mssu07BP5egiCgLP2VaPbOVVPku2/2C/ax6o0R4WoPnsvlGDvhRLMG9ddHAtzoxyzykKUddeEkkgkmPubbvjP/hxUGi2oMloglQDzx3cXt2HRBsuhqzKhqNzgEoi2n74CALitczR6tr/++kmR9sHozT1eKde+FtRtnaMwrpd7v88cMwcvFjMQXc2nB1W///77uOeee/Dkk0+ia9euePHFF/H444/jz3/+s3jNH/7wBzz11FOYMWMGBg4ciIqKCqxbt05cgwgAli9fji5dumDEiBEYO3Yshg0bho8++sgbH4mIqMU59lVzDJjdfb4EAHBP//aQSmy72f+aXYqSSiPkARJ0jaudLZccYfsFWqg3oMpoFhdkjK1nv7TGeOXOrojTBCK9QwSc8487e665q1IMRPX/t3+AVOISaDrFhIphCACiQmyh77JTl54gCNh+5jIA4GY3x5w5xis19yKQjj3mHk5PhszNafRJ9j/PbFaI6vDpClFoaCjeffddvPvuuw1eI5FI8Prrr+P1119v8Jrw8HAuwkhEfsuxavb+C6UQBGCb/Rf6LZ2ikJmjw9miCny7z7YuUJdYNZSy2oUqtcEKsVJyqqAcJ/Jt07lvdGXp393cAb+7uYP4utf8n6CvMaOk0tBs09Mraq4diADbrDNHQHQeUwMAUaFKnCmqcAlE5y5XIq+sBgqZFDclh7vVDkewKm7mCpHzfnHuSrBXiM5fqcQvZ69AKpWglxtVLn/g04GIiIhunGOhxUUbTrscH9QhHF2OheJsUQX+dygXAOrtAkqKUEFXpcMPh/NhtgqIDFG6DEpuDhEhSnsgar4KUYWjQnSNfeUevCkRR3PLYLEKmDok2eVcVGjdCpGjOnRTcrjbK5zXVogaF4jMFiuO5JYhXKWoM2i6xmRBqX0LlDi1+38WSfZAdLncgAc/3gMAuDktUjzf1CUyzRYrvtybjdu7RItT/VsbBiIiojZuanoSSioNMJlrf93d2iUK0aGBGJAUhjWH81FjX1DRsYChs5SIYBzK0WFVpm2aed9EbbNvEhquUiDrSiVKmmkrDatVQKXx+hWipAgVlv9ucL3nHOOkLjsFmZ1nbeOHnEPE9USKFaLGdZn99UfbRrgA6myA69g+JUgeAHWQ+7/KI0KUeHRoCnaevQKD2YILxVXYfuaKeL6ixgxBEBr95/vJziz89ceTePunUzg8f1Sj3usrGIiIiNq4EV1jMKJrTL3nHhyUhFhNIMprzNAGK3B7l+g61zi2IXFUOBxr+TQnRzdZc60cXWWq3f29qRv2OipEjpl1giDg12wdAOCmeoJjQyJC6gYrd/yaXSp+fyK/3CUQ5Tl1lzU2vMwb1w2AbW+zfn/e4HLObBVQbjC7rEXlsOF4Ieb97ygMZiti1YFY/rtBCLP/ue04WwwA0NeYr7vela9iICIi8mMKmRSje9Rds8bZ5IEJyC2tRrnBBE2QHA94YNsHx9pEzbW3mGNAdYBUgkB50345OwLR8Xw9vtmXjUK9ASWVRigCpOgW7940dwCItHeZnS4sx1NfHUS10YJnM9LQo921x+44T413VM4EQcA3+3Jwzj4jMO4GBreHqxQIC5aLXW8OukpTvYHo051Z4kDukkojdp0vxtietr87SqcFJ4/klqGf0x52rQUDERERXVO0OhBv3dPLoz8jrJkrRI4lBlSKgCZ37zlW1D5dWIE5/z0iHu8a7zrw/HritbYxPoV6A1bbV7cu1Nfg+1lDG2xbhcHs8iwc3+84ewUvrahtS/wNrmvUISoEBy6WuhwrqTIiMcJ1HFCNyYL99us6x4TiVGG52G0HuIa3R5ftQ7wmCEt+2w9JESqYLFb87rP9OFNYjoAACZ6/o1OddaF8AQMRERF5naNCVFrVPIHIMaA6tJ5Kh7tuSg7HI0OSkVNSBQHAppO2XQ9So0Ku/carpEWHIDE82GWq+5HcMnR/9Sc44lCPdhp8MX2QuLVH9lXrBDnGHznWHnJwd+p/QzpGqeoEou8O5OBgtuuxPF01jGYrYtRKDE2NtAUip65E53WNdFUm6KpMWHM4HzNvS8XxPD22nr4snv/XjiwGIiIiovo4xhCVNFOF6HprELlDFiDF/PHdxddf7LqA9zedxUPpSY26j0QiwdDUCGTvtYWGmbd1xAebz6HKaYPVPVkl2HKqCCPtW4tcvU6Q47lUXrUpa31jvhojLTq0zrF/785u8PohHSPFbjpHhehyuQHVJtvClmufGY5v9uXgk51ZOGnf7qXY3t0XrlKgpNKIUwXlMJgtjaqytQQGIiIi8jpHIDpwsRQTPtgJpUyKl8d0Qd9GjkU5XViO43l6HMktAwColM33S/eh9GQ8lJ7cpPfOuj0N+y+UYkKfeMy8LRW/HZwkbj77z+3n8e/d2fhg81lxz7jMHB0A2z5sNSar2GXmPAtvYp/4Gwp8gG1xzosllTCZBQxLi8Smk0UwWaz1XhsoD8DM21LFZ+uoEDk2mG0XFoTOsaG4uVOkLRDZ16xyVLd6tNPg8CUddFUmnC6ocGuV75bEQERERF7XMSoEUglQZbTgkD0MLN54Bsum3eT2PaqMZkz8YKdL5cV5XzZvaqcNwobnbxFfO+9p9tvBSfj37mwculSGQ5fKXN43MDkc289cERd1dISLO3vFYcFdNz6uK0ylwBsTe4qvx/W+/hYgjtmGjgqRo3uts33fuy6xtv89f6USBrNFrG5FqBTo2U6D7WeuYPmei+hXYAu7SeHBGNQh4oY/y41iICIiIq9LCA/GumeHI7u4CrpqE178zyHsOHMFZ4vKxY1Xr0UTJEdxhRFVRgsCpBIM6RgBmVSCx2/p2AKtvzFdYtVYcFdPHL4qDIUGyjCqewy2n7kihgpHpSi9Q4TbC0M2t1j7YPMCfQ0EQcCu87Yp94PtoSZWHQhNkBxl1Sb85r0duDnNNs4pXKVAnCYQ289cwdf7cvD1vhzxnptfvBUpkSp4EwMRERH5hE4xoehkrzL8a0cWTuTrkbFom1vvDZIH4J37ewOw/eL9Yvogj7XTEx64KREP1FMMc+w/V2W0oNroWm3xlmi1bTkCo9mKdzacxr4s29YnjkAkkUgwKCUc648X4kxRBapNtopduEqBSX3b4VJptTjofV9WCcoNZuSUVHk9ELW+lZOIiKjN+/0tHRCilEERIL3uFwBUmyz45ZytUhF6ja06WptQ+zMAgCVbz4kzwhyLPXqDUhaAGHsoem/TWVQaLdAGy9EtrnZtpncn90GwvYLl2BA4XKVAvDYI7z3QF588MhCfPDIQXewbCTuWSfCmtvO3hoiI2owJfdphQp92bl372Of7seF4oTglPfQGBxr7EolEghiNEjkl1Xhv4xnxeHNtgNtUC+/pjbVH8gEAEgkwukccpNLaNZWCFTI8cFMi/rUjSzxWX5sdyyKU1zTfHnZN1Xb+1hARkV9yDJzO1dkD0Q2sPeSLXp/QA6sz87D5VJG4qrQ3u8wA4JZOUbjlOmsgdYhy7QKrr82Oap4vVIjYZUZERK2aY5sJR4XoRqei+5rbOkdj0f19cEe32v3ofGX23LVcPSao/gqRIxB5v0LEQERERK2aIxyUi6tTt61A5HDfgAQAgCJA6tI95as6XrWid4Sq7rgnR5jV+0CFqG3+rSEiIr+hCXL9VRbSRgPRgORwfPnYIER5cUB1Y0SHKtFOG4RcXTXiNIH1BtXaMUQMRERERDdEE+zafdTWxhA5G9Ix0ttNcJtEIsGap4bhRIEeXWPV9Va1HCFJ7wNdZgxERETUql09nqYtzTJr7cJUimuGOI4hIiIiaibqwKsrRAxErYXah7rMGIiIiKhVu7pC1FbHELVFnHZPRETUTOp0mbXhMURtjS8tzMhARERErZr66goRxxC1Gs4VIkEQvNoWBiIiImrVAuUBUMhqf51xDFHr4QizZquAc5crvBqKGIiIiKjVc94WQtsKVnEmG5UiAI7Z+BmLtsFkYSAiIiJqspfGdMEtnaLwzIg0RKsDvd0ccpNEIsFd/dpDKZNCKfNuJJEI3u60ayX0ej00Gg3KysqgVqu93RwiIiJyg7u/v1khIiIiIr/HQERERER+j4GIiIiI/B4DEREREfk9BiIiIiLyewxERERE5PcYiIiIiMjvMRARERGR32MgIiIiIr/HQERERER+j4GIiIiI/B4DEREREfk9BiIiIiLyewxERERE5Pdk3m5AayEIAgBAr9d7uSVERETkLsfvbcfv8YYwELmpvLwcAJCQkODllhAREVFjlZeXQ6PRNHheIlwvMhEAwGq1Ii8vD6GhoZBIJM12X71ej4SEBOTk5ECtVjfbfckVn3PL4HNuOXzWLYPPuWV48jkLgoDy8nLEx8dDKm14pBArRG6SSqVo3769x+6vVqv5f7YWwOfcMvicWw6fdcvgc24ZnnrO16oMOXBQNREREfk9BiIiIiLyewxEXqZUKvHqq69CqVR6uyltGp9zy+Bzbjl81i2Dz7ll+MJz5qBqIiIi8nusEBEREZHfYyAiIiIiv8dARERERH6PgYiIiIj8HgORl33wwQdITk5GYGAgBg0ahL1793q7Sa3Ktm3bMG7cOMTHx0MikWDVqlUu5wVBwLx58xAXF4egoCBkZGTgzJkzLteUlJRgypQpUKvV0Gq1mD59OioqKlrwU/i2BQsWYODAgQgNDUV0dDQmTpyIU6dOuVxTU1ODmTNnIiIiAiEhIbj77rtRWFjock12djbuvPNOBAcHIzo6GrNnz4bZbG7Jj+LzlixZgl69eomL06Wnp2Pt2rXieT7n5vfmm29CIpHg2WefFY/xOTeP+fPnQyKRuHx16dJFPO9zz1kgr/n6668FhUIhfPLJJ8KxY8eExx57TNBqtUJhYaG3m9Zq/Pjjj8Kf/vQnYcWKFQIAYeXKlS7n33zzTUGj0QirVq0SDh06JIwfP15ISUkRqqurxWtGjx4t9O7dW9i9e7ewfft2ITU1VXjggQda+JP4rlGjRgmffvqpcPToUSEzM1MYO3askJiYKFRUVIjX/P73vxcSEhKEjRs3Cvv37xcGDx4sDBkyRDxvNpuFHj16CBkZGcLBgweFH3/8UYiMjBRefvllb3wkn/X9998LP/zwg3D69Gnh1KlTwh//+EdBLpcLR48eFQSBz7m57d27V0hOThZ69eolPPPMM+JxPufm8eqrrwrdu3cX8vPzxa/Lly+L533tOTMQedFNN90kzJw5U3xtsViE+Ph4YcGCBV5sVet1dSCyWq1CbGys8Le//U08ptPpBKVSKXz11VeCIAjC8ePHBQDCvn37xGvWrl0rSCQSITc3t8Xa3poUFRUJAIStW7cKgmB7pnK5XPjPf/4jXnPixAkBgLBr1y5BEGzBVSqVCgUFBeI1S5YsEdRqtWAwGFr2A7QyYWFhwscff8zn3MzKy8uFtLQ0YcOGDcItt9wiBiI+5+bz6quvCr179673nC8+Z3aZeYnRaMSBAweQkZEhHpNKpcjIyMCuXbu82LK2IysrCwUFBS7PWKPRYNCgQeIz3rVrF7RaLQYMGCBek5GRAalUij179rR4m1uDsrIyAEB4eDgA4MCBAzCZTC7PuUuXLkhMTHR5zj179kRMTIx4zahRo6DX63Hs2LEWbH3rYbFY8PXXX6OyshLp6el8zs1s5syZuPPOO12eJ8C/z83tzJkziI+PR4cOHTBlyhRkZ2cD8M3nzM1dveTKlSuwWCwuf9AAEBMTg5MnT3qpVW1LQUEBANT7jB3nCgoKEB0d7XJeJpMhPDxcvIZqWa1WPPvssxg6dCh69OgBwPYMFQoFtFqty7VXP+f6/hwc56jWkSNHkJ6ejpqaGoSEhGDlypXo1q0bMjMz+Zybyddff41ff/0V+/btq3OOf5+bz6BBg7Bs2TJ07twZ+fn5eO2113DzzTfj6NGjPvmcGYiIyG0zZ87E0aNHsWPHDm83pc3q3LkzMjMzUVZWhu+++w5Tp07F1q1bvd2sNiMnJwfPPPMMNmzYgMDAQG83p00bM2aM+H2vXr0waNAgJCUl4dtvv0VQUJAXW1Y/dpl5SWRkJAICAuqMqC8sLERsbKyXWtW2OJ7jtZ5xbGwsioqKXM6bzWaUlJTwz+Eqs2bNwpo1a7B582a0b99ePB4bGwuj0QidTudy/dXPub4/B8c5qqVQKJCamor+/ftjwYIF6N27NxYvXszn3EwOHDiAoqIi9OvXDzKZDDKZDFu3bsV7770HmUyGmJgYPmcP0Wq16NSpE86ePeuTf58ZiLxEoVCgf//+2Lhxo3jMarVi48aNSE9P92LL2o6UlBTExsa6PGO9Xo89e/aIzzg9PR06nQ4HDhwQr9m0aROsVisGDRrU4m32RYIgYNasWVi5ciU2bdqElJQUl/P9+/eHXC53ec6nTp1Cdna2y3M+cuSIS/jcsGED1Go1unXr1jIfpJWyWq0wGAx8zs1kxIgROHLkCDIzM8WvAQMGYMqUKeL3fM6eUVFRgXPnziEuLs43/z43+zBtctvXX38tKJVKYdmyZcLx48eFGTNmCFqt1mVEPV1beXm5cPDgQeHgwYMCAGHRokXCwYMHhYsXLwqCYJt2r9Vqhf/973/C4cOHhQkTJtQ77b5v377Cnj17hB07dghpaWmcdu/kiSeeEDQajbBlyxaX6bNVVVXiNb///e+FxMREYdOmTcL+/fuF9PR0IT09XTzvmD47cuRIITMzU1i3bp0QFRXFacpXeemll4StW7cKWVlZwuHDh4WXXnpJkEgkwvr16wVB4HP2FOdZZoLA59xcXnjhBWHLli1CVlaWsHPnTiEjI0OIjIwUioqKBEHwvefMQORl77//vpCYmCgoFArhpptuEnbv3u3tJrUqmzdvFgDU+Zo6daogCLap93PnzhViYmIEpVIpjBgxQjh16pTLPYqLi4UHHnhACAkJEdRqtTBt2jShvLzcC5/GN9X3fAEIn376qXhNdXW18OSTTwphYWFCcHCwMGnSJCE/P9/lPhcuXBDGjBkjBAUFCZGRkcILL7wgmEymFv40vu3RRx8VkpKSBIVCIURFRQkjRowQw5Ag8Dl7ytWBiM+5edx///1CXFycoFAohHbt2gn333+/cPbsWfG8rz1niSAIQvPXnYiIiIhaD44hIiIiIr/HQERERER+j4GIiIiI/B4DEREREfk9BiIiIiLyewxERERE5PcYiIiIiMjvMRARERGR32MgIiJqRsuWLYNWq/V2M4iokRiIiMgrCgoK8MwzzyA1NRWBgYGIiYnB0KFDsWTJElRVVXm7eW5JTk7Gu+++63Ls/vvvx+nTp73TICJqMpm3G0BE/uf8+fMYOnQotFot/vrXv6Jnz55QKpU4cuQIPvroI7Rr1w7jx4/3StsEQYDFYoFM1rR/HoOCghAUFNTMrSIiT2OFiIha3JNPPgmZTIb9+/fjvvvuQ9euXdGhQwdMmDABP/zwA8aNGwcA0Ol0+N3vfoeoqCio1WrcfvvtOHTokHif+fPno0+fPvjiiy+QnJwMjUaDyZMno7y8XLzGarViwYIFSElJQVBQEHr37o3vvvtOPL9lyxZIJBKsXbsW/fv3h1KpxI4dO3Du3DlMmDABMTExCAkJwcCBA/Hzzz+L77v11ltx8eJFPPfcc5BIJJBIJADq7zJbsmQJOnbsCIVCgc6dO+OLL75wOS+RSPDxxx9j0qRJCA4ORlpaGr7//vtme95EdH0MRETUooqLi7F+/XrMnDkTKpWq3msc4eLee+9FUVER1q5diwMHDqBfv34YMWIESkpKxGvPnTuHVatWYc2aNVizZg22bt2KN998Uzy/YMECfP7551i6dCmOHTuG5557Dr/97W+xdetWl5/50ksv4c0338SJEyfQq1cvVFRUYOzYsdi4cSMOHjyI0aNHY9y4ccjOzgYArFixAu3bt8frr7+O/Px85Ofn1/tZVq5ciWeeeQYvvPACjh49iscffxzTpk3D5s2bXa577bXXcN999+Hw4cMYO3YspkyZ4vI5icjDBCKiFrR7924BgLBixQqX4xEREYJKpRJUKpXwhz/8Qdi+fbugVquFmpoal+s6duwo/OMf/xAEQRBeffVVITg4WNDr9eL52bNnC4MGDRIEQRBqamqE4OBg4ZdffnG5x/Tp04UHHnhAEARB2Lx5swBAWLVq1XXb3r17d+H9998XXyclJQnvvPOOyzWffvqpoNFoxNdDhgwRHnvsMZdr7r33XmHs2LHiawDCK6+8Ir6uqKgQAAhr1669bpuIqHlwDBER+YS9e/fCarViypQpMBgMOHToECoqKhAREeFyXXV1Nc6dOye+Tk5ORmhoqPg6Li4ORUVFAICzZ8+iqqoKd9xxh8s9jEYj+vbt63JswIABLq8rKiowf/58/PDDD8jPz4fZbEZ1dbVYIXLXiRMnMGPGDJdjQ4cOxeLFi12O9erVS/xepVJBrVaLn4OIPI+BiIhaVGpqKiQSCU6dOuVyvEOHDgAgDkiuqKhAXFwctmzZUucezmN05HK5yzmJRAKr1SreAwB++OEHtGvXzuU6pVLp8vrq7rsXX3wRGzZswNtvv43U1FQEBQXhnnvugdFodPOTNs61PgcReR4DERG1qIiICNxxxx34+9//jqeeeqrBcUT9+vVDQUEBZDIZkpOTm/SzunXrBqVSiezsbNxyyy2Neu/OnTvxyCOPYNKkSQBs4erChQsu1ygUClgslmvep2vXrti5cyemTp3qcu9u3bo1qj1E5FkMRETU4j788EMMHToUAwYMwPz589GrVy9IpVLs27cPJ0+eRP/+/ZGRkYH09HRMnDgRCxcuRKdOnZCXl4cffvgBkyZNqtPFVZ/Q0FC8+OKLeO6552C1WjFs2DCUlZVh586dUKvVLiHlamlpaVixYgXGjRsHiUSCuXPn1qnYJCcnY9u2bZg8eTKUSiUiIyPr3Gf27Nm477770LdvX2RkZGD16tVYsWKFy4w1IvI+BiIianEdO3bEwYMH8de//hUvv/wyLl26BKVSiW7duuHFF1/Ek08+CYlEgh9//BF/+tOfMG3aNFy+fBmxsbEYPnw4YmJi3P5Zf/7znxEVFYUFCxbg/Pnz0Gq16NevH/74xz9e832LFi3Co48+iiFDhiAyMhJz5syBXq93ueb111/H448/jo4dO8JgMEAQhDr3mThxIhYvXoy3334bzzzzDFJSUvDpp5/i1ltvdfszEJHnSYT6/h9MRERE5Ee4DhERERH5PQYiIiIi8nsMREREROT3GIiIiIjI7zEQERERkd9jICIiIiK/x0BEREREfo+BiIiIiPweAxERERH5PQYiIiIi8nsMREREROT3/h+2kyFWwFtb1QAAAABJRU5ErkJggg==",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "geneticAlgorithmPlot(population = cityList, populationSize = 250, eliteSize = 20, mutationRate = 0.01, generations = 500)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Well, we can see how the distance improved in each generation!!"
   ]
  }
 ],
 "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.10.11"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}