From ecbdb29ad080b4156e0eba03791689f7d86ad1c9 Mon Sep 17 00:00:00 2001
From: Abram Claycomb <aclaycomb@usgs.gov>
Date: Fri, 19 Oct 2018 12:05:39 -0600
Subject: [PATCH] channels, stats

---
 docs/algorithms/FilterAlgorithm.ipynb | 2589 +++-----
 docs/algorithms/Filter_notes.ipynb    | 8500 ++++---------------------
 geomagio/algorithm/FilterAlgorithm.py |   28 +-
 3 files changed, 2212 insertions(+), 8905 deletions(-)

diff --git a/docs/algorithms/FilterAlgorithm.ipynb b/docs/algorithms/FilterAlgorithm.ipynb
index 4492e106a..91a351d38 100644
--- a/docs/algorithms/FilterAlgorithm.ipynb
+++ b/docs/algorithms/FilterAlgorithm.ipynb
@@ -2,7 +2,7 @@
  "cells": [
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": 2,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -20,23 +20,211 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 57,
    "metadata": {},
    "outputs": [],
    "source": [
+    "\"\"\"Algorithm that converts from one geomagnetic coordinate system to a\n",
+    "    related geographic coordinate system, by using transformations generated\n",
+    "    from absolute, baseline measurements.\n",
+    "\"\"\"\n",
+    "\n",
+    "from numpy.lib import stride_tricks as npls\n",
+    "\n",
+    "\n",
+    "import sys\n",
+    "\n",
+    "\n",
     "class FilterAlgorithm(Algorithm):\n",
-    "    \"\"\"Filter Algorithm\"\"\""
+    "    \"\"\"Filter Algorithm\"\"\"\n",
+    "\n",
+    "    def __init__(self, decimation=None, window=None, interval=None, \n",
+    "                 location=None, inchannels=None, outchannels=None):\n",
+    "        Algorithm.__init__(self, inchannels=inchannels,\n",
+    "            outchannels=outchannels)\n",
+    "        self.numtaps=91\n",
+    "        # get filter window (standard intermagnet one-minute filter)\n",
+    "        self.window = sps.get_window(window=('gaussian', 15.8734), \n",
+    "                                             Nx=self.numtaps)\n",
+    "        # normalize filter window\n",
+    "        self.window = self.window/np.sum(self.window)\n",
+    "        self.decimation = 60\n",
+    "        self.sample_period = 1.0\n",
+    "        self.data_type = None\n",
+    "        self.location = None\n",
+    "        self.inchannels = inchannels\n",
+    "        self.outchannels = outchannels\n",
+    "\n",
+    "\n",
+    "    def create_trace(self, channel, stats, data):\n",
+    "        \"\"\"Utility to create a new trace object.\n",
+    "\n",
+    "        Parameters\n",
+    "        ----------\n",
+    "        channel : str\n",
+    "            channel name.\n",
+    "        stats : obspy.core.Stats\n",
+    "            channel metadata to clone.\n",
+    "        data : numpy.array\n",
+    "            channel data.\n",
+    "\n",
+    "        Returns\n",
+    "        -------\n",
+    "        obspy.core.Trace\n",
+    "            trace containing data and metadata.\n",
+    "        \"\"\"\n",
+    "        stats = Stats(stats)\n",
+    "        if self.data_type is None:\n",
+    "            stats.data_type = 'variation'\n",
+    "        else:\n",
+    "            stats.data_type = self.data_type\n",
+    "        if self.data_type is None:\n",
+    "            stats.location = 'R0'\n",
+    "        else:\n",
+    "            stats.location = self.location\n",
+    "\n",
+    "        trace = super(FilterAlgorithm, self).create_trace(channel, stats,\n",
+    "            data)\n",
+    "        return trace\n",
+    "\n",
+    "    def process(self, stream):\n",
+    "        \"\"\"Run algorithm for a stream.\n",
+    "        Processes all traces in the stream.\n",
+    "        Parameters\n",
+    "        ----------\n",
+    "        stream : obspy.core.Stream\n",
+    "            stream of data to process\n",
+    "        Returns\n",
+    "        -------\n",
+    "        out : obspy.core.Stream\n",
+    "            stream containing 1 trace per original trace.\n",
+    "        \"\"\"\n",
+    "\n",
+    "        out = Stream()\n",
+    "        \n",
+    "        trace_channels = []\n",
+    "        \n",
+    "        for trace in stream:\n",
+    "            trace_channels.append(trace.stats.channel)\n",
+    "\n",
+    "        trace_chan_dict = dict(zip(trace_channels, self.outchannels))\n",
+    "        print(trace_chan_dict)\n",
+    "        \n",
+    "        for trace in stream:\n",
+    "            data = trace.data\n",
+    "            times = trace.times()\n",
+    "            half = self.numtaps//2\n",
+    "            step = self.decimation\n",
+    "\n",
+    "            filtered = self.firfilter(data, self.window, step)\n",
+    "            print(len(filtered))\n",
+    "            \n",
+    "            stats=Stats(trace.stats)\n",
+    "            stats.channel = trace_chan_dict[trace.stats.channel]\n",
+    "            stats.starttime = trace.stats.starttime + half\n",
+    "            stats.delta = trace.stats.delta*step\n",
+    "            stats.npts = filtered.shape[0]\n",
+    "            stats.pop('processing')\n",
+    "            trace_out = self.create_trace(\n",
+    "                trace_chan_dict[trace.stats.channel], stats, filtered)\n",
+    "\n",
+    "            out += trace_out\n",
+    "\n",
+    "        return out\n",
+    "    \n",
+    "    @classmethod\n",
+    "    def firfilter(cls, data, window, step, allowed_bad = 0.1):\n",
+    "        \"\"\"Run fir filter for a numpy array.\n",
+    "        Processes all traces in the stream.\n",
+    "        Parameters\n",
+    "        ----------\n",
+    "        data: numpy.ndarray\n",
+    "            array of data to process\n",
+    "        window: numpy.ndarray\n",
+    "            array of filter coefficients\n",
+    "        step: int\n",
+    "            ratio of output sample period to input sample period\n",
+    "            should always be an integer\n",
+    "        allowed_bad: float\n",
+    "            ratio of bad samples to total window size\n",
+    "        Returns\n",
+    "        -------\n",
+    "        filtered_out : numpy.ndarray\n",
+    "            stream containing filtered output\n",
+    "        \"\"\"\n",
+    "        numtaps = len(window)\n",
+    "        half = numtaps//2\n",
+    "\n",
+    "        # build view into data, with numtaps  chunks separated into \n",
+    "        # overlapping 'rows'\n",
+    "        shape = data.shape[:-1] + (data.shape[-1] - numtaps + 1, \n",
+    "                                   numtaps)\n",
+    "        \n",
+    "        strides = data.strides + (data.strides[-1],)\n",
+    "        \n",
+    "        as_s = npls.as_strided(data, shape=shape, strides=strides, \n",
+    "                               writeable=False)\n",
+    "        \n",
+    "        print(as_s.shape)\n",
+    "        # build masked array for invalid entries\n",
+    "        as_masked = np.ma.masked_invalid(as_s[::step], copy=True)\n",
+    "        as_weight_sums =  np.dot(window, (~as_masked.mask).T)\n",
+    "        as_invalid_sums = np.sum(as_masked.mask)\n",
+    "            \n",
+    "        as_invalid_masked = np.ma.masked_greater(as_invalid_sums, \n",
+    "                                                 np.floor(\n",
+    "                                                    allowed_bad*numtaps))\n",
+    "\n",
+    "        print(np.dot(window, as_s[0].T))\n",
+    "        print(np.dot(window, as_s[-1].T))\n",
+    "        # apply filter\n",
+    "        filtered = np.ma.dot(window, as_masked.T)\n",
+    "        # re-normalize, especially important for partially filled windows\n",
+    "        filtered = np.divide(filtered, as_weight_sums)\n",
+    "        filtered.mask = as_invalid_masked.mask\n",
+    "        filtered_out = np.ma.filled(filtered, np.nan)\n",
+    "        \n",
+    "        print(len(filtered_out))\n",
+    "\n",
+    "        return filtered_out\n",
+    "\n",
+    "def get_input_interval(self, start, end, observatory=None, channels=None):\n",
+    "        \"\"\"Get Input Interval\n",
+    "\n",
+    "        start : UTCDateTime\n",
+    "            start time of requested output.\n",
+    "        end : UTCDateTime\n",
+    "            end time of requested output.\n",
+    "        observatory : string\n",
+    "            observatory code.\n",
+    "        channels : string\n",
+    "            input channels.\n",
+    "\n",
+    "        Returns\n",
+    "        -------\n",
+    "        input_start : UTCDateTime\n",
+    "            start of input required to generate requested output\n",
+    "        input_end : UTCDateTime\n",
+    "            end of input required to generate requested output.\n",
+    "        \"\"\"\n",
+    "\n",
+    "        half = self.numtaps//2\n",
+    "        step = self.decimation\n",
+    "        start = start - half*self.interval\n",
+    "        end = end + half*self.interval\n",
+    "\n",
+    "        return (start, end)\n"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 42,
+   "execution_count": 3,
    "metadata": {},
    "outputs": [],
    "source": [
     "# excerpted from https://github.com/scipy/scipy/issues/7725#issuecomment-322094749\n",
     "sample_rate = 10.0\n",
-    "cutoff = 0.2\n",
+    "cutoff = 0.35\n",
     "width = 0.3\n",
     "stop_db = 50.0\n",
     "stop_db = np.abs(stop_db)\n",
@@ -53,7 +241,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 43,
+   "execution_count": 4,
    "metadata": {},
    "outputs": [
     {
@@ -62,7 +250,7 @@
        "99"
       ]
      },
-     "execution_count": 43,
+     "execution_count": 4,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -73,7 +261,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 44,
+   "execution_count": 5,
    "metadata": {},
    "outputs": [
     {
@@ -82,7 +270,7 @@
        "4.533514120981248"
       ]
      },
-     "execution_count": 44,
+     "execution_count": 5,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -93,40 +281,40 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 45,
+   "execution_count": 6,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "array([-4.52198796e-05, -1.11619355e-04, -2.01483397e-04, -3.16506684e-04,\n",
-       "       -4.57626335e-04, -6.24859943e-04, -8.17155093e-04, -1.03225668e-03,\n",
-       "       -1.26659826e-03, -1.51522326e-03, -1.77174156e-03, -2.02832596e-03,\n",
-       "       -2.27575221e-03, -2.50348516e-03, -2.69981225e-03, -2.85202413e-03,\n",
-       "       -2.94664077e-03, -2.96967983e-03, -2.90696256e-03, -2.74445127e-03,\n",
-       "       -2.46861053e-03, -2.06678395e-03, -1.52757659e-03, -8.41232992e-04,\n",
-       "        8.97254861e-19,  1.00153625e-03,  2.16614984e-03,  3.49372106e-03,\n",
-       "        4.98103797e-03,  6.62166161e-03,  8.40586129e-03,  1.03206248e-02,\n",
-       "        1.23497468e-02,  1.44739951e-02,  1.66713562e-02,  1.89173528e-02,\n",
-       "        2.11854322e-02,  2.34474143e-02,  2.56739920e-02,  2.78352727e-02,\n",
-       "        2.99013480e-02,  3.18428788e-02,  3.36316814e-02,  3.52413005e-02,\n",
-       "        3.66475558e-02,  3.78290461e-02,  3.87676015e-02,  3.94486690e-02,\n",
-       "        3.98616244e-02,  4.00000000e-02,  3.98616244e-02,  3.94486690e-02,\n",
-       "        3.87676015e-02,  3.78290461e-02,  3.66475558e-02,  3.52413005e-02,\n",
-       "        3.36316814e-02,  3.18428788e-02,  2.99013480e-02,  2.78352727e-02,\n",
-       "        2.56739920e-02,  2.34474143e-02,  2.11854322e-02,  1.89173528e-02,\n",
-       "        1.66713562e-02,  1.44739951e-02,  1.23497468e-02,  1.03206248e-02,\n",
-       "        8.40586129e-03,  6.62166161e-03,  4.98103797e-03,  3.49372106e-03,\n",
-       "        2.16614984e-03,  1.00153625e-03,  8.97254861e-19, -8.41232992e-04,\n",
-       "       -1.52757659e-03, -2.06678395e-03, -2.46861053e-03, -2.74445127e-03,\n",
-       "       -2.90696256e-03, -2.96967983e-03, -2.94664077e-03, -2.85202413e-03,\n",
-       "       -2.69981225e-03, -2.50348516e-03, -2.27575221e-03, -2.02832596e-03,\n",
-       "       -1.77174156e-03, -1.51522326e-03, -1.26659826e-03, -1.03225668e-03,\n",
-       "       -8.17155093e-04, -6.24859943e-04, -4.57626335e-04, -3.16506684e-04,\n",
-       "       -2.01483397e-04, -1.11619355e-04, -4.52198796e-05])"
+       "array([-3.52108034e-04, -4.06113064e-04, -4.32470789e-04, -4.18780310e-04,\n",
+       "       -3.53459036e-04, -2.27006071e-04, -3.33121617e-05,  2.29088259e-04,\n",
+       "        5.55936989e-04,  9.36459472e-04,  1.35296773e-03,  1.78094988e-03,\n",
+       "        2.18971137e-03,  2.54359924e-03,  2.80380086e-03,  2.93066500e-03,\n",
+       "        2.88644882e-03,  2.63835275e-03,  2.16166912e-03,  1.44284342e-03,\n",
+       "        4.82231450e-04, -7.03665956e-04, -2.08069626e-03, -3.59645375e-03,\n",
+       "       -5.18071820e-03, -6.74701354e-03, -8.19530200e-03, -9.41575888e-03,\n",
+       "       -1.02935010e-02, -1.07140735e-02, -1.05694378e-02, -9.76415629e-03,\n",
+       "       -8.22143526e-03, -5.88867560e-03, -2.74218686e-03,  1.20924955e-03,\n",
+       "        5.92223335e-03,  1.13182119e-02,  1.72846746e-02,  2.36780972e-02,\n",
+       "        3.03285588e-02,  3.70458597e-02,  4.36268766e-02,  4.98638150e-02,\n",
+       "        5.55529612e-02,  6.05034950e-02,  6.45459159e-02,  6.75396436e-02,\n",
+       "        6.93793953e-02,  7.00000000e-02,  6.93793953e-02,  6.75396436e-02,\n",
+       "        6.45459159e-02,  6.05034950e-02,  5.55529612e-02,  4.98638150e-02,\n",
+       "        4.36268766e-02,  3.70458597e-02,  3.03285588e-02,  2.36780972e-02,\n",
+       "        1.72846746e-02,  1.13182119e-02,  5.92223335e-03,  1.20924955e-03,\n",
+       "       -2.74218686e-03, -5.88867560e-03, -8.22143526e-03, -9.76415629e-03,\n",
+       "       -1.05694378e-02, -1.07140735e-02, -1.02935010e-02, -9.41575888e-03,\n",
+       "       -8.19530200e-03, -6.74701354e-03, -5.18071820e-03, -3.59645375e-03,\n",
+       "       -2.08069626e-03, -7.03665956e-04,  4.82231450e-04,  1.44284342e-03,\n",
+       "        2.16166912e-03,  2.63835275e-03,  2.88644882e-03,  2.93066500e-03,\n",
+       "        2.80380086e-03,  2.54359924e-03,  2.18971137e-03,  1.78094988e-03,\n",
+       "        1.35296773e-03,  9.36459472e-04,  5.55936989e-04,  2.29088259e-04,\n",
+       "       -3.33121617e-05, -2.27006071e-04, -3.53459036e-04, -4.18780310e-04,\n",
+       "       -4.32470789e-04, -4.06113064e-04, -3.52108034e-04])"
       ]
      },
-     "execution_count": 45,
+     "execution_count": 6,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -137,16 +325,16 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 46,
+   "execution_count": 7,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "1.0034504636745052"
+       "1.0027947751401205"
       ]
      },
-     "execution_count": 46,
+     "execution_count": 7,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -157,7 +345,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 47,
+   "execution_count": 8,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -166,40 +354,40 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 48,
+   "execution_count": 9,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "array([-4.50643866e-05, -1.11235541e-04, -2.00790576e-04, -3.15418344e-04,\n",
-       "       -4.56052742e-04, -6.22711300e-04, -8.14345224e-04, -1.02870717e-03,\n",
-       "       -1.26224294e-03, -1.51001301e-03, -1.76564925e-03, -2.02135136e-03,\n",
-       "       -2.26792681e-03, -2.49487668e-03, -2.69052868e-03, -2.84221717e-03,\n",
-       "       -2.93650846e-03, -2.95946829e-03, -2.89696669e-03, -2.73501420e-03,\n",
-       "       -2.46012197e-03, -2.05967711e-03, -1.52232387e-03, -8.38340329e-04,\n",
-       "        8.94169561e-19,  9.98092368e-04,  2.15870132e-03,  3.48170755e-03,\n",
-       "        4.96391018e-03,  6.59889237e-03,  8.37695691e-03,  1.02851364e-02,\n",
-       "        1.23072809e-02,  1.44242249e-02,  1.66140301e-02,  1.88523036e-02,\n",
-       "        2.11125840e-02,  2.33667880e-02,  2.55857094e-02,  2.77395583e-02,\n",
-       "        2.97985293e-02,  3.17333839e-02,  3.35160355e-02,  3.51201198e-02,\n",
-       "        3.65215396e-02,  3.76989672e-02,  3.86342953e-02,  3.93130209e-02,\n",
-       "        3.97245562e-02,  3.98624560e-02,  3.97245562e-02,  3.93130209e-02,\n",
-       "        3.86342953e-02,  3.76989672e-02,  3.65215396e-02,  3.51201198e-02,\n",
-       "        3.35160355e-02,  3.17333839e-02,  2.97985293e-02,  2.77395583e-02,\n",
-       "        2.55857094e-02,  2.33667880e-02,  2.11125840e-02,  1.88523036e-02,\n",
-       "        1.66140301e-02,  1.44242249e-02,  1.23072809e-02,  1.02851364e-02,\n",
-       "        8.37695691e-03,  6.59889237e-03,  4.96391018e-03,  3.48170755e-03,\n",
-       "        2.15870132e-03,  9.98092368e-04,  8.94169561e-19, -8.38340329e-04,\n",
-       "       -1.52232387e-03, -2.05967711e-03, -2.46012197e-03, -2.73501420e-03,\n",
-       "       -2.89696669e-03, -2.95946829e-03, -2.93650846e-03, -2.84221717e-03,\n",
-       "       -2.69052868e-03, -2.49487668e-03, -2.26792681e-03, -2.02135136e-03,\n",
-       "       -1.76564925e-03, -1.51001301e-03, -1.26224294e-03, -1.02870717e-03,\n",
-       "       -8.14345224e-04, -6.22711300e-04, -4.56052742e-04, -3.15418344e-04,\n",
-       "       -2.00790576e-04, -1.11235541e-04, -4.50643866e-05])"
+       "array([-3.51126714e-04, -4.04981233e-04, -4.31265499e-04, -4.17613176e-04,\n",
+       "       -3.52473951e-04, -2.26373408e-04, -3.32193212e-05,  2.28449793e-04,\n",
+       "        5.54387600e-04,  9.33849573e-04,  1.34919703e-03,  1.77598640e-03,\n",
+       "        2.18360868e-03,  2.53651026e-03,  2.79598671e-03,  2.92249728e-03,\n",
+       "        2.87840433e-03,  2.63099969e-03,  2.15564458e-03,  1.43882223e-03,\n",
+       "        4.80887478e-04, -7.01704848e-04, -2.07489739e-03, -3.58643048e-03,\n",
+       "       -5.16627961e-03, -6.72820970e-03, -8.17246180e-03, -9.38951729e-03,\n",
+       "       -1.02648132e-02, -1.06842136e-02, -1.05399810e-02, -9.73694372e-03,\n",
+       "       -8.19852223e-03, -5.87226394e-03, -2.73454442e-03,  1.20587938e-03,\n",
+       "        5.90572816e-03,  1.12866682e-02,  1.72365025e-02,  2.36121067e-02,\n",
+       "        3.02440335e-02,  3.69426134e-02,  4.35052891e-02,  4.97248453e-02,\n",
+       "        5.53981359e-02,  6.03348726e-02,  6.43660273e-02,  6.73514115e-02,\n",
+       "        6.91860358e-02,  6.98049110e-02,  6.91860358e-02,  6.73514115e-02,\n",
+       "        6.43660273e-02,  6.03348726e-02,  5.53981359e-02,  4.97248453e-02,\n",
+       "        4.35052891e-02,  3.69426134e-02,  3.02440335e-02,  2.36121067e-02,\n",
+       "        1.72365025e-02,  1.12866682e-02,  5.90572816e-03,  1.20587938e-03,\n",
+       "       -2.73454442e-03, -5.87226394e-03, -8.19852223e-03, -9.73694372e-03,\n",
+       "       -1.05399810e-02, -1.06842136e-02, -1.02648132e-02, -9.38951729e-03,\n",
+       "       -8.17246180e-03, -6.72820970e-03, -5.16627961e-03, -3.58643048e-03,\n",
+       "       -2.07489739e-03, -7.01704848e-04,  4.80887478e-04,  1.43882223e-03,\n",
+       "        2.15564458e-03,  2.63099969e-03,  2.87840433e-03,  2.92249728e-03,\n",
+       "        2.79598671e-03,  2.53651026e-03,  2.18360868e-03,  1.77598640e-03,\n",
+       "        1.34919703e-03,  9.33849573e-04,  5.54387600e-04,  2.28449793e-04,\n",
+       "       -3.32193212e-05, -2.26373408e-04, -3.52473951e-04, -4.17613176e-04,\n",
+       "       -4.31265499e-04, -4.04981233e-04, -3.51126714e-04])"
       ]
      },
-     "execution_count": 48,
+     "execution_count": 9,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -210,22 +398,22 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 49,
+   "execution_count": 10,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "[<matplotlib.lines.Line2D at 0x1c205b1208>]"
+       "[<matplotlib.lines.Line2D at 0x1c20d0c400>]"
       ]
      },
-     "execution_count": 49,
+     "execution_count": 10,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -242,7 +430,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 112,
+   "execution_count": 11,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -251,7 +439,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 113,
+   "execution_count": 12,
    "metadata": {},
    "outputs": [
     {
@@ -264,7 +452,7 @@
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 432x288 with 2 Axes>"
       ]
@@ -293,44 +481,44 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 114,
+   "execution_count": 13,
    "metadata": {},
    "outputs": [],
    "source": [
-    "taps2 = sps.firwin2(99, freq=[0, 0.04, 0.1, 5.0], gain=[1, 1, 10**(-50.0/20.0), 0], nyq=5.0,antisymmetric=False)"
+    "taps2 = sps.firwin2(99, freq=[0, 0.08, 0.5, 5.0], gain=[1, 10**(-25.0/20.0), 10**(-50.0/20.0), 0], nyq=5.0,antisymmetric=False)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 115,
+   "execution_count": 14,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "array([0.00036743, 0.00039389, 0.00043087, 0.00047976, 0.00054214,\n",
-       "       0.00061929, 0.00071271, 0.00082349, 0.00095298, 0.001102  ,\n",
-       "       0.00127171, 0.00146257, 0.00167551, 0.00191056, 0.00216841,\n",
-       "       0.00244856, 0.00275147, 0.00307606, 0.00342256, 0.00378925,\n",
-       "       0.00417619, 0.00458094, 0.0050035 , 0.00544063, 0.0058924 ,\n",
-       "       0.00635471, 0.00682785, 0.00730675, 0.0077922 , 0.008278  ,\n",
-       "       0.00876574, 0.00924788, 0.00972728, 0.01019469, 0.01065487,\n",
-       "       0.01109625, 0.01152651, 0.0119307 , 0.01232103, 0.01267721,\n",
-       "       0.01301894, 0.01331671, 0.01360379, 0.01383258, 0.01406534,\n",
-       "       0.01421121, 0.01441783, 0.01444252, 0.01515414, 0.01613373,\n",
-       "       0.01515414, 0.01444252, 0.01441783, 0.01421121, 0.01406534,\n",
-       "       0.01383258, 0.01360379, 0.01331671, 0.01301894, 0.01267721,\n",
-       "       0.01232103, 0.0119307 , 0.01152651, 0.01109625, 0.01065487,\n",
-       "       0.01019469, 0.00972728, 0.00924788, 0.00876574, 0.008278  ,\n",
-       "       0.0077922 , 0.00730675, 0.00682785, 0.00635471, 0.0058924 ,\n",
-       "       0.00544063, 0.0050035 , 0.00458094, 0.00417619, 0.00378925,\n",
-       "       0.00342256, 0.00307606, 0.00275147, 0.00244856, 0.00216841,\n",
-       "       0.00191056, 0.00167551, 0.00146257, 0.00127171, 0.001102  ,\n",
-       "       0.00095298, 0.00082349, 0.00071271, 0.00061929, 0.00054214,\n",
-       "       0.00047976, 0.00043087, 0.00039389, 0.00036743])"
+       "array([0.00039358, 0.00040542, 0.00042685, 0.00045817, 0.00049988,\n",
+       "       0.00055217, 0.00061552, 0.00069004, 0.00077623, 0.00087413,\n",
+       "       0.00098429, 0.00110658, 0.00124152, 0.00138868, 0.00154838,\n",
+       "       0.00171962, 0.0019024 , 0.00209495, 0.0022969 , 0.00250572,\n",
+       "       0.00272089, 0.00293933, 0.0031609 , 0.00338241, 0.00360487,\n",
+       "       0.0038255 , 0.0040472 , 0.00426795, 0.00449303, 0.00472101,\n",
+       "       0.0049596 , 0.00520703, 0.005473  , 0.00575376, 0.00606023,\n",
+       "       0.00638447, 0.00673808, 0.00710631, 0.00750206, 0.00790081,\n",
+       "       0.00831959, 0.00872002, 0.00913063, 0.00949079, 0.00985902,\n",
+       "       0.01012713, 0.0104473 , 0.01054791, 0.01136939, 0.01245199,\n",
+       "       0.01136939, 0.01054791, 0.0104473 , 0.01012713, 0.00985902,\n",
+       "       0.00949079, 0.00913063, 0.00872002, 0.00831959, 0.00790081,\n",
+       "       0.00750206, 0.00710631, 0.00673808, 0.00638447, 0.00606023,\n",
+       "       0.00575376, 0.005473  , 0.00520703, 0.0049596 , 0.00472101,\n",
+       "       0.00449303, 0.00426795, 0.0040472 , 0.0038255 , 0.00360487,\n",
+       "       0.00338241, 0.0031609 , 0.00293933, 0.00272089, 0.00250572,\n",
+       "       0.0022969 , 0.00209495, 0.0019024 , 0.00171962, 0.00154838,\n",
+       "       0.00138868, 0.00124152, 0.00110658, 0.00098429, 0.00087413,\n",
+       "       0.00077623, 0.00069004, 0.00061552, 0.00055217, 0.00049988,\n",
+       "       0.00045817, 0.00042685, 0.00040542, 0.00039358])"
       ]
      },
-     "execution_count": 115,
+     "execution_count": 14,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -341,22 +529,22 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 116,
+   "execution_count": 15,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "[<matplotlib.lines.Line2D at 0x1c20695748>]"
+       "[<matplotlib.lines.Line2D at 0x1c25603f60>]"
       ]
      },
-     "execution_count": 116,
+     "execution_count": 15,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -373,7 +561,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 82,
+   "execution_count": 16,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -382,7 +570,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 83,
+   "execution_count": 17,
    "metadata": {},
    "outputs": [
     {
@@ -395,7 +583,7 @@
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 432x288 with 2 Axes>"
       ]
@@ -431,7 +619,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 18,
    "metadata": {},
    "outputs": [
     {
@@ -441,7 +629,7 @@
      "traceback": [
       "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
       "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
-      "\u001b[0;32m<ipython-input-11-aa5ebe4e8c59>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mw\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mlinspace\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m0.0\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpi\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m512\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      2\u001b[0m \u001b[0mgd_samples\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mnumtaps\u001b[0m\u001b[0;34m/\u001b[0m\u001b[0;36m2\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mones_like\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mw\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0mgd_time\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mnumtaps\u001b[0m\u001b[0;34m/\u001b[0m\u001b[0;36m2\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0mgd_\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;32m<ipython-input-18-aa5ebe4e8c59>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mw\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mlinspace\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m0.0\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpi\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m512\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      2\u001b[0m \u001b[0mgd_samples\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mnumtaps\u001b[0m\u001b[0;34m/\u001b[0m\u001b[0;36m2\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mones_like\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mw\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0mgd_time\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mnumtaps\u001b[0m\u001b[0;34m/\u001b[0m\u001b[0;36m2\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0mgd_\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
       "\u001b[0;31mNameError\u001b[0m: name 'linspace' is not defined"
      ]
     }
@@ -455,7 +643,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 84,
+   "execution_count": 19,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -464,17 +652,18 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 85,
+   "execution_count": 20,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "array([2.94794932e-09, 2.06356452e-08, 6.19069356e-08, 1.03178226e-07,\n",
-       "       1.03178226e-07, 6.19069356e-08, 2.06356452e-08, 2.94794932e-09])"
+       "array([1.33235776e-10, 1.33235776e-09, 5.99560994e-09, 1.59882932e-08,\n",
+       "       2.79795130e-08, 3.35754157e-08, 2.79795130e-08, 1.59882932e-08,\n",
+       "       5.99560994e-09, 1.33235776e-09, 1.33235776e-10])"
       ]
      },
-     "execution_count": 85,
+     "execution_count": 20,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -485,17 +674,18 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 86,
+   "execution_count": 21,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "array([  1.        ,  -6.43513372,  17.7687487 , -27.28864598,\n",
-       "        25.17318559, -13.94787923,   4.29785921,  -0.56813419])"
+       "array([   1.        ,   -8.59408415,   33.32337585,  -76.76079158,\n",
+       "        116.31514286, -121.13496375,   87.79973581,  -43.72962838,\n",
+       "         14.32217009,   -2.78514048,    0.24418385])"
       ]
      },
-     "execution_count": 86,
+     "execution_count": 21,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -506,7 +696,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 87,
+   "execution_count": 22,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -515,7 +705,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 88,
+   "execution_count": 23,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -524,114 +714,26 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 89,
+   "execution_count": 24,
    "metadata": {},
    "outputs": [],
    "source": [
-    "tout, yout = sps.dimpulse((a,b,0.1), t=np.arange(0,99,0.1))"
+    "tout, yout = sps.dimpulse((a,b,0.1), t=np.arange(0,199,0.1))"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 90,
+   "execution_count": 25,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "array([ 0. ,  0.1,  0.2,  0.3,  0.4,  0.5,  0.6,  0.7,  0.8,  0.9,  1. ,\n",
-       "        1.1,  1.2,  1.3,  1.4,  1.5,  1.6,  1.7,  1.8,  1.9,  2. ,  2.1,\n",
-       "        2.2,  2.3,  2.4,  2.5,  2.6,  2.7,  2.8,  2.9,  3. ,  3.1,  3.2,\n",
-       "        3.3,  3.4,  3.5,  3.6,  3.7,  3.8,  3.9,  4. ,  4.1,  4.2,  4.3,\n",
-       "        4.4,  4.5,  4.6,  4.7,  4.8,  4.9,  5. ,  5.1,  5.2,  5.3,  5.4,\n",
-       "        5.5,  5.6,  5.7,  5.8,  5.9,  6. ,  6.1,  6.2,  6.3,  6.4,  6.5,\n",
-       "        6.6,  6.7,  6.8,  6.9,  7. ,  7.1,  7.2,  7.3,  7.4,  7.5,  7.6,\n",
-       "        7.7,  7.8,  7.9,  8. ,  8.1,  8.2,  8.3,  8.4,  8.5,  8.6,  8.7,\n",
-       "        8.8,  8.9,  9. ,  9.1,  9.2,  9.3,  9.4,  9.5,  9.6,  9.7,  9.8,\n",
-       "        9.9, 10. , 10.1, 10.2, 10.3, 10.4, 10.5, 10.6, 10.7, 10.8, 10.9,\n",
-       "       11. , 11.1, 11.2, 11.3, 11.4, 11.5, 11.6, 11.7, 11.8, 11.9, 12. ,\n",
-       "       12.1, 12.2, 12.3, 12.4, 12.5, 12.6, 12.7, 12.8, 12.9, 13. , 13.1,\n",
-       "       13.2, 13.3, 13.4, 13.5, 13.6, 13.7, 13.8, 13.9, 14. , 14.1, 14.2,\n",
-       "       14.3, 14.4, 14.5, 14.6, 14.7, 14.8, 14.9, 15. , 15.1, 15.2, 15.3,\n",
-       "       15.4, 15.5, 15.6, 15.7, 15.8, 15.9, 16. , 16.1, 16.2, 16.3, 16.4,\n",
-       "       16.5, 16.6, 16.7, 16.8, 16.9, 17. , 17.1, 17.2, 17.3, 17.4, 17.5,\n",
-       "       17.6, 17.7, 17.8, 17.9, 18. , 18.1, 18.2, 18.3, 18.4, 18.5, 18.6,\n",
-       "       18.7, 18.8, 18.9, 19. , 19.1, 19.2, 19.3, 19.4, 19.5, 19.6, 19.7,\n",
-       "       19.8, 19.9, 20. , 20.1, 20.2, 20.3, 20.4, 20.5, 20.6, 20.7, 20.8,\n",
-       "       20.9, 21. , 21.1, 21.2, 21.3, 21.4, 21.5, 21.6, 21.7, 21.8, 21.9,\n",
-       "       22. , 22.1, 22.2, 22.3, 22.4, 22.5, 22.6, 22.7, 22.8, 22.9, 23. ,\n",
-       "       23.1, 23.2, 23.3, 23.4, 23.5, 23.6, 23.7, 23.8, 23.9, 24. , 24.1,\n",
-       "       24.2, 24.3, 24.4, 24.5, 24.6, 24.7, 24.8, 24.9, 25. , 25.1, 25.2,\n",
-       "       25.3, 25.4, 25.5, 25.6, 25.7, 25.8, 25.9, 26. , 26.1, 26.2, 26.3,\n",
-       "       26.4, 26.5, 26.6, 26.7, 26.8, 26.9, 27. , 27.1, 27.2, 27.3, 27.4,\n",
-       "       27.5, 27.6, 27.7, 27.8, 27.9, 28. , 28.1, 28.2, 28.3, 28.4, 28.5,\n",
-       "       28.6, 28.7, 28.8, 28.9, 29. , 29.1, 29.2, 29.3, 29.4, 29.5, 29.6,\n",
-       "       29.7, 29.8, 29.9, 30. , 30.1, 30.2, 30.3, 30.4, 30.5, 30.6, 30.7,\n",
-       "       30.8, 30.9, 31. , 31.1, 31.2, 31.3, 31.4, 31.5, 31.6, 31.7, 31.8,\n",
-       "       31.9, 32. , 32.1, 32.2, 32.3, 32.4, 32.5, 32.6, 32.7, 32.8, 32.9,\n",
-       "       33. , 33.1, 33.2, 33.3, 33.4, 33.5, 33.6, 33.7, 33.8, 33.9, 34. ,\n",
-       "       34.1, 34.2, 34.3, 34.4, 34.5, 34.6, 34.7, 34.8, 34.9, 35. , 35.1,\n",
-       "       35.2, 35.3, 35.4, 35.5, 35.6, 35.7, 35.8, 35.9, 36. , 36.1, 36.2,\n",
-       "       36.3, 36.4, 36.5, 36.6, 36.7, 36.8, 36.9, 37. , 37.1, 37.2, 37.3,\n",
-       "       37.4, 37.5, 37.6, 37.7, 37.8, 37.9, 38. , 38.1, 38.2, 38.3, 38.4,\n",
-       "       38.5, 38.6, 38.7, 38.8, 38.9, 39. , 39.1, 39.2, 39.3, 39.4, 39.5,\n",
-       "       39.6, 39.7, 39.8, 39.9, 40. , 40.1, 40.2, 40.3, 40.4, 40.5, 40.6,\n",
-       "       40.7, 40.8, 40.9, 41. , 41.1, 41.2, 41.3, 41.4, 41.5, 41.6, 41.7,\n",
-       "       41.8, 41.9, 42. , 42.1, 42.2, 42.3, 42.4, 42.5, 42.6, 42.7, 42.8,\n",
-       "       42.9, 43. , 43.1, 43.2, 43.3, 43.4, 43.5, 43.6, 43.7, 43.8, 43.9,\n",
-       "       44. , 44.1, 44.2, 44.3, 44.4, 44.5, 44.6, 44.7, 44.8, 44.9, 45. ,\n",
-       "       45.1, 45.2, 45.3, 45.4, 45.5, 45.6, 45.7, 45.8, 45.9, 46. , 46.1,\n",
-       "       46.2, 46.3, 46.4, 46.5, 46.6, 46.7, 46.8, 46.9, 47. , 47.1, 47.2,\n",
-       "       47.3, 47.4, 47.5, 47.6, 47.7, 47.8, 47.9, 48. , 48.1, 48.2, 48.3,\n",
-       "       48.4, 48.5, 48.6, 48.7, 48.8, 48.9, 49. , 49.1, 49.2, 49.3, 49.4,\n",
-       "       49.5, 49.6, 49.7, 49.8, 49.9, 50. , 50.1, 50.2, 50.3, 50.4, 50.5,\n",
-       "       50.6, 50.7, 50.8, 50.9, 51. , 51.1, 51.2, 51.3, 51.4, 51.5, 51.6,\n",
-       "       51.7, 51.8, 51.9, 52. , 52.1, 52.2, 52.3, 52.4, 52.5, 52.6, 52.7,\n",
-       "       52.8, 52.9, 53. , 53.1, 53.2, 53.3, 53.4, 53.5, 53.6, 53.7, 53.8,\n",
-       "       53.9, 54. , 54.1, 54.2, 54.3, 54.4, 54.5, 54.6, 54.7, 54.8, 54.9,\n",
-       "       55. , 55.1, 55.2, 55.3, 55.4, 55.5, 55.6, 55.7, 55.8, 55.9, 56. ,\n",
-       "       56.1, 56.2, 56.3, 56.4, 56.5, 56.6, 56.7, 56.8, 56.9, 57. , 57.1,\n",
-       "       57.2, 57.3, 57.4, 57.5, 57.6, 57.7, 57.8, 57.9, 58. , 58.1, 58.2,\n",
-       "       58.3, 58.4, 58.5, 58.6, 58.7, 58.8, 58.9, 59. , 59.1, 59.2, 59.3,\n",
-       "       59.4, 59.5, 59.6, 59.7, 59.8, 59.9, 60. , 60.1, 60.2, 60.3, 60.4,\n",
-       "       60.5, 60.6, 60.7, 60.8, 60.9, 61. , 61.1, 61.2, 61.3, 61.4, 61.5,\n",
-       "       61.6, 61.7, 61.8, 61.9, 62. , 62.1, 62.2, 62.3, 62.4, 62.5, 62.6,\n",
-       "       62.7, 62.8, 62.9, 63. , 63.1, 63.2, 63.3, 63.4, 63.5, 63.6, 63.7,\n",
-       "       63.8, 63.9, 64. , 64.1, 64.2, 64.3, 64.4, 64.5, 64.6, 64.7, 64.8,\n",
-       "       64.9, 65. , 65.1, 65.2, 65.3, 65.4, 65.5, 65.6, 65.7, 65.8, 65.9,\n",
-       "       66. , 66.1, 66.2, 66.3, 66.4, 66.5, 66.6, 66.7, 66.8, 66.9, 67. ,\n",
-       "       67.1, 67.2, 67.3, 67.4, 67.5, 67.6, 67.7, 67.8, 67.9, 68. , 68.1,\n",
-       "       68.2, 68.3, 68.4, 68.5, 68.6, 68.7, 68.8, 68.9, 69. , 69.1, 69.2,\n",
-       "       69.3, 69.4, 69.5, 69.6, 69.7, 69.8, 69.9, 70. , 70.1, 70.2, 70.3,\n",
-       "       70.4, 70.5, 70.6, 70.7, 70.8, 70.9, 71. , 71.1, 71.2, 71.3, 71.4,\n",
-       "       71.5, 71.6, 71.7, 71.8, 71.9, 72. , 72.1, 72.2, 72.3, 72.4, 72.5,\n",
-       "       72.6, 72.7, 72.8, 72.9, 73. , 73.1, 73.2, 73.3, 73.4, 73.5, 73.6,\n",
-       "       73.7, 73.8, 73.9, 74. , 74.1, 74.2, 74.3, 74.4, 74.5, 74.6, 74.7,\n",
-       "       74.8, 74.9, 75. , 75.1, 75.2, 75.3, 75.4, 75.5, 75.6, 75.7, 75.8,\n",
-       "       75.9, 76. , 76.1, 76.2, 76.3, 76.4, 76.5, 76.6, 76.7, 76.8, 76.9,\n",
-       "       77. , 77.1, 77.2, 77.3, 77.4, 77.5, 77.6, 77.7, 77.8, 77.9, 78. ,\n",
-       "       78.1, 78.2, 78.3, 78.4, 78.5, 78.6, 78.7, 78.8, 78.9, 79. , 79.1,\n",
-       "       79.2, 79.3, 79.4, 79.5, 79.6, 79.7, 79.8, 79.9, 80. , 80.1, 80.2,\n",
-       "       80.3, 80.4, 80.5, 80.6, 80.7, 80.8, 80.9, 81. , 81.1, 81.2, 81.3,\n",
-       "       81.4, 81.5, 81.6, 81.7, 81.8, 81.9, 82. , 82.1, 82.2, 82.3, 82.4,\n",
-       "       82.5, 82.6, 82.7, 82.8, 82.9, 83. , 83.1, 83.2, 83.3, 83.4, 83.5,\n",
-       "       83.6, 83.7, 83.8, 83.9, 84. , 84.1, 84.2, 84.3, 84.4, 84.5, 84.6,\n",
-       "       84.7, 84.8, 84.9, 85. , 85.1, 85.2, 85.3, 85.4, 85.5, 85.6, 85.7,\n",
-       "       85.8, 85.9, 86. , 86.1, 86.2, 86.3, 86.4, 86.5, 86.6, 86.7, 86.8,\n",
-       "       86.9, 87. , 87.1, 87.2, 87.3, 87.4, 87.5, 87.6, 87.7, 87.8, 87.9,\n",
-       "       88. , 88.1, 88.2, 88.3, 88.4, 88.5, 88.6, 88.7, 88.8, 88.9, 89. ,\n",
-       "       89.1, 89.2, 89.3, 89.4, 89.5, 89.6, 89.7, 89.8, 89.9, 90. , 90.1,\n",
-       "       90.2, 90.3, 90.4, 90.5, 90.6, 90.7, 90.8, 90.9, 91. , 91.1, 91.2,\n",
-       "       91.3, 91.4, 91.5, 91.6, 91.7, 91.8, 91.9, 92. , 92.1, 92.2, 92.3,\n",
-       "       92.4, 92.5, 92.6, 92.7, 92.8, 92.9, 93. , 93.1, 93.2, 93.3, 93.4,\n",
-       "       93.5, 93.6, 93.7, 93.8, 93.9, 94. , 94.1, 94.2, 94.3, 94.4, 94.5,\n",
-       "       94.6, 94.7, 94.8, 94.9, 95. , 95.1, 95.2, 95.3, 95.4, 95.5, 95.6,\n",
-       "       95.7, 95.8, 95.9, 96. , 96.1, 96.2, 96.3, 96.4, 96.5, 96.6, 96.7,\n",
-       "       96.8, 96.9, 97. , 97.1, 97.2, 97.3, 97.4, 97.5, 97.6, 97.7, 97.8,\n",
-       "       97.9, 98. , 98.1, 98.2, 98.3, 98.4, 98.5, 98.6, 98.7, 98.8, 98.9])"
+       "array([0.000e+00, 1.000e-01, 2.000e-01, ..., 1.987e+02, 1.988e+02,\n",
+       "       1.989e+02])"
       ]
      },
-     "execution_count": 90,
+     "execution_count": 25,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -642,1005 +744,22 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 91,
+   "execution_count": 26,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "(array([[ 2.94794932e-09],\n",
-       "        [ 3.96060933e-08],\n",
-       "        [ 2.64396071e-07],\n",
-       "        [ 1.18129713e-06],\n",
-       "        [ 4.01358323e-06],\n",
-       "        [ 1.11587968e-05],\n",
-       "        [ 2.66326925e-05],\n",
-       "        [ 5.64174864e-05],\n",
-       "        [ 1.08660984e-04],\n",
-       "        [ 1.93701617e-04],\n",
-       "        [ 3.23916056e-04],\n",
-       "        [ 5.13401949e-04],\n",
-       "        [ 7.77519340e-04],\n",
-       "        [ 1.13232135e-03],\n",
-       "        [ 1.59390845e-03],\n",
-       "        [ 2.17774164e-03],\n",
-       "        [ 2.89794922e-03],\n",
-       "        [ 3.76665894e-03],\n",
-       "        [ 4.79338394e-03],\n",
-       "        [ 5.98448654e-03],\n",
-       "        [ 7.34273901e-03],\n",
-       "        [ 8.86699534e-03],\n",
-       "        [ 1.05519834e-02],\n",
-       "        [ 1.23882219e-02],\n",
-       "        [ 1.43620611e-02],\n",
-       "        [ 1.64558455e-02],\n",
-       "        [ 1.86481877e-02],\n",
-       "        [ 2.09143458e-02],\n",
-       "        [ 2.32266888e-02],\n",
-       "        [ 2.55552376e-02],\n",
-       "        [ 2.78682631e-02],\n",
-       "        [ 3.01329264e-02],\n",
-       "        [ 3.23159424e-02],\n",
-       "        [ 3.43842520e-02],\n",
-       "        [ 3.63056839e-02],\n",
-       "        [ 3.80495940e-02],\n",
-       "        [ 3.95874653e-02],\n",
-       "        [ 4.08934583e-02],\n",
-       "        [ 4.19448999e-02],\n",
-       "        [ 4.27227032e-02],\n",
-       "        [ 4.32117095e-02],\n",
-       "        [ 4.34009496e-02],\n",
-       "        [ 4.32838207e-02],\n",
-       "        [ 4.28581775e-02],\n",
-       "        [ 4.21263386e-02],\n",
-       "        [ 4.10950117e-02],\n",
-       "        [ 3.97751397e-02],\n",
-       "        [ 3.81816753e-02],\n",
-       "        [ 3.63332887e-02],\n",
-       "        [ 3.42520177e-02],\n",
-       "        [ 3.19628675e-02],\n",
-       "        [ 2.94933702e-02],\n",
-       "        [ 2.68731118e-02],\n",
-       "        [ 2.41332378e-02],\n",
-       "        [ 2.13059465e-02],\n",
-       "        [ 1.84239784e-02],\n",
-       "        [ 1.55201124e-02],\n",
-       "        [ 1.26266753e-02],\n",
-       "        [ 9.77507452e-03],\n",
-       "        [ 6.99535909e-03],\n",
-       "        [ 4.31581716e-03],\n",
-       "        [ 1.76261390e-03],\n",
-       "        [-6.40524902e-04],\n",
-       "        [-2.87258037e-03],\n",
-       "        [-4.91545668e-03],\n",
-       "        [-6.75414426e-03],\n",
-       "        [-8.37682960e-03],\n",
-       "        [-9.77495188e-03],\n",
-       "        [-1.09432079e-02],\n",
-       "        [-1.18795071e-02],\n",
-       "        [-1.25848796e-02],\n",
-       "        [-1.30633409e-02],\n",
-       "        [-1.33217163e-02],\n",
-       "        [-1.33694309e-02],\n",
-       "        [-1.32182690e-02],\n",
-       "        [-1.28821076e-02],\n",
-       "        [-1.23766312e-02],\n",
-       "        [-1.17190299e-02],\n",
-       "        [-1.09276904e-02],\n",
-       "        [-1.00218806e-02],\n",
-       "        [-9.02143675e-03],\n",
-       "        [-7.94645498e-03],\n",
-       "        [-6.81699371e-03],\n",
-       "        [-5.65278982e-03],\n",
-       "        [-4.47299281e-03],\n",
-       "        [-3.29591998e-03],\n",
-       "        [-2.13883545e-03],\n",
-       "        [-1.01775527e-03],\n",
-       "        [ 5.27197842e-05],\n",
-       "        [ 1.05954238e-03],\n",
-       "        [ 1.99132712e-03],\n",
-       "        [ 2.83842920e-03],\n",
-       "        [ 3.59299339e-03],\n",
-       "        [ 4.24897413e-03],\n",
-       "        [ 4.80212789e-03],\n",
-       "        [ 5.24997915e-03],\n",
-       "        [ 5.59176197e-03],\n",
-       "        [ 5.82833918e-03],\n",
-       "        [ 5.96210153e-03],\n",
-       "        [ 5.99684934e-03],\n",
-       "        [ 5.93765939e-03],\n",
-       "        [ 5.79073967e-03],\n",
-       "        [ 5.56327494e-03],\n",
-       "        [ 5.26326581e-03],\n",
-       "        [ 4.89936414e-03],\n",
-       "        [ 4.48070743e-03],\n",
-       "        [ 4.01675474e-03],\n",
-       "        [ 3.51712656e-03],\n",
-       "        [ 2.99145080e-03],\n",
-       "        [ 2.44921696e-03],\n",
-       "        [ 1.89964019e-03],\n",
-       "        [ 1.35153682e-03],\n",
-       "        [ 8.13212675e-04],\n",
-       "        [ 2.92365040e-04],\n",
-       "        [-2.04000784e-04],\n",
-       "        [-6.69639970e-04],\n",
-       "        [-1.09912141e-03],\n",
-       "        [-1.48786574e-03],\n",
-       "        [-1.83216834e-03],\n",
-       "        [-2.12920787e-03],\n",
-       "        [-2.37704084e-03],\n",
-       "        [-2.57458314e-03],\n",
-       "        [-2.72157956e-03],\n",
-       "        [-2.81856229e-03],\n",
-       "        [-2.86679964e-03],\n",
-       "        [-2.86823646e-03],\n",
-       "        [-2.82542733e-03],\n",
-       "        [-2.74146424e-03],\n",
-       "        [-2.61989987e-03],\n",
-       "        [-2.46466810e-03],\n",
-       "        [-2.28000299e-03],\n",
-       "        [-2.07035760e-03],\n",
-       "        [-1.84032386e-03],\n",
-       "        [-1.59455473e-03],\n",
-       "        [-1.33768959e-03],\n",
-       "        [-1.07428400e-03],\n",
-       "        [-8.08744442e-04],\n",
-       "        [-5.45269013e-04],\n",
-       "        [-2.87794472e-04],\n",
-       "        [-3.99501844e-05],\n",
-       "        [ 1.94980718e-04],\n",
-       "        [ 4.14092759e-04],\n",
-       "        [ 6.14882052e-04],\n",
-       "        [ 7.95262775e-04],\n",
-       "        [ 9.53576344e-04],\n",
-       "        [ 1.08859355e-03],\n",
-       "        [ 1.19950998e-03],\n",
-       "        [ 1.28593520e-03],\n",
-       "        [ 1.34787619e-03],\n",
-       "        [ 1.38571553e-03],\n",
-       "        [ 1.40018510e-03],\n",
-       "        [ 1.39233579e-03],\n",
-       "        [ 1.36350398e-03],\n",
-       "        [ 1.31527553e-03],\n",
-       "        [ 1.24944779e-03],\n",
-       "        [ 1.16799051e-03],\n",
-       "        [ 1.07300624e-03],\n",
-       "        [ 9.66690824e-04],\n",
-       "        [ 8.51294582e-04],\n",
-       "        [ 7.29084826e-04],\n",
-       "        [ 6.02310123e-04],\n",
-       "        [ 4.73166790e-04],\n",
-       "        [ 3.43768025e-04],\n",
-       "        [ 2.16115980e-04],\n",
-       "        [ 9.20770665e-05],\n",
-       "        [-2.66393191e-05],\n",
-       "        [-1.38498498e-04],\n",
-       "        [-2.42154573e-04],\n",
-       "        [-3.36460825e-04],\n",
-       "        [-4.20476491e-04],\n",
-       "        [-4.93470008e-04],\n",
-       "        [-5.54918875e-04],\n",
-       "        [-6.04506311e-04],\n",
-       "        [-6.42114930e-04],\n",
-       "        [-6.67817713e-04],\n",
-       "        [-6.81866533e-04],\n",
-       "        [-6.84678570e-04],\n",
-       "        [-6.76820917e-04],\n",
-       "        [-6.58993729e-04],\n",
-       "        [-6.32012236e-04],\n",
-       "        [-5.96787978e-04],\n",
-       "        [-5.54309568e-04],\n",
-       "        [-5.05623331e-04],\n",
-       "        [-4.51814094e-04],\n",
-       "        [-3.93986441e-04],\n",
-       "        [-3.33246677e-04],\n",
-       "        [-2.70685746e-04],\n",
-       "        [-2.07363313e-04],\n",
-       "        [-1.44293193e-04],\n",
-       "        [-8.24302691e-05],\n",
-       "        [-2.26590366e-05],\n",
-       "        [ 3.42161603e-05],\n",
-       "        [ 8.74791253e-05],\n",
-       "        [ 1.36508020e-04],\n",
-       "        [ 1.80779789e-04],\n",
-       "        [ 2.19872827e-04],\n",
-       "        [ 2.53467942e-04],\n",
-       "        [ 2.81347699e-04],\n",
-       "        [ 3.03394228e-04],\n",
-       "        [ 3.19585634e-04],\n",
-       "        [ 3.29991116e-04],\n",
-       "        [ 3.34764961e-04],\n",
-       "        [ 3.34139556e-04],\n",
-       "        [ 3.28417578e-04],\n",
-       "        [ 3.17963528e-04],\n",
-       "        [ 3.03194783e-04],\n",
-       "        [ 2.84572312e-04],\n",
-       "        [ 2.62591231e-04],\n",
-       "        [ 2.37771353e-04],\n",
-       "        [ 2.10647857e-04],\n",
-       "        [ 1.81762242e-04],\n",
-       "        [ 1.51653671e-04],\n",
-       "        [ 1.20850814e-04],\n",
-       "        [ 8.98643029e-05],\n",
-       "        [ 5.91798730e-05],\n",
-       "        [ 2.92522523e-05],\n",
-       "        [ 4.99865603e-07],\n",
-       "        [-2.66996204e-05],\n",
-       "        [-5.20128826e-05],\n",
-       "        [-7.51536523e-05],\n",
-       "        [-9.58845564e-05],\n",
-       "        [-1.14018107e-04],\n",
-       "        [-1.29416873e-04],\n",
-       "        [-1.41992872e-04],\n",
-       "        [-1.51706237e-04],\n",
-       "        [-1.58563217e-04],\n",
-       "        [-1.62613577e-04],\n",
-       "        [-1.63947474e-04],\n",
-       "        [-1.62691876e-04],\n",
-       "        [-1.59006617e-04],\n",
-       "        [-1.53080161e-04],\n",
-       "        [-1.45125149e-04],\n",
-       "        [-1.35373825e-04],\n",
-       "        [-1.24073408e-04],\n",
-       "        [-1.11481480e-04],\n",
-       "        [-9.78614699e-05],\n",
-       "        [-8.34782912e-05],\n",
-       "        [-6.85941958e-05],\n",
-       "        [-5.34648902e-05],\n",
-       "        [-3.83359659e-05],\n",
-       "        [-2.34396771e-05],\n",
-       "        [-8.99209963e-06],\n",
-       "        [ 4.80930904e-06],\n",
-       "        [ 1.77877303e-05],\n",
-       "        [ 2.97885790e-05],\n",
-       "        [ 4.06806698e-05],\n",
-       "        [ 5.03569613e-05],\n",
-       "        [ 5.87348886e-05],\n",
-       "        [ 6.57563025e-05],\n",
-       "        [ 7.13870369e-05],\n",
-       "        [ 7.56161314e-05],\n",
-       "        [ 7.84547400e-05],\n",
-       "        [ 7.99347593e-05],\n",
-       "        [ 8.01072132e-05],\n",
-       "        [ 7.90404306e-05],\n",
-       "        [ 7.68180578e-05],\n",
-       "        [ 7.35369422e-05],\n",
-       "        [ 6.93049288e-05],\n",
-       "        [ 6.42386081e-05],\n",
-       "        [ 5.84610506e-05],\n",
-       "        [ 5.20995659e-05],\n",
-       "        [ 4.52835182e-05],\n",
-       "        [ 3.81422283e-05],\n",
-       "        [ 3.08029906e-05],\n",
-       "        [ 2.33892288e-05],\n",
-       "        [ 1.60188110e-05],\n",
-       "        [ 8.80254179e-06],\n",
-       "        [ 1.84284433e-06],\n",
-       "        [-4.76735708e-06],\n",
-       "        [-1.09455481e-05],\n",
-       "        [-1.66203260e-05],\n",
-       "        [-2.17318930e-05],\n",
-       "        [-2.62323441e-05],\n",
-       "        [-3.00857571e-05],\n",
-       "        [-3.32680938e-05],\n",
-       "        [-3.57669238e-05],\n",
-       "        [-3.75809851e-05],\n",
-       "        [-3.87195976e-05],\n",
-       "        [-3.92019455e-05],\n",
-       "        [-3.90562469e-05],\n",
-       "        [-3.83188308e-05],\n",
-       "        [-3.70331386e-05],\n",
-       "        [-3.52486713e-05],\n",
-       "        [-3.30199005e-05],\n",
-       "        [-3.04051623e-05],\n",
-       "        [-2.74655518e-05],\n",
-       "        [-2.42638356e-05],\n",
-       "        [-2.08633971e-05],\n",
-       "        [-1.73272301e-05],\n",
-       "        [-1.37169929e-05],\n",
-       "        [-1.00921337e-05],\n",
-       "        [-6.50909854e-06],\n",
-       "        [-3.02062703e-06],\n",
-       "        [ 3.24855777e-07],\n",
-       "        [ 3.48374880e-06],\n",
-       "        [ 6.41768244e-06],\n",
-       "        [ 9.09382368e-06],\n",
-       "        [ 1.14850796e-05],\n",
-       "        [ 1.35702019e-05],\n",
-       "        [ 1.53337956e-05],\n",
-       "        [ 1.67662380e-05],\n",
-       "        [ 1.78635125e-05],\n",
-       "        [ 1.86269668e-05],\n",
-       "        [ 1.90630003e-05],\n",
-       "        [ 1.91826920e-05],\n",
-       "        [ 1.90013761e-05],\n",
-       "        [ 1.85381759e-05],\n",
-       "        [ 1.78155045e-05],\n",
-       "        [ 1.68585417e-05],\n",
-       "        [ 1.56946977e-05],\n",
-       "        [ 1.43530711e-05],\n",
-       "        [ 1.28639102e-05],\n",
-       "        [ 1.12580867e-05],\n",
-       "        [ 9.56658741e-06],\n",
-       "        [ 7.82003250e-06],\n",
-       "        [ 6.04822530e-06],\n",
-       "        [ 4.27973898e-06],\n",
-       "        [ 2.54154472e-06],\n",
-       "        [ 8.58684540e-07],\n",
-       "        [-7.46008419e-07],\n",
-       "        [-2.25214057e-06],\n",
-       "        [-3.64193854e-06],\n",
-       "        [-4.90037983e-06],\n",
-       "        [-6.01527408e-06],\n",
-       "        [-6.97729657e-06],\n",
-       "        [-7.77997575e-06],\n",
-       "        [-8.41963776e-06],\n",
-       "        [-8.89531097e-06],\n",
-       "        [-9.20859417e-06],\n",
-       "        [-9.36349256e-06],\n",
-       "        [-9.36622558e-06],\n",
-       "        [-9.22501125e-06],\n",
-       "        [-8.94983149e-06],\n",
-       "        [-8.55218315e-06],\n",
-       "        [-8.04481926e-06],\n",
-       "        [-7.44148501e-06],\n",
-       "        [-6.75665289e-06],\n",
-       "        [-6.00526103e-06],\n",
-       "        [-5.20245855e-06],\n",
-       "        [-4.36336154e-06],\n",
-       "        [-3.50282276e-06],\n",
-       "        [-2.63521793e-06],\n",
-       "        [-1.77425090e-06],\n",
-       "        [-9.32779697e-07],\n",
-       "        [-1.22665095e-07],\n",
-       "        [ 6.45357404e-07],\n",
-       "        [ 1.36178129e-06],\n",
-       "        [ 2.01840827e-06],\n",
-       "        [ 2.60840314e-06],\n",
-       "        [ 3.12632476e-06],\n",
-       "        [ 3.56813383e-06],\n",
-       "        [ 3.93117892e-06],\n",
-       "        [ 4.21416174e-06],\n",
-       "        [ 4.41708370e-06],\n",
-       "        [ 4.54117528e-06],\n",
-       "        [ 4.58881047e-06],\n",
-       "        [ 4.56340818e-06],\n",
-       "        [ 4.46932311e-06],\n",
-       "        [ 4.31172804e-06],\n",
-       "        [ 4.09649002e-06],\n",
-       "        [ 3.83004261e-06],\n",
-       "        [ 3.51925636e-06],\n",
-       "        [ 3.17130959e-06],\n",
-       "        [ 2.79356147e-06],\n",
-       "        [ 2.39342926e-06],\n",
-       "        [ 1.97827123e-06],\n",
-       "        [ 1.55527692e-06],\n",
-       "        [ 1.13136590e-06],\n",
-       "        [ 7.13096217e-07],\n",
-       "        [ 3.06583307e-07],\n",
-       "        [-8.25698570e-08],\n",
-       "        [-4.49330971e-07],\n",
-       "        [-7.89284681e-07],\n",
-       "        [-1.09866689e-06],\n",
-       "        [-1.37438717e-06],\n",
-       "        [-1.61403969e-06],\n",
-       "        [-1.81590293e-06],\n",
-       "        [-1.97892902e-06],\n",
-       "        [-2.10272322e-06],\n",
-       "        [-2.18751454e-06],\n",
-       "        [-2.23411839e-06],\n",
-       "        [-2.24389217e-06],\n",
-       "        [-2.21868508e-06],\n",
-       "        [-2.16078299e-06],\n",
-       "        [-2.07284963e-06],\n",
-       "        [-1.95786524e-06],\n",
-       "        [-1.81906355e-06],\n",
-       "        [-1.65986847e-06],\n",
-       "        [-1.48383111e-06],\n",
-       "        [-1.29456841e-06],\n",
-       "        [-1.09570401e-06],\n",
-       "        [-8.90812280e-07],\n",
-       "        [-6.83366086e-07],\n",
-       "        [-4.76688999e-07],\n",
-       "        [-2.73912369e-07],\n",
-       "        [-7.79376827e-08],\n",
-       "        [ 1.08595502e-07],\n",
-       "        [ 2.83335867e-07],\n",
-       "        [ 4.44240783e-07],\n",
-       "        [ 5.89590916e-07],\n",
-       "        [ 7.17999074e-07],\n",
-       "        [ 8.28413475e-07],\n",
-       "        [ 9.20115687e-07],\n",
-       "        [ 9.92713565e-07],\n",
-       "        [ 1.04612956e-06],\n",
-       "        [ 1.08058482e-06],\n",
-       "        [ 1.09657960e-06],\n",
-       "        [ 1.09487043e-06],\n",
-       "        [ 1.07644457e-06],\n",
-       "        [ 1.04249234e-06],\n",
-       "        [ 9.94377814e-07],\n",
-       "        [ 9.33608474e-07],\n",
-       "        [ 8.61804241e-07],\n",
-       "        [ 7.80666529e-07],\n",
-       "        [ 6.91947686e-07],\n",
-       "        [ 5.97421333e-07],\n",
-       "        [ 4.98853975e-07],\n",
-       "        [ 3.97978268e-07],\n",
-       "        [ 2.96468252e-07],\n",
-       "        [ 1.95916837e-07],\n",
-       "        [ 9.78157464e-08],\n",
-       "        [ 3.53810784e-09],\n",
-       "        [-8.56761880e-08],\n",
-       "        [-1.68732293e-07],\n",
-       "        [-2.44689337e-07],\n",
-       "        [-3.12766515e-07],\n",
-       "        [-3.72346383e-07],\n",
-       "        [-4.22975475e-07],\n",
-       "        [-4.64362360e-07],\n",
-       "        [-4.96373321e-07],\n",
-       "        [-5.19025849e-07],\n",
-       "        [-5.32480164e-07],\n",
-       "        [-5.37029008e-07],\n",
-       "        [-5.33085958e-07],\n",
-       "        [-5.21172516e-07],\n",
-       "        [-5.01904244e-07],\n",
-       "        [-4.75976208e-07],\n",
-       "        [-4.44147990e-07],\n",
-       "        [-4.07228527e-07],\n",
-       "        [-3.66061006e-07],\n",
-       "        [-3.21508069e-07],\n",
-       "        [-2.74437502e-07],\n",
-       "        [-2.25708642e-07],\n",
-       "        [-1.76159635e-07],\n",
-       "        [-1.26595725e-07],\n",
-       "        [-7.77786725e-08],\n",
-       "        [-3.04174198e-08],\n",
-       "        [ 1.48399237e-08],\n",
-       "        [ 5.74127314e-08],\n",
-       "        [ 9.67931101e-08],\n",
-       "        [ 1.32549750e-07],\n",
-       "        [ 1.64330389e-07],\n",
-       "        [ 1.91862929e-07],\n",
-       "        [ 2.14955266e-07],\n",
-       "        [ 2.33493889e-07],\n",
-       "        [ 2.47441367e-07],\n",
-       "        [ 2.56832786e-07],\n",
-       "        [ 2.61771274e-07],\n",
-       "        [ 2.62422731e-07],\n",
-       "        [ 2.59009866e-07],\n",
-       "        [ 2.51805701e-07],\n",
-       "        [ 2.41126643e-07],\n",
-       "        [ 2.27325274e-07],\n",
-       "        [ 2.10782975e-07],\n",
-       "        [ 1.91902502e-07],\n",
-       "        [ 1.71100650e-07],\n",
-       "        [ 1.48801086e-07],\n",
-       "        [ 1.25427474e-07],\n",
-       "        [ 1.01396970e-07],\n",
-       "        [ 7.71141707e-08],\n",
-       "        [ 5.29655831e-08],\n",
-       "        [ 2.93146738e-08],\n",
-       "        [ 6.49753809e-09],\n",
-       "        [-1.51807738e-08],\n",
-       "        [-3.54492548e-08],\n",
-       "        [-5.40732540e-08],\n",
-       "        [-7.08561057e-08],\n",
-       "        [-8.56400866e-08],\n",
-       "        [-9.83067240e-08],\n",
-       "        [-1.08776483e-07],\n",
-       "        [-1.17007876e-07],\n",
-       "        [-1.22996030e-07],\n",
-       "        [-1.26770781e-07],\n",
-       "        [-1.28394324e-07],\n",
-       "        [-1.27958507e-07],\n",
-       "        [-1.25581810e-07],\n",
-       "        [-1.21406077e-07],\n",
-       "        [-1.15593076e-07],\n",
-       "        [-1.08320929e-07],\n",
-       "        [-9.97804917e-08],\n",
-       "        [-9.01717306e-08],\n",
-       "        [-7.97001605e-08],\n",
-       "        [-6.85733863e-08],\n",
-       "        [-5.69978031e-08],\n",
-       "        [-4.51754926e-08],\n",
-       "        [-3.33013551e-08],\n",
-       "        [-2.15605067e-08],\n",
-       "        [-1.01259685e-08],\n",
-       "        [ 8.43333233e-10],\n",
-       "        [ 1.12042419e-08],\n",
-       "        [ 2.08307125e-08],\n",
-       "        [ 2.96148179e-08],\n",
-       "        [ 3.74674224e-08],\n",
-       "        [ 4.43185300e-08],\n",
-       "        [ 5.01173204e-08],\n",
-       "        [ 5.48318878e-08],\n",
-       "        [ 5.84487046e-08],\n",
-       "        [ 6.09718312e-08],\n",
-       "        [ 6.24218989e-08],\n",
-       "        [ 6.28348935e-08],\n",
-       "        [ 6.22607698e-08],\n",
-       "        [ 6.07619258e-08],\n",
-       "        [ 5.84115697e-08],\n",
-       "        [ 5.52920089e-08],\n",
-       "        [ 5.14928924e-08],\n",
-       "        [ 4.71094361e-08],\n",
-       "        [ 4.22406586e-08],\n",
-       "        [ 3.69876544e-08],\n",
-       "        [ 3.14519296e-08],\n",
-       "        [ 2.57338206e-08],\n",
-       "        [ 1.99310175e-08],\n",
-       "        [ 1.41372078e-08],\n",
-       "        [ 8.44085527e-09],\n",
-       "        [ 2.92412535e-09],\n",
-       "        [-2.33803440e-09],\n",
-       "        [-7.27865322e-09],\n",
-       "        [-1.18393323e-08],\n",
-       "        [-1.59706760e-08],\n",
-       "        [-1.96325618e-08],\n",
-       "        [-2.27942524e-08],\n",
-       "        [-2.54343588e-08],\n",
-       "        [-2.75406605e-08],\n",
-       "        [-2.91097962e-08],\n",
-       "        [-3.01468340e-08],\n",
-       "        [-3.06647360e-08],\n",
-       "        [-3.06837313e-08],\n",
-       "        [-3.02306102e-08],\n",
-       "        [-2.93379573e-08],\n",
-       "        [-2.80433366e-08],\n",
-       "        [-2.63884442e-08],\n",
-       "        [-2.44182441e-08],\n",
-       "        [-2.21801006e-08],\n",
-       "        [-1.97229204e-08],\n",
-       "        [-1.70963184e-08],\n",
-       "        [-1.43498173e-08],\n",
-       "        [-1.15320925e-08],\n",
-       "        [-8.69027055e-09],\n",
-       "        [-5.86928976e-09],\n",
-       "        [-3.11132917e-09],\n",
-       "        [-4.55310624e-10],\n",
-       "        [ 2.06352190e-09],\n",
-       "        [ 4.41394380e-09],\n",
-       "        [ 6.56901103e-09],\n",
-       "        [ 8.50624139e-09],\n",
-       "        [ 1.02077175e-08],\n",
-       "        [ 1.16601143e-08],\n",
-       "        [ 1.28546537e-08],\n",
-       "        [ 1.37869935e-08],\n",
-       "        [ 1.44570525e-08],\n",
-       "        [ 1.48687805e-08],\n",
-       "        [ 1.50298794e-08],\n",
-       "        [ 1.49514807e-08],\n",
-       "        [ 1.46477886e-08],\n",
-       "        [ 1.41356953e-08],\n",
-       "        [ 1.34343756e-08],\n",
-       "        [ 1.25648684e-08],\n",
-       "        [ 1.15496531e-08],\n",
-       "        [ 1.04122255e-08],\n",
-       "        [ 9.17668264e-09],\n",
-       "        [ 7.86731961e-09],\n",
-       "        [ 6.50824618e-09],\n",
-       "        [ 5.12302653e-09],\n",
-       "        [ 3.73434713e-09],\n",
-       "        [ 2.36371609e-09],\n",
-       "        [ 1.03119689e-09],\n",
-       "        [-2.44821202e-10],\n",
-       "        [-1.44781462e-09],\n",
-       "        [-2.56327788e-09],\n",
-       "        [-3.57883673e-09],\n",
-       "        [-4.48432247e-09],\n",
-       "        [-5.27180834e-09],\n",
-       "        [-5.93560947e-09],\n",
-       "        [-6.47224856e-09],\n",
-       "        [-6.88038933e-09],\n",
-       "        [-7.16074089e-09],\n",
-       "        [-7.31593579e-09],\n",
-       "        [-7.35038521e-09],\n",
-       "        [-7.27011464e-09],\n",
-       "        [-7.08258382e-09],\n",
-       "        [-6.79649429e-09],\n",
-       "        [-6.42158841e-09],\n",
-       "        [-5.96844330e-09],\n",
-       "        [-5.44826311e-09],\n",
-       "        [-4.87267300e-09],\n",
-       "        [-4.25351776e-09],\n",
-       "        [-3.60266810e-09],\n",
-       "        [-2.93183692e-09],\n",
-       "        [-2.25240810e-09],\n",
-       "        [-1.57527958e-09],\n",
-       "        [-9.10722392e-10],\n",
-       "        [-2.68257031e-10],\n",
-       "        [ 3.43451984e-10],\n",
-       "        [ 9.16682670e-10],\n",
-       "        [ 1.44472297e-09],\n",
-       "        [ 1.92191898e-09],\n",
-       "        [ 2.34370432e-09],\n",
-       "        [ 2.70661121e-09],\n",
-       "        [ 3.00826404e-09],\n",
-       "        [ 3.24735661e-09],\n",
-       "        [ 3.42361409e-09],\n",
-       "        [ 3.53774130e-09],\n",
-       "        [ 3.59135866e-09],\n",
-       "        [ 3.58692762e-09],\n",
-       "        [ 3.52766726e-09],\n",
-       "        [ 3.41746369e-09],\n",
-       "        [ 3.26077420e-09],\n",
-       "        [ 3.06252783e-09],\n",
-       "        [ 2.82802406e-09],\n",
-       "        [ 2.56283137e-09],\n",
-       "        [ 2.27268714e-09],\n",
-       "        [ 1.96340036e-09],\n",
-       "        [ 1.64075862e-09],\n",
-       "        [ 1.31044034e-09],\n",
-       "        [ 9.77933595e-10],\n",
-       "        [ 6.48462130e-10],\n",
-       "        [ 3.26919535e-10],\n",
-       "        [ 1.78120277e-11],\n",
-       "        [-2.74789697e-10],\n",
-       "        [-5.47289326e-10],\n",
-       "        [-7.96594391e-10],\n",
-       "        [-1.02013640e-09],\n",
-       "        [-1.21588181e-09],\n",
-       "        [-1.38233425e-09],\n",
-       "        [-1.51852829e-09],\n",
-       "        [-1.62401545e-09],\n",
-       "        [-1.69884307e-09],\n",
-       "        [-1.74352661e-09],\n",
-       "        [-1.75901636e-09],\n",
-       "        [-1.74665921e-09],\n",
-       "        [-1.70815651e-09],\n",
-       "        [-1.64551864e-09],\n",
-       "        [-1.56101740e-09],\n",
-       "        [-1.45713693e-09],\n",
-       "        [-1.33652408e-09],\n",
-       "        [-1.20193887e-09],\n",
-       "        [-1.05620606e-09],\n",
-       "        [-9.02168180e-10],\n",
-       "        [-7.42640999e-10],\n",
-       "        [-5.80371699e-10],\n",
-       "        [-4.18000438e-10],\n",
-       "        [-2.58025627e-10],\n",
-       "        [-1.02773262e-10],\n",
-       "        [ 4.56294262e-11],\n",
-       "        [ 1.85275842e-10],\n",
-       "        [ 3.14497319e-10],\n",
-       "        [ 4.31875824e-10],\n",
-       "        [ 5.36252125e-10],\n",
-       "        [ 6.26729536e-10],\n",
-       "        [ 7.02673435e-10],\n",
-       "        [ 7.63706783e-10],\n",
-       "        [ 8.09701926e-10],\n",
-       "        [ 8.40769021e-10],\n",
-       "        [ 8.57241435e-10],\n",
-       "        [ 8.59658509e-10],\n",
-       "        [ 8.48746100e-10],\n",
-       "        [ 8.25395306e-10],\n",
-       "        [ 7.90639824e-10],\n",
-       "        [ 7.45632330e-10],\n",
-       "        [ 6.91620331e-10],\n",
-       "        [ 6.29921860e-10],\n",
-       "        [ 5.61901413e-10],\n",
-       "        [ 4.88946479e-10],\n",
-       "        [ 4.12444987e-10],\n",
-       "        [ 3.33763978e-10],\n",
-       "        [ 2.54229747e-10],\n",
-       "        [ 1.75109692e-10],\n",
-       "        [ 9.75960545e-11],\n",
-       "        [ 2.27916963e-11],\n",
-       "        [-4.83019842e-11],\n",
-       "        [-1.14794917e-10],\n",
-       "        [-1.75915983e-10],\n",
-       "        [-2.31018394e-10],\n",
-       "        [-2.79582877e-10],\n",
-       "        [-3.21218723e-10],\n",
-       "        [-3.55662806e-10],\n",
-       "        [-3.82776697e-10],\n",
-       "        [-4.02542024e-10],\n",
-       "        [-4.15054231e-10],\n",
-       "        [-4.20514940e-10],\n",
-       "        [-4.19223089e-10],\n",
-       "        [-4.11565059e-10],\n",
-       "        [-3.98004000e-10],\n",
-       "        [-3.79068546e-10],\n",
-       "        [-3.55341149e-10],\n",
-       "        [-3.27446216e-10],\n",
-       "        [-2.96038242e-10],\n",
-       "        [-2.61790127e-10],\n",
-       "        [-2.25381854e-10],\n",
-       "        [-1.87489655e-10],\n",
-       "        [-1.48775838e-10],\n",
-       "        [-1.09879374e-10],\n",
-       "        [-7.14073523e-11],\n",
-       "        [-3.39273907e-11],\n",
-       "        [ 2.03893505e-12],\n",
-       "        [ 3.60216010e-11],\n",
-       "        [ 6.76065523e-11],\n",
-       "        [ 9.64390223e-11],\n",
-       "        [ 1.22225761e-10],\n",
-       "        [ 1.44736197e-10],\n",
-       "        [ 1.63802576e-10],\n",
-       "        [ 1.79319127e-10],\n",
-       "        [ 1.91240321e-10],\n",
-       "        [ 1.99578298e-10],\n",
-       "        [ 2.04399554e-10],\n",
-       "        [ 2.05820966e-10],\n",
-       "        [ 2.04005264e-10],\n",
-       "        [ 1.99156045e-10],\n",
-       "        [ 1.91512426e-10],\n",
-       "        [ 1.81343448e-10],\n",
-       "        [ 1.68942317e-10],\n",
-       "        [ 1.54620596e-10],\n",
-       "        [ 1.38702421e-10],\n",
-       "        [ 1.21518840e-10],\n",
-       "        [ 1.03402364e-10],\n",
-       "        [ 8.46817735e-11],\n",
-       "        [ 6.56772770e-11],\n",
-       "        [ 4.66960608e-11],\n",
-       "        [ 2.80282784e-11],\n",
-       "        [ 9.94352108e-12],\n",
-       "        [-7.31220555e-12],\n",
-       "        [-2.35189776e-11],\n",
-       "        [-3.84849140e-11],\n",
-       "        [-5.20475998e-11],\n",
-       "        [-6.40749805e-11],\n",
-       "        [-7.44657415e-11],\n",
-       "        [-8.31491944e-11],\n",
-       "        [-9.00847005e-11],\n",
-       "        [-9.52606630e-11],\n",
-       "        [-9.86931288e-11],\n",
-       "        [-1.00424042e-10],\n",
-       "        [-1.00519192e-10],\n",
-       "        [-9.90659131e-11],\n",
-       "        [-9.61705702e-11],\n",
-       "        [-9.19558946e-11],\n",
-       "        [-8.65582113e-11],\n",
-       "        [-8.01246075e-11],\n",
-       "        [-7.28100908e-11],\n",
-       "        [-6.47747788e-11],\n",
-       "        [-5.61811640e-11],\n",
-       "        [-4.71914900e-11],\n",
-       "        [-3.79652737e-11],\n",
-       "        [-2.86570049e-11],\n",
-       "        [-1.94140468e-11],\n",
-       "        [-1.03747606e-11],\n",
-       "        [-1.66687011e-12],\n",
-       "        [ 6.59392227e-12],\n",
-       "        [ 1.43050589e-11],\n",
-       "        [ 2.13779881e-11],\n",
-       "        [ 2.77387635e-11],\n",
-       "        [ 3.33283863e-11],\n",
-       "        [ 3.81028997e-11],\n",
-       "        [ 4.20332475e-11],\n",
-       "        [ 4.51049111e-11],\n",
-       "        [ 4.73173433e-11],\n",
-       "        [ 4.86832183e-11],\n",
-       "        [ 4.92275195e-11],\n",
-       "        [ 4.89864878e-11],\n",
-       "        [ 4.80064537e-11],\n",
-       "        [ 4.63425790e-11],\n",
-       "        [ 4.40575297e-11],\n",
-       "        [ 4.12201072e-11],\n",
-       "        [ 3.79038588e-11],\n",
-       "        [ 3.41856906e-11],\n",
-       "        [ 3.01445047e-11],\n",
-       "        [ 2.58598795e-11],\n",
-       "        [ 2.14108113e-11],\n",
-       "        [ 1.68745326e-11],\n",
-       "        [ 1.23254227e-11],\n",
-       "        [ 7.83402024e-12],\n",
-       "        [ 3.46614894e-12],\n",
-       "        [-7.17837223e-13],\n",
-       "        [-4.66368361e-12],\n",
-       "        [-8.32373682e-12],\n",
-       "        [-1.16573180e-11],\n",
-       "        [-1.46309687e-11],\n",
-       "        [-1.72185728e-11],\n",
-       "        [-1.94013587e-11],\n",
-       "        [-2.11677890e-11],\n",
-       "        [-2.25133446e-11],\n",
-       "        [-2.34402138e-11],\n",
-       "        [-2.39568939e-11],\n",
-       "        [-2.40777185e-11],\n",
-       "        [-2.38223208e-11],\n",
-       "        [-2.32150444e-11],\n",
-       "        [-2.22843137e-11],\n",
-       "        [-2.10619762e-11],\n",
-       "        [-1.95826276e-11],\n",
-       "        [-1.78829317e-11],\n",
-       "        [-1.60009447e-11],\n",
-       "        [-1.39754560e-11],\n",
-       "        [-1.18453524e-11],\n",
-       "        [-9.64901620e-12],\n",
-       "        [-7.42376276e-12],\n",
-       "        [-5.20532599e-12],\n",
-       "        [-3.02739537e-12],\n",
-       "        [-9.21209726e-13],\n",
-       "        [ 1.08478934e-12],\n",
-       "        [ 2.96524227e-12],\n",
-       "        [ 4.69809361e-12],\n",
-       "        [ 6.26475127e-12],\n",
-       "        [ 7.65018391e-12],\n",
-       "        [ 8.84295852e-12],\n",
-       "        [ 9.83522052e-12],\n",
-       "        [ 1.06226202e-11],\n",
-       "        [ 1.12041892e-11],\n",
-       "        [ 1.15821718e-11],\n",
-       "        [ 1.17618161e-11],\n",
-       "        [ 1.17511305e-11],\n",
-       "        [ 1.15606105e-11],\n",
-       "        [ 1.12029433e-11],\n",
-       "        [ 1.06926933e-11],\n",
-       "        [ 1.00459770e-11],\n",
-       "        [ 9.28013104e-12],\n",
-       "        [ 8.41338023e-12],\n",
-       "        [ 7.46450911e-12],\n",
-       "        [ 6.45254336e-12],\n",
-       "        [ 5.39644458e-12],\n",
-       "        [ 4.31482266e-12],\n",
-       "        [ 3.22566912e-12],\n",
-       "        [ 2.14611451e-12],\n",
-       "        [ 1.09221210e-12],\n",
-       "        [ 7.87499061e-14],\n",
-       "        [-8.80907673e-13],\n",
-       "        [-1.77494775e-12],\n",
-       "        [-2.59320609e-12],\n",
-       "        [-3.32723368e-12],\n",
-       "        [-3.97033334e-12],\n",
-       "        [-4.51756744e-12],\n",
-       "        [-4.96573818e-12],\n",
-       "        [-5.31334228e-12],\n",
-       "        [-5.56050204e-12],\n",
-       "        [-5.70887524e-12],\n",
-       "        [-5.76154635e-12],\n",
-       "        [-5.72290169e-12],\n",
-       "        [-5.59849145e-12],\n",
-       "        [-5.39488131e-12],\n",
-       "        [-5.11949646e-12],\n",
-       "        [-4.78046103e-12],\n",
-       "        [-4.38643532e-12],\n",
-       "        [-3.94645383e-12],\n",
-       "        [-3.46976617e-12],\n",
-       "        [-2.96568341e-12],\n",
-       "        [-2.44343179e-12],\n",
-       "        [-1.91201566e-12],\n",
-       "        [-1.38009128e-12],\n",
-       "        [-8.55852851e-13],\n",
-       "        [-3.46931750e-13],\n",
-       "        [ 1.39690062e-13],\n",
-       "        [ 5.97751982e-13],\n",
-       "        [ 1.02177173e-12],\n",
-       "        [ 1.40708727e-12],\n",
-       "        [ 1.74988385e-12],\n",
-       "        [ 2.04720660e-12],\n",
-       "        [ 2.29695918e-12],\n",
-       "        [ 2.49788941e-12],\n",
-       "        [ 2.64956265e-12],\n",
-       "        [ 2.75232406e-12],\n",
-       "        [ 2.80725105e-12],\n",
-       "        [ 2.81609691e-12],\n",
-       "        [ 2.78122724e-12],\n",
-       "        [ 2.70555041e-12],\n",
-       "        [ 2.59244341e-12],\n",
-       "        [ 2.44567457e-12],\n",
-       "        [ 2.26932450e-12],\n",
-       "        [ 2.06770643e-12],\n",
-       "        [ 1.84528742e-12],\n",
-       "        [ 1.60661139e-12],\n",
-       "        [ 1.35622519e-12],\n",
-       "        [ 1.09860864e-12],\n",
-       "        [ 8.38109399e-13],\n",
-       "        [ 5.78883374e-13],\n",
-       "        [ 3.24841331e-13],\n",
-       "        [ 7.96021586e-14],\n",
-       "        [-1.53546849e-13],\n",
-       "        [-3.71682460e-13],\n",
-       "        [-5.72270623e-13],\n",
-       "        [-7.53184249e-13],\n",
-       "        [-9.12713774e-13],\n",
-       "        [-1.04957074e-12],\n",
-       "        [-1.16288473e-12],\n",
-       "        [-1.25219402e-12],\n",
-       "        [-1.31743049e-12],\n",
-       "        [-1.35889932e-12],\n",
-       "        [-1.37725401e-12],\n",
-       "        [-1.37346747e-12],\n",
-       "        [-1.34879972e-12],\n",
-       "        [-1.30476297e-12],\n",
-       "        [-1.24308474e-12],\n",
-       "        [-1.16566958e-12],\n",
-       "        [-1.07456029e-12],\n",
-       "        [-9.71899028e-13],\n",
-       "        [-8.59889017e-13],\n",
-       "        [-7.40757417e-13],\n",
-       "        [-6.16719826e-13],\n",
-       "        [-4.89946897e-13],\n",
-       "        [-3.62533448e-13],\n",
-       "        [-2.36470418e-13],\n",
-       "        [-1.13619940e-13],\n",
-       "        [ 4.30625813e-15],\n",
-       "        [ 1.15764967e-13],\n",
-       "        [ 2.19396044e-13],\n",
-       "        [ 3.14033353e-13],\n",
-       "        [ 3.98712143e-13],\n",
-       "        [ 4.72672923e-13],\n",
-       "        [ 5.35361983e-13],\n",
-       "        [ 5.86428723e-13],\n",
-       "        [ 6.25720013e-13],\n",
-       "        [ 6.53271822e-13],\n",
-       "        [ 6.69298401e-13],\n",
-       "        [ 6.74179318e-13],\n",
-       "        [ 6.68444656e-13],\n",
-       "        [ 6.52758703e-13],\n",
-       "        [ 6.27902469e-13],\n",
-       "        [ 5.94755360e-13],\n",
-       "        [ 5.54276333e-13],\n",
-       "        [ 5.07484858e-13],\n",
-       "        [ 4.55441980e-13],\n",
-       "        [ 3.99231770e-13],\n",
-       "        [ 3.39943434e-13],\n",
-       "        [ 2.78654313e-13],\n",
-       "        [ 2.16413982e-13],\n",
-       "        [ 1.54229647e-13],\n",
-       "        [ 9.30529803e-14],\n",
-       "        [ 3.37685240e-14],\n",
-       "        [-2.28162462e-14],\n",
-       "        [-7.59791352e-14],\n",
-       "        [-1.25089686e-13],\n",
-       "        [-1.69613881e-13],\n",
-       "        [-2.09117104e-13],\n",
-       "        [-2.43265416e-13],\n",
-       "        [-2.71825222e-13],\n",
-       "        [-2.94661405e-13],\n",
-       "        [-3.11734058e-13],\n",
-       "        [-3.23093926e-13],\n",
-       "        [-3.28876708e-13],\n",
-       "        [-3.29296363e-13],\n",
-       "        [-3.24637573e-13],\n",
-       "        [-3.15247537e-13],\n",
-       "        [-3.01527245e-13],\n",
-       "        [-2.83922404e-13],\n",
-       "        [-2.62914163e-13],\n",
-       "        [-2.39009806e-13],\n",
-       "        [-2.12733546e-13],\n",
-       "        [-1.84617554e-13],\n",
-       "        [-1.55193359e-13],\n",
-       "        [-1.24983721e-13],\n",
-       "        [-9.44950827e-14],\n",
-       "        [-6.42106796e-14],\n",
-       "        [-3.45843793e-14],\n",
-       "        [-6.03530863e-15],\n",
-       "        [ 2.10566956e-14],\n",
-       "        [ 4.63547854e-14],\n",
-       "        [ 6.95679398e-14],\n",
-       "        [ 9.04529453e-14],\n",
-       "        [ 1.08815534e-13],\n",
-       "        [ 1.24510712e-13],\n",
-       "        [ 1.37442305e-13],\n",
-       "        [ 1.47561791e-13],\n",
-       "        [ 1.54866456e-13],\n",
-       "        [ 1.59396949e-13],\n",
-       "        [ 1.61234303e-13],\n",
-       "        [ 1.60496501e-13],\n",
-       "        [ 1.57334658e-13],\n",
-       "        [ 1.51928900e-13],\n",
-       "        [ 1.44484028e-13],\n",
-       "        [ 1.35225032e-13],\n",
-       "        [ 1.24392540e-13],\n",
-       "        [ 1.12238277e-13],\n",
-       "        [ 9.90205960e-14],\n",
-       "        [ 8.50001526e-14],\n",
-       "        [ 7.04357778e-14],\n",
-       "        [ 5.55806038e-14],\n",
-       "        [ 4.06784863e-14],\n",
-       "        [ 2.59607649e-14],\n",
-       "        [ 1.16433900e-14],\n",
-       "        [-2.07555641e-15],\n",
-       "        [-1.50179329e-14],\n",
-       "        [-2.70271905e-14],\n",
-       "        [-3.79696042e-14],\n",
-       "        [-4.77350873e-14]]),)"
+       "(array([[ 1.33235776e-10],\n",
+       "        [ 2.47739724e-09],\n",
+       "        [ 2.28467044e-08],\n",
+       "        ...,\n",
+       "        [-3.46484535e-31],\n",
+       "        [-3.93725837e-31],\n",
+       "        [-4.19501562e-31]]),)"
       ]
      },
-     "execution_count": 91,
+     "execution_count": 26,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -1651,22 +770,22 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 92,
+   "execution_count": 27,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "[<matplotlib.lines.Line2D at 0x1c20880320>]"
+       "[<matplotlib.lines.Line2D at 0x1c253e5f98>]"
       ]
      },
-     "execution_count": 92,
+     "execution_count": 27,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -1683,106 +802,159 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 93,
+   "execution_count": 28,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "ename": "ValueError",
+     "evalue": "Denominator polynomial must be rank-1 array.",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
+      "\u001b[0;32m<ipython-input-28-581850618366>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m#tbout, bout = sps.dlsim((a,b,0.1),t=np.append(tout,np.arange(0,199,0.1)) ,u=np.append((np.flip(yout[0],0)),(yout[0][-1]*np.ones_like(np.arange(0,199,0.1)))))\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mtbout\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbout\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0msps\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdimpulse\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mflip\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0myout\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0myout\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m0.1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mt\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0marange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m199\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m0.1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+      "\u001b[0;32m~/anaconda3/envs/geomagenv36/lib/python3.6/site-packages/scipy/signal/ltisys.py\u001b[0m in \u001b[0;36mdimpulse\u001b[0;34m(system, x0, t, n)\u001b[0m\n\u001b[1;32m   3389\u001b[0m                              'dlti systems.')\n\u001b[1;32m   3390\u001b[0m     \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 3391\u001b[0;31m         \u001b[0msystem\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdlti\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0msystem\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdt\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0msystem\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_as_ss\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   3392\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   3393\u001b[0m     \u001b[0;31m# Default to 100 samples if unspecified\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;32m~/anaconda3/envs/geomagenv36/lib/python3.6/site-packages/scipy/signal/ltisys.py\u001b[0m in \u001b[0;36m__init__\u001b[0;34m(self, *system, **kwargs)\u001b[0m\n\u001b[1;32m    760\u001b[0m         \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_den\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    761\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 762\u001b[0;31m         \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnum\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mden\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnormalize\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0msystem\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    763\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    764\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0m__repr__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;32m~/anaconda3/envs/geomagenv36/lib/python3.6/site-packages/scipy/signal/filter_design.py\u001b[0m in \u001b[0;36mnormalize\u001b[0;34m(b, a)\u001b[0m\n\u001b[1;32m   1426\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1427\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0mden\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mndim\u001b[0m \u001b[0;34m!=\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1428\u001b[0;31m         \u001b[0;32mraise\u001b[0m \u001b[0mValueError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Denominator polynomial must be rank-1 array.\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1429\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0mnum\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mndim\u001b[0m \u001b[0;34m>\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1430\u001b[0m         raise ValueError(\"Numerator polynomial must be rank-1 or\"\n",
+      "\u001b[0;31mValueError\u001b[0m: Denominator polynomial must be rank-1 array."
+     ]
+    }
+   ],
    "source": [
-    "tbout, bout = sps.dlsim((a,b,0.1),t=np.append(tout,np.arange(99,199,0.1)) ,u=np.append((np.flip(yout[0],0)),(yout[0][-1]*np.ones_like(np.arange(99,199,0.1)))))"
+    "#tbout, bout = sps.dlsim((a,b,0.1),t=np.append(tout,np.arange(0,199,0.1)) ,u=np.append((np.flip(yout[0],0)),(yout[0][-1]*np.ones_like(np.arange(0,199,0.1)))))\n",
+    "tbout, bout = sps.dimpulse((np.flip(yout,1),yout,0.1), t=np.arange(0,199,0.1))"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 94,
+   "execution_count": 29,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "array([0.00000000e+00, 1.00050302e-01, 2.00100604e-01, ...,\n",
-       "       1.98699899e+02, 1.98799950e+02, 1.98900000e+02])"
+       "array([[[ 1.33235776e-10],\n",
+       "        [ 2.47739724e-09],\n",
+       "        [ 2.28467044e-08],\n",
+       "        ...,\n",
+       "        [-3.46484535e-31],\n",
+       "        [-3.93725837e-31],\n",
+       "        [-4.19501562e-31]]])"
       ]
      },
-     "execution_count": 94,
+     "execution_count": 29,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "tbout"
+    "np.flip(yout,0)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 95,
+   "execution_count": 30,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "array([[-1.40720618e-22],\n",
-       "       [-2.00251656e-21],\n",
-       "       [-1.42042184e-20],\n",
-       "       ...,\n",
-       "       [-4.73992765e-14],\n",
-       "       [-4.91453138e-14],\n",
-       "       [-5.07749201e-14]])"
+       "(array([[ 1.33235776e-10],\n",
+       "        [ 2.47739724e-09],\n",
+       "        [ 2.28467044e-08],\n",
+       "        ...,\n",
+       "        [-3.46484535e-31],\n",
+       "        [-3.93725837e-31],\n",
+       "        [-4.19501562e-31]]),)"
       ]
      },
-     "execution_count": 95,
+     "execution_count": 30,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "bout"
+    "yout"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 96,
+   "execution_count": 31,
    "metadata": {},
    "outputs": [
     {
-     "data": {
-      "text/plain": [
-       "[<matplotlib.lines.Line2D at 0x1c2120acf8>]"
-      ]
-     },
-     "execution_count": 96,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
+     "ename": "NameError",
+     "evalue": "name 'tbout' is not defined",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
+      "\u001b[0;32m<ipython-input-31-f8efd14545dd>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mtbout\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+      "\u001b[0;31mNameError\u001b[0m: name 'tbout' is not defined"
+     ]
+    }
+   ],
+   "source": [
+    "tbout"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "metadata": {},
+   "outputs": [
     {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
+     "ename": "NameError",
+     "evalue": "name 'bout' is not defined",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
+      "\u001b[0;32m<ipython-input-32-aaccf4dd70e3>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mbout\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+      "\u001b[0;31mNameError\u001b[0m: name 'bout' is not defined"
+     ]
     }
    ],
    "source": [
-    "pl.plot(tbout[970:1000],bout[970:1000])"
+    "bout"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 97,
+   "execution_count": 33,
    "metadata": {},
    "outputs": [
     {
-     "data": {
-      "text/plain": [
-       "0.04028381793551497"
-      ]
-     },
-     "execution_count": 97,
-     "metadata": {},
-     "output_type": "execute_result"
+     "ename": "NameError",
+     "evalue": "name 'tbout' is not defined",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
+      "\u001b[0;32m<ipython-input-33-88f592e62b57>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mpl\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mplot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtbout\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mbout\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+      "\u001b[0;31mNameError\u001b[0m: name 'tbout' is not defined"
+     ]
+    }
+   ],
+   "source": [
+    "pl.plot(tbout,bout)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 34,
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "NameError",
+     "evalue": "name 'bout' is not defined",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
+      "\u001b[0;32m<ipython-input-34-9e89fbfc117f>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmax\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbout\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+      "\u001b[0;31mNameError\u001b[0m: name 'bout' is not defined"
+     ]
     }
    ],
    "source": [
@@ -1791,18 +963,19 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 98,
+   "execution_count": 35,
    "metadata": {},
    "outputs": [
     {
-     "data": {
-      "text/plain": [
-       "(array([989]), array([0]))"
-      ]
-     },
-     "execution_count": 98,
-     "metadata": {},
-     "output_type": "execute_result"
+     "ename": "NameError",
+     "evalue": "name 'bout' is not defined",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
+      "\u001b[0;32m<ipython-input-35-577e45679398>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mwhere\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbout\u001b[0m\u001b[0;34m==\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmax\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbout\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+      "\u001b[0;31mNameError\u001b[0m: name 'bout' is not defined"
+     ]
     }
    ],
    "source": [
@@ -1811,223 +984,40 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 99,
+   "execution_count": 36,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "ename": "NameError",
+     "evalue": "name 'bout' is not defined",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
+      "\u001b[0;32m<ipython-input-36-da5e01d07612>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mfilt2\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mbout\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m989\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m99\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;36m989\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m98\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+      "\u001b[0;31mNameError\u001b[0m: name 'bout' is not defined"
+     ]
+    }
+   ],
    "source": [
     "filt2 = bout[989-99:989+98]"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 100,
+   "execution_count": 37,
    "metadata": {},
    "outputs": [
     {
-     "data": {
-      "text/plain": [
-       "array([[-3.00869288e-04],\n",
-       "       [-4.45641762e-04],\n",
-       "       [-5.91481095e-04],\n",
-       "       [-7.36066637e-04],\n",
-       "       [-8.76963144e-04],\n",
-       "       [-1.01165372e-03],\n",
-       "       [-1.13757602e-03],\n",
-       "       [-1.25216124e-03],\n",
-       "       [-1.35287558e-03],\n",
-       "       [-1.43726345e-03],\n",
-       "       [-1.50299200e-03],\n",
-       "       [-1.54789623e-03],\n",
-       "       [-1.57002404e-03],\n",
-       "       [-1.56768041e-03],\n",
-       "       [-1.53947007e-03],\n",
-       "       [-1.48433779e-03],\n",
-       "       [-1.40160548e-03],\n",
-       "       [-1.29100549e-03],\n",
-       "       [-1.15270908e-03],\n",
-       "       [-9.87349619e-04],\n",
-       "       [-7.96039594e-04],\n",
-       "       [-5.80380941e-04],\n",
-       "       [-3.42468088e-04],\n",
-       "       [-8.48832612e-05],\n",
-       "       [ 1.89316336e-04],\n",
-       "       [ 4.76619718e-04],\n",
-       "       [ 7.73091844e-04],\n",
-       "       [ 1.07441189e-03],\n",
-       "       [ 1.37591994e-03],\n",
-       "       [ 1.67267189e-03],\n",
-       "       [ 1.95950204e-03],\n",
-       "       [ 2.23109302e-03],\n",
-       "       [ 2.48205215e-03],\n",
-       "       [ 2.70699358e-03],\n",
-       "       [ 2.90062512e-03],\n",
-       "       [ 3.05783874e-03],\n",
-       "       [ 3.17380345e-03],\n",
-       "       [ 3.24405935e-03],\n",
-       "       [ 3.26461135e-03],\n",
-       "       [ 3.23202113e-03],\n",
-       "       [ 3.14349584e-03],\n",
-       "       [ 2.99697185e-03],\n",
-       "       [ 2.79119224e-03],\n",
-       "       [ 2.52577617e-03],\n",
-       "       [ 2.20127898e-03],\n",
-       "       [ 1.81924122e-03],\n",
-       "       [ 1.38222565e-03],\n",
-       "       [ 8.93840700e-04],\n",
-       "       [ 3.58749524e-04],\n",
-       "       [-2.17336328e-04],\n",
-       "       [-8.27679267e-04],\n",
-       "       [-1.46455455e-03],\n",
-       "       [-2.11930588e-03],\n",
-       "       [-2.78241781e-03],\n",
-       "       [-3.44360450e-03],\n",
-       "       [-4.09191446e-03],\n",
-       "       [-4.71585031e-03],\n",
-       "       [-5.30350257e-03],\n",
-       "       [-5.84269600e-03],\n",
-       "       [-6.32114693e-03],\n",
-       "       [-6.72662967e-03],\n",
-       "       [-7.04714991e-03],\n",
-       "       [-7.27112275e-03],\n",
-       "       [-7.38755293e-03],\n",
-       "       [-7.38621460e-03],\n",
-       "       [-7.25782788e-03],\n",
-       "       [-6.99422940e-03],\n",
-       "       [-6.58853406e-03],\n",
-       "       [-6.03528506e-03],\n",
-       "       [-5.33058967e-03],\n",
-       "       [-4.47223792e-03],\n",
-       "       [-3.45980190e-03],\n",
-       "       [-2.29471338e-03],\n",
-       "       [-9.80317771e-04],\n",
-       "       [ 4.78097188e-04],\n",
-       "       [ 2.07329940e-03],\n",
-       "       [ 3.79613790e-03],\n",
-       "       [ 5.63559653e-03],\n",
-       "       [ 7.57887562e-03],\n",
-       "       [ 9.61150166e-03],\n",
-       "       [ 1.17174638e-02],\n",
-       "       [ 1.38793763e-02],\n",
-       "       [ 1.60786641e-02],\n",
-       "       [ 1.82957713e-02],\n",
-       "       [ 2.05103878e-02],\n",
-       "       [ 2.27016922e-02],\n",
-       "       [ 2.48486072e-02],\n",
-       "       [ 2.69300647e-02],\n",
-       "       [ 2.89252752e-02],\n",
-       "       [ 3.08139982e-02],\n",
-       "       [ 3.25768105e-02],\n",
-       "       [ 3.41953654e-02],\n",
-       "       [ 3.56526419e-02],\n",
-       "       [ 3.69331772e-02],\n",
-       "       [ 3.80232803e-02],\n",
-       "       [ 3.89112220e-02],\n",
-       "       [ 3.95873992e-02],\n",
-       "       [ 4.00444701e-02],\n",
-       "       [ 4.02774572e-02],\n",
-       "       [ 4.02838179e-02],\n",
-       "       [ 4.00634810e-02],\n",
-       "       [ 3.96188470e-02],\n",
-       "       [ 3.89547544e-02],\n",
-       "       [ 3.80784111e-02],\n",
-       "       [ 3.69992928e-02],\n",
-       "       [ 3.57290094e-02],\n",
-       "       [ 3.42811430e-02],\n",
-       "       [ 3.26710588e-02],\n",
-       "       [ 3.09156929e-02],\n",
-       "       [ 2.90333205e-02],\n",
-       "       [ 2.70433083e-02],\n",
-       "       [ 2.49658553e-02],\n",
-       "       [ 2.28217249e-02],\n",
-       "       [ 2.06319754e-02],\n",
-       "       [ 1.84176893e-02],\n",
-       "       [ 1.61997090e-02],\n",
-       "       [ 1.39983804e-02],\n",
-       "       [ 1.18333094e-02],\n",
-       "       [ 9.72313380e-03],\n",
-       "       [ 7.68531478e-03],\n",
-       "       [ 5.73594917e-03],\n",
-       "       [ 3.88960596e-03],\n",
-       "       [ 2.15918824e-03],\n",
-       "       [ 5.55821981e-04],\n",
-       "       [-9.11227333e-04],\n",
-       "       [-2.23461004e-03],\n",
-       "       [-3.40891947e-03],\n",
-       "       [-4.43069159e-03],\n",
-       "       [-5.29837794e-03],\n",
-       "       [-6.01229319e-03],\n",
-       "       [-6.57453903e-03],\n",
-       "       [-6.98890620e-03],\n",
-       "       [-7.26075700e-03],\n",
-       "       [-7.39689067e-03],\n",
-       "       [-7.40539422e-03],\n",
-       "       [-7.29548149e-03],\n",
-       "       [-7.07732315e-03],\n",
-       "       [-6.76187061e-03],\n",
-       "       [-6.36067646e-03],\n",
-       "       [-5.88571435e-03],\n",
-       "       [-5.34920081e-03],\n",
-       "       [-4.76342161e-03],\n",
-       "       [-4.14056493e-03],\n",
-       "       [-3.49256348e-03],\n",
-       "       [-2.83094744e-03],\n",
-       "       [-2.16670989e-03],\n",
-       "       [-1.51018612e-03],\n",
-       "       [-8.70947940e-04],\n",
-       "       [-2.57713811e-04],\n",
-       "       [ 3.21724618e-04],\n",
-       "       [ 8.60559262e-04],\n",
-       "       [ 1.35300561e-03],\n",
-       "       [ 1.79432625e-03],\n",
-       "       [ 2.18083825e-03],\n",
-       "       [ 2.50990526e-03],\n",
-       "       [ 2.77991499e-03],\n",
-       "       [ 2.99024325e-03],\n",
-       "       [ 3.14120569e-03],\n",
-       "       [ 3.23399861e-03],\n",
-       "       [ 3.27063018e-03],\n",
-       "       [ 3.25384360e-03],\n",
-       "       [ 3.18703380e-03],\n",
-       "       [ 3.07415910e-03],\n",
-       "       [ 2.91964954e-03],\n",
-       "       [ 2.72831328e-03],\n",
-       "       [ 2.50524258e-03],\n",
-       "       [ 2.25572088e-03],\n",
-       "       [ 1.98513207e-03],\n",
-       "       [ 1.69887345e-03],\n",
-       "       [ 1.40227322e-03],\n",
-       "       [ 1.10051365e-03],\n",
-       "       [ 7.98560761e-04],\n",
-       "       [ 5.01101043e-04],\n",
-       "       [ 2.12486046e-04],\n",
-       "       [-6.33149855e-05],\n",
-       "       [-3.22754042e-04],\n",
-       "       [-5.62734752e-04],\n",
-       "       [-7.80634259e-04],\n",
-       "       [-9.74316712e-04],\n",
-       "       [-1.14213862e-03],\n",
-       "       [-1.28294643e-03],\n",
-       "       [-1.39606680e-03],\n",
-       "       [-1.48129013e-03],\n",
-       "       [-1.53884790e-03],\n",
-       "       [-1.56938458e-03],\n",
-       "       [-1.57392482e-03],\n",
-       "       [-1.55383658e-03],\n",
-       "       [-1.51079117e-03],\n",
-       "       [-1.44672077e-03],\n",
-       "       [-1.36377435e-03],\n",
-       "       [-1.26427272e-03],\n",
-       "       [-1.15066342e-03],\n",
-       "       [-1.02547614e-03],\n",
-       "       [-8.91279368e-04],\n",
-       "       [-7.50638810e-04],\n",
-       "       [-6.06078155e-04],\n",
-       "       [-4.60042627e-04]])"
-      ]
-     },
-     "execution_count": 100,
-     "metadata": {},
-     "output_type": "execute_result"
+     "ename": "NameError",
+     "evalue": "name 'filt2' is not defined",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
+      "\u001b[0;32m<ipython-input-37-313b18686b6d>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mfilt2\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+      "\u001b[0;31mNameError\u001b[0m: name 'filt2' is not defined"
+     ]
     }
    ],
    "source": [
@@ -2036,16 +1026,28 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 101,
+   "execution_count": 38,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "ename": "NameError",
+     "evalue": "name 'filt2' is not defined",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
+      "\u001b[0;32m<ipython-input-38-9d97b25b0564>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mw\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mh\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0msps\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfreqz\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfilt2\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+      "\u001b[0;31mNameError\u001b[0m: name 'filt2' is not defined"
+     ]
+    }
+   ],
    "source": [
     "w, h = sps.freqz(filt2)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 102,
+   "execution_count": 39,
    "metadata": {},
    "outputs": [
     {
@@ -2058,7 +1060,7 @@
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 432x288 with 2 Axes>"
       ]
@@ -2094,41 +1096,44 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 38,
+   "execution_count": 40,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "ename": "ValueError",
+     "evalue": "The length of the input vector x must be at least padlen, which is 33.",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
+      "\u001b[0;32m<ipython-input-40-46397a19b941>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mts_imp\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0msps\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfiltfilt\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mb\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mb\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mts\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+      "\u001b[0;32m~/anaconda3/envs/geomagenv36/lib/python3.6/site-packages/scipy/signal/signaltools.py\u001b[0m in \u001b[0;36mfiltfilt\u001b[0;34m(b, a, x, axis, padtype, padlen, method, irlen)\u001b[0m\n\u001b[1;32m   3089\u001b[0m     \u001b[0;31m# method == \"pad\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   3090\u001b[0m     edge, ext = _validate_pad(padtype, padlen, x, axis,\n\u001b[0;32m-> 3091\u001b[0;31m                               ntaps=max(len(a), len(b)))\n\u001b[0m\u001b[1;32m   3092\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   3093\u001b[0m     \u001b[0;31m# Get the steady state of the filter's step response.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;32m~/anaconda3/envs/geomagenv36/lib/python3.6/site-packages/scipy/signal/signaltools.py\u001b[0m in \u001b[0;36m_validate_pad\u001b[0;34m(padtype, padlen, x, axis, ntaps)\u001b[0m\n\u001b[1;32m   3139\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0maxis\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m<=\u001b[0m \u001b[0medge\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   3140\u001b[0m         raise ValueError(\"The length of the input vector x must be at least \"\n\u001b[0;32m-> 3141\u001b[0;31m                          \"padlen, which is %d.\" % edge)\n\u001b[0m\u001b[1;32m   3142\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   3143\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0mpadtype\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0medge\u001b[0m \u001b[0;34m>\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;31mValueError\u001b[0m: The length of the input vector x must be at least padlen, which is 33."
+     ]
+    }
+   ],
    "source": [
     "ts_imp = sps.filtfilt(a=a,b=b,x=ts)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 39,
+   "execution_count": 41,
    "metadata": {
     "scrolled": true
    },
    "outputs": [
     {
-     "data": {
-      "text/plain": [
-       "[<matplotlib.lines.Line2D at 0x1c1fb29748>]"
-      ]
-     },
-     "execution_count": 39,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
+     "ename": "NameError",
+     "evalue": "name 'ts_imp' is not defined",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
+      "\u001b[0;32m<ipython-input-41-174a7039e92d>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mpl\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mplot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mts_imp\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+      "\u001b[0;31mNameError\u001b[0m: name 'ts_imp' is not defined"
+     ]
     }
    ],
    "source": [
@@ -2137,19 +1142,18 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 89,
+   "execution_count": 42,
    "metadata": {},
    "outputs": [
     {
-     "ename": "AttributeError",
-     "evalue": "module 'numpy' has no attribute 'epsilon'",
-     "output_type": "error",
-     "traceback": [
-      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
-      "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
-      "\u001b[0;32m<ipython-input-89-56c419ae92da>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mepsilon\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-      "\u001b[0;31mAttributeError\u001b[0m: module 'numpy' has no attribute 'epsilon'"
-     ]
+     "data": {
+      "text/plain": [
+       "<module 'numpy' from '/Users/aclaycomb/anaconda3/envs/geomagenv36/lib/python3.6/site-packages/numpy/__init__.py'>"
+      ]
+     },
+     "execution_count": 42,
+     "metadata": {},
+     "output_type": "execute_result"
     }
    ],
    "source": [
@@ -2165,14 +1169,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 40,
+   "execution_count": 43,
    "metadata": {},
    "outputs": [
     {
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "/Users/aclaycomb/anaconda3/envs/geomagenv36/lib/python3.6/site-packages/scipy/signal/filter_design.py:536: UserWarning: The group delay is singular at frequencies [0.000, 0.006, 0.012, 0.018, 0.025, 0.031, 0.037, 0.043, 0.049, 0.055, 0.061, 0.067, 0.074, 0.080, 0.086, 0.092, 0.098, 0.104, 0.110, 0.117, 0.123, 0.129, 3.013, 3.019, 3.025, 3.031, 3.037, 3.043, 3.050, 3.056, 3.062, 3.068, 3.074, 3.080, 3.086, 3.093, 3.099, 3.105, 3.111, 3.117, 3.123, 3.129, 3.135], setting to 0\n",
+      "/Users/aclaycomb/anaconda3/envs/geomagenv36/lib/python3.6/site-packages/scipy/signal/filter_design.py:536: UserWarning: The group delay is singular at frequencies [2.970, 2.976, 2.982, 2.988, 2.994, 3.000, 3.007, 3.013, 3.019, 3.025, 3.031, 3.037, 3.043, 3.050, 3.056, 3.062, 3.068, 3.074, 3.080, 3.086, 3.093, 3.099, 3.105, 3.111, 3.117, 3.123, 3.129, 3.135], setting to 0\n",
       "  format(\", \".join(\"{0:.3f}\".format(ws) for ws in w[singular]))\n"
      ]
     }
@@ -2183,22 +1187,22 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 41,
+   "execution_count": 44,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "<matplotlib.legend.Legend at 0x1c1fb0ab70>"
+       "<matplotlib.legend.Legend at 0x1c25fee438>"
       ]
      },
-     "execution_count": 41,
+     "execution_count": 44,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -2218,7 +1222,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 23,
+   "execution_count": 45,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -2227,14 +1231,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 24,
+   "execution_count": 46,
    "metadata": {},
    "outputs": [
     {
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "/Users/aclaycomb/anaconda3/envs/geomagenv36/lib/python3.6/site-packages/scipy/signal/filter_design.py:536: UserWarning: The group delay is singular at frequencies [3.129, 3.135], setting to 0\n",
+      "/Users/aclaycomb/anaconda3/envs/geomagenv36/lib/python3.6/site-packages/scipy/signal/filter_design.py:536: UserWarning: The group delay is singular at frequencies [3.117, 3.123, 3.129, 3.135], setting to 0\n",
       "  format(\", \".join(\"{0:.3f}\".format(ws) for ws in w[singular]))\n"
      ]
     }
@@ -2245,17 +1249,17 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 25,
+   "execution_count": 47,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "array([5.92719812e-08, 2.96359906e-07, 5.92719812e-07, 5.92719812e-07,\n",
-       "       2.96359906e-07, 5.92719812e-08])"
+       "array([5.23078520e-08, 3.13847112e-07, 7.84617780e-07, 1.04615704e-06,\n",
+       "       7.84617780e-07, 3.13847112e-07, 5.23078520e-08])"
       ]
      },
-     "execution_count": 25,
+     "execution_count": 47,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -2266,17 +1270,17 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 20,
+   "execution_count": 48,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "array([ 1.        , -4.9082771 ,  9.65633587, -9.51809429,  4.70039227,\n",
-       "       -0.93035486])"
+       "array([  1.        ,  -5.80308622,  14.10288385, -18.37054236,\n",
+       "        13.52693415,  -5.33825224,   0.88206754])"
       ]
      },
-     "execution_count": 20,
+     "execution_count": 48,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -2287,22 +1291,22 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 21,
+   "execution_count": 49,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "<matplotlib.legend.Legend at 0x1c200cd0f0>"
+       "<matplotlib.legend.Legend at 0x1c26093358>"
       ]
      },
-     "execution_count": 21,
+     "execution_count": 49,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -2322,22 +1326,22 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 17,
+   "execution_count": 50,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "<matplotlib.legend.Legend at 0x1c26bdec50>"
+       "<matplotlib.legend.Legend at 0x1c26036cf8>"
       ]
      },
-     "execution_count": 17,
+     "execution_count": 50,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYUAAAEKCAYAAAD9xUlFAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvIxREBQAAIABJREFUeJzt3Xl8VNX5+PHPM9l3SEB2CCCgbGEXAQUpm0pBK4oLbakL1br3p63Wtvr1W19frX5dUItF8atWClatVVu1iGxFVDYR2QREZBcSIPs2yfP7Y27GJGSZhNxMJnner9e8cpdz731mIHnmnHPvOaKqGGOMMQCeYAdgjDGm6bCkYIwxxs+SgjHGGD9LCsYYY/wsKRhjjPGzpGCMMcbPkoIxxhg/SwrGGGP8LCkYY4zxCw92AHXVpk0bTU1NDXYYxhgTUjZs2JCuqm1rK+daUhCRaGAVEOVc5w1Vvb9SmdnAo8BBZ9MzqvpCTedNTU1l/fr1DR+wMcY0YyLybSDl3KwpFALjVTVHRCKA1SLyvqp+Wqnca6p6i4txGGOMCZBrSUF9I+3lOKsRzstG3zPGmCbM1Y5mEQkTkU3AUeBDVf2simKXichmEXlDRLq4GY8xxpiaudrRrKolwCARaQW8JSL9VXVLuSLvAotUtVBEbgReBsZXPo+IzAHmAHTt2tXNkI2pk+LiYg4cOEBBQUGwQzEGgOjoaDp37kxERES9jpfGmk9BRO4HclX1sWr2hwHHVTWppvMMGzZMraPZNBXffPMNCQkJpKSkICLBDse0cKpKRkYG2dnZdO/evcI+EdmgqsNqO4drzUci0tapISAiMcAEYEelMh3KrU4DtrsVjzFuKCgosIRgmgwRISUl5bRqrm42H3UAXnZqAB7gb6r6TxF5EFivqu8At4nINMALHAdmuxiPMa6whGCaktP9/+jm3UebgcFVbP99ueV7gXvdisFthzPzWfvNcaYP6hTsUIwxpkHYMBen4aF/bef2xZtYufNYsEMxLdiRI0e48sor6dmzJ3379uWiiy5i586drFixgqlTp9bpXOPGjTvth0P37t1L//79T+sclT300EMMGjSIQYMGERYW5l+eO3dug16nzIYNGxg5ciT9+/dn4MCBvPHGG1WWmzVrFt27dyctLY3evXvz05/+lEOHDtXrms8++ywLFy48nbAbRMgNc9GUZOQUAfCPzw8ytnetT48b0+BUlUsvvZSf/vSnLF68GIBNmzbx3XffBTmyhnXfffdx3333ARAfH8+mTZtcvV58fDwLFy6kZ8+eHDhwgGHDhjF58mQSEhJOKfvEE09wySWXUFpayuOPP8748eP58ssv63z3z80339xQ4Z8Wqymchj3pvmfzDmfmBzkS01ItX76ciIgIbrzxRv+2QYMGcd555wGQk5PDjBkzOOuss7jmmmsou9tww4YNjB07lqFDhzJ58mQOHz7sP/7VV19l1KhR9O/fn7Vr11JaWkqvXr04dsxXIy4tLeXMM88kPT2d7777jksvvZS0tDTS0tJYs2YNACUlJdxwww3069ePSZMmkZ/v+x35+uuvmTJlCkOHDuW8885jx44dZGZmkpqaSmlpKQB5eXl06dKF4uLiWt//yZMn6dGjB16v17/evXt3SkpKGDNmDHfccQfnnnsuAwYM8NeAcnJymD17NiNGjGDw4MG8++67p5y3T58+9OzZE4DOnTuTkpJCenp6jbF4PB7uuusukpOTWbJkCQDvv/8+5557LkOGDGHmzJnk5uYCcPfdd9O3b18GDhzIr3/9awB++9vf8uSTTwLw6aefMnDgQEaNGsXdd9/NoEGDAHjhhReYMWMGkydPplevXtx7b8O3vltNoZ6yCor5LqsQgCOZdo+6gf96dyvbDmU16Dn7dkzk/h/2q3b/li1bGDp0aLX7P//8c7Zu3UrHjh0ZPXo0H3/8Meeccw633norb7/9Nm3btuW1117jvvvu48UXXwQgNzeXNWvWsGrVKq699lq2bNnCrFmzWLhwIXfccQdLly4lLS2NNm3aMHPmTMaOHctbb71FSUkJOTk5nDhxgl27drFo0SKef/55rrjiCt58801mzZrFnDlzeO655+jVqxefffYZv/jFL1i2bBlpaWmsXLmSCy64gHfffZfJkycH9E27VatWjB49mg8++ICpU6fy17/+lSuuuIKwsDAACgsL+eSTT1i2bBnXX389mzZt4sEHH2TKlCm89NJLnDhxgnPOOYeJEycSHR1d5TXKEl2gA3EOGTKEHTt2MHz4cB5++GE++ugjYmNjeeihh3jqqae47rrreO+999i6dSsiwsmTJ085x89+9jNefvllRowYwV133VVh3xdffMHGjRsJDw+nd+/e3HrrrXTs2DGg2AJhSaGejjoJoV1iFIczC1BVuwvFNDkjRoygc+fOgK8GsXfvXlq1asWWLVuYOHEi4PtW36HD93eHX3XVVQCcf/75ZGVlcfLkSa699lqmT5/OHXfcwYsvvsjPfvYzAJYtW8Yrr7wCQFhYGElJSZw4cYLu3bv7v90OHTqUvXv3kpOTw5o1a7j88sv91yos9P0ezZw5k9dee40LLriAxYsX84tf/CLg93j99dczd+5cpk6dyv/93//xl7/85ZT3Mn78eI4ePUpOTg5Llizh/fff5+GHHwZ8txXv27eP3r17n3LugwcPMnv2bBYuXBjw73dZbWzNmjVs27aNUaNGAVBUVMSYMWNITk7G4/Fwww03cPHFF5/S75Oenk5RUREjRowA4Oqrr2bp0qX+/RMmTPA3Y5111lns27fPkkJTkJHj+8/cv2MSH+04SmZ+Ma1iI4MclQmmmr7Ru6Vfv37VdoICREVF+ZfDwsLwer2oKv369eOTTz6p8pjKf/xEhC5dutCuXTuWLVvGZ599VmuHaOXr5ufnU1paSqtWrarsD5g2bRr33nsvx48fZ8OGDYwff8rABtUaO3Yst9xyi78p7ayzzqrxvagq//jHP/zNQ9XJzMzk4osv5pFHHmH48OEBx7Np0yYuvvhiCgsLmTJlSoUkVWb9+vV8+OGHLF68mHnz5vmbm+D7pFKdqv5NG5L1KdRTRq6vk7lfx0QADlsTkgmC8ePHU1hYyPPPP+/ftm7dOlauXFntMX369OHYsWP+pFBcXMzWrVv9+1977TUAVq9eTVJSEklJvkEGrr/+embNmlWheeYHP/gB8+bNA3w1jqys6pvPEhMT6d69O6+//jrg++P3xRdfAL6O3REjRnD77bczdepU//kDNWvWLK655hp/Dabye1mxYgXt2rUjLi6OyZMnV7hr6fPPPz/lfIWFhUyfPp3rrruOSy+9NKAYVJUnnniCjIwMJk6cyKhRo1i5ciV79uwBfM1yu3btIjs7m6ysLKZOncoTTzxxyvXbtm1LRESEvw+k7AaCxmJJoZ7KagpntvNV407kFQUzHNNCiQhvvfUWH374IT179qRfv3488MADNTYnREZG8sYbb/DrX/+atLQ0Bg0a5G83B2jdujWjRo3ixhtvZMGCBf7t06ZNIycnp8If3qeeeorly5czYMAAhg4dWiG5VGXhwoUsWLCAtLQ0+vXrx9tvv+3fN3PmTF599VVmzpxZ58/hmmuuITMz85RjExMTGTVqFLfeeqs/cd5///3k5eUxYMAA/+dV2aJFi1izZg0LFizw3/765ZdfVnntO++8k7S0NPr06cOmTZtYtmwZERERtGvXjgULFjBz5kzS0tIYNWoUO3fu9NdA0tLSGD9+PI8//vgp5yxrohs1ahQej8efmBuFqobUa+jQodoUPL7kK02955+6ef9J7fbrf+r7Xx4KdkgmCLZt2xbsEBrNunXrdMyYMcEOo0qLFi3S2bNnV9g2evRo/fzzz4MU0enJzs72L//hD3/QX/7yl3U6vqr/l/hGkqj1b6z1KdRTRm4hrWIiaB3nu0MiM7/22+eMCVUPP/ww8+bNaxIPV1V20003sXTpUj744INgh9Jg3nnnHf74xz/i9XpJTU3lpZdearRrW1Kop+O5RSTHRZIU40sKWfkN29ljTFNyzz33cM899wQ7jCqV9WlUtnr16kaOpOFcffXVXH311UG5tvUp1FPZ3UbxUeF4xGoKxpjmwZJCPWUXeEmIDkdESIyJsKRgjGkWLCnUU1Z+MYnRvqajpJgIsgosKRhjQp8lhXoqqymALylYTcEY0xxYUqgHVSWroJiEcjUFSwomWOLj42st8+STT5KXl9cI0bjj5MmT/OlPf6p2f9lw2v379+eHP/xhleMJna7169dz2223Nfh566O2z+N0WFKoh0JvKcUlSmKMr6YQHxVOToHdfWSarvokhZKSEpeiqbva/gjGxMSwadMmtmzZQnJyMs8++2yDxzBs2LAq529o6GEmAmFJoYnJcmoFZTWFuKhw8oqazi+QaZlWrFjBuHHjThkqe+7cuRw6dIgLLriACy64AIAlS5b4h3S+/PLLycnxDQOfmprKgw8+yJgxY3j99dcZN24cd955J+effz5nn30269at40c/+hG9evXit7/9rf/al1xyCUOHDqVfv37Mnz/fv33BggX07t2bcePGccMNN3DLLbcAMHv2bG677TZGjRpFjx49Kozf9OijjzJ8+HAGDhzI/fffD/huif36668ZNGgQd999d42fw7nnnsvBgwdrPB/4Ju7p06cPEyZM4KqrruKxxx4DKk40lJ6e7h8dtfykRQ888ABz5sxh0qRJ/OQnP6GkpIS7777bf50///nP/mPGjh3LFVdcQe/evbnnnntYuHAhI0aMYMCAAXz99dcAHDt2jMsuu4zhw4czfPhwPv74Y/91rr32WsaNG0ePHj38Sakun0dd2XMK9ZDl1AoSnT6FuMgwcgqtptDivX8PHKl6KIR6az8ALnw44OJVDZV922238fjjj7N8+XLatGlDeno6f/jDH1i6dClxcXE88sgjPP744/z+976ZcqOjo/33+D/33HNERkayatUqnnrqKaZPn86GDRtITk6mZ8+e3HnnnaSkpPDiiy+SnJxMfn4+w4cP57LLLqOwsJD//u//ZuPGjSQkJDB+/HjS0tL8sR4+fJjVq1ezY8cOpk2bxowZM1iyZAm7du1i7dq1qCrTpk1j1apVPPzww2zZsqXWyXVKSkr46KOPuO666wCqPV9cXByLFy/m888/x+v1MmTIkBqHIK/Khg0bWL16NTExMcyfP5+kpCTWrVtHYWEho0ePZtKkSYBvqOvt27eTnJxMjx49uP7661m7di1PPfUUTz/9NE8++SS33347d955J2PGjGHfvn1MnjyZ7du3A7Bjxw6WL19OdnY2ffr04aabbgr486gPSwr1kO3caZRYrqaQW+i14bNN0FU1VPaYMWMqlPn000/Ztm0bo0ePBnxDOp977rn+/ZXHD5o2bRqAf6ygsmG2e/Towf79+0lJSWHu3Lm89dZbAOzfv59du3Zx5MgRxo4dS3JyMgCXX345O3fu9J/3kksuwePx0LdvX/9McUuWLGHJkiUMHuyb3j0nJ4ddu3bRtWvXGt93fn6+//0OHTrUPyx4defLzs7m0ksvJTY2tsJ7rItp06YRExPjv87mzZv9NZ7MzEx27dpFZGQkw4cP939mPXv29CeLAQMGsHz5cgCWLl3Ktm3b/OfOysoiOzsbgIsvvpioqCiioqI444wzXJ9Vz7WkICLRwCogyrnOG6p6f6UyUcArwFAgA5ipqnvdiqmh+GsKTp9CXFQ43lKlqKSUqPC6je5ompE6fKN3SyDDKqsqEydOZNGiRVWeIy4urspzejyeCuf3eDx4vV5WrFjB0qVL+eSTT4iNjWXcuHEUFBTUaQjosrKqyr333svPf/7zCmX37t1b47nK+hQyMzOZOnUqzz77LLfddlu153vyySer/QIXHh7unwWuoKD60Y/Lf06qytNPP83kyZMrlFmxYsUpn1n5z7Ps36e0tJRPPvnEn2TKc3uo7Mrc7FMoBMarahowCJgiIiMrlbkOOKGqZwJPAI+4GE+DKasp+PsUIn2JILfQ+hVM05SQkOD/5jly5Eg+/vhjdu/eDfimvyz/Db6uMjMzad26NbGxsezYsYNPP/0U8NVaVq5cyYkTJ/B6vbz55pu1nmvy5Mm8+OKL/j6OgwcPcvTo0Qrx1yQpKYm5c+fy2GOPUVxcXO35zj//fN566y3y8/PJzs6uMCVnamoqGzZsAKhxrorKcc+bN88/hejOnTv9U28GYtKkSTzzzDP+9dqahQL9POrDtaTgDMyX46xGOK/KXx2mAy87y28AP5AQaH8pG+eofPMRQK71K5gmas6cOVx44YVccMEFtG3blpdeeomrrrqKgQMHMnLkSHbs2FHvc0+ZMgWv18vAgQP53e9+x8iRvu9+nTp14je/+Q3nnHMOEyZMoG/fvrUOAT1p0iSuvvpq/7zKM2bMIDs7m5SUFEaPHk3//v1r7VgdPHgwaWlpLF68uNrzlc2ZPGjQIC677DL/nNYAd911F/PmzWPUqFG1zstc5vrrr6dv374MGTKE/v378/Of/7xO3+jnzp3L+vXrGThwIH379uW5556rsXxdPo86C2Qo1fq+gDBgE5ADPFLF/i1A53LrXwNtajpnUxg6+7kVu7Xbr/+pOQXFqqr6r82HtNuv/6nbD2cGOTLT2FrS0Nn1UTYEdHFxsU6dOlX//ve/Bzmiqt1///366KOPBjuMBnM6Q2e7ekuqqpao6iCgMzBCRPpXKlJVreCUhkgRmSMi60Vk/bFjx9wItU6yC7yEeYRYp9nIagrGVO2BBx7wP1TWvXt3LrnkkmCHZGrRKHcfqepJEVkBTMFXOyhzAOgCHBCRcCAJOF7F8fOB+QDDhg2rufeqEfieZg73d1RZn4IxVSu797+pq2r2tZbKtZqCiLQVkVbOcgwwAajccPkO8FNneQawzKnmNGnlxz0Cqym0dCHwX9a0IKf7/9HN5qMOwHIR2QysAz5U1X+KyIMiUnZT8AIgRUR2A78EmuYsHpWUHyEVfMNcAOTaU80tTnR0NBkZGZYYTJOgqmRkZBAdHV3vc7jWfKSqm4HBVWz/fbnlAuByt2JwS+WaQqy/+chqCi1N586dOXDgAE2hr8sY8H1RKXuAsT7sieZ6yCoopmtyrH/d33xUZEmhpYmIiKB79+7BDsOYBmMD4tWDr6bwffNRVLiHMI9YTcEYE/IsKdRD2d1HZUSEuMgwu/vIGBPyLCnUUWmpklPoJTEmosL2eGdQPGOMCWWWFOoop8iL6vfDZpeJjQq3PgVjTMizpFBHZRPslL8lFcqGz7bmI2NMaLOkUEfZzrDZCZVqCr4+BaspGGNCmyWFOvLXFGJOrSnY7GvGmFBnSaGOaqop2DzNxphQZ0mhjrILK06wUybO7j4yxjQDlhTq6PsJdirWFOLt7iNjTDNgSaGOyvoUKtcUYiPDKSguxVtSGoywjDGmQVhSqKPM/GJiIsKIDK/40cVF+QbFyyu2fgVjTOiypFBHmfnFJFW68whsTgVjTPNgSaGOsgosKRhjmi9LCnVUXU0hPsqm5DTGhD5LCnWUmX/qYHjg62gGqykYY0KbJYU6ysovJjHm1LmJbEpOY0xzYEmhjqprPrIpOY0xzYElhTrwlpSSU+itpk/BpuQ0xoQ+15KCiHQRkeUisl1EtorI7VWUGScimSKyyXn93q14GkLZuEd295Exprk6tXG84XiB/6eqG0UkAdggIh+q6rZK5f6jqlNdjKPBZDpPM1eVFGIifM1HOXb3kTEmhLlWU1DVw6q60VnOBrYDndy6XmOoKSl4PL55mvOspmCMCWGN0qcgIqnAYOCzKnafKyJfiMj7ItKvMeKpr8xq5lIoY3MqGGNCnZvNRwCISDzwJnCHqmZV2r0R6KaqOSJyEfAPoFcV55gDzAHo2rWryxFXr6aaAvg6my0pGGNCmas1BRGJwJcQFqrq3yvvV9UsVc1xlt8DIkSkTRXl5qvqMFUd1rZtWzdDrlGtSSHa5lQwxoQ2N+8+EmABsF1VH6+mTHunHCIywoknw62YTldtSSEu0moKxpjQ5mbz0Wjgx8CXIrLJ2fYboCuAqj4HzABuEhEvkA9cqarqYkynJaugmMhwD9HOnUaVxUeHs/94XiNHZYwxDce1pKCqqwGppcwzwDNuxdDQsqp5mrlMgs2+ZowJcfZEcx2czKs5KcRFhZNTYEnBGBO6LCnUQUZuEclxkdXu93U028NrxpjQZUmhDjJyCmkTX0NSiAqnqKSUQq8lBmNMaLKkUAfHa6spOOMfWROSMSZU1djRLCLRwFTgPKAjvjuEtgD/UtWt7ofXdHhLSjmRV0xKXFS1ZfwjpRaWkBLfWJEZY0zDqTYpiMgDwA+BFfiGpzgKRAO9gYedhPH/VHWz+2EG34k83zMKKTU0H5WNlJpdWNwoMRljTEOrqaawTlUfqGbf4yJyBs4zBy1BRm4hQI01hYTo72sKxhgTiqpNCqr6r8rbRMQDxDvDUxzFV3toETJyigAC61OwmoIxJkTV2tEsIn8VkUQRiQO2AV+JyN3uh9a0ZOT6kkJNdx/5m4+so9kYE6ICufuorzO66SXAe/iajH7salRNUEaOr/moppqCNR8ZY0JdIEkhwhnt9BLgbVUtBprs+ERuOZ5bhEegVWztNQVrPjLGhKpAksKfgb1AHLBKRLoBledFaPbSc4poHRtJmKf64ZxiI8IQsecUjDGhq9akoKpzVbWTql7kjGC6D7jA/dCaluO5hTXejgq+KTnjI8NtnmZjTMiqNimIyCznbqMK1McrIj1FZIy74TUdGTk1P81cxjclpzUfGWNCU03PKaQAn4vIBmADcAzfw2tnAmOBdOAe1yNsIjJyi+jbMbHWcjYonjEmlFVbU1DVp4AhwCKgLfADZ/0g8GNVvUxVdzVKlEGmqhzOzKdDYnStZeOiwsm22deMMSGqxrGPVLUE+NB5tVgn84opKC6lfVLtSSEhKpzsAms+MsaEJhslNQCHMwsA6NgqptayiTHhZOVbUjDGhCZLCgE4nJkPEFBNISkmgiy7JdUYE6ICGeai6lnqWxB/TSEpkJpCBJlWUzDGhKhAagq7ReRREelblxOLSBcRWS4i20Vkq4jcXkUZEZG5IrJbRDaLyJC6XKOxHM7MJ8wjtE2ofoTUMkkxERR5SykotjuQjDGhJ5CkMBDYCbwgIp+KyBwRqf3eTPDim2/hbGAkcHMVieVCoJfzmgPMCzz0xnM4s4B2CVE1Ps1cJikmAsBqC8aYkBTIE83Zqvq8qo4CfgXcDxwWkZdF5MwajjusqhvLzgFsBzpVKjYdeMV5IO5ToJWIdKjvm3HL4ZMFdAigkxkgMdqSgjEmdAXUpyAi00TkLeAp4H+BHsC7+EZNrZWIpAKD8c3gVl4nYH+59QOcmjiC7khWQUCdzGA1BWNMaKvxOQXHLmA58Kiqrim3/Q0ROb+2g0UkHngTuMMZgrvC7ioOOWUEVhGZg695ia5dG3eyN1Xl0Ml8Jpx9RkDl/Ukhz5KCMSb0BJIUBqpqTlU7VPW2mg50htx+E1ioqn+vosgBoEu59c7AoSquMx+YDzBs2LBGHbY7PaeIQm9pQM8ogNUUjDGhLZCk4BWRm4F++MY+AkBVr63pIBERYAGwXVUfr6bYO8AtIrIYOAfIVNXDAUXeSL5JzwWge5u4gMqXJYUse6rZGBOCArn76C9Ae2AysBLft/nsAI4bjW+GtvEissl5XSQiN4rIjU6Z94A9wG7geeAXdX0DbtvrJIUebeIDKp9oNQVjTAgLpKZwpqpeLiLTVfVlEfkr8O/aDlLV1VTdZ1C+jAI3BxZqcOxJzyUiTOjUOrDmozCPkBAVbknBGBOSAqkplP11Oyki/YEkINW1iJqYb9Jz6JocG9AzCmXsqWZjTKgKpKYwX0RaA7/D1wcQD/ze1aiakG/Sc+keYNNRmcSYCBsUzxgTkmpNCqr6grO4Et/zCS1GaamyNyOPcX0Cux21TFKMNR8ZY0JTtUlBRH5Z04E13FHUbBzKzKfIWxrwnUdlkmIi/HctGWNMKKmpppDQaFE0UbuO+h7P6FGPpGA1BWNMKKo2KajqfzVmIE3RtkO+B7DPDmBu5vIsKRhjQlUgYx/1FpGPRGSLsz5QRH7rfmjBt+VgJt1SYv2D3AWqdVwkBcWl5BXZZDvGmNASyC2pzwP34tyaqqqbgSvdDKqp2Hooi351rCUAtInzzbuQkVPU0CEZY4yrAkkKsaq6ttK2Zv8VOKugmH3H8+jXManOxybHRQJwPNeSgjEmtASSFNJFpCfO6KUiMgNoUuMTuaGsP6FvPWoKKfG+pJCRW9igMRljjNsCeXjtZnwjlJ4lIgeBb4BrXI2qCfjyQCYA/etRU2gT72s+SrfmI2NMiAnk4bU9wAQRiQM8zixqzd5n3xwnNSU2oHmZK7PmI2NMqKoxKYhIH3yT25zlbNouIvNVdafrkQVRaamybu9xpvRrX6/jYyPDiI7wkJFjzUfGmNBSbZ+CiJwLrMA3TPZ8fHch5QIrRGRko0QXJF99l01mfjHn9Eiu1/EiQkpcFBlWUzDGhJiaagq/B65S1RXltv1DRJYB9wMXuhlYMH22JwOAEd3rlxTA19lst6QaY0JNTXcf9ayUEABQ1WY/MN7q3el0bh1D59ax9T5Hclyk3X1kjAk5NSWFmjqUm+1ob3lFXv6zK50JZ7c7rfOkxEVx3GoKxpgQU1PzURcRmVvFdgE6uRRP0P1nVzqF3lIm9j3NpBAfSXpuEaqKb7pqY4xp+mpKCnfXsG99QwfSVHy47TsSo8NPqz8BICUukiJvKblFJcRHBfI4iDHGBF9No6S+3JiBNAUFxSX8e+sRJp7djoiwQB72rl7Zswrp2YWWFIwxIeP0/vLVQEReFJGjZaOrVrF/nIhkisgm5xX0KT4/2HKE7AIvM4Z1Pu1znZEYDcDRbOtsNsaEDje/wr4EPAO8UkOZ/6jqVBdjqJO/rd9Pl+QYRnZPOe1zdUjyJYUjWQWnfS5jjGksrtUUVHUVcNyt8ze0HUeyWPN1BjOHdcHjOf2O4XZOTeFIZv5pn8sYYxpLIJPs9BCRd0Uk3WkOeltEGuo5hXNF5AsReV/Zw3NzAAAWjklEQVRE+jXQOevlT8u/Ji4yjFkjuzXI+RKjw4mNDONIpjUfGWNCRyA1hb8CfwPaAx2B14FFDXDtjUA3VU0Dngb+UV1BEZkjIutFZP2xY8ca4NIV7T6azT83H2LWud1oFRvZIOcUEdonRnMky2oKxpjQEUhSEFX9i6p6nderOHMrnA5VzVLVHGf5PSBCRNpUU3a+qg5T1WFt27Y93UtXPje/+8dW4qPCmXNewz6o3T4pmiOZ1qdgjAkdgSSF5SJyj4ikikg3EfkV8C8RSRaRet/MLyLtxXmqS0RGOLFk1Pd89fX6+gN8sieDu6ecRUp83YfJrkn7xGi+y7LmI2NM6Ajk7qOZzs+fV9p+Lb4aQ5Vfr0VkETAOaCMiB/ANohcBoKrPATOAm0TEC+QDV6rqaddA6mLroUx+9/YWRvZI5uoRXRv8/O2Tovkuq4DSUm2QzmtjjHFbIJPsdK/PiVX1qlr2P4PvltWg2Hookx8vWEvr2EievmoIYS780W6fFI23VEnPLeSMhOgGP78xxjS0WpOCiPykqu2qWtPzB03WybwiXv30W+Yu202buEj+esPIes2uFoj2/ttSCywpGGNCQiDNR8PLLUcDP8B351BIJYWl277jd29v4UhWAaowsW87Hrq0v6t/rNsnfZ8UBp7+Q9LGGOO6QJqPbi2/LiJJwF9ci8gl7RKjGdWzDV2TY5nYtx19Oya6fs1OrWIAOHDCbks1xoSG+gxzkQf0auhA3DagcxL/e0Vao14zOS6S+Khw9h3Pa9TrGmNMfQXSp/Au3z+XEAacje9hNlMLEaFLciz7LSkYY0JEIDWFx8ote4FvVfWAS/E0O12TY/j6WLOdqM4Y08zU+vCaMyfzDiABaA3YHJN10C0ljv3H8ygtbdRHMIwxpl4CGRDvCmAtcDlwBfCZiMxwO7DmoktyLIXeUo7l2JPNxpimL5Dmo/uA4ap6FEBE2gJLgTfcDKy56JocC8C+43n+4bSNMaapCmTsI09ZQnBkBHicAbo5SeHbDOtsNsY0fYHUFD4QkX/z/XDZM4H33AupeenYKgaPwL4M62w2xjR9gTy8dreI/AgYAwgwX1Xfcj2yZiIy3EPX5Fi+TrekYIxp+mpMCiISBvxbVScAf2+ckJqfM89IYPd3OcEOwxhjalVj34CqlgB5ztAWpp56tYtnT3oO3pLSYIdijDE1CqRPoQD4UkQ+BPxtIKp6m2tRNTO9zoinuET59ngePdvGBzscY4ypViBJ4V/Oy9RTrzMSANj1XbYlBWNMkxZIR/PLjRFIc9bzjDgAdn2Xw5T+QQ7GGGNqUG2fgohMF5Gby61/JiJ7nJc90VwHsZHhdG4dw86j1tlsjGnaaupo/hXwTrn1KHwT7owDbnIxpmbprPYJ7DicFewwjDGmRjUlhUhV3V9ufbWqZqjqPiDO5bianX4dk/j6WA55Rd5gh2KMMdWqKSm0Lr+iqreUW23rTjjN14BOSZQqbLfagjGmCaspKXwmIjdU3igiP8c3amqNRORFETkqIluq2S8iMldEdovIZhEZEnjYoad/J9+jHl8eyAxyJMYYU72a7j66E/iHiFwNbHS2DcXXt3BJAOd+CXgGeKWa/Rfim9azF3AOMM/52Sy1S4yiTXwUWw5ZTcEY03RVmxSckVFHich4oJ+z+V+quiyQE6vqKhFJraHIdOAVVVXgUxFpJSIdVPVwYKGHFhGhf6dEthy0moIxpukK5DmFZUBAiaCOOgHlO7IPONtOSQoiMgeYA9C1a1cXQmkcAzu3YtXOXeQUeomPCuS5QWOMaVzBnBdBqthW5ZyVqjpfVYep6rC2bUO3j3t4amtKFT7fdyLYoRhjTJWCmRQOAF3KrXcGDgUplkYxuGtrPALr9lpSMMY0TcFMCu8AP3HuQhoJZDbX/oQy8VHhnN0hkfV7jwc7FGOMqZJrDdsisgjf089tROQAcD8QAaCqz+Gbve0iYDeQB/zMrViakuGpyby2bj/FJaVEhNmspsaYpsW1pKCqV9WyX4GbayrTHA1PTealNXvZfOAkQ7slBzscY4ypwL6qNrJRPVMQgf/sSg92KMYYcwpLCo2sdVwkAzslWVIwxjRJlhSC4Lxebdm0/yRZBcXBDsUYYyqwpBAE5/VqQ0mp8rHVFowxTYwlhSAY2q01rWMj+GDrkWCHYowxFVhSCILwMA8T+7Zj2fajFHpLgh2OMcb4WVIIkgsHdCC70MvHu60JyRjTdFhSCJLRPduQEB3Oe19aE5IxpumwpBAkkeEeJpzdjg+3fUdxSWmwwzHGGMCSQlBNHdiBzPxilu04GuxQjDEGsKQQVGN7t6VdYhSL1+4LdijGGANYUgiq8DAPlw/twsqdxzh0Mj/Y4RhjjCWFYLtiWBdKFV5ffyDYoRhjjCWFYOuaEsuYM9uweN0+63A2xgSdJYUm4NoxqRzOLODdL5r1xHPGmBBgSaEJuKDPGfRpl8BzK7+mtLTKaaqNMaZRWFJoAkSEG8f1YOd3OXZ7qjEmqCwpNBFTB3akU6sYnvpol9UWjDFBY0mhiYgI8/DLib358mAm7262vgVjTHBYUmhCLh3cib4dEvnjB19RUGyjpxpjGp+rSUFEpojIVyKyW0TuqWL/bBE5JiKbnNf1bsbT1Hk8wn0Xn83Bk/ksWP1NsMMxxrRAriUFEQkDngUuBPoCV4lI3yqKvqaqg5zXC27FEypGn9mGC/u356mPdrHnWE6wwzHGtDBu1hRGALtVdY+qFgGLgekuXq/Z+K9p/YgK93Dv37+0TmdjTKNyMyl0AvaXWz/gbKvsMhHZLCJviEiXqk4kInNEZL2IrD927JgbsTYpZyRGc99FZ/PZN8d58WNrRjLGNB43k4JUsa3y1953gVRVHQgsBV6u6kSqOl9Vh6nqsLZt2zZwmE3TzOFdmNi3HY98sIPNB04GOxxjTAvhZlI4AJT/5t8ZqHCvpapmqGqhs/o8MNTFeEKKiPDojIG0jY/i5r9u5ERuUbBDMsa0AG4mhXVALxHpLiKRwJXAO+ULiEiHcqvTgO0uxhNyWsVG8sw1Q/guq5AbX91AkdcGzDPGuMu1pKCqXuAW4N/4/tj/TVW3isiDIjLNKXabiGwVkS+A24DZbsUTqoZ0bc2jMwby2TfHuefNzdbxbIxxVbibJ1fV94D3Km37fbnle4F73YyhOZg+qBP7MvL43w93EhXh4aFLBuDxVNVlY4wxp8fVpGAazi3jz6TAW8Kzy78mzCM8OK2/JQZjTIOzpBAiRIS7JvXBW6r8eeUesgu8/HHGQKLCw4IdmjGmGbGkEEJEhHumnEVSTAR//OArDp8s4M8/HkrruMhgh2aMaSZsQLwQIyL8YtyZPH3VYDbtP8nUp1fz+b4TwQ7LGNNMWFIIUT9M68jrN56LCFz+3Cf8eeXXlNidScaY02RJIYSldWnFv247jwlnt+N/3t/Bj/70MdsOZQU7LGNMCLOkEOKSYiKYN2sIc68azMGT+fzwmdX8z3vbycwvDnZoxpgQZEmhGRARpqV1ZOkvx3LZkE78edUexj66nOdX7bHJeowxdSKqodUOPWzYMF2/fn2ww2jSthzM5I///opVO4/RPjGaa8ekctWIriRERwQ7NGNMkIjIBlUdVms5SwrN15rd6Ty9bDef7MkgISqcK0d04coRXenZNj7YoRljGpklBeO3+cBJ5q/awwdbjuAtVYantmbm8K5M6d+e+Ch7VMWYlsCSgjnF0ewC/r7xIH9bt5896blEhns4v1dbLuzfnglntyMp1pqXjGmuLCmYaqkqG749wXtfHuGDLYc5lFlAuEcYnprMmF5tOK9XG/p1TCLMxlYyptmwpGACoqp8cSCT97ccZuVXx9hxJBuAVrERjOyewtBurRnSrRX9OiYRHWHjLBkTqiwpmHo5ll3Ix7vT+c+udNbtPc6+43kARIZ56NcpkYGdkjirQyJnd0ikd7t4YiOtT8KYUGBJwTSIY9mFbNx3go37TvD5tyfZdjiLnEIvACLQPSWOszokcGbbeFLbxNHdebWKtUH6jGlKAk0K9jXP1KhtQhST+7Vncr/2AJSWKgdO5LP9SBbbD/teWw9l8cGWI5QfeqlVbASpKXGkpsTSqXUMHZJi6Ngqmo6tfMuJ0eGIWJ+FMU2NJQVTJx6P0DUllq4psf5EAVDoLWH/8Xy+Sc9lb3ou32T4fq7be4J3Nx8+ZbC++KhwOiRF0z4pmjbxUaTERdImIYo28VG0iY90fkaREh9JRJg9eG9MY7GkYBpEVHgYZ54Rz5lnnPpgXEmpciy7kIMn8zmcmc/hkwX+5e+yCvkmPZf0nEIKikurPHdidDhJsREkxfherWIiSSxbLrc9KSaC+Khw4qLCnZ9hxEaG211UxtSBJQXjujCP0N6pFUDrKsuoKrlFJWTkFJKeU8ix7CLSneWTecWczCsiM7+YzPxiDmdmkeUsF5fU3icWExHmJApfkihLGHFR4cRFhhMTGUZ0RBjRER7fz3Dnp7MtKiKMmHLr0eEVy0eGeWxqVNNsuJoURGQK8BQQBrygqg9X2h8FvAIMBTKAmaq6182YTNMkIsQ73/C7pcQFdIyqkldU4k8WJ/OKyS30klvkJafQS15hCTmFXv+23MIScgt9+47lFPJtRh45hV7yi0soLC6lqKTqmkogwj1CRJiHiDAhMjyMyDAhItzjbPMQGe7xbQv7fltUuK98RJiHiHAPkf7jPYR5PIR7hDCPVPwZdur275erOCas4vawU87pwSO+ZkGPyKnLUnFZBOsLauZcSwoiEgY8C0wEDgDrROQdVd1Wrth1wAlVPVNErgQeAWa6FZNpXkTE920/KpyOrWJO+3wlpUpBcYnv5S39frm4lMLiEgq8vuWybQXOtiJvKUXeUopLSikuUYpKSil21otKSinyqrPP98ot9FJUUm6bt5SiEqXIW+I/vilPmFQ+WYj4aoKVlz1O8ggrt+zx4Kz7ynrEl5jEKRPmEQRAfD9FcH6WX/dtLL/uS1TfL3PKMRXXKTuminM4e8tdo+rzUP44Tr1+mVPzp9Syv3KJimXO69W2Ql+eG9ysKYwAdqvqHgARWQxMB8onhenAA87yG8AzIiLqxn2y798DR75s8NOa5iMMiHNeDU7w/baFA1G1F1d8vwKqoPhqReqsU2ld0XLbv1+vsOzs1CrOSdl+Z5uzyX8+fzzly/mP00rlatgOaKlWKlf1dct9EJW26ffrWqFY5cMqbdTKq1Vfr/y2cgunnL+KA+v8R6vKAyq/24rCjqZBv+fqeqU6cTMpdAL2l1s/AJxTXRlV9YpIJpACpJcvJCJzgDkAXbt2dSteY5oM5/vo998SrcnGALRv5fol3EwKVf0vrpz4AimDqs4H5oPv4bV6RXPhw7WXMcaYFs7NG8APAF3KrXcGDlVXRkTCgSTguIsxGWOMqYGbSWEd0EtEuotIJHAl8E6lMu8AP3WWZwDLXOlPMMYYExDXmo+cPoJbgH/j68N7UVW3isiDwHpVfQdYAPxFRHbjqyFc6VY8xhhjaufqcwqq+h7wXqVtvy+3XABc7mYMxhhjAmeDyhhjjPGzpGCMMcbPkoIxxhg/SwrGGGP8Qm7mNRE5Bnxbz8PbUOlp6RbA3nPLYO+5ZTid99xNVdvWVijkksLpEJH1gUxH15zYe24Z7D23DI3xnq35yBhjjJ8lBWOMMX4tLSnMD3YAQWDvuWWw99wyuP6eW1SfgjHGmJq1tJqCMcaYGrSYpCAiU0TkKxHZLSL3BDset4nIiyJyVES2BDuWxiIiXURkuYhsF5GtInJ7sGNym4hEi8haEfnCec//FeyYGouIhInI5yLyz2DH0hhEZK+IfCkim0RkvWvXaQnNR8580TspN180cFWl+aKbFRE5H8gBXlHV/sGOpzGISAegg6puFJEEYANwSTP/dxYgTlVzRCQCWA3crqqfBjk014nIL4FhQKKqTg12PG4Tkb3AMFV19dmMllJT8M8XrapFQNl80c2Wqq6ihU1YpKqHVXWjs5wNbMc35WuzpT45zmqE82r23/REpDNwMfBCsGNpblpKUqhqvuhm/ceipRORVGAw8FlwI3Gf04yyCTgKfKiqzf49A08CvwJKgx1II1JgiYhscOatd0VLSQoBzQVtmgcRiQfeBO5Q1axgx+M2VS1R1UH4prwdISLNurlQRKYCR1V1Q7BjaWSjVXUIcCFws9NE3OBaSlIIZL5o0ww47epvAgtV9e/BjqcxqepJYAUwJcihuG00MM1pY18MjBeRV4MbkvtU9ZDz8yjwFr5m8QbXUpJCIPNFmxDndLouALar6uPBjqcxiEhbEWnlLMcAE4AdwY3KXap6r6p2VtVUfL/Ly1R1VpDDcpWIxDk3TyAiccAkwJU7C1tEUlBVL1A2X/R24G+qujW4UblLRBYBnwB9ROSAiFwX7JgawWjgx/i+OW5yXhcFOyiXdQCWi8hmfF9+PlTVFnGLZgvTDlgtIl8Aa4F/qeoHblyoRdySaowxJjAtoqZgjDEmMJYUjDHG+FlSMMYY42dJwRhjjJ8lBWOMMX6WFEzIEpGScreebnKGtmg2RGSwiLzgLM8WkWcq7V8hItXO1ysii0Wkl9txmuYlPNgBGHMa8p3hHaokIuHOMyqh6jfAH07j+Hn4xge6oWHCMS2B1RRMs+J8o35dRN4Fljjb7haRdSKyufx8AyJynzPHxlIRWSQidznb/d/ARaSNM5xC2cBzj5Y718+d7eOcY94QkR0istB5uhoRGS4ia5z5DtaKSIKI/EdEBpWL42MRGVjpfSQAA1X1iwDe87RytaWvROQbZ9d/gAkiYl/+TMDsP4sJZTHO6KAA36jqpc7yufj+oB4XkUlAL3zjxAjwjjOQWC6+IRIG4/s92Ihv/oWaXAdkqupwEYkCPhaRJc6+wUA/fGNqfQyMFpG1wGvATFVdJyKJQD6+4Z5nA3eISG8gSlU3V7rWME4dxmCmiIwpt34mgKq+gzNsi4j8DVjpbC8Vkd1AWgDvzRjAkoIJbdU1H32oqmVzSUxyXp876/H4kkQC8Jaq5gGISCBjYU0CBorIDGc9yTlXEbBWVQ8459oEpAKZwGFVXQdQNmKriLwO/E5E7gauBV6q4lodgGOVtr2mqreUrYjIivI7ReRX+D6TZ8ttPgp0xJKCCZAlBdMc5ZZbFuB/VPXP5QuIyB1UP3y6l++bVqMrnetWVf13pXONAwrLbSrB97slVV1DVfNE5EN8Ez1dga9WUFl+pWvXSER+AFwOVB5OOdo5lzEBsT4F09z9G7jWmWMBEekkImcAq4BLRSTGab//Yblj9gJDneUZlc51kzM8NyLS2xmxsjo7gI4iMtwpn1Cuff8FYC6wrlytprztOM1DtRGRbsCfgCtUtXIC6A0068EfTcOymoJp1lR1iYicDXzi9P3mALOceZxfAzYB3+LrlC3zGPA3EfkxsKzc9hfwNQttdDqSjwGX1HDtIhGZCTztDGudj29o6xxV3SAiWcD/VXPsDhFJEpEEZ2rRmswGUoC3nPd4SFUvEpF2+JqTDtdyvDF+NkqqMYCIPIDvj/VjjXS9jvgmxDlLVaucUlJE7gSyVbVe8xA7x2ep6oJ6B2paHGs+MqaRichP8M0dfV91CcExj4p9FXV1Enj5NI43LZDVFIwxxvhZTcEYY4yfJQVjjDF+lhSMMcb4WVIwxhjjZ0nBGGOMnyUFY4wxfv8fNKu40orVy0MAAAAASUVORK5CYII=\n",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -2359,22 +1363,22 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
+   "execution_count": 51,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "[<matplotlib.lines.Line2D at 0x1c26d319e8>]"
+       "[<matplotlib.lines.Line2D at 0x1c2612fcf8>]"
       ]
      },
-     "execution_count": 18,
+     "execution_count": 51,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -2393,7 +1397,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 19,
+   "execution_count": 52,
    "metadata": {},
    "outputs": [
     {
@@ -2407,7 +1411,7 @@
       "\u001b[0;31mIndexError\u001b[0m: list index out of range",
       "\nDuring handling of the above exception, another exception occurred:\n",
       "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
-      "\u001b[0;32m<ipython-input-19-2193337a950a>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0ma\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mb\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0msps\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0miirdesign\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcutoff\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcutoff\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0mwidth\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mgpass\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m3.0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mgstop\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m50.0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0manalog\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mftype\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'bessel'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      2\u001b[0m \u001b[0mw\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mgd\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0msps\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgroup_delay\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mb\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0mpl\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mplot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mw\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgd\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;32m<ipython-input-52-2193337a950a>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0ma\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mb\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0msps\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0miirdesign\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcutoff\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcutoff\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0mwidth\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mgpass\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m3.0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mgstop\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m50.0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0manalog\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mftype\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'bessel'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      2\u001b[0m \u001b[0mw\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mgd\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0msps\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgroup_delay\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mb\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0mpl\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mplot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mw\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mgd\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
       "\u001b[0;32m~/anaconda3/envs/geomagenv36/lib/python3.6/site-packages/scipy/signal/filter_design.py\u001b[0m in \u001b[0;36miirdesign\u001b[0;34m(wp, ws, gpass, gstop, analog, ftype, output)\u001b[0m\n\u001b[1;32m   1708\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mIndexError\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1709\u001b[0m         raise ValueError((\"%s does not have order selection. Use \"\n\u001b[0;32m-> 1710\u001b[0;31m                           \"iirfilter function.\") % ftype)\n\u001b[0m\u001b[1;32m   1711\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1712\u001b[0m     \u001b[0mwp\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0matleast_1d\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwp\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
       "\u001b[0;31mValueError\u001b[0m: bessel does not have order selection. Use iirfilter function."
      ]
@@ -2421,7 +1425,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 160,
+   "execution_count": 53,
    "metadata": {},
    "outputs": [
     {
@@ -2430,7 +1434,7 @@
        "0.011920928955078125"
       ]
      },
-     "execution_count": 160,
+     "execution_count": 53,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -2441,7 +1445,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
+   "execution_count": 54,
    "metadata": {},
    "outputs": [
     {
@@ -2450,7 +1454,7 @@
        "(512,)"
       ]
      },
-     "execution_count": 18,
+     "execution_count": 54,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -2461,7 +1465,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 20,
+   "execution_count": 55,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -2470,7 +1474,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 26,
+   "execution_count": 56,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -2479,17 +1483,17 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 27,
+   "execution_count": 57,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
        "1 Trace(s) in Stream:\n",
-       "NT.GXX.R0.UK2 | 2018-09-11T21:44:54.240000Z - 2018-09-11T21:49:53.640000Z | 59.9 s, 6 samples"
+       "NT.GXX.R0.UK2 | 2018-09-11T21:44:57.840000Z - 2018-09-11T21:49:57.240000Z | 59.9 s, 6 samples"
       ]
      },
-     "execution_count": 27,
+     "execution_count": 57,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -2500,12 +1504,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 28,
+   "execution_count": 58,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 800x250 with 1 Axes>"
       ]
@@ -2522,7 +1526,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 29,
+   "execution_count": 59,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -2531,7 +1535,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 30,
+   "execution_count": 60,
    "metadata": {},
    "outputs": [
     {
@@ -2540,7 +1544,7 @@
        "array([  0.  ,  59.88, 119.76, 179.64, 239.52, 299.4 ])"
       ]
      },
-     "execution_count": 30,
+     "execution_count": 60,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -2551,7 +1555,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 31,
+   "execution_count": 61,
    "metadata": {},
    "outputs": [
     {
@@ -2560,7 +1564,7 @@
        "0.016666666666666666"
       ]
      },
-     "execution_count": 31,
+     "execution_count": 61,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -2571,7 +1575,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 32,
+   "execution_count": 8,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -2580,24 +1584,16 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 39,
+   "execution_count": 63,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "read_wave_server_v returned flag FR - requested data right (later) than tank contents\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "brt = c.get_timeseries(channels=['UK1'], starttime=UTCDateTime(\"2018-09-11T21:45:00Z\"), endtime=UTCDateTime(\"2018-09-11T21:50:00Z\"), observatory=\"BRT\", type=\"variation\", interval=\"minute\")"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 34,
+   "execution_count": 64,
    "metadata": {},
    "outputs": [
     {
@@ -2606,7 +1602,7 @@
        "array([  0.  ,  59.88, 119.76, 179.64, 239.52, 299.4 ])"
       ]
      },
-     "execution_count": 34,
+     "execution_count": 64,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -2617,7 +1613,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 40,
+   "execution_count": 65,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -2626,7 +1622,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 41,
+   "execution_count": 66,
    "metadata": {},
    "outputs": [
     {
@@ -2635,7 +1631,7 @@
        "array([  0.,  60., 120., 180., 240., 300.])"
       ]
      },
-     "execution_count": 41,
+     "execution_count": 66,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -2644,6 +1640,455 @@
     "dht[0].times()"
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 65,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "bou1 = c.get_timeseries(channels=['SVH','SVE','SVZ','SSF'], starttime=UTCDateTime(\"2018-10-10T00:59:15Z\"), endtime=UTCDateTime(\"2018-10-10T23:59:45Z\"), observatory=\"BOU\", type=\"variation\", interval=\"second\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 66,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "4 Trace(s) in Stream:\n",
+       "NT.BOU.R0.SVH | 2018-10-10T00:59:15.000000Z - 2018-10-10T23:59:45.000000Z | 1.0 Hz, 82831 samples\n",
+       "NT.BOU.R0.SVE | 2018-10-10T00:59:15.000000Z - 2018-10-10T23:59:45.000000Z | 1.0 Hz, 82831 samples\n",
+       "NT.BOU.R0.SVZ | 2018-10-10T00:59:15.000000Z - 2018-10-10T23:59:45.000000Z | 1.0 Hz, 82831 samples\n",
+       "NT.BOU.R0.SSF | 2018-10-10T00:59:15.000000Z - 2018-10-10T23:59:45.000000Z | 1.0 Hz, 82831 samples"
+      ]
+     },
+     "execution_count": 66,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "bou1"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 67,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'SVH'"
+      ]
+     },
+     "execution_count": 67,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "bou1[0].stats.channel"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 68,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "filterer = FilterAlgorithm(outchannels=['MVH','MVE','MVZ','MSF'])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 69,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'SVH': 'MVH', 'SVE': 'MVE', 'SVZ': 'MVZ', 'SSF': 'MSF'}\n",
+      "(82741, 91)\n",
+      "20816.305334453184\n",
+      "20811.80458828588\n",
+      "1380\n",
+      "1380\n",
+      "(82741, 91)\n",
+      "-42.87911339556943\n",
+      "-43.71903955522315\n",
+      "1380\n",
+      "1380\n",
+      "(82741, 91)\n",
+      "47026.001101399066\n",
+      "47024.503480329244\n",
+      "1380\n",
+      "1380\n",
+      "(82741, 91)\n",
+      "51947.01403967162\n",
+      "51944.07858532072\n",
+      "1380\n",
+      "1380\n"
+     ]
+    }
+   ],
+   "source": [
+    "bouf = filterer.process(bou1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 70,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 800x1000 with 4 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "bou1.plot()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 71,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "4 Trace(s) in Stream:\n",
+       "NT.BOU.R0.MVH | 2018-10-10T01:00:00.000000Z - 2018-10-10T23:59:00.000000Z | 60.0 s, 1380 samples\n",
+       "NT.BOU.R0.MVE | 2018-10-10T01:00:00.000000Z - 2018-10-10T23:59:00.000000Z | 60.0 s, 1380 samples\n",
+       "NT.BOU.R0.MVZ | 2018-10-10T01:00:00.000000Z - 2018-10-10T23:59:00.000000Z | 60.0 s, 1380 samples\n",
+       "NT.BOU.R0.MSF | 2018-10-10T01:00:00.000000Z - 2018-10-10T23:59:00.000000Z | 60.0 s, 1380 samples"
+      ]
+     },
+     "execution_count": 71,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "bouf"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 72,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 800x1000 with 4 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "bouf.plot()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 63,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "             network: NT\n",
+       "             station: BOU\n",
+       "            location: R0\n",
+       "             channel: SVH\n",
+       "           starttime: 2018-10-10T00:59:15.000000Z\n",
+       "             endtime: 2018-10-10T23:59:45.000000Z\n",
+       "       sampling_rate: 1.0\n",
+       "               delta: 1.0\n",
+       "                npts: 82831\n",
+       "               calib: 1.0\n",
+       "         agency_name: United States Geological Survey (USGS)\n",
+       "   conditions_of_use: The Conditions of Use for data provided through INTERMAGNET and acknowledgement templates can be found at www.intermagnet.org\n",
+       "       data_interval: second\n",
+       "  data_interval_type: Average 1-Second\n",
+       "           data_type: variation\n",
+       "    declination_base: 5527\n",
+       "           elevation: 1682\n",
+       "   geodetic_latitude: 40.137\n",
+       "  geodetic_longitude: 254.763\n",
+       "              is_gin: False\n",
+       "      is_intermagnet: False\n",
+       "          processing: ['ObsPy 1.1.0: trim(endtime=UTCDateTime(2018, 10, 10, 23, 59, 45)::fill_value=None::nearest_sample=True::pad=False::starttime=UTCDateTime(2018, 10, 10, 0, 59, 15))']\n",
+       "  sensor_orientation: HDZF\n",
+       "sensor_sampling_rate: 100.0\n",
+       "        station_name: Boulder"
+      ]
+     },
+     "execution_count": 63,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "bou1[0].stats"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 64,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "             network: NT\n",
+       "             station: BOU\n",
+       "            location: R0\n",
+       "             channel: MVH\n",
+       "           starttime: 2018-10-10T01:00:00.000000Z\n",
+       "             endtime: 2018-10-10T23:59:00.000000Z\n",
+       "       sampling_rate: 0.016666666666666666\n",
+       "               delta: 60.0\n",
+       "                npts: 1380\n",
+       "               calib: 1.0\n",
+       "         agency_name: United States Geological Survey (USGS)\n",
+       "   conditions_of_use: The Conditions of Use for data provided through INTERMAGNET and acknowledgement templates can be found at www.intermagnet.org\n",
+       "       data_interval: second\n",
+       "  data_interval_type: Average 1-Second\n",
+       "           data_type: variation\n",
+       "    declination_base: 5527\n",
+       "           elevation: 1682\n",
+       "   geodetic_latitude: 40.137\n",
+       "  geodetic_longitude: 254.763\n",
+       "              is_gin: False\n",
+       "      is_intermagnet: False\n",
+       "  sensor_orientation: HDZF\n",
+       "sensor_sampling_rate: 100.0\n",
+       "        station_name: Boulder"
+      ]
+     },
+     "execution_count": 64,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "bouf[0].stats"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "20811.804588285882"
+      ]
+     },
+     "execution_count": 20,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "bouf[0].data[-1]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "20816.305334453187"
+      ]
+     },
+     "execution_count": 21,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "bouf[0].data[0]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 106,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "82741"
+      ]
+     },
+     "execution_count": 106,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "82831-90"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 107,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "1379.0166666666667"
+      ]
+     },
+     "execution_count": 107,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "82741/60"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 108,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "1377.0"
+      ]
+     },
+     "execution_count": 108,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "82620/60"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 109,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([0.0000e+00, 1.0000e+00, 2.0000e+00, ..., 8.2828e+04, 8.2829e+04,\n",
+       "       8.2830e+04])"
+      ]
+     },
+     "execution_count": 109,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "bou1[0].times()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 123,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "1379.0166666666667"
+      ]
+     },
+     "execution_count": 123,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "(82831-90)/60"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 111,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0"
+      ]
+     },
+     "execution_count": 111,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "np.isnan(bou1[0].data).sum()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 112,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0"
+      ]
+     },
+     "execution_count": 112,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "np.isnan(bouf[0].data).sum()"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": null,
diff --git a/docs/algorithms/Filter_notes.ipynb b/docs/algorithms/Filter_notes.ipynb
index 2dfa50651..9b35c85b8 100644
--- a/docs/algorithms/Filter_notes.ipynb
+++ b/docs/algorithms/Filter_notes.ipynb
@@ -6,8 +6,8 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "#%matplotlib inline\n",
-    "%matplotlib notebook\n",
+    "%matplotlib inline\n",
+    "#%matplotlib notebook\n",
     "\n",
     "import matplotlib as mp\n",
     "\n",
@@ -91,7 +91,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 75,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -107,7306 +107,1089 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 76,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[<matplotlib.lines.Line2D at 0x1c25fa6d68>]"
+      ]
+     },
+     "execution_count": 76,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "pl.plot(t,h.data)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 77,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[<matplotlib.lines.Line2D at 0x1c2606d400>]"
+      ]
+     },
+     "execution_count": 77,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "pl.plot(t,e.data)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 78,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[<matplotlib.lines.Line2D at 0x1c260bde10>]"
+      ]
+     },
+     "execution_count": 78,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "pl.plot(t,z.data)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 79,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "one_minute_gauss_filter=sps.get_window(Nx=91,window=('gaussian', 15.8734))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 80,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[<matplotlib.lines.Line2D at 0x1c2571b048>]"
+      ]
+     },
+     "execution_count": 80,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "one_minute_gauss_filter=one_minute_gauss_filter/sum(one_minute_gauss_filter)\n",
+    "pl.plot(one_minute_gauss_filter)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 81,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "t_filt = np.linspace(0,len(h.data)-91,901)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 82,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([  0.,   1.,   2.,   3.,   4.,   5.,   6.,   7.,   8.,   9.,  10.,\n",
+       "        11.,  12.,  13.,  14.,  15.,  16.,  17.,  18.,  19.,  20.,  21.,\n",
+       "        22.,  23.,  24.,  25.,  26.,  27.,  28.,  29.,  30.,  31.,  32.,\n",
+       "        33.,  34.,  35.,  36.,  37.,  38.,  39.,  40.,  41.,  42.,  43.,\n",
+       "        44.,  45.,  46.,  47.,  48.,  49.,  50.,  51.,  52.,  53.,  54.,\n",
+       "        55.,  56.,  57.,  58.,  59.,  60.,  61.,  62.,  63.,  64.,  65.,\n",
+       "        66.,  67.,  68.,  69.,  70.,  71.,  72.,  73.,  74.,  75.,  76.,\n",
+       "        77.,  78.,  79.,  80.,  81.,  82.,  83.,  84.,  85.,  86.,  87.,\n",
+       "        88.,  89.,  90.,  91.,  92.,  93.,  94.,  95.,  96.,  97.,  98.,\n",
+       "        99., 100., 101., 102., 103., 104., 105., 106., 107., 108., 109.,\n",
+       "       110., 111., 112., 113., 114., 115., 116., 117., 118., 119., 120.,\n",
+       "       121., 122., 123., 124., 125., 126., 127., 128., 129., 130., 131.,\n",
+       "       132., 133., 134., 135., 136., 137., 138., 139., 140., 141., 142.,\n",
+       "       143., 144., 145., 146., 147., 148., 149., 150., 151., 152., 153.,\n",
+       "       154., 155., 156., 157., 158., 159., 160., 161., 162., 163., 164.,\n",
+       "       165., 166., 167., 168., 169., 170., 171., 172., 173., 174., 175.,\n",
+       "       176., 177., 178., 179., 180., 181., 182., 183., 184., 185., 186.,\n",
+       "       187., 188., 189., 190., 191., 192., 193., 194., 195., 196., 197.,\n",
+       "       198., 199., 200., 201., 202., 203., 204., 205., 206., 207., 208.,\n",
+       "       209., 210., 211., 212., 213., 214., 215., 216., 217., 218., 219.,\n",
+       "       220., 221., 222., 223., 224., 225., 226., 227., 228., 229., 230.,\n",
+       "       231., 232., 233., 234., 235., 236., 237., 238., 239., 240., 241.,\n",
+       "       242., 243., 244., 245., 246., 247., 248., 249., 250., 251., 252.,\n",
+       "       253., 254., 255., 256., 257., 258., 259., 260., 261., 262., 263.,\n",
+       "       264., 265., 266., 267., 268., 269., 270., 271., 272., 273., 274.,\n",
+       "       275., 276., 277., 278., 279., 280., 281., 282., 283., 284., 285.,\n",
+       "       286., 287., 288., 289., 290., 291., 292., 293., 294., 295., 296.,\n",
+       "       297., 298., 299., 300., 301., 302., 303., 304., 305., 306., 307.,\n",
+       "       308., 309., 310., 311., 312., 313., 314., 315., 316., 317., 318.,\n",
+       "       319., 320., 321., 322., 323., 324., 325., 326., 327., 328., 329.,\n",
+       "       330., 331., 332., 333., 334., 335., 336., 337., 338., 339., 340.,\n",
+       "       341., 342., 343., 344., 345., 346., 347., 348., 349., 350., 351.,\n",
+       "       352., 353., 354., 355., 356., 357., 358., 359., 360., 361., 362.,\n",
+       "       363., 364., 365., 366., 367., 368., 369., 370., 371., 372., 373.,\n",
+       "       374., 375., 376., 377., 378., 379., 380., 381., 382., 383., 384.,\n",
+       "       385., 386., 387., 388., 389., 390., 391., 392., 393., 394., 395.,\n",
+       "       396., 397., 398., 399., 400., 401., 402., 403., 404., 405., 406.,\n",
+       "       407., 408., 409., 410., 411., 412., 413., 414., 415., 416., 417.,\n",
+       "       418., 419., 420., 421., 422., 423., 424., 425., 426., 427., 428.,\n",
+       "       429., 430., 431., 432., 433., 434., 435., 436., 437., 438., 439.,\n",
+       "       440., 441., 442., 443., 444., 445., 446., 447., 448., 449., 450.,\n",
+       "       451., 452., 453., 454., 455., 456., 457., 458., 459., 460., 461.,\n",
+       "       462., 463., 464., 465., 466., 467., 468., 469., 470., 471., 472.,\n",
+       "       473., 474., 475., 476., 477., 478., 479., 480., 481., 482., 483.,\n",
+       "       484., 485., 486., 487., 488., 489., 490., 491., 492., 493., 494.,\n",
+       "       495., 496., 497., 498., 499., 500., 501., 502., 503., 504., 505.,\n",
+       "       506., 507., 508., 509., 510., 511., 512., 513., 514., 515., 516.,\n",
+       "       517., 518., 519., 520., 521., 522., 523., 524., 525., 526., 527.,\n",
+       "       528., 529., 530., 531., 532., 533., 534., 535., 536., 537., 538.,\n",
+       "       539., 540., 541., 542., 543., 544., 545., 546., 547., 548., 549.,\n",
+       "       550., 551., 552., 553., 554., 555., 556., 557., 558., 559., 560.,\n",
+       "       561., 562., 563., 564., 565., 566., 567., 568., 569., 570., 571.,\n",
+       "       572., 573., 574., 575., 576., 577., 578., 579., 580., 581., 582.,\n",
+       "       583., 584., 585., 586., 587., 588., 589., 590., 591., 592., 593.,\n",
+       "       594., 595., 596., 597., 598., 599., 600., 601., 602., 603., 604.,\n",
+       "       605., 606., 607., 608., 609., 610., 611., 612., 613., 614., 615.,\n",
+       "       616., 617., 618., 619., 620., 621., 622., 623., 624., 625., 626.,\n",
+       "       627., 628., 629., 630., 631., 632., 633., 634., 635., 636., 637.,\n",
+       "       638., 639., 640., 641., 642., 643., 644., 645., 646., 647., 648.,\n",
+       "       649., 650., 651., 652., 653., 654., 655., 656., 657., 658., 659.,\n",
+       "       660., 661., 662., 663., 664., 665., 666., 667., 668., 669., 670.,\n",
+       "       671., 672., 673., 674., 675., 676., 677., 678., 679., 680., 681.,\n",
+       "       682., 683., 684., 685., 686., 687., 688., 689., 690., 691., 692.,\n",
+       "       693., 694., 695., 696., 697., 698., 699., 700., 701., 702., 703.,\n",
+       "       704., 705., 706., 707., 708., 709., 710., 711., 712., 713., 714.,\n",
+       "       715., 716., 717., 718., 719., 720., 721., 722., 723., 724., 725.,\n",
+       "       726., 727., 728., 729., 730., 731., 732., 733., 734., 735., 736.,\n",
+       "       737., 738., 739., 740., 741., 742., 743., 744., 745., 746., 747.,\n",
+       "       748., 749., 750., 751., 752., 753., 754., 755., 756., 757., 758.,\n",
+       "       759., 760., 761., 762., 763., 764., 765., 766., 767., 768., 769.,\n",
+       "       770., 771., 772., 773., 774., 775., 776., 777., 778., 779., 780.,\n",
+       "       781., 782., 783., 784., 785., 786., 787., 788., 789., 790., 791.,\n",
+       "       792., 793., 794., 795., 796., 797., 798., 799., 800., 801., 802.,\n",
+       "       803., 804., 805., 806., 807., 808., 809., 810., 811., 812., 813.,\n",
+       "       814., 815., 816., 817., 818., 819., 820., 821., 822., 823., 824.,\n",
+       "       825., 826., 827., 828., 829., 830., 831., 832., 833., 834., 835.,\n",
+       "       836., 837., 838., 839., 840., 841., 842., 843., 844., 845., 846.,\n",
+       "       847., 848., 849., 850., 851., 852., 853., 854., 855., 856., 857.,\n",
+       "       858., 859., 860., 861., 862., 863., 864., 865., 866., 867., 868.,\n",
+       "       869., 870., 871., 872., 873., 874., 875., 876., 877., 878., 879.,\n",
+       "       880., 881., 882., 883., 884., 885., 886., 887., 888., 889., 890.,\n",
+       "       891., 892., 893., 894., 895., 896., 897., 898., 899., 900.])"
+      ]
+     },
+     "execution_count": 82,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "t_filt"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 83,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "901"
+      ]
+     },
+     "execution_count": 83,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "t_filt.size"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 84,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "991"
+      ]
+     },
+     "execution_count": 84,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "t.size"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 85,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "hf = np.ones_like(t_filt)\n",
+    "ef = np.ones_like(t_filt)\n",
+    "zf = np.ones_like(t_filt)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 86,
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "TypeError",
+     "evalue": "'numpy.float64' object is not iterable",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
+      "\u001b[0;32m<ipython-input-86-1f8b0065d365>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;32mfor\u001b[0m \u001b[0mi\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mt\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mt_filt\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      2\u001b[0m     \u001b[0mt\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mt\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m     \u001b[0mhf\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mone_minute_gauss_filter\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mh\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0;36m60\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0;36m60\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m91\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;31mTypeError\u001b[0m: 'numpy.float64' object is not iterable"
+     ]
+    }
+   ],
+   "source": [
+    "for i, t in t_filt:\n",
+    "    t = np.int(t)\n",
+    "    hf[i] = np.dot(one_minute_gauss_filter, h.data[np.int(i*60):np.int(i*60+91)])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 87,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([  0.,   1.,   2.,   3.,   4.,   5.,   6.,   7.,   8.,   9.,  10.,\n",
+       "        11.,  12.,  13.,  14.,  15.,  16.,  17.,  18.,  19.,  20.,  21.,\n",
+       "        22.,  23.,  24.,  25.,  26.,  27.,  28.,  29.,  30.,  31.,  32.,\n",
+       "        33.,  34.,  35.,  36.,  37.,  38.,  39.,  40.,  41.,  42.,  43.,\n",
+       "        44.,  45.,  46.,  47.,  48.,  49.,  50.,  51.,  52.,  53.,  54.,\n",
+       "        55.,  56.,  57.,  58.,  59.,  60.,  61.,  62.,  63.,  64.,  65.,\n",
+       "        66.,  67.,  68.,  69.,  70.,  71.,  72.,  73.,  74.,  75.,  76.,\n",
+       "        77.,  78.,  79.,  80.,  81.,  82.,  83.,  84.,  85.,  86.,  87.,\n",
+       "        88.,  89.,  90.,  91.,  92.,  93.,  94.,  95.,  96.,  97.,  98.,\n",
+       "        99., 100., 101., 102., 103., 104., 105., 106., 107., 108., 109.,\n",
+       "       110., 111., 112., 113., 114., 115., 116., 117., 118., 119., 120.,\n",
+       "       121., 122., 123., 124., 125., 126., 127., 128., 129., 130., 131.,\n",
+       "       132., 133., 134., 135., 136., 137., 138., 139., 140., 141., 142.,\n",
+       "       143., 144., 145., 146., 147., 148., 149., 150., 151., 152., 153.,\n",
+       "       154., 155., 156., 157., 158., 159., 160., 161., 162., 163., 164.,\n",
+       "       165., 166., 167., 168., 169., 170., 171., 172., 173., 174., 175.,\n",
+       "       176., 177., 178., 179., 180., 181., 182., 183., 184., 185., 186.,\n",
+       "       187., 188., 189., 190., 191., 192., 193., 194., 195., 196., 197.,\n",
+       "       198., 199., 200., 201., 202., 203., 204., 205., 206., 207., 208.,\n",
+       "       209., 210., 211., 212., 213., 214., 215., 216., 217., 218., 219.,\n",
+       "       220., 221., 222., 223., 224., 225., 226., 227., 228., 229., 230.,\n",
+       "       231., 232., 233., 234., 235., 236., 237., 238., 239., 240., 241.,\n",
+       "       242., 243., 244., 245., 246., 247., 248., 249., 250., 251., 252.,\n",
+       "       253., 254., 255., 256., 257., 258., 259., 260., 261., 262., 263.,\n",
+       "       264., 265., 266., 267., 268., 269., 270., 271., 272., 273., 274.,\n",
+       "       275., 276., 277., 278., 279., 280., 281., 282., 283., 284., 285.,\n",
+       "       286., 287., 288., 289., 290., 291., 292., 293., 294., 295., 296.,\n",
+       "       297., 298., 299., 300., 301., 302., 303., 304., 305., 306., 307.,\n",
+       "       308., 309., 310., 311., 312., 313., 314., 315., 316., 317., 318.,\n",
+       "       319., 320., 321., 322., 323., 324., 325., 326., 327., 328., 329.,\n",
+       "       330., 331., 332., 333., 334., 335., 336., 337., 338., 339., 340.,\n",
+       "       341., 342., 343., 344., 345., 346., 347., 348., 349., 350., 351.,\n",
+       "       352., 353., 354., 355., 356., 357., 358., 359., 360., 361., 362.,\n",
+       "       363., 364., 365., 366., 367., 368., 369., 370., 371., 372., 373.,\n",
+       "       374., 375., 376., 377., 378., 379., 380., 381., 382., 383., 384.,\n",
+       "       385., 386., 387., 388., 389., 390., 391., 392., 393., 394., 395.,\n",
+       "       396., 397., 398., 399., 400., 401., 402., 403., 404., 405., 406.,\n",
+       "       407., 408., 409., 410., 411., 412., 413., 414., 415., 416., 417.,\n",
+       "       418., 419., 420., 421., 422., 423., 424., 425., 426., 427., 428.,\n",
+       "       429., 430., 431., 432., 433., 434., 435., 436., 437., 438., 439.,\n",
+       "       440., 441., 442., 443., 444., 445., 446., 447., 448., 449., 450.,\n",
+       "       451., 452., 453., 454., 455., 456., 457., 458., 459., 460., 461.,\n",
+       "       462., 463., 464., 465., 466., 467., 468., 469., 470., 471., 472.,\n",
+       "       473., 474., 475., 476., 477., 478., 479., 480., 481., 482., 483.,\n",
+       "       484., 485., 486., 487., 488., 489., 490., 491., 492., 493., 494.,\n",
+       "       495., 496., 497., 498., 499., 500., 501., 502., 503., 504., 505.,\n",
+       "       506., 507., 508., 509., 510., 511., 512., 513., 514., 515., 516.,\n",
+       "       517., 518., 519., 520., 521., 522., 523., 524., 525., 526., 527.,\n",
+       "       528., 529., 530., 531., 532., 533., 534., 535., 536., 537., 538.,\n",
+       "       539., 540., 541., 542., 543., 544., 545., 546., 547., 548., 549.,\n",
+       "       550., 551., 552., 553., 554., 555., 556., 557., 558., 559., 560.,\n",
+       "       561., 562., 563., 564., 565., 566., 567., 568., 569., 570., 571.,\n",
+       "       572., 573., 574., 575., 576., 577., 578., 579., 580., 581., 582.,\n",
+       "       583., 584., 585., 586., 587., 588., 589., 590., 591., 592., 593.,\n",
+       "       594., 595., 596., 597., 598., 599., 600., 601., 602., 603., 604.,\n",
+       "       605., 606., 607., 608., 609., 610., 611., 612., 613., 614., 615.,\n",
+       "       616., 617., 618., 619., 620., 621., 622., 623., 624., 625., 626.,\n",
+       "       627., 628., 629., 630., 631., 632., 633., 634., 635., 636., 637.,\n",
+       "       638., 639., 640., 641., 642., 643., 644., 645., 646., 647., 648.,\n",
+       "       649., 650., 651., 652., 653., 654., 655., 656., 657., 658., 659.,\n",
+       "       660., 661., 662., 663., 664., 665., 666., 667., 668., 669., 670.,\n",
+       "       671., 672., 673., 674., 675., 676., 677., 678., 679., 680., 681.,\n",
+       "       682., 683., 684., 685., 686., 687., 688., 689., 690., 691., 692.,\n",
+       "       693., 694., 695., 696., 697., 698., 699., 700., 701., 702., 703.,\n",
+       "       704., 705., 706., 707., 708., 709., 710., 711., 712., 713., 714.,\n",
+       "       715., 716., 717., 718., 719., 720., 721., 722., 723., 724., 725.,\n",
+       "       726., 727., 728., 729., 730., 731., 732., 733., 734., 735., 736.,\n",
+       "       737., 738., 739., 740., 741., 742., 743., 744., 745., 746., 747.,\n",
+       "       748., 749., 750., 751., 752., 753., 754., 755., 756., 757., 758.,\n",
+       "       759., 760., 761., 762., 763., 764., 765., 766., 767., 768., 769.,\n",
+       "       770., 771., 772., 773., 774., 775., 776., 777., 778., 779., 780.,\n",
+       "       781., 782., 783., 784., 785., 786., 787., 788., 789., 790., 791.,\n",
+       "       792., 793., 794., 795., 796., 797., 798., 799., 800., 801., 802.,\n",
+       "       803., 804., 805., 806., 807., 808., 809., 810., 811., 812., 813.,\n",
+       "       814., 815., 816., 817., 818., 819., 820., 821., 822., 823., 824.,\n",
+       "       825., 826., 827., 828., 829., 830., 831., 832., 833., 834., 835.,\n",
+       "       836., 837., 838., 839., 840., 841., 842., 843., 844., 845., 846.,\n",
+       "       847., 848., 849., 850., 851., 852., 853., 854., 855., 856., 857.,\n",
+       "       858., 859., 860., 861., 862., 863., 864., 865., 866., 867., 868.,\n",
+       "       869., 870., 871., 872., 873., 874., 875., 876., 877., 878., 879.,\n",
+       "       880., 881., 882., 883., 884., 885., 886., 887., 888., 889., 890.,\n",
+       "       891., 892., 893., 894., 895., 896., 897., 898., 899., 900.])"
+      ]
+     },
+     "execution_count": 87,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "i_filt_s = t_filt\n",
+    "i_filt_e = t_filt + 90\n",
+    "i_filt_s"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 88,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([ 90.,  91.,  92.,  93.,  94.,  95.,  96.,  97.,  98.,  99., 100.,\n",
+       "       101., 102., 103., 104., 105., 106., 107., 108., 109., 110., 111.,\n",
+       "       112., 113., 114., 115., 116., 117., 118., 119., 120., 121., 122.,\n",
+       "       123., 124., 125., 126., 127., 128., 129., 130., 131., 132., 133.,\n",
+       "       134., 135., 136., 137., 138., 139., 140., 141., 142., 143., 144.,\n",
+       "       145., 146., 147., 148., 149., 150., 151., 152., 153., 154., 155.,\n",
+       "       156., 157., 158., 159., 160., 161., 162., 163., 164., 165., 166.,\n",
+       "       167., 168., 169., 170., 171., 172., 173., 174., 175., 176., 177.,\n",
+       "       178., 179., 180., 181., 182., 183., 184., 185., 186., 187., 188.,\n",
+       "       189., 190., 191., 192., 193., 194., 195., 196., 197., 198., 199.,\n",
+       "       200., 201., 202., 203., 204., 205., 206., 207., 208., 209., 210.,\n",
+       "       211., 212., 213., 214., 215., 216., 217., 218., 219., 220., 221.,\n",
+       "       222., 223., 224., 225., 226., 227., 228., 229., 230., 231., 232.,\n",
+       "       233., 234., 235., 236., 237., 238., 239., 240., 241., 242., 243.,\n",
+       "       244., 245., 246., 247., 248., 249., 250., 251., 252., 253., 254.,\n",
+       "       255., 256., 257., 258., 259., 260., 261., 262., 263., 264., 265.,\n",
+       "       266., 267., 268., 269., 270., 271., 272., 273., 274., 275., 276.,\n",
+       "       277., 278., 279., 280., 281., 282., 283., 284., 285., 286., 287.,\n",
+       "       288., 289., 290., 291., 292., 293., 294., 295., 296., 297., 298.,\n",
+       "       299., 300., 301., 302., 303., 304., 305., 306., 307., 308., 309.,\n",
+       "       310., 311., 312., 313., 314., 315., 316., 317., 318., 319., 320.,\n",
+       "       321., 322., 323., 324., 325., 326., 327., 328., 329., 330., 331.,\n",
+       "       332., 333., 334., 335., 336., 337., 338., 339., 340., 341., 342.,\n",
+       "       343., 344., 345., 346., 347., 348., 349., 350., 351., 352., 353.,\n",
+       "       354., 355., 356., 357., 358., 359., 360., 361., 362., 363., 364.,\n",
+       "       365., 366., 367., 368., 369., 370., 371., 372., 373., 374., 375.,\n",
+       "       376., 377., 378., 379., 380., 381., 382., 383., 384., 385., 386.,\n",
+       "       387., 388., 389., 390., 391., 392., 393., 394., 395., 396., 397.,\n",
+       "       398., 399., 400., 401., 402., 403., 404., 405., 406., 407., 408.,\n",
+       "       409., 410., 411., 412., 413., 414., 415., 416., 417., 418., 419.,\n",
+       "       420., 421., 422., 423., 424., 425., 426., 427., 428., 429., 430.,\n",
+       "       431., 432., 433., 434., 435., 436., 437., 438., 439., 440., 441.,\n",
+       "       442., 443., 444., 445., 446., 447., 448., 449., 450., 451., 452.,\n",
+       "       453., 454., 455., 456., 457., 458., 459., 460., 461., 462., 463.,\n",
+       "       464., 465., 466., 467., 468., 469., 470., 471., 472., 473., 474.,\n",
+       "       475., 476., 477., 478., 479., 480., 481., 482., 483., 484., 485.,\n",
+       "       486., 487., 488., 489., 490., 491., 492., 493., 494., 495., 496.,\n",
+       "       497., 498., 499., 500., 501., 502., 503., 504., 505., 506., 507.,\n",
+       "       508., 509., 510., 511., 512., 513., 514., 515., 516., 517., 518.,\n",
+       "       519., 520., 521., 522., 523., 524., 525., 526., 527., 528., 529.,\n",
+       "       530., 531., 532., 533., 534., 535., 536., 537., 538., 539., 540.,\n",
+       "       541., 542., 543., 544., 545., 546., 547., 548., 549., 550., 551.,\n",
+       "       552., 553., 554., 555., 556., 557., 558., 559., 560., 561., 562.,\n",
+       "       563., 564., 565., 566., 567., 568., 569., 570., 571., 572., 573.,\n",
+       "       574., 575., 576., 577., 578., 579., 580., 581., 582., 583., 584.,\n",
+       "       585., 586., 587., 588., 589., 590., 591., 592., 593., 594., 595.,\n",
+       "       596., 597., 598., 599., 600., 601., 602., 603., 604., 605., 606.,\n",
+       "       607., 608., 609., 610., 611., 612., 613., 614., 615., 616., 617.,\n",
+       "       618., 619., 620., 621., 622., 623., 624., 625., 626., 627., 628.,\n",
+       "       629., 630., 631., 632., 633., 634., 635., 636., 637., 638., 639.,\n",
+       "       640., 641., 642., 643., 644., 645., 646., 647., 648., 649., 650.,\n",
+       "       651., 652., 653., 654., 655., 656., 657., 658., 659., 660., 661.,\n",
+       "       662., 663., 664., 665., 666., 667., 668., 669., 670., 671., 672.,\n",
+       "       673., 674., 675., 676., 677., 678., 679., 680., 681., 682., 683.,\n",
+       "       684., 685., 686., 687., 688., 689., 690., 691., 692., 693., 694.,\n",
+       "       695., 696., 697., 698., 699., 700., 701., 702., 703., 704., 705.,\n",
+       "       706., 707., 708., 709., 710., 711., 712., 713., 714., 715., 716.,\n",
+       "       717., 718., 719., 720., 721., 722., 723., 724., 725., 726., 727.,\n",
+       "       728., 729., 730., 731., 732., 733., 734., 735., 736., 737., 738.,\n",
+       "       739., 740., 741., 742., 743., 744., 745., 746., 747., 748., 749.,\n",
+       "       750., 751., 752., 753., 754., 755., 756., 757., 758., 759., 760.,\n",
+       "       761., 762., 763., 764., 765., 766., 767., 768., 769., 770., 771.,\n",
+       "       772., 773., 774., 775., 776., 777., 778., 779., 780., 781., 782.,\n",
+       "       783., 784., 785., 786., 787., 788., 789., 790., 791., 792., 793.,\n",
+       "       794., 795., 796., 797., 798., 799., 800., 801., 802., 803., 804.,\n",
+       "       805., 806., 807., 808., 809., 810., 811., 812., 813., 814., 815.,\n",
+       "       816., 817., 818., 819., 820., 821., 822., 823., 824., 825., 826.,\n",
+       "       827., 828., 829., 830., 831., 832., 833., 834., 835., 836., 837.,\n",
+       "       838., 839., 840., 841., 842., 843., 844., 845., 846., 847., 848.,\n",
+       "       849., 850., 851., 852., 853., 854., 855., 856., 857., 858., 859.,\n",
+       "       860., 861., 862., 863., 864., 865., 866., 867., 868., 869., 870.,\n",
+       "       871., 872., 873., 874., 875., 876., 877., 878., 879., 880., 881.,\n",
+       "       882., 883., 884., 885., 886., 887., 888., 889., 890., 891., 892.,\n",
+       "       893., 894., 895., 896., 897., 898., 899., 900., 901., 902., 903.,\n",
+       "       904., 905., 906., 907., 908., 909., 910., 911., 912., 913., 914.,\n",
+       "       915., 916., 917., 918., 919., 920., 921., 922., 923., 924., 925.,\n",
+       "       926., 927., 928., 929., 930., 931., 932., 933., 934., 935., 936.,\n",
+       "       937., 938., 939., 940., 941., 942., 943., 944., 945., 946., 947.,\n",
+       "       948., 949., 950., 951., 952., 953., 954., 955., 956., 957., 958.,\n",
+       "       959., 960., 961., 962., 963., 964., 965., 966., 967., 968., 969.,\n",
+       "       970., 971., 972., 973., 974., 975., 976., 977., 978., 979., 980.,\n",
+       "       981., 982., 983., 984., 985., 986., 987., 988., 989., 990.])"
+      ]
+     },
+     "execution_count": 88,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "i_filt_e"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 89,
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "TypeError",
+     "evalue": "'int' object is not iterable",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
+      "\u001b[0;32m<ipython-input-89-6664f3db0770>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;32mfor\u001b[0m \u001b[0mi\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mhf\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      2\u001b[0m     \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;31mTypeError\u001b[0m: 'int' object is not iterable"
+     ]
+    }
+   ],
+   "source": [
+    "for i in len(hf):\n",
+    "    print(i)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 90,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from numpy.lib import stride_tricks as npls"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 91,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(901, 91)"
+      ]
+     },
+     "execution_count": 91,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "window = 91\n",
+    "shape = h.data.shape[:-1] + (h.data.shape[-1] - window + 1, window)\n",
+    "strides = h.data.strides + (h.data.strides[-1],)\n",
+    "as_s = npls.as_strided(h.data, shape=shape, strides=strides, writeable=False)\n",
+    "as_s.shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 92,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(901, 91)"
+      ]
+     },
+     "execution_count": 92,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 93,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(8, 8)"
+      ]
+     },
+     "execution_count": 93,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "strides"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 94,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([[9145.616, 9145.659, 9145.698, ..., 9147.489, 9147.453, 9147.415],\n",
+       "       [9146.457, 9146.659, 9146.864, ..., 9152.84 , 9152.933, 9153.046],\n",
+       "       [9149.807, 9149.887, 9149.958, ..., 9151.775, 9151.762, 9151.772],\n",
+       "       ...,\n",
+       "       [9156.414, 9156.362, 9156.33 , ..., 9157.791, 9157.746, 9157.662],\n",
+       "       [9157.573, 9157.555, 9157.543, ..., 9157.463, 9157.493, 9157.475],\n",
+       "       [9156.089, 9156.107, 9156.129, ..., 9158.807, 9158.818, 9158.832]])"
+      ]
+     },
+     "execution_count": 94,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "as_s[::60]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 95,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "hf2 = np.dot(one_minute_gauss_filter, as_s[::].T)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 96,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([9146.3294147 , 9146.34727413, 9146.36700672, 9146.38871274,\n",
+       "       9146.41245012, 9146.43826252, 9146.46617488, 9146.4961749 ,\n",
+       "       9146.52823637, 9146.5623157 , 9146.59832795, 9146.63614451,\n",
+       "       9146.6756066 , 9146.71654228, 9146.7587768 , 9146.8021385 ,\n",
+       "       9146.84643758, 9146.89145024, 9146.93693953, 9146.98268004,\n",
+       "       9147.0284517 , 9147.0740595 , 9147.11933223, 9147.16408598,\n",
+       "       9147.20814227, 9147.25135698, 9147.29362312, 9147.33486287,\n",
+       "       9147.37501995, 9147.41406655, 9147.45200071, 9147.48884501,\n",
+       "       9147.52464808, 9147.55946916, 9147.59339714, 9147.62656116,\n",
+       "       9147.65912327, 9147.69125836, 9147.72313398, 9147.75492814,\n",
+       "       9147.78682483, 9147.81901966, 9147.85172944, 9147.88516094,\n",
+       "       9147.91950993, 9147.95495996, 9147.9916889 , 9148.02987329,\n",
+       "       9148.06966334, 9148.11119517, 9148.15460282, 9148.20000821,\n",
+       "       9148.24750588, 9148.29716011, 9148.34902764, 9148.40314728,\n",
+       "       9148.45955299, 9148.5182719 , 9148.57929871, 9148.64261179,\n",
+       "       9148.70819126, 9148.77600591, 9148.84600612, 9148.91813911,\n",
+       "       9148.99235183, 9149.06857916, 9149.14674233, 9149.22676679,\n",
+       "       9149.30857443, 9149.39208481, 9149.47721967, 9149.56389017,\n",
+       "       9149.65200735, 9149.74148146, 9149.83223975, 9149.92419547,\n",
+       "       9150.0172389 , 9150.11127348, 9150.20620308, 9150.30192348,\n",
+       "       9150.3983424 , 9150.4953694 , 9150.59288013, 9150.69076012,\n",
+       "       9150.78891849, 9150.88723482, 9150.98556927, 9151.08378862,\n",
+       "       9151.18175878, 9151.27933976, 9151.37638912, 9151.47276453,\n",
+       "       9151.56830513, 9151.66282852, 9151.75616281, 9151.8481503 ,\n",
+       "       9151.93862663, 9152.02742555, 9152.11437783, 9152.19929249,\n",
+       "       9152.28196404, 9152.36221976, 9152.43991102, 9152.51487312,\n",
+       "       9152.58694163, 9152.65594849, 9152.72173336, 9152.78415666,\n",
+       "       9152.84308025, 9152.8983711 , 9152.94991059, 9152.99759991,\n",
+       "       9153.04135303, 9153.08109105, 9153.11676563, 9153.14833557,\n",
+       "       9153.17575841, 9153.19902477, 9153.21815123, 9153.23318014,\n",
+       "       9153.2441662 , 9153.25115738, 9153.25421474, 9153.25342434,\n",
+       "       9153.24890119, 9153.24077559, 9153.22918075, 9153.21424296,\n",
+       "       9153.19610037, 9153.17490982, 9153.15083191, 9153.12405065,\n",
+       "       9153.09476085, 9153.06313909, 9153.02936378, 9152.9935991 ,\n",
+       "       9152.95600412, 9152.91675664, 9152.87603556, 9152.83400635,\n",
+       "       9152.79080552, 9152.74655996, 9152.70139306, 9152.65542151,\n",
+       "       9152.60875812, 9152.56150152, 9152.51373655, 9152.46551673,\n",
+       "       9152.41689245, 9152.36792742, 9152.31866951, 9152.26913367,\n",
+       "       9152.21932366, 9152.16925782, 9152.11895131, 9152.06839911,\n",
+       "       9152.01758657, 9151.96650215, 9151.91514015, 9151.86351146,\n",
+       "       9151.81161229, 9151.75941927, 9151.70691397, 9151.65408259,\n",
+       "       9151.60093076, 9151.54747373, 9151.49372966, 9151.43972681,\n",
+       "       9151.38548955, 9151.33102645, 9151.27637207, 9151.2215872 ,\n",
+       "       9151.16671864, 9151.11182499, 9151.05696787, 9151.00219884,\n",
+       "       9150.94759059, 9150.89322982, 9150.83920433, 9150.78559928,\n",
+       "       9150.7324949 , 9150.67997936, 9150.6281303 , 9150.57703561,\n",
+       "       9150.52682015, 9150.47759126, 9150.42942702, 9150.38241424,\n",
+       "       9150.33665364, 9150.29225809, 9150.24933742, 9150.2079954 ,\n",
+       "       9150.16831906, 9150.13039555, 9150.09434076, 9150.06027026,\n",
+       "       9150.02827807, 9149.99843183, 9149.97081415, 9149.94552571,\n",
+       "       9149.92266997, 9149.90236159, 9149.88468784, 9149.86969104,\n",
+       "       9149.8574225 , 9149.84794278, 9149.84133032, 9149.83767784,\n",
+       "       9149.8370098 , 9149.83932201, 9149.84462817, 9149.85293327,\n",
+       "       9149.86424572, 9149.8785707 , 9149.89588695, 9149.91615142,\n",
+       "       9149.93930324, 9149.96526449, 9149.99396031, 9150.02531306,\n",
+       "       9150.05922306, 9150.09557494, 9150.13424385, 9150.1750742 ,\n",
+       "       9150.21789968, 9150.26257864, 9150.30897712, 9150.35693858,\n",
+       "       9150.40628657, 9150.45684196, 9150.50842777, 9150.56088487,\n",
+       "       9150.61406225, 9150.66779349, 9150.72191258, 9150.77627579,\n",
+       "       9150.83074797, 9150.88520113, 9150.93952152, 9150.9936031 ,\n",
+       "       9151.04734904, 9151.10067087, 9151.15349923, 9151.20578561,\n",
+       "       9151.25748365, 9151.30854869, 9151.3589626 , 9151.4087044 ,\n",
+       "       9151.45775133, 9151.50610374, 9151.55376348, 9151.60075791,\n",
+       "       9151.64712976, 9151.69290229, 9151.73808936, 9151.78271216,\n",
+       "       9151.8268044 , 9151.87040878, 9151.91356762, 9151.95631438,\n",
+       "       9151.99867358, 9152.04065486, 9152.08226113, 9152.12351158,\n",
+       "       9152.16441967, 9152.20498882, 9152.24522446, 9152.28512085,\n",
+       "       9152.32466642, 9152.36383623, 9152.40260179, 9152.44094866,\n",
+       "       9152.47885861, 9152.51630764, 9152.5532559 , 9152.58964854,\n",
+       "       9152.62544077, 9152.66060602, 9152.69511503, 9152.72891416,\n",
+       "       9152.76193184, 9152.79411061, 9152.82542771, 9152.85585557,\n",
+       "       9152.88533359, 9152.91379354, 9152.94119019, 9152.9674916 ,\n",
+       "       9152.99267367, 9153.01670699, 9153.03955046, 9153.06116291,\n",
+       "       9153.08150308, 9153.10054882, 9153.11830818, 9153.13478102,\n",
+       "       9153.14996027, 9153.16383384, 9153.17637466, 9153.18760295,\n",
+       "       9153.19756752, 9153.20628772, 9153.21378199, 9153.22008959,\n",
+       "       9153.22524988, 9153.2293041 , 9153.23229074, 9153.23426186,\n",
+       "       9153.23529289, 9153.23544721, 9153.23478221, 9153.23336046,\n",
+       "       9153.23124921, 9153.22851088, 9153.22521649, 9153.22144744,\n",
+       "       9153.21726252, 9153.21270226, 9153.20781335, 9153.20265548,\n",
+       "       9153.1972888 , 9153.19176907, 9153.18612963, 9153.18039362,\n",
+       "       9153.17460315, 9153.16878677, 9153.16294632, 9153.15708628,\n",
+       "       9153.1512156 , 9153.14535173, 9153.13949287, 9153.13361146,\n",
+       "       9153.12769202, 9153.12172608, 9153.11569917, 9153.10959401,\n",
+       "       9153.10339616, 9153.097084  , 9153.09063212, 9153.08400965,\n",
+       "       9153.0771906 , 9153.07015207, 9153.06286425, 9153.0553093 ,\n",
+       "       9153.04747553, 9153.03935548, 9153.03092278, 9153.02214213,\n",
+       "       9153.01300074, 9153.00349429, 9152.99361946, 9152.98337453,\n",
+       "       9152.97275604, 9152.96175392, 9152.95036248, 9152.93858654,\n",
+       "       9152.92643572, 9152.91391813, 9152.90102572, 9152.88774249,\n",
+       "       9152.87407819, 9152.86004573, 9152.84564559, 9152.83088429,\n",
+       "       9152.81576882, 9152.80030687, 9152.78450844, 9152.76838075,\n",
+       "       9152.75192941, 9152.73516676, 9152.71811657, 9152.70081349,\n",
+       "       9152.68328998, 9152.66555331, 9152.64761811, 9152.6295248 ,\n",
+       "       9152.6113035 , 9152.59297131, 9152.57456145, 9152.55611322,\n",
+       "       9152.5376664 , 9152.51926591, 9152.50094579, 9152.4827452 ,\n",
+       "       9152.46470354, 9152.44685356, 9152.42924386, 9152.41193884,\n",
+       "       9152.39499829, 9152.37846951, 9152.36240063, 9152.34685312,\n",
+       "       9152.33189563, 9152.31759037, 9152.30399073, 9152.29116102,\n",
+       "       9152.27917396, 9152.26810501, 9152.25802193, 9152.24898759,\n",
+       "       9152.24107097, 9152.23433787, 9152.2288684 , 9152.22472878,\n",
+       "       9152.22195769, 9152.2206102 , 9152.2207459 , 9152.22240618,\n",
+       "       9152.22564129, 9152.23049364, 9152.2369798 , 9152.24511344,\n",
+       "       9152.25489565, 9152.26632687, 9152.27940101, 9152.29408548,\n",
+       "       9152.31035438, 9152.32817952, 9152.3475092 , 9152.36827961,\n",
+       "       9152.39041223, 9152.41383513, 9152.43848362, 9152.46429633,\n",
+       "       9152.49119538, 9152.51907204, 9152.54783437, 9152.5774084 ,\n",
+       "       9152.60772433, 9152.63871197, 9152.67029159, 9152.70237927,\n",
+       "       9152.73491059, 9152.76783491, 9152.80110388, 9152.8346908 ,\n",
+       "       9152.86857143, 9152.90273106, 9152.93717337, 9152.97189296,\n",
+       "       9153.00689034, 9153.04218709, 9153.07783196, 9153.11388383,\n",
+       "       9153.15039968, 9153.18742787, 9153.22501683, 9153.26322626,\n",
+       "       9153.30212812, 9153.34180717, 9153.38233952, 9153.4237813 ,\n",
+       "       9153.46618585, 9153.50959997, 9153.55405683, 9153.5995865 ,\n",
+       "       9153.64622277, 9153.69398275, 9153.74285957, 9153.7928318 ,\n",
+       "       9153.84387027, 9153.89593078, 9153.94894576, 9154.00283737,\n",
+       "       9154.05751843, 9154.11288258, 9154.16881572, 9154.22519802,\n",
+       "       9154.28189146, 9154.33874413, 9154.39559884, 9154.45229025,\n",
+       "       9154.5086511 , 9154.56452217, 9154.61973869, 9154.67413937,\n",
+       "       9154.72757199, 9154.77986648, 9154.83084589, 9154.8803607 ,\n",
+       "       9154.92828897, 9154.97451658, 9155.01891791, 9155.06137406,\n",
+       "       9155.10179773, 9155.1401078 , 9155.17622663, 9155.21009773,\n",
+       "       9155.24168172, 9155.27093493, 9155.29782046, 9155.32233187,\n",
+       "       9155.34447779, 9155.3642573 , 9155.38167746, 9155.3967807 ,\n",
+       "       9155.40960259, 9155.42016509, 9155.42851765, 9155.43470381,\n",
+       "       9155.43876368, 9155.44076254, 9155.44076946, 9155.43885641,\n",
+       "       9155.43509394, 9155.42955367, 9155.42231175, 9155.41344728,\n",
+       "       9155.40304801, 9155.39119329, 9155.37796796, 9155.36346067,\n",
+       "       9155.34775509, 9155.33096004, 9155.3131756 , 9155.29450329,\n",
+       "       9155.27506805, 9155.25498416, 9155.23436233, 9155.2133202 ,\n",
+       "       9155.19200146, 9155.17055293, 9155.14910305, 9155.12779085,\n",
+       "       9155.1067659 , 9155.08616922, 9155.06613627, 9155.04681598,\n",
+       "       9155.02836435, 9155.0109254 , 9154.99465811, 9154.97971051,\n",
+       "       9154.96619542, 9154.95422052, 9154.94390727, 9154.93538258,\n",
+       "       9154.92875783, 9154.92412398, 9154.92155182, 9154.92109536,\n",
+       "       9154.92281761, 9154.92677952, 9154.93300345, 9154.94149922,\n",
+       "       9154.95227533, 9154.96531699, 9154.98060043, 9154.99809076,\n",
+       "       9155.0177325 , 9155.03946141, 9155.0632018 , 9155.08885734,\n",
+       "       9155.11633226, 9155.14552836, 9155.17633073, 9155.20863268,\n",
+       "       9155.24232394, 9155.27727274, 9155.31335124, 9155.35044521,\n",
+       "       9155.38844298, 9155.42722947, 9155.46668566, 9155.50669759,\n",
+       "       9155.54716588, 9155.58799908, 9155.62911234, 9155.67042555,\n",
+       "       9155.71187354, 9155.75339531, 9155.79493593, 9155.83647059,\n",
+       "       9155.87797022, 9155.91941171, 9155.96078829, 9156.00208437,\n",
+       "       9156.04330315, 9156.08447055, 9156.12559878, 9156.16668882,\n",
+       "       9156.20776667, 9156.24886356, 9156.29000184, 9156.33121012,\n",
+       "       9156.37250709, 9156.41391045, 9156.45543474, 9156.49709961,\n",
+       "       9156.53893285, 9156.58093726, 9156.62309499, 9156.66539641,\n",
+       "       9156.70783205, 9156.75036639, 9156.79296339, 9156.83560226,\n",
+       "       9156.87823703, 9156.92079751, 9156.96319712, 9157.00536311,\n",
+       "       9157.04724769, 9157.08877384, 9157.1298426 , 9157.17036103,\n",
+       "       9157.21022081, 9157.24931153, 9157.28753289, 9157.32478503,\n",
+       "       9157.36094747, 9157.39588991, 9157.42949656, 9157.46165178,\n",
+       "       9157.49225063, 9157.52118918, 9157.54835066, 9157.5736293 ,\n",
+       "       9157.59692742, 9157.61815795, 9157.63724188, 9157.65409038,\n",
+       "       9157.66863124, 9157.68079268, 9157.69051165, 9157.69777037,\n",
+       "       9157.70255069, 9157.7048154 , 9157.70454574, 9157.70175641,\n",
+       "       9157.69647076, 9157.68872519, 9157.67857076, 9157.66603809,\n",
+       "       9157.65117995, 9157.63409197, 9157.61486432, 9157.59359084,\n",
+       "       9157.57038447, 9157.54536789, 9157.51865136, 9157.49035127,\n",
+       "       9157.46061822, 9157.42960419, 9157.39745182, 9157.36431015,\n",
+       "       9157.33033277, 9157.29567289, 9157.2604864 , 9157.22492357,\n",
+       "       9157.18913088, 9157.15325564, 9157.11742628, 9157.0817518 ,\n",
+       "       9157.04635385, 9157.01135441, 9156.97686527, 9156.94297976,\n",
+       "       9156.90976504, 9156.87727405, 9156.84556567, 9156.81469978,\n",
+       "       9156.78471925, 9156.75566174, 9156.72753694, 9156.70032818,\n",
+       "       9156.67402318, 9156.64861023, 9156.6240785 , 9156.60041402,\n",
+       "       9156.57756708, 9156.55547687, 9156.53410771, 9156.51341541,\n",
+       "       9156.49333836, 9156.47381273, 9156.45476666, 9156.43615052,\n",
+       "       9156.41792467, 9156.40002204, 9156.38237063, 9156.36491542,\n",
+       "       9156.34761552, 9156.3304486 , 9156.31338684, 9156.29638872,\n",
+       "       9156.27942873, 9156.26249633, 9156.24558667, 9156.2287156 ,\n",
+       "       9156.21191829, 9156.19522879, 9156.17866731, 9156.16226557,\n",
+       "       9156.14608922, 9156.13022442, 9156.11476199, 9156.09977847,\n",
+       "       9156.08533668, 9156.07152002, 9156.05842657, 9156.04616176,\n",
+       "       9156.03483764, 9156.02454684, 9156.01536094, 9156.00734589,\n",
+       "       9156.00059746, 9155.99520726, 9155.99121699, 9155.98866571,\n",
+       "       9155.98759499, 9155.98803146, 9155.9900193 , 9155.9935882 ,\n",
+       "       9155.99873598, 9156.00545236, 9156.01369843, 9156.02343274,\n",
+       "       9156.03462417, 9156.04722983, 9156.06119199, 9156.07645986,\n",
+       "       9156.09298106, 9156.11070312, 9156.12957786, 9156.14952709,\n",
+       "       9156.17049253, 9156.19243666, 9156.21530317, 9156.23904184,\n",
+       "       9156.26360516, 9156.28895664, 9156.31507828, 9156.34195011,\n",
+       "       9156.36955173, 9156.3978666 , 9156.42687908, 9156.45658616,\n",
+       "       9156.48699079, 9156.51806847, 9156.54980537, 9156.58221248,\n",
+       "       9156.61528791, 9156.64901897, 9156.68340271, 9156.71843021,\n",
+       "       9156.75407963, 9156.79031618, 9156.8270968 , 9156.8643849 ,\n",
+       "       9156.90214494, 9156.94031653, 9156.97881689, 9157.01756593,\n",
+       "       9157.05646693, 9157.09541779, 9157.13432494, 9157.17308781,\n",
+       "       9157.21159945, 9157.24972611, 9157.2873198 , 9157.32426389,\n",
+       "       9157.360453  , 9157.39575422, 9157.43004306, 9157.46321934,\n",
+       "       9157.49517422, 9157.52580466, 9157.5550095 , 9157.58269459,\n",
+       "       9157.60879052, 9157.63323657, 9157.65597552, 9157.67696175,\n",
+       "       9157.69617753, 9157.71360974, 9157.72924745, 9157.74310835,\n",
+       "       9157.7552051 , 9157.76555627, 9157.77421289, 9157.78121643,\n",
+       "       9157.78661802, 9157.7905016 , 9157.79294513, 9157.79400825,\n",
+       "       9157.79375923, 9157.79228362, 9157.78968093, 9157.78606565,\n",
+       "       9157.78154837, 9157.77622157, 9157.77016911, 9157.76347018,\n",
+       "       9157.75620827, 9157.7484731 , 9157.74034054, 9157.73185025,\n",
+       "       9157.72303828, 9157.71396422, 9157.70466818, 9157.69514663,\n",
+       "       9157.68539553, 9157.67539766, 9157.66510675, 9157.65449945,\n",
+       "       9157.64355256, 9157.63221796, 9157.62044594, 9157.60817509,\n",
+       "       9157.59533518, 9157.58185583, 9157.56764971, 9157.55263294,\n",
+       "       9157.53672348, 9157.51985468, 9157.5019831 , 9157.48303713,\n",
+       "       9157.4629457 , 9157.44168372, 9157.41923591, 9157.39558704,\n",
+       "       9157.37074458, 9157.34472033, 9157.31752803, 9157.28920345,\n",
+       "       9157.25980622, 9157.22942504, 9157.19815237, 9157.16608282,\n",
+       "       9157.13335309, 9157.10010647, 9157.06646798, 9157.03258175,\n",
+       "       9156.99862461, 9156.96476211, 9156.93114659, 9156.89795898,\n",
+       "       9156.86538679, 9156.83361153, 9156.80282348, 9156.77319282,\n",
+       "       9156.74486717, 9156.71800158, 9156.69276683, 9156.66932791,\n",
+       "       9156.64781796, 9156.62835085, 9156.6110453 , 9156.59600253,\n",
+       "       9156.58331318, 9156.57306646, 9156.56531908, 9156.56011062,\n",
+       "       9156.55748031, 9156.55745105, 9156.56002435, 9156.56518237,\n",
+       "       9156.57289414, 9156.58313287, 9156.59586476, 9156.61103515,\n",
+       "       9156.62856364, 9156.64836052, 9156.67034745, 9156.69443253,\n",
+       "       9156.72052647, 9156.74854944, 9156.7784076 , 9156.81000603,\n",
+       "       9156.84325196, 9156.87804442, 9156.91429704, 9156.95194393,\n",
+       "       9156.99090445, 9157.03109319, 9157.07245566, 9157.11494547,\n",
+       "       9157.158502  , 9157.20306866, 9157.24859221, 9157.29501682,\n",
+       "       9157.34230991, 9157.39045449, 9157.43942921, 9157.48919742,\n",
+       "       9157.53971217, 9157.59092756, 9157.64280656, 9157.69531364,\n",
+       "       9157.74838729, 9157.8019522 , 9157.85594508, 9157.9102792 ,\n",
+       "       9157.96485336, 9158.01957042, 9158.07430401, 9158.12891716,\n",
+       "       9158.18328275, 9158.23725756, 9158.29069137, 9158.34343053,\n",
+       "       9158.39531688])"
+      ]
+     },
+     "execution_count": 96,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "hf2"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 97,
    "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\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\"];\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"
-    },
-    {
-     "data": {
-      "text/plain": [
-       "[<matplotlib.lines.Line2D at 0x1c27ece630>]"
-      ]
-     },
-     "execution_count": 11,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "pl.plot(t,h.data)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 12,
-   "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\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\"];\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"
-    },
-    {
-     "data": {
-      "text/plain": [
-       "[<matplotlib.lines.Line2D at 0x1c281886d8>]"
-      ]
-     },
-     "execution_count": 12,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "pl.plot(t,e.data)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 13,
-   "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\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\"];\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"
-    },
-    {
-     "data": {
-      "text/plain": [
-       "[<matplotlib.lines.Line2D at 0x1c281dff98>]"
-      ]
-     },
-     "execution_count": 13,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "pl.plot(t,z.data)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 14,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "one_minute_gauss_filter=sps.get_window(Nx=91,window=('gaussian', 15.8734))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 15,
-   "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\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\"];\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"
-    },
-    {
-     "data": {
-      "text/plain": [
-       "[<matplotlib.lines.Line2D at 0x1c286f2320>]"
-      ]
-     },
-     "execution_count": 15,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "one_minute_gauss_filter=one_minute_gauss_filter/sum(one_minute_gauss_filter)\n",
-    "pl.plot(one_minute_gauss_filter)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 16,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "t_filt = np.linspace(0,len(h.data)-91,901)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 17,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "array([  0.,   1.,   2.,   3.,   4.,   5.,   6.,   7.,   8.,   9.,  10.,\n",
-       "        11.,  12.,  13.,  14.,  15.,  16.,  17.,  18.,  19.,  20.,  21.,\n",
-       "        22.,  23.,  24.,  25.,  26.,  27.,  28.,  29.,  30.,  31.,  32.,\n",
-       "        33.,  34.,  35.,  36.,  37.,  38.,  39.,  40.,  41.,  42.,  43.,\n",
-       "        44.,  45.,  46.,  47.,  48.,  49.,  50.,  51.,  52.,  53.,  54.,\n",
-       "        55.,  56.,  57.,  58.,  59.,  60.,  61.,  62.,  63.,  64.,  65.,\n",
-       "        66.,  67.,  68.,  69.,  70.,  71.,  72.,  73.,  74.,  75.,  76.,\n",
-       "        77.,  78.,  79.,  80.,  81.,  82.,  83.,  84.,  85.,  86.,  87.,\n",
-       "        88.,  89.,  90.,  91.,  92.,  93.,  94.,  95.,  96.,  97.,  98.,\n",
-       "        99., 100., 101., 102., 103., 104., 105., 106., 107., 108., 109.,\n",
-       "       110., 111., 112., 113., 114., 115., 116., 117., 118., 119., 120.,\n",
-       "       121., 122., 123., 124., 125., 126., 127., 128., 129., 130., 131.,\n",
-       "       132., 133., 134., 135., 136., 137., 138., 139., 140., 141., 142.,\n",
-       "       143., 144., 145., 146., 147., 148., 149., 150., 151., 152., 153.,\n",
-       "       154., 155., 156., 157., 158., 159., 160., 161., 162., 163., 164.,\n",
-       "       165., 166., 167., 168., 169., 170., 171., 172., 173., 174., 175.,\n",
-       "       176., 177., 178., 179., 180., 181., 182., 183., 184., 185., 186.,\n",
-       "       187., 188., 189., 190., 191., 192., 193., 194., 195., 196., 197.,\n",
-       "       198., 199., 200., 201., 202., 203., 204., 205., 206., 207., 208.,\n",
-       "       209., 210., 211., 212., 213., 214., 215., 216., 217., 218., 219.,\n",
-       "       220., 221., 222., 223., 224., 225., 226., 227., 228., 229., 230.,\n",
-       "       231., 232., 233., 234., 235., 236., 237., 238., 239., 240., 241.,\n",
-       "       242., 243., 244., 245., 246., 247., 248., 249., 250., 251., 252.,\n",
-       "       253., 254., 255., 256., 257., 258., 259., 260., 261., 262., 263.,\n",
-       "       264., 265., 266., 267., 268., 269., 270., 271., 272., 273., 274.,\n",
-       "       275., 276., 277., 278., 279., 280., 281., 282., 283., 284., 285.,\n",
-       "       286., 287., 288., 289., 290., 291., 292., 293., 294., 295., 296.,\n",
-       "       297., 298., 299., 300., 301., 302., 303., 304., 305., 306., 307.,\n",
-       "       308., 309., 310., 311., 312., 313., 314., 315., 316., 317., 318.,\n",
-       "       319., 320., 321., 322., 323., 324., 325., 326., 327., 328., 329.,\n",
-       "       330., 331., 332., 333., 334., 335., 336., 337., 338., 339., 340.,\n",
-       "       341., 342., 343., 344., 345., 346., 347., 348., 349., 350., 351.,\n",
-       "       352., 353., 354., 355., 356., 357., 358., 359., 360., 361., 362.,\n",
-       "       363., 364., 365., 366., 367., 368., 369., 370., 371., 372., 373.,\n",
-       "       374., 375., 376., 377., 378., 379., 380., 381., 382., 383., 384.,\n",
-       "       385., 386., 387., 388., 389., 390., 391., 392., 393., 394., 395.,\n",
-       "       396., 397., 398., 399., 400., 401., 402., 403., 404., 405., 406.,\n",
-       "       407., 408., 409., 410., 411., 412., 413., 414., 415., 416., 417.,\n",
-       "       418., 419., 420., 421., 422., 423., 424., 425., 426., 427., 428.,\n",
-       "       429., 430., 431., 432., 433., 434., 435., 436., 437., 438., 439.,\n",
-       "       440., 441., 442., 443., 444., 445., 446., 447., 448., 449., 450.,\n",
-       "       451., 452., 453., 454., 455., 456., 457., 458., 459., 460., 461.,\n",
-       "       462., 463., 464., 465., 466., 467., 468., 469., 470., 471., 472.,\n",
-       "       473., 474., 475., 476., 477., 478., 479., 480., 481., 482., 483.,\n",
-       "       484., 485., 486., 487., 488., 489., 490., 491., 492., 493., 494.,\n",
-       "       495., 496., 497., 498., 499., 500., 501., 502., 503., 504., 505.,\n",
-       "       506., 507., 508., 509., 510., 511., 512., 513., 514., 515., 516.,\n",
-       "       517., 518., 519., 520., 521., 522., 523., 524., 525., 526., 527.,\n",
-       "       528., 529., 530., 531., 532., 533., 534., 535., 536., 537., 538.,\n",
-       "       539., 540., 541., 542., 543., 544., 545., 546., 547., 548., 549.,\n",
-       "       550., 551., 552., 553., 554., 555., 556., 557., 558., 559., 560.,\n",
-       "       561., 562., 563., 564., 565., 566., 567., 568., 569., 570., 571.,\n",
-       "       572., 573., 574., 575., 576., 577., 578., 579., 580., 581., 582.,\n",
-       "       583., 584., 585., 586., 587., 588., 589., 590., 591., 592., 593.,\n",
-       "       594., 595., 596., 597., 598., 599., 600., 601., 602., 603., 604.,\n",
-       "       605., 606., 607., 608., 609., 610., 611., 612., 613., 614., 615.,\n",
-       "       616., 617., 618., 619., 620., 621., 622., 623., 624., 625., 626.,\n",
-       "       627., 628., 629., 630., 631., 632., 633., 634., 635., 636., 637.,\n",
-       "       638., 639., 640., 641., 642., 643., 644., 645., 646., 647., 648.,\n",
-       "       649., 650., 651., 652., 653., 654., 655., 656., 657., 658., 659.,\n",
-       "       660., 661., 662., 663., 664., 665., 666., 667., 668., 669., 670.,\n",
-       "       671., 672., 673., 674., 675., 676., 677., 678., 679., 680., 681.,\n",
-       "       682., 683., 684., 685., 686., 687., 688., 689., 690., 691., 692.,\n",
-       "       693., 694., 695., 696., 697., 698., 699., 700., 701., 702., 703.,\n",
-       "       704., 705., 706., 707., 708., 709., 710., 711., 712., 713., 714.,\n",
-       "       715., 716., 717., 718., 719., 720., 721., 722., 723., 724., 725.,\n",
-       "       726., 727., 728., 729., 730., 731., 732., 733., 734., 735., 736.,\n",
-       "       737., 738., 739., 740., 741., 742., 743., 744., 745., 746., 747.,\n",
-       "       748., 749., 750., 751., 752., 753., 754., 755., 756., 757., 758.,\n",
-       "       759., 760., 761., 762., 763., 764., 765., 766., 767., 768., 769.,\n",
-       "       770., 771., 772., 773., 774., 775., 776., 777., 778., 779., 780.,\n",
-       "       781., 782., 783., 784., 785., 786., 787., 788., 789., 790., 791.,\n",
-       "       792., 793., 794., 795., 796., 797., 798., 799., 800., 801., 802.,\n",
-       "       803., 804., 805., 806., 807., 808., 809., 810., 811., 812., 813.,\n",
-       "       814., 815., 816., 817., 818., 819., 820., 821., 822., 823., 824.,\n",
-       "       825., 826., 827., 828., 829., 830., 831., 832., 833., 834., 835.,\n",
-       "       836., 837., 838., 839., 840., 841., 842., 843., 844., 845., 846.,\n",
-       "       847., 848., 849., 850., 851., 852., 853., 854., 855., 856., 857.,\n",
-       "       858., 859., 860., 861., 862., 863., 864., 865., 866., 867., 868.,\n",
-       "       869., 870., 871., 872., 873., 874., 875., 876., 877., 878., 879.,\n",
-       "       880., 881., 882., 883., 884., 885., 886., 887., 888., 889., 890.,\n",
-       "       891., 892., 893., 894., 895., 896., 897., 898., 899., 900.])"
-      ]
-     },
-     "execution_count": 17,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "t_filt"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 18,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "901"
-      ]
-     },
-     "execution_count": 18,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "t_filt.size"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 19,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "991"
-      ]
-     },
-     "execution_count": 19,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "t.size"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 20,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "hf = np.ones_like(t_filt)\n",
-    "ef = np.ones_like(t_filt)\n",
-    "zf = np.ones_like(t_filt)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 21,
-   "metadata": {},
-   "outputs": [
-    {
-     "ename": "TypeError",
-     "evalue": "'numpy.float64' object is not iterable",
-     "output_type": "error",
-     "traceback": [
-      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
-      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
-      "\u001b[0;32m<ipython-input-21-1f8b0065d365>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;32mfor\u001b[0m \u001b[0mi\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mt\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mt_filt\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      2\u001b[0m     \u001b[0mt\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mt\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m     \u001b[0mhf\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mone_minute_gauss_filter\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mh\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0;36m60\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0;36m60\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m91\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;31mTypeError\u001b[0m: 'numpy.float64' object is not iterable"
-     ]
-    }
-   ],
-   "source": [
-    "for i, t in t_filt:\n",
-    "    t = np.int(t)\n",
-    "    hf[i] = np.dot(one_minute_gauss_filter, h.data[np.int(i*60):np.int(i*60+91)])"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 22,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "array([  0.,   1.,   2.,   3.,   4.,   5.,   6.,   7.,   8.,   9.,  10.,\n",
-       "        11.,  12.,  13.,  14.,  15.,  16.,  17.,  18.,  19.,  20.,  21.,\n",
-       "        22.,  23.,  24.,  25.,  26.,  27.,  28.,  29.,  30.,  31.,  32.,\n",
-       "        33.,  34.,  35.,  36.,  37.,  38.,  39.,  40.,  41.,  42.,  43.,\n",
-       "        44.,  45.,  46.,  47.,  48.,  49.,  50.,  51.,  52.,  53.,  54.,\n",
-       "        55.,  56.,  57.,  58.,  59.,  60.,  61.,  62.,  63.,  64.,  65.,\n",
-       "        66.,  67.,  68.,  69.,  70.,  71.,  72.,  73.,  74.,  75.,  76.,\n",
-       "        77.,  78.,  79.,  80.,  81.,  82.,  83.,  84.,  85.,  86.,  87.,\n",
-       "        88.,  89.,  90.,  91.,  92.,  93.,  94.,  95.,  96.,  97.,  98.,\n",
-       "        99., 100., 101., 102., 103., 104., 105., 106., 107., 108., 109.,\n",
-       "       110., 111., 112., 113., 114., 115., 116., 117., 118., 119., 120.,\n",
-       "       121., 122., 123., 124., 125., 126., 127., 128., 129., 130., 131.,\n",
-       "       132., 133., 134., 135., 136., 137., 138., 139., 140., 141., 142.,\n",
-       "       143., 144., 145., 146., 147., 148., 149., 150., 151., 152., 153.,\n",
-       "       154., 155., 156., 157., 158., 159., 160., 161., 162., 163., 164.,\n",
-       "       165., 166., 167., 168., 169., 170., 171., 172., 173., 174., 175.,\n",
-       "       176., 177., 178., 179., 180., 181., 182., 183., 184., 185., 186.,\n",
-       "       187., 188., 189., 190., 191., 192., 193., 194., 195., 196., 197.,\n",
-       "       198., 199., 200., 201., 202., 203., 204., 205., 206., 207., 208.,\n",
-       "       209., 210., 211., 212., 213., 214., 215., 216., 217., 218., 219.,\n",
-       "       220., 221., 222., 223., 224., 225., 226., 227., 228., 229., 230.,\n",
-       "       231., 232., 233., 234., 235., 236., 237., 238., 239., 240., 241.,\n",
-       "       242., 243., 244., 245., 246., 247., 248., 249., 250., 251., 252.,\n",
-       "       253., 254., 255., 256., 257., 258., 259., 260., 261., 262., 263.,\n",
-       "       264., 265., 266., 267., 268., 269., 270., 271., 272., 273., 274.,\n",
-       "       275., 276., 277., 278., 279., 280., 281., 282., 283., 284., 285.,\n",
-       "       286., 287., 288., 289., 290., 291., 292., 293., 294., 295., 296.,\n",
-       "       297., 298., 299., 300., 301., 302., 303., 304., 305., 306., 307.,\n",
-       "       308., 309., 310., 311., 312., 313., 314., 315., 316., 317., 318.,\n",
-       "       319., 320., 321., 322., 323., 324., 325., 326., 327., 328., 329.,\n",
-       "       330., 331., 332., 333., 334., 335., 336., 337., 338., 339., 340.,\n",
-       "       341., 342., 343., 344., 345., 346., 347., 348., 349., 350., 351.,\n",
-       "       352., 353., 354., 355., 356., 357., 358., 359., 360., 361., 362.,\n",
-       "       363., 364., 365., 366., 367., 368., 369., 370., 371., 372., 373.,\n",
-       "       374., 375., 376., 377., 378., 379., 380., 381., 382., 383., 384.,\n",
-       "       385., 386., 387., 388., 389., 390., 391., 392., 393., 394., 395.,\n",
-       "       396., 397., 398., 399., 400., 401., 402., 403., 404., 405., 406.,\n",
-       "       407., 408., 409., 410., 411., 412., 413., 414., 415., 416., 417.,\n",
-       "       418., 419., 420., 421., 422., 423., 424., 425., 426., 427., 428.,\n",
-       "       429., 430., 431., 432., 433., 434., 435., 436., 437., 438., 439.,\n",
-       "       440., 441., 442., 443., 444., 445., 446., 447., 448., 449., 450.,\n",
-       "       451., 452., 453., 454., 455., 456., 457., 458., 459., 460., 461.,\n",
-       "       462., 463., 464., 465., 466., 467., 468., 469., 470., 471., 472.,\n",
-       "       473., 474., 475., 476., 477., 478., 479., 480., 481., 482., 483.,\n",
-       "       484., 485., 486., 487., 488., 489., 490., 491., 492., 493., 494.,\n",
-       "       495., 496., 497., 498., 499., 500., 501., 502., 503., 504., 505.,\n",
-       "       506., 507., 508., 509., 510., 511., 512., 513., 514., 515., 516.,\n",
-       "       517., 518., 519., 520., 521., 522., 523., 524., 525., 526., 527.,\n",
-       "       528., 529., 530., 531., 532., 533., 534., 535., 536., 537., 538.,\n",
-       "       539., 540., 541., 542., 543., 544., 545., 546., 547., 548., 549.,\n",
-       "       550., 551., 552., 553., 554., 555., 556., 557., 558., 559., 560.,\n",
-       "       561., 562., 563., 564., 565., 566., 567., 568., 569., 570., 571.,\n",
-       "       572., 573., 574., 575., 576., 577., 578., 579., 580., 581., 582.,\n",
-       "       583., 584., 585., 586., 587., 588., 589., 590., 591., 592., 593.,\n",
-       "       594., 595., 596., 597., 598., 599., 600., 601., 602., 603., 604.,\n",
-       "       605., 606., 607., 608., 609., 610., 611., 612., 613., 614., 615.,\n",
-       "       616., 617., 618., 619., 620., 621., 622., 623., 624., 625., 626.,\n",
-       "       627., 628., 629., 630., 631., 632., 633., 634., 635., 636., 637.,\n",
-       "       638., 639., 640., 641., 642., 643., 644., 645., 646., 647., 648.,\n",
-       "       649., 650., 651., 652., 653., 654., 655., 656., 657., 658., 659.,\n",
-       "       660., 661., 662., 663., 664., 665., 666., 667., 668., 669., 670.,\n",
-       "       671., 672., 673., 674., 675., 676., 677., 678., 679., 680., 681.,\n",
-       "       682., 683., 684., 685., 686., 687., 688., 689., 690., 691., 692.,\n",
-       "       693., 694., 695., 696., 697., 698., 699., 700., 701., 702., 703.,\n",
-       "       704., 705., 706., 707., 708., 709., 710., 711., 712., 713., 714.,\n",
-       "       715., 716., 717., 718., 719., 720., 721., 722., 723., 724., 725.,\n",
-       "       726., 727., 728., 729., 730., 731., 732., 733., 734., 735., 736.,\n",
-       "       737., 738., 739., 740., 741., 742., 743., 744., 745., 746., 747.,\n",
-       "       748., 749., 750., 751., 752., 753., 754., 755., 756., 757., 758.,\n",
-       "       759., 760., 761., 762., 763., 764., 765., 766., 767., 768., 769.,\n",
-       "       770., 771., 772., 773., 774., 775., 776., 777., 778., 779., 780.,\n",
-       "       781., 782., 783., 784., 785., 786., 787., 788., 789., 790., 791.,\n",
-       "       792., 793., 794., 795., 796., 797., 798., 799., 800., 801., 802.,\n",
-       "       803., 804., 805., 806., 807., 808., 809., 810., 811., 812., 813.,\n",
-       "       814., 815., 816., 817., 818., 819., 820., 821., 822., 823., 824.,\n",
-       "       825., 826., 827., 828., 829., 830., 831., 832., 833., 834., 835.,\n",
-       "       836., 837., 838., 839., 840., 841., 842., 843., 844., 845., 846.,\n",
-       "       847., 848., 849., 850., 851., 852., 853., 854., 855., 856., 857.,\n",
-       "       858., 859., 860., 861., 862., 863., 864., 865., 866., 867., 868.,\n",
-       "       869., 870., 871., 872., 873., 874., 875., 876., 877., 878., 879.,\n",
-       "       880., 881., 882., 883., 884., 885., 886., 887., 888., 889., 890.,\n",
-       "       891., 892., 893., 894., 895., 896., 897., 898., 899., 900.])"
-      ]
-     },
-     "execution_count": 22,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "i_filt_s = t_filt\n",
-    "i_filt_e = t_filt + 90\n",
-    "i_filt_s"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 23,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "array([ 90.,  91.,  92.,  93.,  94.,  95.,  96.,  97.,  98.,  99., 100.,\n",
-       "       101., 102., 103., 104., 105., 106., 107., 108., 109., 110., 111.,\n",
-       "       112., 113., 114., 115., 116., 117., 118., 119., 120., 121., 122.,\n",
-       "       123., 124., 125., 126., 127., 128., 129., 130., 131., 132., 133.,\n",
-       "       134., 135., 136., 137., 138., 139., 140., 141., 142., 143., 144.,\n",
-       "       145., 146., 147., 148., 149., 150., 151., 152., 153., 154., 155.,\n",
-       "       156., 157., 158., 159., 160., 161., 162., 163., 164., 165., 166.,\n",
-       "       167., 168., 169., 170., 171., 172., 173., 174., 175., 176., 177.,\n",
-       "       178., 179., 180., 181., 182., 183., 184., 185., 186., 187., 188.,\n",
-       "       189., 190., 191., 192., 193., 194., 195., 196., 197., 198., 199.,\n",
-       "       200., 201., 202., 203., 204., 205., 206., 207., 208., 209., 210.,\n",
-       "       211., 212., 213., 214., 215., 216., 217., 218., 219., 220., 221.,\n",
-       "       222., 223., 224., 225., 226., 227., 228., 229., 230., 231., 232.,\n",
-       "       233., 234., 235., 236., 237., 238., 239., 240., 241., 242., 243.,\n",
-       "       244., 245., 246., 247., 248., 249., 250., 251., 252., 253., 254.,\n",
-       "       255., 256., 257., 258., 259., 260., 261., 262., 263., 264., 265.,\n",
-       "       266., 267., 268., 269., 270., 271., 272., 273., 274., 275., 276.,\n",
-       "       277., 278., 279., 280., 281., 282., 283., 284., 285., 286., 287.,\n",
-       "       288., 289., 290., 291., 292., 293., 294., 295., 296., 297., 298.,\n",
-       "       299., 300., 301., 302., 303., 304., 305., 306., 307., 308., 309.,\n",
-       "       310., 311., 312., 313., 314., 315., 316., 317., 318., 319., 320.,\n",
-       "       321., 322., 323., 324., 325., 326., 327., 328., 329., 330., 331.,\n",
-       "       332., 333., 334., 335., 336., 337., 338., 339., 340., 341., 342.,\n",
-       "       343., 344., 345., 346., 347., 348., 349., 350., 351., 352., 353.,\n",
-       "       354., 355., 356., 357., 358., 359., 360., 361., 362., 363., 364.,\n",
-       "       365., 366., 367., 368., 369., 370., 371., 372., 373., 374., 375.,\n",
-       "       376., 377., 378., 379., 380., 381., 382., 383., 384., 385., 386.,\n",
-       "       387., 388., 389., 390., 391., 392., 393., 394., 395., 396., 397.,\n",
-       "       398., 399., 400., 401., 402., 403., 404., 405., 406., 407., 408.,\n",
-       "       409., 410., 411., 412., 413., 414., 415., 416., 417., 418., 419.,\n",
-       "       420., 421., 422., 423., 424., 425., 426., 427., 428., 429., 430.,\n",
-       "       431., 432., 433., 434., 435., 436., 437., 438., 439., 440., 441.,\n",
-       "       442., 443., 444., 445., 446., 447., 448., 449., 450., 451., 452.,\n",
-       "       453., 454., 455., 456., 457., 458., 459., 460., 461., 462., 463.,\n",
-       "       464., 465., 466., 467., 468., 469., 470., 471., 472., 473., 474.,\n",
-       "       475., 476., 477., 478., 479., 480., 481., 482., 483., 484., 485.,\n",
-       "       486., 487., 488., 489., 490., 491., 492., 493., 494., 495., 496.,\n",
-       "       497., 498., 499., 500., 501., 502., 503., 504., 505., 506., 507.,\n",
-       "       508., 509., 510., 511., 512., 513., 514., 515., 516., 517., 518.,\n",
-       "       519., 520., 521., 522., 523., 524., 525., 526., 527., 528., 529.,\n",
-       "       530., 531., 532., 533., 534., 535., 536., 537., 538., 539., 540.,\n",
-       "       541., 542., 543., 544., 545., 546., 547., 548., 549., 550., 551.,\n",
-       "       552., 553., 554., 555., 556., 557., 558., 559., 560., 561., 562.,\n",
-       "       563., 564., 565., 566., 567., 568., 569., 570., 571., 572., 573.,\n",
-       "       574., 575., 576., 577., 578., 579., 580., 581., 582., 583., 584.,\n",
-       "       585., 586., 587., 588., 589., 590., 591., 592., 593., 594., 595.,\n",
-       "       596., 597., 598., 599., 600., 601., 602., 603., 604., 605., 606.,\n",
-       "       607., 608., 609., 610., 611., 612., 613., 614., 615., 616., 617.,\n",
-       "       618., 619., 620., 621., 622., 623., 624., 625., 626., 627., 628.,\n",
-       "       629., 630., 631., 632., 633., 634., 635., 636., 637., 638., 639.,\n",
-       "       640., 641., 642., 643., 644., 645., 646., 647., 648., 649., 650.,\n",
-       "       651., 652., 653., 654., 655., 656., 657., 658., 659., 660., 661.,\n",
-       "       662., 663., 664., 665., 666., 667., 668., 669., 670., 671., 672.,\n",
-       "       673., 674., 675., 676., 677., 678., 679., 680., 681., 682., 683.,\n",
-       "       684., 685., 686., 687., 688., 689., 690., 691., 692., 693., 694.,\n",
-       "       695., 696., 697., 698., 699., 700., 701., 702., 703., 704., 705.,\n",
-       "       706., 707., 708., 709., 710., 711., 712., 713., 714., 715., 716.,\n",
-       "       717., 718., 719., 720., 721., 722., 723., 724., 725., 726., 727.,\n",
-       "       728., 729., 730., 731., 732., 733., 734., 735., 736., 737., 738.,\n",
-       "       739., 740., 741., 742., 743., 744., 745., 746., 747., 748., 749.,\n",
-       "       750., 751., 752., 753., 754., 755., 756., 757., 758., 759., 760.,\n",
-       "       761., 762., 763., 764., 765., 766., 767., 768., 769., 770., 771.,\n",
-       "       772., 773., 774., 775., 776., 777., 778., 779., 780., 781., 782.,\n",
-       "       783., 784., 785., 786., 787., 788., 789., 790., 791., 792., 793.,\n",
-       "       794., 795., 796., 797., 798., 799., 800., 801., 802., 803., 804.,\n",
-       "       805., 806., 807., 808., 809., 810., 811., 812., 813., 814., 815.,\n",
-       "       816., 817., 818., 819., 820., 821., 822., 823., 824., 825., 826.,\n",
-       "       827., 828., 829., 830., 831., 832., 833., 834., 835., 836., 837.,\n",
-       "       838., 839., 840., 841., 842., 843., 844., 845., 846., 847., 848.,\n",
-       "       849., 850., 851., 852., 853., 854., 855., 856., 857., 858., 859.,\n",
-       "       860., 861., 862., 863., 864., 865., 866., 867., 868., 869., 870.,\n",
-       "       871., 872., 873., 874., 875., 876., 877., 878., 879., 880., 881.,\n",
-       "       882., 883., 884., 885., 886., 887., 888., 889., 890., 891., 892.,\n",
-       "       893., 894., 895., 896., 897., 898., 899., 900., 901., 902., 903.,\n",
-       "       904., 905., 906., 907., 908., 909., 910., 911., 912., 913., 914.,\n",
-       "       915., 916., 917., 918., 919., 920., 921., 922., 923., 924., 925.,\n",
-       "       926., 927., 928., 929., 930., 931., 932., 933., 934., 935., 936.,\n",
-       "       937., 938., 939., 940., 941., 942., 943., 944., 945., 946., 947.,\n",
-       "       948., 949., 950., 951., 952., 953., 954., 955., 956., 957., 958.,\n",
-       "       959., 960., 961., 962., 963., 964., 965., 966., 967., 968., 969.,\n",
-       "       970., 971., 972., 973., 974., 975., 976., 977., 978., 979., 980.,\n",
-       "       981., 982., 983., 984., 985., 986., 987., 988., 989., 990.])"
-      ]
-     },
-     "execution_count": 23,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "i_filt_e"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 24,
-   "metadata": {},
-   "outputs": [
-    {
-     "ename": "TypeError",
-     "evalue": "'int' object is not iterable",
-     "output_type": "error",
-     "traceback": [
-      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
-      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
-      "\u001b[0;32m<ipython-input-24-6664f3db0770>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;32mfor\u001b[0m \u001b[0mi\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mhf\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      2\u001b[0m     \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;31mTypeError\u001b[0m: 'int' object is not iterable"
-     ]
-    }
-   ],
-   "source": [
-    "for i in len(hf):\n",
-    "    print(i)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 25,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from numpy.lib import stride_tricks as npls"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 26,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "(901, 91)"
-      ]
-     },
-     "execution_count": 26,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "window = 91\n",
-    "shape = h.data.shape[:-1] + (h.data.shape[-1] - window + 1, window)\n",
-    "strides = h.data.strides + (h.data.strides[-1],)\n",
-    "as_s = npls.as_strided(h.data, shape=shape, strides=strides, writeable=False)\n",
-    "as_s.shape"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 27,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "(901, 91)"
-      ]
-     },
-     "execution_count": 27,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "shape"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 28,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "(8, 8)"
-      ]
-     },
-     "execution_count": 28,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "strides"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 29,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "array([[9145.616, 9145.659, 9145.698, ..., 9147.489, 9147.453, 9147.415],\n",
-       "       [9146.457, 9146.659, 9146.864, ..., 9152.84 , 9152.933, 9153.046],\n",
-       "       [9149.807, 9149.887, 9149.958, ..., 9151.775, 9151.762, 9151.772],\n",
-       "       ...,\n",
-       "       [9156.414, 9156.362, 9156.33 , ..., 9157.791, 9157.746, 9157.662],\n",
-       "       [9157.573, 9157.555, 9157.543, ..., 9157.463, 9157.493, 9157.475],\n",
-       "       [9156.089, 9156.107, 9156.129, ..., 9158.807, 9158.818, 9158.832]])"
-      ]
-     },
-     "execution_count": 29,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "as_s[::60]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 30,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "hf2 = np.dot(one_minute_gauss_filter, as_s[::].T)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 31,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "array([9146.3294147 , 9146.34727413, 9146.36700672, 9146.38871274,\n",
-       "       9146.41245012, 9146.43826252, 9146.46617488, 9146.4961749 ,\n",
-       "       9146.52823637, 9146.5623157 , 9146.59832795, 9146.63614451,\n",
-       "       9146.6756066 , 9146.71654228, 9146.7587768 , 9146.8021385 ,\n",
-       "       9146.84643758, 9146.89145024, 9146.93693953, 9146.98268004,\n",
-       "       9147.0284517 , 9147.0740595 , 9147.11933223, 9147.16408598,\n",
-       "       9147.20814227, 9147.25135698, 9147.29362312, 9147.33486287,\n",
-       "       9147.37501995, 9147.41406655, 9147.45200071, 9147.48884501,\n",
-       "       9147.52464808, 9147.55946916, 9147.59339714, 9147.62656116,\n",
-       "       9147.65912327, 9147.69125836, 9147.72313398, 9147.75492814,\n",
-       "       9147.78682483, 9147.81901966, 9147.85172944, 9147.88516094,\n",
-       "       9147.91950993, 9147.95495996, 9147.9916889 , 9148.02987329,\n",
-       "       9148.06966334, 9148.11119517, 9148.15460282, 9148.20000821,\n",
-       "       9148.24750588, 9148.29716011, 9148.34902764, 9148.40314728,\n",
-       "       9148.45955299, 9148.5182719 , 9148.57929871, 9148.64261179,\n",
-       "       9148.70819126, 9148.77600591, 9148.84600612, 9148.91813911,\n",
-       "       9148.99235183, 9149.06857916, 9149.14674233, 9149.22676679,\n",
-       "       9149.30857443, 9149.39208481, 9149.47721967, 9149.56389017,\n",
-       "       9149.65200735, 9149.74148146, 9149.83223975, 9149.92419547,\n",
-       "       9150.0172389 , 9150.11127348, 9150.20620308, 9150.30192348,\n",
-       "       9150.3983424 , 9150.4953694 , 9150.59288013, 9150.69076012,\n",
-       "       9150.78891849, 9150.88723482, 9150.98556927, 9151.08378862,\n",
-       "       9151.18175878, 9151.27933976, 9151.37638912, 9151.47276453,\n",
-       "       9151.56830513, 9151.66282852, 9151.75616281, 9151.8481503 ,\n",
-       "       9151.93862663, 9152.02742555, 9152.11437783, 9152.19929249,\n",
-       "       9152.28196404, 9152.36221976, 9152.43991102, 9152.51487312,\n",
-       "       9152.58694163, 9152.65594849, 9152.72173336, 9152.78415666,\n",
-       "       9152.84308025, 9152.8983711 , 9152.94991059, 9152.99759991,\n",
-       "       9153.04135303, 9153.08109105, 9153.11676563, 9153.14833557,\n",
-       "       9153.17575841, 9153.19902477, 9153.21815123, 9153.23318014,\n",
-       "       9153.2441662 , 9153.25115738, 9153.25421474, 9153.25342434,\n",
-       "       9153.24890119, 9153.24077559, 9153.22918075, 9153.21424296,\n",
-       "       9153.19610037, 9153.17490982, 9153.15083191, 9153.12405065,\n",
-       "       9153.09476085, 9153.06313909, 9153.02936378, 9152.9935991 ,\n",
-       "       9152.95600412, 9152.91675664, 9152.87603556, 9152.83400635,\n",
-       "       9152.79080552, 9152.74655996, 9152.70139306, 9152.65542151,\n",
-       "       9152.60875812, 9152.56150152, 9152.51373655, 9152.46551673,\n",
-       "       9152.41689245, 9152.36792742, 9152.31866951, 9152.26913367,\n",
-       "       9152.21932366, 9152.16925782, 9152.11895131, 9152.06839911,\n",
-       "       9152.01758657, 9151.96650215, 9151.91514015, 9151.86351146,\n",
-       "       9151.81161229, 9151.75941927, 9151.70691397, 9151.65408259,\n",
-       "       9151.60093076, 9151.54747373, 9151.49372966, 9151.43972681,\n",
-       "       9151.38548955, 9151.33102645, 9151.27637207, 9151.2215872 ,\n",
-       "       9151.16671864, 9151.11182499, 9151.05696787, 9151.00219884,\n",
-       "       9150.94759059, 9150.89322982, 9150.83920433, 9150.78559928,\n",
-       "       9150.7324949 , 9150.67997936, 9150.6281303 , 9150.57703561,\n",
-       "       9150.52682015, 9150.47759126, 9150.42942702, 9150.38241424,\n",
-       "       9150.33665364, 9150.29225809, 9150.24933742, 9150.2079954 ,\n",
-       "       9150.16831906, 9150.13039555, 9150.09434076, 9150.06027026,\n",
-       "       9150.02827807, 9149.99843183, 9149.97081415, 9149.94552571,\n",
-       "       9149.92266997, 9149.90236159, 9149.88468784, 9149.86969104,\n",
-       "       9149.8574225 , 9149.84794278, 9149.84133032, 9149.83767784,\n",
-       "       9149.8370098 , 9149.83932201, 9149.84462817, 9149.85293327,\n",
-       "       9149.86424572, 9149.8785707 , 9149.89588695, 9149.91615142,\n",
-       "       9149.93930324, 9149.96526449, 9149.99396031, 9150.02531306,\n",
-       "       9150.05922306, 9150.09557494, 9150.13424385, 9150.1750742 ,\n",
-       "       9150.21789968, 9150.26257864, 9150.30897712, 9150.35693858,\n",
-       "       9150.40628657, 9150.45684196, 9150.50842777, 9150.56088487,\n",
-       "       9150.61406225, 9150.66779349, 9150.72191258, 9150.77627579,\n",
-       "       9150.83074797, 9150.88520113, 9150.93952152, 9150.9936031 ,\n",
-       "       9151.04734904, 9151.10067087, 9151.15349923, 9151.20578561,\n",
-       "       9151.25748365, 9151.30854869, 9151.3589626 , 9151.4087044 ,\n",
-       "       9151.45775133, 9151.50610374, 9151.55376348, 9151.60075791,\n",
-       "       9151.64712976, 9151.69290229, 9151.73808936, 9151.78271216,\n",
-       "       9151.8268044 , 9151.87040878, 9151.91356762, 9151.95631438,\n",
-       "       9151.99867358, 9152.04065486, 9152.08226113, 9152.12351158,\n",
-       "       9152.16441967, 9152.20498882, 9152.24522446, 9152.28512085,\n",
-       "       9152.32466642, 9152.36383623, 9152.40260179, 9152.44094866,\n",
-       "       9152.47885861, 9152.51630764, 9152.5532559 , 9152.58964854,\n",
-       "       9152.62544077, 9152.66060602, 9152.69511503, 9152.72891416,\n",
-       "       9152.76193184, 9152.79411061, 9152.82542771, 9152.85585557,\n",
-       "       9152.88533359, 9152.91379354, 9152.94119019, 9152.9674916 ,\n",
-       "       9152.99267367, 9153.01670699, 9153.03955046, 9153.06116291,\n",
-       "       9153.08150308, 9153.10054882, 9153.11830818, 9153.13478102,\n",
-       "       9153.14996027, 9153.16383384, 9153.17637466, 9153.18760295,\n",
-       "       9153.19756752, 9153.20628772, 9153.21378199, 9153.22008959,\n",
-       "       9153.22524988, 9153.2293041 , 9153.23229074, 9153.23426186,\n",
-       "       9153.23529289, 9153.23544721, 9153.23478221, 9153.23336046,\n",
-       "       9153.23124921, 9153.22851088, 9153.22521649, 9153.22144744,\n",
-       "       9153.21726252, 9153.21270226, 9153.20781335, 9153.20265548,\n",
-       "       9153.1972888 , 9153.19176907, 9153.18612963, 9153.18039362,\n",
-       "       9153.17460315, 9153.16878677, 9153.16294632, 9153.15708628,\n",
-       "       9153.1512156 , 9153.14535173, 9153.13949287, 9153.13361146,\n",
-       "       9153.12769202, 9153.12172608, 9153.11569917, 9153.10959401,\n",
-       "       9153.10339616, 9153.097084  , 9153.09063212, 9153.08400965,\n",
-       "       9153.0771906 , 9153.07015207, 9153.06286425, 9153.0553093 ,\n",
-       "       9153.04747553, 9153.03935548, 9153.03092278, 9153.02214213,\n",
-       "       9153.01300074, 9153.00349429, 9152.99361946, 9152.98337453,\n",
-       "       9152.97275604, 9152.96175392, 9152.95036248, 9152.93858654,\n",
-       "       9152.92643572, 9152.91391813, 9152.90102572, 9152.88774249,\n",
-       "       9152.87407819, 9152.86004573, 9152.84564559, 9152.83088429,\n",
-       "       9152.81576882, 9152.80030687, 9152.78450844, 9152.76838075,\n",
-       "       9152.75192941, 9152.73516676, 9152.71811657, 9152.70081349,\n",
-       "       9152.68328998, 9152.66555331, 9152.64761811, 9152.6295248 ,\n",
-       "       9152.6113035 , 9152.59297131, 9152.57456145, 9152.55611322,\n",
-       "       9152.5376664 , 9152.51926591, 9152.50094579, 9152.4827452 ,\n",
-       "       9152.46470354, 9152.44685356, 9152.42924386, 9152.41193884,\n",
-       "       9152.39499829, 9152.37846951, 9152.36240063, 9152.34685312,\n",
-       "       9152.33189563, 9152.31759037, 9152.30399073, 9152.29116102,\n",
-       "       9152.27917396, 9152.26810501, 9152.25802193, 9152.24898759,\n",
-       "       9152.24107097, 9152.23433787, 9152.2288684 , 9152.22472878,\n",
-       "       9152.22195769, 9152.2206102 , 9152.2207459 , 9152.22240618,\n",
-       "       9152.22564129, 9152.23049364, 9152.2369798 , 9152.24511344,\n",
-       "       9152.25489565, 9152.26632687, 9152.27940101, 9152.29408548,\n",
-       "       9152.31035438, 9152.32817952, 9152.3475092 , 9152.36827961,\n",
-       "       9152.39041223, 9152.41383513, 9152.43848362, 9152.46429633,\n",
-       "       9152.49119538, 9152.51907204, 9152.54783437, 9152.5774084 ,\n",
-       "       9152.60772433, 9152.63871197, 9152.67029159, 9152.70237927,\n",
-       "       9152.73491059, 9152.76783491, 9152.80110388, 9152.8346908 ,\n",
-       "       9152.86857143, 9152.90273106, 9152.93717337, 9152.97189296,\n",
-       "       9153.00689034, 9153.04218709, 9153.07783196, 9153.11388383,\n",
-       "       9153.15039968, 9153.18742787, 9153.22501683, 9153.26322626,\n",
-       "       9153.30212812, 9153.34180717, 9153.38233952, 9153.4237813 ,\n",
-       "       9153.46618585, 9153.50959997, 9153.55405683, 9153.5995865 ,\n",
-       "       9153.64622277, 9153.69398275, 9153.74285957, 9153.7928318 ,\n",
-       "       9153.84387027, 9153.89593078, 9153.94894576, 9154.00283737,\n",
-       "       9154.05751843, 9154.11288258, 9154.16881572, 9154.22519802,\n",
-       "       9154.28189146, 9154.33874413, 9154.39559884, 9154.45229025,\n",
-       "       9154.5086511 , 9154.56452217, 9154.61973869, 9154.67413937,\n",
-       "       9154.72757199, 9154.77986648, 9154.83084589, 9154.8803607 ,\n",
-       "       9154.92828897, 9154.97451658, 9155.01891791, 9155.06137406,\n",
-       "       9155.10179773, 9155.1401078 , 9155.17622663, 9155.21009773,\n",
-       "       9155.24168172, 9155.27093493, 9155.29782046, 9155.32233187,\n",
-       "       9155.34447779, 9155.3642573 , 9155.38167746, 9155.3967807 ,\n",
-       "       9155.40960259, 9155.42016509, 9155.42851765, 9155.43470381,\n",
-       "       9155.43876368, 9155.44076254, 9155.44076946, 9155.43885641,\n",
-       "       9155.43509394, 9155.42955367, 9155.42231175, 9155.41344728,\n",
-       "       9155.40304801, 9155.39119329, 9155.37796796, 9155.36346067,\n",
-       "       9155.34775509, 9155.33096004, 9155.3131756 , 9155.29450329,\n",
-       "       9155.27506805, 9155.25498416, 9155.23436233, 9155.2133202 ,\n",
-       "       9155.19200146, 9155.17055293, 9155.14910305, 9155.12779085,\n",
-       "       9155.1067659 , 9155.08616922, 9155.06613627, 9155.04681598,\n",
-       "       9155.02836435, 9155.0109254 , 9154.99465811, 9154.97971051,\n",
-       "       9154.96619542, 9154.95422052, 9154.94390727, 9154.93538258,\n",
-       "       9154.92875783, 9154.92412398, 9154.92155182, 9154.92109536,\n",
-       "       9154.92281761, 9154.92677952, 9154.93300345, 9154.94149922,\n",
-       "       9154.95227533, 9154.96531699, 9154.98060043, 9154.99809076,\n",
-       "       9155.0177325 , 9155.03946141, 9155.0632018 , 9155.08885734,\n",
-       "       9155.11633226, 9155.14552836, 9155.17633073, 9155.20863268,\n",
-       "       9155.24232394, 9155.27727274, 9155.31335124, 9155.35044521,\n",
-       "       9155.38844298, 9155.42722947, 9155.46668566, 9155.50669759,\n",
-       "       9155.54716588, 9155.58799908, 9155.62911234, 9155.67042555,\n",
-       "       9155.71187354, 9155.75339531, 9155.79493593, 9155.83647059,\n",
-       "       9155.87797022, 9155.91941171, 9155.96078829, 9156.00208437,\n",
-       "       9156.04330315, 9156.08447055, 9156.12559878, 9156.16668882,\n",
-       "       9156.20776667, 9156.24886356, 9156.29000184, 9156.33121012,\n",
-       "       9156.37250709, 9156.41391045, 9156.45543474, 9156.49709961,\n",
-       "       9156.53893285, 9156.58093726, 9156.62309499, 9156.66539641,\n",
-       "       9156.70783205, 9156.75036639, 9156.79296339, 9156.83560226,\n",
-       "       9156.87823703, 9156.92079751, 9156.96319712, 9157.00536311,\n",
-       "       9157.04724769, 9157.08877384, 9157.1298426 , 9157.17036103,\n",
-       "       9157.21022081, 9157.24931153, 9157.28753289, 9157.32478503,\n",
-       "       9157.36094747, 9157.39588991, 9157.42949656, 9157.46165178,\n",
-       "       9157.49225063, 9157.52118918, 9157.54835066, 9157.5736293 ,\n",
-       "       9157.59692742, 9157.61815795, 9157.63724188, 9157.65409038,\n",
-       "       9157.66863124, 9157.68079268, 9157.69051165, 9157.69777037,\n",
-       "       9157.70255069, 9157.7048154 , 9157.70454574, 9157.70175641,\n",
-       "       9157.69647076, 9157.68872519, 9157.67857076, 9157.66603809,\n",
-       "       9157.65117995, 9157.63409197, 9157.61486432, 9157.59359084,\n",
-       "       9157.57038447, 9157.54536789, 9157.51865136, 9157.49035127,\n",
-       "       9157.46061822, 9157.42960419, 9157.39745182, 9157.36431015,\n",
-       "       9157.33033277, 9157.29567289, 9157.2604864 , 9157.22492357,\n",
-       "       9157.18913088, 9157.15325564, 9157.11742628, 9157.0817518 ,\n",
-       "       9157.04635385, 9157.01135441, 9156.97686527, 9156.94297976,\n",
-       "       9156.90976504, 9156.87727405, 9156.84556567, 9156.81469978,\n",
-       "       9156.78471925, 9156.75566174, 9156.72753694, 9156.70032818,\n",
-       "       9156.67402318, 9156.64861023, 9156.6240785 , 9156.60041402,\n",
-       "       9156.57756708, 9156.55547687, 9156.53410771, 9156.51341541,\n",
-       "       9156.49333836, 9156.47381273, 9156.45476666, 9156.43615052,\n",
-       "       9156.41792467, 9156.40002204, 9156.38237063, 9156.36491542,\n",
-       "       9156.34761552, 9156.3304486 , 9156.31338684, 9156.29638872,\n",
-       "       9156.27942873, 9156.26249633, 9156.24558667, 9156.2287156 ,\n",
-       "       9156.21191829, 9156.19522879, 9156.17866731, 9156.16226557,\n",
-       "       9156.14608922, 9156.13022442, 9156.11476199, 9156.09977847,\n",
-       "       9156.08533668, 9156.07152002, 9156.05842657, 9156.04616176,\n",
-       "       9156.03483764, 9156.02454684, 9156.01536094, 9156.00734589,\n",
-       "       9156.00059746, 9155.99520726, 9155.99121699, 9155.98866571,\n",
-       "       9155.98759499, 9155.98803146, 9155.9900193 , 9155.9935882 ,\n",
-       "       9155.99873598, 9156.00545236, 9156.01369843, 9156.02343274,\n",
-       "       9156.03462417, 9156.04722983, 9156.06119199, 9156.07645986,\n",
-       "       9156.09298106, 9156.11070312, 9156.12957786, 9156.14952709,\n",
-       "       9156.17049253, 9156.19243666, 9156.21530317, 9156.23904184,\n",
-       "       9156.26360516, 9156.28895664, 9156.31507828, 9156.34195011,\n",
-       "       9156.36955173, 9156.3978666 , 9156.42687908, 9156.45658616,\n",
-       "       9156.48699079, 9156.51806847, 9156.54980537, 9156.58221248,\n",
-       "       9156.61528791, 9156.64901897, 9156.68340271, 9156.71843021,\n",
-       "       9156.75407963, 9156.79031618, 9156.8270968 , 9156.8643849 ,\n",
-       "       9156.90214494, 9156.94031653, 9156.97881689, 9157.01756593,\n",
-       "       9157.05646693, 9157.09541779, 9157.13432494, 9157.17308781,\n",
-       "       9157.21159945, 9157.24972611, 9157.2873198 , 9157.32426389,\n",
-       "       9157.360453  , 9157.39575422, 9157.43004306, 9157.46321934,\n",
-       "       9157.49517422, 9157.52580466, 9157.5550095 , 9157.58269459,\n",
-       "       9157.60879052, 9157.63323657, 9157.65597552, 9157.67696175,\n",
-       "       9157.69617753, 9157.71360974, 9157.72924745, 9157.74310835,\n",
-       "       9157.7552051 , 9157.76555627, 9157.77421289, 9157.78121643,\n",
-       "       9157.78661802, 9157.7905016 , 9157.79294513, 9157.79400825,\n",
-       "       9157.79375923, 9157.79228362, 9157.78968093, 9157.78606565,\n",
-       "       9157.78154837, 9157.77622157, 9157.77016911, 9157.76347018,\n",
-       "       9157.75620827, 9157.7484731 , 9157.74034054, 9157.73185025,\n",
-       "       9157.72303828, 9157.71396422, 9157.70466818, 9157.69514663,\n",
-       "       9157.68539553, 9157.67539766, 9157.66510675, 9157.65449945,\n",
-       "       9157.64355256, 9157.63221796, 9157.62044594, 9157.60817509,\n",
-       "       9157.59533518, 9157.58185583, 9157.56764971, 9157.55263294,\n",
-       "       9157.53672348, 9157.51985468, 9157.5019831 , 9157.48303713,\n",
-       "       9157.4629457 , 9157.44168372, 9157.41923591, 9157.39558704,\n",
-       "       9157.37074458, 9157.34472033, 9157.31752803, 9157.28920345,\n",
-       "       9157.25980622, 9157.22942504, 9157.19815237, 9157.16608282,\n",
-       "       9157.13335309, 9157.10010647, 9157.06646798, 9157.03258175,\n",
-       "       9156.99862461, 9156.96476211, 9156.93114659, 9156.89795898,\n",
-       "       9156.86538679, 9156.83361153, 9156.80282348, 9156.77319282,\n",
-       "       9156.74486717, 9156.71800158, 9156.69276683, 9156.66932791,\n",
-       "       9156.64781796, 9156.62835085, 9156.6110453 , 9156.59600253,\n",
-       "       9156.58331318, 9156.57306646, 9156.56531908, 9156.56011062,\n",
-       "       9156.55748031, 9156.55745105, 9156.56002435, 9156.56518237,\n",
-       "       9156.57289414, 9156.58313287, 9156.59586476, 9156.61103515,\n",
-       "       9156.62856364, 9156.64836052, 9156.67034745, 9156.69443253,\n",
-       "       9156.72052647, 9156.74854944, 9156.7784076 , 9156.81000603,\n",
-       "       9156.84325196, 9156.87804442, 9156.91429704, 9156.95194393,\n",
-       "       9156.99090445, 9157.03109319, 9157.07245566, 9157.11494547,\n",
-       "       9157.158502  , 9157.20306866, 9157.24859221, 9157.29501682,\n",
-       "       9157.34230991, 9157.39045449, 9157.43942921, 9157.48919742,\n",
-       "       9157.53971217, 9157.59092756, 9157.64280656, 9157.69531364,\n",
-       "       9157.74838729, 9157.8019522 , 9157.85594508, 9157.9102792 ,\n",
-       "       9157.96485336, 9158.01957042, 9158.07430401, 9158.12891716,\n",
-       "       9158.18328275, 9158.23725756, 9158.29069137, 9158.34343053,\n",
-       "       9158.39531688])"
-      ]
-     },
-     "execution_count": 31,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "hf2"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 88,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "(901,)"
-      ]
-     },
-     "execution_count": 88,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "hf2.shape"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 32,
-   "metadata": {
-    "scrolled": true
-   },
-   "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\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\"];\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"
-    },
-    {
-     "data": {
-      "text/plain": [
-       "[<matplotlib.lines.Line2D at 0x1c28a056d8>,\n",
-       " <matplotlib.lines.Line2D at 0x1c28a05978>]"
-      ]
-     },
-     "execution_count": 32,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "pl.plot(t-45,h.data,'.',t_filt,hf2,'*')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 33,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "t_filt_dec = np.linspace(0,len(h.data)-91,16)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 34,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "hf3 = np.dot(one_minute_gauss_filter, as_s[::60].T)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 35,
-   "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\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\"];\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": [
-    "pl.plot(t-45,h.data,'.',t_filt,hf2,'*',t_filt_dec,hf3,'^')\n",
-    "pl.xlabel('time (s)')\n",
-    "pl.ylabel('field (nT)')\n",
-    "pl.legend(['One Second Signal', 'One Minute Filter Applied', \n",
-    "           'One Minute Downsampled Filtered Data'])\n",
-    "pl.show()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 36,
-   "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\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\"];\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"
-    },
-    {
-     "data": {
-      "text/plain": [
-       "[<matplotlib.lines.Line2D at 0x1c28d30b70>,\n",
-       " <matplotlib.lines.Line2D at 0x1c28d30cf8>]"
-      ]
-     },
-     "execution_count": 36,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "pl.plot(t_filt, hf2 - h.data[45:-45], '.C1', \n",
-    "        t_filt_dec, hf3 - h.data[45:-45:60], '*C2')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 37,
-   "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\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\"];\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>"
+       "(901,)"
       ]
      },
+     "execution_count": 97,
      "metadata": {},
-     "output_type": "display_data"
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "hf2.shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 98,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[<matplotlib.lines.Line2D at 0x1c256f0668>,\n",
+       " <matplotlib.lines.Line2D at 0x1c256f07f0>]"
+      ]
+     },
+     "execution_count": 98,
+     "metadata": {},
+     "output_type": "execute_result"
     },
     {
      "data": {
-      "text/html": [
-       "<img src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAoAAAAHgCAYAAAA10dzkAAAgAElEQVR4Xuy9CbQVxbn2/xwIaFAUMFEEAZUoEfAa4S5ACAbHaC4gYFZQ/EQJjldl0qsogyAIDomgoDgQgesnypVBgYtzPkRGvz+KH4LTBaMoYq6CXNQIejj/9dY5vendu4eqru49nP30Wi6QXVX91q/e7nr6ramiqqqqCrxIgARIgARIgARIgATKhkAFBWDZtDUrSgIkQAIkQAIkQAKKAAUgHYEESIAESIAESIAEyowABWCZNTirSwIkQAIkQAIkQAIUgPQBEiABEiABEiABEigzAhSAZdbgrC4JkAAJkAAJkAAJUADSB0iABEiABEiABEigzAhQAJZZg7O6JEACJEACJEACJEABSB8gARIgARIgARIggTIjQAFYZg3O6pIACZAACZAACZAABSB9gARIgARIgARIgATKjAAFYJk1OKtLAiRAAiRAAiRAAhSA9AESIAESIAESIAESKDMCFIBl1uCsLgmQAAmQAAmQAAlQANIHSIAESIAESIAESKDMCFAAllmDs7okQAIkQAIkQAIkQAFIHyABEiABEiABEiCBMiNAAVhmDc7qkgAJkAAJkAAJkAAFIH2ABEiABEiABEiABMqMAAVgmTU4q0sCJEACJEACJEACFID0ARIgARIgARIgARIoMwIUgGXW4KwuCZAACZAACZAACVAA0gdIgARIgARIgARIoMwIUACWWYOzuiRAAiRAAiRAAiRAAUgfIAESIAESIAESIIEyI0ABWGYNzuqSAAmQAAmQAAmQAAUgfYAESIAESIAESIAEyowABWCZNTirSwIkQAIkQAIkQAIUgPQBEiABEiABEiABEigzAhSAZdbgrC4JkAAJkAAJkAAJUADSB0iABEiABEiABEigzAhQAJZZg7O6JEACJEACJEACJEABSB8gARIgARIgARIggTIjQAFYZg3O6pIACZAACZAACZAABSB9gARIgARIgARIgATKjAAFYJk1OKtLAiRAAiRAAiRAAhSA9AESIAESIAESIAESKDMCFIBl1uCsLgmQAAmQAAmQAAlQANIHSIAESIAESIAESKDMCFAAllmDs7okQAIkQAIkQAIkQAFIHyABEiABEiABEiCBMiNAAVhmDc7qkgAJkAAJkAAJkAAFIH2ABEiABEiABEiABMqMAAVgmTU4q0sCJEACJEACJEACFID0ARIgARIgARIgARIoMwIUgGXW4KwuCZAACZAACZAACVAA0gdIgARIgARIgARIoMwIUACWWYOzuiRAAiRAAiRAAiRAAUgfIAESIAESIAESIIEyI0ABWGYNzuqSAAmQAAmQAAmQAAUgfYAESIAESIAESIAEyowABWCZNTirSwIkQAIkQAIkQAIUgPQBEiABEiABEiABEigzAqEC8KGHHsK9996Lzz//HO3atcPUqVPRvXv3QEQLFizAmDFjsGXLFrRu3Rp33nkn+vbtm0lfVVWF8ePH49FHH8WuXbvQuXNnPPjgg6ps55J/HzJkCBYvXqz+qXfv3pg2bRoaNWqk/v/777/HNddcg/Xr1+Pdd99Fz5498eyzz2bZtHDhQsyYMQMbNmzA3r17Vfnjxo3Db3/720w6+X+xxX0dddRR2LFjR5m5AKtLAiRAAiRAAiRQbgQCBeC8efNw6aWXQkRgt27d8Mgjj2DmzJnYvHkzWrZsmcNpzZo1ShxOmDBBib5FixZh7NixWLlypRJ6ct19991KFM6ePRsnnngiJk6ciBUrVuD9999Hw4YNVZrzzz8fn376qRKJcl111VU49thjsWTJEvX/3377LW666SZ06NABIjgPPvjgHAE4bNgwNGvWDGeccYYSjrNmzcKf/vQnrFu3DqeeeqoqRwTg/Pnz8corr2TqUrduXfz85z8vNx9gfUmABEiABEiABMqMQKAAFNEmIksiac510kknoU+fPpg8eXIOpv79++N//ud/8Pzzz2d+O++889C4cWM89dRTkOifiDIRZ7fccotKI9E5ibqJMLz66qtVRK9t27ZYu3ZtRjTK30877TS89957aNOmTdZ9L7/8cnz99dc5AtCvDSUKKDaKKHUEoEQOJUrIiwRIgARIgARIgATKiYCvANy3bx8aNGiAZ555JmsId+jQoUowvfbaazmMJCo4fPhw9Z9zTZkyRQ0bf/zxx9i6dasaFn7zzTczUThJd8EFF6go3Zw5c/D4449jxIgRStS5L/ldyho0aFAsAbh//34VRbz55ptx/fXXZwSgDG8ffvjhOOigg5TgnDRpEo4//vhyan/WlQRIgARIgARIoAwJ+ArA7du3o3nz5li1ahW6du2awSICSYSaDNl6r/r166uh3QEDBmR+mjt3rhJtEulbvXq1Gkr+7LPPVCTQuWSIVwTiiy++qASYlPHBBx9kFS/DxVLOrbfeGksAitC76667VITxyCOPVGVIpPK7775TQ9FffPGFGo6WKOOmTZtwxBFH+LqC1EP+cy4Rljt37lTpKyoqytB9WGUSIAESIAESKD0CMiq5Z88epUfq1KlTehVIwOJQASiiTYZfnUvm7z3xxBNKKPkJQBGHF198ceanJ598EoMHD1YLNxwBKOLy6KOPzqS58sorsW3bNrzwwgtKAPoJzBNOOEGVM3LkSGMBKMPPV1xxBZ577jmcffbZgchkbqFEKCVKKFFIv8tv4UgCbcAiSIAESIAESIAECkBA9McxxxxTgDsX/pa1eghYFrJI5FCGsv/lX/4lkvY555yDX/ziF1nzHt2ZvBHA3bt3qwUx4kCHHXZYZPlMQAIkQAIkQAIkUHgCsmahRYsWasqZTAUrxyt0EUjHjh3VKmDnkgUaMmcvaBGIhFOXLVuWSS8remX+nnsRiMwRlCibXDLXUIZkvYtAZLVup06dVBr5e5cuXYwXgcg9//jHP6p7y8KVqEvEnUQAZUjaWSgSlUccSBxHhCAFYBQt/k4CJEACJEACxUGA/TcQuQ3Mww8/rIaBZVuWxx57TM2Ra9WqFQYOHKjmCTpiUIZ4Tz/9dLXNi4hEGXIdPXp0zjYwkl62ZZFhXRnyXb58ec42MDJMLNvOyCWCTO7nbAMj/yZb0Yh4FKEmolMWiMj1q1/9Sv0pok/su//++9GvX7+Mt/30pz/NKH3ZSqZXr14qgvf3v/9dzQGUxS0bN25U99O56EA6lJiGBEiABEiABIqLAPvvEAEoTSXRv3vuuUdtBN2+fXsltETkydWjRw+1slYWbTiX7Ksnos9Z8Sti0C3AnI2gRdy5N4KWsp1LFlV4N4KePn16ZiNoSSf3lYUj3kvKd2zzW6l82WWXZey96KKL1B6EX375pdr7T6KMsoehRDl1LzqQLimmIwESIAESIIHiIcD+O0IAFk9TFacldKDibBdaRQIkQAIkQAJhBNh/UwBaPSF0ICt8zEwCJEACJEACBSHA/psC0Mrx6EBW+JiZBEiABEiABApCgP03BaCV49GBrPAxMwmQAAmQAAkUhAD7bwpAK8ejA1nhY2YSIAESIAESKAgB9t8UgFaORweywsfMJEACJEACJFAQAuy/KQCtHI8OZIWPmUmABEiABEigIATYf1MAWjkeHcgKHzOTAAmQAAmQQEEIsP+mALRyvLw50O7PgJ1bgCatgcObW9nMzCRAAiRAAiRQ7gTy1n8XMejAo+CK2OaiMS0vDvTmvwNLhgJV+4GKOkCv+4EOA4uGAQ0hARIgARIggVIjkJf+u8ihUABaNFDqDiSRv6ntq8Wfc1XUBYZtZCTQot2YlQRIgARIoLwJpN5/lwBeCkCLRkrdgT5aAczplWvhZUuB47pbWM6sJEACJEACJFC+BFLvv0sALQWgRSOl7kCfrgdmnplr4RV/BY7paGE5s5IACZAACZBA+RJIvf8uAbQUgBaNlLoDBUUAuw4Bzp1gYTmzkgAJkAAJkED5Eki9/y4BtBSAFo2UugPJHMAp7QBUZVspi0GGvcN5gBZtx6wkQAIkQALlSyD1/rsE0FIAWjRSXhzopdHA6mm5VnIeoEXLMSsJkAAJkEA5E8hL/13kgCkALRooLw7ElcAWLcSsJEACJEACJJBLIC/9d5GDpwC0aKC8OJAIwHUzgDUP1uwFWBfoNZV7AVq0G7OSAAmQAAmUN4G89N9FjpgC0KKBUncg9ybQqAC63gB0voZz/yzajFlJgARIgARIIPX+uwQQUwBaNFKqDsShX4uWYVYSIAESIAESCCaQav9dIuApAC0aKlUHCtoC5vezgfZ9LaxmVhIgARIgARIobwKp9t8lgpYC0KKhUnUgvwig2MrzgC1ajFlJgARIgARIAEi1/y4RwBSAFg2VugPJHMDFQwG4zgJWIpDnAVs0G7OSAAmQAAmUOYHU++8S4EsBaNFIeXGgdxYC8wflWsl9AC1ajllJgARIgATKmUBe+u8iB0wBaNFAeXEgLgaxaCFmJQESIAESIIFcAnnpv4scPAWgRQPlzYHUdjDDgKrK6uFf7gNo0WrMSgIkQAIkUO4E8tZ/FzFoCkCLxsmrA0kkcOdWoMnx3AfQos2YlQRIgARIgATy2n8XKW4KQIuGoQNZwGNWEiABEiABEigQAfbfAAWghfPRgSzgMSsJkAAJkAAJFIgA+28KQCvXowNZ4WNmEiABEiABEigIAfbfFIBWjpcXB1Jz/7YATVpz7p9VazEzCZAACZAACVQTyEv/XeSwOQRs0UCpO5Ba/TsUqNrPE0As2olZSYAESIAESMBNIPX+uwRwhwrAhx56CPfeey8+//xztGvXDlOnTkX37t0Dq7VgwQKMGTMGW7ZsQevWrXHnnXeib98D59ZWVVVh/PjxePTRR7Fr1y507twZDz74oCrbueTfhwwZgsWLF6t/6t27N6ZNm4ZGjRqp///+++9xzTXXYP369Xj33XfRs2dPPPvsszk2vfbaaxgxYgQ2bdqEZs2a4eabb1b53Jdp/bw3SdWBuP9fCTw+NJEESIAESKAUCaTaf5cIkEABOG/ePFx66aUQkdStWzc88sgjmDlzJjZv3oyWLVvmVG/NmjVKHE6YMEGJvkWLFmHs2LFYuXKlEnpy3X333UoUzp49GyeeeCImTpyIFStW4P3330fDhg1VmvPPPx+ffvqpEolyXXXVVTj22GOxZMkS9f/ffvstbrrpJnTo0AEiOA8++OAcAfjRRx+hffv2uPLKK3H11Vdj1apV+Nd//Vc89dRTuPDCC1U5pvXza89UHeijFcCcXrm3PXcS0K4Ph4NL5AGjmSRAAiRAAsVHINX+u/iq62tRoAAU0SYia8aMGZmMJ510Evr06YPJkyfnFNa/f381pv78889nfjvvvPPQuHFjJbwk+ieRuGHDhuGWW25Rafbu3YujjjpKCUMRahLRa9u2LdauXZsRjfL30047De+99x7atGmTdd/LL78cX3/9dY4AlPIlgijlOZdE/95++22IUJXLtH55F4B+EUDHiIo6QK/7gQ4DS8TNaCYJkAAJkAAJFA8BCsCARSD79u1DgwYN8Mwzz2QN4Q4dOhQbNmyADK96L4kKDh8+XP3nXFOmTFHDxh9//DG2bt2qhoXffPNNnHrqqZk0F1xwgRrenTNnDh5//HE1bCuizn3J71LWoEHZZ+IGCcDTTz9d3eP+++/PFCMRyT/84Q/47rvvlBg1rZ8jWEW0Opc4UIsWLbB7924cdthhyXu2+wQQb+lyIsiwjYwEJk+dJZIACZAACdRyAhSAAQJw+/btaN68uRo67dq1a8YNJk2apISaDNl6r/r166uh3QEDBmR+mjt3rhJtIppWr16thpI/++wzFQl0LhniFYH44osvQsqXMj744IOs4mW4WMq59dZbs/49SABKevnttttuy6R37i91EwFoWj8paNy4cWoOo/dKTQDKjSQSuOlZ4KUDdcnc/7KlwHHBczJr+fPL6pEACZAACZBALAIUgBECUESTDL86l8zfe+KJJ9RwrJ8AFHF48cUXZ3568sknMXjwYLVwwy3Ajj766Ewamae3bds2vPDCC0oA+gnME044QZUzcuRIbQHoFYwiZn/961+rBS379+9XAtCkfnJjEbJ5jQA6teWCkFgPODORAAmQAAmQgB8BCkAOAWsPcRfcgdzDwTL822sq5wDyvUYCJEACJEACMQhQAIZsBC2LJDp27KhWATuXLNCQOXtBi0D27NmDZcuWZdLLil6Zv+deBCJzBGVLFrlkruGRRx6Zswhk3bp16NSpk0ojf+/SpYvxIhBZNSwrlp3r2muvVfMX3YtATOpXcAEoBqhNobcCTY7n3L8YDzyzkAAJkAAJkIAQoAAMEYDONikPP/ywGgaWbVkee+wxta9eq1atMHDgQDWM6ohBGU6VxRcyTCwi8bnnnsPo0aNztoGR9LNmzYIM68qQ7/Lly3O2gZF5erLtjFwyR1Du52wDI/8mwk7Eo2wzI6JTFojI9atf/Ur96WwDIyuLZYhZRJ+sAvbbBiaofjqPCB1IhxLTkAAJkAAJkEBxEWD/HXEUnET/7rnnHjVvTvbVE6ElIk+uHj16qP35ZNGGc82fP1+JPmfFr4jBfv36ZX53NoIWcefeCFrKdq6dO3fmbAQ9ffr0zEbQkk7uKwtHvJeU71yyUlmijc5G0LI1jN9G0EH103FVOpAOJaYhARIgARIggeIiwP6bZwFbeSQdyAofM5MACZAACZBAQQiw/6YAtHK81B1IzfnbAjRpzTl/Vi3FzCRAAiRAAiRwgEDq/XcJwA49C7gE7C+oiak6kFr1OxSo2g/w5I+CtjNvTgIkQAIkULsIpNp/lwgqCkCLhkrNgbjvn0WrMCsJkAAJkAAJhBNIrf8uIfAUgBaNlZoDfbQCmNMr1zKe/GHRWsxKAiRAAiRAAtUEUuu/SwgwBaBFY6XmQIwAWrQKs5IACZAACZAAI4BRPkABGEUo5PfUBKDckyd/WLQMs5IACZAACZBAMIFU++8SAU8BaNFQqTuQ9+QPrgq2aC1mJQESIAESIIFqAqn33yUAmgLQopHy6kBcFWzRUsxKAiRAAiRAAgcI5LX/LlLwFIAWDZM3B+KcQItWYlYSIAESIAESyCaQt/67iMFTAFo0Tt4ciKuCLVqJWUmABEiABEiAAtDrAxSAFk9F3gQgI4AWrcSsJEACJEACJEABSAGY4FOQNwEoNnNVcIItx6JIgARIgATKmUBe++8iBc0IoEXD5N2BvKuCLWxnVhIgARIgARIoVwJ577+LEDQFoEWjpO5A3PbFonWYlQRIgARIgAT8CaTef5cAeApAi0ZK1YG47YtFyzArCZAACZAACQQTSLX/LhHwFIAWDZWaA3HRh0WrMCsJkAAJkAAJhBNIrf8uIfAUgBaNlZoDcdsXi1ZhVhIgARIgARKgAIzyAQrAKEIhv6cmABkBtGgVZiUBEiABEiABCsAoH6AAjCJUCAEo9+S2LxYtw6wkQAIkQAIkEEwgtQBOCUGnALRorNQdiNu+WLQOs5IACZAACZCAP4HU++8SAE8BaNFIdCALeMxKAiRAAiRAAgUiwP4boAC0cD46kAU8ZiUBEiABEiCBAhFg/00BaOV6BXEgbg5t1WbMTAIkQAIkQAIF6b+LDDsjgBYNkncH4ubQFq3FrCRAAiRAAiRQTSDv/XcRgqcAtGiUvDoQt4axaClmJQESIAESIIEDBPLafxcpeApAi4bJqwNxc2iLlmJWEiABEiABEqAAdPsABaDFE5FXAcgIoEVLMSsJkAAJkAAJUABSACb0FORVAIrN3Bw6oZZjMSRAAiRAAuVMIO/9dxHCZgTQolEK4kDcHNqixZiVBEiABEiABLgIRHyAAtDiSSiIALSwl1lJgARIgARIgAQoACMF4EMPPYR7770Xn3/+Odq1a4epU6eie/fugb6zYMECjBkzBlu2bEHr1q1x5513om/fvpn0VVVVGD9+PB599FHs2rULnTt3xoMPPqjKdi759yFDhmDx4sXqn3r37o1p06ahUaNGmTQbN27E9ddfjzfeeANNmjTB1Vdfre5bUVGh0vTo0QOvvfZajp2/+93v8J//+Z/q3y+//HLMmTMnK43Ys3btWu1ngwJQGxUTkgAJkAAJkEDREGD/HRIBnDdvHi699FKICOzWrRseeeQRzJw5E5s3b0bLli1zGnHNmjVKHE6YMEGJvkWLFmHs2LFYuXKlEnpy3X333UoUzp49GyeeeCImTpyIFStW4P3330fDhg1VmvPPPx+ffvqpEolyXXXVVTj22GOxZMkS9f/SaJL3jDPOwKhRo/DBBx8oMXf77bfjxhtvVGl27tyJffv2ZWz86quvcMoppyj7Ja0jAL/44gvMmjUrk65+/fpKUOpedCBdUkxHAiRAAiRAAsVDgP13iAAU0dahQwfMmDEj02InnXQS+vTpg8mTJ+e0Yv/+/ZU4e/755zO/nXfeeWjcuDGeeuopSPSvWbNmGDZsGG655RaVZu/evTjqqKOUMJQo3rvvvou2bduqKJwjGuXvp512Gt577z20adNG2XPrrbdCxNtBBx2kyrnrrrtUlFCEoxMFdBsokUsRoxLJPOSQQzIC8Ouvv8azzz4b2yPpQLHRMSMJkAAJkAAJFIwA++8AASjRswYNGuCZZ57JGsIdOnQoNmzY4Du8KlHB4cOHq/+ca8qUKWrY+OOPP8bWrVvVsPCbb76JU089NZPmggsuUMO7Mhz7+OOPY8SIERBh5r7kdylr0KBBGDhwIHbv3o3nnnsuk+Stt95SYlXucdxxx+U41Mknn6xEpBNVlAQSCRTxJ1E/Kf83v/mNik4eeeSR2g5JB9JGxYQkQAIkQAIkUDQE2H8HCMDt27ejefPmWLVqFbp27ZppsEmTJimhJkO23kuElAztDhgwIPPT3LlzlWiTSN/q1avVUPJnn32mIoHOJUO8IhBffPFFSPlShgzrui8Z8pVyJPJ37rnnqiFht5hz7JV7iNBzXzJPUKKJ69atQ6dOnTI/yRD3oYceilatWuGjjz5Scwh//PFHrF+/PhNZ9NZR6iH/OZc4UIsWLZQgPeyww5J1bJ75myxPlkYCJEACJEACNQQoACMEoFdQSYTsiSeeUMOxfgJQxOHFF1+c+enJJ5/E4MGD8f3332cEoIi1o48+OpPmyiuvxLZt2/DCCy8oAegnME844QRVzsiRI5UAlCifzEl0LhGVxxxzDGQeYpcuXbJMk6FlqYcsHAm7ZHhYxODTTz+Nfv36+SYdN26cWsTivRIXgDzzly8pEiABEiABEkiNAAVgLR8C/u6775TYvOOOOyDD11GXCM0rrrgiM0fRmz4vEUCe+BHVTPydBEiABEiABKwIUABGLALp2LGjWgXsXLJAQ+bsBS0C2bNnD5YtW5ZJLyt6ZX6dexGIzBG8+eabVRqZayhz7ryLQNzDtfJ3ieq5F4HcdtttahGIDDvLJfkfeOCBnEUgMpx8zTXXqGHnI444ItRZZKWwDHvL0LLMM9S5UnEgnvmrg55pSIAESIAESCA2gVT679jWFCZj4EbQzjYwDz/8cGYBxWOPPYZNmzapoVIRSSKYHDEow6ynn366WkghIlEWaYwePTpnGxhJL1uvSLRNhnyXL1+esw2MDBM7Q7wyR1Du52wDI8Otshr4zDPPhAjBDz/8UC3okFW+zjYwDkrZlkZslGFd9/XNN99AhnMvvPBCFSH829/+psr65JNP1EpkZ0uaqCZJxYEYAYzCzt9JgARIgARIwIpAKv23lUX5zxx6EohE/+655x61fUr79u3VSlwReXLJZsuyGEOibM41f/58JfqcFb8iBt3z6ZyNoEXcuTeClrKdS/bw824EPX369JyNoK+77jq1EbRsMyNRPhGA7i1gZCGJCMWXXnoJ55xzThbZf/zjH2o7G1k9LCuORQTKvoKyh6Es6tC9UnMgnvmr2wRMRwIkQAIkQALGBFLrv40tKVwGHgVnwT5VB+KZvxYtw6wkQAIkQAIkEEwg1f67RMBTAFo0FB3IAh6zkgAJkAAJkECBCLD/DlkEUqA2KanbFsSBuD9g8fkI26T42oQWkQAJkEAIgYL030XWIowAWjRI3h2I+wNatFZKWdkmKYFlsSRAAiSQHoG899/pVSV2yRSAsdFBnX18+OGHp3MSiNcurg62aKmUsrJNUgLLYkmABEggXQJ57b/TrUrs0ikAY6PLswBMY39ADl1atD6ANNrEziLmJgESIAES0CBAAcg5gBpuEpwkrw6UdLRp1QPAK2OBqiqgog7Q636gg94G2FbQalNmvzZBHWD4O8DhzWtTTVkXEiABEqhVBPLafxcpOUYALRom7w6U1P6Ar04AXv+Tp+YULrFcQdpk8RAAVTXZK4DeD1BMx4LJTCRAAiSQHwJ577/zUy2ju1AAGuHKTlwQB7LdH3DV/cDLY/1r3XUIcO4ECyJlmNWPZ0VdYNhGRgHL0B1YZRIggdIgUJD+u8jQUABaNEjJOZCIxyltg2ssQ8HDOHyp7RKKZztX9M+V87KlwHHdtYtiQhIgARIggfwRKLn+OwU0FIAWUEvOgd5ZCMwfFF5jChd9jwhaBEIhrc+QKUmABEigAARKrv9OgREFoAXUknOgKAFI4WLmDb6LQACcMwHoJvMCeZEACZAACRQjgZLrv1OASAFoAbXkHChqCPiUAUDfGRZEyjArF4GUYaOzyiRAAqVOoOT67xSAUwBaQC1JB8oRLC4AXLxg7g1Jb89jbgFzkAAJkAAJGBIoyf7bsI5RySkAowiF/F6yDiSiZf0cYMXdubXjHEAzjwgaVidHM45MTQIkQAJ5JFCy/XeCjCgALWCWtAMxcmXR8jVZw6KpnAdoz5clkAAJFDeBEj5NqqT774S8ggLQAmTJO1BSG0tbMCzZrEELQJwKcTi9ZJuWhpNADoESFjqptWaJnyZV8v13Ag1LAWgBsVY4kO3G0hb8Sjpr0BYw7kpxGLikm5jGk4AioD6UhwJV+3lspuMStWAD/FrRf1s+ohSAFgBL0oH4Jbvog00AACAASURBVGvR4q6sURFASTp8M08DSYY2SyGBwhDgVJlc7rVkA/yS7L8TfgooAC2ApulAm77chPvW34cRHUeg3c/ktIkELn7JJgDRVcSia4G35waXyXmAyfJmaWYE+LFnxssvdVCkv5yj+2GjH1f8FTimoz33PJSQZv+dB/MTuQUFoAXGNB1o8uujMHfrYlxy/AUY2X2ihZU1Wfkla8/QXYJOBJAbayfLnKXpE+DHnj6rsJR8bzICmIwnFWUpFIAWzZK0ANz+zXbs2rsLFe8tw7Xvz8LOunXRpLISM9oMQtUvf4fGBzVGs0ObxbOYX7LxuAXl0pkDKHnLOVKQLHGWpkuAokWXVHQ6tdL/hux03DAf8JsDiDrA8NI5Sz7p/jvamYovBQWgRZsk7UAnzzn5gDVVVUBFBeD8WfPLxss2xrM4rFOQEnduAZq05pw1Xbo6EUApq4SGRHSrznRFToAfe8k0UNBcN0b2qxfGeIUxKoDeDwAdBibDP+VSku6/UzY3leIpAC2wJu1AS7cuxeiVo1Apq808V92KOpj46zvR8/ie8S322/ZFSuMKt3hM1TYIt1evDpSvX+S2GyOA8dAylwWBIOHCOalmUMOi/OUc2Q/7+C2h7a+S7r/NnKs4UlMAWrRDGg60+ePl6L/cM+QAYF6PaWjbqoeFtTVZ3du+yD9NbV8jYGp+L6EH2B6GRQnuOVby5dt9BLByCllaIGXWhAgEnfnNyJUZYEYA/XlFTX8pEXGcRv9t5mCFT00BaNEGaTjQ5q82o//S/qioqkJVRUXmz3k956HtEW0trPXJyqGieDyDhtPPHge8Mg6oqgRESPeaWjLDIfFAMFdREmDkKrlm8Tvt55w7gG5Dk7tHqZXkO/+v9AIIafTfpdaUFIAWLZaGA+34dgcuWnoRmh58BPr9rCMWfrkeO77/Ck/3fBpND2lqYa1PVk4Wj8czTDg3OR7YuRWQPw9vHq985iIBGwKMXNnQy80rPFfcC6yf5aickprrliiMqOHfEvroTaP/TpR1HgqjALSAnJYD7avch3p16qGiogJVVVX4Yf8PqF+3/gFLk9zfi8fBmXvAq3cAr/85N5+z4CPJ9jG3jjlIoGaS/hAAVQdo9J7GiHQc3/AV1BXA8E3l95EX9PH720lA2z4lxSOt/juOixUqDwWgBfmCOFAa+3vxODh9L4jaBX/XR1xUo0+TKdMkIIuUXh5bLQJl/l+v+ykA4/B+ZyEwf1Buzt/PBtr3jVNi6ebxjQDWAX7/F6BFZwrAEmtZCkCLBsu7AOSQrUVrJZQ16AtYOtjBrwB/OZsLQRJCzWIsCHy6HvjLWdXbSDkXF3jFA/rGTGDZjRSADgH3qJEsgFNX6X1k5L3/jud9qeaiALTAm3cH4qINi9ZKKGvQHBjZYqPZr4A5vXJvVCKr4hIixGIKTcBv4YJjE33RrHWCWMoercPKcAjYoSfvwW1vAAv+mP3BW0KbQee9/zbzvLykpgC0wJx3B0orAsg5a2ZekPUFXAc4Z1z1qsC02sfMOqYuZwKhG5SX1kkNBW/GQJYVwDnjy3slsDROUECi6xDg3AkFb74oA/Lef0cZVIDfQwXgQw89hHvvvReff/452rVrh6lTp6J79+6BZi5YsABjxozBli1b0Lp1a9x5553o2/fAHAlZ0DB+/Hg8+uij2LVrFzp37owHH3xQle1c8u9DhgzB4sWL1T/17t0b06ZNQ6NGjTJpNm7ciOuvvx5vvPEGmjRpgquvvlrdVxZNyDV79mwMGpQ7Z+Mf//gHDj744Ew5pvXzVrwgDmS7aMMr9tKYU1gAR877LYPmTdq2T94rUgtvWM4fNKF7tJXWSQ0F98wwluU+p1JFANcB8/+YvdBIGq1E9pssSP9dcKfONiBQAM6bNw+XXnopRCR169YNjzzyCGbOnInNmzejZcuWOdVYs2aNEocTJkxQom/RokUYO3YsVq5cqYSeXHfffbcShSLQTjzxREycOBErVqzA+++/j4YNG6o0559/Pj799FMlEuW66qqrcOyxx2LJkiXq/6XRJO8ZZ5yBUaNG4YMPPsDll1+O22+/HTfeWD1PQ8ofOnSoKtd9NW16YBsV0/r5tVvBHCjuog2v2MvsW+c6wYLzhPQe0TCREbd99O7MVGEEvBt0l1ukJmiFusOMz7f+8xMaTRWhUxcYtrGkFj7oVz4kZdYzFpDOZqpBnj7gCtZ/J9IIyRQSKABFtHXo0AEzZszI3Omkk05Cnz59MHny5Jy79+/fX4mz559/PvPbeeedh8aNG+Opp55S25k0a9YMw4YNwy233KLS7N27F0cddZQShhLFe/fdd9G2bVusXbs2Ixrl76eddhree+89tGnTRtlz66234osvvsBBBx2kyrnrrrtUlFCEo0QBRQDKfb7++utASqb1KyoBGKftg1Zv8fgyc5qMmpozy0eOoBXa5XIEWtgKdTd/m845H+1YTPfImu7hY1i5sYwSxQ6iuGeg5/HdSgEIOWjCvUysuvX27duHBg0a4JlnnskawpWo2oYNG/Daa6/lPAkSFRw+fLj6z7mmTJmiho0//vhjbN26VQ0Lv/nmmzj11FMzaS644AI1vDtnzhw8/vjjGDFiRI5wk9+lLBnWHThwIHbv3o3nnnsuU8Zbb72lxKrc47jjjlMC8IorrkDz5s1RWVmJX/3qVyoy6dw3Tv0cwSqi1bnEgVq0aKHsOeyww4rptZVrS+Dq1YrslYIlNIm3IMA5z68g2LVuGrRdR4kMSWnVMSxR1BFdkrdco1Y2cIMWPJQjSx0fE9Zx5gHm+d1KARggALdv367E06pVq9C1a9fMozNp0iQl1LxDq5Kgfv36SngNGDAgk37u3LlKtIloWr16tRpK/uyzz1Qk0LlkiFcE4osvvggpX8qQYV33JUO+Uo5E/s4991w1JOwMEUs6x165h0QLJWr4X//1Xzj55JNVVPL+++/HsmXL8Pbbb+OEE07IpDepn9xn3Lhxag6j9yoJARj0cMkwsLNXmKoY5wmF9hVciW3TlaabN0gAyl3LIVITGZ2pA/TmXoCxnZDze/0XuvkBjfPRled3KwVghAB0BJXTvjJ/74knnlDDsd5LBKCIw4svvjjz05NPPonBgwfj+++/zwhAEWtHH310Js2VV16Jbdu24YUXXlAC0E9gimiTckaOHKkEoET5ZE6ic4moPOaYYyDzELt06ZJj2/79+1WE8PTTT8cDDzyQIxh16idpRMiWbARQKuD3Amt9FjC1Pfeu0+0V8vyVqmsW06G6c5rid152+ZzasGn+/8J9X67DiJ1fo92+fcDRvwJ2/L/q57vcFy4k8ZBwfm9uP3J8D2DLq7l0TT+6ok5YSqL9XGVQANbSIWA/PxGhKXMEZY5i3CFgb7kl6UDeF1iev7oSfoYLU1xUJCBPk5gLU/kiv+urE4DX/5RtZLns2bb7M0z+926Ye1hDXLJ7D0bu3JXbWOU4bFnkLluS5rn7EamAbRAhbP6qqZDUBFqS/bdm3XSThS4C6dixo1oF7FyyQEPm7AUtAtmzZ48aanUuWdEr8/fci0BkjuDNN9+skogQO/LII3MWgaxbtw6dOnVSaeTvEtVzLwK57bbb1CIQiTrKJYtIJLLnLALxVl6mOUp5MiQs8wzlkkUgJvXzA1orHIgRLd1nJTtd6DYwQxlxiUfVLleZboC8/Zvt2LV3FyrWzsC1X/wVO+vWRZPKSszY8Xd1EnDj/fvR7MfKA2xT6lDtGq9Ic/NjTq9hFl0LvD33QNpTBgB9DywgjSwk7ISlYe+kstK6VvTfkWDDE0RuA/Pwww+reXUy5+6xxx7Dpk2b0KpVK7UYQ+YJOmJQhotliFWGiUUkyiKN0aNH52wDI+lnzZql5uLJkO/y5ctztoGRYWJniFfmCMr9nG1gZL6drAY+88wzIULwww8/VNvAyJYzzjYwMk9PRKPcQxpZxKEMXcucP0dYOtvABNVPh2utcSDvw3tSH6D/HB0ETOMmQDFdOH8o4w2QT55z8gHusqZPIp7OnzW/bPzok+q/MQKo76N+K1JlyszOLUCT1qmIEn3jiihlEu+9oAhg95uAs8akUtla039b0IncCPqee+5RG0G3b99ercQVkSdXjx491GIMWbThXPPnz1eiz1nxK2KwX79+md+djaBF3Lk3gpaynWvnzp05G0FPnz49ZyPo6667Tm0ELdvMXHPNNUoAOhtBS5Rx4cKF2LFjBw4//HC1+lcWcIiQdV8S3Qyqnw7TWuFAQR1nuWydodPQumk4nK5LKvl0ZbwB8tKtSzF65ShUyjw/z1UXwMT/3ome33wDyAp/59Sa5FugdpXo+16sqBHXZT6f0hsVTeK9FyQAU5y3Wiv6b8unjkfBWQCsFQ4U2HGWz8R5CxfIzprEl3BixpRZQVErYGt55Gvzx8vRf/kNOY0+r8c0tP30/wGvjK2JCtYBenElcOTTobPdSS33KV9GQVFR2zmAoaeupLPhdq3ovyMdOTwBBaAFwFrhQIErJwH8fjbQ/sBRfhaoalfWsHlBUQtEaheJ4qpNGW/au/mrzei/tL9s7IqqiorMn0oAzu7LVf6mnhr1QeGUV07zKcM+cGUV8JJhQFVl9TSDXlOBDgP1qUfxToFzrei/9Qn7pqQAtABYcg4UJFyWDAXWHxjKzyChAMz1Dp2d6rlVhMVTZZm1TDft3bFjAy76zwFoWvkj+u35FgsbHoIddX+Cp0/9NzRdPCwXagodqmXLFV/2rA+KOjVn3sqympqr3CKAUUO9zrMnS49adDafI6kWcQ0FvKdTpcS55PrvFJ4QCkALqCXlQGHCxW/+RblsnWHS/hziNaFV2LRZnUmCGyCrTm5ddd3idHJpUfloBfbN6YV61Vu5q9W/P8gG/fIRt+CPjADG5e7+mLONcsW1oVjyRb3/dD6Oo+oi91j3MLBmes1OCjGiiVH3qPm9pPpvzTqZJqMANCXmSl8yDhT14Eqdknh4LViWRNaoL+CSqEQtN9KJcm/fALxye7Lb8eRsM1NEp+akOTxXy10mtHreUZNyj+4H9RM6fYyJH+WBc8n03ybcDNNSABoCcycvGQfSFS55eOgscBc+a9IvucLXqHZZ4O6cvDWzHUYKW6WY0j5lxo0TNv+Uz7YxTqx6gItnvNSyPoJcH0C6fUxYK7jFtqRLebudkum/zT1XOwcFoDaq3IQl40AULhat7MnKRR7JsUyypKhJ5HIvm3lvYasUbcpNmoEanq4AWnQyn4OVpC2lXtaq+2vOSHdVxPYjotSZhPUjUrcp7WomH7gqqrudWNbHm0xikEv2tExv1XrJ9N8p+g0FoAXcknIgTeGy6ctNuG/9fRjRcQTa/UweaF45BBhNKT6niNq2w7bzDlstf8VfgWM6FpZJ1BSOsJXrhbW8+O4eFO11PiKaHJ96dKr4oAAIi/IJE79zuEXARUXIoz7ebJ/dAJgl1X+n5BAUgBZgS86BNITL5NdHYe7Wxbjk+AswsvtECzplnpUdbn4dIKwTibMthdd6v4iQk6bQEcCoRVxR4jC/LVX8dws7luzs8cnPLS1+ItUWhkUAZbh2Ti//mkQ9H1Efb47wPq57oqRKrv9OtPbVhVEAWkCtLQ6UOUv0vWW49v1ZB84SbTMIVb/8HRof1BjNDm1mQarMsrLDLUyDe6PcZ9+OTQ2PwH3bXsCIzrfGj2iHRYSkprrDXGlReWchMH9QbumyAliGgm036U3L7mItN+hjQo4lW3lfea+oDhpJCnxGNA4UYASwYE8CBaAF+toiALXOEr1sowWpWpY1LLrH+ZaFbWxPlDuRiHZUhCKlISptkGEC8JAj/CMzUVEZ7ZvX0oTePQDlCL1mp8Zn+el64JM1QMvTCj9dwLbJgkaSfOdNVgDDNkXPR83iLUfuyRRAmQPIbWBsmyssPwWgBd3aIgBDzxKtqIOJv74TPY/vaUGqFmWNiu4lsRquFuEqRFUSj2i/egfw+p/Dq1JIQeU7PF0TeRGrGQGM54Yi2ratBVp0qRZtcT/uFl0LvD33gA2nDAD6zohnU6FzhX382r773MJS6rlzKyBzCw9vnkqta0v/bQOHAtCCXsEcKIX5ZaFnibbqYUGpFmXV6QB00tQiJEVVlZrn4uQV1x0wS0URKmqiCc7qQmCjbkQ7bPGHu/IyPHjWmPzjCBo+cw9Lay4Ay7/xRXzHoA89U5YiImeemVvRYlg4ZIo/6uO3xN59Beu/TbmnmJ4C0AJuQRwo6iGMWZ/As0R7zkPbI9rGLLWWZQsaavNGf0w7iVqGqSDVcT0XSw89BKN//jNUqvMwsq+6phHtoDb3Fqyz2jENMLpRF40FYGmYV5JlRgkZE5arpwMvjcrF8NtJwGmuD5ViBxXFxLG/hN59Bem/i6ydKQAtGiTvDqT7EMao045vd+CipReh6cFHoN/POmLhl+ux4/uv8HTPp9H0kKYxSqxlWXJOgaipX9D8L5NOopahynt1fJ6LzfUPQv/mR+WYMq/HNLQ1iWjrCkC5UyGGgVN8J+S9HYvlhrqiWsfeoAhgoSLGOjb7pTFhUiLvvrz333HZp5iPAtACbt4dyOQhjFGvfZX7UK9OPVRUVKCqqgo/7P8B9evWj1FSLcsSNMyW4ialtYxgutXxeS4216+H/s2Plm0OUFVRkflznmlEO2oFsLtmhRrWK6GoS7qOkFDpSYpq9eF4Q65hhV44ZIoqSSa6905hqpP71nnvv3Xrncd0FIAWsPPuQLYPYcoPlAXK4s4aJLxlm432fYvb9nKwzue52PGTerjoF23R9Kc/t49oy5FgL4+tOeWgDtD1OmD1tFyyhYgAOlZ4FyyUQ7unWcckRHXU9iaF9Jc47JJgonvflKY6UQBmNwAFoK5D+qTLuwAUG+I+hHl4oCxQFnfWoCjQ8M3BK9QotvPbpj7Pxb5TLkK9PX9Hxa6tqGp8PH5oeKR5RNt7RNU544H2v89dWSu1LdR+gHy20/E126HMsO2DSi0CaPqhEef95+Spdwjwl7NT32+xIP13Op4au1QKwNjogII5kOmLyTZyaMGoVmQNEoBBHT475MI0uzcKZtsOYc/NO/OL46xYk2c7TqdcmJYs7rvqcgyMAFYAvR8AOgws7np6rdN9nnTTucv3fmj5LOBKeo5twfrvImp1CkCLxigZB0p57qAFwtLIGvgl77PLvUmHXBq1Lw0rvZ3O2eOAV8bZRRHCnhvpoPyOvsr3sJ7usx2nUy6Nls+vlaYcszY4rjG1FOcO677XdNO5Wy1qqFzSphAxLZn+O0UPpwC0gFsyDmTyUOp+3VpwK7msKgIYsBWOdx6gbodcchCK2GDfDqQOgP25RpsINL/Ir+wpKCcbyFUMGyzrPNs6aYq4eYvGtLgcJTL9l7Oq96LMXBpHpBVNxQG8NFpv3muc91/Y2ctV+1M7DaRk+u8U/YAC0AJuSTmQztxB069bC3Yll3XJUGD97FyzvQIwbidRckCKyODADqRmA+iMqXWA4e/onyzgO/Tv6rh1nql8YIqyI06nnA+7i/kefh/CcTkG5Wt9FnDpwmKmUG1b0BQYv70v47z/gvIMfhn44bvUTgMpqf47JS+hALQAW3IOFDZ3MM6Da8Gu5LKGRYO8RxVFdcglV/kiNzjId2UYOLN6V+pgOPdKp8M3nY+bFko+28mRDfoQjvuODNoLUCwu1NZBJrSCnoOuQ4BzJ+SWFOf9FyePSR180pZc/21ZX7/sFIAWUGuVA+l0dhasSj6rvPzXzQDWPFg9ryxqHk+xCIOSB69ZAb8ORCIsNsO0cTt8TZPzmqwAHWxe65fUzaLa3JRj1uIGHyNL4USQOMfZmb7/JP22ddUfaS066UfpLdq9VvXfMTlQAMYEJ9lqlQNFvfgsOJV8Vu8Kta43AJ2vyctLquTZ5bMC3k7H9qNGbeI7pGb/P+mbKoBeJbh602kD0045n21XLPfS8RldjjqLG0o5AmgynzasfQs09ahW9d8xnx8KwJjgap0AlAqZft1asCuZrBTGpdFUfnO2bNouaGGJyRzC0iBX0lZu+nIT7lt/H0Z0HIF2P2tnXxcbn/HePWwfQEl7ygCg7wx7m9MuIQ4Tv+fRz844ZSdUXwpAyAlJWUuTEkJbHsXUSgfS/botjyYGdCICQSx0X4LlwjKteoZFEFQUb2jNiuA6QO/79fZf0233YmjjYrAhrbaNKHfy66Mwd+tiXHJkZ4zsOj6ZqHxSH8K+HxEV1aMHR/wCaHN+Mvbmgf2mlffgvncew4idX6PdD5VAr6nBz5FJRE/3OUuhjrWy/zbkRAFoCMydnA5kAa9Ussb9QjV5CZYKi2K0M6p94rZDVLmZiPlQvTmhabEzqV8tEYrbv9mOXXt3oeK9Zbj2/VnYWbcumlRWYsaO/0bVb/4NjU/5X2h2aDM74kl9CHvF5D/1B/7f04X1mRhkDgjtLhjZdVz4CUgm826F8xSJ3Lq2yHG2WvIurothd1gW9t+MAFq5VK11oFrSUVg1rjuzaURARzwkZlyZFxQWQWhyvN0ikLB2L4Y2NrHBRCgWuUudPOfkAxbKAJYIBufPml82XraxeGrhiMl6DfJyxFlSFQ8U2m0GoeqXv0PjgxrnCm3TiJ6fAJSFIMM3pR4drbX9t4EDMAJoAMubtFY6UC3qKCyaNjerSUTA9CWYqKFlVliYCNq5xf60Du/xcg7eYmhjXRtMhGIJuM/SrUsx+vVRqPTZ6LtuVRUm/nIQena5Md2axPlI1m2vdC3XLj2W0Db1tQIyqZX9t3brViekADQE5k5eUg6k88IyfXgt2NXqrOSY3+ZNet82x/qwj6FiaGNdGwrYyablCJvfmI7+7z6SU/y8zz5H24EvAsd0TOvWNYvlYgz967ZXepYblayE9spRqJRtrzxX3Yo6mPjrO9Hz+J65ZZqMmIQxkZLlI65J61SigSXVfxu1nH7iUAH40EMP4d5778Xnn3+Odu3aYerUqejevXtg6QsWLMCYMWOwZcsWtG7dGnfeeSf69u2bSS/rTcaPH49HH30Uu3btQufOnfHggw+qsp1L/n3IkCFYvHix+qfevXtj2rRpaNSoUSbNxo0bcf311+ONN95AkyZNcPXVV6v7VshQAIDHHnsM//7v/4533nlH/X/Hjh0xadIkdOrUKVPG5Zdfjjlz5mTVRexZu3atNr2ScSDdqF4t7Ci0GzMqoY6Adpdh8hKMujd/DyeQtV2LZ7PnuO2g01nHLTvJ9tR5tnXqkqRNeShr86tj0P/TZyWCgaqKisyfSgBevAg4LrifsjLPlKX3vVEMPmMAYPPHy9F/+Q05Oeb1mIa2rXoEl2QyYuLHREqW05d09lw1qI87acn03zHrp5MtUADOmzcPl156KUQEduvWDY888ghmzpyJzZs3o2XLljllr1mzRonDCRMmKNG3aNEijB07FitXrlRCT667775bicLZs2fjxBNPxMSJE7FixQq8//77aNiwoUpz/vnn49NPP1UiUa6rrroKxx57LJYsWaL+XxpN8p5xxhkYNWoUPvjgA4iYu/3223HjjdVh/0suuUTZ3LVrVxx88MG45557sHDhQmzatAnNmzdXaSTPF198gVmzZmXqUr9+fSUoda+ScCCTF5ZJWl1ItSGdTifrV08ZPvxkLdCyS7oRidrAOG4ddHzWpDNy7ND9GIpTdty6+uVb9QDw8piaX0JOOikx4RGKaPdn2DHtFFx09JFoWvkj+u35FgsbHoIddX+Cpz//O5re8LZ9xCjog0/XL6QCYZHpnVtTO+IsSffa/NVm9F/aP1do95yHtkcEnI8exwD3cyT5TRaSxLlfbdvHNyaDQAEooq1Dhw6YMePAPkUnnXQS+vTpg8mTJ+fcrn///kqcPf/885nfzjvvPDRu3BhPPfUUJPrXrFkzDBs2DLfccotKs3fvXhx11FFKGEoU791330Xbtm1VFM4RjfL30047De+99x7atGmj7Ln11luVeDvooINUOXfddZeKEopwdKKAbgMrKyuVHdOnT8fAgQMzAvDrr7/Gs88+GxNdiWwEbfLCyry0hgFVlakdwh0beCEy6ggMP7viisZC1LGU72nq37p1jdvuuuUnkW7V/TVH3bkKq6gLDNvoL4AKLVaTqLOU8dJoYPU07ANQr/rsCLWG9AdUoP4544Fusu2PxZXE0L/f4oY8rW61qHlO1h3f7sBFSy9C03qHod9PW2DhP7Zhxw//g6d7Po2mhzRN8lYHykrrmfZYWxIBnHQIZ0r1FYD79u1DgwYN8Mwzz2QN4Q4dOhQbNmzAa6+9lmOWRAWHDx+u/nOuKVOmqGHjjz/+GFu3blXDwm+++SZOPfXUTJoLLrhADe/KcOzjjz+OESNGQISZ+5LfpaxBgwYpAbd7924899xzmSRvvfWWEqtyj+OOOy7Htj179uDII49U9enZs3rOgkQARfxJ1E/K/81vfqOik5JO9yoJB4rTkTFyZfcyisNc1+mYLpuALmvTIXy5SzFHzfwEhkMm7ISGOByKyedUvUMiT1FHNEbVRcefdPxChi/Xz8692+9nA+0PTIuKMqcYft/3/z2Oev95Iyqq9qOqog5++Jc/o/4//zHatLi+ptMG0XePTFES/XdkLewS+ArA7du3q6HSVatWqWFU55J5dCLUZMjWe4mQkqHdAQMGZH6aO3euEm0S6Vu9erUalv3ss89UJNC5ZIhXBOKLL76o5ulJGTKs675kyFfKkcjfueeeq4aEnSFiSefYK/eQaKH3uu6661T5MidQhoTlkiHuQw89FK1atcJHH32k5hD++OOPWL9+fSay6C1H6iH/OZc4UIsWLZQgPeyww+xaIs3cOi8s5/66kau4D3ea9Uyj7Dgvozx9waZR3ZIrM2v+X8Bxbbo+7Vf5Yo2aBfmYCKBh7/hHAG04FItjRJ2uIXaGRUGj6qH77Ib5RZhILTUBGOf9J4xtfc2kz4pq04DftZJszwAAIABJREFUKQADVgEHCSqJkD3xxBNqONZPAIo4vPjiizM/Pfnkkxg8eDC+//77jACUso8++uhMmiuvvBLbtm3DCy+8oASgn8A84YQTVDkjR45UAlCifDIn0blEVB5zzDGQeYhdunTJMk3m/8kQ8fLly/FP//RPga4iC11EDD799NPo16+fb7px48apRSzeq+gFoBis05HpPuxhk+5jPoxFnc30ZeTHUSp4zgSgm5wtyysRAr6c6wDu49p0fTpQ/KW3CtGKgamP2XCwMjThzGGRT/et4p5TmwSnQJGan/3tEiWuK4jdN02CoW6fZVFZCsAAAVhbhoD/9Kc/qYUmr7zyCv75n/850lVEaF5xxRWZOYreDCUbAYyseU0CnYfd9wVcgi82XSaSTobEP3gBOLQp0OY8vQnmpvOzTOxh2moCOv6qk8aPp20EIx9t5LZRZsKFzX+LyyEf9TC9x6Jrgbfnhue64q/xF16ZfvB5LTEV56b1z2f6OGLO1NcKNJpEARiyD6AswpDtU2QVsHPJAg2Zsxe0CETm2i1btiyTXlb0yvw69yIQmSN48803qzQiNGXOnXcRyLp16zJbtsjfJarnXgRy2223qUUgMuwsl+R/4IEHshaByPY1Iv5k6NcbFfR7fr766is17C1Dy85CkajnrNY5UNCLq20f4A81W+YsGQasP7ByOsOo1IY2ohrX+d3b2ege4G76EtS1h+kOENDpnHTS6HTgNsOKabWZSSQ+Doe07LYpN+gd5S2z4yCo82rjXjojJmFlu0Uk6gDnjLNfnBK3Ljb5dKZY2Dw/BfzQqnX9d4x2jtwG5uGHH1bz6kQYyf56spWKDJWKSBLB5IhBmX93+umnq4UUIhJlkcbo0aNztoGR9LL1ikTbZMhXhma928DIMLEzxCtzBOV+zjYwMtwqq4HPPPNMiBD88MMP1YIO2XLG2QZGhn1lTp/MQZR5h84lc/7kv2+++QYynHvhhReq4ei//e1vqqxPPvlErUR2tqSJ4lkrHejVO4DX/5xbdfmibtg0eAJ2bRSAEvmbeaY/i6iNZmtLhxv1EBT6d51ojU4adz1KQbzH8S9TDoVuW7/768wBdPIVespFkIgsUMTLuDl1plgEFarja3F82LgSwRlqZf9tyCdyI2gRUzI/rn379molrog8uXr06KEWY8iiDeeaP3++En3Oil8Rg+75dM5G0CLu3BtBS9nOtXPnzpyNoGX7Fu9G0LKwQzaClu1drrnmGiUAnS1gxC5ZWOK9ZK9AEX7/+Mc/1HY2snpYVhyLCJR9BWUPQ1nUoXsV1IHSeomsng68NCoXQbt+wD8P8j9aS1IX+mWr22gm6YJY/HYScNp10SXpvASjS2GKKAI60RqdNM59TDumtJ7FsHrHFamlvsJfNwIo7MIWxET5VBK/+/lFASNexlWK62Pu5yhsv0Pb8o0rlJ2hoP23pe1JZedRcBYkC+ZAab5EgqJe8jId/EruYeYOv2IcIrNoW5XVJgKo+xK0tZH5axY4JbxYQ1e8p/kshrWtqUiVsgpla9I+6m2bs2/P3Q/RuWfcxSARNm/6chPuW38fRnQcgXY/O3CSVSabH+vWZ+Vlg+PEcMfxMZObp11+hC0F679NGKWclgLQAnBBHCgfD80T/YAtr+aSkZfphrnBE7BTetlaNFH8rMJ53Qy14WzWpTsHMP6dmdOEQJqiJipqmI9nMYyFrkiVMmyG80zaI19p3W0j9wzaG9BmMUhIXSa/Pgpzty7GJcdfgJHdJ2anDPKLC2cC8wf5v1eTPrpORXrXAC1Pi78YRiyNOwda1w9MfFi3TM10Bem/NW3LVzIKQAvSBXGgfITNg15gg1+u/RHAjPCbXnO+gNtBavlqZ4tnoSBZCy3A8vEsRoGNEqlO/iBbuw4Bzp0QdZfi/j1sXmCCH6Xbv9mOXXt3oeK9Zbj2/VnYWbcumlRWYkabQaj65e/Q+KDGaHZos+DV6TJPesEfq8+3da40Rk6e/APw4YsH7hH3o9X2+dKdGqHrwwl7YUH674TrYFscBaAFwYI4kO1DqVtfvy+zxscGzwGM+5LRtSfNdM6LavuGmqEkOVgq4EqwQ0mzSmVRdqEFWL6exSQaU2ydIkOVHt82mSfnPCf1DgG+rplj3aKz3rZISdTBKcMrLJKom4Z9J885+UCqqipAjnZz/qz5ZeNlG/2jrY7Qk5EV2UkhraM2Z/cG/pZ7UhfiREJtnq80I/MabaWTpCD9t45heUxDAWgBu2AOFCdsrvs15ubh/TILm4CdxpesRdtoZ83aSy0il0lnqW0AE8YmUAwCLM6zGLvCnoymz3TNGbo5t9f5qAl8TiqA3g8AHarPWE/9ChIW3u1KxJBz7kh065WlW5di9MpRqHRH8GoqXLeiDib++k70PL76qNHQYwSl3ba9US3GkxTQQTs4iD26C9e87/+p7c0jlsXwXGo4YsH6bw3b8pWEAtCCdEEdyCRsnuTXmHrRymHrrmEMh6FOR2LBOyeraQfoLSAochBkY20YLkuSfzGUpSvAbH0lrK4mz2JSzOI803E75rAPP6lPvj6MouyX31fcW3MGr0To6gC97k9UnG7+eDn6L78hpxXn9ZiGtq16ZP97kF/Eabsov1HvspAzki+eV72Jveml+3y5y7WJHJraZ5G+oP23hd1JZqUAtKBZEg4U9dI0rb+U9/7zwLKbPMNJFcAVr9pNODaxJYmX6DsL/SdlB9kxfLP5cFeawsOEV21Nq6Ip60SFAC06JXcGrkm7maRNoh1snuk4HXpQ5NBdl3x8/EUJCxsu7rqEtOfmrzaj/9L+qKiqQlVFRebPeT3noe0RIQLMKT8pG71+pLM/Yu9p8cSw6QdOWnVM4tlxlVES/XfCdfYWRwFoAbgkHCjqpRkZ2XBtr5E1DFThv0giH8NBSb1gTAWg6V6HSYhUC/+0zppvYWNqsA7fOL6iU65jq0la0/oFpbd5pqVMkw5dJ0peLBFAWy7CJqI9d3y7AxctvQhNDz4C/X7WEQu/XI8d33+Fp3s+jaaHNI1u4SRs9LtL0JZVWWljLGKL+w6I86ERTS/RFCXRfyda49zCKAAtAJeEA8XpAP1ehGePA14Zlz0fxI9dPjqDpF6iOp2bu44mdYvL3cIfE8266gHglbE1k9yTH0qztlWXr6mv6JbrCKk4c6RsK29io9+9TDp1nciS+6hI27pF5Q8TFrb7dmpy3Ve5D/Xq1FMHD8jhBj/s/wH161YfSxp52doYdAOdKK3kNTmxyfbjxuRDI6heJr4aCT87QUn034Z1Mk1OAWhKzJW+ZBzI9GvM70Uo51n6zfvz45f2cFCSL1E1pzF3Tk+gW+jWzVR4WPhh4llX3Z+7sW6xLfLR5avZqWcY6pYrGUzSJt1Ips+0c3/TTl3nIynfvhEkLGzbwza/ThuncQ+dNnJs0xWAps9NGgLO1Fd1+Jdi/21YL5PkFIAmtDxpS0YAit0mX2OBX/1+w74+AONsOWDSDkm+RLWGTmqMM+noknqBmnBJIm1YZ6IrfpOwI6oME74mYsmkXJO0UfWJ87v47ra1QIsuenNv49qrE10qBt/w/XA1OKYyLh+TtrO10e9eOlFaJ5/uPOYk3rE2Ai4PbVFS/beJjxmkpQA0gOVNWmsdKOglpcsq7c4gqQhVaPSvAuh0FfB/H6se9hbx12uq2SRqE+GhyzbtdEEvfpPh77RtzIpmae6pZvIBZNJuJmmT5BKnc43bqUdFmEw+jJJgEDYsaPtuSKo907TRy1D7I9Zgyx5bAWabP66vGvhXre2/DRhQABrAKhsBKBX121dLl5XpYgndciVdkDjtfhNw1hj9kqJEbsdB1YLPRDj43d02v36NkkkZ1Jmc/AdA5oEe3jyZ+yRVimkUTPe+Ju1mklb3/mHp4naucfOFvQ/ifBjZMIiam5qEcLBtzyhxnoSNboYmIzYmYt1GDJvU0U8s2/iqpn9RAEJWsctW5rziEKj1DvTXO4EV94SjEWGw8T+y05i8ZEzBB0aoKoBeBhvSRg2b6A6VmNpf7OnDuKSwr5oVjqiO1qpww8xhER/DoiKTm3Su3sLidupSP9lu57tdQIMmQKOWwA/fAU2Oz99HgU50Lw/CIbR9dO7vG1GNsULXMSTonuffAyy7MddckxGauGJYt45hz3BcX418gKoT1Pr+W4MDBaAGpKAktd6B/vcfgP9ynSnpBSGC4MK/5O+Ac7m/RHz+clb16tQce+oCwzbqdUhBEcBiEzkW/hkrq18n6y4oTXFvYrBOR2tSnk3afAtR27qbdupB9cun6FWCImCfPa+gSVk4hLqKjjj3E0dyrNywTXrvLj8DVGT09uzpKq3P8jn+z0JomjwjQdMG3B/WOn5s6qsGNtb6/luDBQWgBqSyFIA680pkmPT0f8vfSyZrH8KAVjH5unV3FLLKuev1QOdr4r+ELXzJN6vTwcrZqz98CzRpna5tUcPijpEmjJNm4pSn09GmdW93uTqdWBp2+HX4aRzHFlQ/tS2UIzjysE2QnJ+7fpbPR18dYNg7uc9FisIhtDl1/CFp3816L1YA54yvPgIvCaEZV+QH1dF9mlLSHAyfMwpADgEbukx28lrtQKunAy+NCucjX3NyeQ+Zt/2a9burjjiJE50qVEcR5Xm+Ytf1co/KH+f3qGFxp8y0V3nr2K7T0eqUY5umEJ1YUIdvWxe//GFTLtxR+DjPnq69YdE/Z66ut6y4wkXXprB0URHIJH03rKydW4A5vXIt1f2As4lsB0UA3YvJkuQQo91qdf+tyYMRQE1QfslqtQOFRQDdw6T56gB1xMkpA4C+M4xadNOXm3Df+vswouMItPtZO6O8qSWOErtpLbKJuq9TYd0OJDVANYuB1s0A1jwYf5V2mH26AiLfnVgx3C9oT9C0/CLs2febq2sjXJLy2agPyyiRqGtH2PtX5md6NyqXthvuEzH1E9C2m5wHbR/k9pOkOOjycqWr1f23Jg8KQE1QZScApcKLrgXennug6if1ATpdkT3xO18dUtAXpbthYkQhJr8+CnO3LsYlx1+Akd0nWnhDglmjxG6aW7JEDbOneW9dhDL8+bJrxbcMK+kM3euKOlMBkc9OLF8fXO628Nbv7NuBl2/PPQoyrYVTQR8mfh9C+Xof6fpq5EfGVruFNFH1zdnNQXMrmCT8LMo2h02UWE6CtU8ZFIAcArZyrbJwIJ1tNvLVAc67DHj32fA204hCbP9mO3bt3YWK95bh2vdnYWfdumhSWYkZbQah6pe/Q+ODGqPZoc2sfMMqs878S416xrIhavufoCG3WDeLkSlokUqU+NAVdbqdll/EZKdlZ66DI659OmUHpZF7ygpgVAAtOlWn8k77kH9LKzId9DHaf06uxUkIF11Wuh8UuuXFTRf2/o3rL3HzeeuQr74hBruy6L8juDACGMNxnCx0IBe8tL/idCKAmp3QyXNOPmC4zGOSOYvOnzW/bLxso4VneLKadhRREUApPo15eDpDwLpHSSVH70BJceaCSW6TziyfAiIuoyQ6VV2f9BPOjY/1n1smAnG4xUrWMAGqOxxp0tZx+Us+3Q8Km3uY5A16/9r4cxJ+JnWQD9pP1gItNU+sMam3RVr234wAWrgP9xHKgafbqcShriOKpFyNYeClW5di9MpRqJQTPjxX3Yo6mPjrO9Hz+J5xrMzNE6ejCBM6zh3cq+mSsTT4bNtM+Sl18Dr2C5NNi0IWJoXYZtIJ6uw1p2Nv2ml0IvNBNuj6ZJCYGvwyMPNM/9J/dx/QaXCytTdpv4w40zwhxs/SqPdYvkRmEhRtbbX9sNf1tSTqalgGBSAFoKHLZCcvGQeKeqFZUajJnPaDrhsBFHM0hkc3f7wc/ZffkFPzeT2moW2rHkkQMYs8ue+ohmFzbcsyKo25eKF7AFbUbJNzbbpb0fiRj5qX6OQJik7qdoImc82S8ZB4pdg8a7osxLIw4fXOfGD9bB/7NeeYmdTcxGanXDVs/Ub1PMUWnfV9VoetqSANq2tS7+awcuJG8mxti9NuJn5hmbZk+m/LeoZl5xCwBdyScCCdF5oFA5U1Xw+67/y0iuzJ6BoRQDF581eb0X9pfzkKB1UVFZk/5/Wch7ZHBGw4a8opTkehMwzr2KEhdLVNDrqvHLFXuQ9YM71mtW0e9nxzG23CI2x4WqcTjNNe2oATSmj7rJnUMexeUh3Xxsyb6tfHfU0aYcTOr9Huhx/99+azQaDTft6PqCVDzXxWl61uuqj6JvVu1inHNJKnU2ZU/Ux8LaqsFH4vif47hXq7i6QAtABc9A6U1IsqilE+H/TMlz2qJ6RveRWQTWKrKquHf+X8Xo0NcXesexAXvfMgmlb+iH57vsXC5idiR0UVnu75NJoe0jSqxnq/x+Gf4FC3npE1qYLuK6JqwR+rO1Ln0hTZRvcPSqzLQ2f+WVQn6BdlTmNPSxswOltrhJVv6pP/cRmw2bXwyr3Vkmtz5slNGmPu4Q1xye49GLlzl1YU3giDeu5dC1HCzqQ2raNjiMl7zFSQeisb18a0yon66IrzzCdQxzS36Sr6/tvoAYmXmAIwHjeVq+gdyOSFZsEhbxHAIBujOvaAl+a+qv2oV722EVUVdfHDDetRv8lxNiRy85p2FL4RrzpA9xHAyinVQlcs7ngZcPrN+kNbUbUKEj8XPp7fo/68duqsiBYevQ3OgQ7zo5zVrQWc9+jnt36rb02nA+j6ZMR8yO3rH8euF29Wz8+1TY88sJp+x3+j6pJn0PiIE5NZTW8ajYr73jMVLKbvHXd7xrXR6xNJlZOGbVJmlK9FDDOnuU1X0fffUe/sBH6nALSAWPQOZPpCs2ChHvTFQwFIpKgO0Pt+rUiczS0zeU3nqqTx0gyriOkquKCX5qsTgNf/5LpTQsJHSvQTgNK1X/Eq8JezCxMBFJtCF36I4XWAK14Bjulo70r59gtTi4Psi7MgKEq8KH8IP3s3L6vp47zD4uRx2iJKsOi2WdQ7ycZGtw265UTZE6dMIxY+WyQFCPt8bdNV9P23Ll+LdBSAFvBKwoGSeqFFcTL9So8qz+93v5dYnPu+egfw+p9z75DG1ipx7BPLvKs8gxZomEZ/griHiZ8Nc7M3BI9x4opxc+su/DDZey6qE9TtTHV907jSERl8RTqAqD0Q49jxzkL/yK/L39Rq+tdvQ6UstPBcia2mjyvKbd57UeI4iqfuM29jo9uGqHJ07ckp03AOZRQXTZF58rPnHUiZ4jZdJdF/mzCNkZYCMAY0J0tBHSiqM/M+bGluUhs0bKlz5JAuf7+XWOuzco86ipqrEtSJih1JLqqQ8uIKCm9dzx7nf/KCwy4Ju4NslS0/vBFA3eOkdNvWm87XnwIK092XULcTjOpM/czQLTsuDydfUJQ2jb33ggSgZyPw1FfTx32GnI+ofO8/Z2qvrdh0+4bfO97UHqe8rAV3CYw0ePurEGG/tGp3XrbpKmj/bfsuSCg/BaAFyII5UL46HF02SQ5N+d0z6CV24Uzz+WlBtiYVSXPbHyd6ESSm1dC6z5Wk3X7iJ2jT3zjDjrb+5JdfRwCadoImnbJp2boM/NLF8ae499OMNgaupv/FQLTt9m9x756dL5+i3OTDutBtpEM3js8k7dMxPt5T/7AohTn8Ou1rmYYC0AJgQQRg0g+nRf0zWYM6i6TESZIrVINsNRlK1GUWp60CBWrNaSVZ907gy9xbF6/4SbttgwR/0Pwzb/11ol9xOkHdNk6zbL+20T0RI8p+HaGjMa93x7c7cNGSP6Dp/3yBfnu+wcKGh2BH3Z/g6c//jqY3vJ3sIiXdUYw4z53wSuLDOu69o9or7PewtoxjT5I+HXb/v04MnFqSj226CtJ/27RzCnkpAC2gFsSBknw4Leqek9V2e4qoF1xQx2e6DYxmZCMxNO7ohQydnjMO6CaLZQKuoBfmr4d7FoBI/jpAksPsQTal2bZ+9wzdkNrJYLDQyKQT1BFGbptNyk7CqeJEw7z3NRE6GtHQfVteRb0n+lWvpgfwA4D6cs8kpiY4tpu0S5x3ZJLtmEQb6fqKTlua2pMki5gf7+rDYulFaHrwEej3s45Y+OV67Pj+q0S36SpI/63brnlKFykAH3roIdx77734/PPP0a5dO0ydOhXdu3cPNG/BggUYM2YMtmzZgtatW+POO+9E3759M+mrqqowfvx4PProo9i1axc6d+6MBx98UJXtXPLvQ4YMweLFi9U/9e7dG9OmTUOjRo0yaTZu3Ijrr78eb7zxBpo0aYKrr75a3bdC9u2quZKwJawdCuJAST6cSTqZr7BKcAuNsJeYRieVqWqczsGW06oHgFfG1pw3rLGRskp/e80mtjV7GwYNxeajk027bb2Cym+rE3ea02+p3gYnbC84X9ETsV+kTmfq5wumHaytP5n4u/deJu8PXdEVtFWPbCJ+1hjb2ppH5kzq6FgX570QFXnTjVjGJWRST1OfScqng2yUvVrXz8qtuet9tq9yH+rVqaf6dNENP+z/AfXrqk+LRK6C9N+JWJ5cIaECcN68ebj00kshIrBbt2545JFHMHPmTGzevBktW7bMsWLNmjVKHE6YMEGJvkWLFmHs2LFYuXKlEnpy3X333UoUzp49GyeeeCImTpyIFStW4P3330fDhg1VmvPPPx+ffvqpEolyXXXVVTj22GOxZMkS9f/ScJL3jDPOwKhRo/DBBx/g8ssvx+23344bb7xRpUnKlqITgGJQUg9ncn7kv41I0pvomr7E/Opn8tJMgo/p/bJWv1YA54yvjhj6lSP2JTV0HSZ+/ARg0m0b1RFn2sLioyLMf0zbyU9Ypd3hyz11RVmQ7+oKHRMxnOa82rjtYvqONL2PCZ8k3iN+Zei2ZZz7Cw/djbejyl90bfZQ70l9gHefyz7BScpIaspQlD01v1MARpwFLKKtQ4cOmDFjRgbpSSedhD59+mDy5Mk5mPv376/E2fPPP5/57bzzzkPjxo3x1FNPKRXfrFkzDBs2DLfccotKs3fvXhx11FFKGEoU791330Xbtm2xdu3ajGiUv5922ml477330KZNG2XPrbfeii+++AIHHXSQKueuu+5SUUIRjvLFkIQtUX5UUAdKQgxFVdDk9zRfRiZ26KQ17Rx0yrTtcJ3OPWyOV8TGvLHNjOr88tW2Tqcz/4+5nYOqnMGwrymMfNXR1C53+iRER1Rb6/ihn/gNitraRqht2sX0HekVKkHbHekwtGln3bxp2ZGEnzl18P1wrVOzX6ynomkuLPNhWtD+W7eNU04XGAHct28fGjRogGeeeSZrCHfo0KHYsGEDXnvttRzTJCo4fPhw9Z9zTZkyRQ0bf/zxx9i6dasaFn7zzTdx6qmnZtJccMEFanh3zpw5ePzxxzFixAh8/fXXWeXL71LWoEGDMHDgQOzevRvPPSdfEdXXW2+9pcSq3OO4445TEUpbW7wVFLEq/zmXOFCLFi2ULYcddljKTVXkxaf1Mkqr2qadQ1w7TLhEdXZRv8e1MarctKOPYndW5NOnIrLaV47+Mxn2NeFh0k4m5SaVNkn7oj6AovzBr05p7a2ZZL3D2sLkPnH4JOUH3nKi2tL0viYcdMrWXtSWp/nMLpspAEMigNu3b0fz5s2xatUqdO3aNYNt0qRJSqjJkK33ql+/vhraHTBgQOanuXPnKtEmwmn16tVqKPmzzz5TkUDnkiFeEYgvvvgipHwpQ4Z13ZcM+Uo5Evk799xz1ZCwM0Qs6Rx75R4SLUzCFm/9xo0bp+Yvei8KwBoiSb+MdF4wpZBGl0vUyzfq97gsdMpNK/ooNgcJTHd9bCNJTllhQ6i67RSXs02+pEVH0sPhSdvnZmXTLrpD5ib26zwvNm1tmlf3Y1aHhQkHHTuDWMneppl5zhrzonXuZZiGAlBDADqCymEr8/eeeOIJNRzrJwBFHF588cWZn5588kkMHjwY33//fUYAilg7+uijM2muvPJKbNu2DS+88IISgH4C84QTTlDljBw5UglAifLJnETnElF5zDHHqLl/Xbp0UQLQ1hZv/RgB1HjC1DDeG9VDeC06JxuxCXuB6bzcNMxPLYnuSzqqs4v6PW4FospNumNwC7Ko496iNvfWrbPO0JZuO+neM6l0aYiOJMVwGva52cVpF532dvuhyRY7Uc9LUu2uU47Ou0+XRRrt6MdK6rV4SM1UjxS2s9LgRgEYIgA5BDwn0oXoQD6IdF80kXQ9CcLKNb2nzgvT1L4k03uPgfOWHacz1LEvrNyglZ5Bx+fpMI4a9hWbZWJ4rwTOlU6jY9NhmmSaJEWHzjNj6mdu+3S2PEqSjd8zYiroMoJE/K4C6PVA+Hnmpnz86qvznIRx0m1HUxZLIlbMm7adOzDQqFXhzhd32c3+W2MRSMeOHdUqYOeSBRoyZy9oEciePXuwbNmyTHpZ0Svz99yLQGRu3s0336zSiNA88sgjcxaBrFu3Dp06dVJp5O8S1XMvArntttvUIhCJ9Mkli0geeOCBrEUgtrZE+TgdyEMorU42rFwxwfjlluIZl0FOo/OilzTrZgBrHqzZAiZE/OiUF+XAJr+bRAClU3J3pufckbv3oV+b+tmjc9KHTj107c83Vx3b3WmSEh0mz4yJjaZbHumUHadNdNtb7u/ri3mYk6Yj3sL46L5vTVg490vCz9y2Z33sOTtGeiqX1DQPHZ/iSSCKktY2MA8//LCaVydz7h577DFs2rQJrVq1UosxZJ6gIwZluPj0009X27yISJRFGqNHj87ZBkbSz5o1CzKsK0O+y5cvz9kGRoaJnSFemSMo93O2gZE5d7Ia+Mwzz4QIwQ8//FBtAyNbzjjbwCRlS5gvUQB66MR50eg8rGHlylDznF65pfi9THRfmDo2maTRedF7RZNTvt/wp055JvbppNXtJCWd34rQTlcDv7vnwJ2C2tRrS1Lb3Oi0fSG46rBPOk1az6kOY9O6xG0TE1vI8f+RAAAgAElEQVTS4pGEeAsrQ9duExam7aOTXudjL6lpHjr21KRh/x0hAIWTRP/uuecetRF0+/bt1UpcEXly9ejRQy3GkEUbzjV//nwl+pwVvyIG+/Xrl/nd2QhaxJ17I2gp27l27tyZsxH09OnTczaCvu6669RG0LLNzDXXXKMEoHsj6CRsoQA0eKLSetEkFQHUfWEaVDkyqQ6TqBekW8zqlBdpVECCqEhLjkj1mbvzzkL/85nllm37ALLVwydrgJ82Bp7712hLk9wbLGwINU2u0bXMb4q06pr082VrZzFv65IEKxM+SU4fMPXWqI89neF203tqpKcA1BCAGhzLNgkdyKfp03rRhJWre0+TF2ZSXq3zog97QXq/jHXKi2O7TqRFJwq4ZCiw/sAHYRxTcvIkOTQUNLSVFtdEALgKiRLpuvfTfWZ0y5N0ST9fNm2i46vuuumKRS8Pv/bQaaOkWPmdGiSnbPhdSQ/r6vpG1Aduvo609NjL/psCUNeFfdPRgQLwyYKBT9YCLbsAx3S0YpyVOewF5tzziNZA/QZAk9b+K5DT6PjCaqjzog96QfotgNApz5S4bplBHbKzgWvQ8C+ATfXr474mjTBi59dot2+fmYVBC03MSqlOHdQ56zKIauudW4J9L4697jw6It3kHlGCQEfIeO+X5PNluvDIbUuUr7rTxm17v/aQcuUjqGp/9AImW1beeXXOqUEmPpCvtFkLhHxumuRHnmad2H9TAGq6in8yOpAPl6Q7KZ0W8ltNGrZ6NKrj07mnSRqdF33WC7IC6Hg5cPq/+YvYuNGKIJt1Iy1BHbIzTCvix28+JoDJTRpj7uENccnuPRi5c5cJPSCpziHKN3XaKcjyqLLNapybOq5IiStYbeqT1Aegrl/61THoY8RvSkGc+wRFGNX6hv0HLIqa2xb3XZSGP9j6aFR+sVm2CFvwRzNGUeXG/J39NwVgTNepzkYH8uArxEspbHgh6uVr1fqGmXVe9K9OAF7/c/XeWEECNg3GumWGDVWLSGtyfNYCkO0/qYtddepA+sRrmx6JnXXrokllJWbs+LvUEI3370ezHyvDQSbVhjpDgqqDWidr48xOHdHlZ+gyWcnjiJSw+4UJPJv62AhHr702dkhZL40GVk/LpeD9oIhzn6h5be67JvUB4y4zaX+w8U3TvEl/wJrevyY9+28KwJiuQwHoCy7Nl1LQcFTUiziNl6+V1wRk1j1pIy3GOnOJVFSlrX8Fut8E7NgIfPhi5veTj2t5IG2ViNoKwPmz5peNH30STFPEX6+p4Xux6bZF1JCgjXBJq03cdYsjUoLYRJUVtz5R5eq2lZPOu+jIdLGAiT2m0d+kIoCmTJz0JnVz59GdohBn+D+qLs4H1oLBjABGscrT76HbwOTJhpK9Tcl8QaTxMPu1WpyXkk7rR0UrgkSJlJ3k/DEdW+OkCRqukrJ0ohUyifqKV4Afvo03/8xkLlFQVMWn3ksPaYDRPz8CldJxe666VVWY+N9foee33/nkrAB+P8ssChfFPWxIcPArdhvTpuX33jqZipQgJlECL259osqNaqMowRtnsYAuszjRX7+ypQ5Jb6IcxE23bpLf5APHJK1um/pN03HnLcCHesn037qMY6SjAIwBzclScAfSEXZpPMxhzExeSjrsdTqjoIPo/QSUzj3znSYsiuknYL2REa+93W8EzhqrVwsdvt6OOUxwe+66uX499G9+4NhH5+d5n32Otvt+8LfRWVSiVwP9VEHi9dxJwEu35ZZj0ikl7fdBtdKZShBFRKfN49RHp9wo25zfkxSTQXMSnffn9g3xz6X1a48k2kiXk869TNrFJK2Jjd6Nx915k5rmoWtPTbqC99+G9qaRnALQgmpBHUhH2KXxMOvw0nkp6ZQjaXQ7gif/kDX8qIov0ItFt2qZdCYRQMnkO/zkuesJvwUu+Y9oU3T5uksy2Oplc+fB6P/3l2XHeVRVVGT+DBaAKZ7AEPQ8DH7ZLgLosEnS76Nbzi6FjsCLU5+sxUx1gHPG5Z4Co2N5Uu+uoPdkWESqVN4bzrsgaljX5Bk3SavTjmHvcOcdndQ0D117KAAzpCgADZ3GnbxgAlD35ZjGw6zLSyc6qVOWbl2lrKxFFCHzx5KyTcd+3TS6cwCjXqju+8m8vLPGhFvgJz5lyHbYJv8VyE6n43fah/dOJ/wWO866DRf95wA0rfwR/fZ8i4UND8GOuj/B09t3oGmlZwFIUuf+htU4aAK6jiDSbctSSaeGPd+oXnTUovOB9s4MhyL733XrJfNJX3b8zmezcN1ybNvERPB7bTKJ/urWJ+l0OkEA53nVPfrP5H2rWx/1jgmYO3zsb4DLF+uWlGi6gvXfidbCrjAKQAt+BXMgXWGXxsOsw0v3xaRTlqQx6QiiohZJ26ZbB+dFHPa1rrMQQ8oJ2o4lx5YKYHiIkAsUcxr5/ASr9/7DNwM7t2DfnF6oV722Vq3+lYHf6hO8nasC6HoD0PmaYNFpwjkobdTzIFy3rQVaJLx/ZRK2p1GG37Mg93Gf4yz/33ua/kIc32i2hj+FtdnOrdUrzA9vbkYh6D0ZNOSfcce6wLCN5vczs+5A6jgfpFG+7LXF5B1qkla3zs9cDmxa5J+6QPO0C9Z/6zLLQzoKQAvIBXMgk4c/jYc5jJmJbSbsTTpn54Va75DshRFp2aZTD13hGSVg5V5RK5/d9kRFMnQ/Jrx11LHBZ2uY7GLyJPycm4bVdddH+hv46rR3GmniCAUTMSyLLJREl//cl4GACzoK8PezgfZ906ASXGbQVAk5l/qNR/zzma48t20T3feC7vMX9rzrvFuc+5ik1WnVsI/W304CTrtOp5RE0xSs/060FnaFUQBa8CuoA5kIu6Qf5jBmcQVFWJkmL0m/uT3O0GLjY/03Ko4SSRY+orImLTx9oyx+Rmp03HFti4pCuudR+S1akYUeaUf8vEhMhgSLbR6YyTOg4686At5djq6AKyYBKPbrRKoz9awArnhV//Qi2zaJ++yl8U7R8RnbNP/7D8B/HdgmKlMcI4C2ZGPnpwCMja4INoLOp7DT5WTzUvO7h0l5QV/8Uq506ElN9tdl4aRLQxTrbsciw7BRQ2cmHxNRdVKs6wC97s8eNszMN5N5ZZ2ibTJlrJver66F+jBwbI6KIpk8A7ocfJ8ViQC6TrGIIwCDPk7OmQB0G6JrXXLp0hK6YW0i1kctzJA0tu+FOM9tlK8lR96/JO9ivVMGAH1npH1X3/ILGsApSI1zb0oBaNEQdKAAeHFeTEHtYPKSjHrZS6RPDfUNA6oqq0VhPlagpdWB6yzE0N1SxfRjIiwKWaAveu1H2VvXNNpH1xidKJLJM6B7X0nntyBm33fAu89mlxK1KMh7T5MFTSb2xkkbFanOKVNz0UrYxuJrpuudBZyE35k8tzq+FoexaR6T6TymZRukZ//Nk0AM3CU3KR0oBJ/JiymsFUxekmERQFmC4CyISMo2E+9JUhTLfZUAC1hZ57bL7+xTr91xowK6R22ZcCpUWt0FOEnaFxSFG/5OdoTU5BnQtS/o3t6zbKU80+hdWoJVt27udFEfhX5l6j4zOXvb1alZ6WRwFnDS74UgRmn4UJz2KKI87L8pAK3ckQ5khU8/s8lLMnDOj8Z8OH2L4qUME56mIsykYwub42gTFagtnUrWvNEK4Jzx8fauM/WKIAHtF7VN+vzUpPzHr85J+oXpc+H3cRO2CXFQm+nMC/a+l077V72zh30/wGKudNb1uWIS5bo2p5yO/TcFoJWL0YGs8OlnVvPH1lVvJBI1fyysY9N5qetblVzKOCIsbAjWa1nQkGwSHbWJOE+OmH1JjrCQleJ/OTv/Z5OGRnA9HytJtJOWMIoRwQpqCbXwZ2jNnMI6QG/PnFCdFozzXPiVa7QQpGYO6zBPFDYssuZsUyNpdPfb06l/kmnS8KEk7StAWey/KQCt3I4OFILP9svdKdq0EwgSRjrDOlbeEDOzzYvZb3WtnxlB8wCTigoUYkg9Jm6VzRvxy9n2xOcMZpv7+eWNisC5V90m1U5eO7zi/Z/6A28/dWAbGJn71+sB/T0A3eWbPrc6AjXuyuwo1t57686b9WvXOB9ESb0ro3w0jm1RZZbw7+y/KQCt3JcOFIDP9uXvFBtHHPmJIndHlq+Xra5n2XbuKjoqpzkAaNQSmHlW7j5uQeI3Dl/dehVrutB5ojVGxxUaJr4VFcHtOAhqgZJcaS6qcMR7vQa5kVDZF9A7H1GnXZPwK9vnwm2nTptn0sess/d+uptXJ/Wu1GkXSaPzsWbix7r3LcJ07L8pAK3ckg7kgy+Jl79TrGknEPSid45Ey/fL1i+q4d0eIklecj/ThRnlFhUI8ikRyVX7/bew0XlLxPEt9bFyg3/pjmiXX/3msJkuzIiqg+mzFlZeEmUl/VyEDQNn2j5PuwLYfODmCM0tQJPWyW2rFMePo3yrSH9n/00BaOWadCAffEm8/OO+IMM698GvFGaul1OXsBdrkiIsTsepExWwelKKKLPvR4IsfZVLTsDQ3AYkKsKkG0WULTFeuAX49P/mQpI5q2LTnF7+vx3XPRmwzhzbBYOTmQsZxwf9apLkcxG24EY2JNeN2EURN4me2bwr4wq1MPuSarcoRkXyO/tvCkArV6QDpRwBlOJNOoGwYbXTbwFW3J1uRxrkTTov1iRFWNIrRq2ekiLM7PYpv+PPdMWbU7W4HXnWXEQPJ8cG+Wfvfo+m+/KFNUGYDTab9Jo8t2H2JfFcBL4XEtoZwBFV2zcAr9yuH0mOGrGweZ8ECuqhwfbF9eMifMR1TGL/TQGo4yeBaehAAWi8Hew54+y21TDpBMK2gclEeWrsNu3o43pLPl+svp1KHeD3fwFadPYfKjKJWsRlUGz5HJ/69r+B+YPsPgx0BL73DmHz0twblPuKlwSFS9gWKbbPh4osyvzUqmDfy4dfBD1/rc8CLl1oZ4GOiA87iSfofRU2xB/nfaLjozpp7GgVVW723xSAVg5ZcAcq5o5bbaw7Fqiqij+vKm7ryL1fHut/qL1ET9RcrzzO9wl7sUoddY6N0mURtuLR74i2uENJuvYUe7qkOj3TiFdQO/3zYOBXlxw4jzZOZ6/LXGd1rM3WScXiW0ERQNudAcJEvNMGUfyCzk4Osy2Oz+r6kakf6/paEaYreP9dBEx4FJxFIxTUgYrl5erHL84LKnIYyHCyc9CLVe4j2zzIvJ+oM3ItfCMna1ZUtALoPgKQM2iXhAzJxLl/VKfkjuok3U5x7C2GPEl1eiaR6tAIoOss5bRXAKcVASw23zJdHKXjl1ECWieCGvaeitzA3eBIS5P2MPFjHU5Fmqag/XeRMKEAtGiIgjmQycNsUb/YWXW/NnVuEFfohgqhCuCKVw9EWXTsSCLNf1wGbPacs+ouV6fD0LEjZHXppvr1cV/b0zHi13eg3Z6v0l9goGNvIdKo4UnZXFy2z2kFfP2x3kbjSdqa9VHgKVh8YfDLPluzxDiaLcxmv22TJL3NHoCSP8l3QBLM03hn6g7jR33cBh3p6OxeEJTfVKgl9aGTRHsUQRkF67+LoO6OCRSAFo1RMAcqtperl2FSL1vbclTn5pxG4DUyxmpPC1+B7qH07g2A494vaMgLwOQmjTH38Ia45PgLMPKfri3ekwvi1l0nX6DocUXedMqxTeOI0L+/579A6dxJwEu35d4laljRxC7lKwFnSg/fHD9KbvvsmtRBN20aAshb5q+HAQ2OAFp00f/ADIpO2g5R+3ExFY26bEswXcH67yJiRQFo0RgFc6BifLl6OSaxEjUJoRsmvNJ4wQb50+rpwEujor3Nb55edK7sFB5u239SF7vq1JENTnBt0yOxs25dNKmsxIw2g1CFKjT+P/ei2Y/78jsv0rROSaUPEcfqFklFYaPszVo84N6GxpVRIkAr70tma5Yge2QKwvrZ/r/afoxkfYDFPA4uiqPp72kIIKfM7W+ZrQJ2bA/zySTFvimrWp6+YP13EXGlALRojII6kO7XbCEWiiQlUJMq54l+wJZX/Vs6Xy9Y3QhgEiLEE9U5+biWB+quFuXIQpiaP2t+2djxjuhzli2elaLJGjVvSwy18Qmd5y1qnqYDS8To2ePiiQod4GHRP8mfhABMeo6rTr0Kkcb2XfXqHcDrf861POgcb5s66vioTfklkreg/XeRMKIAtGiIgjtQ1Nds3PlzFkxU1iQid44NukI3yOawr+t8RgDFvnmXAe+GzAF018FWhLiG9ZYe0gCjf34EKkX4ea66VVWY+N9foed33wO97o937qutv+Qzf5TosYkA6j5vOiLUYSILllZPi79JdRjbUDsst5qxFUT59Ikk7mX7zrPNr1sHXR/VLa+E0xW8/y4CdhSAFo1Q1A5UyBdwUIQj7vFVUUI3bicX1x4Ln8GrE2q+9OXUiYDLVpj6dCab69dD/+ZH59xw3mefo+2+H6r/3Ub82DDJd96gOVdiR1yfMHnefJ+POuoQErVFUeby+bck2ygsEtl7mt3HQL4ETb59x+9+zlxOm5NUgnwi7Cxm00ieiY8WA9eUbSjq/jvlujvF+wrAXbt2YciQIVi8eLFK17t3b0ybNg2NGjUKNGvv3r246aab8NRT/397ZwIlVZHl/X9SCiIKUkiD7MsozWKD4LAKgx8COoOs02yKQKMo8MkqgooIyjIDKCA0iCCL2AitIy1Ug6AidsumjQ0HKMBWlL0+HLbjhthFfedGVSZZmfky38vIzBdZ7x/n9JGujIgX8Yv7Xtx3b9z73sRPP/2Edu3aYcGCBahSpUqgzbFjxzBs2DBs2bIFJUuWRN++fTFr1iwUL148UOfjjz/G6NGjceDAAVSqVAlPPvkkHnvssULXlX5nzpyJ06dPo379+pgzZw5at87/LNK5c+fw3HPPYfPmzTh+/DhuvvlmdO3aFS+88ALKlCkT6McXwRqycOHCsGtFWwejBcjtB3Ay01c4uTlMPF+jNoxPCxIQR1AE41VC/FwiPOj9CqAvLw95Ph/8/y2kAEp7Hcujk3Vxs240mRCLW4cXnI/O6f0WyRJzdAewd9XVa0ui4khHFxK5RqHpiZoMANqMjT/4I4oMqp+cuDSdKjjOV02/RVgiaKXFx3eeNiw4KUqgWjyWPKcyqk/H6B6M3r9TRC6iAnjffffhxIkTePXVV9UwBg8ejBo1amD9+vWWwxoyZIj6ffny5ShXrhzGjBmjlLHdu3cjIyMDubm5aNSoEcqXL48XX3wRZ8+eRf/+/dG9e3elXEr5+uuv0aBBAzzyyCN49NFHsW3bNgwdOlQplT169FB11qxZg379+inlslWrVli0aBGWLFmC7OxsVKtWDfv371cK4IABA1CvXj0cPXpUKXW/+c1v8PbbbxdSAJctW4Z777038DdREEUxtVuMFiC33/ZMedgIh7/MBHYvK7ysibSk2BWY4HpWfJoMBO6fE0+PhduEpBjJychA70oVUTH3n+j+3Q9458ZSyMm4BqtP5aBibm5+W7eZ6M/afg9WX2CI1/rq9H4rtNn7gPaTgQ8mpdYCGKysJepbuMErYJWOyI51MR4Fx/7qJ6ampQW1YD1bSQYCB8WuDNmtF3ppu+3SQfF2gNWqqtH7dwLmZ6eLMAXw4MGDSnHauXMnmjVrpvqQf7do0QKHDh1CnTp1wvq9ePGiUuxWrlyJXr16qd9PnTqFqlWrYsOGDejYsSM2btyITp06KaucWPakrF69WilqZ86cQenSpTFu3DhldZQx+Isob3v37sWOHTvUn2RMjRs3hljr/KVu3brKyjd9+vSIc37rrbfw4IMP4ocffsA111yTv9f5fFi7dq1qF28xXoB0z8/FC0ba2X3Y6FwjVttEvp3HupaT361cRtKHrvUveBwhlsbLAK7Nz3YnNgqI47e4//8lIvrYCQO360Y7Cxivhc3u/Wbl7kOw+zcCIN3cfKlmbhX4FEvJNuHZYYdV1K/uZAAj9zmzpNp9abZbL9IcYsloOijedtbGRh3j928bc9CtEqYALl26VLlgL1y4UKhvcf/Onj0bAweGfzdTXLri8hWLX9myZQPtGjZsqBSsyZMnY+LEiXj33XeVMucv4mrOzMxULuG7774bbdq0wR133IG5c+cG6oiS1rNnT/z444/Iy8vD9ddfD1HounXrFqgzYsQI7NmzB+I+jlTEQvjUU0/h22+/DfwsCmDlypVx6dIl1KxZE4MGDVKWzmLFitlmmhYCpHN+zjYJi4qxHja6/Udrb/V23uR3QJsnnD2YEznOMKU0pPNEW+FsBxykOC9iIpnG05cVl1jKSaxr2bnfLK9dEJ1teY1iQLQzYbHGlurfo6U+iqZk6yg4qZxjtDOUMg6nLxJ2FV+79axYiGJ+bCdQLSRXoW6/qWSfgGulxf6dgHlG6yJMAZw2bZpy437xxReF2t12221K+RNFKrSsWrVK/SbnAINLhw4dlHIlblpRrr755ht1Ni+4lChRQl2vT58+kGuIRfDpp68mP92+fbty9YpFURRAUdrENdyyZctANzLmFStW4PDhw2FjE1ezWAzFbTxlypTA7/JvUVrF5fvhhx8qBVXmNmHCBEteMr/gOYoAiZVTLKBiwWSJQMDqYWMXVrzuiGRt8HbHHalerA3D38bpxhFtTNHOu4W2S7TyqcMq2W2t1iKRFlirOVhttHeNAv46K/rMEykbyWZc1C2Aws8q2Xy895Ldl2a79ULXOJqFL10U7wTJLRXAq94ghfSzzz5TClokZerWW29VVrLx48fbVgDbt2+P2rVr45VXXlEKoJzH27RpU6H2EgDy+uuvo3fv3koBDFUyRdm76667VMDHlStXlAIoSqG4pP1l6tSpyv0sLurgIgssSqhYJcW1fO214gCLXORc4vPPP6+UOasyadIkZc0MLVQALYjpuhN02psY/GHHGhfvxhHtoRgt6jW0XTopGLobQaFzksWA9pMAp+e2wh4GJ4FzMb5bHXrY3+/aLX5DQWBQlIk5CaLQ5ZOI9qEJ4eXIQeeXY0cYx6vgJGLMTvvwnzP+fEX+GU65h+Ucb+OHnPaUX9+OFdlJPf8oYln4Yv0e32yMbUUFEPAdPHgwEIYogR5izSsKLuDvvvtOnT0Ul3FWVhauu+66qILoVzRzcnJQoUKFiHVpAXRwL+s+THTby1BNiUSO9gCWDVElZk7AxmG1PHYtj8lQPh2IjCtV7W62dgZn54XF6vyfuHbl28Rvhx+xKXTpdFTQxRL4j01AqQpAnXvtH79I5NrYWb9464Qe62g9Bmg3Md7eChTAGC8R8XhG7Fj40knxjp+wakkFEJINQj4JcLX4g0B27dqFpk2bqh/k382bN48ZBPLGG2+o83pSxGInKWBCg0AkuviWW/LzkUlEr0QCBweBSCSxRPT6i0QXy/m+4CCQJk2aqChgf5GglS5dugSCQGRhRfkT97JcX5TAWGX+/PkYO3asOvso7ewUClAUSnYeNtEg67b39/3H/kB2UPLlhn2BblcDiOysc0LrhETn5vftA1o+DjR7zP7m6HRQEa8b0kkq3J9Ox50u9e2+sEST68xa1t/lVWJSDBi5P3kykkzW8SgsyRxPovpO9FECOy8RdupEmp9dGU0XxVtzDbl/R1AAhamkgZEzd3J2T4q4b6tXrx5IA3Py5El1fk5ct34lURQ1sbTJeT4J7JCcgHL+LjQNjFjXJIefBIzIeT8JEglNAyMpYCQVjCh9EgUcKQ2MuJXFDSypahYvXqzyBsoYxfInrmcJGpEAklKlSgXERCKVJSWNKJli6ZP2cgbwo48+UmlrZDzBASix5IsCFIWQ3YeNVRe67aXfRPQRSwji+V0sIq+1y/8cm7+kwvoW6brB409H61I8/JPRxu4LSyyZjOaujzdHYTLm66RPHYUlljvdyTiSUTeRZ41jyUYinmkesvDFWm7u3xYKoChnoYmgxULmTwQtwRwS3CGKU9u2bRVniaYVC5q4kIMTQUuQhL9IImjJ6xeaCDrY4iaRvKNGjQokgpbUMJESQc+YMUNZGSVvoEQnSwSxlK1bt6qI4khF8gyKm/u9995TAR9ffvmlOldYq1YtPPzwwypJtT9NTCzhkd8pQDEo6T5sdNvb3ZTtLHYi67g1rkSnrUgkk3Tvy87m7Z9j6Lm4YKu0OrtaLzKNdDv/p6OwBH8xx+QURdHWy+kLlZ3ngp06se4lj1j4YmHg/m2hAMYCx9/zCaSFALntetF92Oi0d7Ipp1Ko3RpXtLOAbrvGU8k/Wdey88ISa+0TqVAka55O+o1HYYn0zexUWMidzMtf12q94nHXx5INHYU6dG5u7wvxsE5wm7TYvxM859Du+C1gDcDGC1C8rhcNJsY1tbMpuzDoA5/MwEv7F2P0uQuo/0sutKIGnYw/0WkrnFzbC3VjvbBYuXj91qJEuhRN4G1HqQkep1XqGKnj1KKWivlbrVe87no7zys7daLNnftC+hhwkizDVAA1AButADp98GpwML5prE3ZhQlM/+szWHVkHR74VXOMbzkptQf7148M/zSeqRusC2uTtEsqa1H9gu+wBF0l2FqU6KCCpE3GQcdOFBbL5NE+YNSB1N4ndqYYcb00E3bbeV7ZqRNp/NwXAlSM3r/tyF4C6lAB1IBotADF43rRYJG0pkXIVXHq+1M4//N5+A5twJDDy3AuIwOZublYWL0H8hr1RtkSZVHphvzPJCat2FFCknZxj3RsJbN2rUXJyE/oNnq7CouVBbD1E0C7Z92eReTrO1Fw3Z5BUdkXEsDR6P07AfOz0wUVQDuULOoYLUAmvenFq8QVMVfF7StuvypJEgGs8v8V/Lfgl33992lIpI2mdpUQG12xSgQC0WTWSvkelR1u2bKrMBXFRQhN3VS3K9BrhdkzTfR6qS8o7QCqtQCqNAmfe7zPVJP2BZdX1Oj9O0VsqABqgDZCgKI9CEx4M41XiSuCD8VFWkwAACAASURBVKqsI1mY8MkzyJWkzyElIy8PU+4ch04N+mlIpI2mVhaWdIwwtTHdlFaJJbMRFUBDXZspBRd0sUQnVXZrHjrXDY0SD1WA432m+sdkwr6gwydBbY3YvxM0l3i7oQIYLzkTooDtPAgS/WbqhFesDTFaX0XUVZF9dCt6bX08bOZrTp5GvT5rgZqtnRB2XreIcnUOIgktYrGN9XsShmRUl7GsVjrPC6MmqjGYWC7wRDGy+kZ7rDXSmJppTakAMg2Mlky6KkCJehBoEYjRWGfDS4f5xcEu+2w2emX1kk/wIM/nC/x3zakzqDf08+Qfci+iXONYisQ3icU21u+JH5E5Pdp5WdV5XpgzU72RxAqCkcTYK+4Pv4aTCGmrtbCzRnqzM6q1q/u3ISRoAdRYCFcFKB0elrobXhF0VeT8kIPeWb1RMfcKup/+Cu/cWAo5GddgdYNhqNhsmIY0OmhaBLk6mH1yq8Ziu+1l4IPnkvvt5+TO0Hnvdp8Ddus5H0H6tIiVBkc+FzinQb78+IuTHIlWjAe9D7x2T/z9pg/hwEhd3b8N4UUFUGMhXBWgdHlYFso7VwzoPBdo/JB96m66sO2P0lHNy39bimv/PAa+vCvIgw+/3DMRxe8a7agP7cpFkKs2k0R1YMW20Pk2H9B+MtBqRKKuam4/Tl5WPWaFirhosRJhx3rJiCYJVmvRYRqw+Wk9y6K5EhhxZK7u34awogKosRCuC5DOg0Bj3o6a8oFeGFe6KO6OFpmVYxLw8ro7mbt6YRxekCvRB3R+2dkLY8yFSJMKhT6Fl4GwRPHxvsDRAkgLYNAtQAVQ43ngugIoY4/3QaAxb9tNnTz4bXea5hWdWEPSfKqeHX6kg/ReX3c7L6t8XoS/LJ47Aojbt0zlxN1OVmthZ40SNwrXezJi/3aZAhVAjQWgAMWA5/VNLxIebnIad1waNLWyeHPdY7+s8nkRQQH8CsisnVgFMJrhwGSDQoJvf+7fjALWEinjBcjtkP5Imx4cfCbJ7fFrSUeUxh57004WRuP6jaXkcd2jL1ksfsYteBIHxKMzSYSb37Xx+3fSCVAB1EJstACZ8gApdKZHcNs812PK+LUkJEpjD71pJwuhcf3asWB5ed1jvdCFPivkSzn3e/AMIBXhlNzaRu/fKSFABVALs7ECZNIDJJ6xxNNGayXZmAQSQIByaw0x1gudrrcgActnTBexXiRiKdLGTMTsgRi7f6cQG88AasA2VoBiPUA05uy4aTxjiaeN44GxAQkkgQDdvOFQ7SjGvOevcouoDANo/wJQ8iZg/YiCPJLFgPsdptVKgsina5fG7t8pBEoFUAO2sQJk54GrMW9HTeMZSzxtHA2KlUkgiQS87OaNhNWOcsd7vjC5bXOB9yeG0PQB4haPNwl06Np43JJo7P6dxEdTaNdUADVgGy1AJlki4hlLPG001pJNSSChBKw2Vy9uunaVO97zV0XQSmmOJKROPgPnbx8tWl0+N5eMyOOE3mD6nRm9f+tPz1YPVABtYYpcyXgBMskSEc9Y4mmjsZ5sSgIJIcBvrYZjtKvc8Z7PZyccZtcvSIgdRSqdfAbO342VQn7PpKDPFBZ997Lx+3dCHkbRO6ECqAGZAqQBj01JoCgSsNpcPfit1bDlpXJnX+KVAlgvrP6B4sXxUuZNGH3uAur/kouwL4TYuYKVdVG5l/Ou9hCPcmnn+obU4f7NKGAtUaQAOcDnRdeXAzysWkQI8Fur0ReSzwF7gm4hR9Mzy2JVmRvxQMkaGN9yElClib3+gmtZRVzjSnhf8biXnY/IlRbcv6kAagkeBcgmvlgpIGx2w2okYDwBWgCtlyjad379iuG1pYBffvDEGbSoshxkATx1TQbOFysmGVQxpOKvcC4jA5m5uViY8y3y/m0syjZ8EJVuqOTs1gh1yd/zHPDBpMQFmDgbjSu1uX9TAdQSPAqQDXx2D4Db6IpVSCAtCPBbq+HLZHWmbVQ28NWHV1Ob+Fv6iv4ZtJiyXBAJfHvNaleriovW76qV/xaUff33xewurEKwS17WYN3wq2cOPZCEm/s3FUDnN01QCwqQDXx2UkBYdUN3kQ3ArGIkAavzbl49B7f/HeDtgeFLdXtPYP/bhS1PASUwAxi5L/HfwTVSYCwG9eELyPp8ASaUL4fcIIXPXzsjLw9Tfj0QnZqPiX9WVi7hUfuLNHvu31QA479p+C1Be+zitQDSbWyPL2uRQDoQsFIAlWMzKPAgdC5F+Aya7WX78AVk75qLXpVvCWuy5tT/Q72hf9dT1HRe0m1PwryKVACpAGpJJQXIJj67KSD83cWrNNocDquRAAmkmIBFVGvUURTxKFTbK7D/HWSvG6wUQF9eHvJ8vsB/11TphnrtnrfdVcSKHn3ecv+mAqh141CAHOBz4vry6BupA5qsmo4EvH6kIeLXLYoBkaJPZX3l02et5Fyax8v+d5Cz9mH0rlQRFXP/ie7f/YB3biyFnOtuwOoeG1CxVMX4AAXLozqHORLIywVE8b5/DtD4ofj6TZNW3L+pAGqJqvEClK4bjkffSLWEkY2NInDgfw/gpd0vYXST0ah/c32ARxry12fbywWfOBO3bzGg/STg/eciu4Hp/s1nVhBAcxl5uBYIOM1/Gb4HxTNrxif3keSxdjvg3BEgs5aeSzm+EaW8lfH7dwqIMBG0BmSjBSjdNxynbmONdWRTEkg0gel/fQarjqzDA7W6YPxvhgBzGngqxYYlz0jPpZz9wKeLwps8vCW+PHeJXkwT+kvk8zxaqiIPpeAxev9OkcxRAdQAbYQARbLymWpBc2qRdOI21lhHNiWBRBA49f0pnP/5PHyHNmDI4WVX87VV+D/I27saZa9cQaV/5l69lNcsXBGjTf2pTCIEgniNTywhTNTzMNaXQDySgseI/TvWmif5dyqAGoBdFyCrt0ITz9Al8g1WY83YlASSReD2Fbdf7doqX9vXx/LreDHAweq5FGlBvMgnWYIZ2m9ERTykkgf4u75/p2q9o1wnogJ4/vx5DB8+HOvWrVNNO3fujHnz5uGmm26y7Ornn3/GE088gTfffBM//fQT2rVrhwULFqBKlSqBNseOHcOwYcOwZcsWlCxZEn379sWsWbNQvHjxQJ2PP/4Yo0ePxoEDB1CpUiU8+eSTeOyxxwpdV/qdOXMmTp8+jfr162POnDlo3bp1oE7btm0h/QSXXr16YfXq1YE/xTPH0Mm7KkDRrHwyUJNcTqZaJA24ATmEokMg60gWJnzyDHLzwj+plQEfpnz7v+j0/Q+ARywsYStrR/FQyjGTQCf9rgg+YiNnMT32GTjh6+r+nfQFtneBiArgfffdhxMnTuDVV19VvQwePBg1atTA+vXrLXsdMmSI+n358uUoV64cxowZg3PnzmH37t3IyMhAbm4uGjVqhPLly+PFF1/E2bNn0b9/f3Tv3l0pl1K+/vprNGjQAI888ggeffRRbNu2DUOHDlVKZY8ePVSdNWvWoF+/fkq5bNWqFRYtWoQlS5YgOzsb1arlZ0wXBfC2227D889fDY8XhbNMmTKB8cczR6MUwFhWPpPO0MUaqz1ZZS0SMJ5A9tGt6LX18bBxrjmZg3qXL1/9e+d5RT7KMuJiqc/BjbCO/JUQh4c/5Nm/VEi6KOTHPwV+PAtsHOu5M6pUACNEAR88eBD16tXDzp070axZMyWG8u8WLVrg0KFDqFOnTviL3cWLSrFbuXIlxNIm5dSpU6hatSo2bNiAjh07YuPGjejUqROOHz+uLHtSxCI3YMAAnDlzBqVLl8a4ceOU1VHG4C9i/du7dy927Nih/iRjaty4MRYuXBioU7duXXTt2hXTp08PKICibIplMFKJZ46R+nFVgOxY1RJ1ZkT3YWRnrKHXcHpeUHeMbE8CCSCQfTYbvbJ6hedrO3ka9S7/cvUKYuUaWbS/tGCJ0zIpNICWw4EOLyRgJdhFTALBx3JE8VY5ueVTc0wDE5NdEakQZgFcunSpcsFeuHCh0BTF/Tt79mwMHBj+OR9x6YrLVyx+ZcuWDbRr2LChUswmT56MiRMn4t1331XKnL+IGzYzM1O5hO+++260adMGd9xxB+bOnRuos3btWvTs2RM//vgj8vLycP311+Ott95Ct27dAnVGjBiBPXv2BNy+YgEUF7LUr1ChAsTa99xzz+HGG29UbeKZo7QTN7f8z19EARQl9+LFi0qBTXkxycoXa/JOxsrzgrFo8ndDCeT8kIPeWb1R8bpy6H5zE7xzYgtyvj+F1adyUDE3KABExu/VIIdoSaHl28BlKhu6ukVoWFaff/vPpUDVpp5YA1cNOIaIUpgCOG3aNOXG/eKLLwoNUVyqovw99dRTYUNftWqV+i1YOZJKHTp0QM2aNZWbVtzI33zzDTZv3lyofYkSJdT1+vTpo9y2YhF8+umnA3W2b9+uXL1iURSFrnLlyso13LJly0AdGfOKFStw+PBh9bfFixer61asWBH79+9XY/6Xf/kXvP/+++r3eOYo7SZNmqSU2dDimgIoAzHFymdHoO2MNR5roZ1rsw4JpIjA5dzLuLbYtfD5fMjb9z/45X9+h6unnAsG4WUL4Jr+wME/RV4NJn9OjZTyWA7PAAbllFRC99lnnykFLViZ8kvjrbfeikGDBmH8+PG2FcD27dujdu3aeOWVV5QCePToUWzatKlQewkAef3119G7d2+lAIYqmaLs3XXXXSrg48qVK0oBFKVQXNL+MnXqVOV+Fhd1pCLnEO+88051HlHcx6EKo505Sh3jLICpeVQk7ip23Lp8MCWON3tyn0DEr194+CsXJ3YDS/6P9bp4WTFOpbTyRZsKoCiABw8eDCRgkkAPsealuws49D4Sy6FYGv1nFON1AYf2SxOygyeWXbcuH0wOoLKq0QRE2XmtXf65quDS+gmg3bNGDz1pg9s+H9j8TPTuveoaTxp0i44LBeT4gJb/F2g2xBPuXyHC/TtKEMiuXbvQtGlTJTny7+bNm8cMAnnjjTfUeT0pYrGTFDChQSASXXzLLbeoOhLRK5HAwUEgEkksEb3+ItHFcr4vOAikSZMmKgrYXyRopUuXLoEgkFBxFzfw7bffrs4IyjlDfxCIkzlGuoUoQDafWE6VOifnBW0OgdVIIKUE1OYq37FlguNC3GNaADOAkfs8o4SkVCZDL1YoCKTgRw+l4OH+bfEtYAmakDN3cnZPirhvq1evHkgDc/LkSRX0Ia5bv5IoilpWVpY6zyeBHZITUFK9hKaBkaAMyeEnASNy3k+CRELTwEgKGEkFI0qfRAFHSgMjbmVxA0uqGjnzJ0EfMsavvvoKf/jDH/Dv//7vuPnmm5UyKSlpJA2MuLglJY2UWHO0c2NSgOxQkvw+fwFW3B9eOdqbvp3zgjYvz2okkFIC0fLdeSDBbkzWa4cAe1eFV/NI9GlMPqmoQBmlBVBcwHniHw0popyFJoKeP39+IBG0BHNIkMVHH32kcu5JuXTpEsaOHatcyMGJoCVK1l8kEbTk9QtNBC3uWX8RK92oUaMCiaAlNUykRNAzZsxQVkbJGyjRyWLZkyJpZh588EEV/PH999+rKN3/+I//UFHAopj6S6w52rkHjVYA7Zy3szPJRNRxagFMxDXZBwm4RcDyU1tMcBxYErEEHt8JVG0O3FgROHcEyKxFy1+qZDbWV1k84IY3ev9OkRzwU3AaoI0VILvn7TTm7rgp3bqOkbFBmhKw+uZtn9VAnXvTdFIcdpEiEC0VjyQEHHWgyCvjxu7fKRQ0KoAasI0UIJOtbU7cuiZZMDVkhE09SiCSm9ND56s8uurpNe31I4HdyyKMmQpgei1k/KOlAhg/OzPPEMRz3k6DgeOmdhQ7Ey2YjifKBp4lwPNVnl36tJp4NCsgXcBptZTxDpYKYLzkTA0jN9kCaEexM3n8GrLCph4iwPNVHlrsNJ9qpDyVHglUMtKDl2JxogKoAdxYATLxvJ1dxc50C6aGvLCpRwjQAuiRhS4i09z2MvDBc0DeFc98B1hWztj9O4ViRQVQA7bRAuTkvJ0GA9tN7Sp2dhVF2xdmRRJwgYDKA/h4yIV9QOeXgcYPuTAgXpIEohAwbb9IwWIZvX+nYP5yCSqAGqApQA7gWSWAfXgLUKVJ4Y5MtGA6mCqrkgCcyDtxkQAJpJwA928qgFpCRwFygM+uBdDfpQffSB3QZFXTCVh98qzjNKDFMNNHz/GRQJEnwP2bCqCWkBstQHaibbVm77Cx1bmo9i8AreSTWSwkUIQI0AJYhBaTUymKBIzev1MEnC5gDdDGCpCdaFuNecfd1MMRZ3EzY8P0JRCaC7BhX6DbwvSdD0dOAkWIgLH7dwoZUwHUgG2MAAVb+2Q+cxrkR3T5iylh/U7dwBprw6YkYASB4E+ehZ51NWKAHAQJeJOAMfu3i/ipAGrAN0KAQq19cr5o+7zwWZmQ2NNuhK9p7msNGWFTEiABEiAB8wgYsX+7jIUKoMYCuC5AEc/VFYN8ytFIC6CwjhXha6r7WkNO2JQESIAESMAsAq7v3wbgoAKosQiuC5CVS7XlcGDH74G8XDMTe4pb7NhOoFrzwilg7FoINdaMTUmABEiABEjA9f3bgCWgAqixCK4LUDSFSeZ17giQWQsoU1ljlgluGs3CxzOCCYbN7kiABEiABCIRcH3/NmBZqABqLIIRAhTLpaoxv4Q3jWXhi/V7wgfEDkmABEiABLxIwIj922XwVAA1FsAYAUqXpMl2LHzppNBqyA6bkgAJkAAJuEfAmP3bPQT8FJwOewqQQ3p2LXzpotA6nD6rkwAJkAAJmEGA+ze/BKIliRSgOPDRwhcHNDYhARIgARJIJAHu31QAteTJWAEyPY9eLAuf6ePXkho2JgESIAEScJuAsft3CsHwDKAGbCMFKN3z6KX7+DXkiU1JgARIgARSQ8DI/Ts1Uw9chQqgBnDjBMjuGTuNOSe1abqPP6lw2DkJkAAJkECiCBi3fydqYg76oQLoAFZoVeMEyE6UrcZ8E9o0kps3ncafUBjsjARIgARIIJUEjNu/Uzn5gmtRAdSAbpwApYsFzcrNu20u8P7EwiviywBG7jMrmbWGzLApCZAACZCA+wSM279dQEIFUAO6MQIUbE376kNg/UhzPwNnpaQOeh947Z7C3zCWtWn/AtBquMYqsSkJkAAJkAAJFCZgzP7t4sJQAdSAb4QARbKm1W5n5mfghLWVm7fDNGDz0+Gr0T8LqNlaY5XYlARIgARIgASoAIbKABVAjbvCdQUwXVy+wYydWADp/tWQTjYlARIgARKwIuD6/m3A0lAB1FgE1wUoXYMmrJJBMwWMhjSyKQmQAAmQgF0Cru/fdgeaxHpUADXgui5AkaxpKAaM2m9+0ESkZNCiAK6T8355AHxA55eBxg9prBCbkgAJkAAJkEA4Adf3bwMWhQqgxiIYIUCFlCaZTJooTqFpYNLRna0hO2xKAiRAAiTgHgEj9m/3pq+uTAVQYwGMEKB0VJwiuXrL1gBW3B++GgwC0ZBQNiUBEiABEohEwIj92+WliagAnj9/HsOHD8e6devU8Dp37ox58+bhpptushzuzz//jCeeeAJvvvkmfvrpJ7Rr1w4LFixAlSpVAm2OHTuGYcOGYcuWLShZsiT69u2LWbNmoXjx4oE6H3/8MUaPHo0DBw6gUqVKePLJJ/HYY48Vuq70O3PmTJw+fRr169fHnDlz0Lp1fqToN998g5o1a0Yc5x//+Ef89re/zdd8fb6wOgsXLgy7VrT1MUKA0u0coJXb+uEPwtPAMAjE5ccDL08CJEACRZOAEfu3y2gjKoD33XcfTpw4gVdffVUNb/DgwahRowbWr19vOdwhQ4ao35cvX45y5cphzJgxOHfuHHbv3o2MjAzk5uaiUaNGKF++PF588UWcPXsW/fv3R/fu3ZVyKeXrr79GgwYN8Mgjj+DRRx/Ftm3bMHToUKVU9ujRQ9VZs2YN+vXrp5TLVq1aYdGiRViyZAmys7NRrVo1dZ1vv/220DhlHjNmzEBOTg5uuOGGgAK4bNky3HvvvYG6ZcqUUYqp3WKEAKWbBdBKYW0yEMisBXzwXH4uQFH+7p/DM4B2hZH1SIAESIAEbBMwYv+2PdrkVAxTAA8ePIh69eph586daNasmbqq/LtFixY4dOgQ6tSpEzaSixcvKsVu5cqV6NWrl/r91KlTqFq1KjZs2ICOHTti48aN6NSpE44fP64se1JWr16NAQMG4MyZMyhdujTGjRunrI4yBn8R69/evXuxY8cO9ScZU+PGjSHWOn+pW7cuunbtiunTp0ekdMcdd6g2r732WuB3sQCuXbtWtYu3GCNAa4cAe1ddnUbDvkC3q3zinV9S2onCOrt+QaBH6BXEKlsQANJ+MtBqRFKGwE5JgARIgAS8TcCY/dvFZQhTAJcuXapcsBcuXCg0LHH/zp49GwMHDgwbrrh0xeUrFr+yZcsGfm/YsKFSsCZPnoyJEyfi3XffVcqcv4irOTMzU7mE7777brRp0wairM2dOzdQR5S0nj174scff0ReXh6uv/56vPXWW+jWrVugzogRI7Bnzx6I+zi0iAXyzjvvVNbEli1bFlIAK1eujEuXLimX8aBBg5Sls1ixYraXwwgBsnKp/udrQNVmZkYDrx8B7F4enTPdv7blkBVJgARIgAScETBi/3Y25ITXDlMAp02bpty4X3zxRaGL3XbbbUr5e+qpp8IGsWrVKvWbnAMMLh06dFDKlbhpRbmS83mbN28uVKdEiRLqen369IFcQyyCTz999YsQ27dvV65esSiKAihKW6gyJ2NesWIFDh8+HDY2cSFv3bpVuYiDy5QpU5TSKi7fDz/8UCmoMrcJEyZYQpb5Bc9RBEisnGIBFQumK8XKpSqD8RUD7p9rnht1/zvA2+EvEmH8GADiikjxoiRAAiRQ1AlQAVQ5Q5TPTZXPPvtMKWiRlKlbb71VWcnGjx9vWwFs3749ateujVdeeUUpgEePHsWmTZsKtZcAkNdffx29e/dWCmCokinK3l133aUCPq5cuaIUQFEKxSXtL1OnTlXuZ3FRBxcJRrnlllvw7LPPqjOJ0YqcS3z++eeVMmdVJk2apKyZocVVBTCiBTBohCZa0pQbuF7054uJ4y7qT0TOjwRIgAQ8QoAKIOA7ePBgQAGUQA+x5hUVF7AohaK0njx5Up1RjFb8iqYEilSoUCFiVSMtgDLS4C9rRBq5iZa0sPyFMvCC9xFTLZceeTBymiRAAiRQ1AlQAYyQB9AfBLJr1y40bdpUyYD8u3nz5jGDQN544w11Xk+KWOwkBUxoEIhEF4tVTopE9EokcHAQiEQSB7trJbpYzvcFB4E0adJERQH7iwStdOnSJSwIpG3btrj55pvx9ttvx5Tl+fPnY+zYserso7il7RSjBEisasc/Bf7nd/lRtP5isiVt28vA+xOvBn4EjNFpkszajpCwDgmQAAmQgHEEjNq/XaJjmQZGztzJ2T0p4r6tXr16IA2MWNTk/Jy4bv1KoihqWVlZ6jyfBHZITkBJ9RKaBkasa5LDTwJG5LyfBImEpoGRFDCSCkaUPokCjpQGRtzK4gaWFC+LFy9WeQNljP7y5ZdfKpeyKKDBqV7kd1EyxdIn7eUM4EcffaRcxDKe4ACUWGtinACJErhrIbDj9+anUklH13UsgeDvJEACJEACaUHAuP3bBWoRFUBRzkITQYuFzJ8I2p9sWRQnsbJJkWhasaCJCzk4EbQESfiLJIKWoIzQRNDBFjeJ5B01alQgEbSkhomUCFry+omVUfIGSnSyRBAHFwkkERewnDsMjex97733VMCHKIlyrrBWrVp4+OGHVZLqa665xvYyGCVAwV/XEFdqy8eBZo+ZGQUshKMFr/hXwETXtW3pYEUSIAESIAFTCRi1f7sEiZ+C0wBvjAClWzJoYU4LoIbksSkJkAAJkIAOAWP2b51JaLalAqgB0BgBSrfPwfmZFwpe8X+aL49fAdGQSTYlARIgARKITcCY/Tv2UJNWgwqgBlpjBCgdLYB+7hII8sFEIK/gCyCmu6415IVNSYAESIAEzCBgzP7tIg4qgBrwjRKgQta0YkD7SeZ/Si2dFVcNuWFTEiABEiABdwkYtX+7hIIKoAZ44wQo2JqWDrn00tV1rSEzbEoCJEACJOA+AeP2bxeQUAHUgG6UAKWjNS0dx6whL2xKAiRAAiRgBgGj9m+XkFAB1ABvlAClqzUtHV3XGjLDpiRAAiRAAu4TMGr/dgkHFUAN8EYJ0La5BV/VCJqQyV8BCeaebq5rDZlhUxIgARIgAfcJGLV/u4SDCqAGeGMEyCqnXvsXgFbDNWaYgqZ0A6cAMi9BAiRAAiQQTMCY/dvFZaECqAHfGAGycv+2HA50eEFjhilomq6u6xSg4SVIgARIgASSQ8CY/Ts507PVKxVAW5giVzJGgMSKNrs+AMmlF1QkEnjkfnM/BydDTWfXtYbssCkJkAAJkIB7BIzZv91DACqAGvCNEqDNE4Dt88JnY/L3dIPcvweKF8dLmTdh9LkLqP9vz5rvutaQGzYlARIgARJwl4BR+7dLKKgAaoA3SoDS8SxdkPt3emZZrCpzIx64+B3G378SqNlaY2XYlARIgARIgASsCRi1f7u0UFQANcAbJ0DBKVUkAvj+OUDjhzRmmNymp05/jvPL74Uv7wqGVPwVzmVkIDM3Fwur/yfyGvVC2RJlUemGSskdBHsnARIgARLwHAHj9m8XVoAKoAZ0IwVILIHnjgCZtcw++wfg9hW3X6Uv3wL2+fK/CSz/LSj7+u/TWCE2JQESIAESIIFwAkbu3yleKCqAGsApQBrwAGQdycKET55Bbt6VsI4yfMUw5a6p6FSrk95F2JoESIAESIAEQghw/waDQHTuCgqQDr38ttlHt6LX1sfDOlrTdh7qVW+rfwH2QAIkQAIkQAJUAMNkgBZAjduCCqAGvIKmqH8R5gAADMxJREFU2Wez0Surl7yJIM/nC/x3Tac1qFeunv4F2AMJkAAJkAAJUAGkApjIu4AKoD7NnB9y0DurNypeVw7db26Cd/53N3IuncXqTqtRsVRF/QuwBxIgARIgARKgAkgFMJF3ARXAxNC8nHsZ1xa7Fj6fD3l5efjlyi8onlE8MZ2zFxIgARIgARKgAkgFMJF3ARXARNJkXyRAAiRAAiSQGgLcvxkEoiVpFCAtfGxMAiRAAiRAAq4Q4P5NBVBL8ChAWvjYmARIgARIgARcIcD9mwqgluBRgLTwsTEJkAAJkAAJuEKA+zcVQC3BowBp4WNjEiABEiABEnCFAPdvKoBagkcB0sLHxiRAAiRAAiTgCgHu31QAtQSPAqSFj41JgARIgARIwBUC3L+pAGoJHgVICx8bkwAJkAAJkIArBLh/UwHUEjwKkBY+NiYBEiABEiABVwhw/6YCqCV4FCAtfGxMAiRAAiRAAq4Q4P5NBVBL8ChAWvjYmARIgARIgARcIcD9mwqgluBdvHgRN910E44fP47SpUtr9cXGJEACJEACJEACqSEgCmDVqlVx4cIFlClTJjUXNewqvry8vDzDxpQ2wzlx4oQSIBYSIAESIAESIIH0IyAGnCpVqqTfwBMwYiqAGhCvXLmCU6dO4cYbb4TP59PoKbyp/+2E1sWEYo27M65H3OiS0pDrkRSscXfK9YgbXVIacj1iYxXb13fffYdKlSqhWLFisRsUwRpUAA1dVJ5PMGthuB5cD7MImDUa3h9cD7MIcDR2CFABtEPJhTp8oLoAPcoluR5cD7MImDUa3h9cD7MIcDR2CFABtEPJhTp8oLoAnQqgWdC5HlyPtCFg1kC5f5i1HqaOhgqgoSvz888/Y/r06XjqqadQokQJQ0fpnWFxPcxaa64H18MsAmaNhveHWeth6mioAJq6MhwXCZAACZAACZAACSSJABXAJIFltyRAAiRAAiRAAiRgKgEqgKauDMdFAiRAAiRAAiRAAkkiQAUwSWDZLQmQAAmQAAmQAAmYSoAKoKkrw3GRAAmQAAmQAAmQQJIIUAFMElidbhcsWICZM2fi9OnTqF+/PubMmYPWrVvrdMm2EQhIlPU777yDQ4cOoWTJkmjZsiX++7//G3Xq1AnUlmi6J554Am+++SZ++ukntGvXDrI+wZ8OOnbsGIYNG4YtW7aofvr27YtZs2ahePHi5K5BQNbn6aefxogRI9Q9IIXroQE0jqYnT57EuHHjsHHjRiX/t912G1577TU0adJE9SZfU5g8eTJeffVVnD9/Hs2aNcPvf/979dzyF/n78OHDsW7dOvWnzp07Y968eeo76iz2Cfzzn//EpEmT8Ic//AE5OTm45ZZbMGDAAEyYMCHwJQuuh32erAlQATRMCtasWYN+/fopJaNVq1ZYtGgRlixZguzsbFSrVs2w0ab3cO6991707t0b//qv/wp5uD7zzDPYt2+fYl2qVCk1uSFDhmD9+vVYvnw5ypUrhzFjxuDcuXPYvXs3MjIykJubi0aNGqF8+fJ48cUXcfbsWfTv3x/du3dXmxxLfAQ+++wz9OzZE6VLl8bdd98dUAC5HvHxjKeVKG533HGH4i/cf/WrX+Grr75CjRo1ULt2bdWlvDBNnTpV3R+iHE6ZMgV/+ctfcPjwYfWJTCn33Xcf5LvpoiRKGTx4sOpD7isW+wSE8+zZs7FixQqlYP/tb3/DwIEDFXN5SeJ62GfJmvkEqAAaJgnyBt24cWMsXLgwMLK6deuia9euKi8gS/IIfPvtt2qT+/jjj9GmTRtcvHhRKXYrV65Er1691IXl289Vq1bFhg0b0LFjR2UZ6dSpE+SbzfJNSSmrV69Wb+ZnzpxRCgyLMwLff/+9ugfkJUg2N1GwxQLI9XDGUbf2+PHjsW3bNvz1r3+N2JVYm0TmR44cqayEUsRCW6FCBaUYPvroozh48CDq1auHnTt3KuugFPl3ixYtlOU92NquO96i3l6eM8JWLLD+0qNHD1x//fXqGcX1KOoSkPj5UQFMPNO4e7x8+bK6md966y1069Yt0I+83e3Zs0cpJizJI/Dll1/i1ltvVVbABg0aKJeuuHzF4le2bNnAhRs2bKgUcnF9TZw4Ee+++y727t0b+F0sJ5mZmaq9WE9YnBEQC6rwE2tH27ZtAwog18MZR93aorjJS45Y7+TZU7lyZQwdOhSPPPKI6vrIkSPKEvj5558rS6G/dOnSRbl3xVK1dOlSjB49GhcuXCg0HPld1lcsWCz2CPzXf/0XXnnlFWzevFlZW+WZ06FDB/Vy1KdPH66HPYysFUSACqBB4iDWJXnIylu3nEfzl2nTpqmHqbhVWJJDQN6eZeMS5c1v8Vi1apXaoMSqEVzkoVuzZk3lnhd31jfffKMeysFFvt4ibjF5MLPYJyDWU3F1iQv4uuuuK6QAcj3sc0xETeEvRRS43/72t/j000+VtU/k/qGHHsL27dvVMRU5J+i3fkt9uSeOHj2KTZs2QZ5dch988cUXhYYkCozcW/KlIxZ7BOQZJWdixbrqP34i94qfIdfDHkfWukqACqBB0uBXAOVGFheJv8hNLiZ+cZmwJIeABHH8+c9/xieffBII8LBSONq3b68sH/I2HrzZBY9MAkBef/11dcaQxR4BcaPfeeedSpkWK6uUYAsg18Mex0TVEhmW9ZDnkb9IMIco5zt27AgogPLckoAEfxELoazle++9pxTASC+vYmkfNGgQxM3MYo+AvByNHTtWBQjKGUDxColC/tJLL6lzx34FkOthjydr8QygUTJAF7A7y/H444/jT3/6kzq8LpY9f6HLMbXrIWsgRx/EuuEvEmTj8/lUlKNYlO655x665FO0LNWrV4e87EgQmr/I2WQ5lylWP7qAU7QQBZeRs8eiMMvLqr/IWrzxxhvKOMD1SO16FIWr0QJo2CrKQWlJsSAH4P1FzuKIe5JBIIldLHGpiPK3du1abN26VZ3/Cy7+oAN5wEpEqhRJzSMpYEKDQOSclN8KIpHc8kbOIBBn6/Xdd98p12FwETfhr3/9axVkIBugBOVwPZxxjbe2pDMSS15wEMioUaOwa9cuZW3yBx3I35588kl1GXmJlUCq0CAQadO0aVNVR/7dvHlzBoE4XBjJQiAKn0Rk+4vsCcuWLVMudq6HQ6Cszihg02TAnwZG3IviBpbUCYsXL8aBAwcgb+QsiSMgB9rFrShBHMHRiGXKlFH5/KTIwzYrK0udY5LABMkJKKleQtPASHSeuGYkYEQigCVIhGlg9Ncq2AXM9dDn6aQHcfXKWWQJdpIXIDkDKO5deSY98MADqitR9PxKiLxAictXXqZC08CIW1LODkqRYxPyLGMaGCerAfVc+eCDDxRHcQH//e9/Vyx/97vfqXXgejjjydp0ARspA2L9mzFjhrI2STSqRMtJWhKWxBIQ12KkIm/U8rCVcunSJXXuRhTF4ETQYo3yF0kELcpkaCJoCQRh0SMQqgByPfR4Om0tLz8SZPCPf/xDHY+QgBB/FLD05U88LEpJcCJoeW75i7wUhSaCnj9/PhNBO1wMsZA/++yzymMh3gUJvJEgM8lE4E86z/VwCNXj1ekC9rgAcPokQAIkQAIkQALeI0AF0HtrzhmTAAmQAAmQAAl4nAAVQI8LAKdPAiRAAiRAAiTgPQJUAL235pwxCZAACZAACZCAxwlQAfS4AHD6JEACJEACJEAC3iNABdB7a84ZkwAJkAAJkAAJeJwAFUCPCwCnTwIkQAIkQAIk4D0CVAC9t+acMQmQAAmQAAmQgMcJUAH0uABw+iRAAiRAAiRAAt4jQAXQe2vOGZMACZAACZAACXicABVAjwsAp08CJEACJEACJOA9AlQAvbfmnDEJkAAJkAAJkIDHCVAB9LgAcPokQAIkQAIkQALeI0AF0HtrzhmTAAmQAAmQAAl4nAAVQI8LAKdPAiRAAiRAAiTgPQJUAL235pwxCZAACZAACZCAxwlQAfS4AHD6JEACJEACJEAC3iNABdB7a84ZkwAJkAAJkAAJeJwAFUCPCwCnTwIkQAIkQAIk4D0CVAC9t+acMQmQAAmQAAmQgMcJUAH0uABw+iRAAiRAAiRAAt4jQAXQe2vOGZMACZAACZAACXicABVAjwsAp08CJEACJEACJOA9AlQAvbfmnDEJkAAJkAAJkIDHCVAB9LgAcPokQAIkQAIkQALeI0AF0HtrzhmTAAmQAAmQAAl4nAAVQI8LAKdPAiRAAiRAAiTgPQJUAL235pwxCZAACZAACZCAxwlQAfS4AHD6JEACJEACJEAC3iNABdB7a84ZkwAJkAAJkAAJeJwAFUCPCwCnTwIkQAIkQAIk4D0CVAC9t+acMQmQAAmQAAmQgMcJ/H8PfII8g1z6QAAAAABJRU5ErkJggg==\" width=\"640\">"
-      ],
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYEAAAD8CAYAAACRkhiPAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvIxREBQAAIABJREFUeJzt3Xt8VPWZ+PHPk4QkgggRErxgAlGQUFQk4WY11lbbys/dFS8tjda2utJUuz/x0oq2tlipi/3VrbbdCrTWLVuwWwVsLaC1XQu1FixBuUYEgsEISoARQSC3eX5/zEkySeacmSRzy8zzfr2G5HzPZb4no+eZ711UFWOMMekpI9EZMMYYkzgWBIwxJo1ZEDDGmDRmQcAYY9KYBQFjjEljFgSMMSaNWRAwxpg0ZkHAGGPSmAUBY4xJY1mJzkA4Q4cO1REjRiQ6G8YY06dUVVUdUNX8cMclfRAYMWIE69evT3Q2jDGmTxGR2kiOi6g6SETuEJEtIrJVRGY5adc7234RKet0/Pki8ndn/2YRyXXSS53tnSLyYxGR7t6YMcaY6AkbBERkHHArMAm4ALhKREYBW4BrgDWdjs8Cfg1UqurHgE8ATc7uJ4CZwCjn9dmo3IUxxpgeiaQkUAKsVdVjqtoMrAamq2q1qm4PcfyngU2quhFAVQ+qaouInA6coqp/18DUpYuAq6N0H8YYY3ogkiCwBSgXkSEi0h+YBpzlcfxoQEXkRRHZICLfdNLPBOqCjqtz0roQkZkisl5E1tfX10eQRWOMMT0RtmFYVatF5BHgJeAosBFoDnPNi4GJwDHgzyJSBXwY6vIu77kQWAhQVlZmCx4YY0yMRNQwrKpPquoEVS0HDgE7PA6vA1ar6gFVPQasBCY46cODjhsO7O1Zto0xxkRDpL2DCpyfhQQag5/2OPxF4HwR6e80El8KbFPVfcAREZni9Aq6Cfhdr3JvjDF9SFWtj/uXb+ZbyzdTVetLdHaAyMcJLBWRIQR6+dyuqj4RmQ78BMgHVojIG6r6GWfffwD/IFDds1JVVzjX+RrwX8BJwCrnZYwxKa+q1sfnFrxKiz+wveS1PXz/6vOomFyY0HxFFARU9ZIQacuB5S7H/5pAN9HO6euBcd3MozHG9HkLVu9qCwAAqnD/8s2ce9pASovyEpYvmzvIGGPiYOu+UH1j4NvLN8c5Jx1ZEDDGmBirqvWx13c85L7q946wZN2eOOeonQUBY4yJsWUb6kL3h3f88pWauOWlMwsCxhgTY50DwMnZmR22d9V/lLDeQhYEjDEmxk7J6dgH58YpRQTPnqnA0g11JIIFAWOMiaGqWh8/f2V327YAA0/qx5jTBnY47n+3vR/nnAVYEDDGmBhatqGOFn97hVBGhjCleAjZWR0fv+8daWD0t1Yyb2V1XPNnQcAYY2Koc3vAJ8cUUFqUx+cndh0k1tiizF9Tw9U/fSU+mcOCgDHGxNS4MwZ12L7s3AIAKiYXUj5qaMhz3qg7zLTH18SlsdiCgDHGxNDWvYfbfs8AfMca27YX3TKZ8cMHhTgLtu07wucW/D3mgcCCgDHGxEhVrY9n1r/Ttp2VlcGU4iEdjnnu6xdTWV5MRojFdlv8yoLVu2KaRwsCxhgTI2trDtLsNAoLcF3p8JDzBM2eVsIzlReFvMb7H56IZRYtCBhjTKzk9c+mtWOQ0rV9IFhpUR6V5cVd0kM1IEdTpFNJG2OM6SbfsUaEQAAQOrYHhDJ7WgmFQwYEppEQ4eaPj4z5VNMWBIwxJkZGNtWwMecWPtfwHd6kiLz+2WHPqZhcGNc1Bqw6yBhjYmTi+rsYyHF+mv3jLj2DkoWVBIwxJtrmBOr+8wEEzpF91ORWoKuByw57nRl3VhIwxphoy+gXMllc0hMpopKAiNwB3EqgbePnqvqYiFwPzAFKgEnO0pGIyAigGtjunL5WVSudfV8A7ifQTrIXuFFVD0TrZowxPbdk3R7+8+Ud7D/SQIYIV447jcdmXJjobEWkqtbHvFXVbH33MFmZGVRMKmT2tJLEZUhCdPr3Sk+gsEFARMYRCACTgEbgBRFZAWwBrgEWhDhtl6qO73SdLOBxYKyqHhCRHwBfJxBIjDEJNOs3r/PcG3uDUpTn3tjL1ncP89Ldn0hUtiIyb2U189cELcrS5Gf+mhre+/BEYoLYnNDdQBWQWVvim5cIRFIdVELg2/wxVW0GVgPTVbVaVbeHOTeYOK8BIiLAKQRKA8aYBFqybk+nANBuR/1H3PTkujjnKHJdAkCQ597Ym5iFWryqfAYOi18+IhRJENgClIvIEBHpD0wDzgpzzkgReV1EVovIJQCq2gR8DdhM4OE/Fniy51k3xkTDL/+223P/mh0HEroGrpuqWp9rAGgV94Va5haAv6lLsirU5oUeEZxoYauDVLVaRB4BXgKOAhuBZo9T9gGFqnpQREqB50TkY8BxAkHgQqAG+AlwHzC38wVEZCYwE6CwMH79ZY1JN1W1PnbtPxr2uF++UhPXvuuRCJ5TJx8fv8r+d0ZLHZmAv3XHRoELfgfFl3Y5v7Ud4Z1Dx7h6/JnRaUNobnDd9eqUBYzo/TtEXUS9g1T1SVWdoKrlwCFgh8exDap60Pm9CtgFjAbGO2m7VFWB3wIhQ6OqLlTVMlUty8/P79YNGWMiF7wA+kVsYmdOBTW5FezKvYGptNdf70zgGrhutu77EIAxvM3fcv6NEqkj02l3zWh9qaKL/jlQT/+zi+BIYPWuJev2cO0Tr/KPt32892ED89fUMOs3r/cuQ3MLQiarwqv+jyXlGAGIMAiISIHzs5BAY/DTHsfmi0im83sxMIrAN/93gbEi0vpUv4JALyJjTIL8becB8vGxMvubLM6ZR6a0PkCVJTkPszL7XvL5AIBvL9+c2MwGqar18a7vOG/lfJEXcu8nW/yIOA2P0unVetL+rfDoaHw/nMiPlv+1yzV73YagnZePafcVfaDL7KHJItJxAktFZBvwPHC7qvpEZLqI1AFTgRUi8qJzbDmwSUQ2As8Clap6SFX3Ag8Ca0RkE4GSwcNRvRtjTMSWrNvD2weP8VrO7YzNqOvwwGx9mI7NeIfXcm4jnw+ofu9I0rQNPLKqmt05FWRLS7fPzTv6Fq/l3MYYarvs63EbwtwCaAn9TV+BT4zODzl7aDKIaJyAql4SIm05sDxE+lJgqct15gPzu5lHY0wMXLtqAhW5XRsxOxOBf+Texgntx+f/8VzC2waqan38z74rXbvca9s/AaGOE4EXcu/jhGYwpuHXbemv97Qk4FIKUIXJDT8jmUdb2IhhY9JQVa2PbA0fAILlShPPHJweoxxF7rynRnmOuZK2fwJU3WtqcsXP7pyKtiqvHpd2XEoBAPUMZujAnO5fM04sCBiThiY8NaJHg1f7aWIbN5es20O/cMHr5NPY8JW38dPxBt0CgQi8lnNb2/aqLfu6l6kwDcICXDthePeuGUcWBIxJMzpnED14/gPOF2yXEbHx8IVV53kHrzFXwT3bKS3K4+6SlxnZsIT3dXBb7ZBbqUAE3s6t4M2cLzFkQPjpnjvwaBC+oelbnJ0/IGnbA8CCgDHpZW6BdwDIzIY5h+Hk08JeJ948g5dkBgLAjMVtSY/NuJDyUUOZ0vgzihuW0EBWh2AQSg5N/GHTvsh7CYVpEAa4+eKuq4UlEwsCxqQTl8FMCpCVCw/UBxLu2Q79PcboeAyKiolwwWtAfocA0GrRLZN5ePp5nDk4lwtafs2fdCL+Dv1GOxKBHf2+wNqagxFly+/3bhCuLC9OeEN6OKIeRZlkUFZWpuvXr090Nozp++YWhHx4KyCSAedO6/ognTOobWnEkObEaW78h/LdG18zs9uDV6S+lw9+9/aNloxsMr8T5pouf08IjFh+/StvJ7QaSESqVLUs3HFWEjAmXXh9ew8VACBQxeIlXtVCHr1vuh0AAL5TD5m5rrszPAJEK/X4e2acc0VStwMEsyBgTDrweFgLhA4ATrr0z8e1viAe1UIeUzMzorzn1x11OW5lnLAN4C7VUwow8HS48dme5yvOLAgYkw682gLufsv73G/upJF+7p1gYtlbKFxJ48vP9/zaMxbDmP/jfYzbvbn8PQXgzNKe5ykBLAgYk+o8+rH7M3IimuP+WOEno52ryLgFL4Vj/U7t/fVnLAavkk4o4QKTW6kqSVkQMCbVuVXZCGSOviKiS+Td/FsOyynxLQ24VQMpnKAfb964ITrv882dSEaOeyDonI/elKqSkAUBY1KZ14O0X163vrXu+sqmHr1Xj4T5tr0pd2J0G17DBcPvDQ389Ph7RlqqSjYWBIxJZW5LHQqc9K23u3Wp0qI8DskgrwGy0QsEHtVAB3QQWRVLovM+rWYs5mhmnvu9+Zs8A0CLZERcqko2FgSMSVVzBrkudXgiu2dz2988dAnHvRqJIdCnv4fmraymYc5Qz2OenPJiTLpfvnXT6xwny/veXHyU1b1SVTKxIGBMuhE46X7vtXndfH5iIWv842lG3B+WLY00zDmVmYvWd2uRllm/eZ35a2pcZzdVhZf9F3CkwWt1254rLcpjc+4kGr3uLUSeGshi5xerYpKneLAgYEwq8ugRtOvkCT2+bMXkQuYOuI8/+8toxmsOnhZ+vOsKrp//akSBoKrWx3Nv7GV3TkXICeJaG4Nvbrq3ez15uun3Y36ATwfhx3sK6tZ9x+nH7JI/9ZmBYaFYEDAmFXkM4jp8/bJeXfq2y0ZR2XQnf/ZPpAXvufp3ZVfw6NI1Ya+5bEOdawBotdo/PubTMl8zYThTG39GffDMo0H7lfb7VWCNfzyjhg2MWX7iwYKAManGowHTJ6f0+ltrxeRCykcNpbLpTpqdmTm95upffPgmrpuz0HOxlrkbL3ZfKUyhXgdR2XQnl48dFtNv3aVFeVwxdhhTGn/G/tZAoHQpfbQg/NE/kdtb7kratYMjZUHAmFQSpmvlvcVdVoTtkUW3TKZ81FDGNCxivw5uqz4JRQSe5Rtcs/L8kIFgY/X2rk9ZR2uVy6TGJwCovPTsqOTfy1ed92idgnpkwxIuzl3Gkis3M/JEYPuchsVUNt1JaeHgPl0VBBEGARG5Q0S2iMhWEZnlpF3vbPtFpCzo2BEiclxE3nBe84P2ZYvIQhF5S0TeFJFro39LxqQxj7Vu63VQVB+irdM0f4oF1AcFAvfqIeULq86D97a0Jz40lAv+Z5JrO0ALwhr/eACuHn9GXB64pUV5TBrR8X3e/eAEP3jxzS7HntPHq4IggoXmRWQccCswCWgEXhCRFcAW4BpgQYjTdqnq+BDp3wL2q+poEckAojDu2xgDeC5wAvDLKS8yO8oP0YrJhVRMLmTJur8y6i+VlB3/GwKu008LoPM/HnZlMwVU4H/9ZXwz8xtUTi1k9rSSqObdy71XlnDtE692SPvgWMdeS8m+bGSkwgYBoARYq6rHAERkNTBdVX/gbHfn/W4GxgCoqh840K3cGmNcaXND6JktFTaeNDGmD9GKyYUweSX85gbYvhJRf1sNT+c8RRIABEFOHsan7/kTYcYpx0RpUR4lpw2k+r0jrsfEun0iXiKpDtoClIvIEBHpD0wDzgpzzkgReV1EVovIJQAiMtjZ95CIbBCRZ0Sk742xNiYJNT+Y7/pwVYHxs/8Un4zMWAzf9cHJpyHQViqIVFtVUmZ2YHWzBJrg8YAX4tM+EQ9hg4CqVgOPAC8BLwAbAa/RGvuAQlW9ELgLWCIipxAodQwH/qaqE4C/Az8MdQERmSki60VkfX19DxaMMCaNVNX6aPb7Q+5TAgucxN092zssSOPVVhC8XwXk5NPggf1xyKS3ayYMdw2s359+XkqUAiDChmFVfVJVJ6hqOXAI2OFxbIOqHnR+rwJ2AaOBg8AxoLV7wjNAyFErqrpQVctUtSw/v+dD0I1JB+c9NYpcCf29TCBxC5zMWAxzDiOZOW11QG0Pe6fbZefupUezhiS8BNCqtCiPr5Z3XCRegIenn5f06wZ3R6S9gwqcn4UEGoOf9jg2X0Qynd+LgVFAjQYWM34e+IRz6KeAbT3OuTF9yLyV1Ux5+E98LsIRtJGqqvXRz2WaBQASUQro7IH9yJirUNeluAK9gF70T2Tex34X16yFM3taCQ9PP48Lhg/i02OH8ezXLkqpAAARLjQvIn8FhgBNwF2q+mcRmQ78BMgHPgDeUNXPON0+v0egyqgF+K6qPu9cpwj4b2AwUA98RVXdR5BgC82bvu+KR//CjvqPOqQVDMzmmguHU7XHx9Z3D5OVmUHFpO73gNE5g9wbWgeeDnd37daYKDMXreeP295v2x58Uj8+ON4ewDIEnqm8KGWqWRIt0oXmI+kdhKpeEiJtOe1VO8HpS4GlLtepBXqxKKgxfcvVP32lSwAA2H+kkflrgiZxa/Izf00N2/Z9yKJbJkd8/RayyHJrokvyZQ6DAwBAWVGeBYAEsBHDxsTIknV7eKPucIe0i9jEzpwKdudUsKvtdQNTCQygWrPjAPNWVkf2BnMGuQeAAflJN7Vx/sAcz/2D+2fHKScmmAUBY2Lkf/7RsabzIjaxOGcemc52RttLWZLzMH/Mvod8PmD+mpretxt8Y2fvzo+BayYM95wgbmiYIGFiw4KAMTGSk9X+v9funAqW5M5DBNfX6Iy9vJZzWyAQrN7lfXG3SeIARiRnjWtpUR7fv/o81/2pMPq2L7IgYEwMVNX62PDOBwBhp0gOJgL/yL2Nn+z6tHtpwGOSOAH48vPdy2wcVUwu7DIvD8RvXiDTlQUBY2Jg2YY6mlu0WwEgWK60cN5TLiNS3dbfhUBbQJK798oS+mW2/1GuHn8Gj824MIE5Sm8R9Q4yxnSP0r0SQCjZtAS6gM4Jalz2WCugKSOb7CRsC+istCiP38ycytqag0wpHmIlgASzkoAxMXBKTpjvV5k5MOcw4f4XFAg8+I+8H3YB94/OuqxbeUyk0qI8br/sHAsAScCCgDFRVlXrY9a6S9xLARn92ufGmROYbC2sR0e7ThOtCh9kDCbv5t/2LMMmrVkQMCbKlm2oIwePqRy+02kG9Xu2twWC7i6irgoNZPH/zv9DN880JsCCgDFR5rVeLie5rEfrzLrZOqFaBLO5oAp+4C/+C617pekxCwLGRFmTV3+Le2vc981YTPNJBbROCu0WDNoChfNevzzze1a3bnrMgoAxUeR/qIBsr6kcwsi+dwc7T72UFqStaqj1gQ/OT2e7kSzGNCxKiXVuTeJYEDAmiqQldB9+IOKpHM694/d84qSl7NfB7YlBgaAF4Y/+iYxpWESG2Ehb0zs2TsCYaJlb4D6tczencrjtslFMWf6zDmlDT86meOgAXnu7fSSxzbxpestKAsZEi1drbjencqiYXMjY0ztW8xw42tghAIDNvGl6z4KAMdHi0o+/px7ymGytlc28aXrLgoAx0eAyqZsCVP6tR5csLcrrUhoIJlh7gOk9CwLGRINXVdBp43p8Wa/SwOVjh1l7gOk1CwLGJLHSojyWfu0iJo7IIydo5s3sTKHyUpdZRo3phoh6B4nIHcCtBEqgP1fVx0TkemAOUAJMUtX1zrEjgGpgu3P6WlWt7HS93wPFqtrzr0jGJAuPmT03zXiNC3p5+dKiPJ6pvAgIzEtks2+aaAobBERkHIEAMAloBF4QkRXAFuAaYEGI03ap6niX610DHO1xjtNMVa2P+at3sf/DE3x+YiEVkwsTnSXTWUY/8IeYK0jggpJzo/pWpdYl1ERZJCWBEgLf5o8BiMhqYLqq/sDZjvjNRORk4C5gJmBTHoZRVevjcwtepcWZR2Bj3WYACwTJZG5ByACgCm+dMoXohgBjoi+SNoEtQLmIDBGR/sA04Kww54wUkddFZLWIXBKU/hDwKHCsZ9lNL8s21LUFgFb/8dL20AebxHBZ5QvgV8U/jGNGjOmZsEFAVauBR4CXgBeAjeA2OQoA+4BCVb2QwLf+JSJyioiMB85R1eXh3lNEZorIehFZX19fH8l9pKQNIdaYPXC0kXkrqxOQG9OFW7dQhVf1Y9Z90/QJEfUOUtUnVXWCqpYDh4AdHsc2qOpB5/cqYBcwGpgKlIrI28ArwGgR+YvLNRaqapmqluXnJ/+aqbEwb2U11e8dCbnvt+vfiXNuTEge3UJ/dc6Pre7e9AkRBQERKXB+FhJoDH7a49h8Ecl0fi8GRgE1qvqEqp6hqiOAi4G3VPUTvct+aqqq9bFgjfuUw75jTVSFKCWYOIvyCGFjEiHScQJLRWQb8Dxwu6r6RGS6iNQR+Ia/QkRedI4tBzaJyEbgWaBSVQ9FPecpbNmGOs8VphRYuqEuXtkxoXhUBV3Z8O82nYPpMyIaJ6Cql4RIWw50qd9X1aXA0jDXexuwMQIuOgcAAcacNrBD9dDO90NXFfVVfa7/u0eD8FtSxPetPcD0ETaVdBIad0bHwUdfLS/mSENzhyCwvtZHVa2vbzwww5i3spr5TvWXAN+ffl5yd4P1GBx2UAfa9M6mT7FpI5LQX7bv77B9pKGZayYMJyNoSIZf+36V0JJ1e7jgwRfbAgAESkH3L9+c3G0e0s91V1njAlvpy/QpFgSSTFWtjz9Vv9+2nY+P29/8IqVPjWBXTgWfZW3bvr5cJTRvZTX3L9/M4ePN5OPjj9l3U5NTwa6cCnbl3MDzzy1JdBZDmzMINPTgsHoNlBCsa6jpS6w6KMks21CH32kUyMfHqpx7GdLQPsvGEzk/plqX86XG+6jaI32ySmjJuj3MX1PDRWxiUc48MqBtRa7AT+W7h+5H59zvbAsUjIUvLoeBwxKTaXBtDG41qfEJzhyc2+c+D5PeLAgkmR3Ot/vtOTeRIx3H5Inzz1h5h9dybqO4YQlraw72qYdOVa2P+5dvZhqv8p85PyWyWUcU3b8VHh2NX+EEOXwt59/57KeuiGvbgTY3hFw+UhVe9gemibv9slFxy48x0WBBIIlUOY29b+Z8qUsA6EwEdudW0PLXbLis74yqfuC5zezOqYjw4d+u9fBMgf7awK8a7oKVULNqOEc+vyzqE7V11jgnH6+FHG9uupczB+cmd4O2MSFYm0ASWVtzkK3ZXyJXQsxI6SLD33cGLM1bWc2KQ//kGgCUwLdqr/VZIBAAW18jtY7zfjOJpu+dBu9tiXqeIZDvfhr672ylANPXWRBIInn9s+k6SsCbAOrSZTGZVNX6uHfdFM8SgLT90x4MwgUFEcgQ6Oc/jj7xceY+8nBUexZ55VsVTtCPm5vu5erxZ1gpwPRJFgSSiO9YIzmec/OFJhC20TLRJjw1ottVQMEiDQjfPv4IE345gq0beraub2fn/ddoz3y/ljmBh6efx2MzLozK+xkTb9YmkES+umaq+wPnpCEgGXDMpf7fYwRroumcQaEbVGn94p8BcwLf3oWOg8fWZt/GMPmg/SQJKispIf9eIjD2d9N4/6WzGXbbql71KHKrBgKQk/O59Bt/7PG1jUkGVhJIElW1Ppr9fvcD7q2Bb+70vkgSlgbcAgA4ASAzpy0AtJo9rYSHp5/HOfkD+EzWQkqznuWRyWuRkqsQyUBorzpyKx2IwLDju9BHR8OR97se0Mu8k5UD3wjzeRjTB1hJIEmc/1+j6RemRxAA51yO7vxT6IdT95oTEi8zGx7YH3JXxeRQS2kubv/1h+ciR99Dg9oQQpYKAB4dHVgC8jsHopHrgHOuiN61jEkgKwkkC6/K7rvfav/9Ro+5+Voakqo04FUNRFYOPNCLrq33bIc5h5ExVwVKBtLeuygkfxN8b2jk1/cqBZw0BGYsdttrTJ9iQSBJZHg1mnaq05ZzLnf/0p8spYG5Bd7VQNH6Jj1jMcw5DJk5HaqIQvI3RdaTKtwx97qv9WBMX2NBIBnMLSAzxHw0QOiHZR8oDahXQ/WA/Oh/k35gP4wJtBl4BYK2LrVu7QQefzuFQN6NSSEWBJKA3+/x9f3GZ0Mm7x16sfs33kSXBsJVA8WqQXXGYviuD8nMCRsIeHQ01KzuuOOhAtdeVgpIVq41BpuUY0EgCbS4BgH3OqIzv77CfXciSwPh3jceDaoP7EdOPs27aghg0T8Hqn5aXy0uAUDBTwacc3ls8mtMAlkQSAI/HPsMTZrR9sBSgH794e7tnucdPvMTyVcacMmQAhKLaiA392xHxlyFSkZEU1G4UYVmMviw8AprDDYpyYJAos0t4L5tV9NP/G1dHAWg6VjYQU6Db/2da2lAXb7VxpzX4uvxrkqZsZiMMdM6TEXRHaqB4HUi+1Tybv5t1LNnTDKIKAiIyB0iskVEtorILCftemfbLyJlQceOEJHjIvKG85rvpPcXkRUi8qZz3rzY3FIf4/pkimyOhbcHTgg9WAriXyXksezikdMuim9eWs1YjIy5Cr9kRDxBXdsUFUAjWcwb+1w8cmpMQoQNAiIyDrgVmARcAFwlIqOALcA1wJoQp+1S1fHOqzIo/YeqOga4EPi4iFzZ6ztIVZnuSxgGG3n3y67xwrPBOdq8Ao7AKZWr4peXzmYsJnOOj4+y28cJdJ6grvWh3/oXaw0AYxoWJbyd3ZhYiqQkUAKsVdVjqtoMrAamq2q1qnpXWgdxzn/Z+b0R2ACk/Tp80XhOu5UZMvyN+B+KU2nArS1AoSm3G4O0Ymjgt3bxQdFnaPGay9r5sV8HM6ZhEYItF2lSWyTTRmwBvi8iQ4DjwDRgfZhzRorI68CHwLdV9a/BO0VkMPBPwOOhThaRmcBMgMLCFJ6ed26B+3oAs7oxN/7d29FHzw0ZDFr8/tg3/MwtcG8LEMievSvWOYhYa93+knV7mLtiG8caWzyPnzgir0+t3GZMd4V9PqhqNfAI8BLwArARPOc73gcUquqFwF3AEhE5pXWniGQBTwM/VtWQQy9VdaGqlqlqWX5+Cg/OuWMTu0+f1t4ryKmSYNDw7s18OfA019JAP22KfduAW996hb1DL4nte/dQxeRC/vuWyWGPO2fYwDjkxpjEiehLoqo+qaoTVLUcOATs8Di2QVUPOr9XAbuA0UGHLAR2qOpjPc92inj8fEbuW9neK0icqp0P93b/Wh592N3HIUSBS4BRhQMZp3Lm1/8Qu/fupdKiPCrLi133W1WQSQeR9g4qcH4WEmgMftrj2HwRyXRbOSN4AAAUmElEQVR+LwZGATXO9lxgEDCrd9lOEW7dVDJ6MLmrx1QSzS3+qK62FcxreoissybG5D2jafa0EspHhW6zuHzsMKsKMikv0uripSKyDXgeuF1VfSIyXUTqgKnAChF50Tm2HNgkIhuBZ4FKVT0kIsOBbwFjgQ1O99F/je7t9CEu9egK3WsPCOZSGsiRZiY8NaJn1/Tgf8h9kjiEPtO3ftEtkxk/vGP31gyBykvPTlCOjImfiL5yqmqXil1VXQ4sD5G+FOjytVRV64i083s68Oqs3tOVsG5c6tpXv5ksIut0GrnmlhayQ6QrIMHTX/cBz339YuatrOa5N96l8NT+3HtliZUCTFqwRWUSZdZmjvznJzn5+LuBufAVGjIHkFvcy0FVkgHadYUyvwZWL4vWg635wXyyXfoHCPRqScdEmT2thNnTShKdDWPiyqaNSJTHz2fgiXc7NArn+j+Ct0ONveuGu6pDJkezSmjJuj2uS2Eq2KpbxvQhFgQSYW7oKYsV4I7Nvbv2wNNcdzVHqeB33aoJ5LoshSngOv21MSb5WBBIhDs2cbD4n9tGC7dOW3Dw7GujU43i0kDcj+aojCBWr4kUrBRgTJ9iQSARHj+fITW/b1tSUiTwGlrTpZ29Zzy6i0ovZxetqvV5T8BmpQBj+hQLAokQzfEBbkaEHqnb29lFJzw1wrUqyEoBxvQ9FgRS1Zc9Rur2YgCxZ7uClQKM6XMsCCTCrM20kNFhzqCmjJN6Pkisu3q4/KT/oQL6uU4bZUNAjOmLLAjE29wCePRcMvF36B6a6T8e/b71XstT9qA00NISulto2PcyxiQtCwLx1suVxLrFo7to9N+r7w0OM8ZYEEgeGdGe1MEhLh9xd6uE5gyiH02h91mDsDF9lgWBeAvRHnBCcsm4M0btAXdVu9f8dKdKyCtIWYOwMX2WzR0UT85I4cA824EkEcjWE7GrTolGldDcAvB3LQUoIFYKMKZPs5JAPMWzPSD46udcHvpLf0uD66yjHbisGWBTRBjT91kQSAaxag9o5TGCmMxQk0EHcVs5DGBEeY+zZIxJDhYE4ilEe0BDLNsDgtSeelHogkhLo3dpwGuOiC8/3+t8GWMSy4JAvLiMD4hpe0CQg/+yxH2nV2kgxOpnxpjUYUEgXly+UWucRtqWFuWxLmtC90oDHlVBUvm3qObPGJMYFgQSrCWOHbRqPv2r7p3gsYg8p43rXWaMMUkhoiAgIneIyBYR2Sois5y0651tv4iUBR07QkSOOwvJvyEi84P2lYrIZhHZKSI/FpH0mXBm1mb8ktmhPeAjzWHb5+P3jbpiciGbs893r+YPLg24tBOowol+tvauMaki7NdQERkH3ApMAhqBF0RkBbAFuAZYEOK0Xao6PkT6E8BMYC2wEvgssKpnWe9DnPEBGdBhfMBJNHBByblxzUrTjb+HX45wPyCCUcRzxz7P96OXJWNMAkVSEigB1qrqMVVtBlYD01W1WlUjnjVMRE4HTlHVv6uqAouAq3uU674mwe0BwUqL8jgkg9xLA80NrtVAqlCvg3ozE7UxJslEEgS2AOUiMkRE+gPTgLPCnDNSRF4XkdUi0rq6yZlAXdAxdU5aFyIyU0TWi8j6+vr6CLLYN/kTNGD7vuJlHCfLe4WwTlThBP2Y0vQE104YHrvMGWPiKmwQUNVq4BHgJeAFYCO4TioPsA8oVNULgbuAJSJyCqGHxYZ8DKnqQlUtU9Wy/Pz8cFlMfrM20yg5CW0PCPbVS89mjf9CGvEeBtDZav94yoryKC2yNgFjUkVEDcOq+qSqTlDVcuAQsMPj2AZVPej8XgXsAkYT+OYf/BVyOLC3pxnvUx4/n2xt6DA+YIA0cMHS0EtAxlppUR5vTP0JPh1MC96BQAG/Uw1U2XQn5wwbGK9sGmPiINLeQQXOz0ICjcFPexybLyKZzu/FwCigRlX3AUdEZIrTK+gm4He9zH/ycxqFO/MD3LE57tlpNXtaCTcP+e+25SJVuwYDdf7xI0xqfIKsTLGqIGNSTKTjBJaKyDbgeeB2VfWJyHQRqQOmAitE5EXn2HJgk4hsBJ4FKlX1kLPva8AvgJ0ESgip3zPIq1E4wQuxPHT1eYxpWIQ/qKauc25bEP7kD/QA/uS5BVYVZEyKiahlUlW71Fuo6nJgeYj0pUDIGctUdT1go4xIjlF6pUV5TBqRx9lvL2Z+vx9xScZG9vsH03ByIWOa38TXnM2EYz9NdDaNMTFk6wnE2qzNtDxaQoYG5gxShYaMXHLv2pTonAFw75UlXPvEq1Q23dmeeAgqy4tZsKamw7FDB+bEOXfGmFizIBBLiVhEpptKi/IYPjiXug9OdEj/xSu7O1QNCVh7gDEpKBlqJVJXghaR6a7bLhvVJa3Z3zHvZ+cPsPYAY1KQBYFEiPUiMt1UMbmQyvJiz2Nuvth7vzGmb7IgECtzC0LOxa8Ql0Vkumv2tBKuHn9GyH0DczKpmFwY5xwZY+LBgkCsuHYNJWnaAzp7bMaFjB/edfbQGyYXJSA3xph4sCAQZ5Jk7QGdPff1i6ksL2ZgTian5GZRWV7M7Gklic6WMSZGRLszeUwClJWV6fr16xOdje5xGSWsgNz9VtKWBIwxqUNEqlS1LNxxVhKIBa/AagHAGJNELAjEUSLWDzDGGC8WBOIonusJG2NMJCwIRJtb11AlYesHGGOMGwsC0ebWNVSI+3rCxhgTjgWBuLH2AGNM8rEgEE0eVUG/mvpCAjJkjDHeLAhEU4ixAa1yBoeeksEYYxLJgkC0zC0ImawKr/o/hu9Y1xKCMcYkmgWBaPEYIPallm8zpXhIHDNjjDGRiXSh+TtEZIuIbBWRWU7a9c62X0S6DE0WkUIROSoi9wSl3emcs0VEnhaR3OjdSnxU1fq4ddF6/uWnr7Bk3Z5AoktbAASmivjXi0faXPzGmKQUdvSSiIwDbgUmAY3ACyKyAtgCXAMscDn1RwQtJC8iZwL/FxirqsdF5LfADOC/enMD8VRV6+NzC16lxR/Y3li3mdd2H+Qxt26hCpMbfsanG5rjmEtjjIlcJCWBEmCtqh5T1WZgNTBdVatVdXuoE0TkaqAG2NppVxZwkohkAf2BvT3Pevwt21DXFgBaPffGXtSlFABQz2CSe4o+Y0w6iyQIbAHKRWSIiPQHpgFnuR0sIgOAe4EHg9NV9V3gh8AeYB9wWFX/2NOMJ8KO9490SdudUxFyBEBrg3CG2Nq8xpjkFTYIqGo18AjwEvACsBHwqt94EPiRqh4NThSRPOBfgJHAGcAAEbkx1AVEZKaIrBeR9fX19RHdSKxV1fpYX+vrkPZmzpcQjzFgNzR9i7KiPGsPMMYkrYhmNFPVJ4EnAUTkYaDO4/DJwHUi8gNgMOAXkRPA+8BuVa13rrMMuAj4dYj3WwgshMB6AhHfTQwt21BHp7XXyaEp5LGqUK+BFbrOGTYw1lkzxpgeiygIiEiBqu4XkUICjcFT3Y5V1UuCzpsDHFXVn4rIZGCKU6V0HPgU0GdWi6k/0nEg2O6cipClAFU4QT8mNT5BplUFGWOSXKTjBJaKyDbgeeB2VfWJyHQRqSMQEFaIyIteF1DVdcCzwAZgs/PeC3ue9fgaOjCn7Xe3ANBqtX88ALdeUmxVQcaYpBZpddAlIdKWA8vDnDen0/Z3ge92I39JY9wZXRdg70wJVANVNt0JwBHrGmqMSXK2ykmEtu49DERWDdSWFq/MGWNMD9m0ERGoqvXxzPp3wvYGaq0GamXtAcaYZGdBIAJraw7S7NewvYFaq4EAzhyca+0BxpikZ0EgAnn9s9mV7VINRNdqIIDbLxsVn8wZY0wvWBCIgO9YIw1kuu7vXA1UPmooFZMLY50tY4zpNWsYjsBtq0td2wJkQD75n3uGiauqeefQMa4efyazp5XEN4PGGNNDFgR66xs7KQWeqbwo0Tkxxphus+qgcOYWuC8RP6I8njkxxpiosyAQhnqsG8yXn49fRowxJgYsCHjxKgWcZMtFGmP6vrQPAkvW7eGLT65rXyoymFcp4N6a2GXKGGPiJK0bhm96ch1rdhwA4K87DrDn4EftPXvmhJ4rSAGxUoAxJkWkbUlg3srqtgDQav6aGqpaF47J6Od+spUCjDEpIm2DwG+rQq+Ls3RDXaAU4O86RYQqNOUOjXXWjDEmbtIyCFTV+jj0UejF4V/vtIRkZz+f7LlsgjHG9ClpGQSWbXBfHXOl759CpqvC3/VjTCm29gBjTOpIyyDgNs+/11oBLQhv/5/f2MygxpiUkpZB4JScjp2ixg8fFHbJyAM6CN+x0FVIxhjTV6VdEKiq9fGLV3a3bQsw8KR+3NAwm2PaDw0qJijgV2ggiymNPyOvf3bc82uMMbEUURAQkTtEZIuIbBWRWU7a9c62X0TKQpxTKCJHReSeoLTBIvKsiLwpItUiMjV6txKZtTUHafG3P+kzM4Qrx53OaxkX0EigW6hqe5XRcbIZ07CIDLCSgDEm5YQdLCYi44BbgUlAI/CCiKwAtgDXAAtcTv0RsKpT2uPAC6p6nYhkA/17mvGeyuuf3aFN4F8vHknF5EL2HPyI3HWNNJHJJv9Izs/eR1bLcf6mFyBAVlaGNQobY1JOJCOGS4C1qnoMQERWA9NV9QfOdpcTRORqoAb4KCjtFKAc+DKAqjYSCCpx9Zft+ztsH2loBgJVQiUNiwIjgoF7PnkuU4qH8PWFfweUDvVExhiTIiKpDtoClIvIEBHpD0wDznI7WEQGAPcCD3baVQzUA0+JyOsi8gvn2LipqvXx0rb3O6S1PtqDSwjqbC/bUEdTi6JAi19ZW3Mwjrk1xpjYC1sSUNVqEXkEeAk4CmwEmj1OeRD4kaoe7VRKyAImAP+mqutE5HFgNvBA5wuIyExgJkBhYc+Xaayq9TFvVTVv7vuQzAzheLO/Q1WQANdOGA7Alr2HO5z78vb9rN6+v+34zEyrDjLGpJ6IJpBT1SeBJwFE5GHAfbQVTAauE5EfAIMBv4icAJ4F6lR1nXPcswSCQKj3WwgsBCgrK+tRPUxVrY/rnnjVdUwAwNn5A9r6/Xeu1Np94COanQZkAa4rHW5jBIwxKSfS3kEFzs9CAo3BT7sdq6qXqOoIVR0BPAY8rKo/VdX3gHdE5Fzn0E8B23qTeS8LVu/yDAAAN19c3Pb7NROGk5XZHgpq6o/S2olIgXFnhJ5V1Bhj+rJIxwksFZFtwPPA7arqE5HpIlIHTAVWiEgkk+r8G7BYRDYB44GHe5TrCLy+x3sOoIE5mVRMbq9qKi3K45PnFrRt+ztFkK2dqouMMSYVRFoddEmItOXA8jDnzem0/QbQZUxBtC1Zt4f6o94dj26YXNQlLX9gjuvx1jfIGJOKUnJRmVVb9nVJ+/TYYbxz6Bi+Y41cPf7M9sVjgnzMo8rHqoOMMakoJYPAleNO569BC8ZUlheHfOh35jYiWDz2GWNMX5aSQaC1rn/Vln1cOe70DnX/XqYUDyED8HdKF8G6hxpjUlJKBgEIBIJIH/6tSovyuHzsMP7YaUBZ8dAB1j3UGJOS0m4W0XC+eunZZHb6qwR3JTXGmFSSsiWBniotyuO3X72I+at3sf/DE3x+YvdLFMYY01dYEAihtCiPn98U856sxhiTcFYdZIwxacyCgDHGpDELAsYYk8YsCBhjTBqzIGCMMWnMgoAxxqQx0SRfO1dE6oHaOL/tUOBA2KNSSzreM6TnfafjPUP63XeRquaHOyjpg0AiiMh6VU2rgQLpeM+QnvedjvcM6Xvf4Vh1kDHGpDELAsYYk8YsCIS2MNEZSIB0vGdIz/tOx3uG9L1vT9YmYIwxacxKAsYYk8YsCAQRkc+KyHYR2SkisxOdn2gSkbNE5GURqRaRrSJyh5N+qoi8JCI7nJ95TrqIyI+dv8UmEZmQ2DvoORHJFJHXReQPzvZIEVnn3PP/iEi2k57jbO909o9IZL57Q0QGi8izIvKm85lPTfXPWkTudP7b3iIiT4tIbjp81r1lQcAhIpnAfwJXAmOBL4jI2MTmKqqagbtVtQSYAtzu3N9s4M+qOgr4s7MNgb/DKOc1E3gi/lmOmjuA6qDtR4AfOffsA25x0m8BfKp6DvAj57i+6nHgBVUdA1xA4P5T9rMWkTOB/wuUqeo4IBOYQXp81r2jqvYKtItMBV4M2r4PuC/R+Yrh/f4OuALYDpzupJ0ObHd+XwB8Iej4tuP60gsYTuCB90ngD4AQGDCU1flzB14Epjq/ZznHSaLvoQf3fAqwu3PeU/mzBs4E3gFOdT67PwCfSfXPOhovKwm0a/2PqFWdk5ZynKLvhcA6YJiq7gNwfhY4h6XK3+Mx4JuA39keAnygqs3OdvB9td2zs/+wc3xfUwzUA0851WC/EJEBpPBnrarvAj8E9gD7CHx2VaT+Z91rFgTaSYi0lOs6JSInA0uBWar6odehIdL61N9DRK4C9qtqVXByiEM1gn19SRYwAXhCVS8EPqK96ieUPn/fTvvGvwAjgTOAAQSquTpLtc+61ywItKsDzgraHg7sTVBeYkJE+hEIAItVdZmT/L6InO7sPx3Y76Snwt/j48A/i8jbwG8IVAk9BgwWkdalVYPvq+2enf2DgEPxzHCU1AF1qrrO2X6WQFBI5c/6cmC3qtarahOwDLiI1P+se82CQLt/AKOc3gTZBBqVfp/gPEWNiAjwJFCtqv8RtOv3wJec379EoK2gNf0mp+fIFOBwa1VCX6Gq96nqcFUdQeDz/F9VvQF4GbjOOazzPbf+La5zju9z3w5V9T3gHRE510n6FLCNFP6sCVQDTRGR/s5/6633nNKfdVQkulEimV7ANOAtYBfwrUTnJ8r3djGB4u4m4A3nNY1APeifgR3Oz1Od44VAb6ldwGYCvS4Sfh+9uP9PAH9wfi8GXgN2As8AOU56rrO909lfnOh89+J+xwPrnc/7OSAv1T9r4EHgTWAL8N9ATjp81r192YhhY4xJY1YdZIwxacyCgDHGpDELAsYYk8YsCBhjTBqzIGCMMWnMgoAxxqQxCwLGGJPGLAgYY0wa+//r7KsvP/3IlgAAAABJRU5ErkJggg==\n",
       "text/plain": [
-       "<IPython.core.display.HTML object>"
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "pl.plot(t-45,h.data,'.',t_filt,hf2,'*')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 99,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "t_filt_dec = np.linspace(0,len(h.data)-91,16)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 100,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "hf3 = np.dot(one_minute_gauss_filter, as_s[::60].T)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 121,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([9146.3294147 , 9148.70819126, 9153.2441662 , 9150.7324949 ,\n",
+       "       9151.04734904, 9153.19756752, 9152.87407819, 9152.39041223,\n",
+       "       9154.92828897, 9154.92281761, 9157.04724769, 9156.78471925,\n",
+       "       9156.09298106, 9157.78661802, 9156.74486717, 9158.39531688])"
       ]
      },
+     "execution_count": 121,
      "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "hf3"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 101,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
      "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "pl.plot(t-45,h.data,'.',t_filt,hf2,'*',t_filt_dec,hf3,'^')\n",
+    "pl.xlabel('time (s)')\n",
+    "pl.ylabel('field (nT)')\n",
+    "pl.legend(['One Second Signal', 'One Minute Filter Applied', \n",
+    "           'One Minute Downsampled Filtered Data'])\n",
+    "pl.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 102,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[<matplotlib.lines.Line2D at 0x1c26399358>,\n",
+       " <matplotlib.lines.Line2D at 0x1c263994e0>]"
+      ]
+     },
+     "execution_count": 102,
+     "metadata": {},
+     "output_type": "execute_result"
     },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "pl.plot(t_filt, hf2 - h.data[45:-45], '.C1', \n",
+    "        t_filt_dec, hf3 - h.data[45:-45:60], '*C2')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 103,
+   "metadata": {},
+   "outputs": [
     {
      "data": {
       "text/plain": [
-       "[<matplotlib.lines.Line2D at 0x1c2923ef98>,\n",
-       " <matplotlib.lines.Line2D at 0x1c29246160>]"
+       "[<matplotlib.lines.Line2D at 0x1c2645a278>,\n",
+       " <matplotlib.lines.Line2D at 0x1c2645a400>]"
       ]
      },
-     "execution_count": 37,
+     "execution_count": 103,
      "metadata": {},
      "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
     }
    ],
    "source": [
@@ -7416,7 +1199,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 38,
+   "execution_count": 104,
    "metadata": {},
    "outputs": [
     {
@@ -7590,7 +1373,7 @@
        "       9158.832])"
       ]
      },
-     "execution_count": 38,
+     "execution_count": 104,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -7601,7 +1384,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 39,
+   "execution_count": 105,
    "metadata": {},
    "outputs": [
     {
@@ -7610,7 +1393,7 @@
        "9156.74486717354"
       ]
      },
-     "execution_count": 39,
+     "execution_count": 105,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -7621,7 +1404,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 40,
+   "execution_count": 106,
    "metadata": {},
    "outputs": [
     {
@@ -7630,7 +1413,7 @@
        "655928"
       ]
      },
-     "execution_count": 40,
+     "execution_count": 106,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -7641,7 +1424,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 41,
+   "execution_count": 107,
    "metadata": {},
    "outputs": [
     {
@@ -7650,7 +1433,7 @@
        "7928"
       ]
      },
-     "execution_count": 41,
+     "execution_count": 107,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -7661,7 +1444,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 42,
+   "execution_count": 108,
    "metadata": {},
    "outputs": [
     {
@@ -7670,7 +1453,7 @@
        "82.73562058526741"
       ]
      },
-     "execution_count": 42,
+     "execution_count": 108,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -7681,7 +1464,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 43,
+   "execution_count": 109,
    "metadata": {},
    "outputs": [
     {
@@ -7690,7 +1473,7 @@
        "62969088"
       ]
      },
-     "execution_count": 43,
+     "execution_count": 109,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -7701,7 +1484,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 44,
+   "execution_count": 110,
    "metadata": {},
    "outputs": [
     {
@@ -7710,7 +1493,7 @@
        "1952041728"
       ]
      },
-     "execution_count": 44,
+     "execution_count": 110,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -7721,7 +1504,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 45,
+   "execution_count": 111,
    "metadata": {},
    "outputs": [
     {
@@ -7730,7 +1513,7 @@
        "1296000"
       ]
      },
-     "execution_count": 45,
+     "execution_count": 111,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -7741,7 +1524,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 46,
+   "execution_count": 112,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -7750,7 +1533,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 47,
+   "execution_count": 113,
    "metadata": {},
    "outputs": [
     {
@@ -7774,7 +1557,7 @@
        "       9158.832])"
       ]
      },
-     "execution_count": 47,
+     "execution_count": 113,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -7785,63 +1568,83 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 48,
+   "execution_count": 114,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "h_end_nan[5] = np.nan\n",
+    "#h_end_nan\n",
+    "h_end_nan = np.vstack([h.data[-182:-91], h_end_nan])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 115,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "array([9156.089, 9156.107, 9156.129, 9156.162, 9156.21 ,      nan,\n",
-       "       9156.264, 9156.307, 9156.378, 9156.446, 9156.524, 9156.605,\n",
-       "       9156.673, 9156.726, 9156.769, 9156.839, 9156.92 , 9156.983,\n",
-       "       9157.059, 9157.14 , 9157.195, 9157.237, 9157.292, 9157.336,\n",
-       "       9157.352, 9157.378, 9157.406, 9157.424, 9157.463, 9157.493,\n",
-       "       9157.475, 9157.436, 9157.43 , 9157.463, 9157.484, 9157.472,\n",
-       "       9157.485, 9157.524, 9157.561, 9157.625, 9157.707, 9157.799,\n",
-       "       9157.91 , 9158.047, 9158.206, 9158.35 , 9158.476, 9158.619,\n",
-       "       9158.786, 9158.949, 9159.072, 9159.163, 9159.255, 9159.347,\n",
-       "       9159.431, 9159.51 , 9159.58 , 9159.62 , 9159.638, 9159.641,\n",
-       "       9159.616, 9159.595, 9159.579, 9159.537, 9159.488, 9159.45 ,\n",
-       "       9159.408, 9159.352, 9159.283, 9159.21 , 9159.156, 9159.128,\n",
-       "       9159.119, 9159.105, 9159.078, 9159.038, 9159.007, 9159.01 ,\n",
-       "       9159.012, 9158.995, 9158.979, 9158.956, 9158.933, 9158.908,\n",
-       "       9158.871, 9158.835, 9158.812, 9158.804, 9158.807, 9158.818,\n",
-       "       9158.832])"
+       "array([9157.58185583,           nan])"
       ]
      },
-     "execution_count": 48,
+     "execution_count": 115,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "h_end_nan[5] = np.nan\n",
-    "h_end_nan"
+    "np.dot(h_end_nan, one_minute_gauss_filter)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 116,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# build masked array for invalid entries\n",
+    "as_masked = np.ma.masked_invalid(h_end_nan, copy=True)\n",
+    "as_weight_sums =  np.dot(one_minute_gauss_filter, (~as_masked.mask).T)\n",
+    "as_invalid_sums = np.sum(as_masked.mask)\n",
+    "            \n",
+    "as_invalid_masked = np.ma.masked_greater(as_invalid_sums, \n",
+    "                                         np.floor(\n",
+    "                                            0.1*91))"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 49,
+   "execution_count": 117,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "nan"
+       "masked_array(data=1,\n",
+       "             mask=False,\n",
+       "       fill_value=999999)"
       ]
      },
-     "execution_count": 49,
+     "execution_count": 117,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "np.dot(h_end_nan, one_minute_gauss_filter)"
+    "as_invalid_masked"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 94,
+   "execution_count": 118,
    "metadata": {},
    "outputs": [
     {
@@ -7850,7 +1653,56 @@
        "1"
       ]
      },
-     "execution_count": 94,
+     "execution_count": 118,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "as_invalid_sums"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 119,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([9157.58185583, 9158.39741188])"
+      ]
+     },
+     "execution_count": 119,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "filtered = np.ma.dot(one_minute_gauss_filter, as_masked.T)\n",
+    "filtered = np.divide(filtered, as_weight_sums)\n",
+    "filtered.mask = as_invalid_masked.mask\n",
+    "filtered_out = np.ma.filled(filtered, np.nan)\n",
+    "filtered_out\n",
+    "#filtered"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 120,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n",
+       "       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n",
+       "       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n",
+       "       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n",
+       "       0, 0, 0])"
+      ]
+     },
+     "execution_count": 120,
      "metadata": {},
      "output_type": "execute_result"
     }
diff --git a/geomagio/algorithm/FilterAlgorithm.py b/geomagio/algorithm/FilterAlgorithm.py
index 698b061cd..37a0af2c6 100644
--- a/geomagio/algorithm/FilterAlgorithm.py
+++ b/geomagio/algorithm/FilterAlgorithm.py
@@ -17,7 +17,8 @@ class FilterAlgorithm(Algorithm):
     """Filter Algorithm"""
 
     def __init__(self, decimation=None, window=None, interval=None, 
-                 location=None, inchannels=None, outchannels=None):
+                 location=None, inchannels=None, outchannels=None, 
+                 data_type=None):
         Algorithm.__init__(self, inchannels=inchannels,
             outchannels=outchannels)
         self.numtaps=91
@@ -30,6 +31,8 @@ class FilterAlgorithm(Algorithm):
         self.sample_period = 1.0
         self.data_type = data_type
         self.location = location
+        self.inchannels = inchannels
+        self.outchannels = outchannels
 
     def create_trace(self, channel, stats, data):
         """Utility to create a new trace object.
@@ -77,18 +80,26 @@ class FilterAlgorithm(Algorithm):
 
         out = Stream()
 
+        trace_channels = []
+        
+        for trace in stream:
+            trace_channels += trace.stats.channel
+
+        trace_chan_dict = dict(zip(trace_channels, self.outchannels))
+
         for trace in stream:
             data = trace.data
-            times = trace.times()
-            half = self.numtaps//2
             step = self.decimation
-
-            filtered = self.firfilter(data, self.window, half)
+            
+            filtered = self.firfilter(data, self.window, step)
 
             stats=Stats(trace.stats)
+            stats.channel = trace_chan_dict[trace.stats.channels]
             stats.delta = trace.delta*step
-            stats.npts = len(filtered)
-            trace_out = self.create_trace('', trace.stats, filtered_out)
+            stats.pop('processing')
+            stats.npts = filtered.shape[0]
+            trace_out = self.create_trace(
+                stats.channel, stats, filtered)
 
             out += trace_out
 
@@ -128,7 +139,7 @@ class FilterAlgorithm(Algorithm):
                                writeable=False)
             
         # build masked array for invalid entries
-        as_masked = np.ma.masked_invalid(as_s[half:-half:step], copy=True)
+        as_masked = np.ma.masked_invalid(as_s[::step], copy=True)
         as_weight_sums =  np.dot(window, (~as_masked.mask).T)
         as_invalid_sums = np.sum(as_masked.mask)
             
@@ -166,7 +177,6 @@ def get_input_interval(self, start, end, observatory=None, channels=None):
         """
 
         half = self.numtaps//2
-        step = self.decimation
         start = start - half*self.interval
         end = end + half*self.interval
 
-- 
GitLab