HMM_Viterbi_CDMA.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "w-A676oSu4HF"
      },
      "source": [
        "# HMM inference and MAP estimation in Gilbert-Elliot channel model\n",
        "## TensorFlow implementation of Viterbi algorithm and the parallel version of it.\n",
        "\n",
        "This notebook implements the algorithms from Ref.[2]\n",
        "\n",
        "[2] S. S. Hassan, S. Särkkä and Á. F. García-Fernández (2021). __Temporal Parallelization of Inference in Hidden Markov Models__. *__IEEE Transactions on Signal Processing__*, Volume: 69, Pages 4875-4887. DOI: [10.1109/TSP.2021.3103338](https://doi.org/10.1109/TSP.2021.3103338)\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "B5TGeivbzxRI"
      },
      "source": [
        "### Imports and utilities"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "vK5Nq0QJu_6j"
      },
      "outputs": [],
      "source": [
        "# Python specific imports that will make our job easier and our code prettier\n",
        "from collections import namedtuple\n",
        "from functools import partial\n",
        "import math\n",
        "import time\n",
        "from tqdm.auto import trange, tqdm\n",
        "\n",
        "# TF specific imports that we will use to code the logic\n",
        "from tensorflow import function\n",
        "import tensorflow as tf\n",
        "import tensorflow_probability as tfp\n",
        "\n",
        "# Auxiliary libraries that we will use to report results and create the data\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "import scipy as sc\n",
        "\n",
        "# Utilities\n",
        "mm = tf.linalg.matmul\n",
        "mv = tf.linalg.matvec\n",
        "\n",
        "# device = '/TPU:0'\n",
        "device = '/GPU:0'\n",
        "\n",
        "# check if device is available\n",
        "# tf.test.is_gpu_available()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WHKrIHFHwy0Z"
      },
      "source": [
        "### Model"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FygQyOGxzxRL"
      },
      "source": [
        "We consider the Gilbert-Elliot channel model. This is  a classical model used in the transmission of signals in digital communication channels. We consider two inputs: one for input signal and another for channel regime signal. They are binary signals and represented by $b_k$ and $s_k$, respectively.\n",
        "\n",
        "The input signal $b_k$ is flipped by an idependendent error. We can model this as\n",
        "$$\n",
        "y_k = b_k \\oplus v_k\n",
        "$$\n",
        "\n",
        "The regime channel signal $s_k$ is represented as two states hidden Markov model, which can have either a good or a bad channel condition. The good state has a low probability error, while the bad state can have a high probability error. If $v_k = 1$ i.e. an error occurs, where $y_k \\neq b_k$, then\n",
        "\n",
        "- $q_0$ represents the probability of the error in the good state.\n",
        "- $q_1$ represents the probability of the error in the bad state.\n",
        "\n",
        "The transition probability can be represented as\n",
        "\n",
        "- $p_0$: transition from high error state (bad state) to low error state (good state).\n",
        "- $p_1$: transition from low error state (good state) to high error state (bad state).\n",
        "- $p_2$: switching probability of $b_k$.\n",
        "\n",
        "The joint model $x_k = (s_k, b_k)$ is a four-state Markov chain. That is,\n",
        "$$\n",
        "x_k = \\{(0, 0), (0, 1), (1, 0), (1, 1)\\}\n",
        "$$\n",
        "and encoded as $\\{0, 1, 2, 3\\}$. Our transition and observation matrices are as follows:\n",
        "\n",
        "\n",
        "$$\n",
        "\\Pi = p(x_k \\mid x_{k-1}) = \\begin{pmatrix}\n",
        "(1 - p_0)(1 - p_2) & p_0 (1 - p_2)   & (1 - p_0)p_2        & p_0 p_2 \\\\  \n",
        "p_1 (1 - p_2)      & (1-p_1) (1-p_2) & p_1 p_2             & (1- p_1) p_2 \\\\\n",
        "(1 - p_0)          & p_0 p_2         & (1 - p_0) (1 - p_2) & p_0  (1 - p_2) \\\\\n",
        "p_1 p_2            & (1 - p_1)p_2    & p_1 (1 - p_2)       & (1 - p_1) (1 - p_2)\n",
        "\\end{pmatrix}\n",
        "$$\n",
        "\n",
        "and\n",
        "\n",
        "$$\n",
        "O = p(y_k\\mid x_k) = \\begin{pmatrix}\n",
        "(1 - q_0) & q_0 \\\\\n",
        "(1 - q_1) & q_1 \\\\\n",
        "q_0 & (1 - q_0) \\\\\n",
        "q_1 & (1 - q_1)\n",
        "\\end{pmatrix}\n",
        "$$\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "GiqvK_b_wHVK"
      },
      "outputs": [],
      "source": [
        "class HMMModel:\n",
        "    def __init__(self, p0=0.03,  p1=0.1, p2=0.05, q0=0.01, q1=0.1):\n",
        "        \"\"\"Gilbert-Elliot channel model.\n",
        "\n",
        "        :math:``\n",
        "            p0: `P(S_{k+1} = 1 | S_{k} = 0)`\n",
        "            p1: `P(S_{k+1} = 0 | S_{k} = 1)`\n",
        "            p2: `P(B_{k+1} = 1 | B_{k} = 0) = P(B_{k+1} = 0 | B_{k} = 1)`\n",
        "            q0: `P(Y_k != b | B_k = b, S_k = 0)`\n",
        "            q1: `P(Y_k != b | B_k = b, S_k = 1)`\n",
        "\n",
        "        \"\"\"\n",
        "        # transition matrix\n",
        "        self.np_Pi = np.array([\n",
        "                               [(1-p0)*(1-p2), p0*(1-p2),     (1-p0)*p2,     p0*p2],\n",
        "                               [p1*(1-p2),     (1-p1)*(1-p2), p1*p2,         (1-p1)*p2],\n",
        "                               [(1-p0)*p2,     p0*p2,         (1-p0)*(1-p2), p0*(1-p2)],\n",
        "                               [p1*p2,         (1-p1)*p2,     p1*(1-p2),     (1-p1)*(1-p2)]\n",
        "                               ])\n",
        "\n",
        "        # observation matrix\n",
        "        self.np_Po = np.array([\n",
        "                               [(1-q0), q0],\n",
        "                               [(1-q1), q1],\n",
        "                               [q0, (1-q0)],\n",
        "                               [q1, (1-q1)]\n",
        "                            ])\n",
        "\n",
        "        # prior\n",
        "        self.np_prior = np.array([0.25, 0.25, 0.25, 0.25])\n",
        "\n",
        "        # convert to tensor\n",
        "        self.Pi    = tf.convert_to_tensor(self.np_Pi)\n",
        "        self.Po    = tf.convert_to_tensor(self.np_Po)\n",
        "        self.prior = tf.convert_to_tensor(self.np_prior)\n",
        "\n",
        "        # dimensions\n",
        "        self.Pi_dim = self.Pi.shape[-1]\n",
        "        self.Po_dim = self.Po.shape[-1]\n",
        "        self.prior_dim = self.prior.shape[-1]\n",
        "\n",
        "        # transition, observation, and prior in log-space\n",
        "        self.log_Pi    = tf.math.log(self.Pi)\n",
        "        self.log_Po    = tf.math.log(self.Po)\n",
        "        self.log_prior = tf.math.log(self.prior)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "lCDkYwoAzxRM"
      },
      "outputs": [],
      "source": [
        "def catrnd(rng, p):\n",
        "    if p.ndim > 1:\n",
        "        p = p.squeeze()\n",
        "\n",
        "    return rng.choice(p.shape[0], size=1,  p=p)\n",
        "\n",
        "\n",
        "def simulate_data(model: HMMModel, steps:int, seed:int=1):\n",
        "    rng = np.random.default_rng(seed)\n",
        "\n",
        "    X = np.zeros((steps, 1))\n",
        "    Y = np.zeros(steps, dtype=np.int64)\n",
        "    x = catrnd(rng, model.np_prior)\n",
        "\n",
        "    for k in range(steps):\n",
        "        if k > 0:\n",
        "            x = catrnd(rng, model.np_Pi[x])\n",
        "        y = catrnd(rng, model.np_Po[x])\n",
        "        X[k] = x\n",
        "        Y[k] = y\n",
        "\n",
        "    return X, Y\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6Ulz1zf0zxRN"
      },
      "source": [
        "#### Initialize the parameters"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "3OJXpCtHzxRN"
      },
      "outputs": [],
      "source": [
        "log10T = 5\n",
        "nsteps = 100\n",
        "T = np.arange(10 ** log10T)+1"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Pa7Eh5qMzxRO"
      },
      "source": [
        "#### Initialize the model"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "8XWBcn54zxRO"
      },
      "outputs": [],
      "source": [
        "model = HMMModel()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "S34XbyIGzxRO"
      },
      "source": [
        "#### Simulate the data"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "HoDHVeFZzxRO"
      },
      "outputs": [],
      "source": [
        "X, Y = simulate_data(model,10 ** log10T)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wqz2lD3SzxRP"
      },
      "source": [
        "#### Plot the simulated data"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 297
        },
        "id": "omRIWAjIzxRP",
        "outputId": "182f4191-f8a7-4851-947a-e0b62b880eb3"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "<matplotlib.legend.Legend at 0x7fdc60776150>"
            ]
          },
          "execution_count": 7,
          "metadata": {},
          "output_type": "execute_result"
        },
        {
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEGCAYAAABo25JHAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO29eZgU1dX4/znd0z0rmzBugICKC6IgjKKSxIUYUYk77lH8GY275ht3fV0iWXyT1y36uiTxVRPjRlxxF4jiLhBE3FFQBo1sMjBrb/f3R3XP9DS9VPdUTdPV5/M880x11a1bp24tp+4995wjxhgURVGU8sVXbAEURVGU4qKKQFEUpcxRRaAoilLmqCJQFEUpc1QRKIqilDkVxRYgXwYNGmSGDx9ebDEURVFKivnz5682xtSn21ZyimD48OHMmzev2GIoiqKUFCLyVaZtOjSkKIpS5qgiUBRFKXNUESiKopQ5JWcjSEc4HKaxsZH29vZii6I4RFVVFUOGDCEQCBRbFEXxPJ5QBI2NjfTp04fhw4cjIsUWR+khxhjWrFlDY2MjI0aMKLY4iuJ5XBsaEpEqEXlXRN4XkQ9F5Po0ZSpF5BERWSIi74jI8EKO1d7ezsCBA1UJeAQRYeDAgdrDU1xh5fp2jr37LVZuaN8klguRyWnc7BF0AAcYY5pFJAC8LiLPG2PeTipzOvC9MWZ7ETkeuBE4rpCDqRLwFno9Fbe4bdbnvLdsLbe98jlA0ZenH7lr3jJNP3JXR9tEeiMMtYjUAK8DZxtj3kla/yJwnTHmLRGpAP4D1JssQjU0NJhUP4KPP/6YnXfe2R3hlaKh11Vxkh2vfp6OSKzYYjhGZYWPT6cfbLu8iMw3xjSk2+bqrCER8YvIQmAl8HKyEogzGFgOYIyJAE3AwDT1nCki80Rk3qpVq9wUuSDWrFnD2LFjGTt2LFtuuSWDBw/u/B0KhVw77pNPPslHH33kWDlF8TJzL92fg3bZothi9JiqgI/Dx27N3Mv2d6xOVxWBMSZqjBkLDAH2FJHRBdZzjzGmwRjTUF+f1kM6b5wcbxs4cCALFy5k4cKFnHXWWfzyl7/s/B0MBolEIg5IvDGqCBTFPpv3raKywnrlVfi6hh4T64qxLAIjN69DxP4+HZEYfSor2LxPVdbzzYde8SMwxqwD5gCTUzatAIYCxIeG+gFrekOm1DE5p5k2bRpnnXUWEyZM4NJLL+W6667jj3/8Y+f20aNHs2zZMgD+/ve/s+eeezJ27Fh+8YtfEI1GN6rv8ssvZ9SoUey2225cfPHFvPnmmzz99NNccskljB07li+++II///nP7LHHHowZM4ajjz6a1tbWtOW++OILJk+ezPjx4/nhD3/IJ598AsBjjz3G6NGjGTNmDD/60Y9caRdFKSarNlg99MsP3omhA6oZOqCaJ86ZWLTlkyYMo6ktzEkThuW1z6rmDkfbxTUbgYjUA2FjzDoRqQZeAm40xsxMKnMusKsx5qy4sfgoY8yx2erNZSO4/pkP+eib9Rn3f3fZWtKdsgjsOXyztPuM2rov1/50l2xidXLddddRV1fH4sWLWb16NU899RR+v79z/cUXXwxYimDmzJm0tbVx6aWX8vjjjxMIBDjnnHPYa6+9OOWUUzrrXLNmDfvssw+ffPIJIsK6devo378/06ZNY8qUKRxzzDGd5QYOtEbWrr76arbYYgvOP//8jcpNmjSJu+66i5EjR/LOO+9wxRVXMHv2bHbddVdeeOEFBg8e3HmMYqI2AsVp3l26lmPvfou/nz6BH4wcVGxxepVsNgI3Zw1tBdwvIn6snsejxpiZIvJrYJ4x5mngr8DfRGQJsBY43kV5ABg7pD9fr23l+9YQMQM+gQE1QbbZrMbxY02dOhW/35+1zKxZs5g/fz577LEHAG1tbWy++ebdyvTr14+qqipOP/10pkyZwpQpU9LWtXjxYq6++mrWrVtHc3MzBx100EZlmpubefPNN5k6dWrnuo4O6+ti4sSJTJs2jWOPPZajjjoqr3NVlFKgJWQN09ZUZn8uyw3XFIExZhGwe5r11yQttwNTU8v0BDtf7lc98QH/ePdrKit8hKIxDh69pePTsQBqa2s7lysqKojFumYsJObIG2M49dRT+d3vfpexnoqKCt59911mzZrFjBkzuP3225k9e/ZG5aZNm8aTTz7JmDFjuO+++/jXv/61UZlYLEb//v1ZuHDhRtvuuusu3nnnHZ599lnGjx/P/PnzO3sYiuIFWjusYdfaoCd8aR2jLGMNrW7u6ByTc2O8LR3Dhw9nwYIFACxYsIClS5cC1jDNjBkzWLlyJQBr167lq6+6R4ttbm6mqamJQw45hJtvvpn3338fgD59+rBhw4bOchs2bGCrrbYiHA7z4IMPdq5PLte3b19GjBjBY489BliKKFHfF198wYQJE/j1r39NfX09y5cvd6MpFKVodPYIgtojSKYs1eLdP+saJpt+REETmfLm6KOP5oEHHmCXXXZhwoQJ7LDDDgCMGjWK6dOn85Of/IRYLEYgEOCOO+5g2LBhnftu2LCBww8/nPb2dowx3HTTTQAcf/zxnHHGGdx2223MmDGDG264gQkTJlBfX8+ECRM6X/6p5R588EHOPvtspk+fTjgc5vjjj2fMmDFccsklfP755xhjmDRpEmPGjOmVtlGU3qK1w1IEtZVl+erLSK84lDmJOpSVD3pdFae5Y84S/vDip3xyw2SqAuXVKyiaQ5miKMqmRGsogt8n3ebmK6oIFEUpI1o6otQE/RrLKgVVBIqilA2toYjOGEqDKgJFUcqG1lBUfQjSoIpAUZSyoTUU1R5BGlQRKIpSNrR0RNSHIA2qCByisbGRww8/nJEjR7Lddttx4YUXdoagvu+++zjvvPOKLOHG1NXV2S57yy230Nra6lg5RSkGraGo+hCkoTwVwaJH4ebRcF1/6/+iR3tUnTGGo446iiOOOILPP/+czz77jObmZq666iqHBN4Yt0JbZ0IVgeIFWkLaI0hH+SmCRY/CMxdA03LAWP+fuaBHymD27NlUVVVx2mmnAeD3+7n55pu59957O1+Ky5cvZ7/99mPkyJFcf72VvrmlpYVDDz2UMWPGMHr0aB555BEA5s+fz7777sv48eM56KCD+PbbbwHYb7/9uOiii2hoaOA3v/kNw4YN64xf1NLSwtChQwmHwxnDTC9dupS9996bXXfdlauvvjrtuaST6bbbbuObb75h//33Z//9rWQYZ599Ng0NDeyyyy5ce+21AGnLvfTSS+y9996MGzeOqVOn0tzcDGwcVltReoPWDrURpMObLfJ/h268bpcjYM8z4JXrIdzWfVu4DZ6/DHY7FlrWwKOndN9+2rNZD/fhhx8yfvz4buv69u3LNttsw5IlSwB49913Wbx4MTU1Neyxxx4ceuihfPXVV2y99dY8+6xVf1NTE+FwmPPPP5+nnnqK+vp6HnnkEa666iruvfdeAEKhEAnP6gULFvDqq6+y//77M3PmTA466CACgQBnnnlmtzDT55xzDrNnz+bCCy/k7LPP5pRTTuGOO+5Iey4vvPDCRjL169ePm266iTlz5jBokBW69ze/+Q2bbbYZ0WiUSZMmsWjRIi644IJu5VavXs306dN55ZVXqK2t5cYbb+Smm27i3HPP5YknnugWVltReoOWUERnDaWh/HoE61ekX9+21tXDHnjggQwcOJDq6mqOOuooXn/9dXbddVdefvllLrvsMubOnUu/fv349NNPWbx4MQceeCBjx45l+vTpNDY2dtZz3HHHdVtO9CIefvhhjjvuuG5hphOJbhI9ijfeeIMTTjgBgJ/97Gdp5UwnUzoeffRRxo0bx+67786HH36YNgPa22+/zUcffcTEiRMZO3Ys999/P1999VW3sNqPP/44NTXOhwBXlFSMMTprKAPebJFsX/D9hsSHhVLXD7X+1w7M2QNIZdSoUcyYMaPbuvXr1/P111+z/fbbs2DBgo08GUWEHXbYgQULFvDcc89x9dVXM2nSJI488kh22WUX3nrrrbTHSg5tfdhhh3HllVeydu1a5s+fzwEHHEBLS0vGMNOJ42YjnUzXXHNNtzJLly7lj3/8I++99x4DBgxg2rRpnWG1kzHGcOCBB/LQQw9ttM1OWG1FcZKOSIxozGiPIA3l1yOYdA0EqruvC1Rb6wutctIkWltbeeCBBwCIRqP86le/Ytq0aZ1fuy+//DJr166lra2NJ598kokTJ/LNN99QU1PDySefzCWXXMKCBQvYcccdWbVqVaciCIfDfPjhh2mPW1dXxx577MGFF17IlClT8Pv9WcNMT5w4kYcffhigW5jqZNLJBN1DWa9fv57a2lr69evHd999x/PPP9+5f3K5vfbaizfeeKNzeKylpaXTkJ4urLaiuElrSHMRZKL8WmS3eCbMWb+GpkarhzDpmq71BSAiPPHEE5xzzjnccMMNxGIxDjnkEH772992ltlzzz05+uijaWxs5OSTT6ahoYEXX3yRSy65BJ/PRyAQ4M477yQYDDJjxgwuuOACmpqaiEQiXHTRReyyS/qEO8cddxxTp07tloQmU5jpW2+9lRNPPJEbb7yRww8/PG19H3zwwUYyAZx55plMnjyZrbfemjlz5rD77ruz0047MXToUCZOnNi5f2q5++67jxNOOKEzC9r06dPp06dP2rDaiuImLR2aiyATGoZa2WTR66o4yaf/2cBBt7zGHSeO49Ddtiq2OL2OhqFWFKXs0XzFmVFFoChKWaD5ijPjGUVQakNcSnb0eipOo/mKM+MJRVBVVcWaNWv05eERjDGsWbOGqqqqYouieIjWkOYrzoQnWmTIkCE0NjayatWqYouiOERVVRVDhgwpthiKh2jpHBrSHkEqnlAEgUCAESNGFFsMRVE2YVo7jcWeeO05imtDQyIyVETmiMhHIvKhiFyYpsx+ItIkIgvjf4V7dSmKomQh0SOoDmiPIBU3VWME+JUxZoGI9AHmi8jLxpjUoDRzjTFTXJRDURSF1lCE6oAfv08T16fiWo/AGPOtMWZBfHkD8DEw2K3jKYqiZMNKSqO9gXT0yqwhERkO7A68k2bz3iLyvog8LyJp4yiIyJkiMk9E5qlBWFGUQmgNRalRH4K0uK4IRKQO+CdwkTFmfcrmBcAwY8wY4E/Ak+nqMMbcY4xpMMY01NfXuyuwoiieRPMVZ8ZVRSAiASwl8KAx5vHU7caY9caY5vjyc0BARAa5KZOiKOWJ5ivOjJuzhgT4K/CxMSZteEkR2TJeDhHZMy7PGrdkUhSlfNF8xZlxUz1OBH4GfCAiiSwpVwLbABhj7gKOAc4WkQjQBhxv1D1YURQXaO2IskUf9VZPh2uKwBjzOpB1npYx5nbgdrdkUBRFSaD5ijPjiVhDiqIoudB8xZlRRaAoSlnQ0qE9gkyoIlAUxfNEojE6IjHtEWRAFYGiKJ6nNWzFGdJZQ+lRRaAoiufpzE6mfgRpUUWgKIrn0exk2VFFoCiK50n0CDTWUHpUESiK4nkSPQLNTpYeVQSKongezU6WHVUEiqJ4Hs1XnB1VBIqieB7tEWRHFYGiKJ5HewTZUUWgKIrn6ewR6KyhtKgiUBTF87SEogT8QrBCX3np0FZRFMXztGm+4qyoIlAUxfO0dETUPpAFVQSKonie1lBUZwxlQRWBoiiepyWkPYJsqCJQFMXztHaojSAbqggURfE8LaEItZqdLCOqCBRF8TytOmsoK6oIFEXxPC0d2iPIhioCRVE8j/YIsqOKQFEUT2OM0VlDOXBNEYjIUBGZIyIficiHInJhmjIiIreJyBIRWSQi49ySZ+X6do69+y1WbmjvtpxrW2/JUYh8m8Kyk+1n93iKksDOfbl8bRvGwBP/XqH3UAbc7CtFgF8ZYxaISB9gvoi8bIz5KKnMwcDI+N8E4M74f8e5bdbnvLdsLbe98jlA5/L0I3fNuq235Mi0nE2+TWHZyfazc55uXBOldLH1XM/+DIDG79v0HsqAGGN650AiTwG3G2NeTlp3N/AvY8xD8d+fAvsZY77NVE9DQ4OZN2+e7ePuePXzdERiBctdWeHj0+kHF7y/U3KUKnbaL9+2ceqaKKXLpvJclxIiMt8Y05BuW6/YCERkOLA78E7KpsHA8qTfjfF1qfufKSLzRGTeqlWr8jr23Ev357CxWxP0S9rtGVZTFfBx+NitmXvZ/nkdL5ccFb4MB8xAJvk2FZxov0Tb5DpVp6+JUrok7plAkZ9rr+C6IhCROuCfwEXGmPWF1GGMuccY02CMaaivr89r3837VtGnsoJwzFCZFIK2ssKHCGxbX4cI3bZV+ISOSIw+lRVs3qeqEJEzyhGJde+BpcpkR75NZdmp9ku0jQGS9WRlSshgp6+JUrp0Pk/RjZ+nbM+N3kPpcVURiEgASwk8aIx5PE2RFcDQpN9D4uscZXVzBydNGMYT50xk6IBqhg6o5olzJnLShGE0tYU7tw3ub90cp00czkkThrGqucNxOXbcoo66yopucmRaTpXPzj69uZwq31b9rPY774Dt826/1c0d1FX62XeH+o2OVxv0M6Am4Mo1UUqX1c0djBvWH4DB/atsPTd6D2XAGOPKHyDAA8AtWcocCjwfL7sX8G6uesePH2/coi0UMcMum2numPO5a8e44vFFZvwNL7tWfzH5rqnNDLtspvn728sK2n/v375iLn504Ubr/+vJD8zY61/sqXiKB/nfOUvMsMtmmtaOSLFF2eQB5pkM71U3Zw1NBH4GfCAiC+PrrgS2iSugu4DngEOAJUArcJqL8uQk4Lc6SOGIewb0cCSW0V5R6nS1X2FGvFDUEEiTQSrg9xGO9s6kBqW0CEetey2TrUCxh2uKwBjzOmS3/8W11LluyZAvfp/g90nnzeUG4Wgs7cvOCyTOq9CXdjgaI+hPrwhCLl4TpXQJR2OIWM+uUjjefCP1gIDfbUVgOr+cvUbiq6zQl3Y4Gkv7ZReMXxPTS1OdldIhFI0R8PsQUUXQE7z5RuoBbn99Jm5cLxLwJXoEPVEE6XsExkA0popA6U44YtL2IpX80BZMIej3uT405FUbgc8nVBQ4tGaMydhb6umQk+JdMvUilfxQRZBCwO9z11js4R4BFG7YTewTzGAshsKHnBTv4vXnqbfQFkwhUOGyjSDiXRsBWHaCUAGzhrLN/kj0oNy8Lkpp4mWbW2+iLZhCr9gIPDprCKwv+kJe2F2KIHOPQBWBkko4Gkvbi1TyQ1swhaDft5HbupNEYt61EYD10i6k/RJDQ9kUgZvXRSlN1EbgDKoIUgi4bSz2/NBQz3oEaf0IKtRGoKRHbQTOoC2YQsAvrr5wvH7jFtp+nUNDFWojUOwTUhuBI2gLpuB2j8DLfgTQ8x5BVhuBi7O5lNLECtni3eept9AWTMEydro7fTSY5qvXKxTafqFIbhuBDg0pqVghW7z7PPUWqghScN1G4PGurCs2Ap01pGTA60OtvYW2YAqFzoO3Szji7Ru3534EG7dNogelikBJRW0EzqAtmILaCHpGoe0XimZ2KNMegZKJTBFrlfzQFkwh6HLsey/HGoLC26/TjyBbiAk1FispqB+BM9hSBCLy3yLSV0QCIjJLRFaJyMluC1cM3OwRRGOGmEk//OEVCrYRRNRGoOSP14daewu7LfgTYyWenwIsA7YHLnFLqGJS4WI+gq658t69cSt66keQzkagikDJQKasdkp+2G3BRCazQ4HHjDFNLslTdAJ+n2vG4lCWl51XKDSMd1YbgRqLlQyojcAZ7KaqnCkinwBtwNkiUg+0uydW8XDTj6Br+MO7Y5qFhvG2E2sopLGGlBTURuAMtlSpMeZyYB+gwRgTxko0f7ibghULN1NVZnvZeYVCw3h3+hFkMRaHXZzWq5Qm6kfgDHaNxTXAOcCd8VVbAw1uCVVMAn4fkZgh5kJaxGzj4F6h0DDeaiNQ8iVbVjslP+y24P8BIaxeAcAKYLorEhWZzq/PmPMvnVAZGIsLthFEsvkRqI1A2ZhsWe2U/LDbgtsZY/4bCAMYY1oBTw7MdX19utgj8Hmy6YCep6pM93Xnj7eX2giUZBLPU4WHn6fewq4iCIlINWAARGQ7oMM1qYpI59enC+PR4SyB1bxCwO8jGjNE8xxayzY0JCIF9zQU71IOQ629hd0WvA54ARgqIg8Cs4DLsu0gIveKyEoRWZxh+34i0iQiC+N/1+QjuFskhm3ceOmUw9BQoVM9w9EYPun6+t+oXr+osVjpRjk8T72FremjxpiXRGQ+sBfWkNCFxpjVOXa7D7gdeCBLmbnGmCl2ZOgt3Ax5nC1Bu1dINuxWBfy298sVgylQYC5kxbt02gg8/Dz1FnZnDc0yxqwxxjxrjJlpjFktIrOy7WOMeQ1Y64iUvUhv2Ai87AATKLD9whGTtV2s2UhqI1C6CEd0aMgpsragiFSJyGbAIBEZICKbxf+GA4MdOP7eIvK+iDwvIrtkkeNMEZknIvNWrVrlwGEz42Zcm3IY0yy0/awEI5nbRW0ESirl8Dz1FrmGhn4BXITlNzCfrplC67GGfXrCAmCYMaZZRA4BngRGpitojLkHuAegoaHB1c/CxLCNG2EmsmXh8gqFtl8uD1E3Hf2U0qQcQrb0Fllb0BhzqzFmBHCxMWZbY8yI+N8YY0yPFIExZr0xpjm+/BwQEJFBPanTCdw0Fnd5z3p3TDNYYPvltBFoj0BJocuPwLvPU29h11j8JxEZDYwCqpLWZzMEZ0VEtgS+M8YYEdkTSymtKbQ+p+gVPwIPf8EUbCOI2rARaD4CJYlyeJ56C1uKQESuBfbDUgTPAQcDr5NlRpCIPBTfZ5CINALXAgEAY8xdwDFYAewiWMHsjjfGFP1JVxtBzyjYRpAjrrzOGlJSUWOxc9iNPnoMMAb4tzHmNBHZAvh7th2MMSfk2H47PbczOE7nGLcrfgRlZCMoyFicuYsfVBuBkoLaCJzDbgu2GWNiQERE+gIrgaHuiVU83Ix0mS0Ll1cIFth+aiNQ8qXLj8C7z1NvYbdHME9E+gN/xpo91Ay85ZpURaTL2OmijcDDxq1Age2XK5xwwO+jJRTtkWyKt4iUwfPUW9g1Fp8TX7xLRF4A+hpjFrknVvFQG0HPKNyPwFCdxRPZSnijPQKlCx0acg7bnsWJZWPMMmPMolyexaVKb9gIvBwtsUc2gix+BMECE94o3kWHhpwja49ARKqAGuKexXQ5lPXFGc/iTQ43k6Ak8quKeFcRFNp+oVyzhtRGoKRQDj3s3iJfz+IEG9gEZ/w4gdvGYi8HnAP3QkwUmudA8S7lEMSxt8ilSt/Eykp2sTFmW+B6YDHwKvAPl2UrCoUaO+2Q62XnBTrbL0/nL1sOZdojUJLozGrn8WeqN8jVgncDHXHP4h8BvwPuB5qIx/7xGm7bCLzejXXNRqB+BEoKaiNwjlxDQ35jTCKU9HHAPcaYfwL/FJGF7opWHAI+920EXqZQG4Gd6aM6a0hJRm0EzpGrBf0iklAWk4DZSdvs+iCUFD6fUOFz5+sz11evFyjURpDTWFyhNgKlO7my2in2yfUyfwh4VURWY8UDmgsgIttjDQ95ErcMk7m+er1Aj4LO5TAWh6IxjDGennWl2CeXN7pin6yKwBjzm7i/wFbAS0lB4XzA+W4LVywCfnEtH4HXb1y38hEk0hFGYsbzvSrFHrmy2in2yTm8Y4x5O826z9wRZ9Mg6FKky3KYNSQieSeRMcbEX/DZewRQHr0qxR7l8Dz1FtqKaajw+Yi4MDQUicXKItF2hc9HJGa//cI2orIWOuSkeJdysLn1FqoI0hBwKZxBuAyGhiD/obXOzG05jMXJZRVFbQTOoa2YBrecl8rlxs13aM2Oh2iiJ6WKQEmQywlRsY+2YhqCLsW1KZfx7XzjAnVGkcwxawjy91hWvEuurHaKfbQV0+Dm9NFySLSdb/vlYyPQMBNKglxZ7RT7qCJIQ76zXuwSLoMQExC3EeQzNGQjc5ubeSKU0qRchlp7A23FNAT8Ppf8CMrjxs03HISdUAGJnpQqAiVBuQy19gbaimlw1Y+gDG7cfNsvZMNYrD0CJRU1FjuHtmIaXLURlMG854JtBDaMxSE1Fitx1I/AOVQRpEFtBD0jbxuBHT8C7REoKZTLUGtvoK2YBlf9CMrAJT7f6aMJe0JWG4EqAiUFDTHhHK6FkhaRe4EpwEpjzOg02wW4FTgEaAWmGWMWuCLMokdh1q+hqRGqB1jr2r6HfkNg5E/g85e6bftT2/d8J4Ng0W9ht2MdEcEYw8HmNc7+90Xw9nfd5ci0nEG+rPv05nIG+R5o+55VPvvtF4rGOMz3OmNnXAIt36Q93ui273k9OJA1Sy+Dnc/MWecmS/K92G8ITLrGsXus3Ni3/V+c9+U/4LqVzj43ydcl07ujJ+Uz7Qv5H88hpCugqLPEM5o1Aw9kUASHYEUwPQSYANxqjJmQq96GhgYzb948+4IsehSeuQDCbfb3SRCohp/e5kiDRxc+QscT51EjoR7XVTLYbL8Pnv8z2719pa22ifirqDj8T6X58kx3Lzp4j5UVix6l7fHzqKbDnfoD1TDmRHj/H/beHfmWT933p7dZy3bfVQXcNyIy3xjTkHabW4ogfuDhwMwMiuBu4F/GmIfivz8F9jPGfJutzrwVwc2joWl5HlKn0G8o/HJx4fvHid20C771jT2up+Sw0X6tN+5MTds3jta5SZLpXizV8ykmPX2u7SB+MFH3yifTb6j1P59zyvO+yaYIijnANhhIPuvG+LqNEJEzRWSeiMxbtWpVfkdp6uHLt6f7x5H1Kxypp+Sw0X7VbVl1f0F1bpJkkrtUz6eY9Eab5ftSL1QJgHU++Z6Tg21QEpYWY8w9xpgGY0xDfX19fjv3G9Kzg/d0/zixvml1nPex0X6t1Vs6XucmSSa5S/V8iklvtJn43S2fTL8h+Z+Tg21QTEWwAhia9HtIfJ2zTLrGGk8rhEC1tb8DrN/nClpN0JG6Sgab7bdw5IW22ybsq3LsmvQ66e5FB++xsmLSNe4+T4FqGD/N/rsj3/Kp+066Jr93lcP3TTEVwdPAKWKxF9CUyz5QELsdaxlV+g0FBKo3s/4Qa13D6WXAa7YAACAASURBVN23AQZojA0iNsU5I96GkUdxefjnRHxV1opkOTItp5Mv1z69ubyRfAM62+8bM8i2MWvJlgdzefjndFqrUo9X2Td+TQby6o5Xl65hNXEv+uMvsNp6NRQXSGz0VC4P/5z1lVvi2HNT2bdr/5/eBlNusv4n1qeWr4i/tPsN6V4+8TLPdqyq/vEyA7rugWzvqtTzc/i+cXP66EPAfsAgEWkErgUCAMaYu4DnsGYMLcGaPnqaW7J0NrIdPnuJhz+HK+aG+WTUZKocEiEUjfF07AdcPWghmwfD8PNXHKp5E+OGzXl786lMWz6FT3c72NYu4WiMZ2N7cxv/C/tfBfte2r3Am39CXrqayaEb+cWgsfzYBbF7jd2OhXfughXzYcrNsPNPiy1RSRKOWc/Tz7YIsYf/Mzj1mZ5X+sDhEGqFn7/ctW70MfD4GbDvZbD/ld3Lv30XvHAZ/GIu1Fgfkex2rLVPtCP7133bOrhxGPzoku7vpvodYfTRsPd5UJfnMHgPcE0RGGNOyLHdAOe6dfyC2eEntHz3JfAx4WiMqkAPxv2S6AysFmmFuv6O1LlJcvw/+PijGOFlYdu7hKIxahLTAIO1GxeIr6uVDm84lPVkLFkB6Ewl279jBYS+dqbSYB00p0xGCbfGt2W+Lwm1dCkCAJ8PfDmGeJL3TeY/i+GNW6DhNKD3FEFJGIt7la/fZvD6hYCz+XETL7CKaJt1w3mVkT+muW4EMQNRm3mLwxFDBwGixz8CO6bpRcTbq5+/g5AXchbXDoItd9XeQA/oDEsSc/B5CtZCqLn7usSLOp0i2G5/OGkG1Azsvv61P8D8+7Ifyx8Af2WW4/XuO8K1HkHJ8sp17N4cBS5y9OuzSxG0pr+pvMKy1xm64T9ANeFoDL8v99dvOBoj6gvi32ly+gLx9urnD3mjR7DN3hDatdhSlDShZEVQ5dDzFKzd+As98aJO92LONNNn0aOwxS6W8bjg4/XuO0J7BKkEawnELM8+J3MSJKJmrt7uaNj+QMfq3eR4+Vr2+PovgP1sYuFojHp/M3zyHLSs2bhA/KHo6/PI0NA+58N/PoB/P1hsSUqWzoi10XbnXprB2q6hoM4DZRkaavsePnkWNnzXfX2oxZ5MJzwEe6eMjodaQHxQ4ZR10h6qCFIJ1BCIWhffjR7BynEXwm5THat3kyNYa32lge3kNKFojJ39K+DhE2DlhxsXGPYDuOo/fODfxRuKQAS+fBVWflRsSUqWxL3VNGAUDE7rLJs/e54Jpz3Xfd0Wo+HKb2HkQRuX/34ZPHyiZfhPJtRsb2hnm71gs227rwu3WvtK74bX1qGhVIJ1BKLxF5njNgJDZbQFYv3AxpBJSRKsIxC1ZgHbbb9wNEZfXwfESP8l5a8AfwWBCr838hHcOgbCLRuPDyu2SXwQfLz7NWy329bOVNp/G+svGREI1qQvn3jZJw/vGGO/R/DFHIhFYWTSPLiDfgs/vi4fqR1BewSpBGvxR9zpEdTSzugHRsPb/+tYvZscwZokRWpzaChi6COJWUNpvqTam+D5yxknn3ijR9DeZP1PHR9WbNOV1c7BV9iaL2De/0HHhq513yyEF66A5pUbl0+87MNJ1zEasozAdhTB6zfDa//dfZ0IVFTmL3sPUUWQyl5n88G+fwbsj3HbIRQ11NBu/fCysThYaxnEyc9GUOfPMn00FoV37mRn86U3FEFCAagiKJhEb/NHz02C129xptIV82HmRd3H/Fd+ZH24pdoOIP0U0IpKuOob+OGvch8vWLfxPfD2nfDGrfnL3kNUEaQycDs6thgH2B/jtkM4EqNWEorAw9NH97mA+RPvAuz3CELRGHVSJn4EkZD11QjWNFKlIMLRGH6iVLc0drVnT0n3hZ9tOmcggy9APsdLHR78eCZ89mJh9fUAVQSprPmCLZc+TiUhx20EtdmcprzCwO1oGzQGsIZ87BCOxniz8gdw6sy4O38K/iD4KqgRD/gRJF4yk38Ph/2puLKUMOFIDifEQgjEbQHJL/bEizqQxk7gr4Bpz8HYk7rWrVsO//w5fPPv3MfLNH20CO8HVQSpLHudbd+4hAFscNxGUBZDQ6s+Y+hXMwgSzmNoyLAhUA8jfpjeiC4CgVpqaXe0l1YUxGfNTtlyt2JLUtKE3Hie0hl/Qy2AZA4XMXwi9EuKLNy8Ej54DFpW2zheOkVg09DsMKoIUukchmh33EbwLZvRvs/FG08Z8xLLXmPHd66kHy32jcXRGKNjH8NHT2cuVNmHoERKf2ioqh8c8gdofA8eyhqFRclCOGqcH2rtHPNPGq6JhqCyT+bpnJ88B0tf6/qdj0PYXufAGbO7ryuSItDpo6nEb6pa2h3vETSazTH7nQJBj04dhc72qxH77ReKxDio/UV44WMYdVj6Qr9czN/ve49wS4mn+oxGrAQmTcvh67eKLU3JEo7G6DAB1m/3U/oOGO5MpQO3g3PfheTcIQf+GiZdl3mf2TdY+434kfU78YWfbigplX6D2SgXl/jSD4+6jCqCVJJ6BI4qgkiMOloJtH4HFVtagam8SKL98lCkncNm2b6ERAj4faVvI/j6Tbj/p5YTlM4aKphwNMYK6lk9+S761jvUI6iotKJ/ppLtWU0d3sknVtCqz+DLOTD2RKvXAfD/0jhU9gIefRv1gPjLqIZ228ZOO4SjMY7xz6Xilp0t13SvktR+dp2/wlFDdS5F8OafOHzd30p/aCjxoqjbwhp2iJR4D6dIJMK/OOpHEIvBW3fAV0k9tTf/ZAWRy0SqIhCBmkFQaUMRfPNveP7S9D4KvYwqglTqd2LNz2bzdmyU4zaCPr4ymDWUGFrLY6pnOBqjyrRlb5elcxnT8qZ3FEGfLaz/Ye0VFEI4ajjE9zaD79oBVi9xplIReOm/YElSPoLPXoQlszPvk+oLsOsxcOkX0MdG+tVUP4T2JnhsGnz5r3wl7zGqCFIJ1uDbclda4tEznSIcjVmKQPxF8RzsNbYYzYoT5vBubMe8/AiqTHv27nSwlkrTVvqzhhLGxPqdYMielrOckjfhaIw6acMX2uDc8ySy8Ys913TOdL4AdklVBG3r4MMnHE1Kbxe1EaQSDVP9/v+xq4QIR3dyrFrrxm0vSkCpXiVYA1vsTBvf5tUj+NuQ67ly8qgs9dZSGWsjRInbCBIP/ZjjYcIviitLCZMI2QI428NOfbGHWqD/sMzlD7gaoklJmObfZ33RT73PxrFSpqtmy33gMtojSEPVS5eyr+99xx3K6qTD28NCAJEO+r7/V0bLl7YNu+GIoal6m+zTaoN1VMbaSn9oaOvdYeJFXV6pSkF0z2rnoKd+OuNvtvr7b2PNGkrw7SJYOtf+saBL8STCWBTh3lBFkIo/gPFXWn4EDucjmFPxQ9jvMsfq3CQxMfrMuYof+BbbHsYJR2P84PvHoXFe5kI1mxH2VxOOlvhQyrB94MDr4bvF8L97w/J3iy1RSRKOWH4ExheAiqBzFacqgooqqBmQufw3/7YMzIkhvnz8AAZuDxe+DzvEQ1wXKSkN6NBQWiRYS12ogw0O2wg+qBwH4/dzrM5NkooqjPjy8iMIRyNMWXELfBaAIRliy+97KXe2HUZ47pcOClsE2tZZ/03MCmjWmiYRj5KTcDTGZ2ZbZPypzlZ80ozuiuWCBdnLL50LL/8XjDvFmgJqNxcBWMdJ9oEwBuq2hKre9yPQHkE6gnXUSQcRmzl37RCJxRjGt7D+G8fq3CQRgWAttdhvv4poB4LJ+SUU8PsIRw3GlLCd4IXL4a4fpg9noNgmHI0xy7cXHPo/zlZcV295f9sl1eCbT48gFoO5N8GyN6zf2+0PF39q5bPuZVQRpCNYS53P+aGhq9v+AM9c5FidmyzBurgfgb32S2SEy/oALXuDIz65mHq+d1RB9zqJWSjpwhkotglFY1T5jfUV7SQfP2P5DgC0r4eHToQlr2Qun6rQa+vth5ARgdnT4Yss01N7CVUE6Th5Br/3n+X49NGcTlMeQYK19PHZGxqKxQyVxkbMmJZVjFjzKgOkubQNxokvxkTWq1CaOPdKTsLRGHdwI/zV4fzfn70Ib8UTR7U3wafPwvpvM5dPVehH/xmOutvesVKnq374BPzjOAi3FSZ7D1BFkI5+Q2it6Oe8IjDloQg49Rlu4Axb7ReO2ZwGmBwDqpTTVXYqgjrYdj97jkfKRljG4g7nk7wnv5jtTOdMl5wmr+PVdDkVrvoUPnvBCrvey7iqCERksoh8KiJLROTyNNunicgqEVkY//u5m/LY5uOZTI294Pj0Uct71sNJaRL03Zp2fx9b7ReOGj43g3l4n2dhuwMyF0yErnA4Kmyvk5iO6A/AKU/B6KOKLVFJ0hWfyuHnKeFHkMg9DNmPsc1ecNFiK3YUwINTrSxjeR0voXiaoaK6KPnMXVMEIuIH7gAOBkYBJ4hIOo+hR4wxY+N/f3FLnrz46CmOizztbIiJSMwaAimHHsGHT3CCvGSr/cKRGBEq6Kgbkj0+S7zd6hyOCtvr7HU2jNXw0z2lMx+B089TsNaKDhvpsDedM1AN/Yd2zTRaOhfWr8jveIUYmh3GzR7BnsASY8yXxpgQ8DBwuIvHc45gLdUOJ0GJRKI8UP8r2HmKY3Vusnz0FMeb52y1XzgaY6Q0MmbZX6Ely1TKqr401wwlgq+0FcHuJ8POP7WW7z0Ynve4X4lL2IpYWwjJxl8Ry6s42yyi9vXw6h9gxQLLlyCSZ6//lKe6vJA9qggGA8uTfjeyUfBtAI4WkUUiMkNEhqarSETOFJF5IjJv1apVbsjanWAtVTibHzcUg3n9D7E8S71OsNaK3mqj/ULRGLvKl4z97DboWJ+54IDh/GvyS8yKjS9tRbD6867os21rvT+d2CXCUcMLVQfD9j92tuLxp8JV30HNZlaOgYsWwZajM5ePhmHOdCvRUCEhIqoHdGU/qxmYPgx2L1BsY/EzwHBjzG7Ay8D96QoZY+4xxjQYYxrq6+vdlypYS5VpJxJxzovVF2ljZMeH0LrWsTo3WYJ1VJt22zaCGrEXKiARcthueOtNjlgMbm+At++yfqdLVajYIhyNMaPPyZkTGRVKRSUEquzHA0ueNVSIIlj8OMyN+0JM/h2c9Jj9fR3ETUWwAkj+wh8SX9eJMWaNMSb+FuAvwHgX5bFPsBYfBiLtjlVZH/mWi74+r3taO68SH1qzZSPoFjwsS1YnY9jjtdM4zj+ndHsE4RR/CVUEBROJROgvLVbGNydZvQSeuxTWfgkfzIAHjsg+xbei0oooHGqxvMUHN3TPcJaLL2bBe3/tudw9xE1F8B4wUkRGiEgQOB7olpRWRLZK+nkY8LGL8thnjzM4Y/CTNMcCjlUZiMbnBpeDsThQQwVRYpGOnEVDkRg10o5BrBkTmRCh35qFbCfflK4i6PxijCu81JDHim2qIk3c+91UmP9/zlbcsgrevRu+/wrWfGFlEMs2nTPuSU+o1Uo9ecasrthBdgjWdRmlZ5wOs3/TM/kLxLVYQ8aYiIicB7wI+IF7jTEfisivgXnGmKeBC0TkMCACrAWmuSVPXgRriAXqCLc71yMIxmx4z3qFvc/lxMXjkGju74xEjyBaUUNFjvSd0Yoaam32NDZJOmehxIfAhk2EAWojKISKSB4pIfMh2S8g1Gz5KfhzvCZ7mpMg1GJNV218D3zFCf/m6lGNMc8Bz6WsuyZp+QrgCjdlKIhVn3Hc9/fwQGyyY1UGo21W/6scFEGgGlNRQ8SmjeC/I8ez25E3sGeOsrFAbTyYXYnaCFLHkPc5r3iylDgVkcSHlY0k8fmQrAjCrfae13PespLVL3vdmgV29F9g853tHy8WsdKWenTWUOmyvpGfND3KgIhzuUQrY4mhoTJwKPvuI07dcDd1odztF47GCBFAagfmLGsCtdTQUbpZyvpuDVNugS13K7YkJU+FnfhUhZBq/LVTf/UAy1bQvNIKL57X8ZKmq6oi2MSIX5zOYGg9xBjDm5Edmbnj78ojpEBTI5M3PE6/SO6pvqFojOP8c9jq07/lLjtoFN+YgaVrI6gdBA2nwYB4xqvXb4HfDrZmEyl5EYy69GEVrAXxWV/odVvYU9rz77NmgqVOBrBDw+lwzfeWr0K+PggOovkI0hG/kJ3j+j0kEjN8wyC+2nJieQwNxc/RjiINR2Ic5nuTAUtrgAuzll1z4K1cv+hVbi1VRdCy2spHu/nO8dkmYn15RtrK475wkK9j9by0+en8JFsayUII1sE1a/NLJ/vJs1ZvYOyJ1u98Mowl7A/hNhg6oesjoZfRHkE6Eoog6oyxOByNsZ2sYNi6MslG1akIckdRDEcNtdJm6+FJ+BGUrI3gsxfhnn1hQzyaZU8DlpUxS82WvLrVadB3q9yF80Ek/5ziCYNvIRnGVn0Kz1xoORae/pKVy7oIqCJIR2JoKOaQIogYjvX/i4M++KUj9W3ydA6t2VEEMWrpsNUl7v/eLdwf+H3pDg2lBjHrHB/WnAT5UhnZwMDoaneG1V68CubfD4+eAi9fm7t8QhH0HWx5I1dU2j9Wy2praKlpec6ibqKKIB01A/n9nq/z96gz7uuh+BTJSIXDMxw2VeJfRBU2FGkoavkR2PmKCrStZLRvaQkrgpQvRu0RFMwRsVf4f4uPsIbVnOaTmfDVG/Dt+129t2wk/EHGHA+nPpNfjyJxDzS+B3fs1ZWtrJdRRZAOEQIVQcdeOOFojFqx5sqXBX225Nqxc/mnyRJWOo6VsKcDqcytCKSyzvIjKNVZQ6EWyxCZiKG/2bYw7lQr162SF1WmLbcTYqEkXux2Z/EEay2FVEi2tESvsKkRVn1sTSUtAqoIMrD/V7fyU3mdqANpEcPl1iMQoaKiwl6soUiMcR1303HA9JxlfZV1VEmYSDjshJS9TyIXQeKLcYtd4LDbuicwV3ISixmqTRthfzXkcEIsiISDmF1FsP9VcPVKmPlL+NuR+R0rEXq9OT7VWmcNbVrsuOpF9vLtSjgaw9/DRBGJkLmxivKZGXLw8ptYG9sSyO5ubykLIVCZe1zVXxV/SMIlmt5x7AlWIpNkjLFi1BQhGUmpEo5Zz1PYX40rubyCtdC2Lu5QZuPFnLh261fkH1QyWGs5o7Wv7/pdBLRHkIGIv4Zah7JhhSKG30VO4tOxVzogWWkwas3LjONjTI7usgk187uKPxNsfCtnnb7NRvBGbBeikZBTYvYuW42BXY7o+v39V3D9AFj0SPFkKkGsmWYdRPwu9bBr662X+4gf2UtE3zgPnjoXvl+W/xd9ZR+46tuuZEVOe0rbRHsEGYhU1FhfHQ6MR4ejMT40w2nbfIwDkpUGYb/VftGYocKf2Xjm61jHCRVziK07Evhh9kp3OpT/L+Zjmq+vs8L2Ft/827IRbBW/D4K1gFFjcZ6EIzEej/6QAdv24UduHOCoe/Ir37Qc/v138FfCgBGFHbO23sphXVmce1sVQQYiFbXU0ubInPVwNMZPfO/Rv6kG2KLnwpUAkYoaaukgHDVUZBn1kPhL0JctTWUSQb+vdJPXv/Rf1jDQafHwW8nhDBTbhKMxXo2N4SfbZEkY05skegHRjsKGdp79FWw+yspWViR0aCgDkWA/oogjM4dC0Ri/C/yFrb+c4YBkpUHEX02NjUihvk63fBuKoHE+z8n5bLn+fQckLAKh5u4viooqq4egPYK8CMUdNPuGvnPnAIseg9vGwW27w5ev5i6fuKYDR1rewfny+cuw/J3893MQVQQZmLf37ZwcvsoRG0E4aqzkK/m4npc4ocrNiNrILyzh/LI6DeU7AqGmnopXHFJnoYhoToICCEcNdwZuYdzHf3DnAGu/hLVfWP+Njec/cU1/fB3sdVb+xwvWWXaiO3+Q/74OoYogA13hDHquCCKhEFUSRmwOf3iB1/e4ndPCl+VsPxMN00KVPUUQbz9/pERnDaWbjjjhLCsvgWKbcDRGjXS4Nwsv+RrZ6akG6yDYp3AfgMTx2oqXxlZtBBkY2vgM/xN4inCk51o6Vkgu0xKnU5HmGM//uKaBH1f+g7e23j13pfH2K11F0Lzxi+WAq4ojSwkTisSop50Nbj1PyR9sdo4xcDu4ZAn8YXto/g4m/CK/43VmrCve+0EVQQb6bviCw3xvsciBBPaxDssYWE49gu0an+B/Ai8Qiu6btVw4ajqVRk4SwexKVREc+4AV2jiZcBtEw1BVojOhikDCL2e9W0OtwTwVAcQ9kTcAeQasA+izdX7HcgFVBJkI1hKQKJFwzwPPNVf056cd07lr+4MdEKw06Nf8JYf43mVZjqGhHZvmcmjoJQjvBYEc4QKCdbwdmMBK3+YOStqLbLvfxuv+dpQ1Z33azN6WpmSJhDqolIh7L86azaz/A4ZbeQJyYQw8dJy1XIhMR94J676yJg4UCVUEmYhf0MTXfE8ImQo+MNvi71OiL7ACMMFaqiVEOEc4iK3alvDjyGv2crX6A9w44FrqKisouSSP4Xb47AUYPA76b9O1PlgLrWuKJ1cJEo4ZLgqdw+nDDnTnANsdANflMSFBxAoaB4Urp2H7WH4IRUKNxRlIDOPEOno+oyPQ/A0n+GcRbM+dscszxB+IaA5FGoi2EiIA/oCtagP+3DORNklaVsJjp8LS17qvT4QwVmzTYfw8GfsBkUE28wL3JoXEClr4EHy7CPa9xHl5bKKKIBPVA1hhBhIN9zycQZ+mT/ld4K8EW75xQLASIaEI2rO/5Cqi7bSL/QiSv199PtO+/1OPRCsKmSYM6PTRvIm1b2AP+YSq8Hp3DtDUCNf1s/7ypf/Q/PdZ9xV8/iLEem6PLBRVBBno2O5gJnb8iabqAi5sCom58oGq8jEWm+qBfB2rJxruyFouGGulw1dlu95KOugTXddT8XqfUAbHuUSkS8U2ld9/wWOVv6bv6gXuHKCQcNJbjIadpkD9jvnvm/g4eOHy/Pd1CLURZMBJP4KE92xFdfnEnW/Z7lB+/EJ//lq9ddZybVSypmIL6m3WG/JVdyUuLyUSL/tASlCxHQ6CvtnbSEkh3pZ2w5LkTSHj/H0HF55XInFPhIo3G057BBmoalnOfYEb6bdqXo/r8sWnO/rLaPqoXUV6R83Z/GGrm23XG/LVUGWcSSHaq2QaGtp+Evzgot6Xp4Qx8R62r6oXpo/aZYeDLO/gDQWEvbAzUcJlJFeY4B5VLjIZuBXwA38xxvw+ZXsl8AAwHlgDHGeMWZatzoaGBjNvXs9fzrnYMPsm+rx2PQYwlQOsmQHt30Nl/7yXI6FWgqaDaJ/B+A+8DnY71nX5i82qF/9Inzd/T6WEs7bf+o4IfWnG9BmM/8Brs7fNokcJPXEugVgIU5XfNTF9BuPf8SCin76IbFhR0HXs2bJB2tcR67M1zT+4mjMWbsufd/+Surm/wbdhBbE+g/HvOLmI8pVOW0YiHQSjrYRrNicw+TfOP0+LHoXHz7CW+w2FSdfkvC957mJob7J6Bj++Lj+ZZv4K5v3F/vEKRETmG2Ma0m5zSxGIiB/4DDgQaATeA04wxnyUVOYcYDdjzFkicjxwpDHmuGz19ooiWPQo5unzkYgLX56Bavjpbd5WBoseJfbUefii2e0DG5GtbRY9Cs9cYDlglTghqeTh8A85PjCXoMmzjZTuOP08pbvP8r0v85Fp0aPw9PmQ/K5x6R2RTRG4OTS0J7DEGPOlMSYEPAwcnlLmcOD++PIMYJJIPpmf3WHFP69wRwkAhNtY8c8r3Kl7E2HFP6/IXwlA1rZZ8c8rPKEEAIKmgxP9s1UJOIHTz9OsX298n4XbrPVOlE+3f+q7Jp/9HcJNRTAYWJ70uzG+Lm0ZY0wEaAIGplYkImeKyDwRmbdqlftz8bcWdx183K6/2PTk/DLt67U281OCvhCbKI7eG02N7q53en+HKAljsTHmHmNMgzGmob7e7vySwpF+Q0q6/mLTk/PLtK/X2ixaGo9eSeDovZGpLqfWO72/Q7h5N64AkifhD4mvS1tGRCqAflhG4+Iy6Ro6xB137w6ptIxBXqbA9svaNg5ck00lr1kblTSNOok2up/PpiKfHTYVWR1/niZds3HMq0B11vsyr/JO7+8QbiqC94CRIjJCRILA8cDTKWWeBk6NLx8DzDZuTmOyy27HUnnk7ZYFH4Hqzay/ni73G2rV62VDMRTWfrnapqfXpN9QpOF0569pAXJUH3U7A4+7neqjks5nU5GvxNrS8edpt2MtQ23SdclquM23vNP7O4Tb00cPAW7Bmj56rzHmNyLya2CeMeZpEakC/gbsDqwFjjfGfJmtzt6aPqooiuIlss0actWTwRjzHPBcyrprkpbbgaluyqAoiqJkRy1WiqIoZY4qAkVRlDJHFYGiKEqZo4pAURSlzHF11pAbiMgq4Ks8dhkErHZJnE2ZcjzvcjxnKM/zLsdzhp6d9zBjTFqP3JJTBPkiIvMyTZnyMuV43uV4zlCe512O5wzunbcODSmKopQ5qggURVHKnHJQBPcUW4AiUY7nXY7nDOV53uV4zuDSeXveRqAoiqJkpxx6BIqiKEoWVBEoiqKUOZ5WBCIyWUQ+FZElInJ5seVxAxEZKiJzROQjEflQRC6Mr99MRF4Wkc/j/wcUW1Y3EBG/iPxbRGbGf48QkXfi1/yReAh0zyAi/UVkhoh8IiIfi8je5XCtReSX8ft7sYg8JCJVXrvWInKviKwUkcVJ69JeW7G4LX7ui0RkXE+O7VlFICJ+4A7gYGAUcIKIjCquVK4QAX5ljBkF7AWcGz/Py4FZxpiRwKz4by9yIfBx0u8bgZuNMdsD3wOnF0Uq97gVeMEYsxMwBuvcPX2tRWQwcAHQYIwZjRXW/ni8d63vAyanrMt0bQ8GRsb/zgTu7MmBPasIgD2BJcaYL40xIeBh4PAiy+Q4xphvjTEL4ssbsF4Mg7HO9f54sfuBI4ojoXuIyBDgUOAv8d8CHADMiBfxpjIuMQAABdFJREFU1HmLSD/gR8BfAYwxIWPMOsrgWmOFzK+OZzKsAb7FY9faGPMaVl6WZDJd28OBB4zF20B/Edmq0GN7WREMBpYn/W6Mr/MsIjIcK8nPO8AWxphv45v+A2xRJLHc5BbgUujMBD8QWGeMicR/e+2ajwBWAf8XHw77i4jU4vFrbYxZAfwR+BpLATQB8/H2tU6Q6do6+n7zsiIoK0SkDvgncJExZn3ytnj6T0/NExaRKcBKY8z8YsvSi1QA44A7jTG7Ay2kDAN59FoPwPoCHgFsDdSy8RCK53Hz2npZEawAhib9HhJf5zlEJIClBB40xjweX/1doqsY/7+yWPK5xETgMBFZhjXsdwDW+Hn/+PABeO+aNwKNxph34r9nYCkGr1/rHwNLjTGrjDFh4HGs6+/la50g07V19P3mZUXwHjAyPrMgiGVcerrIMjlOfFz8r8DHxpibkjY9DZwaXz4VeKq3ZXMTY8wVxpghxpjhWNd2tjHmJGAOcEy8mKfO2xjzH2C5iOwYXzUJ+AiPX2usIaG9RKQmfr8nztuz1zqJTNf2aeCU+OyhvYCmpCGk/DHGePYPOAT4DPgCuKrY8rh0jj/A6i4uAhbG/w7BGi+fBXwOvAJsVmxZXWyD/YCZ8eVtgXeBJcBjQGWx5XP4XMcC8+LX+0lgQDlca+B64BNgMfA3oNJr1xp4CMsGEsbq/Z2e6doCgjUr8gvgA6wZVQUfW0NMKIqilDleHhpSFEVRbKCKQFEUpcxRRaAoilLmqCJQFEUpc1QRKIqilDmqCJSSQUSMiPxP0u+LReQ6h+q+T0SOyV2yx8eZGo8aOsdm+SvdlklRVBEopUQHcJSIDCq2IMkkebfa4XTgDGPM/jbLqyJQXEcVgVJKRLBytv4ydUPqF72INMf/7ycir4rIUyLypYj8XkROEpF3ReQDEdkuqZofi8g8EfksHssoke/gDyLyXjzu+y+S6p0rIk9jebmmynNCvP7FInJjfN01WA6AfxWRP6SU30pEXhORhfF9figiv8eKuLlQRB6Mlzs5LvtCEbk7Hm4dEWkWkZvjMftniUh9fP0FYuWqWCQiDxfc8oq3KbY3nf7pn90/oBnoCywD+gEXA9fFt90HHJNcNv5/P2AdsBWWN+oK4Pr4tguBW5L2fwHr42gklmdnFVas96vjZSqxvHpHxOttAUakkXNrrLAI9ViB4mYDR8S3/Ys0XqDAr4h7v2PF2++TfB7x5Z2BZ4BA/Pf/AqfElw1wUnz5GuD2+PI3xD1ugf7Fvob6t2n+5dOlVZSiY4xZLyIPYCUqabO523smHodFRL4AXoqv/wBIHqJ51BgTAz4XkS+BnYCfALsl9Tb6YSmKEPCuMWZpmuPtAfzLGLMqfswHsfIIPJlNRuDeeADBJ40xC9OUmQSMB96zQu5QTVcQshjwSHz571iB2cAKRfGgiDyZ4/hKGaNDQ0opcgvWWHtt0roI8ftZRHxActrCjqTlWNLvGHT7GEqNt2KwYrqcb4wZG/8bYYxJKJKWHp1F8oGspCQ/wuqx3Ccip6QpJsD9SbLsaIy5LlOV8f+HYsWkGYelQPTjT9kIVQRKyWGMWQs8SvfUhMuwvpYBDgMCBVQ9VUR8cbvBtsCnwIvA2fEvdURkh3gymGy8C+wrIoPiY/gnAK9m20FEhgHfGWP+jJVxLZGDNpw4NlbwsWNEZPP4PpvF9wPrWU70Wk4EXo8rxKHGmDnAZVi9mbrczaCUG/p1oJQq/wOcl/T7z8BTIvI+1lh/IV/rX2O9xPsCZxlj2kXkL8BwYEE8BPIqcqRENMZ8KyKXY4VJFuBZY0yuEMn7AZeISBjLFpLoEdwDLBKRBcaYk0TkauCl+Es+DJwLfIV1vnvGt68EjsOyNfxdrBSXAtxmrNSWitINjT6qKB5ARJqNMfq1rxSEDg0piqKUOdojUBRFKXO0R6AoilLmqCJQFEUpc1QRKIqilDmqCBRFUcocVQSKoihlzv8P/E2EOsV2V8YAAAAASUVORK5CYII=\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          },
          "output_type": "display_data"
        }
      ],
      "source": [
        "plt.plot(T[:nsteps], X[:nsteps], '*-', T[:nsteps], Y[:nsteps], 'o--')\n",
        "plt.xlabel('Number of steps')\n",
        "plt.ylabel('States')\n",
        "plt.legend(['True states', 'Observed states'])"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1Ffp-XeIFXM8"
      },
      "source": [
        "### Reference implementations for comparison and debugging"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "b_WJXy1-Fawx"
      },
      "outputs": [],
      "source": [
        "def ref_viterbi_classic(model, Y):\n",
        "    \"\"\"Reference classical viterbi implementation (path based)\n",
        "\n",
        "    Parameters\n",
        "    ----------\n",
        "    model:\n",
        "\n",
        "        HMM model\n",
        "    Y: array_like\n",
        "        Observations\n",
        "    Returns\n",
        "    -------\n",
        "    xmap:\n",
        "        MAP path\n",
        "    max_prob:\n",
        "        maximum probability\n",
        "    V_list:\n",
        "        probabilities of most probable paths\n",
        "    u_list:\n",
        "        most probable path sequence\n",
        "    \"\"\"\n",
        "\n",
        "\n",
        "    V_list = np.zeros((Y.shape[0], model.prior_dim, ))\n",
        "    u_list = np.zeros((Y.shape[0], model.prior_dim, ))\n",
        "\n",
        "    V = model.Po[:, int(Y[0])] * model.prior\n",
        "    V_list[0] = V\n",
        "    u = [0] * model.prior.shape[0]\n",
        "    u_list[0] = u\n",
        "    for k in range(1, len(Y)):\n",
        "        psi = model.Po[:, int(Y[k])] * model.Pi\n",
        "        old_V = V\n",
        "        V = np.zeros(V.shape)\n",
        "        u = [0] * V.shape[0]\n",
        "        for i in range(psi.shape[0]):\n",
        "            tmp = psi[:, i] * old_V\n",
        "            u[i] = np.argmax(tmp)\n",
        "            V[i] = tmp[u[i]]\n",
        "        V_list[k] = V\n",
        "        u_list[k] = u\n",
        "\n",
        "    xmap = [0] * len(Y)\n",
        "    xmap[-1] = np.argmax(V_list[-1])\n",
        "    max_prob = V_list[-1][xmap[-1]]\n",
        "\n",
        "    for k in reversed(range(len(Y)-1)):\n",
        "        xmap[k] = int(u_list[k+1][xmap[k+1]])\n",
        "\n",
        "    return xmap, max_prob, V_list, u_list\n",
        "\n",
        "\n",
        "def ref_viterbi_maxproduct(model, Y):\n",
        "    \"\"\"Reference viterbi max-product implementation\n",
        "\n",
        "    Parameters\n",
        "    ----------\n",
        "    model:\n",
        "        HMM model\n",
        "    Y: array_like\n",
        "        Observations\n",
        "    Returns\n",
        "    -------\n",
        "    xmap:\n",
        "        MAP path\n",
        "    max_prob:\n",
        "        maximum probability\n",
        "    V_list:\n",
        "        probabilities of most probable paths in forward direction\n",
        "    W_list:\n",
        "        probabilities of most probable paths in reverse direction\n",
        "    \"\"\"\n",
        "\n",
        "\n",
        "    V_list = np.zeros((Y.shape[0], model.prior_dim, ))\n",
        "    V = model.Po[:, Y[0]] * model.prior\n",
        "    V_list[0] = V\n",
        "    for k in range(1,len(Y)):\n",
        "        psi = model.Po[:, Y[k]] * model.Pi\n",
        "        old_V = V\n",
        "        V = np.zeros(V.shape)\n",
        "        for i in range(psi.shape[1]):\n",
        "            tmp = psi[:, i] * old_V\n",
        "            V[i] = np.max(tmp)\n",
        "        V_list[k] = V\n",
        "\n",
        "    W_list = V_list.copy()\n",
        "    W = np.ones(model.Pi.shape[0])\n",
        "    W_list[-1] = W\n",
        "    for k in reversed(range(len(Y)-1)):\n",
        "        psi = model.Po[:, Y[k+1]] * model.Pi\n",
        "\n",
        "        old_W = W\n",
        "        W = np.zeros(W.shape)\n",
        "        for i in range(psi.shape[0]):\n",
        "            tmp = psi[i, :] * old_W\n",
        "            W[i] = np.max(tmp)\n",
        "        W_list[k] = W\n",
        "\n",
        "    xmap = []\n",
        "    for k in range(len(Y)):\n",
        "        tmp = V_list[k] * W_list[k]\n",
        "        ind = np.argmax(tmp)\n",
        "        max_prob = tmp[ind] # These are all equal\n",
        "        xmap.append(ind)\n",
        "\n",
        "    return xmap, max_prob, V_list, W_list\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vm6uWe0JzxRQ"
      },
      "source": [
        "#### Reference classical and potential-based Viterbi"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lWCcSW9rzxRQ",
        "outputId": "b18b301e-0065-4663-f531-280ce277fae0"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Difference between classical and max-product based Viterbi:  3\n",
            "0.0\n",
            "0.0\n"
          ]
        }
      ],
      "source": [
        "ref_xmap1, ref_max_prob1, ref_V_list1, ref_u_list1 = ref_viterbi_classic(model, Y)\n",
        "ref_xmap2, ref_max_prob2, ref_V_list2, ref_W_list2 = ref_viterbi_maxproduct(model, Y)\n",
        "print('Difference between classical and max-product based Viterbi: ', max([abs(a-b) for a, b in zip(ref_xmap1, ref_xmap2)]))\n",
        "print(ref_max_prob1)\n",
        "print(ref_max_prob2)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "X8TB_g77zxRQ"
      },
      "source": [
        "### Plot for reference classical Viterbi implementation"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 279
        },
        "id": "ZNh8-XjSs7O6",
        "outputId": "e86b3c11-e2b9-4766-c32c-1acaaa2362fe"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          },
          "output_type": "display_data"
        }
      ],
      "source": [
        "plt.clf()\n",
        "plt.plot(T[:nsteps], X[:nsteps], '*-', T[:nsteps], [x for x in ref_xmap1[:nsteps]])\n",
        "plt.xlabel('Number of steps')\n",
        "plt.ylabel('States')\n",
        "plt.legend(['True states', 'Observed states'])\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nQjmem2ZwHLL"
      },
      "source": [
        "### Utilities for log-space computations\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5lPjL7LvwMiq",
        "outputId": "dc932d30-9b39-4e68-a4b1-b1f611ac4d26"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Test utility functions:\n",
            "tf.Tensor(\n",
            "[[1.4257064  1.0391585  0.7607688  1.0484284 ]\n",
            " [0.9447347  0.76951545 0.44059256 0.6164023 ]\n",
            " [0.35811597 0.34018368 0.16159499 0.33705997]\n",
            " [0.75753486 0.5810969  0.41004145 0.6656992 ]], shape=(4, 4), dtype=float32)\n",
            "tf.Tensor(\n",
            "[[1.4257064  1.0391583  0.7607688  1.0484283 ]\n",
            " [0.94473475 0.76951534 0.44059253 0.61640227]\n",
            " [0.35811597 0.3401837  0.161595   0.33705997]\n",
            " [0.75753486 0.58109677 0.41004142 0.6656991 ]], shape=(4, 4), dtype=float32)\n",
            "tf.Tensor([0.5768026  0.33639905 0.15708235 0.353592  ], shape=(4,), dtype=float32)\n",
            "tf.Tensor([0.5768026  0.33639905 0.15708235 0.35359204], shape=(4,), dtype=float32)\n",
            "tf.Tensor([0.5768026  0.3363991  0.15708235 0.35359204], shape=(4,), dtype=float32)\n",
            "tf.Tensor([0.19298144 0.3319118  0.0531239  0.42198285], shape=(4,), dtype=float32)\n",
            "tf.Tensor([0.19298144 0.3319118  0.0531239  0.42198288], shape=(4,), dtype=float32)\n"
          ]
        }
      ],
      "source": [
        "@tf.function\n",
        "def log_mv(log_A, log_b, transpose_a=False):\n",
        "    Amax = tf.reduce_max(log_A, axis=(-1, -2), keepdims=True)\n",
        "    bmax = tf.reduce_max(log_b, axis=(-1), keepdims=True)\n",
        "    return tf.squeeze(Amax,axis=-1) + bmax + tf.math.log(mv(tf.math.exp(log_A - Amax), tf.math.exp(log_b - bmax), transpose_a=transpose_a))\n",
        "\n",
        "@tf.function\n",
        "def semilog_mv(A, log_b, transpose_a=False):\n",
        "    bmax = tf.reduce_max(log_b, axis=(-1), keepdims=True)\n",
        "    return bmax + tf.math.log(mv(A, tf.math.exp(log_b - bmax), transpose_a=transpose_a))\n",
        "\n",
        "@tf.function\n",
        "def log_mm(log_A, log_B, transpose_a=False,transpose_b=False):\n",
        "    Amax = tf.reduce_max(log_A, axis=(-1, -2), keepdims=True)\n",
        "    Bmax = tf.reduce_max(log_B, axis=(-1, -2), keepdims=True)\n",
        "    return Amax + Bmax + tf.math.log(mm(tf.math.exp(log_A - Amax), tf.math.exp(log_B - Bmax), transpose_a=transpose_a, transpose_b=transpose_b))\n",
        "\n",
        "@tf.function\n",
        "def log_normalize(log_p):\n",
        "    pmax = tf.reduce_max(log_p, axis=(-1), keepdims=True)\n",
        "    temp = tf.math.exp(log_p - pmax)\n",
        "    return tf.math.log(temp / tf.reduce_sum(temp, axis=-1, keepdims=True))\n",
        "\n",
        "print('Test utility functions:')\n",
        "with tf.device('/CPU:0'):\n",
        "    tf.random.set_seed(5)\n",
        "    A = tf.random.uniform(shape=[4, 4])\n",
        "    B = tf.random.uniform(shape=[4, 4])\n",
        "    log_A = tf.math.log(A)\n",
        "    log_B = tf.math.log(B)\n",
        "    print(mm(A, B))\n",
        "    print(tf.math.exp(log_mm(log_A, log_B)))\n",
        "\n",
        "    b = tf.random.uniform(shape=[4])\n",
        "    log_b = tf.math.log(b)\n",
        "    print(mv(A, b))\n",
        "    print(tf.math.exp(log_mv(log_A, log_b)))\n",
        "    print(tf.math.exp(semilog_mv(A, log_b)))\n",
        "\n",
        "    print(b / tf.reduce_sum(b, keepdims=True))\n",
        "    print(tf.math.exp(log_normalize(log_b)))\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "_OCdhTzmzxRR"
      },
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WU_QVbGq1gP8"
      },
      "source": [
        "### Sequential Viterbi in classic and potential forms"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FJ36ReIN3DKC"
      },
      "source": [
        "#### Classic forward routine"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "_bZqTHQK1l29"
      },
      "outputs": [],
      "source": [
        "@tf.function\n",
        "def viterbi_classic_forward_pass(model, obs):\n",
        "    psi_full = tf.expand_dims(model.Po, 0) * tf.expand_dims(model.Pi, -1)\n",
        "\n",
        "    def body(carry, y):\n",
        "        V, _ = carry\n",
        "        psi = psi_full[..., y]\n",
        "        temp = psi * tf.expand_dims(V, -1)\n",
        "        V = tf.reduce_max(temp, axis=0)\n",
        "        u = tf.math.argmax(temp, axis=0)\n",
        "        return (V, u)\n",
        "\n",
        "    V = model.Po[:, obs[0]] * model.prior\n",
        "    u = tf.zeros_like(model.prior, dtype=tf.int64)\n",
        "    Vs, us = tf.scan(body, obs[1:], (V, u))\n",
        "    Vs = tf.concat([tf.expand_dims(V, 0), Vs], axis=0)\n",
        "    us = tf.concat([tf.expand_dims(u, 0), us], axis=0)\n",
        "    return Vs, us\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UptBIYeX3Ngj"
      },
      "source": [
        "#### Classic backward routine"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "G0FYf2qm3Nnr"
      },
      "outputs": [],
      "source": [
        "@tf.function\n",
        "def viterbi_classic_backward_pass(model, us, Vend):\n",
        "    def body(carry, u):\n",
        "        x = carry\n",
        "        return u[x]\n",
        "\n",
        "    x = tf.argmax(Vend)\n",
        "    xs = tf.scan(body, us[1:], x, reverse=True)\n",
        "    return tf.concat([xs, tf.expand_dims(x, 0)], axis=0)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HjXD-oY23Nu6"
      },
      "source": [
        "#### Classic forward-backward routine"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ThhZ_BB-3N4X"
      },
      "outputs": [],
      "source": [
        "@tf.function\n",
        "def viterbi_classic(model, obs):\n",
        "    Vs, us = viterbi_classic_forward_pass(model, obs)\n",
        "    xmap = viterbi_classic_backward_pass(model, us, Vs[-1])\n",
        "    return xmap\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Q_6AgnZv3N_S"
      },
      "source": [
        "#### Potential-based forward routine"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "0QPfcDbo3OGJ"
      },
      "outputs": [],
      "source": [
        "@tf.function\n",
        "def viterbi_potential_forward_pass(model, obs):\n",
        "    psi_full = tf.expand_dims(model.Po, 0) * tf.expand_dims(model.Pi, -1)\n",
        "\n",
        "    def body(carry, y):\n",
        "        V = carry\n",
        "        psi = psi_full[..., y]\n",
        "        temp = psi * tf.expand_dims(V, -1)\n",
        "        V = tf.reduce_max(temp, axis=0)\n",
        "        return V\n",
        "\n",
        "    V = model.Po[:,obs[0]] * model.prior\n",
        "    Vs = tf.scan(body, obs[1:], V)\n",
        "\n",
        "    return tf.concat([tf.expand_dims(V, 0), Vs], axis=0)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ltHhyCdO3OPp"
      },
      "source": [
        "#### Potential-based backward routine"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "9EHT0jfO3OYS"
      },
      "outputs": [],
      "source": [
        "@tf.function\n",
        "def viterbi_potential_backward_pass(model, obs):\n",
        "    psi_full = tf.expand_dims(model.Po, 0) * tf.expand_dims(model.Pi, -1)\n",
        "\n",
        "    def body(carry, y):\n",
        "        W = carry\n",
        "        psi = psi_full[..., y]\n",
        "        temp = psi * tf.expand_dims(W, 0)\n",
        "        W = tf.reduce_max(temp, axis=1)\n",
        "        return W\n",
        "\n",
        "    W  = tf.ones_like(model.prior)\n",
        "    Ws = tf.scan(body, obs[1:], W, reverse=True)\n",
        "    return tf.concat([Ws, tf.expand_dims(W, 0)], 0)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GhWtGnON3Wnr"
      },
      "source": [
        "#### Potential-based smoother routine"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "qfBfCvYF3WxA"
      },
      "outputs": [],
      "source": [
        "@tf.function\n",
        "def viterbi_potential_smoother(model, obs):\n",
        "    Vs = viterbi_potential_forward_pass(model, obs)\n",
        "    Ws = viterbi_potential_backward_pass(model, obs)\n",
        "    V = Vs * Ws\n",
        "    return tf.math.argmax(V,axis=1)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4xVsMgtF3YQ8"
      },
      "source": [
        "#### Compare classic and potential-based smoother routines"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "D1JwrX0h-xoV",
        "outputId": "bf33ff11-7d2b-4904-fe12-1845d1675047"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "0.0\n",
            "3\n",
            "2\n",
            "2\n",
            "0.0\n",
            "0.0\n",
            "3\n"
          ]
        }
      ],
      "source": [
        "with tf.device('/CPU:0'):\n",
        "\n",
        "    Vs, us = viterbi_classic_forward_pass(model, Y)\n",
        "    print(np.abs(Vs - tf.convert_to_tensor(ref_V_list1)).max())\n",
        "    print(np.abs(us - tf.convert_to_tensor(ref_u_list1, dtype=tf.int64)).max())\n",
        "\n",
        "    xmap = viterbi_classic_backward_pass(model, us, Vs[-1])\n",
        "    print(np.abs(xmap - tf.convert_to_tensor(ref_xmap1, dtype=tf.int64)).max())\n",
        "\n",
        "    xmap = viterbi_classic(model, Y)\n",
        "    print(np.abs(xmap - tf.convert_to_tensor(ref_xmap1, dtype=tf.int64)).max())\n",
        "\n",
        "    Vs2 = viterbi_potential_forward_pass(model, Y)\n",
        "    print(np.abs(Vs2 - Vs).max())\n",
        "\n",
        "    Ws2 = viterbi_potential_backward_pass(model, Y)\n",
        "    print(np.abs(Ws2 - tf.convert_to_tensor(ref_W_list2)).max())\n",
        "\n",
        "    xmap2 = viterbi_potential_smoother(model, Y)\n",
        "    print(np.abs(xmap2 - tf.convert_to_tensor(ref_xmap1, dtype=tf.int64)).max())"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qbk-W1Z4Mono"
      },
      "source": [
        "### Log-space sequential Viterbi in classic and potential forms"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_-Y1y3Rm479b"
      },
      "source": [
        "#### Forward routine"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "yCiswvDhMrJ9"
      },
      "outputs": [],
      "source": [
        "@tf.function\n",
        "def log_viterbi_classic_forward_pass(model, obs):\n",
        "    log_psi_full = tf.expand_dims(model.log_Po, 0) + tf.expand_dims(model.log_Pi, -1)\n",
        "\n",
        "    def body(carry, y):\n",
        "        V, _ = carry\n",
        "        log_psi = log_psi_full[..., y]\n",
        "        temp = log_psi + tf.expand_dims(V, -1)\n",
        "        V = tf.reduce_max(temp, axis=0)\n",
        "        u = tf.math.argmax(temp, axis=0)\n",
        "        return (V, u)\n",
        "\n",
        "    V = model.log_Po[:, obs[0]] + model.log_prior\n",
        "    u = tf.zeros_like(model.log_prior, dtype=tf.int64)\n",
        "    Vs, us = tf.scan(body, obs[1:], (V, u))\n",
        "    Vs = tf.concat([tf.expand_dims(V, 0), Vs], axis=0)\n",
        "    us = tf.concat([tf.expand_dims(u, 0), us], axis=0)\n",
        "    return Vs, us\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wZixX8XD4PCd"
      },
      "source": [
        "#### Backward routine"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "J4jf1wfc4PKZ"
      },
      "outputs": [],
      "source": [
        "@tf.function\n",
        "def log_viterbi_classic_backward_pass(model, us, Vend):\n",
        "    def body(carry, u):\n",
        "        x = carry\n",
        "        return u[x]\n",
        "\n",
        "    x = tf.argmax(Vend)\n",
        "    xs = tf.scan(body, us[1:], x, reverse=True)\n",
        "    return tf.concat([xs, tf.expand_dims(x, 0)], axis=0)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OJN4xe004PRi"
      },
      "source": [
        "#### Viterbi path routine"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "_5LUzaE_4PYr"
      },
      "outputs": [],
      "source": [
        "@tf.function\n",
        "def log_viterbi_classic(model, obs, max_parallel=0):\n",
        "    Vs, us = log_viterbi_classic_forward_pass(model, obs)\n",
        "    xmap = log_viterbi_classic_backward_pass(model, us, Vs[-1])\n",
        "    return xmap\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "u-Uj4_iv4Pfy"
      },
      "source": [
        "#### Potential based forward routine"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "C9MVwXi44Pna"
      },
      "outputs": [],
      "source": [
        "@tf.function\n",
        "def log_viterbi_potential_forward_pass(model, obs):\n",
        "    log_psi_full = tf.expand_dims(model.log_Po, 0) + tf.expand_dims(model.log_Pi, -1)\n",
        "\n",
        "    def body(carry, y):\n",
        "        V = carry\n",
        "        log_psi = log_psi_full[..., y]\n",
        "        temp = log_psi + tf.expand_dims(V, -1)\n",
        "        V = tf.reduce_max(temp, axis=0)\n",
        "        return V\n",
        "\n",
        "    V = model.log_Po[:,obs[0]] + model.log_prior\n",
        "    Vs = tf.scan(body, obs[1:], V)\n",
        "\n",
        "    return tf.concat([tf.expand_dims(V, 0), Vs], axis=0)\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lEBxKYgX4PvS"
      },
      "source": [
        "#### Potential based backward routine"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ztCu4bAE4P26"
      },
      "outputs": [],
      "source": [
        "@tf.function\n",
        "def log_viterbi_potential_backward_pass(model, obs):\n",
        "    log_psi_full = tf.expand_dims(model.log_Po, 0) + tf.expand_dims(model.log_Pi, -1)\n",
        "\n",
        "    def body(carry, y):\n",
        "        W = carry\n",
        "        log_psi = log_psi_full[..., y]\n",
        "        temp = log_psi + tf.expand_dims(W, 0)\n",
        "        W = tf.reduce_max(temp, axis=1)\n",
        "        return W\n",
        "\n",
        "    W  = tf.zeros_like(model.log_prior)\n",
        "    Ws = tf.scan(body, obs[1:], W, reverse=True)\n",
        "    return tf.concat([Ws, tf.expand_dims(W, 0)], 0)\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_cs9JiNc4g-z"
      },
      "source": [
        "#### Potential based smoother routine"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "na9dKrdV4hHa"
      },
      "outputs": [],
      "source": [
        "@tf.function\n",
        "def log_viterbi_potential_smoother(model, obs, max_parallel=0):\n",
        "    Vs = log_viterbi_potential_forward_pass(model, obs)\n",
        "    Ws = log_viterbi_potential_backward_pass(model, obs)\n",
        "    V = Vs + Ws\n",
        "    return tf.math.argmax(V,axis=1)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LbCkwJw-5bpG"
      },
      "source": [
        "#### Compare the classical and log based Viterbi implementations"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zlvnBhdCNc33",
        "outputId": "3d5c64e0-d328-441b-d4ea-de81520ad339"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "8.326672684688674e-17\n",
            "3\n",
            "3\n",
            "8.326672684688674e-17\n",
            "1.1102230246251565e-16\n",
            "3\n",
            "2\n"
          ]
        }
      ],
      "source": [
        "with tf.device('/CPU:0'):\n",
        "\n",
        "    Vs, us = viterbi_classic_forward_pass(model, Y)\n",
        "    log_Vs, log_us = log_viterbi_classic_forward_pass(model, Y)\n",
        "    print(np.abs(Vs - tf.math.exp(log_Vs)).max())\n",
        "    print(np.abs(us - log_us).max())\n",
        "    xmap = viterbi_classic_backward_pass(model, us, Vs[-1])\n",
        "    log_xmap = log_viterbi_classic_backward_pass(model, log_us, log_Vs[-1])\n",
        "    print(np.abs(xmap - log_xmap).max())\n",
        "\n",
        "    Vs2 = viterbi_potential_forward_pass(model, Y)\n",
        "    log_Vs2 = log_viterbi_potential_forward_pass(model, Y)\n",
        "    print(np.abs(Vs2 - tf.math.exp(log_Vs2)).max())\n",
        "\n",
        "    Ws2 = viterbi_potential_backward_pass(model, Y)\n",
        "    log_Ws2 = log_viterbi_potential_backward_pass(model, Y)\n",
        "    print(np.abs(Ws2 - tf.math.exp(log_Ws2)).max())\n",
        "\n",
        "    xmap2 = viterbi_potential_smoother(model, Y)\n",
        "    log_xmap2 = log_viterbi_potential_smoother(model, Y)\n",
        "    print(np.abs(xmap2 - log_xmap2).max())\n",
        "    print(np.abs(log_xmap - log_xmap2).max())\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xd_iG6j8O7n-"
      },
      "source": [
        "### Parallel Viterbi\n",
        "We  present  the  tensorflow implementation of parallel  max-product based Viterbi Algorithm 5 described in the paper."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fCCz12Tj7Myj"
      },
      "source": [
        "#### Forward part"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EVlt5oW07Szz"
      },
      "source": [
        "#### Initialization routines"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "nDgJTbB8O99N"
      },
      "outputs": [],
      "source": [
        "@tf.function\n",
        "def parallel_forward_viterbi_init_first(model, y):\n",
        "    prior = tf.tile(tf.expand_dims(model.prior, axis=1), [1, model.prior.shape[0]])\n",
        "    psi = tf.multiply(model.Po[:, y], prior)\n",
        "    return psi\n",
        "\n",
        "@tf.function\n",
        "def parallel_forward_viterbi_init_rest(model, obs):\n",
        "    temp = tf.gather(tf.transpose(model.Po), obs, axis=0)\n",
        "    psi = tf.expand_dims(temp, 1) * tf.expand_dims(model.Pi, 0)\n",
        "    return psi\n",
        "\n",
        "@tf.function\n",
        "def parallel_forward_viterbi_init(model, obs):\n",
        "    first_elem = parallel_forward_viterbi_init_first(model, obs[0])\n",
        "    generic_elems = parallel_forward_viterbi_init_rest(model, obs[1:])\n",
        "    return tf.concat([tf.expand_dims(first_elem, 0), generic_elems], axis=0)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jml7Zt2D7oLG"
      },
      "source": [
        "#### Parallel forward operator"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "l7TpoN4B7nmS"
      },
      "outputs": [],
      "source": [
        "@tf.function\n",
        "def parallel_viterbi_op(elemij, elemjk):\n",
        "    elemij = tf.expand_dims(elemij, -1)\n",
        "    elemjk = tf.expand_dims(elemjk, 1)\n",
        "    return tf.reduce_max(elemij * elemjk, axis=2)\n",
        ""
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NK1DTz7I8P_U"
      },
      "source": [
        "#### Parallel forward routine"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "KxJ19PF98QGF"
      },
      "outputs": [],
      "source": [
        "@tf.function\n",
        "def parallel_forward_viterbi(model, obs,  max_parallel=100000):\n",
        "    initial_elements = parallel_forward_viterbi_init(model, obs)\n",
        "    final_elements = tfp.math.scan_associative(parallel_viterbi_op,\n",
        "                                             initial_elements,\n",
        "                                             max_num_levels=math.ceil(math.log2(max_parallel)))\n",
        "    return final_elements[:,0]\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "o6wT6IQx7ppT"
      },
      "source": [
        "#### Backward part"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "C8CnwQC68j9l"
      },
      "source": [
        "#### Initialization routines"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "V3YxFbdr7RrK"
      },
      "outputs": [],
      "source": [
        "@tf.function\n",
        "def parallel_backward_viterbi_init_last(model):\n",
        "    psi = tf.ones_like(model.Pi)\n",
        "    return psi\n",
        "\n",
        "@tf.function\n",
        "def parallel_backward_viterbi_init_rest(model, obs):\n",
        "    temp = tf.gather(tf.transpose(model.Po), obs, axis=0)\n",
        "    psi = tf.expand_dims(temp, 1) * tf.expand_dims(model.Pi, 0)\n",
        "    return psi\n",
        "\n",
        "@tf.function\n",
        "def parallel_backward_viterbi_init(model, obs):\n",
        "    last_elem = parallel_backward_viterbi_init_last(model)\n",
        "    generic_elems = parallel_backward_viterbi_init_rest(model, obs[1:])\n",
        "    return tf.concat([generic_elems, tf.expand_dims(last_elem, 0)], axis=0)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vQjzmlFH7w8M"
      },
      "source": [
        "#### Backward operator"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "AvGHdobk7xDw"
      },
      "outputs": [],
      "source": [
        "@tf.function\n",
        "def parallel_backward_viterbi_op(elemjk, elemij):\n",
        "    elemij = tf.expand_dims(elemij, -1)\n",
        "    elemjk = tf.expand_dims(elemjk, 1)\n",
        "    return tf.reduce_max(elemij * elemjk, axis=2)\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3_6nk3z77xN8"
      },
      "source": [
        "#### Parallel backward routine"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "f27eqOgd7xWj"
      },
      "outputs": [],
      "source": [
        "@tf.function\n",
        "def parallel_backward_viterbi(model, obs, max_parallel=10000):\n",
        "    initial_elements = parallel_backward_viterbi_init(model, obs)\n",
        "    reversed_elements = tf.reverse(initial_elements, axis=[0])\n",
        "    final_elements = tfp.math.scan_associative(parallel_backward_viterbi_op,\n",
        "                                             reversed_elements,\n",
        "                                             max_num_levels=math.ceil(math.log2(max_parallel)))\n",
        "    final_elements = tf.reverse(final_elements, axis=[0])\n",
        "\n",
        "    return final_elements[..., 0]\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0t7vPByD71o7"
      },
      "source": [
        "#### Parallel Viterbi path"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "SAFd4dTq71wz"
      },
      "outputs": [],
      "source": [
        "@tf.function\n",
        "def parallel_potential_viterbi(model, obs, max_parallel=10000):\n",
        "    vlist = parallel_forward_viterbi(model, obs, max_parallel)\n",
        "    wlist = parallel_backward_viterbi(model, obs, max_parallel)\n",
        "\n",
        "    prob = vlist * wlist\n",
        "    max_prob = tf.reduce_max(prob)\n",
        "    xmap = tf.squeeze(tf.math.argmax(prob, axis=1))\n",
        "\n",
        "    return xmap"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hzBv-sCj716j"
      },
      "source": [
        "#### Comparison with sequential and parallel Viterbi implementations"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0vDiRS1TPicD",
        "outputId": "8e13c896-5ff0-458a-f45c-9704877d7c62"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Diff between parallel and sequential potential-based Viterbi path:  0\n",
            "Diff between parallel and sequential classical Viterbi path:  3\n",
            "3\n",
            "3\n",
            "2\n"
          ]
        }
      ],
      "source": [
        "with tf.device('/CPU:0'):\n",
        "    xmap2 = viterbi_potential_smoother(model, Y)\n",
        "    xmap3 = viterbi_classic(model, Y)\n",
        "    xmap = parallel_potential_viterbi(model, Y, max_parallel=100000)\n",
        "    print('Diff between parallel and sequential potential-based Viterbi path: ', np.abs(xmap - xmap2).max())\n",
        "    print('Diff between parallel and sequential classical Viterbi path: ', np.abs(xmap - xmap3).max())\n",
        "    print(np.abs(xmap - tf.convert_to_tensor(ref_xmap1, dtype=tf.int64)).max())\n",
        "    print(np.abs(xmap2 - tf.convert_to_tensor(ref_xmap1, dtype=tf.int64)).max())\n",
        "    print(np.abs(xmap3 - tf.convert_to_tensor(ref_xmap1, dtype=tf.int64)).max())"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YCWfXsbtOhG_"
      },
      "source": [
        "### Log-space parallel Viterbi"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8NNS5YeL94C6"
      },
      "source": [
        "#### Forward part\n",
        "#### Initialization routines"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "2xpnSDf-94xi"
      },
      "outputs": [],
      "source": [
        "@tf.function\n",
        "def log_parallel_forward_viterbi_init_first(model, y):\n",
        "    return tf.math.log(parallel_forward_viterbi_init_first(model, y))\n",
        "\n",
        "@tf.function\n",
        "def log_parallel_forward_viterbi_init_rest(model, obs):\n",
        "    return tf.math.log(parallel_forward_viterbi_init_rest(model, obs))\n",
        "\n",
        "@tf.function\n",
        "def log_parallel_forward_viterbi_init(model, obs):\n",
        "    first_elem = log_parallel_forward_viterbi_init_first(model, obs[0])\n",
        "    generic_elems = log_parallel_forward_viterbi_init_rest(model, obs[1:])\n",
        "    return tf.concat([tf.expand_dims(first_elem, 0), generic_elems], axis=0)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wc3Ch1rJ-DlE"
      },
      "source": [
        "#### Viterbi operator"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "idvmB7WXOjaE"
      },
      "outputs": [],
      "source": [
        "@tf.function\n",
        "def log_parallel_viterbi_op(elemij, elemjk):\n",
        "    elemij = tf.expand_dims(elemij, -1)\n",
        "    elemjk = tf.expand_dims(elemjk, 1)\n",
        "    return tf.reduce_max(elemij + elemjk, axis=2)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iffnW0Q5-M7C"
      },
      "source": [
        "#### Parallel forward routine"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "c_8Ood9C-NGc"
      },
      "outputs": [],
      "source": [
        "@tf.function\n",
        "def log_parallel_forward_viterbi(model, obs,  max_parallel=100000):\n",
        "    initial_elements = log_parallel_forward_viterbi_init(model, obs)\n",
        "    final_elements = tfp.math.scan_associative(log_parallel_viterbi_op,\n",
        "                                             initial_elements,\n",
        "                                             max_num_levels=math.ceil(math.log2(max_parallel)))\n",
        "    return final_elements[:,0]\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UuQJ8LEM-6yT"
      },
      "source": [
        "#### Backward part"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UAbryy4M-NUA"
      },
      "source": [
        "#### Initialization routines"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "pwqYDIqj-NeG"
      },
      "outputs": [],
      "source": [
        "@tf.function\n",
        "def log_parallel_backward_viterbi_init_last(model):\n",
        "    log_psi = tf.zeros_like(model.log_Pi)\n",
        "    return log_psi\n",
        "\n",
        "@tf.function\n",
        "def log_parallel_backward_viterbi_init_rest(model, obs):\n",
        "    temp = tf.gather(tf.transpose(model.log_Po), obs, axis=0)\n",
        "    log_psi = tf.expand_dims(temp, 1) + tf.expand_dims(model.log_Pi, 0)\n",
        "    return log_psi\n",
        "\n",
        "@tf.function\n",
        "def log_parallel_backward_viterbi_init(model, obs):\n",
        "    last_elem = log_parallel_backward_viterbi_init_last(model)\n",
        "    generic_elems = log_parallel_backward_viterbi_init_rest(model, obs[1:])\n",
        "    return tf.concat([generic_elems, tf.expand_dims(last_elem, 0)], axis=0)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NHLsGnCn-Nnz"
      },
      "source": [
        "#### Backward operator"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "9nqTMIGz-Nxe"
      },
      "outputs": [],
      "source": [
        "@tf.function\n",
        "def log_parallel_backward_viterbi_op(elemjk, elemij):\n",
        "    elemij = tf.expand_dims(elemij, -1)\n",
        "    elemjk = tf.expand_dims(elemjk, 1)\n",
        "    return tf.reduce_max(elemij + elemjk, axis=2)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2ABfvbMm-N6z"
      },
      "source": [
        "#### Backward routine"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "B8IERQTg-ODU"
      },
      "outputs": [],
      "source": [
        "@tf.function\n",
        "def log_parallel_backward_viterbi(model, obs, max_parallel=100000):\n",
        "    initial_elements = log_parallel_backward_viterbi_init(model, obs)\n",
        "    reversed_elements = tf.reverse(initial_elements, axis=[0])\n",
        "    final_elements = tfp.math.scan_associative(log_parallel_backward_viterbi_op,\n",
        "                                             reversed_elements,\n",
        "                                             max_num_levels=math.ceil(math.log2(max_parallel)))\n",
        "    final_elements = tf.reverse(final_elements, axis=[0])\n",
        "\n",
        "    return final_elements[..., 0]\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UrlrNte0-YmY"
      },
      "source": [
        "#### Parallel potential-based Viterbi forward-backward routine in log-space"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "48bn3XC7-Y0R"
      },
      "outputs": [],
      "source": [
        "@tf.function\n",
        "def log_parallel_potential_viterbi(model, obs, max_parallel=100000):\n",
        "    vlist = log_parallel_forward_viterbi(model, obs, max_parallel)\n",
        "    wlist = log_parallel_backward_viterbi(model, obs, max_parallel)\n",
        "\n",
        "    prob = vlist + wlist\n",
        "    max_prob = tf.reduce_max(prob)\n",
        "    xmap = tf.math.argmax(prob, axis=1)\n",
        "\n",
        "    return xmap"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "txOMizyG-bgU"
      },
      "source": [
        "#### Comparison of different Viterbi implementations"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "47KNgV8TOjlw",
        "outputId": "78239643-30fe-4830-bd37-e89b4ac27fda"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "3\n",
            "2\n",
            "2\n",
            "2\n",
            "3\n"
          ]
        }
      ],
      "source": [
        "with tf.device('/CPU:0'):\n",
        "    xmap = parallel_potential_viterbi(model, Y, max_parallel=100000)\n",
        "    log_xmap = log_parallel_potential_viterbi(model, Y, max_parallel=100000)\n",
        "    log_xmap2 = log_viterbi_potential_smoother(model, Y)\n",
        "    log_xmap3 = log_viterbi_classic(model, Y)\n",
        "    log_xmap4 = viterbi_classic(model, Y)\n",
        "    print(np.abs(xmap - log_xmap).max())\n",
        "    print(np.abs(log_xmap2 - log_xmap).max())\n",
        "    print(np.abs(log_xmap3 - log_xmap).max())\n",
        "    print(np.abs(log_xmap3 - log_xmap2).max())\n",
        "    print(np.abs(log_xmap4 - log_xmap3).max())\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VUlmlodBvNfY"
      },
      "source": [
        "### Performance analysis"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "2fqZglmcvO1j"
      },
      "outputs": [],
      "source": [
        "input_sizes = np.logspace(2, log10T, num=20, base=10).astype(int)\n",
        "n_iter = 100\n",
        "n_iter_seq = 10\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "67ZJOauhvaJy"
      },
      "outputs": [],
      "source": [
        "def get_average_runtimes(func, n_iter, model, observations):\n",
        "    runtimes = np.empty(input_sizes.shape)\n",
        "    for i, input_size in tqdm(enumerate(input_sizes), total=runtimes.shape[0]):\n",
        "        observation_slice = observations[:input_size]\n",
        "        max_parallel = int(input_size)\n",
        "        _ = func(model, observation_slice, max_parallel=max_parallel)  # compilation run\n",
        "        tic = time.time()\n",
        "        for _ in trange(n_iter, leave=False):\n",
        "            res = func(model, observation_slice, max_parallel=max_parallel)\n",
        "        runtimes[i] = (time.time() - tic) / n_iter\n",
        "    return runtimes"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "nMJyFdJ9vhnO"
      },
      "outputs": [],
      "source": [
        "with tf.device('/CPU:0'):\n",
        "    cpu_Y = tf.constant(Y)\n",
        "    cpu_sequential_runtimes3a = get_average_runtimes(log_viterbi_classic, n_iter_seq, model, cpu_Y)\n",
        "    cpu_sequential_runtimes3b = get_average_runtimes(log_viterbi_potential_smoother, n_iter_seq, model, cpu_Y)\n",
        "    cpu_parallel_runtimes3 = get_average_runtimes(log_parallel_potential_viterbi, n_iter, model, cpu_Y)\n",
        "\n",
        "with tf.device(device):\n",
        "    xpu_Y = tf.constant(Y)\n",
        "    xpu_sequential_runtimes3a = get_average_runtimes(log_viterbi_classic, n_iter_seq, model, xpu_Y)\n",
        "    xpu_sequential_runtimes3b = get_average_runtimes(log_viterbi_potential_smoother, n_iter_seq, model, xpu_Y)\n",
        "    xpu_parallel_runtimes3 = get_average_runtimes(log_parallel_potential_viterbi, n_iter, model, xpu_Y)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 568
        },
        "id": "13DKAy5Dzxsa",
        "outputId": "5f05898c-abe1-49a2-99dd-621b7e334fde"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 900x600 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          },
          "output_type": "display_data"
        }
      ],
      "source": [
        "fig = plt.figure(1, dpi=150)\n",
        "plt.loglog(input_sizes, cpu_sequential_runtimes3a, label=\"Viterbi C Sequential-CPU\", linestyle=\"-.\", linewidth=3)\n",
        "plt.loglog(input_sizes, cpu_sequential_runtimes3b, label=\"Viterbi P Sequential-CPU\", linestyle=\"-.\", linewidth=3)\n",
        "plt.loglog(input_sizes, cpu_parallel_runtimes3, label=\"Viterbi Parallel-CPU\", linewidth=3)\n",
        "plt.legend()\n",
        "plt.xlabel(\"Number of data points\")\n",
        "plt.ylabel(\"Average run time (seconds)\")\n",
        "plt.grid()\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 568
        },
        "id": "xHA77tPvw4S0",
        "outputId": "e88290db-3a19-4c1b-b5fd-b168eb231d89"
      },
      "outputs": [
        {
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAzMAAAInCAYAAACsmwePAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAAXEQAAFxEByibzPwAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOzdeVxV1fr48c9mngkREUHBicEJnCFEUUv9pmk5pKhcRUlN1L71LetmGda9Zf2s8FpaKg5XzbmcUlNRUZHBCUpxwAHNHHBIZRCVw/79gaDHcxgOQ6I+79frvIqz11p77cM+eJ6z1rOWoqoqQgghhBBCCPGkMXrcHRBCCCGEEEKI8pBgRgghhBBCCPFEkmBGCCGEEEII8USSYEYIIYQQQgjxRJJgRgghhBBCCPFEkmBGCCGEEEII8USSYEYIIYQQQgjxRJJgRgghhBBCCPFEkmBGCCGEEEII8USSYEYIIYQQQgjxRJJgRgghhBBCCPFEkmBGCCGEEEII8USSYEYIIYQQQgjxRDJ53B0QZaMoyiXACvjjcfdFCCGEEEKISlIXyFFVtXZ5KiuqqlZyf0RVUBTllrm5uW3Dhg0fy/mzs7MBsLa2fiznF+JpIe8lISqHvJeEqDyP8/106tQp7ty5k6mqql156svITDWmKMpzwHP3f7xUv3592yNHjjyWvmzfvh2ALl26PJbzC/G0kPeSEJVD3ktCVJ7H+X5q2rQpqamp5Z55JDkz1dv/AmfuPxpfu3btMXdHCCGEEEKI6kOCmeotCqh//5Hm6Oj4mLsjhBBCCCFE9SHTzKoxVVVvADcAFEW5Z2QksacQQgghhBCFJJipxh7JmTHNz89/nN0RQgghhBCiWpGv+qs3yZkRQgghhBCiGBLMVG+SMyOEEEIIIUQxZJpZNVYZOTOqqlKZewnJVDchKoe8lx4/RVFQFOVxd0MIIUQFSDDzFNJoNFy7do3MzEzu3r1bKW0WbqJ0/PjxSmlPiGeVvJeqFzMzM2xtbXF0dMTY2Phxd0cIIYSBJJh5ymg0Gs6dO0dubm6ltis7LAtROeS9VL3cvXuXa9eukZ2dTb169SSgEUKIJ4wEM9VYeVYzu3btGrm5uRgbG+Ps7Iy1tTWVsaTzrVu3ALCzs6twW0I8y+S9VH3k5+eTnZ3N5cuXyc3N5dq1a9SqVetxd0sIIYQBJJip3v4X+Ljwh7KsZpaZmQmAs7Mz9vb2ldaRwoBI9roRomLkvVR9GBkZFf2dvHDhApmZmRLMCCHEE0b+Na3eDFrNTFXVohwZmcoihBBlU/j38u7du5W6YIoQQoiqJyMz1Zihq5k9/I+wfOsrhBBl8/DfS1VVZYUzIYR4gsgnXiGEEEIIIcQTSYIZIYQQQgghxBNJpplVY+VZzUwIIYQQQoiyuHn7HjdyKmdPwsdFgpnqzeDVzIQQQgghhChJ+tVs5sedYeWB87R2dyCs/uPuUfnJNLPqzaDVzISuwYMHoygKn376aallk5KSUBQFZ2dn8vLy2LlzJ4qiMHz48KrvaBl4eHgYnJgcGRmJoigsWLDA4PNlZ2fz9ddf07lzZ5ydnTEzM8PBwYGAgAAmT57MuXPnDGrv4MGDhIaG4u7ujrm5OXZ2djRq1IiXX36ZadOmcfHiRYP7+KyrzHt0+PDhKIrCzp07y93Gvn37GD16ND4+Ptjb22NmZoazszNdu3bls88+4+zZszp1FixYgKIoWg9TU1Pc3NwICQnh4MGDOnUKy6Wnpxfbl8J7v7q8f4UQ4nFTVZXE09d4/b/76fzVThbGnyXnrobdaVc5n/nkzv6RYKYaU1X1hqqq6aqqpgOlrmYmdIWGhgKwZMmSUssuXrwYgJCQEExMih+0rEiA8KTYu3cvjRo14v/+7/9ISkqiWbNm9O/fn+eff55Tp07x6aef4unpybZt28rU3vz582nXrh2LFy/GyMiI7t2707NnTxwdHfn111959913iY2NreKrevI8Kffa3bt3CQ8Pp127dsyePZvc3FyCg4Pp378/LVq04MCBA0yaNInGjRvz448/6m2jYcOGDBs2jGHDhtGnTx9MTExYtmwZ/v7+rFu37m++IiGEeHrc0+Sz5tCf9P42joGzE9iaeplHV6Hfci7v8XSuEsg0M/FU69atG87Ozhw/fpx9+/bRtm1bveXy8vJYvnw58CAAateuHUePHq3UzUf/buPGjWPQoEG4uLiUuU5ycjJdu3YlNzeX9957j48++khr36L8/HzWrFnDxIkTOX/+fKnt/fnnn4wdOxaNRsPMmTMZPXq01lK4f/31FytWrMDV1dWwixPV5h4dOnQoK1euxNPTkzlz5tCxY0et43l5eaxfv56PP/6Y06dP622jQ4cOWkHbvXv3GDt2LHPnzmXMmDH06NEDMzOzqrwMIYR4qtzIucuPSef4796zXLqVW2LZhAsa+jV6MvfZkmBGPNWMjY0JCQkhKiqKxYsXFxvMbNmyhYyMDHx8fGjdujUAVlZWeHt7/53drXQ1a9akZs2aZS6vqiqhoaHk5uYSGRnJxx9/rFPGyMiIvn370rVrV/74449S29y4cSO5ubkEBgbyxhtv6Bx3cHBg9OjRZe6jeKA63KPLli1j5cqVuLi4sGfPHpycnHTKmJiY8Oqrr9KzZ09OnDhRpnZNTU2Jiopi2bJlXLx4kaSkJDp06FDZ3RdCiKfO6StZzI9LZ9WB89y+pylTnTwVdvyRx6tV3LeqIPOWnlF/XM8x6PHnjVz+vJFrcL3yPirT0KFDAVi+fDkajf43deE0tMKyoD8fwcPDgylTpgAQFhamNc//0VyDxMREBgwYgIuLC2ZmZri5uREeHq431+Th6URJSUn06tULR0dHFEUhOTlZq6yqqkyfPp0mTZpgYWGBq6srEyZM4MaNGyW2WxabN2/m8OHDuLm5MWnSpBLL2tvb06xZs1LbvHLlCoDeD7mlycvLY9asWQQEBGBnZ4elpSV+fn5ERUWRl6d/SPzIkSO88sorODg4YGtrS1BQEJs3by42vyQ4OLjY/Iv09HQURSE4OFjvuTZv3kzPnj1xcnLC3NycBg0a8Pbbb+tdrKMwJ2X37t3ExcXRpUsXbG1tsbOzo2fPnqSmpmqVL8u9Vtw13bhxgxkzZtC9e/eiHCVHR0d69OjB1q1b9V5LeU2bNg2AKVOmlPo7NjMzK9M9U8ja2hpPT0+AMgXOQgjxrFJVlfhT1whfuI+uX8eyKOFsmQMZADszsDZ9MjcMlpGZaqwql2YO+nJHpbVVFdKn9qy0tlq3bo2Pjw9Hjx5l69at9OjRQ+t4dnY2a9euRVEUhgwZUmJb/fv3Z9u2baSkpBAYGEijRo2KjtWuXbvo/2fOnMn48eMBaNu2LUFBQRw/fpzo6GjWrVtHbGwsPj4+Ou3v2rWLUaNG4enpSbdu3bhw4QKP5kqNHz+e2bNnExwcTPPmzYmNjWXGjBnExsaye/du7OzsDH6NCv3yyy8ADBgwoMS8IUPUrVsXgJiYGI4fP46Xl1eZ6t2+fZuePXuyY8cOatSogb+/PxYWFiQmJvLWW2+xY8cOfv75Z63XZ//+/XTu3JmsrCyaNWtGs2bNSEtL46WXXtI7KlQR77//Pl988QVmZma0bdsWFxcXUlJS+Oabb1i3bh1xcXE4Ozvr1Nu8eTOzZs2iTZs2vPTSSyQnJ7Nx40YSExM5fPhw0X1U1ntNn4SEBCZMmICHhwdeXl4EBARw7tw5tmzZwpYtW5g7dy4jRoyo8Gtw5coVDhw4gJGREQMHDqxwe/pkZmYCYG5uXiXtCyHEk+xuXj4bfrvA3N1nSL14y+D6Xs62jOxQH/sbJzA1lmBGVD5ZmrmShIaG8sEHH7B48WKdYOann34iOzubTp064e7uXmI706ZNIzIykpSUFMLDw/WulFT4QdLFxYW1a9cWTVsDiI6OJjw8nLCwMBISEnTqzp8/ny+++IKJEycW24dFixYRHx9f1G5WVhZ9+vRh+/btTJ48maioqBKvoSSFo0CtWrUqdxuP6t27N7Vq1SIjIwNfX1969+5NcHAwrVq1olWrVsXmQbzzzjvs2LGDgQMH8sMPPxTlhWRmZjJo0CDWrVvH7NmzGTNmDFDwrdSwYcPIyspi8uTJRaMaUBBcRkREVNo1rVy5ki+++IJmzZrx888/FwUaqqoSGRnJJ598wptvvsmyZct06s6cOZNFixYxePBgADQaDQMHDmT16tXMnDmTTz75BCjbvVYcLy8v4uPj8ff313r+0KFDdOnShbfeeovXXnsNGxubcr4CBVJSUgBo0KBBhYLo4qSmphbl2LRo0aLS2xdCiCfVX9kF+TAL96aTkXnH4PrBXk6M7FCfDo1qoigK27enVUEv/x4yzax6k6WZK8mQIUNQFIU1a9aQnZ2tdaxwFbOHp5hVxNSpU9FoNHz//fdagQzAyJEj6d27N4mJiRw6dEinbvPmzXn33XdLbH/cuHFa7drY2DBjxgwURSE6Oprc3JKT/EpSGDCXZ0pYcezt7fn1119p0qQJd+7cYeXKlURERBAQEICDgwNDhgwhLU37j2hGRgZz5syhbt26zJ8/XyvB3dbWlujoaMzMzJg1a1bR8zt37iQ1NZUGDRowefJkrfbGjh1L+/btK+2a/v3vfwOwdOlSrRETRVGIjIzEz8+PVatWcfXqVZ26/fv3p1evXkU/Gxsb889//hMoGJmrDPXr19cJZABatmxJREQEt27dYseOio/OFt4vxeVlrV+/nuHDh2s93nnnnVLbzc7OJiYmhr59+6LRaHjhhRe0XmchhHhWnbqSxaSffydgagz/79fjBgUy5iZGhLSrx7a3O7IgrB1BjZ0M3vKhOpKRmWpMVdUbwA0ARVFkaeYKqFevHh07diQ2NpY1a9YUTSe7fPkyMTExWFhYMGDAgAqfJz8/n5iYGKysrOjevbveMkFBQaxbt46kpCRatmypdaxXr16l/mEZNGiQznNNmjTB19eX5ORkDh06REBAQPkvogr4+fnx+++/s23bNjZt2kRCQgLJycnk5OTw448/snbtWjZt2kRQUBBQEJjcu3ePHj16YGlpqdNe7dq1ady4Mb///ju3b9/G0tKS3bt3AwXBgrGxsU6dkJAQEhMTK3wtGRkZpKSk0LhxY735H4qiEBgYSHJyMgcOHNC5D7p06aJTpzAvpDL32tFoNMTExLB3714uXrzInTsF/+AVBo6PBpBVISUlhYULF2o95+7uXpRn87CFCxfqlAVo06YNixYtqrI+CiFEdVeYDzN3zxm2H8swuH5NG3OGBbgzuH09HG0emrJ76wLsmwvmdsCTO/otwYx4ZoSGhhIbG8vixYuLgpmlS5ei0Wjo27dvpSxve/XqVbKysgBKXUZW37f29erVK/UcxU2F8/DwIDk5mQsXLpShp/oVjv4VJu1XJiMjI7p160a3bt0AyMnJYe3atUVLPI8cObJopavCZPw5c+YwZ86cEtu9fv06rq6uRddd0utTGQr7lpaWVmrgqe93XKdOHZ3nbG1tAYoCjoo6f/48vXr1KpoGpk9hLkpJpk6dyrFjx7Se8/b25v333wce3C/6rhPgww8/5MMPPwTg0qVLJS4R3rBhw6LVykxNTXF2diYoKIgXX3xRJ2+sLNT7myg8Dd86CiGeTXfyNKxLvkD0njMcu1T63+xHede2JTyoAS/7umBu8tCXfOcPQMJMSF0D+XlgWQOjVjPJN34ycxMlmBHPjP79+zNu3Di2bdtGRkYGtWrVKppiVri3TEUVLtJgY2NDv379SizbtGlTnecsLCwqpR/l5efnR1xcHAcPHqy0aXfFsbKyIiQkhKZNm+Lr60taWhonTpzA09Oz6HX08/PD19e3xHaqMjFc36Ibhc/Vrl272NG3QvoCq79jhDU8PJyUlBT69evHxIkT8fLywtbWFiMjI2bPns3o0aOLPuyXZPPmzTqbmXbq1KkomCnMYzl9+jS3bt2qUN7Mo/vMlMTKyoqcnBxycopf+bDw2MN7JAkhxJPkg58Os/pg6fu5PaqLdy3CO9QnoKHjgy90NHlwdB0kzILzSdoVbl+ndkYsF1y6VUKv/34SzDyjdk/sbFD5wtGGiiYMP0729vb07t2bFStWsHTpUrp3786BAweoWbOmzqIA5VWzZk0sLCwwMjJi/vz5VfKt8NmzZ2nevLne50H/N/9l1bNnT7777jtWrlzJl19+WWkrmpWkRYsWODo6cu3aNa5evYqnpydubm5AwQfcGTNmlKmdwm/9C1+HRxX3fOEIWuE9/jB9ywEX9q1mzZpl/vD9d8rOzmbr1q04OzuzfPlynSl3xW1aqc+jy40/qlatWrRu3ZoDBw6wYsUKwsPDy9Nlg7m5uXHixAlOnz5NkyZN9JYpvM7C35cQQjxpBratW+ZgxsLUiH6t3AgLrE+jWg99Vsu5DgcXQtJcuFV8W25/buBC7Rcr2uXHQpIwnlF1a1gZ9HB9zgLX5ywMrlfeR1UpHG1YsmRJ0d4yAwcOxNTUtMxtFH741bfPiYmJCcHBwdy6dYuYmJhK6LGuFStW6Dx37NgxkpOTsbGxwc/Pr9xt9+jRg6ZNm3L+/PmiJPfi3Lp1iyNHjpTaZmkjANevX+f69esAuLq6AtC5c2eMjY3ZsGED9+7dK1PfC/NtVq9erXdERd/KYvAgCNK3maO+PVnc3Nzw9vYmNTW1zBtAlldJ91pxbt68SX5+Pi4uLjqBzL179/j5558rtY+FCf2TJ0+ukumJ+nTs2BF4sJT4o7Kzs9m+fTvw4L4QQognTVsPB5q7ljwFvpatOe929yL+/a78+9XmDwKZKydgw1vwdRPYFlliIANgk/MHDjeKn5pcnUkwI54pPXr0oGbNmuzbt4/vv/8eMHyKWeHIx/Hjx/UenzRpEkZGRoSFhen9ZjsrK4t58+Zx+/Ztwzp/34wZM7RWQsvJyWH8+PGoqkpYWJjehPmyUhSFxYsXY2FhQWRkJP/85z91Vn9TVZV169bRpk0b9u3bV2qbs2bNYtSoUfz22286x65fv87w4cNRVZU2bdoUTctydXVlxIgRpKenExISwuXLl3Xqnjx5ktWrVxf9HBwcjLe3N6dOneJf//qXVtkffviB+Ph4vf3r1KkTAF999ZXWtKXt27cXu8z1Rx99RH5+Pv369dPZ1BQKVvkqLdenLEq71/SpVasW9vb2HD58mLi4uKLnNRoN7733XqUHYIMGDaJ///5cvHiRDh06FLsiW3Gvf3lERERgbGxMdHQ069ev1zqWm5vLmDFjuHHjBm3atCEwMLDSziuEEH8nRVEID6qv91gTFzu+fs2XPe91IaJzIxyszUBV4eQ2WNwPvmsL++dBXtk/a7he3FJZXf9byTSzaqwqN818VpmamjJo0CC+/fZbrl69SuPGjQ1esrdbt25YWFjwzTffcPjwYerUqYOiKLz77rt4eXnRoUMHvvvuO8aNG0fnzp1p1qwZnp6emJqakp6eTnJyMnfu3KFv377lCjyGDh1K+/bt6dKlC/b29uzatYtLly7RtGlTPv30U4Pbe5Sfnx/btm2jX79+TJ06lf/85z8EBATg7OzMzZs32b9/P5cvX8bCwqJoQ8yS3L17tyiR393dnRYtWmBjY8OlS5dISkoiOzsbJycn5s2bp1Vv+vTppKens3r1ajZv3oyfnx/16tUjOzub1NRUTp48SZ8+fYpyk4yMjFiwYAFdu3bl448/ZtWqVTRr1oyTJ0+yf/9+xo4dy8yZM3X6FxISwpdffsnevXvx8fGhbdu2nD9/nn379vH222/rXXlr8ODBHDlyhM8++4zWrVvj5+dHw4YNUVWVU6dO8dtvv2FjY8Prr79ezt9CgdLuNX1MTEyYOHEikyZNolOnTnTp0oUaNWqQmJjI5cuXiYiI4LvvvqtQvx61ZMkS7OzsmDdvHp06dcLDwwNfX1+srKy4fPkyJ06c4Pz585iYmOhdjc9Qfn5+TJ8+nQkTJtC7d29atmyJt7c3t2/fZu/evWRkZODm5lY0+iqEENXFtaw7LE44R88WLtrTwYrxUnMXPt94jEu3clEU6Opdi5EdGuDfoMaDqex3c+C3ZZDwPVwt+5dfRRzqc6JGFy46d6GW4bUfOwlmqjfZNLMKhIaG8u233wLl21umTp06rF27lk8++YQ9e/YU5VoMHTq06APmmDFj8Pf3Jyoqip07d7JhwwasrKxwdXVlyJAhFVo97T//+Q/169dn7ty5nDlzhho1ahAREcGnn35aKSuyAQQGBnLy5El++OEH1q9fz2+//cZff/2FjY0NXl5ejBkzhvDw8DLlI4wYMYK6devy66+/sn//fhITE7l+/TrW1tY0adKE//mf/2H8+PE6e5VYWlqyadMmlixZwsKFC0lOTiYpKQknJyfc3d0JDQ3V+WDcvn174uPjmTRpErt27eL06dO0aNGC9evXY21trTeYsbS0JCYmhnfffZfNmzezceNGmjZtyvLly2nTpo3eYAYK9prp3r073377LXFxcfz+++/Y2dnh6urKG2+8USlLfZflXtPngw8+wM3NjaioKOLi4rC0tKRDhw588sknHDx4sML9epSZmRnR0dGMGTOGuXPnEhsbS0xMDHfu3MHBwQEfHx9ef/11/vGPf1TaqnIRERG0adOGqKgo9uzZw5EjRzAzM6Nhw4a8/vrrvPXWW8jeXEKI6uLE5Uzm7TnDT4f+5G5ePpdu5fJ5X93810eZGhsxulMDTl/JJizQgwZODwVAN89D0hw4sABybxjeKY8g8B8Lnt05vzO29PLVlFKWFW3E4/HIyMwWb2/vxkePHi22fH5+ftF0FC8vr0pdNenWrVsAVbLLtxB/h507d9K5c2eGDRv2WBP35b1U/VTl305RdQrzovTt3SREdXHg7F9Mj0lj1wntnEJzEyPi/9mVGtYlb+Og1x/77i+tvBZUjWF1jc2hxQBo/wbUfrBX2uN8PzVt2pTU1NRUVVV1l3ktAxmZqcZk00whhBBCiCfX+b9ydAIZgDt5+SxJOMv4ro3L1pDmXkHwkjAL/txveEdsnKFtOLQOAxsnw+tXYxLMCCGEEEIIUQUeznl51ML4s4zq1EB7Q8tH5VwvmEaWNAcyy7EptotvwVSypq+CyZO5KWZpJJgRQgghhBCiCpgaGzHseQ++2HxM59jVrDusT7lI/9bF5J8e3wQrwwxakQwAxQi8exUEMfX8oQr2vKtOJJgRQjwTgoODy7TrvRBCCFEaVVW5q8kveVTlvsHt6vGfmDRu33uQ31LbzoLhgR686ONcfMU6rSC/7PuMYW4PrUKh3ShwcC97vSecBDNCCCGEEEKUQe49DWsO/Un0njP08avDuC6l57zYW5kyoI0b/40/Sws3e0Z2qM9LzV0wNS4lF9rWGZr3h5SlJZer0RD83wDfEDAvfbnnp40EM0IIIYQQQpTgSuYdFiWcZXHCWa5n3wUKcl5e71hKzst9ozo2oFeLOrT1cHiwP0xZtB9TfDDTILhgKlmjF+EZXiRKghkhhBBCCCH0OHbpFtG7z7A2+QJ3Ndqbl1/JLCXn5SFuDla4OVgV/PDnQUAF19ald6COH7gHwtm4gp9NLKDFawVLKzs3MfBqnk4SzAghhBBCCHFffr5KbNoVonefYc/JqyWWjd5zhn6tXEsfbcnXFCT0x38H5/YWBChhG8vWIf834PrpB0srW8uGwA+TYEYIIYQQQjzzcu9p+Ongn8yLO8PJjKwy1Tl68Rbxp67xfKOa+gvczYbkHws2ubx++sHzZ+MKRmhcW5V+Eq+XoHF3MCnHBpvPAAlmqjFFUZ4Dnrv/o2l+fn5JxYUQQgghhIEyMnNZFH+WJYnnivJhyspIgeTzN4oPZq4ch43v6D+WMBP6zS3DSYwLHkIvCWaqt/8FPi784dq1a4+xK0IIIYQQT4/UC7eI3nOG9Sm6+TClsTYzZmDbeoQFelC3hlXxBV1baee8POzIz/BCJNiXnnMjiifBTPUWBSy4//9bHB0dS1//TwghhBBC6JWnyWfb0cv8N/4se08Z/iWx63OWDH/eg4Ht6mJnYVq2SgER+oOZ/DxI/AG6fWpwP8QDEsxUY6qq3gBuACiKcs/oGV52TwghhBCivDIyc1mW9Ac/Jp7j0q1cg+v71X2O8KD69GhaG5PS9od5lOf/QI0G2jkzAB5B0KCTwX0R2uTTsXiqDR48GEVR+PTT0r/1SEpKQlEUnJ2dycvLY+fOnSiKwvDhw6u+o2Xg4eFh2Nr0QGRkJIqisGDBgjLXURRF62FkZMRzzz1HUFAQc+fORVVVg/pw8OBBQkNDcXd3x9zcHDs7Oxo1asTLL7/MtGnTuHjxokHtCSr13hw+fDiKorBz585yt7Fv3z5Gjx6Nj48P9vb2mJmZ4ezsTNeuXfnss884e/asTp0FCxbo3Gumpqa4ubkREhLCwYMHdeoUlktPTy+2L4X3fHV53wohHh9VVdmXfp3xSw8ROHU7X289YVAgY6TAS81rs/qN51kTEUivFnUKApnMy7D9X7DpvTI2ZFSwHwyAkQk0fw1G7YThG6DRCwZfl9AmIzPiqRYaGsrSpUtZsmQJH330UYllFy9eDEBISAgmJsW/NSIjI5kyZQrz589/qj8wDRs2DACNRsOpU6eIi4tjz549xMTEsHRpKbsR3zd//nxef/11NBoNHh4edO/eHWtra06fPs2vv/7Khg0bcHNzY9CgQVV5KU+cJ+Ueu3v3LmPHjiU6OhooCLiDg4OxtrbmypUr7Nu3j+3btxMZGcmCBQsYPHiwThsNGzakQ4cOAGRlZbF//36WLVvG6tWrWbVqFb179/5br0kI8eTLvpPHmuQ/WRR/lmOXMg2ub2NuwsC2dRn+/CP5MJePQPxM+H0FaO4WBCaBb4JdndIb9RsMmZegzQiwdzW4T6J4EsyIp1q3bt1wdnbm+PHj7Nu3j7Zt2+otl5eXx/Lly4GCAAigXbt2HD16FHt7+7+tv5Vt3LhxDBo0CBcXF4PrPjqas3XrVl566SWWLVvGkCFD6NWrV4n1//zzT8aOHYtGo2HmzJmMHj2ah6dK/vXXX6xYsQJXV/mjbqjqcm8OHTqUlStX4unpyZw5c+jYsaPW8by8PNavX935VbQAACAASURBVM/HH3/M6dOn9bbRoUMHrXvt3r17jB07lrlz5zJmzBh69OiBmZksRyqEKN2pK1ksij/L6gPnybyTZ3B91+csCQv0YGDbutgW5sOoKpyMgfhv4fQO7Qr5eZA0uyCJvzRm1tC15C9VRflIMCOeasbGxoSEhBAVFcXixYuLDWa2bNlCRkYGPj4+tG5dsCOvlZUV3t7ef2d3K13NmjWpWbOY5SIN9OKLLxIaGsr8+fNZs2ZNqcHMxo0byc3NJTAwkDfeeEPnuIODA6NHj66Uvj1rqsO9uWzZMlauXImLiwt79uzByclJp4yJiQmvvvoqPXv25MSJE2Vq19TUlKioKJYtW8bFixdJSkoqGrkRQohHFST0Z7AoIZ24k+Vb9bVlvecI79CA7k2dH+TD3MstGIGJ/w6uHCu+8v55EPQOmNuU69yi4iRnRjz1hg4dCsDy5cvRaDR6yyxZskSrLOjPS/Dw8GDKlCkAhIWFac33fzTnIDExkQEDBuDi4oKZmRlubm6Eh4dz7tw5nfM/nNuSlJREr169cHR0RFEUkpOTtcqqqsr06dNp0qQJFhYWuLq6MmHCBG7cuFFiu5WhZcuWAPzxxx+llr1y5QqA3g+5pcnLy2PWrFkEBARgZ2eHpaUlfn5+REVFkZen/9u2I0eO8Morr+Dg4ICtrS1BQUFs3ry52PyS4ODgYvMv0tPTURSF4OBgvefavHkzPXv2xMnJCXNzcxo0aMDbb7+td/n0h3NSdu3aRa9evXB1dcXOzo6ePXuSmpqqVb4s91hx13Tjxg1mzJhB9+7di3KUHB0d6dGjB1u3btV7LeU1bdo0AKZMmVLq79jMzIxmzZqVuW1ra2s8PT2Bst1rQohnz5XMO3y7PY2OX+5gzOIDBgcy5iZG9G/txrpxgfw8NpCeLVwKApmsK7BzKnzTFNaNLzmQAci9WbAppnhsZGTmWfWXbkJuSZSs+zvhav6mbx4c3CutqdatW+Pj48PRo0fZunUrPXr00DqenZ3N2rVrURSFIUOGlNhW//792bZtGykpKQQGBtKoUaOiY7Vr1y76/5kzZzJ+/HgA2rZtS1BQEMePHyc6Opp169YRGxuLj4+PTvu7du1i1KhReHp60q1bNy5cuMCjq9iNHz+e2bNnExwcTPPmzYmNjWXGjBnExsaye/du7OzsDH6Nyiozs2Dusbm5eall69atC0BMTAzHjx/Hy8urTOe4ffs2PXv2ZMeOHdSoUQN/f38sLCxITEzkrbfeYseOHfz8889ar8v+/fvp3LkzWVlZNGvWjGbNmpGWlsZLL72kd1SoIt5//32++OILzMzMaNu2LS4uLqSkpPDNN9+wbt064uLicHZ21qm3fv16pk+fTsuWLXnxxRc5cuQIGzduJDExkcOHDxfdP2W9x/RJSEhgwoQJeHh44OXlRUBAAOfOnWPLli1s2bKFuXPnMmLEiAq/BleuXOHAgQMYGRkxcODACrenjyH3mhDi2aCqKgfO/sV/48+y6fBF7mkMW5AGoF4NK4b612NA67o4WD80hTXjWMEmlinLQHPHsEYPLYL2owzui6gcEsw8q6a3MKi4bRV1o1iRNyu1udDQUD744AMWL16sE8z89NNPZGdn06lTJ9zdSw6ipk2bRmRkJCkpKYSHh+tNzi78QOni4sLatWuLpq0BREdHEx4eTlhYGAkJCTp158+fzxdffMHEiROL7cOiRYuIj48vajcrK4s+ffqwfft2Jk+eTFRUVInXUF6qqrJhwwYAWrQo/f7p3bs3tWrVIiMjA19fX3r37k1wcDCtWrWiVatWxeZBvPPOO+zYsYOBAwfyww8/FOWFZGZmMmjQINatW8fs2bMZM2ZMUb+GDRtGVlYWkydPLhrVgIKgMiIioqKXXmTlypV88cUXNGvWjJ9//rko0FBVlcjISD755BPefPNNli1bplM3KiqK1atX06VLF6Bg9GHgwIGsXr2amTNn8sknnwBlu8eK4+XlRXx8PP7+/lrPHzp0iC5duvDWW2/x2muvYWNTsS8lUlJSAGjQoEGVBM+pqalFOTZludeEEE+/Q+f+4oOfD3P04i2D6yoKBHs68Y8ADzp5OmFkdH9lUFWF0zsLppKdLMfotX098B8DLUMNrysqjUwzE8+EIUOGoCgKa9asITs7W+tY4SpmD08xq4ipU6ei0Wj4/vvvtQIZgJEjR9K7d28SExM5dOiQTt3mzZvz7rvvltj+uHHjtNq1sbFhxowZKIpCdHQ0ubmGr59fEo1GQ1paGiNGjCA+Ph5zc3PCwsJKrWdvb8+vv/5KkyZNuHPnDitXriQiIoKAgAAcHBwYMmQIaWlpWnUyMjKYM2cOdevWZf78+VoJ7ra2tkRHR2NmZsasWbOKnt+5cyepqak0aNCAyZMna7U3duxY2rdvX8FX4IF///vfACxdulRrxERRFCIjI/Hz82PVqlVcvXpVp25ISAivvPJK0c/Gxsb885//BApG5CpD/fr1dQIZKJgeGBERwa1bt9ixY4eemoYpnE5XXD7W+vXrGT58uNbjnXfeKbXd7OxsYmJi6Nu3LxqNhhdeeEHrdRZCPLscrc05dsmwQOY5K1NGd2xA7DudmR/Wjs7etQoCmbw7BVPDvu8Ai14xPJBxbQMDFsCEQwUbYlpU3YwIUToZmRHPhHr16tGxY0diY2NZs2ZN0XSyy5cvExMTg4WFBQMGDKjwefLz84mJicHKyoru3bvrLRMUFMS6detISkoqykEp1KtXr1L3ktG3jHGTJk3w9fUlOTmZQ4cOERAQUP6LuE9fP2xtbVm4cCENGzYsUxt+fn78/vvvbNu2jU2bNpGQkEBycjI5OTn8+OOPrF27lk2bNhEUFAQUBCb37t2jR48eWFpa6rRXu3ZtGjduzO+//87t27extLRk9+7dQMH0LGNjY506ISEhJCYmGnLpemVkZJCSkkLjxo315n8oikJgYCDJyckcOHBA5/ffrVs3nTqFeSGVudeORqMhJiaGvXv3cvHiRe7cKZguURg4PhpAVoWUlBQWLlyo9Zy7u3tRns3DFi5cqFMWoE2bNixatKjK+iiEeLLUc7Qi2NOJHcevlFq2hZs9of7uvOxbBwvTh/5dyLkO+6MhaQ5kXTasA4oRePeCgHFQr/K+JBMVJ8GMeGaEhoYSGxvL4sWLi4KZpUuXotFo6Nu3b6Usc3v16lWy7ucXlbacrL5v7+vVq1fqOYqbCufh4UFycjIXLlwoQ09LV7jPjJGREXZ2djRv3py+ffvi4OBgUDtGRkZ069at6MN8Tk4Oa9euZeLEiZw/f56RI0cWrXRVmIw/Z84c5syZU2K7169fx9XVteh6S3pdKkNh39LS0koNOPX9bt3c3HSes7UtmMBZGHBU1Pnz5+nVq1fRNDB9CnNRSjJ16lSOHdNOevX29ub9998HwNHREdB/nQAffvghH374IQCXLl0qcWnwh/eZMTU1xdnZmaCgIF588UWdfLGyKNzU1dANZoUQ1d8/AjyKDWbMTIx4uUUdQgPc8av7nPbBqycL8mGSf4S824ad1NQaWv0D2o+GGvXL2XNRlSSYEc+M/v37M27cOLZt20ZGRga1atUqmmJWuLdMReXn5wMFU7/69etXYtmmTZvqPGdhYVEp/agMlbUC2qOsrKwICQmhadOm+Pr6kpaWxokTJ/D09Cx6/fz8/PD19S2xnapMDC/sh77nateuXeyoWyF9gVV5PpgbKjw8nJSUFPr168fEiRPx8vLC1tYWIyMjZs+ezejRo4s+7Jdk8+bNxMbGaj3XqVOnomCmMI/l9OnT3Lp1q0J5M4/uM1MSKysrcnJyyMnJKbZM4TFra+ty90kI8fdQVZWD525gZmxEc7fSv1Ds5OlEvRpWnLv+4G+Am4MlQ/3dea1NXWo8nNCvqnA2DvZ+Cyc2AwYuFmDnWhDAtBoGls+VXl48NhLMiGeGvb09vXv3ZsWKFSxdupTu3btz4MABatasqbMoQHnVrFkTCwsLjIyMmD9/fpV8O3z27FmaN2+u93mAOnXKsBNxNdCiRQscHR25du0aV69exdPTs2j0okOHDsyYMaNM7RR+6194/Y8q7vnCkbPCkbSH6VsOuLBvNWvWrLJAryKys7PZunUrzs7OLF++XGfKXXGbVurz6DLjj6pVqxatW7fmwIEDrFixgvDw8PJ02WBubm6cOHGC06dP06RJE71lCq9T30iYEKJ6uH1Xw9rkP1mUcJYjF27RydOJhSPalVrPyEhhqH89Ptt4jGAvJ0L93Qn2qoWx0UP/1mruwZE1ED8DLhY/Sl0sFz94fjw06QPGpobXF387CWaqMUVRngMKvw4w1fdtcbm9+ZtBxTPvf+CzreAqSI/b0KFDWbFiBUuWLCmaIjNw4EBMTcv+B6vwQ7C+/U5MTEwIDg5m8+bNxMTE8MILL1ROxx+yYsUKnWDm2LFjJCcnY2Njg5+fX6WfszxUVS0xmLt+/TrXr18HwNXVFYDOnTtjbGzMhg0b+Prrr8v0eynMt1m9ejWff/65zgiIvpXF4EEQdOLECZ0cGH17sri5ueHt7U1qamrRSFJVKekeK87NmzfJz8/HxcVFJ5C5d+8eP//8c6X28Z133iEkJITJkyfTp0+fcu0nZKiOHTty4sQJfvnlF72btmZnZ7N9+3bgwX0hhKg+MjJzWRCXzuKEs9zKffD3LfbEFc5ey8bdsfQR1YFt69G9aW3dsrf/ggMLIfEHyDR0urUCXi8VJPO7P1+w/Jl4YshqZtXb/wJn7j8a69uQr9wc3A16qPZ1Ue3rGlyv3I8q0qNHD2rWrMm+ffv4/vvvAcOnmBWOfBw/flzv8UmTJmFkZERYWJjeb7izsrKYN28et28bOG/3vhkzZmithJaTk8P48eNRVZWwsDC9ifOPw6xZsxg1ahS//aYbOF+/fp3hw4ejqipt2rQpmpbl6urKiBEjSE9PJyQkhMuXdRM0T548yerVq4t+Dg4Oxtvbm1OnTvGvf/1Lq+wPP/xAfHy83v516tQJgK+++kpr2tL27duLXd76o48+Ij8/n379+ulsZgoFq3yVlutTFqXdY/rUqlULe3t7Dh8+TFxcXNHzGo2G9957rygvqbIMGjSI/v37c/HiRTp06FDsimzFvf7lERERgbGxMdHR0axfv17rWG5uLmPGjOHGjRu0adOGwMDASjuvEKJyHDx7g5k7T2kFMoUWJ5Rt/zt7S1PtQOb6Gdj0HnzdFLZ9bFggY2IJbcNh/AEI+RE8AiWQeQLJyEz1FgUsuP//WxwdHRs/xr48FUxNTRk0aBDffvstV69epXHjxgYv3dutWzcsLCz45ptvOHz4MHXq1EFRFN599128vLzo0KED3333HePGjaNz5840a9YMT09PTE1NSU9PJzk5mTt37tC3b99yBR5Dhw6lffv2dOnSBXt7e3bt2sWlS5do2rQpn376qcHtVZW7d+8WJfK7u7vTokULbGxsuHTpEklJSWRnZ+Pk5MS8efO06k2fPp309HRWr17N5s2b8fPzo169emRnZ5OamsrJkyfp06dPUU6SkZERCxYsoGvXrnz88cesWrWKZs2acfLkSfbv38/YsWOZOXOmTv9CQkL48ssv2bt3Lz4+PrRt25bz58+zb98+3n77bb0rbw0ePJgjR47w2Wef0bp1a/z8/GjYsCGqqnLq1Cl+++03bGxseP311yv02pV2j+ljYmLCxIkTmTRpEp06daJLly7UqFGDxMRELl++TEREBN99912F+vWoJUuWYGdnx7x58+jUqRMeHh74+vpiZWXF5cuXOXHiBOfPn8fExETvKnyG8vPzY/r06UyYMIHevXvTsmVLvL29uX37Nnv37iUjIwM3NzeWLFlSCVcnhKhsLzZxpn5Na85czdY5tmL/ed5+0QtLM91VKXWoKvyRVDCV7NgvoBo4c8WmdsEml63DwKqGYXVFtSMjM9WYqqo3VFVNV1U1Hbj3dyQQPwseHokpz94yderUYe3atfj7+7Nnzx7mzZtHdHS01vK6Y8aMYf/+/QwbNozMzEw2bNjAr7/+SlZWFkOGDGHDhg3lXj3tP//5D59//jlnz55l7dq1KIpCREQEu3fvrpQV2SrLiBEjWLVqFa+//nrRh+qVK1dy8OBBmjRpwuTJk0lNTdWZMmdpacmmTZtYuHAh7du35+jRo6xatYr9+/fj5OTElClT+PLLL7XqtG/fnvj4eF5++WXOnTvHunXrMDExYf369cUuuW1paUlMTAwhISFkZmayceNGNBoNy5cvL3GjzX//+9/ExsbSr18/Ll26xJo1a9ixYwcajYY33niDdevWVfi1K8s9ps8HH3zAwoULadGiBXFxcWzbtg1fX18SEhJo06ZNhfv1KDMzM6Kjo0lKSmLUqFGYm5sTExPDqlWrOHz4MA0bNmTKlCmkpaUxderUSjlnREQEe/fuZdCgQVy5coXVq1ezbds2XFxcmDRpEsnJyVU6BVAIUX7GRgrhQfpXBLt5+x7rU0oZVdHkweGfYO4LMK8bHF1vWCDj3Bxe+R7+93cI+j8JZJ4SSllWthGPn6IoR5o0adLkyJEjxZbJz88vmpbi5eVVqasn3bpVsFFVVez2LURV2rlzJ507d2bYsGHVInFf3kvVT1X+7RRVpzA/qkuXLo+5J8IQufc0BE7dzrXsu1rPBzWuSUTnRvg3cNRfMV8Ds56HK8f0Hy9J424F+8PU7yjTyIrxON9PTZs2JTU1NVVVVd1lXstAppkJIYQQQohyuZZ1h0UJZ7EyM2ZUx9I3VLYwNWbY8x58vfUEthYmvNamLkP93alfs5TkfyNj8OhQ9mDGxAJ8B4H/WHDSPz1XPB0kmBFCCCGEEAZJv5rN3D2nWXXgPLn38rG3NGVIe3eszUv/aBnqX1BuYNu62JShfBH/sbAvmhL3jLF2gravQ9uRYF2z7G2LJ5YEM0IIIYQQokwOnfuL2btOs/nIJR7OVLh5+x4r9v9BWKD+nJiHOVibMbJD6eV0ODYsWEL5+C+6x5y8C5ZWbv4amFafDahF1ZNgRgjxVAsODi7TrvdCCCH0y89X2X4sg9m7TpOUfr3YctF7zhDq746JsQF5Z3ez4egGaPFa2fJZAiK0g5kGnQvyYRp1lXyYZ5QEM0IIIYQQQsedPA1rDv3JnN1nOJmRVWr583/dZuPhS/T2rVN647cuQNJs2D8fcm+AnUtBgn5p3J+Huv4FozQBEeBcrpxx8RSRYEYIIYQQQhS5mXOPxYlnWbA3nSuZdwyquzjhbMnBzIVDkPA9HF4F+Q9tnhn/XdmCGUWBsI0FCwIIgQQzQgghhBACOP9XDvP2pLNs3zly7moMqutsZ05YYH1C2tUrueDur+Gonv24TmyGKyfAqQz7REkgIx4iwYwQQgghxDPs8J83mb3rNL/8fhFNvmE5hp7ONrwe1IA+fq6YmZQhV8b/Df3BDEDCTHg5yqDzCyHBjBBCCCHEM0ZVVXalXWX2rlPEnbxmcH3/BjUY3bEhwV5OKIYk3tcLgNot4NJvusdSlkKXj8C6mI0zhdBDghkhhBBCiGfEPU0+61MuMHvXaY5dyjSorpEC/9PchdEdG9DC7Tntg6pattXEFKVgdGbNG9rPW9hD6zBZkUwYTIIZIYQQQoin3M2ceyzff475celcvJlrUF1LU2Nea+PGyA4NqOdopX3wThYk/whJP8Bri8C5SekNNusHWydD9hVw8CjYDNNvCJjbGNQvIUCCGSGEEEKIp9bJjCwW7D3D6gN/cvueYUn9NW3MGBbgwVB/dxyszbQP/pUOibPh0CK4c6vgucTvofd/Sm/YxBy6/QtMrcC7pyT0iwqRYEYIIYQQ4imSn6+yK+0K8+PSiT1xxeD6DWpaEx7UgL6tXLEwfSjQUFVI31MQtBzfCGq+dsXflsMLkWBVo/ST+A4yuF9C6CPBjBBCCCHEUyDnbh6rD/7JgrgznLqSbXD91u4OjOrYgBd9nDEyeih35V4u/L4SEn+Ay78X30BeLhxYAEFvG955IcqpDGvoCUMoitJGUZT/KopyUlEUVVGUfz3uPj3LBg8ejKIofPrpp6WWTUpKQlEUnJ2dycvLY+fOnSiKwvDhw6u+o2Xg4eFh2IoxQGRkJIqisGDBgjLXURRF62FkZMRzzz1HUFAQc+fORVUNW7bz71Dc72rBggUoikJkZGSFzzF8+HAURWHnzp3lbmPfvn28+eabtG3bFnt7e8zMzHB2dqZr16589tlnnD17VqdO4TU8/DA1NcXNzY2QkBAOHjyoU6ewXHp6erF9Kbw3qsv9LYQov/N/5fD5xqP4fxbDR2sOGxTIKAp0a+LM6jcCWP3G83RvWvtBIHPrIsR8Ct80gXXjSg5kCu2bC5p75bwSIQwnIzOVLxDwB/YANR9zX555oaGhLF26lCVLlvDRRx+VWHbx4sUAhISEYGJS/FsjMjKSKVOmMH/+/Kf6g+CwYcMA0Gg0nDp1iri4OPbs2UNMTAxLly59zL17sty9e5exY8cSHR0NQL169QgODsba2porV66wb98+tm/fTmRkJAsWLGDw4ME6bTRs2JAOHToAkJWVxf79+1m2bBmrV69m1apV9O7d+2+9JiHE46WqKvvP/sX8uDNsPnwJA7eHwczEiH6t3AgPqk9Dp0cS788fgMRZcORnyM8zrOHMS/DnQajX3rB6QpSTBDOVb4aqqtMBFEVJf8x9eeZ169YNZ2dnjh8/zr59+2jbtq3ecnl5eSxfvhwoCIAA2rVrx9GjR7G3t//b+lvZxo0bx6BBg3BxcTG47qOjOVu3buWll15i2bJlDBkyhF69elVSL59+Q4cOZeXKlXh6ehIVFUVgYCB2dnZFx/Py8li/fj0ff/wxp0+f1ttGhw4dtH4n9+7dY+zYscydO5cxY8bQo0cPzMzM9NYVQjxd8jT5DPghnkPnbhhc18nWnKHt3Rncvh5OtuYPDmjuQeragnyY8/sM75SlA7QeDm3Dwd7N8PpClJNMM6tkqvpoNpx4nIyNjQkJCQEejLzos2XLFjIyMvDx8aF169YAWFlZ4e3tXa5AoLqoWbMm3t7elRKQvfjii0WB3po1ayrc3rNi2bJlrFy5EhcXF/bs2UNgYKBOGRMTE1599VX279/PK6+8UqZ2TU1NiYqKwsbGhosXL5KUlFTZXRdCVFMmxka4OViVXvAhzV3t+fo1X/a815k3X2j8IJDJvga7pkFUC1g90vBAxskbekXBW6kFyf8SyIi/WaUHM4qimCmK4qsoyguKovS//19fRVEe+1eGiqK0VhTlfUVRflIU5fz9nJZSB2YVRbFUFOUTRVFOKIqSqyjKBUVR5imK4vp39Lsy5OXn8WfWn+V+XMy+yMXsixVqoyKPPEOHuR8ydOhQAJYvX45Go39ZyiVLlmiVBf15GB4eHkyZMgWAsLAwrTyGR3MpEhMTGTBgAC4uLpiZmeHm5kZ4eDjnzp3TOf/DuS1JSUn06tULR0dHFEUhOTlZq6yqqkyfPp0mTZpgYWGBq6srEyZM4MYN3W/oypMzU5KWLVsC8McffwBw48YNZsyYQffu3XF3d8fc3BxHR0d69OjB1q1b9bYRHBxclM/x448/4u/vj62tLc8992ADtl9++YURI0bg4+ODnZ0d1tbW+Pr68tlnn3Hnzp1KuRZVVVm6dCldunTBwcEBCwsLfHx8iIyMJCcnp1LOATBt2jQApkyZgpOTU4llzczMaNasWZnbtra2xtPTE3jwOxFCPBtGBHqUWsZIgZea12bVmADWjQukbys3zE3ur052ORXWjS/Ih9n+KWReMODsCnj2gNA1MDYB2oSBmWHBlRCVpVKmmSmK4gQMB3oC7QBzPcXuKIqSBGwAFqqqavhagRX3EdDHkAqKolgA2ynIg7kIrAU8gDCgl6Io/qqq6p8XUo1czrlMj9U9Hnc3ym1zv8242pQvdmzdujU+Pj4cPXqUrVu30qOH9uuQnZ3N2rVrURSFIUOGlNhW//792bZtGykpKQQGBtKoUaOiY7Vr1y76/5kzZzJ+/HgA2rZtS1BQEMePHyc6Opp169YRGxuLj4+PTvu7du1i1KhReHp60q1bNy5cuICRkfZ3DuPHj2f27NkEBwfTvHlzYmNjmTFjBrGxsezevVtr+lJly8ws2C3a3LzgLZ6QkMCECRPw8PDAy8uLgIAAzp07x5YtW9iyZQtz585lxIgRetv6/PPPmTt3LoGBgfTq1Uvrw/jIkSO5ffs2zZo1o0WLFty8eZOkpCQmTZpETEwMW7Zswdi4/PsS5OfnM3ToUJYuXYqNjQ1t2rTBwcGB/fv3M2XKFDZt2sTOnTuxtLQs9zkArly5woEDBzAyMmLgwIEVaqs4j/5OhBDPhpb1HPCr+xzJf+h+kWVnYUJIu3qEBrhrj+Dka+DErwX5MGd2GX5SMxtoORTajQLHhhXovRCVp0LBjKIojYBPgVeBwpGXq8AB4DpwC7AHHABvoOP9x78URfkJmKyq6smK9MFA8cBvwL77j3T0B14P+5CCQCYe6KaqahaAoihvA18B84DgqumuqCyhoaF88MEHLF68WCeY+emnn8jOzqZTp064u7uX2M60adOIjIwkJSWF8PBwvQsAFH7Ad3FxYe3atUXT1gCio6MJDw8nLCyMhIQEnbrz58/niy++YOLEicX2YdGiRcTHxxe1m5WVRZ8+fdi+fTuTJ08mKiqqxGsoL1VV2bBhAwAtWrQAwMvLi/j4ePz9/bXKHjp0iC5duvDWW2/x2muvYWOju6vzf//7X7Zv306nTp10jv3www9069ZNK5jIzMxk8ODBbNiwgSVLlvCPf/yj3Nfy1VdfsXTpUoKDg1m6dGlRIPpwov6UKVOYOnVquc8BkJKSAkCDBg2qJMhMTU0tyrEp/J0IIZ5cN2/fY+fxDPr4le3Lu7BAD95c9mD0vqGTNWGB9enbyhUrs4c+4t3J0qiQowAAIABJREFUguQfIWEm/HXG8I45eEC70dByCFg8uXmk4ulU7mlmiqJ8CxwBBgC7gZFAQ1VVa6mqGqSqah9VVUNVVe19/2cnoBHwOhAHvAYcURRlRsUvo2xUVf1CVdXJqqquV1X1Umnl70+NG3f/x4jCQOZ+W19TEBh1UhSltb76ovoYMmQIiqKwZs0asrO1l6wszKV5eIpZRUydOhWNRsP333+vFchAwYhD7969SUxM5NChQzp1mzdvzrvvvlti++PGjdNq18bGhhkzZqAoCtHR0eTm5lbKdRTSaDSkpaUxYsQI4uPjMTc3JywsDID69evrBDJQMB0tIiKCW7dusWPHDr3tjhw5Um8gA9CnTx+dURFbW1u++eYbANauXVvu68nLy+PLL7/E2tqaZcuWaY2omZmZMWPGDGrXrs3s2bPJz69YCty1a9eAgtwlfdavX8/w4cO1Hu+8806p7WZnZxMTE0Pfvn3RaDS88MILWqOEQogny5mr2Xy89jABn8fw5rJkjly4WaZ6LzV3wcXegmAvJxaOaMfWtzox1N/9QSBz8zxs+ahgKtmmdw0PZOp3hEFLYfxBCBgrgYyolioyMjMCmAV8qapqmSZa3p+OdRqIvp9vMhEIB8ZXoB9VKZCCkaVTqqrqfvKEVUAL4GUKRqNENVWvXj06duxIbGwsa9asKZpOdvnyZWJiYrCwsGDAgAEVPk9+fj4xMTFYWVnRvXt3vWWCgoJYt24dSUlJRTkohXr16lXqXjKDBunumtykSRN8fX1JTk7m0KFDBAQElP8i7tPXD1tbWxYuXEjDhg+mF2g0GmJiYti7dy8XL14symlJS0vT+u+jSltKOC0tjY0bN3Ly5Emys7PJz88v2uOmuDbL4uDBg1y9epUXX3wRZ2dnneOWlpa0bt2aX375hbS0NLy8vMp9rtKkpKSwcOFCrefc3d2L8mwetnDhQp2yAG3atGHRokVV1kchRNXZk3aVeXFn2H4sQ+v5+XHpTBvgW2p9U2MjtrzVEVsLU+0D5w9Awnfw/9m77/isy3v/46/rziQhYSTskMGWjcwwHChu1DpxS8WqtXqsrbY9trU9Pb/T021P3RVE3LhX3RZkhDBkyJKVAWHPDELm9fvjmxuy7/ubfCEkeT8fjzzg/l6TkeT+5Lquz7XuXbC1nxWtU2gkDL0Oxt4NXQa5ayvSBBoTzPQKZnWjLtbaHOA/jDG/b8QcTjb/V5Kat9JVfe7Z/g5jzLo6inoXFBTw1Vdf1ds+Ojqa6OhocnNzq5y1yC/Ir6fV6S8/L5/c8txG9XHNNdcwf/58Zs+ezdSpUwFnW1dZWRlTp07FGENu7okx/Cs4JSUlVZ7736wXFhZWeQ7OGYn8fOfvOlCa3B07dhxv7++zU6dONfr087+R79ChQ611EhISWLVqFVu2bGHQoEEB5xqI/64Tn89HTEwMAwcOZOrUqVXGz8nJ4frrr+fbb+u+SG3//v1VxvYnYejYsWOtc7LW8stf/pInnniizgs6jxw5EtS/VWFhIeD8Pfifr1+/HnBSTQcKHLOyso5nsyspKTk+lr+vv/71rzUCq759+/Lgg87t15GRkQDs3bv3eBv/ak9ubi73338/999/P+AE1v369cNaW+ufISUl5XiQGhoaSufOnUlNTWXy5Mn4fL5a/y7z8vLq/Hf3r+CVlpa6/r/R0pSXl1NWVkZBQUGjLkWVU8v/eR/o++Lp7H+WFrHlcM0V4He/2cHEtvuJjXBxUbIto9P+pfTMeZ/2uRtdz6UovCM7ul/Mzm4XUBIWC+v2OB/SKjTl51P1HTNuNTiYaUwgczL6OUkSK37dUUe5//nxgxYVyRD8e2eigAHGmGuAAmvtxydllhKUK664goceeoh58+axb98+OnXqdPxumdpWOxrC/0a1bdu2AVceaksA4H/zezp46qmnAta57777+Pbbb7n88st54IEH6NOnDzExMfh8Pp5//nkeeOCBOgOSug6sv/XWWzz++OMkJCTwP//zP4wZM4b4+HjCwsIoLi4OmBEsEP+/Ua9evWrdIldZx44d6y3/8ssvWbhwYZVnEydOPB7M+DOTZWZmkpub26hzM6mpqUH9m4CTVvzo0aPHA6Ha+DO2RUUpA5FIU7kgMZQth4trPC+1MG9HKZf3DqulVVUhpUfptvtLeu78iDbH3AcfR2L6sb3HZeyLT8X6dP2gND/6X1s//6nluvK0+kPJmErPBgFvVHp9dcVHFk4WtHpZa2td0zXGrIuOjh44efLkOtuWl5fz3XffARAbG1tlZSaqbRSfXP1JoOHrlJ/nrDa0jal5kPtU6BLVhdBGfpGNjY3l8ssvZ+7cuXz44YdceOGFrFq1ivj4eK666irCwqp+04iOjgac+zwqvwn1vwlv06ZNjTenUVFRREZG4vP5eOmllwL+5D+YPv38fR06dIiEhJp5/HNycgDo06fP8T6C6bcugeoXFBTw73//my5duvD222/XyC62a9eu43Oo3Je/XkxMTK1jfPrppwA8/fTTXHrppVXKNm50ftpojKnStq5/K/+5m8pz8KcyHjhw4PGU3MHw//+Ijo4+3teCBQvqbRMbG8vIkSNZsWIFn3zyCTNmzDi+ClL9z+4PLqr/2fx/hup/tvokJCSwadMm9u7dy5gxY2qt4///crKSEzQn5eXlhISEEBsby+jRo2tkEJTTk/8nyPV9XzzdnVVWznvZ88g5XPMHD4v2hvCH6WefSKVc3eFsSH8GvpkDRS5XV32hMPBKGHcP7RJGoZMw0pSfT/7v4Q3lWTBjjOkLpAILrLUZlZ6PAx4DBgPZwC+ttW97Ne7pxlo7D3CxLnxqhPpCG5zaGDi+xSu2bfN+03PzzTczd+5cXn75Zfbv3w/A9ddfXyOQqY9/+1hpac27b0JDQznnnHP45JNP+PLLLzn//PO9mXglc+fOZciQIVWebdy4kVWrVtG2bVuGDx/u+Zi1OXLkCOXl5XTr1q1GIFNSUsI777zToH4PHToEUGvANnfu3Ab1Wdno0aNp164d8+fP5+DBgwFXXxrrpz/9KTfccAO//vWvueKKK05JCuWzzjqLTZs28dFHH3HZZZfVKK+8ZXXSpEknfT4irY21NqgfZoWG+Lg1NYnff1x1W1h823BuGJNIaZkloq53aitegLTH3U0ssh2MnO6kVm7XbK7KE6mXlz9++glOmuIS/wNjTBfgU5y7Z9rgpGd+3Rhzpofjnkz+gyZ17cPwh5J5p2Au4oGLLrqI+Ph4li1bxtNPPw1w/Fb7YHXv3h3g+CpYdY888gg+n4/p06fXuv8+Pz+fWbNm1bsFqD7/+Mc/qmRCO3r0KPfddx/WWqZPn97ou1GC1blzZ9q1a8fatWtZtGjR8edlZWX87Gc/Y9OmTQ3q179y8uyzz1bZorZgwQL+9Kc/NW7SOKs0Dz/8MHl5eVx11VXHUxtXlpOT49mh+mnTpnHNNdewa9cuJk6cWOXvqrK0tDRPxgO49957CQkJYebMmXzwwQdVyo4dO8bdd9/N4cOHGTVqFBMmTPBsXJHWLvdYCc8t2MZ5f53P3rzgMktOG51ImzDnB0IDu8Xyp2uGsvBnk3lwSj+i64xkgDF3gi/IH8R17AWX/Bl+vB6m/FaBjLQoXm4zmwisstZWPl/yfZwtWH8F/hO4BHgLeBDwJg/uyeW/qr3mj4irPs86GYMbY9oD/mvRwxqbJlacrTrTpk3j8ccfZ//+/fTt25exY8e66uOCCy4gMjKSv/3tb6xdu5bu3btjjOGhhx6if//+TJw4kSeeeIIf/ehHnHvuuQwePJh+/foRFhZGZmYmq1atoqioiKuuuqpBgcfNN9/M2LFjmTx5Mu3atePrr79m9+7dDBo0iN/97neu+2uo0NBQHn74YR555BHOPvtsJk+eTMeOHUlPT2fPnj3ce++9PPHEE677vf/++5k9ezZPPvkk8+bNY+jQoeTk5LBw4UJ+8pOf1Jrpy62f//znbNy4kRdffJEzzjiDESNGkJKSQnFxMd999x3r169n6NChrgPdurz88svExsYya9YsLrnkEhITExkxYgRRUVHs2bOHTZs2sWPHDkJDQz05vzV8+HD+/ve/c//993P55ZczYsQIBgwYQGFhIYsXL2bv3r0kJCS42mYnInXLPnCU5xdn8MbyHeQXOav2Ly3J5sEp/QK2bRcVxq+nDqRXfDRjUjoGvT2ZmK4w5BpY/WrddZInQeq90PdC0PZJaaG8/J/djZpv6i8CioDfWGuLrbXvAumAu3ePTWd1xa91rST5n685SeM/AGRUfPT131khjVP5DWpD7pbp3r077733HuPGjWPhwoXMmjWLmTNnHj8jAnD33XezfPlybrvtNvLy8vjwww/59NNPyc/P56abbuLDDz+kXbuG7VL+v//7P37/+9+TlZXFe++9hzGGe++9lwULFjS4z4b6z//8T1544QWGDh3KokWL+OKLLxg2bBhLlixh1KhRDeqzX79+LF++nKlTp7J//37ef/998vPzeeaZZzxZmQEnQ9ucOXN47733mDJlChkZGbz11lssXLiQyMhIHnroIWbNmuXJWOBsTZw5cyZLly7l9ttvJyIigi+//JI333yTtWvX0rt3b37729+yefPmRl/U6XfvvfeyePFipk2bxr59+3jrrbf44osv6NatG4888girVq06vgomIu5Za1macZC7XlzOOX/+N88vyjweyAC8vCSLYyXBpUW+YUwiY3vFBR/I+I37Yc1nvjAYdgPc9TXc/iH0v1iBjLRopq5MQ647MqYA+Mhae13F6wjgELDUWntOpXovA1daaxt32scDxphjQIS1ttavHhWXZu7FuWtmhLV2VbXy1ThpmUdZaz2/Z6baysxnAwYM6Lthw4Y661dOANC/f39PD7HWdWhZRNzR59Lp52R+7ZSTp6kOLJeUlfPRml3MWpTBmh31X275x6uHct3onsF1bC1kL3Huhxk6Dc6oed6tVrMvg8wF0KYDjLoDRs+A2G7BtRWp0JQJAAYNGsT69evX15UEKxAvt5ntoOp9K+cDkUD1hNVtOJEF7LRmrS02xjwOPAI8YYy5wFpbAGCMeRDnzzv/ZAQyFeMfBg5XjFeib7AiIiJN4/DRYl5Zms2cxVnszg3uPMysRRlcOyqh/hWXshJY/55zmH9nxXnIgv3BBzNnPwyDr3ICoHClWpfWx8tg5ivgB8aYx4Avgd8DFnivWr0hwHYPxw2aMeZS4FeVHoVXPF9S6dnvrLUfVXr93ziB2XhgszFmAc69MmOBfTjngk7WfHVmRkREpAlt3ZfP84syeGtFDoVBbhur3HbL3nz6dompvcKmz+DDByA3p+rz7DTIWQE9RgYeJOUs50OklfIymPk9cB1wX8WHAV631vrPnWCMGQT0BlzmEvRMJ2o/rzO2Wp3jrLXHjDHnAr8AbgSuBA4Cs4FfVUt44LUHgEf9L3RmRkRE5OSz1rJ46wFmLszgq417XbfvGB3OzWMTuTk1ic4x9VyGHNOlZiDjl/YkXDPT9dgirY1nwYy1NtsYMwyYgRMQrMB5w1/ZCJyVmsZfFtEA1trZ1JxTMO0KgV9XfJxKj3Fivp/FxcX1PcXji4iItBpFpWW8t2onsxZmsHG3+1sX+nZuyx0TU7hyRA8iw+q47LKybsOcjGOZtVzAu/5dOPJbaFdXQlURAW9XZqhYpfhNPeUvAS95OWZLpjMzIiIiJ9/+/CJeXpLNi0sy2Z9f7Lr92f06ccfEFCb1jW9YRrLagpnyUvj2TZj4gOv5iLQmngYzIiIiIs3Fd7vzmLUwg3dW5VBc6u5cakSoj6vO7MH3J6TUPBOTvw9KC6F9YuCO+l3kXGp5sNIFvr3Pc+6H6X3qM0uJNDcNDmaMMY06bWat/box7UVERETcKi+3zN+8j1kLM1iweb/r9p1iIrh1XBI3jUuiY3R41cI962DJk7DmDRhwKVz7fOAOfT5ndebTR2DYNOf3nQe4npdIa9WYlZl5ONnKGiqIzaStm9tsZpWXtsvLy3VXgohIECp/bXW9RUiajcLiMt5euYNZCzPYus/9DREDu8Vyx8QULhvWjYjQSm9hysth82dOEJMx/8Tz9e/B4e3QPoh7ZobfBIO+B9Hxrucl0to1JpiZQ81gpiMwteL5aiCz4nkSMLzi9x/iZAOTwFxlMzPGEB4eTnFxMQUFBaf8NngRkeaooMB5YxseHq5gpgXafeQYLy7J5JX0bA4dLXHV1hg4b0AX7piYwrheHav+/yjKh9WvwpKn4ODWmo1tGSz7J0z5r8ADhUfpjhiRBmpwMGOtvb3ya2NMFyAd576Z+6y1G6qVDwD+gXPRZGpDx21lXGczi4mJ4cCBA+zZsweA6OhoT1Zo/D+51F03Io2jz6XTR3l5OQUFBce/XsbE1HEXiDQ71lq+yT7M7MWZfPztLkrL3W0kiQoP4dqRCdw+IYWU+OiqhYe3w9Jn4ZsX4NiR+jtaMRvO/hmER9dfT0QazMsEAP8LRACXW2uPVi+01m40xlwJbKmoe7uHY7dIDclmFhcXR0FBAceOHWPnzp2ezaWszLkoLCREuwNFGkOfS6enyMhI4uLimnoa0khFpWV8tGYXsxdnsmZHgECjFt3bRXLb+GSmjU6kXVRY1cLtS52tZOvfd1ZdgnHsCKx6Bcbc6XouIhIcL4OZi4D5tQUyftbaAmPMfOBCD8eVSkJCQkhMTOTAgQPk5eVRXOw+xWRt/NswYmNjPelPpLXS59LpJTw8nJiYGOLi4hRgNmN7c4/xUno2r6Rnsz+/yHX7YT3bM2NiChcN7kpYSKUfHJaVOGdfljwFOcvdTyw2QasyIieZl8FMu4oPr+pJA4WEhNC5c2c6d+6MtRZrG5OnwTFv3jwARo8e3ei+RFozfS6dPowxOiPTQjzx7y28kJblqo3PwEWDu3LHxBTOTOxQ9f/C0YPONrKl/4TcHPcTShgD4+6BMy6HEN2CIXIyefkZtgk41xgz1Fq7prYKxpihwGRgvYfjtlhus5nV0Yen36yVIU3EG/pcEvHOreOTgw5mYiJCuX50T24bn0zPjtUO3e/bBOlPOwf7S+rcaFI7EwKDrnRSKyeMctdWRBrMy2Dm/4DngHnGmMeA1wH/V5Yk4Dqc7FyhOIkAJDBX2cxERERao96d2nJ2v07M37SvzjpJcVHclprMtaMSiImsdB7GWtj2b0h7ErZ87n7wyPYw8nbnXEy7BPftRaRRPAtmrLWzjDH9gIdw3oA/Wks1A/zJWjvLq3FbONfZzERERFqj2yck1xrMTOobz/QJyZzTrzM+X6WdCiWFsGaucx5m34Ya7QKK6wvj7oZhN+hcjEgT8nQjp7X258aYd4AfAhOB7hVFu4AFwNPW2jQvx2zJGpLNTEREpLkrKSvn03W7mb0okx9P6ceEPoEvkzy7byd6xUezbX8BUeEhXH1mAreNT6JP52opt/N2O2dhls+CwgZce9frXEi9F3qfB/q+LNLkPD+VZq1Nx7lvRkRERCRoB/KLeG3Zdl5My2J37jEAnl+UGVQw4/MZ/uP8vuzLK+LaUT1p16ZaauWdq5zUymvfhnJ3l2cSGglDr4exd0OXge7aishJpRQbIiIi0uReTMvkdx9toLi0arKbLzfuIfvAURLjompvWMkVw3tUfVBeBhs/craSZS92P6m2XWHMDBg5HaIDB1QicuqdlGDGGBMKxOFcolkra232yRhbREREmp/endvWCGTAOZ8/Jy2TX17mYkWk8DCsfBHSn4UjDXi70W0YjLsXBn0PQsPdtxeRU8bTYMYYcz7wS2AcEFZPVev12C2RF6mZRUREmoPUXnH07xLDd3vyapS9vnw7P57Sj+iIAG8d9m9xUiuvegVKCtxNwPhgwKVOauXEVNAdRCLNgmcBhTHmMuAdIAQ4BGQANb8iiRtKzSwiIq2CMYbbJyTzi7e/rVGWd6yU+Zv2ccmQbrU3PpQF//opbP7M/cDhMXDmrTD2B9Ah2X17EWlSXq6OPAr4gB8Dj1tryzzsu7VSamYREWm2ysotX27YQ78uMSTHB05ffOXwHvzhk40cPuoc0I8I9XHl8B7cNj6Zgd1j627YpgNkuUyW2iHZOdA//CaIrKdvETmteRnMDALSrLV/97DPVk2pmUVEpDkqKCrljeXbmbUok+yDR7llXBK/u3JwwHZtwkOYNjqR91blcEtqEtNGJ9IxOogzK5GxMOJmSH8qcN2kiTDuHuh/MfhCgvjTiMjpzMtgJh/QoX4REZFWam/uMWYvzuTl9GyOFJ5If/zWNzv46YX9a6ZLrsWPJvfhJxf0IyzE5Q/wxv7AOS+DrVkWEg6Dr3Euuew2zF2/InJa8zKY+QIY5WF/IiIi0gxs3J3LcwsyeG9VDiVlNYOJo8VlvLF8OzMm9QrYV9vKh/zLSuDIDuiYEngSHXs5qy3f/evEs+hOMHoGjPo+tO0czB9FRJoZL4OZnwHLjDF/AB6x1pZ62LeIiIicRqy1LNyyn2e/3saCzfsD1n8hLZPpE1II8QWRJezoQVgxG5b+EyJi4N704LKLjbvHCWa6DnGykg2+GkLrvCVCRFoAL4OZ6cDHwE+Bq40x84AdQG35hK219nceji0iIiKnQHFpOe+v3slzC7axcXfwSUu3Hyzkq417mTKwS92V9m50zr2sfh1KC51necDWr6DPeYEHSZ4Ed3wBCaOUWlmklfAymPkNzkZVA/Sq+KiLBRTMiIiINBNHjpbw8tIsZi/KZG9ekau2YSGGy4Z2J7FjVN2V8vfCU+OhtmSoS54KLpgxBnqOdjU3EWnevF6ZEQ/p0kwREWlq2w8eZebCDOYu387RYne3LsRGhnLTuCRuS02ma7vI+iu37QwDLoENH9Qs2/I57N8M8bqhQESq8iyYsda+4FVfcpwuzRQRkSaxMvsQ/1ywjU/W7qa8lgRh9Uno0IY7JqZw3aieREe4eKsx7oe1BzPgZCq79C/uJiIiLZ6XKzPiPV2aKSIip0xZueXz9Xt4bsE2lmcdct1+WM/2/GBSLy4c1IVQt6mVARJToetQ2L2m6vOQCPDpLYuI1HRSvjIYY1KBSUCPikc5wAJrrcvreVs3XZopIiKnQmFxGW+u2M7MhRlkHjjqqq0xMOWMLtx5Vi9GJXXAVD54X1oM696BXavgot8H19m4H8K7dzuv23aFMTNg5HSIjnc1LxFpHTwNZowx/YAXOXHfjP8rmq0oXw7cbK3d7OW4IiIi4t6+vCLmpGXy0pIsDh0tCVi/ssgwH9eMTOCOib1IiY+uWliwH5Y/D8v+Cfl7nGdn3gqdzwjc8eCrYN3bMOQ6GHgFhIa7mpeItC6eBTPGmG7AfKALsBN4A8jECWSSgWuB0cA8Y8woa+0ur8YWERGR4G3ek8dzCzJ4Z2UOxWXuksvEtw3n1tRkbh6XRMfoaoHGnnVO5rE1c6GsWsaz9Kdh6t8DDxAaATe94WpOItJ6ebky80ucQOZvwC+stcWVC40xPwN+DzwI/Cdwn4dji4iISD2stSzeeoB/LtjGvO/2uW7fp3Nb7pyUwhXDexAZFnKioLwcNn8GS56EjPl1d7D6NTjvUYjq2IDZi4jUzstg5hLgO2vtT2ortNaWGGMeAi4FLkPBjIiIyElXUlbOh2t28s+vM1i/K9d1+/G947hzUi/O7tcJn6/SeZiifFj1inPJ5cFtgTsqPQYrZsOkB13PQUSkLl4GM92At+qrYK21xphvgKs9HFdERESqyT1Wwqvp2cxenMmuI8dctQ31GS4b2o0Zk3oxuEe7qoWHsmDps/DNi1B0xN2klj0HE/4DfCGB64qIBMHLYCYX6BlEvZ4VdUVERMRje3OP8eS8rbyxfDsFLi+5jIkI5Yaxidw+Ppnu7ducKLAWspc4W8k2fgjW5SXOYVEwbBqMvUeBjIh4ystgJg24zBhzqbX2o9oqGGMuASYAddyIJSIiIo1hgZeWZFHq4qbLHu3bMH1CMteP7klMZNiJAn9q5SVPOumV3YrtAWN+4GQy01kZETkJvAxm/hfn3Mw7xpjXgVdwspkBJAE3ANOA8oq6IiIi4rEusZFcMqQb76/eGbDukB7tuPOsXlwyuGvVSy4L9sOK52Hpc5C/2/0kEsbAuHvgjKkQEha4vohIA3kWzFhr04wx04FngJuAG6tVMUAhcJe1dolX47Zkxpj2QPuKl2Hl5S6X9UVEpFWaPiG53mDm/DM6M2NSL8amdKx6yeWe9c6B/jVznQP7bvhCYeCVThCTMCpwfRERD3h6aaa19iVjzDzgTmAi0L2iaCewAJhprd3u5Zgt3APAo/4XBw4caMKpiIhIU7LWcqSwhPZRgS+RHJHYgeE927Nq++Hjz8JDfVx9ZgJ3TEyhT+e2JyqXl8OWz52tZNvmuZ9Ymw4wcjqMngHterhvLyLSCJ4GMwDW2h1UegMujfIYMLvi95/FxcX1bcK5iIhIEzhWUsa7K3OYvTiT2Mgw5t6dGlS76ROS+Y/XVhEXHc7N45K4JTWJ+LYRJyoU5cPqV51LLg9udT+x+P7OKszQ6yE8yn17EREPeB7MiHestYeBwwDGmBKfzxeghYiItBQ7Dxfy4pIsXl2azeGjJcefr805UjNdci0uHtyNsusslwzpVvWSy8PZTmrlFXPcp1YG6DPFCWJ6T4bKW9RERJqAZ8GMMWYy8CPgb9baBXXUOQtn69Rj1tqvvRpbRESkJdlx6Chn/2keZbVkJJu9OJM/XzssYB/hoT6uOjPBeWEtbE93tpJt+MB9auXQNjD8Rhh7N3Tq566tiMhJ5OXKzF3AFOC2euqsAi4AjgEKZkRERGqR0CGKkYkdWJp5sEbZ+6t28vOLB1TdMlaX0mJY/64TxOxc6X4isT1gzJ1w5m1KrSwipyUvg5kxwEprbV5dFay1ucaYb4CxHo4rIiLS4kyfkFxrMFNcVs6r6dncd149xygLDsAmM6fKAAAgAElEQVSKWY1IrTy6IrXy5UqtLCKnNS+Dma7A4iDqbQeUs1FERKQeUwZ2oUf7NuQcLqzy3BjYeaSetMnlZfDMWZC7w92AJgQGXQlj74GeoxswYxGRU8/LYKYA6BJEvc4428xERERajZKycj5eu5vM/QXcX9+qSoXQEB+3pCbxvx9vBCAmIpTrRvfk1tQkkuKi627oC4HhN8DXfwpuYpHtYdR0GH2nUiuLSLPjZTCzEphojEm01mbXVsEYkwhMAtI8HFdEROS0dSC/iFeXZvPikiz25BYR6jNcN6onXdtFBmw7bXRPPli9k+tH9+SqMxNoGxHkt+3Rd8Kiv0NZcd114vtVSq1cT3AkInIa8zKYmQWcB3xojPm+tXZ55UJjzChgJhBWUVdERKTFWrfzCM8vyuT91TspLj2RPay03PJyehY/uaB/wD7aR4Xz0f2T3A8e0wUGXwOrX6lZ1ud8J4jpNRmU8l9EmjnPghlr7avGmO8B1wDpxpjVgP8Wrt7AMMAA71hrX/RqXBERkdNFSVk5n6/fw+xFmbUe3vd7JT2be8/tU/X+l0D2bXKCk8m/craSBZL6wxPBTGgbZ+vZ2LuhU+AgSkSkufD60sxpwH8CDwLDKz78DgN/A/7H4zFFRESa1N68Y7y2dDsvpztbyQI5UFDMB6t3cu2onvVXtBYyvoa0J2Dzp86z7mfCwMsDT6rrEGcLWaf+MHK6UiuLSIvkaTBjrS0H/tsY8wecjGX+r9LbgRXW2no274qIiDQf1lq+yT7EC4uz+HjtLkrKal5wWZ/ZizO5ZmQCxpjaK6x5wzn3sufbqs/TnggumAG46llXcxIRaW68XpkBwFpbgnPIXwf9RUSkRSksLuP91TnMScti3c5c1+0jw3x8b0QPbh+fUncgA7Dli5qBDMD2JbBjBSSMdD22iEhLc1KCGWNMR2AkEA9kWWuDuX9GRETktJV94CgvpWfx+rLtHCkscd2+e7tIbh2fzPWjetIhOjxwg9QfwprXai9b8gRco1w6IiKeBjPGmE7A33GSAPhPJ75AxWWaxpgZwB+By621C70cuyUyxrQH2le8DCsvL6+vuoiIeKy83PL15n3MScvi39/txbrbSQbAmOSO3D4hmQsGdiE0xEX2sG7DIHkSZC6oWbbuXTj/t9A+wJkbEZEWzrNgpmI1ZjFO5rJVwCLg3mrV3gaewgl2FMwE9gDwqP/FgQMHmnAqIiKtx5HCEt5Yvp2XlmSReeCo6/YRoT6uHN6DW1KTGNyjXdXCshIICQuuo9Qf1Qxmug51nrcN5p5qEZGWzcuVmUdwApn/stb+BsAYUyWYsdYeNMasAc72cNyW7DFgdsXvP4uLiwt8ZbSIiDTYhl25zEnL4t2VORSWlLlu37NjG24dl8y1oxJoH1VtK9nRg7B8Jix9Dm54BXoEceal7wUQ1wcObIX+F0PqvZA0Aeo7ayMi0op4GcxcCWzyBzL12Aqc4+G4LZa19jBOSmuMMSU+XW4mIuK5krJyPl23mzmLs+q9G6Y+Z/frxG3jkzi7X2dCfNUCjf2bYcmTsOpVKC10nqU9CdfMDNyxzwdT/89ZhYnv06C5iYi0ZF4GMz2A94KoZ4FYD8cVERFxbW/uMV6tuBtmb17gu2Gqi4kM5bpRPbl5XBIp8dFVC611toelPQGbPqnZeN07MOW30C4h8EDJE1zPTUSktfAymMkFugVRrzewz8NxRUREgmKtZUXWIV5Iy+Ljb3dRWu7+RP+ArjHcmprMlSO6ExVe7dtoyTFY97azErO7lrTKxydSBunPwAW/cz2+iIic4GUwswyYbIxJsdZm1FbBGDMMGA686eG4IiIi9SosLuO9VTm8kJbFhl3u74YJ9RkuHNyV21KTGZ3coeb9MLk7YdlMWDEbju4PrtMVL8DZP4OItq7nIyIiDi+DmX8AFwPvGGNusNZuqFxojOkDvAgY4HEPxxUREanV4aPFPPHvLby+bDu5x0pdt+8UE8GNYxK5cWwiXWIjqxZaC9uXQvrTsOF9KHfZf1kx7PwGUs5yPS8REXF4FsxYaz8xxvwReBhYa4zZjHM+5kJjzGpgIM7dM/9Pd8yIiMipEBbi47Wl28krchdojE7uwC2pyVw0qCvhodWSr5QWwdq3nSBm1yr3k2rbFcb+AEZOh6iO7tuLiMhxnl6aaa39uTFmBU6a5qEVj7tVfGwEfmetfdXLMUVEROoSHRHK1SMTmL04M2DdyLATd8MM6t6uZoXcXbB8Fqx4HgoacPSz6xDnfphBV0FoeOD6IiISkKfBDIC19g3gDWNMJyAZ8AE7rLU5Xo8lIiISyC2pSfUGM4kdo7g1NYlrR/akXVS1yyythR3LnVWY9e+630oG0O9iSP0hJE/S/TAiIh7zPJjxs9buQ1nLRETkJMkvKqVtROBvY707tWVS33gWbK56MP+c/p24LTWZs/t1wlf9bpjSIlj3rhPE7PzG/eTC28Lwm2DMD3Q/jIjISXTSghk/Y0woMAMYDGwHnrXWHjrZ44qISMtTXm75cuNe/rlgG0UlZbx774SamcVqcWtqMgs27ye20t0wydXvhgHI2w3Ln3e2kxXsdT/Bjr1gzF0w/EaI1JVqIiInm2fBjDHm18CjwLnW2q8rnvmA+cA4nCxmFrjTGDOq4nZ7ERGRgAqLy3jzmx3MWphBxv6C48+XZR5iTErgQ/STB3TmL9cO45Ih3WgTHlKzwo7lzr0v696B8hL3E+x9Hoy9G/qcDz5f4PoiIuIJL1dmpuCcjfm60rNrgFRgDfAETurmK4F7gf/n4dgiItJCHT5azOS/zOdgQXGNsn8u2BZUMBPiM1w9MqHqw9Ji5xxM+tOQs8L9xMKinRWYMT+ATv3ctxcRkUbzMpjpBVS/7vgqnNWYG6y1G4wxzwGZOEGOghkREQmofVQ4g3u04+tNNY9hfrFhDxn7C0ipbctYXfL2OBnJls+C/D3uJ9Qh2dlKNuImiKwl65mIiJwyXgYzcUD1a4/PBjb7L9C01lpjzDLgXA/HFRGRFu7OSSm1BjPWwqyFGfzuysGBO8lZ4WwlW/t2w7aS9TrX2UrWdwr4atmqJiIip5yXwcx+oIf/hTFmINAFeK9avWJACfZFRCRoE/vEM6BrDBt359Uoyz54FGtt3YkANn8O8/8AO5a5HzgsCobd4Gwl6zzAfXsRETmpvAxmNgBnG2NGWGtXAg/ibDH7V7V6ycAuD8cVEZFm6PDRYtK2HuDiId0C1jXGMGNSL376xmrAOQNzyZBuzJiYwrCe7etvfDDDfSDTPskJYEbcDG0C9C8iIk3Gy2Dmb8B5wDJjzGGgA5ABfOKvYIxpB4wE3vdw3NOKMWY48A9gFLAb+Iu19vGmnZWIyOkjc38BsxZl8MbyHRSVljH/oXPp2TEqYLvLh3XnyXlbOG9AZ26fkEKP9m2CG3D4DfDlf0FxzVWdGlLOdraS9btQW8lERJoBz4IZa+2/jDH3AQ8D8cAi4F5rbeX0M7cCYcCXXo17OjHGdAI+B5YClwFnAo8ZY45Ya19s0smJiDQhay3Lsw7x3IJtfLZ+D9aeKJu5MIPfXD4oYB/hoT6++PHZNS+4DCQixllhSX+q9vLQNjBsGoy9Czqf4a5vERFpUp5emmmtfQInBXNdngPmAPlejnsauRtna9211tqjwJfGmBTgV4CCGRFpdUrLyvlk3W7+uSCD1dtrv15s7vLt/Pj8frSLCgvYX5VApvAwhEZAWBArNGPurBnMtE+stJWsQ+A+RETktONpMBOItbYQKDyVY55iFwL/qghk/N4A7jHG9LLWbmuieYmInFL5RaW8tjSb5xdlknO4/i/7R4vLeGVpNvec0zu4zvdvdu6GWfUqXPjfMOr7gdvE9Ya+F8DmzyDlrIqtZBdpK5mISDN3SoOZpmSMGYlzseeYio8eANbaevcrGGPaAL8ApgGJwEGcc0C/stbmVKveD/iw2rONFb/2BxTMiEiLtvNwIbMXZ/JqejZ5RaVBt5u9OIM7JqYQHuqrvYK1sPUrWPIUbPn8xPMlT8PI6VBXJrPKznsUzv8NdAm8pU1ERJqHBgczxpglwKPW2k8b0cclFX2MbWgfLvwKuMJNA2NMJPAVMA4nA9t7ONnYpgOXGWPGVVtt6QBU30dxqFKZiEiLtHr7YWYtyuCjNbsoLbeBG1QS3zaCW8YlUVZfu4V/dQ7xV7f/OyfI6XNe4IG6BnEXjYiINCuNWZnpAPzLGLMGeAF43VobMOWyMaY7cANwCzAU+K4Rc3AjDVgDLKv4yAQiArT5JU4gkwZcYK3NBzDGPAj8BZgFnHNypisicnorLi3n47W7mL04k5XZtZ+HqU//LjHcMSmFK4Z3JyI0wHavwdfAV/8NtrxmWfrTwQUzIiLS4jQmmBmIc+D9V8BfgT8bY7bgBArf4axI5AExQEecbVajgT6AAfYA9wLPNmIOQbPW/qHy6zovVztRHg78qOLlvf5ApqKvvxpjbsO5V2ektXZFRdEhoF21rtpXKhMRafb25xfxano2Ly7JYm9ekev2k/rGc+ekXkzqGx/wa/FxHZJgwKWw4YOaZZs/c87RxPd1PRcREWneGhzMWGvLgCeMMf8ErgVmABNxzo2Ak9XLz//dqgyYD/wTeKta2ubTzQScwGRrxSWg1b2Js7I0FfAHM5uA6ldE+1+fqhUoEZGTYm3OEWYvzuT91TspLq1lhaQeYSGGK4b3YMakFAZ0jW3YBMbeU3swE93ZuRhTwYyISKvT6AQAFQHJy8DLxpgYYDzOm/zOOMHAEWAvsBpYXHmF4zQ3rOLXb+oo9z8fWunZp8CPjDFtKjK3AVwDbA42k5kxZl0dRb0LCgr46quvgunGcwUFBQBNNr5IS9HcPpfKyi0r95bzeXYpmw+7C2AAosPg3IRQJieG0j7iADvXH2DneqcsrPgI3Xd/xpHYARxuPyRwZ9Yyum0vYvKdL6d5bXuxvcdU9nSagN0RCjuax9+peKO5fS6JnM6a8vPJP3ZDeX3PTB7OG/oGJwU4jSRW/LqjjnL/86RKz54G7gfmGmMeA0YAdwFB5A0VETl95Bdb5ueU8u/tZRw85u5AP0DnKMMFiaFM6B5CRGjVrWTRBVn0zPmQLnvmE2JLONBheHDBjDFk95hKpwNL2d7jMo7EnhFcFjMREWmxWk1q5gZoW/Hr0TrK/WFkjP+BtXafMWYK8DjwEc65oAettUFfmGmtrTVnqDFmXXR09MDJkycH25Wn/JF6U40v0lKc7p9LG3fnMntRJu+szKHI5VYygAl94rgtNZnzzuhCSOULLsvLYfOnsORJyPi6Spu4Q6uYPLgbdD4jiBGcv7fOrmcmLc3p/rkk0pw05edTdHR0o9ormPGYtXYVztkhEZFmoazc8sWGPcxelEnatgOu20eG+fjeiARuH59M/64xVQuL8mDly07GsUMZdXeS/jRM/bvrsUVEpHVTMFM3/9meqDrK/WFk3imYi4iI544cLWHu8u28kJbJjkOFAetX171dJLeOT+b6UT3pEB1etfBgBix9Fla+BEW5gTtb/bpzqWVUR9fzEBGR1kvBTN2yK35NqKPc/zzrZE3AGNOeE6mdw8rL3W/5EBGpbsvePGYvzuStFTkUlpS5bj8mpSPTxyczZWAXQkN8JwqshcyFsOQp+O5fVE1qGUBpIayYDZMedD0fERFpvRTM1G11xa9n1lHuf77mJM7hAeBR/4sDB9xv/xARqeyB11by7qqdrtuFh/q4Ylh3bhufzOAe1a7TKimEb9+E9Gdgz7fuJxXbA8bcCWfe5r6tiIi0agpm6rYIJ610b2PM8IqzMJVdU/FrLZceeOYxYHbF7z+Li4vTJQoi0iiJHevaOVu7LrER3JqazLTRPYlrG1G18MgOWDbTWVEpPOh+MgljYNw9cMZUCAlz315ERFo9BTN1sNYWG2MeBx7BuRz0AmttAYAx5kGc+2XmW2tX1NdPI+dwGDhcMWaJz+cL0EJEpH43jUviyXlbKS2vfwvYyKQO3D4+mYsGdyWs+lay7CXOgf0NH4B1uU3NFwqDvudcgJkwsgF/AhERkRNaTTBjjLkU+FWlR+EVz5dUevY7a+1HlV7/N3A+zkWgm40xC3DulRkL7OMk3x+jMzMi4rUusZFcMqQb76+uudUsLMQwdaizlWxYz/ZVC0uOwbq3nSBm1+oabQNq0xFGfR9G3wGx3Rs4exERkao8D2aMMQOBO4ExQDzwnrX24Yqy8cAo4CVrbQP2JDRKJ5wgpLqx1eocZ609Zow5F/gFcCNwJXAQZ+vXr6y1dV2o6RWdmRGRgAqKSvlg9U6uGZlQ9UB+HaZPSK4SzMS3jeDmcYncODaRzjGRVSvn7oTls2D583B0v/vJdR7obCUbci2EtXHfXkREpB6eBjMV26/+t1K/FiegqexvQBHwjJdjB2Ktnc2J8ydu2hUCv674ONV0ZkZE6rTzcCEvLM7k1aXZ5B4rJbZNGJcM6Raw3YjEDs7Ki7VMn5DCJUO6ER5abSvZjmXOKsz696C81OXMDPS7yAliUs4CYwI3ERERaQDPgpmKbVx/BjKAnwALgb2V61hrFxtj9gFXcIqDmeZIZ2ZEpDartx/muYUZ/OvbXZRVOvsye1FmUMEMwJzvjyE2MhRTOdAoLYJ17zhBzM6V7icWEQsjbobRMyCut/v2IiIiLnm5MvMgUABMsdZuA6p+kzxhFdDfw3FFRFqVmQsz+KCWMy9LMw+yNudIzdTJtWjXplL2sLzdFVvJZkHBPvcTiusDY+6C4TdARIz79iIiIg3kZTAzEljiD2TqsR+Y5OG4IiKtyoxJKbUe4AeYvTiTP187LLiOdqxwVmHWvQPlJe4n0mcKjL0bek8GrRyLiEgT8DKYCQfygqjXGXC7AbtVUjYzEanN0IT2jE7uwLLMQzXK3l+1k59fPID46nfC+JUWO+dg0p+GnOXuBw9vC8NvgjE/gPg+7tuLiIh4yMtgJgOo98eBxphwnPtZNnk4bkumbGYiUqs7JqbUCGbatQnjhjGJ+Oo7cL/hfXh7hvsBO/aq2Ep2I0TGum8vIiJyEngZzLwPPGyMedBa+9c66jyMk/747x6O25Ipm5lIK1BSVs7Ha3czc2EG/+/KwUGdeZkysCs9O7Zh+8FCUuKj+f6EZK4emUBUeIAv62dMhejOULC3/np+vSc7F1z2OV9byURE5LTjZTDzR+Am4E/GmLHAOxXPuxhjvgd8r6I8A3jcw3FbLGUzE2nZjhSW8NrSbGYvzmTXkWMAzFqYwV+vHx6wbYjP8MtLBxLqM5zbvzM+X5Dpj0MjnMsr5/9v3XXCop3D/GN+AJ2Ur0VERE5fngUz1tpDxpjzgTeBa4FrKoouqvgwwHrgSmttMGdrRERapD1Hy3n0vbW8sWIHR4vLqpR9sGYnP7t4AF1iI+tofcKFg7o2bAKjpsOCv9Q89N8h2Qlght8EbdrX2lREROR04umlmdbaTcaY4cBU4AIgGfABO4DPgbestWV19yAi0jJZa0nPOMg/Vhaxal85lqxa65WUWeakZfLQhQOC73zXakh/BjqfAePvC1w/pisM+h58O9d53escJytZ3wvAFxL8uCIiIk3M02AGwFpbDrxX8SGNoGxmIs1fcWk5H327k5kLM1ibkxtUm5fTs/nRuX1pE15PYFFWChs/cIKY7DTnWUx3JygJCau7nd+4uyE8Gsbe5QRBIiIizZDnwYx4StnMRJqpw0eLeTk9mzlpmezJLXLZtoSFW/YzZWCX2itsXwpv3A65OVWf5+2EDR/A4KsCD9JjpPMhIiLSjHkezBhjooBRQDegjosOwFo7x+uxWyBlMxNpZrbuy2fWwgze+mYHx0rcraaGh/r43vAefH9iCv27xtRdsWNvOFrHDzfSnwkumBEREWkBPAtmjDEG+C+c1YSo+qoCFlAwE4CymYk0D9ZaFm89wMyFGXy1MciUx5XEtw3nlnHJ3DQuse7LLiuLjoMh18LKF2uWbV8CO1dC9xGu5yEiItLceLky82vgEaAYeBfYBuR72L+IyGnlWEkZH6x2zsNs3O0+SWP/LjHcMSmFy4d1JzLM5cH7sXfXHswArH5dwYyIiLQKXgYzdwC5QKq1doOH/YqInFZ2HDrKS0uyeX1ZNoeOlgRuUM3QeB8PXzGaCX3icBa1K+zdCEW50HNM4E66DobkSZC54MSzpIkw9gfQ/1LXcxIREWmOvAxm4oHPFciISEtkrWXhlv3MScviyw17KLfu2keE+rh6ZAIDQ/bQva2PiX3jnYLyMtj8GaQ/DdvmQbfh8IN5YIK4BHPsXbBjmbPlbOxd0HWIyz+ViIhI8+ZlMLMZ504Z8YhSM4s0vbxjJby1YgdzlmSxbV+B6/adYyK4NTWJG8cm0TE6nK++2ucUHDsCK1+Cpc/CocwTDXatcrKVJY4N3Hn/S+DH650zNCIiIq2Ql8HMU8CfjTHJ1tpMD/ttzZSaWaSJbNqTx5y0TN75JoeCYvd3/Q7sFsuMSSlcNrQ74aEnfs4TdXQHCTv/BWlfQ0kdwVH6U8EFM74QBTIiItKqeRbMWGufNsacASwwxvwKZ8tZTqB2Ui+lZhY5hUrLyvl8/R7mpGWRts39Dw+MgfMGdOGOiSmM69XxxHmY8nLY8gWkP824rV8G7mj9+3AkB9r1cD0HERGR1sTre2aeAc4DZgJVD7ZWZa21urAzAKVmFjk19ucX8drSbF5Oz2bXkWOu27eNCOXqM3tw+4QUUuKjTxQcy4XVrzp3vxzcGnyHtgyWz4Tzfu16LiIiIq2Jl/fMpAKfAdE498gcRKmZReQ0tjbnCM8t2Ma/vt1NcZn7M2l9O7fl1vHJfG9ED9pGVPpyemCrcxZm5ctQ7D5lMz1GQfcz3bcTERFpZbxcHfkjTiDzW+Bv1tpcD/sWEfHciqxDvLtqp6s2IT7DBQO7cEtqEqm9KqVWtha2fuWswmz+DOdnOi74wmDQ95ysZAmj3LUVERFppbwMZkYAS6y1v/WwTxGRk+aqM3vwx082BnXAPy46nBvGJHLj2ES6t29zoqAo39lKtvRZ2L/J/SSiO8Go7zsfMV3dtxcREWnFvAxm8oBMD/sTETmpYiLDuHpkAnPSsuqsMyKxPbelJnPxkK5EhIacKNj3HSybCatfg6Ij7gfvNhzG3eOsxoRGNGD2IiIi4mUw8y/gXGNMiLXWfR5TERGP5B4rIczno014SMC6t4xLqhHMhIf6uGJYd25NTWZIQrsTBWUlsPFDJ4jJXOB+YiaEPfGpbO9+KaOuvCe4izFFRESkTl4GMz8H0oCZxpj/sNY24EeVUpkuzRRxx383zNvf5PCLiwdwS2pywDZ9u8Qwvncci7ceoEf7NtySmsR1o3rSMTr8RKUjObBiNnwzB/J3u59Ym44wajqMuoN1K75znimQERERaTQvg5k/AN8CtwBXGGOWAzlAbe/ArbX2Dg/Hbql0aaZIAP67YV5Iy2TJtoPHn7+QlsXN45LqSxF/3I+n9GP6hBImD+hMiK/S3TAZ85xVmO8+dtIlu9VlCIy7GwZfDWH+czbfue9HREREauVlMHN7pd+3w7lvpi4WUDATmC7NFAngyXlb+evnNQ/eb9mbT9rWA4zvEx+wj9HJHU+8OHoQVr3i3PNycJv7CRkfDLgMxt4NSeO1AiMiInISeRnMnOthX4IuzRQJxlVn9uCxLzZRXksm5BfSMoMKZgDIWeGswqx9C0rdX5xJmw5w5q0wega0T3TfXkRERFzzLJix1s73qi8RkWAldIji/DO68Nn6PTXKPl+/h5zDhfSonEq5suKjTvCy7DnYtaphE+gxCkbf4WQlC6tjHBERETkpvFyZERFpEreNT641mOkYHc62ffl1BzM5K+D9H7kfMLQNDL0WRt0B3Ye7by8iIiKeUDAjIqcV/4H+F5dkcWtqEhcN7hawzfjecfTuFM3WfQUAnJnYntvGJ3PR4Gp3w1SXPBHi+8P+IA/lx/V1tpENmwZt2geuLyIiIidVg4MZY8w2nIP851trMypeB8taa3s3dGwRaXn25h7j1aXbeXVpNrtzT5xZCSaYMcZw56RefJN9iFtTkxnco13ANhUNnS1iHz9cdx1fKAy41AlikifpQL+IiMhppDErM8kVv4ZVey0iEhRrLUszDjJnSRafrt1NabVT/Iu3HmDL3jz6dI4J2Ne0MYlMG5Po7xhKjkJ4dOBJDJsGX/zGqV9ZTHcYebtzqD82cEAlIiIip16Dgxlrra++1yIidckvKuWdlTm8lJbFd3vy6q370pJsfnP5oOA6LjwEq1510ir3Ogcu/UvgNpHtYMi18M0Lzute5zqrNf0uhhDtxBURETmd6Tu1iJwym/fk8eKSLN7+Jof8otKg2ry1YgcPXdif6Ih6vlztXOlkJPv2LSgtdJ7l7YbzfwMRgVd1GHMnhLeFUd+H+D5BzUtERESanmfBjDHm18Aqa+37AepNBUZYa//Lq7FF5PRVUnGgf05aJku2HXTdPq+olH9/t5fLhnavvcKmT+GV62o+L86HNXOdVZZAug6Bi4a4npuIiIg0LS9XZn6Dc1t9vcEMcDnwfUDBTADGmPaAP2VSWHl5eVNOR8SVvbnHeGVpNq8uzWZPbpHr9hGhPi4f1p1bUpMYmlBP5rBe50BUPBzdX7Ns2UxntUWH9kVERFqkpthmFgLoXXlwHgAe9b84cOBAE05FJDBrLekZB3kxLYtP19U80B+MpLgobh6bxDUjE+gQHR64QWgEnHkLLPxbzbK96yB7CSSlup6HiIiInP6aIpgZBBxqgnGbo8dwVrsAPouLi+vbhHMRqVN+USnvfLODF5dksWlPvuv2xsDk/p25JTWJs/p2wudzuZIycjosfAwnW3zljkOc8zQKZkRERFqkRgUzxphZ1R5NrOVZ5bH6A6OAdxszbmthrT0MHAYwxpT4fEoYJ6eXTXvyeDEti9konPUAACAASURBVLe/2UFBcZnr9h2iwrh+dCI3jU2kZ8eoEwVHdjhbxDokw8jbgugoCfpeAJs/dV637eqkVR55G8TWcdZGREREmr3GrszcXun3FuhT8VGfNcBDjRxXRJpIcWk5n63fzYtpWaRnuD/QDzC8Z3tuTU3ikiHdiAwLcR5aC9lpkP40bPgQbJkTzIy4GXwhgTsdPcPJZDZ6BvS/BELCArcRERGRZq2xwcy5Fb8a4CvgE+APddQtBnZaa7MaOaaINIHtB4/y6tJs5i7fzv78YtftI0J9XDG8O7eMS2ZIQrsTBSWF8O2bsPQZ2P1t1UaHMmHzZ9D/4sAD9LvA+RAREZFWo1HBjLV2vv/3xpgXgAWVn4lI81ZaVs5XG/fycno2X2/eh3V/np/kuChuHucc6G8fVelAv38r2YrZUFjPCk/6M8EFMyIiItLqeJYAwFo73au+RKRp7TpSyGtLt/P6su3szj3mur0xcN6AztySmsykPvEnDvQf30r2DGz4wNlKFsi2f8PejdB5gOt5iIiISMvWFNnMROQ0VFZu+XrzPl5Jz+bLDXtoQFZlOkaHc/3ontw4ptqB/pJjsPZN5zxM9a1kwVg+Cy75o/t2IiIi0qIpmBERAH76xmreWZnToLZnJrbnlooD/RGhlQ7r+7eSffMCHG3APUlxfWHsXTBsWoPmJSIiIi2bghkRAWDKwC6ugpmo8BCuGN6dm8YmMbhHpQP91joXVaY/HfxWsiqMk2Z57F3Q61xQSnIRERGpg4IZEQGcYKZTTAT78orqrTegaww3jUviyuHdiYmslP64sVvJImKdNMyjZ0Bcb/ftRUREpNVRMCMiAISF+Lh+VE8e//eWGmURoT4uG9qdm8YlMqJne4wxJwq93EoWEdOIP4GIiIi0NgpmRFqoI4UlvLsyh1eXZjPr9tF0b98mYJtpY3ryxLwtx1Mw9+4UzU1jk7jqzB5V0yo3eisZ0PdCbSUTERGRRlEwI9KCWGtZs+MIL6dn8f7qnRwrKQfgtWXbeXBKv4DtEzpEMeWMLkSEhXDT2ETGpnSsugpzLBe+nQvLZ8OeBm4lG34TjLlTW8lERESk0TwPZowxKcAkoBsQUUc1a639nddji7R297+2ig9W76zx/LWl2dw3uQ9hIYFXQJ65ZWTVAAZg50pY/jx8+yaUFLifmLaSiYiIyEngWTBjjAkHngNu8j+qp7oFFMwEYIxpD7SveBlWXl7elNORZuDMxPa1BjN784r4csNeLhrcNWAfxwOZonxY+5Zzx8uuVQ2b0PGsZJO1lUxEREQ85+XKzH8BNwOHgZeATUCeh/23Rg8Aj/pfHDjQgMPV0qpcNSKB//14I0WlNQPfV5ZmBxXMsPtbZxVmzVwobsCncHiMk5VMW8lERETkJPMymLkRJ5AZYa3N8rDf1uwxYHbF7z+Li4vr24RzkWagXVQYU4d1580VO2qULdqyn315RXSKqWP35/Zl8OkvYMeyhg0e1wfG3AXDb9BWMhERETklvAxmOgOfKpDxjrX2ME6AiDGmxKdtOq2OtZa0rQf+f3t3HmdXWR9+/POdNclkgyGShCUJi8gmYBTCVhYV64JAFcUV3K1Li7b9VatUa21rq7ZYRbQqgkvdkKKIAmoAQVbZQUW2hCUJS0K2yTbL8/vjnJvcTO6dJTkz996Zz/v1Oq9zz3Oec57n3tzzyv3Os3HxbY/zr39xMBNamwe95k1H7LlVMDNjSjtnvGgPXv+iPaoHMgBtHdsRyATs8xJY8F67kkmSpFFXZDBjECMVZN2mHi69YwkX3vAIf3pyLQBH77MLr5m/+6DXHrrHdA6cPZWdO9p40xF78uL9dx3SwH92PQD2WACP3TR43o7nZF3J5p8JO80dPL8kSdIIKDKYuQD4h4iYkVJ6usD7SuPGYyvW8e2bFvODWx9j1frurc5deMMi/uIFu20701g/EcGP//KoIbXibOOFbxs4mJl3XJZnv1dCS1v1fJIkSaOgyGDms8BhwNUR8UHgmpRKS+9JqialxI0PL+fC3y7iV394kr4qT809T6zi9kdXMn/OToPec3Mg07MJ/vizrPVktxcMXpkDToErPgLrn92SNqkzWxtm/lkO6JckSXWlyGDmwXw/B/gV0B0Ry4BK8wmnlJK/ijSulbqSXXTDIu5/cmizhl14w6IhBTOseARuuxDu/C50PQ0HnAqvu2jw61onwiFvhJvOgznHZK0w+58MLQOMtZEkSaqRIoOZuf2O24A9C7y/NCYM1JVsML+4ZylPvXJ/njN1QpWb3wrX/Cs8tHDr9D/+DNY+BZOfM3ghR74/GwszY79h1U2SJGm0FRbMpJScxkiqYqhdyaqJgJfsvytvO2ruwDOSbVqzbSAD0NcDd3wHjv3w4IVN2214lZMkSaqRIltmJPWzflMv/3fHE8PqSlZu6oQWzjh8T96yYA577Dxp8AvmHZ+Nj3l20bbnbrsQjj7b6ZMlSdKYYTAjjYAd6UoGsO9zJnPW0XM57bDdmNQ2jMe0qQnmvw1+9Yltz61cDA8vzNaFkSRJGgMKC2Yi4s+Gkz+l9JuiypbqQZFdyY7cu3PLFMx9vfDgr2GXfWDnvQa/0aFvgoWfhr6yIKq1A55/OkyfM7xKSZIk1bEiW2auAYbz8207FsGQ6s+IdSVbvSQb53L7t2DVY3DEe+Hl/z74DSfPyGYgu+8S2PXgbEayg0+HCVOHXTdJkqR6VmQw8y0qBzNNwB7AC4CpwE+AlQWWK9XEYyvW8Z2bFvP9IruSlVphbvsm/OkKSGUzm9/1PXjJJ7Ppkwdz3P/LZiXbbX7W5CNJkjQGFTmb2VkDnY+InYCvAQcBRxZVrjSaRqwrWf9WmEo2rIL7LoVD3zB4Qc/Zf3gVkyRJakCjNgFASunZiHgr8BDwb8B7R6tsaUdtzwKX5Sp2JevrhQd+nc0y9qcrIPUOfqPbvjm0YEaSJGkcGNXZzFJK6yLiFuDVGMyoASx6potv37SYH/7uMdZs6Bn29RW7kg2lFaaax26GJ38Pux4w7LpIkiSNNbWYmnkysFMNypWG7Or7n+KiGxZxzf1PD/vail3J+nrhT1cNrxWmv+Z2OOAUaG4d/rWSJElj0KgGMxFxMvBnwO9Hs9zRFBEvBP4KOArYG/iXlNLHa1srDdf2BDIVu5KtXgp3fHv7WmFKOvfNZiQ75A0waeftu4ckSdIYVOQ6MxcMcHoy8FzgYCCAzxdVbh06GlgAXA/sUuO6aDudeeTcIQcz23Ql6+uFB34Jv/vmDrTCtGWtMPPfBnOOckYySZKkCopsmTlrCHkeBf4ppfStAsutN19MKX0BICIW1bgu2k7HPXcGe+48iUdXrKt4vmJXstVL4UZbYSRJkkZLkcHMCQOc2wQsTSktKrC8upRS+cIgqjer1nczbeLgY06amoK3HjmHT1/+h63Sp01s5fUv2mNLV7K+XnjwV9lYmPt/YSuMJEnSKCpynZlri7rXUETEfOClwOH5tltejwF/CUbEROCjwBnAnsAK4ArgnJTSEyNZZ9VGSonbFj/Lt25czBX3LeOXH/oz5nR2DHrd6fP34HNX3c+G7j4OmDWVs46ay8mHzGZiW3PWCnPteXkrzKPbV7HOfWH+WVkrTEfn9t1DkiRpHCtyzMwK4J6U0nFF3XMQ5wCnDOeCiJgALCQb07IU+AkwF3gb8KqIWJBSerjgeqpG1m/q5ad3PcFFNyzm90tXb07/zk2L+dgrB5/aeNqkVv7p1Qeyz3Mm84I9dyJSHzy0sKBWmLNgztG2wkiSJO2AIruZtQCPF3i/wdwI3A3cmm+LgPZBrvk4WSBzI3BSSmktQER8mGxSgguA40uZI2I6MHOQe65LKW3nn+Y1kt524S3c9PCKbdJ/cOtjfPil+2UtLIN4/Yv2hHUr4IYvwq1fg5W2wkiSJNWLIoOZ+8i7eo2GlNK/lx/HIH/hjog24AP54ftLgUx+r/+MiDOB4yJifkrptvzUGcD5g1TlWsoCINWPUw7drWIws3pDDz+58wnOOHzPgW/w5H1w81fh7h9Cz/rhV8BWGEmSpBHVVOC9vggcExHHFHjPIh0NTAMeSindUeH8xfn+5FJCSukrKaUYZDt+FOqu7XDKobOZOqFyvH7RjYtJKVW/+HtvhPOPgtsvGn4g07kPnPQv8OE/wmu+DnOPMZCRJEkaAUW2zFwPfB24MiK+DlxGNhXzhkqZa9A165B8f3uV86X0549CXaqKiPuqnNq7q6uLhQsXjmp9Srq6ugBqVv72WrArXLV42/RnVq7h0isWMq29cpCxz9omBmm32UpftPDULkeyZNZJrJx2IGwIuPmu7au0xrRGfZakeuOzJBWnls9TqeztVWQwswhIZItifoAtXboqSQWXPRSl36bVxvWU0ufsSCERMQMoTYIwCXheRLwW6Eop/WJH7j3e9fQl7nyqj9880cN7nt9GR+vgrR0n7NHMLxf3UGqDOXiXJl68RwsH7dJE0wCtJU/Mfjl7PPEzggFab4CuibNZMusklu16At2tU4fzdiRJkrSDigwofgOD/PKrrcn5vvIqiFAKC6fsYDkHAj8qO35Nvi0mmzltQCmlAyulR8R9HR0dB5x44ok7WL3tU4rUa1H+8rUb+d+bH+W7tzzKstWbAHhy0jzeeexeQ7r+prV3sMvkdt68YA7zdhl8SubNVl4KD1y1bXpTKxzwapj/NjrmHsO+Eew79LtqnKvlsySNJT5LUnFq+Tx1dAzjt1kFRa4zc3xR92pkKaVryFqntIMefGoN37j+EX58+xNs6tl6LdJv37SYtx89j6amwT/qL5xxWPZi7VNw07fg8PdA0xCGix3+nq2Dmckz4YVvzwb0T9l1GO9EkiRJI2G0u3rVUmn2sklVzpfCwjWjUBdVkVLihoeW8/XrHubq+5+umm/x8nVc+8DTnLDfcwa/6eO3wS1fhfv+D3o3wS7PhX1ePPh1e5+YDeaf1AmHvxv2fzW0tA3j3UiSJGkkjadgpjThwO5VzpfSKwwXr418nZvp+WFrX1/fQNkb2qaePi67awlfv/4R/lC2wOVAvnXDooGDmXsuhpu+DE/ctnX6zV8dWjDT1ATv/BVM3GlI9ZEkSdLoGk/BTGlqqRdUOV9Kv3sU6jJUZwOfKB0sX768hlUZGSvXbeK7Nz/KRTcs4qk1G4d17TV/epolK9cze/rEyhn+8NNtAxnIuo6teBh2HsKYGwMZSZKkulXkOjP17rfAKmDviDi0wvnX5vvLRq9KgzoXmJdvD3R2jp2V4x95potzLr2XI/9tIZ+98v5hBTLtLU287oW7c9kHjqkeyEA25qWiBLd8fXgVliRJUt0ZNy0zKaVNEfEl4GPAeRFxUkqpCyAiPky2vsy1KaUKf8qvjZTSSmAlQER0Nw1l0HodSylx66Jn+dp1D/OrPzzJQGtWVjJz6gTOPGouZ7xoD3bqGMLYlTlHwa4HwZP3bnvuju/ACf8A7ZO3PSdJkqSG0LDBTES8EjinLKktT7+pLO2fU0qXlx1/GngJcBTwQERcR7auzBHA08DbR7TSwzRWxsx09/bx83uW8o3rH+Hux1cN+/qDdpvKu47di1ccPIvW5iboegbYZfALI7KB+5f91dbp0/aEw9857HpIkiSpvjRsMAPMIAtC+juiX57NUkobIuIE4KPAG4FTgRXAhcA5KaVqC2rWSkOPmVm9oZvv3/IoF/52EUtWbRj29S/Z/zm889i9OGLeztlc14t/mw3e/+Pl8N7rYdcDBr/JwafDrz4B65+FecfBEe+B5/45NDUPuz6SJEmqLw0bzKSULiQLQoZ73XrgH/Ot3p3Llvd4VWdnZ0OszfjYinV887eL+MGtj9K1qXdY105obeK183fn7UfPY68Zk6F7Q9Yl7OavbN1d7Jb/gZPPHfyGbZPg1V/Kplh+zvOG+U4kSZJUzwoPZiKiBXglcDhZX6CbU0oX5Odm52m/Tyn1FF32WNNoY2ZuW/ws37j+Ya64dxl9wxwPM2NKO2ceOYc3HjGHnTvasq5k15wHt34NuiqsN3P3D+AlnxjabGP7v2p4lZEkSVJDKDSYiYhjgO8AewABJKAVuCDPciTwQ+B04JIiy1Zt9PYlrrxvGV+/7mFuf3TlsK9/3swpvPPYvTj5kFm0tzTD0/fDr8/LgpWeAbqmda/LWmyO+uAO1F6SJEmNrLBgJiIOAK4gC16+CFxPFriUuwxYB7wGg5mGtnZjDz+89TG+ecMjPLZi/bCvP36/GbzzmL04ep/ObDzMI9fCjedla8AM1S1fgwXvc/yLJEnSOFVky8w5wATgFSmlqwAiYqsM+fTItwOHFVjumFWPs5ktWbmei25YxP/e8ihrNgyvp2BbSxN/cdhuvP2YeTx31ynQsxHu+l4WxFSaPnkwzW2w+gmYvufwr5UkSVLDKzKYOQG4pRTIDOAJ4JACyx3L6mY2s0Wr+7hyUQ+/+9XV9A5zQMzOHW28ZcEc3rxgDjOmtMO6FfCbz2YtK2ufHGZNAp77smzK5b1OgDofRyRJkqSRU2QwMx14bAj5Osi6omlwdTGb2b9f8UfOv2njsK/be0YH7zx2L047bDcmtDbDMw/AtV+GO78HPcPsmtbaAYe9OZtauXPvYddFkiRJY0+RwcxTwD5DyLc/Qwt6xr16mc3s2H124fxrHhpy/qP36eSdx+7FcfvOoCmARddlXcn+dMXwC58yOwtg5p85tJnLJEmSNG4UGcwsBN4SESeklK6ulCEiTiMLeM4rsFyNsCP37mSPKcFja6p3L2ttDl59yG6845h5HDB7KvRsgnt+ADd+CZbdM/xCZx0CR34QDjwVmm3IkyRJ0raKDGY+A7weuDQiPgL8X+lEROwEnAZ8DugC/rPAcjXCIoKT5rTwjXu7tzk3bWIrb16wJ2ceOZfnTJ2QjYe57vNw8//A2mXDLQn2ewUc+X6YcxT0m0BCkiRJKldYMJNS+mNEvAH4NvClfEvAmfkGsAF4Q0rpkaLKHcvqaTazI2Y2c/ED3azKh87M7ZzEO46Zx2vm786kthZY/hBc/mW483+zNWCGo3USHPomWPCXjoeRJEnSkBW6aGZK6dKIOAj4EPBSYC7QBDwO/BL4fEpp6IMvVDezmbU0BS/Zo4XHeqfyrmP34sXPe042HmbxDdl4mPt/Tha7DsOUWdmsZPPPgkk7j0CtJUmSNJYVGswApJQWk/0I146ri9nMSl4+r4WXvPhI6O2Gey/OxsMsvXP4N5p5cD4e5jRoaSu+opIkSRoXCg9mVJx6mc2spK2nC64/F27+KqxZMvwbPPflcOT7YO6xjoeRJEnSDjOY0eBWPMy+D36dWct+DX0bhndty0Q49I3ZeJhdatqwJEmSpDGmsGAmInqHmLUbWA7cAXwnpfT9ouqgEXLbheyx5PLhXTN512w8zAvf7ngYSZIkjYgiW2YeIxsBPqcsbWW+n16WtgzYFXgF8PKIeB3w2pRS7abq0sAOfw99N3yJpjSEeHXXg7KplQ96DbS0j3zdJEmSNG4VOQhjH7LWlseAdwFTU0o7p5R2BqYC7wQW53mmAUcB9wKnAO8psB5jRkRMj4i5ETGXWk7NPG03nppx9MB59j0J3voTeO/1WbcyAxlJkiSNsCJbZj5CNh3zgSmlR8tPpJTWAhdExK/JApiPpJQ+FRGnAfcBbwHOL7AuY0XdTM382G6vZuZTv9k6sWUCHHIGLHgfzNivNhWTJEnSuFVky8yZwML+gUy5fNrmhWTBCymlh4HbgAMKrMdYci4wL98e6OzsrFlF1kzZm2enHZgddMyAEz4GH7oPTv6CgYwkSZJqosiWmd3JupANZmOet+RR4IUF1mPMqLepmR+ZcwY7zdsZDnottE6oaV0kSZKkIoOZZcAJETElpbSmUoaImAqckOct6QRWFFgPjZCV0w+Cw06sdTUkSZIkoNhuZj8gC0yujIgj+5+MiAXAL4Cdge/naQEcDNxfYD0kSZIkjQNFtsx8CjgOWABcHxHLyGY2A9gDmAkEcBPwz3n6IcAq4IcF1kOSJEnSOFBYMJNSWhcRxwH/j2yq5d2AWWVZngC+Anw2pbQpv+ZOYP+i6iBJkiRp/CiyZYY8SPk08OmI2JMtwczSgWY5kyRJkqThKjSYKZcHLwYwOyAipgPT88PaLZopSZIk1aHazvWrwZwNPJJv+9Zy0UxJkiSp3hTeMhMRxwCnAPsCU8gG/feXUkovLrrsMehc4ML89VWdnZ371rAukiRJUl0pLJjJp1n+BnAmWwKYxNbBTOk4FVXuWFZvi2ZKkiRJ9aTIX8fvBc4CbgNeClySp+8HvJyshaEP+CywV4HlSpIkSRqHiuxmdhbQBbw8pbQ8It4MkFJ6AHiAbDHNn5MtrnkDsLjAsiVJkiSNM0W2zOwP3JBSKo1STwAR0VzKkFK6mKzl5m8LLFeSJEnSOFRkMNMElE+3tS7f79Qv3wPAwQWWK0mSJGkcKjKYeQKYXXZc6kZ2WL98zwV6CixXkiRJ0jhUZDBzO3BAWbeyq8hmLvuPiHheREyJiL8D5gN3FFiuJEmSpHGoyGDmp8AuwCsBUkp3Ad8HDgHuI5ti+DNkrTIfK7BcSZIkSeNQYbOZpZS+FxGXsHUXsjOBu4FTycbO/An4j5TSLUWVK0mSJGl8KnJqZlJKG/sdd5O1xnymyHLGi4iYDkzPD1v7+vpqWR1JkiSprhTWzSwibo+IHxV1PwFwNvBIvu27fPnyQbJLkiRJ40eRY2b2A7oLvJ/gXGBevj3Q2dlZ4+pIkiRJ9aPIbmYPAP7aLlBKaSXZxAlERHdTU5GxpyRJktTYivx1/A3guIh4XoH3lCRJkqSKCgtmUkpfBC4Ero2ID0XEPhHRVtT9JUmSJKlcYd3MIqK39BL4XL4REZWyp5RSoTOpSZIkSRpfigwoHgNSgfeTJEmSpKqKXDRzblH3kiRJkqTBOD2WJEmSpIY0YuNWIqId2BnYmFJaMVLlSJIkSRqfCm+ZiYh3R8QdQBfwOPlEAPm5v4iISyJin6LLlSRJkjS+FBbMRERzRPwfcD6wP/AHspnNyt0FnAq8vqhyJUmSJI1PRbbMfAA4BfgFMCeldHD/DCmlh4AHgZcXWK4kSZKkcajIYOYs4Eng9SmlJwfI93tgToHlSpIkSRqHigxm9gNuTil1DZKvC5hRYLmSJEmSxqEiZzPrBiYMId+ewJoCyx2zImI6MD0/bO3r66tldSRJkqS6UmTLzH3A/IiYUi1DRDwHOBS4s8Byx7KzgUfybd/ly5fXuDqSJElS/SgymPk20Al8JSLa+p+MiGbgPGAScFGB5Y5l5wLz8u2Bzs7OGldHkiRJqh9FdjP7H+B04A3AURFxZZ5+SER8AXgV2Y/yq4DvFljumJVSWgmsBIiI7qamwpcFkiRJkhpWYb+OU0q9wCvI1pmZDbw7P3UY8EGysTJfA05NKaWiypUkSZI0PhXZMkNKaQPw/oj4JHA8MJcsYHocuDqltKTI8iRJkiSNX4UGMyUppaeBH43EvSVJkiQJCuxmFhGfi4hDirqfJEmSJA2kyBHlHwZuj4h7I+KjETGnwHtLkiRJ0laKDGb+GrgVOAD4F+DhiPhNRLwnInYqsBxJkiRJKnQ2sy+mlBYA+wCfBB4EjgG+DCyNiEsj4vSIaC+qTEmSJEnjV+ELl6SUHk4pfSqltB/wIuC/gRXAq4HvA09GxAVFlytJkiRpfBnRVRhTSrellD4E7A6cBPwAmAqcOZLlSpIkSRr7RmtJ+T8DXge8bJTKkyRJkjTGjcg6MwARcSjwJuAMYDYQwBrgW8B3R6pcSZIkSeNDocFMRMwD3phvzyMLYLqBy8kCmJ+klDYUWaYkSZKk8amwYCYibgQOJwtgAG4gC2B+kFJaUVQ5kiRJkgTFtswcAfyRLID5bkppUbWMEdGUUuorsGxJkiRJ40yRwcz8lNIdA2WIiMOAt7BlHI0kSZIkbZciF82sGMhExB4R8ZGIuBf4HXA2sGtR5dabiHhdRFweEUsjYlVE/CYijql1vSRJkqSxZkRmM4uIKcDpwJvJpmWOfHuCbK2Z741EuXXibOAB4P3AWuBtwK8j4vCU0l01rZkkSZI0hhQ5AUAz8Odk3chOBiawZTKABBwPXJdSSkWVWadOTiktLx1ExK+Ae8iCm3fXrFaSJEnSGLPD3cwi4kUR8d/AEuCnZItjtuSvTwduBUgp/WYcBDKUBzL5cR9wLzCvNjWSJEmSxqbtDmYi4uMR8QfgJuADwAzgRuB9wKyU0mkppR8Dmwqp6bblz8/H4lwSEY9HRIqIQYOliJgYEZ+KiD9FxIaIWBIRF0TEbiNUz2bgRcCDI3F/SZIkabzakW5mnyLrPrYM+DKDTMc8As4BThnOBRExAVgILACWAj8B5pKNa3lVRCxIKT1ccD0/AOxJ9hlJkiRJKsiOjpkJYCbwMuCpiPhRSmnljldrSG4E7ibrxnYrsAhoH+Saj5MFMjcCJ6WU1gJExIeBzwMXkI3tIU+fTvb+BrIupfRopRMRcQTwGeDTKaV7BrmPJEmSpGHYkWDmCOCtwOuBY4Cjgf+OiJ+TLZx5WUqpe8erWFlK6d/LjyOiWtbS+TayVhKA95cCmfxe/xkRZwLHRcT8lNJt+akzgPMHqcq1lAVAZeXNJWv5uQz4p0HuIUmSJGmYtnvMTErp1pTSB8kWvzwFuJis29lpwI+ApRHxVepnTZmjgWnAQ1XWxLk4359cSkgpfSWlFINsx/e/Ud6iczlZa9GZ42HiA0mSJGm07fDUzCmlHrLWh8siYirZDGZvAY4F3kUW4BARnwG+n1K6c0fL3E6H5Pvbq5wvpT9/RwrJW4AuASYBJ6aU1g/z+vuqnNq7q6uLhQsX7kj1tltXVxdAzcqXxgqfJakYPktScWr5PJXK3l47PDVzuZTS6pTSN/LWirnAx4A/ko2t+Tvgtoj4Q0ScfBkvrgAAIABJREFUU2S5Q7Rnvn+8yvlS+pwdLOfLwHHAPwPzImJBvh22g/eVJEmSVKawRTP7Syk9Bvwb8G8R8QKy1pozgP2AT5L92B9Nk/P9uirnS2HhlB0s5yVkQeI3+qUvJgvwBpRSOrBSekTc19HRccCJJ564g9XbPqVIvVblS2OFz5JUDJ8lqTi1fJ46Ojp26PoRC2bKpZRuB26PiL8hm/nszaNRbi2klObWug6SJEnSeDAqwUxJSqkP+EW+jbbS7GWTqpwvhYVrRqEukiRJknbQqAYzNVZaC2b3KudL6YtHoS5Dks+KNj0/bO3r66tldSRJkqS6UugEAHXurnz/girnS+l3j0Jdhups4JF823f58uU1ro4kSZJUP8ZTMPNbYBWwd0QcWuH8a/P9ZaNXpUGdC8zLtwc6OztrXB1JkiSpfoybYCaltAn4Un54XkRsnjohIj5Mtr7MtSml22pRv0pSSitTSotSSouA7qamcfPPJUmSJA2qYcfMRMQrgfL1atry9JvK0v45pXR52fGnyaZOPgp4ICKuI1tX5gjgaeDtI1rpYXLMjCRJklRdwwYzwAyyIKS/I/rl2SyltCEiTgA+CrwROBVYAVwInJNSqragZq2cDXyidOCYGUmSJGmLhg1mUkoXkgUhw71uPfCP+VbvzmXLe7yqs7Nz3xrWRZIkSaorDRvMjAcppZXASoCIcMyMJEmSVMZfx5IkSZIaksGMJEmSpIZkN7M65mxmkiRJUnW2zNS3s4FH8m1fZzOTJEmStjCYqW/nAvPy7YHOzs4aV0eSJEmqH3Yzq2POZiZJkiRV569jSZIkSQ3JYEaSJElSQ7KbWR1zNjNJkiSpOltm6puzmUmSJElVGMzUN2czkyRJkqqwm1kdczYzSZIkqTp/HUuSJElqSAYzkiRJkhqSwYwkSZKkhuSYmTrm1MySJElSdbbM1DenZpYkSZKqMJipb07NLEmSJFVhN7M65tTMkiRJUnX+OpYkSZLUkAxmJEmSJDUku5lJkiRJY0Rf6mN9z3rW96xnXfc61vWs2/x6fc/67Lh7/VbpD654kI1pIz+9+qe8cNcX8uYD3lzrtzFkBjOSJEnSKEspsb5nPWs2rakccAzhuDwoKZ3f0Lth+yv1KExomVDcmxwFBjOSJEnSDtrYu5FnNzzLyo0rN+9XblzJyg0reXbjs1v2Zec39m6sdbW3sb57fa2rMCwGM3XMRTMlSZJGX3dvdxZ0lAUhqzau2hKslAcn+X59T2MFAdWs61lX6yoMi8FMfTsb+ETpwEUzJUnSjupLfWzq3cSmvk1s6t3Ext6N2XGl19XyDCG9u7ebjb0bs9d9Za97u+nu6yYiaIkWmpuaaY5mWppaaIqmza+bo3nzudLr8vxbnc/PNUXTNvkGum9Xd9dWLSWl/drutbX+Z6qZRgvKDGbq27nAhfnrqzo7O/etYV0kSdIANvVu4smuJ1natZQlXUtY2rWUZV3LWLp2KUu7lvLUuqfo7uuueG0iVb9xlVMDXTPQub5UJz09EvTQA721rojK2TKjwrhopiRJ9SGlxKqNq1jatXTLlgcpy7qWsaRrCc+sf6bW1ZSqao5mJrVMYmLLRCa1ZvuJLROZ2DqRrhVdtEUbe+2xF7Mmz6p1VYfFYEaSJI173b3dPLnuyaqByrKuZQ3X/UaNqbWpdXOw0T/42JHj1qZWIqJimQsXLgTgxAUnjuZbLYTBjCRJ40RvX+/mMQ7l+419W6dt6NlQOV+/10PNA9DW3EZbUxttzW20Nrduft3W1O+4uY3WptYB87c1t/FA1wPZGInHmrbco+x8/7Te1JsFJmvLun/l3cGWrV3G0+ufHrirlzRM09qnsVP7Tkxvn870CdOZ3j49O54wfXP6ThN2Ymr7VDpaOpjYmrWUtDa11rrqDcVgRpKkBtHb18vqTatZuXElqzauYtXGVZunfy29Lk9fvWn1VkFFT19Prd9C4b658Ju1roLGgSmtU7YEIXlgUgpGtglSJkxnattUWpr8mT0a/JQlSRplpcXyNq9DUSUY6X+8ZtMaWw80KlqiZXNLWVtzG+3N7Ztbvdqb27dOz1u/hpPe0tSSTQCQeujt66U39W5+3Zf66OnroTf10tvXu1WeUlpv6t0qT9Vz5ef73aunr4eJLRO3aSnpv5/WNo3WZltL6pXBjCRJ26Ev9dHV3UVXdxdrNq2hq7uLtd1rWbtpLWu7125uQVm9cXXFgKXarFYaG3Zq34mZHTOZ1TGLWZNnMatjFjM7ZjK5dXLVa4LK4xnyk8O+ptr4iCaaaG9pHzAAaW5qrl4XqY4YzEiSxpWUEut61rF209osEOleQ9emfN/dtTkYWdu9tmqgUgpiND61NLUwc9LMrYKU2R2zs9eTZzJz0kwmtU6qdTWlccFgRpJUcymliovtberbtNXr0uJ8m/PlC/GVLwC4qXfTlhaTPFDZHJzkr+2qpYFMbZvK7Mmzt7SslLWuzOqYReeETlsupDphMCNJ41hKiZ7Us83q3+UBwjZp/Watqpanf4DRP/jo/1q1FwQTWiZkXY6a2rfqetTe3L7V67bmtixv08B52pvbATYHplt9Lyqkdfd1b/X96e7trph/7fq19NBDakps6t1EbxrayovN0cyuk3bdKjiZ2TGT2ZNnb37d0doxkh+zpAIZzNSxiJgOTM8PW/v66mTFXkmjLqXE2u61rNq4itWbVmeDwjetYvXG1ZsHiK/rWbdVq0b5dLub08qCjlIwUTergWvYWptamd4+nWnt0zbPrjStfdrm42nt05jUMikLPJonDBictDe309LUUnWcRb3ZvC7Gidm6GL19vQMGRH2pjxmTZjBj4gxbVaQxxGCmvp0NfKJ0sHz58hpWRVIRelMv6/vW88iqR7YKTDYHKHmQUkorBSurN60e8l+e1XiCYErblK0Ckv6BSaWgZWLLxIYJPkZac1MzE5uydTokjR8GM/XtXODC/PVVnZ2d+9awLtK4UpoatLuve/O+u7fsdVn6pt5NrNm0ZnMQUrX1ZNOqLYPGL63t+9PIaIkWJrdNpqO1g8mtk7cJTCrtp7dPZ0rbFFsLJGk7GMzUsZTSSmAlQER0NzU11bhG0sBK4y96+7bM8d/d1715bv+evuxcd1/3VusA9PT1bLVtTiu7pvy40nX9A4zNr3u76U7d9PT2VD5fClJSnjc/ZyvI+NIUTXS0djCldQodbVkgUto62vL01g4mt21JL70uT29vbrelRJJGkcGMpM16+npYtXEVz254lmc3Ppvty1/3S9vQs2GroMIAQCMpiC2L+JUt3tfa3Lp5EHrp9aTWSdsEGqUApFLQYnctSWpMBjPSGLa+Z/22AckAgcrqjaudslbbCGKbGar6DyQvBRf9F94rDz42BxsVrqmWt/xejTQ4XZI0OgxmpDpRGqNRPk6jf9eq0rahdwMrN6xkxcYV2X7DClZuXMmzG57d6vWG3g21flsaIaUB49PapzGtLRsk3tHasWVa3bJgoVog0t7cTmtTa8XpdMtft4RBhCSpPhnMaMwojdfoP/5hKGMktifPVlvqqZzeLxipFqR093U7Pe441dLUwvT26Uxtm7o5MJna3u91HqyUp01pm0JTOI5OkjS+GcyornT3drNs3TKWrl3Kkq4lW+1XbFxRdTap0mupVia1TNoccJQCk80BSlkQ8vB9DzOpaRIvPfalTG2b6lgNSZJ2gMGMRtW67nUs7VrKkrVLNu/Lg5an1z3tmI1xqimaaIkWmpuaaWlqobWplebIXpf2pW2r42ihpTnL39rUuvnaiq+bWwc+F620Nm99bqD7lNJbmlqG3Eqy8KFsob+ZHTNH8uOUJGlcMJhRYVJKrN60epsAZenapTyx9gmWdi1l5caVta6mhqGjtYOd2ndipwnZNr19OjtP2Dk7bt+JjtaOrYKMlsiDjTwg2XzcLxgpD1pKr+0yJUmShstgRkPWl/p4at1TW7Wq9N+v61lX62qqiqZoYnr79K2Ck4FeT58wnfbm9lpXW5IkqSqDGVX1jXu+weLVi1mydgkPPfMQz/Y8S++PXEekXkxsmbg56CgPRnaesHMWtPRLc8C4JEkaawxmVNUlD1zCo2serXU1RkxTNA08zqK5lZbYenxE+RiJ8m5U26T3OzfQdducH+Bc+b6tua3WH6EkSVJNGcyoqlmTZ9U0mJnePp1ZHbOYPXk2szpmMbNjJhNbJg5pgPdgeUrjNCRJktS4DGZU1eyO2SN27yCYMXEGsyZnwcrsjtmbg5bSflLrpBErX5IkSY3PYKaORcR0YHp+2NrXN7qLKs6aPGu7r21pamHmpJnbBCilwGVmx0xam1sLrK0kSZLGG4OZ+nY28InSwfLly0e18IFaZia2TGR2x+ysZaVsXwpadpm4i924JEmSNKIMZurbucCF+eurOjs79x3NwvfZaR9O3ONEZk+ezdqla9m5eWdOOvIkZnfMZnr7dFctlyRJUk0ZzNSxlNJKYCVARHQ3NY3utLoHdh7IF078AgALFy7cnCZJkiTVAxedkCRJktSQDGYkSZIkNSSDGUmSJEkNyWBGkiRJUkMymJEkSZLUkAxmJEmSJDUkgxlJkiRJDclgRpIkSVJDMpiRJEmS1JAMZiRJkiQ1JIMZSZIkSQ3JYEaSJElSQzKYkSRJktSQDGYkSZIkNSSDGUmSJEkNKVJKta6DhiAiVre3t0/Ze++9a1J+V1cXAB0dHTUpXxorfJakYvgsScWp5fP00EMPsXHjxjUppanbc73BTIOIiGXAJOCxIWRvAjqB5UBfQXlLUdRDQyh/rBnO5zlaRrNORZdVxP229x7Dvc5nqXjj+XkaiXJ29J6j9SwN95qh5PVZ8lmqp2dpR+4x3v9v2gNYl1KauT0XG8yMQRExF3gEmJdSWlRE3oi4DyCldGAxtWwcw/k8R8to1qnosoq43/beY7jX+SwVbzw/TyNRzo7ec7SepeFeM5S8PksxF5+lunmWduQe/t+0YxwzI0mSJKkhGcxIkiRJakgGM2PTSuCf8n2RecerevyMRrNORZdVxP229x7Dvc5nqXj1+DmNVp1GopwdvedoPUvDvaYevyf1ph4/o/H8LO3IPfy/aQc4ZkZD0sh9KaV64rMkFcNnSSpOIz9PtsxIkiRJaki2zEiSJElqSLbMSJIkSWpIBjOSJEmSGpLBjCRJkqSGZDAjSZIkqSEZzEiSJElqSAYzkiRJkhqSwYwkSZKkhmQwo0JFxOsi4vKIWBoRqyLiNxFxTK3rJTWaiDgzIn4XESsjoisibo+IM2pdL6nRRcTBEdETEY/Xui5So4mIsyIiVdiOr1WdWmpVsMass4EHgPcDa4G3Ab+OiMNTSnfVtGZSY9kJuBS4E9gAnAp8LyI2pJQurWnNpMZ2LrC81pWQGtwxQG/Z8e9rVZFIKdWqbI1BEdGZUlpedtwE3AP8NqX07trVTGp8EXE9sDSldHqt6yI1oog4Ffgv4PvAW1JKu9e4SlJDiYizgG8CrSmlnhpXB7CbmQpWHsjkx33AvcC82tRIGlOWA621roTUiCKiDfgc8BFgY42rI6kgBjPjSETMj4iPRMQlEfF4qZ/jEK6bGBGfiog/RcSGiFgSERdExG5DuLYZeBHwYBHvQaoHo/ksRURLREyNiNcDLwW+WuR7kWptFJ+ns4GnU0o/KPYdSPVhlH/nPZGPPbs7Il5b4NsYNruZjSMRcSlwSv/0lFIMcM0E4GpgAbAUuA6YCxwOPA0sSCk9PMD1fw18HjgspXTPjtRfqhej9SxFxMw8L2R9k9+XUvqfAt6CVDdG43mKiF2BPwF/nlK6MSI+CbzTbmYaS0bpWXoZMB+4GZgIvINsTOepKaWfFPVehsMJAMaXG4G7gVvzbRHQPsg1Hyf7gt8InJRSWgsQER8mC1IuAI6vdGFEHAF8Bvi0gYzGmNF6lp4ha9mcAvw58KWIWJ5S+nEh70KqD6PxPP0rcEVK6cYiKy7VmRF/llJKVwJXll3/s4i4DvgHoCbBjC0z41hEbADaq0Xsef/ip4BpwAtSSnf0O38X8HzghSml2/qdmwvcBPwGeH3yi6YxbCSfpX75vgYcl1J6bmGVl+pM0c9TRBwE3Eb2g+2RPNtHgLcABwLrUkqbRuTNSDU0iv83/S3wLymlwQKnEeGYGQ3kaLIv+EP9v+C5i/P9yeWJETEduJzsLwJnGshI2/csVXAnsFeRFZMa0HCfp32ANuB24Nl8+3tgdv767SNaW6l+FfV/U03ZzUwDOSTf317lfCn9+aWEPMq/BJgEnJhSWj9y1ZMaxrCfpSqOIvsjgTSeDfd5uh44oV+es4BXAqeTjaWRxqMd/r8pIgI4DagUDI0KgxkNZM98X22V5FL6nLK0LwPHAe8C5kVEaUrmjVWifmk8GPazFBFXAz8G/ghMIBvU+UbA9Zo03g3reUopPQNcU54hX618Y0ppq3RpnNme/5suBm4hG5vTDrwTOBJ49QjVcVAGMxrI5Hy/rsr5rnw/pSztJWTdF7/RL+9istkxpPFoe56lu4APAnvk538PnJxS+tmI1FBqHNvzPEna1vY8S38iC2BKMwHeAbwqpfTz4qs3NAYzKlRKaW6t6yCNBSmls8nWxZBUsJTSJ4FP1rgaUsNJKf0D2cxldcMJADSQtfl+UpXzHfl+zSjURWpkPktScXyepGKMiWfJYEYDeTTfV1tUrJS+eBTqIjUynyWpOD5PUjHGxLNkMKOB3JXvX1DlfCn97lGoi9TIfJak4vg8ScUYE8+SwYwG8ltgFbB3RBxa4fxr8/1lo1clqSH5LEnF8XmSijEmniWDGVWVr4j8pfzwvIgo9Z0kIj5MNu/4tQOtCivJZ0kqks+TVIyx8iyFi7OPHxHxSuCcsqTDgQBuLkv755TS5WXXTCCbn/8IYClwHdl840cATwMLUkoPj2zNpfrisyQVx+dJKsZ4fZacmnl8mUH25ezviH55NkspbYiIE4CPki3YdyqwArgQOCelVG2hJWks81mSiuPzJBVjXD5LtsxIkiRJakiOmZEkSZLUkAxmJEmSJDUkgxlJkiRJDclgRpIkSVJDMpiRJEmS1JAMZiRJkiQ1JIMZSZIkSQ3JYEaSJElSQzKYkSRJktSQDGYkSZIkNSSDGUmSJEkNyWBGkiRJUkMymJGkgkREyreVETG9Sp6P5Hk+OcrVG1REHJ/X7cJa12UkRMRfRcR9EbExf5/X7OD9Ppnf56xiaji2+PlIGg0GM5JUvGnAh2tdCW0REX8BfAGYBfwUuAi4oqaVykXE3CKCq7EsIi7MP6Pja10XSfWlpdYVkKQxJgEbgb+OiP9KKT1b6woJgFPz/WtTSgtrWpPx40vA94Glta6IpLHLlhlJKlYf8D/AVOBva1wXbbF7vn+4prUYR1JKz6SU/phSWlXrukgauwxmJKl4nwHWAx+MiM6hXBAR1+TdaOZWOFexG1L5mISImB8Rv8jH66yIiB9GxO55vo6I+I+IWBQRGyLi3oh47SD1mZV37XkyItZHxO0R8dYB8u8cEf8WEb/P86+KiIUR8aqB3k9ETI2I/4yIRyKiOyLOHeLntUdEfDUiFudjYJ6KiEsi4kWVPiPghDzpkbKxTccPsaxXR8SNEbEuIpZHxI8j4rkD5D80/7xvi4in8/o9HBFfjojZ/esHPJIfHldWt63GLkXEsRHxpYi4OyKezT/jP0bEZ6qNzxqgfpu7bEXEyyPi+ohYm9/3koh43gDXviXPvzr/PO6OiI9GxIQKeSuOmSn/rkfEqRFxU0R05d/b75W+t2X5E3Bmfnh1v89obp4nIuJNed2ezL/nj0XEryLi/cP5fCQ1FoMZSSpYSmkp8BVgCvB3o1DkEcBvgRnAlcBy4HTg1xExDbia7MfgrcCNwAHADyPiZVXutzNwE/DnwDXAdcDBwEVRYeKC/If9ncBHgIl5HX6X1+uyiKjWQjURuBY4K7/+p8Cg3fIi4mDgduDdZEHjJcADwGnADRFxeln2O8nGxzyZH/84P74IWDaEst4L/CR/L7cCvwTmA7cAe1e57CPAh/LX1wM/BwL4S+B3/QKaO/M6kdfxorLt+rJ8nwXekb/fX+fbVODvgesjYvJg76WC04HLgTbgMmAJ2Wd4U0Qc0j9zRHwV+BbZ+78uv3YW8K/AwoiYNMzy3wdcnL+nnwNrgTPye00sy3cR8FD++kq2/ozW5un/AXwHeCFwF1u+E89ndJ5BSbWSUnJzc3NzK2AjGy/Tk7/eFegi+7E1oyzPR/J8n+x37TV5+twK952bn7umX/on8/QEvLcsvZXsR3cC7iP74dtRdv4d+blr+93v+LL7XdXvmhcBa4Be4AVl6c3A3fk1fwc0lZ3bh6xbVw9wUIX3k4AbgOnD+IyjrLx/B6Ls3Gvy+q0BZg318x2grDlkP7Q3AS/r9/l+p+w9nNXvuhOAXfulNQH/mOe/YCj/vv3yvByY1i+tHfhqfu0/DuN9XVhW93f1+2w/k6ff0e+a1+TpTwD7lqVPIwtsEvC5Kt/P/p9P6d+iCziyLH0SWVCegLdXqfPxFd7PBGADsBqY1+9cC3Bs0c+6m5tb/Wy2zEjSCEgpPQmcD3SQ/fV8JF2fUvpKWdndwBfzw+cBf5lS6irLfyHwDHBkRLRWuF8f8MHya1JKtwLnkf0of19Z3pPJWm1+nFL6bEqpr+yaB4G/IQt43lWl7n+VUlo5pHeZOT4v71Hg4ymlVFbej4FLgcnA24dxz2reTvZD+XsppSvLyukG/hpYV+milNLV+b9/eVpfSulTZMHAq4dbkZTSL1K/sScppY3A2WTB4inDvSdwQ0rpa2X3S8A5wOPAoRFxTFnev8r3/5RSeqDsmlXA+8kCjfdU6m42gP9KKd1Ydq91wH/mh382jPtMJQvsHkopPVJ+IqXUk1K6bhj3ktRgDGYkaeT8O9lfn/8yInYdwXKuqpBWGui+KKX0p/ITKaVeYDFZC8MuFa69M6V0f4X07+X7Y8vSTsr3l1SpW+mH5OEVzi1NKf2uynXVlMr+YR5U9Pftfvl2ROke3+9/IqW0nMqfOwAR0RkRb4uIz0fEN/JxKheSfeadEbHzcCsTEbtFxHsj4tyIuCC/3/lkLUf7Dvd+VH5f3WRdvyB//3nAuyBP+26Fa+4may2bDBw6jPIrfX6l7+qsod4kpfQUWwKwz0TEXsOog6QG59TMkjRCUkpPR8R5wP9j63EURXuiQtraAc6Vn2+vcG5xlWsW5fvyMR9z8/13I2KbH7plKgVNjw6Qv5pS2YuqnC+l77Yd965W1mCfx1Yi4g1kM9oNNI5lCrBiqBWJiA+TdQGr1JK2vYb679xJNq7mmX4tfP2vOYThfe6PV0hbk+8rfS8HciZZcPb3wN9HxGKy8VjfTyn9Ypj3ktRADGYkaWR9lqxb1nsj4j+28x6DtaL3bee5IpTqdgVbBtlX8kyFtA3FV4c0eJaRExFzyLrxQdYF7HLgiZTS+vz8DcCRZONThnrPBcDngVVk3duuAZbl3cyIiCUMoyVjhGzP517YdzOltDAi9gFeRTZxxfHAW4G3RsSPU0oDzt4nqXEZzEjSCEopPRMRXwQ+mm9LqmTdlO8r/TV/j5Go2wDmDJJe/h5Kf13/ej5mZaSVyq5Wx7n5vlqL1HAsBfbLy/p9hfOV6vAKslaMz6WUvlDh/PZ0gTot338spXRR+Yl81q+Z23FPGPq/83Ky7+cuEdFRpXVmbr4v4nPfLiml1cD/5lspCPwR8JqIeEVK6ee1qpukkeOYGUkaeZ8n6z7zbqp3wymtkl5p/ZKXjkSlBnBoRFQag3FGvi+fMviX+f40RkdpDM7pEdFc4fyb++UroqzX9T+Rj3k5qX86sFO+36YLVUT8Gdksd/2VAtlqf2Csek+y6ZWH3MrTT6X31UI2cxnk/875OJqb8rQzKlxzEFkXs7VkU02PhME+o22klG5iyxiqgwqvkaS6YDAjSSMsHyz+32TjAN5RJdu1+f5vytfriIgTyborjaYm4Iv96jEf+ABZd6Lzy/L+mKzV4k0RcU5EbDXWIV/M8OiIOLqgul0D3EPWEvCpiNj8Qz4iTgP+guxH9QUFlPVNYCPZe3tJWTmtwH+RzVTXX2kA+5sjoqPsmt3I1h6q5BmgG9i7SoBWuuc7ymefi4gDyCaZ2F7HRET/Wd/+CdgTuLvfLGCl2fE+WT7APiKmAF8iC6i+mlIaia6DsKWVaL/+JyJiz8gWjp3UL30CWxZLfWyE6iWpxgxmJGl0fJ5sHYyJVc5/D7gfOAr4Q0RcHBE3kbV8nF/lmpHyM7KFNR+KiB9ExBVki21OAf6lfAaylFIPcCrZKvafAh6NiF9GxHcj4kqyhSmvJ1unZofl0we/iazr0z8A90XE/0bE9WQzqvUB70jZwqU7WtYjZFNLtwJXRsTVEfE9suDiFCrM7EW28Od9ZIs3Ppj/O/4sv+ZZsnV1+peziWzM0Uzgroj4VkR8PSLelmf5JtnneDJwf/5v8kuyVpDrqD6QfzDnA1+PiJvzz/Bess90NdlCpuV1vJhsUoPdgXsj4mcR8UOyxSyPI2u5+cftrMdQXEa+lk1EXJp/Pl+PiE6yRV6/CTwdEdfm371LySaYWEC2gGu12fYkNTiDGUkaBSmlZ4FzBzi/HngxWVAzhWzsRTPwerL1XUbTcrIfgb8i+8v28WStL29LKZ3TP3O+7shhwMfJukItIGsheS5wB9k6JN8pqnIppXuAFwBfIxtj9Fqyv9hfChydUvphgWWdR9aF7lbgCOBlZCvMLwAerJB/E9mUxueTTXDwKmB/spaNl5K1wFTyTrIuUZ3AG8la8I7L77mcLBj8X7LxOK8m6654DvCGHXh7P8zv1UsWnO0O/IRsIcs7Kry395ANqr8jr9vJwFPAx4AT83ViRkRK6TayLoS/J+ve9458m0IWUP0NWavdnmTfvWPIgrwPAccIKWjkAAAAsElEQVSVJkuQNPZE2XpjkiRpjMvXpzkTOCGldE1tayNJO8aWGUmSJEkNyWBGkiRJUkMymJEkSZLUkBwzI0mSJKkh2TIjSZIkqSEZzEiSJElqSAYzkiRJkhqSwYwkSZKkhmQwI0mSJKkhGcxIkiRJakgGM5IkSZIaksGMJEmSpIZkMCNJkiSpIRnMSJIkSWpIBjOSJEmSGpLBjCRJkqSGZDAjSZIkqSEZzEiSJElqSP8fcKGlwytOizIAAAAASUVORK5CYII=\n",
            "text/plain": [
              "<Figure size 900x600 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          },
          "output_type": "display_data"
        }
      ],
      "source": [
        "fig = plt.figure(1, dpi=150)\n",
        "plt.loglog(input_sizes, xpu_sequential_runtimes3a, label=\"Viterbi C Sequential-GPU\", linestyle=\"-.\", linewidth=3)\n",
        "plt.loglog(input_sizes, xpu_sequential_runtimes3b, label=\"Viterbi P Sequential-GPU\", linestyle=\"-.\", linewidth=3)\n",
        "plt.loglog(input_sizes, xpu_parallel_runtimes3, label=\"Viterbi Parallel-GPU\", linewidth=3)\n",
        "plt.legend()\n",
        "plt.xlabel(\"Number of data points\")\n",
        "plt.ylabel(\"Average run time (seconds)\")\n",
        "plt.grid()\n",
        "plt.show()"
      ]
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "machine_shape": "hm",
      "name": "phmm_viterbi.ipynb",
      "provenance": []
    },
    "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.8.3"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}