3. Landmark Detection and Tracking.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Project 3:  Implement SLAM \n",
    "\n",
    "---\n",
    "\n",
    "## Project Overview\n",
    "\n",
    "In this project, you'll implement SLAM for robot that moves and senses in a 2 dimensional, grid world!\n",
    "\n",
    "SLAM gives us a way to both localize a robot and build up a map of its environment as a robot moves and senses in real-time. This is an active area of research in the fields of robotics and autonomous systems. Since this localization and map-building relies on the visual sensing of landmarks, this is a computer vision problem. \n",
    "\n",
    "Using what you've learned about robot motion, representations of uncertainty in motion and sensing, and localization techniques, you will be tasked with defining a function, `slam`, which takes in six parameters as input and returns the vector `mu`. \n",
    "> `mu` contains the (x,y) coordinate locations of the robot as it moves, and the positions of landmarks that it senses in the world\n",
    "\n",
    "You can implement helper functions as you see fit, but your function must return `mu`. The vector, `mu`, should have (x, y) coordinates interlaced, for example, if there were 2 poses and 2 landmarks, `mu` will look like the following, where `P` is the robot position and `L` the landmark position:\n",
    "```\n",
    "mu =  matrix([[Px0],\n",
    "              [Py0],\n",
    "              [Px1],\n",
    "              [Py1],\n",
    "              [Lx0],\n",
    "              [Ly0],\n",
    "              [Lx1],\n",
    "              [Ly1]])\n",
    "```\n",
    "\n",
    "You can see that `mu` holds the poses first `(x0, y0), (x1, y1), ...,` then the landmark locations at the end of the matrix; we consider a `nx1` matrix to be a vector.\n",
    "\n",
    "## Generating an environment\n",
    "\n",
    "In a real SLAM problem, you may be given a map that contains information about landmark locations, and in this example, we will make our own data using the `make_data` function, which generates a world grid with landmarks in it and then generates data by placing a robot in that world and moving and sensing over some numer of time steps. The `make_data` function relies on a correct implementation of robot move/sense functions, which, at this point, should be complete and in the `robot_class.py` file. The data is collected as an instantiated robot moves and senses in a world. Your SLAM function will take in this data as input. So, let's first create this data and explore how it represents the movement and sensor measurements that our robot takes.\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Create the world\n",
    "\n",
    "Use the code below to generate a world of a specified size with randomly generated landmark locations. You can change these parameters and see how your implementation of SLAM responds! \n",
    "\n",
    "`data` holds the sensors measurements and motion of your robot over time. It stores the measurements as `data[i][0]` and the motion as `data[i][1]`.\n",
    "\n",
    "#### Helper functions\n",
    "\n",
    "You will be working with the `robot` class that may look familiar from the first notebook, \n",
    "\n",
    "In fact, in the `helpers.py` file, you can read the details of how data is made with the `make_data` function. It should look very similar to the robot move/sense cycle you've seen in the first notebook."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " \n",
      "Landmarks:  [[65, 88], [79, 84], [83, 12], [73, 52], [12, 79]]\n",
      "Robot: [x=80.63065 y=94.11884]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "from helpers import make_data\n",
    "\n",
    "# your implementation of slam should work with the following inputs\n",
    "# feel free to change these input values and see how it responds!\n",
    "\n",
    "# world parameters\n",
    "num_landmarks      = 5        # number of landmarks\n",
    "N                  = 20       # time steps\n",
    "world_size         = 100.0    # size of world (square)\n",
    "\n",
    "# robot parameters\n",
    "measurement_range  = 50.0     # range at which we can sense landmarks\n",
    "motion_noise       = 2.0      # noise in robot motion\n",
    "measurement_noise  = 2.0      # noise in the measurements\n",
    "distance           = 20.0     # distance by which robot (intends to) move each iteratation \n",
    "\n",
    "\n",
    "# make_data instantiates a robot, AND generates random landmarks for a given world size and number of landmarks\n",
    "data = make_data(N, num_landmarks, world_size, measurement_range, motion_noise, measurement_noise, distance)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### A note on `make_data`\n",
    "\n",
    "The function above, `make_data`, takes in so many world and robot motion/sensor parameters because it is responsible for:\n",
    "1. Instantiating a robot (using the robot class)\n",
    "2. Creating a grid world with landmarks in it\n",
    "\n",
    "**This function also prints out the true location of landmarks and the *final* robot location, which you should refer back to when you test your implementation of SLAM.**\n",
    "\n",
    "The `data` this returns is an array that holds information about **robot sensor measurements** and **robot motion** `(dx, dy)` that is collected over a number of time steps, `N`. You will have to use *only* these readings about motion and measurements to track a robot over time and find the determine the location of the landmarks using SLAM. We only print out the true landmark locations for comparison, later.\n",
    "\n",
    "\n",
    "In `data` the measurement and motion data can be accessed from the first and second index in the columns of the data array. See the following code for an example, where `i` is the time step:\n",
    "```\n",
    "measurement = data[i][0]\n",
    "motion = data[i][1]\n",
    "```\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Example measurements: \n",
      " [[0, 14.645449622420989, 38.38899611929795], [1, 29.50162473843008, 34.1330526266597], [2, 31.20586178575541, -38.42037787241423], [3, 23.959061131942413, 3.8159377072329135], [4, -36.90740900002001, 30.09939844517981]]\n",
      "\n",
      "\n",
      "Example motion: \n",
      " [-16.949389555796703, 10.616882484319474]\n"
     ]
    }
   ],
   "source": [
    "# print out some stats about the data\n",
    "time_step = 0\n",
    "\n",
    "print('Example measurements: \\n', data[time_step][0])\n",
    "print('\\n')\n",
    "print('Example motion: \\n', data[time_step][1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Try changing the value of `time_step`, you should see that the list of measurements varies based on what in the world the robot sees after it moves. As you know from the first notebook, the robot can only sense so far and with a certain amount of accuracy in the measure of distance between its location and the location of landmarks. The motion of the robot always is a vector with two values: one for x and one for y displacement. This structure will be useful to keep in mind as you traverse this data in your implementation of slam."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Initialize Constraints\n",
    "\n",
    "One of the most challenging tasks here will be to create and modify the constraint matrix and vector: omega and xi. In the second notebook, you saw an example of how omega and xi could hold all the values the define the relationships between robot poses `xi` and landmark positions `Li` in a 1D world, as seen below, where omega is the blue matrix and xi is the pink vector.\n",
    "\n",
    "<img src='images/motion_constraint.png' width=50% height=50% />\n",
    "\n",
    "\n",
    "In *this* project, you are tasked with implementing constraints for a 2D world. We are referring to robot poses as `Px, Py` and landmark positions as `Lx, Ly`, and one way to approach this challenge is to add *both* x and y locations in the constraint matrices.\n",
    "\n",
    "<img src='images/constraints2D.png' width=50% height=50% />\n",
    "\n",
    "You may also choose to create two of each omega and xi (one for x and one for y positions)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### TODO: Write a function that initializes omega and xi\n",
    "\n",
    "Complete the function `initialize_constraints` so that it returns `omega` and `xi` constraints for the starting position of the robot. Any values that we do not yet know should be initialized with the value `0`. You may assume that our robot starts out in exactly the middle of the world with 100% confidence (no motion or measurement noise at this point). The inputs `N` time steps, `num_landmarks`, and `world_size` should give you all the information you need to construct intial constraints of the correct size and starting values.\n",
    "\n",
    "*Depending on your approach you may choose to return one omega and one xi that hold all (x,y) positions *or* two of each (one for x values and one for y); choose whichever makes most sense to you!*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def initialize_constraints(N, num_landmarks, world_size):\n",
    "    ''' This function takes in a number of time steps N, number of landmarks, and a world_size,\n",
    "        and returns initialized constraint matrices, omega and xi.'''\n",
    "    \n",
    "    ## Recommended: Define and store the size (rows/cols) of the constraint matrix in a variable\n",
    "    \n",
    "    ## TODO: Define the constraint matrix, Omega, with two initial \"strength\" values\n",
    "    ## for the initial x, y location of our robot\n",
    "    d = (N + num_landmarks) * 2 # because we are in a 2D world (x,y) we multiply by 2\n",
    "    omega = np.zeros((d, d))\n",
    "    omega[0][0] = 1\n",
    "    omega[1][1] = 1\n",
    "    \n",
    "    ## TODO: Define the constraint *vector*, xi\n",
    "    ## you can assume that the robot starts out in the middle of the world with 100% confidence\n",
    "    xi = np.zeros((d, 1))\n",
    "    xi[0] = world_size / 2.0 # initial position x in the center of the map\n",
    "    xi[1] = world_size / 2.0 # initial position y in the center of the map\n",
    "    \n",
    "    return omega, xi\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Test as you go\n",
    "\n",
    "It's good practice to test out your code, as you go. Since `slam` relies on creating and updating constraint matrices, `omega` and `xi` to account for robot sensor measurements and motion, let's check that they initialize as expected for any given parameters.\n",
    "\n",
    "Below, you'll find some test code that allows you to visualize the results of your function `initialize_constraints`. We are using the [seaborn](https://seaborn.pydata.org/) library for visualization.\n",
    "\n",
    "**Please change the test values of N, landmarks, and world_size and see the results**. Be careful not to use these values as input into your final smal function.\n",
    "\n",
    "This code assumes that you have created one of each constraint: `omega` and `xi`, but you can change and add to this code, accordingly. The constraints should vary in size with the number of time steps and landmarks as these values affect the number of poses a robot will take `(Px0,Py0,...Pxn,Pyn)` and landmark locations `(Lx0,Ly0,...Lxn,Lyn)` whose relationships should be tracked in the constraint matrices. Recall that `omega` holds the weights of each variable and `xi` holds the value of the sum of these variables, as seen in Notebook 2. You'll need the `world_size` to determine the starting pose of the robot in the world and fill in the initial values for `xi`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import data viz resources\n",
    "import matplotlib.pyplot as plt\n",
    "from pandas import DataFrame\n",
    "import seaborn as sns\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# define a small N and world_size (small for ease of visualization)\n",
    "N_test = 5\n",
    "num_landmarks_test = 2\n",
    "small_world = 10\n",
    "\n",
    "# initialize the constraints\n",
    "initial_omega, initial_xi = initialize_constraints(N_test, num_landmarks_test, small_world)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x7f3fcf3e6b38>"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f3fcf936da0>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# define figure size\n",
    "plt.rcParams[\"figure.figsize\"] = (10,7)\n",
    "\n",
    "# display omega\n",
    "sns.heatmap(DataFrame(initial_omega), cmap='Blues', annot=True, linewidths=.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x7f3fccdee278>"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f3fcd086160>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# define  figure size\n",
    "plt.rcParams[\"figure.figsize\"] = (1,7)\n",
    "\n",
    "# display xi\n",
    "sns.heatmap(DataFrame(initial_xi), cmap='Oranges', annot=True, linewidths=.5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## SLAM inputs \n",
    "\n",
    "In addition to `data`, your slam function will also take in:\n",
    "* N -   The number of time steps that a robot will be moving and sensing\n",
    "* num_landmarks - The number of landmarks in the world\n",
    "* world_size - The size (w/h) of your world\n",
    "* motion_noise - The noise associated with motion; the update confidence for motion should be `1.0/motion_noise`\n",
    "* measurement_noise - The noise associated with measurement/sensing; the update weight for measurement should be `1.0/measurement_noise`\n",
    "\n",
    "#### A note on noise\n",
    "\n",
    "Recall that `omega` holds the relative \"strengths\" or weights for each position variable, and you can update these weights by accessing the correct index in omega `omega[row][col]` and *adding/subtracting* `1.0/noise` where `noise` is measurement or motion noise. `Xi` holds actual position values, and so to update `xi` you'll do a similar addition process only using the actual value of a motion or measurement. So for a vector index `xi[row][0]` you will end up adding/subtracting one measurement or motion divided by their respective `noise`.\n",
    "\n",
    "### TODO: Implement Graph SLAM\n",
    "\n",
    "Follow the TODO's below to help you complete this slam implementation (these TODO's are in the recommended order), then test out your implementation! \n",
    "\n",
    "#### Updating with motion and measurements\n",
    "\n",
    "With a 2D omega and xi structure as shown above (in earlier cells), you'll have to be mindful about how you update the values in these constraint matrices to account for motion and measurement constraints in the x and y directions. Recall that the solution to these matrices (which holds all values for robot poses `P` and landmark locations `L`) is the vector, `mu`, which can be computed at the end of the construction of omega and xi as the inverse of omega times xi: $\\mu = \\Omega^{-1}\\xi$\n",
    "\n",
    "**You may also choose to return the values of `omega` and `xi` if you want to visualize their final state!**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "## TODO: Complete the code to implement SLAM\n",
    "\n",
    "## slam takes in 6 arguments and returns mu, \n",
    "## mu is the entire path traversed by a robot (all x,y poses) *and* all landmarks locations\n",
    "def slam(data, N, num_landmarks, world_size, motion_noise, measurement_noise):\n",
    "    \n",
    "    ## TODO: Use your initilization to create constraint matrices, omega and xi\n",
    "    omega, xi = initialize_constraints(N, num_landmarks, world_size)\n",
    "    \n",
    "    ## TODO: Iterate through each time step in the data\n",
    "    ## get all the motion and measurement data as you iterate\n",
    "    for idx, (measurement, motion)  in enumerate(data):\n",
    "        \n",
    "        for i in range(len(measurement)):\n",
    "            # get the landmark index\n",
    "            landmark = measurement[i][0]\n",
    "            \n",
    "            ## TODO: update the constraint matrix/vector to account for all *measurements*\n",
    "            ## this should be a series of additions that take into account the measurement noise  \n",
    "            \n",
    "            ## Update omega\n",
    "            # Px update\n",
    "            omega[idx * 2][idx * 2] += 1.0 / measurement_noise \n",
    "            omega[N*2 + landmark*2][N*2 + landmark*2] += 1.0 / measurement_noise \n",
    "            omega[idx * 2][N*2 + landmark*2] += -1.0 / measurement_noise \n",
    "            omega[N*2 + landmark*2][idx * 2] += -1.0 / measurement_noise \n",
    "            \n",
    "            # Py update\n",
    "            omega[idx*2 +1][idx*2 + 1] += 1.0 / measurement_noise \n",
    "            omega[N*2 + landmark*2 +1][N*2 + landmark*2 + 1] += 1.0 / measurement_noise\n",
    "            omega[idx*2 + 1][N*2 + landmark*2 + 1] += -1.0 / measurement_noise \n",
    "            omega[N*2 + landmark*2 + 1][idx*2 + 1] += -1.0 / measurement_noise \n",
    "            \n",
    "            ## Update xi\n",
    "            # Px update\n",
    "            xi[idx * 2] += -measurement[i][1] / measurement_noise\n",
    "            xi[N*2 + landmark*2] += measurement[i][1] / measurement_noise\n",
    "            \n",
    "            # Py update\n",
    "            xi[idx*2 + 1] += -measurement[i][2] / measurement_noise\n",
    "            xi[N*2 + landmark*2 + 1] += measurement[i][2] / measurement_noise\n",
    "            \n",
    "        ## TODO: update the constraint matrix/vector to account for all *motion* and motion noise\n",
    "        ## Update omega\n",
    "        # Px update\n",
    "        omega[idx * 2][idx * 2] += 1.0 / motion_noise\n",
    "        omega[idx * 2][(idx+1) * 2] += -1.0 / motion_noise\n",
    "        omega[(idx+1) * 2][(idx+1) * 2] += 1.0 / motion_noise\n",
    "        omega[(idx+1) * 2][idx * 2] += -1.0 / motion_noise\n",
    "\n",
    "        # Py update\n",
    "        omega[idx*2 + 1][idx*2 + 1] += 1.0 / motion_noise\n",
    "        omega[idx*2 + 1][(idx+1)*2 + 1] += -1.0 / motion_noise\n",
    "        omega[(idx+1) * 2 + 1][(idx+1) * 2 + 1] += 1.0 / motion_noise\n",
    "        omega[(idx+1)*2 + 1][idx*2 + 1] += -1.0 / motion_noise\n",
    "\n",
    "\n",
    "        ## Update xi\n",
    "        # Px update\n",
    "        xi[idx * 2] += -motion[0] / motion_noise\n",
    "        xi[(idx+1) * 2] += motion[0] / motion_noise\n",
    "\n",
    "        # Py update\n",
    "        xi[idx*2 + 1] += -motion[1] / motion_noise\n",
    "        xi[(idx+1) * 2 + 1] += motion[1] / motion_noise\n",
    "    \n",
    "    \n",
    "    ## TODO: After iterating through all the data\n",
    "    ## Compute the best estimate of poses and landmark positions\n",
    "    ## using the formula, omega_inverse * Xi\n",
    "    mu = np.linalg.inv(np.matrix(omega)) * xi\n",
    "    \n",
    "    return mu, omega, xi # return `mu`\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Helper functions\n",
    "\n",
    "To check that your implementation of SLAM works for various inputs, we have provided two helper functions that will help display the estimated pose and landmark locations that your function has produced. First, given a result `mu` and number of time steps, `N`, we define a function that extracts the poses and landmarks locations and returns those as their own, separate lists. \n",
    "\n",
    "Then, we define a function that nicely print out these lists; both of these we will call, in the next step.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# a helper function that creates a list of poses and of landmarks for ease of printing\n",
    "# this only works for the suggested constraint architecture of interlaced x,y poses\n",
    "def get_poses_landmarks(mu, N):\n",
    "    # create a list of poses\n",
    "    poses = []\n",
    "    for i in range(N):\n",
    "        poses.append((mu[2*i].item(), mu[2*i+1].item()))\n",
    "\n",
    "    # create a list of landmarks\n",
    "    landmarks = []\n",
    "    for i in range(num_landmarks):\n",
    "        landmarks.append((mu[2*(N+i)].item(), mu[2*(N+i)+1].item()))\n",
    "\n",
    "    # return completed lists\n",
    "    return poses, landmarks\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def print_all(poses, landmarks):\n",
    "    print('\\n')\n",
    "    print('Estimated Poses:')\n",
    "    for i in range(len(poses)):\n",
    "        print('['+', '.join('%.3f'%p for p in poses[i])+']')\n",
    "    print('\\n')\n",
    "    print('Estimated Landmarks:')\n",
    "    for i in range(len(landmarks)):\n",
    "        print('['+', '.join('%.3f'%l for l in landmarks[i])+']')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Run SLAM\n",
    "\n",
    "Once you've completed your implementation of `slam`, see what `mu` it returns for different world sizes and different landmarks!\n",
    "\n",
    "### What to Expect\n",
    "\n",
    "The `data` that is generated is random, but you did specify the number, `N`, or time steps that the robot was expected to move and the `num_landmarks` in the world (which your implementation of `slam` should see and estimate a position for. Your robot should also start with an estimated pose in the very center of your square world, whose size is defined by `world_size`.\n",
    "\n",
    "With these values in mind, you should expect to see a result that displays two lists:\n",
    "1. **Estimated poses**, a list of (x, y) pairs that is exactly `N` in length since this is how many motions your robot has taken. The very first pose should be the center of your world, i.e. `[50.000, 50.000]` for a world that is 100.0 in square size.\n",
    "2. **Estimated landmarks**, a list of landmark positions (x, y) that is exactly `num_landmarks` in length. \n",
    "\n",
    "#### Landmark Locations\n",
    "\n",
    "If you refer back to the printout of *exact* landmark locations when this data was created, you should see values that are very similar to those coordinates, but not quite (since `slam` must account for noise in motion and measurement)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "Estimated Poses:\n",
      "[50.000, 50.000]\n",
      "[34.040, 61.075]\n",
      "[17.483, 72.318]\n",
      "[18.368, 92.686]\n",
      "[22.353, 72.483]\n",
      "[23.861, 54.115]\n",
      "[27.638, 35.424]\n",
      "[31.756, 15.050]\n",
      "[24.190, 34.211]\n",
      "[15.851, 52.174]\n",
      "[7.255, 69.197]\n",
      "[9.541, 48.457]\n",
      "[10.706, 29.119]\n",
      "[12.234, 8.574]\n",
      "[22.211, 25.018]\n",
      "[31.142, 41.699]\n",
      "[41.781, 58.639]\n",
      "[51.588, 74.692]\n",
      "[59.755, 90.640]\n",
      "[79.326, 94.760]\n",
      "\n",
      "\n",
      "Estimated Landmarks:\n",
      "[65.121, 88.592]\n",
      "[79.169, 83.557]\n",
      "[82.022, 12.778]\n",
      "[72.877, 52.681]\n",
      "[12.226, 79.951]\n"
     ]
    }
   ],
   "source": [
    "# call your implementation of slam, passing in the necessary parameters\n",
    "mu ,_ ,_ = slam(data, N, num_landmarks, world_size, motion_noise, measurement_noise)\n",
    "\n",
    "# print out the resulting landmarks and poses\n",
    "if(mu is not None):\n",
    "    # get the lists of poses and landmarks\n",
    "    # and print them out\n",
    "    poses, landmarks = get_poses_landmarks(mu, N)\n",
    "    print_all(poses, landmarks)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Visualize the constructed world\n",
    "\n",
    "Finally, using the `display_world` code from the `helpers.py` file (which was also used in the first notebook), we can actually visualize what you have coded with `slam`: the final position of the robot and the positon of landmarks, created from only motion and measurement data!\n",
    "\n",
    "**Note that these should be very similar to the printed *true* landmark locations and final pose from our call to `make_data` early in this notebook.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Last pose:  (79.32642489488373, 94.76009188051614)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f3fccfeb2e8>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# import the helper function\n",
    "from helpers import display_world\n",
    "\n",
    "# Display the final world!\n",
    "\n",
    "# define figure size\n",
    "plt.rcParams[\"figure.figsize\"] = (20,20)\n",
    "\n",
    "# check if poses has been created\n",
    "if 'poses' in locals():\n",
    "    # print out the last pose\n",
    "    print('Last pose: ', poses[-1])\n",
    "    # display the last position of the robot *and* the landmark positions\n",
    "    display_world(int(world_size), poses[-1], landmarks)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x7f3fccbfc048>"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f3fccc120b8>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "mu, omega, xi = slam(data, N, num_landmarks, world_size, motion_noise, measurement_noise)\n",
    "\n",
    "plt.rcParams[\"figure.figsize\"] = (20,20)\n",
    "sns.heatmap(DataFrame(omega).astype(int), cmap='Blues', annot=True, linewidths=.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAHIAAAGZCAYAAABVKWWIAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4wLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvpW3flQAAIABJREFUeJzsnXdYU1cbwH8Jey9ZbkVx4qirdYtgtdYq4izaalXaat2j4qp71aptbd3Vz1HbKo66ByqIIq5WHLgQRJGhyN5J7vdH2ggFEiCJBPX3PHme5N5z73n15dx7zruOSBAEgbdUeMTlLcBbNMNbRb4mvFXka8JbRb4mvFXka8JbRb4m6Je3AEURGxvLtGnTeP78OWKxmAEDBvDpp58yYcIEIiMjAUhLS8PCwoIDBw6Us7Q6gqCDxMfHCzdv3hQEQRDS0tKEbt26Cffv3y/QZsmSJcKPP/5YHuLpJCJBUG4QiIiIICAggISEBAAcHBzo2rUrLi4uxV4j2zpQo39sY/Y85OMW9rSrZQGAIAi4/3SbLR/Xoaatkdr3Fw/7Xe17lDdK35EbNmxg0qRJALi5ueHm5gbApEmT2LBhg/alA2KScwiPz6JpZVPFsSuPM7Az09eIEl8XlL4j/f39OXToEAYGBgWODxs2jA8//BBfX1+tCpeRK2Xcviime1TB3EhPcfzw7SR6NrTRat8VDaUjUiQSKR6p+Xn27BkikUhrQgHkSQXG742iVyMbutWzVhyXyARO3U2hRwNrJVe/eSgdkTNmzGDYsGHUqFEDZ2dnAJ4+fUp0dDSzZ8/WmlCCIDDrSDS17YwY1tqhwLmQyDRq2RnhZGmotf4rIkoV2bFjR44fP05YWBjx8fEIgoCTkxNubm7o6ekpu1Qtrj3J4M+bSbjaG+O1+Q4AEzpVplMdS46Ev32sFoXKWWt54efnx9mzZ7Gzs+PQoUMAHD16lDVr1hAREcHu3bsVk6+3aEmRMv8v1L7H5chkTA31mL47nIMTWgMQkZCBWCTim/13mdbDhcZVLdXuB0DsvU4j9ylPdNKyA9CqljUxSVkFjrk4mJWTNLrPW1vra8JbRb4mvFXka8JbRb4m6Ozyo3fv3ty/fx+pVIqenh4ymYylS5eycuVKnj9/jiAIGBoaMmbMGK2bCisE5eN0KR0BAQHC0KFDBUEQBIlEInTt2lWIjo4WcnJyhF69ehVycb2JaGX5IUSf1+j9Dv2xlZ5t6yNEn+f67QdUd7CkqhANcdF80K4xp/x/wWVwzzLfX1S9nQalLR9UviMjIiIICQkhIyOjwPGgoCCtCZWfrOwcgq/cpFv7FgDEP0/G2d5Wcd6pkg3xz5NeiSy6jFJFbtu2jdGjR7N9+3Z69erFqVOnFOdWrVqldeEAzly8TvNGdbC2NJcfKOKVrm1PTEVA6aN19+7d7N27FzMzM548ecK4ceOIiYnh008/RdDCHGnngQB2H5GP9PWLJuBYyYYjZ0Pp2aWNoo2jvQ2xz14ofsc9T8LB7q1LS6kipVIpZmZys1jVqlXZvn0748aN4+nTp1pRpE/vrvj07qr4nZaRyeWweyz/+uWs1K1eLR7FxPMk9hkO/yh6hd/nGpeloqH00VqpUiXCw8MVv83MzFi/fj1JSUncu3dP68KdDL5GuxaNMDV5GdKhr6fH7K+GMMJvJT1HzKRHx1bUrVlF67LoOkrXkXFxcejp6WFvb1/o3NWrV2nRooXWBAsNDWXx4sVIJBJsbGzYsWNHoTaTJ0/m5s2bGBgY4Obmxvz58wuFpbwpaMeNdVy96IHUzFw+XnWaDV92oLKtGYlp2dhZGBdqF3grlo4NnQCY8r+LtHSxZ3CHOqXuT/z+ArXk1QV00o116Go0Hk2rUNlW/n4uSokAnRo5K7671bAlPiWryHZvAjppa41KSCM1M5dPfjiD9/KT7L8UpbR9nlTGn5cf0b6B06sRUAfRyREplQncepzElq86k5MnZdCqAJrWtKOWg0WR7ef/cZWWLva0dCn8Ln9T0BlF7gy6z54QeV5H9+ZV6dDACVMjfUyN9GnpYs/dmOQiFfnT0Vskpecwb0TLVy2yTqEzivTpWBefjnUBiIhLZeGea0ikMvKkMsIeJfJpZ9dC1+y+8JDg8Di2fNUJsfjNtu7orBtr06ZN7N27F7FYTL9+/Rg2bBgAo0aNYuHChTg6OtKwYUMqV66sMFp4enry1VdflaPU5YfOKrIk68gdO3bwv//9j+joaEJCQrC1tS3iTm8GFXodeftxElamhnzy4xn2TPHExrxsST2vwzqy1MuPadOmaUOOApR0Hdmwmg1V7N6GSIKKyc4XXxQONA4NDVUcX7dOO4G9UQlpSKQyPvnhDBnZEoZ2rkuf1jW10tfrglJFxsfH4+LiQv/+/RGJRAiCwM2bN/nss8+0KlRp15FvUfFo9ff3p3Hjxqxbtw4LCwvatGmDkZERrVu3pnXr1hoVZGfQfbyWncBr2QkcrIwV60gbcyPFOvItxaN0RIrFYoYNG0b37t1ZvHgxlSpVQiqVakWQsqwj35KP0kRqnTlzRvjuu+80GPtVNKmpqUKPHj2Exo0bC40bNxYmTpyoODdy5EghLi5OEARB+N///id06NBBcHV1FRo0aCDMmDFD67LpKjq5jly3bh1paWlMnTqVFy9e0L17d4KDgzE0LJzceuLECY4fP87du3cV6XdvIlox0clOzlXvBg9ukZ6cifREOumJGVgZSBGfWYTsP2a4jJw8tvx0lnmDWzPxakKZ+xV7qimvDqAzttb8+HRyZfT6IDrO3E9mtoTvPmtbpC31h0M3GNa1PiaG2suerijopD8yODyW+lVtCFrUh71+3Vm4+yrpWXkF2oQ/SSL6WRqeTauVk5S6hc6MyJ2B99hzIQIAS1NDxvZ0QyQSUcPegqp2ZjyMT6VJTTtF+78jn3MrOomuc/5EKpPxIi2HT1YHsG1C1+K6eK3RGUX6dHLFp5N8iTH3t8tcvBtPyzoOPE/NIjI+jWqVzAu0H9yhLoM7yJcrMYnpfLEu6I1VIujoo3V090b8FfmcjxYdYfiPZ5jcu6nCIO615Gg5S6eb6OTyA+DPP/9k48aNgDyedu7cudSvX7/YypFvOtpxY134Xu17/HU/ltqVbbAyMyYo7BE/HbjM77P7kZCcwbPkTBrVtCcjKxfvebtZM7YHdaqU3RcpbjtebXnLG6XvyOvXr+Pi4oK5uTnZ2dls2LCB27dv4+LiwhdffIGFhfaM2M3rvgx1bOriSNwLeTaYg7UZDtZy15WZiSEuzjbEJ2eopcjXAaXvyBkzZmBsLPcFLlq0iLS0NEaOHImJiQl+fn6vREAA/6BwOrhVL3Q85nkq4dHPaVrb8ZXJoqsoHZEymQx9fXmTmzdvsm/fPgBatmxJ7969tS8dEBoeg/+5cHbM6FvgeEZ2HuPWHGf64HaYm7ytS6d0RNatWxd/f38A6tevz40bNwCIjIxUKFiT7Ay4gdec3/Ga8zsJSRncffyc2VvOsGbcB9iYv4wSyJNIGb/mGL3eq0u3lsUXAH6TUDrZSUtLY9GiRVy5cgUbGxtu376Nk5MTzs7OzJo1i/r16xd5nSYmO08T0xi+/ABLR3Yt8L4UBIHpmwKwMjNmxsft1e4HXo/JTolmrenp6Tx58gSJRIKTkxOVKlXSqlCxsbH079+fxMRE9PX1sba2xt7ensWLFzN58mQePHiAmZkZlStXRk9Pj0mTJtGpUyetyqTzlJP7TCnFFafv27evEBoaKgiCIOzevVtYtWpVeYqpU2jHjbWlv1rXV/rnI7sEpkBt/RfEbvuKyHuPaHFzObJbIt5LzWXUH5GMs1K/goh4+G6171He6KSJLj8xybmEJ8iL09e1N+b0/VQAjt9JITYtT8XVbw46rUh5cfpHTO9aGXMjPRZ9UJVfryXiveU+GbkyDN7wfI/86Iz347/kSQXG73tEr0bWdKtnBUBtO2M2D6oNQOSLHAIjUstTRJ1CJ0ekIAjMOvKY2nbGDGv9MucxMUMCgEwQWHc+noHN7Iq7xRuHTo7Ia08y+fNWsrw4/S/y6iETOjnx6EUuv157DoBnPSv6NnlbpF5BeU+bVXH9+nWhfv36wtGjRxXH9u7dK3h6egqenp7C3r17y1E63UE7y48buzRyH6lUxooF22jXtDZCdDCyG0kkp2WyZuUGdi/zRSQS0W/aUjo7JWFlblLmfsRugzUib3mi9B2Zm5vL/v37uXDhAgAHDx5k/vz57Ny5k7w87U/9dxwNxbNNQ+ysXmZcnb8eQdumLlhbmGJlbkLbpi4E//1A67LoOkpHpJ+fH1KplOzsbPbt20dmZiaenp5cvHiRsLAwli1bpjXB4hNTOXXpDlu/+ZRZa2MKHHeye7lNhKOtJfGJb2evShV57949Dh48iEQioWPHjpw7dw49PT169+7NRx99pFXBlmw5xuQhHujpFXxoFGUYflsdUoUiBUEgNzeXrKwssrKySEtLw9ramtzcXCQSicaF2Xn0EnsCrgKQlpnD5FV7AEhOyyTo2n309MQ42Vly6VaU4pr4F6m0blRT47JUNJQqsl+/fvTo0QOZTMbEiRMZP3481apV4/r16/TsWfaKxcXh06M1Pj0Kp+v5rdlH5xaueLRuQHJaJqt+DSAlXV7l6vz1CCZ+/OaGQf6LUkUOGzaMHj16AODo6EifPn24cOECAwYMoEmTJq9EwP9ibWHKl94dGTBdvhHp6H6dsLYwVXHV649OhkMWFwr5X0JCQli+fDkymQxTU1OWLl1KjRo1XrW4OoF2wiGPqheY9VdkIrUdLbAyNSTodhw/HQvn90ldCrXrvugEP414FxcnS34NjuDGoySW+JS+Apa4xxK15NUFdNJE17zWSxtq05q2xBVT9VEEpGfLJ13pWRIcrIqu/vEmoJOKzI//xSg6NCg63HHBoHf4fMMFjA3EmBsb8NvEzq9WOB1CJ70f/xJ6/xn+Fx8xuVfjIs//L/AB633bcnbeB3i1qcHS/WGvWELdQWdG5M5zEewJiQJg/edtScrIZfZv11j/eVtszApXtHqRnsPdmBSa1pRHmPdoXhXfdZrdOKYioTOK9Onggk8HeYzq06RMxv1ykWVDWhZbW8fSxIC07DwiE9Ko5WDBhbsJ1HZ8c+vw6OTyY+bMmZw4cYLKlSuTlZXFo0eP+P777+nevTujRo2iXbt2/Prrr2RmZiIWi7G2tsbKyorFixdTrdobmsFcji40lUgkEmHo0KHCyJEjFf7IpKQkwd3dXUhKShKSk5MFd3d3ITk5uZwlLX902h+57VAIno3tuBkRo/BHngu+QdsGjlg+lie8tm3gSNCvy+jZvuw7oL/2/sjy5F831qBuLQsdf+vGKozOKvKtG6t0KH20pqWlsX79ek6dOkVSknxrP1tbW7p27Yqvry+WlpbKLi81b91YZUepIidMmECbNm3Yvn27YlulZ8+esW/fPsaPH8+WLVs0KsxbN1bZUarIJ0+esHnz5gLH7O3t8fX1VeRNvmreurGKRqkiq1SpwsaNG/Hy8lKk0j1//py9e/fi7Oxc7HWamAX+15VVq+MQxP+4sjKv5WJkEY4gCKRbNXwtZp3qotQgkJKSwoYNGwgICODFC/nmm3Z2dri7u+Pr64uVlVWR18kub1BbsL/uxVC7ip28qsf1SH7ae4Hf5/lw7/FzJv90iD/m+WCgr8eo5f58M9yDmk5lD1YWt6r4u6YrHZFWVlZMnTqVqVOnFjrn7++Pt7e31gRr7vpyT8imdZyJe5EOwMOniTR1ccbESL69YKv6VTl15T4jP9RsReeKRpmXHz/++KMm5VCK/9kbdGhSE4C6VStx5W4MSWlZZOXkEXQ9krjEtFcmi66idET26tWr2HPPnz/XuDBFEXo7Gv/Am+yYPQgAlyp2jPywFSOW7sHU2ID61e0LrTXfRJQqMjExkc2bNxdaLwqCwKBBgzQuzM6Tf7HnjLxyyPqpfUlKy2L2phOsn9oXG4uXKQH9OrvRr7PcJLfq93M42r65Xo9/UarIzp07k5GRQYMGDQqda9OmTRFXqIePZ3N8PJsD8PR5KuNW/8myL3pQy7lgVavElEzsrEx5+jyVk1fus2vuxxqXpaKhk24sKOjKAtDT02Pv3r0AfPzxxyQnJ6Ovr4+fnx/vvfdeeYqqE+jsy+Wzzz6jdu3aRERE8NFHHymUCC838RaJRHz77bflKKXuoB03VqD6yT2WqVnM+KAaAc4yhIdnkAW+nFwJ2SlsndQJm3/2zFK3P3Gnr9W6XhfQ2RFpZ2mCW0179N/OSEuEzsTslAYRMGL1cUQiGNixHgM6Fl1K7U1CqSLT09NZv349cXFxdOzYscC6cu7cucydO1fb8hXJr19/iIO1KYmpWYxYfYxaTta0cn1zdzwHFY9WPz8/BEHg/fff5/Dhw4wdO5bc3FxAXpRX0+w8cxuv+fvxmr+fhOTMYts5WMu9HXaWJng0q8GNqGcal6WioXRERkdHK0xxHh4erF27lk8++YS1a9dqRRifLg3x6dJQaZvMnDwEAcyMDcjMyeP87aeM/rCZVuSpSChVZG5uLjKZDLFYPnC//PJLnJycGDJkCJmZxY8YTcwC9+7dy+zZs5HJZABsCnigiFQYMmQIiYmJAHTp0oVOY16d3VdXUarILl26cPHiRdq2bas45uXlhZ2dHQsXLiz2Ok24sTztc+m9ZRwikYi70c+Y+ONBTMN/JTc9C31pFkE/jpJX9Zi1g6SzP2BlVvYEntfejVXcfsodO3bk888/14pA/2Jm/LK8dWZOniLA6nxYFG0b18D6n3IsbRvXIPh6JD3bFjYjvkmUefnx448/atUfCXDy8n1W/XGOF6lZrJ3iBUB8UjpOdi+N5I625sQnpWtVjoqATruxPFvVxbNVXS7fecIPe86zxa8/RVmG34ZD6rgby8FGvh9Wq/pVeZyQTFJaJk625lwKf6K4Jv5FOq0bVNW4LBUNnXVjPYpLQhAERCIRtyLjyZPIsDY3oV2TmqzaHUxKRjYA529GMXGgZorUV2S0U0NAA7PWjQcvcSD4NgZ6YowM9Zk6uCMt6slHnn/gDTYcuATA573b0LdT0YmwJeW1n7WWFU38x3zeypfPgbCwMAYOHEhipbaIW3UHQP/JPkQmdwHQc+mCuJWX2v39y9z6Bqrb3NG9Etw6nY1VHtUhK+q0Sad9ROVRHVIkUv3RRUqtyH9NY9qmvNLq9ESqP7qIUkUmJycX+CQlJdG/f39SUlJITk7WqmDllVYnKsFHF1H6jnz33XcVwU//Eh8fj5eXFyKRiICAAI0Kowtpdbo64lShVJFTp07lwoULTJs2jXr16gHg7u7O6dOntSKMLqTV6eo7UBVKFTlixAh69uzJ4sWLcXZ2ZuzYsSV6jGkiO+rUqVN8//33iMVi4uLiqN6kE2K3wdy7eBGp2JgOo1YCcivTtcwaeLT1ULtPgIq6J0yJDQKnT59m3bp1xMTEcP689gsTZWRkYGpqikgk4s6dO0yYMIFjx44VaJOcnEy3bt0IDAzExKTsy4/8fOemeh05+UYFXke6u7vTtm1boqOjAeXZWLKwHWoLZoJ8YiMAGXefIMpNLXTfYyev0cGtGkb3/ZGp0Ze4yRDF99fyHflfjI2NcXV1BV6RGyv0Dqt+Pc2LlAzW+hV+XB85f4tPe2nW5vtaviPL3Y3Vpj6ebepz+fYjfvj9LFvmvBw5CUlp3ItOoH1TzW7NqyfSyQwKleiWG+vYZfac+guA9TMG4/BPllWrhjV4HPcnSamZ2FjKI+iOXbiNR+t6GOjraVSGCjogdcyN1b0VPt1bAfAo9sVLN9bDWPIkUqzzpdYdPn+LSR+7a1yGijprVarIxYsXF3vuu+++07gw+TkRGs6BwDAM9PQwMtRn5cS+iqVPTEIycc9TadVQ8/XLK6geteTGyjcLLCseZu9x+tYMbt26xcSJE2k1cITiXMDWrVjaOdJn1u+4urqyZMkSjIwK13QtC2/ErLWkyM6tUPselqlZzOhZk4DKIEQGIjsnr7wVn5TBto1/cmh+f4wN9Zm47hSHVo3Fq51rmfsSd5ii+F5RZ60668ayszTBrVbR2VhSqUB2rgSJVEZWrkSRQqAJKqr3o8JlYznamDH8/SZ0/XoXRgb6tGtUhXaNNBd8VVEnO6Uekf8WFywvUjJyOP13FCeXDiJwhQ9ZORL+DLmvsfuXxY31b/r7hx9+qDgWHh7OgAED6N27N3379iUsTF44XxAEFi5ciKenJ7169eLWrVsakVupIlesWKGoeHXjxg26du3KgAED6NKlC5cuXdKIAPnZefoWXvP88ZrnT0JyRpFtQsJjqFLJAlsLEwz0xXi8U5O/IuI1JkNZHq19+/Zl06ZNBY59++23jBkzhgMHDjB+/HhFinxQUBBRUVGcOHGCBQsWaCw1UemjNTAwkClT5BOB5cuXs2rVKpo0aUJkZCSTJ08ukNevCXzcG+Hj3khpG2dbc64/TCArR4KxoR4Xw5/SuGYljclQlslOq1atePLkSYFjIpGIjAz5H2NaWhoODg4ABAQE0KdPH0QiEc2aNSM1NZWEhATF+bKiVJF5eXlIJBL09fXJyclRbGxWq1YtpTu65p8FlpVnz57h7e1Neno6YrGYbUFRHDlyhOYdzOme8gPeK46gr69PgwYNGDRjEWJDQ9U3LQGamszMmDGDESNGsGzZMmQyGb/99hsgd8w7Ob1MynVyciI+Pl5tRSp9tPr4+ODr60tISAgdOnRg0aJFXL58mR9++KHITcc0yfXr17GysqJatWpUr16dlStXYm5uTnh4OOfPn1dU9ejSpQuGGlIiaC7UY9euXfj5+REYGIifnx8zZ84E5O/IQn1qYM2jdEQOHToUV1dXdu3aRVRUFFKplKioKDw8PBg9enSx18mubS72XElpY5rL/rm95Wl1jxKYOHUsR74biWHsC5Z80pKazrYkvEjDe+Ys2lpEYqlOWt07L40N+hoakfv27VMor0ePHsyaNQuQj8C4uDhFu7i4OLVHI5Rg+dGmTZsi7ararg5ZKK3un+/5q2A52FpgZ2nKi9RMtRSZH00ZBBwcHLh06RJt2rTh4sWL1KxZE5D7dXfs2EHPnj25fv06FhYWr0aRxfFq0uruseq3IF6kZLJ2WuG+wh7IjenVHcteq/W/lOUdOWnSJC5dukRSUhIdO3Zk7NixLFiwgMWLFyORSDAyMmL+/PkAdOrUicDAQDw9PTExMVFqzy4NSkM9lPkjIyMjuXnzZpHnNPFozc/l8Mf8vPcCW2YOVBxLSErn0wW7WPJlT5rVrazkatXkf7Qeaq/aLfZhsFSt/rSBbvkjT1xjz2n5wnn9NO+X/sgG1Xgcn6zwR6Zn5vDF8j2MH9BBbSX+F101walCt/yR3d7Bp9s7wH/T6uIU/shciZSxK/fRu0Njur+r+ZmzzhqfVaCz1SEnTpzIqVOnEIlE6OnpMWvWLLy9vdmzZw8zZ87EyMgIQRCwsLBg8+bNRf6xlYVTHVU/Wj2CdO/RqrN/gEOHDiU4OJiwsDBWr16tWFB7e3tz7do1wsLCuHbtGlWqVCEnJ0dj/YpFqj+6iHb8kRe+V/sezQBunUMGNMnNJi46QnFfE0AG5ObkkZf8FOHGH8gyA8vcl7jteMX31/IdqSv4B4XTwa264rdUJqPf3N1EJ6Qw2N2Npi5F78FcFt46lrVEaHgM/ufCmTzgZZVkPbGYffMHcmblp9yIjOfeE82l+umLVH90EaWKvHHjBkOHDmXKlCnExsYyfPhwWrRogbe3N7dv39a4MDsDbuA153e85vxOQlIGdx8/Z/aWM6wZ9wE25oUtN5amRrSuV4XgG9Eak6GiRggoVeS8efMYOXIknTt3ZtCgQQwcOJCrV68yZcoU5s2bp3FhfLq6sW/+QPbNH4hEJmPcmmMsG9WVWk7WijYvUrNIzZRPbrJzJYTcfkItZ81Zdl7L/EiJREKnTp0AuZO5e3d5MYb33nuPZcvUL3etjJ8PXCE5PYf524MA0NMTs+eb/jxLycBv02mkMhkyAbq3cqFLs5oa61dfrJOrMZUoVaSRkRHBwcGkpaUhEok4deoUHh4eXLp0SVExsijyzwLLintmI27Efw9iMXp6esyYMQNxy5YQHo6R7T2Fn9Kl08eI236gdn//oqsjThVKDQJ37tzh22+/RSQS4efnx65du9i/fz+Ojo4sWLCAd955p8jrNGFrzcjOxdTI4KUb64c/OfLdSCJjXyCCfG6sbRxeMUJjbqywbqrnf01OqJP7pR2Ujsj69esX2D9y1qxZCr+av79/sYrUBOXlxtLVBb8q3rqx/oOuzkpVodtpda1c8WzlyuXwx/ywO7iQG+vrnw+x5MueiDU4jF7LEfkmurHEFdS089aN9R8qqB510421adMmtm7dSkpKCiAvkr9+/Xo6d+7MgQMHmDFjBnXq1CEjI4OEhAQcHR155513WLRoEfr66pmPI3qpvt7loEStPrSBTioyP6dPn2br1q1s27atwHGZTEaXLl3YunUrtWrV4vvvv6dy5cr0799frf4efqS6qkftPytwVY/SIDsxR2P3OrQ1hA/qOhS654u0bAwl6dS4vwXZfXjP4Bkbft2Ht9WNUvch7jZf8V1UQaetOu39yMqVEBweR7dmhbOtbMyNyJPKuBktz0058fdj4pKK34ukpIhEIpWf/1JUEs+yZcvo3r07vXr1YsyYMaSmvix8uH79ejw9PXn//fc5d+6c2jKDCkWmpaUpbKz/xrf26NGDFStWFBBMW5y58ZTmtSthbVY4G1kkEvHd8PdY6v8XA749iamxAfoaGE1isUjl578UlcTTrl07Dh06xMGDB6lZsybr168H4MGDBxw+fJjDhw+zadMm5s2bh1SqfuiIUkVOmDABS0tLtm/fTmhoKKGhoWzbtg1LS0vGj1ffnpqfnUH38Vp6HK+lx0lIkdeZO3Itmp4tqhd7TfNaldgxsSt/TPWklYs9New1sNdyGdwfrVq1wsrKqsCx9u3bKyZezZo1U0SXBwQE0LNnTwwNDalWrRo1atRQpNypg9J35JMnTwqY6ADs7e3x9fXF399f7c7z49OxLj4d6yp+p2Ul0OccAAAgAElEQVTlcuXBM5Z/8m6x1ySmZWNnYUxunpRNp8L5vJvyfbVKgiaNC//i7+9Pjx49AHkST9OmTRXnHB0diY9XPy1Q6YisUqUKGzduLGDFef78ORs2bMDZ2VntzpVx6noMbes7YmpU8G/Nd22QYsT+EnCHnguP0HvpcTo3rsy79dQP+RCJxSo/pWHt2rXo6enx0UcfAeWUxLNq1So2bNig2FRMJBJhZ2eHu7s7q1evLva6/LPAsnLljB+hUQ/46IdrHDp0SHF8UzfYvHkzy2ctJyQkhK9tbZXcpfRo0iCwb98+zp49y9atWxXK+m8SjyZS6kCFIq2srOjbty/t2rWjadOmmJm9rC0eFBREx44di7xO9of6uwz0sUnm44E1me5/p8D9YlOyOb//Hs5WRggHJiMzU73uU4V4wMvtLTT1aA0KCmLjxo3s2LGjQOVKd3d3Jk+ezPDhw4mPjycqKkqRd6oOSp8T27ZtY/To0ezYsYNevXpx6tQpxblVq1ap3bkyWtW0xtqksJKWHolgSrfa2jOllaE6/aRJkxg0aBCRkZF07NiR3bt3s2DBAjIyMhg+fDi9e/dmzhz5Orhu3br06NGDDz74gJEjRzJnzhz09NQvw6Z0RO7evZu9e/diZmbGkydPGDduHDExMXz66adFPuu1zenw5zhaGlHf2VxrfZRlRK5cubLQMWUWpi+//JIvv/yy1P0oQ6kipVKp4nFatWpVtm/fzrhx43j69OkrV2RWrpT1QdFs+lT9x5AyKuqGaUofrZUqVSI8PFzx28zMjPXr15OUlMS9e/e0Llx+Hr/I4klSNn1+ukLX7y4Sn5qD99qrPEvL1Wg/IrFI5UcXUToily9fXuj5ra+vz/Llyxk4cGAxV2kHVydzzk9/ubNs1+8usueLFthoYLKTnwo6IHXX+5E/C9jOzo6xY8cWeO+4u7uzZ88ebDW8/EgapTpsxGZj+RaNKgqdUaQgCCxatIjAwECMjY1ZunQpjRoVrLmTnp6Oj4+P4ndcXBwfffQRM2fO5OnTp3z99dekpaUhlUqZMmWKIia3NCT5qv7DsNnwotT31TbacWMdLnpvZmUE3o4n6vJDjo1/l+uPkpg74TN+n1BQEabAPt96it/eK2PxsIhAdngaP//xN92rWTG4nSsP4lL5/OvxBMzuVqK+xT2Xv/yuo+9AVeiMG+v0zVh6t6wmrwhV05bUrDwSUrOLbR/1LJ0X6Tm0rG0HyG3Z6dlyz31atgQHq7KFR5bFjaULKFVkeno63333HVOnTuXgwYMFzmmqhtq/xKdm42T90gLiZG2isKkWxeFrMfRoVkXxHzume30OXn1M53nH+WLjRWZ5lW2ZItITq/zoIkql8vPzQxAE3n//fQ4fPszYsWPJzZVP969fv65RQYrcBFtJAP/Rv5/Qs/lLh/ORa0/wal2ds9+8z7pR7/L1r1eRycrw+q+g+w4qfUdGR0fz448/AuDh4cHatWv55JNPWLt2rUY63xn8kD0XHwHQuJoNcckvR2Bcchb2xTwe78SkIJEJNKr2MktrT2g0G33lOZTNa9qSkycjKSMXO4vSlcgWiTW7a8GrQqkic3NzkclkioSdL7/8EicnJ4YMGUJmpvphFT7ta+PTvjYAZ2/H8WtwJB80r8L1R0lYGBvgYFm0Ig//VXA0AlS2MeHi/Wd4ta5ORHwaORIptuZlqFGnoyNOFUqXH8uXL6d9+/a0bdu2wPGgoCAWLlzIiRMnNCaIIAjMnz+fc+fOYWJiwpgxY9iyZQu3bt3C2tqa4OBgRdsuXbpQq1Ytnj59ikgkYvHixVhYWDBr1iwyMzMRiURMnTqV9u1Lvxt6xqRqKtuYrXxc6vtqG5XryIiICBISEmjSpEkBN1ZgYGCZ1mklJTExkZiYGAICArC0tGTEiJcZU19//TUtW7akf//+5Obmkp2dXSgavqxkTq2pso3pt1Ea6UuTKH20bt++nR07duDi4sKdO3eYMWMGHh7y7f1Wr15drCJlQcuLPF4abP75nI25hvDcAFmQvE5AelYul8+dYvEHtsiClqMPmIN6m5x1zLfuraCPVqWK/OOPP3TKjQXw+FkathbGzNhyjrtPEmlYoxIzBr2LqZFmbK4VdbKjdPlRlBsrKCiIJUuWlJsipTIZt6MTGdS5PnvneGFqpM/Go+pHoSmooMsPnXJj7TxzG695+/Cat6/Y4vSONmY42pjRtLY8zqXbO7W4Ha25FD+RWE/lRxfRKTeWT5eG+HRRHtJob2WKs40ZkXHJ1HKy5uKdp9TRYFUPXR1xqlCqyPxF1P9LixYtNC5Mfp6lZNJ/4QHSs/MQi0RsO3WTQ/O9MTcxZObg95i6KZA8iZRq9hYsGlZ0EFhZEGkgfqY80M4mZx1L7/0oyo0VFDq3ULsjR46w9ve1yAys6eTRiWnTCvZ17Ngxxo8fz549e3Bzcyu98GUckampqcyaNYt79+4p1ra1atVi4sSJxMTEUKVKFVavXl0oIl1TaMUfWVY31s7gh6wfJXdjLdl/o5AbKykjF+/vzrJnUidszY2Y/us1eresxnuu9gBkZOfx+aZQ8iQyZnu70bhayR65+d1YufObKmkpx3BOYTtzUWvbdevWYW1tja+vLxs2bCAlJYWpU6eWSKbSUmpTfmKi5uq+5ackbqwniRnUsDfD1lxuP33P1Z4TYU8V578/eocRXepgZKCGh0IkVv35D+np6Vy+fJl+/foBYGhoiKWlpWKzFoA+ffoUCCfVNEr/xcnJyQU+SUlJ9O/fn5SUFJKTkzUqSEncWNUrmRGZkE7Mi0wkUhkBN2IVhvbbT5KJS86iS6Pi3+sloSxurMePH2Nra4ufnx99+vRh5syZZGZmkpiYqIgid3BwUGxPpQ2UviPfffddKlcuWGwhPj4eLy8vRCIRAQEBGhOkJG4sK1NDvunXlEnbLiMSiWhe05bHiRnIZAJLD9xkyWD16/6IihhxqpBIJNy+fZvZs2fTtGlTFi5cyIYNG1RfqEGUKnLq1KlcuHCBadOmUa+ePMTC3d2d06dPa6TzsrixujRyUoy6P0KiEItFZORIuB+Xxic/yQ3rz9NyGL05lJ9HtCnxe1JBKZN0QD67d3JyUmRZde/enQ0bNmBnZ6fY9yohIUHjgWL5UarIESNG0LNnTxYvXoyzszNjx47VaKhDWdxYiWk52FkYkZKZy67zkaz8pBUWJgaELOihaPPJT8FM+6hR6ZVI2QKU7e3tcXJy4uHDh9SuXZuQkBBcXFxwcXFh//79+Pr6sn//frp27Vrqe5eUEs9aT58+zbp164iJieH8+fMaF+S/bqzu3btz7NgxQP4O+u2336hfvz6TJk3i+PHjiMViKlWqhI2NTaFd84YOHcq0adPKtPyQrminso3elML//vDwcGbOnEleXh7VqlVjyZIlyGQyJkyYQGxsLM7Oznz//fdYW1sXcUf1KZUbS09Pj+joaFxdXZVmY2mCa9eu4eLigpWVFYGBgaxZs4bdu3cD2otpBZB9p9qHKZ4crLLNq0bpo3Xbtm3s3LmzSDfWqlWrik+ru/iT2oI1AwgPkRenl/xTnP6f+wo5qQhXf0FmYaLsFiVG/O6Ylz9eR8uOrmRj+QfepkOTGorfIkSM+HY/ImBgFzcGdGmsuc501CiuCp3PxgoNf4x/0C12zOqnOPbrrH442JiTmJrJiOX7qeVsQ6v6VTTTYRmWH7qAbrmxTl3Ha/aveM3+lYSkdO5GP2f25gDWTPgQG/OXj1EHG3l+pJ2lKR4tanPjoeb2WEasp/qjg+iWG8ujKT4e8rXY08Q0xv14mGWfv08tp5fLiMycPASZgJmJIZk5eZy/Gc3o3q01J8RbN5Zm+Xl/KMnp2czfdgaQ7/WxZ94gElMyGfvDYQAkUhkfvlePDk1qaq5jHR1xqtCZbKyiCAsLY+DAgaxatUqxw8G/ZGVlMX78eKKjo9HT06NLly6KHdrVQbb+Q5VtxJ8fUtnmVaOdbKxjM9W+h1QmsOLnINrVc0D4excyCtZsk+VKGO4m0KZvC3IlMj77aS9nxbfp2LD09X/E3Rfl+1ExR6TOTtF2BD3As2mVYkP+TQz1aVNX7lkw1BfTsGpBW22ZKYMbSxcotVRJSdrP1o1PzuJUWAyD2rmUqH1qZi5nbsXynqv6hYcq6qxVqSJXrFih8KHduHGDrl27MmDAALp06cKlS5e0JtSSfX8z+SM39EqQdCqRypiyLZQhHetQrZIGyrZU0HBIpe/IwMBAxQRi+fLlrFq1iiZNmhAZGcnkyZMLGavVYee5B+wJiQQgLSuPyf8LBSA5PYeg23HoiUV4NCm86P/m92vUsLfg0851C50rEzo64lShVJF5eXlIJBL09fXJyclRlNqqVasWeXmaLQft06EOPh3qFDrut/MynRs5F6nE1YdvkpaVx4JBGlwK6eg7UBVKpfbx8cHX15eQkBA6dOjAokWLuHz5Mj/88AP162u+wn9J8Fp+EoC45EzWn7hDRHwq3itO4bX8JLv/GdFqUUHfkSrXkaGhoezatYuoqCikUilOTk54eHjQt29fDAw0W+MmPxEREcyYMYNbt24xceLEAtlYW7duZffu3YhEIlxdXVmyZAlGRqVLaC0O2c5PVLYR+2xT2eZVo3IdWalSJQYOHFgorU5pdchzK9QWzDI1ixk9axJQGYTIQGTn5LPl+KQMtm38k0Pz+2NsqM/Edac4tGosXu1cy9yXuEM+Q4KOjjhVlKg65Pbt2195dUg7SxPcatmjX0TUmlQqkJ0rQSKVkZUrwcHaVHMdV9B1ZIXwR+bH0caM4e83oevXuzAy0Kddoyq0a1R4F4Iy8zqOSF1Mq0vJyOH031GcXDqIwBU+ZOVI+DPkvuY6EItUf3QQ3fJHnr6F1zx/vOb5F5tWFxIeQ5VKFthamGCgL8bjnZr8FfHWH6lb/kj3Rvi4N1LaxtnWnOsPE8jKkWBsqMfF8Kc0rllJc0KUUVFBQUEsWrQImUxG//798fVVvxx4adBZN9bOnTtZvHgxUqkUkUiEtbU1J0+exNzcnJYtW5KdnY1IJMLExITg4GAMDctQiqUIZAdU72ci7v19gd9SqZT333+fLVu24OjoSL9+/Vi5ciV16hQ2cGgLrbixNEGDBg24cOFCgXBIc3O5LdXS0pITJ05oJ3K7DCMyLCyMGjVqUK2avLRLz549CQgIqPiKrNDhkGVYXsTHxxeIpnB0dNTI7jqlQWdHZH50PRxSW5uylAalf343btxg6NChTJkyhdjYWIYPH06LFi3w9vbm9u3br0TAf8MhJw98Gcr/66x+7J0/mA1TevNrQBiX78RorsMyGAS0tSlLaVCqyHnz5jFy5Eg6d+7MoEGDGDhwIFevXmXKlCnMmzdP48LoRjikvurPf3BzcyMqKorHjx+Tm5vL4cOHcXd315xMJRFb2UmJREKnTp348MMPEYlEigCo9957j5ycHI0L4+PRlH0LPmbfgo+RyIRiwyEzsnIV38/fjKZuVQ1OesrgWNbX12fOnDmMHDmSDz74gB49elC3rob8oyVE6TvSyMiI4OBg0tLSEIlEnDp1Cg8PDy5duqSoGKktyi8csmzThk6dOmm1Np8qlK4j79y5w7fffotIJMLPz49du3axf/9+HB0dWbBgAe+8o36GcHEoc2OBfO3m7e2No6OjYpNNTSA7vVBlG7H7LI31pynKXB1SqRvr7BK1BUtMzeLpiwwC/o7G0tSQz7oVnJluPXmLm4+ek56dx7qvPNTqS9zZT/G9JLLnb68rqHRjjRkzpvzcWDUrFbndblxSBoE3ntCvfdl9kMXyurqx/P39dcqNBbDkj0tM8W5BRrYWtpHXUaO4KnQ+re6/nAl7jK2FMY1qVOLS3VjNd6CjI04VuuXGOhOO14IDeC04QEJy0TXT/4pI4Mz1x3SdsZvJmwIJvRPLtM1BmhOigrqxlE524uLi0NPTw97evtC5q1evFpuRpYnJzr+sOfgXpkYGhSY7AJfuxvLLyVuaneyE/Ki6/Xtj1epPG2glrU4Ts7pnz57h7e1Neno6YrGYbcGPOXLkiMIDAiAyCUV07ReN9KdAR0ecKnTWaP7w4UMyMjIUriFPT0/Mzc3JycnBx8eH3NxchR9Qo5TRIFDeaMeNdfeg6kYqEB4/oEX9aqyb89IQILt7EH1BYMusQZiZGJEnkTJk+hra1xDTrH4NJXdTjrher5c/Kuhkp8L9+YlEIsxM5MHIEqmUPIlMs3k1r2N5FolEwp49ezh58iQJCQmIRCIcHBzo2rUr/fr102qkOcDfdx/RZ9x3ONhaMvWzXtStLn9nS6Uy+k1aTXTscwZ/0Jam9co+GgtRQUek0lnrpEmTsLCwwMvLSzHxiYuLY9++faSkpLB69eoir9PEozU9M1sx+gKvhLN44wGOr59eoE1qehZjl2xlpm8fXGuUPlP5X/I/WmVhO1S3bzKkzH1pC6Uj8tatWxw/frzAMScnJ5o1a6b5SQaw8/B59pyQp9OtnzMCBzt52ehOLRswf91eklIzsLF8ae+1NDehdWMXgq/dVUuRBdHNuFVVKH2OWFlZcfToUWSyl/vcyGQyjhw5orEtjPLj07Md+76fxL7vJyESixTWo7B70QgyAWsLU16kpJOaLk8xz87JI+T6fWpV1aA3/nU0CDx58oQVK1YQGhqqUFxqaipt2rRh8uTJiqWBNtixYwebN29WlN6uVasWBw4c4M6dO/j6+ipS4Nu0acOmTZs01q/s5h8q24gbD9BYf5pC6aO1atWqDB8+nM8++4xq1aoRERHB9evXqVOnjlIlCo/Ur57Yq7kDv+oLHN28gMoOdiQmpSI8CkYU9wRLYz2O7VmNgYE+o2asIvKCPzWrOJa5L1GNfBUhteww1xZKFblmzRqCgoKQSCS0a9eOsLAwWrVqxYYNG7h9+zZffvml1gQ7dPoinu3eobKDfA9lOxv5E+Hh41iaNnDBxFi+BGnlVo9T568xckCPYu9VOl5DRR4/fpz9+/eTm5tLu3btCAoKwtzcnJEjR9K/f3+tKjIqJh6JRMrQKcvJyMzmEy8P+ni2pW7NKqzaso+k1HSMDQ0IvBxGY9eamuv4dRyRenp66OnpYWJiQvXq1RV2TmNjY63H7EikMm7df8SWZVPIyc1l0PjFNG1QG5fqlRk1oAcjpn+HqbER9WtXQ1+jExDN/7v+3b5RX1+fTp1ebjqzfv169uzZg1gsZtasWXTo0KHMfShVpIGBAVlZWZiYmBSo4JGWlqYVRe788zS7j8hdUt07tcKmZWNMTYwwNTGipZsrdx8+plZVJ/r16EC/HvJ/9Mpf/HGqpMG9sTQ8K7148SIBAQEcPHgQQ0NDxeTtwYMHHD58mMOHDxMfH8/w4cM5fvx4oaSpkqJUGzt37sTERB5Pml9xeXl5LF26tEwdKsPnI3f2r5vL/nVz8WzXnKs37yGRSsnKziHszkNqV5OvFROTUgF4mpDIyeBr9OzSRoNSiErwKTm7du3C19dXkWRkZyd/5wcEBNCzZ08MDQ2pVq0aNWrUUCvNQOmILC7DydbWVqtbHwC4VK9Mh5Zu9P78G8QiEf16dMS1ljwzedyCn0lOTUdfX485Y32wsjBTcbdSoOERGRUVxZUrV1i1ahVGRkZMmzaNJk2aEB8fr9heAuT5IvHxZQ+01orRvMB0voyEhoay9rejVK0qV166gb3ivjVc3Yg8exY7Ozva9tFsHmJZcjaGDRvG8+eF97CcMGECUqmU1NRU/vjjD27cuMGECRMICAjQeL6IdtxYd/5U+x5CdITcjTX7s0L37dPSkY/bD2X66t800pe4/kcvf4hKPyK3bt1a7Lldu3bh6emJSCSiSZMmiMVikpKSNJ4vUiHn2q0a1cbaXIOVPPIj0lP9KQUeHh5cvHgRgMjISPLy8rCxscHd3Z3Dhw+Tm5vL48ePiYqKUlQWKwsqo+h2795NXFwcHTp0KBDe8fPPPzN69Ogyd1wS/r77iD7jV8rdWMM/VLixtIqG0+G8vb2ZMWMGH374IQYGBixduhSRSETdunXp0aMHH3zwAXp6esyZM6fMM1ZQYWudOXMm2dnZuLm58eeff9KqVSv8/OTxMV5eXuzbt6/I6zTxuCvkxtr0J8fXfa04HxP/gi8W/sLBH9Wvmpz/0VoS86Im5gCaRumjNSwsjO+++45hw4bxxx9/kJmZyVdffUVubq5W4lp3Hj6P14SVeE1YSWZWjiISoFPLBkikUpJSi670oVFexzKf+StA6uvrs2DBAtasWcMnn3xCZmbRcafq4NOzHT495Qmtz5JSEQQBkUhUwI2ldcow2dEFlCqycePGhZJ1vvrqKxwdHZk7d26x1xWYBZaRXatX88svy8nNzcXJyYmVP65Fr8E7xMbG0rdvX1JSUpBKpbQeMp+vv/6a/v37q90noLMjThUqs7H+tTY0adKEBw8ecO7cOWrXrq31XMDExERiYmIICAjA0tJSkVaXkJDAs2fPaNSoEenp6Xh7e/PTTz9prIKG8PSKyjaiyi010pcmKZUb6/r167Ru3VqlG6skOYaqsPnnc/bxdQQjfWSn5Xkelf75yOL3YQrUtpQQe3wltaMrF38zFRTMd6yYI1Jn3VglISYxnfDHL2iqycpXr+M7sjzdWKrIyM5j3PpApvdvhbmJZqpeARX2Halbbqyzd9lzXl7pcf0Y92LrsOZJZYzfEEiv1rXo1ry6ZoWooHGtShW5c+dOhQfklbixOtfDp3M9pW0EQWDW9hBqO1kxzKOhxmWoqOisG+tZShb9lx4hPTsPsQi2nb7DoTm9uBuTzJ+hD3GtYo3XIvkeVRN6N6dT4zd7/0iteD80UfUiPSIC55oPClX1aAX0jfTj7D9urEOHNLzhWAV9R2qlzKfs1Hy175GYli2v6nH9sbyqR77H6OX78ZgaGTB92wUOzlK9u5wqxB5zFN+F53dUthdVKp+tMpShs88ROwtj3GrYFVmcvlVdR6zNNDhTLYBmQz1eFaVWpDZyPnSK17E8S/PmzRXhB/8+gbOzsxXHr127pn0JXzU6qihVKFVk3759SUtLY9q0aVSqJLeeuLu7c/r0aa0IszPwLnvORwCwfnRnze7n8ZqjVJGzZ8/m5s2bTJo0CQ8PD4YMGaLVgrI+nerh00n5OlLbiCroiCzRrFUmk7Fjxw6OHTtGdHQ0wcHqJ+mo4r9VPUxNTRVVPSZNmsSlS5dISkrCzs6OsWPHas6NlRyluo11Tc30pUFK5ca6cuUKFy9exM3N7ZWXtDx16hTff/89YrEYPT09ZsyYQcuWWnAnpUSrbmOlYbOgBlCqyOKysUJCQmjfvn3xbqyjmq+emJEjwdRQD5FIxN2nKUzcGsqRGd00cm9xj3wFnlIeq77ASnt5oWVF6Qvh+PHj7Nq1i507d7Jz505++uknvvrqKzZv3syRI0delYwAmBnpK97PmTkSRNpaz2l4+XH06FF69uxJ/fr1uXHjhuL4+fPn6du3L7169aJv376EhIQozt28eZNevXrh6enJwoULSxQfVaHcWCfDYlh16BYv0nNYO6qtdjrR8GTO1dWVH3/8kW+++abAcRsbG9auXYujoyP37t1jxIgRnDt3DoC5c+cyf/58mjVrxqhRowgKClL5KtMpN5YqPJtUwbNJFS5HPOeHo7fZMrrsaWjFomFFurgUvXN7w4YvTY5169YlNzeX3NxckpOTSU9Pp3nz5gD06dOHgIAA9RT5qt1Yhfo/F8GekCgA1n/eFgcreWZYK5dKPH6eQVJ6DjbmmtnJ9SWv3gR3/PhxGjRogKGhYaHNYJycnEqU3KOzbiwAnw4u+HSQ/0U/epauCI+89TiJPKlMO/bWMqwjlSXxeHgor1x5//59VqxYwS+//AKUfTMY7bixepS+zKcgCCxatIjAwECMjY1ZunQpjRq93Lnu5IYNHPjpAJmZmbx48QJ7e3t8/Z/x7bffYmtry507d/jmm2/IzMykSpUqrFixokAlyRJThkersiQeZcTFxfHVV1+xbNkyqleXL2n+m9wTFxdXsuQeQUc4e/asMGLECEEmkwl//fWX0K9fv0Jt8vLyhHfffVdITEwUBEEQli1bJvzwww+CIAhC3759hdDQUEEQBGH37t3CqlWrXp3wJWDIkCFCWFiY4ndKSorQq1cv4dixY4Xa9u3bV/jrr78EmUwmjBgxQjh79qzK+2snre7wtFJfc+qPv+ldpxLCka9pAqTGRhC3axwOlsaKNlKpDCEnnYzDc7CyMSH9dhjVq1ohO/yYyPt3aJGwG9nhPbyXncWovRcYV/dpifoW91xeanlLysmTJ1mwYAEvXrzg888/p0GDBmzevJkdO3YQHR3Nzz//zM8//wzAL7/8gp2dHXPnzsXPz4/s7Gw6duxY7G4O+dGZ6pDxqdk4Wb/cNsnJ2oSElKwCijTQE/NNv6b0/vYMJoZ61LA3Z7a3PBWtrrMFp2/F0bWxM8evxxCbnPXK/w1F4enpiaenZ6Hjo0ePLjabzc3NrdSRD0rf7Dt27ODFixcAPHr0CB8fH1q2bEn//v25e/duqTpSRVFr3v8u+vOkMn67EMneyZ0Jmvs+9Zwt2RAgr62+aGBzfg2OxHvlWTJyJBgU4ZB+nVE6Inft2sWQIfJKiIsWLWLYsGF4enoSGhrKN998w2+//aZW5zuDH7Ln4iMAGlezIS7fKIpLzsLeyrhA+zsxKQBUrySvGdC9WWU2BsjDJ2s7WrD5C7mRIDIhncDbGtz4rAKgsl7rvyQmJioeEW3atCEjQ/0UN5/2tfFpXxuAs7fj+DU4kg+aV+H6oyQsjA0KPFYBHK2MeRCXxov0HGzNjbhw7xkujhZy+dJysLMwQiYTWHfqLgPb1lRbvoqEUkV2796d6dOnM2bMGDw9Pdm6dSvdunUjJCSEypXLnmtRFJ0aOBIUHs/7i09hbKDH4sHNFUtsID8AABrvSURBVOe8Vpxh35QuOFiZMOb9egxdE4y+npjKNiYsHizfn+vwX0/49XwkAJ5uzvRtrXseCm2i0o21d+9edu3aRXR0NLm5uTg7O+Ph4cGoUaOwsLDQilBFFaAfN24c06dP59KlS4p+ly5dSoMGDbQiQ0WjVP7I+/fvc+7cOVxcXJTa/mQb1MuPFASBzDwBM0MxeVKBIb9F49fFgd/Dkulc25z3XTX7ByT2VT9VvrzRyeqQIpEIM0P5jFUiE8iTCRU1bviVoXRE9urVq8i0uuzsbPr378/Bg0XXLld3RAJIZQL9djwiOjmXwc1smNLRHr9jsfz9NAtDPRHvVjdjcodKGOqrv8x47Udkefoj9cQi9n1Sk9RsKWP/jOHe8xwmtrfH3kyPPKnAnJPxbLz8gjHvaTA3sgKjVBv/+iOBcvNHWhrr0bqqKcGRGTiYy6MEDPXF9G1sxY247FciQ0VAp6pD/suLTAmp2VIAsvNkhERnUsvWkIR0+bpWEAROPUinrp2mfZEVF60k8ajLt99+y/bt2xEEAUtLSwYPHsxXX33FJ598QlJSEhKJhIyMDCwtLREEgc8++wxvb+/yFrt8Uds/o2Hu3r0r9OzZU8jMzBTy8vKETz/9VIiMjCzQZu3atcLy5csFQRCExMREoVWrVkJOTk45SKs7aMeNtbfsNeoe3IiniVUGRkcnA9DSLJ4Tq8YwslO+bZNuR5GenI3U/yHpSdlY6eUi/nM8MnHZ1ijivj+XWV5dQedcBHUdzbkSmURSRh5ZuVKC7j4nLqXgpMbnvao8fJZBxyXB9P4+FL9erojLqMTXBaUj8vHjx/z88884ODjg6+vLkiVL+Pvvv6lduzbTpk1TFMXVJC4OZozsVJMRv/yFqaEe9Z0t0PuPkoLvJVLf2YKtI98hOjGLEb/8Rcua1pgb64x79ZWjdEROnz4dNzc3zMzMGDhwILVr12bjxo106NCBGTNmaE2ofq0qs3dsa3Z83gIrU31q2BXMytp7NRbPRvaIRCJqVDKlqo0JD5+9goKDOoxSRWZkZPDxxx/j6+tLeno6n332Gc7OzvTv35/U1FStCZWYngvA0+RsTt56Rs9mBXfZcbY25mKEfEul52k5RD7PpJqtSaH7vEkofRaJxWIiIyNJS0sjKyuLGzdu4ObmxqNHj5BKpVoTavzOMJIz89AXi5n9UT2sTAz4LfQJAIPaVGW0ey38dt/mo9UXEYDJ3V2w0VoqesVAqSKnTp3KF198gVgs5qeffmLDhg3cvXuXtLQ0FixYUOx16swCY2Nj0ds3DeH5c6RiMQ8ce9Cu76d83Pdlm4yICDKPziDqkbziR58RI4q/4RuCSoPA9evXFYXV79+/T1BQEHXq1FHuxjo4qcwCJaRm8yw1h0ZVrcjIluC9Opg1w1pQx+ml6yoxLYenSVkE3IrD0sSAzzoXHZZfUsS9Vqp1vS6gc24sB0tjRYiHmbE+Lo7mxKdmF1CknYURdhZGBIYnaLz/iopOV4eMeZFJeEwKTatba7Wf1wGls9bydGNl5EgY97+rTO/dEHNj7W7K/Tqgk26sPKmM8f+7Sq93qtDNTVN7J7/e6FxanSAIzPojjNqO5gzrVFsrfbyO6Jwb68qVK/j4+ODq6qr445k0aRJPn8rzOAYPHqy04sebis4p8i1lQytW5ise8rrg5m4dkGWlU+vrrdwa1bRQO4umnXDsP5kHs0ofrGXoWINa037h7uSuBY7bf/QFJrWaEP39aGw6D8SmfR8eLhyMSZ1mSJLiyUuMxbhmI1yXHiVskDyIueUp7VmpXhVanXqm3ziHJO1Fma617epDgzUhNFx3lRoT1pZ472Prtr1JPLENgKSgPVg0dwcg68Hf5CXKdyrIjrqF2NAYkcHrY9ZTmfuxZ88eTp48SUJCAiKRCAcHB7p27Uq/fv0wMFB/WWDe8F0arr9GXmIsj9dPJfvRbYyr18e28wDujO+AIJVQfdwa7Lr6kHhyu8r7GdpVJvfZP7VyZFKkGSnoW9ohSU1UtLHp4E3mg78Q8nLVll9XUKrIadOmYWFhwdixYxUFCuLi4ti3bx9Tp05l9erVanWecf8aYR/XQpadgVXrHtSZt5ebw+pj0dwd07rv0OCnUADERiZIkuVWHJe5/hg51URkYIihQ3UarrsKQPy+H0k8vrXI1HGBl9MA4xoNqTJqCfe/7q6W7LqGUkXeunWL48ePFzjm5OREs2bNNFK3VZaZpviecuko1cetQd/SDpFIROLJbcRsnlnomoi58iCr4t6Ruf9v78zjqqjXP/4+K7LokX1R3M09l6tyTUNEUMvcNb254ZKW2mImN7VcQjGXS6a5L4kXrqhhWZlWqKiYYurPAEs0F0QTZJMdzja/PyYPEnBAAT0Hef/FzPnOzDM8r/luz/f7fFLvoHR0R5N6B6QyZNYqdFli9a5waECLJeHcXOFH4d3rlbbflDDa8KhUKg4dOoRerzec0+v1fP/999SrV6/SD5fbFsUZrVt1A6kUbVYaWReOYvviCOT1HQGQ1bVF6VSx3VX3f/4G+34TALD1HEn2xWPiPaxVtFz2Lbe3LyDn0s+Vtt3UMDr8uH37NqtXr+bMmTOoVCoEQSA7OxsPDw/mzJmDu7vp5WR7VqnwODIjIwNBEAgMDGT16tXVbVctj4hRR77xxhslzkVHR+Ph4QHApk2bSr3uzpiiNTYyx0bY+4dzb24344ZY18d51TmSZoiqc5a9xmAzYAbIlWj++IX7298BoaiKlzk2wvbNLaR+XLzTYj/vANlfLkN99SxIZbhsukHStJLVsuvWRO6+2Ry0ahqEVb0W5pPGaGcnOTmZ5s2bM2rUKCQSCYIgEBcXx+TJk41d9lhY95lIwcUfRaPcWmHZYyQpi7xBp0U1eQ2WvcaQf/J/5d5HZueGNu2OeKDXIeRnIa1rjz67aPhRx2Mo6pu/gvYZGX6Eh4eza9cuNm3ahL+/P23atMHCwoLu3btXqRHKtp5Y9ZlI6iIx3ZdFhz4om3bGcZmYqVmirIM+KwUAu/fCkDk1QSJXIHNwx/ETUVE899B68o7/l1JzyT1U6cgbtkH12lJSAwdV6Ts8bcpdfOXn58eAAQMIDAzEwcGhyhddyRu1x3b6BtI+GYo+p2gWKO9ECFlhi0qUTw8aA5RdterS7yC3b4A6XRx+SCzrGe4rtWuA/ZwwMtZPRZd8o0rf42lToXkvFxcX1q5di6enJ4MHV34T6wNk9g2xf283GeunoL37h+F8YVwklh7DkNYThx8Sa1tkDhXrIRec/x4rTzGljKXHMAovHRfvYaXC4d/hZO5eiPrKmSp7B1OhWqIfDzo7tm/txKKtp9hGZd4j68ulIBOn9fIitlF/2gYsuw9Bm/rXlJpOS8oCURresscIbIbMFdtmnZb7O95F88cvhmeU9UWisMBu5nYUTTqiz8kgfe0EdPduUnfYv7EZ8j7apGuGommBg9BnpdSIzk5tGKuGUC1hrLQppS+Wkj/3AkJBLjZTN5K5sOKprOvN/Y6cHTPQpxUpAEis66P6KJLMAC8QBFQLj5P5cW8ErRp5065o40+CTEG99w+QfzAITVxEmfe3336/wraYKk9014v2ys9I7YuP6aSOTbAeuxppXQcEdR45we+gT7pa7r0U7fqiuXQMIVd0gubSMRTtfVCfDRedCKDToL0Vg9SuapM7mSJGOzs6nY6wsDDWrFnD+fPni/32IDVlZbGZ+Bm5//MnM8CLvL0fYTPuPxW6Tmrrij7jjuFYn/EnUtviC7UkliqUHQeg+e14ldhqyhj9IhcuXEhBQQEdOnRg2bJldOvWjXnzRE2Pn376qcw0lRXGwhp58+7UfTP4IYvEYK9Fz7HU8RFnlmROTan77l7QatCnJpC9fhyljxcf+lsqw2b6NgoiNqNPTaicnWaAUUfGxMQYcumMGzeOJUuWMGvWLIKCgiqkRVEeEokUIS+TzCUl1QIKT4VSeCoUKL2N1Gf8iaJVL8Ox1NYNTXyR1JP1xM/QJV+nIGJjpe00B4xWrRqNxvC3XC4nICCA1q1bM2HCBPLyKt9lFwqy0aUmoOw6xHBO1rB9ha7VXDqCop03EisVEisVinbeaC4dAcBy2AIklvXIC/ug0jaaDcYSDMyZM0c4fvx4ifN79+4V2rZtWxU5DGqpIh55HOnv78/KldWXA7yWx6NawliapV0qZ5XSGvm0MLSflz2xLWnVB2mbvui+rrzCuuJD81emNdrZSUpKokWLFk8kjFUM2wYIuRnIBi1G4vwcwt3f0f24CjRF2T2kHYeg/+3H6rXDjDDa2dm/fz/t27dn06ZN1K1bFw8PD0MYq6pDWQ8jkcqQuLZGf/5LtNteQ9DkI31hUpHRPaeAXosQ92QV80yZpx7GKg0h6x5k3UP4M048/v0I0hf8AJA8/wqSli+iCylZ7T/LVGiK7kEYKzIy8slslMlNQ8hKBrvGkJ6ApGl3hNQbSJq9gKyHH9r/TgVtbWbIh6mW6EelOzsAzs8hG7gQiUyBcP82um8XI58cAnIF5ImyEfo7segPBVb6UTWhs1MbxqohVEv0I/e9yq13lahcqDMrnPyVfUFTgMWEDeh+P4a0eQ90v0Wgi6naTo51UAV0lU0ck0sqaEAqB0UdkMpAYYmQ+Wwp6zwqJulIITMJTeRmrD46g9Xi81CQje7KCQCUL/tj+f6PKIcsAlnN2RZXWR7ZkVWxeadcLFXI2/cjb+kL5C3uCkorZP8YhubgJ+R/4kX+p6+AlQpF3+pND2NOGG0jO3fubJCFfdAnKigoMJy/cKF6enuy53qhT0+EXHEZoy72ELImXdGd/0osoFOjPbsXhdf0anm+OWLUkcOHDyc7Oxt/f38cHERZBm9vb44ePVqtRgkZd5A17iy2kZoCpC17ok+MQVLXCSFb3Ccp79AffVLVSh+aNeWFR2JjY4Xx48cLwcHBgk6nE7y9vasvFlPLY1OhcaReryckJITDhw9z69YtoqKiyrukSoiOjiYwMBCtVoutrS0hISFcv36d2bNnG8okJiby9ttv4+fn90RsMlUeaULg3r17DBo0iOjoaKPlhJuVX+yUlZPHv2avYOuyt3Fzsiftfhb29YtvrtXp9PQe68+ez+bRwNn+sZ8laVJ2pktzwWgbWVo8Uq1WG86XFY+sCr47dhbfnp1xcxId9HcnApy++Dvuro6VcmJNwWS21f2dm7eT0ep0jJ+7mty8AiYM7ctQ3x7Fynwf+QsDvYzvu3xWMDqODA8PfyrxSACtTselqwlsDniL7YHvsPF/B7lxu2h2R63RcvTMrwzw7FqtdpgLJhWPDP3mGPsOiavEB3h2xVZlg1UdC6zqWNC1Q0viryfStKGYQOLkL3G0bdEIB9vKJ6WoCZhUPHLs4D6MHdwHgGu37hKwfjdanQ6NRkvM5RtMHO5jKHsw8iwDvaq3VjAnTDqMtW3bNvbv349UKmXkyJGGIUZ+fj5eXl5ERERUm86zuWHSjqyl4lRLPHJx65I56sasD+ds6Aau/3yk1GsadvonQ5ZtYf3A5wF4YfJ7tHtpFHKlBb9HfE3kuo+LlW/S3ZNOwyby9bziUhGzDsWxc4IPOSlJ2Di64Lcrgs9fKr56vU69+sz49iJBvZuI9l7WYO48kW119Rs0xrVNJ+78erbEb619huDz3lKs7ZwIfUPcOtC8pw/2TVqydVQPJBIJ/9r4FY279iLhXPkzSjb2zuSkJAGQk5KEtZ1TiTJdRk7ijxM/lDhvzhh1ZEhICC+//DJ2dnYkJCQwf/584uPjadq0KUuXLqVVq1blPkBpZc2ra/dyePkcCnOzS/x+OeIAlyMO0LhrL7zfXsyuyQNo3tOX5j19eOOrc4Z72DVuScK5KKbuOYVcaYHSyhpLlZ2hzE//mce1qJ/KtaeJR286j5jEjrFe5ZY1J4w6cvfu3YwbJyZWWLZsGX5+fvj6+hIdHc2iRYsICwszenOpXM6ra/cS++1ufv/pa6NlE85FYduoGVb17UEi4eSWlZzfs7VEuW2jewJlV605acnYOLoYqtbc9CJtEOfnOjA4YDOh0waRf//x8siaKkYnBLRareHvtLQ0fH19AfDw8CA3t3x1uCFLt5J67TKnd5aeDtSuUZGCjmvbzsgUSvLup3Et6kc6D/dDaWUNQF0nN6ztHMt/GyD+6Hd0GjoegE5DxxN/RNwWqHJ1Z/S6vXz170mk3Sx/R7S5YfSLHDBgAB988AEzZ87E19eXnTt30q9fP06fPo2bm/Ht3I269KTj0HEkx8caqr8jn36IylXcen5uzxba9BtGxyHj0Gu1aArz+XL2WACunYrAoVkbpoSJbaI6L4f9cyeSm55S7gtFbV3JqE9303nEJDLvJrLvXTEvT+8ZH2JZ356BC9cBoNdp2TLyn+Xez1wod/gRHh5OWFgYt27dQq1W4+rqio+PD6+//nq1jeGCg4PZt28fgiAwatSoUkNUpYW4nmUeeRw5d+5cVq1aZbRMZTSWryTlMCcsjr0zuqGQSXj9i4ssGtqaJg5FiQqz8jW8tukcWyZ1xq1+HdJy1NjbPP5CrJqgsfzIYazo6OhqDWNdT8mlo7sKS6WoVNCtqS0Rl1KKiWV/dzEZn3ZOuNUXxdAq48SagsmFsVo627Dmh2tk5Gqoo5ByIj6V9g2LT4zfTM1Dq9czYct5cgt1jO/pztAuz7b0kklkh3yYiohl6/QCl+5k88XULhRqdIzZeI6O7iqaOlqVcdeaj0mFsR4wspsbI7uJveJPf/gD57/0JB/gorLA1toeK6UMK6WMrk3rE5+U/Uw78qlmhyyL8sSyvds6cv7mfbQ6PflqHTGJWTRztK52u0yZao1+XLt2jfnz53PpkqiFPKUMLeQ5c+YQFxeHQqGgQ4cO3Lx5k8zMTORyOfPmzaNHjx7s3r0bEEXOoOwQ1wPi4uKYN28eBQUF9O7dmwULFiCRSFixYgXHjh1DoVDQqFEjli9fXiWKCU+d6lxrmZqaKvz6669CUFCQsG3btjLLRUZGCnq9XtDr9cLs2bOF0NDQCj9j7dq1Qnh4eInzI0aMEC5cuCDo9XphypQpQmRkpCAIgnDy5ElBo9EIgiAIK1euFFauXPmIb2WaVE/0Iy8VAHtLsG/hxvEINWhyDef/Tu9u7SBfzDn+fOtmJN++AXmp5OXnE7DiU65cvYZOp2PW9Cn49PlblixNHqizi937XkoqOdmZdG7lDvlpDH2pL0d+OEjvbu3o1aU1qO+DGjq1acbhiGPV8i940pjUbiyNRsuBgz/w4gt/pX/ZFsw/u/2D8NDt7Nq6jlVr1pP3l8KsMZLvpeDiVBS+cnF2JPleyem98AMH8ezZo8R5c8ToF5mYmMiGDRtwcnJi2rRpLF++nIsXL9KsWTP8/f1p2LBhlRqzZPlqunbpSNcunQCIOn2Wo8ej2LFLVBcoVKu5e1dcJun/oRhoTk1LR6FQEBy6F4Cdm9dSWqMv+Ztm1sZtwchkMga/3K9K3+FpYdSRH3zwAQMHDiQnJ4fRo0czfPhwZs6cSVRUFPPnz2fXrl0lrgkNDWVvmPiP37JuNc5OFYtafL55B+kZ9/n8w+I5AdauXkazJo1LlD+wR8wouW7Tdhq4uTB88EDDbxqNhqR7ReGrpOQUnBwdDMdfffM9kSdOsXPz2hIONleMVq25ubm89tprTJs2jZycHCZPnoyrqyujRo0iKyur1GvGjh3LgT3BHNgTXGEn7tv/DVE/RxO0fEkxLedePboTEvalYUvfb5evVOh+To4OWFtZcTEmDkEQ+Pq7w/TtLWaSPHHqDFt3hrJxzQosLeuUcyfzwagjpVIpN27cICYmhvz8fGJjYwFISEio0MRASmoanv2H8kVIGBu3BuPZfyg5OWIc8/VZcwzt1qLA1aSmpzN64jSGjJ7I55t3ADDj9UlotToGvzqBV0aO47MNJQPNZbF4/vt8+PEn+A5+lUbubnj2EtvCgBVB5OblMenNdxkyeiILl9aMvHpGx5GnT59m8eLFSKVSAgICCA4OJj4+nuzsbAICAvDx8Snr0lqeMI88ITB9+nQ2btxYrAr8O9/1EiMXdh1fRJufQ6cPd3JiQkmN5Ydx6vkKzV59hzPv+FbIDkuXxnRasIPTbxXXj2w87A3qNX+e2NUzcOs7GhfPoVxY9C/qtexEYXoyhWl3qdu0HR5Bh4gYJga5X4kyf43lRw5jnT171pACu7wwVvqvJ7F0KdlRKY0GPmP4M2JP0XG/sTQdOQuJQsn9384S+5+Z8JCOZVk49xrClR1LALgb+SXtZ68FIOvqRUOZ7BuixrJUoURfQ+R5TSI7pNTCEkeP/sQFvQWATePWuPV9lVNvihrL7ed8ToN+Y7lzuHyN5TqObhTcE/PmCDodmtxMFCp7NJlFImeuXiPIvPp/NcaJUI4j9+/f/0TCWM49B5ER+zOa7AwAHP7hjapVF3ptEzfUyiwsUWeIw4mugeFYujZBKldi6dyIF78Q1Q9u7FvH7e93lj6ceKj1sGnaltZvLid69jOksfykwlgNfEZzJ+KhpZUSCbcP7eLy5pIay+fmixrLZbWR+ffuUMfJnYKUO0hkMhTWKjR/aSzXcWxA18BwLi71I+/PZ0hj+QHVGcaSW9fDrpMnyScPGM6lnj+Kq9cIlH9pLCvq2mLpXDGN5eRT3+D+kqix7Oo1ktQL4lyq3EZF91XfcnnTAjJia57G8iNNmnt5eeHl5VXh8p0Xh2LfqTfK+g703Z/Ale1LkMjFfSG3DmwGwMVzGClnf0JXUKRakHPzdy5vXYjHp4eRSKTodRrigt4iP/lWqc95mMTvdtDpo130CYtHk5XOhcWvAdBkxEysGrSgpd8CWvqJX3r07AGo75e/xNIcqN2NVUMwqehHLY9PrSNrCLWOrCGYjSNPnDhB//798fX1ZcuWLU/bHNPjqS0yeQS0Wq3Qt29f4datW0JhYaEwaNAg4erVq0/bLJPCLL7ImJgYGjdujLu7O0qlkoEDB3LkSOlb2J9VzMKRycnJuLi4GI6dnZ1JTq5Njf0wZuFIoZShbk1ZolFVmIUjXVxcSEpKMhwnJyfj5FQyycOzjFk48sHq88TERNRqNQcPHsTb2/tpm2VSPFHV88dFLpezcOFCpk6dik6nY8SIEbRs2fJpm2VS1M611hDMomqtpXxqHVlDqHVkDaHWkTWEWkfWEGodWUOodWQNodaRNYT/B4c06r2hSKo6AAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f3fcbf12828>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# define  figure size\n",
    "plt.rcParams[\"figure.figsize\"] = (1,7)\n",
    "\n",
    "# display xi\n",
    "sns.heatmap(DataFrame(xi), cmap='Oranges', annot=True, linewidths=.5);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Testing\n",
    "\n",
    "To confirm that your slam code works before submitting your project, it is suggested that you run it on some test data and cases. A few such cases have been provided for you, in the cells below. When you are ready, uncomment the test cases in the next cells (there are two test cases, total); your output should be **close-to or exactly** identical to the given results. If there are minor discrepancies it could be a matter of floating point accuracy or in the calculation of the inverse matrix.\n",
    "\n",
    "### Submit your project\n",
    "\n",
    "If you pass these tests, it is a good indication that your project will pass all the specifications in the project rubric. Follow the submission instructions to officially submit!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "Estimated Poses:\n",
      "[50.000, 50.000]\n",
      "[37.973, 33.652]\n",
      "[26.185, 18.155]\n",
      "[13.745, 2.116]\n",
      "[28.097, 16.783]\n",
      "[42.384, 30.902]\n",
      "[55.831, 44.497]\n",
      "[70.857, 59.699]\n",
      "[85.697, 75.543]\n",
      "[74.011, 92.434]\n",
      "[53.544, 96.454]\n",
      "[34.525, 100.080]\n",
      "[48.623, 83.953]\n",
      "[60.197, 68.107]\n",
      "[73.778, 52.935]\n",
      "[87.132, 38.538]\n",
      "[80.303, 20.508]\n",
      "[72.798, 2.945]\n",
      "[55.245, 13.255]\n",
      "[37.416, 22.317]\n",
      "\n",
      "\n",
      "Estimated Landmarks:\n",
      "[82.956, 13.539]\n",
      "[70.495, 74.141]\n",
      "[36.740, 61.281]\n",
      "[18.698, 66.060]\n",
      "[20.635, 16.875]\n"
     ]
    }
   ],
   "source": [
    "# Here is the data and estimated outputs for test case 1\n",
    "\n",
    "test_data1 = [[[[1, 19.457599255548065, 23.8387362100849], [2, -13.195807561967236, 11.708840328458608], [3, -30.0954905279171, 15.387879242505843]], [-12.2607279422326, -15.801093326936487]], [[[2, -0.4659930049620491, 28.088559771215664], [4, -17.866382374890936, -16.384904503932]], [-12.2607279422326, -15.801093326936487]], [[[4, -6.202512900833806, -1.823403210274639]], [-12.2607279422326, -15.801093326936487]], [[[4, 7.412136480918645, 15.388585962142429]], [14.008259661173426, 14.274756084260822]], [[[4, -7.526138813444998, -0.4563942429717849]], [14.008259661173426, 14.274756084260822]], [[[2, -6.299793150150058, 29.047830407717623], [4, -21.93551130411791, -13.21956810989039]], [14.008259661173426, 14.274756084260822]], [[[1, 15.796300959032276, 30.65769689694247], [2, -18.64370821983482, 17.380022987031367]], [14.008259661173426, 14.274756084260822]], [[[1, 0.40311325410337906, 14.169429532679855], [2, -35.069349468466235, 2.4945558982439957]], [14.008259661173426, 14.274756084260822]], [[[1, -16.71340983241936, -2.777000269543834]], [-11.006096015782283, 16.699276945166858]], [[[1, -3.611096830835776, -17.954019226763958]], [-19.693482634035977, 3.488085684573048]], [[[1, 18.398273354362416, -22.705102332550947]], [-19.693482634035977, 3.488085684573048]], [[[2, 2.789312482883833, -39.73720193121324]], [12.849049222879723, -15.326510824972983]], [[[1, 21.26897046581808, -10.121029799040915], [2, -11.917698965880655, -23.17711662602097], [3, -31.81167947898398, -16.7985673023331]], [12.849049222879723, -15.326510824972983]], [[[1, 10.48157743234859, 5.692957082575485], [2, -22.31488473554935, -5.389184118551409], [3, -40.81803984305378, -2.4703329790238118]], [12.849049222879723, -15.326510824972983]], [[[0, 10.591050242096598, -39.2051798967113], [1, -3.5675572049297553, 22.849456408289125], [2, -38.39251065320351, 7.288990306029511]], [12.849049222879723, -15.326510824972983]], [[[0, -3.6225556479370766, -25.58006865235512]], [-7.8874682868419965, -18.379005523261092]], [[[0, 1.9784503557879374, -6.5025974151499]], [-7.8874682868419965, -18.379005523261092]], [[[0, 10.050665232782423, 11.026385307998742]], [-17.82919359778298, 9.062000642947142]], [[[0, 26.526838150174818, -0.22563393232425621], [4, -33.70303936886652, 2.880339841013677]], [-17.82919359778298, 9.062000642947142]]]\n",
    "\n",
    "##  Test Case 1\n",
    "##\n",
    "# Estimated Pose(s):\n",
    "#     [50.000, 50.000]\n",
    "#     [37.858, 33.921]\n",
    "#     [25.905, 18.268]\n",
    "#     [13.524, 2.224]\n",
    "#     [27.912, 16.886]\n",
    "#     [42.250, 30.994]\n",
    "#     [55.992, 44.886]\n",
    "#     [70.749, 59.867]\n",
    "#     [85.371, 75.230]\n",
    "#     [73.831, 92.354]\n",
    "#     [53.406, 96.465]\n",
    "#     [34.370, 100.134]\n",
    "#     [48.346, 83.952]\n",
    "#     [60.494, 68.338]\n",
    "#     [73.648, 53.082]\n",
    "#     [86.733, 38.197]\n",
    "#     [79.983, 20.324]\n",
    "#     [72.515, 2.837]\n",
    "#     [54.993, 13.221]\n",
    "#     [37.164, 22.283]\n",
    "\n",
    "\n",
    "# Estimated Landmarks:\n",
    "#     [82.679, 13.435]\n",
    "#     [70.417, 74.203]\n",
    "#     [36.688, 61.431]\n",
    "#     [18.705, 66.136]\n",
    "#     [20.437, 16.983]\n",
    "\n",
    "\n",
    "### Uncomment the following three lines for test case 1 and compare the output to the values above ###\n",
    "\n",
    "mu_1, _, _ = slam(test_data1, 20, 5, 100.0, 2.0, 2.0)\n",
    "poses, landmarks = get_poses_landmarks(mu_1, 20)\n",
    "print_all(poses, landmarks)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "Estimated Poses:\n",
      "[50.000, 50.000]\n",
      "[69.181, 45.665]\n",
      "[87.743, 39.703]\n",
      "[76.270, 56.311]\n",
      "[64.317, 72.176]\n",
      "[52.257, 88.154]\n",
      "[44.059, 69.401]\n",
      "[37.002, 49.918]\n",
      "[30.924, 30.955]\n",
      "[23.508, 11.419]\n",
      "[34.180, 27.133]\n",
      "[44.155, 43.846]\n",
      "[54.806, 60.920]\n",
      "[65.698, 78.546]\n",
      "[77.468, 95.626]\n",
      "[96.802, 98.821]\n",
      "[75.957, 99.971]\n",
      "[70.200, 81.181]\n",
      "[64.054, 61.723]\n",
      "[58.107, 42.628]\n",
      "\n",
      "\n",
      "Estimated Landmarks:\n",
      "[76.779, 42.887]\n",
      "[85.065, 77.438]\n",
      "[13.548, 95.652]\n",
      "[59.449, 39.595]\n",
      "[69.263, 94.240]\n"
     ]
    }
   ],
   "source": [
    "# Here is the data and estimated outputs for test case 2\n",
    "\n",
    "test_data2 = [[[[0, 26.543274387283322, -6.262538160312672], [3, 9.937396825799755, -9.128540360867689]], [18.92765331253674, -6.460955043986683]], [[[0, 7.706544739722961, -3.758467215445748], [1, 17.03954411948937, 31.705489938553438], [3, -11.61731288777497, -6.64964096716416]], [18.92765331253674, -6.460955043986683]], [[[0, -12.35130507136378, 2.585119104239249], [1, -2.563534536165313, 38.22159657838369], [3, -26.961236804740935, -0.4802312626141525]], [-11.167066095509824, 16.592065417497455]], [[[0, 1.4138633151721272, -13.912454837810632], [1, 8.087721200818589, 20.51845934354381], [3, -17.091723454402302, -16.521500551709707], [4, -7.414211721400232, 38.09191602674439]], [-11.167066095509824, 16.592065417497455]], [[[0, 12.886743222179561, -28.703968411636318], [1, 21.660953298391387, 3.4912891084614914], [3, -6.401401414569506, -32.321583037341625], [4, 5.034079343639034, 23.102207946092893]], [-11.167066095509824, 16.592065417497455]], [[[1, 31.126317672358578, -10.036784369535214], [2, -38.70878528420893, 7.4987265861424595], [4, 17.977218575473767, 6.150889254289742]], [-6.595520680493778, -18.88118393939265]], [[[1, 41.82460922922086, 7.847527392202475], [3, 15.711709540417502, -30.34633659912818]], [-6.595520680493778, -18.88118393939265]], [[[0, 40.18454208294434, -6.710999804403755], [3, 23.019508919299156, -10.12110867290604]], [-6.595520680493778, -18.88118393939265]], [[[3, 27.18579315312821, 8.067219022708391]], [-6.595520680493778, -18.88118393939265]], [[], [11.492663265706092, 16.36822198838621]], [[[3, 24.57154567653098, 13.461499960708197]], [11.492663265706092, 16.36822198838621]], [[[0, 31.61945290413707, 0.4272295085799329], [3, 16.97392299158991, -5.274596836133088]], [11.492663265706092, 16.36822198838621]], [[[0, 22.407381798735177, -18.03500068379259], [1, 29.642444125196995, 17.3794951934614], [3, 4.7969752441371645, -21.07505361639969], [4, 14.726069092569372, 32.75999422300078]], [11.492663265706092, 16.36822198838621]], [[[0, 10.705527984670137, -34.589764174299596], [1, 18.58772336795603, -0.20109708164787765], [3, -4.839806195049413, -39.92208742305105], [4, 4.18824810165454, 14.146847823548889]], [11.492663265706092, 16.36822198838621]], [[[1, 5.878492140223764, -19.955352450942357], [4, -7.059505455306587, -0.9740849280550585]], [19.628527845173146, 3.83678180657467]], [[[1, -11.150789592446378, -22.736641053247872], [4, -28.832815721158255, -3.9462962046291388]], [-19.841703647091965, 2.5113335861604362]], [[[1, 8.64427397916182, -20.286336970889053], [4, -5.036917727942285, -6.311739993868336]], [-5.946642674882207, -19.09548221169787]], [[[0, 7.151866679283043, -39.56103232616369], [1, 16.01535401373368, -3.780995345194027], [4, -3.04801331832137, 13.697362774960865]], [-5.946642674882207, -19.09548221169787]], [[[0, 12.872879480504395, -19.707592098123207], [1, 22.236710716903136, 16.331770792606406], [3, -4.841206109583004, -21.24604435851242], [4, 4.27111163223552, 32.25309748614184]], [-5.946642674882207, -19.09548221169787]]] \n",
    "\n",
    "\n",
    "##  Test Case 2\n",
    "##\n",
    "# Estimated Pose(s):\n",
    "#     [50.000, 50.000]\n",
    "#     [69.035, 45.061]\n",
    "#     [87.655, 38.971]\n",
    "#     [76.084, 55.541]\n",
    "#     [64.283, 71.684]\n",
    "#     [52.396, 87.887]\n",
    "#     [44.674, 68.948]\n",
    "#     [37.532, 49.680]\n",
    "#     [31.392, 30.893]\n",
    "#     [24.796, 12.012]\n",
    "#     [33.641, 26.440]\n",
    "#     [43.858, 43.560]\n",
    "#     [54.735, 60.659]\n",
    "#     [65.884, 77.791]\n",
    "#     [77.413, 94.554]\n",
    "#     [96.740, 98.020]\n",
    "#     [76.149, 99.586]\n",
    "#     [70.211, 80.580]\n",
    "#     [64.130, 61.270]\n",
    "#     [58.183, 42.175]\n",
    "\n",
    "\n",
    "# Estimated Landmarks:\n",
    "#     [76.777, 42.415]\n",
    "#     [85.109, 76.850]\n",
    "#     [13.687, 95.386]\n",
    "#     [59.488, 39.149]\n",
    "#     [69.283, 93.654]\n",
    "\n",
    "\n",
    "### Uncomment the following three lines for test case 2 and compare to the values above ###\n",
    "\n",
    "mu_2, _, _ = slam(test_data2, 20, 5, 100.0, 2.0, 2.0)\n",
    "poses, landmarks = get_poses_landmarks(mu_2, 20)\n",
    "print_all(poses, landmarks)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}