exploration.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib.patches import Rectangle, Arrow\n",
    "from matplotlib.animation import FuncAnimation\n",
    "from tqdm import tqdm\n",
    "import queue\n",
    "import cv2\n",
    "import time\n",
    "import pickle\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "P_TRUE = 0.90\n",
    "FREESPACE_ALPHA = 0.05\n",
    "PAD = 1e-6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class OccupancySpace:\n",
    "    \n",
    "    def __init__(self, x, y, freespace):\n",
    "        self.x = x\n",
    "        self.y = y\n",
    "        self.freespace = freespace\n",
    "        \n",
    "    def __str__(self):\n",
    "        return f'({self.x}, {self.y})'\n",
    "\n",
    "class Pose(OccupancySpace):\n",
    "    THETA_LIST = [i * np.pi / 2 for i in range(0, 4)]\n",
    "    \n",
    "    def __init__(self, x, y, theta):\n",
    "        super().__init__(x, y, freespace=1e-6)\n",
    "        self.theta = theta\n",
    "        self.cost = np.inf\n",
    "        self.parent = None\n",
    "        \n",
    "    def compute_cost(self, other):\n",
    "        dtheta = (self.theta - other.theta)\n",
    "        if abs(dtheta) > np.pi:\n",
    "            dtheta = abs(dtheta) - np.pi\n",
    "        return np.linalg.norm([self.x - other.x, self.y - other.y, 1*dtheta])\n",
    "    \n",
    "    def get_neighbors(self, grid, cell_width=0.5):\n",
    "        ret = []\n",
    "        \n",
    "        dx, dy = cell_width * round(np.cos(self.theta)), cell_width * round(np.sin(self.theta)) # compute possible dx, dy based on theta (can only drive straight)\n",
    "        # NEED TO FIX THIS\n",
    "        if  self.x + dx >= 0 and self.y + dy >= 0 \\\n",
    "            and self.x + dx < grid.xoffset + grid.xlim \\\n",
    "            and self.y + dy < grid.yoffset + grid.ylim \\\n",
    "            and grid.pose_grid[(self.x + dx, self.y + dy)].freespace <= FREESPACE_ALPHA:\n",
    "            # print((self.x + dx, self.y + dy), grid.pose_grid[(self.x + dx, self.y + dy)].freespace)\n",
    "            ret.append((self.x + dx, self.y + dy, self.theta))\n",
    "            \n",
    "        for t in Pose.THETA_LIST: # add in turns\n",
    "            if self.theta != t:\n",
    "                ret.append((self.x, self.y, t))\n",
    "\n",
    "        return ret\n",
    "                       \n",
    "    def __lt__(self, other):\n",
    "        return self.cost < other.cost # for priority queue\n",
    "    \n",
    "    def __str__(self):\n",
    "        return f'({self.x}, {self.y}, {self.theta})'\n",
    "    \n",
    "    def round(self, cell_width=0.5):\n",
    "        \"\"\"Truncates, not round...\"\"\"\n",
    "        self.x = int(self.x / cell_width) * cell_width\n",
    "        self.y = int(self.y / cell_width) * cell_width\n",
    "        self.theta = round(self.theta * 4 / np.pi) / 4 * np.pi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class OccupancyGrid:\n",
    "    \n",
    "    def __init__(self, grid_array, xoffset=0, yoffset=0, cell_width=0.5):\n",
    "        self.xoffset = xoffset\n",
    "        self.yoffset = yoffset\n",
    "        self.cell_width = cell_width\n",
    "        self.make_map(grid_array)\n",
    "    \n",
    "    def make_map(self, grid_array):\n",
    "        self.pose_grid = {}\n",
    "        for x in range(grid_array.shape[0]):\n",
    "            for y in range(grid_array.shape[1]):\n",
    "                self.pose_grid[(x * self.cell_width + self.xoffset, y * self.cell_width + self.yoffset)] = OccupancySpace(x * self.cell_width + self.xoffset, y * self.cell_width + self.yoffset, freespace=grid_array[x,y])\n",
    "        \n",
    "        self.xlim = grid_array.shape[0] * self.cell_width\n",
    "        self.ylim = grid_array.shape[1] * self.cell_width\n",
    "    \n",
    "    def get_freespace(self, x, y):\n",
    "        return self.pose_grid[(x,y)].freespace        \n",
    "    \n",
    "    def to_idx(self, position):\n",
    "        x, y = position\n",
    "        return int(x / self.cell_width - self.xoffset), int(y / self.cell_width - self.yoffset)\n",
    "    \n",
    "    def to_array(self):\n",
    "        new_grid = np.zeros((int(self.xlim / self.cell_width), int(self.ylim / self.cell_width)))\n",
    "        for x,y in self.pose_grid:\n",
    "            i,j = self.to_idx((x,y))\n",
    "            new_grid[i,j] = self.pose_grid[(x,y)].freespace\n",
    "            \n",
    "        return new_grid\n",
    "    \n",
    "    def get_freespace_nodes(self):\n",
    "        positions = []\n",
    "        for x,y in self.pose_grid:\n",
    "            if self.pose_grid[(x,y)].freespace <= FREESPACE_ALPHA:\n",
    "                for theta in Pose.THETA_LIST:\n",
    "                    positions.append((x,y,theta))\n",
    "        \n",
    "        return positions\n",
    "        \n",
    "\n",
    "class ExplorationGrid(OccupancyGrid):\n",
    "    \n",
    "    def __init__(self, grid_array, explore_grid, ptrue, xoffset=0, yoffset=0, cell_width=0.5):\n",
    "        super().__init__(grid_array, xoffset, yoffset, cell_width)\n",
    "        self.ptrue = ptrue\n",
    "        self.explore_grid = OccupancyGrid(explore_grid, xoffset, yoffset, cell_width)\n",
    "    \n",
    "    def occupied_update(self, pij):\n",
    "        return self.ptrue * pij / (self.ptrue * pij + (1 - self.ptrue) * (1 - pij))\n",
    "    \n",
    "    def unoccupied_update(self, pij):\n",
    "        return 1 - self.ptrue * (1 - pij) / (self.ptrue * (1 - pij) + (1 - self.ptrue) * pij)\n",
    "    \n",
    "    def measurement_update(self, o, x, y):\n",
    "        pij = self.explore_grid.pose_grid[(x,y)].freespace\n",
    "        if o > 0.5:\n",
    "            self.explore_grid.pose_grid[(x,y)].freespace = self.occupied_update(pij)\n",
    "        else:\n",
    "            self.explore_grid.pose_grid[(x,y)].freespace = self.unoccupied_update(pij)  \n",
    "            \n",
    "    def E(self, x, y):\n",
    "        pij = self.explore_grid.pose_grid[(x,y)].freespace\n",
    "        return -P_TRUE * pij * np.log(P_TRUE * pij / (P_TRUE * pij + (1-P_TRUE) * (1-pij)) + PAD) - P_TRUE * (1-pij) * np.log(P_TRUE * (1-pij) / (P_TRUE * (1-pij) + (1-P_TRUE) * pij) + PAD)\n",
    "            \n",
    "    def Hp(self, x, y):\n",
    "        pij = self.explore_grid.pose_grid[(x,y)].freespace\n",
    "        return -pij * np.log(pij + PAD) - (1-pij) * np.log(1-pij + PAD)\n",
    "    \n",
    "\n",
    "    def EIG(self, x, y):\n",
    "        return self.Hp(x,y) - self.E(x,y)\n",
    "    \n",
    "        \n",
    "    def plot(self, axs, start=None, goal=None, path=None):\n",
    "        assert len(axs) == 2\n",
    "        \n",
    "        visualize(self, axs[0], start=start, goal=goal, path=path)\n",
    "        visualize(self.explore_grid, axs[1], start=start, goal=goal, path=path)\n",
    "        axs[0].set_title('Occupancy Grid')\n",
    "        axs[1].set_title('Exploration Grid')\n",
    "\n",
    "\n",
    "def visualize(grid, ax, start=None, goal=None, path=None):\n",
    "        grid_array = grid.to_array()\n",
    "        ax.imshow(1 - grid_array.T, \n",
    "                    aspect='equal', \n",
    "                    cmap='gray',\n",
    "                    extent=[0, grid_array.shape[0] * grid.cell_width, 0, grid_array.shape[1] * grid.cell_width], \n",
    "                    origin='lower',\n",
    "                    vmin=0,\n",
    "                    vmax=1)\n",
    "                \n",
    "        if start != None:\n",
    "            ax.add_patch(Rectangle((start.x, start.y), grid.cell_width, grid.cell_width, linewidth=1, edgecolor='Red', facecolor='Red'))\n",
    "            ax.add_patch(Arrow(start.x,\n",
    "                                start.y,\n",
    "                                0.2 * np.cos(start.theta),\n",
    "                                0.2 * np.sin(start.theta),\n",
    "                                width=0.6,\n",
    "                                edgecolor='Blue',\n",
    "                                facecolor='Blue'))\n",
    "        \n",
    "        if goal != None: ax.add_patch(Rectangle((goal.x, goal.y), grid.cell_width, grid.cell_width, linewidth=1, edgecolor='Green', facecolor='Green'))\n",
    "        \n",
    "        if path != None: # draw the path\n",
    "            for node in path:\n",
    "                ax.add_patch(Arrow(node.x,\n",
    "                                node.y,\n",
    "                                0.2 * np.cos(node.theta),\n",
    "                                0.2 * np.sin(node.theta),\n",
    "                                width=0.6,\n",
    "                                edgecolor='Blue',\n",
    "                                facecolor='Blue'))\n",
    "        \n",
    "        ax.set_xlabel('x')\n",
    "        ax.set_ylabel('y')\n",
    "        # ax.set_xticks(np.arange(grid.xoffset, grid.xlim + grid.xoffset + grid.cell_width, grid.cell_width))\n",
    "        # ax.set_yticks(np.arange(grid.yoffset, grid.ylim + grid.yoffset + grid.cell_width, grid.cell_width))\n",
    "        ax.set_aspect('equal', adjustable='box')\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x500 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "grid_array = pickle.load(open('maps/map1000.pkl', 'rb'))\n",
    "explore_array = np.ones(grid_array.shape) * 0.5\n",
    "grid = ExplorationGrid(grid_array, explore_array, P_TRUE)\n",
    "fig, axs = plt.subplots(nrows=1, ncols=2)\n",
    "grid.plot(axs)\n",
    "fig.set_size_inches((10,5))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  4%|▍         | 2/50 [00:05<02:21,  2.95s/it]\n"
     ]
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[13], line 10\u001b[0m\n\u001b[1;32m      8\u001b[0m     o \u001b[39m=\u001b[39m \u001b[39m1\u001b[39m \u001b[39m-\u001b[39m o \u001b[39mif\u001b[39;00m np\u001b[39m.\u001b[39mrandom\u001b[39m.\u001b[39mrandom() \u001b[39m>\u001b[39m P_TRUE \u001b[39melse\u001b[39;00m o\n\u001b[1;32m      9\u001b[0m     grid\u001b[39m.\u001b[39mmeasurement_update(o, x, y)\n\u001b[0;32m---> 10\u001b[0m grid\u001b[39m.\u001b[39;49mplot(axs)\n\u001b[1;32m     11\u001b[0m fig\u001b[39m.\u001b[39mset_size_inches((\u001b[39m10\u001b[39m,\u001b[39m4\u001b[39m))\n\u001b[1;32m     12\u001b[0m fig\u001b[39m.\u001b[39mtight_layout()\n",
      "Cell \u001b[0;32mIn[4], line 80\u001b[0m, in \u001b[0;36mExplorationGrid.plot\u001b[0;34m(self, axs, start, goal, path)\u001b[0m\n\u001b[1;32m     77\u001b[0m \u001b[39massert\u001b[39;00m \u001b[39mlen\u001b[39m(axs) \u001b[39m==\u001b[39m \u001b[39m2\u001b[39m\n\u001b[1;32m     79\u001b[0m visualize(\u001b[39mself\u001b[39m, axs[\u001b[39m0\u001b[39m], start\u001b[39m=\u001b[39mstart, goal\u001b[39m=\u001b[39mgoal, path\u001b[39m=\u001b[39mpath)\n\u001b[0;32m---> 80\u001b[0m visualize(\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mexplore_grid, axs[\u001b[39m1\u001b[39;49m], start\u001b[39m=\u001b[39;49mstart, goal\u001b[39m=\u001b[39;49mgoal, path\u001b[39m=\u001b[39;49mpath)\n\u001b[1;32m     81\u001b[0m axs[\u001b[39m0\u001b[39m]\u001b[39m.\u001b[39mset_title(\u001b[39m'\u001b[39m\u001b[39mOccupancy Grid\u001b[39m\u001b[39m'\u001b[39m)\n\u001b[1;32m     82\u001b[0m axs[\u001b[39m1\u001b[39m]\u001b[39m.\u001b[39mset_title(\u001b[39m'\u001b[39m\u001b[39mExploration Grid\u001b[39m\u001b[39m'\u001b[39m)\n",
      "Cell \u001b[0;32mIn[4], line 86\u001b[0m, in \u001b[0;36mvisualize\u001b[0;34m(grid, ax, start, goal, path)\u001b[0m\n\u001b[1;32m     85\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mvisualize\u001b[39m(grid, ax, start\u001b[39m=\u001b[39m\u001b[39mNone\u001b[39;00m, goal\u001b[39m=\u001b[39m\u001b[39mNone\u001b[39;00m, path\u001b[39m=\u001b[39m\u001b[39mNone\u001b[39;00m):\n\u001b[0;32m---> 86\u001b[0m         grid_array \u001b[39m=\u001b[39m grid\u001b[39m.\u001b[39;49mto_array()\n\u001b[1;32m     87\u001b[0m         ax\u001b[39m.\u001b[39mimshow(\u001b[39m1\u001b[39m \u001b[39m-\u001b[39m grid_array\u001b[39m.\u001b[39mT, \n\u001b[1;32m     88\u001b[0m                     aspect\u001b[39m=\u001b[39m\u001b[39m'\u001b[39m\u001b[39mequal\u001b[39m\u001b[39m'\u001b[39m, \n\u001b[1;32m     89\u001b[0m                     cmap\u001b[39m=\u001b[39m\u001b[39m'\u001b[39m\u001b[39mgray\u001b[39m\u001b[39m'\u001b[39m,\n\u001b[0;32m   (...)\u001b[0m\n\u001b[1;32m     92\u001b[0m                     vmin\u001b[39m=\u001b[39m\u001b[39m0\u001b[39m,\n\u001b[1;32m     93\u001b[0m                     vmax\u001b[39m=\u001b[39m\u001b[39m1\u001b[39m)\n\u001b[1;32m     95\u001b[0m         \u001b[39mif\u001b[39;00m start \u001b[39m!=\u001b[39m \u001b[39mNone\u001b[39;00m:\n",
      "Cell \u001b[0;32mIn[4], line 29\u001b[0m, in \u001b[0;36mOccupancyGrid.to_array\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m     27\u001b[0m \u001b[39mfor\u001b[39;00m x,y \u001b[39min\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mpose_grid:\n\u001b[1;32m     28\u001b[0m     i,j \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mto_idx((x,y))\n\u001b[0;32m---> 29\u001b[0m     new_grid[i,j] \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mpose_grid[(x,y)]\u001b[39m.\u001b[39mfreespace\n\u001b[1;32m     31\u001b[0m \u001b[39mreturn\u001b[39;00m new_grid\n",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkYAAAGiCAYAAAAC4AllAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAACb+UlEQVR4nOzdd1gU19cH8O/uwi4gvYOKiijEEEExIGosCWqMiTWJXWNi712JXWOLNZafGkuwiw0ragz2LiiKImIHlSLSpWy77x/qvqKULbO7LJ7P88zzJLsz954dHPYwc++5PMYYAyGEEEIIAV/fARBCCCGElBeUGBFCCCGEvEWJESGEEELIW5QYEUIIIYS8RYkRIYQQQshblBgRQgghhLxFiREhhBBCyFuUGBFCCCGEvEWJESGEEELIW5QYEUIIIYS8RYkRIcTgnT17Fj/88ANcXV3B4/Gwf//+Mo85ffo06tevD5FIBA8PD4SEhGg9TkJI+UeJESHE4L1+/Ro+Pj5YtWqVUvs/fvwYbdu2RYsWLRAdHY1Ro0ahX79+OH78uJYjJYSUdzxaRJYQUpHweDyEhYWhQ4cOJe4zceJEHDlyBLdv31a81rVrV2RmZuLYsWM6iJIQUl4Z6TsAQgjRtUuXLiEoKKjIa61bt8aoUaNKPKawsBCFhYWK/5fL5UhPT4ednR14PJ62QiWElIIxhpycHLi6uoLP5+YhGCVGhJBPTnJyMpycnIq85uTkhOzsbOTn58PU1PSjY+bNm4eZM2fqKkRCiAoSExNRpUoVTtqixIgQQpQQHByMMWPGKP4/KysLbm5uSExMhKWlpR4jI+TTlZ2djapVq8LCwoKzNikxIoR8cpydnZGSklLktZSUFFhaWhZ7twgARCIRRCLRR69bWlpSYkSInnH5OJtmpRFCPjmBgYGIiIgo8tqJEycQGBiop4gIIeUFJUaEEIOXm5uL6OhoREdHA3gzHT86OhoJCQkA3jwG6927t2L/QYMG4dGjR5gwYQLi4uLwv//9D7t27cLo0aP1ET4hpByhxIgQYvAiIyNRr1491KtXDwAwZswY1KtXD9OmTQMAJCUlKZIkAKhRowaOHDmCEydOwMfHB4sXL8b69evRunVrvcRPCCk/qI4RIYSoITs7G1ZWVsjKyqIxRoToiTauQ7pjRAghhBDyFiVGhBBCCCFvUWJECCGEEPIWJUaEEEIIIW9RYkQIIYQQ8hYlRoQQQgghb1FiRAghhBDyFiVGhBBCCCFvUWJECCGEEPIWJUaEEEIIIW9RYkQIIYQQ8hYlRoQQQgghb1FiRAghhBDyFiVGhBBCCCFvUWJECCGEEPIWJUaEEEIIIW9RYkQIIYQQ8hYlRoQQQgghb1FiRAghhBDyFiVGhBBCCCFvUWJECCGEEPIWJUaEEEIIIW9RYkQIIYQQ8hYlRoQQQgghb1FiRAghhBDyFiVGhBBCCCFvUWJECCGEEPIWJUaEEEIIIW9RYkQIIYQQ8hYlRoQQQgghb1FiRAghhBDyFiVGhBBCCCFvUWJECCGEEPIWJUaEEEIIIW9RYkQIIYQQ8hYlRoQQQgghb1FiRAghhBDyFiVGhBBCCCFvUWJECCGEEPIWJUaEEEIIIW9RYkQIIYQQ8hYlRoQQQgghb1FiRAghhBDyFiVGhBBCCCFvUWJECCGEEPIWJUaEEEIIIW9RYkQIIYQQ8hYlRoQQQgghb1FiRAghhBDyFiVGhBBCCCFvUWJECCGEEPIWJUaEEEIIIW9RYkQIIYQQ8hYlRoQQQgghb1FiRAghhBDyFiVGhBBCCCFvUWJECCGEEPIWJUaEEEIIIW9RYkQIIYQQ8hYlRoQQQgghb1FiRAghhBDyll4ToxkzZoDH4xXZvLy8FO8XFBRg6NChsLOzg7m5OTp37oyUlJQibSQkJKBt27YwMzODo6Mjxo8fD6lUquuPQgghhJAKwEjfAXz++ef477//FP9vZPT/IY0ePRpHjhzB7t27YWVlhWHDhqFTp064cOECAEAmk6Ft27ZwdnbGxYsXkZSUhN69e8PY2Bhz587V+WchhBBCiGHT+6M0IyMjODs7KzZ7e3sAQFZWFjZs2IAlS5bg66+/hp+fH/755x9cvHgRly9fBgD8+++/iI2NxdatW+Hr64s2bdpg9uzZWLVqFcRisT4/FiFEx1atWoXq1avDxMQEAQEBuHr1aqn7L1u2DJ6enjA1NUXVqlUxevRoFBQU6ChaQkh5pfc7Rvfv34erqytMTEwQGBiIefPmwc3NDVFRUZBIJAgKClLs6+XlBTc3N1y6dAkNGzbEpUuX8MUXX8DJyUmxT+vWrTF48GDcuXMH9erVK7bPwsJCFBYWKv5fLpcjPT0ddnZ24PF42vuwhJBiMcaQk5MDV1dX8Pmq/70WGhqKMWPGYM2aNQgICMCyZcvQunVr3Lt3D46Ojh/tv337dkyaNAkbN25Eo0aNEB8fj19++QU8Hg9Llizh4iMRQgyUXhOjgIAAhISEwNPTE0lJSZg5cya++uor3L59G8nJyRAKhbC2ti5yjJOTE5KTkwEAycnJRZKid++/e68k8+bNw8yZM7n9MIQQjSUmJqJKlSoqH7dkyRL0798fffv2BQCsWbMGR44cwcaNGzFp0qSP9r948SIaN26M7t27AwCqV6+Obt264cqVK5p9AEKIwdNrYtSmTRvFf9etWxcBAQGoVq0adu3aBVNTU631GxwcjDFjxij+PysrC25ubkhMTISlpSXWrl2LCRMmcNafi4sLZs6ciU6dOsHY2LjYfV69eoXdu3dj3bp1ePDggUrt29vbo3nz5mjcuDEaNGiAKlWqwNzcHEZGRkX++haLxRCLxXj69CnWrFkDb29vdOvWDZaWlmp9ruTkZDRs2BAZGRlKH1O1alUcPHgQ7u7uavVZEd26dQstW7ZU6zFOx44dsWbNGpiYmGghsuIVFBTgu+++Q1RUFOdtW1hYqHyMWCxGVFQUgoODFa/x+XwEBQXh0qVLxR7TqFEjbN26FVevXoW/vz8ePXqE8PBw9OrVq8R+PrzTnJ2drXKshJDyT++P0t5nbW2N2rVr48GDB2jZsiXEYjEyMzOL3DVKSUmBs7MzAMDZ2fmjcQTvZq2926c4IpEIIpHoo9ctLS1haWmJb775BkKhkLNxSklJSRg+fDjOnz+PoUOHok6dOqhUqRIKCgqQmJiIY8eO4X//+x/i4+PBGFO5/bS0NOzZswd79uyBqakpHB0dYWNjgxo1asDW1hYAIJFIEBsbi9zcXCQkJOCLL77A+vXrS0zUlCEUCvHZZ5/h4sWLSh+TmJiI9evXY/ny5Wo9MqmI6tatCzc3N8THx6t0nJubG/78889iHxVp08OHDxEXF6eVttV5lJ2WlgaZTFbs3eOS4uzevTvS0tLQpEkTMMYglUoxaNAg/P777yX2Q3eaCflEsHIkJyeH2djYsL/++otlZmYyY2NjtmfPHsX7cXFxDAC7dOkSY4yx8PBwxufzWUpKimKftWvXMktLS1ZQUKB0v1lZWQwAy8rKYowxFh0dzUQiEQPA+WZqasq8vLxY27Ztma+vL7OwsGA8Hk8rfZW2NWzYkEkkEo1/ZiEhIYzP56vUt52dHYuNjdW474pk/PjxKp1DoVDIQkJCdB6nTCZjgwcP1tq/y3fXoCqeP3/OALCLFy8WeX38+PHM39+/2GNOnTrFnJyc2Lp169itW7fYvn37WNWqVdmsWbNK7KegoIBlZWUptsTERLVjJoRw48Pvby7oNTEaO3YsO336NHv8+DG7cOECCwoKYvb29iw1NZUxxtigQYOYm5sbO3nyJIuMjGSBgYEsMDBQcbxUKmXe3t6sVatWLDo6mh07dow5ODiw4OBgleL48MQeOnRI5S97Q9u8vb1ZTk6Oxj/DnJwc1rJlS5X7X7hwocZ9VySJiYmsdu3aSp07Ho/HBg0axMRisc7jjI2NZba2tuUqMSosLGQCgYCFhYUVeb13796sXbt2xR7TpEkTNm7cuCKvbdmyhZmamjKZTKZUv9r4hUwIUY02rkO9Pst49uwZunXrBk9PT/z888+ws7PD5cuX4eDgAABYunQpvv/+e3Tu3BlNmzaFs7Mz9u3bpzheIBDg8OHDEAgECAwMRM+ePdG7d2/MmjVLo7hOnjwJuVyuURvlXXJyMnJycjRux9zcHKtXr4aPj49Kx12/fl3jviuSKlWqYMOGDahTp06p+1WqVAkjRozAggULNHoMqg6JRIKZM2ciPT1dp/2WRSgUws/PDxEREYrX5HI5IiIiEBgYWOwxeXl5Hz3KFQgEAKDW42xCSAXCWYplwN7POB88eMDc3Nz0fkdH25udnR17/vw5Z+fw3LlzrE6dOkr3361bN876rkhevHjBZsyYwXx9fVm1atWYqakpq1KlCvP29mYjRoxgFy9eZFKpVC+x/ffff8zMzEyr/y7V/atv586dTCQSsZCQEBYbG8sGDBjArK2tWXJyMmOMsV69erFJkyYp9p8+fTqzsLBgO3bsYI8ePWL//vsvq1mzJvv555+V7pPuGBGif9q4DsvV4Gt9KywsxJQpU5CQkKDvULQuOzsbT548gaurKyftNWnSBAcPHsQvv/yCCxculPpXN4/HK/Ev+U+di4sLpk+fjokTJyI/Px/JyclwcHCAmZkZzMzM9BZXbm4upk2bhry8PL3FUJouXbrg5cuXmDZtGpKTk+Hr64tjx44pBmQnJCQUuUM0ZcoU8Hg8TJkyBc+fP4eDgwN++OEHzJkzR18fgRBSTvBYad9gn4js7GxYWVlh8uTJWLBgwSex1hqPx8PevXvRsWNHTtvNysrC8uXLsWrVqo/WtXunWbNm2L17t+KRKSn/du/eje7du2v92sjKylK7fISuvfu9YUgxE1LRaOM6pPnS7/nrr78+iaQIeDOOQhvjfKysrDBlyhRcuHAB48ePh7u7O0xNTSEQCODo6Ij+/ftjx44dlBQZkPz8/E/q2iCEfNroUdp7cnNz9R2CTl2+fBlSqbTIwr1c4PF4qFmzJhYsWIBJkyYhMTERL1++RJ06deDk5KQY5Ep0Qy6XQy6XQyAQqFUnKDIyUivFHAkhpDyixOgTdvv2baSlpZVaDFMTPB4Ptra2iiKTFY1MJkNSUtJHCbW5uTkcHByKLSKqS1lZWdi1axeOHz+O58+fw8PDA35+fmjdujVq166tdIJ6/PhxWlyVEPLJoMToE5aamor//vsPPXv21HconJJKpUhISMCLFy8AvFkews3NTe0FSj/EGMOJEyewYsUKXL58Ga9fvy7yvrm5OapVq4aAgAC0a9cOjRo1grm5ucb9quLWrVsYPHgwLl++rCg9cfnyZWzduhWWlpZo27Ytxo4di/r165d5F0nVityEEGLQOJvfZsDeTff7FLdWrVqxwsJCff8IOHP58mXWtm1bZmtry4yMjBSbs7Mz++WXX9jjx4817iMsLEzpIodGRkbM39+fHTx4kJNK48p4+vQp8/LyKjM2W1tbtnTp0jLjGjhwoM7+PRrS1Heark+I/lW4ytflxaecGJmYmLATJ07o+0fAicuXL7OqVauW+nl9fX1ZYmKi2n0kJSUxd3d3lc+zqakpmzNnjk6So+DgYKXjEolEbPPmzaW2d+zYMSYUCikx+gAlRoToX4WrfF0RmZmZoUqVKqhSpQqsra3VGuyqSwUFBViyZAlnC+bqi1QqxcyZM5GYmFjqftHR0Vi3bp3a/WzZsgWPHz9W+bj8/HzMnDkT27ZtU7tvZchkMly+fFnp/QsLC7Fp06ZSZ5w1b94cHTp04CA6Qggp/ygx4oiNjQ2Cg4Nx/vx5xMTEICYmBteuXcOCBQvKXOZB306dOoWzZ8/qOwyNZGRk4MaNG0rte/DgQRQWFqrch0QiQXh4uNpLRojFYkybNg0PHjxQ63hlqTrLsKCgoNTPJBKJMGfOHFSvXl3DyAghpPyjxIgDPj4+CA8Px5w5c1CvXj1YW1vD2toaHh4eGD9+PCIiItC5c+dye/eooKAA06dP52TtNH1hbx4LK7VvcnIyMjIyVO4jJSUFsbGxKh/3voSEBCxbtkxr63EJBAJ89913Kv1b+/7778tcd83DwwN//fUXZ4PITUxM4OHhgYYNG8Le3p6TNgkhhAuUGGnI0dERISEhaNiwYYlfRs7OzlizZg0+//xzrcQgEolQpUoVeHh4wMrKSq0E7MqVKzhw4IAWotMNKysr1KpVS+l9K1WqpHIf6enpyMrKUvm4D+3btw/Pnz/XuJ2SdO3aFTVr1lRq3+rVq6NLly5K7fv9999j1KhRGs3sMzY2RufOnREREYHIyEicOXMGUVFRWL58udptEkIIlygx0gCPx8P48ePh6+tb5r729vYYNmwYZ3eNBAIB3N3dMXPmTFy4cAE3btzAjRs3EBkZicWLF8Pd3V2l9mQyGVasWGGwRS5FIhEGDBigVG0eNzc3mJqaqtxHXFwcJ2OxkpOTcejQIY3bKYmzszOWLl1aZvJna2uLv/76CzVq1FCqXT6fjwkTJqB169ZqxWVmZoZp06Zh27ZtaNSoEaysrCAUCuHm5oY+ffqo1SYhhHCOs2HcBuzdqHYHBweVZtBUrVpVpRlOp0+fZgKBQOOZO9WqVWMrVqxgL1++LLGvu3fvsrp166rUrkgkMugZajk5Oaxly5Zlfs4VK1ao1f6mTZs4m33VunVrrc5Qk8lkbPXq1czc3LzY/m1tbVlYWBiTy+Uqt33v3j2lygG8vxkbG7PZs2czqVRabJuGOMPLEGMmpKKhWWla9vfffytW41ZGv379UKVKFaX3t7a21qgasqmpKYYOHYrz589j2LBhpY7N8PLywoYNG2BnZ6d0+4WFhfj7778VBQG1LTc3F1lZWZzNiDM3N8eqVatQu3btEvepXr262jOsPizkqInIyEhFAUpt4PP5GDBgAHbv3g1PT0/F4y+BQABfX19s2rQJ7du3V+sOZu3atbFixQql/23xeDyMGzcOEydOpOVgCCHlH2cplgF7P+M8c+aMUnda3NzcVK6HExMTU+Jf8GVtnp6e7NChQyrdZZDL5WzixIkq9WNjY8Pi4+NVPYUqefnyJZs6dSrz9vZmVatWZUFBQez06dNMJpNx0v6JEyeYi4vLR5/NzMyMbdmyRe12Bw8ezNkdIz6fz3bu3MnJ5y1Lamoq2759O5s+fTrbv38/y8zM5KTdVatWMZFIVOrn5PF47Oeffy7zrzlDvPtiiDETUtFQgUct+fDEPnr0iP3000/M2Ni4xEdOGzduVLmf0NBQxuPxVPoCFQgErH379mpXbH706BFzdnZWqc9p06ap1VdZJBIJ27dvH6tTp85H58HCwoJt2LCBs75u3LjB2rZty8zMzBiPx2NOTk5s9erVGiVfXFeADg4O5uzz6oNEImEbN24ssaimiYkJGzhwIMvIyCizLUNMMgwxZkIqGkqMtKS4E1tQUMC2bNnC/Pz8iiRIpqambMqUKSqPD0lJSWG+vr4qJ0WjR49mr1+/VvuzyeVylb/QnZ2dWUxMjNp9FiclJYUNGDCAmZiYlNivk5MTO3fuHGd9FhYWsuvXr7NDhw6xp0+fqjWe5n2UGBUvPj6ejR8/njVo0IA5OTkxLy8v1rlzZ/bff/8pfZ0YYpJhiDETUtFo4zqkRWRLIBKJ0LNnT7Rv3x7Xr1/HzZs3wRhD/fr1ERgYqFIRvYcPH2LkyJG4efOmSjEMHjwYc+fOhYmJiarhK/B4PPTu3RshISFKFzVMTk5GcHAwQkNDYWZmpnbf76SmpqJPnz44duxYqfulpKRg+PDhOHTokEpjt0oiFApRr1491KtXT+O2tEGdmXHlUa1atfDnn3+ioKAAubm5MDExgZmZGScL9hJCiK7Rb64yWFhYoFmzZhgxYgRGjhyJr776SumkSC6X4+jRo/juu+9w5MgRlYr6eXt7Y/r06RolRe/UrVsXnp6eKh1z9OhRrF69WuNChC9fvkTv3r3LTIreiY6OxqxZs0pdokJfLCwsOGvL1NQU33zzDWftlQcmJiawt7eHubk5JUWEEINFv7205NWrVwgODkaXLl0QHx+v8vE//vgjZxWBzc3NERAQoNIxMpkMc+bMwb///qt2v1KpFFOnTsXx48dVOm7Lli1arfOjLm9vb87a+uWXX+Dv789Ze4QQQrhBiRHHGGM4f/48WrdujYULF6q9zEbVqlU5jatp06YqT83OyMjAsGHD1F7b6/z589i6davKxxUUFOD3339HcnKyWv1qS/Xq1ctcOkMZDRo0wNSpU1Ve04wQQoj2UWLEIblcjpCQEHTo0AFRUVFaWw9LHX5+fmotg/HgwQOMGTNG5YrYUqkUy5cvV7v2z71797S6ppg6atasCWtra7WP5/F4aNeuHUJDQ+Hi4sJdYIQQQjhDiRGHdu7ciREjRuDVq1cat5WXl8dBRP/P1dUVzs7Oah0bHh6O7du3q3TM8+fPcfbsWbX6A97ceVu3bh0iIyPVboNrTk5Oaq93Z2FhgYkTJ2Lz5s0qL9dCCCFEdygx4khWVhbmzJnD2VpjUVFRnLTzTqVKlVC5cmW1jpXJZJg3bx6SkpKUPubRo0fIzMxUq7930tPTMW/ePEgkEo3a4YqxsTF69Oih0iNJgUCAFi1a4PDhw5gzZw6srKy0GCEhhBBNUWLEkZycHE6XeLh8+TKys7M5a8/IyEjlmWnve/r0KSIiIjiLR1nh4eE4fPiwzvstSfv27ZW6a2RiYoKGDRsiJCQEBw8eRNOmTWmmFiGEGAD6Tc0RY2NjjdZB+9DDhw9x48YNztoDUOoaYmVhjKk0u0zT8TjvFBYWYvHixZzdidOUg4MDZs2aVew6YQKBAFWrVkWvXr1w+PBhnDp1Cj179oS5ubkeIjUsulqfjxBCykLTYjhib2+PgIAAHDx4kJP2JBIJtmzZotZsspJUrlwZPB5P7QHNyhaIBN6MaQoKCkJoaKhafb3v8uXL2Lx5M4YMGaJxW1zo0KEDqlatig0bNuDZs2fg8Xjw9vbGl19+icaNG8PBwYGzn9mn4ty5c/oOgRBCAFBixBmBQIBevXohPDycs+KE4eHhePr0KapXr85Je5999hmEQqFKCc77fH19ld7XyMgIo0ePxtGjRzV+JCiTybBixQr8/PPPnNV20gSPx0ODBg3QoEEDRZJJiZD6GGPYvHmzvsMghBAA9CiNU99//z2+++47ztpLSkrC33//zdmUdRcXl2IfASnD2toa33//vUrHfPnllxg6dCgnScO9e/fw119/lavp+8CbhIiSIs1kZ2fj+vXr+g6DEEIAUGLEKRMTE0yfPh0ODg6ctRkSEoLHjx9z0pa1tbXaU8V//PFHlSs/8/l8jBs3Ds2aNVOrz/cxxrB+/Xo8efJE47bIx/Ly8pCbm4vc3FwUFBTotO/Xr18jIyNDp30SQkhJKDHiWL169RAcHMxJhWTgzV2j2bNnQyaTadyWUCjEF198ofJx7u7uGDdunFqzqmxtbbF8+XK1SwW8Lzk5GWvXri13d40MlVwux7lz5zBkyBD4+/srFtxt3Lgxfv/9d9y8eVMng6LNzMyojAEhpPxghGVlZTEALCsri5P2CgoKWLdu3RgATjYzMzN26NAhTmLbuXMn4/P5SvdtY2PDDhw4oHG/+/btY5UqVdL4XDg7O7NHjx5xcCY+bampqWzw4MHMwsKi1J/9zJkz2evXr7Uai0wmYx06dOD0GtQFrn9vEEJUp43rkO4YaYFIJMKff/7J2aKjeXl5mDhxIhISEjRu66uvvoKTk5NS+9rY2GD9+vX44YcfNO63Xbt2GDt2rMbjcZKTk2mgroZiY2Px3XffYfXq1aWu5ZeRkYFZs2aha9euSE1N1Vo8fD4fXbp00Vr7hBCiinKTGM2fPx88Hg+jRo1SvFZQUIChQ4fCzs4O5ubm6Ny5M1JSUoocl5CQgLZt28LMzAyOjo4YP348Z7PCNFGlShWsWLECNjY2nLQXGxuL33//HWKxWKN2XFxc0LVr1zL3q127NrZt24aOHTtyMrhYIBBgzJgxaNy4scZtHTx4kPMlUz4VFy9exM8//6z0UisymQyHDh3CpEmTtDr2KCgoSGttE0KIKspFYnTt2jWsXbsWdevWLfL66NGjcejQIezevRtnzpzBixcv0KlTJ8X7MpkMbdu2hVgsxsWLF7Fp0yaEhIRg2rRpuv4IxWrWrBmmTZsGgUDASXu7d+/G+vXrNRpjw+PxMHToUFSrVq3Y94VCIXr06IFjx46hTZs2nM64srKywsKFCzVOFh89evRRgkzKdvjwYbRv3x537txR+djNmzfjf//7n9bGdwmFQq20SwghKuPsoZyacnJyWK1atdiJEydYs2bN2MiRIxljjGVmZjJjY2O2e/duxb53795lANilS5cYY4yFh4czPp/PkpOTFfusXr2aWVpassLCQqVj0OZYgby8PNa3b1/OxhvZ2Niw//77T+O4zp07xzw8PBiPx2MAmEgkYr6+vmz//v0qnTtVyWQyNnbsWEW/6mx8Pp9FRERoLUZ9k0gkTCqVctZefn4+W7t2LbO3t9fo356DgwOLjo7mLK73GeJ4HUOMmZCKRhvXod4LPA4dOhRt27ZFUFAQ/vjjD8XrUVFRkEgkRW6xe3l5wc3NDZcuXULDhg1x6dIlfPHFF0XGzLRu3RqDBw/GnTt3UK9evWL7LCwsLFLkkMs1yT5kamqKuXPn4tq1a7h9+7bG7WVkZGDIkCHYtWsXfHx81G6nSZMmOHv2LM6cOYO0tDT4+vrC19dX68tX8Pl8jBkzBnv27MHTp0/VaoMxhrS0NI4j0w+5XI6srCzcuHED58+fx/Pnz3Hnzh2YmZnB09MTrq6u8PHxQd26deHk5KTSbEexWIyoqCgsWLAAR44c0fgR88uXL/HHH39g69atnC5/Qwgh5YleE6OdO3fi+vXruHbt2kfvJScnQygUfrTelpOTE5KTkxX7fDiQ+N3/v9unOPPmzcPMmTM1jF55zs7OWLlyJb7//ntO1vyKj4/Hzz//jO3bt6N+/fpqP+5SdrwR11xdXTFlyhQMGTIEEolE5eMZY7h7964WItMNuVyOlJQUnD9/HmFhYbh06RKePXv2UeJy4sQJAG/GZ9nY2KBOnTpo3bo1GjduDC8vL9jY2BR5TMsYQ1ZWFu7du4eTJ0/i+PHjuH79OqfjsQ4cOIDt27ejb9++nLVJCCHlid4So8TERIwcORInTpyAiYmJTvsODg7GmDFjFP+fnZ2NqlWrarXPJk2aoE+fPli1ahUn7cXHx6Nt27ZYvnw5OnXqBCMjvd/8U0nPnj0RHh6OsLAwtY4/c+YMxGKxQYxNkUqlyMzMRFxcHC5evIjz58/j+vXrSEpKUqpOkEwmQ1paGs6ePYuzZ8/C2NgYtra2qFGjRpE7NzKZDE+ePMHLly/VXvalLBKJBNOnT8eXX37J2axLQggpT/T2bRoVFYXU1FTUr19f8ZpMJsPZs2excuVKHD9+HGKxGJmZmUXuGqWkpMDZ2RnAmzsxV69eLdLuu0G57/Ypjkgk0vmjAIFAgFGjRmH37t2cTX1OSUlBnz59cPLkSUybNg2urq6ctKsLJiYmWLhwIWJiYvDgwQOVj7906RLOnz+Pr7/+WgvRaaagoADPnz/H9evXcf78edy6dQsPHz5ESkqKxrMKgTfJSUpKit4GoCcmJqJ///44ePAgp1XeCSGkXOBstJKKsrOzWUxMTJGtQYMGrGfPniwmJkYx+HrPnj2KY+Li4oodfJ2SkqLYZ+3atczS0pIVFBQoHYuuBlHK5XI2aNAgzgZiv795eXmx/fv3M4lEotXPwLV///2XOTk5qfWZvb292fHjx1lOTg6ng5U1ceLECdakSRNmbW2tUiFNQ9x69uyp0nVWGkMcyGyIMRNS0WjjOuQxVn7WV2jevDl8fX2xbNkyAMDgwYMRHh6OkJAQWFpaYvjw4QDe1GIB3txh8vX1haurK/78808kJyejV69e6NevH+bOnat0v9nZ2bCyskJWVhYsLS05/1zvO3/+PFq2bKmVmjCmpqbo3bs3Zs6cqXQRx/IgIiICw4YNQ1xcnMrHmpiYoGbNmnBzc0OVKlUAvFmGpEmTJggMDFR70Vx1PH78GE2aNMGLFy901qc+GRkZYeLEiZg1a5Zay8W8T5fXIFcMMWZCKhqtXIecpVgceH+6PmNvphkPGTKE2djYMDMzM9axY0eWlJRU5JgnT56wNm3aMFNTU2Zvb8/Gjh2r8l2Tdxlnjx492LBhw1h0dDSTy+VcfKSP5OTkMC8vL63+Jd+iRYuPzlN59/jxY9azZ08mFAo5OQd8Pp/Vrl2bbdq0iYnFYp18hjNnzjCBQKD3Ozm63CpVqsS2bNmi8bkzxLsvhhgzIRWNNq7DcpUY6cu7E/tuc3R0ZEePHtVaf4MHD9b6F1a/fv3KzeMlZRUWFrK9e/eyJk2aMCMjI07Og1AoZNOmTdNJcnTu3DnO4jakrXLlyhrXNzLEJMMQYyakoqG10nQkNTUVI0eOxOPHj7XSvr+/P6cVpYuzf/9+g3ukIxQK0alTJxw/fhyhoaFo3Lixxo9oxGIx5s+fj507d3IUZcmqV6/+Sa4S//z5c4wbN46TUhSEEKJvlBiVID4+HtOnT4dMJuO8bT8/P5iZmXHe7vsyMjLUWvqhPDAzM0OnTp0QHh6OZcuWwcXFRaP2xGIx/vzzz1IXTOWCtbW1QY3t4tLJkydpcV9CSIVAiVEp9uzZg6NHj3Lerpubm9anORsbG2ucUOjbuwH34eHh8PT01Kit+Ph4REdHcxNYCd5Vq/4UyeVyzJ8/X+1q5oQQUl5QYlSK/Px8TJw4EUlJSZy2a2FhUeJyJVyxsbGpMHcvfH19sWvXLo2SDrFYrPXEiM/no2nTplrtozxLTEzEP//8o+8wCCFEI5QYlSE2NhYTJ07k9DEMn8/HV199xVl7xfn+++/h6OjIWXtisRgJCQmIjo7Gjh07sHnzZpw/fx63b9/mrHBhaerWrYtly5Zp9AhSF8uINGrUSOeV3MuT3bt3IzMzU99hEEKI2gxrHQk92bZtGwoKChAcHIxatWqV+MXH4/GKrF1VmpYtW8Lc3FwrA1ZtbGwwfPhwjQcuA0Bubi62b9+OLVu24O7du8jNzVUsN2FsbKxYx8vd3R1fffUV2rVrBz8/P60s1dGyZUv07dtX7WVVmA5KdtWpUwfu7u6IjY3Vel/lUXx8PG7cuIEWLVroOxRCCFELJUZKkMvl2L17N8LDw0udeWRqaorPP/8c7u7uaNasGb744osSEyVPT0+0bt0ae/fu5TzeX375BZ9//rnG7SQkJKBfv36IiIgodk0viUQCiUSCpKQkJCUl4cKFC1i2bBlatGiB2bNna7TAbXEEAgFGjhyJsLCwcjvjztzcHM2aNSs3iZGdnR38/f3RqFEjiEQi3LhxAzdu3MDDhw/VWsC3LFKpFDdv3qTEiBBiuDib+G/APqxjxMVmYWHB+vXrx9LT00vsNzY2lrm6unLab+PGjVlaWprG5yQtLY01adJE7Tjs7OzY4sWLtbJEyYIFCxiPx1M5pkGDBnEeS3FOnTrFRCKRXmsL8fl81rFjR3b37t2P6lllZWWxkydPsr59+zJra2vO+548ebLK58wQawIZYsyEVDRU4FFLtJEYAWA8Ho/17t271EKLISEhzNzcnJP+PDw82M2bNzk5J8uXL1cr+Xh/EwqFbM6cOZwXmnz58iXz8/NTOZ5Ro0ZxGkdJXr9+zfz9/fWWFAkEAjZr1iyWk5NTapwymYxFR0ezbt26cZbIGRkZsWPHjql8zgwxyTDEmAmpaCgx0pIPEyMTExP2/fffs3Xr1rF//vmHTZo0iVlaWqr1ReHo6MhevHhRYt8ymYxt2LCBVapUSaMvJBsbG86qdYvFYo3uFr2/mZmZaaWKeEREhEp3O3g8HgsNDeU8jpLs27ePmZiY6CUx6tq1K8vLy1M61sLCQnbgwAFWv359jZPhhg0bqvULyhCTDEOMmZCKhhIjLXk/MfLz82P//vsvKywsVLwvl8vZli1b1EqOrKysWEJCQqn9y2Qytn79erXvHNnY2LC9e/dytr7bq1evOH3E5+Pjw169esVJbO/I5XK2c+dOpZOjypUrs8TERE5jKI1EImEDBgzQONFQdbOwsFD7ruGrV69YcHCwWv/OeTweq1+/PouMjFSrb0NMMgwxZkIqGkqMtOTdiW3WrFmJd3feJUeq3tmpXbs2y8zMLDMGde8c1a5dm/3777+cLnqbl5fHfH19Ofuy5vF4bPXq1ZzF945cLmfHjh1jLVq0YFZWViUmIfb29mzfvn2c91+WjIwMNm7cOGZlZaWzxCggIIAVFBSoHbNMJmOnT59m/v7+Sid19vb2bMKECezly5dq92uISYYhxkxIRaON65Bmpb1n48aNJVaL5vF46N69O+7fv4+5c+dCKpUq1WbXrl2VWj+Lz+fjl19+AQCMHDlSqWn8DRo0wIYNG1C3bl2lYlGWqakpAgMDOSuIyBjDnj170K9fPxgZcfdPjsfjoXXr1mjRogUSExNx9+5dPHv2rMgadzVq1ECTJk04maWnKmtrayxYsAC9e/fGuXPn8OTJEzx48AByuRy1a9cGj8eDqakp6tati8zMTERGRuLo0aN4+vSp2qUFTExMNDrHfD4fzZo1w7Fjx7Bs2TL8888/eP78eZFZiUZGRrC3t4e3tzfatGmD77//HrVq1dL6+n+EEKILPKbub+AKJDs7G1ZWVsjKyoKlpWWp+4rFYsyYMQMLFy4sMzlyc3PDuXPn4ObmpnQscrkcW7duxaRJk0qsuP0uIQgJCdFadevw8HB07NiRs8KNzs7OuHHjBpydnTlpz1C9SzBKqjGVmpqK5cuXY9GiRYp6Uapo2LAhzp49C2NjY43iBN4ktKmpqbhw4YJiqQ9jY2P4+PigVq1asLe35yzRVeUaLC8MMWZCKhqtXIec3XsyYKreiissLGTBwcHMyMioxMcLJiYmbPfu3WrHdO7cOebl5fVRuyKRiI0aNYplZGSo3bYy8vLyWIMGDTh7xGNkZMROnTql1ZgrCqlUyhYuXMiMjY1VPs/W1tYsPj5e3x9BZYb4WMoQYyakotHGdUhLgqhBKBRixowZGD9+fLF/MQuFQsyZMwcdO3ZUu48mTZogIiIC06ZNg4+PD6pXr46OHTvi4MGDWLBgAaytrTX4BGUzNTVF7969OWtPKpVqfa0yTUkkEhQWFqq0KftIVRUCgQDDhg1Dt27dVD42KysLkZGRnMdECCGfCnqUBvVvxb17rLZkyRLFYw8+n4/ffvsNq1at4uRxBgDk5eVBJpPBzMxM6SVHuJCQkAB/f3+kpKRw0t6MGTMwffp0TtriQnZ2Ni5fvoxz587h+fPnuH//vspr4tnb26NWrVr4+uuv8fXXX8POzo6z+B4+fIjmzZvj2bNnKh33/fffIywsjNPxXNpmiI+lDDFmQioaepSmJZrcihOLxWzp0qXMyMiI8Xg81rdv3zIL6xkKmUzGfvzxR84ep82YMUPfH4kx9uZz7dq1i9WvX7/Ux6GqbHw+n/n6+rKoqChOY128eLHKU/6trKzUnjavL4b4WMoQYyakoqFHaeWQsbExhgwZgm7duqFq1aqYP38+zM3N9R0WJ/h8Ptq3b8/ZbCMzMzNO2tGEXC5HSEgIfv31V1y/fp2zR2FyuRzR0dGYMGECCgoKOGkTAHr27ImaNWuqdExWVhamT5/OaRyEEPKpoMSIA69fv0ZiYiLy8vLw6tUrfYfDqebNm3My883Y2BgBAQEcRKSZY8eOKV0OQR1XrlwpUi5AU46OjujatavKxx0/fhzbtm3jLA5CCPlUUGKkoYKCAsycORNnzpxBWloa+vXrV6GSI1dXVzRu3Fjjdr744gs0aNCAg4jUl5KSgokTJ2otKQKA3NxcxMTEcNrm119/rfJ4IalUihkzZiA+Pp7TWMqzVatWoXr16jAxMUFAQACuXr1a6v6ZmZkYOnQoXFxcIBKJULt2bYSHh+soWkJIeUWJkQYyMjIQHByMlStXKgryXbp0CcOHD1d5EG95xefz0alTpxLr7ijD2NgYI0eO1OujNJlMhjlz5uD27dta7yszM5PT9qpVqwZTU1OVj3v27Bl+//33cv1ITSaT4dWrV7h06ZJG7YSGhmLMmDGYPn06rl+/Dh8fH7Ru3RqpqanF7i8Wi9GyZUs8efIEe/bswb1797Bu3TpUrlxZozgIIRUAZ6OVDJg6g7dSU1NZmzZtih0Yy+Px2OTJk5lEItFi1LqTlpbG3N3d1R6Y3L59e5UWNdWGI0eOMDMzM84Gkpe2DR8+nNPYHz58yCwsLNSKxdjYmIWFhXEajyby8/PZgwcP2MGDB1lwcDBr2bIlq1q1qmIQvLoDKP39/dnQoUMV/y+TyZirqyubN29esfuvXr2aubu7M7FYrFZ/jNHga0LKA1oSpJxITU3FL7/8gqNHjxb7PmMMCxcuRNWqVTFgwACDXyrBzs4OgwYNwqRJk4osDaGMOnXqYMmSJWrd8eBKcnIyJk6ciLy8PJ30p+o50iaJRIJly5ahTZs2EIlEOu+/oKAACQkJOHfuHC5fvozo6Gjcv38f2dnZai978iGxWIyoqCgEBwcrXuPz+QgKCirxTtTBgwcRGBiIoUOH4sCBA3BwcED37t0xceLEEktivKtd9U52djYn8RNCyhdKjFQUExODAQMG4PLly6XuJxaL8fvvv6Ny5cr4/vvvdRSd9gwePBgxMTHYunWr0l9oXl5eCA0Nhbu7u5ajK5lYLMasWbN08ghNW9ibxZ7VPj4yMhL379+Ht7c3h1GVLD8/H7GxsThy5AgOHTqE+/fvIysrS2v9paWlQSaTfTRJwMnJCXFxccUe8+jRI5w8eRI9evRAeHg4Hjx4gCFDhkAikZRYa2vevHmYOXMm5/ETQsoXSoxUEBMTg59//rnEX7YfSk9Px+jRo+Hu7o46depoOTrtMjc3x6pVq2BjY4MtW7YgIyOjxH2FQiFatWqFhQsXwsvLS4dRfmz79u3YsGGDXmPQ1MOHD5Gfn6/28Xl5ebh+/brWE6OMjAyEhoZiw4YNuHPnjkYxa5tcLoejoyP+/vtvCAQC+Pn54fnz51i4cGGJiVFwcDDGjBmj+P/s7GxUrVpVVyETQnSEEiMlMMYQHR2N7t27K50UvfPgwQOMHj0ae/fuNfj6RhYWFli6dCn69++P7du34/Lly0W+tG1sbODn54fu3bsjKCgIJiYmeo338uXLCA4O5mwhXH25ceMGZDKZ2sczxvD69WsOIyqqoKAA27Ztw9KlS3H37l2dP0q0t7eHQCD4qEJ7SkpKiYsWu7i4wNjYuMhjs88++wzJyckQi8UQCoUfHSMSifTyOJIQoluUGJWBMYYDBw5g0KBBai+NERERgZCQEAwbNozj6D4mk8mQlJSEx48fIykpCdHR0cUWMTQyMoKPjw9q1qyJWrVqwcrKSqn2+Xw+vL29MXfuXMhkMmRlZSnaF4lEsLS0LBdjqhISEvDLL78gOTlZ531Xr16ds7akUilOnTqlcTva+pncu3cPwcHBOHTokFbWjVOGUCiEn58fIiIi0KFDBwBv7ghFRESUeM01btwY27dvh1wuV8y4jI+Ph4uLS7FJESHkE8LZMG4DVtKodrlczsLCwpitra3GM5U8PT1Zenq61j5DZmYmCw0NZT/88ANzcHBQemV2kUjEPD092ahRo9jjx4+1Fp8uvX79mnXu3FknM9CK27Zt28bZZ3nw4AGzsbHRKB5jY2N27tw5zmJi7M2sr/DwcFa1alVOz526M0t27tzJRCIRCwkJYbGxsWzAgAHM2tqaJScnM8YY69WrF5s0aZJi/4SEBGZhYcGGDRvG7t27xw4fPswcHR3ZH3/8oXSfNCuNEP3TxnVIiREr+cSeOnWKk6QIABMKhezChQtaiT8iIoI1bNiQCQQCjWL08PBgFy9e1EqMurRq1SrG5/MrRGK0aNEilddKK+7nynVSvnPnTmZubs75udPkl9uKFSuYm5sbEwqFzN/fn12+fFnxXrNmzVifPn2K7H/x4kUWEBDARCIRc3d3Z3PmzGFSqVTp/igxIkT/KDHSkuJO7K1bt5iXlxenv/S1UU/m6NGjzMHBgbMY/f39DXoR3MTERM7vYqi6bd++nZPPkpKSwjw8PDSOZ/To0ZzE805cXByrUqWKVs6dISUZlBgRon+0iKyOpKWlYcCAASoPtC6NQCDgfPB1amoqRo0ahZcvX3LW5o0bNxAVFcVZe7r233//4dmzZ3rrXygUokaNGhq3wxjDkiVL8PDhQ43asbe3x8CBAzWO533//POPXs8xIYRoEyVGH5DJZJg1a1aZdYpU5ejoiM8//5zTNi9fvoz79+9z2qZEIsGLFy84bVNXGGM4duwYZ4UD1SEQCJQeyF6aq1evYt26dRp/lu7du6N27doax/OOVCrFhQsXOGuPEELKG0qMPhAREaGVujc9evQoceqwul6/fl2uqizrW2FhIe7cuaPXGGxtbWFvb69RGy9fvsSwYcOQnp6uUTseHh4YN24cpzPSeDweLCwsOGuPEELKG70mRqtXr0bdunVhaWkJS0tLBAYGFllmo6CgAEOHDoWdnR3Mzc3RuXPnj6bMJyQkoG3btjAzM4OjoyPGjx+v9rRhmUyGlStXcr50hLe3N8aMGcP5lGlXV1cYGxtz2qZAIIC1tTWnbeqSuomijY0NGjZsiA4dOqBDhw7w9vZWa9FbZ2dnWFpaqhUD8Obf/IgRIzR+nCkSiTBv3jzOCxAKBAJ89dVXnLZJCCHliV4ToypVqmD+/PmIiopCZGQkvv76a7Rv317xV//o0aNx6NAh7N69G2fOnMGLFy/QqVMnxfEymQxt27aFWCzGxYsXsWnTJoSEhGDatGlqxfPs2TNcvHiRk8/2Tu3atbF161a4uLhw2i7wJuGqVq0ap23a2triiy++4LTN8sza2hrBwcG4ePEizpw5g7CwMISFheHSpUs4e/YsBgwYABsbG6Xba9iwodpFAN8tX7Jnzx6NH6F17doV7du316iNknTs2FHju2KEEFJucTaMmyM2NjZs/fr1LDMzkxkbG7Pdu3cr3rt79y4DwC5dusQYYyw8PJzx+XxFrRLG3qyabWlpyQoLC5Xu892o9rCwMI2nvL+/eXp6sujoaO5OTjEWL16s8XTu97d27dqpNGW5PJHJZOyHH35Q+rN6e3uzixcvMrlcXmqbMTExbMCAAWXWEzI2NmbHjx9XK/acnBwWHBysWGVek61y5cosLi5O3dNYJrlczubNm8dpSQQ7OzuDm+FFs9II0b8KPStNJpNh586deP36NQIDAxEVFQWJRIKgoCDFPl5eXnBzc1OsmH3p0iV88cUXRRaPbN26NbKzs0sda1JYWIjs7OwiG/BmTSpNll54X9WqVREaGgofHx9O2itJz549UbNmTU7aEggE6N27d4mri6sqPz8fcXFxuHv3LnJzczlpszR8Ph++vr5K7evt7Y1du3YhMDCw1Eec7yp9r169GmfPnsXAgQNRuXJlRbXk9/fr3LkzmjZtqnLc8fHx6N69O/7880+Nq0fz+XxMnjwZnp6eGrVTGh6PhyFDhqBBgwactGdqaoply5Zx0hYhhGhK70uCxMTEIDAwEAUFBTA3N0dYWBjq1KmD6OhoCIXCj8a7ODk5KZZ5SE5OLnZF7XfvlaSkVbK5muFlbm6OZcuWaT0pAt7MdhswYAAmTJigcVtVqlRR64v9Q3K5HPv378fChQsRExMD4E2i2Lt3b/z444/w8PDQ2hIVvr6+4PP5pY41cnBwwNq1a/HZZ58p3e77CdLMmTNx7do1XL16FRKJBMCbdbY6duyo0vpwGRkZ2LhxI5YsWcLZTMCvvvoKPXv25KSt0lhaWmLWrFlo3749CgsL1W5HJBJh9uzZaNu2LYfREUKIBji796SmwsJCdv/+fRYZGckmTZrE7O3t2Z07d9i2bduYUCj8aP8vv/ySTZgwgTHGWP/+/VmrVq2KvP/69WsGgIWHh5fYZ0FBAcvKylJsiYmJDADr3bs3J48Fxo0bx2QyGbcnqhT3799n9vb2GsfdsWNHjeOWyWQsJCSkxKrIjo6ObO7cuUUef3IpNja21IrMxsbGLCQkRCt9K+vFixdszZo1zNvbm9PHUcbGxuzgwYM6+xyFhYWsTZs2asfL5/PZwIEDmVgsNsjHUoYYMyEVTYV8lCYUCuHh4QE/Pz/MmzcPPj4++Ouvv+Ds7AyxWIzMzMwi+7+/Yrazs3OxK2q/e68k7xY7fX8DwMkdnsqVK2PYsGEfPWrRJnd3dwQGBmrcTr169TSO+/jx4xg+fHiJj85SU1MxefJkBAUF4dSpU5zXHKpatWqpi7h26tQJ3bp147TPsjDGkJ6ejmPHjmHQoEHw9/fHkCFDcPv2bU7LLXTo0AGtW7fmrL2yCIVC9OrVS+1/Mz/++CMWLVrE+cxKQgjRhN4Tow/J5XIUFhbCz88PxsbGiIiIULx37949JCQkKJKAwMBAxMTEIDU1VbHPiRMnYGlpiTp16qjcd0BAgMbVqX/66Se4ublp1Iaq+Hw+mjRponE73t7eGh2fnZ2NKVOmICcnp9T9GGO4ffs2unTpgnXr1nGaHFSqVAlffvllse9ZWlpiwoQJOl09PT4+HmPHjkVAQAB++OEHrF27Fs+ePeO8/pS5uTnGjh2r85Xhv/rqKzg6Oqp8XOPGjbFo0SLOq8ETQojGOLv3pIZJkyaxM2fOsMePH7Nbt26xSZMmMR6Px/7991/GGGODBg1ibm5u7OTJkywyMpIFBgaywMBAxfFSqZR5e3uzVq1asejoaHbs2DHm4ODAgoODVYrj3a249PR0NmLECLVneRkbG7PTp09zeo6UdfbsWY1mNJmYmLDIyEiNYvjnn39UntVnamrKVq1axemjx3/++afYvvr06aPTGXcnT55krq6unD0qK20bPny4XmYTSqVS1rRpU5VirV69Ort3716RdgzxsZQhxkxIRVPhFpH99ddfWbVq1ZhQKGQODg7sm2++USRFjDGWn5/PhgwZwmxsbJiZmRnr2LEjS0pKKtLGkydPWJs2bZipqSmzt7dnY8eOZRKJRKU43j+xycnJrEGDBmp9OTk6OrLnz59zcm5U9fDhQ2Ztba32F6u5uTl7+PCh2v1LJBIWFBSkVt8WFhZqT3MvztWrV5mJiclHCdj7q61rW05ODvP399dJUuTo6Mju37+vs8/2PplMxtq3b690rG5ubuzixYsftWOISYYhxkxIRVPhEqPy4sMT++jRI9a+fXuV7xx5e3uzgoICvXyG9PR0VrlyZbW/XCtVqsTi4+PV7v/evXsaJWaVK1dmN2/e5ORcZGRksJo1axZpv379+uz169ectK+M6OhoZmZmppPEaOzYsaXWYtImmUzG2rZtq3RSdOHChWLbMcQkwxBjJqSiqZCDr8ujGjVqYNOmTZgyZYrBVPjl8/kwMlK/+kJ+fr5G5Qpu3rz50UB5VTx//hwTJkxQ1JTSRKVKlT6qNF6tWjW1lvhQV2JiIvLz87Xej6OjIwYNGqS18gdlkUgkePnyZZn7ubi4YOfOnWjUqJEOoiKEEPVRYlQCKysrzJw5E+fOnUPfvn2VSpDS09M1Sg40YW5uDnd3d7WPl8vliI+PV/v4GzduqH3sO//++y/Wrl2r8Uw1Y2NjrRY4LE9+/vlnzgp8quPhw4e4e/duqfuYm5tjwYIFnMycJIQQbaPEqBQ8Hg9eXl7YsGEDLly4gDlz5sDb27vEtbCSk5Oxc+dOvax4z+fzVSouWJzTp0+rXflb04rNAMAYw+LFizkrtPk+mUzGeWkAfTM3N0fPnj31drcIAHbs2FHqLESBQIAJEyagR48eOoyKEELUR4mREng8HmrXro3ff/8dly5dwpEjR9C/f39Urly5yH5yuRxTpkzBjBkz8OjRI50mSDweDw0bNtSojTNnzigqVauKqxIFKSkp+N///qdREiOXy5GVlVXktZs3byr1yMeQ/PDDD/Dz89Nb/3fv3sWGDRtK3ScwMBCjR4/WaV0vQgjRBP22UpG5uTm++eYbrF27FhcvXsTIkSOLjO3Jzc3F7Nmz4e/vj969e2PLli24e/cusrKylLprwd4MiFdsubm5yMrK+mjLzc39qK2BAweiY8eOsLa2VusuQmZmJgYNGoSnT5+qfOwPP/zA2SOdffv2IS0tTe3jpVIpHjx4UOS1hIQE7Ny5U9PQlFalShWN7+CVxsTEBMOGDdNoXJkmxGIxJk+ejKSkpBL3MTIywpgxY6hWESHEoPBYRXu+oIbs7GxYWVkhKytLUQVbWWKxGNOmTcPChQuLvUPE4/FQqVIl2Nvbo2bNmjAxMUHdunWL/dJMT08vMs6HMYbHjx8XO4jXzMwMDRo0QJcuXdCmTRvFwq8SiQSPHz/GnTt3EBUVhejoaKSkpOD58+d49eoVJBJJmclZgwYNMHv2bLRo0aLEx4bFuXr1Krp164ZHjx4pfUxx+Hw+9u7diw4dOqh1fHJyMurVq/fRenkeHh44deoUqlSpolF8ynj16hUaNGiAJ0+eaKX9Fi1aIDw8XKvJV2l27dqF3r17l7pOmoeHByIjI2FlZVVme5pcg/piiDETUtFo5TrkbH6bAdN0ut+rV6+Yp6enTqZmf7hZWlqyW7dulRibXC5n+fn5LDU1lUVFRbHt27ezQYMGMV9fX2ZqalpiuyKRiLVs2ZIdPXpUpRIE9+7dYz///DMTiUQafa5Bgwap9bNgjLGLFy+W2P9vv/3GxGKx2m0rSy6Xs1GjRmnlZy4SidihQ4e0/hlKkp2dzfz8/MqMs2vXrkqXETDEqe+GGDMhFQ1N1y+nbG1t8eOPP+ql79evXyM9Pb3E93k8HkxMTODg4ID69eujW7duWL16NS5evIj//vsPffv2LfauQ2FhIU6cOIEOHTqgX79+H43ZKUnt2rWxbds2xdRsdceW3Lp1S+0B3bdv3y7xTsaWLVuwevVqrQ/E5vF4GDp0aKnrtqmrY8eOOl0T7UPHjx9HdHR0mft5eHjodWA4IYSogxIjjnTp0kUvt9OFQiEsLCxUPs7U1BSNGjXC2rVrsW3bNlSrVq3Y/QoLC7Ft2zbMnj1b6WTCyMgIHTp0wNGjRzFz5kzY2NioHJ+6A9cZYzh37lyJ74vFYsycORMHDx7UenLk4eGBnTt3cpoc2dvbY/z48XpdeDUiIkKp2YvqrFdICCH6RokRR+rUqYNOnTrpvN/PPvsMXl5eah9vbGyMTp06YceOHSUmR4wxXLt2TeVkxdLSEpMnT8aRI0c0ilEVUqm0zDFO6enp+O2333Dy5EmtxxMQEIADBw6gc+fOGi/wamRkhOnTp6NevXocRac6iUSCW7dulbmfkZGRWovLEkKIvlFixJF39VpcXV111iefz0fv3r05qegcGBiIw4cPo0WLFsU+/vL19VUM8FYFj8dDYGAg/v33X3zzzTcax1mWnJwcPH78uMz9Xr16hWHDhuH27dtaj6lu3brYtm0b9uzZo/KA9vf16NED/fr10+vjKR6Pp1T8pqamJSbahBBSnlFixKHPPvsM//vf/2BnZ6eT/vz9/fHrr79y1p63tzf279+P+fPnw93dHXw+H3w+Hz4+PhgxYoRGbVetWhWrVq2Ch4eHUvvXqFFDrUQsMTERGRkZSu0bFxeH3377DampqSr3oyqRSIQffvgB4eHh+O+//9CtWzeVprG3bNkSCxYs0NsstHeMjIzQuHHjMvdzdXWFs7OzDiIihBBuUWLEsXbt2uHgwYPo0KGDVtfmsrW1xeLFi9UaX1QaS0tLjB8/HhcuXMCRI0dw9OhRnDx5kpMaRZ6enli5ciUqVapU5r716tVT685ITk4OJBKJ0vtfvXoV06dP56RytzJMTEzQpEkTbNmyBYcOHUKLFi3KrEXk7e2NtWvXwsnJSScxlqVDhw5l/rtr2LChUj9nQggpb1ROjPr06YOzZ89qI5YKgcfjoVGjRti1axfOnj2LGTNmICAgQKlaLsqysLDAkiVLtLr2lLOzM7799lu0atUKtra2nLUbFBRUZn0ic3NzfPvtt2q1f+fOHZWTnE2bNuHYsWNq9acugUCA5s2bIzw8HGvXri32Thqfz0erVq1w9OhR1KhRQ6fxlcbX17fUR3rGxsb48ccfaUYaIcQgqZwYZWVlISgoCLVq1cLcuXPx/PlzbcRl8IyNjeHn54fp06fj7NmzuHr1KmbNmgUvLy+NlkcwMjLC7Nmz0bt3b4P84hEIBBg7dmypjxt9fHxQu3ZttdpXZ623/Px8LFy4EHl5eWr1qQkTExP8+uuvOHXqFFavXo3vv/8eTZo0QYsWLbBq1SqEhobqpCClKgQCAaZOnVriI7VmzZrpZDwZIYRohTrFj1JTU9nixYtZ3bp1mZGREfv222/Z7t27dVI4Txt0WagtLS2NzZ49m7m4uKhc2M/IyIiNHz9epYKL5ZFcLmfjx48v9jPy+Xy2YsUKtdtetWqVWkUTjY2N2b59+zj8lOqRyWRMKpUyqVSq71DKFB8fzxo2bMh4PJ7iPLq6urLIyEiV2zLEYomGGDMhFU25KfDo4OCAMWPG4ObNm7hy5Qo8PDzQq1cvuLq6YvTo0VpZHV0X1F1ZXhV2dnaYPHkyzp8/j759+6o0DqlXr16YPXu22rOaygsej4dRo0YVe1eocuXK+Omnn3Qek0QiwaJFi5QuZKktfD4fAoFArYHnularVi0cOXIEs2bNQsOGDdGlSxccOHBArwvbEkKIpjQafJ2UlIQTJ07gxIkTEAgE+O677xATE4M6depg6dKlXMWoM8HBwUhISNB6PzweD+7u7li3bh3CwsLQqlWrMpOd+vXrY/78+QafFL3j6uqKyZMnFylUyOPxMHz4cI3q33z++edq1wu6fPky5s6dC7FYXOR1uVyOBw8eYNOmTZg6dSqWLl2Ku3fvql2EsiKxtbXFlClTcO7cOWzfvh0NGjTQd0iEEKIZVW8xicVitmfPHta2bVtmbGzM/Pz82OrVq4vcxtq3bx+ztrbm7LaWtr27FQeAeXh4sG3btrH8/Hyd9V9QUMD27t3LfH19mbGx8UePeezt7dmlS5d0Fo+uFBQUsC5duig+5+eff87S0tI0avP169esefPmaq9DZmRkxHr37s2OHz/OoqOj2ZYtW1jHjh2Zvb19kf1sbW3Z/PnzmUQi4ehsfNoM8bGUIcZMSEWjjetQ5cTIzs6O2djYsCFDhrAbN24Uu09GRgarXr26prHpzPuJ0bsvx44dO7InT57oNI7s7GwWHh7O2rVrx+zt7ZmRkRFzdXVlBw8e1GkcuvTw4UPm7e3NLC0tOVsY9fLly6xKlSoaLdQqEAiYUCgsMn7mw00oFLI5c+ZQcsQBQ0wyDDFmQioabVyHPMZUWzBqy5Yt+Omnn/ReaI5L2dnZxU6n9/T0xPLly9GyZUudzgCTyWRITExESkoKnJ2dK3wF4fv37+Pp06f45ptvODvPsbGxGDNmDE6dOvXRozEuiUQirF+/Hj169DDIWYLlxbtrMCsrSy9rDqrDEGMmpKLRxnWocmJUEZWUGAGAlZUV1qxZgy5dutAXn4EpLCzE6dOnsWXLFpw7dw5JSUkqFX9UlrOzM06cOAFvb2/O2/5UGGKSYYgxE1LRUGKkJaUlRgAlR7ogFos1XmS1JIwxpKen4+bNmzh58iQuXLiA2NhYvHz5Elz98+/SpQs2b96stc9Q0RlikmGIMRNS0WjjOqQlQZSQlZWFYcOG4cqVK/oOpUI6d+4cmjVrhi1btmilZAKPx4OdnR2+/vpr/PHHH/j3338RFRWFzZs3o1mzZkVmxqkrLCwMR48e5SBaQggh+kSJkZLercb+6tUrnfctk8kQFRWF06dPIz09Xef9a1N2djbGjx+Py5cvY8CAAfjrr7+08rjrfcbGxqhSpQp69uyJo0ePcrI4q1gsxvTp0yvcz4cQQj41lBip4Pr161i0aBFnj1+UtXXrVjRr1gwtW7ZEYGAgli5dipcvX+o0Bm1Zv349rl27BgAoKCjA77//juHDhyM3N1cn/ZuammLEiBGYN2+exo/Bbt26hZUrV3IUGSGEEH2gxEgFjDGsW7cO169f11mfeXl5WLZsGV6/fg2pVIr4+HiMHTsWzZs3R2hoqNIJhEwm00llb1UkJSVhxYoVRQolFhYWYt26dejatSsePnyokzgEAgGGDBmCzp07a9QOYwwrV67EjRs3OIqMEEKIrtHga5Q9+PpDXbp0wdatW2FkZKTFqN64cuUKmjdvjoKCgo/eMzIygre3N9q2bQt/f3/UqlULjDHExcVBLBYjPj4eaWlpAID4+HiIxWJ8/vnnMDMzQ6NGjeDv7w8nJyeNFrVVF2MMEyZMwOLFi0u8A+fu7o7169ejWbNmOonx0aNHaNq0qcYLI7ds2RL79u2Dubk5R5FVfIY4kNkQYyakotHKdchZRSQD9mGBx7I2MzMzduzYMZ3EtmnTJqVi4vP5zNTUlJmampZalPD9/V1cXNiIESNYcnKyTj7L+2JjY5mdnV2ZcVpaWrKFCxfqrBL5lClTNCoMibfFIWfMmMFkMplOYq4IDLFYoiHGTEhFU24Wkf3U5eXlYd68ecjLy9N6X9HR0UrtJ5fLkZ+fj/z8fKXGQMnlciQlJWH58uX48ccfkZiYqGGkypNIJJg7d65SA9mzs7MRHByMPn36KO5+adPAgQPh4eGhURsymQyLFy/G3r17OYqKEEKIrlBipKbz589jy5YtWu9Hm1Wb3zl//jz69u2LnJwcrfcFvHk8uG/fPqX3l0ql2LVrF3r06IG4uDgtRgZUqVIFkyZN0ngKf05ODsaNG4erV69yFBkhhBBdoMRITTKZDPPnz9f6AGFdjf85deoUQkJCdNLXhg0b1Lrb9u+//6Jjx464ffu2FqL6f927d0fz5s01bichIQHdunXDvXv3NA+KEEKITlBipIEnT55g0qRJWr3T4uPjo7W23yeXy/G///0PWVlZWu/riy++UHtqfFxcHH766SfcvXuX46j+n6mpKdauXQtPT0+N23r06BEGDBiA5ORkDiIjhBCibZQYaWjv3r1YuHAhpFKpVtr/5ptv4OrqqpW2P/Tw4UNFTSFtGj58OKZOnapRcjR8+HCt1nKqUaMGDh48iFatWkEgEGjU1tmzZ/H777+jsLCQo+jKv4SEBAQHB6N9+/Zo3749+vTpg127diEtLU3ndcAIIUQlnA3jVsPcuXNZgwYNmLm5OXNwcGDt27dncXFxRfbJz89nQ4YMYba2tqxSpUqsU6dOH82ievr0Kfvuu++Yqakpc3BwYOPGjWMSiUTpOFSdlfbhJhKJ2N9//83JOSnO7t27maurq8azpZTZ5syZo7XP8T6xWMzGjh2r1Ay6krbOnTuzvLw8rcaZk5PD9u3bx1q0aMGEQqHasQqFQhYeHq7VWNUhl8vZ69ev2cOHD9m9e/fYy5cvNZ5NFxkZyTw8PIqdCenh4cGmTp3KXr58WeQYQ5zhZYgxE1LRaOM61Gti1Lp1a/bPP/+w27dvs+joaPbdd98xNzc3lpubq9hn0KBBrGrVqiwiIoJFRkayhg0bskaNGinel0qlzNvbmwUFBbEbN26w8PBwZm9vz4KDg5WOQ9PECACzt7dnhw4d4vT8vO/x48dszpw5rHPnzqxhw4asadOmbPDgwWzEiBGsQ4cOzNHRkZPE6Oeff9baZ/hQWloa8/Pz02ha/OTJk3UyLT4/P58dOnSINWzYkPH5fLXi7dixY7mYwi+VSllCQgLbvHkz69atG/Py8mKWlpbMzMyMVa1alfXt25elpaWp1XZ+fj5r2bJlqeeBx+Oxzz//nB04cEDxB4whJhmGGDMhFU2FS4w+lJqaygCwM2fOMMYYy8zMZMbGxmz37t2Kfe7evcsAsEuXLjHGGAsPD2d8Pr/IXaTVq1czS0tLVlhYqFS/706stbW1xsnRtm3bVLpbpSqZTMYkEgmTSqVFXnv06BHr27cvMzIy0ugz/Pjjj1qLvTj79+9nxsbGasdbqVIlFhYWprN4MzIy2KhRo5iJiYnKsXp4eLCcnBydxfo+uVzO0tLSWGhoKOvYsSNzdHQs8W4dj8dj/fr1K/JvTFnR0dHM1NRUqfNhamrKBg8ezF6+fGmQSYYhxkxIRVPhE6P79+8zACwmJoYxxlhERAQDwDIyMors5+bmxpYsWcIYY2zq1KnMx8enyPuPHj1iANj169eL7aegoIBlZWUptsTEREWyNWDAAGZhYaH2F7VIJGLBwcF6KZpYUFDAVq1axczMzAwmMcrLy2NNmzbVKJmrXr06i4+P11nMUqmULVu2jFWqVKncJ0Z5eXns3LlzbNSoUax69epMIBAoFaudnR17+vSpyv2FhISodE54PB4LCAhgp0+fNrgkgxIjQvSvQhd4lMvlGDVqFBo3bgxvb28AQHJyMoRCIaytrYvs6+TkpJjlk5ycDCcnp4/ef/decebNmwcrKyvFVrVqVQBAnTp1sHr1ahw4cAB16tRR63MUFhZi3rx5CAoKwj///KOTWV7viEQiDBo0CEOGDAGPx9NZv5owNTVF9+7dNWrjyZMn6N+/PzIyMjiKqnQCgQDDhg3DkiVLYGJiovRxRkZGOim/UFhYiFu3bmHBggX4+uuvERQUhGXLluHJkydKr5eXkZGBS5cuqdz35cuXVdqfMYYrV67gxx9/VLkvQgjRhnKTGA0dOhS3b9/Gzp07td5XcHAwsrKyFNv7VZ/5fD5atGiB48ePIygoSO0+bt++jX79+qF58+Y6TZD4fD4mTJjAyVRzXalXr57GBRXPnj2LGTNm6GyhXIFAgN9++w2zZ89WatYaj8fDt99+C1NTU63EwxhDUlIS/v77b3zzzTdo1KgRJk2ahMuXL6s1G04ulyM0NFSl2ZaJiYk4evSoyn0B0ElVc0IIUUa5SIyGDRuGw4cP49SpU6hSpYridWdnZ4jFYmRmZhbZPyUlBc7Ozop9UlJSPnr/3XvFEYlEsLS0LLJ9qEqVKvj7779RvXp1tT+XXC5HdHS0IkE6fPiwTr64HRwcOClQqCuaTocH3iQGf//9N0JDQzmISDkCgQBDhw7FTz/9VOp+IpEIv/76K2bOnMn5nTypVIrr169j9OjR+PLLLzFo0CBcuHABr1+/1rjt48eP48CBA0rtm5qaigEDBuDp06ca90sIIXrF2UM5NcjlcjZ06FDm6upa7BiRd4Ov9+zZo3gtLi5OMR6Isf8ffJ2SkqLYZ+3atczS0pIVFBQoFUdpzyjnz5+v0fiX9zczMzM2evRo9vr1a1VPlcrUjVvXY4wYezO9W5MB2O9v1atXZ48fP9Zp/M+fP2e9e/dmFhYWjM/nMz6fz8zMzFjNmjVZnz592KFDh5hYLOa0T7lczmJiYtjPP/+s8lgnVbZq1aqxEydOlDibTiKRsKtXr7JmzZpx0p8hjdehMUaE6J82rkMjJfMnrRg6dCi2b9+OAwcOwMLCQjEmyMrKCqamprCyssJvv/2GMWPGwNbWFpaWlhg+fDgCAwPRsGFDAECrVq1Qp04d9OrVC3/++SeSk5MxZcoUDB06FCKRSOMYAwMDIRAIOLnTk5eXh7/++gsFBQVYtGgRzMzMNG6zOIwx3L9/Xytta8OjR484u5P25MkTTJ06FRs2bFC7gKSqXF1dsX79ekyZMgVxcXFgjKF27dpwcXGBpaUl53eJXr16hYULF2LDhg1afwT19OlTdOzYEd9++y2aNGkCLy8vPH/+HHl5eUhLS8P58+cRGRmp07F0hBCiVZylWGpACX81/vPPP4p93hV4tLGxYWZmZqxjx44sKSmpSDtPnjxhbdq0Yaampsze3p6NHTtWrQKPxWWcERERSs/kUXbj8/ls7ty5ap+3sjx69Ii5uLioFVurVq3UmqatLplMxvr06cPp+RUKhWz//v06+wy6FB0dzZo0aaJRYUxNNq6vhQ83Q7r7QneMCNE/bVyHPMaoPn92djasrKyQlZX10XijSZMmYcGCBZz36ebmhgsXLhQZU8WFgoIC/Prrr9ixY4dax3t4eODmzZtau5v1oZiYGHz99dec3/kICAjAsWPHPprRqIriLg19zva7fv06unTpggcPHugtBm0r7hosr0r7vUEI0Q1tXId6fZRW3sXExGDLli1aaTshIQEHDx7EkCFDOGszMzMTEyZMwJ49ezRqRy6XcxRR6XJzc/HHH39o5XHQtWvXcPz4cXTp0kWl4woKCnDv3j1ERETg4sWLyMvLU7xnZGQEHx8fNG/eHE2bNtV4Jp0qXrx4gV69elXopIgQQsoDSoxKcPv2bXTt2hUvXrzQWh/R0dGctCORSHDp0iVMnjwZFy5cMIhFOnNzczF27FiNk7iSyOVyrFmzBh06dFBqrFlSUhIOHDiALVu24ObNmyXO6jp06BAWLVqECRMmYMaMGTq5g8QYw6JFixAbG6v1vggh5FNHidEHJBIJ9u/fj+DgYDx8+FCrfWmawOTm5uLixYtYs2YNjh07hvz8fI4i0x65XI7Y2FjMnTsXoaGhWr07de3aNdy/f19RMLS4WOLi4rBjxw5s3boVT58+VepnUlBQgJCQEIwcORK2trZch/2Rhw8fYtu2bVrvhxBCCCVGRTx79gyLFi3C9u3b1SqKB7x53GJpaQlbW1tkZ2cjIyMDEonko/14PB4+++wztfpIT0/H1q1bsWnTJsTExBTbfnn07NkzRUKUnp6u9f7y8vIQFRVVbGIUFxeHlStXYufOnXj16pXKbb9+/VrtfyOqOnz4MFJTU3XSFyGEfOooMXpP27Zt8eTJE7WOdXFxQadOndC+fXvUrl0bdnZ2yMzMxJMnT3D+/HkcO3YMcXFxyMjIgEgkwnfffYfffvtNpT4YYzh9+jQmTJiAqKgog3hk9s79+/fx448/4tatWzrrk8fjfTSIPDc3FytXrsRff/1V4pIx5YlYLFa6yOKnbtWqVVi4cCGSk5Ph4+ODFStWwN/fv8zjdu7ciW7duqF9+/bYv3+/9gMlhJRvnM1vM2Dvpvups/F4PNaxY0cWHx/P5HJ5iX1IJBKWnJzMLl68yO7evat08cl35HI527x5M7O0tNTqdGk/Pz+VYyuLVCplvXv31vnU8vr167O0tDRFHIWFhWzgwIGMz+dr3Labm1uRtrUlNjZW6z/z8rSpO+V2586dTCgUso0bN7I7d+6w/v37M2tr6yKFX4vz+PFjVrlyZfbVV1+x9u3bq9QnTdcnRP8q9CKyhqpDhw4ICQlBrVq1Sh2Ia2RkBCcnJwQGBsLLy0vl4pNPnjzBhAkTkJ2drWnIpapRowYnhTHf9+LFCxw+fJjTNsvi7u6Ov//+G3Z2dorX7t27h82bN3Myrqlu3bqwsbHRuJ2ynD59Wus/84pgyZIl6N+/P/r27Ys6depgzZo1MDMzw8aNG0s8RiaToUePHpg5cybc3d3L7KOwsBDZ2dlFNkJIxUOJkQZcXV2xYMECndQwiY6ONohHP8VJSUkpMu1d2xo3boy9e/fCz8+vyOtisVilRVFLwuPx0K5dO/D52r18ZDIZ/v33X632URGIxWJERUUVWfSZz+cjKCgIly5dKvG4WbNmwdHRUelH2vPmzYOVlZViq1q1qsaxE0LKH0qMNNCnTx94eHjopC+RSKT1L2IAsLe357xNS0tLGBnpZjhbixYtsHv3bvj6+n70XuXKlYvcQVKXvb19kS9hbYmPj8fJkye13s87RkZGcHZ2Rp06deDh4QFTU1Od9a2JtLQ0yGQyODk5FXndycmpxD8mzp8/jw0bNmDdunVK9xMcHIysrCzFlpiYqFHchJDyiRIjNVlaWqJr1646q4QcGBiIunXrar2fWrVqcd6mo6MjXF1dOW/3Qx4eHli/fj1cXFyKfd/BwQFffvmlxv107doV1atX17id0sjlcmzYsEEnj2vs7e3Rr18/HDx4ENevX0dkZCSioqJw4cIFDBw40GASJGXl5OSgV69eWLdunUp/CIhEIlhaWhbZCCEVEGejlQyYOoOvAwICOB+kXJYLFy4wW1tbrQ185fF4Rdap49LMmTO1ur6XtbU1O3XqVJlxbN68WaPB115eXiwxMVEr5+h9J0+eZBYWFlod6Gxvb8+GDx/O4uLiSpw4IJFI2K5du1i1atXK7eDrwsJCJhAIWFhYWJHXe/fuzdq1a/fR/jdu3GDAm3Xf3m08Ho/xeDwmEAjYgwcPlOqXBl8Ton80+LocadWqFeeDlMsSGBiIdevWaW3QL5/P19qjwWHDhiEgIEArbfN4PIwdOxbNmjUrc99vv/0Wbm5uavVjbW2NlStXcr6+3Yfu37+PUaNGIScnRyvtm5mZoU+fPjh//jz++usveHp6lnjn08jICD/99BP27duns8fGqhIKhfDz80NERITiNblcjoiICAQGBn60v5eXF2JiYhAdHa3Y2rVrhxYtWiA6OprGDhHyqeMsxTJgqt4xMjY2ZhEREXqJVS6Xs7179zI7OzvO/1q3sLBgd+/e1VrsDx8+ZA0aNOA87sqVK7Pnz58rHcfs2bNVvntlbW3NQkNDSy3JwIX4+Hjm6+urlbsxQqGQNW3alJ09e5ZJJBKVY4uKimIeHh6cxGJtbc3c3NyYm5sbc3Z2Vvw8NJmuLxKJWEhICIuNjWUDBgxg1tbWLDk5mTHGWK9evdikSZNKPL5Pnz40XZ8QA6SN65AKPKrB3d39oxlPusLj8dCxY0e4urril19+wb179zhr28zMjJPBySVxd3dHaGgounTpgsjISM7a9ff3L3FcUXGGDBmCw4cP48qVK0rtX716dSxZsgQdOnTQ6piyuLg4dOvWTa019MzMzODo6AgrKyvFaxkZGcjLy0PlypVRv3599O7dG/7+/h8VvVRW/fr1ERYWhuHDh+P06dMqH8/j8VCtWjX0798fP//8MxwcHAAA+fn5OHnyJHr06KFWXADQpUsXvHz5EtOmTUNycjJ8fX1x7NgxxYDshIQEnUxeIIRUAJylWAbsXcbp5+dX5p0EHo/HJk+erFY/6enpbNOmTWzu3Lns0qVLGt99uHfvHmvVqhVnY3fq1KnDcnJyNIpJGVzfOZo9e7bKMVy4cIG5uLiU+bNu0qQJu3HjBvcn4QMnTpxQeRwPj8djvr6+bPHixezWrVssPT2dFRQUKLaXL1+yxMREVlBQwOmdrhcvXrBvvvlGpVgtLCzYxIkTS7yzZ4h3XwwxZkIqGm1ch5QYsf8/sU+ePGFLly5ltWvXZgKBoNhf8E2aNFG54rFcLmcXLlxgdevWVQz8tbW1ZSdPntQ49levXrHhw4eXGK8qW7NmzZhUKtU4JmVwmRytWrVKrRhOnjzJ3N3di23T3t6eTZw4UevVraVSKQsNDWXOzs4qfWYTExM2bNgw9vLlS63GV5KkpCTWpk0bpQaye3l5sf/++4/JZLIS2zPEJMMQYyakoqHESEs+PLGvXr1ihw4dYr/99htr3Lgx8/b2Zo0aNWLjxo1TaSwLY4zJZDK2adMmZm9vX2yS9fr1a43jz8/PZ6NGjdI4OerSpYvWx9C87969e6x69eoaxczn89mePXvUjuHJkyds1KhRzNvbmzk6OrKAgAAWHBzM7t27p/VzIZVK2fLly5mpqalKn1kgELCJEyeqNU6ISzk5OWzatGnMysqqxLtEAwcOVGoWnyEmGYYYMyEVDSVGWlLSiZXL5UwqlbKcnBwmkUhU/qLMzMxkkydPZubm5sV+cRgbG7O9e/dy8hm4SI4mTJjASSyqCAsLY2ZmZmrHLBAI2PHjxzWKQS6Xs5ycHJacnKyzEgzqJkUA2A8//MBJQs0FmUzGrl+/zvr37888PT2Zu7s78/T0ZH379mVXr15V+g6kISYZhhgzIRUNJUZawuWJlcvlLC0tja1fv575+PiU+aiBq7tGjL1JjgYNGqR2kvH3339zEocqZDIZmzhxokbjpNR9lKZP69atUyspsrKy0smYJ1W9Sy7fbar+EWGISYYhxkxIRUOz0sqprKwsPHjwAHfu3MHZs2dx6tQpPHnyRKnFSq9cuYKjR4+ic+fOGsdhYmKCWbNm4fHjxzh+/LhKxwqFQnh7e2scg6r4fD7Gjx+PCxcu4Pz582q18fTpU46j0q7Y2FhMmzYN+fn5Kh/bqVMnnVRAVxWPx4O5ubm+wyCEEI3R/FU1yeVy3Lp1CyNHjoS/vz+aNGmCPn36YMOGDXj06JHSK7hLJBLMnz8fGRkZnMTl4OCAzZs3o02bNipNT3Z3d4eXlxcnMajKzs4OK1euVLuA4LFjx5Cbm8txVNohlUoxa9YsJCUlqXysqakpBg4cSNPOCSFEi+g3rBoYY1i5ciWaNWuG5cuXIz4+HgUFBWq3FxUVhW3btnEWn6OjI3bu3Inx48crVSXbyMgIw4cP11pFbWX4+PggNDRUreQoNjYWhw8f1kJU3IuMjFQ7Vn9//2IXxyWEEMIdSozUEBUVhZkzZyIzM5OT9hhjWLVqFV6+fMlJe8CbRW7nzp2LM2fOYOTIkWjQoAGsra1hamoKHo8HPp+PSpUq4fPPP8eSJUvw22+/cda3uurXr4+9e/eiZcuWKt0VkUqlmDBhAq5fv67F6Lixa9cuvH79WuXjeDweevfurfNlaAgh5FPDY4wxfQehb9nZ2bCyskJWVlaZK2bLZDL06tULO3bs4DQGHo+HUaNGYeHChRAIBJy2DQCFhYVISkpCbm4u4uPjIRQKUbt2bbi4uMDCwoLz/jSRm5uLzZs3Y8WKFYiPj1f6saSLiwv++OMPtG/fHtbW1orzyN5MMvhof10/kiosLETDhg3VqmxdtWpVXLlyRaUK34ZElWuwvDDEmAmpaLRxHVJiBNVO7JMnT9CgQQO8evWK8zgqVaqEsLAwtGzZkvO2DdGrV6+wY8cOrFq1Cvfu3Ss2ufmQQCBA1apVUb16ddSuXRvW1ta4f//+R2O4LC0t0aRJE7Rp0wZ16tTRSZKUmJiIevXqqfVvp2/fvtiwYYNWlyTRJ0NMMgwxZkIqGkqMtESVE7thwwb0799fqS9pdXh4eGDXrl2oV6+eVtpXR2ZmJuLj43H79m1IJBLExsYiJycHvr6+MDExAQB4enqicuXKcHZ2RqVKlTj9An+XIL27g8QlGxsbdO/eHZMnT9b63ZiYmBgEBASoPBvNzMwMx48fR5MmTbQUmf4ZYpJhiDETUtFo5TrkbOK/AVO2DoJcLmddunRRu96OspuHhwe7cuWKTqtQF0cmk7Ht27ezunXrMqFQWGrMRkZGzMrKinl5ebFevXqxgwcPsszMTE7jef78ORs4cCATiUScn3NfX1927tw5TuP90KFDh5RaQuPDrXPnznqvcq1thlgTyBBjJqSioQKPWqLsiX358iWrWrWq1hMjAMzOzo7NnDlTqeUUtCUkJETtqtTGxsbM29ubbdmyhRUWFnIWk0QiYQsXLtRKcuTi4sIiIiI4i/VD9+7dY5UqVVIpJltbW3bp0iWtxVReGGKSYYgxE1LRaOM6pFlpKoiLi0NycrJO+nr16hWmT5+Oxo0b4/fff8eVK1cgFot10jcAZGRkYO7cucjLy1PreIlEgtu3b+O3337D9OnTUVhYyElcRkZGGDVqFEaOHMn5uKCkpCT07NkTp06d4rTdd5ycnFCjRg2l97e1tcW6desQEBCglXjKC5lMhmPHjuk7DEIIAUDT9VVy6dIlSCQSnfaZkJCAefPmoUWLFmjVqhV27typVsVkVcXFxeHJkycatyMWi7Fo0SL88ccfSs8uK4uRkREmT56Mpk2bctLe+5KSktCjRw+cPn2a87atrKwwb948ODg4lLiPiYkJKleujC5duiA8PBwdO3assAOugTczEOfMmYNff/1V36EQQggAGnwNQLnBW4wx9OjRg/Np+qoSCARo06YNVq1aBTc3N631c+jQIbRv356zQeaVKlXCwYMH8fXXX3PSHgCcP38e3333HXJycjhr8506derg4MGDqFmzJqftMsZw584dnDp1Cg8ePIC7uzucnZ0BvPnZenl5wcnJCba2tlop26BtjDFkZGTgwYMHePHiBeRyOSpXrowaNWrA3t6+yF2+lJQUTJgwAVu3blUkzYY0kJkGXxOif9q4DmmtNCXl5+cjNjZW32FAJpPh8OHDkEql2L17t8GsT/X69WtFtXCuvvAbNWqEwYMHY+HChZzPEoyNjUXXrl0RFhaGKlWqcNYuj8eDt7e3Xtal07b4+HisXr0ahw4dQmJiIqRSKYA3CZ+joyMaNmyIDh06oFmzZnjy5AnGjRuHq1ev6jlqQggpih6lKamwsBBpaWn6DkPhv//+w9mzZ/UdhkquX7/O6ZpmfD4fo0ePhqenJ2dtvi8yMhKzZs2CTCbTSvsVRX5+viLpXbZsGR4+fAixWAy5XA65XA6JRILnz59j79696N27NwIDA9GtWzdERkbqO3RCCPkIJUZ6wOPxNL5rIpVK8ejRI44i0o1Xr16ptXhqaZydnTF37lxFPSWu7d69G48fP9ZK2xVBbm4uRo0ahVGjRik1MaFKlSpYuHAhzp07hwULFsDV1VUHURJCiPL0mhidPXsWP/zwA1xdXcHj8bB///4i7zPGMG3aNLi4uMDU1BRBQUG4f/9+kX3S09PRo0cPWFpawtraGr/99lu5XGmdz+fD29sbU6ZMwaZNm3D06FGsWLECP/30k9rPRU1NTTmOUrvkcrni8QqXfvjhBwwbNkwrg5QLCws1WiC4IpNIJJgwYQLWr1+v1F21ypUrY+fOnejWrRtq1KiBsWPH4tSpU/jxxx8NcjwVIaSC4mzivxrCw8PZ5MmT2b59+xgAFhYWVuT9+fPnMysrK7Z//3528+ZN1q5dO1ajRg2Wn5+v2Ofbb79lPj4+7PLly+zcuXPMw8ODdevWTaU4lKmDUFhYyJo0aaJWfRx3d3e2fv16lpGR8VG7MpmMXb58mTVu3JjxeDyl27SxsWFxcXEqfU5VXLp0ifNaQVWrVi32HHAhKyuL/fDDD5zXNmrYsCHLycnRSsyGbs+ePUr/GzE3N2fbtm0rtp2CggI2d+5cg6sJRHWMCNG/Cl3g8cPESC6XM2dnZ7Zw4ULFa5mZmUwkErEdO3YwxhiLjY1lANi1a9cU+xw9epTxeDz2/PlzpftW9sQuXrxYpeRFKBSyHj16sEePHpUZw8uXL9nAgQOVrow8YMAAJpPJlP6Mqnr8+DGztLTkNMlo3ry5Vis4P3r0iHl7e3MWr5WVlVYLPqpDKpWyu3fvsj179rDdu3ezPXv2sLt37zKxWKzTOHJycljDhg2VOo8CgYDNnTu31H+vmZmZBpdkUGJEiP59UonRw4cPGQB248aNIvs1bdqUjRgxgjHG2IYNG5i1tXWR9yUSCRMIBGzfvn0l9lVQUMCysrIUW2JiolIn9uXLl8zPz0+pLwMXFxe2Zs0alb6w8vLy2OjRo5mpqWmpbVepUkWrd4sYYywjI4PVrFmT08RoypQpWo2ZMcZOnjzJrK2tNY7VyMiIrV69Wu/Lsrzv6dOnrG/fvszGxqZIrJaWlqxVq1bsyJEjOls65Pjx48zIyEipc9myZUuWl5dXanuGmGQYYsyEVDSfVOXrdwM5nZycirzu5OSkeC85ORmOjo5F3jcyMoKtrW2pA0HnzZsHKysrxVa1alWlYrK3t8c///wDLy+vEvcxNzdH165d8e+//2LgwIEwNjZWqm3gzZihhQsXYvHixTAzMyt2H5FIhIULF2ptJtY7ZmZmsLGx4aw9oVCIoKAgztorSbNmzTB16lSNx6z06NEDv/76a7kprnj16lW0bNkS//zzDzIyMoq8l52djX///RedO3fG4MGDdTIof//+/UqNFxOJRBgzZozBjYcjhHy6ym1ipE3BwcHIyspSbImJiUof+8UXX2D//v3o3bs37O3tYWxsDHNzc1SvXh39+vXDiRMnsGXLFrXr1AgEAgwcOBAhISGoXbt2kS9me3t7zJs3Dz/++KNabatCKBTiyy+/5Kw9Z2dnndTu4fP5GDx4sEbnyNbWFpMnT4ZQKOQwMvUwxnD69Gl06dIF8fHxpe5bUFCA9evXo3nz5ti4cSNny7B8KCMjAydOnFBq34CAALRo0UIrcRBCiDaU2wKP76oBp6SkwMXFRfF6SkoKfH19FfukpqYWOU4qlSI9PV1xfHFEIhFEIpHasXl6emLjxo1ISkrCo0eP4OzsDHt7e9jY2HByh4HP5+Onn35C8+bNsW/fPjx//hxCoRAdOnTA559/rrO7GM2aNcOaNWs4KZ7YvHlz2NrachBV2UxNTbFo0SLExMSoVZSzTp06qF69OveB4U2BTrlcDj6fX+ZdLbFYjH/++QcTJ05EVlaW0n0kJiZi0KBBOHr0KObOnYtatWppGnYRkZGRSi0Xw+Px0KtXL42uNUII0bVymxjVqFEDzs7OiIiIUCRC2dnZuHLlCgYPHgwACAwMRGZmJqKiouDn5wcAOHnyJORyudYX3hQIBKhSpQqnVZE/5ODggIEDB2qt/bI0btwYrq6ueP78uUbtCAQCna/5VaVKFaxcuRLt27dXeckQgUDA+QK1BQUFCA0NRWhoKF69egU7Ozu0b98ebdu2haura5H+5HI5bt++jaVLl2Lbtm1qrc8nkUiwZ88eXLlyBcuXL0f79u05O/9nzpxR6jGag4MDWrVqxUmfhBCiK3pNjHJzc/HgwQPF/z9+/BjR0dGwtbWFm5sbRo0ahT/++AO1atVCjRo1MHXqVLi6uqJDhw4AgM8++wzffvst+vfvjzVr1kAikWDYsGHo2rUrFY7jQJUqVdCtWzcsWrRIo3YqV66Mxo0bcxSV8po1a4YePXpgzZo1Kh137949PHv2DNWqVeMkjoSEBIwbNw5hYWFFEoqjR4/CxcUFAQEB8Pf3h1AohFwux7Vr13DixAlkZmZq3HdiYiL69u2LyZMnY+TIkSqNeStOYWGh0o/RvvvuO63+4UAIIVrB2TBuNZw6darYWSx9+vRhjL2Zsj916lTm5OTERCIR++abb9i9e/eKtPHq1SvWrVs3Zm5uziwtLVnfvn1VrjtDs0tKFh0dzaysrDSa4TVixAi9ze6KiYlRa5Za3759y5xJpYy4uDjm4+PD6ew+dTahUMhmz56t8bT+R48eKXU+TU1N2ZkzZ5Ru1xCvQUOMmZCKpkJP19cn+gVXMplMxvr27avRF/Lp06f1Fr9EImFBQUEqxy0QCNjw4cM1So5evnzJGjRooPekiMvk6MiRI0rV2mrSpAkrKChQul1DvAYNMWZCKppParo+KR/4fD5GjBih9rIl7u7uqFevHsdRKc/IyAiNGjVS+TiZTIb//e9/6N69O+7du6fy8bm5uRg8eDCioqJUPlZbxGIxZs+ejfHjx6s0mPt9V65cgVwuL3UfCwsLzJw5kwZdE0IMEiVGpEyff/45vvrqK7WObdGihdpJFVesra3VOk4mk2H//v349ttvERYWptR6YMCbmZELFixAWFgYJzP6uCQWi7F8+XJ07doVMTExKh0rlUpx7ty5UvcxMjLCmDFj0Lx5cw2iJIQQ/aHEiJTJ2NgY3bt3V2umljp3a7im6SDmJ0+eoFevXhg3btxHxRWLExYWhiVLliidSOkaYwzHjh1Dy5YtMXv2bDx58kSpWB89eoSbN2+W+L6pqSnGjx+P33//nfNZfYQQoiv026sMcrkcubm5ePToEbKzs8t8jFBRNWnSROU7LyYmJjop6lgWVe+MFOf169f466+/0K5dO9y6davE/R4/fowJEyYgLy9P4z61LSUlBdOmTYO/vz86deqEv//+Gzdu3MCTJ0+Qm5tbZIuLi8OsWbOQnp7+UTvm5uZo1qwZQkNDMWvWrHJRGJMQQtRVbusY6ZtMJsOJEyfw999/IyYmBi9fvoSdnR38/PwwcOBAtGjR4pP6q9jBwQFubm7FfjGWhM/nl7i0ia7k5ubi7t27nLTFGMP58+fx7bffYtWqVWjXrl2RIo0ymUxxB8aQvHz5EgcPHsTBgwchEolgZmYGOzu7IvukpqYiOzsbAGBpaQl3d3d8/vnnaNq0KRo1aoTatWtTQkQIqRAoMSpGfn4+Zs+ejWXLliE/P1/xelZWFh49eoSjR49i/PjxmDBhAkxMTPQYqe4IhUKYm5vrOwyVxcbGcp6oJCUloWfPnli8eDEGDRqkeD0hIQEHDx7ktC9dKywsRGFhYYmPDGvXro2tW7fC29sbJiYm5WYtOUII4cqnc8tDBSEhIfjzzz+LJEXvy83NxaxZszBp0iQUFBToODqiLMYY9uzZo5WfUV5eHmbMmFEk6Xr9+rVaVaoNBY/Hw5QpU/Dll1/C1NSUkiJCSIVEidEHUlJSsHjx4jIHo8pkMqxatQrr168vdzOPtCEvLw9paWkqHSORSJCcnKyliMr26tUr7Nu3T2vty+XyIo/SPvvsMwwaNKjMNdAMVXkZM0YIIdpEidEHjh8/jkePHim1r1QqxfTp0xEZGVnmvnl5eYiNjcWtW7dw69YtpKWlGVRC9eDBAyQkJKh0jEQiKXWgsradOHECjx8/1krbPB4PvXv3RuXKlRWvCQQCTJ8+HXPmzKmQj1hFIhEcHBz0HQYhhGgVJUbvkclkKteeSU9Px+rVq0s8hjGGo0ePolmzZvjyyy/h7+8Pf39/NGjQAFOnTlUMaC3vdu7cqdZMq8OHDyu14CjX8vLysGrVKq3NImzatCmmTJny0QB8MzMzjBs3DiEhIXByctJK3/pibW2NSpUq6TsMQgjRKkqM3pOVlaXU3Z8PXbp0Cbm5ucW+d/fuXfTq1QuRkZHIy8tTDG59+vQp5s6diyFDhpT75Cg1NVXtR1JXr17Vyyyto0eP4sqVK1pp28/PDxs2bCixfIFAIECXLl1w5MgR+Pv7V5ixOHZ2dgY5AJ8QQlRBidF7nj17pvI4GgAoKCgocdDtpUuX8OrVq2LfY4xh+/btWLZsmcp96gpjDOvXr8fDhw/VOj4zMxOHDx/mOKrS5eXlYdmyZZzfqeLxeAgICEBoaChq1qxZ5v5+fn4IDw/HxIkTYWFhwWkshBBCtIMSo/c8efIEYrFY5eMCAgJKvHvg6+tb6pciYwz79u1DYWGhyv3qwt27d/HXX3+pPR6KMYZt27aVeEdNG86dO8f53SI+n4+uXbvi8OHDSiVF79jZ2WHOnDk4cuQIWrZsCVNT02L3E4lEMDExUWxc1ATi8/mK9ri4a8XeLDqtcTuEEFKeUR2j9zx69EjlMSnGxsbo3bt3icUefX19MWnSJMycObPEpEsikZTLL5z8/HwEBwcjNTVVo3Zu3bqFqKgoNGvWjKPISiaVSrFu3TpOp82bmppi4sSJGDt2rFqPkvh8Pr766iscPHgQkZGROH36NJ49ewY+nw9vb2/Y2Njgs88+g5HR/1+OOTk5ePDgAV68eIF79+7hzp07ePbsGfLy8pCTk/PRv1M+nw9zc3O4uLjAy8sLvr6+8PX1Rc2aNcEYQ3R0NP7++29cvHhR7XFXz549Q3p6OpydndU6nhBCDAElRu+5c+eOysd8//33+Oabb0p8XyAQYPz48RAKhZg7d26xhfNq1KhR5EuxvNi0aRPCw8M1bkcsFiM0NBRNmzbV+nibx48fIyIigrP2PDw8sHTpUnz77bca/4xMTEzQpEkTNGnSRKn9AwMDFf8tkUiQmZmJ/Px8PHz48KPEz8jICDVr1oSdnR3MzMw+StS/+OILdOjQAX/99RfmzJmjVm0nsVisl4H0hBCiU4ywrKwsBoAFBQUxAEpvxsbG7MSJE0r1IZfLWWRkJOvVqxdzdnZmRkZGzNjYmNWvX5/FxcVpFH9BQQFLTExkr1+/1qid98XGxjIXFxeVzkdpm5ubG0tNTeUsvpIsWLCAs5iDgoJYbGys1mPWJalUyqZOncr4fL7K50MkErGrV69qJa5312BWVpZW2tcGQ4yZkIpGG9chjTF6T2Jiokr7BwQEKL16PI/Hg5+fH0JCQnD9+nUcO3YMEREROHHiBDw9PdUJF4WFhQgJCUGzZs3g5+eHRo0aYe3atSVW7FZWTk4ORo4ciaSkJI3aed+zZ8+0Pgg7JycHO3bs4KSt1q1bY9u2bfjss884aa+8EAgEmDBhAjp16qTysWKxuMSlQgghpKIof89v9EiVOj0mJiYYP368youk8vl8uLi4wMXFRdXwikhPT8ewYcOwZ88exWOV1NRUDBs2DBcuXMDatWtLHOhbGqlUiqlTp3L6OAp4UyV6+fLl6NChA2xsbDhtG3gzMHjdunWIiYnRuK1WrVph8+bNcHR05CCy8sfc3BxLlizBo0ePcP36dX2HQwgh5QrdMXpPSdPqi9OhQwd89913WoymZOnp6fjtt9+wc+fOj8aaSKVS7NixA6tWrVK5XblcjnXr1mHt2rVaKYx48+ZNzJgxQyvjVK5du4b58+eXuZRLWWrXro0VK1ZU2KTonapVq2LVqlVwc3PTdyiEEFKuUGKkBnd3d8yaNUsvA6Zzc3PRr18/HDhwoMSZbFKpFMuWLVNpCQ+5XI6///4b48aN09rCuIwxrF27FitWrOBsFh5jDKdOnUKPHj3w8uVLjdqysrLCypUrUbt2bU5iK+8aNmyIHTt2KJ0cGRsbUz0mQkiFR4mRiszNzbF06VLUqlVLL/2vW7cOBw8eLDOxeP78OU6dOqV0u2FhYRg7dqxay36oorCwELNnz8aRI0c0bkssFmPt2rXo1KkTHjx4oFFbPB4PY8eORVBQkMZxGZJGjRphx44dqF69epn7Ojs7fzJJIyHk00WJ0Xvs7e1LfZ/P52PMmDH4/vvvdRRRUXK5HMeOHVP6cdHdu3eV2u/UqVMYMWKE1pOidzIyMtC3b1/s2LFDrcdqjDHExsaid+/eGDFiBDIzMzWO6auvvsKIESMqzPIdqmjUqBFOnDiBJk2alPr5/f39tTI+jBBCyhNKjN5T1i/99u3bY9y4cSUWc9Q2Ho+n9IBqY2NjtGjRosz9YmJi0KtXL7x48ULT8FSSlpaGvn37YtasWUonNjKZDPfv38fYsWPRokULhIaGclLI0dXVFatWrYKVlZXGbRkqDw8P7N27F7/99htEItFH71eqVAnDhw/X2799QgjRFfot9546deqU+J6Pjw+WLl2q1zEWPB4Pv/zyS5kx8Hg8tGnTBk2bNi11P4lEgqlTp+L58+dchqm0wsJC/PHHHwgKCsKWLVuQkpICqVSqWHpCKpUiNzcXDx8+xMaNG9GhQwcEBgZi6dKlGlfjfsfS0hIhISHw9vbmpD1NyeVySKVSxabpYHJVODo64n//+x82bdoET09Pxd0jgUCAoUOHonHjxjqLhRBC9IXHuBoFa8Cys7NhZWWFNWvWYPDgwR+N33F0dERYWJjSNYu0SSaT4fjx45g4cSLu3LnzUayVKlVCv379MG3aNNja2pbaVkJCAnx8fDh5FKUpgUAAJycnuLm5oUaNGgDexJeVlYVnz54hKyuL82VTTE1NsWjRIgwaNEhvd0JkMhlevHiBmzdv4uLFi4plQN4xNzdH48aN0bZtW/j4+EAgEOgkrrS0NBw+fBiRkZFo0qQJ2rdvr1b5B2W9uwazsrJgaWmptX64ZIgxE1LRaOM6pMQI/39i79y5gxYtWhS5G2FhYYHQ0FC0adNGjxF+LC0tDbt27cLu3bsVs8jq1q2LX375BV9++aVSM+aePHmCunXrIicnR9vhljvOzs6YP38+evXqpZek6NWrVzhw4AD27duHK1euID09vdQSCRYWFujcuTNmzJiBatWq6TBS3TDEJMMQYyakotHKdchZDW0D9q6keEZGBhswYIBiCQQTExO2bNkyJpPJ9B1iiaRSKZNIJEwikTC5XK7SsS9evGBOTk6cLaFhKFv9+vXZuXPntPQTKZ1UKmWHDh1iXl5ejMfjqRy7t7c3u3Pnjl5i1yZDXF7DEGMmpKKhJUG0jM/nY+bMmfjhhx/g6emJjRs3YtiwYeV6wKlAIICRkRGMjIxUnlHl5OSk1ADtikIgEKBr1644fPiw0gu5ckkmk2H58uXo2rUr4uLi1Ho0ePv2bfz888+IjY3VQoSEEELoURo+vhVXUFCA/Pz8T2Jq8uXLlxEUFITXr1/rOxStsrKywqRJkzBixAiVl3Hhwruk6Pfff+ekgKa3tzeOHj2KKlWqcBCd/hniYylDjJmQikYb12H5vRWiRyYmJp9EUgQAX375JX799dcKXb/H3t4eGzduxMSJEytEUgS8uXM0fPhw5ObmctIeIYSQN2gR2XKisLAQz549w/Pnz2FsbIwvvvgC5ubmWu9XIBBg8uTJOHfuHKKjo7Xen655enpi8+bN+PLLLzlJ/hhjSElJQXR0NG7fvo2UlBQ8fPgQZmZmqFu3LgQCAby9veHg4IDKlStDIpFg69atmDlzJudLrRw6dAiLFi3CtGnTyvXjXkIIMSSUGOlZYWEhTp06hSVLluDatWvIyckBn89Hs2bNsGLFCnh5eWk9BicnJ6xYsQIdO3ZEWlqa1vvTFU9PT+zatQt169blpL309HQsXboUISEhSEpK+qjG0LZt2wC8GasmFAphYWEBuVyOjIwMrSzKK5PJsGTJEjRo0EBv1dgJIaSioT8z9SguLg5du3ZF+/btceLECWRmZkImk0EikeC///7D8OHDdVZjqEmTJpg+fTqMjY110p+21a5dG6GhoZwlRbm5uejZsyfmzJmDZ8+elVp4US6Xo6CgAC9fvoSxsTF69OiBBg0aQCgUchLL+3JycjBp0iQ8e/aM87YJIeRTRImRHshkMmzYsAFBQUHYv38/xGJxsftFRERg6dKlnBc2LEn//v3RvXt3nfSlTdWrV8euXbvg4+PDWZt79uzBv//+q9LPokGDBjh16hQ2bdqEs2fPYs+ePWjSpAnnj73u3LmD8ePHIz8/n9N2Dc2qVatQvXp1mJiYICAgAFevXi1x33Xr1uGrr76CjY0NbGxsEBQUVOr+hJBPCGcT/w2YLuuR5OTksNGjRzMTExOl6tY4ODiw6Ohorcf1zosXL1j9+vX1XmtI3c3Gxobt37+f03Mil8tZ586dVYqjQYMG7OHDhx+1lZ2dzaZNm8bMzc05/dwCgYCtWLGC08+tS5pegzt37mRCoZBt3LiR3blzh/Xv359ZW1uzlJSUYvfv3r07W7VqFbtx4wa7e/cu++WXX5iVlRV79uyZzmImhGhOG9dhhUmMVq5cyapVq8ZEIhHz9/dnV65cUfpYXf2Cy8nJYX379mV8Pl+lL70ff/yRFRQUaDW29504cYKZmppy+sXN5/OZsbGxYjMyMtJKUrR3716VC12WRS6Xsy5duigdh6urK7t+/XqJ7clkMnbgwAHm7u7O6ed3cHBgly9f5vSz64qm16C/vz8bOnSo4v9lMhlzdXVl8+bNU+p4qVTKLCws2KZNm0rcp6CggGVlZSm2xMRESowI0TMq8FiC0NBQjBkzBtOnT8f169fh4+OD1q1bc7bQKBdyc3MxYsQIbNq0SeWBuAcOHMCOHTu0FNnHmjdvztkjNWNjY7Rp0wbbtm3D+fPnFVtERAT69+8Pa2trTvqxsbHB+vXr0bFjR85LD/B4PDRr1kypdl1cXLB161bUq1evxH34fD7atWuH/fv3o1mzZpzF+fLlS4wbNw5ZWVmctWkIxGIxoqKiEBQUpHiNz+cjKCgIly5dUqqNvLw8SCSSUtcXnDdvHqysrBRb1apVNY6dEFL+VIhZaUuWLEH//v3Rt29fAMCaNWtw5MgRbNy4EZMmTfpo/8LCQhQWFir+/90XyalTp1CpUiXO45PJZNi0aRN27typ1nghiUSCiRMnQiQSwcHBgfP4iuPr6wtjY2NIJBK12+DxeOjWrRt++ukniEQiZGdnF3m/c+fO8PDwwOzZszWqx8Pj8dCrVy9UqlQJERERardTGisrK1hbWyMjI6PEfYyNjfHrr79CKpXiv//+K7NNxhgGDBiA7Oxs3Lhxg5M4z58/jylTpqBdu3YGVZvqXYFRda6PtLQ0yGQyODk5FXndyckJcXFxSrUxceJEuLq6FkmuPhQcHIwxY8Yo/j87O5uSI0IqIs7uPelJYWEhEwgELCwsrMjrvXv3Zu3atSv2mOnTp3P+GIc22mjTfCtuXFZZnj9/zgCwixcvFnl9/PjxzN/fv8zj582bx2xsbNjNmzdV6pfGGBGif9q4Dg3+jpE6fy1++JdfZmYmqlWrhoSEBFhZWWk1Xq68+2s1MTHRYJYjoJh1wxBjzsrKgpubW6mPskpib28PgUCAlJSUIq+npKTA2dm51GMXLVqE+fPn47///uOstAMhxLAZfGKkDpFIBJFI9NHrVlZWBvNF8o6lpSXFrAMUs26oU8pAKBTCz88PERER6NChA4A3taQiIiIwbNiwEo/7888/MWfOHBw/fhwNGjRQN2RCSAVj8ImRJn8tEkIqhjFjxqBPnz5o0KAB/P39sWzZMrx+/Vox7rB3796oXLky5s2bBwBYsGABpk2bhu3bt6N69epITk4GAJibm+tkKR5CSPll8LPS3v9r8Z13fy0GBgbqMTJCiK506dJFsW6cr68voqOjcezYMcUj9oSEBCQlJSn2X716NcRiMX788Ue4uLgotkWLFunrIxBCygmDv2MElP3XYllEIhGmT59e7OO18opi1g2KWTe4iHnYsGElPjo7ffp0kf9/8uSJ2v0QQio2HmM6Wm9Cy1auXImFCxciOTkZvr6+WL58OQICAvQdFiGkgsrOzoaVlRWysrIMbiwXIRWFNq7DCpMYEUKILlFiRIj+aeM6NPgxRoQQQgghXKHEiBBCCCHkLUqMCCGEEELeosSIEEIIIeStTz4xWrVqFapXrw4TExMEBATg6tWreovl7Nmz+OGHH+Dq6goej4f9+/cXeZ8xhmnTpsHFxQWmpqYICgrC/fv3i+yTnp6OHj16wNLSEtbW1vjtt980WqC1LPPmzcOXX34JCwsLODo6okOHDrh3716RfQoKCjB06FDY2dnB3NwcnTt3/qggZ0JCAtq2bQszMzM4Ojpi/PjxkEqlWol59erVqFu3rqIydGBgII4ePVpu4y3O/PnzwePxMGrUqHIb94wZM8Dj8YpsXl5e5TZeQggBPvHEKDQ0FGPGjMH06dNx/fp1+Pj4oHXr1khNTdVLPK9fv4aPjw9WrVpV7Pt//vknli9fjjVr1uDKlSuoVKkSWrdujYKCAsU+PXr0wJ07d3DixAkcPnwYZ8+exYABA7QW85kzZzB06FBcvnwZJ06cgEQiQatWrRSrpQPA6NGjcejQIezevRtnzpzBixcv0KlTJ8X7MpkMbdu2hVgsxsWLF7Fp0yaEhIRg2rRpWom5SpUqmD9/PqKiohAZGYmvv/4a7du3x507d8plvB+6du0a1q5d+9HaXuUx7s8//xxJSUmK7fz58+U6XkIIAWfL0Rogf39/NnToUMX/y2Qy5urqyubNm6fHqN4AwMLCwhT/L5fLmbOzM1u4cKHitczMTCYSidiOHTsYY4zFxsYyAOzatWuKfY4ePcp4PB57/vy5TuJOTU1lANiZM2cUMRobG7Pdu3cr9rl79y4DwC5dusQYYyw8PJzx+XyWnJys2Gf16tXM0tKSFRYW6iRuGxsbtn79+nIfb05ODqtVqxY7ceIEa9asGRs5ciRjrHye5+nTpzMfH59i3yuP8apKG6t6E0JUo43r8JO9YyQWixEVFYWgoCDFa3w+H0FBQbh06ZIeIyve48ePkZycXCReKysrBAQEKOK9dOkSrK2tiyyIGRQUBD6fjytXrugkzqysLABQrJIeFRUFiURSJG4vLy+4ubkVifuLL75QLN8AAK1bt0Z2drbiLo62yGQy7Ny5E69fv0ZgYGC5j3fo0KFo27ZtkfiA8nue79+/D1dXV7i7u6NHjx5ISEgo1/ESQkiFWBJEHWlpaZDJZEV+6QKAk5MT4uLi9BRVyd4tcllcvO/eS05OhqOjY5H3jYyMYGtrq9hHm+RyOUaNGoXGjRvD29tbEZNQKIS1tXWpcRf3ud69pw0xMTEIDAxEQUEBzM3NERYWhjp16iA6OrpcxgsAO3fuxPXr13Ht2rWP3iuP5zkgIAAhISHw9PREUlISZs6cia+++gq3b98ul/ESQgjwCSdGhHtDhw7F7du3i4wjKa88PT0RHR2NrKws7NmzB3369MGZM2f0HVaJEhMTMXLkSJw4cQImJib6Dkcpbdq0Ufx33bp1ERAQgGrVqmHXrl0wNTXVY2SEEFKyT/ZRmr29PQQCwUezYFJSUuDs7KynqEr2LqbS4nV2dv5o4LhUKkV6errWP9OwYcNw+PBhnDp1ClWqVCkSt1gsRmZmZqlxF/e53r2nDUKhEB4eHvDz88O8efPg4+ODv/76q9zGGxUVhdTUVNSvXx9GRkYwMjLCmTNnsHz5chgZGcHJyalcxv0+a2tr1K5dGw8ePCi355kQQj7ZxEgoFMLPzw8RERGK1+RyOSIiIhAYGKjHyIpXo0YNODs7F4k3OzsbV65cUcQbGBiIzMxMREVFKfY5efIk5HK51hbUZYxh2LBhCAsLw8mTJ1GjRo0i7/v5+cHY2LhI3Pfu3UNCQkKRuGNiYookdSdOnIClpSXq1Kmjlbg/JJfLUVhYWG7j/eabbxATE4Po6GjF1qBBA/To0UPx3+Ux7vfl5ubi4cOHcHFxKbfnmRBCPulZaTt37mQikYiFhISw2NhYNmDAAGZtbV1kFowu5eTksBs3brAbN24wAGzJkiXsxo0b7OnTp4wxxubPn8+sra3ZgQMH2K1bt1j79u1ZjRo1WH5+vqKNb7/9ltWrV49duXKFnT9/ntWqVYt169ZNazEPHjyYWVlZsdOnT7OkpCTFlpeXp9hn0KBBzM3NjZ08eZJFRkaywMBAFhgYqHhfKpUyb29v1qpVKxYdHc2OHTvGHBwcWHBwsFZinjRpEjtz5gx7/Pgxu3XrFps0aRLj8Xjs33//LZfxluT9WWnlMe6xY8ey06dPs8ePH7MLFy6woKAgZm9vz1JTU8tlvKqiWWmE6J82rsNPOjFijLEVK1YwNzc3JhQKmb+/P7t8+bLeYjl16hQD8NHWp08fxtibKftTp05lTk5OTCQSsW+++Ybdu3evSBuvXr1i3bp1Y+bm5szS0pL17duX5eTkaC3m4uIFwP755x/FPvn5+WzIkCHMxsaGmZmZsY4dO7KkpKQi7Tx58oS1adOGmZqaMnt7ezZ27FgmkUi0EvOvv/7KqlWrxoRCIXNwcGDffPONIikqj/GW5MPEqLzF3aVLF+bi4sKEQiGrXLky69KlC3vw4EG5jVdVlBgRon/auA55jDGm+/tUhBBi2LKzs2FlZYWsrCxYWlrqOxxCPknauA4/2TFGhBBCCCEfosSIEEIIIeQtSowIIYQQQt6ixIgQQggh5C1KjAghhBBC3qLEiBBCCCHkLUqMCCGEEELeosSIEEIIIeQtSowIIYQQQt6ixIgQQggh5C1KjIjBevnyJZydnTF37lzFaxcvXoRQKCyyajshhBCiLCN9B0CIuhwcHLBx40Z06NABrVq1gqenJ3r16oVhw4bhm2++0Xd4hBBCDBAtIksM3tChQ/Hff/+hQYMGiImJwbVr1yASifQdFqngaBFZQvRPG9chJUbE4OXn58Pb2xuJiYmIiorCF198oe+QyCeAEiNC9E8b1yGNMSIG7+HDh3jx4gXkcjmePHmi73AIIYQYMBpjRAyaWCxGz5490aVLF3h6eqJfv36IiYmBo6OjvkMjhBDyf+3df0zV9R7H8Reg5xzbAG2MX+4ogyKaUSyIE5rDGhubzuIvWTaisqxJrclWYthOZQkja0wlnfbD5lwUTVtTZhnFSqW5EDYLtBmYtXVotECGxc/P/efLuRc5eD1cOJxzez628wcf39/zfcE48OL7wxOCOGKEkFZeXq7e3l7t2LFDmzZtUmpqqh577LHZjgUACFEUI4SsxsZGVVdX68CBA4qKilJ4eLgOHDigb775Rrt3757teACAEMSpNISsFStWaGhoaNxaUlKSent7ZykRACDUccQIAADAQjECAACwUIwAAAAsFCMAAAALxQgAAMBCMQIAALBQjAAAACwUIwAAAAvFCAAAwEIxAgAAsFCMAAAALBQjAAAAC8UIAADAQjECAACwUIwAAAAsFCMAAAALxQgAAMBCMQIAALBQjAAAACwUIwAAAAvFCAAAwEIxAgAAsFCMAAAALBQjAAAAC8UIAADAQjECAACwUIwAAAAsFCMA/xdqamqUlJQkh8Mhl8ul06dPX3O+rq5OaWlpcjgcSk9PV319fYCSAghmFCMAIe/DDz9UaWmp3G63zpw5ozvuuEP5+fn6/ffffc6fOnVKDz74oNatW6eWlhYVFBSooKBA33//fYCTAwg2YcYYM9shAOB/4XK5dNddd2nXrl2SpNHRUTmdTj3zzDMqKyubMF9YWKj+/n4dOXLEu3b33XcrIyNDe/bs8bmPgYEBDQwMeD/u7e3VokWL9MsvvygqKmqaPyMA1+Py5ctyOp3q6elRdHT0tDznnGl5FgCYJYODg2pubtbmzZu9a+Hh4crLy1NTU5PPbZqamlRaWjpuLT8/X5988smk+6moqNDLL788Yd3pdE4tOIBp88cff1CMAECSuru7NTIyori4uHHrcXFxOnfunM9tPB6Pz3mPxzPpfjZv3jyuTPX09Gjx4sW6dOnStP1Anmljf12H0lEuMgdOKOYeO3J74403TttzUowA4DrY7XbZ7fYJ69HR0SHzS2RMVFQUmQMgFDNLoZk7PHz6Lpnm4msAIS0mJkYRERHq6uoat97V1aX4+Hif28THx/s1D+Cfg2IEIKTZbDZlZmaqoaHBuzY6OqqGhgbl5OT43CYnJ2fcvCQdP3580nkA/xycSgMQ8kpLS1VcXKysrCxlZ2erurpa/f39evTRRyVJDz/8sBYuXKiKigpJ0rPPPqvc3Fy98cYbWrVqlWpra/Xdd99p7969171Pu90ut9vt8/RasCJzYIRiZik0c89EZm7XB/B/YdeuXXr99dfl8XiUkZGhHTt2yOVySZJWrFihpKQk7d+/3ztfV1enLVu26OLFi7r55ptVVVWllStXzlJ6AMGCYgQAAGDhGiMAAAALxQgAAMBCMQIAALBQjAAAACwUIwCYRE1NjZKSkuRwOORyuXT69OlrztfV1SktLU0Oh0Pp6emqr68PUNJ/8yfzvn37tHz5ci1YsEALFixQXl7ef/0cZ4K/X+cxtbW1CgsLU0FBwcwG9MHfzD09PSopKVFCQoLsdrtSU1MD/v3hb+bq6mrdcsstmjdvnpxOpzZu3Ki///47QGmlr7/+WqtXr1ZiYqLCwsKu+V6GYxobG3XnnXfKbrfrpptuGncn6nUzAIAJamtrjc1mM++++6754YcfzBNPPGHmz59vurq6fM6fPHnSREREmKqqKtPW1ma2bNli5s6da86ePRu0mdeuXWtqampMS0uLaW9vN4888oiJjo42v/76a9BmHtPZ2WkWLlxoli9fbh544IHAhLX4m3lgYMBkZWWZlStXmhMnTpjOzk7T2NhoWltbgzbzwYMHjd1uNwcPHjSdnZ3ms88+MwkJCWbjxo0By1xfX2/Ky8vNoUOHjCRz+PDha853dHSYG264wZSWlpq2tjazc+dOExERYY4dO+bXfilGAOBDdna2KSkp8X48MjJiEhMTTUVFhc/5NWvWmFWrVo1bc7lc5sknn5zRnP/J38xXGx4eNpGRkeb999+fqYgTTCXz8PCwWbp0qXn77bdNcXFxwIuRv5l3795tkpOTzeDgYKAiTuBv5pKSEnPfffeNWystLTXLli2b0ZyTuZ5i9Pzzz5slS5aMWyssLDT5+fl+7YtTaQBwlcHBQTU3NysvL8+7Fh4erry8PDU1Nfncpqmpady8JOXn5086P92mkvlqV65c0dDQ0LS+U/m1TDXzK6+8otjYWK1bty4QMceZSuZPP/1UOTk5KikpUVxcnG677TZt27ZNIyMjQZt56dKlam5u9p5u6+joUH19fVD/J6jT9RrkLUEA4Crd3d0aGRlRXFzcuPW4uDidO3fO5zYej8fnvMfjmbGc/2kqma+2adMmJSYmTvjlMlOmkvnEiRN655131NraGoCEE00lc0dHh7788ks99NBDqq+v14ULF7RhwwYNDQ3J7XYHZea1a9equ7tb99xzj4wxGh4e1lNPPaUXXnhhxvNO1WSvwcuXL+uvv/7SvHnzrut5OGIEAFBlZaVqa2t1+PBhORyO2Y7jU19fn4qKirRv3z7FxMTMdpzrNjo6qtjYWO3du1eZmZkqLCxUeXm59uzZM9vRJtXY2Kht27bprbfe0pkzZ3To0CEdPXpUW7dune1oM44jRgBwlZiYGEVERKirq2vceldXl+Lj431uEx8f79f8dJtK5jHbt29XZWWlvvjiC91+++0zGXMcfzP/9NNPunjxolavXu1dGx0dlSTNmTNH58+fV0pKSlBllqSEhATNnTtXERER3rVbb71VHo9Hg4ODstlsQZf5xRdfVFFRkR5//HFJUnp6uvr7+7V+/XqVl5crPDz4jqtM9hqMioq67qNFEkeMAGACm82mzMxMNTQ0eNdGR0fV0NCgnJwcn9vk5OSMm5ek48ePTzo/3aaSWZKqqqq0detWHTt2TFlZWYGI6uVv5rS0NJ09e1atra3ex/333697771Xra2tcjqdQZdZkpYtW6YLFy54S5wk/fjjj0pISJjxUjTVzFeuXJlQfsaKnQnSt1idttegf9eFA8A/Q21trbHb7Wb//v2mra3NrF+/3syfP994PB5jjDFFRUWmrKzMO3/y5EkzZ84cs337dtPe3m7cbves3K7vT+bKykpjs9nMxx9/bH777Tfvo6+vL2gzX2027krzN/OlS5dMZGSkefrpp8358+fNkSNHTGxsrHn11VeDNrPb7TaRkZHmgw8+MB0dHebzzz83KSkpZs2aNQHL3NfXZ1paWkxLS4uRZN58803T0tJifv75Z2OMMWVlZaaoqMg7P3a7/nPPPWfa29tNTU0Nt+sDwHTauXOnWbRokbHZbCY7O9t8++233n/Lzc01xcXF4+Y/+ugjk5qaamw2m1myZIk5evRogBP7l3nx4sVG0oSH2+0O2sxXm41iZIz/mU+dOmVcLpex2+0mOTnZvPbaa2Z4eDhoMw8NDZmXXnrJpKSkGIfDYZxOp9mwYYP5888/A5b3q6++8vn9OZazuLjY5ObmTtgmIyPD2Gw2k5ycbN577z2/9xtmTJAeEwMAAAgwrjECAACwUIwAAAAsFCMAAAALxQgAAMBCMQIAALBQjAAAACwUIwAAAAvFCAAAwEIxAgAAsFCMAAAALBQjAAAAy78AF2Rbjm3VXbwAAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "UPDATES = 50\n",
    "filenames = []\n",
    "\n",
    "for i in tqdm(range(UPDATES)):\n",
    "    fig, axs = plt.subplots(nrows=1, ncols=2)\n",
    "    for x, y in grid.pose_grid:\n",
    "        o = grid.pose_grid[(x,y)].freespace\n",
    "        o = 1 - o if np.random.random() > P_TRUE else o\n",
    "        grid.measurement_update(o, x, y)\n",
    "    grid.plot(axs)\n",
    "    fig.set_size_inches((10,4))\n",
    "    fig.tight_layout()\n",
    "    filenames.append(rf'/Users/neiljanwani/Documents/exploration-scrat/images/test/image{i}.png')\n",
    "    plt.savefig(filenames[-1])\n",
    "    plt.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def corrupted_measurement(grid, x, y, theta):\n",
    "    dx, dy = grid.cell_width * round(np.cos(theta)), grid.cell_width * round(np.sin(theta))\n",
    "    dx2, dy2 = grid.cell_width * round(np.cos(theta + np.pi / 2)), grid.cell_width * round(np.sin(theta + np.pi / 2))\n",
    "    measured = [(x + dx2, y + dy2), (x - dx2, y - dy2)] + [(x + dx, y + dy)] + [(x + dx + dx2, y + dy + dy2), (x - dx2 + dx, y - dy2 + dy)]\n",
    "    # print(measured)\n",
    "    for x,y in measured:\n",
    "        if x >= 0 and y >= 0 and x < grid.xlim + grid.xoffset and y < grid.ylim + grid.yoffset:\n",
    "            o = grid.pose_grid[(x,y)].freespace\n",
    "            o = 1 - o if np.random.random() > P_TRUE else o\n",
    "            grid.measurement_update(o, x, y)\n",
    "\n",
    "def corrupted_EIG(grid, x, y, theta):\n",
    "    dx, dy = grid.cell_width * np.round(np.cos(theta)), grid.cell_width * np.round(np.sin(theta))\n",
    "    dx2, dy2 = grid.cell_width * np.round(np.cos(theta + np.pi / 2)), grid.cell_width * np.round(np.sin(theta + np.pi / 2))\n",
    "    # print(np.round(np.cos(theta)), np.round(np.sin(theta)), np.round(np.cos(theta + np.pi / 2)), np.round(np.sin(theta + np.pi / 2)))\n",
    "    # print(dx, dy, dx2, dy2)\n",
    "    # print(x,y,theta)\n",
    "    # print('----')\n",
    "    assert dx != dx2\n",
    "    assert dy != dy2\n",
    "    measured = [(x + dx2, y + dy2), (x - dx2, y - dy2)] + [(x + dx, y + dy)] + [(x + dx + dx2, y + dy + dy2), (x - dx2 + dx, y - dy2 + dy)]\n",
    "    totalEIG = 0\n",
    "    mbool = [v[0]<0 or v[1]<0 for v in measured]\n",
    "    # if any(mbool):\n",
    "    #     print('AHH', measured)\n",
    "    i = 0\n",
    "    for x,y in measured:\n",
    "        if x >= 0 and y >= 0 and x < grid.xlim + grid.xoffset and y < grid.ylim + grid.yoffset:\n",
    "            totalEIG += grid.EIG(x,y)\n",
    "            i += 1\n",
    "    return totalEIG / i\n",
    "\n",
    "def unknown_area(grid, x,y,theta):\n",
    "    dx, dy = grid.cell_width * np.round(np.cos(theta)), grid.cell_width * np.round(np.sin(theta))\n",
    "    dx2, dy2 = grid.cell_width * np.round(np.cos(theta + np.pi / 2)), grid.cell_width * np.round(np.sin(theta + np.pi / 2))\n",
    "    measured = [(x + dx2, y + dy2), (x - dx2, y - dy2)] + [(x + dx, y + dy)] + [(x + dx + dx2, y + dy + dy2), (x - dx2 + dx, y - dy2 + dy)]\n",
    "    for x,y in measured:\n",
    "        if x >= 0 and y >= 0 and x < grid.xlim + grid.xoffset and y < grid.ylim + grid.yoffset:\n",
    "            if not (grid.pose_grid[x,y].freespace < FREESPACE_ALPHA or grid.pose_grid[x,y].freespace > 1 - FREESPACE_ALPHA):\n",
    "                return True\n",
    "    return False\n",
    "\n",
    "def add_pose(grid, point_to_pose, pose):\n",
    "    grid.explore_grid.pose_grid[(pose.x, pose.y)].freespace = pose.freespace\n",
    "    for theta in Pose.THETA_LIST:\n",
    "        point_to_pose[(pose.x, pose.y, pose.theta)] = Pose(pose.x, pose.y, theta)\n",
    "    \n",
    "    return point_to_pose"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def waypoint_gen(grid, start, goal):\n",
    "    \"\"\"\n",
    "    Function requested in prelab. Uses Dijkstra's\n",
    "\n",
    "    Args:\n",
    "        grid (numpy array): grid description of world, 0 = fresespace and 1 = obstacle\n",
    "        start (Pose): Pose object for starting location. ASSUMES THIS IS ROUNDED\n",
    "        goal (Pose): Pose object for requested ending location. ASSUMES THIS IS ROUNDED\n",
    "\n",
    "    Returns:\n",
    "        list: list of Pose objects representing the start to goal path if it exists\n",
    "    \"\"\"\n",
    "    start.round()\n",
    "    goal.round()\n",
    "    point_to_pose = {} # assemble a dictionary relating (x,y,theta) to Pose object (need this to store cost/parent)\n",
    "    for x,y in grid.pose_grid:\n",
    "        if grid.pose_grid[x,y].freespace <= FREESPACE_ALPHA:\n",
    "            for theta in Pose.THETA_LIST:\n",
    "                # print('MADE A POSE')\n",
    "                point_to_pose[(grid.pose_grid[x,y].x, grid.pose_grid[x,y].y, theta)] = Pose(grid.pose_grid[x,y].x, grid.pose_grid[x,y].y, theta)\n",
    "                \n",
    "    point_to_pose[(start.x, start.y, start.theta)] = start\n",
    "    point_to_pose[(goal.x, goal.y, goal.theta)] = goal\n",
    "    start.cost = start.compute_cost(start)\n",
    "\n",
    "    onDeck = queue.PriorityQueue()\n",
    "    onDeck.put(start)\n",
    "    iters = 0\n",
    "    # print(point_to_pose.keys())\n",
    "    # print(start)\n",
    "    # print(goal)\n",
    "    # print('--')\n",
    "    while True:\n",
    "        if onDeck.empty():\n",
    "            return None\n",
    "        \n",
    "        iters += 1\n",
    "        node = onDeck.get()\n",
    "        # print(node)\n",
    "        if node == goal:\n",
    "            break\n",
    "        for neighbor_point in node.get_neighbors(grid):\n",
    "            # print(neighbor_point)\n",
    "            neighbor = point_to_pose[neighbor_point]\n",
    "            new_cost = neighbor.compute_cost(start) + node.cost\n",
    "            if new_cost < neighbor.cost: # only search if neighbor is 'more optimal'\n",
    "                neighbor.cost = new_cost\n",
    "                neighbor.parent = node\n",
    "                onDeck.put(neighbor)\n",
    "        # print('iter')\n",
    "\n",
    "    node = goal\n",
    "    path = [goal]\n",
    "    while node != start: # construct path\n",
    "        path.append(node.parent)\n",
    "        node = node.parent\n",
    "        \n",
    "    # fig, ax = plt.subplots()\n",
    "    # visualize(ax, grid, start, goal, path)\n",
    "    # fig.suptitle('Grid world')\n",
    "    # plt.show()\n",
    "    path.reverse()\n",
    "    return path"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# EIG EXPLORE"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.9475\r"
     ]
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[42], line 22\u001b[0m\n\u001b[1;32m     19\u001b[0m positions \u001b[39m=\u001b[39m grid\u001b[39m.\u001b[39mexplore_grid\u001b[39m.\u001b[39mget_freespace_nodes()\n\u001b[1;32m     20\u001b[0m positions \u001b[39m=\u001b[39m \u001b[39msorted\u001b[39m(positions, key\u001b[39m=\u001b[39m\u001b[39mlambda\u001b[39;00m v: \u001b[39m-\u001b[39m\u001b[39m1\u001b[39m \u001b[39m*\u001b[39m corrupted_EIG(grid, \u001b[39m*\u001b[39mv))\n\u001b[0;32m---> 22\u001b[0m \u001b[39mwhile\u001b[39;00m \u001b[39mTrue\u001b[39;00m:\n\u001b[1;32m     23\u001b[0m     goal \u001b[39m=\u001b[39m Pose(\u001b[39m*\u001b[39mpositions[\u001b[39m0\u001b[39m])\n\u001b[1;32m     24\u001b[0m     path \u001b[39m=\u001b[39m waypoint_gen(grid\u001b[39m.\u001b[39mexplore_grid, pose, goal)\n",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "grid_array = pickle.load(open('maps/map20.pkl', 'rb'))\n",
    "# grid_array = np.zeros((12,12))\n",
    "explore_array = np.ones(grid_array.shape) * 0.5\n",
    "grid = ExplorationGrid(grid_array, explore_array, P_TRUE)\n",
    "metric_eig_20 = []\n",
    "\n",
    "fig, axs = plt.subplots(nrows=1, ncols=2)\n",
    "\n",
    "start = Pose(1, 0.5, np.pi / 2)\n",
    "pose = start\n",
    "\n",
    "grid.explore_grid.pose_grid[start.x, start.y].freespace = 0\n",
    "iters = 1000\n",
    "\n",
    "filenames = []\n",
    "i = 0\n",
    "\n",
    "while True:\n",
    "    positions = grid.explore_grid.get_freespace_nodes()\n",
    "    positions = sorted(positions, key=lambda v: -1 * corrupted_EIG(grid, *v))\n",
    "\n",
    "    while True:\n",
    "        goal = Pose(*positions[0])\n",
    "        path = waypoint_gen(grid.explore_grid, pose, goal)\n",
    "        if path != None:\n",
    "            break\n",
    "        positions = positions[1:]\n",
    "    pose = path[1]\n",
    "    if i % 10 == 0:\n",
    "        fig, axs = plt.subplots(nrows=1, ncols=2)\n",
    "        grid.plot(axs, start=pose, goal=goal, path=path)\n",
    "        fig.set_size_inches((10,5))\n",
    "        fig.tight_layout()\n",
    "        filenames.append(rf'/Users/neiljanwani/Documents/exploration-scrat/images/simple/image{i}.png')\n",
    "        plt.savefig(filenames[-1])\n",
    "        plt.close()\n",
    "    corrupted_measurement(grid, pose.x, pose.y, pose.theta)\n",
    "    metric_eig_20.append(np.mean([int(grid.explore_grid.pose_grid[(x,y)].freespace < FREESPACE_ALPHA or grid.explore_grid.pose_grid[(x,y)].freespace > 1 - FREESPACE_ALPHA) for x,y in grid.pose_grid]))\n",
    "    print(metric_eig_20[-1], end='\\r')\n",
    "    # input()\n",
    "    i += 1\n",
    "# 0.3286"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots()\n",
    "ax.plot(metric_eig_basic, label='EIG')\n",
    "ax.plot(mapbasic_metric, label='SMART')\n",
    "# ax.plot(map20_metric, label = 'Map 20x20')\n",
    "# ax.plot(map30_metric, label = 'Map 30x30')\n",
    "# ax.plot(map50_metric, label = 'Map 50x50')\n",
    "ax.set_xlabel('Iterations (robot steps)')\n",
    "ax.set_ylabel('Percent explored')\n",
    "ax.set_title('Smart vs. Eig Algorithm Comparison on Basic')\n",
    "plt.legend()\n",
    "plt.savefig('/Users/neiljanwani/Documents/exploration-scrat/images/graphs/basic_eigvsmart')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots()\n",
    "ax.plot(metric_eig_20, label='EIG')\n",
    "ax.plot(map20_metric, label='SMART')\n",
    "# ax.plot(map20_metric, label = 'Map 20x20')\n",
    "# ax.plot(map30_metric, label = 'Map 30x30')\n",
    "# ax.plot(map50_metric, label = 'Map 50x50')\n",
    "ax.set_xlabel('Iterations (robot steps)')\n",
    "ax.set_ylabel('Percent explored')\n",
    "ax.set_title('Smart vs. Eig Algorithm Comparison on Map 20x20')\n",
    "plt.legend()\n",
    "plt.savefig('/Users/neiljanwani/Documents/exploration-scrat/images/graphs/map20_eigvssmart')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.0355\r"
     ]
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "File \u001b[0;32m/opt/homebrew/lib/python3.11/site-packages/PIL/ImageFile.py:515\u001b[0m, in \u001b[0;36m_save\u001b[0;34m(im, fp, tile, bufsize)\u001b[0m\n\u001b[1;32m    514\u001b[0m \u001b[39mtry\u001b[39;00m:\n\u001b[0;32m--> 515\u001b[0m     fh \u001b[39m=\u001b[39m fp\u001b[39m.\u001b[39;49mfileno()\n\u001b[1;32m    516\u001b[0m     fp\u001b[39m.\u001b[39mflush()\n",
      "\u001b[0;31mAttributeError\u001b[0m: '_idat' object has no attribute 'fileno'",
      "\nDuring handling of the above exception, another exception occurred:\n",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[52], line 45\u001b[0m\n\u001b[1;32m     43\u001b[0m     fig\u001b[39m.\u001b[39mtight_layout()\n\u001b[1;32m     44\u001b[0m     filenames\u001b[39m.\u001b[39mappend(\u001b[39mrf\u001b[39m\u001b[39m'\u001b[39m\u001b[39m/Users/neiljanwani/Documents/exploration-scrat/images/map20_eig/image\u001b[39m\u001b[39m{\u001b[39;00mi\u001b[39m}\u001b[39;00m\u001b[39m.png\u001b[39m\u001b[39m'\u001b[39m)\n\u001b[0;32m---> 45\u001b[0m     plt\u001b[39m.\u001b[39;49msavefig(filenames[\u001b[39m-\u001b[39;49m\u001b[39m1\u001b[39;49m])\n\u001b[1;32m     46\u001b[0m     plt\u001b[39m.\u001b[39mclose()\n\u001b[1;32m     47\u001b[0m \u001b[39mif\u001b[39;00m unknown_area(grid\u001b[39m.\u001b[39mexplore_grid, pose\u001b[39m.\u001b[39mx, pose\u001b[39m.\u001b[39my, pose\u001b[39m.\u001b[39mtheta):\n",
      "File \u001b[0;32m/opt/homebrew/lib/python3.11/site-packages/matplotlib/pyplot.py:1023\u001b[0m, in \u001b[0;36msavefig\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m   1020\u001b[0m \u001b[39m@_copy_docstring_and_deprecators\u001b[39m(Figure\u001b[39m.\u001b[39msavefig)\n\u001b[1;32m   1021\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39msavefig\u001b[39m(\u001b[39m*\u001b[39margs, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwargs):\n\u001b[1;32m   1022\u001b[0m     fig \u001b[39m=\u001b[39m gcf()\n\u001b[0;32m-> 1023\u001b[0m     res \u001b[39m=\u001b[39m fig\u001b[39m.\u001b[39;49msavefig(\u001b[39m*\u001b[39;49margs, \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49mkwargs)\n\u001b[1;32m   1024\u001b[0m     fig\u001b[39m.\u001b[39mcanvas\u001b[39m.\u001b[39mdraw_idle()  \u001b[39m# Need this if 'transparent=True', to reset colors.\u001b[39;00m\n\u001b[1;32m   1025\u001b[0m     \u001b[39mreturn\u001b[39;00m res\n",
      "File \u001b[0;32m/opt/homebrew/lib/python3.11/site-packages/matplotlib/figure.py:3343\u001b[0m, in \u001b[0;36mFigure.savefig\u001b[0;34m(self, fname, transparent, **kwargs)\u001b[0m\n\u001b[1;32m   3339\u001b[0m     \u001b[39mfor\u001b[39;00m ax \u001b[39min\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39maxes:\n\u001b[1;32m   3340\u001b[0m         stack\u001b[39m.\u001b[39menter_context(\n\u001b[1;32m   3341\u001b[0m             ax\u001b[39m.\u001b[39mpatch\u001b[39m.\u001b[39m_cm_set(facecolor\u001b[39m=\u001b[39m\u001b[39m'\u001b[39m\u001b[39mnone\u001b[39m\u001b[39m'\u001b[39m, edgecolor\u001b[39m=\u001b[39m\u001b[39m'\u001b[39m\u001b[39mnone\u001b[39m\u001b[39m'\u001b[39m))\n\u001b[0;32m-> 3343\u001b[0m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mcanvas\u001b[39m.\u001b[39;49mprint_figure(fname, \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49mkwargs)\n",
      "File \u001b[0;32m/opt/homebrew/lib/python3.11/site-packages/matplotlib/backend_bases.py:2366\u001b[0m, in \u001b[0;36mFigureCanvasBase.print_figure\u001b[0;34m(self, filename, dpi, facecolor, edgecolor, orientation, format, bbox_inches, pad_inches, bbox_extra_artists, backend, **kwargs)\u001b[0m\n\u001b[1;32m   2362\u001b[0m \u001b[39mtry\u001b[39;00m:\n\u001b[1;32m   2363\u001b[0m     \u001b[39m# _get_renderer may change the figure dpi (as vector formats\u001b[39;00m\n\u001b[1;32m   2364\u001b[0m     \u001b[39m# force the figure dpi to 72), so we need to set it again here.\u001b[39;00m\n\u001b[1;32m   2365\u001b[0m     \u001b[39mwith\u001b[39;00m cbook\u001b[39m.\u001b[39m_setattr_cm(\u001b[39mself\u001b[39m\u001b[39m.\u001b[39mfigure, dpi\u001b[39m=\u001b[39mdpi):\n\u001b[0;32m-> 2366\u001b[0m         result \u001b[39m=\u001b[39m print_method(\n\u001b[1;32m   2367\u001b[0m             filename,\n\u001b[1;32m   2368\u001b[0m             facecolor\u001b[39m=\u001b[39;49mfacecolor,\n\u001b[1;32m   2369\u001b[0m             edgecolor\u001b[39m=\u001b[39;49medgecolor,\n\u001b[1;32m   2370\u001b[0m             orientation\u001b[39m=\u001b[39;49morientation,\n\u001b[1;32m   2371\u001b[0m             bbox_inches_restore\u001b[39m=\u001b[39;49m_bbox_inches_restore,\n\u001b[1;32m   2372\u001b[0m             \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49mkwargs)\n\u001b[1;32m   2373\u001b[0m \u001b[39mfinally\u001b[39;00m:\n\u001b[1;32m   2374\u001b[0m     \u001b[39mif\u001b[39;00m bbox_inches \u001b[39mand\u001b[39;00m restore_bbox:\n",
      "File \u001b[0;32m/opt/homebrew/lib/python3.11/site-packages/matplotlib/backend_bases.py:2232\u001b[0m, in \u001b[0;36mFigureCanvasBase._switch_canvas_and_return_print_method.<locals>.<lambda>\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m   2228\u001b[0m     optional_kws \u001b[39m=\u001b[39m {  \u001b[39m# Passed by print_figure for other renderers.\u001b[39;00m\n\u001b[1;32m   2229\u001b[0m         \u001b[39m\"\u001b[39m\u001b[39mdpi\u001b[39m\u001b[39m\"\u001b[39m, \u001b[39m\"\u001b[39m\u001b[39mfacecolor\u001b[39m\u001b[39m\"\u001b[39m, \u001b[39m\"\u001b[39m\u001b[39medgecolor\u001b[39m\u001b[39m\"\u001b[39m, \u001b[39m\"\u001b[39m\u001b[39morientation\u001b[39m\u001b[39m\"\u001b[39m,\n\u001b[1;32m   2230\u001b[0m         \u001b[39m\"\u001b[39m\u001b[39mbbox_inches_restore\u001b[39m\u001b[39m\"\u001b[39m}\n\u001b[1;32m   2231\u001b[0m     skip \u001b[39m=\u001b[39m optional_kws \u001b[39m-\u001b[39m {\u001b[39m*\u001b[39minspect\u001b[39m.\u001b[39msignature(meth)\u001b[39m.\u001b[39mparameters}\n\u001b[0;32m-> 2232\u001b[0m     print_method \u001b[39m=\u001b[39m functools\u001b[39m.\u001b[39mwraps(meth)(\u001b[39mlambda\u001b[39;00m \u001b[39m*\u001b[39margs, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwargs: meth(\n\u001b[1;32m   2233\u001b[0m         \u001b[39m*\u001b[39;49margs, \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49m{k: v \u001b[39mfor\u001b[39;49;00m k, v \u001b[39min\u001b[39;49;00m kwargs\u001b[39m.\u001b[39;49mitems() \u001b[39mif\u001b[39;49;00m k \u001b[39mnot\u001b[39;49;00m \u001b[39min\u001b[39;49;00m skip}))\n\u001b[1;32m   2234\u001b[0m \u001b[39melse\u001b[39;00m:  \u001b[39m# Let third-parties do as they see fit.\u001b[39;00m\n\u001b[1;32m   2235\u001b[0m     print_method \u001b[39m=\u001b[39m meth\n",
      "File \u001b[0;32m/opt/homebrew/lib/python3.11/site-packages/matplotlib/backends/backend_agg.py:509\u001b[0m, in \u001b[0;36mFigureCanvasAgg.print_png\u001b[0;34m(self, filename_or_obj, metadata, pil_kwargs)\u001b[0m\n\u001b[1;32m    462\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mprint_png\u001b[39m(\u001b[39mself\u001b[39m, filename_or_obj, \u001b[39m*\u001b[39m, metadata\u001b[39m=\u001b[39m\u001b[39mNone\u001b[39;00m, pil_kwargs\u001b[39m=\u001b[39m\u001b[39mNone\u001b[39;00m):\n\u001b[1;32m    463\u001b[0m \u001b[39m    \u001b[39m\u001b[39m\"\"\"\u001b[39;00m\n\u001b[1;32m    464\u001b[0m \u001b[39m    Write the figure to a PNG file.\u001b[39;00m\n\u001b[1;32m    465\u001b[0m \n\u001b[0;32m   (...)\u001b[0m\n\u001b[1;32m    507\u001b[0m \u001b[39m        *metadata*, including the default 'Software' key.\u001b[39;00m\n\u001b[1;32m    508\u001b[0m \u001b[39m    \"\"\"\u001b[39;00m\n\u001b[0;32m--> 509\u001b[0m     \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_print_pil(filename_or_obj, \u001b[39m\"\u001b[39;49m\u001b[39mpng\u001b[39;49m\u001b[39m\"\u001b[39;49m, pil_kwargs, metadata)\n",
      "File \u001b[0;32m/opt/homebrew/lib/python3.11/site-packages/matplotlib/backends/backend_agg.py:458\u001b[0m, in \u001b[0;36mFigureCanvasAgg._print_pil\u001b[0;34m(self, filename_or_obj, fmt, pil_kwargs, metadata)\u001b[0m\n\u001b[1;32m    453\u001b[0m \u001b[39m\u001b[39m\u001b[39m\"\"\"\u001b[39;00m\n\u001b[1;32m    454\u001b[0m \u001b[39mDraw the canvas, then save it using `.image.imsave` (to which\u001b[39;00m\n\u001b[1;32m    455\u001b[0m \u001b[39m*pil_kwargs* and *metadata* are forwarded).\u001b[39;00m\n\u001b[1;32m    456\u001b[0m \u001b[39m\"\"\"\u001b[39;00m\n\u001b[1;32m    457\u001b[0m FigureCanvasAgg\u001b[39m.\u001b[39mdraw(\u001b[39mself\u001b[39m)\n\u001b[0;32m--> 458\u001b[0m mpl\u001b[39m.\u001b[39;49mimage\u001b[39m.\u001b[39;49mimsave(\n\u001b[1;32m    459\u001b[0m     filename_or_obj, \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mbuffer_rgba(), \u001b[39mformat\u001b[39;49m\u001b[39m=\u001b[39;49mfmt, origin\u001b[39m=\u001b[39;49m\u001b[39m\"\u001b[39;49m\u001b[39mupper\u001b[39;49m\u001b[39m\"\u001b[39;49m,\n\u001b[1;32m    460\u001b[0m     dpi\u001b[39m=\u001b[39;49m\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mfigure\u001b[39m.\u001b[39;49mdpi, metadata\u001b[39m=\u001b[39;49mmetadata, pil_kwargs\u001b[39m=\u001b[39;49mpil_kwargs)\n",
      "File \u001b[0;32m/opt/homebrew/lib/python3.11/site-packages/matplotlib/image.py:1689\u001b[0m, in \u001b[0;36mimsave\u001b[0;34m(fname, arr, vmin, vmax, cmap, format, origin, dpi, metadata, pil_kwargs)\u001b[0m\n\u001b[1;32m   1687\u001b[0m pil_kwargs\u001b[39m.\u001b[39msetdefault(\u001b[39m\"\u001b[39m\u001b[39mformat\u001b[39m\u001b[39m\"\u001b[39m, \u001b[39mformat\u001b[39m)\n\u001b[1;32m   1688\u001b[0m pil_kwargs\u001b[39m.\u001b[39msetdefault(\u001b[39m\"\u001b[39m\u001b[39mdpi\u001b[39m\u001b[39m\"\u001b[39m, (dpi, dpi))\n\u001b[0;32m-> 1689\u001b[0m image\u001b[39m.\u001b[39;49msave(fname, \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49mpil_kwargs)\n",
      "File \u001b[0;32m/opt/homebrew/lib/python3.11/site-packages/PIL/Image.py:2432\u001b[0m, in \u001b[0;36mImage.save\u001b[0;34m(self, fp, format, **params)\u001b[0m\n\u001b[1;32m   2429\u001b[0m         fp \u001b[39m=\u001b[39m builtins\u001b[39m.\u001b[39mopen(filename, \u001b[39m\"\u001b[39m\u001b[39mw+b\u001b[39m\u001b[39m\"\u001b[39m)\n\u001b[1;32m   2431\u001b[0m \u001b[39mtry\u001b[39;00m:\n\u001b[0;32m-> 2432\u001b[0m     save_handler(\u001b[39mself\u001b[39;49m, fp, filename)\n\u001b[1;32m   2433\u001b[0m \u001b[39mexcept\u001b[39;00m \u001b[39mException\u001b[39;00m:\n\u001b[1;32m   2434\u001b[0m     \u001b[39mif\u001b[39;00m open_fp:\n",
      "File \u001b[0;32m/opt/homebrew/lib/python3.11/site-packages/PIL/PngImagePlugin.py:1407\u001b[0m, in \u001b[0;36m_save\u001b[0;34m(im, fp, filename, chunk, save_all)\u001b[0m\n\u001b[1;32m   1405\u001b[0m     _write_multiple_frames(im, fp, chunk, rawmode, default_image, append_images)\n\u001b[1;32m   1406\u001b[0m \u001b[39melse\u001b[39;00m:\n\u001b[0;32m-> 1407\u001b[0m     ImageFile\u001b[39m.\u001b[39;49m_save(im, _idat(fp, chunk), [(\u001b[39m\"\u001b[39;49m\u001b[39mzip\u001b[39;49m\u001b[39m\"\u001b[39;49m, (\u001b[39m0\u001b[39;49m, \u001b[39m0\u001b[39;49m) \u001b[39m+\u001b[39;49m im\u001b[39m.\u001b[39;49msize, \u001b[39m0\u001b[39;49m, rawmode)])\n\u001b[1;32m   1409\u001b[0m \u001b[39mif\u001b[39;00m info:\n\u001b[1;32m   1410\u001b[0m     \u001b[39mfor\u001b[39;00m info_chunk \u001b[39min\u001b[39;00m info\u001b[39m.\u001b[39mchunks:\n",
      "File \u001b[0;32m/opt/homebrew/lib/python3.11/site-packages/PIL/ImageFile.py:519\u001b[0m, in \u001b[0;36m_save\u001b[0;34m(im, fp, tile, bufsize)\u001b[0m\n\u001b[1;32m    517\u001b[0m     _encode_tile(im, fp, tile, bufsize, fh)\n\u001b[1;32m    518\u001b[0m \u001b[39mexcept\u001b[39;00m (\u001b[39mAttributeError\u001b[39;00m, io\u001b[39m.\u001b[39mUnsupportedOperation) \u001b[39mas\u001b[39;00m exc:\n\u001b[0;32m--> 519\u001b[0m     _encode_tile(im, fp, tile, bufsize, \u001b[39mNone\u001b[39;49;00m, exc)\n\u001b[1;32m    520\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mhasattr\u001b[39m(fp, \u001b[39m\"\u001b[39m\u001b[39mflush\u001b[39m\u001b[39m\"\u001b[39m):\n\u001b[1;32m    521\u001b[0m     fp\u001b[39m.\u001b[39mflush()\n",
      "File \u001b[0;32m/opt/homebrew/lib/python3.11/site-packages/PIL/ImageFile.py:538\u001b[0m, in \u001b[0;36m_encode_tile\u001b[0;34m(im, fp, tile, bufsize, fh, exc)\u001b[0m\n\u001b[1;32m    535\u001b[0m \u001b[39mif\u001b[39;00m exc:\n\u001b[1;32m    536\u001b[0m     \u001b[39m# compress to Python file-compatible object\u001b[39;00m\n\u001b[1;32m    537\u001b[0m     \u001b[39mwhile\u001b[39;00m \u001b[39mTrue\u001b[39;00m:\n\u001b[0;32m--> 538\u001b[0m         errcode, data \u001b[39m=\u001b[39m encoder\u001b[39m.\u001b[39;49mencode(bufsize)[\u001b[39m1\u001b[39m:]\n\u001b[1;32m    539\u001b[0m         fp\u001b[39m.\u001b[39mwrite(data)\n\u001b[1;32m    540\u001b[0m         \u001b[39mif\u001b[39;00m errcode:\n",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x500 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "grid_array = pickle.load(open('maps/map20.pkl', 'rb'))\n",
    "# grid_array = np.zeros((12,12))\n",
    "explore_array = np.ones(grid_array.shape) * 0.5\n",
    "grid = ExplorationGrid(grid_array, explore_array, P_TRUE)\n",
    "\n",
    "fig, axs = plt.subplots(nrows=1, ncols=2)\n",
    "\n",
    "start = Pose(1, 0.5, np.pi / 2)\n",
    "pose = start\n",
    "\n",
    "grid.explore_grid.pose_grid[start.x, start.y].freespace = 0\n",
    "iters = 1000\n",
    "\n",
    "filenames = []\n",
    "i = 0\n",
    "path = []\n",
    "\n",
    "while True:\n",
    "    positions = grid.explore_grid.get_freespace_nodes()\n",
    "    positions = sorted(positions, key=lambda v: corrupted_EIG(grid, *v), reverse=True)\n",
    "\n",
    "    # print(pose)\n",
    "    # for i in range(3):\n",
    "    #     print(positions[i], ':', corrupted_EIG(grid, *positions[i]) + 0*pose.compute_cost(Pose(*positions[i])))\n",
    "    # print()\n",
    "\n",
    "    # print(corrupted_EIG(grid, *positions[0]))\n",
    "    while path == []:\n",
    "        goal = Pose(*positions[0])\n",
    "        path = waypoint_gen(grid.explore_grid, pose, goal)\n",
    "        if path != None:\n",
    "            break\n",
    "        else:\n",
    "            path = []\n",
    "        positions = positions[1:]\n",
    "    # assert True if len(path) < 3 else path[0] != path[2]\n",
    "    pose = path[0]\n",
    "    path = path[1:]\n",
    "    if i % 1 == 0:\n",
    "        fig, axs = plt.subplots(nrows=1, ncols=2)\n",
    "        grid.plot(axs, start=pose, goal=goal, path=path)\n",
    "        fig.set_size_inches((10,5))\n",
    "        fig.tight_layout()\n",
    "        filenames.append(rf'/Users/neiljanwani/Documents/exploration-scrat/images/map20_eig/image{i}.png')\n",
    "        plt.savefig(filenames[-1])\n",
    "        plt.close()\n",
    "    if unknown_area(grid.explore_grid, pose.x, pose.y, pose.theta):\n",
    "        corrupted_measurement(grid, pose.x, pose.y, pose.theta)\n",
    "        path = []\n",
    "        # print('making measurement')\n",
    "    print(np.mean([int(grid.explore_grid.pose_grid[(x,y)].freespace < FREESPACE_ALPHA or grid.explore_grid.pose_grid[(x,y)].freespace > 1 - FREESPACE_ALPHA) for x,y in grid.pose_grid]), end='\\r')\n",
    "    # input()\n",
    "    i += 1\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# SMART EXPLORE"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.8688\r"
     ]
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[27], line 21\u001b[0m\n\u001b[1;32m     19\u001b[0m \u001b[39mwhile\u001b[39;00m \u001b[39mTrue\u001b[39;00m:\n\u001b[1;32m     20\u001b[0m     positions \u001b[39m=\u001b[39m grid\u001b[39m.\u001b[39mexplore_grid\u001b[39m.\u001b[39mget_freespace_nodes()\n\u001b[0;32m---> 21\u001b[0m     positions \u001b[39m=\u001b[39m \u001b[39msorted\u001b[39m(positions, key\u001b[39m=\u001b[39m\u001b[39mlambda\u001b[39;00m v:  (corrupted_EIG(grid, \u001b[39m*\u001b[39mv) \u001b[39m/\u001b[39m (pose\u001b[39m.\u001b[39mcompute_cost(Pose(\u001b[39m*\u001b[39mv)) \u001b[39m+\u001b[39m \u001b[39m1\u001b[39m), corrupted_EIG(grid, \u001b[39m*\u001b[39mv)), reverse\u001b[39m=\u001b[39m\u001b[39mTrue\u001b[39;00m)\n\u001b[1;32m     23\u001b[0m     \u001b[39m# print(pose)\u001b[39;00m\n\u001b[1;32m     24\u001b[0m     \u001b[39m# for i in range(3):\u001b[39;00m\n\u001b[1;32m     25\u001b[0m     \u001b[39m#     print(positions[i], ':', corrupted_EIG(grid, *positions[i]) + 0*pose.compute_cost(Pose(*positions[i])))\u001b[39;00m\n\u001b[1;32m     26\u001b[0m     \u001b[39m# print()\u001b[39;00m\n\u001b[1;32m     27\u001b[0m \n\u001b[1;32m     28\u001b[0m     \u001b[39m# print(corrupted_EIG(grid, *positions[0]))\u001b[39;00m\n\u001b[1;32m     29\u001b[0m     \u001b[39mwhile\u001b[39;00m path \u001b[39m==\u001b[39m []:\n",
      "Cell \u001b[0;32mIn[27], line 21\u001b[0m, in \u001b[0;36m<lambda>\u001b[0;34m(v)\u001b[0m\n\u001b[1;32m     19\u001b[0m \u001b[39mwhile\u001b[39;00m \u001b[39mTrue\u001b[39;00m:\n\u001b[1;32m     20\u001b[0m     positions \u001b[39m=\u001b[39m grid\u001b[39m.\u001b[39mexplore_grid\u001b[39m.\u001b[39mget_freespace_nodes()\n\u001b[0;32m---> 21\u001b[0m     positions \u001b[39m=\u001b[39m \u001b[39msorted\u001b[39m(positions, key\u001b[39m=\u001b[39m\u001b[39mlambda\u001b[39;00m v:  (corrupted_EIG(grid, \u001b[39m*\u001b[39;49mv) \u001b[39m/\u001b[39m (pose\u001b[39m.\u001b[39mcompute_cost(Pose(\u001b[39m*\u001b[39mv)) \u001b[39m+\u001b[39m \u001b[39m1\u001b[39m), corrupted_EIG(grid, \u001b[39m*\u001b[39mv)), reverse\u001b[39m=\u001b[39m\u001b[39mTrue\u001b[39;00m)\n\u001b[1;32m     23\u001b[0m     \u001b[39m# print(pose)\u001b[39;00m\n\u001b[1;32m     24\u001b[0m     \u001b[39m# for i in range(3):\u001b[39;00m\n\u001b[1;32m     25\u001b[0m     \u001b[39m#     print(positions[i], ':', corrupted_EIG(grid, *positions[i]) + 0*pose.compute_cost(Pose(*positions[i])))\u001b[39;00m\n\u001b[1;32m     26\u001b[0m     \u001b[39m# print()\u001b[39;00m\n\u001b[1;32m     27\u001b[0m \n\u001b[1;32m     28\u001b[0m     \u001b[39m# print(corrupted_EIG(grid, *positions[0]))\u001b[39;00m\n\u001b[1;32m     29\u001b[0m     \u001b[39mwhile\u001b[39;00m path \u001b[39m==\u001b[39m []:\n",
      "Cell \u001b[0;32mIn[5], line 14\u001b[0m, in \u001b[0;36mcorrupted_EIG\u001b[0;34m(grid, x, y, theta)\u001b[0m\n\u001b[1;32m     12\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mcorrupted_EIG\u001b[39m(grid, x, y, theta):\n\u001b[1;32m     13\u001b[0m     dx, dy \u001b[39m=\u001b[39m grid\u001b[39m.\u001b[39mcell_width \u001b[39m*\u001b[39m np\u001b[39m.\u001b[39mround(np\u001b[39m.\u001b[39mcos(theta)), grid\u001b[39m.\u001b[39mcell_width \u001b[39m*\u001b[39m np\u001b[39m.\u001b[39mround(np\u001b[39m.\u001b[39msin(theta))\n\u001b[0;32m---> 14\u001b[0m     dx2, dy2 \u001b[39m=\u001b[39m grid\u001b[39m.\u001b[39mcell_width \u001b[39m*\u001b[39m np\u001b[39m.\u001b[39mround(np\u001b[39m.\u001b[39mcos(theta \u001b[39m+\u001b[39m np\u001b[39m.\u001b[39mpi \u001b[39m/\u001b[39m \u001b[39m2\u001b[39m)), grid\u001b[39m.\u001b[39mcell_width \u001b[39m*\u001b[39m np\u001b[39m.\u001b[39;49mround(np\u001b[39m.\u001b[39;49msin(theta \u001b[39m+\u001b[39;49m np\u001b[39m.\u001b[39;49mpi \u001b[39m/\u001b[39;49m \u001b[39m2\u001b[39;49m))\n\u001b[1;32m     15\u001b[0m     \u001b[39m# print(np.round(np.cos(theta)), np.round(np.sin(theta)), np.round(np.cos(theta + np.pi / 2)), np.round(np.sin(theta + np.pi / 2)))\u001b[39;00m\n\u001b[1;32m     16\u001b[0m     \u001b[39m# print(dx, dy, dx2, dy2)\u001b[39;00m\n\u001b[1;32m     17\u001b[0m     \u001b[39m# print(x,y,theta)\u001b[39;00m\n\u001b[1;32m     18\u001b[0m     \u001b[39m# print('----')\u001b[39;00m\n\u001b[1;32m     19\u001b[0m     \u001b[39massert\u001b[39;00m dx \u001b[39m!=\u001b[39m dx2\n",
      "File \u001b[0;32m<__array_function__ internals>:180\u001b[0m, in \u001b[0;36mround_\u001b[0;34m(*args, **kwargs)\u001b[0m\n",
      "File \u001b[0;32m/opt/homebrew/lib/python3.11/site-packages/numpy/core/fromnumeric.py:3241\u001b[0m, in \u001b[0;36m_around_dispatcher\u001b[0;34m(a, decimals, out)\u001b[0m\n\u001b[1;32m   3237\u001b[0m         \u001b[39mexcept\u001b[39;00m \u001b[39mAttributeError\u001b[39;00m:\n\u001b[1;32m   3238\u001b[0m             \u001b[39mreturn\u001b[39;00m asarray(a)\u001b[39m.\u001b[39mshape[axis]\n\u001b[0;32m-> 3241\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39m_around_dispatcher\u001b[39m(a, decimals\u001b[39m=\u001b[39m\u001b[39mNone\u001b[39;00m, out\u001b[39m=\u001b[39m\u001b[39mNone\u001b[39;00m):\n\u001b[1;32m   3242\u001b[0m     \u001b[39mreturn\u001b[39;00m (a, out)\n\u001b[1;32m   3245\u001b[0m \u001b[39m@array_function_dispatch\u001b[39m(_around_dispatcher)\n\u001b[1;32m   3246\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39maround\u001b[39m(a, decimals\u001b[39m=\u001b[39m\u001b[39m0\u001b[39m, out\u001b[39m=\u001b[39m\u001b[39mNone\u001b[39;00m):\n",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "grid_array = pickle.load(open('maps/mapsm_09.pkl', 'rb'))\n",
    "map50_metric = []\n",
    "# grid_array = np.zeros((12,12))\n",
    "explore_array = np.ones(grid_array.shape) * 0.5\n",
    "grid = ExplorationGrid(grid_array, explore_array, P_TRUE)\n",
    "\n",
    "fig, axs = plt.subplots(nrows=1, ncols=2)\n",
    "\n",
    "start = Pose(1, 0.5, np.pi / 2)\n",
    "pose = start\n",
    "\n",
    "grid.explore_grid.pose_grid[start.x, start.y].freespace = 0\n",
    "iters = 1000\n",
    "\n",
    "filenames = []\n",
    "i = 0\n",
    "path = []\n",
    "\n",
    "while True:\n",
    "    positions = grid.explore_grid.get_freespace_nodes()\n",
    "    positions = sorted(positions, key=lambda v:  (corrupted_EIG(grid, *v) / (pose.compute_cost(Pose(*v)) + 1), corrupted_EIG(grid, *v)), reverse=True)\n",
    "\n",
    "    # print(pose)\n",
    "    # for i in range(3):\n",
    "    #     print(positions[i], ':', corrupted_EIG(grid, *positions[i]) + 0*pose.compute_cost(Pose(*positions[i])))\n",
    "    # print()\n",
    "\n",
    "    # print(corrupted_EIG(grid, *positions[0]))\n",
    "    while path == []:\n",
    "        goal = Pose(*positions[0])\n",
    "        path = waypoint_gen(grid.explore_grid, pose, goal)\n",
    "        if path != None:\n",
    "            break\n",
    "        else:\n",
    "            path = []\n",
    "        positions = positions[1:]\n",
    "    # assert True if len(path) < 3 else path[0] != path[2]\n",
    "    pose = path[0]\n",
    "    path = path[1:]\n",
    "    if i % 1 == -1:\n",
    "        fig, axs = plt.subplots(nrows=1, ncols=2)\n",
    "        grid.plot(axs, start=pose, goal=goal, path=path)\n",
    "        fig.set_size_inches((10,5))\n",
    "        fig.tight_layout()\n",
    "        filenames.append(rf'/Users/neiljanwani/Documents/exploration-scrat/images/mapbasic_smart/image{i}.png')\n",
    "        plt.savefig(filenames[-1])\n",
    "        plt.close()\n",
    "    if unknown_area(grid.explore_grid, pose.x, pose.y, pose.theta):\n",
    "        corrupted_measurement(grid, pose.x, pose.y, pose.theta)\n",
    "        path = []\n",
    "        # print('making measurement')\n",
    "    map50_metric.append(np.mean([int(grid.explore_grid.pose_grid[(x,y)].freespace < FREESPACE_ALPHA or grid.explore_grid.pose_grid[(x,y)].freespace > 1 - FREESPACE_ALPHA) for x,y in grid.pose_grid]))\n",
    "    print(map50_metric[-1], end='\\r')\n",
    "    # input()\n",
    "    i += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots()\n",
    "ax.plot(mapbasic_metric, label='Map basic')\n",
    "ax.plot(map20_metric, label = 'Map 20x20')\n",
    "ax.plot(map30_metric, label = 'Map 30x30')\n",
    "ax.plot(map50_metric, label = 'Map 50x50')\n",
    "ax.set_xlabel('Iterations (robot steps)')\n",
    "ax.set_ylabel('Percent explored')\n",
    "ax.set_title('Smart Exploration Algorithm Performance')\n",
    "plt.legend()\n",
    "plt.savefig('/Users/neiljanwani/Documents/exploration-scrat/images/graphs/smart_explore_performance')"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# DIRECTED EXPLORE"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.006944444444444444\n",
      "0.020833333333333332\n",
      "0.020833333333333332\n",
      "0.041666666666666664\n",
      "0.041666666666666664\n",
      "0.041666666666666664\n",
      "0.041666666666666664\n",
      "0.0625\n",
      "0.0625\n",
      "0.0625\n",
      "0.0763888888888889\n",
      "0.08333333333333333\n",
      "0.09027777777777778\n",
      "0.09722222222222222\n",
      "0.09722222222222222\n",
      "0.09722222222222222\n",
      "0.09722222222222222\n",
      "0.09722222222222222\n",
      "0.09722222222222222\n",
      "0.09722222222222222\n",
      "0.09722222222222222\n",
      "0.09722222222222222\n",
      "0.09722222222222222\n",
      "0.09722222222222222\n",
      "0.09722222222222222\n",
      "0.09722222222222222\n",
      "0.09722222222222222\n"
     ]
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[25], line 47\u001b[0m\n\u001b[1;32m     45\u001b[0m     fig\u001b[39m.\u001b[39mtight_layout()\n\u001b[1;32m     46\u001b[0m     filenames\u001b[39m.\u001b[39mappend(\u001b[39mrf\u001b[39m\u001b[39m'\u001b[39m\u001b[39m/Users/neiljanwani/Documents/exploration-scrat/images/map20_smart/image\u001b[39m\u001b[39m{\u001b[39;00mi\u001b[39m}\u001b[39;00m\u001b[39m.png\u001b[39m\u001b[39m'\u001b[39m)\n\u001b[0;32m---> 47\u001b[0m     plt\u001b[39m.\u001b[39;49msavefig(filenames[\u001b[39m-\u001b[39;49m\u001b[39m1\u001b[39;49m])\n\u001b[1;32m     48\u001b[0m     plt\u001b[39m.\u001b[39mclose()\n\u001b[1;32m     49\u001b[0m corrupted_measurement(grid, pose\u001b[39m.\u001b[39mx, pose\u001b[39m.\u001b[39my, pose\u001b[39m.\u001b[39mtheta)\n",
      "File \u001b[0;32m/opt/homebrew/lib/python3.11/site-packages/matplotlib/pyplot.py:1024\u001b[0m, in \u001b[0;36msavefig\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m   1022\u001b[0m fig \u001b[39m=\u001b[39m gcf()\n\u001b[1;32m   1023\u001b[0m res \u001b[39m=\u001b[39m fig\u001b[39m.\u001b[39msavefig(\u001b[39m*\u001b[39margs, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwargs)\n\u001b[0;32m-> 1024\u001b[0m fig\u001b[39m.\u001b[39;49mcanvas\u001b[39m.\u001b[39;49mdraw_idle()  \u001b[39m# Need this if 'transparent=True', to reset colors.\u001b[39;00m\n\u001b[1;32m   1025\u001b[0m \u001b[39mreturn\u001b[39;00m res\n",
      "File \u001b[0;32m/opt/homebrew/lib/python3.11/site-packages/matplotlib/backend_bases.py:2082\u001b[0m, in \u001b[0;36mFigureCanvasBase.draw_idle\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   2080\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_is_idle_drawing:\n\u001b[1;32m   2081\u001b[0m     \u001b[39mwith\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_idle_draw_cntx():\n\u001b[0;32m-> 2082\u001b[0m         \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mdraw(\u001b[39m*\u001b[39;49margs, \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49mkwargs)\n",
      "File \u001b[0;32m/opt/homebrew/lib/python3.11/site-packages/matplotlib/backends/backend_agg.py:400\u001b[0m, in \u001b[0;36mFigureCanvasAgg.draw\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m    396\u001b[0m \u001b[39m# Acquire a lock on the shared font cache.\u001b[39;00m\n\u001b[1;32m    397\u001b[0m \u001b[39mwith\u001b[39;00m RendererAgg\u001b[39m.\u001b[39mlock, \\\n\u001b[1;32m    398\u001b[0m      (\u001b[39mself\u001b[39m\u001b[39m.\u001b[39mtoolbar\u001b[39m.\u001b[39m_wait_cursor_for_draw_cm() \u001b[39mif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mtoolbar\n\u001b[1;32m    399\u001b[0m       \u001b[39melse\u001b[39;00m nullcontext()):\n\u001b[0;32m--> 400\u001b[0m     \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mfigure\u001b[39m.\u001b[39;49mdraw(\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mrenderer)\n\u001b[1;32m    401\u001b[0m     \u001b[39m# A GUI class may be need to update a window using this draw, so\u001b[39;00m\n\u001b[1;32m    402\u001b[0m     \u001b[39m# don't forget to call the superclass.\u001b[39;00m\n\u001b[1;32m    403\u001b[0m     \u001b[39msuper\u001b[39m()\u001b[39m.\u001b[39mdraw()\n",
      "File \u001b[0;32m/opt/homebrew/lib/python3.11/site-packages/matplotlib/artist.py:95\u001b[0m, in \u001b[0;36m_finalize_rasterization.<locals>.draw_wrapper\u001b[0;34m(artist, renderer, *args, **kwargs)\u001b[0m\n\u001b[1;32m     93\u001b[0m \u001b[39m@wraps\u001b[39m(draw)\n\u001b[1;32m     94\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mdraw_wrapper\u001b[39m(artist, renderer, \u001b[39m*\u001b[39margs, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwargs):\n\u001b[0;32m---> 95\u001b[0m     result \u001b[39m=\u001b[39m draw(artist, renderer, \u001b[39m*\u001b[39;49margs, \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49mkwargs)\n\u001b[1;32m     96\u001b[0m     \u001b[39mif\u001b[39;00m renderer\u001b[39m.\u001b[39m_rasterizing:\n\u001b[1;32m     97\u001b[0m         renderer\u001b[39m.\u001b[39mstop_rasterizing()\n",
      "File \u001b[0;32m/opt/homebrew/lib/python3.11/site-packages/matplotlib/artist.py:72\u001b[0m, in \u001b[0;36mallow_rasterization.<locals>.draw_wrapper\u001b[0;34m(artist, renderer)\u001b[0m\n\u001b[1;32m     69\u001b[0m     \u001b[39mif\u001b[39;00m artist\u001b[39m.\u001b[39mget_agg_filter() \u001b[39mis\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[1;32m     70\u001b[0m         renderer\u001b[39m.\u001b[39mstart_filter()\n\u001b[0;32m---> 72\u001b[0m     \u001b[39mreturn\u001b[39;00m draw(artist, renderer)\n\u001b[1;32m     73\u001b[0m \u001b[39mfinally\u001b[39;00m:\n\u001b[1;32m     74\u001b[0m     \u001b[39mif\u001b[39;00m artist\u001b[39m.\u001b[39mget_agg_filter() \u001b[39mis\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n",
      "File \u001b[0;32m/opt/homebrew/lib/python3.11/site-packages/matplotlib/figure.py:3140\u001b[0m, in \u001b[0;36mFigure.draw\u001b[0;34m(self, renderer)\u001b[0m\n\u001b[1;32m   3137\u001b[0m         \u001b[39m# ValueError can occur when resizing a window.\u001b[39;00m\n\u001b[1;32m   3139\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mpatch\u001b[39m.\u001b[39mdraw(renderer)\n\u001b[0;32m-> 3140\u001b[0m mimage\u001b[39m.\u001b[39;49m_draw_list_compositing_images(\n\u001b[1;32m   3141\u001b[0m     renderer, \u001b[39mself\u001b[39;49m, artists, \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49msuppressComposite)\n\u001b[1;32m   3143\u001b[0m \u001b[39mfor\u001b[39;00m sfig \u001b[39min\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39msubfigs:\n\u001b[1;32m   3144\u001b[0m     sfig\u001b[39m.\u001b[39mdraw(renderer)\n",
      "File \u001b[0;32m/opt/homebrew/lib/python3.11/site-packages/matplotlib/image.py:131\u001b[0m, in \u001b[0;36m_draw_list_compositing_images\u001b[0;34m(renderer, parent, artists, suppress_composite)\u001b[0m\n\u001b[1;32m    129\u001b[0m \u001b[39mif\u001b[39;00m not_composite \u001b[39mor\u001b[39;00m \u001b[39mnot\u001b[39;00m has_images:\n\u001b[1;32m    130\u001b[0m     \u001b[39mfor\u001b[39;00m a \u001b[39min\u001b[39;00m artists:\n\u001b[0;32m--> 131\u001b[0m         a\u001b[39m.\u001b[39;49mdraw(renderer)\n\u001b[1;32m    132\u001b[0m \u001b[39melse\u001b[39;00m:\n\u001b[1;32m    133\u001b[0m     \u001b[39m# Composite any adjacent images together\u001b[39;00m\n\u001b[1;32m    134\u001b[0m     image_group \u001b[39m=\u001b[39m []\n",
      "File \u001b[0;32m/opt/homebrew/lib/python3.11/site-packages/matplotlib/artist.py:72\u001b[0m, in \u001b[0;36mallow_rasterization.<locals>.draw_wrapper\u001b[0;34m(artist, renderer)\u001b[0m\n\u001b[1;32m     69\u001b[0m     \u001b[39mif\u001b[39;00m artist\u001b[39m.\u001b[39mget_agg_filter() \u001b[39mis\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[1;32m     70\u001b[0m         renderer\u001b[39m.\u001b[39mstart_filter()\n\u001b[0;32m---> 72\u001b[0m     \u001b[39mreturn\u001b[39;00m draw(artist, renderer)\n\u001b[1;32m     73\u001b[0m \u001b[39mfinally\u001b[39;00m:\n\u001b[1;32m     74\u001b[0m     \u001b[39mif\u001b[39;00m artist\u001b[39m.\u001b[39mget_agg_filter() \u001b[39mis\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n",
      "File \u001b[0;32m/opt/homebrew/lib/python3.11/site-packages/matplotlib/axes/_base.py:3064\u001b[0m, in \u001b[0;36m_AxesBase.draw\u001b[0;34m(self, renderer)\u001b[0m\n\u001b[1;32m   3061\u001b[0m \u001b[39mif\u001b[39;00m artists_rasterized:\n\u001b[1;32m   3062\u001b[0m     _draw_rasterized(\u001b[39mself\u001b[39m\u001b[39m.\u001b[39mfigure, artists_rasterized, renderer)\n\u001b[0;32m-> 3064\u001b[0m mimage\u001b[39m.\u001b[39;49m_draw_list_compositing_images(\n\u001b[1;32m   3065\u001b[0m     renderer, \u001b[39mself\u001b[39;49m, artists, \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mfigure\u001b[39m.\u001b[39;49msuppressComposite)\n\u001b[1;32m   3067\u001b[0m renderer\u001b[39m.\u001b[39mclose_group(\u001b[39m'\u001b[39m\u001b[39maxes\u001b[39m\u001b[39m'\u001b[39m)\n\u001b[1;32m   3068\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mstale \u001b[39m=\u001b[39m \u001b[39mFalse\u001b[39;00m\n",
      "File \u001b[0;32m/opt/homebrew/lib/python3.11/site-packages/matplotlib/image.py:131\u001b[0m, in \u001b[0;36m_draw_list_compositing_images\u001b[0;34m(renderer, parent, artists, suppress_composite)\u001b[0m\n\u001b[1;32m    129\u001b[0m \u001b[39mif\u001b[39;00m not_composite \u001b[39mor\u001b[39;00m \u001b[39mnot\u001b[39;00m has_images:\n\u001b[1;32m    130\u001b[0m     \u001b[39mfor\u001b[39;00m a \u001b[39min\u001b[39;00m artists:\n\u001b[0;32m--> 131\u001b[0m         a\u001b[39m.\u001b[39;49mdraw(renderer)\n\u001b[1;32m    132\u001b[0m \u001b[39melse\u001b[39;00m:\n\u001b[1;32m    133\u001b[0m     \u001b[39m# Composite any adjacent images together\u001b[39;00m\n\u001b[1;32m    134\u001b[0m     image_group \u001b[39m=\u001b[39m []\n",
      "File \u001b[0;32m/opt/homebrew/lib/python3.11/site-packages/matplotlib/artist.py:72\u001b[0m, in \u001b[0;36mallow_rasterization.<locals>.draw_wrapper\u001b[0;34m(artist, renderer)\u001b[0m\n\u001b[1;32m     69\u001b[0m     \u001b[39mif\u001b[39;00m artist\u001b[39m.\u001b[39mget_agg_filter() \u001b[39mis\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[1;32m     70\u001b[0m         renderer\u001b[39m.\u001b[39mstart_filter()\n\u001b[0;32m---> 72\u001b[0m     \u001b[39mreturn\u001b[39;00m draw(artist, renderer)\n\u001b[1;32m     73\u001b[0m \u001b[39mfinally\u001b[39;00m:\n\u001b[1;32m     74\u001b[0m     \u001b[39mif\u001b[39;00m artist\u001b[39m.\u001b[39mget_agg_filter() \u001b[39mis\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n",
      "File \u001b[0;32m/opt/homebrew/lib/python3.11/site-packages/matplotlib/text.py:800\u001b[0m, in \u001b[0;36mText.draw\u001b[0;34m(self, renderer)\u001b[0m\n\u001b[1;32m    796\u001b[0m             textrenderer\u001b[39m.\u001b[39mdraw_tex(gc, x, y, clean_line,\n\u001b[1;32m    797\u001b[0m                                   \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_fontproperties, angle,\n\u001b[1;32m    798\u001b[0m                                   mtext\u001b[39m=\u001b[39mmtext)\n\u001b[1;32m    799\u001b[0m         \u001b[39melse\u001b[39;00m:\n\u001b[0;32m--> 800\u001b[0m             textrenderer\u001b[39m.\u001b[39;49mdraw_text(gc, x, y, clean_line,\n\u001b[1;32m    801\u001b[0m                                    \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_fontproperties, angle,\n\u001b[1;32m    802\u001b[0m                                    ismath\u001b[39m=\u001b[39;49mismath, mtext\u001b[39m=\u001b[39;49mmtext)\n\u001b[1;32m    804\u001b[0m gc\u001b[39m.\u001b[39mrestore()\n\u001b[1;32m    805\u001b[0m renderer\u001b[39m.\u001b[39mclose_group(\u001b[39m'\u001b[39m\u001b[39mtext\u001b[39m\u001b[39m'\u001b[39m)\n",
      "File \u001b[0;32m/opt/homebrew/lib/python3.11/site-packages/matplotlib/backends/backend_agg.py:208\u001b[0m, in \u001b[0;36mRendererAgg.draw_text\u001b[0;34m(self, gc, x, y, s, prop, angle, ismath, mtext)\u001b[0m\n\u001b[1;32m    205\u001b[0m \u001b[39m# We pass '0' for angle here, since it will be rotated (in raster\u001b[39;00m\n\u001b[1;32m    206\u001b[0m \u001b[39m# space) in the following call to draw_text_image).\u001b[39;00m\n\u001b[1;32m    207\u001b[0m font\u001b[39m.\u001b[39mset_text(s, \u001b[39m0\u001b[39m, flags\u001b[39m=\u001b[39mget_hinting_flag())\n\u001b[0;32m--> 208\u001b[0m font\u001b[39m.\u001b[39;49mdraw_glyphs_to_bitmap(\n\u001b[1;32m    209\u001b[0m     antialiased\u001b[39m=\u001b[39;49mmpl\u001b[39m.\u001b[39;49mrcParams[\u001b[39m'\u001b[39;49m\u001b[39mtext.antialiased\u001b[39;49m\u001b[39m'\u001b[39;49m])\n\u001b[1;32m    210\u001b[0m d \u001b[39m=\u001b[39m font\u001b[39m.\u001b[39mget_descent() \u001b[39m/\u001b[39m \u001b[39m64.0\u001b[39m\n\u001b[1;32m    211\u001b[0m \u001b[39m# The descent needs to be adjusted for the angle.\u001b[39;00m\n",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x500 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "grid_array = pickle.load(open('maps/map20.pkl', 'rb'))\n",
    "grid_array = np.zeros((12,12))\n",
    "explore_array = np.ones(grid_array.shape) * 0.5\n",
    "grid = ExplorationGrid(grid_array, explore_array, P_TRUE)\n",
    "\n",
    "fig, axs = plt.subplots(nrows=1, ncols=2)\n",
    "\n",
    "start = Pose(1, 0.5, np.pi / 2)\n",
    "pose = start\n",
    "\n",
    "grid.explore_grid.pose_grid[start.x, start.y].freespace = 0\n",
    "iters = 1000\n",
    "\n",
    "filenames = []\n",
    "i = 0\n",
    "\n",
    "goals = [(2,1,0), (1,2,0), (6,5,0)]\n",
    "cgoal = 0\n",
    "path = []\n",
    "\n",
    "while True:\n",
    "    if pose.x == goals[cgoal][0] and pose.y == goals[cgoal][1]:\n",
    "        cgoal += 1\n",
    "        print(\"GOAL REACHED!\")\n",
    "    cgoal %= len(goals)\n",
    "    \n",
    "    positions = grid.explore_grid.get_freespace_nodes()\n",
    "    positions = sorted(positions, key=lambda v:  (0*corrupted_EIG(grid, *v) + 0.1 * pose.compute_cost(Pose(*goals[cgoal])), 0*corrupted_EIG(grid, *v)), reverse=False)\n",
    "    \n",
    "    while len(path) == 0:\n",
    "        goal = Pose(*positions[0])\n",
    "        path = waypoint_gen(grid.explore_grid, pose, goal)\n",
    "        if path != None:\n",
    "            path = path[1:]\n",
    "            break\n",
    "        else:\n",
    "            path = []\n",
    "        positions = positions[1:]\n",
    "    # assert True if len(path) < 3 else path[0] != path[2]\n",
    "    pose = path.pop(0)\n",
    "    if i % 1 == 0:\n",
    "        fig, axs = plt.subplots(nrows=1, ncols=2)\n",
    "        grid.plot(axs, start=pose, goal=Pose(*goals[cgoal]), path=None)\n",
    "        fig.set_size_inches((10,5))\n",
    "        fig.tight_layout()\n",
    "        filenames.append(rf'/Users/neiljanwani/Documents/exploration-scrat/images/map20_smart/image{i}.png')\n",
    "        plt.savefig(filenames[-1])\n",
    "        plt.close()\n",
    "    corrupted_measurement(grid, pose.x, pose.y, pose.theta)\n",
    "    print(np.mean([int(grid.explore_grid.pose_grid[(x,y)].freespace < FREESPACE_ALPHA or grid.explore_grid.pose_grid[(x,y)].freespace > 1 - FREESPACE_ALPHA) for x,y in grid.pose_grid]), end='\\n')\n",
    "    # input()\n",
    "    i += 1\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "import cv2\n",
    "import time\n",
    " \n",
    "img_array = []\n",
    "for filename in filenames[:-1]:\n",
    "    img = cv2.imread(filename)\n",
    "    height, width, layers = img.shape\n",
    "    size = (width,height)\n",
    "    img_array.append(img)\n",
    " \n",
    " \n",
    "out = cv2.VideoWriter(f'/Users/neiljanwani/Documents/exploration-scrat/images/final/exploration_{str(time.asctime()).replace(\" \",\"_\").replace(\":\",\"-\")}.mp4', cv2.VideoWriter_fourcc(*'mp4v'), 15, size)\n",
    " \n",
    "for i in range(len(img_array)):\n",
    "    out.write(img_array[i])\n",
    "out.release()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "filenames"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "base",
   "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.11.3"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}