CSS_group_3.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Complex System Simulation\n",
    "\n",
    "Complex river networks with cellular automata\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import random as rd\n",
    "import seaborn as sns\n",
    "import matplotlib\n",
    "import matplotlib.pyplot as plt\n",
    "# matplotlib.use(\"Agg\")\n",
    "import matplotlib.animation as animation\n",
    "from matplotlib import rc as rc\n",
    "import matplotlib.cm as cm\n",
    "from IPython.display import HTML\n",
    "import time as tm"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following cell contains the class we created to simulate the rivers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "class CA:\n",
    "    \"\"\"\n",
    "    parameters:\n",
    "    \n",
    "    - size:         size of grid (square grid of size x size)\n",
    "    - slope:        slope of the grid, slope from row to row\n",
    "    - time_limit:   maximum number of time steps\n",
    "    - rand_lower:   lower bound of randomly generated number\n",
    "    - rand_upper:   upper bound of randomly generated number\n",
    "    - branch_tresh: branching threshold\n",
    "    - init_water:   initial water level\n",
    "    - delta_water:  water loss variable, loss per step\n",
    "    \n",
    "    \"\"\"\n",
    "    \n",
    "    \n",
    "    def __init__(\n",
    "        self, size, slope, time_limit, rand_lower=0.9999, rand_upper=1.00001,\n",
    "        branch_tresh=0.1, init_water=1, delta_water=0.0008, viz=False\n",
    "    ):\n",
    "        self.size = size\n",
    "        self.slope = slope\n",
    "        self.time_limit = time_limit\n",
    "        self.rand_lower = rand_lower\n",
    "        self.rand_upper = rand_upper\n",
    "        self.branch_tresh = branch_tresh\n",
    "        self.init_water_level = init_water\n",
    "        self.delta_w = delta_water\n",
    "        \n",
    "        # starting point / source cell in the middle of the grid\n",
    "        self.starting_column = int(self.size / 2)\n",
    "        \n",
    "        self.terrain = np.zeros((size, size))\n",
    "        self.cur_river_nr = 1\n",
    "        self.rivers = {}\n",
    "\n",
    "        self.path = np.zeros((size, size))\n",
    "        \n",
    "        self.river_coors = set()\n",
    "        self.split_dict = {}\n",
    "        self.segment_dict = {}\n",
    "        self.segment_grid = self.path.copy()\n",
    "        self.viz = viz\n",
    "        if self.viz:\n",
    "            self.path_list = []\n",
    "\n",
    "    def moore_neighborhood(self, grid, i, j):\n",
    "        \"\"\"\n",
    "        Function returning the Moore neigborhood of a given cell \n",
    "        \n",
    "        Also returns the grid coordinates of all the individual neighbors\n",
    "        \"\"\"\n",
    "\n",
    "        if i == 0 and j == 0:\n",
    "            neighborhood = [\n",
    "                grid[i + 1, j + 1],\n",
    "                grid[i, j + 1],\n",
    "                grid[i + 1, j],\n",
    "            ]\n",
    "            locations = [\n",
    "                [i + 1, j + 1],\n",
    "                [i, j + 1],\n",
    "                [i + 1, j]\n",
    "            ]\n",
    "\n",
    "        elif i == 0 and j == (self.size - 1):\n",
    "            neighborhood = [\n",
    "                grid[i, j - 1],\n",
    "                grid[i + 1, j - 1],\n",
    "                grid[i + 1, j],\n",
    "            ]\n",
    "            locations = [\n",
    "                [i, j - 1],\n",
    "                [i + 1, j - 1],\n",
    "                [i + 1, j],\n",
    "            ]\n",
    "\n",
    "        elif i == 0 and 0 < j < (self.size - 1):\n",
    "            neighborhood = [\n",
    "                grid[i, j - 1],\n",
    "                grid[i, j + 1],\n",
    "                grid[i + 1, j - 1],\n",
    "                grid[i + 1, j],\n",
    "                grid[i + 1, j + 1],\n",
    "            ]\n",
    "            locations = [\n",
    "                [i, j - 1],\n",
    "                [i, j + 1],\n",
    "                [i + 1, j - 1],\n",
    "                [i + 1, j],\n",
    "                [i + 1, j + 1],\n",
    "            ]\n",
    "\n",
    "        elif i == (self.size - 1) and j == 0:\n",
    "            neighborhood = [\n",
    "                grid[i, j + 1],\n",
    "                grid[i - 1, j + 1],\n",
    "                grid[i - 1, j],\n",
    "            ]\n",
    "            locations = [\n",
    "                [i, j + 1],\n",
    "                [i - 1, j + 1],\n",
    "                [i - 1, j],\n",
    "            ]\n",
    "\n",
    "        elif i == (self.size - 1) and j == (self.size - 1):\n",
    "            neighborhood = [\n",
    "                grid[i - 1, j - 1],\n",
    "                grid[i, j - 1],\n",
    "                grid[i - 1, j],\n",
    "            ]\n",
    "            locations = [\n",
    "                [i - 1, j - 1],\n",
    "                [i, j - 1],\n",
    "                [i - 1, j],\n",
    "            ]\n",
    "\n",
    "        elif i == (self.size - 1) and 0 < j < (self.size - 1):\n",
    "            neighborhood = [\n",
    "                grid[i, j - 1],\n",
    "                grid[i, j + 1],\n",
    "                grid[i - 1, j - 1],\n",
    "                grid[i - 1, j],\n",
    "                grid[i - 1, j + 1],\n",
    "            ]\n",
    "            locations = [\n",
    "                [i, j - 1],\n",
    "                [i, j + 1],\n",
    "                [i - 1, j - 1],\n",
    "                [i - 1, j],\n",
    "                [i - 1, j + 1],\n",
    "            ]\n",
    "\n",
    "        elif 0 < i < (self.size - 1) and j == 0:\n",
    "            neighborhood = [\n",
    "                grid[i - 1, j],\n",
    "                grid[i - 1, j + 1],\n",
    "                grid[i, j + 1],\n",
    "                grid[i + 1, j],\n",
    "                grid[i + 1, j + 1],\n",
    "            ]\n",
    "            locations = [\n",
    "                [i - 1, j],\n",
    "                [i - 1, j + 1],\n",
    "                [i, j + 1],\n",
    "                [i + 1, j],\n",
    "                [i + 1, j + 1],\n",
    "            ]\n",
    "\n",
    "        elif 0 < i < (self.size - 1) and j == (self.size - 1):\n",
    "            neighborhood = [\n",
    "                grid[i - 1, j],\n",
    "                grid[i - 1, j - 1],\n",
    "                grid[i, j - 1],\n",
    "                grid[i + 1, j],\n",
    "                grid[i + 1, j - 1],\n",
    "            ]\n",
    "            locations = [\n",
    "                [i - 1, j],\n",
    "                [i - 1, j - 1],\n",
    "                [i, j - 1],\n",
    "                [i + 1, j],\n",
    "                [i + 1, j - 1],\n",
    "            ]\n",
    "\n",
    "        else:\n",
    "            neighborhood = [\n",
    "                grid[i - 1, j - 1],\n",
    "                grid[i - 1, j],\n",
    "                grid[i - 1, j + 1],\n",
    "                grid[i, j - 1],\n",
    "                grid[i, j + 1],\n",
    "                grid[i + 1, j - 1],\n",
    "                grid[i + 1, j],\n",
    "                grid[i + 1, j + 1],\n",
    "            ]\n",
    "            locations = [\n",
    "                [i - 1, j - 1],\n",
    "                [i - 1, j],\n",
    "                [i - 1, j + 1],\n",
    "                [i, j - 1],\n",
    "                [i, j + 1],\n",
    "                [i + 1, j - 1],\n",
    "                [i + 1, j],\n",
    "                [i + 1, j + 1],\n",
    "            ]\n",
    "\n",
    "        return neighborhood, locations\n",
    "\n",
    "    def initialize_terrain(self):\n",
    "        \"\"\"\n",
    "        Function creating the sloping terrain including random perturbations with respect to neighbors\n",
    "        \n",
    "        Additionally, evelavations in the terrain can be created (referred to as hills)\n",
    "        \n",
    "        \"\"\"\n",
    "        \n",
    "        # terrain is initialized as a size x size grid with equal height\n",
    "        terrain = np.ones((self.size, self.size))\n",
    "\n",
    "        # turn into sloping terrain\n",
    "        for i in range(self.size - 1):\n",
    "            terrain[i + 1] = terrain[i] * (1 - self.slope)\n",
    "\n",
    "        # incorporate randomness in terrain\n",
    "        for i in range(self.size):\n",
    "            for j in range(self.size):\n",
    "                neighbors = self.moore_neighborhood(terrain, i, j)[0]\n",
    "                if rd.random() < 0.01:\n",
    "                    perturb = rd.uniform(0.999, 1.0001)\n",
    "                else:\n",
    "                    perturb = rd.uniform(self.rand_lower, self.rand_upper)\n",
    "                terrain[i, j] = np.mean(neighbors) * perturb\n",
    "\n",
    "        # enter the coordinates, commented coordinates were used on a 200 x 200 grid\n",
    "        hill_coords = [\n",
    "            (0, int(self.size / 2)),\n",
    "            # (5, 12),\n",
    "            # (7, 40),\n",
    "            # (1, 60),\n",
    "            # (1, 135),\n",
    "            # (5, 150),\n",
    "            # (5, 170),\n",
    "            # (7, 185),\n",
    "            # (1, 195),\n",
    "            # (28, 150),\n",
    "            # (33, 115),\n",
    "            # (20, 70),\n",
    "            # (45, 80),\n",
    "            # (60, 110),\n",
    "        ]\n",
    "        \n",
    "        # create hill tops, multiply by number higher than one to elevate terrain at the specific coordinates\n",
    "        for hill_coord in hill_coords:\n",
    "            terrain[hill_coord] = terrain[hill_coord] * 1\n",
    "            \n",
    "        # from the hill tops, create hills\n",
    "        for _ in range(2):\n",
    "\n",
    "            for i in range(self.size):\n",
    "                for j in range(self.size):\n",
    "                    neighborhood, locations = self.moore_neighborhood(terrain, i, j)\n",
    "                    for n, neighbor in enumerate(neighborhood):\n",
    "                        location = (locations[n][0], locations[n][1])\n",
    "                        if ((terrain[i, j] - neighbor) / neighbor) > 0.01:\n",
    "                            terrain[location] = terrain[i, j] * rd.uniform(0.995, 0.999)\n",
    "\n",
    "            for i in range(self.size - 1, 0, -1):\n",
    "                for j in range(self.size - 1, 0, -1):\n",
    "                    neighborhood, locations = self.moore_neighborhood(terrain, i, j)\n",
    "                    for n, neighbor in enumerate(neighborhood):\n",
    "                        location = (locations[n][0], locations[n][1])\n",
    "                        if ((terrain[i, j] - neighbor) / neighbor) > 0.01:\n",
    "                            terrain[location] = terrain[i, j] * rd.uniform(0.995, 0.999)\n",
    "\n",
    "        self.terrain = terrain\n",
    "        return self.terrain\n",
    "\n",
    "    def get_location_of_lowest_neighbor(self, grid, i, j, temp_ends):\n",
    "        \"\"\"\n",
    "        Function returning both the values as the locations of the neighbors \n",
    "        \n",
    "        Values are sorted from low to high\n",
    "        \n",
    "        \"\"\"\n",
    "        neighborhood = self.moore_neighborhood(grid, i, j)\n",
    "        neighborhood0, neighborhood1 = [], []\n",
    "        for i, val in enumerate(neighborhood[1]):\n",
    "            if tuple(val) not in self.river_coors:\n",
    "                neighborhood0.append(neighborhood[0][i])\n",
    "                neighborhood1.append(val)\n",
    "        try:\n",
    "            value, location = (list(t) for t in zip(*sorted(zip(neighborhood0, neighborhood1))))\n",
    "        except ValueError:\n",
    "            value, location = [], []\n",
    "\n",
    "        return value, location\n",
    "\n",
    "    def get_path(self, prev_val, coor_list, value_list):\n",
    "        \"\"\"\n",
    "        Function adding the next cell to the river and reducing the water using the water loss variable\n",
    "        \"\"\"\n",
    "        for i, coor in enumerate(coor_list):\n",
    "            tup = tuple(coor)\n",
    "            if tup not in self.river_coors:\n",
    "                self.river_coors.add(tup)\n",
    "            else:\n",
    "                pass\n",
    "            self.path[tup] = self.path[tup] + float(prev_val[i])*(1-self.delta_w)\n",
    "        return self.path\n",
    "\n",
    "    def create_path_from_start(self):\n",
    "        \"\"\"\n",
    "        Function creating the river (network) from the source cell\n",
    "        \n",
    "        \"\"\"    \n",
    "        self.path = self.get_path([self.init_water_level/(1-self.delta_w)],[(0, self.starting_column)], [self.init_water_level])\n",
    "        self.river_coors.add((0, self.starting_column))\n",
    "        self.cur_ends = {}\n",
    "        self.cur_ends[(0, self.starting_column)] = self.cur_river_nr\n",
    "        self.segment_dict = {self.cur_river_nr:[(0, self.starting_column)]}\n",
    "        self.segment_grid[(0, self.starting_column)] = self.cur_river_nr\n",
    "        self.cur_river_nr += 1\n",
    "\n",
    "        for x in range(1, self.time_limit):\n",
    "            temp_ends = {}\n",
    "            for item, val in self.cur_ends.items():\n",
    "                if self.path[item] > self.branch_tresh:\n",
    "\n",
    "                    old_value = self.terrain[item]\n",
    "                    sort_values, sort_location = self.get_location_of_lowest_neighbor(self.terrain, item[0], item[1], temp_ends)\n",
    "                    if not sort_values:\n",
    "                        continue\n",
    "\n",
    "                    next_cell, next_value = [tuple(sort_location[0])], [sort_values[0]]\n",
    "                    next_water = [self.path[item]]\n",
    "                    if old_value < sort_values[0] and len(sort_location) > 1:\n",
    "                        next_cell.append(tuple(sort_location[1]))\n",
    "                        next_value.append(sort_values[1])\n",
    "                        next_water = self.new_water_ratio(item, tuple(sort_location[0]), tuple(sort_location[1]))\n",
    "                        temp_ends[next_cell[0]] = self.cur_river_nr\n",
    "                        self.segment_grid[next_cell[0]] = self.cur_river_nr\n",
    "                        self.segment_dict[self.cur_river_nr] = [next_cell[0]]\n",
    "                        self.cur_river_nr += 1\n",
    "                        temp_ends[next_cell[1]] = self.cur_river_nr\n",
    "                        self.segment_grid[next_cell[1]] = self.cur_river_nr\n",
    "                        self.segment_dict[self.cur_river_nr] = [next_cell[1]]\n",
    "                        self.cur_river_nr += 1\n",
    "                        self.split_dict[self.segment_grid[item]] = (self.segment_grid[next_cell[1]], self.segment_grid[next_cell[0]])\n",
    "                    else:\n",
    "                        temp_ends[(next_cell[0])] = self.segment_grid[item]\n",
    "                        self.segment_grid[(next_cell[0])] = self.segment_grid[item]\n",
    "                        self.segment_dict[self.segment_grid[item]].append(next_cell[0])\n",
    "                    self.path = self.get_path(next_water, next_cell, next_value)\n",
    "            if self.viz:\n",
    "                self.path_list.append(self.path.copy())\t\n",
    "            self.cur_ends = temp_ends.copy()\n",
    "\n",
    "\n",
    "            if not self.cur_ends:\n",
    "                if self.viz:\n",
    "                    return self.path_list \n",
    "                return self.path, self.segment_grid, self.split_dict, self.segment_dict\n",
    "        if self.viz:\n",
    "            return self.path_list \n",
    "        return self.path, self.segment_grid, self.split_dict, self.segment_dict\n",
    "\n",
    "    def new_water_ratio(self, old, coor_split1, coor_split2):\n",
    "        \"\"\"\n",
    "        Function returning the water ratio when river splits\n",
    "        \n",
    "        \"\"\"\n",
    "        new_l = self.terrain[coor_split1] - self.terrain[old]\n",
    "        new_r = self.terrain[coor_split2] - self.terrain[old]\n",
    "        l = new_l/(new_l + new_r) * self.path[old]\n",
    "        r = new_r/(new_l + new_r) * self.path[old]\n",
    "        return [l, r]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cell creating the Moore neighborhood function used in the slides"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "ca = CA(7, slope=0, time_limit=7, delta_water=0)\n",
    "\n",
    "matrix = np.zeros((7, 7))\n",
    "neighborhood, locations = ca.moore_neighborhood(matrix, 3, 3)\n",
    "\n",
    "for location in locations:\n",
    "    location = tuple(location)\n",
    "    matrix[location] = 1\n",
    "\n",
    "matrix[3, 3] = 2\n",
    "\n",
    "sns.heatmap(matrix, linewidths=.5, cmap=\"YlGnBu_r\")\n",
    "plt.savefig(f'Moore_neighborhood.png', dpi=300)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/yannick/.pyenv/versions/3.7.3/Python.framework/Versions/3.7/lib/python3.7/site-packages/matplotlib/pyplot.py:514: RuntimeWarning: More than 20 figures have been opened. Figures created through the pyplot interface (`matplotlib.pyplot.figure`) are retained until explicitly closed and may consume too much memory. (To control this warning, see the rcParam `figure.max_open_warning`).\n",
      "  max_open_warning, RuntimeWarning)\n"
     ]
    }
   ],
   "source": [
    "for i in range(1):\n",
    "    size = 200\n",
    "    slopes = [0.0001, 0.0002, 0.0004, 0.0006, 0.0008, 0.001]\n",
    "    waters = [0.0001, 0.0005, 0.0010, 0.0015]\n",
    "#     slopes = [0.0001]\n",
    "#     waters = [0.0008]\n",
    "    for slope in slopes:\n",
    "        for water in waters:\n",
    "            ca = CA(size=size, slope=slope, time_limit=size, delta_water=water)\n",
    "            terrain = ca.initialize_terrain()\n",
    "            path, segments, split_dict, segment_dict = ca.create_path_from_start()\n",
    "\n",
    "            fig, axes = plt.subplots(1, 2,figsize=(15,5))\n",
    "\n",
    "            sns.heatmap(terrain[:, 0:size-1], cmap=\"Greens\", ax=axes[0])\n",
    "            axes[0].set_title(f\"Terrain with slope {slope*100}% and water loss {water*100}%\")\n",
    "            sns.heatmap(path, cmap=\"Blues\", ax=axes[1])\n",
    "            axes[1].set_title(\"Path of river\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.0 1.0\n",
      "0.0 1.0\n",
      "0.0 1.0\n",
      "0.0 1.0\n",
      "0.0 1.0\n",
      "0.0 1.0\n"
     ]
    }
   ],
   "source": [
    "for i in range(1):\n",
    "    size = 200\n",
    "    slopes = [0.0001, 0.0002, 0.0004, 0.0006, 0.0008, 0.001]\n",
    "    for slope in slopes:\n",
    "        ca = CA(size=size, slope=slope, time_limit=size)\n",
    "        terrain = ca.initialize_terrain()\n",
    "        path, segments,_,_ = ca.create_path_from_start()\n",
    "\n",
    "        # masked_data = np.random.random((100,100))\n",
    "        masked_data = np.ma.masked_where(path < 0.01, path)\n",
    "        print(np.min(path), np.max(path))\n",
    "        # Overlay the two images\n",
    "        fig, ax = plt.subplots()\n",
    "        ax.imshow(terrain[:, 0:199], cmap='Greens')\n",
    "        ax.imshow(masked_data, cmap='Blues',vmin=-1,vmax=1, interpolation='none')\n",
    "        ax.set_title(f\"Terrain with slope {slope*100}% and water loss 0.08%\")\n",
    "        plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "def animation_func(iterationsres, steps, terrain, grid_size):\n",
    "    \"\"\" Creates animation object for given grid states.\n",
    "    \n",
    "    Arguments:\n",
    "        iterationsres {list} -- list with numpy grid states\n",
    "        steps {int} -- number of frames for the animation\n",
    "        terrain {numpy array} -- background terrain grid\n",
    "    \n",
    "    Returns:\n",
    "        matplotlib.animation object -- returns animation object\n",
    "    \"\"\"\n",
    "    sns.set_style('dark')\n",
    "\n",
    "    fig, ax = plt.subplots()\n",
    "    ax.imshow(terrain[:, 0:(grid_size-1)], cmap='Greens')\n",
    "    ax = plt.imshow(iterationsres[0], cmap='Blues',vmin=-1,vmax=1, interpolation='none')\n",
    "\n",
    "    def animate(i):\n",
    "        ax.set_array(iterationsres[i])\n",
    "        return ax,\n",
    "\n",
    "    anim = animation.FuncAnimation(fig, animate, frames=steps, interval=20, blit=True)\n",
    "\n",
    "    return anim"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Run the code below to animate a river over a random created terrain."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/yannick/.pyenv/versions/3.7.3/Python.framework/Versions/3.7/lib/python3.7/site-packages/matplotlib/pyplot.py:514: RuntimeWarning: More than 20 figures have been opened. Figures created through the pyplot interface (`matplotlib.pyplot.figure`) are retained until explicitly closed and may consume too much memory. (To control this warning, see the rcParam `figure.max_open_warning`).\n",
      "  max_open_warning, RuntimeWarning)\n"
     ]
    }
   ],
   "source": [
    "# Creates river by creating an ca object and running the animation_func function.\n",
    "size = 200\n",
    "slope = 0.0001\n",
    "water = 0.01\n",
    "caz = CA(size=size, slope=slope, time_limit=size, delta_water=water, viz=True)\n",
    "\n",
    "terrain = caz.initialize_terrain()\n",
    "path = caz.create_path_from_start()\n",
    "new_path = []\n",
    "\n",
    "# masks river grid for cells without river\n",
    "for val in path:\n",
    "    new_val = np.ma.masked_where(val < 0.01, val)\n",
    "    new_path.append(new_val)\n",
    "\n",
    "anim = animation_func(new_path, len(path), terrain, grid_size=size)\n",
    "\n",
    "# saves movie to animations folder\n",
    "anim.save(f\"animations/anim_river_water_{water}_slope_{slope}_{tm.time()}.mp4\", fps=60, extra_args=['-vcodec', 'libx264'])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Run cell below to get inline animation of the anim animation object created above"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<video width=\"432\" height=\"288\" controls autoplay loop>\n",
       "  <source type=\"video/mp4\" src=\"data:video/mp4;base64,AAAAHGZ0eXBNNFYgAAACAGlzb21pc28yYXZjMQAAAAhmcmVlAAAXlG1kYXQAAAKuBgX//6rcRem9\n",
       "5tlIt5Ys2CDZI+7veDI2NCAtIGNvcmUgMTU1IHIyOTE3IDBhODRkOTggLSBILjI2NC9NUEVHLTQg\n",
       "QVZDIGNvZGVjIC0gQ29weWxlZnQgMjAwMy0yMDE4IC0gaHR0cDovL3d3dy52aWRlb2xhbi5vcmcv\n",
       "eDI2NC5odG1sIC0gb3B0aW9uczogY2FiYWM9MSByZWY9MyBkZWJsb2NrPTE6MDowIGFuYWx5c2U9\n",
       "MHgzOjB4MTEzIG1lPWhleCBzdWJtZT03IHBzeT0xIHBzeV9yZD0xLjAwOjAuMDAgbWl4ZWRfcmVm\n",
       "PTEgbWVfcmFuZ2U9MTYgY2hyb21hX21lPTEgdHJlbGxpcz0xIDh4OGRjdD0xIGNxbT0wIGRlYWR6\n",
       "b25lPTIxLDExIGZhc3RfcHNraXA9MSBjaHJvbWFfcXBfb2Zmc2V0PS0yIHRocmVhZHM9OSBsb29r\n",
       "YWhlYWRfdGhyZWFkcz0xIHNsaWNlZF90aHJlYWRzPTAgbnI9MCBkZWNpbWF0ZT0xIGludGVybGFj\n",
       "ZWQ9MCBibHVyYXlfY29tcGF0PTAgY29uc3RyYWluZWRfaW50cmE9MCBiZnJhbWVzPTMgYl9weXJh\n",
       "bWlkPTIgYl9hZGFwdD0xIGJfYmlhcz0wIGRpcmVjdD0xIHdlaWdodGI9MSBvcGVuX2dvcD0wIHdl\n",
       "aWdodHA9MiBrZXlpbnQ9MjUwIGtleWludF9taW49MjUgc2NlbmVjdXQ9NDAgaW50cmFfcmVmcmVz\n",
       "aD0wIHJjX2xvb2thaGVhZD00MCByYz1jcmYgbWJ0cmVlPTEgY3JmPTIzLjAgcWNvbXA9MC42MCBx\n",
       "cG1pbj0wIHFwbWF4PTY5IHFwc3RlcD00IGlwX3JhdGlvPTEuNDAgYXE9MToxLjAwAIAAAAebZYiE\n",
       "ADP//vbsvgU1/Z/QlxEsxdpKcD4qpICAdzTAAAADAAB4HShe6DhKq9DAABt7rloQYe24gGTdwan/\n",
       "Tv4SW6y+4jjZ9EpxjfRhpp6nkOFb2EXtGnMVrpzTNYDxxYpXWbrF1kQW0RTPGEfb8mQpfK4Y1m76\n",
       "+L8Gi3gqfhF/KqnLk7n83WILlI3n4N4tg36KBNuZxJwBvxq1BfZS+G0GdxH3hYfH8cHBtjemMzwO\n",
       "sBLoG86tajAujq6g9fs/BiPUx6ha0DljlpFx+Atdkw3FGBmpXVJ6eo6lqIyBm9phgmAYEtgLATP+\n",
       "GMt3RdbOYNSX26EMyeA1F8dDNutom5DxD49RW2DdISOZ/xFv04GfnK0eI67Oe9UC28Z4L6t4nJzN\n",
       "T6QnwzZek6SFY3lRVi2RrM+1Q2Ssq00euhSknV6Dr/jxQgxs1XvN4OtQxLVR7J8bdtepNOocxs2R\n",
       "8sB8mebiWZA+6fZUrvXHomzz/vtSgFVyr+f27rgFZnRsYIe9j+vaYhFDaHM3TbfLX+rXaLTAhPTd\n",
       "41jPBdRUstNULrR4NW6hRi5F9Pye2LRNyL0503zy3yo5PFlAylBjiJeS9mWoNUAqI4LQnjPJLH7i\n",
       "zkQ5FIu3BlS0VXJ+vH5rBk+9CIccfHqHPfa+Cj3XzF2xIVv2CEZUiZC5FcEUvRPwPsqzJcVhCILS\n",
       "R7kz6fOmA1kG9Nzcx1Pgj5Pg5efw+jwQnjbVQi8KpvhifDg6/MesUYX1nv3ZOZIsOzZwTv/ItHc2\n",
       "JNh5c+x7SDHshxxjDeefijOgB5gXIRsG7DWrht5cX0GMl65HzIV+zhD4MMBOMu113fY+DXwuOTaf\n",
       "vZ9s4aApqGT2njy/l9AVAna3r3qATCw9fFp5bSyN0zzK+8x0b4R+AAgZnj/dfeMwM38XcnKJ1DH+\n",
       "+x9mgGv9GQ2QVH5KmuBob7j3cAsSJS9CRh40fFJj4kGkqndM0hQM+/5MhpuUpaidvjQHXTcmcICV\n",
       "qHvEhM/Iuik3Qot20Vbeqgj+OpEt7DB/LMLiN4FBnKlT7ca7wuHAen9XEF9e9PUo8uOg22Lyd5rB\n",
       "luQRGCLgBMTetz0jU6OrxPZTfx4KY9aeS00G+I/iQcX9HR+uHCe3cVYTs/Awkz8bzBDykshzS//O\n",
       "WBXz57hfeXMrsyx5ZzWq9noDz2R7C4JAwrpu35cRY5QQ6mSqMCQk4uykyAV16y/jOkkH6maZVh6g\n",
       "83DHOzr4+/avA+T4NhU7AT0mjzF2S14OwRxt1jFc64ZY5wbAq58UAFrTeK9CLyF6Nr9cuiBBNqEO\n",
       "dKMBuSRa0oa1RaYdiy/KoLTN3l1TlRPNsyBr0/Ds2o/uUG/6XKzyhtDT8scSgpvP/WqR7LDd0Mdc\n",
       "Kzh7C17ifO35t3L6+Xz8pKN7CTuk+9x97YHbYxA5jkn0OS6GP1kew40PvbTgp/mcxmklBLvxbIkQ\n",
       "JP0wcdF0+HxAmCuyOUAyNCPCJcQ+K+XdL/YuT4mg/UGIJDko3JDwn8w+l8wk7ru0MV5EuUGEGfJR\n",
       "AlLR7ezYMjus2LfvZtQU+6ig9MV2TDXHohwC/sKRwQKd/ZBIdtdTmz6O8ftJxBUdig51u/8HRLUp\n",
       "nxJ4uKn+ys8TdzZ22twxvu4p4SUl8uLSu1DAin4HXBRRY/55IFhRLp74XQcKqT9ZoRewZ6eGa/kq\n",
       "ppHGvt/nVa3J8QKj2UmCh0ar9lgso9Cr/v84FLFd61QZ3kv0A1Dqoc+AJkP3ujv/sVfQYcyspwHx\n",
       "35zh6aSDGyaPj+yE3U/Gg3ek65a/6IHb8fpTZCNU3wB9Q+BvcJqWto5EheA0pO9GFVth+Cywreo8\n",
       "Q2PYHp4ec9NPwpo+HHA9+GGi60/eVyGW5eb9S7OtnSd/Qp50o2fjM4rZ0LLoMWZsAE3fUZ5C99R/\n",
       "zV4FY3toI6hjvCYWh8cJcL892PiIhBqyLNZOMrSdqB2G5kJxSkD6Y6TMn4qv+enKijGKh/0ioMuw\n",
       "p26QxZFr1EHhpXl6d2QEM3s1n7AbfOm7E+PQ9CwJkXz/AGPL5O6pm49R+yok3R7uicouOh5wL+2K\n",
       "2K9JM6FSsv/wtY2ry98fy/4IWP8LuZA6mGZcobAZzQZsc52mq5sG3W/uApOICkf0LaK3bcfOV1Pt\n",
       "+98ervC/iGwEHVCLeRgeW0JUys9P3qNQRyhnEX06fdu3htupXe2M84yT2C1hc2SqwM5XQDEfjBaE\n",
       "P62ML96NEfPuRy0lD3jcySP+RK0suFoIR0lZZ/Y9A+/kDDG8b2hqLJswOOBO0zbchx15jeRerh5q\n",
       "XCMrpVyDP86iSFXrv99vJqR2peRm3WzVtK1pinj1zZ1JS59hP97GctmJ4Ckn+Z+B4c81QUJ0jagC\n",
       "TS5hpBttIdTret7vRKSCrN/Lyk51LAg96wyusGhJyAp6jj4rNe3T91L+Z3cb6IOW+Xl2t1zlkHec\n",
       "2PcA63Co7e407Octbg/QQtFWjMz9c3cOh4b2UMXkiJGGwgiiZ5wpyKYC68ab2cxN4xXHCecXFYO0\n",
       "ygOH+zjBBjWc8M5WDYFWK36b92Ez7QoHyGziDLugGMBhHO1PyJTjL73yHgqJPg0VWOlWQVtkgqCR\n",
       "ANnSnYXJAAAAfEGaJGxDP/6eEAMLxuIigqgdL0HoWi3XDwrJYV6i4eHhZPphKJeBGr0b3hC51ugN\n",
       "PNz9UDXPSAibIi9GniYCxdQwXmSfWrw53aOyL/mqmA1R8KU9Z4wX5Fea+cQ7a7S/Jzfa/0DMVtZv\n",
       "pErpGKirmLdGVHfMX/hcjRCf9KAAAAAVQZ5CeIR/AHFBMGUIHfd7ho6IImyhAAAADgGeYXRH/wAM\n",
       "3hWsIViBAAAACwGeY2pH/wAAAwO7AAAAO0GaaEmoQWiZTAhn//6eEAVAMrgCHaP6ftRFjlfISqDh\n",
       "+Hj86UyLmvdKa6l4v+IZ4mil235Wm0PlgT9xAAAADUGehkURLCP/AAADAl8AAAALAZ6ldEf/AAAD\n",
       "A7sAAAAMAZ6nakf/AAGl+0e+AAAAP0GarEmoQWyZTAhn//6eEAVAP44ArfLTPMTpeFkASQht0tkW\n",
       "2+ciH6vGxa8iGClj5/4dQJfetAR94BLGnqC3gAAAAA1BnspFFSwj/wAAAwJfAAAACwGe6XRH/wAA\n",
       "AwO6AAAACwGe62pH/wAAAwO6AAAAW0Ga8EmoQWyZTAhn//6eEAVAQaUAR59aPeoHZBccXNYUxPxZ\n",
       "sD/d/CR1mrisLK+tqWsK0pGx36sXj3/q9be/7dTnh5JlIxQZU8yUNc6yAa/Iv79FxCQMrs+V+FkA\n",
       "AAAZQZ8ORRUsI/8BsCa04/C4Bhw3Amlx6LAiYQAAAA0Bny10R/8CsCk2uAEjAAAAGgGfL2pH/wFa\n",
       "zjACxyyhEU6kXisUegUXgNSAAAAAY0GbNEmoQWyZTAhn//6eEAKdvJOwCxPdk8x0s4QixM8F/Eaz\n",
       "XUfTHfLEeDwYBP/6pYjv+7hbHqWfGESCmMch1mIdVFPnOiLVmYBfev4KiPcY9FJ+oKtf4c+wUqqs\n",
       "XJ5msutK5gAAACNBn1JFFSwj/wDYIlRgCt4yrAHYYLEh8Ncc2sC0NwENlgCigQAAABUBn3F0R/8B\n",
       "WO6w8AK3RFQfs/WYAkYAAAALAZ9zakf/AAADA7oAAABUQZt4SahBbJlMCGf//p4QAp2NxwDRkPmA\n",
       "rsCW1drOP8zsfejofTzxAw4TgphV/jERiq81dfKOkI6/+H9Akidz6o+s/mkxKLmOGBI1ypZS+Z1C\n",
       "Q4N1AAAAHEGflkUVLCP/ANi3vAFVIiA4jL3A1ZkZ5fUAf4AAAAALAZ+1dEf/AAADA7sAAAAMAZ+3\n",
       "akf/AVBQAgMHAAAAdkGbvEmoQWyZTAhn//6eEAKdjccBQTeCp8Efne8YK9cGDioG48v26kRyyv4R\n",
       "1KZ4MV8BLMCOGmhlvNaDaOfwjPyCr/6vpaPHqWu+ArRk8RMvjgGtjirazFpivp3+EfIz+/Db1MsD\n",
       "80uXz3nWDD+jFCG10IiTHpAAAAAZQZ/aRRUsI/8A2BspADjtFOPmGxr4M9AkYQAAAAsBn/l0R/8A\n",
       "AAMDugAAAA4Bn/tqR/8ArRAUOHgakQAAAHBBm+BJqEFsmUwIZ//+nhABYcT1B5u/ba/WXkyAbjRS\n",
       "xfXURDDPhXzsdesIS/s+5QhwKjEREZq5+fprXB4nbKcQbkpNUMAt6qCTM94TR0VngkkKBC1xP1XL\n",
       "M7PgWL8bZc89eKclm5sGMP3UZJZSfkmBAAAAFkGeHkUVLCP/AGxtxQBwWHcYmobYBRQAAAAMAZ49\n",
       "dEf/AKgLkUG1AAAACwGeP2pH/wAAAwO7AAAAV0GaJEmoQWyZTAhn//6eEAFhxPUHoYYRlYfZuW2o\n",
       "VBSenBY59OAdQ7eXuqavl5mwdJ0sdZMD/N1LrhbBdZaps7wnopgT0tqgTl1zePg157COImSE8bq9\n",
       "1gAAAA1BnkJFFSwj/wAAAwJfAAAACwGeYXRH/wAAAwO6AAAACwGeY2pH/wAAAwO7AAAAV0GaaEmo\n",
       "QWyZTAhn//6eEAFhxPUHm778YdD6MxvIgIxFACb0Lb1gF7got43NeEbhdkS0XZxddTJ1FjdlvIFy\n",
       "/YUb60Usr22BEUUXsLKZk95t7P5RX1vTwQAAAA1BnoZFFSwj/wAAAwJfAAAACwGepXRH/wAAAwO7\n",
       "AAAADAGep2pH/wCsqAEC8gAAAExBmqxJqEFsmUwIZ//+nhABYcT1B6GGDeT0zgl9JsHiQk7BAJDr\n",
       "thbCaN8d8xp9S2qEG+2rzClCqIDApPmGM445qVRkSVY33ZSgB2SWAAAAEEGeykUVLCP/AGwKbyUA\n",
       "VMEAAAALAZ7pdEf/AAADA7oAAAAPAZ7rakf/AFWrnoyfRBeQAAAATEGa8EmoQWyZTAhn//6eEAFh\n",
       "xPUHm5QYjnJZnz2NZClPFNGiAzvpDsmwkSOJsBFk5EBX/IIe9P2brcEf7eOgeMAmL/oz9bv9HXLC\n",
       "VmEAAAANQZ8ORRUsI/8AAAMCXwAAAA0Bny10R/8AVoqvRBeRAAAACwGfL2pH/wAAAwO6AAAAUEGb\n",
       "NEmoQWyZTAhn//6eEAFhxPUHoVwZCmHkaVRN7V9UkPI91uWiUGgMDLpnUURCess5MCrZxYgxA8Cm\n",
       "ym+xsQfVGkTaaTYDWlz247/xgz++AAAADUGfUkUVLCP/AAADAl8AAAAMAZ9xdEf/AFZFyKGrAAAA\n",
       "DAGfc2pH/wBWVACC8gAAAEBBm3hJqEFsmUwIZ//+nhABYcT1B5uUGQKZZdhIBynewr+DU9RERc4D\n",
       "NtcccbpRBEAyeLxerV9PCwqUw460CTsxAAAADkGflkUVLCP/ADYFOqE7AAAADAGftXRH/wBWRcih\n",
       "qwAAAAsBn7dqR/8AAAMDuwAAAEdBm7xJqEFsmUwIZ//+nhABYcT1B6FcGQpnwTIv3RiSby7d3vGR\n",
       "l69N2Ezw8BUL4OvskcQilFEAGQtrlPg+fn1MguoVfGCoewAAAA5Bn9pFFSwj/wA2BTqhOwAAAAwB\n",
       "n/l0R/8AVkXIoasAAAALAZ/7akf/AAADA7sAAAA8QZvgSahBbJlMCGf//p4QAWHE9Qebkx2SEVHt\n",
       "fpzuhEKEldQSJ6a1wA0Jm6NgowBr/dQJCX7/N8oi3nqhAAAADkGeHkUVLCP/ABsCnVE7AAAACwGe\n",
       "PXRH/wAAAwO6AAAACwGeP2pH/wAAAwO7AAAAPEGaJEmoQWyZTAhn//6eEAFhxPUHoVsYA72+yAy+\n",
       "wQwgYd/uM/HFh5ONXAmfNl9/WYst2RSd8ac/L2jBUAAAAA1BnkJFFSwj/wAAAwJfAAAACwGeYXRH\n",
       "/wAAAwO6AAAACwGeY2pH/wAAAwO7AAAAN0GaaEmoQWyZTAhn//6eEAFhxPUHm5MYA8kipgLZ9hcF\n",
       "PQ9+3xA1PP7ulO1awLY00V/pPy9u3VEAAAANQZ6GRRUsI/8AAAMCXwAAAAsBnqV0R/8AAAMDuwAA\n",
       "AAsBnqdqR/8AAAMDugAAAEFBmqxJqEFsmUwIZ//+nhABYcT1B6FanAVmVxRed3o3EmUoNmwiLlXM\n",
       "zm7+031johtH8fCa+kQYuStKqjJOFcg0YAAAAA5BnspFFSwj/wANMU6pRQAAAAsBnul0R/8AAAMD\n",
       "ugAAAAsBnutqR/8AAAMDugAAAC9BmvBJqEFsmUwIZ//+nhAAKNh1wU/sBnrm2h0wKg0RTASpRe//\n",
       "Ncv2zNUmreVmkQAAAA1Bnw5FFSwj/wAAAwJfAAAACwGfLXRH/wAAAwO7AAAACwGfL2pH/wAAAwO6\n",
       "AAAAJkGbNEmoQWyZTAhn//6eEAAo2HXBT31qLlH83TgGXILdz94OLw3AAAAADUGfUkUVLCP/AAAD\n",
       "Al8AAAALAZ9xdEf/AAADA7oAAAALAZ9zakf/AAADA7oAAAA/QZt4SahBbJlMCGf//p4QACjYdcDB\n",
       "vrFoPQbI030Nt1TbSa5vCilEuaIyzcZkghf9WrmbmZXh8l9wvl6sdbshAAAADUGflkUVLCP/AAAD\n",
       "Al4AAAALAZ+1dEf/AAADA7sAAAALAZ+3akf/AAADA7sAAAArQZu8SahBbJlMCF///oywABSd7yAM\n",
       "XKe9/uGEUfuHPcEVl63Zt58QEhvqQAAAAA1Bn9pFFSwj/wAAAwJfAAAACwGf+XRH/wAAAwO6AAAA\n",
       "CwGf+2pH/wAAAwO7AAAAJUGb4EmoQWyZTAhf//6MsAAUnfj8Aenox00ISvT3vDz+wD4CDb8AAAAN\n",
       "QZ4eRRUsI/8AAAMCXgAAAAsBnj10R/8AAAMDugAAAAsBnj9qR/8AAAMDuwAAACRBmiRJqEFsmUwI\n",
       "X//+jLAAFJZkx+mwFCojlZcgQJfC6cgYz4AAAAANQZ5CRRUsI/8AAAMCXwAAAAsBnmF0R/8AAAMD\n",
       "ugAAAAsBnmNqR/8AAAMDuwAAABtBmmhJqEFsmUwIV//+OEAAJ7XrACPWQwJECkcAAAANQZ6GRRUs\n",
       "I/8AAAMCXwAAAAsBnqV0R/8AAAMDuwAAAAsBnqdqR/8AAAMDugAAACFBmqxJqEFsmUwIR//94QAA\n",
       "moNcoA2+qWkD+Ew2IfJecYEAAAANQZ7KRRUsI/8AAAMCXwAAAAsBnul0R/8AAAMDugAAAAwBnutq\n",
       "R/8ABUFACwYAAAASQZrtSahBbJlMCP/8hAAAAwGzAAAIVm1vb3YAAABsbXZoZAAAAAAAAAAAAAAA\n",
       "AAAAA+gAAAiYAAEAAAEAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAA\n",
       "QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAeAdHJhawAAAFx0a2hkAAAAAwAAAAAA\n",
       "AAAAAAAAAQAAAAAAAAiYAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAA\n",
       "AAAAAAAAQAAAAAGwAAABIAAAAAAAJGVkdHMAAAAcZWxzdAAAAAAAAAABAAAImAAAAgAAAQAAAAAG\n",
       "+G1kaWEAAAAgbWRoZAAAAAAAAAAAAAAAAAAAMgAAAG4AVcQAAAAAAC1oZGxyAAAAAAAAAAB2aWRl\n",
       "AAAAAAAAAAAAAAAAVmlkZW9IYW5kbGVyAAAABqNtaW5mAAAAFHZtaGQAAAABAAAAAAAAAAAAAAAk\n",
       "ZGluZgAAABxkcmVmAAAAAAAAAAEAAAAMdXJsIAAAAAEAAAZjc3RibAAAALNzdHNkAAAAAAAAAAEA\n",
       "AACjYXZjMQAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAGwASAASAAAAEgAAAAAAAAAAQAAAAAAAAAA\n",
       "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABj//wAAADFhdmNDAWQAHv/hABhnZAAerNlBsJaEAAAD\n",
       "AAQAAAMBkDxYtlgBAAZo6+PLIsAAAAAcdXVpZGtoQPJfJE/FujmlG88DI/MAAAAAAAAAGHN0dHMA\n",
       "AAAAAAAAAQAAAG4AAAEAAAAAFHN0c3MAAAAAAAAAAQAAAAEAAAOAY3R0cwAAAAAAAABuAAAAAQAA\n",
       "AgAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAA\n",
       "AAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIA\n",
       "AAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAA\n",
       "AAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAA\n",
       "AAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAA\n",
       "AQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAAB\n",
       "AAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEA\n",
       "AAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAA\n",
       "BQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAAB\n",
       "AAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAA\n",
       "AAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAA\n",
       "AAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAA\n",
       "AAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAA\n",
       "AQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAAB\n",
       "AAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEA\n",
       "AAAAAAAAAQAAAQAAAAABAAACAAAAABxzdHNjAAAAAAAAAAEAAAABAAAAbgAAAAEAAAHMc3RzegAA\n",
       "AAAAAAAAAAAAbgAAClEAAACAAAAAGQAAABIAAAAPAAAAPwAAABEAAAAPAAAAEAAAAEMAAAARAAAA\n",
       "DwAAAA8AAABfAAAAHQAAABEAAAAeAAAAZwAAACcAAAAZAAAADwAAAFgAAAAgAAAADwAAABAAAAB6\n",
       "AAAAHQAAAA8AAAASAAAAdAAAABoAAAAQAAAADwAAAFsAAAARAAAADwAAAA8AAABbAAAAEQAAAA8A\n",
       "AAAQAAAAUAAAABQAAAAPAAAAEwAAAFAAAAARAAAAEQAAAA8AAABUAAAAEQAAABAAAAAQAAAARAAA\n",
       "ABIAAAAQAAAADwAAAEsAAAASAAAAEAAAAA8AAABAAAAAEgAAAA8AAAAPAAAAQAAAABEAAAAPAAAA\n",
       "DwAAADsAAAARAAAADwAAAA8AAABFAAAAEgAAAA8AAAAPAAAAMwAAABEAAAAPAAAADwAAACoAAAAR\n",
       "AAAADwAAAA8AAABDAAAAEQAAAA8AAAAPAAAALwAAABEAAAAPAAAADwAAACkAAAARAAAADwAAAA8A\n",
       "AAAoAAAAEQAAAA8AAAAPAAAAHwAAABEAAAAPAAAADwAAACUAAAARAAAADwAAABAAAAAWAAAAFHN0\n",
       "Y28AAAAAAAAAAQAAACwAAABidWR0YQAAAFptZXRhAAAAAAAAACFoZGxyAAAAAAAAAABtZGlyYXBw\n",
       "bAAAAAAAAAAAAAAAAC1pbHN0AAAAJal0b28AAAAdZGF0YQAAAAEAAAAATGF2ZjU4LjIwLjEwMA==\n",
       "\">\n",
       "  Your browser does not support the video tag.\n",
       "</video>"
      ],
      "text/plain": [
       "<matplotlib.animation.FuncAnimation at 0x1356e0358>"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rc('animation', html='html5')\n",
    "anim"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}