diff --git a/docs/OTFFT.ipynb b/docs/OTFFT.ipynb
new file mode 100644
index 000000000..438aa3fd4
--- /dev/null
+++ b/docs/OTFFT.ipynb
@@ -0,0 +1,289 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "5b88fa48",
+   "metadata": {},
+   "source": [
+    "This notebook implements the 6-step / 8-step FFT (fft) algorithm as provided in [OTFFT](http://wwwa.pikara.ne.jp/okojisan/otfft-en/stockham2.html). Accordingly, the inverse FFT (ifft) algorithm will be implemented as well. When the input of FFT, `T` with length `n`, consists of real-valued elements only, we can take advantage of real FFT (rfft) as explained in [2.6.2](https://www.researchgate.net/profile/Christos-Bechlioulis/publication/341270520_FFT_algorithms_are_not_mine_However_I_am_going_to_convince_you_soon_regarding_the_visit_of_RMS_to_our_university_Believe_it_or_not_this_is_me_This_is_us_Univeristy_of_Patras_you_have_chosen_a_quite_wr/links/5fa53ce7299bf10f7328c33b/FFT-algorithms-are-not-mine-However-I-am-going-to-convince-you-soon-regarding-the-visit-of-RMS-to-our-university-Believe-it-or-not-this-is-me-This-is-us-Univeristy-of-Patras-you-have-chosen-a-quite.pdf). "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "c9a886c2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import math\n",
+    "import time\n",
+    "\n",
+    "import numba\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "import scipy\n",
+    "\n",
+    "from numba import njit, prange\n",
+    "import numpy.testing as npt\n",
+    "\n",
+    "from stumpy import core"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "80765bca",
+   "metadata": {},
+   "source": [
+    "Let's start with `rfft`. First, we write the test!"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8fc07997",
+   "metadata": {},
+   "source": [
+    "## rfft"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "7bb4242c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def test_rfft(n_powers_list):\n",
+    "    seed = 0\n",
+    "    np.random.seed(seed)\n",
+    "    for p in n_powers_list:\n",
+    "        n = 2 ** p\n",
+    "        T = np.random.rand(n)\n",
+    "        \n",
+    "        ref = scipy.fft.rfft(T)\n",
+    "        comp = rfft(T)\n",
+    "        \n",
+    "        npt.assert_almost_equal(ref, comp)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5a1c553e",
+   "metadata": {},
+   "source": [
+    "We now implement `rfft` function according to the steps provided in [2.6.2](https://www.researchgate.net/profile/Christos-Bechlioulis/publication/341270520_FFT_algorithms_are_not_mine_However_I_am_going_to_convince_you_soon_regarding_the_visit_of_RMS_to_our_university_Believe_it_or_not_this_is_me_This_is_us_Univeristy_of_Patras_you_have_chosen_a_quite_wr/links/5fa53ce7299bf10f7328c33b/FFT-algorithms-are-not-mine-However-I-am-going-to-convince-you-soon-regarding-the-visit-of-RMS-to-our-university-Believe-it-or-not-this-is-me-This-is-us-Univeristy-of-Patras-you-have-chosen-a-quite.pdf)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "d0033890",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def _rfft(T):\n",
+    "    \"\"\"\n",
+    "    For the input `T` with length `n=len(T)`, this function returns its\n",
+    "    real fast fourier transform (rfft) with length of `(n // 2) + 1`.\n",
+    "    \n",
+    "    Parameters\n",
+    "    ----------\n",
+    "    T : numpy.ndarray\n",
+    "        A time series of interest, with real-valued numbers\n",
+    "    \n",
+    "    Returns\n",
+    "    -------\n",
+    "    out : numpy.ndarray\n",
+    "        the real fast fourier transform (rfft) of input `T`\n",
+    "    \"\"\"\n",
+    "    n = len(T)\n",
+    "    half_n = int(n // 2)\n",
+    "    \n",
+    "    x = T[::2] + 1j * T[1::2]\n",
+    "    x[:] = scipy.fft.fft(x)  # we will implement our fft shortly!\n",
+    "    \n",
+    "    out = np.empty(half_n + 1, dtype=np.complex_)\n",
+    "    out[0] = x[0].real + x[0].imag\n",
+    "    out[half_n] = x[0].real - x[0].imag\n",
+    "    out[n // 4] = x[n // 4].conjugate()\n",
+    "    \n",
+    "    theta0 = 2 * math.pi / n\n",
+    "    for k in range(1, n // 4):\n",
+    "        theta = theta0 * k\n",
+    "        a =  x[half_n - k].conjugate()\n",
+    "        b = 0.5 * (x[k] - a) * (1.0 + complex(math.sin(theta), math.cos(theta)))\n",
+    "        out[k] = x[k] - b\n",
+    "        out[half_n - k] = (a + b).conjugate()\n",
+    "    \n",
+    "    return out"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "d5db0eb9",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def rfft(T):\n",
+    "    \"\"\"\n",
+    "    For the input `T` with length `n=len(T)`, this function returns its\n",
+    "    real fast fourier transform (rfft) with length of `(n // 2) + 1`.\n",
+    "    \n",
+    "    Parameters\n",
+    "    ----------\n",
+    "    T : numpy.ndarray\n",
+    "        A time series of interest, with real-valued numbers\n",
+    "    \n",
+    "    Returns\n",
+    "    -------\n",
+    "    out : numpy.ndarray\n",
+    "        the real fast fourier transform (rfft) of input `T`\n",
+    "    \"\"\"\n",
+    "    return _rfft(T)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "ded21f89",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "n_powers_list = np.arange(2, 11)\n",
+    "test_rfft(n_powers_list)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6398a98a",
+   "metadata": {},
+   "source": [
+    "We now work on implementing 6-step / 8-step FFT algorithm. We then revisit the two functions above. We will replace `scipy.fft.fft(x)` with our FFT function, and then change them accordingly."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 133,
+   "id": "09e2fb6d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "@njit(fastmath=True)\n",
+    "def _fft0(n, s, eo, x, y):\n",
+    "    \"\"\"\n",
+    "    A recurive function that is being called by six-step / eight-step FFT algorithm, \n",
+    "    and update `x` in place.\n",
+    "    \n",
+    "    Parameters\n",
+    "    ----------\n",
+    "    n : int\n",
+    "        Length of sequence\n",
+    "    \n",
+    "    s : int\n",
+    "        size of striding window\n",
+    "    \n",
+    "    eo : bool\n",
+    "        If False, `x` is output. If True, `y` is the output.\n",
+    "        \n",
+    "    x : numpy.ndarray\n",
+    "        A 1D numpy.ndarray with `np.complex_` dtype\n",
+    "        \n",
+    "    y : nummpy.ndarray\n",
+    "        A 1D numpy.ndarray with same size as `x` and `np.complex_` dtype. \n",
+    "    \n",
+    "    Returns\n",
+    "    -------\n",
+    "    \n",
+    "    Notes\n",
+    "    -----\n",
+    "    <http://wwwa.pikara.ne.jp/okojisan/otfft-en/sixstepfft.html>`__\n",
+    "\n",
+    "    See function `fft0` provided in \"List-11: Six-Step FFT\"\n",
+    "    \"\"\"\n",
+    "    if n == 2:\n",
+    "        if eo:\n",
+    "            z = y\n",
+    "        else:\n",
+    "            z = x\n",
+    "        \n",
+    "        for i in range(s):\n",
+    "            j = i + s\n",
+    "            a = x[i]\n",
+    "            b = x[j]\n",
+    "            z[i] = a + b\n",
+    "            z[j] = a - b\n",
+    "            \n",
+    "    elif n >= 4:\n",
+    "        m = n // 2\n",
+    "        sm = s * m\n",
+    "        \n",
+    "        theta = 2 * math.pi / n\n",
+    "        c = complex(math.cos(theta), -math.sin(theta))\n",
+    "        \n",
+    "        twiddle_factor = 1.0\n",
+    "        for p in range(m):\n",
+    "            sp = s * p\n",
+    "            two_sp = 2 * sp\n",
+    "            for q in range(s):\n",
+    "                i = sp + q\n",
+    "                j = i + sm\n",
+    "                \n",
+    "                k = two_sp + q\n",
+    "                y[k] = x[i] + x[j]\n",
+    "                y[k + s] = (x[i] - x[j]) * twiddle_factor\n",
+    "        \n",
+    "            twiddle_factor = twiddle_factor * c\n",
+    "        \n",
+    "        _fft0(m, 2 * s, not eo, y, x)\n",
+    "        \n",
+    "    else:\n",
+    "        pass"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9813fb90",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a57bf1ac",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "88312d26",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.12"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/docs/dev_sliding_dot_product.ipynb b/docs/dev_sliding_dot_product.ipynb
new file mode 100644
index 000000000..dfc46a976
--- /dev/null
+++ b/docs/dev_sliding_dot_product.ipynb
@@ -0,0 +1,981 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 111,
+   "id": "c53b4858",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import math\n",
+    "import time\n",
+    "\n",
+    "import numba\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "import scipy\n",
+    "\n",
+    "from numba import njit, prange\n",
+    "from stumpy import core"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ad628828",
+   "metadata": {},
+   "source": [
+    "## The [OTFFT](http://wwwa.pikara.ne.jp/okojisan/otfft-en/stockham2.html) algorithm"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "29db390b",
+   "metadata": {},
+   "source": [
+    "We will implement the `OTFFT` algorith, and we will try to enhance its performance. Our reference algorithm is `stumpy.core.sliding_dot_product`, which uses `scipy.fft.convolve`. Each new version is built on top of the previous version, i.e. all previously-implement enhancemants are included.\n",
+    "\n",
+    "We use time series `T` with length $2^{15}$, and the query of different lengths in `range(10, 1000+10, 10)`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 112,
+   "id": "f1f33ace",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def plot_performance(comp_func, ref_func=core.sliding_dot_product, test_output=False):\n",
+    "    \"\"\"\n",
+    "    Plot the performance of `ref_func` and `comp_func`. \n",
+    "    As a bonus, it tests their performance too when `test_output` is set to True.\n",
+    "    \"\"\"\n",
+    "    n_power = 15\n",
+    "    n = 2 ** n_power\n",
+    "    m_values = range(10, 1000 + 10, 10)\n",
+    "    \n",
+    "    m_values_labels = np.arange(0, 1000 + 100, 100)\n",
+    "    m_values_labels[0] = 10\n",
+    "    m_values_ticks = np.flatnonzero(np.isin(m_values, m_values_labels))\n",
+    "    \n",
+    "    seed = 0\n",
+    "    np.random.seed(seed)\n",
+    "\n",
+    "    T = np.random.rand(n)\n",
+    "\n",
+    "    running_time = np.zeros((len(m_values), 2)) \n",
+    "    for i, m in enumerate(m_values):\n",
+    "        Q = T[:m]\n",
+    "\n",
+    "        # ref\n",
+    "        t1 = time.time()\n",
+    "        ref = ref_func(Q, T)\n",
+    "        t2 = time.time()\n",
+    "        running_time[i, 0] = t2 - t1\n",
+    "\n",
+    "        # comp\n",
+    "        t1 = time.time()\n",
+    "        comp = comp_func(Q, T)\n",
+    "        t2 = time.time()\n",
+    "        running_time[i, 1] = t2 - t1\n",
+    "        \n",
+    "        if test_output:\n",
+    "            np.testing.assert_almost_equal(ref, comp)\n",
+    "\n",
+    "            \n",
+    "    plt.figure(figsize=(20, 5))\n",
+    "    plt.title(f\"The log2 of length of `T` is: {n_power}\", fontsize=13)\n",
+    "    plt.plot(running_time[:, 0], label='ref')\n",
+    "    plt.plot(running_time[:, 1], label='comp')\n",
+    "    \n",
+    "    plt.xticks(ticks=m_values_ticks, labels=m_values_labels, fontsize=13)\n",
+    "    plt.yticks(fontsize=13)\n",
+    "    \n",
+    "    plt.xlabel('The length of query, `Q`', fontsize=13)\n",
+    "    plt.ylabel('running time', fontsize=13)\n",
+    "    plt.legend()\n",
+    "    plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c2143c64",
+   "metadata": {},
+   "source": [
+    "### version 0"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 113,
+   "id": "a7816ee6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def _list7_fft_v0(n, s, eo, x, y):\n",
+    "    m = n // 2\n",
+    "    theta0 = 2 * math.pi / n\n",
+    "    if n == 1:\n",
+    "        if eo:\n",
+    "            for q in range(s):\n",
+    "                y[q] = x[q]\n",
+    "    else:\n",
+    "        for p in range(m):\n",
+    "            wp = complex(math.cos(p*theta0), -math.sin(p*theta0))\n",
+    "            for q in range(s):\n",
+    "                a = complex(x[q + s*(p + 0)])\n",
+    "                b = complex(x[q + s*(p + m)])\n",
+    "                y[q + s*(2*p + 0)] = a + b\n",
+    "                y[q + s*(2*p + 1)] = (a - b) * wp\n",
+    "        _list7_fft_v0(n//2, 2*s, not eo, y, x)\n",
+    "\n",
+    "\n",
+    "# I swapped the params of `fft` function to make its signature similar to `scipy.ftt.ftt`\n",
+    "def list7_fft_v0(x):\n",
+    "    n = len(x)\n",
+    "    y = np.empty(n, dtype=complex)\n",
+    "    _list7_fft_v0(n, 1, False, x, y)\n",
+    "    \n",
+    "    \n",
+    "\n",
+    "def list7_ifft_v0(x):\n",
+    "    \"\"\"\n",
+    "    where x is the fft result\n",
+    "    \"\"\"\n",
+    "    n = len(x) \n",
+    "    x = np.conjugate(x)\n",
+    "    y = np.empty(n, dtype=np.complex128)\n",
+    "    _list7_fft_v0(n, 1, False, x, y)\n",
+    "    \n",
+    "    return np.conjugate(x / n)\n",
+    "\n",
+    "\n",
+    "def _list7_sliding_dot_product_v0(Q, T):\n",
+    "    n = len(T)\n",
+    "    m = len(Q)\n",
+    "    \n",
+    "    x = T.astype(complex)\n",
+    "    Qr = np.zeros(n, dtype=complex)\n",
+    "    Qr[:m] = np.flipud(Q)\n",
+    "    \n",
+    "    list7_fft_v0(x)\n",
+    "    list7_fft_v0(Qr)\n",
+    "    Qr[:] = list7_ifft_v0(x * Qr)\n",
+    "    \n",
+    "    return Qr.real[m-1:]\n",
+    "\n",
+    "\n",
+    "def sliding_dot_product_v0(Q, T):\n",
+    "    return _list7_sliding_dot_product_v0(Q, T)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 115,
+   "id": "91da6f63",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1440x360 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# check performance\n",
+    "comp = sliding_dot_product_v0\n",
+    "plot_performance(\n",
+    "    comp, \n",
+    "    ref_func=core.sliding_dot_product, \n",
+    "    test_output=True\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c40564b9",
+   "metadata": {},
+   "source": [
+    "### version 1\n",
+    "**Enhancement:** created the array `y` once, and reused it."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 73,
+   "id": "d5815e97",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# let's improve the function\n",
+    "def _list7_fft_v1(n, s, eo, x, y):\n",
+    "    m = n // 2\n",
+    "    theta0 = 2 * math.pi / n\n",
+    "    if n == 1:\n",
+    "        if eo:\n",
+    "            for q in range(s):\n",
+    "                y[q] = x[q]\n",
+    "    else:\n",
+    "        for p in range(m):\n",
+    "            wp = complex(math.cos(p*theta0), -math.sin(p*theta0))\n",
+    "            for q in range(s):\n",
+    "                a = complex(x[q + s*(p + 0)])\n",
+    "                b = complex(x[q + s*(p + m)])\n",
+    "                y[q + s*(2*p + 0)] = a + b\n",
+    "                y[q + s*(2*p + 1)] = (a - b) * wp\n",
+    "        _list7_fft_v1(n//2, 2*s, not eo, y, x)\n",
+    "\n",
+    "\n",
+    "# I swapped the params of `fft` function to make its signature similar to `scipy.ftt.ftt`\n",
+    "def list7_fft_v1(x):\n",
+    "    n = len(x)\n",
+    "    y = np.empty(n, dtype=complex)\n",
+    "    _list7_fft_v1(n, 1, False, x, y)\n",
+    "    \n",
+    "\n",
+    "    \n",
+    "def _list7_ifft_v1(n, x, y):\n",
+    "    x[:] = np.conjugate(x)\n",
+    "    _list7_fft_v1(n, 1, False, x, y)\n",
+    "    x[:] = np.conjugate(x / n)\n",
+    "\n",
+    "def list7_ifft_v1(x):\n",
+    "    \"\"\"\n",
+    "    where x is the fft result\n",
+    "    \"\"\"\n",
+    "    n = len(x) \n",
+    "    _list7_ifft_v1(n, x, y)\n",
+    "\n",
+    "def _list7_sliding_dot_product_v1(Q, T):\n",
+    "    n = len(T)\n",
+    "    m = len(Q)\n",
+    "    \n",
+    "    x = T.astype(complex)\n",
+    "    y = np.empty(n, dtype=complex)\n",
+    "    Qr = np.zeros(n, dtype=complex)\n",
+    "    Qr[:m] = np.flipud(Q)\n",
+    "    \n",
+    "    _list7_fft_v1(n, 1, False, x, y)\n",
+    "    _list7_fft_v1(n, 1, False, Qr, y)\n",
+    "    \n",
+    "    Qr[:] = Qr * x\n",
+    "    _list7_ifft_v1(n, Qr, y)\n",
+    "        \n",
+    "    return Qr.real[m-1:]\n",
+    "\n",
+    "\n",
+    "def sliding_dot_product_v1(Q, T):\n",
+    "    return _list7_sliding_dot_product_v1(Q, T)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 116,
+   "id": "206479fd",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAABJ8AAAFUCAYAAACKmp2hAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAAsTAAALEwEAmpwYAABNuUlEQVR4nO3deZxkVX3//9ene1ZmhZlhd5gBRJEd22CMa1BivglqYvI1Ci4hCZrlq/40EVy+MZq4IFHzNZpENOAaJYImalxwwd2oA8picBsYlgFkGJh97enP749zq+t2TfVM9UxXV0/zej76PurWvbfuPfee6qq67zr3VGQmkiRJkiRJUjf09boAkiRJkiRJmroMnyRJkiRJktQ1hk+SJEmSJEnqGsMnSZIkSZIkdY3hkyRJkiRJkrrG8EmSJEmSJEldY/gkSZKkfRYRJ0XEy/fxsX8eEaePb4kkSdJkY/gkSZLGJCJWRcT547i+J0fE4Hitrxsi4tiI+E5EbIiIT7WZvywiMiKO7kX5auX4QES8f5zX+fSI+EVEbIyIV7RZ5BbgqRHx5/uw+huBj0XEvL2U4QkRsW4f1i9JkiYBwydJkjQsIjbVhp3VMDyt1+XrREQ8NiL+KyJ+GRHrI+K6iHjWfq72YuBOYEFm/s7+l3L/RcTXIuJ1E7CpdwHvyMx5mfmO1pmZOQQ8F/jDiDi5KtvSlufSYETsqN3/cfXYbwKXAv+0pwJk5jczc+F47ExEzI6IT0TEzyNiqN0xrALWbS37cMp4bF+SpIciwydJkjQsM+c2BuCDwEdbph0IDgGuBE4GDgb+ltK65jH7sc5jgZsyM8ehfAeaYyktlEaVmRszcyAzb67u39HyvPka8ObatJNqj708M5/fzR1oLS7wHeBC4Pt7WO6P6/uQmTdNTPEkSZp6DJ8kSdK+WBoRX6lahNwcEY+rz4yIP6mmr4+IH0bEOZ2uOCKmRcRfR8StEfFAtZ2Ta/OnR8Q7I+K+iLg3Il5VXRb2IoDM/Fxmfigz12TmUGb+B3Az8Pg9bPOYiPjPiLg/Iu6MiH+IiNnVvBuApwD/t9rfP+pwP55VtbpaFxG3RMR5tXkvqsr80oi4KyIejIj3RkR/bZmzqsdvjIhvVcdkVTXv3cATamX6aW3TMyPifdV2V0fEi/dSzidFxPequvpJY/mIOLJq7dYPXFNt54RO9n28tV6aGRFPrZ5XG6o6+3Kn68rMbZn5zsy8FtjWlQJLkqQRDJ8kSdK+uAB4KbAA+BKllRQAEXEhcBFwHqXl0WuBT0bE8R2u+6+AFwD/CzgC+CbwpYiYX81/NfCbwGOB5cDRwDGjrSwiDgdOYpTWOxExDfgv4N5qPY8Ffg34e4DMPK0qw99WLWD+dW87EBFPA/4VeDmlJdYLgXdHxBNrix0DHAYcBzwG+H3gD6rHLwA+B3y8evz/AYZDpMz8i5YyPaK23t8DPlN73Lsjou3xiYjlwBeAfwEWAS8C3hIRv5+Zd9dau51Tbedne9v3CfIhyuWAC4CjgDc1ZkTExRGxx5ZaHXpHFX7+aG8BniRJ2jPDJ0mStC/em5k/zsxdwPuB46vABEoo9cbMvKFqefQ54FqqYKUDfwhckpk/ycztwBuBXcBvVfNfALwtM2/NzK2UoGuo3YoiYg5wNfDpzPzKKNv7FeDhwCsyc3NmrgZeB1wQEdFhmVu9DPh/VV9FQ5n5feAjVdkbtgJ/nZnbM/MXwFeAgWreucAm4O8zc2dm/hC4vMNtfzUzP11t95PAOuD0UZZ9LnB9Zl6RmYOZ+d/Ae4E/7nxXe2IHJbQ7rDp+1zZmZOZbM/PU/Vz/CymXGx5GCUPfbAAlSdK+M3ySJEn74p7a+ObqtvGLZcuB91SXfa2L8itlT6G0UOnEw4BbG3eqDq1XVdOp1nN7bf5WYE3rSqL8gtrngfsYGfq02959mbm5Nm0lMAtY0mGZWy0HLmo5Bi8Cjqwtc18V3jVspnkMjwLuaOlj6nY6c0/L/fp6W4041pWVNI/1ZPVMSmB4U0T8T0S8fDxXnplfz8xNVfD3JeAdwLj9wqMkSQ8103pdAEmSNOXcDrw+Mz+xj4+/kxLeABARfcCyajrAamqX2VV9M40IiSLiEMrlZLcC52fmIKO7Ezg0Ig7KzC3VtGMp/QHdv4/7cDvwgcy8dB8fv5rSr1bUAqilLcu0be01RndSLm+sO5bmsZ6UMvMG4DlVy7THU/qkujEzv9qlTQ4B+9oKTpKkhzxbPkmSpPH2TuBvIuL0KGZHxOMj4pEdPv4DwKsi4oSImEHpM6rRLxPAh4G/iojlETELeAu1zzRVH09fB24BzttL8ATlF89+Abw9Ig6KiCMpv5B3RdXqal/8A/DyiHhCRPRHxIyIeHREDOztgZXPUlorvaLqYP00yuWIdfcCnfajNZqPAY+OiBdUHb3/CqVvqb32a9Ur1bF8YUQsroK5Bynh0N7qub6OmdVzpw+YFhGzImJ6Ne+YiHhKNa0/Ip4E/H+UX1CUJEn7wPBJkiSNq8x8H/A24ApKMHAH8H+B6R2u4lJKKHIN8Evg1ykdXm+o5r+F0sn59ymX490D3A1sr+a/GDiZ0vH2+upX2jZFxGtGKe8g8NuUjsvvqNb7PeAvOyxvu3VeA1xY7cv9VRnfCczd0+Nqj19H6ePqPMoxfA8llNteW+ydwEB1Wd+P97Gct1FaPv0FsJYS7P11Zv77vqxvAj0H+En1a3yfprS0+wZARLymg+PxU0qfW08AXl+Nv6+aN4dymd0amsf+jZn5j+O+F5IkPUTEyK4EJEmSDiwRMZcSEjwpM7/T6/J0S0S8BXh0Zp7T67JIkiSNhS2fJEnSASUiDo6Ip1eXoy0A3kXpY+kHPS7auIqIp0XEERHRFxFPoLSk+livyyVJkjRWhk+SJOlA0w/8HfAAcBvlcrlzM3NnT0s1/k4BfghsolzCeCnwwZ6WSJIkaR942Z0kSZIkSZK6xpZPkiRJkiRJ6hrDJ0mSJEmSJHXNtF4XYKItXrw4ly1b1utiSJIkSZIkTRnXXXfd/Zm5pN28h1z4tGzZMlasWNHrYkiSJEmSJE0ZEXH7aPO87E6SJEmSJEldY/gkSZIkSZKkrjF8kiRJkiRJUtcYPkmSJEmSJKlrDJ8kSZIkSZLUNYZPkiRJkiRJ6hrDJ0mSJEmSJHWN4ZMkSZIkSZK6xvDpQDW0CwZ39LoUkiRJkiRJe2T4dCDath7++dfge//c65JIkiRJkiTtkeHTgWjWAlhwNHzrnSWIkiRJkiRJmqQMnw5Uv/462PogfPc9vS6JJEmSJEnSqAyfDlRHng6PelYJnzbf3+vSSJIkSZIktWX4dCB7ymth55Zy+Z0kSZIkSdIkZPh0IFtyApz2PPj++2D96l6XRpIkSZIkaTeGTwe6J18EOQTfeFuvSyJJkiRJkrQbw6cD3cKlMHABXP9hWLuy16WRJEmSJEkawfBpKnjCK2HaTPjaW3pdEkmSJEmSpBEMn6aCeYfBWS+Bm66Ce2/udWkkSZIkSZKGGT5NFb/2Upg5H659U69LIkmSJEmSNMzwaaqYfXAJoH76ObjzB70ujSRJkiRJEmD4NLWc9RKYswS++sZel0SSJEmSJAmYwPApIvoj4tKIWBMRGyPi6ohYPMqyT4iI6yPigYhYX43/bssyGRFbImJTbVgwMXszSc2cC0/4S7jtG3Dr13pdGkmSJEmSpAlt+XQx8EzgLODoatqHR1n2p8DvAIuAhcDLgY9ExIkty52TmXNrw/pxL/WBZuAPYf7R8JU3QmavSyNJkiRJkh7iJjJ8uhC4JDNvrUKiVwFPj4hlrQtm5n2ZeXtmJhDAUFXW4yewvAemaTPhyRfD6utK/0+SJEmSJEk9NCHhU3U53FLgusa0zFwJbABO3cPj1gHbgW8C3wOuaVnkExFxf0R8r/WyvIe0054Li46Hr/4dDO3qdWkkSZIkSdJD2ES1fJpf3bZeFreuNm83mbkQmEu5BO9zwGBt9lOB5ZRL+N4BfDQint5uPRFxYUSsiIgVa9as2ZfyH1j6p8FTXgv3/Q/cfHWvSyNJkiRJkh7CJip82ljdtnYIvpDS+mlUmbk9M/8DeBLwx7XpX8nMbdVwJfAR4LxR1nFZZg5k5sCSJUv2cRcOMI96Fhx+Clz7Jti1s9elkSRJkiRJD1ETEj5l5jrgDuDMxrSIOJbS6unGDlczDXj4HuYPUfqHEkBfH/z6X8ODq+C//wl2De71IZIkSZIkSeNt2gRu6zLgooi4FlgLXAJ8MTNXtS4YEc8GfgbcUpXx+cCvA5dW808GDgJ+BCTwW9Uyf9DtnTigPPxpcMzj4Ut/Dd94Oyx/Ahz7ZDju1+GQYyHM6iRJkiZMJuRQaZU+uA0Gt8Ou7eV2cBsM7qhuq3l9/TD3UJh7GMw5tHStsK/b3bYOtjwAO7fCrh3NYXBHKcPweHWfgP7p0D8D+qaV2/7pZeibXrs/A6YfBNNnldtps8rQ14XvuAe3wwO3wf0/g7U/L+WdNR9mzoOZ1e2sBdX9atqMOb37zJtZ+l/NoT0M1XMCSv32Ta+O9/RS/700tKs8V4cGYWgnRH85rvtyPHdsgfV3wfo7YN2dsP5O2HAPHHQILFwKCx5WbhcuLXWqzuzYUo5l37RSNzPmwvTZvT3P27kN1vwEfnkz3HtzuV27EhYfD8f8GhzzODhqAGYcNPZ1b3kA7v4h3H09bLwX+mfCtBnVbTX0z6jGZ5XxGXNgwdHluTVjzvjvb93OrbD2F7Dmp3D/z8vr7ow51TC3Zbzl/pzFvf+f77KJDJ/eChwM/ACYCXwJOB8gIs4D3puZc6tlj6iWPwLYAfwUeG5mfqmavwR4N7Csmr8SuCAzPz0he3KgiIDnXQk//yKsvBZu/Rr85LNl3oKlcOyT4LinwPInw5xFPSyoJEnquqEh2PoAbLoPNv2y3G6+DzbfD/OOgENPhEMfBXPH2EXB0BA8cGt1QlAN6+5onlCT1U027w+PU50oVCcP/dOrk4fGCcWM5olE9AFRnVTVb2nej75y8j59dhmmzdo9GGnM65+xewDQGMjm9KFB2LahnERsW18N1fjW2rTtG0pL89Zwgdq690vAQYtg3uFVIFXdzjscZi0sZdhyP2xZW4bNa5vjW9ZCTvCP0EybPfK4zzgIDloMc5ZUQ328dn/GQaXs9/+sGTLd//My/uCqsR/H6CtliP7yHOnrL+N9/WVe9JegLBr32520t5mWjWBmVwlmhgbLsGuwGdaMR50Ph33Tms/tBQ+Dg4+Bg5eNHOYeNnrosG19OX4ProIHb2+Or7u9PL8b5R8abAZO5O7rib4S8M1aCLMXlttZC5rjsxeW/98Nq0sosq4Km7bc37Ke/lLerQ/C4NaR82YthIUPg4XHNIOp2Qv3EoROa/5Pb99YGza03N/Y/F89eBksOq78UNOi42H+UWMLTTPLujbcXYadLfsxoi5q4/0zqtB0frmdtaB6jo5Sd4M7Sl09sLIEG2tXVuMry3FuFf0wcy7MmFfdzq3C2Lll2+3KNLztaJaxEeIOB7zzYOaCkdMB7rsF7r0JfvnjEjTd//Pm68202XDYo2DZ40sg9bW3Alnq7agzSxB1zK/Bw87aPXTcuRXuubH8ivvd15fbB25tzp99cBXkby//b504aHH531m4tPn8WnhMmbbg6PJa1Ulwt+WB8pq05qfN16o1Py3P9+H/myjHacfmzl5/X3ELzD+ys/04QEVmmxeVKWxgYCBXrFjR62L0Rmb5h1351RJE3fZN2L4eCDjiVFj+RDjyDDjidFtGSZImt63ryg9rwMhWDzPn7711yM5tJXTZtKa6/WVzfHBbOamfd3j5EDjv8BLMzFlyYHwjufn+6iTg5vJBf+Mvy/5tXlPCpnYfgKN/5PSDFjeDqOHbR5YTpMxyElQPmu65oZyAQfngfvip5USurwqLYPcTm0ZwRDZPHnZtr403WuVsb94OBznQDLBabnOonITs3Frqshumz6lOvhsn3NX4zPnlhK0Rgg3ftgyNQKHxLf20WSO/ta9/Yz+0q3p+1of7yjf+jRCxftIVfTD7kBJSHbSofLnYGD9ocWllMn12S7hXD/1qgR+Ude/aUU7Ud+2o7jeGHSWgGNxW/qcGt5bjvnNLdVsbBrfC9k1VKLamPE93bm5/fPtnlHUP358Jix9enlOLT6iG6v702bBjUwlP6kFDIwzcvrHM27m1PMdzqGqJ1BgfKuPDrZPa/H+0PVfKEoL0NVoq9VdByLT2w2jPheGh+r8YDn52ViHWzpFh0K6d5fiuu6P8H264mxEB0bTZzVBq/lHleK+rgqatD47chdkHN0+6Zx8ysrVVa+urxv2hwTbh67paCLuuWXfTZlWtmR5Wu61aNi18WHld7esvx3fz/WWf1t9RhVVVYNUYH+25MiZRe5+YV477g6tGrnvaLDjkuJGB1MHLyvNow+pmyLTx7ub4jk3jUDbK63AjiJpZ3fb1VwFhPcyn1N0hjTIeV8pYD912bCr/bzs2Vf8Hm5rTGq8X9S8DGurP9V07mutrF0K2s+BhcNjJcPjJcNhJcNgpcMjyke+dW9fBnd+H278Nt3+nhEpDg6U+Dj8Flj6uvF6svg5++T/N/8n5R5Xz1KMeXUKrI88ox6hhaKh6r9jWfM9ovK9s31g9n26vhtpzbE+hVbsvPKIKJ+vvL43XqMUnwJJHVOOPKHUzfXY5roPbSwi1Y1N122b89PNKYH+Ai4jrMnOg7TzDp4ewXYPlQ+OtX4Nbr4W7ftB8w5i5oARSR5xWBVKnlRe5dt8GZJY3t+EX5dWwfjVsvKe8EDaaX0+fVd4Up82sfRtZ3Z97eHnBmTl39/WPxdCu5rdjC5fCkkdOiX/itrZtKGHiAyth7a1lfMemZhPOmXNbmnjOHTlv5rzqG5F51TfKho3jYtfO8oZW/2Zqw93lTXPxCaXJ8eITyn2PudSZTWtKwHHPj8rtvTeWD+SjmX7QyJOMWfPLN8eNwGl764/vVmYtKB8it9y/e4uF6Cvf0tfDqOjroOXMUPNEvfWypsb0xrT6pQELjq4NDyuvGfVLFIZ2ldf9e28slzU0AqeN9zSXmXtYCdDmHFq1lGlcvrWk3DamzZxfgoz7/qd8gz18e8vIE7P5R5UT38ZJbN/0cpJxZHUicOQZ5X13Xy8NG29DQ81L2HZuKQHJzi3V/a3l+I8IBfYQEDRaesyaX07IJ4uhoerk/8FyQto4YT0Q7NhcQoct95fbzWvKsOWB8n/WCJkWPOzA2aeJtnNbaV003KJpVbNl0/o7S+g43DKq1lJq4TElOB1vmc3gd/bB4/M5J7M8v7dv2D34HL58tBaONlqb1N8DZs5rf/llZgly1/6iNlStix68rWr9VRP95fV//pG7D/OObLmka5RQB0pZt20o70Xb1lfjG6oWluub47u2l7pqhEyNYOygQ/b/uHZqaKgKruotyTY0A9+hwfK6f9hJ+/ac2rEZ7lpRgqjbv13OR6fNLO8rw0HTmTD/iHHfNYZ2lfpvBFLr76z6Sa5/qTHU5ouOofIe2gjDFy71NarG8KnG8GkPBnfAmlvg7h/VPuDfXF33Twkqjji1vMAMfwOwulyv3VimoW9aCZT6+qvkeWt5g2xdboQoHzKOOB2OPL0EXoefOvp130ND5Y3h7h/C6uub377WPyhHf3lROOykKoU/pdzuqVlyw66d5c2u0Vx92/pyXXVrSr1zy8j0etfOqnnr3Npt482v1vR1xpxSvt0OQ7s3xrurIOPWZqCxec3I5eYdWY7ViLLsoCN905vla7xZz5hbPsQuXFq+tTjkWDh4efVNVYdNknftLC/kD9zW/EC0bX3tm4PY83hj/8tI+/uNE8IFR5cTowVHlzLu7eRnaKg6rr8ogWXjw8baX5QPTrMPLm+isw+umpEfPHLa7IWlnPU6WfuL8oGv/s3prAWlbjasbrYMgPLN+aLjat/iHg+LHl4+wMxaOHlO3jSxRoT595TnaN+0KoCoAoluBOrbNjSb8D9wWxl/4Lby+tYIUBqtBer9lzSm0XLS3tfuBL6/PK/bXQbQ+hoZfSX4uOeGMmy8u1nWg5eX94cjTi3vEX3TRrZwaPfhePuG0ppiOHRZUgUytfE5S5rHdtdgCao23lM+mLbebrin+RrcrgVDPcQgapeVtQwjpk0vZV1/VxkaX+DUHbSoPAeiv7Rq2rmlTO+bVn34r75xPvyU8n63v5fUDw2V1/B6IDVtZvNb50MfVe5L0lSza7DZUmbmgvL5bO6hhgzdtmuw+TlCByTDpxrDpzHatbNcv3rPj6pQ6oZyf/bCcqLfSPsXHF1L/48a/fKEoaESQDW+FWk01V53R/Nb7bt/VDvRiHKC3gik5h4Ov7ypaup/Q/Pb62mzyoftxjevix9Rmu42Orm792bYcFezHActKh/SDzu5vLhteWBkvwiNsGlvps0qIdL0Oc0O4/qntzR33Th+Tf/nHVFCoEOOHfkNyMHL23faN7ijFpZVt/XmuNs3wo7W6+A31U7k1pWToPo3P9NmlW/NGuU4eFnZ/vYNtW/cqrBp/V0jT576Z5RgZdRvFKi1GMhRLtOo36ec/LY2eY6+6pupo2BBI5A6stRrvUVS48QNmmHQouNLPTaakW99sHk7WrPv6QeNrI9Fx9e+nVpUyp1ZLo+4/2dV67yfN/uyWHcnuzVpnrWwfLM1+5Bye9CiavzgMt74Bn5mrc+Abnes2jjWO7a0XFaxpXlZRf1+37Sqf4/qco85i8vttBl73k6jY9zNa5vfiG+5v+ood0vz9aO1FUOjdcPg9vKcHQ5HWlqk1Idps6rjfHDLcW459gctKq9v+3OinVn2ofFhttFkf8PdJWjYsLoEG3sLjeccuvtlDAuOLq+7jctG6peQjLisZFc5bg+uqrWcXLl7Xxzzjiz/3zPn1vpDqQKkRn8pwyFT9Vo/3Ppn18hjXA+rdu1sfxlAa38fQPlC4oQqaKqGw0/pzrf1k9GuneW50Qij1t/ZHN+1vfkedvgppZm/IZAkSeoxw6caw6cDxKb7RrbAuvtHzfCof0b5wH3kGSWQGm7mv5dm8FsfLB3hNQKpX95cvsWF6uSydpI5Yqimz1ow8lcJps/pvHXKrsEq5KkFUjs2telHYJT/x7mHlRPBbv9CQzu7Bqsm3bdVLSJurZ243rb7SeOcJbt3gHnw8nI7llZTY7F9Y7nUc/1d5XnSOr5hdQkmor/qXLK6jn/x8c3xeUfsPbQZ3NG8vGHruhJwHHJsuTxgfwKfnVurllc/L8/9LQ+UToG3rK2NV63w9tbvQfQ1O4ScNb88Z+u/AjL8CyD1Dn1nlqBouFl1S4uRRnPw8erXYOb8qi+SKoyaPqvWOW7VWW5rU/fmDu7eiXCjU9vGtGlV/yWtrW7aXVIzuLUKnxvHubodrZPYgxY3Q/bdmt0fVQKrjfc0m3A/WAVNjdvWYzhtdmlKPv+oKjCtjx9ZbnNX85eB1t058peC1t25lxale9AImBYdW8LSRqg9WpjdTfXXyO0bSwC3+OG9ec2TJEnSPjF8qjF8OoA1OoNd9PC9t5zo1IjWNRqzxrXy624vIcfBx5TgY7Jp9BfQCGIOZIPbS0CybV0zFKoHRCNuq5ZtjZ/RHu58cUezE8bGz3qTJQip/2R1/ZdY6i2sph9UDbNrt7NGTps2q7TcGG651GjF1NKaafPaEgA1OsNtbSU14v6izn+FZH8MDZVWlfVQatN9zdZJG+5p9m+39YE9r2v6nOpXVY5pua1aK81auH/7k1ku/2r8klD9V5tG/KJTbfq0mWXbBjuSJEkaR4ZPNYZPktSicVma/RiM3c6tIy+f27K2tIRrhEyNyy4lSZKkKW5P4ZM92krSQ11E+87vtXfTZ1f9fB3X65JIkiRJk5bdyEuSJEmSJKlrDJ8kSZIkSZLUNYZPkiRJkiRJ6hrDJ0mSJEmSJHWN4ZMkSZIkSZK6xvBJkiRJkiRJXWP4JEmSJEmSpK4xfJIkSZIkSVLXGD5JkiRJkiSpawyfJEmSJEmS1DWGT5IkSZIkSeoawydJkiRJkiR1jeGTJEmSJEmSusbwSZIkSZIkSV1j+CRJkiRJkqSuMXySJEmSJElS10xY+BQR/RFxaUSsiYiNEXF1RCweZdknRMT1EfFARKyvxn+3ZZnjI+LLEbE5Iu6KiFdOzJ5IkiRJkiSpUxPZ8uli4JnAWcDR1bQPj7LsT4HfARYBC4GXAx+JiBOhBFnAZ4BbgCXAM4CLIuI5XSq7JEmSJEmS9sFEhk8XApdk5q2ZuR54FfD0iFjWumBm3peZt2dmAgEMVWU9vlrkicAxwKszc0tmXg+8F3jJBOyHJEmSJEmSOjQh4VNELACWAtc1pmXmSmADcOoeHrcO2A58E/gecE016zTgZ5m5qbb49dV0SZIkSZIkTRLTJmg786vb9S3T19Xm7SYzF0bETOA3gUcAg9WseWNZV0RcSGl5xdKlS8dQbEmSJEmSJO2PibrsbmN1u6Bl+kJK66dRZeb2zPwP4EnAH9fW1/G6MvOyzBzIzIElS5Z0XmpJkiRJkiTtlwkJnzJzHXAHcGZjWkQcS2mpdGOHq5kGPLwavwE4ISLm1OafUU2XJEmSJEnSJDGRHY5fRvlFuuURMR+4BPhiZq5qXTAinh0Rp0TEtIiYFRF/Avw68MVqkW8AtwNvjojZEXE68GJKp+OSJEmSJEmaJCYyfHor8BngB8BqoB84HyAizouIeufhRwCfpPTjdDdwAfDczPwSQGbuAs4FTgbWAp8DLs3Mj0/InkiSJEmSJKkjkZm9LsOEGhgYyBUrVvS6GJIkSZIkSVNGRFyXmQPt5k1kyydJkiRJkiQ9xBg+SZIkSZIkqWsMnyRJkiRJktQ1hk+SJEmSJEnqGsMnSZIkSZIkdY3hkyRJkiRJkrrG8EmSJEmSJEldY/gkSZIkSZKkrjF8kiRJkiRJUtcYPkmSJEmSJKlrDJ8kSZIkSZLUNYZPkiRJkiRJ6hrDJ0mSJEmSJHWN4ZMkSZIkSZK6xvBJkiRJkiRJXWP4JEmSJEmSpK4xfJIkSZIkSVLXGD5JkiRJkiSpawyfJEmSJEmS1DWGT5IkSZIkSeoawydJkiRJkiR1jeGTJEmSJEmSusbwSZIkSZIkSV0zYeFTRPRHxKURsSYiNkbE1RGxeJRl/1dEfDUi7o+IByPimxHxhJZlMiK2RMSm2rBgYvZGkiRJkiRJnZjIlk8XA88EzgKOrqZ9eJRlDwb+ETgeWAL8G/D5iHhYy3LnZObc2rC+C+WWJEmSJEnSPprI8OlC4JLMvLUKiV4FPD0ilrUumJkfzcxPZea6zBzMzH8GtgIDE1heSZIkSZIk7acJCZ+qy+GWAtc1pmXmSmADcGoHjz8VWATc3DLrE9Wled+LiN8dxyJLkiRJkiRpHExUy6f51W3rZXHravPaiohDgauAt2Xmz2uzngosp1zC9w7goxHx9FHWcWFErIiIFWvWrNmH4kuSJEmSJGlfdBw+RcSxEfGaiHhPdf8REXFShw/fWN22dgi+kNL6abRtHglcC1wDvLo+LzO/kpnbquFK4CPAee3Wk5mXZeZAZg4sWbKkwyJLkiRJkiRpf3UUPkXE04AbgMcCz68mLwb+vpPHZ+Y64A7gzNo6j6W0erpxlG0uA74JfD4z/yIzcy+bGQKik/JIkiRJkiRpYnTa8umtwO9n5jOAXdW066mFSR24DLgoIpZHxHzgEuCLmbmqdcGIeCTwLeBjmfmXbeafHBG/EhEzImJ6RDyLEor9+xjKI0mSJEmSpC7rNHw6LjO/UI0nQGZuBaaPYVtvBT4D/ABYDfQD5wNExHkRsam27EXAUcDLI2JTbWhcVrcEuAJ4ELgPeB1wQWZ+egzlkSRJkiRJUpfF3q9mg4i4CXhuZt4cEQ9k5iERcRpwRWaOpfVTzw0MDOSKFSt6XQxJkiRJkqQpIyKuy8yBdvM6bfn0LuCTEXE+0B8Rz6Z08P3OcSqjJEmSJEmSpqBpnSyUme+LiKBcDtcPvAH4h8z8cDcLJ0mSJEmSpANbR+ETQGZeRuk0XJIkSZIkSepIx+ETQETMA+bVp2Xm3eNaIkmSJEmSJE0ZHYVPEfFrlF+XO64+mfLLd/1dKJckSZIkSZKmgE5bPr0P+ASlk/Et3SuOJEmSJEmSppJOw6ejgNdlZnazMJIkSZIkSZpa+jpc7kvAQDcLIkmSJEmSpKmn05ZPFwKfi4gfAPfUZ2Tmm8e9VJIkSZIkSZoSOg2fLgZOp3QyXu/zKQHDJ0mSJEmSJLXVafj0YuAxmXlTNwsjSZIkSZKkqaXTPp82ALd0syCSJEmSJEmaejoNn94OvKabBZEkSZIkSdLU0+lld38OHBMRrwDuq8/IzBPGvVSSJEmSJEmaEjoNn/6uq6WQJEmSJEnSlNRR+JSZH+x2QSRJkiRJkjT1jBo+RcRZmfm9avxxoy2Xmd/pRsEkSZIkSZJ04NtTy6cvA/Oq8W+NskwC/eNaIkmSJEmSJE0Zo4ZPmTmvNt7pr+JJkiRJkiRJwzrq8ykinp+ZH24z/bzM/Oj4F0uSJEmSJGny2rlzJ3fddRfbtm3rdVEm1KxZszj66KOZPn16x4/p9Nfu3gPsFj4B/wgYPkmSJEmSpIeUu+66i3nz5rFs2TIiotfFmRCZydq1a7nrrrtYvnx5x4/r9HK63Y5iRCwDBjvekiRJkiRJ0hSxbds2Fi1a9JAJngAigkWLFo25tdceWz5FxE6qTsUjYkfL7H7gn8a0NUmSJEmSpCnioRQ8NezLPu+t5dNTgXOA7cDTasPZwCMz8/+MoXD9EXFpRKyJiI0RcXVELB5l2f8VEV+NiPsj4sGI+GZEPKFlmeMj4ssRsTki7oqIV3ZaFkmSJEmSpIeKd73rXZx44omcd955Pdn+Hls+ZebXASLiuMy8Zz+3dTHwTOAsYC1wOaUfqd9ss+zBlP6krgU2AX8CfD4iTszMOyOiH/gM8GXgGcAjgS9ExF2ZeeV+llOSJEmSJOmAkplkJn19u7cz+qd/+ic+//nPj6mfpvHUUZ9P4xA8AVwIXJKZt2bmeuBVwNOrvqNat/fRzPxUZq7LzMHM/GdgKzBQLfJE4Bjg1Zm5JTOvB94LvGQcyilJkiRJkjTprVq1ihNPPJE/+7M/48wzz+Rv//ZvecxjHsOpp57K61//egBe8pKXcOutt/KMZzyDd77znT0pZ6e/drdfImIBsBS4rjEtM1dGxAbgVGDVXh5/KrAIuLmadBrws8zcVFvseuDPx7HYkiRJkiRJe/WGz/yY/7l7w7iu81FHzuf155601+V++tOfcsUVV/CsZz2Lq666iu9///tkJs94xjP4xje+wb/8y7/whS98gWuvvZbFi9v2ftR1nf7a3f6aX92ub5m+rjavrYg4FLgKeFtm/ryaPG8s64qICyNiRUSsWLNmzRiKLUmSJEmSNHkdc8wxPPaxj+Waa67hmmuu4YwzzuDMM8/kJz/5CT//+c/3voIJMCEtn4CN1e2ClukLgVGjwYg4EvgScA3w6pb1dbyuzLwMuAxgYGAgOyyzJEmSJEnSXnXSQqlb5syZA5Q+n1796lfz4he/uGdlGU1HLZ8i4omjDGdFxOF7e3xmrgPuAM6srfNYSkulG0fZ5jLgm8DnM/MvMrMeGt0AnBARc2rTzqimS5IkSZIkPaT8xm/8BpdffjmbNpUeilavXs19993X41IVnbZ8+golqIratOEwKCK+Dpy3l47JLwMuiohrKb92dwnwxcxc1bpgRDyS8kt2H8jM17VZ1zeA24E3R8TFwCOAFwMv63B/JEmSJEmSpoxzzjmHW265hV/91V8FYO7cuXzkIx/h0EMP7XHJOu/z6QLgE8DxwPTq9krgj4BHUX6J7h/2so63Ap8BfgCsBvqB8wEi4ryIqHcefhFwFPDyiNhUG84DyMxdwLnAyZQg63PApZn58Q73R5IkSZIk6YC2bNkybr755uH7L3vZy7jpppu46aab+O53v8txxx0HlF/F61Vn4wAx8mq2URaKuA04pf7rchExD7gxM5dHxGHADZm510vwem1gYCBXrFjR62JIkiRJkqQD2C233MKJJ57Y62L0RLt9j4jrMnOg3fKdtnyaD8xsmTaTZqffa4CDxlBOSZIkSZIkPQR0Gj79F/CpiHhSRCyPiCcDVwGfreafRemDSZIkSZIkSRrWafj0Z8AvgC8CK4EvALdW0wHuAf73uJdOkiRJkiRJB7SOfu2u6uvpgoj4I2AJsCZrnUW1+8U6SZIkSZIkqaPwqaEKnO7rUlkkSZIkSZI0xXR02V1EnBARX4yItRGxoz50u4CSJEmSJEk6cHXa8ukDwF3A84HNXSuNJEmSJEmSppROOxw/GTgvMz+XmV+vD90snCRJkiRJktr70Ic+xKmnnsppp53G85//fG6//XbOPvtsTj31VM4++2zuuOMOAF70ohfxp3/6pzzlKU/h2GOP5etf/zoXXHABJ554Ii960YuG1zd37lxe+cpXcuaZZ3L22WezZs2acSlnpy2ffgIcCqwel61KkiRJkiRNFZ+/GO69aXzXefgp8JtvHXX2j3/8Y970pjfx7W9/m8WLF/PAAw/wwhe+kBe84AW88IUv5PLLL+elL30p//Ef/wHAgw8+yFe/+lU+/elPc+655/Ltb3+b97///TzmMY/hRz/6EaeffjqbN2/mzDPP5O1vfztvfOMbecMb3sC73/3u/d6VTls+XQFcHRG/GxGPqw/7XQJJkiRJkiSNyVe/+lV+7/d+j8WLFwNwyCGH8N3vfpfnPe95ADz/+c/nW9/61vDy5557LhHBKaecwmGHHcYpp5xCX18fJ510EqtWrQKgr6+P5zznOQCcf/75Ix6/Pzpt+fSe6vaqlukJ9I9LSSRJkiRJkg5Ee2ih1C2ZSUTscZn6/JkzZwIlYGqMN+4PDg7u9fH7o6OWT5nZN8pg8CRJkiRJkjTBzj77bP793/+dtWvXAvDAAw/wuMc9jo9//OMAfPSjH+Xxj3/8mNY5NDTEVVeVdkf/9m//NubHj6bTlk+SJEmSJEmaJE466SRe+9rX8qQnPYn+/n7OOOMM3vWud3HBBRdw6aWXsmTJEq644ooxrXPOnDn8+Mc/5tGPfjQLFizgyiuvHJeyRma2nxHxrsx8aTV+2WgryMwLx6UkE2RgYCBXrFjR62JIkiRJkqQD2C233MKJJ57Y62KMq7lz57Jp06a9Ltdu3yPiuswcaLf8nlo+TR9lXJIkSZIkSerIqOFTZv5pbfwPJ6Y4kiRJkiRJ6oVOWj3ti446HJckSZIkSZL2RUfhU0ScEBFfjIi1EbGjPnS7gJIkSZIkSZPRaP1oT2X7ss+d/trdB4C7gOcDm8e8FUmSJEmSpClk1qxZrF27lkWLFhERvS7OhMhM1q5dy6xZs8b0uE7Dp5OBJ2XmzjGXTJIkSZIkaYo5+uijueuuu1izZk2vizKhZs2axdFHHz2mx3QaPv0EOBRYPdZCSZIkSZIkTTXTp09n+fLlvS7GAaHT8OkK4OqIeBtwb31GZn5n3EslSZIkSZKkKaHT8Ok91e1VLdMT6B+/4kiSJEmSJGkq6ejX7jKzb5Sh4+ApIvoj4tKIWBMRGyPi6ohYPMqyR0XEf0bE7RGREXF+m2UyIrZExKbasKDT8kiSJEmSJKn7OgqfxsnFwDOBs4BGz1QfHmXZIeAa4HmUX9kbzTmZObc2rB+30kqSJEmSJGm/dXTZXUTMAV4KDADz6vMy85wOt3Uh8MbMvLVa56uAX0TEssxc1bLOe6gu9YuIXR2uX5IkSZIkSZNMp30+XQ6cAfwHsHmsG6kuh1sKXNeYlpkrI2IDcCqwaqzrrHwiIqYDK4FLMvOT+7geSZIkSZIkdUGn4dM5wAmZuWYftzO/um29LG5dbd5YPRX4djX+TOCjEfE7mfmF1gUj4kJKyyuWLl26j5uTJEmSJEnSWHXa59NaYNN+bGdjddvaIfhCYMO+rDAzv5KZ26rhSuAjwHmjLHtZZg5k5sCSJUv2ZXOSJEmSJEnaB52GT68B3hURh+zLRjJzHXAHcGZjWkQcS2n1dOO+rLONISDGaV2SJEmSJEkaB51edvdRoB+4oLUD8Myc0eE6LgMuiohrKS2pLgG+2NrZeENEzGqMAtOr+4OZORgRJwMHAT8CEvgt4PnAH3RYFkmSJEmSJE2ATsOnp47Dtt4KHAz8AJgJfAk4HyAizgPem5lza8tvrY1fXg1vAP4GWAK8G1gG7KB0OH5BZn56HMopSZIkSZKkcRKZ2esyTKiBgYFcsWJFr4shSZIkSZI0ZUTEdZk50G5eRy2fIuI1o83LzDfva8EkSZIkSZI0tXV62d3TWu4fCSwHvgUYPkmSJEmSJKmtjsKnzHxK67SI+AtK30uSJEmSJElSW3378dh/Bl4yXgWRJEmSJEnS1LM/4dNpQIxXQSRJkiRJkjT1dNrh+JeA+s/izQHOBN7ejUJJkiRJkiRpaui0w/FvtdzfBLwmM78+zuWRJEmSJEnSFLLX8CkipgG3AJ/OzG3dL5IkSZIkSZKmir32+ZSZg8C/GjxJkiRJkiRprDrtcPwHEXFqV0siSZIkSZKkKafTPp+uBT4TEZcBtwNDjRmZ+W/dKJgkSZIkSZIOfJ2GTxdQAqc/bpmegOGTJEmSJEmS2uoofMrM5d0uiCRJkiRJkqaeTvt8kiRJkiRJksbM8EmSJEmSJEldY/gkSZIkSZKkrjF8kiRJkiRJUtcYPkmSJEmSJKlrDJ8kSZIkSZLUNYZPkiRJkiRJ6hrDJ0mSJEmSJHWN4ZMkSZIkSZK6xvBJkiRJkiRJXTNh4VNE9EfEpRGxJiI2RsTVEbF4lGWPioj/jIjbIyIj4vw2yxwfEV+OiM0RcVdEvLL7eyFJkiRJkqSxmMiWTxcDzwTOAo6upn14lGWHgGuA5wF3tc6MiH7gM8AtwBLgGcBFEfGccS6zJEmSJEmS9sNEhk8XApdk5q2ZuR54FfD0iFjWumBm3pOZ78nMbwO72qzricAxwKszc0tmXg+8F3hJ94ovSZIkSZKksZqQ8CkiFgBLgesa0zJzJbABOHUfVnka8LPM3FSbdn01XZIkSZIkSZPERLV8ml/drm+Zvq42byzmjWVdEXFhRKyIiBVr1qzZh81JkiRJkiRpX0xU+LSxul3QMn0hpfXTvqyv43Vl5mWZOZCZA0uWLNmHzUmSJEmSJGlfTEj4lJnrgDuAMxvTIuJYSkulG/dhlTcAJ0TEnNq0M6rpkiRJkiRJmiQmssPxyyi/SLc8IuYDlwBfzMxV7RaOiFkRMQsIYHp1f1o1+xvA7cCbI2J2RJwOvJjS6bgkSZIkSZImiYkMn94KfAb4AbAa6AfOB4iI8yJiU8vyW6thKXB5Nf46gMzcBZwLnAysBT4HXJqZH+/+bkiSJEmSJKlTkZm9LsOEGhgYyBUrVvS6GJIkSZIkSVNGRFyXmQPt5k1kyydJkiRJkiQ9xBg+SZIkSZIkqWsMnyRJkiRJktQ1hk+SJEmSJEnqGsMnSZIkSZIkdY3hkyRJkiRJkrrG8EmSJEmSJEldY/gkSZIkSZKkrjF8kiRJkiRJUtcYPkmSJEmSJKlrDJ8kSZIkSZLUNYZPkiRJkiRJ6hrDJ0mSJEmSJHWN4ZMkSZIkSZK6xvBJkiRJkiRJXWP4JEmSJEmSpK4xfJIkSZIkSVLXGD5JkiRJkiSpawyfJEmSJEmS1DWGT5IkSZIkSeoawydJkiRJkiR1jeGTJEmSJEmSusbwSZIkSZIkSV0zYeFTRPRHxKURsSYiNkbE1RGxeA/LPz0ifhwRWyPi5og4p2V+RsSWiNhUGxZ0f08kSZIkSZLUqYls+XQx8EzgLODoatqH2y0YEccCnwTeAiyobj8VEctaFj0nM+fWhvVdKbkkSZIkSZL2yUSGTxcCl2TmrVVI9Crg6W0CJYAXAtdl5kcyc0dmfhS4vpouSZIkSZKkA8SEhE/V5XBLgesa0zJzJbABOLXNQ06rL1u5vppe94mIuD8ivhcRvzuORZYkSZIkSdI4mKiWT/Or29bL4tbV5tXN62DZpwLLKZfwvQP4aEQ8vd3GI+LCiFgRESvWrFkztpJLkiRJkiRpn01U+LSxum3tEHwhpfVTu+X3uGxmfiUzt1XDlcBHgPPabTwzL8vMgcwcWLJkyT4UX5IkSZIkSftiQsKnzFwH3AGc2ZhWdSo+H7ixzUNuqC9bOaOaPpohIParoJIkSZIkSRpXE9nh+GXARRGxPCLmA5cAX8zMVW2W/RAwEBHPjYjpEfFc4NHABwEi4uSI+JWImFHNfxbwfODfJ2RPJEmSJEmS1JFpE7ittwIHAz8AZgJfAs4HiIjzgPdm5lwonZFXHYi/HbgcuBX4nVpQtQR4N7AM2AGsBC7IzE9P1M5IkiRJkiRp7yIze12GCTUwMJArVqzodTEkSZIkSZKmjIi4LjMH2s2byMvuJEmSJEmS9BBj+CRJkiRJkqSuMXySJEmSJElS1xg+SZIkSZIkqWsMnyRJkiRJktQ1hk+SJEmSJEnqGsMnSZIkSZIkdY3hkyRJkiRJkrrG8EmSJEmSJEldY/gkSZIkSZKkrjF8kiRJkiRJUtcYPkmSJEmSJKlrDJ8kSZIkSZLUNYZPkiRJkiRJ6hrDJ0mSJEmSJHWN4ZMkSZIkSZK6xvBJkiRJkiRJXWP4JEmSJEmSpK4xfJIkSZIkSVLXGD5JkiRJkiSpawyfJEmSJEmS1DWGT5IkSZIkSeoawydJkiRJkiR1zbSJ2lBE9ANvBV4EzAKuAV6cmfePsvzTgbcDxwIrgVdk5jW1+ccD/wL8KvAg8M7MfHs390GSpE5lJkMJQ5llGCrjuzLJajxryyVJ9VfmNcaHyviuaj2Zya6h3dc7VK0HqvXVtk0yvI3+vuCRh8/nkDkzenp8JEmS9NAxYeETcDHwTOAsYC1wOfBh4DdbF4yIY4FPAhcC/w78PvCpiDgpM1dVQdZngC8DzwAeCXwhIu7KzCsnYmckTV2NMGDXUA6HAMMn/kPN8eGAoHaSX7/fDBGymtYMFZrhQo6Yno3HDTUDic7WWQ86GvtQgonGY6ivj5HrpPb4XUPNMu5qbGcoq/2mtu0cXk9mS5BSK1f9cbuGauWsjVeZyYj9LZNGlnd4v9qEOiOnlweMCHKG19P+2Nfre6hW1sY2h4Ogqqwj9p/GNkcet8nsmEUHcfrDFg4PjzpyPjOn9fe6WJIkSZqCIifo03FE3A68MTP/tbp/HPALYHlmrmpZ9g3Ar2fmE2rTvgl8OTPfEBFPAf4LODQzN1Xz/xZ4fGY+ZU/lGBgYyBUrVozjnqlbhoaSwepkcNdQs7UAAAERw6NERHXbmBbNgGCo+fihRnBQW29dVCuIEdNqZWp3oj80MlCon5BCMyDIlhNVqkBj13BZqI3X9nto7yFF0txGc1+rdTbGa8diZKjRcoJO8yS/uU97O+kfGT4097PcZ/h4tIQEjf2srX/XUO1kvx4WlMPZZhtVwNImfGns84j9qIUZIwOEer1pTyKgr/Y/V///a04P+gL6+oK+aAxlfn9fDC/b31eWJ3b/X67mNP+vI+jvq7ZRra+/Wne0rLuxnr6W8rWuf7eyNMYj6OurtllbP7XHRlXmvhH70CxjY+jvaxyP3cs/8vGNMjfX3dhuX1WePa23Uab68WiUtXEc+gK27RziptXr+dGdD/KjO9fxyw3bAZjR38eJR87njIct5LSHLeC0oxdyyJwZw3XYOA79fc36bLxm6sDVeK2H5v9IN7fVfD9pvh431DcdtXfi1vf75vjUfA5m7f0PJs++Nt+zWwJ7GPEaT8v9bpR9b+cvvT5WnWj9f4D276+9Vv88uK9a96Pd5+zJsK+aOlpfR2HyvJZOdRFxXWYOtJs3IS2fImIBsBS4rjEtM1dGxAbgVGBVy0NOqy9bub6a3pj/s0bwVJv/5+NY7Ent1L/5Itt2DtHfF0zrD6b1BdP6+5jWV06gpvf3lXnVSULjDSNHOdneLRgZnk41Xk1jZIsERtxnxH3q66ltr7nukfcHh4aGw6HWUEj7p692wti4bZ7cRtsPO43x/saJcu3Et36C3li+L3Y/Kae+TprrLSezMG1aX3XC3wwSGgHD8HoaIUTbcKJ58t34kNvX1yxP/US9lLn5eFr3mZHHpL+veXLdGK+HKP3VDjen7+Hkv/4hnPrxqn1YbwQRtW3Uy9gIKBr1FTCiLuuPG7G91tCkts+NdTdDkz3vczm+vmFPBY9/+OLh8XvWb+VHd6zjR3eu44d3ruPKH9zJB76zqqP1NF8jdp+3p/OUZphQSxVofjCsP761VVxjWruTzz19gRC0FDLajrbVdlfaTMw2Ezs9X2u+H2abae0f0/rauvvrZbsWf80vG0Yz2npH+7w+2vEZ2Vpz9O2Nl3q5x/zYlvWUaWN4koxVy5chY/kCpLGf9YC5Ueftlt2n4jWeK0P1S3r3XWvdtDveZXq50+7/fby+IIo21Vp/znR6yNqVu91TpvXLrrH+P9Q/uzQ+LzRXPPrn8RFlpeV5HfV93/11Ymgcj/e+aPd86VZeUN/HHDF9z+8xo72PNf63G+uuv7aPVjet66bd+segvqW97d/IaW3KN9r7TFXY1ud5ffut4c/wOtnz83HEvoxS/saExpfz+/Ia0W7fdtvEuLz2jfycX38Nr5/ffOkVT+TQebP2b4OT3ERddje/ul3fMn1dbV7dvFGWPWkv89uti4i4kHIJH0uXLu2guJPfHz3+WLYN7mJw1xCDQ8ngrtJKaNfQ0PD4YDU+lDniTat+Qt96Mlr/BwSGT0qj5UVh9xYJtQfUp7c8ZuR6YsS8af3Nb/D7I+jv6yutBPqiul/mt550NAKzkR9SGNH6oL8vausZOX33E51RXrCTES0j2p3o9/W1fvAfGUpEyzGtB0KNlhbN8eZ+17dZr7/69oMgho9dPWjatw/ikh4ajlgwmyNOmc1vnnIEAIO7hvjZLzdx8+r1bNo+OKK1YmmJ2WxV2WhtOZo9fZBrDVYaLUIb8xqvl+VmZGuw+rTd17v7a3hrCUd+mG2ZO7zxln1pM7Hd/u1PADBaa5/6hJEf9Hdv0Tn8JVI2d6UeWtc/+FJ7/xjZKnSU9WaOembe7vi0tnzpG/He1SxXQ7sP+fXWsyO+wGp532c/Tpb39pwZ7xPwJHd7TjeOy8gvbWI4GKhfIl2v58Zlzm1Pa0eZ1OknguEvhlq+JGq2aK2+iKFZxkYLZGDkpdW1AGtvJ8aZjPr/3njejnai2LrO3Q7FXsLd9vHAnrexx/VUB3z4i6Q9/D801lEPqNq1Th/K3P1zeLXddoFFu8/I9fK1vk6M+NzaWu6Ojk7LsWq93+Y4jQgpWv6XW1tIjpf6/0LbILFlervytL4m1etltPOm+jFs+z444n6H+5K7/z/U7+5t/0Y8tGWn68+Zdq/D9QNZf19ut/9lnzp7Po62M63vNXv/8rv5Otr6Ptdu3/bnPbydEa/Rjf/hoea2mw1EktnTp37XBxMVPm2sbhe0TF8IbBhl+T0tu7f5I2TmZcBlUC6766C8k97LnvrwXhdBkjQFTevv41FHzudRR7b9PkeSJEkas76J2EhmrgPuAM5sTKs6FZ8P3NjmITfUl62cUU1vzD8hIuaMMl+SJEmSJEmTwISET5XLgIsiYnlEzAcuAb7Y2tl45UPAQEQ8NyKmR8RzgUcDH6zmfwO4HXhzRMyOiNOBFwPv7fZOSJIkSZIkqXMTGT69FfgM8ANgNdAPnA8QEedFxHDn4Zm5Evhd4HWUS+leB/xOI6jKzF3AucDJwFrgc8ClmfnxidoZSZIkSZIk7V3s7adKp5qBgYFcsWJFr4shSZIkSZI0ZUTEdZk50G7eRLZ8kiRJkiRJ0kOM4ZMkSZIkSZK6xvBJkiRJkiRJXWP4JEmSJEmSpK4xfJIkSZIkSVLXGD5JkiRJkiSpayIze12GCRURa4Dbe12OcbIYuL/XhXgI8XhPXtbN5GS9TE7Wy+Rl3UxO1svkZd1MTtbL5GXdTE5TqV6Oycwl7WY85MKnqSQiVmTmQK/L8VDh8Z68rJvJyXqZnKyXycu6mZysl8nLupmcrJfJy7qZnB4q9eJld5IkSZIkSeoawydJkiRJkiR1jeHTge2yXhfgIcbjPXlZN5OT9TI5WS+Tl3UzOVkvk5d1MzlZL5OXdTM5PSTqxT6fJEmSJEmS1DW2fJIkSZIkSVLXGD5JkiRJkiSpawyfJrmI+IOI+GZEbIiIwTbzXxARKyNiS0R8LyIe3YtyHqj29/hGxEBEfL+avzIizp+40k9dEXFJRPy4qpe7I+J9EXFIyzLWTY9ExJsi4raqfu6LiKsiYmltvnXTQxHRFxHfiYiMiKNr062XHoiID0TEzojYVBv+rGUZ66ZHIuKpEfHfVb3cHxH/VJtnvfRA9f5f/3/ZWr2enVnNt156JCIOj4grI2JNRDwYEV+NiNNq862bHoiIRRHxwYi4NyLWR8S/RcTBtfnWywSILp9XRsShEfHJiNhY/Q9eEhEHVp6TmQ6TeAB+A3gucAEw2DLv8cBm4BxgJvAq4JfA/F6X+0AZ9uf4AguANcBF1fynAZuAX+31fh3oA/Bm4AxgOrAE+Dzwn9bN5BiARwILqvGDgHcA37FuJscAvBL4MpDA0dZLz+vjA8D79zDfuuld3TwZWAf8XnVsZwFnWi+TawDeBPzYeun9AHwS+BJwCDADeBtwJxDWTU/r5b+Aq4F5Vd18EfhsNc96mbh66Op5ZfW/98lq2WOBnwEX9Xq/x3SMel0Ahw4rqnxAan0SfxD4cO1+AHcAL+x1eQ+0YV+OL/CH1f2oLfNh4Ipe789UG4DfAtZbN5NvAOYAfw+stW56PwAnACuB0xkZPlkvvauTD7Dn8Mm66V3dfBd4q/UyeQdgGnAP8FLrpfcDcCNwYe3+I6r3msXWTc/qZA4wBJxWm/akql6OsV56UidPZpzPK4HlVZ0eV5v/R8Btvd7fsQwHVjMttToNuK5xJ8uz8IfVdO2/vR3f04Drq+kN1+Px74azKR94GqybHouI50XEesq3Mi8D/qaaZd30SNX0+nLgryitOeqsl956dkQ8EBE/i4hLI2JubZ510wMRMQf4FWBbRFxfXXL3tYgYqBaxXiaHZ1G+5f9Qdd966a1LKa9niyNiFnAh8K3MvB/rpleiNjQ0zvFPw3qZLPa3Hk6jfBG/smX+soiY37VSjzPDpwPbPGB9y7R1wAHzBJzk9nZ8Pf4TICKeDfwJJeBosG56LDP/LTMXAEdQgqebqlnWTe+8DLg3Mz/ZZp710jv/SLlUdTHwO5RvpN9Xm2/d9MbBlM/BfwK8CDgSuAb4XEQsxHqZLF4MXJmZ66r71ktvfRvop1wetAn4Xcr/EFg3PZGZm4CvAX8TEQsjYgnwmmr2fKyXyWJ/62G0+XAA1ZXh04FtI+XboLqFwIaJL8qUtLfj6/Hvsoj4fcpJ2jMy8/raLOtmksjMeyl19NkoncJbNz0QEcdT+nr6i1EWsV56JDOvy8xfZuZQZv4Y+P+A34uImdUi1k1vbKxur8jMGzNzB/AWSl+Dj8N66bmIOI7S8vlfapOtlx6pWtd+mdLPzAJKn49vAr4ZEYdh3fTS+cB24Bbg+8B/VtPvx3qZLPa3Hkab35h3QDB8OrDdAJzZuBMRQenn44ZeFWiK2dvxvYHSKXbdGXj8x0VE/CHwXuDczLy2ZbZ1M7lMo/Q5cCTWTa88ntI5/80RcT+lKTbAjVF+Wc16mTyGqtvGJRLWTQ9k5npgFaUPjd1mY71MBi8GbsjM79WmWS+9cwil35l/zMwNmbkjM99POZ98LNZNz2Tm6sx8TmYekZnLgduAbcB/Y71MFvtbDzcACyLi2Jb5q6r3swNDrzudctjzQGnaOovSM/5gNT6L5q9KbKJ8KzQD+Ev8tbsJO76UtHkNpX+VGdVy/jrE+NTLS4G1wGNGmW/d9K5u+iitaw6t7h8NfIryQWeaddOzejmoqovG8FjKCfQAMNd66Wnd/AGwsBp/OPAd4OrafOumd3XzV8BdwKOq169XUTq3XmC99LxuZgD3AS9umW699LZefkq5lHhO9T9zAbCD8stb1k3v6uURlHCwD3gM8HPg9dU862Xi6qGr55WUX7u7inKZ3fLq//HiXu/3mI5RrwvgsJcKKv0QZJthWTX/BcCtwFZKM8tH97rMB9Kwv8e3eoH/fjX/VuD8Xu/TVBiqOthZvegODy3LWDe9qZs+4HOUk4LNwGrgo4z89Q3rpvf1tIzar91ZLz2ti68BD1T/L7cB76DlSyLrpmd1E8AbgXspfWdcC5xuvfR+oIS2G4G5beZZL72rlxOBz1Iu51pP6UD5mdZNz+vlTyjB+RZK8PSylvnWy8TUw4vo4nklcCjwyeq18X7gbUBfr/d7LENUOyJJkiRJkiSNO/t8kiRJkiRJUtcYPkmSJEmSJKlrDJ8kSZIkSZLUNYZPkiRJkiRJ6hrDJ0mSJEmSJHWN4ZMkSZIkSZK6xvBJkiRJPRURvxYRL9rPdZwXEU8elwJJkqRxZfgkSZJ6KiJWRcT547i+J0fE4Hitbz/K8bWIeN04r/OFEXFXRGyKiGeP57p77IfAX0TEb+3HOlYAl0fE0eNUJkmSNE4MnyRJUtdUIUlj2FkNw9N6Xb7xMt4B2ijbmAb8E3BhZs7NzKu7ub2JlJlbgGcCb46Iw1vnR8QLIuK6iNgcEesj4gsR8diWdfwUeAnwgYjwM64kSZOIb8ySJKlrqpBkbmbOBT4IfLRlmjp3OHAQcGOvC9IQxbTxWFdmrs7M0zLz3pZtvAH4f8DbgCXAscB3gK9FxNkt67gmM5+amUPjUSZJkjQ+DJ8kSdJksDQivlK1iLo5Ih5XnxkRf1JNXx8RP4yIc8ay8j09PiL+ptr2myPivmp4Q8vjfysi/qcq32cj4p0R8bVq3meApcD7q/nX1B56cERcHREbI2JlRDxzL+V8dkTcUJXzhoj4nWr6rwI/rRb7abWdmW0ePz0i3lHtw70RcVFE/KLRn1JEvCgiftHymA9ExPtr95dGxFURcU81XBYR82rzMyJeFhErgC3AYyJiR0QcWlsmqtZgz9/T/u5NRCwDXgu8PDOvzMwtmbk2M98IfBx4z/6sX5IkTQzDJ0mSNBlcALwUWAB8idJKCoCIuBC4CDgPOJgSRnwyIo7vZMUdPv6JwB3AkcC5wGsi4teqxx8HfBL4W2Ah8E7gjxoPzMxzq8f+cdWiqx6MvRB4R7Vf7wY+GBEHjVLOXwU+ClwMLAJeA3wsIs7KzO8CJ1WLPqLazvY2q7kY+G3gccByYBlwzF4OUb0Ms4CvAv9DaWH0KOBoSsujuj8CngPMBa4H/rva14anVft8VafbHsU5QAAfazPvw8AjqvqRJEmTmOGTJEmaDN6bmT/OzF3A+4HjI2JBNe+lwBsz84bMHMrMzwHXAn/Q4bo7efzPMvNfMnMwM78H/AgYqOY9F/heZn6smv8V4D873PaVmfnt6jKwyyiBzMNHWfYPgasz8/PVdv4L+BQlmOvUC4BLMvMXmbkV+Esgx/D43wYiM/86M7dm5oPA/wXOi4j+2nJ/n5krM3NXFYJdRi2Qq8Y/UpVhfywB1mTmjjbz7q5uD20zT5IkTSKGT5IkaTK4pza+ubptXOq1HHhPRKxrDMBTgKM6XHcnj7+n5TGba9s/Cri9ZX7r/dEMrzczW/er1cOAW1umraymd+poYFXLNu8bw+OXUy6BrB+rr1ACrHpH4KtaHncVsCQiHh8Riyidh79vDNsdzRpgcUTMaDPvyOp2LPsnSZJ6YFw6iJQkSeqi24HXZ+YnevT41ZTLv+qWttwfjw6u76SEP3XHVtM7tZpyqR0AETGHkS2DNgFzWh5zJOWyQSjH6meZeRJ7NmJ/M3NbRHyQ0uLpBuCGzByPjtG/VN0+h3KZXd15lHCuNbCTJEmTjC2fJEnSZPdO4G8i4vSqI+vZVQubR07Q4z8GnBUR/zsi+iPiycCzWpa5l9Evp+vUB4BnR8RvVNv5TeB3gSvGsI4PA38VEcdFxGzKL8RFbf4PgUMj4rcjoq/q0PyJtfmfBaZHxGsiYl51vI5qdHy+F5cBvw/8KS2tnqpO3VeNYT8AyMzbgEuA/xcRv1fV3SER8Vrg+cArMnMslxVKkqQeMHySJEmTWma+jxKiXAE8SGml83+B6RP0+JWUUOUNwHpKP0ofBuodfv8dcH5EPBgRn+9kvW228x1Kp91/X5XzbcD5mfnfY1jNW4AvUjoAv42yr8OXCFb78jJKUPQA8HTg6tr8LcDZlI7Gf0LZ368Ap3dQ/p8A11FaUn28ZfZS4Gtj2I/6el8LvJLSAfv9wFpKP16/lZmf3pd1SpKkiRV+WSRJkjQ2EfExYGNmXtjrsuxNRPwC+LvM/MAEbOsDwI7W4xIRPwPOzsyxXEI42jbOoARiL8/MD+3v+iRJUvfZ55MkSdJeRMS5wLeAjcBvAc8GfqOnhZpkIuIESguxs1rnZeYJ47WdzPxhdUniORGxIDPXj9e6JUlSdxg+SZIk7d2TKJftzaJcyvaSzLy2t0WaPCLiKkoY95bMvLnb28vM7wHf6/Z2JEnS+PCyO0mSJEmSJHWNHY5LkiRJkiSpawyfJEmSJEmS1DWGT5IkSZIkSeoawydJkiRJkiR1jeGTJEmSJEmSusbwSZIkSZIkSV3z/wNnRsT6o4JwQAAAAABJRU5ErkJggg==\n",
+      "text/plain": [
+       "<Figure size 1440x360 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# check performance\n",
+    "comp = sliding_dot_product_v1\n",
+    "plot_performance(\n",
+    "    comp, \n",
+    "    ref_func=core.sliding_dot_product, \n",
+    "    test_output=True\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "10cba6f1",
+   "metadata": {},
+   "source": [
+    "### version 2\n",
+    "**Enhancement:** Converted the inner for-loop to a numpy vectorized operation"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 117,
+   "id": "5de6f6d2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# let's improve the function\n",
+    "def _list7_fft_v2(n, s, eo, x, y):\n",
+    "    m = n // 2\n",
+    "    theta0 = 2 * math.pi / n\n",
+    "    if n == 1:\n",
+    "        if eo:\n",
+    "            y[:s] = x[:s]\n",
+    "            \"\"\"for q in range(s):\n",
+    "                y[q] = x[q]\"\"\"\n",
+    "    else:\n",
+    "        sm = s * m\n",
+    "        for p in range(m):\n",
+    "            wp = complex(math.cos(p*theta0), -math.sin(p*theta0))\n",
+    "            sp = s * p\n",
+    "            a_start = sp\n",
+    "            b_start = sp + sm\n",
+    "            # a_start = s * (p + 0)\n",
+    "            # b_start = s * (p + m)\n",
+    "            \n",
+    "            idx = 2 * sp\n",
+    "            y[idx : idx + s] = x[a_start:a_start + s] + x[b_start : b_start + s]\n",
+    "            y[idx + s : idx + 2 * s] = (x[a_start:a_start + s] - x[b_start : b_start + s]) * wp\n",
+    "            \"\"\"for q in range(s):\n",
+    "                a = x[q + s * (p + 0)]\n",
+    "                b = x[q + s * (p + m)]\n",
+    "                y[q + s * (2 * p + 0)] = a + b\n",
+    "                y[q + s * (2 * p + 1)] = (a - b) * wp\"\"\"\n",
+    "\n",
+    "        _list7_fft_v2(n//2, 2*s, not eo, y, x)\n",
+    "\n",
+    "\n",
+    "# I swapped the params of `fft` function to make its signature similar to `scipy.ftt.ftt`\n",
+    "def list7_fft_v2(x):\n",
+    "    n = len(x)\n",
+    "    y = np.empty(n, dtype=complex)\n",
+    "    _list7_fft_v2(n, 1, False, x, y)\n",
+    "    \n",
+    "\n",
+    "    \n",
+    "def _list7_ifft_v2(n, x, y):\n",
+    "    x[:] = np.conjugate(x)\n",
+    "    _list7_fft_v2(n, 1, False, x, y)\n",
+    "    x[:] = np.conjugate(x / n)\n",
+    "\n",
+    "def list7_ifft_v2(x):\n",
+    "    \"\"\"\n",
+    "    where x is the fft result\n",
+    "    \"\"\"\n",
+    "    n = len(x) \n",
+    "    _list7_ifft_v2(n, x, y)\n",
+    "\n",
+    "def _list7_sliding_dot_product_v2(Q, T):\n",
+    "    n = len(T)\n",
+    "    m = len(Q)\n",
+    "    \n",
+    "    x = T.astype(complex)\n",
+    "    y = np.empty(n, dtype=complex)\n",
+    "    Qr = np.zeros(n, dtype=complex)\n",
+    "    Qr[:m] = np.flipud(Q)\n",
+    "    \n",
+    "    _list7_fft_v2(n, 1, False, x, y)\n",
+    "    _list7_fft_v2(n, 1, False, Qr, y)\n",
+    "    \n",
+    "    Qr[:] = Qr * x\n",
+    "    _list7_ifft_v2(n, Qr, y)\n",
+    "        \n",
+    "    return Qr.real[m-1:]\n",
+    "\n",
+    "\n",
+    "def sliding_dot_product_v2(Q, T):\n",
+    "    return _list7_sliding_dot_product_v2(Q, T)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 118,
+   "id": "e20c337d",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1440x360 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# check performance\n",
+    "comp = sliding_dot_product_v2\n",
+    "plot_performance(\n",
+    "    comp, \n",
+    "    ref_func=core.sliding_dot_product, \n",
+    "    test_output=True\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "fb4a0055",
+   "metadata": {},
+   "source": [
+    "### version 3\n",
+    "**Enhancement:** Added the numba `njit` decorator with `fastmath=True`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 119,
+   "id": "e9bd4017",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# let's improve the function\n",
+    "@njit(fastmath=True)\n",
+    "def _list7_fft_v3(n, s, eo, x, y):\n",
+    "    m = n // 2\n",
+    "    theta0 = 2 * math.pi / n\n",
+    "    if n == 1:\n",
+    "        if eo:\n",
+    "            y[:s] = x[:s]\n",
+    "            \"\"\"for q in range(s):\n",
+    "                y[q] = x[q]\"\"\"\n",
+    "    else:\n",
+    "        sm = s * m\n",
+    "        for p in range(m):\n",
+    "            wp = complex(math.cos(p*theta0), -math.sin(p*theta0))\n",
+    "            sp = s * p\n",
+    "            a_start = sp\n",
+    "            b_start = sp + sm\n",
+    "            # a_start = s * (p + 0)\n",
+    "            # b_start = s * (p + m)\n",
+    "            \n",
+    "            idx = 2 * sp\n",
+    "            y[idx : idx + s] = x[a_start:a_start + s] + x[b_start : b_start + s]\n",
+    "            y[idx + s : idx + 2 * s] = (x[a_start:a_start + s] - x[b_start : b_start + s]) * wp\n",
+    "            \"\"\"for q in range(s):\n",
+    "                a = x[q + s * (p + 0)]\n",
+    "                b = x[q + s * (p + m)]\n",
+    "                y[q + s * (2 * p + 0)] = a + b\n",
+    "                y[q + s * (2 * p + 1)] = (a - b) * wp\"\"\"\n",
+    "\n",
+    "        _list7_fft_v3(n//2, 2*s, not eo, y, x)\n",
+    "\n",
+    "\n",
+    "# I swapped the params of `fft` function to make its signature similar to `scipy.ftt.ftt`\n",
+    "def list7_fft_v3(x):\n",
+    "    n = len(x)\n",
+    "    y = np.empty(n, dtype=np.complex128)\n",
+    "    _list7_fft_v3(n, 1, False, x, y)\n",
+    "    \n",
+    "\n",
+    "@njit(fastmath=True)\n",
+    "def _list7_ifft_v3(n, x, y):\n",
+    "    x[:] = np.conjugate(x)\n",
+    "    _list7_fft_v3(n, 1, False, x, y)\n",
+    "    x[:] = np.conjugate(x / n)\n",
+    "\n",
+    "def list7_ifft_v3(x):\n",
+    "    \"\"\"\n",
+    "    where x is the fft result\n",
+    "    \"\"\"\n",
+    "    n = len(x) \n",
+    "    _list7_ifft_v3(n, x, y)\n",
+    "\n",
+    "@njit(fastmath=True)\n",
+    "def _list7_sliding_dot_product_v3(Q, T):\n",
+    "    n = len(T)\n",
+    "    m = len(Q)\n",
+    "    \n",
+    "    x = T.astype(np.complex128)\n",
+    "    y = np.empty(n, dtype=np.complex128)\n",
+    "    Qr = np.zeros(n, dtype=np.complex128)\n",
+    "    Qr[:m] = np.flipud(Q)\n",
+    "    \n",
+    "    _list7_fft_v3(n, 1, False, x, y)\n",
+    "    _list7_fft_v3(n, 1, False, Qr, y)\n",
+    "    \n",
+    "    Qr[:] = Qr * x\n",
+    "    _list7_ifft_v3(n, Qr, y)\n",
+    "        \n",
+    "    return Qr.real[m-1:]\n",
+    "\n",
+    "\n",
+    "def sliding_dot_product_v3(Q, T):\n",
+    "    return _list7_sliding_dot_product_v3(Q, T)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 120,
+   "id": "28dc96b4",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1440x360 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# check performance\n",
+    "comp = sliding_dot_product_v3\n",
+    "plot_performance(\n",
+    "    comp, \n",
+    "    ref_func=core.sliding_dot_product, \n",
+    "    test_output=True\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "69b2c27b",
+   "metadata": {},
+   "source": [
+    "### version 4\n",
+    "**Enhancement:** Parallelized the outer for-loop using numba `prange`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 121,
+   "id": "887644db",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# let's improve the function\n",
+    "@njit(fastmath=True, parallel=True)\n",
+    "def _list7_fft_v4(n, s, eo, x, y):\n",
+    "    m = n // 2\n",
+    "    theta0 = 2 * math.pi / n\n",
+    "    if n == 1:\n",
+    "        if eo:\n",
+    "            y[:s] = x[:s]\n",
+    "            \"\"\"for q in range(s):\n",
+    "                y[q] = x[q]\"\"\"\n",
+    "    else:\n",
+    "        sm = s * m\n",
+    "        for p in prange(m):\n",
+    "            wp = complex(math.cos(p*theta0), -math.sin(p*theta0))\n",
+    "            sp = s * p\n",
+    "            a_start = sp\n",
+    "            b_start = sp + sm\n",
+    "            # a_start = s * (p + 0)\n",
+    "            # b_start = s * (p + m)\n",
+    "            \n",
+    "            idx = 2 * sp\n",
+    "            y[idx : idx + s] = x[a_start:a_start + s] + x[b_start : b_start + s]\n",
+    "            y[idx + s : idx + 2 * s] = (x[a_start:a_start + s] - x[b_start : b_start + s]) * wp\n",
+    "            \"\"\"for q in range(s):\n",
+    "                a = x[q + s * (p + 0)]\n",
+    "                b = x[q + s * (p + m)]\n",
+    "                y[q + s * (2 * p + 0)] = a + b\n",
+    "                y[q + s * (2 * p + 1)] = (a - b) * wp\"\"\"\n",
+    "\n",
+    "        _list7_fft_v4(n//2, 2*s, not eo, y, x)\n",
+    "\n",
+    "\n",
+    "# I swapped the params of `fft` function to make its signature similar to `scipy.ftt.ftt`\n",
+    "def list7_fft_v4(x):\n",
+    "    n = len(x)\n",
+    "    y = np.empty(n, dtype=np.complex128)\n",
+    "    _list7_fft_v4(n, 1, False, x, y)\n",
+    "    \n",
+    "\n",
+    "@njit(fastmath=True)\n",
+    "def _list7_ifft_v4(n, x, y):\n",
+    "    x[:] = np.conjugate(x)\n",
+    "    _list7_fft_v4(n, 1, False, x, y)\n",
+    "    x[:] = np.conjugate(x / n)\n",
+    "\n",
+    "def list7_ifft_v4(x):\n",
+    "    \"\"\"\n",
+    "    where x is the fft result\n",
+    "    \"\"\"\n",
+    "    n = len(x) \n",
+    "    _list7_ifft_v4(n, x, y)\n",
+    "\n",
+    "@njit(fastmath=True)\n",
+    "def _list7_sliding_dot_product_v4(Q, T):\n",
+    "    n = len(T)\n",
+    "    m = len(Q)\n",
+    "    \n",
+    "    x = T.astype(np.complex128)\n",
+    "    y = np.empty(n, dtype=np.complex128)\n",
+    "    Qr = np.zeros(n, dtype=np.complex128)\n",
+    "    Qr[:m] = np.flipud(Q)\n",
+    "    \n",
+    "    _list7_fft_v4(n, 1, False, x, y)\n",
+    "    _list7_fft_v4(n, 1, False, Qr, y)\n",
+    "    \n",
+    "    Qr[:] = Qr * x\n",
+    "    _list7_ifft_v4(n, Qr, y)\n",
+    "        \n",
+    "    return Qr.real[m-1:]\n",
+    "\n",
+    "\n",
+    "def sliding_dot_product_v4(Q, T):\n",
+    "    return _list7_sliding_dot_product_v4(Q, T)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 122,
+   "id": "e661a6a4",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAABJcAAAFUCAYAAACZTd1VAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAAsTAAALEwEAmpwYAAA+v0lEQVR4nO3de5xdVXn4/88zkzMkEyCIBFvEkKDVUpRrqHir+kPRVlFb7VctIIgVvP2Eb7WCSqviFVFpvVUjCop4qaBWrQpW0OJdUEEQb2BAECTcSQjkMs/3j73PzJ4zM5mTyczZ+ySf9+u1s89Za1+evdc5ZybPrLVOZCaSJEmSJEnSTAzUHYAkSZIkSZL6l8klSZIkSZIkzZjJJUmSJEmSJM2YySVJkiRJkiTNmMklSZIkSZIkzZjJJUmSJEmSJM2YySVJkiRNKiL2jogTZrjvyyNiv9mNSJIkNZHJJUmSNCoiVkbEEbN4vCdExIbZOt5ciIg9I+J7EXFXRHxhkvqlEZERsXsd8VXiOCsizpjlYz41In4bEXdHxD9NsslVwJMi4uUzOPzlwKcjYodpYnhcRNwxg+NLkqSGMLkkSdI2IiJWV5b15TJaVnd83YiIgyPivyPijxFxZ0RcGhHP2sLDngT8HliUmX+75VFuuYj4VkSc3INTvRd4T2bukJnv6azMzBHg+cALI+LhZWxLOl5LGyJiXeX5leW+FwOnAR/cVACZeXFm7jQbFxMRCyLicxHxm4gYmewelgnUezuu4RGzcX5JkrZVJpckSdpGZOb27QX4OHBOR1k/2Bn4LPBw4H7Amyl6xxy0BcfcE/h5ZuYsxNdv9qToYTSlzLw7M5dn5hXl8+s6XjffAt5WKdu7su/HMvPIubyAznCB7wHHAj/axHb/WL2GzPx5b8KTJGnrZHJJkiR1WhIR3yx7dFwREY+uVkbEi8vyOyPipxFxaLcHjoh5EfGvEXFNRNxWnufhlfpWRJweETdHxE0R8Zpy2NbRAJn51cz8RGauysyRzPwicAXw2E2cc4+I+K+IuCUifh8R/xYRC8q6y4AnAv9SXu+LuryOZ5W9pu6IiKsi4vBK3dFlzK+MiOsj4vaI+HBEDFa2eWS5/90R8Z3ynqws694PPK4S068qp94uIj5SnveGiDhumjgfHxE/LNvql+3tI2K3srfaIHBBeZ6HdnPts61z6GREPKl8Xd1Vttn/dHuszLw3M0/PzIuAe+ckYEmSNIHJJUmS1OkY4JXAIuAbFL2cAIiIY4ETgcMpeg69Hvh8RDyky2P/M/AC4G+APwUuBr4RETuW9a8F/ho4GFgG7A7sMdXBIuJPgL2ZovdNRMwD/hu4qTzOwcBjgHcBZOa+ZQxvLnuwfHS6C4iIJwMfBU6g6El1FPD+iPirymZ7AA8AHgwcBPw98Lxy/0XAV4HPlPv//8BokigzX9ER08Mqx30O8OXKfu+PiEnvT0QsA74OfAi4P3A08PaI+PvM/EOlt9qh5Xl+Pd2198gnKIbrLQIeCLy1XRERJ0XEJntadek9ZXLzZ9Ml6CRJ0vRMLkmSpE4fzswrM3MjcAbwkDIhAkXS6ZTMvKzsOfRV4CLKxEkXXgicmpm/zMz7gFOAjcDTyvoXAO/MzGsycy1FImtksgNFxELgPOBLmfnNKc73l8CfAf+UmWsy8wbgZOCYiIguY+50PPDv5VxBI5n5I+CTZexta4F/zcz7MvO3wDeB5WXdYcBq4F2ZuT4zfwp8rMtzX5iZXyrP+3ngDmC/KbZ9PvCTzDwzMzdk5g+ADwP/2P2l1mIdRVLuAeX9u6hdkZnvyMx9tvD4R1EMB3wARbLzbSaYJEnaMiaXJElSpxsrj9eU6/Y3fi0DPlAOy7ojim/5eiJFD5NuPAi4pv2knDB6ZVlOeZxrK/VrgVWdB4niG8i+BtzM+KTOZOe7OTPXVMquBuYDi7uMudMy4MSOe3A0sFtlm5vL5FzbGsbu4QOB6zrmeLqW7tzY8bx63E7j7nXpasbudVM9kyIh+POI+EVEnDCbB8/Mb2fm6jKx9w3gPcCsfUOiJEnbonl1ByBJkvrKtcAbMvNzM9z/9xTJGQAiYgBYWpYD3EBlGFw5N9K4JFBE7Ewx3Osa4IjM3MDUfg/sGhHDmXlPWbYnxXw8t8zwGq4FzsrM02a4/w0U81pFJcG0pGObSXtrbabfUww/rNqTsXvdSJl5GfDcsmfZYynmhLo8My+co1OOADPtxSZJkrDnkiRJ2jynA2+MiP2isCAiHhsRf97l/mcBr4mIh0bEEMWcTe15kQDOBv45IpZFxHzg7VR+XynnWPo2cBVw+DSJJSi+Mey3wLsjYjgidqP4hrkzy15TM/FvwAkR8biIGIyIoYg4MCKWT7dj6SsUvY3+qZzAfF+K4YJVNwHdzmM1lU8DB0bEC8qJ1P+SYm6naeeVqkt5L4+KiF3KxNvtFMmf6dq5eoztytfOADAvIuZHRKus2yMinliWDUbE44H/S/ENhJIkaYZMLkmSpK5l5keAdwJnUvzH/zrgX4BWl4c4jSLpcQHwR+D/o5hQ+q6y/u0Uk4j/iGK43I3AH4D7yvrjgIdTTGx9Z/ktZ6sj4nVTxLsBeDrFxODXlcf9IfDqLuOd7JgXUHzV/WkUvZ9upEi6bb+p/Sr730Exx9ThFPfwAxRJt/sqm50OLC+H3V05wzh/R9Fz6RXArRSJu3/NzP+cyfF66LnAL8tvs/sSRU+5/wWIiNd1cT9+RTHn1eOAN5SPP1LWLaQYBreKsXt/Sma+b9avQpKkbUiMH+4vSZLUHBGxPUUS4PGZ+b2645krEfF24MDMPLTuWCRJkjaXPZckSVJjRMT9IuKp5XCxRRRfSX8t8OOaQ5tVEfHkiPjTiBiIiMdR9IT6dN1xSZIkzYTJJUmS1CSDwFuA24DfUQxnOywz19ca1ex7BPBTYDXFEMPTgI/XGpEkSdIMOSxOkiRJkiRJM2bPJUmSJEmSJM2YySVJkiRJkiTN2Ly6A5htu+yySy5durTuMCRJkiRJkrYal1566S2ZuXiyuq0uubR06VIuueSSusOQJEmSJEnaakTEtVPVOSxOkiRJkiRJM2ZySZIkSZIkSTPWs+RSRDwvIi6OiLsiYsNm7PfSiMiIOHku45MkSZIkSdLm6+WcS7cDHwQWACu62SEi9gBeBfx8DuOSJEmSJEkatX79eq6//nruvffeukPpufnz57P77rvTarW63qdnyaXMPB8gIp6wGbt9FHg98NI5CEmSJEmSJGmC66+/nh122IGlS5cSEXWH0zOZya233sr111/PsmXLut6vsXMuRcRxwD2Z+dm6Y5EkSZIkSduOe++9l/vf//7bVGIJICK4//3vv9k9tno5LK5rEbEEOBk4uMvtjwWOBViyZMkcRiZJkiRJkrYF21piqW0m193UnktnAG/JzBu62TgzV2Tm8sxcvnjx4jkOTZIkSZIkqRne+973stdee3H44YfXFkMjey4BTwYOjIi3ls8XAQdFxFMy83E1xiVJkiRJktRTmUlmMjAwsY/QBz/4Qb72ta9t1hxJs61nPZciYjAi5gND5fP55TJZf6sHAfsC+5XLJcAHgOf0Jtqa3fRzeNfD4OqL6o5EkiRJkiTVYOXKley111687GUv44ADDuDNb34zBx10EPvssw9veMMbAHjJS17CNddcwzOe8QxOP/302mLtZc+lI4EzK8/XlutlEfEY4MOZuT1AZl5f3TEi7gPuysw/9iTSusUgrL4J7r2z7kgkSZIkSdqmvenLV/KLP9w1q8f8i9125A2H7T3tdr/61a8488wzedaznsW5557Lj370IzKTZzzjGfzv//4vH/rQh/j617/ORRddxC677DKrMW6OnvVcysyzMjMmWVZm5jntxNIU+z4hM9/Sq1hr11pQrNffU28ckiRJkiSpNnvssQcHH3wwF1xwARdccAH7778/BxxwAL/85S/5zW9+U3d4o5o659K2bWhhsTa5JEmSJElSrbrpYTRXFi4s8gOZyWtf+1qOO+642mLZlKZ+W9y2rTVcrNeZXJIkSZIkaVv3lKc8hY997GOsXr0agBtuuIGbb7655qjG2HOpiRwWJ0mSJEmSSoceeihXXXUVj3rUowDYfvvt+eQnP8muu+5ac2QFk0tNNDAI8+abXJIkSZIkaRu1dOlSrrjiitHnxx9/PMcff/yE7VauXNnDqCbnsLimai1wWJwkSZIkSWo8k0tN1VoI69fWHYUkSZIkSdImmVxqqqFhWL+m7igkSZIkSZI2yeRSUzksTpIkSZIk9QGTS03VWuiE3pIkSZIkqfFMLjXV0LDJJUmSJEmS1Hgml5rKYXGSJEmSJKkPmFxqKofFSZIkSZKkPmByqakcFidJkiRJ0jbtE5/4BPvssw/77rsvRx55JNdeey2HHHII++yzD4cccgjXXXcdAEcffTQvfelLeeITn8iee+7Jt7/9bY455hj22msvjj766NHjbb/99rzqVa/igAMO4JBDDmHVqlWzEue8WTmKZl9rGNavrTsKSZIkSZK2bV87CW76+ewe808eAX/9jk1ucuWVV/LWt76V7373u+yyyy7cdtttHHXUUbzgBS/gqKOO4mMf+xivfOUr+eIXvwjA7bffzoUXXsiXvvQlDjvsML773e9yxhlncNBBB/Gzn/2M/fbbjzVr1nDAAQfw7ne/m1NOOYU3velNvP/979/iy7HnUlO1hmHdGsisOxJJkiRJktRjF154Ic95znPYZZddANh55535/ve/zz/8wz8AcOSRR/Kd73xndPvDDjuMiOARj3gED3jAA3jEIx7BwMAAe++9NytXrgRgYGCA5z73uQAcccQR4/bfEvZcaqrWAiBhw73lY0mSJEmS1HPT9DCaK5lJRGxym2r9dtttBxQJpPbj9vMNGzZMu/+WsOdSUw0tLNYOjZMkSZIkaZtzyCGH8J//+Z/ceuutANx22208+tGP5jOf+QwA55xzDo997GM365gjIyOce+65AHzqU5/a7P2nYs+lpmoNF+t1a2B453pjkSRJkiRJPbX33nvz+te/nsc//vEMDg6y//778973vpdjjjmG0047jcWLF3PmmWdu1jEXLlzIlVdeyYEHHsiiRYv47Gc/OyuxRm5lc/osX748L7nkkrrD2HI/PxfOexG8/Eew+GF1RyNJkiRJ0jbjqquuYq+99qo7jFm3/fbbs3r16mm3m+z6I+LSzFw+2fYOi2uq0WFx99QbhyRJkiRJ0iaYXGqq0WFxJpckSZIkSdKW66bX0kyYXGqqdnLJnkuSJEmSJKnBTC411ZDJJUmSJEmS6rK1zVHdrZlct8mlpmotKNYOi5MkSZIkqafmz5/Prbfeus0lmDKTW2+9lfnz52/WfvPmKB5tqZYTekuSJEmSVIfdd9+d66+/nlWrVtUdSs/Nnz+f3XfffbP2MbnUVA6LkyRJkiSpFq1Wi2XLltUdRt/o2bC4iHheRFwcEXdFxIZptv2biLgwIm6JiNvL/R7Xq1gbwW+LkyRJkiRJfaCXcy7dDnwQOKGLbe8HvA94CLAY+BTwtYh40JxF1zQDgzC4nT2XJEmSJElSo/VsWFxmng8QEU/oYttzOor+IyJOAZYDv5/14JpqaNjkkiRJkiRJarS++La4iNgHuD9wRd2x9FRr2GFxkiRJkiSp0RqfXIqIXYFzgXdm5m+m2ObYiLgkIi7ZqmZyb9lzSZIkSZIkNVujk0sRsRtwEXAB8NqptsvMFZm5PDOXL168uGfxzbnWApNLkiRJkiSp0RqbXIqIpcDFwNcy8xWZmTWH1HtDC2HdmrqjkCRJkiRJmlLPkksRMRgR84Gh8vn8colJtv1z4DvApzPz1b2KsXFaw7B+bd1RSJIkSZIkTamXPZeOBNYC5wOD5eO1wB4RcXhErK5seyLwQOCEiFhdWQ7vYbz1c1icJEmSJElquHm9OlFmngWcNUX1SuCcyrYvBF4450E13dBCk0uSJEmSJKnRGjvnkiiGxa0zuSRJkiRJkprL5FKTtYbtuSRJkiRJkhrN5FKTDZXJpW3wi/IkSZIkSVJ/MLnUZK1hyBHYcF/dkUiSJEmSJE3K5FKTtYaLtUPjJEmSJElSQ5lcarIhk0uSJEmSJKnZTC41Wbvnkt8YJ0mSJEmSGsrkUpM5LE6SJEmSJDWcyaUmc1icJEmSJElqOJNLTeawOEmSJEmS1HAml5rMYXGSJEmSJKnhTC41mcPiJEmSJElSw5lcarLRYXFr6o1DkiRJkiRpCiaXmmx0WNzaeuOQJEmSJEmagsmlJnPOJUmSJEmS1HAml5pscB4MDjksTpIkSZIkNZbJpaZrDTssTpIkSZIkNZbJpaZrDcN6ey5JkiRJkqRmMrnUdEP2XJIkSZIkSc1lcqnpWsOwzgm9JUmSJElSM5lcajqHxUmSJEmSpAYzudR0DouTJEmSJEkNZnKp6RwWJ0mSJEmSGszkUtM5LE6SJEmSJDWYyaWmc1icJEmSJElqMJNLTeewOEmSJEmS1GA9Sy5FxPMi4uKIuCsiNnSx/VMj4sqIWBsRV0TEob2Is3Haw+Iy645EkiRJkiRpgl72XLod+CBwwnQbRsSewOeBtwOLyvUXImLpHMbXTEPDkCOwcV3dkUiSJEmSJE3Qs+RSZp6fmZ8Gruli86OASzPzk5m5LjPPAX5Slm9bWsPFep2TekuSJEmSpOZp6pxL+wKXdpT9pCzftrSTS07qLUmSJEmSGqipyaUdgDs7yu4Adpxs44g4NiIuiYhLVq1aNdex9dbQwmK93km9JUmSJElS8zQ1uXQ3xVxLVTsBd022cWauyMzlmbl88eLFcx1bb7UWFGuHxUmSJEmSpAZqanLpMuCAjrL9y/Jti8PiJEmSJElSg/UsuRQRgxExHxgqn88vl5hk808AyyPi+RHRiojnAwcCH+9VvI0xmlyy55IkSZIkSWqeXvZcOhJYC5wPDJaP1wJ7RMThEbG6vWFmXg38HXAyxVC4k4G/zcyVPYy3GYba3xbnnEuSJEmSJKl55vXqRJl5FnDWFNUrgXM6tv868PU5DaofOCxOkiRJkiQ1WFPnXFKbw+IkSZIkSVKDmVxquiF7LkmSJEmSpOYyudR0LedckiRJkiRJzWVyqekGWzDQclicJEmSJElqJJNL/WBo2GFxkiRJkiSpkUwu9YPWQlhnzyVJkiRJktQ8Jpf6QWsBrHfOJUmSJEmS1Dwml/qBw+IkSZIkSVJDmVzqB61hh8VJkiRJkqRGmtfthhGxJ/A84IGZ+fKIeBgwLzOvnLPoVGgNw7rVdUchSZIkSZI0QVc9lyLiycBlwMHAkWXxLsC75iguVQ0tdFicJEmSJElqpG6Hxb0D+PvMfAawsSz7CXDAnESl8VoLHBYnSZIkSZIaqdvk0oMz8+vl4wTIzLVAa06i0ngtJ/SWJEmSJEnN1G1y6fcR8fBqQUTsC6yc9Yg00dBCWH9P3VFIkiRJkiRN0G1y6b3A5yPiCGAwIp4NfBI4fc4i05j2sLjMuiORJEmSJEkap6tvi8vMj0REACcCg8CbgH/LzLPnMjiVWsOQG2Hjepg3VHc0kiRJkiRJo7pKLgFk5gpgxRzGoqm0hov1+jUmlyRJkiRJUqN0nVwCiIgdgB2qZZn5h1mNSBMNlcmldffAgvvVG4skSZIkSVJFV8mliHgMcCbw4GoxxTfHDc5BXKpqLSzWfmOcJEmSJElqmG57Ln0E+BzFJN5+bVmvtRYU6/Vr6o1DkiRJkiSpQ7fJpQcCJ2f6dWW1qA6LkyRJkiRJapCBLrf7BrB8LgPRJowOizO5JEmSJEmSmqXbnkvHAl+NiB8DN1YrMvNtsx6VxhsdFmdySZIkSZIkNUu3yaWTgP0oJvGuZjgSMLk014ac0FuSJEmSJDVTt8ml44CDMvPncxmMptBqz7nkhN6SJEmSJKlZup1z6S7gqrkMRJvgsDhJkiRJktRQ3SaX3g28bktOFBGDEXFaRKyKiLsj4ryI2GUT2786Iq4ut/1NRLxsS87f14ac0FuSJEmSJDVTt8mllwMnR8QdEfHr6rIZ5zoJeCbwSGD3suzsyTaMiGcAbwIOz8wdgBcAp0XEkzfjfFuPwRYMzIN1JpckSZIkSVKzdDvn0ltm4VzHAqdk5jUAEfEa4LcRsTQzV3Zs+xDgssz8AUBmfj8iLgf2Bb4xC7H0n9ZCey5JkiRJkqTG6Sq5lJkf35KTRMQiYAlwaeWYV0fEXcA+wMqOXT4DHBMRjwG+DzwGeCjw9S2Jo68NDZtckiRJkiRJjTNlcikiHpmZPywfP3qq7TLze12cZ8dyfWdH+R2VuqqbgXOBixgbundCZl4xRazHUvSMYsmSJV2E04daCxwWJ0mSJEmSGmdTPZf+B9ihfPydKbZJYLCL89xdrhd1lO9E8U10nf4FeD6wH8W31P0F8KWIWJuZH50QROYKYAXA8uXLs4t4+o/D4iRJkiRJUgNNOaF3OZF2+/HAFEs3iSUy8w7gOuCAdllE7EnRa+nySXY5EPhCZv4iC1cCXwSe3s35tkoOi5MkSZIkSQ3U1bfFRcSRU5QfvhnnWgGcGBHLImJH4FTg/Ekm8wb4LvCsiPiz8jx7Ac8CfrIZ59u6OCxOkiRJkiQ1UFfJJeADU5S/bzPO9Q7gy8CPgRsohtMdAUWSKiJWV7Y9DfgC8I2y/HyKnkvv2IzzbV1aC2H92rqjkCRJkiRJGqerb4sDYkJBxFJgQ7cnysyNwKvLpbPuHOCcyvMNwEnlIih6Lq1fU3cUkiRJkiRJ42wyuRQR6ykn7Y6IdR3Vg8AH5yowdRgadlicJEmSJElqnOl6Lj2JotfSV4G/rpSPADdl5m/mKjB1cFicJEmSJElqoE0mlzLz2wAR8eDMvLE3IWlSDouTJEmSJEkN1NWE3iaWGmBoGEY2wIbO0YmSJEmSJEn16fbb4lS31sJivd55lyRJkiRJUnOYXOoXrQXF2uSSJEmSJElqEJNL/WKo3XPJSb0lSZIkSVJzTPdtcQBExF9NUXUfcG1m3jR7IWlSreFivc5JvSVJkiRJUnN0lVwCvknRyykqZdl+EBHfBg534u855LA4SZIkSZLUQN0OizsG+BzwEKBVrj8LvAj4C2At8G9zEJ/ahpzQW5IkSZIkNU+3PZdOAR6RmavL59dExHHA5Zm5LCKOAS6bkwhVaPdcWmdySZIkSZIkNUe3PZd2BLbrKNsOWFQ+XgUMz1ZQmkTLnkuSJEmSJKl5uk0u/TfwhYh4fEQsi4gnAOcCXynrHwlcO/vhadRQmbszuSRJkiRJkhqk2+TSy4DfAucDVwNfB64pywFuBP7PrEenMQ6LkyRJkiRJDdTVnEvlXEvHRMSLgMXAqszMSv3KuQlPo0aHxa2pNw5JkiRJkqSKbif0BqBMKN08R7FoU+YNwcA8WL+27kgkSZIkSZJGdTUsLiIeGhHnR8StEbGuusx1gKpoDTssTpIkSZIkNUq3PZfOAq4HjgQcl1WX1rATekuSJEmSpEbpNrn0cODxmbl+LoPRNFoLTC5JkiRJkqRG6fbb4n4J7DqXgagLQwsdFidJkiRJkhql255LZwLnRcQ7gZuqFZn5vVmPSpNzWJwkSZIkSWqYbpNLHyjX53aUJzA4e+FokxwWJ0mSJEmSGqar5FJmdjt8TnNpaCHcc1vdUUiSJEmSJI0yadRPHBYnSZIkSZIaZsqeSxHx3sx8Zfl4xVTbZeaxcxGYJuGwOEmSJEmS1DCbGhbXmuKx6uK3xUmSJEmSpIaZMrmUmS+tPH7hlp4oIgaBdwBHA/OBC4DjMvOWKbbfFTgNeDpFcusa4G8y8w9bGkvfsueSJEmSJElqmF7OuXQS8EzgkcDuZdnZk20YEfOBbwLrgIcBOwGHA6vnPMomay2EkfWwcX3dkUiSJEmSJAFdJpci4qERcX5E3BoR66rLZpzrWODUzLwmM+8EXgM8NSKWTrLtURQJpZdl5i2ZOZKZV2bmXZtxvq3P0HCxtveSJEmSJElqiE3NuVR1FnA9cCSwZnNPEhGLgCXApe2yzLw6Iu4C9gFWduzyROAXwIcj4pnAKmBFZr5niuMfS5G8YsmSJZsbXv9oLSjW6+6B+YvqjUWSJEmSJInuk0sPBx6fmTMdj7Vjub6zo/yOSl3VLsAhwAnASygSUF+PiD9m5jmdG2fmCmAFwPLly3OGMTZfa2GxtueSJEmSJElqiG7nXPolsOsWnOfuct3Z3WYnYLKhbncDN2Tmv2fmusy8BPgkxZxN2y6HxUmSJEmSpIbptufSmcB5EfFO4KZqRWZ+b7qdM/OOiLgOOAD4GUBE7EnRa+nySXb5GbB8skN1Ge/WqTosTpIkSZIkqQG6TS59oFyf21GewGCXx1gBnBgRFwG3AqcC52fmykm2Pavc9uXAhyiG5R0OvKLLc22dRofFbfa0V5IkSZIkSXOiq2FxmTkwxdJtYgngHcCXgR8DN1AkpY4AiIjDI2J15XzXAn8D/CPFsLlzgTdm5mc343xbn9FhcWvrjUOSJEmSJKnUbc+lLZaZG4FXl0tn3TnAOR1l3wL270lw/aJVJpccFidJkiRJkhqiq+RSRCwEXkkxD9IO1brMPHQO4tJkWk7oLUmSJEmSmqXbnksfo+hF9EXACX/q0p7Q2+SSJEmSJElqiG6TS4cCD83MVXMZjKYxVE7ovc78niRJkiRJaoauJvSm+Ha31dNupbk1OAQx6ITekiRJkiSpMbpNLr0OeG9E7DyXwWgaEcW8Sw6LkyRJkiRJDdHtsLhzgEHgmIjYWK3IzKFZj0pTGxp2WJwkSZIkSWqMbpNLT5rTKNS91rDD4iRJkiRJUmN0lVzKzG/PdSDqksPiJEmSJElSg3SVXIqI101Vl5lvm71wNC2HxUmSJEmSpAbpdljckzue7wYsA74DmFzqpdYCh8VJkiRJkqTG6HZY3BM7yyLiFcDiWY9Im9ZaCGtvrzsKSZIkSZIkAAa2YN//AF4yW4GoS0NO6C1JkiRJkppjS5JL+wIxW4GoS60FsM4JvSVJkiRJUjN0O6H3N4CsFC0EDgDePRdBaRNaC2G9E3pLkiRJkqRm6HZC7+90PF8NvC4zvz3L8Wg6DouTJEmSJEkNMm1yKSLmAVcBX8rMe+c+JG1Saxg2roONG2Cw29ygJEmSJEnS3Jh2zqXM3AB81MRSQ7SGi7VD4yRJkiRJUgN0O6H3jyNinzmNRN0ZaieXHBonSZIkSZLq1+24qouAL0fECuBaYKRdkZmfmovANIV2z6V19lySJEmSJEn16za5dAxFQukfO8oTMLnUS6PD4u6pNw5JkiRJkiS6TC5l5rK5DkRdajksTpIkSZIkNUe3cy6pKYYcFidJkiRJkprD5FK/seeSJEmSJElqEJNL/cY5lyRJkiRJUoOYXOo3DouTJEmSJEkN0rPkUkQMRsRpEbEqIu6OiPMiYpcu9ntpRGREnNyLOBvPYXGSJEmSJKlBetlz6STgmcAjgd3LsrM3tUNE7AG8Cvj53IbWR0aTS/ZckiRJkiRJ9etlculY4NTMvCYz7wReAzw1IpZuYp+PAq8HbutBfP1h3nYQA7DOOZckSZIkSVL9epJciohFwBLg0nZZZl4N3AXsM8U+xwH3ZOZnexFj34goei85LE6SJEmSJDXAvB6dZ8dyfWdH+R2VulERsQQ4GTi4m4NHxLEUPaNYsmTJjIPsG61hh8VJkiRJkqRG6NWwuLvL9aKO8p0oei91OgN4S2be0M3BM3NFZi7PzOWLFy+eeZT9YsieS5IkSZIkqRl6klzKzDuA64AD2mURsSdFr6XLJ9nlycDbIuKWiLgFeAzw2oi4uAfhNl9rGNbZc0mSJEmSJNWvV8PiAFYAJ0bERcCtwKnA+Zm5cpJtH9Tx/HPAxcC75zTCftEahvVO6C1JkiRJkurXy+TSO4D7AT8GtgO+ARwBEBGHAx/OzO0BMvP66o4RcR9wV2b+sYfxNpfD4iRJkiRJUkP0LLmUmRuBV5dLZ905wDmb2PcJcxdZH2oNw9o/1B2FJEmSJElSzyb01mxyWJwkSZIkSWoIk0v9yGFxkiRJkiSpIUwu9SO/LU6SJEmSJDWEyaV+5LA4SZIkSZLUECaX+lFrGDaug40b6o5EkiRJkiRt40wu9aOh4WJt7yVJkiRJklQzk0v9qNVOLjmptyRJkiRJqpfJpX40mlxyUm9JkiRJklQvk0v9qD0sbp3D4iRJkiRJUr1MLvWj1sJi7bA4SZIkSZJUM5NL/ai1oFg7LE6SJEmSJNXM5FI/clicJEmSJElqCJNL/Wh0Qm+TS5IkSZIkqV4ml/qRySVJkiRJktQQJpf60VA5obfD4iRJkiRJUs1MLvWj0Qm9TS5JkiRJkqR6mVzqR/PmA2FySZIkSZIk1c7kUj+KKIbGrV9bdySSJEmSJGkbZ3KpX7UWwLo1dUchSZIkSZK2cSaX+lVr2GFxkiRJkiSpdiaX+tXQQpNLkiRJkiSpdiaX+lVrAawzuSRJkiRJkuplcqlfOSxOkiRJkiQ1gMmlfmVySZIkSZIkNYDJpX41NOywOEmSJEmSVDuTS/2qtRDWr607CkmSJEmStI3rWXIpIgYj4rSIWBURd0fEeRGxyxTb/k1EXBgRt0TE7RFxcUQ8rlex9oXWAli/pu4oJEmSJEnSNq6XPZdOAp4JPBLYvSw7e4pt7we8D3gIsBj4FPC1iHjQXAfZNxwWJ0mSJEmSGqCXyaVjgVMz85rMvBN4DfDUiFjauWFmnpOZX8jMOzJzQ2b+B7AWWN7DeJuttRA23gcjG+uORJIkSZIkbcN6klyKiEXAEuDSdllmXg3cBezTxf77APcHrpirGPtOa0Gx9hvjJEmSJElSjXrVc2nHcn1nR/kdlbpJRcSuwLnAOzPzN1Nsc2xEXBIRl6xatWpLY+0PQ8PF2qFxkiRJkiSpRr1KLt1drhd1lO9E0XtpUhGxG3ARcAHw2qm2y8wVmbk8M5cvXrx4C0PtE60yuWTPJUmSJEmSVKOeJJcy8w7gOuCAdllE7EnRa+nyyfYp52K6GPhaZr4iM3PuI+0jJpckSZIkSVID9HJC7xXAiRGxLCJ2BE4Fzs/MlZ0bRsSfA98BPp2Zr+5hjP1jaGGxdlicJEmSJEmqUS+TS+8Avgz8GLgBGASOAIiIwyNidWXbE4EHAidExOrKcngP4202J/SWJEmSJEkNMK9XJ8rMjcCry6Wz7hzgnMrzFwIv7FVsfclhcZIkSZIkqQF62XNJs6k9LM7kkiRJkiRJqpHJpX7VHhbnnEuSJEmSJKlGJpf6VcueS5IkSZIkqX4ml/qVE3pLkiRJkqQGMLnUr1oLgHBYnCRJkiRJqpXJpX4VUXxjnD2XJEmSJElSjUwu9bPWApNLkiRJkiSpViaX+tnQsMPiJEmSJElSrUwu9bPWQli/pu4oJEmSJEnSNszkUj9rLYD1a+uOQpIkSZIkbcNMLvWzoYUOi5MkSZIkSbUyudTP/LY4SZIkSZJUM5NL/cxvi5MkSZIkSTUzudTPHBYnSZIkSZJqZnKpn9lzSZIkSZIk1czkUj9zziVJkiRJklQzk0v9bGghbLgXRjbWHYkkSZIkSdpGmVzqZ60FxXr92nrjkCRJkiRJ2yyTS/2sNVysHRonSZIkSZJqYnKpnw0tLNbr1tQbhyRJkiRJ2maZXOpnDouTJEmSJEk1M7nUz1plzyWHxUmSJEmSpJqYXOpnoz2XTC5JkiRJkqR6mFzqZ0PlhN7rTC5JkiRJkqR6mFzqZ6PD4pzQW5IkSZIk1cPkUj9zQm9JkiRJklSzniWXImIwIk6LiFURcXdEnBcRu2xi+6dGxJURsTYiroiIQ3sVa98YKnsuOSxOkiRJkiTVpJc9l04Cngk8Eti9LDt7sg0jYk/g88DbgUXl+gsRsXTuw+wjrXLOJYfFSZIkSZKkmszr4bmOBU7JzGsAIuI1wG8jYmlmruzY9ijg0sz8ZPn8nIh4SVn+pl4F3Hjz5hfrO6+HVb8qC6NcxRTPgcz2g2meV01WVtXFeSecv5vjdhy/M6bM8evR4+f481Tjiqis6XjchW7vT+d93WRZTvO4ctwo/kmiLA4ygkzI9rWV15REsXN5fZkxoY1ydJ3FsSqnHB9tEplkVuMr12Ws2d5y3OVl5RiV3apHzynuTfvw7djasZbXmZllWeW6MstDje0FkCPtONoxjozbFsrHlWvM0XtXuacdz0fbItv3vHpWynZq3+P2fWzfl+JcUb5eM0eKe9xx39vtUj1O5vg7NXYdY9cz/mU2/n0x/nkZdbV9Ixihcq3t11lZlxnjjjPaTqOBjYwdaxKTVU18jVRj79x28tdt510Ye51MuCWV+zj2Wq62XMcLeZJYi61z3P2g495NvJ6xuCtGkmRk3HkyE3LifSziHnv/jox7fcHgQDA81GL7+fNYuN08Fm43yPZDrWK93TyGt5vHYPv9Mtln37iyTWy3SZP8TOj8+TDuiqpPJ/kZMeGzsayb0EbVnwsjk5SV5dX6ceuRSn1CDMDAYLGOAYjB4jo6y3MERjaW+2+EkZGxx9W6iOIYA4PlsQZgYKDyuFI+eis3oz0mlMckdZO0RcT4bbu+71O/RyY8j45zbfLnckfsE66tm9djjt37kQ0dj8v1SKWNqset3o9xscVY+094bXQuXcQ44Z5O8vO129+/xhVtIvbquivTnb+6afX9VX3Pdb7/GLuPo/e0+nxg7Hn7PTn6/up4r7WfQ+W+dxyj+nxzf+eb7h5GTNJ2OXE98cAd55iqrAvdfj5WP+PGfQ62l+ne29XriOL13/7MGphXLp1lg5v4jO34DN6c19q4NmWS9p7qNT7ZLx/TfZ5Ncm8nbDPFcaYz3c+rznZsm+6zvvM+dL7+J7s/m/UZ28Xn0rQ/Z6Y53ibv9zSv99G6Kdpq3Gun47N9ss+Iqf7vOt1neDWOwRbcb+nE69zK9CS5FBGLgCXApe2yzLw6Iu4C9gFWduyyb3Xb0k/K8q3eL2+6ixd/4hIGIghgIKL4DC+fR/kY4D9jB3b88Rnw4zNqjVm9tzm/GkqSJEmSeu/GebvzpydfWXcYc65XPZd2LNd3dpTfUamr2mGKbfee7OARcSxFzyiWLFky0xgbY+HQPJbvsTOZyUgWOdCRsjfASI71EBhJ+Lfhd/KA9TcASZmDAqj2aSnXAaO9MIqSsdVYmiJHsxWTpS0m/+tYZOe5xmeHY9x5Jzvs+NGZE7esXsP4Y+boHjH6PMqeItF+HpV9oIy3eDwQxX1t71kNIJgY9mgMk1xPTnp/yn1iLPoY99fasfqxCCoZ846/nrZjjyiuo93mxeN2H5ny2ib8FWBcX6dKWTu2yhVE+z5FGUo7urLnzrjXUfv+l0eb5J5N/ANLeS0TNm4/b78myjsSWbn2HIut7KEzGn+MXcnYvRw7Tvv449ug3DbGriNo/0WjOFf7PO3n7b9QjJaXbVGcvIgRINqvrSget2McfUWXPaGCICt/Lcnq66UdffUc5Fg5nQ/a1ziuoigbGHtvjLv+0V5u7bja18fYNbdfEzkydt+r7TV6i8f+IhZRPddEm/yU6Xgw9j4u7kXlho+7V+M+L8q4R48U488Z7fffuGvpeH1X3ovtMwWT3B8o71sZw7j2muy62iqv1vIvaRFj70oGxu4l7Vg7Psui8pfzADaOjLB2/UbuXbeRtevLx+s3FI/XbSyfb+S+9RtGO5pF+7Yy1gOxfV2ba1zvr/a64+dE552Z+DqJCTctK2VZLascuf3OGKH6aVddgBgoHw8wUt7rEQaKHmjlz6MsP4MGIxmM4tkgGxmIZF7AABsZIIslkpEszrmRAUYYYCSLxxvLY2/MYGO2fzqNMJAjRZQjI+UWI0S21xs7rqptfB/IsTszVj++euJfWsc+y6j87GZc2eg9LdtkpLMNKkerbjd5u4wZbYGcLIbKX3xHn0fHvpVrmfTH7cTCoo0HizscA4wwyEgMsDEGi7qyvmjhia/R9quhGmfxmoDB2Dj2mGSQEQbK18sgI2T5O9sIkCPt3+eSkREYIStlY/e0+snefr23yyb0dqzcv/HX3P75X/nsrjyvnmHyT+HO43W3XdtItOONsdhHX0sDVFu3/U4t4mq/0kZGf+4GI2Ubjr7bRh+PX4/+xCey+u4fO375auj2ssc+X6uvixy7qnG/A7RLo9KWo5/ZY/ehelc7H497r+fkr/HJYsyI8hCdvaSr0RdXX/Q+bn/+FZ937c/CjPbvBwNERPEH7YFgIMo/bo8ri+I1NrKRHNlQ9gjcCDn2OHIDUfbiLO5H5VzEJLFU7lGMtefotVYetO8qWXz+jrVv56d9jvbyrd7t0Xsy7u1T3rspeu9U7+m47UdjrtZXPkenk+17Q+X3jGpbjt2bidFMfJmM/SQc//tr+70xGvFob83qfpMfs/gUm+zzdbLP+Yk/UyZuPfFNONXnTOfe48/Z8RMxYsJ2Mcm+1dfHuN/ncuwzaPIYJ39tjNZHZ9tVYwy2234Rz52w19anV8mlu8v1oo7ynYC7pti+223JzBXACoDly5fP7LfhBnnQzsOc/tz9utx6+VyGIknqM/Mo/kKzQ92BSJIkaZvRkwm9M/MO4DrggHZZOWn3jsDlk+xyWXXb0v5luSRJkiRJkhqil98WtwI4MSKWRcSOwKnA+ZNM5g3wCWB5RDw/IloR8XzgQODjvQtXkiRJkiRJ0+llcukdwJeBHwM3AIPAEQARcXhErG5vmJlXA38HnEwxFO5k4G+nSERJkiRJkiSpJrGpr4ruR8uXL89LLrmk7jAkSZIkSZK2GhFxaWZOOvFzL3suSZIkSZIkaStjckmSJEmSJEkzZnJJkiRJkiRJM2ZySZIkSZIkSTNmckmSJEmSJEkzZnJJkiRJkiRJMxaZWXcMsyoiVgHX1h3HLNkFuKXuILYh3u9msl2ay7ZpJtuluWybZrJdmsu2aSbbpblsm2bamtplj8xcPFnFVpdc2ppExCWZubzuOLYV3u9msl2ay7ZpJtuluWybZrJdmsu2aSbbpblsm2baVtrFYXGSJEmSJEmaMZNLkiRJkiRJmjGTS822ou4AtjHe72ayXZrLtmkm26W5bJtmsl2ay7ZpJtuluWybZtom2sU5lyRJkiRJkjRj9lySJEmSJEnSjJlckiRJkiRJ0oyZXKpZRDwvIi6OiLsiYsMk9S+IiKsj4p6I+GFEHFhHnP1qS+9vRCyPiB+V9VdHxBG9i37rFRGnRsSVZbv8ISI+EhE7d2xj29QgIt4aEb8r2+bmiDg3IpZU6m2XGkXEQER8LyIyInavlNsuNYiIsyJifUSsriwv69jGtqlRRDwpIn5Qts0tEfHBSp1t02Plz/7q+2Vt+Xl2QFlvm9QoIv4kIj4bEasi4vaIuDAi9q3U2z41iIj7R8THI+KmiLgzIj4VEfer1NsuPRBz/P/KiNg1Ij4fEXeX78FTI6K/8jWZ6VLjAjwFeD5wDLCho+6xwBrgUGA74DXAH4Ed6467X5Ytub/AImAVcGJZ/2RgNfCouq+r3xfgbcD+QAtYDHwN+C/bpv4F+HNgUfl4GHgP8D3bpRkL8Crgf4AEdrddam+Ps4AzNlFv29TbPk8A7gCeU97f+cABtk1zFuCtwJW2STMW4PPAN4CdgSHgncDvgbB9am2X/wbOA3Yo2+Z84Ctlne3Su3aY0/9Xlu+9z5fb7gn8Gjix7uverHtUdwAuZUMUvwB1vkg/DpxdeR7AdcBRdcfbb8tM7i/wwvJ5VLY5Gziz7uvZ2hbgacCdtk2zFmAh8C7gVtul/gV4KHA1sB/jk0u2S31tchabTi7ZNvW2z/eBd9g2zVyAecCNwCttk2YswOXAsZXnDyt/3uxi+9TWJguBEWDfStnjy3bZw3appU2ewCz/vxJYVrbpgyv1LwJ+V/f1bs7SX92stj37Ape2n2TxKvtpWa4tN9393Rf4SVne9hO8/3PhEIpfaNpsmxpFxD9ExJ0Uf1E5HnhjWWW71KTsFv0x4J8pemJU2S71enZE3BYRv46I0yJi+0qdbVOTiFgI/CVwb0T8pBwS962IWF5uYtvU71kUf6H/RPncNqnfaRSfabtExHzgWOA7mXkLtk9dorK0tf8Pvy+2S1NsaTvsS/GH9qs76pdGxI5zFvUsM7nUbDsAd3aU3QH0zQus4aa7v97/HoiIZwMvpkhitNk2NcrMT2XmIuBPKRJLPy+rbJf6HA/clJmfn6TOdqnP+yiGku4C/C3FX5M/Uqm3bepzP4rfc18MHA3sBlwAfDUidsK2aYLjgM9m5h3lc9ukft8FBimG76wG/o7iPQS2Ty0yczXwLeCNEbFTRCwGXldW74jt0hRb2g5T1UMftZXJpWa7m+IvOlU7AXf1PpSt0nT31/s/xyLi7yn+I/aMzPxJpcq2aYDMvImifb4SxYTrtksNIuIhFHMtvWKKTWyXmmTmpZn5x8wcycwrgf8LPCcitis3sW3qc3e5PjMzL8/MdcDbKeb6ezS2Ta0i4sEUvZY/VCm2TWpU9pD9H4p5XhZRzLv4VuDiiHgAtk+djgDuA64CfgT8V1l+C7ZLU2xpO0xV367rCyaXmu0y4ID2k4gIirk2LqsroK3MdPf3MopJp6v2x/s/KyLihcCHgcMy86KOatumOeZRjPffDdulLo+lmPj+ioi4haKbNMDlUXwzme3SHCPluj18wbapSWbeCaykmMNiQjW2Td2OAy7LzB9WymyTeu1MMe/L+zLzrsxcl5lnUPx/8WBsn9pk5g2Z+dzM/NPMXAb8DrgX+AG2S1NsaTtcBiyKiD076leWP8/6Q92TPm3rC0XX0/kUM8tvKB/PZ+xbGVZT/GVnCHg1fltcz+4vRbZ4FcUcJ0Pldn67wuy0yyuBW4GDpqi3bepplwGK3jG7ls93B75A8UvMPNultnYZLtuivRxM8Z/j5cD2tkutbfM8YKfy8Z8B3wPOq9TbNvW2zz8D1wN/UX6GvYZiAulFtk2t7TIE3Awc11Fum9TfNr+iGO67sHzPHAOso/jmKtunvnZ5GEXybwA4CPgN8IayznbpXTvM6f8rKb4t7lyKYXDLyvfjSXVf92bdo7oD2NYXinkAcpJlaVn/AuAaYC1FN8gD6465n5Ytvb/lB/iPyvprgCPqvqatYSnbYH35oTq6dGxj2/S+XQaAr1L80r8GuAE4h/HfXGG71N9OS6l8W5ztUmtbfAu4rXy//A54Dx1/ALJtam2fAE4BbqKYu+IiYD/bpvZ2eR7FMI/tJ6mzTeptm72Ar1AMt7qTYoLiZ9o+tbfLiykS4/dQJJaO76i3XXrTDkczh/+vBHYFPl9+Pt4CvBMYqPu6N2eJ8kIkSZIkSZKkzeacS5IkSZIkSZoxk0uSJEmSJEmaMZNLkiRJkiRJmjGTS5IkSZIkSZoxk0uSJEmSJEmaMZNLkiRJkiRJmjGTS5IkSZpTEfGYiDh6C49xeEQ8YVYCkiRJs8rkkiRJmlMRsTIijpjF4z0hIjbM1vG2II5vRcTJs3zMoyLi+ohYHRHPns1j1+ynwCsi4mlbcIxLgI9FxO6zFJMkSZolJpckSdKMlUmQ9rK+XEbL6o5vtsx2gmyKc8wDPggcm5nbZ+Z5c3m+XsrMe4BnAm+LiD/prI+IF0TEpRGxJiLujIivR8TBHcf4FfAS4KyI8HdYSZIaxB/MkiRpxsokyPaZuT3wceCcjjJ170+AYeDyugNpi8K82ThWZt6Qmftm5k0d53gT8O/AO4HFwJ7A94BvRcQhHce4IDOflJkjsxGTJEmaHSaXJElSLyyJiG+WPZquiIhHVysj4sVl+Z0R8dOIOHRzDr6p/SPijeW53xYRN5fLmzr2f1pE/KKM7ysRcXpEfKus+zKwBDijrL+gsuv9IuK8iLg7Iq6OiGdOE+ezI+KyMs7LIuJvy/JHAb8qN/tVeZ7tJtm/FRHvKa/hpog4MSJ+257PKCKOjojfduxzVkScUXm+JCLOjYgby2VFROxQqc+IOD4iLgHuAQ6KiHURsWtlmyh7cx25qeudTkQsBV4PnJCZn83MezLz1sw8BfgM8IEtOb4kSeoNk0uSJKkXjgFeCSwCvkHRywmAiDgWOBE4HLgfRbLh8xHxkG4O3OX+fwVcB+wGHAa8LiIeU+7/YODzwJuBnYDTgRe1d8zMw8p9/7HskVVNfB0FvKe8rvcDH4+I4SnifBRwDnAScH/gdcCnI+KRmfl9YO9y04eV57lvksOcBDwdeDSwDFgK7DHNLarGMB+4EPgFRQ+hvwB2p+g5VPUi4LnA9sBPgB+U19r25PKaz+323FM4FAjg05PUnQ08rGwfSZLUYCaXJElSL3w4M6/MzI3AGcBDImJRWfdK4JTMvCwzRzLzq8BFwPO6PHY3+/86Mz+UmRsy84fAz4DlZd3zgR9m5qfL+m8C/9XluT+bmd8th2mtoEi4/NkU274QOC8zv1ae57+BL1Ak3rr1AuDUzPxtZq4FXg3kZuz/dCAy818zc21m3g78C3B4RAxWtntXZl6dmRvLJNcKKgm38vEnyxi2xGJgVWaum6TuD+V610nqJElSg5hckiRJvXBj5fGact0eirUM+EBE3NFegCcCD+zy2N3sf2PHPmsq538gcG1HfefzqYweNzM7r6vTg4BrOsquLsu7tTuwsuOcN2/G/ssohihW79U3KRJU1Ym2V3bsdy6wOCIeGxH3p5ic+yObcd6prAJ2iYihSep2K9ebc32SJKkGszJBoyRJ0ha4FnhDZn6upv1voBieVbWk4/lsTCD9e4rkTtWeZXm3bqAYCgdARCxkfM+e1cDCjn12oxjWB8W9+nVm7s2mjbvezLw3Ij5O0WPpMuCyzJyNice/Ua6fSzEMrupwiuRbZ0JOkiQ1jD2XJElS3U4H3hgR+5UTRS8oe8j8eY/2/zTwyIj4PxExGBFPAJ7Vsc1NTD3crVtnAc+OiKeU5/lr4O+AMzfjGGcD/xwRD46IBRTfsBaV+p8Cu0bE0yNioJww/K8q9V8BWhHxuojYobxfD2xPLD6NFcDfAy+lo9dSOWn6ys24DgAy83fAqcC/R8RzyrbbOSJeDxwJ/FNmbs6wP0mSVAOTS5IkqVaZ+RGKJMmZwO0UvWz+BWj1aP+rKZImbwLupJjH6GygOqH2W4AjIuL2iPhaN8ed5Dzfo5gU+11lnO8EjsjMH2zGYd4OnE8xwfbvKK51dAhfeS3HUySCbgOeCpxXqb8HOIRiIu9fUlzvN4H9uoj/l8ClFD2hPtNRvQT41mZcR/W4rwdeRTHB+S3ArRTzaD0tM780k2NKkqTeCv8YJEmSNF5EfBq4OzOPrTuW6UTEb4G3ZOZZPTjXWcC6zvsSEb8GDsnMzRniN9U59qdIeJ2QmZ/Y0uNJkqS555xLkiRpmxcRhwHfAe4GngY8G3hKrUE1TEQ8lKKH1yM76zLzobN1nsz8aTlk8NCIWJSZd87WsSVJ0twwuSRJkgSPpxhWN59iqNlLMvOiekNqjog4lyLZ9vbMvGKuz5eZPwR+ONfnkSRJs8NhcZIkSZIkSZoxJ/SWJEmSJEnSjJlckiRJkiRJ0oyZXJIkSZIkSdKMmVySJEmSJEnSjJlckiRJkiRJ0oyZXJIkSZIkSdKM/T+r6E0iDfpRBgAAAABJRU5ErkJggg==\n",
+      "text/plain": [
+       "<Figure size 1440x360 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# check performance\n",
+    "comp = sliding_dot_product_v4\n",
+    "plot_performance(\n",
+    "    comp, \n",
+    "    ref_func=core.sliding_dot_product, \n",
+    "    test_output=True\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8066d66b",
+   "metadata": {},
+   "source": [
+    "## let's compare the four version"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 123,
+   "id": "a470fcce",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "ref_func = core.sliding_dot_product\n",
+    "\n",
+    "comp_func_v0 = sliding_dot_product_v0\n",
+    "comp_func_v1 = sliding_dot_product_v1\n",
+    "comp_func_v2 = sliding_dot_product_v2\n",
+    "comp_func_v3 = sliding_dot_product_v3\n",
+    "comp_func_v4 = sliding_dot_product_v4\n",
+    "\n",
+    "seed = 0\n",
+    "np.random.seed(seed)\n",
+    "\n",
+    "T = np.random.rand(n)\n",
+    "\n",
+    "running_time = np.zeros((len(m_values), 6)) \n",
+    "for i, m in enumerate(m_values):\n",
+    "    Q = T[:m]\n",
+    "    \n",
+    "    # ref\n",
+    "    t1 = time.time()\n",
+    "    ref = ref_func(Q, T)\n",
+    "    t2 = time.time()\n",
+    "    running_time[i, 0] = t2 - t1\n",
+    "    \n",
+    "    # comp_v0\n",
+    "    t1 = time.time()\n",
+    "    ref = comp_func_v0(Q, T)\n",
+    "    t2 = time.time()\n",
+    "    running_time[i, 1] = t2 - t1\n",
+    "    \n",
+    "    # comp_v1\n",
+    "    t1 = time.time()\n",
+    "    comp = comp_func_v1(Q, T)\n",
+    "    t2 = time.time()\n",
+    "    running_time[i, 2] = t2 - t1\n",
+    "    \n",
+    "    # comp_v2\n",
+    "    t1 = time.time()\n",
+    "    comp = comp_func_v2(Q, T)\n",
+    "    t2 = time.time()\n",
+    "    running_time[i, 3] = t2 - t1\n",
+    "    \n",
+    "    # comp_v3\n",
+    "    t1 = time.time()\n",
+    "    comp = comp_func_v3(Q, T)\n",
+    "    t2 = time.time()\n",
+    "    running_time[i, 4] = t2 - t1\n",
+    "    \n",
+    "    # comp_v4\n",
+    "    t1 = time.time()\n",
+    "    comp = comp_func_v4(Q, T)\n",
+    "    t2 = time.time()\n",
+    "    running_time[i, 5] = t2 - t1"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 124,
+   "id": "7517c4d3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "m_values_labels = np.arange(0, 1000 + 100, 100)\n",
+    "m_values_labels[0] = 10\n",
+    "\n",
+    "m_values_ticks = np.flatnonzero(np.isin(m_values, m_values_labels))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 125,
+   "id": "376d5d20",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1440x360 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.figure(figsize=(20, 5))\n",
+    "plt.title('The length of `T` is $2^{15}$', fontsize=13)\n",
+    "plt.plot(running_time[:, 0], color='k', label='ref')\n",
+    "plt.plot(running_time[:, 1], color='darkblue', label='comp_v0')\n",
+    "plt.plot(running_time[:, 2], color='orange', label='comp_v1')\n",
+    "plt.plot(running_time[:, 3], color='darkgreen', label='comp_v2')\n",
+    "plt.plot(running_time[:, 4], color='cyan', label='comp_v3')\n",
+    "plt.plot(running_time[:, 5], color='r', label='comp_v4')\n",
+    "\n",
+    "plt.xticks(ticks=m_values_ticks, labels=m_values_labels, fontsize=13)\n",
+    "plt.xlabel('The window size of query', fontsize=13)\n",
+    "plt.ylabel('Running time [sec]', fontsize=13)\n",
+    "\n",
+    "plt.legend(ncols=1, fontsize=13)\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 126,
+   "id": "4b954978",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1440x360 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.figure(figsize=(20, 5))\n",
+    "plt.title('The length of `T` is $2^{15}$', fontsize=13)\n",
+    "\n",
+    "plt.plot(running_time[:, 0], color='k', label='ref')\n",
+    "#plt.plot(running_time[:, 1], color='orange', label='comp_v1')\n",
+    "#plt.plot(running_time[:, 2], color='darkgreen', label='comp_v2')\n",
+    "plt.plot(running_time[:, 3], color='cyan', label='comp_v3')\n",
+    "plt.plot(running_time[:, 4], color='r', label='comp_v4')\n",
+    "\n",
+    "plt.xticks(ticks=IDX, labels=m_values_label, fontsize=13)\n",
+    "plt.xlabel('The window size of query', fontsize=13)\n",
+    "plt.ylabel('Running time [sec]', fontsize=13)\n",
+    "\n",
+    "plt.legend(ncols=1, fontsize=13)\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 127,
+   "id": "757c1c7f",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1440x360 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.figure(figsize=(20, 5))\n",
+    "plt.title('The length of `T` is $2^{15}$', fontsize=13)\n",
+    "\n",
+    "plt.plot(running_time[:, 0], color='k', label='ref')\n",
+    "#plt.plot(running_time[:, 1], color='orange', label='comp_v1')\n",
+    "#plt.plot(running_time[:, 2], color='darkgreen', label='comp_v2')\n",
+    "#plt.plot(running_time[:, 3], color='cyan', label='comp_v3')\n",
+    "plt.plot(running_time[:, 4], color='r', label='comp_v4')\n",
+    "\n",
+    "plt.xticks(ticks=IDX, labels=m_values_label, fontsize=13)\n",
+    "plt.xlabel('The window size of query', fontsize=13)\n",
+    "plt.ylabel('Running time [sec]', fontsize=13)\n",
+    "\n",
+    "plt.legend(ncols=1, fontsize=13)\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8914baa1",
+   "metadata": {},
+   "source": [
+    "## Let's conider different length for `T`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 129,
+   "id": "2ca81a9c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "n_T = np.power(2, range(11, 21))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 130,
+   "id": "8195624d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "comp_func = sliding_dot_product_v4\n",
+    "ref_func = core.sliding_dot_product\n",
+    "\n",
+    "seed = 0\n",
+    "np.random.seed(seed)\n",
+    "\n",
+    "out = {}\n",
+    "m_values = range(10, 1000 + 10, 10)\n",
+    "for p in range(10, 21):\n",
+    "    n = 2 ** p\n",
+    "    T = np.random.rand(n)\n",
+    "    \n",
+    "    running_time = np.zeros((len(m_values), 2))         \n",
+    "    for i, m in enumerate(m_values):\n",
+    "        Q = T[:m]\n",
+    "\n",
+    "        # ref\n",
+    "        t1 = time.time()\n",
+    "        ref = ref_func(Q, T)\n",
+    "        t2 = time.time()\n",
+    "        running_time[i, 0] = t2 - t1\n",
+    "\n",
+    "        # comp\n",
+    "        t1 = time.time()\n",
+    "        comp = comp_func(Q, T)\n",
+    "        t2 = time.time()\n",
+    "        running_time[i, 1] = t2 - t1\n",
+    "\n",
+    "        np.testing.assert_almost_equal(ref, comp)\n",
+    "    \n",
+    "    out[p] = running_time"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 132,
+   "id": "5a859f1d",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1440x360 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# let's plot the figures for n = 2 ** p, with p in {16, 18, 20}\n",
+    "\n",
+    "colors=['k', 'r', 'b', 'orange', 'gray', 'darkgreen', 'darkgreen', 'cyan', 'gray', 'purple', 'brown']\n",
+    "\n",
+    "m_values_labels = np.arange(0, 1000 + 100, 100)\n",
+    "m_values_labels[0] = 10\n",
+    "m_values_ticks = np.flatnonzero(np.isin(m_values, m_values_labels))\n",
+    "\n",
+    "plt.figure(figsize=(20, 5))\n",
+    "plt.title('sliding dot product', fontsize=13)\n",
+    "for i, p in enumerate([16, 18, 20]): \n",
+    "    plt.plot(out[p][:, 0], c=colors[i], label=f'ref_{p}')\n",
+    "    plt.plot(out[p][:, 1], c=colors[i], linestyle='--', label=f'comp_{p}')\n",
+    "\n",
+    "\n",
+    "plt.xticks(ticks=m_values_ticks, labels=m_values_labels, fontsize=13)\n",
+    "plt.yticks(fontsize=13)\n",
+    "\n",
+    "plt.xlabel('The length of query', fontsize=13)\n",
+    "plt.ylabel('Running time [sec]', fontsize=13)\n",
+    "plt.legend(title='Each number is the log2 of length of `T`', ncols=3, fontsize=13)\n",
+    "plt.show()"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.12"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}