A Simple Trend Following System in Python

trend_following_1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Trend Following System 1\n",
    "Most of the following imports are mainstream, well known Python libraries.\n",
    "\n",
    "alpha_vantage and fix_yahoo are specialist libraries to download stock data free.  To use alpha_vantage you will need to obtain your own key from the providers https://www.alphavantage.co/\n",
    "\n",
    "ffn is a specialist library to report trading systems statistics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib.pyplot import figure\n",
    "%matplotlib notebook\n",
    "import pandas as pd\n",
    "import datetime as datetime\n",
    "from alpha_vantage.timeseries import TimeSeries\n",
    "import fix_yahoo_finance as yf\n",
    "#because the is_list_like is moved to pandas.api.types\n",
    "pd.core.common.is_list_like = pd.api.types.is_list_like\n",
    "import ffn\n",
    "pd.set_option(\"max_colwidth\", 100)\n",
    "pd.set_option(\"display.max_rows\", 100000)\n",
    "pd.set_option(\"display.max_columns\", 1000)\n",
    "#import pixiedust"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following two cells can be used to download stock data and then blanked out again once the data has been saved to csv.\n",
    "\n",
    "The following line is to create split adjusted Open prices since only the adjusted close is provided:\n",
    "\n",
    "data['Adj_Open']=data.Open*(data.Adj_Close/data.Close)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "#ts = TimeSeries(key='insert own key', output_format='pandas')\n",
    "#data, meta_data = ts.get_daily_adjusted(symbol='SPY', outputsize='full')\n",
    "#data = yf.download(\"SPY\", start=\"1970-01-01\", end=\"2018-12-08\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "#data.rename(columns={'Adj Close': 'Adj_Close'}, inplace=True)\n",
    "#data['Adj_Open']=data.Open*(data.Adj_Close/data.Close)\n",
    "#data.to_csv('../data/Stocks/spy.csv')\n",
    "#data.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Chart the data to check there are no obvious problems with the split adjusted data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x19133806a58>"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 480x320 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "pricing = pd.read_csv(\n",
    "    '../data/Stocks/spy.csv',\n",
    "    header=0,\n",
    "    parse_dates=[\"Date\"],\n",
    "    #index_col=0,\n",
    "    usecols=['Date','Adj_Open', 'Adj_Close'])\n",
    "figure(num=None, figsize=(6, 4), dpi=80, facecolor='w', edgecolor='k')\n",
    "plt.plot(pricing.Adj_Open, label='Spy Open')\n",
    "plt.plot(pricing.Adj_Close, label='Spy Close')\n",
    "plt.xlabel('Date')\n",
    "plt.ylabel('Price')\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Date</th>\n",
       "      <th>Adj_Close</th>\n",
       "      <th>Adj_Open</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1993-01-29</td>\n",
       "      <td>27.112253</td>\n",
       "      <td>27.131505</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1993-02-01</td>\n",
       "      <td>27.305082</td>\n",
       "      <td>27.131502</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>1993-02-02</td>\n",
       "      <td>27.362904</td>\n",
       "      <td>27.285771</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>1993-02-03</td>\n",
       "      <td>27.652185</td>\n",
       "      <td>27.401472</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>1993-02-04</td>\n",
       "      <td>27.767893</td>\n",
       "      <td>27.748579</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "        Date  Adj_Close   Adj_Open\n",
       "0 1993-01-29  27.112253  27.131505\n",
       "1 1993-02-01  27.305082  27.131502\n",
       "2 1993-02-02  27.362904  27.285771\n",
       "3 1993-02-03  27.652185  27.401472\n",
       "4 1993-02-04  27.767893  27.748579"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pricing.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Shift the Adjusted Close down one row so that it aligns with the next day's Adjusted Open.  That way we can calculate the signals using the previous day's Close and enter the trade on the next day's Open"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Date</th>\n",
       "      <th>Adj_Close</th>\n",
       "      <th>Adj_Open</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>6508</th>\n",
       "      <td>2018-11-30</td>\n",
       "      <td>273.980011</td>\n",
       "      <td>273.809998</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6509</th>\n",
       "      <td>2018-12-03</td>\n",
       "      <td>275.649994</td>\n",
       "      <td>280.279999</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6510</th>\n",
       "      <td>2018-12-04</td>\n",
       "      <td>279.299988</td>\n",
       "      <td>278.369995</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6511</th>\n",
       "      <td>2018-12-06</td>\n",
       "      <td>270.250000</td>\n",
       "      <td>265.920013</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6512</th>\n",
       "      <td>2018-12-07</td>\n",
       "      <td>269.839996</td>\n",
       "      <td>269.459991</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "           Date   Adj_Close    Adj_Open\n",
       "6508 2018-11-30  273.980011  273.809998\n",
       "6509 2018-12-03  275.649994  280.279999\n",
       "6510 2018-12-04  279.299988  278.369995\n",
       "6511 2018-12-06  270.250000  265.920013\n",
       "6512 2018-12-07  269.839996  269.459991"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "stock=pricing.copy()\n",
    "stock.Adj_Close=stock.Adj_Close.shift(1)\n",
    "stock.tail()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create three or more separate blocks of data for testing. Reserve one of these for out of sample testing."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Date</th>\n",
       "      <th>Adj_Close</th>\n",
       "      <th>Adj_Open</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>2001-09-04</td>\n",
       "      <td>81.720024</td>\n",
       "      <td>81.505194</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2001-09-05</td>\n",
       "      <td>81.197357</td>\n",
       "      <td>81.397842</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2001-09-06</td>\n",
       "      <td>81.397842</td>\n",
       "      <td>80.646166</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>2001-09-07</td>\n",
       "      <td>79.300270</td>\n",
       "      <td>78.763331</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>2001-09-10</td>\n",
       "      <td>77.832664</td>\n",
       "      <td>77.102443</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "        Date  Adj_Close   Adj_Open\n",
       "0 2001-09-04  81.720024  81.505194\n",
       "1 2001-09-05  81.197357  81.397842\n",
       "2 2001-09-06  81.397842  80.646166\n",
       "3 2001-09-07  79.300270  78.763331\n",
       "4 2001-09-10  77.832664  77.102443"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "stock_1=stock.iloc[0:2170].copy()\n",
    "stock_2=stock.iloc[2170:4342].copy().reset_index(drop=True)\n",
    "stock_3=stock.iloc[4342:6513].copy().reset_index(drop=True) \n",
    "stock_2.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here is the code for the actual function which loops through the stock data and executes the trades.  You can experiment with different parameters such as changing the maximum position size or starting capital."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 358,
   "metadata": {
    "pixiedust": {
     "displayParams": {}
    }
   },
   "outputs": [],
   "source": [
    "# Trade using a simple trend following strategy\n",
    "def trade(stock, length):\n",
    "\n",
    "    temp_dict = {}\n",
    "    # If window length is 0, algorithm doesn't make sense, so exit\n",
    "    if length == 0:\n",
    "        return 0\n",
    "\n",
    "    # Compute rolling mean and rolling standard deviation\n",
    "    rolling_window = stock.Adj_Close.rolling(window=length)\n",
    "    mu = rolling_window.mean()\n",
    "    std = rolling_window.std()\n",
    "\n",
    "    #If you don't use a maximum position size the positions will keep on pyramidding.\n",
    "    #Set max_position to a high number (1000?) to disable this parameter\n",
    "    max_position =1\n",
    "    \n",
    "    #Slippage and commission adjustment  - simply reduces equity by a percentage guess\n",
    "    slippage_adj=0.99\n",
    "\n",
    "    # Compute the z-scores for each day using the historical data up to that day\n",
    "    zscores = (stock.Adj_Close - mu) / std\n",
    "\n",
    "    # Simulate trading\n",
    "    # Start with your chosen starting capital and no positions\n",
    "    money = 30\n",
    "    position_count = 0\n",
    "\n",
    "    for i, row in enumerate(stock.itertuples(),0):\n",
    "\n",
    "        # Sell short if the z-score is > 1\n",
    "        if zscores[i] >  1 and position_count < max_position:\n",
    "            money -= stock.Adj_Open[i] *(1/slippage_adj)\n",
    "            position_count += 1\n",
    "        # Buy long if the z-score is < 1\n",
    "        elif zscores[i] < -1 and position_count > max_position * -1:\n",
    "            # print (position_count)\n",
    "            money += stock.Adj_Open[i] *slippage_adj\n",
    "            position_count -= 1\n",
    "        # Clear positions if the z-score between -.5 and .5\n",
    "        elif abs(zscores[i]) < 0.5:\n",
    "            if position_count > 0:                \n",
    "                money += position_count * stock.Adj_Open[i]*slippage_adj  \n",
    "            elif position_count < 0: \n",
    "                money += position_count * stock.Adj_Open[i]*(1/slippage_adj)              \n",
    "            position_count = 0\n",
    "        #fill dictionary with the trading results.\n",
    "        temp_dict[stock.Date[i]] = [\n",
    "            stock.Adj_Open[i], stock.Adj_Close[i], mu[i], std[i], zscores[i],\n",
    "            money, position_count,stock.Adj_Open[i] *(1/slippage_adj),stock.Adj_Open[i] *slippage_adj\n",
    "        ]\n",
    "    #create a dataframe to return for use in calculating and charting the trading results\n",
    "    pr = pd.DataFrame(data=temp_dict).T\n",
    "    pr.index.name = 'Date'\n",
    "    pr.index = pd.to_datetime(pr.index)\n",
    "    pr.columns = [\n",
    "        'Open', 'Close', 'mu', 'std', 'zscores', 'money', 'position_count','buy_slippage','sell_slippage'\n",
    "    ]\n",
    "    pr['equity'] = pr.money + (pr.Open * pr.position_count)\n",
    "    #\n",
    "    return pr"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The next cell calls the function. Experiment with different moving averages by altering the number in brackets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 359,
   "metadata": {
    "pixiedust": {
     "displayParams": {}
    }
   },
   "outputs": [],
   "source": [
    "moving_average=200\n",
    "profit = trade(pricing, moving_average)\n",
    "profit.to_csv('../data/profit.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 360,
   "metadata": {},
   "outputs": [],
   "source": [
    "#copy_profit = pd.read_csv('../data/profit.csv',header=0,parse_dates=[\"Date\"],)\n",
    "#copy_profit.head(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 361,
   "metadata": {},
   "outputs": [],
   "source": [
    "series=profit[['equity']].copy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 362,
   "metadata": {},
   "outputs": [],
   "source": [
    "series=series[moving_average:-1]\n",
    "#series.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 363,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Stat                 equity\n",
      "-------------------  ----------\n",
      "Start                1993-11-12\n",
      "End                  2018-12-06\n",
      "Risk-free rate       0.00%\n",
      "\n",
      "Total Return         570.57%\n",
      "Daily Sharpe         0.51\n",
      "Daily Sortino        0.80\n",
      "CAGR                 7.89%\n",
      "Max Drawdown         -41.74%\n",
      "Calmar Ratio         0.19\n",
      "\n",
      "MTD                  0.00%\n",
      "3m                   -9.45%\n",
      "6m                   -3.04%\n",
      "YTD                  -5.11%\n",
      "1Y                   -2.08%\n",
      "3Y (ann.)            8.53%\n",
      "5Y (ann.)            5.32%\n",
      "10Y (ann.)           5.59%\n",
      "Since Incep. (ann.)  7.89%\n",
      "\n",
      "Daily Sharpe         0.51\n",
      "Daily Sortino        0.80\n",
      "Daily Mean (ann.)    9.27%\n",
      "Daily Vol (ann.)     18.25%\n",
      "Daily Skew           0.03\n",
      "Daily Kurt           7.84\n",
      "Best Day             9.72%\n",
      "Worst Day            -8.86%\n",
      "\n",
      "Monthly Sharpe       0.58\n",
      "Monthly Sortino      1.10\n",
      "Monthly Mean (ann.)  8.77%\n",
      "Monthly Vol (ann.)   15.21%\n",
      "Monthly Skew         0.26\n",
      "Monthly Kurt         1.19\n",
      "Best Month           16.21%\n",
      "Worst Month          -12.82%\n",
      "\n",
      "Yearly Sharpe        0.51\n",
      "Yearly Sortino       1.39\n",
      "Yearly Mean          9.34%\n",
      "Yearly Vol           18.30%\n",
      "Yearly Skew          0.06\n",
      "Yearly Kurt          -0.35\n",
      "Best Year            44.26%\n",
      "Worst Year           -30.42%\n",
      "\n",
      "Avg. Drawdown        -2.92%\n",
      "Avg. Drawdown Days   47.78\n",
      "Avg. Up Month        3.62%\n",
      "Avg. Down Month      -2.97%\n",
      "Win Year %           60.00%\n",
      "Win 12m %            70.45%\n"
     ]
    }
   ],
   "source": [
    "stats = series.calc_stats()\n",
    "stats.display()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 364,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "/* Put everything inside the global mpl namespace */\n",
       "window.mpl = {};\n",
       "\n",
       "\n",
       "mpl.get_websocket_type = function() {\n",
       "    if (typeof(WebSocket) !== 'undefined') {\n",
       "        return WebSocket;\n",
       "    } else if (typeof(MozWebSocket) !== 'undefined') {\n",
       "        return MozWebSocket;\n",
       "    } else {\n",
       "        alert('Your browser does not have WebSocket support.' +\n",
       "              'Please try Chrome, Safari or Firefox ≥ 6. ' +\n",
       "              'Firefox 4 and 5 are also supported but you ' +\n",
       "              'have to enable WebSockets in about:config.');\n",
       "    };\n",
       "}\n",
       "\n",
       "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n",
       "    this.id = figure_id;\n",
       "\n",
       "    this.ws = websocket;\n",
       "\n",
       "    this.supports_binary = (this.ws.binaryType != undefined);\n",
       "\n",
       "    if (!this.supports_binary) {\n",
       "        var warnings = document.getElementById(\"mpl-warnings\");\n",
       "        if (warnings) {\n",
       "            warnings.style.display = 'block';\n",
       "            warnings.textContent = (\n",
       "                \"This browser does not support binary websocket messages. \" +\n",
       "                    \"Performance may be slow.\");\n",
       "        }\n",
       "    }\n",
       "\n",
       "    this.imageObj = new Image();\n",
       "\n",
       "    this.context = undefined;\n",
       "    this.message = undefined;\n",
       "    this.canvas = undefined;\n",
       "    this.rubberband_canvas = undefined;\n",
       "    this.rubberband_context = undefined;\n",
       "    this.format_dropdown = undefined;\n",
       "\n",
       "    this.image_mode = 'full';\n",
       "\n",
       "    this.root = $('<div/>');\n",
       "    this._root_extra_style(this.root)\n",
       "    this.root.attr('style', 'display: inline-block');\n",
       "\n",
       "    $(parent_element).append(this.root);\n",
       "\n",
       "    this._init_header(this);\n",
       "    this._init_canvas(this);\n",
       "    this._init_toolbar(this);\n",
       "\n",
       "    var fig = this;\n",
       "\n",
       "    this.waiting = false;\n",
       "\n",
       "    this.ws.onopen =  function () {\n",
       "            fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n",
       "            fig.send_message(\"send_image_mode\", {});\n",
       "            if (mpl.ratio != 1) {\n",
       "                fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.ratio});\n",
       "            }\n",
       "            fig.send_message(\"refresh\", {});\n",
       "        }\n",
       "\n",
       "    this.imageObj.onload = function() {\n",
       "            if (fig.image_mode == 'full') {\n",
       "                // Full images could contain transparency (where diff images\n",
       "                // almost always do), so we need to clear the canvas so that\n",
       "                // there is no ghosting.\n",
       "                fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n",
       "            }\n",
       "            fig.context.drawImage(fig.imageObj, 0, 0);\n",
       "        };\n",
       "\n",
       "    this.imageObj.onunload = function() {\n",
       "        fig.ws.close();\n",
       "    }\n",
       "\n",
       "    this.ws.onmessage = this._make_on_message_function(this);\n",
       "\n",
       "    this.ondownload = ondownload;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_header = function() {\n",
       "    var titlebar = $(\n",
       "        '<div class=\"ui-dialog-titlebar ui-widget-header ui-corner-all ' +\n",
       "        'ui-helper-clearfix\"/>');\n",
       "    var titletext = $(\n",
       "        '<div class=\"ui-dialog-title\" style=\"width: 100%; ' +\n",
       "        'text-align: center; padding: 3px;\"/>');\n",
       "    titlebar.append(titletext)\n",
       "    this.root.append(titlebar);\n",
       "    this.header = titletext[0];\n",
       "}\n",
       "\n",
       "\n",
       "\n",
       "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n",
       "\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n",
       "\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_canvas = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var canvas_div = $('<div/>');\n",
       "\n",
       "    canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n",
       "\n",
       "    function canvas_keyboard_event(event) {\n",
       "        return fig.key_event(event, event['data']);\n",
       "    }\n",
       "\n",
       "    canvas_div.keydown('key_press', canvas_keyboard_event);\n",
       "    canvas_div.keyup('key_release', canvas_keyboard_event);\n",
       "    this.canvas_div = canvas_div\n",
       "    this._canvas_extra_style(canvas_div)\n",
       "    this.root.append(canvas_div);\n",
       "\n",
       "    var canvas = $('<canvas/>');\n",
       "    canvas.addClass('mpl-canvas');\n",
       "    canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n",
       "\n",
       "    this.canvas = canvas[0];\n",
       "    this.context = canvas[0].getContext(\"2d\");\n",
       "\n",
       "    var backingStore = this.context.backingStorePixelRatio ||\n",
       "\tthis.context.webkitBackingStorePixelRatio ||\n",
       "\tthis.context.mozBackingStorePixelRatio ||\n",
       "\tthis.context.msBackingStorePixelRatio ||\n",
       "\tthis.context.oBackingStorePixelRatio ||\n",
       "\tthis.context.backingStorePixelRatio || 1;\n",
       "\n",
       "    mpl.ratio = (window.devicePixelRatio || 1) / backingStore;\n",
       "\n",
       "    var rubberband = $('<canvas/>');\n",
       "    rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n",
       "\n",
       "    var pass_mouse_events = true;\n",
       "\n",
       "    canvas_div.resizable({\n",
       "        start: function(event, ui) {\n",
       "            pass_mouse_events = false;\n",
       "        },\n",
       "        resize: function(event, ui) {\n",
       "            fig.request_resize(ui.size.width, ui.size.height);\n",
       "        },\n",
       "        stop: function(event, ui) {\n",
       "            pass_mouse_events = true;\n",
       "            fig.request_resize(ui.size.width, ui.size.height);\n",
       "        },\n",
       "    });\n",
       "\n",
       "    function mouse_event_fn(event) {\n",
       "        if (pass_mouse_events)\n",
       "            return fig.mouse_event(event, event['data']);\n",
       "    }\n",
       "\n",
       "    rubberband.mousedown('button_press', mouse_event_fn);\n",
       "    rubberband.mouseup('button_release', mouse_event_fn);\n",
       "    // Throttle sequential mouse events to 1 every 20ms.\n",
       "    rubberband.mousemove('motion_notify', mouse_event_fn);\n",
       "\n",
       "    rubberband.mouseenter('figure_enter', mouse_event_fn);\n",
       "    rubberband.mouseleave('figure_leave', mouse_event_fn);\n",
       "\n",
       "    canvas_div.on(\"wheel\", function (event) {\n",
       "        event = event.originalEvent;\n",
       "        event['data'] = 'scroll'\n",
       "        if (event.deltaY < 0) {\n",
       "            event.step = 1;\n",
       "        } else {\n",
       "            event.step = -1;\n",
       "        }\n",
       "        mouse_event_fn(event);\n",
       "    });\n",
       "\n",
       "    canvas_div.append(canvas);\n",
       "    canvas_div.append(rubberband);\n",
       "\n",
       "    this.rubberband = rubberband;\n",
       "    this.rubberband_canvas = rubberband[0];\n",
       "    this.rubberband_context = rubberband[0].getContext(\"2d\");\n",
       "    this.rubberband_context.strokeStyle = \"#000000\";\n",
       "\n",
       "    this._resize_canvas = function(width, height) {\n",
       "        // Keep the size of the canvas, canvas container, and rubber band\n",
       "        // canvas in synch.\n",
       "        canvas_div.css('width', width)\n",
       "        canvas_div.css('height', height)\n",
       "\n",
       "        canvas.attr('width', width * mpl.ratio);\n",
       "        canvas.attr('height', height * mpl.ratio);\n",
       "        canvas.attr('style', 'width: ' + width + 'px; height: ' + height + 'px;');\n",
       "\n",
       "        rubberband.attr('width', width);\n",
       "        rubberband.attr('height', height);\n",
       "    }\n",
       "\n",
       "    // Set the figure to an initial 600x600px, this will subsequently be updated\n",
       "    // upon first draw.\n",
       "    this._resize_canvas(600, 600);\n",
       "\n",
       "    // Disable right mouse context menu.\n",
       "    $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n",
       "        return false;\n",
       "    });\n",
       "\n",
       "    function set_focus () {\n",
       "        canvas.focus();\n",
       "        canvas_div.focus();\n",
       "    }\n",
       "\n",
       "    window.setTimeout(set_focus, 100);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_toolbar = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var nav_element = $('<div/>')\n",
       "    nav_element.attr('style', 'width: 100%');\n",
       "    this.root.append(nav_element);\n",
       "\n",
       "    // Define a callback function for later on.\n",
       "    function toolbar_event(event) {\n",
       "        return fig.toolbar_button_onclick(event['data']);\n",
       "    }\n",
       "    function toolbar_mouse_event(event) {\n",
       "        return fig.toolbar_button_onmouseover(event['data']);\n",
       "    }\n",
       "\n",
       "    for(var toolbar_ind in mpl.toolbar_items) {\n",
       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
       "\n",
       "        if (!name) {\n",
       "            // put a spacer in here.\n",
       "            continue;\n",
       "        }\n",
       "        var button = $('<button/>');\n",
       "        button.addClass('ui-button ui-widget ui-state-default ui-corner-all ' +\n",
       "                        'ui-button-icon-only');\n",
       "        button.attr('role', 'button');\n",
       "        button.attr('aria-disabled', 'false');\n",
       "        button.click(method_name, toolbar_event);\n",
       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
       "\n",
       "        var icon_img = $('<span/>');\n",
       "        icon_img.addClass('ui-button-icon-primary ui-icon');\n",
       "        icon_img.addClass(image);\n",
       "        icon_img.addClass('ui-corner-all');\n",
       "\n",
       "        var tooltip_span = $('<span/>');\n",
       "        tooltip_span.addClass('ui-button-text');\n",
       "        tooltip_span.html(tooltip);\n",
       "\n",
       "        button.append(icon_img);\n",
       "        button.append(tooltip_span);\n",
       "\n",
       "        nav_element.append(button);\n",
       "    }\n",
       "\n",
       "    var fmt_picker_span = $('<span/>');\n",
       "\n",
       "    var fmt_picker = $('<select/>');\n",
       "    fmt_picker.addClass('mpl-toolbar-option ui-widget ui-widget-content');\n",
       "    fmt_picker_span.append(fmt_picker);\n",
       "    nav_element.append(fmt_picker_span);\n",
       "    this.format_dropdown = fmt_picker[0];\n",
       "\n",
       "    for (var ind in mpl.extensions) {\n",
       "        var fmt = mpl.extensions[ind];\n",
       "        var option = $(\n",
       "            '<option/>', {selected: fmt === mpl.default_extension}).html(fmt);\n",
       "        fmt_picker.append(option)\n",
       "    }\n",
       "\n",
       "    // Add hover states to the ui-buttons\n",
       "    $( \".ui-button\" ).hover(\n",
       "        function() { $(this).addClass(\"ui-state-hover\");},\n",
       "        function() { $(this).removeClass(\"ui-state-hover\");}\n",
       "    );\n",
       "\n",
       "    var status_bar = $('<span class=\"mpl-message\"/>');\n",
       "    nav_element.append(status_bar);\n",
       "    this.message = status_bar[0];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.request_resize = function(x_pixels, y_pixels) {\n",
       "    // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n",
       "    // which will in turn request a refresh of the image.\n",
       "    this.send_message('resize', {'width': x_pixels, 'height': y_pixels});\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.send_message = function(type, properties) {\n",
       "    properties['type'] = type;\n",
       "    properties['figure_id'] = this.id;\n",
       "    this.ws.send(JSON.stringify(properties));\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.send_draw_message = function() {\n",
       "    if (!this.waiting) {\n",
       "        this.waiting = true;\n",
       "        this.ws.send(JSON.stringify({type: \"draw\", figure_id: this.id}));\n",
       "    }\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype.handle_save = function(fig, msg) {\n",
       "    var format_dropdown = fig.format_dropdown;\n",
       "    var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n",
       "    fig.ondownload(fig, format);\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype.handle_resize = function(fig, msg) {\n",
       "    var size = msg['size'];\n",
       "    if (size[0] != fig.canvas.width || size[1] != fig.canvas.height) {\n",
       "        fig._resize_canvas(size[0], size[1]);\n",
       "        fig.send_message(\"refresh\", {});\n",
       "    };\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_rubberband = function(fig, msg) {\n",
       "    var x0 = msg['x0'] / mpl.ratio;\n",
       "    var y0 = (fig.canvas.height - msg['y0']) / mpl.ratio;\n",
       "    var x1 = msg['x1'] / mpl.ratio;\n",
       "    var y1 = (fig.canvas.height - msg['y1']) / mpl.ratio;\n",
       "    x0 = Math.floor(x0) + 0.5;\n",
       "    y0 = Math.floor(y0) + 0.5;\n",
       "    x1 = Math.floor(x1) + 0.5;\n",
       "    y1 = Math.floor(y1) + 0.5;\n",
       "    var min_x = Math.min(x0, x1);\n",
       "    var min_y = Math.min(y0, y1);\n",
       "    var width = Math.abs(x1 - x0);\n",
       "    var height = Math.abs(y1 - y0);\n",
       "\n",
       "    fig.rubberband_context.clearRect(\n",
       "        0, 0, fig.canvas.width, fig.canvas.height);\n",
       "\n",
       "    fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_figure_label = function(fig, msg) {\n",
       "    // Updates the figure title.\n",
       "    fig.header.textContent = msg['label'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_cursor = function(fig, msg) {\n",
       "    var cursor = msg['cursor'];\n",
       "    switch(cursor)\n",
       "    {\n",
       "    case 0:\n",
       "        cursor = 'pointer';\n",
       "        break;\n",
       "    case 1:\n",
       "        cursor = 'default';\n",
       "        break;\n",
       "    case 2:\n",
       "        cursor = 'crosshair';\n",
       "        break;\n",
       "    case 3:\n",
       "        cursor = 'move';\n",
       "        break;\n",
       "    }\n",
       "    fig.rubberband_canvas.style.cursor = cursor;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_message = function(fig, msg) {\n",
       "    fig.message.textContent = msg['message'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_draw = function(fig, msg) {\n",
       "    // Request the server to send over a new figure.\n",
       "    fig.send_draw_message();\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_image_mode = function(fig, msg) {\n",
       "    fig.image_mode = msg['mode'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.updated_canvas_event = function() {\n",
       "    // Called whenever the canvas gets updated.\n",
       "    this.send_message(\"ack\", {});\n",
       "}\n",
       "\n",
       "// A function to construct a web socket function for onmessage handling.\n",
       "// Called in the figure constructor.\n",
       "mpl.figure.prototype._make_on_message_function = function(fig) {\n",
       "    return function socket_on_message(evt) {\n",
       "        if (evt.data instanceof Blob) {\n",
       "            /* FIXME: We get \"Resource interpreted as Image but\n",
       "             * transferred with MIME type text/plain:\" errors on\n",
       "             * Chrome.  But how to set the MIME type?  It doesn't seem\n",
       "             * to be part of the websocket stream */\n",
       "            evt.data.type = \"image/png\";\n",
       "\n",
       "            /* Free the memory for the previous frames */\n",
       "            if (fig.imageObj.src) {\n",
       "                (window.URL || window.webkitURL).revokeObjectURL(\n",
       "                    fig.imageObj.src);\n",
       "            }\n",
       "\n",
       "            fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n",
       "                evt.data);\n",
       "            fig.updated_canvas_event();\n",
       "            fig.waiting = false;\n",
       "            return;\n",
       "        }\n",
       "        else if (typeof evt.data === 'string' && evt.data.slice(0, 21) == \"data:image/png;base64\") {\n",
       "            fig.imageObj.src = evt.data;\n",
       "            fig.updated_canvas_event();\n",
       "            fig.waiting = false;\n",
       "            return;\n",
       "        }\n",
       "\n",
       "        var msg = JSON.parse(evt.data);\n",
       "        var msg_type = msg['type'];\n",
       "\n",
       "        // Call the  \"handle_{type}\" callback, which takes\n",
       "        // the figure and JSON message as its only arguments.\n",
       "        try {\n",
       "            var callback = fig[\"handle_\" + msg_type];\n",
       "        } catch (e) {\n",
       "            console.log(\"No handler for the '\" + msg_type + \"' message type: \", msg);\n",
       "            return;\n",
       "        }\n",
       "\n",
       "        if (callback) {\n",
       "            try {\n",
       "                // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n",
       "                callback(fig, msg);\n",
       "            } catch (e) {\n",
       "                console.log(\"Exception inside the 'handler_\" + msg_type + \"' callback:\", e, e.stack, msg);\n",
       "            }\n",
       "        }\n",
       "    };\n",
       "}\n",
       "\n",
       "// from http://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n",
       "mpl.findpos = function(e) {\n",
       "    //this section is from http://www.quirksmode.org/js/events_properties.html\n",
       "    var targ;\n",
       "    if (!e)\n",
       "        e = window.event;\n",
       "    if (e.target)\n",
       "        targ = e.target;\n",
       "    else if (e.srcElement)\n",
       "        targ = e.srcElement;\n",
       "    if (targ.nodeType == 3) // defeat Safari bug\n",
       "        targ = targ.parentNode;\n",
       "\n",
       "    // jQuery normalizes the pageX and pageY\n",
       "    // pageX,Y are the mouse positions relative to the document\n",
       "    // offset() returns the position of the element relative to the document\n",
       "    var x = e.pageX - $(targ).offset().left;\n",
       "    var y = e.pageY - $(targ).offset().top;\n",
       "\n",
       "    return {\"x\": x, \"y\": y};\n",
       "};\n",
       "\n",
       "/*\n",
       " * return a copy of an object with only non-object keys\n",
       " * we need this to avoid circular references\n",
       " * http://stackoverflow.com/a/24161582/3208463\n",
       " */\n",
       "function simpleKeys (original) {\n",
       "  return Object.keys(original).reduce(function (obj, key) {\n",
       "    if (typeof original[key] !== 'object')\n",
       "        obj[key] = original[key]\n",
       "    return obj;\n",
       "  }, {});\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.mouse_event = function(event, name) {\n",
       "    var canvas_pos = mpl.findpos(event)\n",
       "\n",
       "    if (name === 'button_press')\n",
       "    {\n",
       "        this.canvas.focus();\n",
       "        this.canvas_div.focus();\n",
       "    }\n",
       "\n",
       "    var x = canvas_pos.x * mpl.ratio;\n",
       "    var y = canvas_pos.y * mpl.ratio;\n",
       "\n",
       "    this.send_message(name, {x: x, y: y, button: event.button,\n",
       "                             step: event.step,\n",
       "                             guiEvent: simpleKeys(event)});\n",
       "\n",
       "    /* This prevents the web browser from automatically changing to\n",
       "     * the text insertion cursor when the button is pressed.  We want\n",
       "     * to control all of the cursor setting manually through the\n",
       "     * 'cursor' event from matplotlib */\n",
       "    event.preventDefault();\n",
       "    return false;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._key_event_extra = function(event, name) {\n",
       "    // Handle any extra behaviour associated with a key event\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.key_event = function(event, name) {\n",
       "\n",
       "    // Prevent repeat events\n",
       "    if (name == 'key_press')\n",
       "    {\n",
       "        if (event.which === this._key)\n",
       "            return;\n",
       "        else\n",
       "            this._key = event.which;\n",
       "    }\n",
       "    if (name == 'key_release')\n",
       "        this._key = null;\n",
       "\n",
       "    var value = '';\n",
       "    if (event.ctrlKey && event.which != 17)\n",
       "        value += \"ctrl+\";\n",
       "    if (event.altKey && event.which != 18)\n",
       "        value += \"alt+\";\n",
       "    if (event.shiftKey && event.which != 16)\n",
       "        value += \"shift+\";\n",
       "\n",
       "    value += 'k';\n",
       "    value += event.which.toString();\n",
       "\n",
       "    this._key_event_extra(event, name);\n",
       "\n",
       "    this.send_message(name, {key: value,\n",
       "                             guiEvent: simpleKeys(event)});\n",
       "    return false;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.toolbar_button_onclick = function(name) {\n",
       "    if (name == 'download') {\n",
       "        this.handle_save(this, null);\n",
       "    } else {\n",
       "        this.send_message(\"toolbar_button\", {name: name});\n",
       "    }\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.toolbar_button_onmouseover = function(tooltip) {\n",
       "    this.message.textContent = tooltip;\n",
       "};\n",
       "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to  previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Pan axes with left mouse, zoom with right\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n",
       "\n",
       "mpl.extensions = [\"eps\", \"jpeg\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\", \"tif\"];\n",
       "\n",
       "mpl.default_extension = \"png\";var comm_websocket_adapter = function(comm) {\n",
       "    // Create a \"websocket\"-like object which calls the given IPython comm\n",
       "    // object with the appropriate methods. Currently this is a non binary\n",
       "    // socket, so there is still some room for performance tuning.\n",
       "    var ws = {};\n",
       "\n",
       "    ws.close = function() {\n",
       "        comm.close()\n",
       "    };\n",
       "    ws.send = function(m) {\n",
       "        //console.log('sending', m);\n",
       "        comm.send(m);\n",
       "    };\n",
       "    // Register the callback with on_msg.\n",
       "    comm.on_msg(function(msg) {\n",
       "        //console.log('receiving', msg['content']['data'], msg);\n",
       "        // Pass the mpl event to the overridden (by mpl) onmessage function.\n",
       "        ws.onmessage(msg['content']['data'])\n",
       "    });\n",
       "    return ws;\n",
       "}\n",
       "\n",
       "mpl.mpl_figure_comm = function(comm, msg) {\n",
       "    // This is the function which gets called when the mpl process\n",
       "    // starts-up an IPython Comm through the \"matplotlib\" channel.\n",
       "\n",
       "    var id = msg.content.data.id;\n",
       "    // Get hold of the div created by the display call when the Comm\n",
       "    // socket was opened in Python.\n",
       "    var element = $(\"#\" + id);\n",
       "    var ws_proxy = comm_websocket_adapter(comm)\n",
       "\n",
       "    function ondownload(figure, format) {\n",
       "        window.open(figure.imageObj.src);\n",
       "    }\n",
       "\n",
       "    var fig = new mpl.figure(id, ws_proxy,\n",
       "                           ondownload,\n",
       "                           element.get(0));\n",
       "\n",
       "    // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n",
       "    // web socket which is closed, not our websocket->open comm proxy.\n",
       "    ws_proxy.onopen();\n",
       "\n",
       "    fig.parent_element = element.get(0);\n",
       "    fig.cell_info = mpl.find_output_cell(\"<div id='\" + id + \"'></div>\");\n",
       "    if (!fig.cell_info) {\n",
       "        console.error(\"Failed to find cell for figure\", id, fig);\n",
       "        return;\n",
       "    }\n",
       "\n",
       "    var output_index = fig.cell_info[2]\n",
       "    var cell = fig.cell_info[0];\n",
       "\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_close = function(fig, msg) {\n",
       "    var width = fig.canvas.width/mpl.ratio\n",
       "    fig.root.unbind('remove')\n",
       "\n",
       "    // Update the output cell to use the data from the current canvas.\n",
       "    fig.push_to_output();\n",
       "    var dataURL = fig.canvas.toDataURL();\n",
       "    // Re-enable the keyboard manager in IPython - without this line, in FF,\n",
       "    // the notebook keyboard shortcuts fail.\n",
       "    IPython.keyboard_manager.enable()\n",
       "    $(fig.parent_element).html('<img src=\"' + dataURL + '\" width=\"' + width + '\">');\n",
       "    fig.close_ws(fig, msg);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.close_ws = function(fig, msg){\n",
       "    fig.send_message('closing', msg);\n",
       "    // fig.ws.close()\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.push_to_output = function(remove_interactive) {\n",
       "    // Turn the data on the canvas into data in the output cell.\n",
       "    var width = this.canvas.width/mpl.ratio\n",
       "    var dataURL = this.canvas.toDataURL();\n",
       "    this.cell_info[1]['text/html'] = '<img src=\"' + dataURL + '\" width=\"' + width + '\">';\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.updated_canvas_event = function() {\n",
       "    // Tell IPython that the notebook contents must change.\n",
       "    IPython.notebook.set_dirty(true);\n",
       "    this.send_message(\"ack\", {});\n",
       "    var fig = this;\n",
       "    // Wait a second, then push the new image to the DOM so\n",
       "    // that it is saved nicely (might be nice to debounce this).\n",
       "    setTimeout(function () { fig.push_to_output() }, 1000);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_toolbar = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var nav_element = $('<div/>')\n",
       "    nav_element.attr('style', 'width: 100%');\n",
       "    this.root.append(nav_element);\n",
       "\n",
       "    // Define a callback function for later on.\n",
       "    function toolbar_event(event) {\n",
       "        return fig.toolbar_button_onclick(event['data']);\n",
       "    }\n",
       "    function toolbar_mouse_event(event) {\n",
       "        return fig.toolbar_button_onmouseover(event['data']);\n",
       "    }\n",
       "\n",
       "    for(var toolbar_ind in mpl.toolbar_items){\n",
       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
       "\n",
       "        if (!name) { continue; };\n",
       "\n",
       "        var button = $('<button class=\"btn btn-default\" href=\"#\" title=\"' + name + '\"><i class=\"fa ' + image + ' fa-lg\"></i></button>');\n",
       "        button.click(method_name, toolbar_event);\n",
       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
       "        nav_element.append(button);\n",
       "    }\n",
       "\n",
       "    // Add the status bar.\n",
       "    var status_bar = $('<span class=\"mpl-message\" style=\"text-align:right; float: right;\"/>');\n",
       "    nav_element.append(status_bar);\n",
       "    this.message = status_bar[0];\n",
       "\n",
       "    // Add the close button to the window.\n",
       "    var buttongrp = $('<div class=\"btn-group inline pull-right\"></div>');\n",
       "    var button = $('<button class=\"btn btn-mini btn-primary\" href=\"#\" title=\"Stop Interaction\"><i class=\"fa fa-power-off icon-remove icon-large\"></i></button>');\n",
       "    button.click(function (evt) { fig.handle_close(fig, {}); } );\n",
       "    button.mouseover('Stop Interaction', toolbar_mouse_event);\n",
       "    buttongrp.append(button);\n",
       "    var titlebar = this.root.find($('.ui-dialog-titlebar'));\n",
       "    titlebar.prepend(buttongrp);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._root_extra_style = function(el){\n",
       "    var fig = this\n",
       "    el.on(\"remove\", function(){\n",
       "\tfig.close_ws(fig, {});\n",
       "    });\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._canvas_extra_style = function(el){\n",
       "    // this is important to make the div 'focusable\n",
       "    el.attr('tabindex', 0)\n",
       "    // reach out to IPython and tell the keyboard manager to turn it's self\n",
       "    // off when our div gets focus\n",
       "\n",
       "    // location in version 3\n",
       "    if (IPython.notebook.keyboard_manager) {\n",
       "        IPython.notebook.keyboard_manager.register_events(el);\n",
       "    }\n",
       "    else {\n",
       "        // location in version 2\n",
       "        IPython.keyboard_manager.register_events(el);\n",
       "    }\n",
       "\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._key_event_extra = function(event, name) {\n",
       "    var manager = IPython.notebook.keyboard_manager;\n",
       "    if (!manager)\n",
       "        manager = IPython.keyboard_manager;\n",
       "\n",
       "    // Check for shift+enter\n",
       "    if (event.shiftKey && event.which == 13) {\n",
       "        this.canvas_div.blur();\n",
       "        event.shiftKey = false;\n",
       "        // Send a \"J\" for go to next cell\n",
       "        event.which = 74;\n",
       "        event.keyCode = 74;\n",
       "        manager.command_mode();\n",
       "        manager.handle_keydown(event);\n",
       "    }\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_save = function(fig, msg) {\n",
       "    fig.ondownload(fig, null);\n",
       "}\n",
       "\n",
       "\n",
       "mpl.find_output_cell = function(html_output) {\n",
       "    // Return the cell and output element which can be found *uniquely* in the notebook.\n",
       "    // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n",
       "    // IPython event is triggered only after the cells have been serialised, which for\n",
       "    // our purposes (turning an active figure into a static one), is too late.\n",
       "    var cells = IPython.notebook.get_cells();\n",
       "    var ncells = cells.length;\n",
       "    for (var i=0; i<ncells; i++) {\n",
       "        var cell = cells[i];\n",
       "        if (cell.cell_type === 'code'){\n",
       "            for (var j=0; j<cell.output_area.outputs.length; j++) {\n",
       "                var data = cell.output_area.outputs[j];\n",
       "                if (data.data) {\n",
       "                    // IPython >= 3 moved mimebundle to data attribute of output\n",
       "                    data = data.data;\n",
       "                }\n",
       "                if (data['text/html'] == html_output) {\n",
       "                    return [cell, data, j];\n",
       "                }\n",
       "            }\n",
       "        }\n",
       "    }\n",
       "}\n",
       "\n",
       "// Register the function which deals with the matplotlib target/channel.\n",
       "// The kernel may be null if the page has been refreshed.\n",
       "if (IPython.notebook.kernel != null) {\n",
       "    IPython.notebook.kernel.comm_manager.register_target('matplotlib', mpl.mpl_figure_comm);\n",
       "}\n"
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<img src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAoAAAAHgCAYAAAA10dzkAAAgAElEQVR4XuxdB7QUNRe+VCnSq/Tee++9WxBUUBQFRcAuICggCEhRUUBFRECKCIiA/ljovffee++9Sec/d/Zl3928zExmZnffg3dzjufI2ySTfMkk3yT3fjfOgwcPHgAnRoARYAQYAUaAEWAEGIFYg0AcJoCxZqy5o4wAI8AIMAKMACPACBgIMAHkicAIMAKMACPACDACjEAsQ4AJYCwbcO4uI8AIMAKMACPACDACTAB5DjACjAAjwAgwAowAIxDLEGACGMsGnLvLCDACjAAjwAgwAowAE0CeA4wAI8AIMAKMACPACMQyBJgAxrIB5+4yAowAI8AIMAKMACPABJDnACPACDACjAAjwAgwArEMASaAsWzAubuMACPACDACjAAjwAgwAeQ5wAgwAowAI8AIMAKMQCxDgAlgLBtw7i4jwAgwAowAI8AIMAJMAHkOMAKMACPACDACjAAjEMsQYAIYywacu8sIMAKMACPACDACjAATQJ4DjAAjwAgwAowAI8AIxDIEmADGsgHn7jICjAAjwAgwAowAI8AEkOcAI8AIMAKMACPACDACsQwBJoCxbMC5u4wAI8AIMAKMACPACDAB5DnACDACjAAjwAgwAoxALEOACWAsG3DuLiPACDACjAAjwAgwAkwAeQ4wAowAI8AIMAKMACMQyxBgAhjLBpy7ywgwAowAI8AIMAKMABNAngOMACPACDACjAAjwAjEMgSYAMayAefuMgKMACPACDACjAAjwASQ5wAjwAgwAowAI8AIMAKxDAEmgLFswLm7jAAjwAgwAowAI8AIMAHkOcAIMAKMACPACDACjEAsQ4AJYCwbcO4uI8AIMAKMACPACDACTAB5DjACjAAjwAgwAowAIxDLEGACGMsGnLvLCDACjAAjwAgwAowAE0CeA4wAI8AIMAKMACPACMQyBJgAxrIB5+4yAowAI8AIMAKMACPABJDnACPACDACjAAjwAgwArEMASaAsWzAubuMACPACDACjAAjwAgwAeQ5wAgwAowAI8AIMAKMQCxDgAlgLBtw7i4jwAgwAowAI8AIMAJMAHkOMAKMACPACDACjAAjEMsQYAIYywacu8sIMAKMACPACDACjAATQJ4DjAAjwAgwAowAI8AIxDIEmADGsgHn7jICjAAjwAgwAowAI8AEkOcAI8AIMAKMACPACDACsQwBJoCxbMC5u4wAI8AIMAKMACPACDAB5DnACDACjAAjwAgwAoxALEOACWAsG3DuLiPACDACjAAjwAgwAkwAeQ4wAowAI8AIMAKMACMQyxBgAhjLBpy7ywgwAowAI8AIMAKMABNAngOMACPACDACjAAjwAjEMgSYAMayAefuMgKMACPACDACjAAjwASQ5wAjwAgwAowAI8AIMAKxDAEmgLFswLm7jAAjwAgwAowAI8AIMAHkOcAIMAKMACPACDACjEAsQ4AJYCwbcO4uI8AIMAKMACPACDACTAB5DjACjAAjwAgwAowAIxDLEGACGMsGnLvLCDACjAAjwAgwAowAE0CeA4wAI8AIMAKMACPACMQyBJgAxrIB5+4yAowAI8AIMAKMACPABJDnACPACDACjAAjwAgwArEMASaAHgb8/v37cOLECUiWLBnEiRPHQ01clBFgBBgBRoARYATChcCDBw/g6tWrkClTJogbN264HhujnsME0MNwHDt2DLJmzeqhBi7KCDACjAAjwAgwAtGFwNGjRyFLlizR9fhofS4TQA/wX758GVKmTAk4gZInT+6hJi7KCDACjAAjwAgwAuFC4MqVK8YBzqVLlyBFihThemyMeg4TQA/DgRMIJw4SQSaAHoDkoowAI8AIMAKMQBgR4P0bgAmghwnHE8gDeFyUEWAEGAFGgBGIJgR4/2YC6Gnq8QTyBB8XZgQYAUaAEWAEogUB3r+ZAHqaeDyBPMHHhRkBRoARYAQYgWhBgPdvJoCeJh5PIE/wcWFGgBFgBBgBRiBaEOD9mwmgp4nHE8gTfFyYEWAEGAFGgBGIFgR4/2YC6Gni8QTyBB8XZgQYAUaAEWAEogUB3r+ZAHqaeDyBPMHHhRkBRoARYAQYgWhBgPfvR4wADhs2DAYOHAgnT56EwoULw5AhQ6Bq1aqmk2vatGnQo0cP2L9/P+TOnRv69esHTZo00Z6MPIG0oeKMjAAjwAgwAoxAjEGA9+9HiABOnjwZWrZsCUgCK1euDD/99BOMGjUKduzYAdmyZYsy6VauXGmQw88//9wgfX/++Sf07NkTli1bBuXLl9eapDyBtGDiTIwAI8AIMAKMQIxCgPfvR4gAImkrVaoU/Pjjj/5JVrBgQXj22WdhwIABUSZe8+bNASfAzJkz/b81aNAAUqVKBZMmTdKaqDyBtGDiTIwAI8AIMAKMQIxCgPfvR4QA3r59G5IkSQJTpkwJuML94IMPYNOmTbB48eIoEw9PBTt06GD8J9LgwYONa+PDhw8rJ+qtW7cA/xNJxBIMdii4OdtPQdvx6/3PiRc3DtQvnAG6NSoIWVIlCfpLdOP2XXhp5GrYfPSSUXf+DMngq+eLwUsjV8Gtu/fh3v0HAc9sVSkHjF1xyPjbks41IVuaJHD26i0o22+e8bfp71SG4llTRmnnhiMXoemwFcbfP25QAL6ctcufB+vsUDcfpEicwPhbr7+2+5+B/x73ejkomDEZVPpiAXzTrDg0LpE5oP7z125B6b6+52Oa06Ea5MuQDC5cvw2lPp9r/O3zZ4tAywrZlfhtPXYZJqw+DCmTJISCTySDD37b5M/XoHBG6NekCHw8bSvM23naaEv1fOmCPg6xoUJ5bneqmw/erZUH4sSJ89B1//KNO8acv33vPrxcPhtMXHMEHkS8Kht71IVUSRPC5f/uwLsTN8DSveegUdGMMGPrKRjbuizUyJ/etL84D9M9/hiUy5kaRi8/BM+VygzZ0yRV5r904za8MHwl7D1zDWrmTwf5MyaHKnnSQpW8aY38s7efgnbj18NL5bJC/yZFHeO8Yv85WLn/PLxVIzesP3wRWv68xt+OVV1rQ8YUiR66cdNt8NK9Z43+ZkqRCH54uRQ0GbYCKudJA8v3nY9SRce6+WDQ3D1QOFNyqFMwA1TIlQbem7QBzl277c/brEwW+H3dMaO+Ma3LQf6MyYzfHjx4AKev3DKwHDx3D4xefhAWfVQDNh65BG1+WWfkmfhmeYgXJ44xJ6L7XcG18umhy/z9wrmVLlkiGL54P9y+e18Jb7tquaBro4K60IclHxPAR4QAnjhxAjJnzgzLly+HSpUq+SdP//79Ydy4cbB79+4oEyphwoQwduxYaNGihf+3iRMnQuvWrQNIHi3Yq1cv6N27d5S6gk0AcVNBQiUnXOBx4Qh26j9jJ4xYcsB1tYe+eBJyd5sRQBTxb3LK8cm/ls9oWiozDGpWAs5cvQnl+s23zCvXL9edJVViWPZxLZD/rmoXPsiubQUyJoNdp67622RWj2sQY0lBFc6jXi0DdQpleOgQkOc87UDFXGlgUtsK8N38vQYxkJPZ/Nl35hrUGeT7YK1XKAPM2XHa+Cja/Fk9JT5ILv/ZctK0for37A+r+UmHLtiifK+nC0Gvv3cEFMuQ/DFY3a2OblUPXT67NcFrh8Qc6Pj7Jvhjw3F4oXQWmLL+mGW1w14uBY2KPuH10Z7Ku8Vl4Uc1IGda9YeMpwa5LMwE8BEjgCtWrICKFSv6pwM6dYwfPx527Yo8aRI/IgFEcvjSSy/580+YMAHeeOMNuHnzpnJKhesEUD79oo0JBfFoNnwlrDl0weVrBIBt0iFadgtH9jRJYHHnmnD4/HWoPnCRJwKIhXXbpUMAdTdw1yDGgoJ4Gla895woPe3TuDC8WjHHQ4eA3XzG+ffhbxvhf5tOaBNAPG3Dk3dMSPwQMzGXVQBV6D8fTl2Jul6JdYK28c+3K0HJbKkc4SzKp308YcBplqgkFOsRbSDePuANSHQku/H12ibVGNnV2bRkZhjUvIRdtpD+7haXf96rAkUypwhp25xUzgTwESGA4boClidXqCbQukMX4PnhK5VzORQL7gvDV8DaQxedvDsBefEauNrAhQF/c3MCmDV1YljapRbsP3sNan8T9doer05OXPZtdnYngJhnxSe1jCtjmtyeADIBdD09/AUPnbsONb6OSuw/qJ0X3q+dN9o2erc9s9sIca69N2kj/L1ZnwDilWuLkau1CWDlLxbA8Uv/mRJM2sZpb1WC0tn1CSCahhTqOdsSnlCsR+KBE1cfgT7/bIexrcsZV6rhSmgKgx+j+BEqCHgonu2GAL5WMTv0blwkFM3RrtNu3ptV9Ne7laFYlqimQdoPDnLGUO3fQW5mSKuL8wANEB6BhE4gpUuXNryARSpUqBA0btzY1Ank6tWrMGPGDH/+hg0bQsqUKaPdCYTayoWDeDQdthw2HPHZ/wUreSGAe09fhbqDl0RpStHMKWDr8cvG33UIoKovTACDNcLO69lz+irUU4wr1lQuR2r4vX3k6b3z2sNbYvm+c/DyKB9RU6ViWVLAX+9WgbcnrDfs/nTf4xX7zkGLiHqTJ4oPV27eVc53UV+1rxbCkQs3TOunm/XU9hWhTI7U2kD1+XuHYY9mlUJJAEXb0yV7DNZ2D89Vs8A/ddKEcP/BA7h0w3cCG4rkhgDGBFs6twTwf+9UhhIK2/BQYKtTJxPAR+QEEAdbyMAMHz7cuAYeMWIEjBw5ErZv3w7Zs2eHV1991bATFB7BeF1crVo1Q/sPSeL06dPh008/jREyMPgF2viH5co5HIoFF58lHEB0XhydPG4IoLDb23XqCjQYstTRxqOzKFnZUumUpw0KxTjo4Pow55GNx3VJUUzsc5UvF8Cxi1FP3kRbhQ1g21/WGXZ8un1dtvccvPKzj1jqEMCaXy+Cg+euaxHAyW0rQHkHJ2k674SX9wDPHqauP2Y4jKHDlpzE89MnewzWhIkA9vjfNhi/yucESK/gQzEH3RDAN6vmhO5PFgpFc7Tr1JkXqsqcnkBrN8hlRiaAjxABxDmAp39fffWVIQRdpEgRQK9eJHmYatSoATly5DAcP0SaOnWqQfoOHDjgF4Ju2rSp9nQK1QTadvwyPPV9pJdVqImH2xfaCqjPni4ErSvnDMjS6NulsOPkFdNiggBuP3EZnvxO3X9RWPcEkJ4aMgHUntohyWh1so0P9EImQtJgi0rL9J0H565FddQSRSrlTgMT36wAbcathXk7z2gTQOF5igWSJYoPV21OANFhBB1H5KQiF5PerAAVc+tfpeqsC17G7N8tJ+GdiRuMplt9MIbT2aTzlM22jhjBmmvY57v37kOe7pFSZHZ1v145J/R8+uEkgFPaV4SyNifQ127dhb7/7IAniz0BVfOGVmkhVPu33RjGpN8fmSvg6AA1VBNox4kr0Oi7qCdgudIlhQWdagS9qzoLvd1DVV/Le/o2hITx4/qLNhm23JA2MEuCAG45dgmeGao+AXVKAOmzcEPd2qu+8vFOMfCy8dlh+aj+bmXb+rARwMI9Z8H12/dMhwrlQia0qQD5Pp2plMbA+XP//gP4edlBKJktpf9qdsmes/DqaJ/USrLH4sPVW9ZXwE4I4MQ25aFSHp88jE7SeSe8vAdUfSCmEMB3JmyAf7dG9arWwctpnoMDGhm200cvmJ8ky3WiXFavZwo7fVRQ81vNixnvV42yd+VKmxQOnLsOv7WtYGvL+dWsXTBs0X6jvbs+bwCJEsQLattpZaHav0PW4BBUzATQA6ihmkC7T12F+kOi2sBhU1d2rQVPpEjsodVRi+os9FgqZZIEjmxidvZpAIkTRr7AdlfNggBuPHLR0NyySvv7NwpwGtDpA26oW3szAQzq5HFQ2aoD5+HFET4PV1XyQiYcNCMoWe3mG2rxjWldFvKanO5gX//ZcgLenbjRaI/o++I9Z+E1BwSw1jeL4MBZvSvgX98o79cH1AGh3fh1MHt71OtrWtbLmPX+ezuMWe7TE7UigBmTJ4JV3WrrNNlzHsQexyAcaUTL0gF6rzrPRB1T1DONrmQl0YX2fWjnJ78bedM/buhUopZhpdzWHyAdJm+CPzceN7qHzmGoDRuqFKr9O1TtDUW9TAA9oBqqCUS1wOTm4dH4+7XyQu50SSF+vMjTNbfduHPvvukm5bZOUW5Lr3qQPJFP2BnT098v8ztxqOrGL8UFH9WA9YcvwHM/qr2gRbnPGxeGlkQ6xG5DxnKPPxYfBj5fzLDtkU9CdMoHa+PziuvDWp46OKj6IJ8Yx+R+2s2XqnnTwoCmRaHKl4He8aJPSHiGzNsDQ+btNf4kCNCi3Weg1Zi1xt9wvuKVGP1dxqTW14uM0xU5qa6AnQqYC306rBuVWFAPPkG8OHDnXqTfoBcCSO3trAjgEykSwcqu4SGAz/+4AtYddq+I4GTOosD8rO1RHYSs6nilQjbo+2xRJ48Jat4DZ69BLYVCAz4ET7L/fLsy5Ok2A+6S4AFCQ1XnA+TjqVtg8rqjRptROH3Yy6WD2n5aWaj275A1OAQVMwH0AGqoJpCZXhpt6jPFM8F3L5X00Hpf0Vt370H+T2d5rkdVgYiGIH6zswHMl+FxmNOhOqw+cB6aW5wU0U1U/L/dhmy2QQarfEgAfMQqpfZtqq7FBAN3Xcjt5huKtuNVnZmeJRIejPrw7fxAArhw9xlo7YAA1hi4EA6d1/MCxhPJmhYRSOS+qyRskiSMBzfI1bcXAtj1j60wac0R47ExhQA2GLIkQPBddz64yYd20r0lcW27ejDiTL8m0UcArTz5BQGUnfgKPZHcsP3W+QChHwVPFXsChrYoZQeJ699DtX+7blA0FGQC6AH0UE6ggbN3GRpUnesVgCnrj0Lff3dGaamXxVdUdvPOPSjQIzQEcN2ndSDt44/52223uKLX45Ze9YFqoVkND+2/3YbMBNDDRA9SUUpuzKoMxpwOUnMtq7GbbzXyp4PPni4M6KWrStjPQXN2w3cL9gUQoIW7zkDrsb4TwKQJ4/ntDM1wqT5wIRzWJICjW5WBWgX0Iq6Y2SFTz2Qz4qaLf5epm43QaJjQHk4OcSYwRv3PFWE6ATTDU7dPcj78EFi4W32ljBFwRKg33fpblM9mhPSLrvTZ9G0wbqU6VCqdD2LsEsaLC/kyPg7bjl+BMa3KQs0C5iEQsfzn/+ww7GIxPVsiEwx50fshhxlWody/o2t8nD6XCaBTxEj+cE0gs40zGJvl6GUHoc8/gSGePEASUHRNt9qQPnlkrNB6gxfDntNRPRZpIeyTWfgsuV3zOlY34mfiVVnOrv/647DqtF/Xi1hVVzhlKXT68rDkmb/zNLwxzhfb1CwFY06HAw87hyaMFY3emipBc7FR0og/wuB9wa7T8PpYH0Y6BNCJDqCTkHtmBDdN0oRw/npkfFsv40WvmFXxkUUbMqdMDMs/qRWOYYXy/ecZcXmDlbb2qmdc41ccEChIj/WPfLUMvBkR61f3eS+Vy2aYFkRXsvvwEfPhjw3H4LPp22HEq2Xgi5k7YfOxy/Dza2WgdkHrDxCMD/9jhBPIc6WyGHHfQ5XCtX+Hqv3BqJcJoAcUwzWBJq89Ah9P2xqlpV4WX1GZnWOGB3gCHFaowbsdAbBbZGh5FIlFopmza6Sgt06b5RMHJ8/EeJYY15KTMwRmbz8F7cavfyQIYIuRq2DF/vOmfUEbQLziqzNI7cyF7y4NE4dEIVmiBEBJMr1uNXvXzfQIVTaAP7UsDfULZ9QaNLP3ASVZUMpDxB/2sgZ98NtGmB4RJu+9WnmgU738AW2LDgJYrNdsv/i2FVCoyKByvqFlfnm9HFTL55MyUeGJ42H3PshteKlcVhjQtJjWGIYiE+0Herov3xf4DtD5gF7ucePGAfGxhE4v9WzmH8bNxgMATM3LZIUvnw9dX8O1f4diHIJVJxNAD0iGawKZKfJ7WXxFt62uZVF1/qclB1wjtOzjmpAlVRLTBVCuuHaB9PBzq7LKxdKqEeg8gHIbTtKB/o2MxUkkJwRQxCx28jzOC4CnAh1/3/xIEEAz71vROSSAPZ4qZBr5BN9dKjkiCOC8Haf914JmBBAdt9YeugClsqUyThitQsHRE8Lhr5SCBkWesJ2KNB6xnBlP48a9XtZPbL2sQdTGsHzO1DC5XWAkmOgggPm6z4Tb9+7bYrS3X0ODvKEz3sil6mgpv7erCOVy+iKvqNYXHI/2v/p0EHXTi2WzwhfPhY4U2bWD9gPHXrYTVc0H4VijM/9+WLgPBs7ebTQj1H0N1/5th2l0/s4E0AP64ZpA1FicNtfL4qsiPvIX3dAWJf0yFW5gWty5BmRPk1SbANYtlMG4FnFCxrDy2R9WM5XNMWs3LuAJiBe1k2dmS50ElnSp6QaSWF1m7PKD0MvG6D0YczocIMvzBW1d0UMWjfS/nrMH8F36pEFBeHqouaA7FYne/Fk9wzt97o7T/mvBxAniwX93fFqDFBchn4JekpuOXPLHx1atDTRW8LCXS0GjovYE8Jmhy2DLMV/IRTnh6Tde16JzC15Rb+/TwDXcski22am8kIdy/SAHBXXXATEeeL1b5DN1vOT5napD7nSPm65/7avnhuGLfZp3uinUp2JW7fjv9j0o2DPSXtz4iJm4AVDQWyTV+9vsp5Ww5uAF+KFFKUPg2SqNXHIA+s3w2bvzFbDurHCfjwmge+wgXAQQF4kvZu6K0tJgbJZ0wcOvVXxRRfr+pZLGF57btKBTdchlsQDK9dYrlMGwGdFdhEX5r54vBl2mbnHUzN19G8Bj8SM1Cp08M5wbkqNOxfDM387bC4Pn7bFsZTDmdDhgkOdLt0YF4M2queDvLSfh/UkbASOB3Lp7H9abSIpgP1v+vBqW7j1nNHdTz7qQMklCmLP9lFIbzszhCSVSTl6+abo2VBww3/87ftA9VSyTLTx2p5tLu9SEql8tBDyh3OGBADYeusywDRNJviIUGIfzfdNdB8R4yKSIgktVEHTrtRucZmWywFfPh84uzur5xy7eCJA1QgxkzVrV+/vSiFWw8sB5Q7UC1Sus0qilB/wOj41LZIJv2QnEbkp4+p0JoAf4wkUA6VcRbW4wNku6MGHYNAxvhRsKnmYMalbCEwGc17Ea5Envi/GpswC6JYD9mhSB7n9uM57zYZ28fm01q6GVVeZ12ifqC6dRuofpGeOKYoinUREefmaNC8acDkfH5fnSvVFBeLNaLvh78wnjnamQKzWsOhD5MSW3Cfv59oT1MGOrTwduQ4+6kDppQjCzkzQjgCiSfOpKVAIoTtOoU8O3L5aAxiUy28JTacB85amiKCgIYKIEcWHX5w1t6zPLIDvSyHaAAuOsqRPD0i7hcQLRXQfEeFjJaG3rXd9wUNNd/3SADPWpmFUbZHkulZ2p6v19edQqw1bQbv4dPn89QDapU9188F7tvDqwuMoTrv3bVePCVIgJoAegwzWBzDx1g7FZ0gUP9ZrwJf1y1m6DSGGQeS8ngHg1mz+jPgHEocA+6S7CYugwxJCIMNHzqUJaXs07+tSHJAl9i7PTBTqcshQepmeMKyrGNX7cOAFCsbShwZjT4ei4PEfFXBfxbdGmbTU5TVcRQHraISSTZm07Be1/jeooY0YAzaLzCBtXGrN4SPMS8GxJewJo9/6hbS8KXD8WPy7s7uueAMpXze/XzgsdSeQH0Y5wmlzY9V2MoxgPq1i+dI3Rrddu7oZaGkX1/AcPHhgSPbKKgy4BFCfdg5oVh6alsph2sdnwlbDmUORH00f18sG7tZgA2s0JL78zAfSAXrgI4JjlB5WCocHYLOnCVPCJ5DDzg6p+RMRphluIMC5koUzJHREs9Ogt13++q0fiydxrlbJD/xlRr8vlCunXuVMCGM7IBK6AiKGF6FxD+6iu07YGLPjiAyCGNj+gWbQviz6qATnS+mxdZ2w9CW9P2ADlcqSO0jeZ6FLb3jXda0P6ZIlg1raTSscAMwJohhXauKKt4K+rfELLmOw2YMxz6cZtKNFnruUQoCQL2hZinG90wHKSbty+CxciZGTkKCkd6uSDD+pEbvjRQQB1VRHEeCA5EgoEVLYHMaG3DG4JIN7KoOzLU9/7bEnRhg5t6cKVTl2+CU2HLQfUH0TNytt3Ix1kdAlgqzFrYNHus0YUphfKZDVtumx6gIcQH9bhUHChHGsmgB7QDRcBHL/yEPSYvj1KS4NNADFkz6wPq/mfoxORxAq+f96rAkUypzCy6C6AbsRRRRvypH8cmpTM7Pcis2qbMLoXeXTbh/nDGZvUw/SMcUUpxjh3VVIqwZjT4ei46Avq/WGEA5EEgSubIxWsPaQOKYYnoPv6N4L+M3bCiAgv+9XdakOG5Ilg5taT8NaEqJ6hTgkgfnw1+m5pABRfv1Acni9tfgKDmUv2mQMXb9yxhHDFJ7WgEhLAeHFhTz9nBLBC//nGlXXaxxPCuWuReoL4wM7188M7NfMA2pphDGIUBcYUTq971OVDRxy7pBoPGroPy9PQhk7WF/rsPo0Lw6sVcwDdA+QwmHZt9fI7jdbSqlIOGLvCF7sZk0wAzTQKXx+7FhbsOgNoq93MggCiaDreOomkkgby0he5bLj272C2Odh1MQH0gGi4JtD1W3ehsMLTLBibJV2YPn2yILSpmisAEYxL/NLIVYAvv3DP14Vs+juVoXjWlEZ23QXQCwFEAtugSEYtG0A5TJ1u+7AvLAStOwMC88kE8JVRq2HZPp8ThLypuHtCeEqhvlmubj7dyfWf1oE0JNqNuMItnT2VqQMIqg8dGPAkUJvIlV1rwRMpEvtPEOWeOCWA096qGCWett0GrPueYltR2BjthPf2a+QIdKv37JOGBQA9Y+U8OdIkgUWdw+N1/8bYtTB/1xnbPqnGA7248aNZpH39GvrjtTtZX+jDxU3FxNVHoNufkVqwwVj7bTsJADRai9mcFCd3qI2KXuJyEt7eXz5XFJqXzWb6WOqxjpnerj+f8w0AACAASURBVJEbujQooNNMV3nCtX+7alyYCjEB9AB0OCdQ859WRrEpCsYiQBem/f0bQTyijSegETYgdt6BMpR/vF3J0CrT3VgwX9OSmeGPjcddjQpel+D1SLWBC23LC6N7kdHJAo3i02u717F9BmcIREBgjCe1GMWFesGKnMGY06HGnRr+C/0+8UzhxVsqW0rYcOSSsilx4mDos0BbV6GZKWwIzTZb3XdJRQC/aFoUXixnvgHr1r2qa22oMGC+sVbgmuEkWb1n+AGKH3Dy1XA4CaDuOqAigHKUFCpro1uvjKWo4/e1R6HLtEilA3w+HgzgfzTakpOx0MmrQwDRE/rCjduAJjiqJE5V8SobTwnNUptx62DezsjTV9Sh7dqooE4zXeUJ5/7tqoFhKMQE0API4ZxANGySaPLcDtUgbwafk4XbJJ/KWNVz5eYdKNZrjvajpravCGVypIYle87Cq6PXaJVD5XzMjwm9DFFK48EDraIggpGjDMdfm09YFpJPbpws0Hh9te7TunqN4lwGAtRWSmwEQiCWQvQwEECq/SZ7kwsdvxJZU8Kmo2oCiP2VnZ3QszZr6iRgFjHH6QkgvnvPD18ZMPswhizaclkl+T14q0Zuf2guUU7Y6YqTTCdT3Oo9w8gp+89eC7BbxLrDGXlHdx1QjQfeDFTOkxb+jPiAdTpmMo4U32nrj0GnKZEi6lh3gR4z4ead+yDMB5yMg27ezlM2w5T1vnjNctJ9V9uNX2dc6aPQP+pl9m5cGBIliJTgEvV2+n0zTNsQ+aw2VXLCp08V0m2q43zh3L8dNy5MBZgAegA6nBNo67HLUURlUWx2QpsKHnoQeDWr80IX6jkLbtz2idPapcltK0D5XGlAR/9NVRduou/WzKMdMB0N739vXxE+/d/WKJuIXL/wuhR/1134MT9+6a/vwQTQbvzp79RbUpxEqTBHBwOzkwQnzwtl3ovXb0PJz32OEvKpuQjlhqYPmy0IIJ7s0PCFQjTdzPHKKZlQEcC+zxaBVypkt4RGHhMk62gHRhM6rJTrNx/ESaYTrK3eM7Rt23XqKkxYHem4gnXnSpsUFoQp9KLuOqAaDwyT17Zabr/totMxk3GkV6BL956Flj9HfkTTDwhdgW8n4yTyBoMAvvXrepi5zSd3hMnMu1c+5MBwews6hS7kZjj3bzfYh6MME0APKIdzAh04ew1qfbM4oLWq8ElOu+PkBBDr1l0gMe/EN8tDpdxpYdCc3YYHmZx6P1PYsBF89oflymbjiV6fZ4qYRlOQC6H47sQ3K0DP6dvgl5WHLaHAK1y8yhXJSb9SJUkAG3vWcwp1rM5Pr02FN6AKc6odGVMBO3PlpuGprjoBW7DrNLw+dh0Uy5LCNJoG9gtlWoQdIf5byMjgyTWeYMvJKZlQEUA75wF6Siuej57Dcvg+fHfK9ptnZNH5aKR9sXrPUM9zw+FLAadAWPZhIYDYVrzG7vuvL5KF0zGjOKFH8fxONSBjikTGn6ndqahbYBlKAvjJtC3w29qjyldRd+yp3iVWhNFy+jUpGqVOGhta/Kj7DDdrRTj3bzftC0cZJoAeUA7nBMKrEYz7SRPaGf3xdmXXPVAtKnaVOSFK498oB1XzpoOBs3fBDwujhjzCBb92gQyGPZEqYf8wPmje7npxfvH6GAOwfzZ9G4yzIYBCdkM810m/UHttExNAu6kS8DuNmDC4eXFoUjKL8mMiGGYNjhrmIrOIiKDSwVu46wy0HrsW0B4VBdVRWF2V0EEgD5nXedM/DnM7Vofpm47DB79tilLEKZmY0r4ivCBdAfd6uhC0qpzTtMco8SHH1FZFA8LTc9QXxCSHb7OC00ozD8uhk8DH0wJPG/HvoT4Jom3O022GqUYlzWc2HhgRRshQOR0zUT9e0/d5prDfgUS1RtETQJ0Qay6muVFEhB1UldclZ3K4uFcqZIO+z0YlgO9O3AD/kLBy+EzdZ7jpXzj3bzftC0cZJoAeUA7nBFIRQLSnwMXYbcKg8pRc6bxsTogSxgytkT+9EcZOFfMSr6Qw/m95E90/9KTEgOq5Izwu7fqJNiY/tyoLvf7aHiBXoCqHdkzUeNpJv5Inig9betW3aw7/ThCgdnMiJFRMPgHEj6Nrt+9C8kQJopKxc9ehxteLINlj8WFr78B5sGj3GWg1Zi0UzpQc7t57ALtPX1XOA9Tpa/vLOli422fvKja7YBHASW9WMLz3aUKR9NermBNAlY2vfJKI1/N/vVsZSkcQQCE4rTPZL9+4A8X7mNsQo0zNR8TOTdQZrhNA1QmoWb/MyB0KWQ+a6wt36IUAor2mnOTbGvFvJOlP24RY0xkfVR6zj3cn5AyDCaBpg0hmBFC+Ksb84hbJbfutyoVz/w5F+4NRJxNADyiGcwKhHEudQYEngE5eQlU35TBGwSaAo1uVgVoFMph+RdoRwDLZUwGeZFBbKavhql84A/zUsozlV6soLxtOOyGAyRLFh61MAB29OVRTUlxZqTCn8aMdPSDImUXbqCe7eMTe01eh7uAlRug29CanafGes/Da6DWAUXXwA2vvmWug8ghGjbi249cZArki4fv3v43H4cPJ3k8A8d1ZJ8UhVsk80bafuXrTsO0TSXxQ0XFC8pclVRIoZWIDaTUMRy/cMGIImyWMVKLqe7i8gO1OKGm7zcgddZpxSwDN9PTMCKCdwLKXV+OHhftM5b909gt8tny1a0YA8YNojkKDUfc5TvsZzv3badvClZ8JoAekwzmBQkEA6bWc7sZrR5ReLJvVMORGD8iRr5YxTviomCg6rmBcSEyfP1sE6hfKYBr5Qzh12D1TDKFQyUcB2Z9tYs6ilIWwrzl95abpKaRqeqDgK+pzcdJHgDpO/NSyNNQvnFF5BSycIfRrDk1OMeeEZzl9Cj2lkzcnYayPUXWQAOJ7iyfheCpIE3oPtxu/HpAwUgL458Zj0GFypLcn/U38v+77ICMj4hWbISYTNJSSKZ09dcA4YdQTNIEQ0UKo1p3dSOw8eQUafhsoTk3LmBHArGGKBXzzzj0o0GNWlG7gFfSBs5ECxZjBjNxRseRwEUAhq2SHv5vfrXQRdYlZh8mb/J7R2IaWFbIba7+chGC0/Hfd5zjtXzj3b6dtC1d+JoAekA7nBNp35irUGbQkoLVeA4NTgemdfRpA4oRRXfNleMTmI4c9Evmal8kKxy7dMEjeV88Vg2ZlswL17qpVIL2hCo8JF4HGJTKZSsuUy5nauALW3fBEnEwqsGs2vEJ4F3+ftOZIFE9Hq2mBfd/ep4GHmRP7iqItnLAbEx8GqnGlYdWiCyV6FagiTVSwVt6clu09B6/8vBpQlBwJ4P6z1wFjVePpxpWbd/1dQgLYdvx6v+SRIBV/bDgWxenCinA4wUgILZuVESeb4vc/364EJbOlCnj/0Ev78YTx/Ve5eJWdIF5crWasOXgBmv0UKE1DC6ocTvB3vHbG54Y6Xb15B4oqZK7wCvoAiVBhNR74ASycJujcEBqqGNf4yIUbll2pkict/NqmfJQ8ZieAbiKy6GJptvY6uQWRvXvNCCCenNMPItFGJoC6o+U8HxNA55j5S0Q3AcSvzV7PFHbdA2rzs7tvA3gsvj0BRCP3Pv/sgG8wsPewFVGejRIfePU0df0x+LhBAcArEWoEXK9QBv8xf6OiGWHYy6VNvXadEkAMc4V2RDTElhk4GM4qU4Rw6W9rjsAnktSFFahJEsaDHUwAHc271QfOQ/MRPps0YRqg2lzMogk4epjHzNQ0QiWeTJ2M5M1pxb5z0GLUasifIRncuX/fODlCOSQUw6UEED+48Ap46d7ISChYl6z3ptoEdT+IZBi6NMgPb9fIY4qOvFH//W4VKJolRQABRA9gjAFcvLfPlo+GO7ODXXhIm+X75oXiAVp3Il+4Qi8K7265fahDSEOUWRHAoS1KwrsTNxoaprs+jwyTh+VHLj0Ab1XPbXkNjnWbCWybEUA3EVnsxkr8rpprGAsdHfzypNfToEW7TtwPRDIjgM2Gr1TGz2YCqDtazvMxAXSOWbQQQJX9zOuVc0LPp90LZdLA706+5M0WB9xg2lXLDSgdgOKhYsOh1wgNCmeEWdt9mlBZUiWGZR/7vuxVC02FXKnht7b6J4AvlcsKA5oWgwEzd8JPiw9YjizVm5NV9u2mhLy42+Xn3wGo6DPGzsUYuqoTIV1ThFBiSj+MkJQ8J8XP/W7+XsPQX2WrtWL/OWgxcjWgVy/a/2HCU2wMh0UJ4Pbe9aFkn7lw+959f1dwo8ONUuUI4fY6keIkYu2qsBPOK/S3f9+vAoUzBRLAzT3rQZy44D+11/1wxHrNHFxQTxDF3vHjber6o7DqwIWAJoaLAG4/cRme/G5ZFHgwFvHh875TO4w1jvFsK+ZO489H1y70il6056zhBJQ+mU/CRU5269NTxZ6AoS1KRSlX9asFcPTCf8bfqRewiC0dindCtS4LfVfd58lagmYEUDwLbT4PReAt+qr7LCf5wnmA46Rd4czLBNAD2uGeQPLVZttquaCbh1A5F67f9htzO/HmE5DJi8Pmz+oBxsMU4YPEhvPx1C0weZ1PS6phkYx+UVAq79B46DLYfOxywGhUzJUGJrWtoH0FLBaWwXP3wLfz91qOrAi9hZkmrz2ilJ8wq0Al/+FhGsWKonSuLOlcE7KlSQIqcfP5napD7nSPRysmK/ef93vQ4rVk01JZAtozZN4eI960Ss9s1YHz8OKIVYB2WWj/hwmN9NEuVSaAcnxv3NSnrDsKnadGhvwSD6YnbW5PADvVzQfv1c6rxBZP9GgcW8wktAnpurOjT324d/+B/6pUjoRiNXC/rjoMn/5vW5QseOKFdWKsYgylN29nYCzecBHADUcuGrcaiRPEg//u+MTu8Sr/yn934MTlm37iJXdAPpmzm7xmYyzK0dsJWte6Qxf80V1wbVx5wGdL7SYii10bzdZ4/LvKMcqqPrr+Y75XK2aHPo2j2gCazWs+AdQdLef5mAA6x8xfItwEEB9MX5L3auWBTvXyu+4BdSxxoudltjjg5pAkYXwQL7wggMMW7YOvZu0G/JL+qF5+QFkAsbjO+rCa8f8oBo2OIyiyfPGGL6A6RgH5qH5+bQIorsRxI8NNGI3OzZIIvYW/fz17NwxdGFWo2qxsKG1uXA9mDC+o2iRVJy4YIxjJU3Qm2lahWUjbg6d/eAqo2sjEVTd1HEDihdd/lAD+753KUQTQcaP7fd1R6KIggF0bFoB21XMbzXBLADvUyQcf1FETQFWdQpSbyirhTQGGZyzy2WyjLbq2w5gXpaBQEkpOGFrx3LXbhs3w7O2nYH6EjbDIh1eOK7vWDvmUWH/4Ijz34wqgdnrozIMh6jBuNdqDqnQUnRJAesqLBBOd5mgyIzwbj1yEJgqzGywbKpKkmhf/vFcFimROoT0eXf/YApPWRIpJq94b2jf8sKLRYELVt+jYv7VBC1NGJoAegI6OCURfyHbVc0HXhu6DZf+y8hD0nL7dQMDNSyYvDuKUQqjHi5A/Qxfsha/n7AF0EPniuaJ+WReMlvDXu1WM5zcZthw2HrkESK7wWgw9bVHjEGNG6m54b1bNCd2fjLwStyonTqHw2bm6/gv3NeMNY/5Q2tx4mI4xuqhqk9x96irUHxLo2ISbC2pe1iuUUcspKRSdpm399sUS0LhE5oDHfDNnN3y/YB+obHDXHrpgCDBTx4EPauc1rgVpaDgkdAMkMoTvoNlp9Auls8DAF4p7IoDv184LqFOnSqp3QNhjdv9zq39Dxg9FPB0r1NNHAMVHn844qDTlEEM0b0HSh0LQGDNWOImJOsN1Arj+8AV47seVxoequPJFOZ8ZH1Q1HHrMnF28EEAkmPKHqtlavOXYJXhmqDpqkpv1W2fMVGvonA7VIJ+DGPTd/twKE0l4PxUBLN9/Hpy+4hNNR9vxL2dFfiiEqm/RsX/rYB7OPEwAPaAdHROIvpBmR+m6XcKX7MdFvggdbl4yeXEQp4jiiw83G9x0RCxgVLhHgVNR7smiT8APL/tsXfDLG7/ARUIj+tkdfKeDugQQHU5w8RDJqhx1NtCtX9RrZqSti3so8uEVGkagyJf+8ZAGUHfbdtUmqfJsp/W7mZNu20fL2RHAr2btgmGL9kPryjngs6cDnbDENR21Y8LTPowfjc5TcyN0zlRRL7C/Zg5J+PH05fPFHL0PMhZWAuaqCBjiI0l4sIp1gspHoS1j0sfia8He5+8dMHr5wYC82GchAIwfjBuOXIo2AqgaO0EArTrolABSR58imZPDtuOBNxVm837b8cvw1PdRbRTdrt86g6ZaG506asmx2V+rmB16S1fA1AQBvc/pSWeo1oHo2L91MA9nHiaAHtCOjglEPem8ysA4XbhkqOTFQbyoQvdPXDmJWMDCRk+Uo8bALwxfAWsPRRJAuqjpErT3a+WBjuRK3KocvWrUrT8mkBOz6bp83zl4edRq12Tew2ugVVRNACPFzYUjgBuM0cPy+MX/oEretFptscqERJpGnkFtumdLBp4Air48UzwTYFQTmsQ1Ij1FEmEHqXcx2rvJV734/phJEgkHJ3yWm/kq2mi2mebrPjPAIQXzCztZeeyoXh7qYeJpvU5ShWjE9givfSTUh85dD4iOgvWG6wRQnN5Sr1+8ohVmKmZ9dLqOUqmf4llSBNg+4/Xzki41lY8y01EMlUmKWWQUaj+tM+5ybHbVwQWaFGC0IEwo0VVxwAJ/1UwAdVB2l4cJoDvcjFLRQQDxueNXHYYeEcbUbmz3RJedLlxWBJAGJBdH/h/WyQsf1snnjwUsrsxUBBD1wdArVCS68OpueOLEUdU/ue30GkNlAG83LZxsfHZ1BeN36sXpZsEcueQAJEoYzxBpDUWyI4Di6p8+W7cfom7hteql/SOW7PfHcsV6VDaAVu+NcCTImjqx32MTTRkwbCONtWtGAPGqDN8fOVGPY933QYWDGabl+s2DM1cD4xYLsXRZ95ASwC296inD5amerWo3tkc41eANwYlL/wVERwknAfTbbxLdv1ATQBQaR9MXTCiR1eOpQpA1dRLlFN5z+irUGxxoMoEZ21fPDajxGOwkx4oX9ctx1O2eK4fmRK3EL57znWaLhDGo8f3ARGNN47911wG7dsi/R9f+7bSdoczPBNADutE1gZbsOQuvjl5jtDxfhsdhTofqrnoRLAKIge//fs9ny4dJHPmj7VOHuvn8sYDfqJLTWOBUBPDFESsD5B9KZE0JeHWGSXfDk3XO6FelDNDMD6oC2t9gGjBjJ/y0xFo2Ri6PQd/bVvMZ5ceEJEKQuVkwaSQUNPKPFycOfLdgryECjHItXpOs/yYWdOqEZBdtwaoNYn6oyJrTtlf7amGAUK/KC9jqvUFHJnRoQvHi45d8kh3rP60DaTQIIH7MTVxzBLr/GdVTVphPOHkfVH0320xV0iRioxdeq2LjpieZwvNfB2czAijCjeE7f+ziDcMhhKZwnQAKD246F3XWV6frKI32QkP22Ymgm0WDspL30RkXszxmofE29qgLqZIm1K5aJoBNS2aGQc1LBJSnGOKcEjqTbtYz3YZF1/6t275w5GMC6AHl6JpA8tG82y8kpwuXDBUumGhD2KdxYcieJqn/ZzydxFNKYXQuEz4VAXxpxCq/rAFWhPFT/3jbGQGUozbgaUzHyZsM0vnGuHUBzaeebFYBz82mh5VHpYcp5bqoCEHmZsE8cPYa1PrGF2cadd3QTg3FbN3UpeqAmakA3dDwtKnCgMg4tLrPpu/Cjy+XgoZFn3CNIZKPKl8GxqpV6QBavTfo6NH4h+XGteWpKz7pEIwXjHGD0ZEgb/eZxt/Q47XLtEC5FwyrhlEkVFIpVHJG94PICQFUvQOi3YgxRjRBu8b46KR19z7giQ0m1AVMkSSBFuZmBNDMO1hUGi4CqIrCgnqOcztaf2A7XUdpvGe0dd592ucFbGdbh6YONb9eFAVrIbivNQgOMtFxpsWcnPpiud5/b4cxyw/5q6C23/hHGicc/43SQjQkn9v9za6r0bV/27UrnL8zAfSAdnROIKeLjt3GHMyXTNh8CJka0VaMIbqpZz3lCeDLo1b5YwRjW/HLeOpblYxm6254BtGrklM5oo2+XQo7iCwMBrUvliWlkZc6w+hOByuPSt06gplPhCDDOp2OJSWA6MmNcZSFF57TuuzmGSVU6O1bO4J44nMFqRB16DybnkaNaV0WauZP7xpWeaPCipwSQKFtiE4f56/7TrK29qoHyRIlAHqighFG5OgzuPGhgLow76Adofayuu+DDIRVzFgVATQjd5TIbupZF1ImsT8NoqLztF04xqOWHoC+/+40HbdwEcAqXy6AYxd9p7Yi5U6XFOZ3qmE5p5yuxbO2nYL2v66PUqedCLoqGABWYhfiz+0LoYqNLG51nNQpO/+gFuyPr5T2VyHbNu7v3yjADldnHXDSHpE3OvdvN+0NRRkmgB5Qjc4J5HTRsduYg/mS9ft3B4xcetC4PsTNYsV+n2ApJnyO6gQQdbZoWCwRBg7L6G54qNfVurKaAMpSBCLOKdaP2mR4CkHTKxWywa+rjpjODqFR6GH6BLWoFycQmQCiZt3A2bv94+W1oXT8qL3Sycv/+Y295UVfzBW7Z1+8fhtKfj7XyDbpzQoBERrsysq/PzN0GWyRxMgxOgWGGKTJ6t0TnproGCGM2oVYMiWA6A0v2/qhRy2eQvWIkGaiz6Sek7rvg9w/K6cx4dlMywjiKtdDHWV0rwOFY5hcF64Ho5cdNDykzVKG5I/B6m51nA6n4/yFes6CG7d9AtAiUbF6swr/3XLSCHeJdp0YJcQuqYgVlrEjgGhSgPaYcgqVOQr19hbPdCL7I8rIBFCEABW/y3JQdI/QXQfsMFf9Hp37t5v2hqIME0APqEbnBPJKAOnVWbBlTYROmgpaMwKINo1o2yiSCAOH/6Z9RfuRPzYeV45a72cKw2uVcih/E9fS4sdpb1WE0tlTG/9U2T/Ji5BcaagMr91ORxGD1s2CKZ/EoSME6ja6qUvVfjp+cztUg7xEQ+z7+XsNGZHXq+SEEn3mwKUIEXDdZ5+5ehPK9fNdHf/WtgJUyBUZossplioCqNrUrd49IW6NWpF37vnEJUWUHUqcPn+2SJSTPrxaw+tBoc1J2081B90SQJXtlXiGigCaiTxT5wBh32iHtXzCL/Lje0b1SFX1JEsUH7b2qm/3CE+/Hzl/A6oNDLz+xwrRIxivZu0SXpdijGTdRMcQr0TxGhTj68ZBd3iTdOryzShmEphVNn3RbYNdvqs37/gjvoi8TkL/iTJ2BHDv6atQlzi3MAG0G5ng/c4E0AOWDzMBpHFYkyaMB9v7NPCARGBRYdQtV/j9SyXh6eKZlCeArcasCfD+q5wnDUxoU8Gogi6Wqqsz/0LTuDC8WlFNAGVDZIzPiqeMmIQMBW2vHQGURaeDBp7LikQMWizu9DSXEkBc4DGOMka7cFOX3Hw53JuVhMTT3y+DrccjwwFa9QPJ1P0HD+D8tdv+TXFim/JQKY97KRgVAcT59mK5bAHdEvNRFQt4x4kr0Oi7pf78NE4rJYBoNysTPTxN+2vzCfjsL584O01Uc9AtAcQ4toMl43vxDJUMjNlmTz8eVfioprBZm3GMJ6w+rHR8EfUgJzo44EmXb4ZesZ8W748izG2sPWmSwKLOalkWvZrVudx8wNOPHVrrp08WhDZVc3lpjrLs+Wu3oHTfeQG/oZ0q2oE6SRgGEc1KRJJtAGU9UJwTaOuINo/BWIPM2hqd+7cT/EKZlwmgB3SjcwK5WUBoVynhCraNjdmVjogtqroCloWgq+ZNC+PfKG80mfZVJZ8h+oWnKmYyJvIiRK8LxZU1xQcXIfTonLntpEGI5CQ8mj1Mn6AWpfFrnRJA6oyBmz469mCsW6+Lr0pHDDW+nkiRWNl3eQ6Y9QOJFIoTJ4ofD35uVcbvuIEnKFXzuvdarjNosT9+r2hgvyZF4OXykdI49PpOFRFh16kr0GBIJAHEuLI7P/d9XNGTMzytlokeyl/8s/kE9PpbfR0q8HBLAJ8tkQmGvBioWyj6qaoTr+XxdkCVRH7dEzIrAqgTi9vpnHb6cmFoP/HRU6dgBpi387RRhZXdpNNn0Pxu1m8VIcM6Q0UAVSeObmTH5LVXvgKmJ4DifZm+6Th88NsmQKHsf96r6gVq07LRuX+HpEMuKmUC6AI0USQ6J5AQTna7QDUeuswvQIqSFcs/qeUBicCiZmK2q7vVhgzJE/nj/k5/pzIUz+pzxJA3iGr50sEvr5eL8hsa5XeaslnZ1r7PFoFXTHTs5FO+CW3KQ+WI0yIa7F5UTDcc1ealCgMWNABdVCQkLNyQNkoA0V4No1zghuimLtp0lYzEmm61IX3yRMoedvp9M0zbcMz/m9mmT0Niofbfk9/5oiPQU2MXEELRXrPh6k2fGK1Ib9fIDV1IdBmq0ze/U3XInS4wbrEqvJ3oByXEOFdlb198P2ZsPQm9TQggXiXfvBsZhs1pHxuXyATfOiCAVpu9eCeypk4MS7vYrx1WBJDGxjXrU6gJIOpg9pvhc0R5vXJOKJolOQyctRtGvFrGUdxb3TFxQwDNZFlCdQUsrsWTJIwHq7rVNuShdKO+UBzsCCD9aBJ9mbn1JLw1YQOUzZEKprT3OQMGO0Xn/h3svritjwmgW+SiUQgamyxkP3SESlVdbDpsuRF2SaRgLrBU5oA+WzwDF7IL128HEAF5g6iZPx2MaR2VAKLWW4fJagKIhvWol6ZKsqMHkkskmZjMQlSJelSbV0w7ARQitthmp1/pMgHEK3yMdYvJy7yg3qICSyunAXTo6PD7Jr8pgNmzP566BSav8wWXf6rYE/DPlpNBmcdUjFY1b/Fv70/aaFzTYlrcuUaA/BH+TbZnohhSAjjw+WLQeWqgDAx+hM3edsrUIQJPZ8evPGzpMWu1MyatpwAAIABJREFUnKkil2B+6khj1m+5XvFOZEqRCFZ0rW27iloRQLP1Qrcttg/XyDB2+UH/yWuoTtRoM4r1mg1XIj42nLxjKntljCvdrnrwNUnF1axQb9CAUZlF9q6XTwBpiDshaTNr20lo/+uGADUIt883K8cEEIAJoIdZFZ0TSHh90pi5TrrSZtw6/zWH141efq7qFMTuGfIGUadgehj1Wlmjavobht7CTViVBjQtCmiXpUqyzAWVDFHJf9idAA5tURKeKpbJCeQhzSvCWOFDrK7uVI2gNjh4Avj9gr3ww0L3MaLFM6hEi/ibmWep+B0/DEpFePUK5wm5zYV7zoLrkremyONkMzUjNfLfzebC0i41o0RtUMU3VpVX6QBifXN2nAY8MVEljD4zZtlB+CbCPtPphEKyPLSFL/Y2TR/+thH+t8lHammywlK8k+mSPQZru9t76FoRQBE+z6w/6FGNfQ9lGrfikP9KvudThQynpFAmnOM41zE5mbMirjptW6h0AIVDU/pkj8EajTE2w0sOBScTQKGdieUxHvS7tfKCkMqherDBHo/o3L+D3Re39TEBdItcNJ8ACpsvt1fAKJAsvGlVJxkeYDGKqhZ8nQ1FPLduoQww8tUyUer6oUUpQ3JBlb58rig0L6smgCIesSj382tloHbBDMY/ZQcR+XSP9qVirjSGYDUSUTxRiSlJBLLH9jg11KakBT0/MQoI2gE63ZxkLFRyF0ISxQy3yzfuQPE+c4yfMSpJAoXBuZUNnJPNVG7DG2PXwvxdZ6I0zYwAquwZqUONqEhVXuXMhN6m83eeNj3hQ/KM9qhDF/pOZ3USOn7kSpvUTxpVYbwafrsUUIuNJjtRYjEGuqdDIj9qwM3cdsp4VKIEcWHX5w2N/5dloGhb5EhDOv12mod6IlvJSTmt1yz/+sMXoN349YZIfeMSgbGmrZ6hcrALVSSQjUcuQpNhKyBLqsSw7GP7a36zdssKDLIOII0UJMKHztl+CtqOXw8YKu/PiIAAwcJe1MMEkE8APc2p6JxA/riV6ZLCAhuhUlUn3digOAHLKwHEuJhof4OJ1jX8lVLG1YAq4alKs7JqHS75y3lEy9JQr3BGoxo5SL1MIujzq+RJC8v2nYMhzUvAsyX1F24n2LnJixvKcz+uNIqiqLITSQqZAA6Zv8fv+OKFUN24fRcK9Zwd0B2700kqPWFGFkNFAK206kQn6LNVZIpqKooyKgKo0gGc17Gacf1tJoqMIbIwbCFGC9FNeDp06b/b/vFsViYLfPV88YDiMgHUkV0ROKB9WLbUSSB/xmSm9oX0HW5aKjP8scEn40TJo/wO0gYWeiI5zPggNI4A4jmUAPZ6uhC0MtET1cVdJx+aBFjJvqjqUEVNEadmOs90kkcoReAHxAINKRxdAli/cAb4qaVvbcdEY7ELfVWMRvTmL+uAhgR10nadvNG5f+u0Lxx5+ATQA8rROYHElZ+uF57czZhOAOlXIm0rEjf8MlQltKt6wUSIdeiCvX5tOyyLRLJBEV/YMPmKwooAoncyClarYsR6mEqei9JrNKdaXZQAotAregCPiIiN7IUAUqFn0UG7+ihpRGFkldF5qAhgl6mb4fd1kU4oqjbTZ6s08A6duw41pHBdtM85u/4LDx4AoHexHPMXveRRC1M4I8iTAqNuoIPInyY6mKpJhCLBwxcf8F83PlnsCcBTdJpkPFMkTgBINq2SagzMPLxpBAs8NRc2lKmSJICNPX3PEfHDVc90a+fs5KWqPnAhHD5/wygSLgLopH0iL3VWEX8LVVhKEV3IK/7y2NLbHewDnUtCX3XejtPQ5pd1hpMgOguGIkXn/h2K/ripkwmgG9QiykTnBBIbPn59L+niXKcqphNAulHRto5uVQZeHxsY11cMoSpqg/ht2KJ98NUsX3QLTLgJ4jMwyVcUZgQQFyf0WMNTGiuy6WFKuS6KcY+bDlthlLe7ZpUfQh0XkAAOnrvHiOSCyY6wWTW4+59bYcLqwGgqdvVRu0GzmKNy3GjaBrv6zdqrEr0VeWmdr41eA4sjBMtVJ62Hz1+H6gMD47WqCGCXBvkD5iM+Cz2a0ba3/4xdymaiA02vv7fDdIW9nlm/0KEBT7+v3vJ5N6MOJ+px0iSTOQxjt75HXcu5qCKAKlkcrISG+qJXwBgfGeMNY+r6xxaYtEZ9spkvw+Mwp4N1PF7XL05EQdof1Gg00xP1+hyv5VFPT7YRdROeTacdC3edgdZj14LXK3h5HahdID383Mpn342JYi/0VdEUAuO3F8+SAqa/W0WnuY7zROf+7bixISrABNADsNE5gYR9Bkq4DH+lNORIm8SIN6qbwk0Aa+RPB2MjvHpVbZQ3lHbVc0HXhgWjLBAT3ywPLUau9leBV7EfTt5k/NvqVE4WeqU2fPICZUYAMf7v9uOXDTsxK3tD3TEIZj7ULHz2h+VGlWYRHMyeRwkgnrp9M2cPjF7unQC+PnYtLJBs6uwIGpW6MIsz23nKZiNmrpxeLp8N+jUp6gpWxA4xVCXaZiFpgbagk9r6hMppUsVrpeVzdf0X7vsChERJf79bBVDQe8BMNQHEE0fUDqRez3adRYeGIfP2+D1OVVqA8runIwulIoBmocyoGDhu/sLOkhJNszHF/unE47XDwe532p/PGxeGliaC8nb1hPr3McsPRpEJer9WHuhYL3/QH+0nYR5P4eT1lSo8YKMp9kJeK1jk0wqU6Ny/gz5YLitkAugSOCwWnROIek5hW5yeBIabAMpffTLs8oayqmttyJjCpxdHf5vSviK8MNxn64aJEkCUiGlSMjBuq8gnB5ynNnxynGAzAtixbj4jbNW5a7cNb2P0Oo4pic4Hs6tTs7ZSAojell/P3g1jVxwystsRNqv+Nxu+EtYcuhCQxa4+KpViFmbM7AoYJYDQts5Jwviqf28+YcSDViV6SoW/C4ehd2rmhs71C0QpYkcA24xbC/N2RnU0wYowPvXqgxdM24Letvj8f7dGyt7Y9RWvM4fM3+sPsYc2eIOalQgoJuOpY/NVd9Bi2HvmmnFFh3MPk9kVMJX5wBPJyWuPGmUx3nbfZ33jpbo6p400mzcoro0RYZxGp7Baf6z0RO3wDvXv1FtZPCtUccmFHZ5XRwx5zmOM+HERGq/YBzr/8COoaJYUsHD3GWg9Zi0LQYd4QjEB9ABwdBJAuqiKLthtrrSroSaAJfvMgYskrit16lBBLm9Cm3vWgxRJfCea9Lf/vVPZf9KFv9GQWt++WMLUo07+ckZB6edK+8iibPxvRgDRoP7LWZFEQeUE4GE6eSpKxZHtpFbkB+05fRXqRcTiRAI4cNYuGLfysG9j/sJdCC6zgPc69Qk7OTPRaDMC+FK5rDCgaTFHOFYcMB9OXr5pWkYWTxbOCu/VygOdFKcuSCgrf7HAX5+qTRg39qWRqwDNOGia2r4irD10MWCO0d9xvvX833aYtd3nRauT8DRr8Ly9fhtAlROIjKeO04WInoPXs3tOXzOagjqGeHooJyEngn9HJ6BLN24bZhSNij4BiRPG82e3su1UkUv8WMjdbYZxoqobk1iFmSxXJEd/0cE5XHlw/REe+uKZslh5sNoye/spw1O5dPZUMO0t92LM8rjSKE/y+i7Wh0W7z0CrMWuhcKbk8O/7oXEAis79O1hj5LUeJoAeEIzOCYQaUrh53bp7398Dnc1VZA41AUS7n/cmbfSH1pJd/2XY5UWC2n+hTdq3EZEpcCOoOCByg6XelFYEUA44jyHlmkU4jHwybUuAZ6WMo4gQMevDqgFhvpyeunqYarZF6TWbme2cWSWUACJ5RFvJ8au8EUDZ5lI8W2eO5uk2A+7ef2B6omRGFJqXyQpfPu+MAKrqqlUgvXGijqegsnZelS8XwLGL/4GZ3dWJS/9BJUIAza7nmv20EtDLkqbJbSvAusMXYeDsSFtV+jtGCvloymbDCUk34WkWXgHjqTUmFSEt0GMm3LwTuY7MeL8qFMqU3PIRWCc6C2EYyVNXfATaLM6zCOuFeazG34oAUt1O0TD6keHFW7TqVwvg6IX//P21EpTXxT1U+cr0nesfS/EM4TgR7GcKMWav0TjkcZUj9qj2IrSzRXtbnY8Rt/2Ozv3bbZuDXY4JoAdEo3sCycHBdTbXcBFAfA69DlN5H1Lo5UUCT6JQABaTuA7A/8dTkHL95vuLUkFdKwL466rDAaG3XiybFb54zkcWaGQJ1SZ15eYdOHf1FuRK93gUfUMnmHuYarZF6YkwPT21LQgAVLgbCSCeMvy6yue84bZ/sraiaIdOffk/nWl82BTLkgJQk6109tQB3TAjCi+UzgIDXwiUOLHrv6oulNVInjgB9Jy+HWjgeoxBjCdOmDDmNMaelpMcPxXtRtF0QE4qAogCuQUzJjcVesaPn/bj1/tDONr1DX9HMjN43h44e/WWkV1lJ1mwxyz478494/clnWtCtjRJbKsW3qhJE8bzi3KrhLGxIt2PTSuB77Gty0KN/OkD2kU9xhPEiwN7+zWybbcqgzwHrATlXT0giIU++G1jFCegdtVyQddGPnvpYCbhmOP1FE7Gt0Ku1PBb24pGU6nzWuvKOeCzpwsbfxeRrvD/0TEtSULfXhDMFN37dzD74rYuJoBukYtmG0DRbHlxRQX1XOmSQr4MySx7prsoe4AHjl28AVW+XGhUYbeIyIsEdWTAqx60G8JTiaypkkDJiEgRWC86fnT83RcazooAquKNCjJC5T9QfBplCsyS3E4dQuMFQ92ylACaOU+Y1UUJIJ4eoj0cxrzF5LZ/qvB6qKH4a5vytl0S9mWYUT6xojaCqoqctldFAFFYFwkgeofTk2sapUR1lYrtOX3lJpTvH/mB4uQEEMu/WjE7/BJx/S73b8UntaDVmDX+K1dbIAEMZ6Xrt+75w8th/X0aBxJXSgDxGZkU17jys2hMZPGbGXnUXWvkDzH6TBUBvPzfHUNDDlPCeHFhTz+fqLTTJM+BmObgRfuj8qwXnrNO+22XX3fcnNSDecvlTA2/t6sIVLsU/45/w98w0djmlBjaPcvJ70wAWQjayXyJkjcmTCD6kuILhCcLOhu3KCe8rjwBYVKY6sA9Fj8u7O5rvkDLi7CZlIks14EblrhysyKAaHdUos/cgJYKsoDXakgQUZrj7Rp5LKGIqQSQ2lmhtAY6L+gmSgBR/+2LmTv9khxOCZV4prARo20wC+0mtxPHqv+MnYYmn3yqh/ZzGLPXLDltrxkBRJFi1OmjtqtUL9HstFE+ldchgHHigKENiAlPPbccu6zsHl6x4rXY/rPXdYcW0NQBba6E2YTqfacY6Nq1ilCUtCGLPqoBOdImjdI2XSJx/dZdKPxZoHC4qExFAM9fuwWl+87zP8/p2IuC8hywEpTXBj5EGVV6iaq45OgcEzduHE+t0B03u4fI+Ior5a9m7YJhERGHsA60M0R7Q0zye+52bK3aFhP2bzvsQv07nwB6QDgmTCD6cuHJFXpuYbILByYC35tJN3iAxV/0zJWbUC7iNAQjBuzo08C0WnmRMItm8d/te1Cw5yx/PXhiVayX7xTALoQTDfhOvSE7/b4Zpm04Bp80LABoT2OVYioB3HHiCjT6bqnRdKcG8aht2GCIrywSwP7/7oTJ63yabG4XXoxY8VOEmLTA00ldwsZMbsO1W3ehiAlJcNNeFQFEb2LUPkPnoDoFM8Co13xRC6inddOSmWFQ80BvWsyDV61l+0WSEjNnEXoF/Osb5eGVn33SRuhxufGIWo4Gr1iRAB44p08A0dmpSt60/lPJ1yvnhJ5PF/JPcVm3UPfjAU9i0YbxtTFr/PaDZuHjnBAJs+v9Ma3KQs0CgVfAssc1De/oZP2SnxnTND5pX2TRevxNPiHDj5CGQ5YakYow1JybhAQyV4S5g5v3ij5TxlfE95UdWv56tzIUy5LSX5RGqHGyduj2Nybs37ptDVU+JoAekI0JE8hswTT7GhfdFYbfZnY7HmDxF6WboV1Ad7kfZiHD7ty7D3m7R54AIWER10DPlcoC3zQztwGjdoBol4X2WZg6/r7JCE/VtWEBaPcIEECUC0mX7DHtIQwggD3rQd9/d/h19twuvHiNjGGraHJSV9HPZvvFi6k5wMXrtwNMAOROOnkGllW9P4hd53r5ocu0LYAOIaMjRGvplRVGtEAtSTnJp1I6BHBim/LQYpSPAFJZFbluvGIdvmS//3peZ4BRGqlKnnR+UipfF9KTY6zPqQPRcz+u8Hszm31Mluk7D85duwVU29Os7WbrGUrTIN5FMqfwF5WdN9wSFfmZVoLyOpiHMg9KNMmxoOVTXTw99xrJh57AlcuRGn5v77PZc5NkfIXDjrxGyM5Htb5ZBAciTrudvtc67YwJ+7dOO0OZhwmgB3RjwgQyWzDndawOedI/bto7UY7q7XmAQlmU2kwleyw+bO1d37Y9IsPBAY2UcTJlGzC0dxNXu2absqjztzVH4JM/thr/FEHH8f87TN5khNfCsFltq1mfAMpfrfLChO3D5DTGp1fs6QmgmXyK2TNopAZ0IOnzzw7jRNTthorl5Osdp3XReU3nMtUslPuTN/3jMLejs4gRqvcnPRLA+vmh89QthqxJnYK+kyfU6Nt16qrx/9Q5hLZDnp9mGm30BJCKm1tdAeNHHWoAmnkJq8YXZWBQbkVclcoOA7I+plMRcUoAzdYcYdOp8uSV22y2nol89MNQldcNUZDrsTIl8fqeei2vilgj23XS03c3eGAbqYe12VzX7YuML87xv96tYsS1prcEciSZeoMX++1d3fbDqo0xYf/WxTBU+ZgAekA2Jkyg0csO+g28aVdQsqRARrWUg5frQidwXb5xB4r38V3P2gWYd3K1SvOi12rRiCvg50tnAfx6N0vUEYTKeHz420b436YT0L1RQXizWi7LLv6wcF/ABkwXJtz8MUrJzbv3YFr7Sp5tcJxgTccU5UIyJPeJaOskSgCRUKMDxx8R8WbdLryqkwonddExntuhGuSNcGqim4LcN50IFjqEAwkgyqeYxZzGOqx0LWlYM3qCSJ8tPkYwzmqvZwrDiyNWGT8XyZwcth2/ohw2PGH7d8tJUy9hVaH8GZLB5HYV/B9JsmSI/N7t7dcQEsSLqzNtjDxU5Hdex2qQJ32g8xklLL+1rQAVcqWxrJu2Bx3Htp8IxILaBoeKADqNpa0NVpAyyv2mgtr4iGAQQGqPaafgYNctub04x/95r6ph5ytOKrEO+QS50bdLYcdJ3/g7WTvs2iN+jwn7t25bQ5WPCaAHZGPCBKKhs2hX8ATjnZpqhwa8mhORD/AKFYO/hyKhfIqwzwsVAcSFQSwwdt5iVI9MGOfP2X7Kv9GjvQwaVFslWd+OLky0v2aiuKHAGeukV3lmERnMni0TQJRwQULsZeH1ujnT8rM/rAb5M/qIhapeNC9A20DUpFvVrbYjiFX1odPEz6+Vhclrj/jlU+49eAA/LIy80raKbEMJYO9nCsNrlXJEaRPaWK0/chEKPpHcCC/YPIIAopzJnXvqWHHzO1WHfzafNGRdqOOIVYfxVHTqW5X8ZhLyaRHaUyJ2IpmdvJs9gwpfq2IBCy05LC/beKnqFOOBtpcjWpYOsEPD/PSE0uscw/rkE1vE9eAAd+Lnjiaeh8xyv+WoRDUGLoRD5294en+ph7Wshem06XJ7hbaf7CgmmyM9M3SZ3yGKCaBT1PXyMwHUw0mZKyYQQGyYvIiLxpq9NKgkLyJahEpjCdtAvyLDQQDtPJpnbD0Jb0/YYMAjbLPo4qQTA1SOKUwxpvZpTk/hPExDoyglgLpSHuKZlABu7FHXiDf71+boJYDU2J3aBqk2fTxlw5jDGZI/Bqu71XEEpao+1QmQbHtaLV86+IWEs6IPpZFldDautYcuBIQ3NOsAEsC/Np0wRNGtiCItj5E60LtSnJLjb7RNQuTcbs2wAlWIE1OiLvJTAkhPcs3qE+MhokXI40P1QYNBAOUPaLtbBEeTK0SZRb9RWQH1MqmmKT6S4qIz/1TNpGvZ08UzwfcKe1fd7snjhKfesz6sBiKutqhHXreaDlsOGyIcotz2w6qNMWX/1sUxFPmYAHpANaZMoEFz98B38/cCXl2diRB8lRd62k16jWnmbesBFn9RakcSDgJod4KHhuhokC5Shzr5jNMUkb5oWhReLJfNsutCAFe1YdL6nTpieMWb6gCaRWQwewYlgOgFWq7fPCMSh9UcsmovFUwW+dDRoVKetNrdpCcz/7xXxW/8r9r06xfOALO3nzbm/5ru+gRw09FLAWEFsXFmnqwyUZCjGdCO0djSOhvXukMX4HkS39oMJLSxw1Ps7xfsA7H52wGKV8AYPpF6ztM2yVFAdNorP1M4ecz8oKpxokkTJYBm2NL8YnzFaa483vTGIhgEkIaBwxBwTUtmCQhPZ4dvdPwu+p04QTxDwFvWpAwGAaRrmZ1znR0G8jjhR8mcDtUNU5PRyw/6i8sSRNRO1s28tGtXTNm/7doZyt+ZAHpAN6ZMoG/n7TWIDGq/oeOFipzQbuLV1sfTfM4QoXixxLPo4hpKArhi/zlYvPusEZs1YXxr+yXh8KEadh3vv5+XHTS+XFUYU9kbXTkND9MvoCglgE49u6n9ILa7FBHadjM/ZKket8HqRZxeESDeTAQar6j+2XIS0j7+GKz7VJ8AqgjE4s41IHuaqFp2sixG+ZypYXI7tWckFevVwY/Ky9BBxevIJAkiI22gjR06K+FVNI3AYTWHhA2iGSmQMdBpr/w8/GDAD09VCDlKAHVOxUV7hD1ngyFL/I43+Fw8oU4VoXFJvUTt1jwzjOhc3d67PiSNiD4UrPcyFPUIjMQckE8tg0EAn/1hOeAHEiavsYblOZY7XVKY36kGyNGC5DWzxchVsGL/eaMNTk0TdHCPKfu3TltDleeRIIAXL16E999/H/766y8Dp2eeeQa+//57SJkyUlNIBnDEiBEwceJE2LBhA1y9ehWwDqv8qgGIKRPo+/l7DcNwYQtltxhinFeMcoAnJz+19GmchSLJpyZWm4uTjcjLAidfO9B+63j/jVl+EHr/rSaANA4s3ahCga1cJyWAuuG8RB2yU5BXcV0aoguf8U7N3NC5fgHHMFT+YgGgjRmeYKF0BLXhpJXhCQiKRqN486ae9bSfoyKAZuRZJp+y3RV9qFMCKIePE3Whjm+iBPHgxm1fmDYkgNM2HAc04UiVJAFcvHFH2Vc0hcA4xpjEySvtK7VPdfLemQErE3WaTzcOsCgj2pMpRSJY0bU2yAQQCT4SfUyqjzmnBJbqSpqJz2tPqDBlFBiJ9Z5qmmITvKyPWF6OZkOv3d10UZ5jKOmz4KOoBFCWIBowcyf8tPiA8chQ3FTFlP3bDabBKvNIEMCGDRvCsWPHAEkdprZt20KOHDng77//NsVpyJAhcPOmL4h5165dH2oCKK508fQL9Zv8G3uf+hA/btwop2KCxHg17rWbhPKmGRMIoCpChejHjy+XgoZFn7Ds1i8rDxkxYkWifaLCtNF5AminASl3kNoPooi0VwIoS1W4JYBC5+2PtytBqWypgGoD0j5gfNsJEaHrnGwUKgJo5bxD81vFW6bRGnQIiWyaQPsmrvnwb2hDN3XDMWNTlM09aJmp7Sv6r5Tx/8vkSB1ACqiIdcufV8PSveeM4nYmFGYvhvDMntCmPFSWrvl/X3s0ip6i1QsmMH4iRSJY2bU2UDFgLEcljt6btBH+jrBVVb2PdusT/k6dHZzMHZ26Q5VHYIRXqXtOX4MmJTPDYCJK7pUA4g2Azk2Sbv/k9yxHmiSwqHNN4xACDyNEkiWIqB1iKGzVmQA+AqHgdu7cCYUKFYJVq1ZB+fK+OKP4/xUrVoRdu3ZB/vz5LefpokWLoGbNmg81AaROHXJnVZ6Rwo5NXjh0X2gn+XQXIycnEbp1qtopSw/QPHZxgDEvDZuG/6YbPNWoi04CqGNrRftNCSASIDx5c7uhypsq/tvtFVL1gQvh8PkbgCQGT8Ke+n6ZcurhPMarUUyqa0iz+aoigFYe1CJ/meypDM9as+SUAKrCFIq6KQFEL1uUMkLpDIyrvGyfj7ih5zqaJoiETh+oz4dJxFelfaV6ma+PXWs40GD69MmC0KaqtQySqs/Nhq+ENYcuwA8tSgFKhtAkbhsaFM4Iw1uWtl06RDvFukWlQLAwHZ93JmwwdBFp0iHcND8lGWbi87aNDnOGeTtOG7FyUbB8wMxd0LhEJvj2RZ8o+b4z16DOoMWu31/Z1AErcoqpDIf8nmVNnRiWdqkFcuxnmYBTG3KnAuU6Q8IE8BEggKNHj4aOHTvCpUuB4ZPwOnfw4MHQunVry7nwKBBA2TNV7rD8AosTQ7N4pjovj24eXbKGixYuXiLpnhY6XZzotYLch9GtykCtAhlsu2bWJ1p3qAK0mzVu67HL8PRQH0FCb9Hc6cxFwOU6ZPvBql8t1BoHs7bI0TrcEsBaXy8ywp5haLaJESd8qmeiF+Rva32h62SpkWV7zwF62WJoN7STxUgxqI/5x4Zj0PH3zVGqsxJGF+MuTtXM+o+mAHh12bxsVuj+pH0oLqvwdmg7e/WmT6YFvWynrDsKo5YdNEIWikgrGLoMRatF+vPtStBkmI8ACu09OmepVyf9u44OpqrPL49aBcv3nQeVCYXQKdX1JBXtQYL7a5vy8OR3SwO0AOkVffvx62HW9lMBTXJqK0YlsZyWtV0oQpxBhS0l9G7IG7XZxPJer3+xDpkACvvOjpM3+fVGMZ+MP41GEgq5MiaAjwAB7N+/P4wdOxb27In05sTJlC9fPoP84fWuVXJCAG/dugX4n0g4gbJmzQqXL1+G5MnVosshXgOM6mXPVPmZMkkSTiO4sfZvUjSkTdQlgPvOXIU6g5ZoEY+83Wf4tdKcEkBViDLxUFW8URU4Zn2S43Q6bZuXgaAE0C4KjPwcSgCLSQAfAAAgAElEQVTRCaL6wEX+LG42RTkc2ls1csPHDZzbANb+ZhHsjwgFZYUNatv9stJ3lSSui0V+efMR0UJUp39YxkqqRJTRibWMntDx0IhPI9GTDjl7mqQJ4XyEYxcSwMlrjxqek0iqm5XJCkcv3jBOgkQsZyyPJPiZocuNqjDKSKXcaeGF4Stg7aGLxt+o6QfFQScSjqo74hp5ULPi0LRUFn8WPFl+b+JGg8TrepLiPEYzi4/q5zfEzJ/6fmmAMDZ10mkzbh3M2+mLfS6SXQx0uf2665PGMIY9izBHaVgkI/z4iu90lQpz47+drkETVh+G7n9u8/fFaXkVCPK7Jq7335m4wRA2F0l+FrUhR4H6lEkSBhVjJoAxmAD26tULevfubTnga9euhTlz5sC4ceNg9+7dAXnz5s0Lb7zxBnzyySeWdTghgGZtim4CKHumyh2WFfq/mbPbkJJ4rWJ26N24SFBfKrMFFjcplEaxSrqLsRcCqApRJto0tnVZqJE/MOC83YJGF63Fe87Ca6PXBCxoc3ecBiRYGHoulOHhthy75N/0dfTWaL8oeUQ1/lrfRF4hOY0MgfViMPpy/eb7H+GWAIoQYqoxQI/tj6b4TvC+fK6o36t9SvuKUDZHan8RefMRUjFmBNCqv2jjiWRNRCUJ1otjJuaO9eNV6KkrPltljO7z25qjhoMH9ayWzRJQNkdclwu7POq8RKOYUBw+aVjAOFl0mlqNWQOLdp+Fr54vZpBSkWjdL5XLCgOaFnNadRQCSKNFyKddWLnTKB66a47jhoehgFBzoKLkb/6yDnDNEckpgbNycnPbJfldE3qdr45eA0v2nDVtK72ODoVJDRPAGEwAz507B/ifJWHIkcPw5A3XFXBMPQGkAscqvEToHfGbOAVD2yE0/A5lEi8/6oOhTphVovqEVgtXnm4zXOvUDZy9KyCiA23PuNfLQfV86WzhMNs0/tx4DDpMjrxWxD6IvLp12z7cJAMlgKqIDFb1yuSx7uDIk1insWHxOdQbGv/tlgDKHqC0D6gZJkjm+DfKQcuffcR70psVoGLuyHBjKqJHx0XGxemG6Xa8aDkzeRvMg/ZSRy/8Z2TH9wdDyI1beRhEJBuD9Jy6CvWH+MYMTzhRZDd3txnGvxGbqnnTgVAKwL/VyJ8OxrYuZ/xOo0boOEGp+itOnWQdTYq9nUi7GY6fTNviv97HPPRjFj+28KOLJqfz9WEmgP/beBw+nLzJsAfF63JM7cavMzQxRXI6n62E7t3OdfkdRC/uca+XhSe/C7TpldtK3wvq/e22HXI5JoAxmADqDrJwAlm9ejWUK+db1PD/K1SoEGucQPBLCQPVvzTSF09UTtlSJ4ElXWr6/yykUOS4oLqYO8knXn6h/m5VduiCvfD1HN9VfqgIoDj9VLUDIztghAe7ZLZpFOs1G65E2GuJPoi8OhIzds+1+p2SOKs40Ko6qA4dkgz0vBRJ1wYI7R+3HL0Mv7xRDl4asQrWHfZdN2JySwBlD1DadtRsK/zZbONPv75RHvr+u8PQi8P/r5I3UnD6YSCA2AezE0nq0DHq1TKwaM8Z+HXVEaCxrPecvgr1Iki7kDIR9Yk5Td8t/MjBDxL63LqFfKHX3JxSt/1lHczZcRpQSPnl8tmNeuVTTTwB/7BOPsdTHEnAy6NW+/XgRLQR6r1LK9Wdr1hGrsMpWXLcmSAXmLn1JLwVEdlI3F68PWE9zNgaaRfptE90ntitw7rdkec2mjUUz5rS73wk6lG1NWfXf+HBAwBZJFr32Vb5mAA+AgQQBxhlYE6cOAE//fSTMd4oA5M9e3a/DMzx48ehdu3a8Msvv/hJ4qlTpwD/W7duHbz55puwZMkSSJYsGWTLlg1Sp468QnqYJpDZJkJf5GMXb0CVL31G/iIcWjBeJrM6RJsaFc0Iw1629gIMBwEcNGc3fLdgn7K54rTEDg8zAijjj/ZzObv6TmKGv1IaGhTJaFe1698piXPiCYsPpBEx6PUh/ra1Vz1Ilsg+VrToO54iiU1JdMYtAZQdACg4eFWbt/tM409IeDv9vtlwFpCv8R9mAijkc0Qf8KQnW5okhkMMRrH5oE5eo/9WBFDgQd8tEWaNnrAMbVESniqWydX8e+vX9TBz2ymgoRRlLUi3EjPYICoXIuY2la+hjVY5C6ATEH70YlzmktlS+bOjgHyLkav9/3ZKllyBFcRCC3adhtfHrgtof+Ohy2Dzscuu+4Q2eWibJ1IwMJHfwSQJI7UtKRyqZ+FJNtrT6oiIO4WWCeAjQgAvXLgQRQh66NChfmHnQ4cOQc6cOWHhwoVQo0YNY56Y2fONGTMGWrVqpTWXYtoE0iGA5fvPg9NXfI4sdBPR6rCLTBuOXDSurbo0KOAXcDWrhl5TheoEcPDcPUYsVVVS6Zip8ukSQLRHyv/pLKMKXftCFxAbRVAW4sURvhPgf9+vAoUzpdCuauORi36v0envVIbGP/gcCDDpyi9YzT23J800GLzcGSTXSDpOXr5pyKCIjY96cludEmH8bDlVyJUafmurju6hDabLjKrrbuGAI9vSTVpzFD6qlw/erWVPAIVjE7UTFjcC1Pnk82eLQMsKvtM7p+ndiRuMSCyfPV0IWlfOaRSXPZv7NC4Mr1bM4bRqIz+NGCHCAprNN9lBh4YlxPjJe/s18rcB5VTa/BJIoFw1MJoKrdh3DlqMCiSwMi5OCZy4VsYu0atlL120Whtovaq25us+E27fux8g/+OlLbRsTNu/g9UvJ/U8EkLQTjoczLwxbQLpEECap0uD/PB2jTzBhMRTXboEcOzyg9Dr7x3gRmplyLw9MGSemgDqxqvVJYBojyRisIbaBpCeiNDYuToDgiS9aYRsCL1yxLK68guhIIAf/LYRpm86oeyCvFk0GbYcNh65FHDSajbWGDoL9fRoQnmRTCkTa3vu6uDqJI983Z0icQIDe0wU2+ZlssLkdUehc/388E5N37tL9SflK+CfXysDtQtmgOX7zhlXqSIhflSAWkRbcdJmkVeME9URvHLzDhTrNcdfnReC2fefHYb0DSb8QMHrQxonlrZZ1jKctv4YdIpwFsJ8dN7M2nYK2v+6PgATN/2PrjLrD1+A535cGdB+rwRQOJag89GizjUM/U2vibYJ1+wdJ68YskFyUhHA/J/OhFt374OVQLvb9sW0/dttP7yUYwLoAb2YNoGcEkC3ul8eILMs+t38vTBorr0NIFaCIcIwXJRTmyX6DLkxQjLDrn9iU0n2WHzY2ru+P7tsgE0JYKhPAOnJroida9cP8TslgCgcjJurSFYRL2j9VnOvXfVc0LVhQd3m+PPduXff8KAWmnbiB9XJRNNhy2HDkUtQp2AGGPWaL7zhZ9O3GQ4TcsKToDv3HgT82anzgOPO2BSQr7vRHq9eYZ/JgMAWYwM/XyoLTFl/zJDVwat1TJQACi/Ysv3mwdmrt/yxc1VhGWnkGqcnRbQ7Qs+NyshcvnEHiveJJIDUPtApdvSqEzUO8RqXzneqAylLW8lOX7SfC3edgdZj1/qb4wUDp30KRn4q34T1qZybnPZJyMAEM0yo6oPZzDRDxqVgj1nw35174DS+uQ6+MW3/1mlzsPMwAfSAaEybQE4JIL2y8QBD0IrqegF7eSA9ZZTrEaK5dvWjTdELw1dCzrRJAaNuiCQbUK/4pBZUioiqoasxaPdss9/L9ZsHZ676rvbFKYluXesPX/RHjkAvWupMpKu/ZUkAq+WCro2cE0DRfrlulT3Z8z+uMBxPaFzUzlM2G2RJTiobpOiOAyvr3VGxadH/pAnjQYMiT8C0Dcega8MC0C5CsoVqaAoCeOvuPbh5+z6kSOKz31SFZdx/9hrU/mYxJE8UH7b0ivyQ0Z03Ih/K8eCJKtosvlUjjxGTXBYDH9C0KGD8ZDeJth1PqEtnTxVwKope78IJRtYbtDoR+2fLCXh34saHlgBSoWTsBLU5Fp1ySgCdRm7RGU8vBLBwz1lw/fY9cBrfXKddMW3/1mlzsPMwAfSAaEybQE9/vwy2Ho80AKZdEwsBfRmp0bYHGIJWFE8NMJoFOkt080AYrBpESaacb3LbClA+V6SEiFk94uole5oksLhzpHe1bF+I5LDm1z5RZd0oI27BFCc+WN7pdR69SkIv2ld+jrwq3NijLqRKai/AakUAZZyc9lGuW+VROmLJfug/YxfUKZgeRr1W1niEWZuQSOGmQpMbvUOn/bDKL9s7qgggSimhNz2GvaOn9zT8l5UOnrwRC+eR1EkTAuqsuU2yVAuewn7xXFEo03eev0rUamxe1h0BxErwPTp47roRFlCObUwJII1zrJoDlOgjaRVakpjXKVlyi1cwy9GPHOoY5ZoArjwEPaZvBx2nPd1+0NjCqn3Iqq0i/rfT+OY6bYtp+7dOm4OdhwmgB0Rj2gTCL0I0fEcyICfVi1c+Z2qY3C56jN7NYMevfafXuk6G0IoAiripdvWJK9OsETEtRX5ZZJoSQGGLZVe329/L9J0L567dNorL0TDs6lx36AI8P9x37YtX1a3GRF6L6US9UG20ZvPPri2q32UipyLq1IbOapPB+lVXwNG9+cvem/TjDGMzo8kDij8fPH/diJ6AHq2vVfI5VVACKMdTpXjKBFDEgBbi2G7GBsugLR0SKXT8EInqNOLfZJFop88SYQFVsY1RGkboINK4uKp5SeWYuv6xFSatOeJvSnTPAaeYYH5q5oAe+0WJ3SX+7rRP41Ycgs/+2m7EdMbYzsFIO05cMbywOzfID6UivLB1r4CFtBYVAA9Gm7COmLZ/B6tfTuphAugELSlvTJ1AVi8X/U0EXPcAwUNX9MdF++HLWbuU7baL8SoKCdkUEdNS/L3/jJ0wYskBf900qoYcJivYwNGv7GlvVYTS2fWkjLAd4kob/x+15qhnpK4Aq9UJINWsc9NvuW7VdZDuNZPZ851ulG76YVWmw+RNxsmeSK9UyAZ9n/WFaRResCjbtPPkFZi38wxQ0WW3BFBoR6It7YqutT13iY4BynaU7x8ZDQYjt6DzjdskwgIK8k+fRQmgHHNYnjsYN/mFiGglXh0m3PYlmOVoaEv6wSme4TSUo4gEQsMFBrO9oi5dAliizxy4dOMOOA1vqdPmmLp/67Q9WHmYAHpAMqZOIF0C2LpyDvjs6cIeEHj4itLg73LrdYmT2cbZ++/tMGb5IX+1uGjVGRQZVi2UJEMslPhwXSIrGrrm4AW/48fwV0pB+18jdcAwfB+G8bNKV2/eiXLyIPKjY02FnGkgrmZcXNVz5PmsMgj3QgBzp0sK8ztF2nJGx6xGJ42l+85B64jTV6obKQggngBuPnYJlu49B4ObF4cmJX2EihJAq6tsGSNh+ykLxbvtP61/ZddaUHHAAn9VXj+ARFhAEenFjADKJ1fy3KEnkY8CAaS3DrKGJ4K/v38jR57to5cdhD7/Z+88oKOoujj+p1fpvbcA0nvvPaiIwCcioCBIVRQQpEtHUKSDFKmK0nsPhB5CJxBIKEkgdEjoocN37iSzmZ1smd23m+zu3HcOR5O8NzPvN3fm/ee+9+7dfB4tyubC9Hbl7TUFq+20CkD5w9bW9JZWL4A9gBIiFoBaLMVMHVcVgHJuTuVlm5oWOzqkIbKlSylAwP2aymvFTF25vMDcWq/k3XdqD6oyXhkdg9JWNfojNq2aMwWgMguJ1qlsuZ/+IRFoGxNDsGaRzEYhGrRE4FfHUzNld9aYWvq7vQJQnjo1d+wMqZOBAgvTGjhHhLsQ6SO1vfv4BarEeM2UIle2K9pkcSz0AY6GRWJ2+wpoXjqndEp5Mwf9vy1TwLLwL5Q1DfY4QAAr7xOF7SD+cpnathxals9tN6KmU/Yj+M4TUKimigUyGuJr0gGVHsA+Db3Qr3FsxhFlEGmqq1yL6AkC8PcdwZjpGx3Ynnb/0xpqZbF1beuCAyEYu+UCWpbLhalfJLwAlJe2yBlg7DYgEw1ddfx2ZB+tHYsFoDVCFv7uqgZ09vqjOC8CEh/KXWNaQ54I4HHJpvP3h2Dc1gsmr03r2jla09J8+gGo106pw47QV6syr64zBWDpkTvwJCYNndbNLDIEZRBpNRgtHwmUmWLIurMmmTqizxQaiML3yEWrB/D7f09h0xnTcQTpWI7yfDnK0Clsi7x+l3aQU1xCKrJnuVe9wjh0JQKU9YWm6huVyC79PeTeUzSYHO1p1iIAkydJjIvjvCEHEi6aPS129q0r3A2loKJ7VHtSdMYhKqKpEOVA2bRJKej2Y0mkyIUywXRaeAy3H7+Icx61V16eOleHxaFjOcJWhSHaeADls0Gbv1oqgrjToWzd3S6/H9WbaWy8LKvVy47aKa1Xp0IhZwY0LY4i2dLGaSdvbqMUlbQJypHFVcdvR/bR2rFYAFojZOHvrmpA5gTghtM38MN/p6UeHRncEDnS68v7R/2Wv3BN3Vatu2dpAGo29QCypE2O48Nid0+O2HAOSxVx55S7E509wFBmC3kRvjxNptW0/a5EmM0jrSUFk6X1f44YVOXNCnJ/Dv5cH3kypjbqnqkpYHVeVDWPKgUyYWUP19kEpQzMrBTeozedx8JDoSABePDyfQRcf2S0q1wpAC3tAv5m8TEp/2rZPOmx4bta2HfxHr5eeBQlcqbD1h9qazUXs/WU92B3/7pSiBm5zGhXHrQ+z97SfNoBKYAw5Tae4nNRCvqtFICTd17ErvN3MP6z0qBYgHJRewDlcDTqTCUpkiZG8Fhvey8vwdqtPB6OgasDpPOrg7jT786PborUyZNqvr65+65gwrYgo3BKmhvbUJGy0IRFPEPqZEml9IbmihzvUfnBY8NpLFZ11fHbUf3TchwWgFoomanjqgakFoAU9+z86GZQpvm5PM4bSZMkFui9ezaV17iYunqtnjNz4TOGrT+Lv4/E7ipUTk3R+RwhhsxRLzFiO6JiQptozWgiH0udE1V5Di0fCs4WgHQ9ylzHpgSgLJKUnNWBudXsXG0XfMTTl6gYEzpFufmGdlBSKjcK/Hzw0n0p1NOizpVRv1g2qUsUHkUON2TJ4yMLPvIA0sfftcgoAxJH2KbSDsjjJ39s0klEcg1TezlQNu1Sn7g9WNoMI5fAUU0lDzRljVFnAhm8NgCUOk8uckBqZZzCbnUKgYJJF8oa1wPl6m85Zaq7VT2qS/FJlUVrLm+5jbxGmjbs0MadhC41JuzGzUcv8Fn53JjStpxDL8dVx2+HdtLKwVgACtB2VQNSC0B5ykceAJwtRgSQOr2pvMvN1Im0hmqRA+/SGrLTI6LTdVEZuu4s/vGPFYA0bUHhSeTiiEHWHKDiw7fhxet30p+15jSWj6XOKao8By3mz5k+eirSXIkPAfgw6hXKjd4lXYKpKWClZ5c43370AtUmxO5CVV47PQ+UX7R6ocz4t1s1p9uc1hMop4ApLh+tTaQiC0DKqXzg0j0E3nwMZWrBd+/eo9Wcw1IA5mVdqpgNo3Q1IloovjNOgiKdwxG2qfa2KfstGnNUjnFKwnfUxkCERUSLV/II1imaFXJIF1r/R+sA5SIHqZZ/HtuyFDpUy4+7T16gyrjdoOwqoRM+0nqLXLKevEOaAtnL+cDlC9WaylGuP3vvZUzaHozPK+XBpDYJLwDJI0mheijkkZxn2lE3wVXHb0f1T8txWABqoWSmjqsakDpFEG3ADJnwEeSUSvIUkEDX3bapHOfKVAe0CkBzGRTIC0Hr4eRCGwxoraBcHDHImgMv58ykv5MIqO2VVfM9UueJVTZUrkUzd8D4EIDK3LKmwsDI+aFlMWPpmmQBWKNwZiz/1nUEoHITiDIFn5wLl1Lq7b94X/J+qe8xxc+kYi2G5s2Hz3Hr0Qup7ld/+RsCYjvCNuWA4nkzpUJ45HMjcxFNOynHSaSA6gNXn5XyGFORPaVKkTzIu7jh3D/+dwrrFfmku9QqCMokQ3EVaZNK8qSJpXWT7lzkHdK0rpu8ncp1r1oDucv9l+OkUs7piW3KuDMWq9fuquO31Qt3YAUWgAIwXdWAwu4/Q72YDBRy90LGN8euC3fQfdkJVMiXAWt71RToufs2XeoXhhEbAk12QKsAlKfc1LmA1YFlt/SphY+mx+7Kc8Qga4580aHbJK8WFdkrovUu0bSiMvuHsp2WJOzmxJZI+i/1tT97+QYlf9kh/dpUVgB5Wp7+biollvJ4SRInAk2dmcoprJWZM+rdevTcEDolYGQTpEsZncZt3JbzmH8gFCQA9wXfQ9DtJ6DNELW8sghdhnKXtCNsUw6QTptrlNPLdJEDmhZD7/pF7L5e2txA8TdpLVif/04ZljvI1z1h6wXM3R8Cms5VZhGS1z0qT0xtyBta97e9oKwwgaOb2X1drtBQuUGG1gRuVGx8Uu+KVl4v5TSnpQXzvqpoWFMrp7NsVyUvJrRiAegK99eZ18ACUICuqwpA6pJ6UKbF4bsv3EWvf06iSsFMoFAheixyrktTfdcqAM0NHur1Ruq4XI4YZM3dM6+hW/H6bbQXiNZJ1YtZH6blHtO0Yse/jpqsamq9nbqiOQHoyP7SovHiw7dLpzaVFSDy2StQzDAq9LFTaMhWq12v7ZUFy7pUtVovviood+kr47fJAcaVGUxsXedpqg+mUnSJ9FUZIJ08bMrSp0ER9GtSzO7Dt5p9CCevPcS8jhWl/L3yx45sY3JA5K61CmLYxyUM5zEXb87cMg67LzABG8obZGhZAKW3U+98N/ccymyyp0sB/yGNpB7Iv/MulQNzOlRMwF45/9SuPH47v/fRZ2ABKEDalQ1IvSO1UJY0qEZTXv7X4GpTXwK3wOamfx+5imHrz5lsp1UAhkdGSSEuUiVLggtjYr0H6pyo8SkACw/ZKnm1qCzqVBn1i0dvENBS9l+8h68WmhaAptbbqY8ZHwLw5Zu3hthvprICKNcI0ganIkO3We26qwlAumAKqp04USKkSRG7c3PlsXAMXBO901Mutu70NgVDDpFSuUBGrOpRwyovaxWUG3XUddWeOWvHUv+9zZzDOH71AShA9vZzt6Rp3dK502PT97WkqnJAZHVwe3MCUA7llCVtCmka2Z2LYX1kp8pYc/I6NgfcMuqOKQGoniWS15ya2k3vzmwsXbsrj9/xxZwFoABpVzYgmjJb4hcmLeiVC+0Gpp2itGiapgn1WCzFrKP1RQ2KR8dWs1SuP4hCrYm+UIeOGLj6DFYev25ouvG7mmgx85DhZ0d6xNTXV3DwFsQsA8P8ryqhcUyMOGt9ob8rNwep67uKAFTGbTOVFeBR1GuUHb1TunwKfuulEIC00F9mo+xf/sypsW9AfS2IErwOLTv4eXWAFASaCi34r1Yos9B1kVeVwsLULJIF6VNFTzeLFHnzGa05Vm80sdUrrb6Oz//0k/o+p30FbA+8HWfH7+SdwZix5zI61SiAkS1isxuZE4DyR4+jYiCKcBNt++msQ4bYkOtO35ByRSuL/N4h0UspB39qWkyKwUcbZORCEQsoI47yw8mZ7yvRPjuivSuP347on5ZjsADUQslMHXcwIIp3RdHiFx+OTVHWoHg2LOxUWaDn7tuUdpTRWj1TRasHkBbS16AF5DEBdelYyrAS8rE39K4JejnLxZkvVOVAp8wSoeVOWRKApjZcqI8ZHx5A2uRQcHD0tK6prADKTSK03KHYsOjpYiok1F++iV4fqS7OvCda2NtSR7nEwNZsL7acx9666s1ndBx613xbuxCqFcpkdYOKpfN+PtcPlLlk1pcVQGIv5P4zjPykBDrVLCg1kwMid6yWH2NaljIcypwAXHU8HANWB3jEx7A8PT63Y0VsPH0TW86aFoB1Jvka1mbS/TgSEv0xQYXW6zYsns2QiYZ+507Phj026w7jtz39sqUNC0BbaKnquosB0UJf2iUnlyYlsmPeV5UEeu6+TVccu4af14gJQDnESNLEiXB5fHMJRv+VZ6TpF2VRR+Z35gtVHYPt03La027tDb6LTjE5aNV3dt+AesifOY3FGx4fApAuQD6PMkaefGHKwL4UC09eL0h/p806T16+MdkHZ94TRz8lyjiTtuZ7dvS1mDqePK2q/Js6Lp+91/HFPD9JsCjjCyo3lkz1uYipPpfQvmo+jPustFUBKC8FoSwUczu697swdnq8grQBZOvZ20aYZRtXBov/unp+LFEEracGtLZWzijDAtBeS3WvdiwABe6XuwhA9bq35qVzYHZ7z17ga+62mlpPJdfVOgWsDNchv1zlXYrK867rVQOfzT5s+JUzxYZShP3Wpgz+VymvZsv2Db6LzmYEoKkdt+oDx5cAPHXtgbSEgaYs1UW5S5iyH5QYEb1jmArF06NNIqaKM++J5hugsaK80YGqaw1arvHQDqkmZ8hRHuynJkXxXYPYuHz2nujL+Udw+EoEJrUpY8h8QbuiB3t/KB1yxu5LmLzrItpVySd5s+Ty4fDteP76rdFp6QNhxbFw/LIxEB+VzolZ7SvYe1ku0U7pHd0ccBPbzpkWgMpQUd83KCJNmStL9zqFpJ3UVCiUz4GBDVyif866CHcZv53VfzouC0ABuu5iQPP2X8H4rUGGnrYomwvT2zkv0bcAUqc3lad+TJ1IqwBUpuyiaZemJXNAnoZRHpdyC7dKAAGoTodlDapv0F10XnzMZDXfn+qhYBbX8ABa6sfzV2/x4YjoaV8KoVJmZPR6QCo50qWU8sSaKu4kAOUYbdQPrcsVrN17R/5dGYpHPq5o/D/5OB0W+Etp8PJkTIXrD6J3GFNqvIHNomP+mYtfpwyQLh+LnksKpzNt9yV8Wi4Xpn3h3u/CdvOOwC8kQnqnbzt7y6wAVH6omVqnSWtir8YE2HbFDVKOtFU6lruM347ut/J4LAAF6LqLATWYvBch954ZeursRN8CSJ3elF6QPf85afI8WgWgMmVX7gypQLHyKo31MQSnlQ++pmd1tJ4Tm5rJmWJD+XIf1aKkFDlfa2o+aPwAACAASURBVJEDhJuqbyrkirpefHkALfVHGSaGdjTKIWGozTc1C2JTwE3Q+jDyfjf6Y790KDkrhFZOCV1PztNK1/FnhwpoVipnQl+S0fnl0CrKX9qai9Zch9QZPageebH6x4SWkTNY/K9iHvwWk8LMXMgndco0Zz6X8XGDZHE8tW05LDocJm0IURa5f5aCo6uvUw/rxN1l/HamDbEAFKDrLgbUdMp+BN95Yuipq6T5EUBvd1OlUFAehHZIHxvayCj8hrmTqDd8qNecye1onVYbRW5OZw40yiwktq672n3hDrosOW6yu7v710VhKzlSTXk/6WDO7K/6YpUx9Ga0K4/v/z1lqEKZH76pWUDahHDn8QtUHR+dIs6RgartNkgbGhoLwIpoViqHDa2dX1XOkGNKfIiendZ4UsByOQQMHe/HRl74sVFR6dAym3QpkyJ3xtSS2KdnwlShGIpfLvA3/Ck+7VSUg6n2FMKJdjWT599Un3f2rQPaod1fsevX2nXIOZOt1XPnv7vL+O1MxiwABei6iwGppz3V62QEELhlU/WXcJUCmfB316pSWigtRRlzjur7D2loEBXK9vHpaZB3QdL5BzYrhl71tGdd8Dl/B12XmhaApmLuqRmZ2gAT3wLw9dt3RqFflNeo9Igq129ObF0abSvn03LLXaLOzsDb6LbsRLTgiVl64BIXFnMRcoYcZwhA+ZjKDW39GxfF9zF5f7eevSUFuddSKIuKMvONuwvAzouOwjf4npaua66jDESuuZGbVXSX8duZWFkACtB1FwNSh2fQQ55HS7dVLQCrF8qMf7tpzwlLMbTKjopdY0ZesoaT98U5JYXqoAXacnHmQCPHQaNz9W1UFD800r7wftf5O/jWrACsgyLZPrD4lFBssXWnbsSp48z+qk9GYWIotZc6BRnVU0713nvyEpXH+UjNaUPB5zZslhF4VTikqTIUjisKQFMpKB1tAwsPhmJ0TEQD5S5gYhN48zGOhUVi1KbYiAcyeFr2sjbGRrf9UBve0+InR7dDbryVgyw6FB3lQR170d5z6yVTlLuM3/beRy3tWABqoWSmjrsYUODNR0Y5aak7jn4xC2CM96ZqAWhrTlhlzDm6eJouGboubnYR2qnZdt6ReBGAv+0IwizfK9K5vqtfRAr2qrUoPUvqNjR9VDS7ZQHY599TRvlH40PwmuobTRNSflPa3aksyk0xyg08tu6W1srTmfVk23VFAUjZWppM2W/YSOCM94zSzgd5F0ePuoWNcNNOceXOe/mPtE6Xch9ToTiSTadGrwP1lIgItASCNkLJwdBFbNATNsZo6b+7jN9a+mJvHRaA9pJzo11EpuJzsQCMvfEUFPW/btpzIytjztFRKDht7+Vxp5+UISuoXuiE5kLBcC2Z6sTtQZizN1oAKsNjaDHvHYG30T1malFdX0sOV+q7OvuAMwZ/LX3xuxKBdvNjRTe1+bVVaXxRJXqqV+kB7NPQC/0aR68hc5ciC0DKidukpGutASSGyowtzrCBtnP94B8aHcDY1FpXc+noKHZks6kHpI1ay7pUMeS+pswi3qVdazONvbaoTJcoH4MyvNCMhS1FL5sEWQByGBhbnos4dd3FgEzF52IBaHw7beGhjDlHR5n5ZXkpQb26kGeRQlfIJWR8cySm+AtOKBO2XcDcfdExvGwVgNvP3UaPv6PXlqlLvWJZsbiz5bSBPf8+ESf0hDMGfy3YjodFGm28oTaTWpfB55Wj4yLeePjc4AlqVSE3/vi8nJbDukwdVxeABMqZ+WSX+YVh+IZoD68pAWhuOcOZEU3QeMo+3H3yUsonLNu7JwlAU+tgKVTO7JgPQ61GrNxJrbWNO9Zzl/HbmWzZAyhA110MyFR8LlsEjwAil2xqLj2U1otVC0CKv0XToOqiFoDOXFg9fusFzIsJ4koBXQc3jw6Qq6XQzsoef5teQE8bZFb2sOwd7bb0OHaevxPnVAlhY6fDH4KCcivL7/8rizYV80i/inr1xhAk+qvq+TH609i0YVpYJXQdvQvAE1cjDaGVlGsA5ftiLvQLhaOp//te3Hn8EpQqUd4w4sxnMr5t5e279yg8JDpdImUpevPuPXrXL2xYGqL1er6onBe/ti6jtbrb1nOX8duZgFkACtB1FwO6dOcJGk+JXvNCxVHBWQXQJWhTUQGoDiWjTE9lqWOXxnkjWRJtO41tBTRuy3nMPxAqNbNVAFqKjUjHsybkui45Dp8Ld6SwKtN3X8KtR9FBl621s7WPWuoHXH+IFjONBSB5fJQhU+T7/3Oz4uhZz3gNmZZzJGQd+drnf1UJjUtkT8hLMXtuZ3oAlV4uU1P4lC9YufFKvkiyxeoTdku2KYcJSpsiKc6NauqSDO25qHfv3qNQjAAslDWNFPuV8vvuDrpr8nBdahUE7apWl041CmBki5L2XIJbtXGX8duZUFkACtB1FwNShy1xxUTyArfB5qamsgPYKlbkQY7SjP3ySQn88N9pq9dxcay35lAzVg+mqkC7AOWXebc6hTDEBg+gtRAayjV0pq7rm8XHsCforjTV+vvOYGmaLaEEoKm8xuoNE7RRhKYKp35RDimTJbEVdYLWl+3uwMD6yJspdYJei7mTkz1RaCDyjDtDpJYZuQOPX7zBmp41UDF/RqPLUO/QVwpA2gRCSwDkDzbKEX3WgwSgcpe4FsMwt3TF1veHlnO5Yh13Gb+dyY4FoABddzIg5Vc5ZaiomD+TQM/du6mp/KC2CkA5MwF9RZfOnR4/rrAuAClgtLMEx6hNgVh0KEy6Mba+wGkDh6lNLMq7bInP1wuPYt/Fe6CpVvImyh4HW5k6wqpMrQFzxR2z9vY1PDJKymtcNm8Gew8RL+1oOjKJk9a7Pop6jfAHUSiVO32cvjx58RqlFWkAqULG1MlwakQT1Jq4R0oj98fnZdFv5RlQ0OiAkZ7jAaS+2pLtQ7kWUgky2wcpcHRoo3ixk4Q8iTuN387ixAJQgKw7GZDX0K14/fa91Nv1vWuinIsPIAK3xWrTEiO2I+qVcYJ4W8XKpO1B0uLqzjULSAKQBhRrxZkCcOTGQCw+HC0Av61dEEM/KmHtcgx/FxWAHf/yx4FL9zGlbVnU9soq7UZuWzmv1fAxmi/QhoqyByhZkkQGe/ckAWgDCl1WVa/PJQiLOlVG/eLZUHvSHoRHPpdyW1PQ6hRJEyN4rLdHcbr75AUoJEytib5W+7Xgq0omA8AnT5IYF8d5FhdTMNxp/LZ6M+2swALQTnDUzJ0MSCkAN31XC6XzxP16FkDhVk0/nnEA5248NrpmewUgHYQCa684Hm6VgaPyopo60YgN57DU76rhT7b0Z3PATZO7mJXnsXS8L+cfweErEdLU2qflclvl4OwKFKeRBvdiw7ZLp2IB6GzirnN8ioX34Yjo+y4X2Xbr/uZrFKOQ/m7Lc+I6vbR+JVo8gYs6V0bnRcfiHMzTpsbN0XKn8dv6HbevBgtA+7hJrdzJgJQCcEufWiiZS78C0BFhcWbuuYTfd160yXoCRzXVlGvYpoPGVB62/iz+PnLNLgG46cxNo9y5ps6vHChpGpKmfGlnLU1py7HZaE3Rx2Vy2XP5TmnjykGTndJhPijU6+BoDSJtmKFCu4DJ82dKHHoaOi0CUBkPUdn/LGmT4/iwxp6GJE5/3Gn8dtbNYAEoQNadDEgpACkV0oc50wn03P2bVhrrIwWFlYutnoCrEc8wdssFaTOB1nJ2ZBN8kDKZ1uo21Ru67iz+8bdPAG48c9NkGBtzA6W8iUbOOPK/Pw/jWNgDuFpMtVazD+Hczcc4MayR07jbdJO4crwQUIqfL6vmA2WCodJg8l5pZywLwGgCy7+tii/n+8e5JwUyp8beAfXj5V4l5Encafx2FicWgAJk3cmAlAJwa5/aKJFL3wKw2vjduP04OlwJFVsFILWxddddwMgmSOckATh47Vn8e9Q+Abjh9A2ru5iVfOQBtny+DFjXqyZIaJ289tDlplopLMbrd++QIql77fQVeCVxU9VGCNqkNfzj6PWwDSfvxRWdCMBZvpfx245gi/agzlUuV6bd2y3Kuo4n31lG7U7jt7MYsAAUIOtOBqR8IWz+vpbJHXQCKNyu6dx9VzBhW5CQAKTGWqZa5JNQNoL0qZ3jARy0JgD/HYtdh2iLoLVXAFbIlwFre9XEp7MOgVJw0aLyRi4am87tDJQv2G4CymdSmRe72dT9CLr9xOi4tjwndl9QAjS8fPcJGv0RG/vV1CVQGJ3Wcw7H+dN/3aqhWqHMCXDV8XtKdxq/nUWGBaAAWXcyIGWOzo3f1USZPK4dRkLgtmhu6oiAtbYIwNMjGiND6uSar09dkYLgmgskPXD1Gaw8ft3QhGITdq5ZUNO51p+6YTWMjSkPIMVgo0HkkxkHcfbGI8NuS00n5UpMwEkElM+kMig6LXWgtbsX7zwV/vBz0qU79LCmYmIqT7Chd/THm7qs6FYNVVkAOvReuOrBWAAK3Bl3EoDK6Uq9h4GRb3l8C8CTwxuDAkfbU+RgzZPalMHnlaLz2iqLHJdQ+Tut3o11p66j7wrLYWwsCcCPph9A4M3HWNy5MuoVy2ZP97gNE3AYAeVzTaEIQyZ8ZDj2nqA7+GbxcV0IQOqkpQ9Umgn6eMZBiUWejKmkGIlU9JIowJ3Gb4c9HKoDsQAUIOtuBiS/DEQ9UQLIXKqpzMO7VA7M6VDRrmuzxQNImxEyp00hfB5Twq7fytNYe/KG0bG1CsC1J69bjWNoSgBWyp8Rq3vWgPe0A7hw6zFoVyHFAeTCBBKSgPqZVNqub/Bdo9AnWp+RhOyPyLktvZ+2/1hbCoe15HAYKK3et0ujhfGqHtVRuYDnJwpwt/FbxA7MtWUBKEDV3QyIgoS+ePUO+TK7ZgopgVthV1P55SgSv84WAXhsaCNk/cA5ArDvitNYd8o+AUip0fqvst0DWLlARqzqUQNNp+xH8J0n+KdrVdQsksWue8GNmICjCFgSgBS+iDLXyEXPAtCnXx0UyfaBhEIZGmthp0poUNw180w7ykboOO42fjuy7/KxWAAKUGUDEoDnAk2dIQDzZUqNa5FRJnt3dGhDZPsgpV09tzZd/eN/p7D+9E27PICrT1wHTSFbKqY8gLIAbPzHPly6+xT/flsN1Qt7/uJxu24gN4o3AspnhdLRXRnf3HBuypdNebNZAAJ7f6qHAlnSSCiUa8QntCqNdlXyxdv9SqgT8fgNsAAUsD42IAF4LtDUGQIwb6ZUUropU8V/SENkT+ccAdjn31OgRe7KotW7sep4OAasDrBZAObOkApbf6iNsqN2Sm31snjcBUyXL8ECgRYzDyLg+iOpRvKkiXFRke6t/8ozWHMydrOU1mfEXYFbmqE4MLA+8maKnQ2S61LcRIqf6OmFx28WgEI2zgYkhC/BG8svvKlty6FleftSmMlBkOXOKBdTqzt4ZHBD5EjvHAH43fKT2Bxwy+iUoROaI1GiRFY5rzwejoF2CEA6cM0imXHocoR0Dr2sHbIKlCskKIFHUa9RdnT0R0nq5ElwfnQzw/VQ4HZ5rRv9Us8C8PCgBsiVIZWBjfw+HPdZKbSvmj9B72F8nJzHbxaAQnbGBiSEL8Eb08aJ42EPsOPHOkiV3L5gwZ//6YejYZGGvkxqXQYD15j2pqlfuLYAsDYF3Pufk9hy1lgA0tQXTYFZKxRAmgJJWyqmpoDV9df0rI6K+T1/8bg1nvz3hCXw4vVbFB8enQ9YndeW0hjWnuRruEA9C8CjQxoim2JGQn7HjG1ZCh2qsQBMWCuOn7PzFLAAZxaAAvBcpCmFx9HiJTN3uXIeXPp76wp5MPnzsmZDLxwa1AA0bWpPsSYAe/59AtvO3TY6NE190RSYtaLOimKqvjxQTvW5iKk+l0wecm2vGqiQL6O10/HfmYBTCSjXs2VInQynRzQxnO/6gyjUmqgfAXjxzhM0mWI6ILR6U5r8jhnTshQ6sgB0qo26ysFZAArcCRaAAvA8pGm7eUfgFxI9Bdq/cVF839DLrABUr7mxBYE1Adh92XHsCDTOSxw0phlSJrPu2dSyk5kEoNKzYuraKbBs2bwcYNyW+8p1HU9AGfO0eI4PsP3HOoaT3HvyEpXH+Rh+9nQPoNzRR89fI+LpS/y6LQg7Y/KXq8NSGQTgpyXRsXoBx98YFzsij988BSxkkmxAQvg8onH7BUcMa+AGNC2G3vWLOFwAqnMOmxq0ui09bnixy2AvjG6maWrbUQJw03e1UDpPeo+4r9wJ9yYg23STEtkx76tKRp0pPGQr3r57L/1OLwJQBkDrH2kdJJVTwxsjoyIwPQtA97Z5e66ePYD2UItpwwJQAJ6HNO2wwB8HL9+XetO0ZHbM7VjJrADcN6Ae8meODrtgSzkWFon//eln0WvRdclx+Fww9gAGjmqKNCmSWj2VVgH4/NVbfDgiem2VqcI5pq2i5grxRIAy5yw+FIZp7cohZ3rjZRcDVp3BqhPRO4H1JgC7LjkGnwt3pb6rc5PzJpB4Mk4XOg0LQIGbwQJQAJ6HNO34lz8OXIoWgPKAYk5QKeNu2dJ9LTsXuyw+ht1B0S92uQSMbIJ0KZNZPZWp682VPiVuPnph1K9nL9+g5C87DL8rny8DTl17aPh5a5/aKJErndXzcQUmkJAEBq8NwL9Hw3UpAMuM3IHHL95IfVe/HyZsvQAKlE1reVMnt/7hmJD30BHn5vGbp4CF7IgNSAifRzSmrAL00tQiAPf0r4tCWdPa3G+f83fQNSZNkywy1QfpvOgofINjr4P+rv7CN3diUwKwUJY0CLn/zKhfT168RumR0eE1qPSoWxh/7rti+JlSSxXPwQLQ5hvMDeKVwNB1Z/GP/zVdCkDls35uVFOk1TBDEK83Jx5PxuM3C0Ahc2MDEsLnEY07LTqKvQrhRVNK5jyAu/vXRWE7BODuC3fQZYnlBPZqIUpw1Wt8RAUgLSSXgz7TsXrWK4w5e2MF4K6+deCVPTq1FBcm4KoERmw4h6V+V3UvAM+PbqoLT585O+TxmwWg0DuKDUgIn0c0/mbxMexRTL1aEoDK3Ju2dF6LAFRPRdPx1bv8hAWgIsAuHatXvcKYrRCAPv3qokg22z2ctrDgukxAlMCoTYFYdChMlwKw/OideBD1Wuq71igBorxdtT2P3ywAhWyTDUgIn0c0Vi6qpg5ZEoD2esj2BN3BN4stewCVm1FksFpzD2udAn7w7BXKj9lluG+96xfGLN9YD6C9U9weYQjcCbchMG7Lecw/EKpLAVhhzC5EPnsl9T14bDOkSGo9TJTb3FgbL5THbxaANpqMcXU2ICF8HtFYvfvWkgCkjCPFctg+ReobdBedFx8z8DK1c1EZjkauqDX3sCkB2KpCbqw9ecPonNciolDnt9ggut3rFMLc/SGGOvYKXI8wBO6E2xCgWIDNpx/AZ+VzY0jzD93muh1xoRXH7EJEjAC8NM4byZJYDxTviPO64jF4/GYBKGSXbEBC+DyisTr+niUBaO8mCd/gu+i8yLIAVAaklsH6DW4AdQgMU9BNCcAzvzQxWu9H/Vp0KBSjNp03HKJLrYL462C0J4XK/gH1kS9zbHJ5j7jB3AmPJCCaAchdoVQa64P7T19Kl395nDeSsgDEo0ePkC6dPjevcRgYgSeZBaAAPA9p2mPZCWwPjE3BZkkA2hsmZW/wXXSyIgCVKelktFpTz6kFYPZ0KeA/pJHRZhbq14IDIRi75YLhznWuWcCwlop+qbeYah5iwtwNHRFQ5i4PndBcKA2mu2Pj8Zs9gEI2zAYkhM8jGtsSB3BLn1oomcv2TBn7L97DVwuPGniZElrKF7tcUWvqObUAlPOnqtPPUcgXSiUll041CmDx4ejF9CwAPcKcuRMeTkD5oaj3DzYev1kACj3ubEBC+DyiMYVBmbg9VhRZ8gDamynj4KX76PCXv0Wh1WbOYRy/+sCIqdbMI2oBSLHBKEbYgUv30PGvo0iTPAkCRzfDsPVn8feR6PhpVL6qnt8QToMFoEeYM3fCwwn8e/QaBq89C69sabGrX10P763l7vH4zQJQ6AFgAxLC5xGNdwTeRvdlJ6S+JEuSCJfGNcf03Zfwx66Lcfpnb67cw5fv48sFlgVgq9mHcFKRlYNO7vtTPRTMYj31nFoAyv2QN32kTp4E50c3MxvfkD2AHmHK3AkdEHj37j0otSRl7PlAQ5YgT0bC47eHCMAHDx6gT58+2Lhxo2SvLVq0wIwZM5AhQwaT9hsZGYlffvkFO3fuRHh4OLJkyYKWLVtizJgxSJ9e+xQdG5Anvx609W1n4G10ixGAOdOnhN/ghlJDUxsr+jUuij4NvbQdWFHL70oE2s0/YviNqambz2YfMkrLRpW1Bp42da10jvDIKNSe5ItUyZLgwhgWgDbfOG7ABJiAyxLg8dtDBKC3tzeuX7+OefPmScbWrVs3FChQAJs2bTJpfOfOnZMEYKdOnVCiRAlcvXoVPXr0QJkyZbB69WrNBssGpBmVx1bcfu4Wevx9Uupf7gypQBsvzAlA+r096278QyLQdp5lAfjprEM4Ex6bl5fOpTXszBfz/HAkJNLoHikFYMpkiRE0xjuOqE2eJDFevX1nUZh67I3njjEBJuDWBHj89gABeOHCBUnEHTlyBFWrVpUMkv6/evXqCAoKQrFixTQZ6apVq9ChQwc8e/YMSZNqS4TNBqQJrUdXGr3pPBYeig6F4iwBeDQ0Ep/P9bMotFrMPIiA64+MWG/8ribK5DHtBVdWNBVDkATg9QdRqDXRFymSJkbw2LgCkNYRXbr7lAWgR1s4d44JeCYBHr89QAAuXLgQ/fr1w8OHxt4Pmv6dMmUKOnfurMl6FyxYgMGDB+PevXua6lMlNiDNqDy24pB1Z7E8JrF8ba8sWNYl+iOk6ngf3HkcHW9LWezxAB4Pi0SbPy0LwI9nHMC5G4+NzrW+d02Uy2tdAH45/wgOX4mIc503Hj5HzV/3IFEioLZXVtBuZEvFnr55rGFwx5gAE3BpAjx+e4AAHD9+PBYvXoyLF40X3RctWlQSfyTqrJWIiAhUqFABHTt2xNixY81Wf/nyJeifXMiA8ubNq+tAktbYevrfB64+g5XHr0vd3PtTPRSI2XSh3BwiKgBPXnuAVrMPGw5jSmg1n3YA528ZC8C1vWqgQr6MVm+BOQH45MVrVBzrg1dvYqd5zR2Ms4BYxcwVmAATcCECLABdWACOHDkSo0aNsmgux44dkzZyLFmyBMHBwUZ1vby80KVLFwwaNMjiMcgImjRpgowZM0qbSJIlS2a2vrlr0nMkcRd6nhPkUoavP4dlR65K51YnV68+YTduPXphdF32eMlOXXuAz6wIwGZT9yPo9hOjc63pWQMV89svAOlg528+RtDtaGHZb+UZs4zt6VeC3DA+KRNgAkyAZ/AkG3DZTCD3798H/bNUaKPH8uXL7Z4CfvLkCZo2bYrUqVNj8+bNSJkypcXzsQeQ3xtqAhRS4X8x07NqEVRjwm7cdIAApM0dtMlDLqbEVtMp+xF8x1gAUpy+0Z+WsnrTTKWRM3UOU7uFLV2T1RNzBSbABJhAAhFgD6ALC0CtNiFvAvH390eVKlWkZvT/1apVs7gJhG4+ib8UKVJg69atkgi0tbAB2UrMM+uTlyx3xlRIn8rYe0zr52gdnbLY4ynTIgCbTNmHi3diN2TYIswqjd2F+09fWb1OpQCkvka9eoPXb99L7ezpl2daA/eKCTABdyDA47cHCEAyNAoDc/PmTcydO1eyOwoDkz9/fkMYmBs3bqBhw4ZYunSpJBLJ89e4cWNERUVh3bp1SJMmNlhu1qxZkSRJEk32ywakCZNuKzlKAJ4Of4iWVjyAjf7Yh8t3n+K3NmUwYHWAgbk1YRb57BUqjNkV5x5Z8wBSHtEav+4xTHFbO49ujYA7zgSYgEsS4PHbQwQgBXZWB4KeOXOmIRB0WFgYChYsCF9fX9SrVw979+5F/fr1TRplaGioFENQS2ED0kJJv3VqTdyD6w/EPYBaBGCDyXsRcu8ZVnSrZjVmoPKOqNcXWvIcqnMD1560B+GR0f1jAahfO+eeMwF3JMDjt4cIwIQyPjaghCLvHudVCiRLwspab7RsAqn/+16E3n+GVT2qG9YkahFm6ullWwSgLDq1nMdaH/nvTIAJMIH4JMDjNwtAIXtjAxLC5/GN60zyxbXIKKN+2uMp0xIHsO5vvrgaEYU1Pauj9RzLMQOVF6ROM2eLAFRuPLGnXx5vANxBJsAEXJYAj98sAIWMkw1ICJ/HN241+xBOXjMOUG6PUOq/8gzWnIyONWjO2yZ7Gyn0S+s5lmMGKsF7TzuAC6r4gebOoZ4C/mj6AQTejA4RY0+/PN4AuINMgAm4LAEev1kAChknG5AQPo9vfDXiGQasCsDRsNg8u/YIJfUOX1PHkNcbrutVw2rMQCV4c6FdLG0CyZI2OY4PayxtTKH1iSwAPd6UuYNMwOMI8PjNAlDIqNmAhPDpprHac2Zrx+UdvpY8gPKO4w29a1qNGSgqAGsWyYx/ulbDmM3n8dfB6DzI9ghbWzlwfSbABJiAowjw+M0CUMiW2ICE8OmmsagAVG62MCe25Kwjm76rhU9mHjSwtSbM7PEAygKQ4gDO3x+KZqVyoFiOD3RzP7mjTIAJuD8BHr9ZAApZMRuQED7dNBYVgPIOX0sewKrjfXDn8Uts/r4WPp7hXAFYo3BmLP+2mm7uH3eUCTABzyPA4zcLQCGrZgMSwqebxqICUN7ha0kAVh7ng3tPXmJrn9poPv2AkAcwR7qUODKkYZz7M9XnImbuuYz1vWuiVO70url/3FEmwAQ8jwCP3ywAhayaDUgIn24aiwpAdTxBysKRKFEiI37yObb9UBu0s9eSWFQ2VF5bqwq5cS0iCmNalsKHOdOZvD9v3r5D0iSJdXPvuKNMgAl4JgEev1kAClk2G5AQPt003m2JbgAAIABJREFUFhWA6owil8d5G4mwW4+eo/qEPRLPHT/WQdOp+6X/1zJVq7y2ia1Lo23lfLq5L9xRJsAE9EuAx28WgELWzwYkhE83jZUiy5T3zhoIdU7hoDHNkDJZbL7qHYG30X3ZCekwu/rWwaYzNzF9z2V0rJZf8uZZKspr+7VVaXxRhQWgtfvBf2cCTMD9CfD4zQJQyIrZgITw6aaxUmSFjG+OxImNp2+tgZB3+Mr1Akc1RZoUSQ3NlNk8aA0gCcJpuy+hQ7V8GNuytGYBOKFVabRjAWjtdvDfmQAT8AACPH6zABQyYzYgIXy6aawUgOrpWy0Q5B2+ct0/O1RAs1I5DU3P3Xhk2Pm7u39dbD5zC1N8LqJ91XwY95l2ATj+s9L4sip7ALXcE67DBJiAexPg8ZsFoJAFswEJ4dNNY+Uu3otjvZE8qW2bKOQdvjKwvo2K4odGXiYFIMX9m777Ev7YdVHy5pFXz1JRitNxn5VC+6r5dXNfuKNMgAnolwCP3ywAhayfDUgIn24aK3MCB49thhRJY9fvaYFQaewu3H/6ylD1h4Ze6Nu4qOHngOsP0WLmIeRMnxJ+gxti5p5L+H0nCcC8mNCqDAtALZC5DhNgAroiwOM3C0Ahg2cDEsKnm8Zt5hzG8asPpP6qN3BogVBhzC5EPosVgH0aFEG/JsUMTc+EP5TSv+VKnxKHBzfELN/L+G1HMNpWyouJbbQLwLEtS6FDNfYAarknXIcJMAH3JsDjNwtAIQtmAxLCp5vGn//ph6NhkVJ/z49uitTJYzdwaIHw3fKT2Bxwy1C1d/3CGNC0uOHn0+EP0XLWIeTOkAqHBjUwCMDPK+XBpDZlNXsAx3xaEh2rF9BySVyHCTABJuDWBHj8ZgEoZMBsQEL4dNO47Vw/+IdGC8Bzo5oirWIHrxYIS/3CMGJDoKFqj7qFMcg7VgCeuvYAn80+bBCAc/ZewcTtQWhTMQ9+/x8LQC2MuQ4TYAL6IsDjNwtAIYtnAxLCp5vG7eYdgV9IhNTfgJFNkC5lMpv6vvhQKEZuOm9o8139IvipaewU8MlrD9Bq9mHkzZQKBwY2wJ/7ruDXbUFoXSEPJn+uXQCO/rQkvmIPoE33hiszASbgngR4/GYBKGS5bEBC+HTT+Mv5R3D4SrQAPDOiCdKntk0ALjwYitGbYwXgim7VULVQZgO/E1cj0XqOH/JlSo39A+tj3v4rGL81CK3K58YfbctZ5KzcBTyqRUl8XYOngHVjmNxRJqBjAjx+swAUMn82ICF8umncYYE/Dl6+L/X31PDGyJgmuU19X3AgBGO3XDC0WdWjOioXyGT4+XhYJNr86Yf8mVNj34D6mL8/BOO2XsBn5XNjig0CcOQnJdCpZkGbro0rMwEmwATckQCP3ywAheyWDUgIn24ad/zLHwcuRQvAE8MaIXPaFDb1XRZ0cqOV3aujSsFYAXgsLBL/+9MPBTKnxt4B9SELxk/L5cK0L8pr9gD+8kkJdGYBaNO94cpMgAm4JwEev1kAClkuG5AQPt00/mrhUey/eE/q77GhjZD1A9sE4Nx9VzBhW5CBl3oK+GhoJD6f64eCWdLA96d6+OtgKMZsPo8WZXNhejvtAnDExyXwTS32AOrGMLmjTEDHBHj8ZgEoZP5sQEL4dNM45N5TNJi8T+rv0SENkS1dSpv6Lm/qkBupBaB/SATazjuCQlnTYE//elh0KBSjNp3HJ2VzYYYNAnD4xyXQhQWgTfeGKzMBJuCeBHj8ZgEoZLlsQEL4dNW4yJCtePPuPQ4PaoBcGVLZ1PfZey9j0vZgQ5v/ulVDNcUmEL8rEWg3/wgKZ02D3f3rQd41/FGZnJj1ZQWL51JuAmEBaNNt4cpMgAm4MQEev1kACpkvG5AQPl01lgVg55oF8MsnJW3qu5zZQ27077fVUL1w7C7gw1fu48v5/iiSLS18+tXFksNh+GVjID4qnROz2msXgMM++hBdaxey6dq4MhNgAkzAHQnw+M0CUMhu2YCE8OmqcemRO/DkxRv8r2Ie/GYlOLMazIzdlzB510XDr5d/WxU1Cmcx/Hz48n18ucAfXtnSYle/uljmF4bhGwLhXSoH5nSoqNkDOLT5h/i2DgtAXRkmd5YJ6JQAj98sAIVMnw1ICJ+uGsvTuFqyc6jBTPO5hCk+5gXgocv30X6BP4pmT4udfeti2ZGrGL7+HJqVzIE/O2oXgOt61UD5fBl1dV+4s0yACeiTAI/fLACFLJ8NSAifrhrL6dm0ZOdQg5my6yKm7b4U6wHsWhU1isR6AA9euo8Of/mjeI4PsP3HOvjH/yqGrjuHJiWyY95XlTR7AMN+/UhX94Q7ywSYgH4J8PjNAlDI+tmAhPDpqrG8k7dVhdz443PL2TnUYP7YGYzpey4bfv1P16qoqRCAFGKGQs3IAnC5/zUMWXcWjUtkx3wWgLqyM+4sE2AC2gjw+M0CUJulmKnFBiSET1eN5Vh+WtKzqcH8viMYM31jBeDfXaqillesB1D2+OXJmAoHf26A/45ew6C1Z6Up4XZV8kmHS5E0CeoWy4rcqh3Iyl3A7AHUlUlyZ5mArgnw+M0CUOgBYAMSwqerxrakZ1ODmbQ9CLP3XjH8elmXKqjtldXws1rErT91Az+uOG2S78TWpdG2crQopMICUFdmyJ1lAkwghgCP3ywAhR4GNiAhfLpqbEt6NjWYX7cFgaaQ5WJNAD558RqTd17E/acvpSah958h8OZjQ3ulp48FoK7MkDvLBJgAC0CDDSR6//79e7YI+wiwALSPmx5byQJQS3o2NZ8JWy9g7v4Qw6+XflMFdYqa9wCq2/dbcRprT92IIwBfv30Hr6HbTApDPd4j7jMTYAL6IcDjN3sAhaydDUgIn64ay/l5taRnU4MZt+U85h8INfx6yTdVUNcGAVhxzC5EPHsVR+hFPnuFCmN2sQDUlSVyZ5kAEyACPH6zABR6EtiAhPDpqvHCg6EYvfk8Pi6TEzOtpGdTgxmz+TxIQMplcefKqFcsm+Fna9O4lcf54N6T6OlgKvIU8MOoVyg3mgWgrgyRO8sEmIBEgMdvFoBCjwIbkBA+XTVedCgUozadh5b8vGowozYFYtGhMLsFYNXxPrjzOK4AfPT8NcqO2ikdN3u6FPAf0khX94Q7ywSYgH4J8PjNAlDI+tmAhPDpqrEt+XnVYEZuDMTiw7ECcFHnyqhvgwew+oTduPXoRRwPoFIAdqtTCEOaf6ire8KdZQJMQL8EePxmAShk/WxAQvh01XipXxhGbAhE89I5MLu95fRsajAjNpzDUr+rhl9/WTUfxn9WWvr5u+UnsTngVhxxpzxGzV/34MbD53HqKKeAWQDqyhy5s0xA9wR4/GYBKPQQsAEJ4dNV42V+YRi+IRDepXJgTgfbBOCw9Wfx95FrRrxoHd++i/fw9cKjcX6vBltr4h5cfxBXAD549grlYzaBsADUlTlyZ5mA7gnw+M0CUOghYAMSwqerxsuOXMXw9efQtGR2zO1oOT+vGgyldaP0bspCAlC5+UP+m6lsHuopZLlOxNOXqDjWR2rKAlBX5sidZQK6J8DjNwtAoYeADUgIn64a/33kKoatP4cmJbJjnpX8vGowg9cG4N+j4XYLwIt3nqDJlP2G9rIApEDRlWIE4Le1C2LoRyV0dU+4s0yACeiXAI/fLACFrJ8NSAifrhrL+Xobl8iO+TYKQHUgZwJniwcw5N5TNJi8L44AVP6+a62CGPYxC0BdGSV3lgnomACP3ywAhcyfDUgIn64a/3v0GgavPYtGH2bHgq+1TwFHvXqDEiN2xGFliwC8GvEMdX/bayQAVxy7hp/XnDX87puaBTHiExaAujJK7iwT0DEBHr9ZAAqZPxuQED5dNf7v6DUMkgRgNiz4urLmvu8NvotOi44JCcDwyCjUnuRrJADV6wc71yyAXz4pqfm6uCITYAJMwJ0J8PjNAlDIftmAhPDpqrHscWtYPBv+6qRdAB64dA8d/zLe6WvrFPDNh89R49c9FgUgewB1ZY7cWSagewI8frMAFHoI2ICE8Omq8cpj4Ri4JgANimfDQhsE4OHL9/HlAn9NHsC+jYrih0ZecereefwCVcfvtigAu9QqiOG8BlBXNsmdZQJ6JsDjNwtAIftnAxLCp6vGK4+HY+DqANQrlhWLO1fR3He/KxFoN/+IJgF4YGB95M2UOk5dygNM+YDlYmr9IG8C0XxLuCITYAIeQIDHbxaAQmbMBiSET1eNVx0Px4DVAahbNCuWfKNdAB4NjcTnc/00CcDDgxogV4ZUcepGPnuFCjEBn+mPLAB1ZXrcWSbABEwQ4PGbBaDQg8EGJIRPV41Xn7iOn1adQZ2iWbHUBgF44mokWs/RJgCPDG6IHOlTxuH6KOo1yo7eafj9pXHe8Bq6zageB4LWlTlyZ5mA7gnw+M0CUOghYAMSwqerxmtPXke/lWdQ2ysLlnWpqrnvJ689QKvZhzV5AP2HNET2dHEF4JMXr1F6ZKwAHNOylJSVRFm61ymEwc0/1HxdXJEJMAEm4M4EePxmAShkv2xAQvh01Xjdqevou8J2AXgm/CE+nXVIkwA0NwWsjiXYu35hzPK9YiwA6xbCYG8WgLoySu4sE9AxAR6/WQAKmT8bkBA+XTVef+oGflxxGrWKZMHfXbV7AM9ef4RPZh7UJADNbQJ58fotig/fbjhGr3qFMXuvsQDsUbcwBnkX19U94c4yASagXwI8frMAFLJ+NiAhfLpqvOH0Dfzw32nULJIZ/3StprnvgTcf4aPpcQXguVFNUeoX4wwhp0c0RobUyeMc+/Xbd0Zr/nrWK4w5KgFIv/u5GQtAzTeGKzIBJuDWBHj8ZgEoZMBsQEL4dNVYFoA1CmfG8m+1C8DzNx+j+fQDcVgdHdIQVRSx/agC7e41Vd69e49CQ7Ya/kTevj/3GXsAySs4kAWgrmySO8sE9EyAx28WgEL2zwYkhE9XjTeeuYk+/55CtUKZ8F+36pr7bs4DSBs+lMGd06VMioCRTc0eV5n6rXvdQpi7L8So7g8NvdC3cVHN18UVmQATYALuTIDHbxaAQvbLBiSET1eNNwfcxHfLT6FqwUxY0V1cAPoNboDqE2LTu2VKkxwnhzfWJAC/rV0Q8w+EGtXd0qcWSuZKr6t7wp1lAkxAvwR4/GYBKGT9bEBC+HTVeEvALfRefhJVCmbCShsE4Lkbj/DxjLhrACnt2xSfiwaGWT9IgWNDG2kSgF9Xz48lfleN6pqbPtbVTeLOMgEmoBsCPH6zABQydjYgIXy6arz17C30+uckqhTIhJU9tHsAzQlAU/AsiTjlFHC7Knnx79FwFoC6skDuLBNgAkoCPH6zABR6ItiAhPDpqvG2s7fQ85+TqFwgI1b1qKG57/4hEWg7L24uYFsFYMHBW/D+PZA9XQrULJwFa0/dYAGo+S5wRSbABDyNAI/fLACFbJoNSAifrhpvP3cLPf4+iUr5M2J1T+0CsNnU/Qi6/UQTK0seQDmlXPKkifHqzbs4x+MpYE2IuRITYAIeQoDHbw8RgA8ePECfPn2wceNGyTRbtGiBGTNmIEOGDGZNtXv37vDx8cHNmzeRNm1a1KhRAxMnTkTx4tpjobEBecibIB66sf3cbfT4+wQq5s+INTYIQOXUrbXLtCTibj58jpoT90heQFu9h9bOy39nAkyACbgbAR6/PUQAent74/r165g3b55kg926dUOBAgWwadMmszZJdUns5cuXD5GRkRg5ciROnz6N0NBQJEmSRJMtswFpwsSVAOwIvI3uy06gQr4MWNurpmYmjhKAdMLg208QFvFMug51YQ+g5lvCFZkAE/AAAjx+e4AAvHDhAkqUKIEjR46gatXoFFv0/9WrV0dQUBCKFSumyVQDAgJQtmxZXL58GYULF9bUhg1IEyauBGDX+Tv4dulxlMubAfO/qoSBq8+gfdX8aFQiu0U+jhSA8olMHZMFIJspE2ACeiLA47cHCMCFCxeiX79+ePjwoZHt0vTvlClT0LlzZ6s2/ezZMwwbNgwbNmyQRGPy5HHTaZk6CBuQVbRcIYaAz/k76Lr0OMrmzYC8GVNhc8At6S/WhJczBGCFMbsQ+eyV0b2xdh18I5kAE2ACnkSAx28PEIDjx4/H4sWLcfFibEw0MtKiRYtK4m/w4MFmbXb27NkYOHAgSADSdPDmzZstev9evnwJ+icXMqC8efPi0aNHSJcunSc9G9wXBxPYfeEOuiw5jrJ50iNRokQ4HR79wWJKeN14+By0a/iLKvni5Ps1d1mJEgGhE0ynglO3qTzOB/eexNqxFiHqYBx8OCbABJhAghJgAejCApDW5I0aNcqigRw7dgw7d+7EkiVLEBwcbFTXy8sLXbp0waBBg8weg4Tb3bt3cevWLfz++++4ceMGDh06hJQpU5psY+6aWAAm6HPsFiffE3QH3yw+jjJ50uP12/e4cOuxWQFYaawP7j99idYV8mDNyeua+pc0cSJcHt9cU10WgJowcSUmwAQ8mAALQBcWgPfv3wf9s1Roo8fy5cuFp4DpHK9evULGjBmxYMECtGvXzuRp2QPowW8DJ3fNN+guOi8+htK50+PZqzcIuffMrACUp30pZt+dx8aeOnOXmTxJYlwc562pF7LAVFbmKWBN6LgSE2ACHkKABaALC0CtNiZvAvH390eVKlWkZvT/1apVs2kTCAlAWjdI08KdOnXSdHo2IE2YuBIA3+C76LzoGIpkS4s3b98hLCLKoQIwRdLECB6rTQAOXnsW/x69ZrgvH6RMirMjm/J9YgJMgAnohgCP3x4gAMlaKQwMxfObO3euZLwUBiZ//vyGMDA0tduwYUMsXbpUEokhISFYsWIFmjRpgqxZs0pTvxQD8MCBAyBBmS1bNk0PARuQJkxcCcC+i/fw9cKjcViY8rzZ4wG0RQBGvXqDBr/vw+3HL6Tr6VWvMAY20x7/km8oE2ACTMDdCfD47SECkOL4qQNBz5w50xAIOiwsDAULFoSvry/q1asnicWuXbvixIkToCDS2bNnR506dTBixAjNYWPI+NmA3P0VEH/XT2v6aOpVXRwlAFMmS4ygMdo8gHQN03wuYYpP9Map3vULY0BTFoDxZw18JibABBKaAI/fHiIAE8qQ2IASirx7nvenVWew+oTxpg5rApDStj2Iem21w7YKwOm7L+GPXdEC8Lv6RfBTU23xMq1eCFdgAkyACbgBAR6/WQAKmSkbkBA+3TX+eXUAVhwPN+q3NQHYvHROLDoUJrUZ+UkJjNx03iQ3WwXgjN2XMJkFoO5skDvMBJhANAEev1kACj0LbEBC+HTXePDaAPx71FgAXh7njcSJEiFx4kQGHso1gC3L5cbc/SGoWSQzetUrgvYL/E1y+6hMTsz6soJmprN8L+O3HdGhk75vUAT9m7AHUDM8rsgEmIDbE+DxmwWgkBGzAQnh013joevO4h//2N23BCBHupSgcC9T2pbDqWsP8Vn53Cg0ZKvEhn7/abncmLc/BN/WLoh6xbKZFIB9GxVF51oFkC5lMs1M/zoYijGbo72Jn5bLhWlflNfclisyASbABNydAI/fLACFbJgNSAif7hqP2HAOS/2uWuz35P+VRf9VZwwCsEXZXJh/IBTd6hRCHa+s6PBXXA/guVFNkTZFUpt4Rjx9iYoxm1LqFM2Kpd9Eh1DiwgSYABPQAwEev1kACtk5G5AQPt01HrkxEIsPR6/nM1faV81n8BKSB/CTMrmw4GAoutcphNpmBGDQmGZImSyJzTzlqebaXlmwrEtVm9tzAybABJiAuxLg8ZsFoJDtsgEJ4dNd49GbzmPhoVCL/W5ZLhfWn75p8AB+XCYXaLq2e91CaPxhdrT50y9Oe1pHmDRJYpt5sgC0GRk3YAJMwEMI8PjNAlDIlNmAhPDprvG4Leel6VxLpdGH2eFz4Y5BAH5UOpckGnvULYyfmxVD3xWnUShrWlQpmAlfzDsi1Qud0ByJEsVuItEKVhaA9YplxeLOPAWslRvXYwJMwP0J8PjNAlDIitmAhPDprvGErRekHb22CEA5DEzPeiQAjYM1n7vxCJQBxCv7B3axlAUgbwKxCx83YgJMwI0J8PjNAlDIfNmAhPDprvHE7UGYs/eKFQGYDT4X7hrqdKpRQFo36Ix0bbIA7FgtP8a0LKW7+8EdZgJMQL8EePxmAShk/WxAQvh01/i3HUGY5WtZADYsng27g2IFYNOS2bEj8I5T0rXJApDEH4lALkyACTABvRDg8ZsFoJCtswEJ4dNd4z92BmP6nssW+92geDbsUQjA6oUywy8kwinp2nyD7uLwlfvS1LI9m0h0dwO5w0yACXgMAR6/WQAKGTMbkBA+3TWe6nMRU30uWex3/WJZ4Rt8z1BHFoCcrUN35sIdZgJMwIkEePxmAShkXmxAQvh013j67kv4Iyb/rrnOqwVgtUKZcCQkEn0aFEE/TtemO5vhDjMBJuAcAjx+swAUsiw2ICF8umuszL9rrvMUkmWvwgMo1+vT0Av9GhfVHTPuMBNgAkzAGQR4/GYBKGRXbEBC+HTXmHYA005gS6Vu0azYdzF2Cliu+0NDL/RlAag7m+EOMwEm4BwCPH6zABSyLDYgIXy6azx33xVM2GZZAFJe3v0mBOCPjbzwYyP2AOrOaLjDTIAJOIUAj98sAIUMiw1ICJ/uGv+8OgArjodb7Lc5Adi3UVH80MhLd8y4w0yACTABZxDg8ZsFoJBdsQEJ4dNd4yrjfHD3yUu7BCCt/6N1gFyYABNgAkxAnACP3ywAhayIDUgIn+4a1/vNF2ERURb7XdsrCw5cuh+nTv/GRfE9C0Dd2Qx3mAkwAecQ4PGbBaCQZbEBCeHTXWPvaQdw4dZjuwTgT02K4rsG7AHUndFwh5kAE3AKAR6/WQAKGRYbkBA+3TVuOesQToc/tNjvWkWy4ODluB7AAU2LoXf9Irpjxh1mAkyACTiDAI/fLACF7IoNSAif7hp/NvsQTl2zLABrFsmMQ5cj4rBhAag7c+EOMwEm4EQCPH6zABQyLzYgIXy6a6wlELSc+k0NZ2CzYuhVjz2AujMa7jATYAJOIcDjNwtAIcNiAxLCp7vGd5+8QJVxuy32W079pq70c7Pi6FmvsO6YcYeZABNgAs4gwOM3C0Ahu2IDEsKnu8YRT1+i4lgfi/2uUjATjoZGxqkzyLs4etRlAag7o+EOMwEm4BQCPH6zABQyLDYgIXy6axz57BUqjNllWQAWyISjYXEF4GDv4ujOAlB3NsMdZgJMwDkEePxmAShkWWxAQvh01/jBs1cob0UAVi6QEcfCHsRh803NghjxSQndMeMOMwEmwAScQYDHbxaAQnbFBiSET3eNtQjAivkz4sTVuAKQp4B1Zy7cYSbABJxIgMdvFoBC5sUGJIRPd421TAGXy5vBZKzA/7pVQ7VCmXXHjDvMBJgAE3AGAR6/WQAK2RUbkBA+3TXWIgDNQVnRrRqqsgDUnc1wh5kAE3AOAR6/WQAKWRYbkBA+3TXWsgvYHJSV3auDdghzYQJMgAkwAXECPH6zABSyIjYgIXy6aywiAOe0rwDv0jl1x4w7zASYABNwBgEev1kACtkVG5AQPt01vv/0JSpZiQNoDsrML8vj4zK5dMeMO8wEmAATcAYBHr9ZAArZFRuQED7dNRYRgOwB1J25cIeZABNwIgEev1kACpkXG5AQPt01fv/+PQoO3mpXv+d2rIimJXPY1ZYbMQEmwASYgDEBHr9ZAAo9E2xAQvh02XjZkasYvv6czX2f/1UlNC6R3eZ23IAJMAEmwATiEuDxmwWg0HPBBiSET5eNl/mFYfiGQJv7/tfXldDwQxaANoPjBkyACTABEwR4/GYBKPRgsAEJ4dNl41PXHuCz2Ydt7nvPeoXxc7PiNrfjBkyACTABJsAeQFM2kOg9LUziYhcBFoB2YdN9I9/gu+i86JhNHPo0KIJ+TYrZ1IYrMwEmwASYgGkCPH6zB1Do2WADEsKn68ZlRu7A4xdvNDNY07M6KubnQNCagXFFJsAEmIAFAjx+swAUekDYgITw6bqx7QKwBirmz6hrZtx5JsAEmICjCPD4zQJQyJbYgITw6bpx6ZE78MQmDyALQF0bDHeeCTABhxLg8ZsFoJBBsQEJ4dN149K/7MCTl9qngNf1qoHy+dgDqGuj4c4zASbgMAI8frMAFDImNiAhfLpuXOqXHXgaIwBzpEuJ249fWOSxvndNlMubQdfMuPNMgAkwAUcR4PGbBaCQLbEBCeHTdeOav+7BjYfPJQYTW5fGz2vOWuRxfnRTpE6eVNfMuPNMgAkwAUcR4PGbBaCQLbEBCeHTdeMTVx+g9ZzoeICTWpfBwDUBZnmkTJYYQWO8dc2LO88EmAATcCQBHr9ZAArZExuQED7dN94bfBdZ0qbA+ZuPLQpAqnN8WCPd82IATIAJMAFHEeDxmwWgkC2xAQnh48YxBFYeC7coADOnSY4TwxszLybABJgAE3AQAR6/WQAKmRIbkBA+biwLwOPhGLja/BRw6uRJcH50M+bFBJgAE2ACDiLA4zcLQCFTYgMSwseNYwisOh6OARYEIFUL+/Uj5sUEmAATYAIOIsDjNwtAIVNiAxLCx41ZALINMAEmwAQShACP3ywAhQyPDUgIHzeOIeAfEoG2845Y5MEeQDYXJsAEmIDjCPD4zQJQyJrYgITwcWMFgQKDtpjlkS5lUgSMbMq8mAATYAJMwEEEePxmAShkSmxAQvi4sUYBSNXYA8jmwgSYABNwHAEev1kAClkTG5AQPm7MApBtgAkwASaQIAR4/GYBKGR4bEBC+LgxC0C2ASbABJhAghDg8ZsFoJDhsQEJ4ePGLADZBpgAE2ACCUKAx28WgEKGxwYkhI8bKwhM3B6EOXuvmGXCawDZXJgAE2ACjiPA4zcLQCFrYgMSwseNFQTuPn6BKuN3swBkq2ACTIAJxAN+z0pvAAAgAElEQVQBHr9ZAAqZmVYDevv2LV6/fi10Lm5snUCyZMmQJEkS6xVdsMbdJy9QZRwLQBe8NXxJTIAJeCABreO3B3bd0KVE79+/f+/uHXzw4AH69OmDjRs3Sl1p0aIFZsyYgQwZMljtGnW/efPm2L59O9atW4eWLVtabSNXsGZAdOzbt2/j4cOHmo/JFcUI0D3PkSMHEiVKJHageG5978lLVB7nwx7AeObOp2MCTECfBKyN33qg4hEC0NvbG9evX8e8efOke9atWzcUKFAAmzZtsnoPp0yZgl27dmHbtm0OF4C3bt2SxF+2bNmQOnVqtxMlVuG5UAUS21FRUbh7964k/HPmzOlCV2f9UiKevkTFsSwArZPiGkyACTABcQIsAD1gCvjChQsoUaIEjhw5gqpVq0pWQf9fvXp1BAUFoVixYmYt5cyZM/j4449x7NgxSTA40gNI074XL16UxF/mzJnFrZWPoIlARESEJAKLFi3qVtPBkc9eocKYXewB1HSXuRITYAJMQIwAC0APEIALFy5Ev3794kyzkheIvHudO3c2aSXkLapUqRImTJiATz/9VPLOOVIAvnjxAqGhoZInMlWqVGKWyq01E3j+/DnCwsJQsGBBpEyZUnO7hK74MOoVyo1mAZjQ94HPzwSYgD4IsAD0AAE4fvx4LF68WPK2KQt5gEj8DR482KQ1d+/eHeSlW7BggfR3LQLw5cuXoH9yIQPKmzcvHj16hHTp0hmdRxaA7iZE3P3Rd1fuj6Jeo+zonewBdHcD5OtnAkzALQiwAHRhAThy5EiMGjXKoiHR1O3OnTuxZMkSBAcHG9X18vJCly5dMGjQoDjHoM0i/fv3x6lTp5A2bVrNAtDcNbEAdJ3n3V0F4OMXr1FmJAtA17EkvhImwAQ8mQALQBcWgPfv3wf9s1RoenX58uU2TwH/+OOPmD59OhInTmw4PHkD6efatWtj7969Jk/LHkDHvQ46deokTduvX7/ecQcF4K4C8Pmrt/hwxHb2ADrUGvhgTIAJMAHTBFgAurAA1Gq08iYQf39/VKlSRWpG/1+tWjWzm0AoNItaXJYuXRrTpk3DJ598Iq0f01IsGZC7ChEt/XZEHfKa0s5dOVRPvXr1UK5cOUydOlXo8O7MvcCgLSwAhe4+N2YCTIAJaCPAAtADBCDdagoDc/PmTcydO1e68xQGJn/+/IYwMDdu3EDDhg2xdOlSg0hUm4iWNYDqNiwAtT1oWmqxAATUAnDaF+UwcmMgJrYugyYlc2jByHWYABNgAkxAAwEWgB4iACMjI+MEgp45c6bBuyTvCvX19QUJDVOFBWAsFfLM/fbbb/jzzz9BsQxpQ83w4cPRpk0bqdLWrVtB0+jh4eGSp/Xrr7+WNtxQQG7y6NFaSZraPX36tOGg5Nmjf3QvqCingOn/aR2nsoSEhKBx48bo0aMHfvrpJ8Ofzp07hzJlyuDSpUsoXLhwnFvpSR7AU8MbI0PqZBw/UsPLnKswASbABGwhwALQQwSgLTfdkXVt9QCSsHr++q0jL0HTsVIlS2KTiBg6dCjWrl0rCTbaTLN//35JiO3YsQOFChWSfkc/9+zZE8ePH5c21Ny5c8duAUjTweTFLVWqFEaPHi31KWvWrJg4cSL++ecfBAYGGvpJIX9OnDiBffv2mey7JwnA0yNIACbXdI+5EhNgAkyACWgnwAKQBaB2azFR01YBGPXqDUqM2CF0Tnsanx/dFKmTJ9XU9NmzZ8iSJQv27NkjBdOWS9euXaVMG7Txhrx7JMrkdGu005rEmr0eQDqHqSlg8j5SmJ3Dhw9LU/eUTzl37tySd5K8jqaKJwlA8gBmTMMCUJPhciUmwASYgA0EWACyALTBXOJW9UQBSKF1SGylSZPGqMOvXr1C+fLlkStXLmTMmBEUgFsuGzZskHIoO1oA0vEpSDdlaaHpaArUTcKPNvFQaj1PF4AnhzdGJhaAQs8oN2YCTIAJmCLAApAFoNCTYasAdIcpYHkHNYXCIW+bsqRIkQLff/89MmXKZFEA0jTumjVrQKn25EJeu1mzZplcA2jOA0i/p3zOHTt2lNYitm3bFtmzZ8f8+fPN3jdP8gAeH9YIWdKmELJRbswEmAATYAK2OXD0wivRe1IlXOwiYKsAtOsk8dzoyZMn0vo7ElkkvNRlyJAh0hTw+fPnDX+ibCu//vqrwQM4Z84caSMIeerkaeL27dvj0KFDZgVgkyZNpLzNM2bMMDolxWfMly+ftM7w559/ltYjKqem1dfnSQLw6NCGyPaB+6Szi2dT5dMxASbABOwmwB5A9gDabTzU0BMFIPVr2LBh0pTr5MmTUatWLamftA6PsqbUr19f2gTSu3dvUDo92pBB4ozEnjwFTLEZS5YsKeVZpp3D27dvl3YRU7o8U7uA6ZwUuod2Da9cuVI6D3kZ5UDdtCnl999/lzag0LEtFY8SgEMaIls6FoBCDyk3ZgJMgAmYIMACkAWg0IPhqQKQnMLkiZs9ezYoHAuFdqlQoQLI+1enTh1s3rwZffv2lcLA0HpBCgHzzTffGAQgQSUBSXmaKURP69atJe/evHnzzApAyuVM6/to2vj58+cIDQ2VNpxQoWugkC+TJk3CgAEDPFYAbjt7Cz3/OWnon/+QhsjOAlDoGeXGTIAJMAFTBFgAsgAUejI8VQDaCoXWC5JnUPYA2treWn2aOqZdwtevX5fWAHqqB5D69ebtOxQZuk3q4sWx3kieNDZdoTVO/HcmwASYABPQRoAFIAtAbZZiphYLwGgwzhKAlHuZvIw0PUw7gSkmoLXizlPAct+evnwjpcn7IGUya93lvzMBJsAEmIAdBFgAsgC0w2xim7AAdK4AXLx4Mbp06SLlCN64cWOcXcmmbp4nCEAho+TGTIAJMAEmYJUAC0AWgFaNxFIFFoBC+JzSmAWgU7DyQZkAE2ACHkWABSALQCGDZgEohM8pjVkAOgUrH5QJMAEm4FEEWACyABQyaC0CkHaypkqVSug83Fg7AdpBTKFmChYsiJQpOYSKdnJckwkwASagHwIsAFkAClm7JQOiAMYU2iRbtmzInDmz0Hm4sXYCERERuHv3LooWLYokSZJob8g1mQATYAJMQDcEWACyABQydmsGROnLHj58KIlAyl0rZ8UQOik3NkmAds1GRUVJ4o/iFtKuYS5MgAkwASbABEwRsDZ+64Eap4ITuMvWDIhECWXIIBHIJX4IkPjLkSMHi+34wc1nYQJMgAm4JQFr47dbdsrGi2YBaCMwZXWtBkTTwa9fvxY4EzfVQiBZsmQ87asFFNdhAkyACeicgNbx25MxsQAUuLtsQALwuCkTYAJMgAkwgQQiwOM3rwEUMj02ICF83JgJMAEmwASYQIIQ4PGbBaCQ4bEBCeHjxkyACTABJsAEEoQAj98sAIUMjw1ICB83ZgJMgAkwASaQIAR4/GYBKGR4jx49kkKOhIeHI126dELH4sZMgAkwASbABJhA/BAgAZg3b14pSkf69Onj56QudhbeBCJwQ65fvy4ZEBcmwASYABNgAkzA/QiQAydPnjzud+EOuGIWgAIQ3717h5s3b+KDDz6IE3dO/rpg76BpwMzHsuExH+Yj8GoC2w/bD9uPZQIUp/fJkyfIlSsXEidOLILLbduyAHTSreP1BdZfwOR2p2l0nj6Py4rth+1H5NXE9sP2w/YjQkAfbVkAOuk+8wuYX8AipsX2w/bD9iNCgO1HhB6/f0TouU9bFoBOulf8APELWMS02H7Yfth+RAiw/YjQ4/ePCD33acsC0En36uXLl5gwYQIGDx6MFClSOOks7ntY5mP53jEf5iPydLP9sP2w/YgQ0EdbFoD6uM/cSybABJgAE2ACTIAJGAiwAGRjYAJMgAkwASbABJiAzgiwANTZDefuMgEmwASYABNgAkyABSDbABNgAkyACTABJsAEdEaABaDObjh3lwkwASbABJgAE2ACLADZBpgAE2ACTMCjCFCWh0SJEnlUn7gzTMDRBFgAChLlF01cgJcvX0ZQUBA+/vhjMB/zBsZsTLM5d+4cKM92s2bNBJ9Oz2z+/PlzpEqVytA5tiPj+/zw4UOkSZMGyZIlk/7AfIz50Pv5m2++wbfffouOHTsyH898TWjqFQtATZiiK71+/RpTp05FkiRJULhwYXz66ac2tPb8qq9evcL333+P+fPnI1++fAgLC/P8TtvQQ7KfadOmSbbz2Wef2dBSH1XJfnr27IlFixZh+PDhGDVqlD46rrGXZD8//PADrl27hkyZMqFLly6oU6cOe7pi+JH99O3bFydPnpTyszds2BADBgzQbZ5XtVkRn65du2L58uWgPPYDBw7Er7/+qtH6uJonEmABqPGuzp07Fz///DPKli0rvVD8/f2lQM/0QqaHSa/JpGV8f/zxB4YOHYrKlSujYsWK2Lt3L1asWIGiRYtqJOzZ1bZt24affvoJFy5cwJdffolJkyZJScjZOxF932fOnIlBgwZJz9fs2bOl/3KJJUBe0c8//xzZsmVDjx498NdffyEyMhKffPIJRo4cqft3EIkaej/TxxW9kzdu3IjTp0+jT58+6Ny5s+5NiYTemDFjUKlSJSxZskRilDFjRixevBhv376VnBpc9EeABaCGez5kyBBs2LABI0aMQNu2baUX7/jx47Fjxw4EBATo+gs8IiICtWvXBv2XBu7WrVtjz549kneUpoFz586tgbBnV3n27JnkmaBpu5w5c2LNmjXSFAx5u7gAwcHBKF++vCRm6KOBCk1TpU2bFunTpzea7tQrr7Fjx+Lo0aNYv3699LEZFRUlvY/ow+vYsWPSR5dey927d9GvXz/po4E8flToHV2vXj1JFLZv316vaKR+08fC9OnTMWzYMPzvf/+Tfjd69GgsXbpUes646JcAC0AL917+MiJv1o0bNyTPjbywmL4sCxQoIL14qOjVk/Po0SMcOXIEjRs3NnhBaf1W6dKlQV5T8lrolY1sWtR/Pz8/ZM6cGcWKFZNEMk3n0aBepkwZ3XtvXrx4gYkTJ2LevHnYvXu3NPV76tQpyTORJ08eyYuj1ylzsh3i06lTJ8lLQ54u+b1Enj8ayOvWrQtfX1/djWLye4WeJfKsk0c9S5YsEgf6+OzWrZskAKtVqyY9e3or8swUiWHy9ik3xUyePFny/tEHBXlNueiTAAtAE/f9ypUrKFSokFnPHg1If/75J0qVKoXs2bNL65Vq1KihGwsiPgULFowz7S2/cEJCQiSR89VXX0meL72VOXPmSF4rmm4hG1GXXbt2SQMTeUnJi6O33Yqm+NC6tkaNGoFsi6bsyNNOi/n//fdfBAYGSl6MWrVq6cKUTPHp0KEDaPMH5RYnu6LyxRdfSO8pGsxpyrNp06a6+NgiT2iVKlXMfjgRI1piQV5l8g7SekmasWnevLkuPrZkPqamdmXRfOjQIWn96NWrV6WPLL1/pOvixWKikywAFVAWLlwoeR+yZs2KpEmTShsa2rVrJwkdekBkrw15BMnzR4Jn7dq1ktfi4MGDHv8lZY2PUsjQdAx5JmjqQS9rTEjY0UBN095Pnz7Fy5cv0b17d9ASAirKtaK9e/eWhA19PNBidT28gE3xIS8NrR2lQt6I8+fP47vvvkO6dOmk39HPtHaSPBj//POPR7+nTfGhjR70kXD8+HFp7d+DBw+kqc2VK1dK074kFnv16iV53OlZ8+RC9kHPDT1XxINmYEytv6aPTopAQEtTSOCQQN66dau0ecaTi1Y+xIA+tOi9Q15k8i5z0ScBFoAx9512Z9JCdFoomzdvXuzcuVOaopsxY4a0XV4OKXDnzh1pmkG5aDZ16tTSeoo2bdp4rBVp4UMihv6RYCYvKa1NoqlPvRSa7s6QIYM0lUmDDa0RJQFItkEeLbKhN2/eSB8XNEVFL17yZNBmIvIY0nocT940Y4kPLa+gXYr0TxZ/st3Q2kB6xv7++2/Dc+iJNqXmQ+8gEsg0VUfedFpvTDZFmxvIw96qVSsJA01xkuChNV6eWmjqmyIw0HQlLTEpWbKkNAujLLIYVH9M0YcriWgfHx8UL17cIxFp4aPsOC1pql+/vjRDQ2uR9fAB6pE3XrBTLAABaUF1y5YtpWlc+iKSHwZykdNATuJHDvki/03+L3n+aCqGQp94e3sL3g7XbK6Vj/IlQl4bEn+bN2+WvDeeWuQ+h4aGokKFCpJI+eijjwzdJQFI67NWrVpl2Nkqt6F1b7S5iDylNNiTcKb1lJ60I08LH9o0RBtjaD2kutAaU4oHSGtMab2bpxUtfGiGgWYa1HyoLXlyyN5I/FFMN08r8uwBRV0gDxeJFdooREsCSACSN9TaDAN5DclzSiLJ04o9fGSbIw8pLSGgXcEcycLTLENbf1gAApLXgXZnkgeQpnxp0XXKlCkljx6JGFqb9Pvvv0tTw8pC3kASOlSfvtIp+KgnFlv4yB4umnIhD8WtW7c8UgDSonMvLy/Jm0eFbCB//vySB5m8NjRNlSJFCsm2aJ0oTWvSxwWJO/llS9NY9NFBzMjLTN7m5MmTe4QJifAhALTejQZtmiInTrQWsESJEh7BhjphKx9ajvLLL78YPg5u374tfaj2799f+kglcSRvgPAESGo+1Cf53UJLJ2hZBf28ZcsWqbtqDxZ9ONA/eh5JQNOzRULZUzxdonyIA3n/aJaGPj49dezyhGfBmX3QnQAkTwwZPC3Ob9CggbR2hgpNQdHOQ5omoDVctN6IvjJpymH//v3SV2e5cuWklwqt1aEvUgpYSwuNaYqBpo09oYjykRkQY2JKx6OpBk8p1B8KNUHijj4SSLiRV4LWh5K3jwQveT1JyJH4o//SFC+tz6K/yYW8F7R2izxbtI6LvsQ9oTiCDz1r5DVdvXq19HwuWLDAY9bXOoIP2RGFXJo1a5bEhz4+aVOWJxRTfOi5ouUTSvFG7176KKcPcNo0pPRg0fuZPkD/++8/acqXlmTQx5onFEfwkTnQe4vWbdPUuqd8eHrCPY7PPuhGAFKcOlpETVO2NN1LgVVp+oSm4Wjq5NKlS4bUU+TNoR2Iy5Ytk7xY9PKhqTraRUa7yugh3LRpk+TVobU3nlAcxUeekqA1Jjdv3pQCQ3tKIU8CCT7yutAHBIkUOcAqbQqijwZ6mZKdkRdQ9ljQ2j7iQN4Kebc4reeidYC07stTiigfeqZopy9t/KApT1of2aRJE0/BI3miROyHPixq1qwp2RW9x0j00EespxRLfEisUFxI+Zmi9wt5ROk5oiUE9Df5gys8PFz6SCdR7Ekfn6J86COVxjL5HS3/7Cn2w/2wnYBuBCB5E3777TdpYJGDE5MQPHPmDKZMmSKJQlpcTIMPTa/QVDA9LPfu3ZMWWdNALwfRpDVxtCjdk4ooHxLSnroJRvY80HQS2Q95f+UvZgo5Qd5O+i+tASVvBYXBofVGtEuRCgkbGsDkReieMg0l27+j+NCg/eGHH3rSYyX1hflYvqXW+JDwoXV8X3/9tdGB/t/enYRGscRxHP+jntxwAQkexINBD2oUQQmiuAQEQUEP7qgQweXkVXAFdxG9qIjgElAQD0oO4kFURL3pwQ0MqDnoQYgoiQe3g/zqUWHiSzqd9FSsqfk2yHsw05XqT9X0/KfqX9X6QaW0Ck3t6oe6VpNrZDSV2Zi8n69q90nuhjGAF1Q1AaBuEBruVrK5tujQL0Ylv2r6QL+ilWOkHL+/k2G13YJ+aWq0p6amZgCbZmD/FD69e2uxj349awTY/3pWSoCeNKCAUKkAeqqFRgj1un5wKC9QX1KatlPfSznXBp/sPoRP/32UbqGnnugZ434ESz/ElY6hFArl1mpbE83UKD0jxSOr/+CTYouHv6YkA0Dl7CmJXDcEn6SvjXd1c9C0mz80aqMkWE356telpmd0aNRPU6IasVH+lrbr0P6AusmksGkvPtkfLI1EadRO+Z/19fVuKlKHVnprqleLE9SvfBCoqV/1E40SKyVAQaCCwo6ODmtvb3cLjDQimMoWFPjQf4p8NfWn/2iGQavANVOjQ49X1OdROYBazaocW5/PXaRuMZyLTwytUB11SCoAbGtrc6Mvyt3TlglaGeen4TQtp6lcrSRULp9e01SvEsz1pb58+fLObSaePXvmVo9pelg3HW3um8KBT3YrapROuXvaSV+LM5RfpBWWmuJVENjS0uJGi/UcX/ULn3OkUidNmuT2atN+Yzo0yqwfEepjc+bMSaH7uFFMfHpuSnzCfr70I12rwnUoVUefQ00Np7L9TdH+k7pPEjfRyC4imQBQycH6RahRPk3r6uagm4WWuvspAT3+RtO+T58+dcn4mtrV1gn64tZ0gvLg/KEVwVrhm8qBT3ZLqv21KlejwRrN86sqFfhp01mtOtSInkYaDh065Eb5lGvkUwaU/6f9Dv1eY6nl+eFD/ylyLyx3/ylSlxjPxSfGVkm/TskEgGoqJedr+lbTcBqh0b5+Gr3R9i2lR+nIjVb1aqpY+RVKIvarzFJsenyyW1ULOFasWOFWg/t+oH6kLSW0H6Sm/7Xhs0Yc9LryRhUoavGQAkC9V+eneuBD/ynSt+k/9J8i/Ydzyy+QVAD496iLVvsqGNR+USNGjOiyj5RGepTTpylgjRxqZDCVHJKeugk+2R+g0m0RvJWCPT2mTXuJ+cM/Rkl9SNu7KLDWFLD2HUt5oRA+9J8iX0H0H/pPkf7DueUXSCoA9Dx+hE+rNbUZsUZwlNNV+gXe3NzsVm0qN9A/AaT8vHGWiE/+dtHjAJVOoIVAmu7VoUe2aW8/pRJoEZHyTZVGUI0HPtmtjg8+Re4L9J8iepzbm0CSAWDpRSvXT1tvaKXmuHHj3BSxtnvR9J02KtaikWo+8Om59fXjQD7ab2zWrFnujaXpA9Xcb3Tt+GT3AHzwKXKPoP8U0ePcPALJBoClz42sq6tze0jpyR/aQV/TvXqSQzUf+PTc+n76t6mpyeX1abRPh7YC0qpe/Vc/Jqr1wCe75fHBp8i9gf5TRI9z+yKQbABYiqCVnHqgvDYRPX/+vC1ZsqQvRsm/F5/um1iP+tPocUNDg9v+RCv1tMVQSo8nK9K58cnWwwcfPl9FBDg3tEDSAaBG/LRxqIbStX1HY2NjaM+KKh+fnptLCzy0KEhGesqHRv20mTjHfwL4ZPcEfPApcq+g/xTR49y8AkkHgK2trXb58mX3xa2VnBxdBfDJ7hFaOFRbW+vSB/SoJY6uAvjQf4p8Jug/9J8i/YdziwskHQAW56GEahbwzxytZoOsa8cnu2fgg0+Rewf9p4ge5+YRIADMo8R7EEAAAQQQQACBhAQIABNqTC4FAQQQQAABBBDII0AAmEeJ9yCAAAIIIIAAAgkJEAAm1JhcCgIIIIAAAgggkEeAADCPEu9BAAEEEEAAAQQSEiAATKgxuRQEEEAAAQQQQCCPAAFgHiXegwACCCCAAAIIJCRAAJhQY3IpCCCAAAIIIIBAHgECwDxKvAcBBCpWYPPmzXblyhVX/yFDhtiYMWNs+vTptnbtWtNrgwYNynVteqrQzp077evXr7nez5sQQACBmAUIAGNuHeqGAAKFBRTkffr0yS5dumR6uoL+/86dO3bkyBGbN2+eNTc3u8Cwt4MAsDchXkcAgUoSIACspNairggg0GcBBYAatbt161aXc+/du2eLFy+2Cxcu2JYtW9wznxUkvnv3zo0SLlu2zI4fP27Dhw+3Bw8e2MKFC7ucv2/fPtu/f7/9/PnTdu/ebVevXnV/Z+rUqXbs2DFbsGBBn+vKCQgggMBACRAADpQ0fwcBBP6JQE8BoCozY8YMGz9+vN2+fdtOnz5tdXV1NnHiRHv//r3t2LHDFi1aZGfPnnVB3rlz52zv3r325s0bdx0KDPVv/fr11traakePHnVl3bx50wWEL168sNra2n9yzfxRBBBAoDcBAsDehHgdAQQqWiArAFyzZo09f/7cXr9+/b9rvHHjhm3fvt3a2trca91NAb99+9YFeR8+fHDBnz8aGhps9uzZdvjw4Yq2o/IIIJCuAAFgum3LlSGAgJlb6NHdFLBwVq9ebS9fvrRXr17Z/fv3XcCmYLC9vd1+//5t379/t2/fvtmwYcO6DQAVJK5atcq9Xnr8+PHDVq5cadevX6cNEEAAgSgFCACjbBYqhQAC5RLICgC1GnjChAl25swZmzJlim3bts0FhcoBfPTokTU2NtqXL19s1KhR3QaACvA0BawAcvDgwV2qrOnhmpqacl0G5SCAAAJlFSAALCsnhSGAQGwCvS0CuXjxoo0cOdI0HayRO78tzMGDB23Pnj2dAeC1a9ds69at1tHR0XmJLS0tNnnyZHv48KFbUcyBAAIIVIoAAWCltBT1RACBfglkbQOjlbpaHawFGzNnznQLQbT69/Hjx7Zr1y77+PFjZwD45MkTmzt3rt29e9ctFhk6dKj7t2HDBvf+kydPujKUM6gVxtOmTbOlS5f2q86chAACCIQWIAAMLUz5CCDwTwX+3gh69OjRLoBbt26dbdq0qXPE79SpU3bixAmXLzh//nw3tbtx48bOAFAXoUUhyvv7/Pmz+W1gfv36ZRotbGpqcgHj2LFjrb6+3g4cOOCCQA4EEEAgRgECwBhbhTohgAACCCCAAAIBBQgAA+JSNAIIIIAAAgggEKMAAWCMrUKdEEAAAQQQQACBgAIEgAFxKRoBBBBAAAEEEIhRgAAwxlahTggggAACCCCAQEABAsCAuBSNAAIIIIAAAgjEKEAAGGOrUCcEEEAAAQQQQCCgAAFgQFyKRgABBBBAAAEEYhQgAIyxVagTAggggAACCCAQUIAAMCAuRSOAAAIIIIAAAjEKEADG2CrUCQEEEEAAAQQQCChAABgQl6IRQAABBBBAAIEYBQgAY2wV6oQAAggggAACCAQUIAAMiEvRCCCAAAIIIIBAjAIEgDG2CnVCAAEEEEAAAQQCChAABuHoDRQAAAGqSURBVMSlaAQQQAABBBBAIEYBAsAYW4U6IYAAAggggAACAQUIAAPiUjQCCCCAAAIIIBCjAAFgjK1CnRBAAAEEEEAAgYACBIABcSkaAQQQQAABBBCIUYAAMMZWoU4IIIAAAggggEBAAQLAgLgUjQACCCCAAAIIxChAABhjq1AnBBBAAAEEEEAgoAABYEBcikYAAQQQQAABBGIUIACMsVWoEwIIIIAAAgggEFCAADAgLkUjgAACCCCAAAIxChAAxtgq1AkBBBBAAAEEEAgoQAAYEJeiEUAAAQQQQACBGAUIAGNsFeqEAAIIIIAAAggEFCAADIhL0QgggAACCCCAQIwCBIAxtgp1QgABBBBAAAEEAgoQAAbEpWgEEEAAAQQQQCBGAQLAGFuFOiGAAAIIIIAAAgEFCAAD4lI0AggggAACCCAQowABYIytQp0QQAABBBBAAIGAAgSAAXEpGgEEEEAAAQQQiFGAADDGVqFOCCCAAAIIIIBAQAECwIC4FI0AAggggAACCMQoQAAYY6tQJwQQQAABBBBAIKAAAWBAXIpGAAEEEEAAAQRiFPgDuu140iZ1YDwAAAAASUVORK5CYII=\" width=\"640\">"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "prices =series\n",
    "ax = stats.prices.to_drawdown_series().plot()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 365,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "/* Put everything inside the global mpl namespace */\n",
       "window.mpl = {};\n",
       "\n",
       "\n",
       "mpl.get_websocket_type = function() {\n",
       "    if (typeof(WebSocket) !== 'undefined') {\n",
       "        return WebSocket;\n",
       "    } else if (typeof(MozWebSocket) !== 'undefined') {\n",
       "        return MozWebSocket;\n",
       "    } else {\n",
       "        alert('Your browser does not have WebSocket support.' +\n",
       "              'Please try Chrome, Safari or Firefox ≥ 6. ' +\n",
       "              'Firefox 4 and 5 are also supported but you ' +\n",
       "              'have to enable WebSockets in about:config.');\n",
       "    };\n",
       "}\n",
       "\n",
       "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n",
       "    this.id = figure_id;\n",
       "\n",
       "    this.ws = websocket;\n",
       "\n",
       "    this.supports_binary = (this.ws.binaryType != undefined);\n",
       "\n",
       "    if (!this.supports_binary) {\n",
       "        var warnings = document.getElementById(\"mpl-warnings\");\n",
       "        if (warnings) {\n",
       "            warnings.style.display = 'block';\n",
       "            warnings.textContent = (\n",
       "                \"This browser does not support binary websocket messages. \" +\n",
       "                    \"Performance may be slow.\");\n",
       "        }\n",
       "    }\n",
       "\n",
       "    this.imageObj = new Image();\n",
       "\n",
       "    this.context = undefined;\n",
       "    this.message = undefined;\n",
       "    this.canvas = undefined;\n",
       "    this.rubberband_canvas = undefined;\n",
       "    this.rubberband_context = undefined;\n",
       "    this.format_dropdown = undefined;\n",
       "\n",
       "    this.image_mode = 'full';\n",
       "\n",
       "    this.root = $('<div/>');\n",
       "    this._root_extra_style(this.root)\n",
       "    this.root.attr('style', 'display: inline-block');\n",
       "\n",
       "    $(parent_element).append(this.root);\n",
       "\n",
       "    this._init_header(this);\n",
       "    this._init_canvas(this);\n",
       "    this._init_toolbar(this);\n",
       "\n",
       "    var fig = this;\n",
       "\n",
       "    this.waiting = false;\n",
       "\n",
       "    this.ws.onopen =  function () {\n",
       "            fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n",
       "            fig.send_message(\"send_image_mode\", {});\n",
       "            if (mpl.ratio != 1) {\n",
       "                fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.ratio});\n",
       "            }\n",
       "            fig.send_message(\"refresh\", {});\n",
       "        }\n",
       "\n",
       "    this.imageObj.onload = function() {\n",
       "            if (fig.image_mode == 'full') {\n",
       "                // Full images could contain transparency (where diff images\n",
       "                // almost always do), so we need to clear the canvas so that\n",
       "                // there is no ghosting.\n",
       "                fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n",
       "            }\n",
       "            fig.context.drawImage(fig.imageObj, 0, 0);\n",
       "        };\n",
       "\n",
       "    this.imageObj.onunload = function() {\n",
       "        fig.ws.close();\n",
       "    }\n",
       "\n",
       "    this.ws.onmessage = this._make_on_message_function(this);\n",
       "\n",
       "    this.ondownload = ondownload;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_header = function() {\n",
       "    var titlebar = $(\n",
       "        '<div class=\"ui-dialog-titlebar ui-widget-header ui-corner-all ' +\n",
       "        'ui-helper-clearfix\"/>');\n",
       "    var titletext = $(\n",
       "        '<div class=\"ui-dialog-title\" style=\"width: 100%; ' +\n",
       "        'text-align: center; padding: 3px;\"/>');\n",
       "    titlebar.append(titletext)\n",
       "    this.root.append(titlebar);\n",
       "    this.header = titletext[0];\n",
       "}\n",
       "\n",
       "\n",
       "\n",
       "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n",
       "\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n",
       "\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_canvas = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var canvas_div = $('<div/>');\n",
       "\n",
       "    canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n",
       "\n",
       "    function canvas_keyboard_event(event) {\n",
       "        return fig.key_event(event, event['data']);\n",
       "    }\n",
       "\n",
       "    canvas_div.keydown('key_press', canvas_keyboard_event);\n",
       "    canvas_div.keyup('key_release', canvas_keyboard_event);\n",
       "    this.canvas_div = canvas_div\n",
       "    this._canvas_extra_style(canvas_div)\n",
       "    this.root.append(canvas_div);\n",
       "\n",
       "    var canvas = $('<canvas/>');\n",
       "    canvas.addClass('mpl-canvas');\n",
       "    canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n",
       "\n",
       "    this.canvas = canvas[0];\n",
       "    this.context = canvas[0].getContext(\"2d\");\n",
       "\n",
       "    var backingStore = this.context.backingStorePixelRatio ||\n",
       "\tthis.context.webkitBackingStorePixelRatio ||\n",
       "\tthis.context.mozBackingStorePixelRatio ||\n",
       "\tthis.context.msBackingStorePixelRatio ||\n",
       "\tthis.context.oBackingStorePixelRatio ||\n",
       "\tthis.context.backingStorePixelRatio || 1;\n",
       "\n",
       "    mpl.ratio = (window.devicePixelRatio || 1) / backingStore;\n",
       "\n",
       "    var rubberband = $('<canvas/>');\n",
       "    rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n",
       "\n",
       "    var pass_mouse_events = true;\n",
       "\n",
       "    canvas_div.resizable({\n",
       "        start: function(event, ui) {\n",
       "            pass_mouse_events = false;\n",
       "        },\n",
       "        resize: function(event, ui) {\n",
       "            fig.request_resize(ui.size.width, ui.size.height);\n",
       "        },\n",
       "        stop: function(event, ui) {\n",
       "            pass_mouse_events = true;\n",
       "            fig.request_resize(ui.size.width, ui.size.height);\n",
       "        },\n",
       "    });\n",
       "\n",
       "    function mouse_event_fn(event) {\n",
       "        if (pass_mouse_events)\n",
       "            return fig.mouse_event(event, event['data']);\n",
       "    }\n",
       "\n",
       "    rubberband.mousedown('button_press', mouse_event_fn);\n",
       "    rubberband.mouseup('button_release', mouse_event_fn);\n",
       "    // Throttle sequential mouse events to 1 every 20ms.\n",
       "    rubberband.mousemove('motion_notify', mouse_event_fn);\n",
       "\n",
       "    rubberband.mouseenter('figure_enter', mouse_event_fn);\n",
       "    rubberband.mouseleave('figure_leave', mouse_event_fn);\n",
       "\n",
       "    canvas_div.on(\"wheel\", function (event) {\n",
       "        event = event.originalEvent;\n",
       "        event['data'] = 'scroll'\n",
       "        if (event.deltaY < 0) {\n",
       "            event.step = 1;\n",
       "        } else {\n",
       "            event.step = -1;\n",
       "        }\n",
       "        mouse_event_fn(event);\n",
       "    });\n",
       "\n",
       "    canvas_div.append(canvas);\n",
       "    canvas_div.append(rubberband);\n",
       "\n",
       "    this.rubberband = rubberband;\n",
       "    this.rubberband_canvas = rubberband[0];\n",
       "    this.rubberband_context = rubberband[0].getContext(\"2d\");\n",
       "    this.rubberband_context.strokeStyle = \"#000000\";\n",
       "\n",
       "    this._resize_canvas = function(width, height) {\n",
       "        // Keep the size of the canvas, canvas container, and rubber band\n",
       "        // canvas in synch.\n",
       "        canvas_div.css('width', width)\n",
       "        canvas_div.css('height', height)\n",
       "\n",
       "        canvas.attr('width', width * mpl.ratio);\n",
       "        canvas.attr('height', height * mpl.ratio);\n",
       "        canvas.attr('style', 'width: ' + width + 'px; height: ' + height + 'px;');\n",
       "\n",
       "        rubberband.attr('width', width);\n",
       "        rubberband.attr('height', height);\n",
       "    }\n",
       "\n",
       "    // Set the figure to an initial 600x600px, this will subsequently be updated\n",
       "    // upon first draw.\n",
       "    this._resize_canvas(600, 600);\n",
       "\n",
       "    // Disable right mouse context menu.\n",
       "    $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n",
       "        return false;\n",
       "    });\n",
       "\n",
       "    function set_focus () {\n",
       "        canvas.focus();\n",
       "        canvas_div.focus();\n",
       "    }\n",
       "\n",
       "    window.setTimeout(set_focus, 100);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_toolbar = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var nav_element = $('<div/>')\n",
       "    nav_element.attr('style', 'width: 100%');\n",
       "    this.root.append(nav_element);\n",
       "\n",
       "    // Define a callback function for later on.\n",
       "    function toolbar_event(event) {\n",
       "        return fig.toolbar_button_onclick(event['data']);\n",
       "    }\n",
       "    function toolbar_mouse_event(event) {\n",
       "        return fig.toolbar_button_onmouseover(event['data']);\n",
       "    }\n",
       "\n",
       "    for(var toolbar_ind in mpl.toolbar_items) {\n",
       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
       "\n",
       "        if (!name) {\n",
       "            // put a spacer in here.\n",
       "            continue;\n",
       "        }\n",
       "        var button = $('<button/>');\n",
       "        button.addClass('ui-button ui-widget ui-state-default ui-corner-all ' +\n",
       "                        'ui-button-icon-only');\n",
       "        button.attr('role', 'button');\n",
       "        button.attr('aria-disabled', 'false');\n",
       "        button.click(method_name, toolbar_event);\n",
       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
       "\n",
       "        var icon_img = $('<span/>');\n",
       "        icon_img.addClass('ui-button-icon-primary ui-icon');\n",
       "        icon_img.addClass(image);\n",
       "        icon_img.addClass('ui-corner-all');\n",
       "\n",
       "        var tooltip_span = $('<span/>');\n",
       "        tooltip_span.addClass('ui-button-text');\n",
       "        tooltip_span.html(tooltip);\n",
       "\n",
       "        button.append(icon_img);\n",
       "        button.append(tooltip_span);\n",
       "\n",
       "        nav_element.append(button);\n",
       "    }\n",
       "\n",
       "    var fmt_picker_span = $('<span/>');\n",
       "\n",
       "    var fmt_picker = $('<select/>');\n",
       "    fmt_picker.addClass('mpl-toolbar-option ui-widget ui-widget-content');\n",
       "    fmt_picker_span.append(fmt_picker);\n",
       "    nav_element.append(fmt_picker_span);\n",
       "    this.format_dropdown = fmt_picker[0];\n",
       "\n",
       "    for (var ind in mpl.extensions) {\n",
       "        var fmt = mpl.extensions[ind];\n",
       "        var option = $(\n",
       "            '<option/>', {selected: fmt === mpl.default_extension}).html(fmt);\n",
       "        fmt_picker.append(option)\n",
       "    }\n",
       "\n",
       "    // Add hover states to the ui-buttons\n",
       "    $( \".ui-button\" ).hover(\n",
       "        function() { $(this).addClass(\"ui-state-hover\");},\n",
       "        function() { $(this).removeClass(\"ui-state-hover\");}\n",
       "    );\n",
       "\n",
       "    var status_bar = $('<span class=\"mpl-message\"/>');\n",
       "    nav_element.append(status_bar);\n",
       "    this.message = status_bar[0];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.request_resize = function(x_pixels, y_pixels) {\n",
       "    // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n",
       "    // which will in turn request a refresh of the image.\n",
       "    this.send_message('resize', {'width': x_pixels, 'height': y_pixels});\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.send_message = function(type, properties) {\n",
       "    properties['type'] = type;\n",
       "    properties['figure_id'] = this.id;\n",
       "    this.ws.send(JSON.stringify(properties));\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.send_draw_message = function() {\n",
       "    if (!this.waiting) {\n",
       "        this.waiting = true;\n",
       "        this.ws.send(JSON.stringify({type: \"draw\", figure_id: this.id}));\n",
       "    }\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype.handle_save = function(fig, msg) {\n",
       "    var format_dropdown = fig.format_dropdown;\n",
       "    var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n",
       "    fig.ondownload(fig, format);\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype.handle_resize = function(fig, msg) {\n",
       "    var size = msg['size'];\n",
       "    if (size[0] != fig.canvas.width || size[1] != fig.canvas.height) {\n",
       "        fig._resize_canvas(size[0], size[1]);\n",
       "        fig.send_message(\"refresh\", {});\n",
       "    };\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_rubberband = function(fig, msg) {\n",
       "    var x0 = msg['x0'] / mpl.ratio;\n",
       "    var y0 = (fig.canvas.height - msg['y0']) / mpl.ratio;\n",
       "    var x1 = msg['x1'] / mpl.ratio;\n",
       "    var y1 = (fig.canvas.height - msg['y1']) / mpl.ratio;\n",
       "    x0 = Math.floor(x0) + 0.5;\n",
       "    y0 = Math.floor(y0) + 0.5;\n",
       "    x1 = Math.floor(x1) + 0.5;\n",
       "    y1 = Math.floor(y1) + 0.5;\n",
       "    var min_x = Math.min(x0, x1);\n",
       "    var min_y = Math.min(y0, y1);\n",
       "    var width = Math.abs(x1 - x0);\n",
       "    var height = Math.abs(y1 - y0);\n",
       "\n",
       "    fig.rubberband_context.clearRect(\n",
       "        0, 0, fig.canvas.width, fig.canvas.height);\n",
       "\n",
       "    fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_figure_label = function(fig, msg) {\n",
       "    // Updates the figure title.\n",
       "    fig.header.textContent = msg['label'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_cursor = function(fig, msg) {\n",
       "    var cursor = msg['cursor'];\n",
       "    switch(cursor)\n",
       "    {\n",
       "    case 0:\n",
       "        cursor = 'pointer';\n",
       "        break;\n",
       "    case 1:\n",
       "        cursor = 'default';\n",
       "        break;\n",
       "    case 2:\n",
       "        cursor = 'crosshair';\n",
       "        break;\n",
       "    case 3:\n",
       "        cursor = 'move';\n",
       "        break;\n",
       "    }\n",
       "    fig.rubberband_canvas.style.cursor = cursor;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_message = function(fig, msg) {\n",
       "    fig.message.textContent = msg['message'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_draw = function(fig, msg) {\n",
       "    // Request the server to send over a new figure.\n",
       "    fig.send_draw_message();\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_image_mode = function(fig, msg) {\n",
       "    fig.image_mode = msg['mode'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.updated_canvas_event = function() {\n",
       "    // Called whenever the canvas gets updated.\n",
       "    this.send_message(\"ack\", {});\n",
       "}\n",
       "\n",
       "// A function to construct a web socket function for onmessage handling.\n",
       "// Called in the figure constructor.\n",
       "mpl.figure.prototype._make_on_message_function = function(fig) {\n",
       "    return function socket_on_message(evt) {\n",
       "        if (evt.data instanceof Blob) {\n",
       "            /* FIXME: We get \"Resource interpreted as Image but\n",
       "             * transferred with MIME type text/plain:\" errors on\n",
       "             * Chrome.  But how to set the MIME type?  It doesn't seem\n",
       "             * to be part of the websocket stream */\n",
       "            evt.data.type = \"image/png\";\n",
       "\n",
       "            /* Free the memory for the previous frames */\n",
       "            if (fig.imageObj.src) {\n",
       "                (window.URL || window.webkitURL).revokeObjectURL(\n",
       "                    fig.imageObj.src);\n",
       "            }\n",
       "\n",
       "            fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n",
       "                evt.data);\n",
       "            fig.updated_canvas_event();\n",
       "            fig.waiting = false;\n",
       "            return;\n",
       "        }\n",
       "        else if (typeof evt.data === 'string' && evt.data.slice(0, 21) == \"data:image/png;base64\") {\n",
       "            fig.imageObj.src = evt.data;\n",
       "            fig.updated_canvas_event();\n",
       "            fig.waiting = false;\n",
       "            return;\n",
       "        }\n",
       "\n",
       "        var msg = JSON.parse(evt.data);\n",
       "        var msg_type = msg['type'];\n",
       "\n",
       "        // Call the  \"handle_{type}\" callback, which takes\n",
       "        // the figure and JSON message as its only arguments.\n",
       "        try {\n",
       "            var callback = fig[\"handle_\" + msg_type];\n",
       "        } catch (e) {\n",
       "            console.log(\"No handler for the '\" + msg_type + \"' message type: \", msg);\n",
       "            return;\n",
       "        }\n",
       "\n",
       "        if (callback) {\n",
       "            try {\n",
       "                // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n",
       "                callback(fig, msg);\n",
       "            } catch (e) {\n",
       "                console.log(\"Exception inside the 'handler_\" + msg_type + \"' callback:\", e, e.stack, msg);\n",
       "            }\n",
       "        }\n",
       "    };\n",
       "}\n",
       "\n",
       "// from http://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n",
       "mpl.findpos = function(e) {\n",
       "    //this section is from http://www.quirksmode.org/js/events_properties.html\n",
       "    var targ;\n",
       "    if (!e)\n",
       "        e = window.event;\n",
       "    if (e.target)\n",
       "        targ = e.target;\n",
       "    else if (e.srcElement)\n",
       "        targ = e.srcElement;\n",
       "    if (targ.nodeType == 3) // defeat Safari bug\n",
       "        targ = targ.parentNode;\n",
       "\n",
       "    // jQuery normalizes the pageX and pageY\n",
       "    // pageX,Y are the mouse positions relative to the document\n",
       "    // offset() returns the position of the element relative to the document\n",
       "    var x = e.pageX - $(targ).offset().left;\n",
       "    var y = e.pageY - $(targ).offset().top;\n",
       "\n",
       "    return {\"x\": x, \"y\": y};\n",
       "};\n",
       "\n",
       "/*\n",
       " * return a copy of an object with only non-object keys\n",
       " * we need this to avoid circular references\n",
       " * http://stackoverflow.com/a/24161582/3208463\n",
       " */\n",
       "function simpleKeys (original) {\n",
       "  return Object.keys(original).reduce(function (obj, key) {\n",
       "    if (typeof original[key] !== 'object')\n",
       "        obj[key] = original[key]\n",
       "    return obj;\n",
       "  }, {});\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.mouse_event = function(event, name) {\n",
       "    var canvas_pos = mpl.findpos(event)\n",
       "\n",
       "    if (name === 'button_press')\n",
       "    {\n",
       "        this.canvas.focus();\n",
       "        this.canvas_div.focus();\n",
       "    }\n",
       "\n",
       "    var x = canvas_pos.x * mpl.ratio;\n",
       "    var y = canvas_pos.y * mpl.ratio;\n",
       "\n",
       "    this.send_message(name, {x: x, y: y, button: event.button,\n",
       "                             step: event.step,\n",
       "                             guiEvent: simpleKeys(event)});\n",
       "\n",
       "    /* This prevents the web browser from automatically changing to\n",
       "     * the text insertion cursor when the button is pressed.  We want\n",
       "     * to control all of the cursor setting manually through the\n",
       "     * 'cursor' event from matplotlib */\n",
       "    event.preventDefault();\n",
       "    return false;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._key_event_extra = function(event, name) {\n",
       "    // Handle any extra behaviour associated with a key event\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.key_event = function(event, name) {\n",
       "\n",
       "    // Prevent repeat events\n",
       "    if (name == 'key_press')\n",
       "    {\n",
       "        if (event.which === this._key)\n",
       "            return;\n",
       "        else\n",
       "            this._key = event.which;\n",
       "    }\n",
       "    if (name == 'key_release')\n",
       "        this._key = null;\n",
       "\n",
       "    var value = '';\n",
       "    if (event.ctrlKey && event.which != 17)\n",
       "        value += \"ctrl+\";\n",
       "    if (event.altKey && event.which != 18)\n",
       "        value += \"alt+\";\n",
       "    if (event.shiftKey && event.which != 16)\n",
       "        value += \"shift+\";\n",
       "\n",
       "    value += 'k';\n",
       "    value += event.which.toString();\n",
       "\n",
       "    this._key_event_extra(event, name);\n",
       "\n",
       "    this.send_message(name, {key: value,\n",
       "                             guiEvent: simpleKeys(event)});\n",
       "    return false;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.toolbar_button_onclick = function(name) {\n",
       "    if (name == 'download') {\n",
       "        this.handle_save(this, null);\n",
       "    } else {\n",
       "        this.send_message(\"toolbar_button\", {name: name});\n",
       "    }\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.toolbar_button_onmouseover = function(tooltip) {\n",
       "    this.message.textContent = tooltip;\n",
       "};\n",
       "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to  previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Pan axes with left mouse, zoom with right\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n",
       "\n",
       "mpl.extensions = [\"eps\", \"jpeg\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\", \"tif\"];\n",
       "\n",
       "mpl.default_extension = \"png\";var comm_websocket_adapter = function(comm) {\n",
       "    // Create a \"websocket\"-like object which calls the given IPython comm\n",
       "    // object with the appropriate methods. Currently this is a non binary\n",
       "    // socket, so there is still some room for performance tuning.\n",
       "    var ws = {};\n",
       "\n",
       "    ws.close = function() {\n",
       "        comm.close()\n",
       "    };\n",
       "    ws.send = function(m) {\n",
       "        //console.log('sending', m);\n",
       "        comm.send(m);\n",
       "    };\n",
       "    // Register the callback with on_msg.\n",
       "    comm.on_msg(function(msg) {\n",
       "        //console.log('receiving', msg['content']['data'], msg);\n",
       "        // Pass the mpl event to the overridden (by mpl) onmessage function.\n",
       "        ws.onmessage(msg['content']['data'])\n",
       "    });\n",
       "    return ws;\n",
       "}\n",
       "\n",
       "mpl.mpl_figure_comm = function(comm, msg) {\n",
       "    // This is the function which gets called when the mpl process\n",
       "    // starts-up an IPython Comm through the \"matplotlib\" channel.\n",
       "\n",
       "    var id = msg.content.data.id;\n",
       "    // Get hold of the div created by the display call when the Comm\n",
       "    // socket was opened in Python.\n",
       "    var element = $(\"#\" + id);\n",
       "    var ws_proxy = comm_websocket_adapter(comm)\n",
       "\n",
       "    function ondownload(figure, format) {\n",
       "        window.open(figure.imageObj.src);\n",
       "    }\n",
       "\n",
       "    var fig = new mpl.figure(id, ws_proxy,\n",
       "                           ondownload,\n",
       "                           element.get(0));\n",
       "\n",
       "    // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n",
       "    // web socket which is closed, not our websocket->open comm proxy.\n",
       "    ws_proxy.onopen();\n",
       "\n",
       "    fig.parent_element = element.get(0);\n",
       "    fig.cell_info = mpl.find_output_cell(\"<div id='\" + id + \"'></div>\");\n",
       "    if (!fig.cell_info) {\n",
       "        console.error(\"Failed to find cell for figure\", id, fig);\n",
       "        return;\n",
       "    }\n",
       "\n",
       "    var output_index = fig.cell_info[2]\n",
       "    var cell = fig.cell_info[0];\n",
       "\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_close = function(fig, msg) {\n",
       "    var width = fig.canvas.width/mpl.ratio\n",
       "    fig.root.unbind('remove')\n",
       "\n",
       "    // Update the output cell to use the data from the current canvas.\n",
       "    fig.push_to_output();\n",
       "    var dataURL = fig.canvas.toDataURL();\n",
       "    // Re-enable the keyboard manager in IPython - without this line, in FF,\n",
       "    // the notebook keyboard shortcuts fail.\n",
       "    IPython.keyboard_manager.enable()\n",
       "    $(fig.parent_element).html('<img src=\"' + dataURL + '\" width=\"' + width + '\">');\n",
       "    fig.close_ws(fig, msg);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.close_ws = function(fig, msg){\n",
       "    fig.send_message('closing', msg);\n",
       "    // fig.ws.close()\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.push_to_output = function(remove_interactive) {\n",
       "    // Turn the data on the canvas into data in the output cell.\n",
       "    var width = this.canvas.width/mpl.ratio\n",
       "    var dataURL = this.canvas.toDataURL();\n",
       "    this.cell_info[1]['text/html'] = '<img src=\"' + dataURL + '\" width=\"' + width + '\">';\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.updated_canvas_event = function() {\n",
       "    // Tell IPython that the notebook contents must change.\n",
       "    IPython.notebook.set_dirty(true);\n",
       "    this.send_message(\"ack\", {});\n",
       "    var fig = this;\n",
       "    // Wait a second, then push the new image to the DOM so\n",
       "    // that it is saved nicely (might be nice to debounce this).\n",
       "    setTimeout(function () { fig.push_to_output() }, 1000);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_toolbar = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var nav_element = $('<div/>')\n",
       "    nav_element.attr('style', 'width: 100%');\n",
       "    this.root.append(nav_element);\n",
       "\n",
       "    // Define a callback function for later on.\n",
       "    function toolbar_event(event) {\n",
       "        return fig.toolbar_button_onclick(event['data']);\n",
       "    }\n",
       "    function toolbar_mouse_event(event) {\n",
       "        return fig.toolbar_button_onmouseover(event['data']);\n",
       "    }\n",
       "\n",
       "    for(var toolbar_ind in mpl.toolbar_items){\n",
       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
       "\n",
       "        if (!name) { continue; };\n",
       "\n",
       "        var button = $('<button class=\"btn btn-default\" href=\"#\" title=\"' + name + '\"><i class=\"fa ' + image + ' fa-lg\"></i></button>');\n",
       "        button.click(method_name, toolbar_event);\n",
       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
       "        nav_element.append(button);\n",
       "    }\n",
       "\n",
       "    // Add the status bar.\n",
       "    var status_bar = $('<span class=\"mpl-message\" style=\"text-align:right; float: right;\"/>');\n",
       "    nav_element.append(status_bar);\n",
       "    this.message = status_bar[0];\n",
       "\n",
       "    // Add the close button to the window.\n",
       "    var buttongrp = $('<div class=\"btn-group inline pull-right\"></div>');\n",
       "    var button = $('<button class=\"btn btn-mini btn-primary\" href=\"#\" title=\"Stop Interaction\"><i class=\"fa fa-power-off icon-remove icon-large\"></i></button>');\n",
       "    button.click(function (evt) { fig.handle_close(fig, {}); } );\n",
       "    button.mouseover('Stop Interaction', toolbar_mouse_event);\n",
       "    buttongrp.append(button);\n",
       "    var titlebar = this.root.find($('.ui-dialog-titlebar'));\n",
       "    titlebar.prepend(buttongrp);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._root_extra_style = function(el){\n",
       "    var fig = this\n",
       "    el.on(\"remove\", function(){\n",
       "\tfig.close_ws(fig, {});\n",
       "    });\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._canvas_extra_style = function(el){\n",
       "    // this is important to make the div 'focusable\n",
       "    el.attr('tabindex', 0)\n",
       "    // reach out to IPython and tell the keyboard manager to turn it's self\n",
       "    // off when our div gets focus\n",
       "\n",
       "    // location in version 3\n",
       "    if (IPython.notebook.keyboard_manager) {\n",
       "        IPython.notebook.keyboard_manager.register_events(el);\n",
       "    }\n",
       "    else {\n",
       "        // location in version 2\n",
       "        IPython.keyboard_manager.register_events(el);\n",
       "    }\n",
       "\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._key_event_extra = function(event, name) {\n",
       "    var manager = IPython.notebook.keyboard_manager;\n",
       "    if (!manager)\n",
       "        manager = IPython.keyboard_manager;\n",
       "\n",
       "    // Check for shift+enter\n",
       "    if (event.shiftKey && event.which == 13) {\n",
       "        this.canvas_div.blur();\n",
       "        event.shiftKey = false;\n",
       "        // Send a \"J\" for go to next cell\n",
       "        event.which = 74;\n",
       "        event.keyCode = 74;\n",
       "        manager.command_mode();\n",
       "        manager.handle_keydown(event);\n",
       "    }\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_save = function(fig, msg) {\n",
       "    fig.ondownload(fig, null);\n",
       "}\n",
       "\n",
       "\n",
       "mpl.find_output_cell = function(html_output) {\n",
       "    // Return the cell and output element which can be found *uniquely* in the notebook.\n",
       "    // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n",
       "    // IPython event is triggered only after the cells have been serialised, which for\n",
       "    // our purposes (turning an active figure into a static one), is too late.\n",
       "    var cells = IPython.notebook.get_cells();\n",
       "    var ncells = cells.length;\n",
       "    for (var i=0; i<ncells; i++) {\n",
       "        var cell = cells[i];\n",
       "        if (cell.cell_type === 'code'){\n",
       "            for (var j=0; j<cell.output_area.outputs.length; j++) {\n",
       "                var data = cell.output_area.outputs[j];\n",
       "                if (data.data) {\n",
       "                    // IPython >= 3 moved mimebundle to data attribute of output\n",
       "                    data = data.data;\n",
       "                }\n",
       "                if (data['text/html'] == html_output) {\n",
       "                    return [cell, data, j];\n",
       "                }\n",
       "            }\n",
       "        }\n",
       "    }\n",
       "}\n",
       "\n",
       "// Register the function which deals with the matplotlib target/channel.\n",
       "// The kernel may be null if the page has been refreshed.\n",
       "if (IPython.notebook.kernel != null) {\n",
       "    IPython.notebook.kernel.comm_manager.register_target('matplotlib', mpl.mpl_figure_comm);\n",
       "}\n"
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<img src=\"data:image/png;base64,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\" width=\"640\">"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "ax = prices.plot(logy=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}