skimage_test.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from scipy.interpolate import RectBivariateSpline\n",
    "from skimage._shared.utils import _supported_float_type\n",
    "from skimage.util import img_as_float\n",
    "from skimage.filters import sobel\n",
    "\n",
    "\n",
    "def active_contour(\n",
    "    image,\n",
    "    snake,\n",
    "    alpha=0.01,\n",
    "    beta=0.1,\n",
    "    w_line=0,\n",
    "    w_edge=1,\n",
    "    gamma=0.01,\n",
    "    max_px_move=1.0,\n",
    "    max_num_iter=2500,\n",
    "    convergence=0.1,\n",
    "    *,\n",
    "    boundary_condition='periodic',\n",
    "):\n",
    "    \"\"\"Active contour model.\n",
    "\n",
    "    Active contours by fitting snakes to features of images. Supports single\n",
    "    and multichannel 2D images. Snakes can be periodic (for segmentation) or\n",
    "    have fixed and/or free ends.\n",
    "    The output snake has the same length as the input boundary.\n",
    "    As the number of points is constant, make sure that the initial snake\n",
    "    has enough points to capture the details of the final contour.\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    image : (M, N) or (M, N, 3) ndarray\n",
    "        Input image.\n",
    "    snake : (K, 2) ndarray\n",
    "        Initial snake coordinates. For periodic boundary conditions, endpoints\n",
    "        must not be duplicated.\n",
    "    alpha : float, optional\n",
    "        Snake length shape parameter. Higher values makes snake contract\n",
    "        faster.\n",
    "    beta : float, optional\n",
    "        Snake smoothness shape parameter. Higher values makes snake smoother.\n",
    "    w_line : float, optional\n",
    "        Controls attraction to brightness. Use negative values to attract\n",
    "        toward dark regions.\n",
    "    w_edge : float, optional\n",
    "        Controls attraction to edges. Use negative values to repel snake from\n",
    "        edges.\n",
    "    gamma : float, optional\n",
    "        Explicit time stepping parameter.\n",
    "    max_px_move : float, optional\n",
    "        Maximum pixel distance to move per iteration.\n",
    "    max_num_iter : int, optional\n",
    "        Maximum iterations to optimize snake shape.\n",
    "    convergence : float, optional\n",
    "        Convergence criteria.\n",
    "    boundary_condition : string, optional\n",
    "        Boundary conditions for the contour. Can be one of 'periodic',\n",
    "        'free', 'fixed', 'free-fixed', or 'fixed-free'. 'periodic' attaches\n",
    "        the two ends of the snake, 'fixed' holds the end-points in place,\n",
    "        and 'free' allows free movement of the ends. 'fixed' and 'free' can\n",
    "        be combined by parsing 'fixed-free', 'free-fixed'. Parsing\n",
    "        'fixed-fixed' or 'free-free' yields same behaviour as 'fixed' and\n",
    "        'free', respectively.\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    snake : (K, 2) ndarray\n",
    "        Optimised snake, same shape as input parameter.\n",
    "\n",
    "    References\n",
    "    ----------\n",
    "    .. [1]  Kass, M.; Witkin, A.; Terzopoulos, D. \"Snakes: Active contour\n",
    "            models\". International Journal of Computer Vision 1 (4): 321\n",
    "            (1988). :DOI:`10.1007/BF00133570`\n",
    "\n",
    "    Examples\n",
    "    --------\n",
    "    >>> from skimage.draw import circle_perimeter\n",
    "    >>> from skimage.filters import gaussian\n",
    "\n",
    "    Create and smooth image:\n",
    "\n",
    "    >>> img = np.zeros((100, 100))\n",
    "    >>> rr, cc = circle_perimeter(35, 45, 25)\n",
    "    >>> img[rr, cc] = 1\n",
    "    >>> img = gaussian(img, sigma=2, preserve_range=False)\n",
    "\n",
    "    Initialize spline:\n",
    "\n",
    "    >>> s = np.linspace(0, 2*np.pi, 100)\n",
    "    >>> init = 50 * np.array([np.sin(s), np.cos(s)]).T + 50\n",
    "\n",
    "    Fit spline to image:\n",
    "\n",
    "    >>> snake = active_contour(img, init, w_edge=0, w_line=1)  # doctest: +SKIP\n",
    "    >>> dist = np.sqrt((45-snake[:, 0])**2 + (35-snake[:, 1])**2)  # doctest: +SKIP\n",
    "    >>> int(np.mean(dist))  # doctest: +SKIP\n",
    "    25\n",
    "\n",
    "    \"\"\"\n",
    "    max_num_iter = int(max_num_iter)\n",
    "    if max_num_iter <= 0:\n",
    "        raise ValueError(\"max_num_iter should be >0.\")\n",
    "    convergence_order = 10\n",
    "    valid_bcs = [\n",
    "        'periodic',\n",
    "        'free',\n",
    "        'fixed',\n",
    "        'free-fixed',\n",
    "        'fixed-free',\n",
    "        'fixed-fixed',\n",
    "        'free-free',\n",
    "    ]\n",
    "    if boundary_condition not in valid_bcs:\n",
    "        raise ValueError(\n",
    "            \"Invalid boundary condition.\\n\"\n",
    "            + \"Should be one of: \"\n",
    "            + \", \".join(valid_bcs)\n",
    "            + '.'\n",
    "        )\n",
    "\n",
    "    img = img_as_float(image)\n",
    "    float_dtype = _supported_float_type(image.dtype)\n",
    "    img = img.astype(float_dtype, copy=False)\n",
    "\n",
    "    RGB = img.ndim == 3\n",
    "\n",
    "    # Find edges using sobel:\n",
    "    if w_edge != 0:\n",
    "        if RGB:\n",
    "            edge = [sobel(img[:, :, 0]), sobel(img[:, :, 1]), sobel(img[:, :, 2])]\n",
    "        else:\n",
    "            edge = [sobel(img)]\n",
    "    else:\n",
    "        edge = [0]\n",
    "\n",
    "    # Superimpose intensity and edge images:\n",
    "    if RGB:\n",
    "        img = w_line * np.sum(img, axis=2) + w_edge * sum(edge)\n",
    "    else:\n",
    "        img = w_line * img + w_edge * edge[0]\n",
    "\n",
    "    # Interpolate for smoothness:\n",
    "    intp = RectBivariateSpline(\n",
    "        np.arange(img.shape[1]), np.arange(img.shape[0]), img.T, kx=2, ky=2, s=0\n",
    "    )\n",
    "\n",
    "    snake_xy = snake[:, ::-1]\n",
    "    x = snake_xy[:, 0].astype(float_dtype)\n",
    "    y = snake_xy[:, 1].astype(float_dtype)\n",
    "    n = len(x)\n",
    "    xsave = np.empty((convergence_order, n), dtype=float_dtype)\n",
    "    ysave = np.empty((convergence_order, n), dtype=float_dtype)\n",
    "\n",
    "    # Build snake shape matrix for Euler equation in double precision\n",
    "    eye_n = np.eye(n, dtype=float)\n",
    "    a = (\n",
    "        np.roll(eye_n, -1, axis=0) + np.roll(eye_n, -1, axis=1) - 2 * eye_n\n",
    "    )  # second order derivative, central difference\n",
    "    b = (\n",
    "        np.roll(eye_n, -2, axis=0)\n",
    "        + np.roll(eye_n, -2, axis=1)\n",
    "        - 4 * np.roll(eye_n, -1, axis=0)\n",
    "        - 4 * np.roll(eye_n, -1, axis=1)\n",
    "        + 6 * eye_n\n",
    "    )  # fourth order derivative, central difference\n",
    "    A = -alpha * a + beta * b\n",
    "\n",
    "    # Impose boundary conditions different from periodic:\n",
    "    sfixed = False\n",
    "    if boundary_condition.startswith('fixed'):\n",
    "        A[0, :] = 0\n",
    "        A[1, :] = 0\n",
    "        A[1, :3] = [1, -2, 1]\n",
    "        sfixed = True\n",
    "    efixed = False\n",
    "    if boundary_condition.endswith('fixed'):\n",
    "        A[-1, :] = 0\n",
    "        A[-2, :] = 0\n",
    "        A[-2, -3:] = [1, -2, 1]\n",
    "        efixed = True\n",
    "    sfree = False\n",
    "    if boundary_condition.startswith('free'):\n",
    "        A[0, :] = 0\n",
    "        A[0, :3] = [1, -2, 1]\n",
    "        A[1, :] = 0\n",
    "        A[1, :4] = [-1, 3, -3, 1]\n",
    "        sfree = True\n",
    "    efree = False\n",
    "    if boundary_condition.endswith('free'):\n",
    "        A[-1, :] = 0\n",
    "        A[-1, -3:] = [1, -2, 1]\n",
    "        A[-2, :] = 0\n",
    "        A[-2, -4:] = [-1, 3, -3, 1]\n",
    "        efree = True\n",
    "\n",
    "    # Only one inversion is needed for implicit spline energy minimization:\n",
    "    inv = np.linalg.inv(A + gamma * eye_n)\n",
    "    # can use float_dtype once we have computed the inverse in double precision\n",
    "    inv = inv.astype(float_dtype, copy=False)\n",
    "\n",
    "    ####### OURS #######\n",
    "    energies = np.zeros((max_num_iter, 3), dtype=float_dtype)\n",
    "\n",
    "\n",
    "    # Explicit time stepping for image energy minimization:\n",
    "    for i in range(max_num_iter):\n",
    "        # RectBivariateSpline always returns float64, so call astype here\n",
    "        fx = intp(x, y, dx=1, grid=False).astype(float_dtype, copy=False)\n",
    "        fy = intp(x, y, dy=1, grid=False).astype(float_dtype, copy=False)\n",
    "\n",
    "        if sfixed:\n",
    "            fx[0] = 0\n",
    "            fy[0] = 0\n",
    "        if efixed:\n",
    "            fx[-1] = 0\n",
    "            fy[-1] = 0\n",
    "        if sfree:\n",
    "            fx[0] *= 2\n",
    "            fy[0] *= 2\n",
    "        if efree:\n",
    "            fx[-1] *= 2\n",
    "            fy[-1] *= 2\n",
    "        xn = inv @ (gamma * x + fx)\n",
    "        yn = inv @ (gamma * y + fy)\n",
    "\n",
    "        # Movements are capped to max_px_move per iteration:\n",
    "        dx = max_px_move * np.tanh(xn - x)\n",
    "        dy = max_px_move * np.tanh(yn - y)\n",
    "        if sfixed:\n",
    "            dx[0] = 0\n",
    "            dy[0] = 0\n",
    "        if efixed:\n",
    "            dx[-1] = 0\n",
    "            dy[-1] = 0\n",
    "        x += dx\n",
    "        y += dy\n",
    "\n",
    "\n",
    "        ######## OURS #######\n",
    "        shape_energy = x @ (A @ x) + y @ (A @ y)\n",
    "        image_energy = np.sum(intp(x, y, grid=False))\n",
    "        total_energy = shape_energy + image_energy\n",
    "\n",
    "        energies[i, 0] = shape_energy\n",
    "        energies[i, 1] = image_energy\n",
    "        energies[i, 2] = total_energy\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "        # Convergence criteria needs to compare to a number of previous\n",
    "        # configurations since oscillations can occur.\n",
    "        j = i % (convergence_order + 1)\n",
    "        if j < convergence_order:\n",
    "            xsave[j, :] = x\n",
    "            ysave[j, :] = y\n",
    "        else:\n",
    "            dist = np.min(\n",
    "                np.max(np.abs(xsave - x[None, :]) + np.abs(ysave - y[None, :]), 1)\n",
    "            )\n",
    "            if dist < convergence:\n",
    "                break\n",
    "\n",
    "    energies = energies[: i + 1]\n",
    "\n",
    "    return np.stack([y, x], axis=1), energies"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_energies(energies):\n",
    "    \"\"\"\n",
    "    Plot the shape, image, and total energies over the iterations.\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    energies : (num_iterations, 3) ndarray\n",
    "        2D array where\n",
    "        - energies[:, 0] = shape_energy\n",
    "        - energies[:, 1] = image_energy\n",
    "        - energies[:, 2] = total_energy\n",
    "    \"\"\"\n",
    "    plt.figure(figsize=(8, 6))\n",
    "    plt.plot(energies[:, 0], label='Shape Energy')\n",
    "    plt.plot(energies[:, 1], label='Image Energy')\n",
    "    plt.plot(energies[:, 2], label='Total Energy')\n",
    "\n",
    "    plt.xlabel('Iteration')\n",
    "    plt.ylabel('Energy')\n",
    "    plt.title('Evolution of Energies')\n",
    "    plt.legend()\n",
    "    plt.grid(True)\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_energies_specific(energies, iteration_range):\n",
    "    \"\"\"\n",
    "    Plot the shape, image, and total energies over the iterations.\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    energies : (num_iterations, 3) ndarray\n",
    "        2D array where\n",
    "        - energies[:, 0] = shape_energy\n",
    "        - energies[:, 1] = image_energy\n",
    "        - energies[:, 2] = total_energy\n",
    "    \"\"\"\n",
    "    import matplotlib.pyplot as plt\n",
    "\n",
    "    lower = iteration_range[0]\n",
    "    upper = iteration_range[1]\n",
    "\n",
    "    plt.figure(figsize=(8, 6))\n",
    "    plt.plot(range(lower, upper), energies[lower:upper, 0], label='Shape Energy')\n",
    "    plt.plot(range(lower, upper), energies[lower:upper, 1], label='Image Energy')\n",
    "    plt.plot(range(lower, upper), energies[lower:upper, 2], label='Total Energy')\n",
    "\n",
    "    plt.xlabel('Iteration')\n",
    "    plt.ylabel('Energy')\n",
    "    plt.title('Evolution of Energies')\n",
    "    plt.legend()\n",
    "    plt.grid(True)\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.image as mpimg\n",
    "\n",
    "simple_image = mpimg.imread('simple_image.png')\n",
    "simple_image = simple_image[:, :, 0]  # remove unnecessary coordinates\n",
    "\n",
    "simple_points = np.load('simple_points.npy')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def interpolate_user_points(user_points, min_points=1, max_points=5):\n",
    "    new_points = []\n",
    "    for i in range(len(user_points) - 1):\n",
    "        start_point = user_points[i]\n",
    "        end_point = user_points[i + 1]\n",
    "        distance = np.linalg.norm(end_point - start_point)\n",
    "        num_points = int(np.clip(distance / 10, min_points, max_points))\n",
    "        \n",
    "        x = np.linspace(start_point[0], end_point[0], num_points)\n",
    "        y = np.linspace(start_point[1], end_point[1], num_points)\n",
    "        \n",
    "        new_points.extend(np.vstack((x, y)).T)\n",
    "    \n",
    "    return np.array(new_points)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "points = interpolate_user_points(simple_points, min_points=5, max_points=20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.imshow(simple_image, cmap='gray')\n",
    "plt.plot(points[:, 0], points[:, 1], 'r-')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "<link rel=\"stylesheet\"\n",
       "href=\"https://maxcdn.bootstrapcdn.com/font-awesome/4.4.0/css/font-awesome.min.css\">\n",
       "<script language=\"javascript\">\n",
       "  function isInternetExplorer() {\n",
       "    ua = navigator.userAgent;\n",
       "    /* MSIE used to detect old browsers and Trident used to newer ones*/\n",
       "    return ua.indexOf(\"MSIE \") > -1 || ua.indexOf(\"Trident/\") > -1;\n",
       "  }\n",
       "\n",
       "  /* Define the Animation class */\n",
       "  function Animation(frames, img_id, slider_id, interval, loop_select_id){\n",
       "    this.img_id = img_id;\n",
       "    this.slider_id = slider_id;\n",
       "    this.loop_select_id = loop_select_id;\n",
       "    this.interval = interval;\n",
       "    this.current_frame = 0;\n",
       "    this.direction = 0;\n",
       "    this.timer = null;\n",
       "    this.frames = new Array(frames.length);\n",
       "\n",
       "    for (var i=0; i<frames.length; i++)\n",
       "    {\n",
       "     this.frames[i] = new Image();\n",
       "     this.frames[i].src = frames[i];\n",
       "    }\n",
       "    var slider = document.getElementById(this.slider_id);\n",
       "    slider.max = this.frames.length - 1;\n",
       "    if (isInternetExplorer()) {\n",
       "        // switch from oninput to onchange because IE <= 11 does not conform\n",
       "        // with W3C specification. It ignores oninput and onchange behaves\n",
       "        // like oninput. In contrast, Microsoft Edge behaves correctly.\n",
       "        slider.setAttribute('onchange', slider.getAttribute('oninput'));\n",
       "        slider.setAttribute('oninput', null);\n",
       "    }\n",
       "    this.set_frame(this.current_frame);\n",
       "  }\n",
       "\n",
       "  Animation.prototype.get_loop_state = function(){\n",
       "    var button_group = document[this.loop_select_id].state;\n",
       "    for (var i = 0; i < button_group.length; i++) {\n",
       "        var button = button_group[i];\n",
       "        if (button.checked) {\n",
       "            return button.value;\n",
       "        }\n",
       "    }\n",
       "    return undefined;\n",
       "  }\n",
       "\n",
       "  Animation.prototype.set_frame = function(frame){\n",
       "    this.current_frame = frame;\n",
       "    document.getElementById(this.img_id).src =\n",
       "            this.frames[this.current_frame].src;\n",
       "    document.getElementById(this.slider_id).value = this.current_frame;\n",
       "  }\n",
       "\n",
       "  Animation.prototype.next_frame = function()\n",
       "  {\n",
       "    this.set_frame(Math.min(this.frames.length - 1, this.current_frame + 1));\n",
       "  }\n",
       "\n",
       "  Animation.prototype.previous_frame = function()\n",
       "  {\n",
       "    this.set_frame(Math.max(0, this.current_frame - 1));\n",
       "  }\n",
       "\n",
       "  Animation.prototype.first_frame = function()\n",
       "  {\n",
       "    this.set_frame(0);\n",
       "  }\n",
       "\n",
       "  Animation.prototype.last_frame = function()\n",
       "  {\n",
       "    this.set_frame(this.frames.length - 1);\n",
       "  }\n",
       "\n",
       "  Animation.prototype.slower = function()\n",
       "  {\n",
       "    this.interval /= 0.7;\n",
       "    if(this.direction > 0){this.play_animation();}\n",
       "    else if(this.direction < 0){this.reverse_animation();}\n",
       "  }\n",
       "\n",
       "  Animation.prototype.faster = function()\n",
       "  {\n",
       "    this.interval *= 0.7;\n",
       "    if(this.direction > 0){this.play_animation();}\n",
       "    else if(this.direction < 0){this.reverse_animation();}\n",
       "  }\n",
       "\n",
       "  Animation.prototype.anim_step_forward = function()\n",
       "  {\n",
       "    this.current_frame += 1;\n",
       "    if(this.current_frame < this.frames.length){\n",
       "      this.set_frame(this.current_frame);\n",
       "    }else{\n",
       "      var loop_state = this.get_loop_state();\n",
       "      if(loop_state == \"loop\"){\n",
       "        this.first_frame();\n",
       "      }else if(loop_state == \"reflect\"){\n",
       "        this.last_frame();\n",
       "        this.reverse_animation();\n",
       "      }else{\n",
       "        this.pause_animation();\n",
       "        this.last_frame();\n",
       "      }\n",
       "    }\n",
       "  }\n",
       "\n",
       "  Animation.prototype.anim_step_reverse = function()\n",
       "  {\n",
       "    this.current_frame -= 1;\n",
       "    if(this.current_frame >= 0){\n",
       "      this.set_frame(this.current_frame);\n",
       "    }else{\n",
       "      var loop_state = this.get_loop_state();\n",
       "      if(loop_state == \"loop\"){\n",
       "        this.last_frame();\n",
       "      }else if(loop_state == \"reflect\"){\n",
       "        this.first_frame();\n",
       "        this.play_animation();\n",
       "      }else{\n",
       "        this.pause_animation();\n",
       "        this.first_frame();\n",
       "      }\n",
       "    }\n",
       "  }\n",
       "\n",
       "  Animation.prototype.pause_animation = function()\n",
       "  {\n",
       "    this.direction = 0;\n",
       "    if (this.timer){\n",
       "      clearInterval(this.timer);\n",
       "      this.timer = null;\n",
       "    }\n",
       "  }\n",
       "\n",
       "  Animation.prototype.play_animation = function()\n",
       "  {\n",
       "    this.pause_animation();\n",
       "    this.direction = 1;\n",
       "    var t = this;\n",
       "    if (!this.timer) this.timer = setInterval(function() {\n",
       "        t.anim_step_forward();\n",
       "    }, this.interval);\n",
       "  }\n",
       "\n",
       "  Animation.prototype.reverse_animation = function()\n",
       "  {\n",
       "    this.pause_animation();\n",
       "    this.direction = -1;\n",
       "    var t = this;\n",
       "    if (!this.timer) this.timer = setInterval(function() {\n",
       "        t.anim_step_reverse();\n",
       "    }, this.interval);\n",
       "  }\n",
       "</script>\n",
       "\n",
       "<style>\n",
       ".animation {\n",
       "    display: inline-block;\n",
       "    text-align: center;\n",
       "}\n",
       "input[type=range].anim-slider {\n",
       "    width: 374px;\n",
       "    margin-left: auto;\n",
       "    margin-right: auto;\n",
       "}\n",
       ".anim-buttons {\n",
       "    margin: 8px 0px;\n",
       "}\n",
       ".anim-buttons button {\n",
       "    padding: 0;\n",
       "    width: 36px;\n",
       "}\n",
       ".anim-state label {\n",
       "    margin-right: 8px;\n",
       "}\n",
       ".anim-state input {\n",
       "    margin: 0;\n",
       "    vertical-align: middle;\n",
       "}\n",
       "</style>\n",
       "\n",
       "<div class=\"animation\">\n",
       "  <img id=\"_anim_imgc71c3bb1562e420e8fc6d46ad750245b\">\n",
       "  <div class=\"anim-controls\">\n",
       "    <input id=\"_anim_sliderc71c3bb1562e420e8fc6d46ad750245b\" type=\"range\" class=\"anim-slider\"\n",
       "           name=\"points\" min=\"0\" max=\"1\" step=\"1\" value=\"0\"\n",
       "           oninput=\"animc71c3bb1562e420e8fc6d46ad750245b.set_frame(parseInt(this.value));\">\n",
       "    <div class=\"anim-buttons\">\n",
       "      <button title=\"Decrease speed\" aria-label=\"Decrease speed\" onclick=\"animc71c3bb1562e420e8fc6d46ad750245b.slower()\">\n",
       "          <i class=\"fa fa-minus\"></i></button>\n",
       "      <button title=\"First frame\" aria-label=\"First frame\" onclick=\"animc71c3bb1562e420e8fc6d46ad750245b.first_frame()\">\n",
       "        <i class=\"fa fa-fast-backward\"></i></button>\n",
       "      <button title=\"Previous frame\" aria-label=\"Previous frame\" onclick=\"animc71c3bb1562e420e8fc6d46ad750245b.previous_frame()\">\n",
       "          <i class=\"fa fa-step-backward\"></i></button>\n",
       "      <button title=\"Play backwards\" aria-label=\"Play backwards\" onclick=\"animc71c3bb1562e420e8fc6d46ad750245b.reverse_animation()\">\n",
       "          <i class=\"fa fa-play fa-flip-horizontal\"></i></button>\n",
       "      <button title=\"Pause\" aria-label=\"Pause\" onclick=\"animc71c3bb1562e420e8fc6d46ad750245b.pause_animation()\">\n",
       "          <i class=\"fa fa-pause\"></i></button>\n",
       "      <button title=\"Play\" aria-label=\"Play\" onclick=\"animc71c3bb1562e420e8fc6d46ad750245b.play_animation()\">\n",
       "          <i class=\"fa fa-play\"></i></button>\n",
       "      <button title=\"Next frame\" aria-label=\"Next frame\" onclick=\"animc71c3bb1562e420e8fc6d46ad750245b.next_frame()\">\n",
       "          <i class=\"fa fa-step-forward\"></i></button>\n",
       "      <button title=\"Last frame\" aria-label=\"Last frame\" onclick=\"animc71c3bb1562e420e8fc6d46ad750245b.last_frame()\">\n",
       "          <i class=\"fa fa-fast-forward\"></i></button>\n",
       "      <button title=\"Increase speed\" aria-label=\"Increase speed\" onclick=\"animc71c3bb1562e420e8fc6d46ad750245b.faster()\">\n",
       "          <i class=\"fa fa-plus\"></i></button>\n",
       "    </div>\n",
       "    <form title=\"Repetition mode\" aria-label=\"Repetition mode\" action=\"#n\" name=\"_anim_loop_selectc71c3bb1562e420e8fc6d46ad750245b\"\n",
       "          class=\"anim-state\">\n",
       "      <input type=\"radio\" name=\"state\" value=\"once\" id=\"_anim_radio1_c71c3bb1562e420e8fc6d46ad750245b\"\n",
       "             >\n",
       "      <label for=\"_anim_radio1_c71c3bb1562e420e8fc6d46ad750245b\">Once</label>\n",
       "      <input type=\"radio\" name=\"state\" value=\"loop\" id=\"_anim_radio2_c71c3bb1562e420e8fc6d46ad750245b\"\n",
       "             checked>\n",
       "      <label for=\"_anim_radio2_c71c3bb1562e420e8fc6d46ad750245b\">Loop</label>\n",
       "      <input type=\"radio\" name=\"state\" value=\"reflect\" id=\"_anim_radio3_c71c3bb1562e420e8fc6d46ad750245b\"\n",
       "             >\n",
       "      <label for=\"_anim_radio3_c71c3bb1562e420e8fc6d46ad750245b\">Reflect</label>\n",
       "    </form>\n",
       "  </div>\n",
       "</div>\n",
       "\n",
       "\n",
       "<script language=\"javascript\">\n",
       "  /* Instantiate the Animation class. */\n",
       "  /* The IDs given should match those used in the template above. */\n",
       "  (function() {\n",
       "    var img_id = \"_anim_imgc71c3bb1562e420e8fc6d46ad750245b\";\n",
       "    var slider_id = \"_anim_sliderc71c3bb1562e420e8fc6d46ad750245b\";\n",
       "    var loop_select_id = \"_anim_loop_selectc71c3bb1562e420e8fc6d46ad750245b\";\n",
       "    var frames = new Array(49);\n",
       "    \n",
       "  frames[0] = \"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAoAAAAHgCAYAAAA10dzkAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90\\\n",
       "bGliIHZlcnNpb24zLjYuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy89olMNAAAACXBIWXMAAA9h\\\n",
       "AAAPYQGoP6dpAABgUklEQVR4nO3dd3hUxcIG8Hd76qYnm0ASIJTQq4Yg2IgiYkG4CIiKio0mRb2I\\\n",
       "Ba/lGi56bfcCtovYEMRPRBRBioBKABMIhBZ6QiCFAOnJJtmd74/jbnKyG2ra7nl/z7NP2JnZzRyz\\\n",
       "5ryZc2ZGJYQQICIiIiLFUDd3B4iIiIioaTEAEhERESkMAyARERGRwjAAEhERESkMAyARERGRwjAA\\\n",
       "EhERESkMAyARERGRwjAAEhERESkMAyARERGRwjAAEhERESkMAyARERGRwjAAEhERESkMAyARERGR\\\n",
       "wjAAEhERESkMAyARERGRwjAAEhERESkMAyARERGRwjAAEhERESkMAyARERGRwjAAEhERESkMAyAR\\\n",
       "ERGRwjAAEhERESkMAyARERGRwjAAEhERESkMAyARERGRwjAAEhERESkMAyARERGRwjAAEhERESkM\\\n",
       "AyARERGRwjAAEhERESkMAyARERGRwjAAEhERESkMAyARERGRwjAAEhERESkMAyARERGRwjAAEhER\\\n",
       "ESkMAyARERGRwjAAEhERESkMAyARERGRwjAAEhERESkMAyARERGRwjAAEhERESkMAyARERGRwjAA\\\n",
       "EhERESkMAyARERGRwjAAEhERESkMAyARERGRwjAAEhERESkMAyARERGRwjAAEhERESkMAyARERGR\\\n",
       "wjAAEhERESkMA+Bf5s+fjzZt2sDDwwNxcXHYsWNHc3eJiIiIqFEwAAJYtmwZZs6ciZdffhk7d+5E\\\n",
       "z549MWTIEOTl5TV314iIiIganEoIIZq7E80tLi4O11xzDf773/8CAKxWKyIjIzF16lQ899xzzdw7\\\n",
       "IiIiooal+BHAyspKpKSkICEhwV6mVquRkJCApKSkZuwZERERUePQNncHmlt+fj4sFgvCwsJk5WFh\\\n",
       "YTh48KDT15jNZpjNZvtzq9WKc+fOISgoCCqVqlH7S0RERFdGCIHi4mJERERArVb2GJjiA+CVSExM\\\n",
       "xCuvvNLc3SAiIqIrcPLkSbRu3bq5u9GsFB8Ag4ODodFokJubKyvPzc2FyWRy+prZs2dj5syZ9ueF\\\n",
       "hYWIiorCyZMnYTQaG7W/REREdGWKiooQGRkJX1/f5u5Ks1N8ANTr9ejbty82bNiA4cOHA5Au6W7Y\\\n",
       "sAFTpkxx+hqDwQCDweBQbjQaGQCJiIhaON6uxQAIAJg5cybGjx+Pfv364dprr8W7776L0tJSPPzw\\\n",
       "w83dNSIiIqIGxwAIYPTo0Thz5gzmzJmDnJwc9OrVC2vWrHGYGEJERETkDrgOYAMoKiqCn58fCgsL\\\n",
       "eQmYiIioheL5uoay50ATERERKRADIBEREZHCMAASERERKQwDIBEREZHCMAASERERKQwDIBEREZHC\\\n",
       "MAASERERKQwDIBEREZHCMAASERERKQwDIBEREZHCMAASERERKQwDIBEREZHCMAASERERKQwDIBER\\\n",
       "EZHCMAASERERKQwDIBEREZHCMAASERERKQwDIBEREZHCMAASERERKQwDIBEREZHCMAASERERKQwD\\\n",
       "IBEREZHCMAASERERKQwDIBEREZHCMAASERERKQwDIBEREZHCMAASERERKQwDIBEREZHCMAASERER\\\n",
       "KQwDIBEREZHCMAASERERKQwDIBEREZHCMAASERERKQwDIBEREZHCMAASERERKQwDIBEREZHCMAAS\\\n",
       "ERERKQwDIBEREZHCMAASERERKQwDIBEREZHCMAASERERKQwDIBEREZHCMAASERERKQwDIBEREZHC\\\n",
       "MAASERERKQwDIBEREZHCMAASERERKQwDIBEREZHCMAASERERKQwDIBEREZHCMAASERERKYxLB8At\\\n",
       "W7bgzjvvREREBFQqFb7//ntZvRACc+bMQXh4ODw9PZGQkIDDhw/L2pw7dw7jxo2D0WiEv78/JkyY\\\n",
       "gJKSkiY8CiIiIqKm5dIBsLS0FD179sT8+fOd1s+bNw/vv/8+PvjgA2zfvh3e3t4YMmQIKioq7G3G\\\n",
       "jRuHffv2Yd26dfjxxx+xZcsWPP744011CERERERNTiWEEM3diYagUqmwYsUKDB8+HIA0+hcREYGn\\\n",
       "n34azzzzDACgsLAQYWFhWLx4McaMGYMDBw6gS5cu+PPPP9GvXz8AwJo1a3D77bcjKysLERERl/S9\\\n",
       "i4qK4Ofnh8LCQhiNxkY5PiIiIro6PF/XcOkRwAs5fvw4cnJykJCQYC/z8/NDXFwckpKSAABJSUnw\\\n",
       "9/e3hz8ASEhIgFqtxvbt25u8z0RERERNQdvcHWgsOTk5AICwsDBZeVhYmL0uJycHoaGhsnqtVovA\\\n",
       "wEB7G2fMZjPMZrP9eVFRUUN1m4iIiKjRue0IYGNKTEyEn5+f/REZGdncXSIiIiK6ZG4bAE0mEwAg\\\n",
       "NzdXVp6bm2uvM5lMyMvLk9VXV1fj3Llz9jbOzJ49G4WFhfbHyZMnG7j3RERERI3HbQNg27ZtYTKZ\\\n",
       "sGHDBntZUVERtm/fjvj4eABAfHw8CgoKkJKSYm+zceNGWK1WxMXF1fveBoMBRqNR9iAiIiJyFS59\\\n",
       "D2BJSQmOHDlif378+HGkpqYiMDAQUVFRmD59Ol5//XV06NABbdu2xUsvvYSIiAj7TOHOnTvjtttu\\\n",
       "w2OPPYYPPvgAVVVVmDJlCsaMGXPJM4CJiIiIXI1LB8Dk5GTcdNNN9uczZ84EAIwfPx6LFy/G3//+\\\n",
       "d5SWluLxxx9HQUEBBg4ciDVr1sDDw8P+mq+++gpTpkzB4MGDoVarMXLkSLz//vtNfixERERETcVt\\\n",
       "1gFsTlxXiIiIqOXj+bqG294DSERERETOMQASERERKQwDIBEREZHCMAASERERKQwDIBEREZHCMAAS\\\n",
       "ERERKQwDIBEREZHCMAASERERKQwDIBEREZHCMAASERERKQwDIBEREZHCMAASERERKQwDIBEREZHC\\\n",
       "MAASERERKQwDIBEREZHCMAASERERKQwDIBEREZHCMAASERERKQwDIBEREZHCMAASERERKQwDIBER\\\n",
       "EZHCMAASERERKQwDIBEREZHCMAASERERKQwDIBEREZHCMAASERERKQwDIBEREZHCMAASERERKQwD\\\n",
       "IBEREZHCMAASERERKQwDIBEREZHCMAASERERKQwDIBEREZHCMAASERERKQwDIBEREZHCMAASERER\\\n",
       "KQwDIBEREZHCMAASERERKQwDIBEREZHCMAASERERKYy2uTtARFemuho4exY4dw44f97515wcoKQE\\\n",
       "sFoBIRwfAKBWAxqN9LX2vzUawGBwfHh4SA9vb+nh4yM9bP/29QWMRunh5QWoVM3734mIiBwxABK1\\\n",
       "MFVVQGYmcPw4cOIEcPo0kJfn+Dh7trl7enFqtTwQ+vsDQUFAYGDNw/Y8OBgIDZUeQUFSACUiosbB\\\n",
       "AEjUDEpLgUOHgPR06euxY1LgO34cOHVKGrFzB1YrUFgoPS6HSiUPhJGRwDXXAP36Ad27S6ONRER0\\\n",
       "5VRC2C4E0ZUqKiqCn58fCgsLYTQam7s71EJUVkqB7sgR4PDhmsCXni6FPLoyajXQsSPQu3fNo1cv\\\n",
       "KTASEV0Iz9c1OAJIdBUqK6XLtLaQZ/t6+DCQkQFYLE3TD29v6TJqQID8a0iI9FWlcv4ApHsBLRZp\\\n",
       "tM72sFikewwrKwGzGaiokL7aHuXl0ihmSYnjV7O5cY/VagUOHpQeX39dUx4eLo0OdutW87VLF+k+\\\n",
       "RCIikmMAJLoIs1m6RGsLeLUfGRmNd7nWaATatgWiooCwsJrLobUftoCn1zdOH65EZSVQXAwUFckf\\\n",
       "hYVAQYE0OcU2ecX2OHsWyM+/uvsas7Olxy+/1JSpVEBMTE0gtD06dAB0uqs+VCIil8VLwA2AQ8qu\\\n",
       "z2qVJl4cOCBdorWN4h0+LJU3RshTqaRw17GjFEjatq15tGkD+PhUwWyuQGVlJQoLC5GRkYHCwkJY\\\n",
       "/+qMEAIqleqiX521BQCdTofQ0FC0atUKXl5eUKsdV4VSqVTQaDTQarWyMpVKBa1W6/Q1V6OqSgqC\\\n",
       "tSe75OQAu3cDycnSz6YhfhY6HRAbKwXDnj2lS8i9ekmhmojcF8/XNRgAGwA/UK7l5EkgJUUKe/v3\\\n",
       "S18PHADKyhrn+wUHA+3bSyGvUycp8HXsKNChA6BSVaC0tBRVVVUoLi7GuXPnUFZWhrNnz2LXrl3Y\\\n",
       "u3cvTp48iXPnzqG4uBhmsxkN9b+sRqOBh4cH/P394e/vLwt5Nnq9HkFBQQgODoaHhwdUKhXUajV8\\\n",
       "fHwQERGBVq1awcfHxx4qbeHQ09MTgYGBDnUeHh7w8vJy+r0uRVkZsGcPsGsXkJoqfd2zp+EuO4eH\\\n",
       "S0HQFgr79QPateNSNkTugufrGgyADYAfKNdQWgpMngx8/nnNGngNxRbybEGv9ld/f4HS0lJkZ2cj\\\n",
       "IyMDGRkZyM7OxtmzZ5GdnY28vDwUFRWhsLDQHgbNZjPKyspgaaqbCC9CrVY7hDytVgu9Xg+tVmuv\\\n",
       "s9XrdDr4+PjAaDTaRwq1Wi0CAwPRrVs3xMXFISgoyN7Ox8cHOp0OWq0Wnp6e8PDwuOTRxepqaaQ2\\\n",
       "LQ3Yu7fm69GjDfNz9vcH+vaVwqDta5s2DIVErojn6xoMgA2AH6iWSwjp8uGXXwKffSZdXrxSoaFS\\\n",
       "qLMFO9sjJkYKCQBgsVhgsVhQUVGBvLw85Ofn48iRI9iyZQv+/PNPZGRkoLS0FNXV1RBCNNhonitR\\\n",
       "q9Xw8vKCt7c3dDodvLy8YDQa4evrCx8fH4SHhyM6Ohr+/v7QaDTQ6/UICQlBYGAgAgMDERYWBl9f\\\n",
       "X2g0GlnwrKu0VBrZTUsD9u2rCYanT1/9MQQGSkHQ9ujbV1qqhqGQqGXj+boGA2AD4Aeq5cnKAr76\\\n",
       "Sgp+e/de+uv8/IDOnWvuy6sd+Jz9aIUQqKysxJkzZ7Bv3z7s2bMHBw4cwOHDh5GTk4OCggKUlJSg\\\n",
       "srLSfu8e1c82ulh3xNE2Mujn54e2bdvimmuuQUxMDFq1aoWgoCB4eXnBx8cH/v7+0Ov19tFEZwHx\\\n",
       "3LmaQJiWJl1K3rPn6m8BCAmpCYO2R+vWDIVELQnP1zVcOgAmJibiu+++w8GDB+Hp6YkBAwbgX//6\\\n",
       "Fzp16mRvU1FRgaeffhpLly6F2WzGkCFDsGDBAoSFhdnbZGZmYuLEifj111/h4+OD8ePHIzEx8ZLv\\\n",
       "U+IHqmUoKAC++04KfZs2Xfzy36BB0ozQzp2l5UK6dAFMpvpP2EIIlJeXo7S0FKWlpcjIyMC+ffuQ\\\n",
       "lpaGPXv24NixYzh37hyqqqoUObLXlGz3L3p6esLT0xMGgwFGoxHBwcEIDQ1FeHg4TCYTTCYTYmJi\\\n",
       "EB0dDR8fH3s4rBsMLRZpVndqas0jJQU4c+bq+hkSIgXBPn1qLh9zpJCo+fB8XcOlA+Btt92GMWPG\\\n",
       "4JprrkF1dTWef/557N27F/v374f3X1sFTJw4ET/99BMWL14MPz8/TJkyBWq1Gn/88QcA6ZJdr169\\\n",
       "YDKZ8OabbyI7OxsPPvggHnvsMbzxxhuX1A9+oJpPcTHwww/AsmXAmjXSLNKLGTgQWLRIGtm7ENsl\\\n",
       "2rKyMmRnZ2P79u3YuHEjDh06ZL+Hz3Y5t7HZRsY0Go1sdOxSZgDXPh5bHSB99q1Wq/25C/8qcEqt\\\n",
       "VkOv18PPzw8xMTHo2LEjIiMjER0djeDgYAQFBSE0NNR+r6Knp2ed/7bSSHJycs0jJeXqt+ALDpaP\\\n",
       "EvbtK80GZygkanw8X9dw6QBY15kzZxAaGorNmzfj+uuvR2FhIUJCQrBkyRL87W9/AwAcPHgQnTt3\\\n",
       "RlJSEvr374+ff/4Zd9xxB06fPm0fFfzggw8wa9YsnDlzBvpLWGCNH6imVVYGrF4NLF0K/PSTtEjx\\\n",
       "xURFAePGAfffL430OWM2m1FYWIj8/HycOnUKhw8fRnp6Og4fPmy/pFtWVtZol3JtAc92+VKn0yEw\\\n",
       "MBCdOnVCTEwMIiMjERoaCoPBYG9fN9TVfq8LhUMAKCsrs1+mto1a1m5jNpuRm5uL7OxslJSU2I/b\\\n",
       "arWiokKavWy7tF07RFosFlRXV8NisbSoUKlWq+1L2mi1WhgMBvj4+CA4OBghISGIiIhA+/bt0atX\\\n",
       "L7Rt2xZ+fn4wGo2yCSlCSAt/p6TIQ2FBwdX1rXYotN1XyMvHRA2P5+sabrUQdOFfG44GBgYCAFJS\\\n",
       "UlBVVYWEhAR7m9jYWERFRdkDYFJSErp37y67JDxkyBBMnDgR+/btQ+/evR2+j9lshrnWuhNFRUWN\\\n",
       "dUhUS3o68P770izekpKLt/fzA0aNkkLfoEHSFmI2VqsV1dXVqKysRElJCdLS0rBx40akpKQgMzMT\\\n",
       "Z86cQUlJSYNfzlWpVPbg4e3tDW9vb4SEhCA0NBSBgYFo3bo1QkND4eXlBS8vL0RHR6Ndu3bw8fGx\\\n",
       "j/41JCGELMDVrTObzSgoKEB5ebls/cHy8nLk5+ejoKAAFRUVsgBYUVGB3NxcnD59GmVlZfZQmJeX\\\n",
       "hyNHjuD8+fOorq6G1WqF1Wp1GIlsLLbvV/XXMHFxcTHy8/Nx4sQJADUB3NfXFxEREQgNDUVkZCRi\\\n",
       "YmLQrl07BAUFISgoCCaTCbfc4oe77vKEXq+HENJC4bUD4c6dl7f/cX4+sHat9LCx3VPYrx8wZkz9\\\n",
       "f7gQEV0JtwmAVqsV06dPx3XXXYdu3boBAHJycqDX6+Fvm6L5l7CwMOTk5Njb1A5/tnpbnTOJiYl4\\\n",
       "5ZVXGvgIyBmrVdrZ4b33pEu8F6PXA0OHSqN9d94JeHjU1AkhUFJSgvT0dKSlpeHAgQM4cuQIDh06\\\n",
       "hKysLJSUlDT4siu2CQxeXl5o1aoV4uLiMHDgQHTt2tUeAAMDA+2XH+tOfmhsttBTH9syLRdSX3is\\\n",
       "PVIqhEB1dTWysrJw9OhRFBQUwGw249y5czhx4gTy8vJQUlKC4uJinD9/3j7SajabUVRUBLPZ3Oj3\\\n",
       "Vtr6eP78eZw/fx779u2TLXljMBjg6ekJo9GIyMhI9OrVC/Hx8Wjfvj1CQkIwdKgR99zjAZ1OB0CF\\\n",
       "Y8ekMFj7cTkjhWfOAD//LD3++U9g9Gjg5pul9Qm7dgU8PRvpPwQRKYLbBMDJkydj7969+P333xv9\\\n",
       "e82ePRszZ860Py8qKkJkZGSjf18lKSmRRvref18a+bsQrRa45RZplOTuu6WRPxuLxYKSkhKcOnUK\\\n",
       "v/32G1auXIl9+/bh7NmzqKioaNDAZ1voOCQkBJGRkYiKikK7du3so3ht27aFyWSCp6dnk4S7puLs\\\n",
       "WGwzeWvT6XTo0KEDOtS6+dJqtaKyshJms9l+6bi8vBxVVVX2upycHBw7dgzHjx/H7t27cfz4cRQW\\\n",
       "FqKsrAyVlZX2y82NcWnedlm8srISlZWVKC4uto9kbt68GZ988gkCAwMREBAAk8lkHzGMjY1Fq1at\\\n",
       "0LdvAG6/PQxeXl5QqdQ4frwmDF7O5WOrVdr32Lb3sUYjLSpuW7TaNskkIKDB/xMQkZtyiwA4ZcoU\\\n",
       "/Pjjj9iyZQtat25tLzeZTKisrERBQYFsFDA3Nxcmk8neZseOHbL3y83Ntdc5YzAY7PdhUcPKzAT+\\\n",
       "8x/g448vfAlNrQZuukkaFRkxAggKqqkTQqCoqAi7du3Ctm3bkJKSgl27duHkyZOorKxskH7W3iLN\\\n",
       "aDQiIiICXbt2Rf/+/XHttdeibdu28PHxgcFgaPDLtu5ErVbDw8MDHrWHauuwjehbrVaUlJQgJycH\\\n",
       "eXl5yM3NRVZWFs6fP4/CwkL7otpnzpzB+fPnUVRUhPLy8ka7F9FqtaK4uBjFxcXIyMiwl9tmKPv6\\\n",
       "+iI0NBRdu3bFtddei86dOyMsLAz9+wfhttv8/7q3UIOMDPVlh0KLRdrFZv9+YMmSmvL27aVLxtdc\\\n",
       "I33t0we4yAAuESmUS08CEUJg6tSpWLFiBTZt2iQbWQBgnwTy9ddfY+TIkQCA9PR0xMbGOkwCyc7O\\\n",
       "RuhfG4F+9NFHePbZZ5GXl3dJQY83lV4dIYCkJODdd6VlXC40KBcYCDz2GDBpkjSxo7bKykpkZWVh\\\n",
       "69atWLx4MXbu3ImSkhL7ostXS6VSwcvLCzExMejfvz9iY2PRpk0bREdHo3Xr1vD19WXga0K171+0\\\n",
       "Xb61WCwoKyvD6dOnkZWVhf379yM1NRWnTp2yb6dnW8an7gSWxmK7hOzh4QEfHx8EBgaiVatW6Nix\\\n",
       "Izp16oROnTohNjYWJpMJOp3Ofk9hSgqwYQOweDFwpX+3qFTSUkcDBgDx8dLX9u05uYSUi+frGi4d\\\n",
       "ACdNmoQlS5Zg5cqVsrX//Pz84PnXDTITJ07E6tWrsXjxYhiNRkydOhUAsHXrVgA1y8BERERg3rx5\\\n",
       "yMnJwQMPPIBHH32Uy8A0sqoqYPlyKfj9+eeF23btCkybJt3b5+UlrysvL8fu3bvx9ddfY8uWLTh6\\\n",
       "9CiKi4uvuF+1Fx62zRK1nbD79euHvn37om3btjAYDG51KdcdVVdXo7S0FMXFxSgvL0dBQQEKCgpw\\\n",
       "5swZnDhxAllZWcjKysKpU6dw+vRp+/2GTREMbcvUBAQEoG3btrj22mvRrVs3tGnTBpGRkfDz84PB\\\n",
       "YEBWlg4rVuiRlqbB7t1qHD58dVvcBQdLQXDAAGlJpH79AF7QIKXg+bqGSwfA+k6+n376KR566CEA\\\n",
       "NQtBf/3117KFoGtf3s3IyMDEiROxadMmeHt7Y/z48Zg7dy4Xgm4k+fnARx8BCxYAp07V306lAoYN\\\n",
       "A6ZPl25+r/vjLikpQWpqKr799lssX74c2dnZV3zStoW+kJAQ9O7dG/3790eXLl0QHR2NsLAw+Pn5\\\n",
       "wdvbm6N7bsQ2gmgLhidOnMCuXbtw+PBhnD9/HmfOnEFGRgbOnDmD8vJyVFZWNurSNrUnDPn5+dln\\\n",
       "h4eEhCAoKAidO3dGXFwcQkPb4ehRT+zZo8bu3Srs3Cltd3ilo4QeHtLo4A03SI+4OE4wIffF83UN\\\n",
       "lw6ALQU/UJdm715pNu+XX1547T5vb+CRR4CpU50v1lxZWYldu3Zh4cKFWL9+PXJzcy97MWa1Wo2A\\\n",
       "gAD7wsDt2rVDly5d0Lt3b7Rt2xZGo/GS/wAg91FdXY2qqir7hBTbBKKTJ0/i/PnzyMjIQHJyMtLT\\\n",
       "03Hu3DlUVFTYl7RpLLb7TT08PBAcHIxOnTqhffv2iImJQefOndG6dWt4evrhxAkfHDzog927dUhO\\\n",
       "lra5u5I1yvV64NprpYlVt90mTS65wERxIpfC83UNBsAGwA9U/axWadHmd9+V7me6kOho4KmnpPBX\\\n",
       "Z+Wev97LitOnT2P58uX46KOPcOjQocs68Wo0Gnh5eSEyMhLXX389brvtNnTr1g0hISHw9PSsd+9Y\\\n",
       "IhuLxYJz587hwIEDOH78OM6ePYvs7GxkZGQgMzPTvrC2bdmahl5WyKb2aKFthDAkJATdunXDTTfd\\\n",
       "hJ49e0Kt9sbevTr8+acW27ersXWrCvWsbHVBgYHArbcCQ4ZIj/Dwhj8eoqbC83UNBsAGwA+Uo7Vr\\\n",
       "pcu827df+DIvIN2HNH26tIRLfYNu5eXlWL9+Pd566y1s375dthD3hajVaphMJvTo0cO+blvXrl0R\\\n",
       "Hh7udsuxUNOyTT6xLWZdWlqKvLw8ZGdnIysrCwcOHEBKSgoOHTqEs2fPNuqMZBvbQtatW7eGyWRC\\\n",
       "SEgIYmJi/tpNpj1UqrY4dCgIO3Zo8dtv0ijh5XanVy/g9tulR//+HB0k18LzdQ0GwAbAD5Tc1q3A\\\n",
       "9ddfeDavTiet2zdtmnSJqT7V1dU4evQoPvzwQyxbtuyS7vOzzdaNjIzErbfeirFjx6J9+/YwGo3Q\\\n",
       "6XQMfdQkbItK5+Tk2BfAzsrKQkZGBo4dO2bfT7q8vLxR7yu0XT728/ND69atERcXh4SEBHTq1Akq\\\n",
       "VRB27/bF1q06bNmiwq5d0qj9pQoMlEYFhw2TvgYHN8phEDUYnq9rMAA2AH6galRXS2uPpaU5rw8J\\\n",
       "AZ58Epg48eKXkkpKSrB69Wq8+eabSE1Nveh9frbgN3DgQIwaNQrx8fGIiYnhmo3UYti21zt//jyy\\\n",
       "srKQmpqK3377DTt37kRubi5KS0vti2DbRhgbmu3/k7CwMPui1b1798aAAQPg5xeF5GQDNm5UY80a\\\n",
       "4MCBy3lfacvFUaOAkSN5qZhaJp6vazAANgB+oGq88w5Qa5MUux49pMu8Y8fKt2dzprq6Grt378Z/\\\n",
       "/vMf/PDDDzh//vxFv29ISAiuu+46jB07FjfffDMCAwM5Y5daPKvVioqKCpw7dw6nTp2yL0djW5rG\\\n",
       "tkxNTk6OfXu8hqZWq2EwGBAYGIguXbogPj4ePXv2RExMDKqqIrBjRwA2bNBi/XrgUrc9V6mkWzts\\\n",
       "YTAiosG7TXRFeL6uwQDYAPiBkpw+DcTGAnWX4PvtN+C66y5t8dmioiL8+OOPmDdvHvbu3XvRm+g9\\\n",
       "PDzQr18/zJw5E4MGDWLwI5cnhIDFYkFFRQWKi4tx5swZHDhwALt27cLx48ftk01s2+HZFsBuKBqN\\\n",
       "Bt7e3ggJCUHr1q3RsWNHDBo0CNdeex0yM1th/Xo9Vq9WYe/eS3s/lUq6V7BbN+Cee6S9uomaC8/X\\\n",
       "NRgAGwA/UJKxY4GlS+Vlf/whLTh7MUII7Nu3D//+97/x3XffoegiQw1qtRodOnTAQw89hAcffBDh\\\n",
       "4eG8t4/cmm2yiW0/4pMnT2L//v1IT0/H7t27kZ6ejsLCwsteEulS6HQ6REdH45ZbbsGgQYPQq1cv\\\n",
       "AFHYvNkLq1ersGEDUFZ2ae81f760kw9Rc+D5ugYDYAPgB0pa4iUhQV728MPAokUXf63VasW2bdsw\\\n",
       "a9YsJCUlXXQ0IygoCHfeeSeeeuopdO3aFXq9/ip6TuS6bJeQCwsLcfjwYezZswdHjx5Fbm4u8vPz\\\n",
       "kZ2djfz8fPvSNFf76962lFJYWBj69euHe++9FwMHDoSPTzB++UWF5cuBH35wvApQm0oFfPuttIc3\\\n",
       "UVPj+boGA2ADUPoHymwGevYE0tNrygICpOchIRd+bXl5OdauXYvXXnsNu3btuuAJSqPRoFu3bpgx\\\n",
       "YwbuvPNOBAQEcNSPqBbbnshmsxmVlZWyySbr169HWloazpw502Db3QUEBGDQoEG4++67ceONN6J1\\\n",
       "69awWvX45Rcp5K1c6fy+QYMBWLdOmjRC1JSUfr6ujQGwASj9A5WYCDz/vLzsgw+AJ5648OtOnz6N\\\n",
       "BQsW4IMPPsDZs2cv2DY4OBj33HMPnnrqKXTu3BkaLj5GdMlsl45ty9GkpqZi3759SE9PR0ZGBoqK\\\n",
       "iq4qDBoMBsTGxmL06NG4//770apVK6jVapjN0tWBF14AUlPlr/H3B37/Xdrnm6ipKP18XRsDYANQ\\\n",
       "8gfq5Elp4kft+3+uuQZISqp/gVir1YojR47gueeew5o1a1BeXl7v++t0OvTt2xdPP/00EhIS4O9s\\\n",
       "ixAiuiwWiwUlJSXIz8/H0aNHsWXLFuzYsQMnT57EmTNnUFJSgsrKyssOhZ6enujZsycmTJiA4cOH\\\n",
       "I/ivhQGFkP4g/PhjefvWraV1QyMjG+rIiC5MyefruhgAG4CSP1BjxgDLltU8V6mAHTuAfv2ctzeb\\\n",
       "zdi8eTNee+01bN269YLLWvj6+mLs2LGYMWMGOnbsyNm9RI3EarWiuLgY+fn5OHToEPbt24d9+/Zh\\\n",
       "27ZtOHHixGXfP+jj44N77rkHzz//PDp06ACNRoPqamlJmB9+kLft2lUaCeTfdtQUlHy+rosBsAEo\\\n",
       "9QP166/AzTfLy554Qrr860xZWRkWLVqEf//738jIyKj3hKJSqRAVFYVZs2Zh7NixHPUjamIWiwVm\\\n",
       "sxlnz57F5s2bsWbNGuzevRuZmZkXnaFvo9Fo0KFDBzz11FO477774Ofnh7IyabJYUpK87S23SHuG\\\n",
       "17cVJFFDUer52hkGwAagxA9UVRXQuzewb19NWUAAcPgwEBTk2L6goACffvopEhMTcebMmXrfV6vV\\\n",
       "ol+/fnjhhRcwePBgeHp6NkLviehSWa1WlJSU4NSpU9izZw+WLVuGP/74A2fPnr2k9Qf9/f3x5JNP\\\n",
       "YubMmQgODsa5cyoMHAgcPChvN3GitEQM53VRY1Li+bo+DIANQIkfqHffBWbMkJctWCD9Eq+roKAA\\\n",
       "r7/+Oj788EOUlJTU+57e3t4YN24cnn76aXTo0IEzfIlaoPLyciQnJ+Pbb7/FihUrkJWVddHLwwaD\\\n",
       "AWPGjMEzzzyDbt26ISMDiIsDcnPl7d5/H5g6tRE7T4qnxPN1fRgAG4DSPlC5uUDHjvLlHXr1ApKT\\\n",
       "5RM/hBA4cuQI/vnPf2L58uUou8BKsREREXjuuefwwAMP8JIvkQsoKytDamoqFi1ahHXr1uHUqVMX\\\n",
       "HBHU6XS48cYb8e6776Jz587YsUOFG26QlpGyUauBn34CbrutCQ6AFElp5+sLYQBsAEr7QD38MLB4\\\n",
       "sbzs99+l7d5sqqursWPHDrzyyivYsGFDvScGlUqFdu3aYc6cObj33nvhcbGNgomoRSkpKUFqaio+\\\n",
       "++wzrFix4oJLOmk0GiQkJOC///0vYmJisGyZCmPHytv4+kozg7t1a+SOkyIp7Xx9IZxWSZclKckx\\\n",
       "/D34oGP427BhAx5//HGsX7++3vCnVqsxaNAgfPHFFxg7dizDH5EL8vHxwcCBA/HOO+/gww8/RJ8+\\\n",
       "feqdsW+xWLBu3To89dRT2LlzJ+6914qXX5a3KS4Gbr0VOHasCTpPpGAMgHTJLBZg8mR5ma8vMHdu\\\n",
       "zXMhBH7//XfMmjUL+/fvr3eZF41Gg9tvvx3vvvsu+vfvD51O14g9J6LG5uPjg+HDh+Ojjz7C4MGD\\\n",
       "692i0Wq1Yt26dXjmmWeQmpqKl16yYswYeZvsbGm28KlTTdBxIoViAKRL9tFHwK5d8rJXXgHCw6V/\\\n",
       "V1dXY9OmTZg6dSp2795d743hOp0OCQkJeOedd9C7d29O9iByExqNBn369MF7772HcePGwWAwOG1X\\\n",
       "XV2NLVu2YObMmUhL24NFi4ABA+Rtjh+XlofJz2+CjhMpEAMgXZL8fGk7p9q6dgWmTJH+XVlZiZUr\\\n",
       "V+Lxxx/Hvtprw9RhNBoxYcIEzJ8/HzExMY3YYyJqDiqVCrGxsZg7dy4mTZoEHx8fp+2sVit+++03\\\n",
       "TJ06FQcP7sKqVVb07Clvc+CANCGksLAJOk6kMAyAdEmefx44f15e9t//Ajqd9Nf8mjVr8OKLL+LI\\\n",
       "kSP1jvyZTCbMmTMHr732GmJiYjjyR+SmVCoVQkND8fzzz+Ohhx6qdz1Pq9WKpKQk/P3vf0de3iH8\\\n",
       "8ou0wkBtKSnAnXcCF9gxkoiuAAMgXVRyMvDJJ/KyMWOAG2+smfDx7LPP4mDdlV1riYyMxJtvvomp\\\n",
       "U6fa9wclIvcWHByMF198EdOnT693eSeLxYJff/0Vr776KsrLM7B+PRAVJW/z22/A6NHSAvRE1DAY\\\n",
       "AOmChACeeUb6auPtDbz5Zs0v7meeeQaHDx+u9z0iIyPxxhtvYNSoUfXeGE5E7iksLAzPPfccZs2a\\\n",
       "hcDAQKdtLBYLvvvuOzz33HNQqbKwfj0QFiZvs2oV8OijwAW2Dyeiy8AASBf044/A5s3yspdeAsLD\\\n",
       "Ldi0aRNmzpyJvXv31nvZt127dnjzzTdx77331ntDOBG5N6PRiEmTJmHGjBnw9vZ22sZsNmPFihV4\\\n",
       "++23ERR0Dr/8Avj5ydt8/rnjH6REdGUYAKle1dXArFnysuhoYPLkaqxduxZPPPHEBSd8xMbG4r33\\\n",
       "3sOIESM48kekcEajEU899RSeffZZ+Pr6Om1jNpvxwQcf4K233kLbtsX48Ueg7u2D77wjX3qKiK4M\\\n",
       "AyDVa9EiaRZeba+9ZsW2bZvw7LPP4ujRo/WO/EVFReG1117DrbfeyjX+iAiAFAKnTZuGRx99tN6J\\\n",
       "IeXl5fjss8+wefNmXHedwPLl8i0mAWlS2scfN0GHidwYAyA5VVIChxX6+/QRaNVqC5555hns37+/\\\n",
       "3tdGRUUhMTERd999N0f+iEjG398fM2fOxJgxY6DVap22yc7Oxocffojz589j2DDH3YcAYNIk4MSJ\\\n",
       "Ru0qkVtjACSn3n4byMmRlz322GHMnj0LaWlpTl+jUqnQqVMn/Otf/8KIESM48kdETrVu3Rqvvvoq\\\n",
       "hgwZAk3d4T1IOwpt3LgRixYtQkVFBe6/H3jvPXmb6mpphQIiujIMgOQgJweYN09edvPNFdi0aQ6S\\\n",
       "k5Odbu+mUqnQtWtXfPDBBxgxYgT39SWiC2rVqhVefPFF9Ky7+vNfysrKsHDhQvz5558AgKeeAoxG\\\n",
       "eZtz5xq7l0TuiwGQHDz3HFBaWvNcrRZo1+5DrFy5st69fWNiYvDee+/hhhtu4GVfIroolUqFa6+9\\\n",
       "Fi+99BKCgoKctjl+/Dg+/PBDFBUVAQCGDJHX793b2L0kcl8MgCSzdSvw2Wfysvj4Q/j++9dRUVHh\\\n",
       "9DXh4eF49dVXMWjQIO7uQUSXTK1W4+abb8ajjz7q9KqBEAKrV6/GDz/8AIvFgh495PV79jRRR4nc\\\n",
       "EAMg2VksNXv72nh5VeHIkdHIr2dH9oCAALz44ou854+IrojRaMSMGTMQFxfntP78+fP48MMPkZ+f\\\n",
       "7zQAck1AoivDAEh2H30E7NolL/P1/Tdyc3c7bW8wGPDII4/ggQce4CLPRHTFQkND8eijj8JY9ya/\\\n",
       "v/z555/YsmWLQwA8fx7IymqCDhK5IQZAAgDk5wMvvCAv8/I6jry8l52212q1uOuuuzB16tR6F3Ul\\\n",
       "IroUKpUKgwcPxq233ur0NhKz2YyPP/4YGk2Ww0QQXgYmujIMgARACn/nz8vLKioegxCVDm1VKhUG\\\n",
       "DBiAf/7zn4iOjm6iHhKROwsPD8fs2bMRERHhtH7btm1Yv34devSQX/NlACS6MgyAhJQUx1X1NZrl\\\n",
       "sFo3OG3fu3dvJCYmon379k3QOyJSii5duuCuu+5yujZgcXExfvjhB3TpUi0rZwAkujIMgIT//Ed+\\\n",
       "I7VKVQaLZYbTtlFRUfjHP/6BuLg4zvglogZlMBgwcuRIhIWFOa3funUrfH1PyMp2O79FmYguggFQ\\\n",
       "4YQAfvutbtk7AE45tPXz88Pzzz9f7+r9RERXw3Z7ydChQ53+gZmfn4+dOz+VlaWny9ctJaJLwwCo\\\n",
       "cNu2AceO1S39zqGdXq/H3/72N4wePZoLPRNRo/H09MSoUaOcLg5ttVqxe/cXUKuttcqA1NQm7CCR\\\n",
       "m2AAVLjPP69bcgjATlmJ7a/y6dOnw9/fv4l6RkRKdc011+Cmm25yOgp4/vwpBAXlyspSUpqqZ0Tu\\\n",
       "gwFQwSoqgKVL65Y6JEK0bdsWc+bMQZcuXZqkX0SkbAEBAZgwYQICAgIc6oQQUKnkC5YmJzdVz4jc\\\n",
       "BwOggq1aBRQU1C39QvYsODgYzz77LPr37w+1mh8XImp8KpUK/fv3R79+/ZzWl5f/LnvOEUCiy8cz\\\n",
       "uoI5Xv7dCCDT/kyn0+Hhhx/G+PHj4enp2ZRdIyKF8/HxwQ033OB0i8myMvnMtYMHORGE6HIxACrU\\\n",
       "2bPAmjV1N9GsSYQqlQo33ngjJk6cyPBHRE1Oo9GgX79+CAwMdKizWFIA1KwHyIkgRJePAVChli2z\\\n",
       "orq69g3W5QD+z/4sICAAM2fORJs2bZq6a0REAIDu3bsjNjbWSU051Op0WQkvAxNdHgZAhfr886o6\\\n",
       "JT8AKAEAqNVqDBs2DAMHDuRiz0TUbMLCwnDHHXdAq9U61Akhn/nBEUCiy8MAqEBHjlRi+3ZDndIl\\\n",
       "9n+1bdsWjzzyCLy9vZu2Y0REtajVagwePNjpmoBCpMqec0s4osvDAKhAH35YWKfkPIA1AKT7bu67\\\n",
       "7z7Ex8dz9I+Iml14eHg9t6LI94Dbtw+ornbSjIicYgBUGKvViq+/ttYp/RZAJQCgU6dOGDt2LAyG\\\n",
       "uiOERERNz9vbG23btnXyB2ma7FlFBXDkSNP1i8jVuXQAXLhwIXr06AGj0Qij0Yj4+Hj8/PPP9vqK\\\n",
       "igpMnjwZQUFB8PHxwciRI5GbK19BPjMzE8OGDYOXlxdCQ0Px7LPPotqN/4z888/zOHWq7kbr0mrQ\\\n",
       "BoMBo0ePRtu2bZu+Y0RETnh4eKBTp05O7gPMB3BaVsLLwESXzqUDYOvWrTF37lykpKQgOTkZN998\\\n",
       "M+6++27s27cPADBjxgysWrUKy5cvx+bNm3H69GmMGDHC/nqLxYJhw4ahsrISW7duxWeffYbFixdj\\\n",
       "zpw5zXVIjcpisWDu3Lob/+YC2AwA6NChAx588EF4eHg0ed+IiJzR6XTo1atXPctRyS8DMwASXQbh\\\n",
       "ZgICAsQnn3wiCgoKhE6nE8uXL7fXHThwQAAQSUlJQgghVq9eLdRqtcjJybG3WbhwoTAajcJsNl/y\\\n",
       "9ywsLBQARGFhYcMdSCPIzc0VPj5HBCBqPeYLAEKv14vExERhsViau5tERDLZ2dmiW7duAkCdx1zZ\\\n",
       "77M772zunlJL5yrn66bg0iOAtVksFixduhSlpaWIj49HSkoKqqqqkJCQYG8TGxuLqKgoJCUlAQCS\\\n",
       "kpLQvXt3hIXVXBIdMmQIioqK7KOI7mTDhiyUlMTUKf0GgDT6N2zYMG73RkQtTkhICG6//XYnv5/k\\\n",
       "Q34cASS6dI6LK7mYtLQ0xMfHo6KiAj4+PlixYgW6dOmC1NRU6PV6+Pv7y9qHhYUhJycHAJCTkyML\\\n",
       "f7Z6W119zGYzzGaz/XlRUVEDHU3jsVqt+PTTunslZQP4DRqNBqNGjUKnTp2ao2tERBek0WgQHx8P\\\n",
       "X19fFBbWXsVA/od6ZqY0GYR3sRBdnMsP93Tq1AmpqanYvn07Jk6ciPHjx2P//v2N+j0TExPh5+dn\\\n",
       "f0RGRjbq92sIp0+fxh9/tK5T+i0AK4KDg3H33XdDr9c3R9eIiC4qMjLS4Q96QD7tVwjgWN3bnInI\\\n",
       "KZcPgHq9Hu3bt0ffvn2RmJiInj174r333oPJZEJlZSUKCgpk7XNzc2EymQAAJpPJYVaw7bmtjTOz\\\n",
       "Z89GYWGh/XHy5MmGPagGJoTA11/vQVlZ3dm9ywBIIToqKqrpO0ZEdIlCQ0Od/F4uhXQlo8bhw03W\\\n",
       "JSKX5vIBsC6r1Qqz2Yy+fftCp9Nhw4YN9rr09HRkZmYiPj4eABAfH4+0tDTk5eXZ26xbtw5GoxFd\\\n",
       "unSp93sYDAb70jO2R0tWXV2NpUtFndIsAFuh1WrRq1cv7vpBRC1aQEBAPQtCyxMf1wIkujQufQ/g\\\n",
       "7NmzMXToUERFRaG4uBhLlizBpk2bsHbtWvj5+WHChAmYOXMmAgMDYTQaMXXqVMTHx6N///4AgFtv\\\n",
       "vRVdunTBAw88gHnz5iEnJwcvvvgiJk+e7FYLIVdUmJGe3rNO6TcABPz9/XHjjTfy8i8RtWgGgwHt\\\n",
       "27eHWq2G1Vp7MfsjAK63P+MIINGlcekAmJeXhwcffBDZ2dnw8/NDjx49sHbtWtxyyy0AgHfeeQdq\\\n",
       "tRojR46E2WzGkCFDsGDBAvvrNRoNfvzxR0ycOBHx8fHw9vbG+PHj8eqrrzbXITWKtDQ1Skvr3v/3\\\n",
       "DVQqFQYNGoTrr7+e274RUYum1WoxYMAAGAwGlJeX16qRD/lxBJDo0qiEEHWvDdJlKioqgp+fHwoL\\\n",
       "C1vk5eBZs6yYN6/21f4TUKli0KlTRyxYsAA33XRTs/WNiOhSZWVlYfDgwTh06FCt0r8BWG5/FhUF\\\n",
       "ZGQ0edfIRbT083VTcrt7AMnR8OFqPPhgBby9pb+aAwLW45ZbEvDqq6/a74ckImrp/P390bVr1zql\\\n",
       "8iG/kyelpWCI6MJc+hIwXZr4eCA+3gPz55vx7bfZCAiIx7XXDkNISIiT/TWJiFomnU4Hk8lU5z5A\\\n",
       "x6Vgjh8HOndu+v4RuRKe/RXEx8eAhx4KBxDe3F0hIrpsarUa/v7+0Gg0tQJgCYA8AKH2dgyARBfH\\\n",
       "S8BEROQS1Go1IiIinFy5kK/+zMWgiS6OAZCIiFyCRqNBmzZt4OGw19tx+bPjIKKLYAAkIiKX0bp1\\\n",
       "a/j6+tYp5Qgg0eViACQiIpcRHBzsZE9gjgASXS4GQCIichkGgwEBAQF1Sh1HALnCLdGFMQASEZHL\\\n",
       "8PDwQHR0dJ1S+ZBfcTFw7lzT9YnIFTEAEhGRy/D29sb1119fZ7/2kwCqZe3S0pq0W0QuhwGQiIhc\\\n",
       "hlqtRt++fREWFlar1AJgv6zd1183abeIXA4DIBERuZTg4GCYTKY6pUtlz377ren6Q+SKGACJiMil\\\n",
       "GAwGJzOBf5U9O3gQKClpsi4RuRwGQCIicikeHh4ICQmBSqWqVbob0qVgiRBAampT94zIdTAAEhGR\\\n",
       "S/H29kaHDh2gVtc+hZWj7n2AO3c2abeIXAoDIBERuRS1Wo2wsDBoNJo6NSnyZykgonowABIRkcvx\\\n",
       "8fGpMwIIMAASXToGQCIicjkmkwk6na5OabLs2YEDQGlp0/WJyJUwABIRkcvx8fGBXq+vUyqfCGK1\\\n",
       "Art3N2m3iFwGAyAREbkclUrl5B5Ax4kgnAlM5BwDIBERuRy9Xl9nOzibPbJn+/Y1TX+IXA0DIBER\\\n",
       "uZzg4OA628HZyBPf3r1N0x8iV8MASERELickJAS9e/d2MhNYHgD37ZMWhSYiOQZAIiJyOXq9HjEx\\\n",
       "MdBqtXVq5EN+Z88CublN1y8iV8EASERELkmv1zsZATwOlapcVsL7AIkcMQASEZFLku8FbCOg1R6S\\\n",
       "lfA+QCJHDIBEROSSnI8AAmr1QdlzjgASOWIAJCIil6NSqRAYGOjkHkBACPmQ3549Dk2IFI8BkIiI\\\n",
       "XI5KpYLJZIKXl5dDnRC7ZM/37AGqq5uqZ0SugQGQiIhckp+fHzw8PJzUyANgeTmQnt40fSJyFQyA\\\n",
       "RETkkjQajdN7AIXIg9FYICvbubOJOkXkIhgAiYjIJanVaqcB0GKxIDAwQ1bGAEgkxwBIREQuydvb\\\n",
       "Gz4+Pg7lQggYDPKpvwyARHIMgERE5JICAgLq2Q8Y0OvlM4F37QKs1qboFZFrYAAkIiKXpNVqERgY\\\n",
       "6LROpZJPBCkuBo4caYpeEbkGBkAiInJJWq0W/v7+TusKCw8iOFi+9ktychN0ishFMAASEZFL0ul0\\\n",
       "CA8Pd7olXFlZKTp2LJKV7djRVD0javkYAImIyCVpNBoEBQU5nQlcUVGBmJizsrI//2yqnhG1fAyA\\\n",
       "RETksvR6vdMRwIqKCvj4HJCV7dwJVFU1Vc+IWjYGQCIiclkGg8HpfsDV1dU4e3aNrKyiAti3z6Ep\\\n",
       "kSIxABIRkcuKjo6udy3A3Nz9iI6WTwThfYBEEgZAIiJyWe3atUNMTIzTOrPZjJ49zbIy3gdIJGEA\\\n",
       "JCIil2U0GhEdHe30PsDq6mr06CEPgNu3N1XPiFo2BkAiInJZarUafn5+TmcCl5WVoVMn+VIw+/ZJ\\\n",
       "i0ITKR0DIBERuSyDwYDWrVs7DYBFRUVo1SoHteeIWK28DEwEMAASEZEL02q1aNOmDXQ6nUNdRUUF\\\n",
       "qquL0auXvHzbtqbpG1FLxgBIREQuS6VSwd/fHxqNxqHObDajtLQU8fHy8qSkJuocUQvGAEhERC7N\\\n",
       "x8fH6VqAZrMZWVlZDgFw2zZAiCbqHFELxQBIREQuLTg4GF5eXg7l1dXVyMjIQFycVVaenw8cPdpU\\\n",
       "vSNqmRgAiYjIpfn6+sLX19eh3Gq1Ijs7G61bWxAWJq/jZWBSOgZAIiJyaT4+PggKCnJad/r0aZSV\\\n",
       "Od4H+MEH0oxgIqVymwA4d+5cqFQqTJ8+3V5WUVGByZMnIygoCD4+Phg5ciRyc3Nlr8vMzMSwYcPg\\\n",
       "5eWF0NBQPPvss6iurgYREbkGPz8/hIeHO63Ly8tDYWEhBg6Ul2/dCixY0ASdI2qh3CIA/vnnn/jw\\\n",
       "ww/Ro0cPWfmMGTOwatUqLF++HJs3b8bp06cxYsQIe73FYsGwYcNQWVmJrVu34rPPPsPixYsxZ86c\\\n",
       "pj4EIiK6QlqtFiaTyeluILm5uTh27BjGjwcCA+V18+YB/HuflMrlA2BJSQnGjRuHjz/+GAEBAfby\\\n",
       "wsJC/O9//8Pbb7+Nm2++GX379sWnn36KrVu3Yttfi0D98ssv2L9/P7788kv06tULQ4cOxWuvvYb5\\\n",
       "8+ejsrKyuQ6JiIgug1qtRocOHZzOBC4uLkZycjL8/auxZIm87uRJ4LvvmqiTRC2MywfAyZMnY9iw\\\n",
       "YUhISJCVp6SkoKqqSlYeGxuLqKgoJP11929SUhK6d++OsFp3Bw8ZMgRFRUXYt29fvd/TbDajqKhI\\\n",
       "9iAioubTs2dPBNYd4gNQVVWF9PR0VFZWYsgQoH9/ef077zRRB4laGJcOgEuXLsXOnTuRmJjoUJeT\\\n",
       "kwO9Xg9/f39ZeVhYGHJycuxtwupMDbM9t7VxJjExEX5+fvZHZGTkVR4JERFdjTZt2qBNmzYO5Var\\\n",
       "FTk5OaiqqgIA1LpNHIC0JiB3BiElctkAePLkSUybNg1fffUVPDw8mvR7z549G4WFhfbHyZMnm/T7\\\n",
       "ExGRXFBQENq1a+e07uTJkygvLwcAjBwJ1P2b/d13G7lzRC2QywbAlJQU5OXloU+fPtBqtdBqtdi8\\\n",
       "eTPef/99aLVahIWFobKyEgUFBbLX5ebmwmQyAQBMJpPDrGDbc1sbZwwGA4xGo+xBRETNx8PDA23a\\\n",
       "tIFa7Xhay8vLQ35+PgBAqwWmTpXXf/stkJnZFL0kajlcNgAOHjwYaWlpSE1NtT/69euHcePG2f+t\\\n",
       "0+mwYcMG+2vS09ORmZmJ+L8WhIqPj0daWhry8vLsbdatWwej0YguXbo0+TEREdGV0Wg0iImJcbon\\\n",
       "cHFxMY4dO2Z//uijgLd3Tb3FAvz3v03RS6KWw3HKlIvw9fVFt27dZGXe3t4ICgqyl0+YMAEzZ85E\\\n",
       "YGAgjEYjpk6divj4ePT/6y7gW2+9FV26dMEDDzyAefPmIScnBy+++CImT54Mg8HQ5MdERERXRqVS\\\n",
       "ISIiAgaDwX6/n01FRQUyaw3xBQQADz0EzJ9f0+ajj4CXX5YHQyJ35rIjgJfinXfewR133IGRI0fi\\\n",
       "+uuvh8lkwne15vxrNBr8+OOP0Gg0iI+Px/33348HH3wQr776ajP2moiIrkRISAi8nSQ4i8WC5ORk\\\n",
       "lJSU2MumTQNqLxtYWAh8801T9JKoZVAJIURzd8LVFRUVwc/PD4WFhbwfkIiomZw+fRq33nqr02W8\\\n",
       "OnXqhCVLlqBPnz72sttvB37+uaZNXBxnBLs7nq9ruPUIIBERKUdAQAB69+7tdEeQzMxM/P7777DW\\\n",
       "2gD4iSfkbbZvB3bvbuxeErUMDIBEROQWPDw8cMstt8DHx8ehrqKiAtu2bZPt8jRsGBARIW/38ceN\\\n",
       "3UuiloEBkIiI3IJKpcINN9yADh06ONQJIbB79277cjCAtCTMhAnydl98AZSWNnZPiZofAyAREbmN\\\n",
       "iIgI9OvXz2ldZmYmUlJSUPvW9wkT5JNBioo4GYSUgQGQiIjchk6nQ58+faDT6RzqSktL8fXXX6Ow\\\n",
       "sNBeFh0N3HabvN2HHzZ2L4maHwMgERG5lWuvvRbh4eEO5UIIbN68GXv27JGVO5sMsmNHY/aQqPkx\\\n",
       "ABIRkVvp0KEDBg8e7HRbuPz8fCQnJ8suAzubDPLKK43dS6LmxQBIRERuxcfHB6NHj4avr69DXXV1\\\n",
       "NZKTk2E2m+1lWi0wfbq83erVHAUk98YASEREbqd3796IiYlxWrdz507Z3sAAMGkSEBIib8dRQHJn\\\n",
       "DIBEROR2/P390bNnT6eLQmdkZGDVqlWyPYO9vYG//13ejqOA5M4YAImIyO3odDoMGDAAXl5eDnUV\\\n",
       "FRVYsWIFzp07JyufONFxFPAf/2jEThI1IwZAIiJyOyqVCgMHDkT79u2d1h88eNBhz2Bno4A//yzN\\\n",
       "CiZyNwyARETkltq1a4fbb7/d6Wzg4uJirFixAiUlJbLyiROB0FB521dfbcxeEjUPBkAiInJLer0e\\\n",
       "d999N4KCghzqrFYrfvjhB6SkpMjK67sXMDm5MXtK1PQYAImIyG116NAB/fr1czoZJCsrC0uWLEFl\\\n",
       "ZaWs/MknHe8FfP31xuwlUdNjACQiIrfl7++PUaNGwdvb26HOarViw4YNOHnypKzc2xt4+ml525Ur\\\n",
       "gdTURuwoURNjACQiIrelVqsxZMgQ9OnTx2l9VlYWli9f7jAKOGkSEBgob8tRQHInDIBEROTWTCYT\\\n",
       "7rvvPnh6ejrUmc1m/O9//3OYEezrC8ycKW/7f/8H7N3bmD0lajoMgERE5NbUajVuuOEGdOzY0Wn9\\\n",
       "0aNHMX/+fBQXF8vKp0wB/P3lbTkKSO6CAZCIiNxedHQ0hg8fDr1e71AnhMDKlSvxzTffoLq62l7u\\\n",
       "5+e4R/A33wAHDjRyZ4maAAMgERG5PU9PTzz00EPo37+/0xnB+fn5WLBgAU6cOCErf+opwGiseS4E\\\n",
       "9wgm98AASEREihAVFYXp06cjODjYaX1aWhrmz5+PgoICe1lAgBQCa1u2DNizpxE7StQEGACJiEgR\\\n",
       "1Go1br75ZgwdOhQajcahvqqqCl999RXWrFkDq9VqL3/6acd7AefMaeTOEjUyBkAiIlIMPz8/TJs2\\\n",
       "DZ07d3Zaf+bMGbz33nuytQH9/Z2vC/jnn43YUaJGxgBIRESK0qNHD0yZMsXp4tAAsGvXLixYsEC2\\\n",
       "T/C0aUDdHeVeeqkxe0nUuBgAiYhIUbRaLUaMGIEbb7wRarXjadC2NuDGjRvtl4J9fYHnnpO3W7sW\\\n",
       "+O23pugxUcNjACQiIsUJCQnByy+/XO+l4LNnz2LevHlIT0+3l02aBJhM8nb33gtYLI3ZU6LGwQBI\\\n",
       "RESK1KtXLzzxxBMwGAxO63fs2IE333zTPivYywt44QV5m5wcIDIS+PhjwGxu5A4TNSAGQCIiUiSd\\\n",
       "TodRo0YhISHB6aXgqqoqLF++HB999BHKysoAAI89JgW+2rKzgccfB9q2Bd56C6izoQhRi8QASERE\\\n",
       "ihUWFoaXX34ZsbGxTutLSkrw1ltv4csvv4TZbIbBAPzrX87fKzsbePZZICoKePFF4MyZRuw40VVi\\\n",
       "ACQiIsVSqVTo06cPpk6dioCAAKdtzpw5g9dffx2ff/45ysrKMHYs8MMPQO/ezt+zoAD45z+B6Ghp\\\n",
       "EenMzMbrP9GVYgAkIiJF02g0GDNmDMaNGwedTue0zcmTJ/H8889j0aJFKC8vx513Aikp0kzgm25y\\\n",
       "/r7l5cB//gO0bw9MmAAcPtyIB0F0mRgAiYhI8fz9/TFjxgwMGTIEWq3WaZv8/Hy89tprWLhwIQoK\\\n",
       "CqBSAbfeCmzcCCQlAcOHO3/vqipg0SIgNhYYM4bbyFHLwABIREQEoG3btnjllVcQFxcHlUrltE1e\\\n",
       "Xh5ee+01/Otf/0J+fr69vH9/YMUKYP9+4KGHAGcZ0mqV9hHu2RO46y5g27ZGOhCiS8AASEREBOl+\\\n",
       "wF69euH1119Hz5496w2BBQUFePfdd/Hiiy/KtowDgM6dgU8/BY4eBaZMATw8nH+vVauA+Hhg6FDp\\\n",
       "UjJRU2MAJCIi+otarcbAgQOxYMECxMfHO10eBgAqKiqwePFiTJw4Edu2bYO5ziKAUVHS/X8nTgCz\\\n",
       "Zkk7iTizZg3Qrx8wYgSwd28DHwzRBTAAEhER1aLVatG/f38kJiaiW7du9Y4Ems1mrF69Gvfffz/m\\\n",
       "z5+PvLw8hzZhYcDcuUBGBvDqq0BgoPPvuWIF0KMHcN99wKFDDXk0RM4xABIREdWhUqnQv39/zJ07\\\n",
       "F3FxcfVODBFC4OjRo5gzZw4eeeQRrF+/HiUlJQ7tAgKAl16SguBbb0nB0PG9gK+/Brp0AR5+GDh4\\\n",
       "sKGPiqiGSgghmrsTrq6oqAh+fn4oLCyE0Whs7u4QEVEDqaqqwv79+zF37lysXLkS5eXl9bZVqVQw\\\n",
       "mUwYOXIknnjiCXTs2BF6vd5p29JSYP58aVHpc+fq//533iktLj1wIFDPQCRdBp6vazAANgB+oIiI\\\n",
       "3Ft2djbmz5+P+fPn2/cGro9Go0H79u3x+OOP495770WrVq3qvYxcWAi8+y7w739feAu5uDgpCA4f\\\n",
       "Dmg0V3wYisfzdQ0GwAbADxQRkfsrLi7GsmXL8NZbb+HQoUO42OnTy8sLPXr0wGOPPYZbbrkFERER\\\n",
       "0NST3s6elS4Nv/8+8Ne2w061bw/MnAmMHw94eV3N0SgTz9c1GAAbAD9QRETKUF1dja1btyIxMRG/\\\n",
       "/vqrw+xfZzw9PdG3b1/cfffdGD58OKKiouq9NJybK4XABQukLeXqExgIPPEEMGkS0Lr1FR6MAvF8\\\n",
       "XYMBsAHwA0VEpBxCCJw6dQrvvfcevvrqK2RnZ1/S63Q6HaKiojBixAjcdttt6N69O4KCgpwuNVNc\\\n",
       "DPzvf8A771x4L2GtFvjb34Dp06XLxHRhPF/XYABsAPxAEREpT0FBAbZv347PPvsM69atw9mzZy96\\\n",
       "WRiQ7hEMDg5G586dMXz4cNx1112IiIiAwWBwaFtVBXz7LfDmm8CuXRd+3/79gWnTgJEjgXq2NFY8\\\n",
       "nq9rMAA2AH6giIiUq6ysDD/99BPefvttJCcno7q6+pJfq9FoEBsbi1tuuQU333wz+vfv73RUUAhp\\\n",
       "z+G33pIWj76QyEjgv/+VtpsjOZ6vazAANgB+oIiIlM1isSArKwtffPEFli1bhvT0dFRVVV3y6zUa\\\n",
       "DXx8fBAbG4vRo0djxIgRiIyMdHp5+OBB6T7Bzz678ISRJ58E3nsPqOd2Q0Xi+boGA2AD4AeKiIgA\\\n",
       "oLKyEgcOHMDKlSuxfPlyHDt2DGUXSmlOGAwG9O7dG4888giGDRuGsLAwp7OHz50DPvlE2nIuK8v5\\\n",
       "ew0YIF1CDg+/kqNxPzxf12AAbAD8QBERUW0WiwXZ2dlYu3Ytli1bhq1bt6K0tPSy3kOv16NXr14Y\\\n",
       "P3487rnnHphMJqfrCVZVSVvJvfMOsG2b4/tERAD/93/SPYJKx/N1DQbABsAPFBEROWO1WpGfn49N\\\n",
       "mzZhyZIl2LVrF3Jzcy9p+Rgbb29v9OrVCw8++CBuv/12REREOL00LATw6afAlClA3Q1L9HppaZkJ\\\n",
       "E672iFwbz9c1GAAbAD9QRER0IUIIFBcXY//+/fjjjz/w7bffIi0tDeXl5bBarZf0HgaDAQMHDsSU\\\n",
       "KVNw6623wquelaBTU6UdQzIyHOsmTZJGCpV6XyDP1zUc/4RwIf/4xz+gUqlkj9jYWHt9RUUFJk+e\\\n",
       "jKCgIPj4+GDkyJHIzc2VvUdmZiaGDRsGLy8vhIaG4tlnn72sGVxEREQXo1KpYDQa0b9/f0yfPh2r\\\n",
       "Vq3CF198gUcffRRdu3Z1ugRMXWazGRs2bMAjjzyCGTNmYP/+/U7DY69eQHIycPPNju+xYAGQkCDt\\\n",
       "PELK5tIBEAC6du2K7Oxs++P333+3182YMQOrVq3C8uXLsXnzZpw+fRojRoyw11ssFgwbNgyVlZXY\\\n",
       "unUrPvvsMyxevBhz5sxpjkMhIiIFsK0DOHz4cLz77rv47rvv8NZbb6Fv377w8PC46OvPnz+PRYsW\\\n",
       "YcKECfj+++9RUlLi0CY4GFi7Vto2rq7ffpPuBzx8uCGOhlyWcGEvv/yy6Nmzp9O6goICodPpxPLl\\\n",
       "y+1lBw4cEABEUlKSEEKI1atXC7VaLXJycuxtFi5cKIxGozCbzZfcj8LCQgFAFBYWXtmBEBGRolmt\\\n",
       "VnHq1Cnx1ltviT59+gidTicAXPQREBAgpk2bJg4dOiSsVqvT9/7qKyE8PISQ7hKseQQGCrF5cxMf\\\n",
       "aDPj+bqGy48AHj58GBEREWjXrh3GjRuHzL/2zElJSUFVVRUSEhLsbWNjYxEVFYWkpCQAQFJSErp3\\\n",
       "746wsDB7myFDhqCoqAj79u1r2gMhIiLFUqlUiIiIwLRp0/Ddd99h3rx56NOnT717BtucP38eCxYs\\\n",
       "wBNPPIFNmzY5XXvwvvuArVsd9ww+d066HPzllw15JOQqXDoAxsXFYfHixVizZg0WLlyI48ePY9Cg\\\n",
       "QSguLkZOTg70ej38/f1lrwkLC0NOTg4AICcnRxb+bPW2uvqYzWYUFRXJHkRERFdLq9UiOjoaU6dO\\\n",
       "xddff42XXnoJUVFRTmf92lRVVWHTpk145JFH8PHHH6OgoMChTe/ewPbt0lf5a4EHHgD+8Q9pXJCU\\\n",
       "w6UD4NChQzFq1Cj06NEDQ4YMwerVq1FQUIBvvvmmUb9vYmIi/Pz87I/IyMhG/X5ERKQsGo0GHTt2\\\n",
       "xHPPPYcVK1bggQcegJ+fX73thRA4ceIEnnnmGUyaNAl79+51mCASEQFs2QLceafj6195Bbj/fqCi\\\n",
       "oqGPhFoqlw6Adfn7+6Njx444cuQITCYTKisrHf4Sys3NhclkAgCYTCaHWcG257Y2zsyePRuFhYX2\\\n",