Repository: jrenaud90/CyRK (language: python)

Issue:
Switch to vectors for dense
Greatly improved performance when using dense output with `cysolve_ivp` (and a slight improvement for `pysolve_ivp`).
Various bug fixes.


Discussion / hints:

Fix patch:
diff --git a/Benchmarks/CyRK - SciPy Comparison.ipynb b/Benchmarks/CyRK - SciPy Comparison.ipynb
index e77dc03..0b911b5 100644
--- a/Benchmarks/CyRK - SciPy Comparison.ipynb
+++ b/Benchmarks/CyRK - SciPy Comparison.ipynb
@@ -10,7 +10,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 1,
    "id": "971e366b",
    "metadata": {},
    "outputs": [
@@ -18,7 +18,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "0.11.2\n"
+      "0.11.3\n"
      ]
     }
    ],
@@ -43,7 +43,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 2,
    "id": "eff22823",
    "metadata": {},
    "outputs": [],
@@ -152,7 +152,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 3,
    "id": "bdae6603",
    "metadata": {},
    "outputs": [
@@ -183,7 +183,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 4,
    "id": "86846611",
    "metadata": {},
    "outputs": [
@@ -216,7 +216,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 5,
    "id": "3e9ff9df",
    "metadata": {},
    "outputs": [
@@ -246,6 +246,38 @@
     "diff_plot(cysolverNew_results.t, cysolverNew_results.y, fig_name='CyRK_CySolver')"
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "84a316d8-2940-49c2-a83b-5e8b6627e9ca",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "CyRK (Cython - cysolve_ivp; dense on) Solution\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# CyRK - CySolver (Cython Based Solver) -- dense output on\n",
+    "from CyRK.cy.cysolver_test import cytester\n",
+    "cysolverNew_results = cytester(diffeq_num, time_span, initial_conds, method=1, rtol=rtol, atol=atol, dense_output=True)\n",
+    "print('CyRK (Cython - cysolve_ivp; dense on) Solution')\n",
+    "diff_plot(cysolverNew_results.t, cysolverNew_results.y, fig_name='CyRK_CySolver_DenseOn')"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": 7,
@@ -332,100 +364,84 @@
       "\n",
       "Working on end_time = 1.0e-03.\n",
       "\tNumba Pre-Compile\n",
-      "\tWorking on SciPy\n",
-      "\tFinished SciPy.\n",
-      "\tWorking on numba\n",
-      "\tFinished numba.\n",
-      "\tWorking on cython - cysolve_ivp\n",
-      "\tFinished cython - cysolve_ivp.\n",
-      "\tWorking on PySolver\n",
-      "\tFinished PySolver.\n",
-      "\tWorking on PySolver (njit)\n",
-      "\tFinished PySolver (njit).\n",
+      "\tWorking on SciPy ... Finsihed!\n",
+      "\tWorking on SciPy (Dense output) ... Finsihed!\n",
+      "\tWorking on numba ... Finsihed!\n",
+      "\tWorking on cython - cysolve_ivp ... Finsihed!\n",
+      "\tWorking on cython - cysolve_ivp (Dense output) ... Finsihed!\n",
+      "\tWorking on PySolver ... Finsihed!\n",
+      "\tWorking on PySolver (njit) ... Finsihed!\n",
+      "\tWorking on PySolver (njit; Dense output) ... Finsihed!\n",
       "Working on end_time = 1.0e-02.\n",
       "\tNumba Pre-Compile\n",
-      "\tWorking on SciPy\n",
-      "\tFinished SciPy.\n",
-      "\tWorking on numba\n",
-      "\tFinished numba.\n",
-      "\tWorking on cython - cysolve_ivp\n",
-      "\tFinished cython - cysolve_ivp.\n",
-      "\tWorking on PySolver\n",
-      "\tFinished PySolver.\n",
-      "\tWorking on PySolver (njit)\n",
-      "\tFinished PySolver (njit).\n",
+      "\tWorking on SciPy ... Finsihed!\n",
+      "\tWorking on SciPy (Dense output) ... Finsihed!\n",
+      "\tWorking on numba ... Finsihed!\n",
+      "\tWorking on cython - cysolve_ivp ... Finsihed!\n",
+      "\tWorking on cython - cysolve_ivp (Dense output) ... Finsihed!\n",
+      "\tWorking on PySolver ... Finsihed!\n",
+      "\tWorking on PySolver (njit) ... Finsihed!\n",
+      "\tWorking on PySolver (njit; Dense output) ... Finsihed!\n",
       "Working on end_time = 1.0e-01.\n",
       "\tNumba Pre-Compile\n",
-      "\tWorking on SciPy\n",
-      "\tFinished SciPy.\n",
-      "\tWorking on numba\n",
-      "\tFinished numba.\n",
-      "\tWorking on cython - cysolve_ivp\n",
-      "\tFinished cython - cysolve_ivp.\n",
-      "\tWorking on PySolver\n",
-      "\tFinished PySolver.\n",
-      "\tWorking on PySolver (njit)\n",
-      "\tFinished PySolver (njit).\n",
+      "\tWorking on SciPy ... Finsihed!\n",
+      "\tWorking on SciPy (Dense output) ... Finsihed!\n",
+      "\tWorking on numba ... Finsihed!\n",
+      "\tWorking on cython - cysolve_ivp ... Finsihed!\n",
+      "\tWorking on cython - cysolve_ivp (Dense output) ... Finsihed!\n",
+      "\tWorking on PySolver ... Finsihed!\n",
+      "\tWorking on PySolver (njit) ... Finsihed!\n",
+      "\tWorking on PySolver (njit; Dense output) ... Finsihed!\n",
       "Working on end_time = 1.0e+00.\n",
       "\tNumba Pre-Compile\n",
-      "\tWorking on SciPy\n",
-      "\tFinished SciPy.\n",
-      "\tWorking on numba\n",
-      "\tFinished numba.\n",
-      "\tWorking on cython - cysolve_ivp\n",
-      "\tFinished cython - cysolve_ivp.\n",
-      "\tWorking on PySolver\n",
-      "\tFinished PySolver.\n",
-      "\tWorking on PySolver (njit)\n",
-      "\tFinished PySolver (njit).\n",
+      "\tWorking on SciPy ... Finsihed!\n",
+      "\tWorking on SciPy (Dense output) ... Finsihed!\n",
+      "\tWorking on numba ... Finsihed!\n",
+      "\tWorking on cython - cysolve_ivp ... Finsihed!\n",
+      "\tWorking on cython - cysolve_ivp (Dense output) ... Finsihed!\n",
+      "\tWorking on PySolver ... Finsihed!\n",
+      "\tWorking on PySolver (njit) ... Finsihed!\n",
+      "\tWorking on PySolver (njit; Dense output) ... Finsihed!\n",
       "Working on end_time = 1.0e+01.\n",
       "\tNumba Pre-Compile\n",
-      "\tWorking on SciPy\n",
-      "\tFinished SciPy.\n",
-      "\tWorking on numba\n",
-      "\tFinished numba.\n",
-      "\tWorking on cython - cysolve_ivp\n",
-      "\tFinished cython - cysolve_ivp.\n",
-      "\tWorking on PySolver\n",
-      "\tFinished PySolver.\n",
-      "\tWorking on PySolver (njit)\n",
-      "\tFinished PySolver (njit).\n",
+      "\tWorking on SciPy ... Finsihed!\n",
+      "\tWorking on SciPy (Dense output) ... Finsihed!\n",
+      "\tWorking on numba ... Finsihed!\n",
+      "\tWorking on cython - cysolve_ivp ... Finsihed!\n",
+      "\tWorking on cython - cysolve_ivp (Dense output) ... Finsihed!\n",
+      "\tWorking on PySolver ... Finsihed!\n",
+      "\tWorking on PySolver (njit) ... Finsihed!\n",
+      "\tWorking on PySolver (njit; Dense output) ... Finsihed!\n",
       "Working on end_time = 1.0e+02.\n",
       "\tNumba Pre-Compile\n",
-      "\tWorking on SciPy\n",
-      "\tFinished SciPy.\n",
-      "\tWorking on numba\n",
-      "\tFinished numba.\n",
-      "\tWorking on cython - cysolve_ivp\n",
-      "\tFinished cython - cysolve_ivp.\n",
-      "\tWorking on PySolver\n",
-      "\tFinished PySolver.\n",
-      "\tWorking on PySolver (njit)\n",
-      "\tFinished PySolver (njit).\n",
+      "\tWorking on SciPy ... Finsihed!\n",
+      "\tWorking on SciPy (Dense output) ... Finsihed!\n",
+      "\tWorking on numba ... Finsihed!\n",
+      "\tWorking on cython - cysolve_ivp ... Finsihed!\n",
+      "\tWorking on cython - cysolve_ivp (Dense output) ... Finsihed!\n",
+      "\tWorking on PySolver ... Finsihed!\n",
+      "\tWorking on PySolver (njit) ... Finsihed!\n",
+      "\tWorking on PySolver (njit; Dense output) ... Finsihed!\n",
       "Working on end_time = 1.0e+03.\n",
       "\tNumba Pre-Compile\n",
-      "\tWorking on SciPy\n",
-      "\tFinished SciPy.\n",
-      "\tWorking on numba\n",
-      "\tFinished numba.\n",
-      "\tWorking on cython - cysolve_ivp\n",
-      "\tFinished cython - cysolve_ivp.\n",
-      "\tWorking on PySolver\n",
-      "\tFinished PySolver.\n",
-      "\tWorking on PySolver (njit)\n",
-      "\tFinished PySolver (njit).\n",
+      "\tWorking on SciPy ... Finsihed!\n",
+      "\tWorking on SciPy (Dense output) ... Finsihed!\n",
+      "\tWorking on numba ... Finsihed!\n",
+      "\tWorking on cython - cysolve_ivp ... Finsihed!\n",
+      "\tWorking on cython - cysolve_ivp (Dense output) ... Finsihed!\n",
+      "\tWorking on PySolver ... Finsihed!\n",
+      "\tWorking on PySolver (njit) ... Finsihed!\n",
+      "\tWorking on PySolver (njit; Dense output) ... Finsihed!\n",
       "Working on end_time = 1.0e+04.\n",
       "\tNumba Pre-Compile\n",
-      "\tWorking on SciPy\n",
-      "\tFinished SciPy.\n",
-      "\tWorking on numba\n",
-      "\tFinished numba.\n",
-      "\tWorking on cython - cysolve_ivp\n",
-      "\tFinished cython - cysolve_ivp.\n",
-      "\tWorking on PySolver\n",
-      "\tFinished PySolver.\n",
-      "\tWorking on PySolver (njit)\n",
-      "\tFinished PySolver (njit).\n",
+      "\tWorking on SciPy ... Finsihed!\n",
+      "\tWorking on SciPy (Dense output) ... Finsihed!\n",
+      "\tWorking on numba ... Finsihed!\n",
+      "\tWorking on cython - cysolve_ivp ... Finsihed!\n",
+      "\tWorking on cython - cysolve_ivp (Dense output) ... Finsihed!\n",
+      "\tWorking on PySolver ... Finsihed!\n",
+      "\tWorking on PySolver (njit) ... Finsihed!\n",
+      "\tWorking on PySolver (njit; Dense output) ... Finsihed!\n",
       "Done!\n"
      ]
     }
@@ -441,22 +457,31 @@
     "# end_times = np.logspace(-3, -2, 2)\n",
     "\n",
     "sci_steps = list()\n",
+    "sci_dense_steps = list()\n",
     "nb_steps = list()\n",
     "cysolver_steps = list()\n",
+    "cysolver_dense_steps = list()\n",
     "pysolver_steps = list()\n",
     "pysolver_njit_steps = list()\n",
+    "pysolver_dense_njit_steps = list()\n",
     "\n",
     "sci_times = list()\n",
+    "sci_dense_times = list()\n",
     "nb_times = list()\n",
     "cysolver_times = list()\n",
+    "cysolver_dense_times = list()\n",
     "pysolver_times = list()\n",
     "pysolver_njit_times = list()\n",
+    "pysolver_dense_njit_times = list()\n",
     "\n",
     "sci_errors = list()\n",
+    "sci_dense_errors = list()\n",
     "nb_errors = list()\n",
     "cysolver_errors = list()\n",
+    "cysolver_dense_errors = list()\n",
     "pysolver_errors = list()\n",
     "pysolver_njit_errors = list()\n",
+    "pysolver_dense_njit_errors = list()\n",
     "\n",
     "# temp_scipy_span = (0.0, 1.0e-2) # Uncomment to speed up time comparison if you don't need to compare to scipy\n",
     "\n",
@@ -469,7 +494,7 @@
     "    print(f'\\tNumba Pre-Compile')\n",
     "    _ = nbsolve_ivp(diffeq_scipy_njit, time_s, initial_conds, rk_method=1, args=args, rtol=rtol, atol=atol)\n",
     "    \n",
-    "    print('\\tWorking on SciPy')\n",
+    "    print('\\tWorking on SciPy', end='')\n",
     "    sci_timer = timeit.Timer(lambda: solve_ivp(diffeq_scipy, temp_scipy_span, initial_conds, method='RK45', args=args, rtol=rtol, atol=atol))\n",
     "    scipy_time_list = list()\n",
     "    for i in range(REPEATS):\n",
@@ -480,9 +505,22 @@
     "    sci_errors.append(np.std(scipy_time_list))\n",
     "    _sol = solve_ivp(diffeq_scipy, temp_scipy_span, initial_conds, method='RK45', args=args, rtol=rtol, atol=atol)\n",
     "    sci_steps.append(_sol.t.size)\n",
-    "    print('\\tFinished SciPy.')\n",
+    "    print(' ... Finsihed!')\n",
+    "\n",
+    "    print('\\tWorking on SciPy (Dense output)', end='')\n",
+    "    sci_dense_timer = timeit.Timer(lambda: solve_ivp(diffeq_scipy, temp_scipy_span, initial_conds, method='RK45', args=args, rtol=rtol, atol=atol, dense_output=True))\n",
+    "    scipy_dense_time_list = list()\n",
+    "    for i in range(REPEATS):\n",
+    "        N, T = sci_dense_timer.autorange()\n",
+    "        scipy_dense_time_list.append(T / N * 1000.)\n",
+    "    scipy_dense_time_list = np.asarray(scipy_dense_time_list)\n",
+    "    sci_dense_times.append(np.average(scipy_dense_time_list))\n",
+    "    sci_dense_errors.append(np.std(scipy_dense_time_list))\n",
+    "    dense_sol = solve_ivp(diffeq_scipy, temp_scipy_span, initial_conds, method='RK45', args=args, rtol=rtol, atol=atol, dense_output=True)\n",
+    "    sci_dense_steps.append(dense_sol.t.size)\n",
+    "    print(' ... Finsihed!')\n",
     "    \n",
-    "    print('\\tWorking on numba')\n",
+    "    print('\\tWorking on numba', end='')\n",
     "    nb_timer = timeit.Timer(lambda: nbsolve_ivp(diffeq_scipy_njit, time_s, initial_conds, rk_method=1, args=args, rtol=rtol, atol=atol))\n",
     "    nb_times_list = list()\n",
     "    for i in range(REPEATS):\n",
@@ -493,9 +531,9 @@
     "    nb_errors.append(np.std(nb_times_list))\n",
     "    _out = nbsolve_ivp(diffeq_scipy_njit, time_s, initial_conds, rk_method=1, args=args, rtol=rtol, atol=atol)\n",
     "    nb_steps.append(_out.size)\n",
-    "    print('\\tFinished numba.')\n",
+    "    print(' ... Finsihed!')\n",
     "    \n",
-    "    print('\\tWorking on cython - cysolve_ivp')    \n",
+    "    print('\\tWorking on cython - cysolve_ivp', end='')    \n",
     "    cysolver_timer = timeit.Timer(lambda: cytester(diffeq_num, time_s, initial_conds, method=1, rtol=rtol, atol=atol))\n",
     "    cysolver_times_list = list()\n",
     "    for i in range(REPEATS):\n",
@@ -506,9 +544,22 @@
     "    cysolver_errors.append(np.std(cysolver_times_list))\n",
     "    cysolverResult = cytester(diffeq_num, time_s, initial_conds, method=1, rtol=rtol, atol=atol)\n",
     "    cysolver_steps.append(cysolverResult.size)\n",
-    "    print('\\tFinished cython - cysolve_ivp.')\n",
+    "    print(' ... Finsihed!')\n",
+    "\n",
+    "    print('\\tWorking on cython - cysolve_ivp (Dense output)', end='')    \n",
+    "    cysolver_dense_timer = timeit.Timer(lambda: cytester(diffeq_num, time_s, initial_conds, method=1, rtol=rtol, atol=atol, dense_output=True))\n",
+    "    cysolver_dense_times_list = list()\n",
+    "    for i in range(REPEATS):\n",
+    "        N, T = cysolver_dense_timer.autorange()\n",
+    "        cysolver_dense_times_list.append(T / N * 1000.)\n",
+    "    cysolver_dense_times_list = np.asarray(cysolver_dense_times_list)\n",
+    "    cysolver_dense_times.append(np.average(cysolver_dense_times_list))\n",
+    "    cysolver_dense_errors.append(np.std(cysolver_dense_times_list))\n",
+    "    cysolverdense_Result = cytester(diffeq_num, time_s, initial_conds, method=1, rtol=rtol, atol=atol, dense_output=True)\n",
+    "    cysolver_dense_steps.append(cysolverdense_Result.size)\n",
+    "    print(' ... Finsihed!')\n",
     "    \n",
-    "    print('\\tWorking on PySolver')    \n",
+    "    print('\\tWorking on PySolver', end='')    \n",
     "    pysolver_timer = timeit.Timer(lambda: pysolve_ivp(diffeq, time_s, initial_conds, method='RK45', args=args, rtol=rtol, atol=atol, pass_dy_as_arg=True))\n",
     "    pysolver_times_list = list()\n",
     "    for i in range(REPEATS):\n",
@@ -519,9 +570,9 @@
     "    pysolver_errors.append(np.std(pysolver_times_list))\n",
     "    pysolverResult = pysolve_ivp(diffeq, time_s, initial_conds, method='RK45', args=args, rtol=rtol, atol=atol, pass_dy_as_arg=True)\n",
     "    pysolver_steps.append(pysolverResult.size)\n",
-    "    print('\\tFinished PySolver.')\n",
+    "    print(' ... Finsihed!')\n",
     "    \n",
-    "    print('\\tWorking on PySolver (njit)')    \n",
+    "    print('\\tWorking on PySolver (njit)', end='')    \n",
     "    pysolver_njit_timer = timeit.Timer(lambda: pysolve_ivp(diffeq_njit, time_s, initial_conds, method='RK45', args=args, rtol=rtol, atol=atol, pass_dy_as_arg=True))\n",
     "    pysolver_njit_times_list = list()\n",
     "    for i in range(REPEATS):\n",
@@ -532,7 +583,20 @@
     "    pysolver_njit_errors.append(np.std(pysolver_njit_times_list))\n",
     "    pysolver_njitResult = pysolve_ivp(diffeq_njit, time_s, initial_conds, method='RK45', args=args, rtol=rtol, atol=atol, pass_dy_as_arg=True)\n",
     "    pysolver_njit_steps.append(pysolver_njitResult.size)\n",
-    "    print('\\tFinished PySolver (njit).')\n",
+    "    print(' ... Finsihed!')\n",
+    "\n",
+    "    print('\\tWorking on PySolver (njit; Dense output)', end='')    \n",
+    "    pysolver_dense_njit_timer = timeit.Timer(lambda: pysolve_ivp(diffeq_njit, time_s, initial_conds, method='RK45', args=args, rtol=rtol, atol=atol, pass_dy_as_arg=True, dense_output=True))\n",
+    "    pysolver_dense_njit_times_list = list()\n",
+    "    for i in range(REPEATS):\n",
+    "        N, T = pysolver_dense_njit_timer.autorange()\n",
+    "        pysolver_dense_njit_times_list.append(T / N * 1000.)\n",
+    "    pysolver_dense_njit_times_list = np.asarray(pysolver_dense_njit_times_list)\n",
+    "    pysolver_dense_njit_times.append(np.average(pysolver_dense_njit_times_list))\n",
+    "    pysolver_dense_njit_errors.append(np.std(pysolver_dense_njit_times_list))\n",
+    "    pysolver_dense_njitResult = pysolve_ivp(diffeq_njit, time_s, initial_conds, method='RK45', args=args, rtol=rtol, atol=atol, pass_dy_as_arg=True, dense_output=True)\n",
+    "    pysolver_dense_njit_steps.append(pysolver_dense_njitResult.size)\n",
+    "    print(' ... Finsihed!')\n",
     "    \n",
     "print('Done!')"
    ]
@@ -545,7 +609,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAnUAAAHWCAYAAAARl3+JAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAADE2UlEQVR4nOzdd1hT1xsH8G8SphgBBRUX4K5ad60L+blwW3HhXrWt4KxWW1dxtZaqqLWitkUQXLhHZbhQ3BtUnGhAQERGgCCbnN8fgVtCEkgYBvD9PM95IOeee+659yTh5d57zuUBYCCEEEIIIZUaX9sNIIQQQgghpUdBHSGEEEJIFUBBHSGEEEJIFUBBHSGEEEJIFUBBHSGEEEJIFUBBHSGEEEJIFUBBHSGEEEJIFUBBHSGEEEJIFUBBHSGEEEJIFUBBHSGEEEJIFUBBHSGkUmjcuDF27tyJV69eIT09HcnJybh69SrmzZsHAwMDjetjjMml5ORkXLp0CYMHD1YoO3XqVDDG0KlTJ7n8GjVq4NatW0hPT8eAAQNKvG8F6enp4bfffkN0dDTS0tJw8+ZN9OvXT611mzdvDldXV1y7dg3p6elgjMHS0lJp2bFjx8Lb2xsvXrwAYwyBgYFqt9HAwAD//PMPHj16hKSkJEgkEgQHB2PevHnQ0dFRux5CSNmiTx8hpMIbPHgwDh8+jMzMTHh5eeHx48fQ09NDz549sWHDBrRu3RrfffedxvWePXsWXl5e4PF4sLS0hKOjI06fPo1Bgwbh7NmzRa4rFApx9uxZtG3bFvb29ggICCjp7snx9PTE6NGjsWXLFrx8+RLTpk2Dr68vevfujWvXrhW5brdu3TBv3jw8efIET58+RYcOHVSWdXR0RKdOnXDnzh3UqlVLozYaGhqidevW8PX1RXh4OKRSKbp3747Nmzfjyy+/xMSJEzWqjxBSdhglSpQoVdRkZWXFUlJS2JMnT1jdunUVljdp0oTNmzdP43oZY2zbtm1yeS1btmSMMXbmzBm5/KlTpzLGGOvUqRMDwKpXr86uX7/OMjIy2ODBg8tsX7/44gvGGGOLFi3i8vT19dnLly/ZtWvXil3f1NSUVa9enQFgixYtYowxZmlpqbRsgwYNGI/HYwDYo0ePWGBgYKnb/8cffzDGGKtTp47W3zeUKH2KiS6/EkIqtCVLlkAoFOLrr7/Gu3fvFJa/evUKf/zxBwDg0qVLCA4OVlrPs2fP4O/vX+S2nj17hri4ODRp0kRlGSMjI/j7+6Njx44YNWoUfH19i6yzU6dOYIxhypQpCsvs7OzAGMOQIUMAAKNHj0ZOTg7++usvrkxmZibc3d3RvXt3NGjQoMhticVipKamFlkmX1RUFBhjapVVV3h4OADAxMSkTOslhKiHgjpCSIU2bNgwvHr1Cjdu3Ci2rLe3N9q1a4fWrVvL5Xfu3BktWrTA3r17i1y/Ro0aMDU1hVgsVrrcyMgIfn5++OKLLzBmzBicOXOm2Dbdu3cPr169wtixYxWWOTg4IDExkbt026FDB7x48QISiUSu3O3btwEA7du3L3Z7H5Ouri5q1aqFBg0aYMSIEfjhhx8QHh6OsLAwbTeNkE8SBXWEkApLKBSiQYMGePTokVrlDx8+jPT0dEyaNEkuf9KkSUhNTcWxY8fk8g0MDFCrVi2YmZmhY8eOOHjwIHR0dHDkyBGl9e/ZswdffvklxowZg9OnT6u9Hz4+Pujfv7/cGSxdXV3Y29vj+PHjyMnJAQBYWFggJiZGYf38vHr16qm9zY9h5MiRiI+PR2RkJI4fP46oqCgMGzYMubm52m4aIZ8kCuoIIRVWjRo1AEDhzJUqKSkpOHnyJMaPH8/l8fl8ODg44MSJE0hLS5MrP3PmTMTHxyMuLg737t1D37594eLiAldXV6X116lTBxkZGYiMjNRoP3x8fKCnp4eRI0dyeXZ2djA1NYWPjw+XZ2hoiMzMTIX1MzIyuOUVSWBgIPr164fRo0djx44dyM7OhpGRkbabRcgni4I6QkiFlZKSAkB2xk5dXl5esLS0hI2NDQCgX79+qFu3Lry9vRXKnjhxAv369cPgwYPh7OwMxhiqVaum8l6z7777DllZWfD390fz5s3VbtPDhw/x9OlTODg4cHkODg6Ii4vDxYsXubz09HTo6+srrJ8/ZUt6erra2/wY3r9/jwsXLuDo0aNwcnLCv//+i3PnzqFOnTrabhohnyQK6gghFZZEIkF0dDTatGmj9joBAQF49+4ddwl20qRJiImJwfnz5xXKRkVF4cKFC/Dz88OaNWuwcOFCzJ07F/b29krrfvLkCQYPHgxDQ0OcO3eu2IELBfn4+KB3796oVasW9PT0MHz4cBw9elTuUmVMTAwsLCwU1s3Pe/v2rdrb04YjR45AKBTiq6++0nZTCPkkUVBHCKnQ/v33XzRt2hRdu3ZVq7xUKsX+/fsxevRomJiYYMSIEThw4ACkUmmx6+7atQthYWFYt26dyjJ37tzBiBEjULt2bZw7dw5mZmZqtcvHxwe6uroYNWoUBg0aBGNjYxw8eFCuTHBwMJo3b65wZvLLL7/klldk+ZeHjY2NtdwSQj5NFNQRQiq033//Hampqfjnn39Qu3ZtheWNGzfGvHnz5PK8vb1Rs2ZN7Nq1C0KhsNhRr/lyc3OxadMmtGrVqsizTRcvXsT48ePRtGlT+Pv7q3V5+NmzZ3j48CEcHBzg4OCAt2/fIigoSK7MkSNHoKOjg2+//ZbL09PTw/Tp03Hz5k1ERUVx+Q0bNkSLFi3U2q/SMDQ0RIsWLeQmKFY1WfHMmTMBAHfv3i33dhFClNP6ZHmUKFGiVFQaNmwYS0tLYwkJCWzz5s3s66+/Zo6Ojszb25tlZGSwnTt3Kqzz8OFDxhhjoaGhSutUNvkwAGZgYMDev3/Prl+/zuUVnnw4P02bNo0xxlhgYCDT19cvdj+WLVvGcnJyWGpqKtu6davSMj4+PiwrK4u5uLiwb775hl29epVlZWUxGxsbuXKBgYGMyW7+41KNGjXY8uXL2fLly5mvry9jjLENGzaw5cuXs9mzZ8uVtbGx4cq+e/eOvX79mntdcFu2traMMcacnZ25vPnz57OnT5+y9evXs2+++YYtXLiQBQQEMMYYO3nypNbfL5QofcJJ6w2gRIkSpWJT06ZN2a5du9jr169ZRkYGS05OZleuXGGzZ89menp6CuV/+OEHxhhjP/30k9L6VAV1ANjPP//MGGPM1taWAaqDOgBs4cKFjDHGTp06xQQCQZH70KRJE5ave/fuSsvo6+uz33//nb19+5alp6ezW7duMTs7O4VyyoI6S0tLpopIJJIr6+zsrLJswQBOWVDXqVMn5uPjw8LDw1l6ejqTSCTs7t27bMGCBcUeA0qUKJVf4uX9QgghVcq8efOwefNmWFlZaTwFCSGEVEYU1BFCqqSQkBAkJCSgT58+2m4KIYR8FDrabgAhhJSVatWqYfjw4ejduzfatm2L4cOHa7tJhBDy0dCZOkJIlWFpaYnw8HCIxWK4ublhxYoV2m4SIYR8NBTUEUIIIYRUATRPHSGEEEJIFUBBHSGEEEJIFUBBXRWyePFiPH36FDweT9tN4eQ/JJ1oV2BgIAIDA+XyateujcOHDyM+Ph6MMcyfPx8A0LRpUwQEBCApKQmMsU/+OZ4ikQgeHh7lWqetrS0YY7C1tS3T7VRkyt6ThGjiY/x9GTBgACQSidqPA9Q2CuqqCKFQiB9//BEuLi5yb3LGGJdyc3MRHR2NgICASvHHw9HREVOnTv1o25s6darc8UpPT8fz58+xbds2pY+n0hYPDw+5dkokErx69QqHDx/GyJEj1Q7qN2/ejAEDBmD9+vWYNGkS/P39AQB79uzB559/juXLl2PSpEm4e/euwrEpnPKfTVpenJ2dIRKJAPzXTyUhEong7OwMQBZUlHWwVlF169YNzs7O9EzWSmDQoEHce7S8GRoawtnZuVL8PdCWgIAAhIWFYenSpdpuilpoSpMqYsaMGdDR0cGBAwcUlp09exZeXl7g8XiwtraGk5MTLl68iCFDhnB/yCsiJycnxMfHY8+ePR91uytXroRIJIKBgQF69uwJR0dHDB48GG3atEF6evpHbYsqGRkZ3HM2DQ0NYWlpiWHDhuHo0aMIDAzEV199BYlEwpW3s7NTqKNPnz44efIkNm3axOUZGBige/fuWLduHbZv366wTv6xKSwsLKwsdqtCatGiBaRSabluIygoCAYGBsjKyiqX+rt3745Vq1bB09MTycnJ5bINUjYGDx6MOXPmYPXq1eW+rWrVqmHVqlVYtWoVLl++XO7bK2vr1q3Db7/9Vu7b2bVrFzZu3AhnZ2ekpqaW+/ZKg4K6KmL69Ok4deoUMjMzFZa9ePEC+/bt414fP34cjx49woIFC1QGdfr6+sjKyqpyl07V2S8/Pz/cu3cPAODu7o6EhAQsWrQIX331FQ4ePKh0nWrVqiEtLa1c2qxMTk6OXJ8CsoDrxx9/xG+//Ya///4b48aN45ZlZ2cr1FG7dm0kJSXJ5ZmbmwOAQn6+gsfmU1FegVZBjDGln11CPjWa/O3Jzc1Fbm5uubfp6NGj2LZtG8aMGVPhz+7T5dcqwMrKCu3atcP58+fVKv/48WPExcXB2toawH/38zg4OGDt2rWIiopCWloaatSoAQDo0qUL/Pz8kJSUhA8fPuDSpUvo3r27Qr09evTA7du3kZ6ejrCwMHz77bdKtz9t2jRcuHABsbGxyMjIQGhoKGbNmiVXRiQSoU2bNvjf//7HXeIreP+NtbU1Dh06hISEBHz48AE3btzA4MGD5eoobr/UdfHiRW6bgOzyp0QiQePGjXHmzBmkpKRwARaPx8P8+fPx+PFjpKen4927d9i5cydMTEy4+jw9PREXFwcdHcX/qQICAvDs2TON2leQi4sLAgICMGbMGDRr1ozLL3j/Uv7lSz6fjzlz5nDH19nZGW/evAEAbNy4EYwxpWflimNsbAwPDw8kJSVBLBbD09MT7dq1A2NM7nK6jo4OWrRogbp165Z4fwGgd+/eyM3NVTizMX78eDDGFN5bmip8/1v+8evevTs2bdqE9+/fIzU1FceOHVN6383y5csRGRmJDx8+4OLFi2jVqpVCGVX31HXp0gVnzpxBYmIiUlNTERISgnnz5nHLP//8c3h4eODVq1dIT09HTEwM3N3dUbNmTa6Ms7MzNm7cCAAIDw/n+tvS0pIrM3HiRNy9exdpaWlISEjAgQMH0KBBA7m2NG3aFEeOHEFMTAzS09MRGRmJAwcOqPV5+uabbxAWFoa0tDTcunULPXv2VFpOT08Pq1atwsuXL5GRkYE3b97AxcUFenp6cuUYY9i2bRu++uorPHr0CBkZGXj8+DEGDBggV6569erYvHkzRCIRMjIyEBsbi7Nnz6JDhw4Kx1md7zhlzM3N8c8//+Ddu3dIT09HcHAwpkyZIldGVf9aWlrKfS48PDwwZ84cbh/zU8GyixYtwoIFCxAeHo60tDRcunQJrVu3lqtX1f2KHh4e3Gfa0tIS8fHxAIBVq1bJfQ8o06lTJzDGFPYNkF0JYIxhyJAhXF69evXg7u6Od+/ecf0zffp0pcdF2Xe0jo4Ofv75Z7x48QLp6emIj4/HlStX0K9fP259ZffUCQQCrFixAmFhYcjIyIBIJMIvv/yi8B4SiUQ4ffo0evTogVu3biE9PR2vXr3C5MmTFfYvLi4ODx8+rBT3F9OZuiog/8vn/v37apU3MTGBqampwiWzlStXIisrCxs3buT+W+rduzd3dmb16tWQSqWYPn06Ll68CBsbG9y5cwcA0KZNG5w9exZxcXFYtWoVdHR0sHr1asTGxips39HREaGhoTh16hRycnIwbNgw7NixA3w+H25ubgCABQsWYNu2bUhNTcUvv/wCAFxdtWvXxvXr11GtWjX88ccfSEhIwNSpU3Hq1CmMHj0aJ06cKHa/NNGkSRMAQEJCApeno6ODgIAAXL16FT/88AN3lm7Xrl2YNm0aPDw88Mcff8Da2hpz5sxBhw4d0KNHD+Tk5MDb2xtTp07FgAEDcObMGa7OOnXqoE+fPqW+7OLt7Y0BAwagf//+ePnypcLyoKAgTJo0CXv37uUuzQPAw4cPkZSUhC1btmD//v3w9fVVuNRgbGyMWrVqyeUxxpCYmMi9PnnyJHr27ImdO3fi6dOnsLe3V3oJvX79+nj27Bk8PT0Vvuw1ERgYCDc3NyxduhQnTpzAgwcPULduXWzbtg3nzp3Dzp07S1x3UbZt2waxWIzVq1fDysoKCxYswJ9//il3hnTNmjVYuXIlzpw5A19fX3Ts2BFnz55V+AOjTL9+/fDvv/8iJiYGW7duxbt37/DZZ59h6NCh+OOPPwAA/fv3R+PGjeHh4YF3796hdevW+Pbbb9G6dWt07doVAHDs2DE0b94cEyZMwIIFC7g/5HFxcQCAZcuWYe3atTh06BD++ecfmJubY+7cuQgKCkKHDh2QnJwMXV1dBAQEQF9fH9u2bcO7d+9Qv359DB06FCYmJkhJSVG5HzNmzMBff/2Fa9euYcuWLWjcuDFOnTqFxMREuWfy8ng8nDp1Cj179sRff/2Fp0+f4vPPP8f333+P5s2bw97eXq7enj17YuTIkXBzc4NEIsG8efNw9OhRNGrUiHs/7ty5E6NHj8aff/6JJ0+eoFatWujZsyc+++wzPHjwAADU/o5TxsDAAJcuXULTpk3x559/QiQSYcyYMdizZw9MTEy4flLXrl27UK9ePdjZ2WHSpElKy0yZMgVCoRDbt2+HgYEB5s+fj4sXL+Lzzz/H+/fv1d5WXFwcZs2ahZ07d+LYsWM4duwYANn3gDL37t3Dq1evMHbsWO47I5+DgwMSExMREBAAQPYdffPmTTDG8OeffyIuLg6DBg3C7t27UaNGDWzdulVufWXf0atWrcLSpUvxzz//4Pbt26hRowY6d+6Mjh07FnkC459//sG0adNw+PBhbNq0CV9++SWWLVuGzz77DCNHjpQrm/+Piru7O/bs2YMZM2bA09MT9+7dw5MnTxT2f8SIEWodW21jlCp3WrNmDWOMMSMjI4VljDH2999/s1q1ajEzMzP2xRdfsHPnzjHGGPv+++8ZAGZra8sYYywsLIwZGBjIrf/8+XPm5+cnl2dgYMBevXrFAgICuLxjx46xtLQ01rBhQy6vZcuWLDs7mzHZv1Jy6xdup5+fHwsLC5PLe/ToEQsMDFQo6+rqyhhjrEePHlyekZERe/XqFXv9+jXj8XjF7peyNHXqVMYYY3369GG1atVi9evXZ2PHjmVxcXHsw4cPrF69egwA8/DwYIwx9uuvv8qt36NHD8YYY+PHj5fLt7Ozk8vn8XjszZs37MCBA3LlFixYwHJzc5mVlVWR7fTw8GASiUTl8nbt2jHGGNu0aROXFxgYqHAsGWNs27ZtcnmWlpaMMcYWLVqk9Ngok56ezpUbPnw4Y4yxH374gcvj8/ns8uXLjDHGpk6dqrAtDw+PUn8GDA0N2YsXL9ijR4+Ynp4eO336NEtKSpJ7P5Y0iUQiuTbmH4uzZ8/Kldu0aRPLzs5mNWrUYACYmZkZy8jIYKdPn5Yrt27dOoX9zn+v2tracsfs1atXTCQSMWNjY5VtU/a+dnBwYIwx1rNnTy5v0aJFjDHGLC0t5co2atSIZWdns6VLl8rlt27dmmVlZXH5+e+pUaNGaXTsdHR02Lt379j9+/eZrq4ulz9z5kzGGJN7T06cOJHl5OTIfa4BsG+//ZYxxli3bt3k3rsZGRmscePGXN7nn3/OGGNs9uzZXJ5YLFZ4jxdO6n7HKUvz5s1jjDE2YcIEuX2+du0aS0lJYdWrV1fav4U/AwU/F9u2bVP4zixYtuB3EQD2xRdfqPV5B2TfHSKRiHtdq1Ytxhhjzs7OavXnL7/8wjIzM5mJiQmXp6uryxITE9k///zD5f39998sOjqa1axZU279/fv3M7FYzL1vi/qOfvDggcJnp3BydnaWO1Zt27ZljDH2119/yZX7/fffGWOM/e9//5P7XBf+nJiZmbH09HS2YcMGhW399NNPjDHGzM3NNfoMfOxEl1+rgFq1aiE7OxsfPnxQunzmzJmIj49HXFwcbt++jR49emDTpk3YsmWLXLk9e/YgIyODe92+fXs0b94c+/fvR61atbhkZGSECxcuoFevXuDxeODz+RgwYABOnDgh95/3s2fPuP/cCiq4jRo1aqBWrVq4fPkymjRpotalnMGDB+PWrVu4du0al/fhwwf89ddfsLa2Vri8VXi/inPhwgXEx8cjKioKPj4+SE1Nhb29Pd6+fStXbseOHXKvx4wZg6SkJJw7d07ueN27dw8SiQS9e/cGADDGsG/fPgwfPhzVq1fn1p84cSKuX7+O8PBwtduqTP7ZNaFQWKp6lHFyckK/fv3k0qBBg7jlgwcPRnZ2ttyxkUql2LZtm0JdERER4PF4pTpLly89PR3Tpk3DZ599hqCgIAwdOhTff/+93PuxrP31119yr69cuQIdHR3usma/fv24M1sFFf7cKdOhQwc0btwYW7ZsKXJgQ8H3tb6+PmrVqoWbN28CADp27FjsdkaOHAk+n49Dhw7JvWffvXuHly9fcu/Z/DYMGDAAhoaGxdabr3PnzqhTpw527twpd1+np6enwn2bY8aMwdOnT/Hs2TO5tuTf/pDflnznz5/H69evudePHj1CcnIyGjduzOUlJSXhyy+/hIWFhdL2qfsdp8rgwYMRExMjN0AtJycHf/zxB4RCYbmMKj1x4oTcd9GdO3dw8+ZNhdtPyoOPjw/09PTkznjZ2dnB1NQUPj4+XN6oUaNw+vRp8Hg8ueMaEBAAExMThfemsu/opKQktG7dGk2bNlW7ffnHwNXVVS4/fzBYwcvDABAaGoqrV69yr+Pj4/H8+XO591A+sVgMABV+ahO6/PoJOHHiBP78809u+ovQ0FClN/UXvn8q/56swqfaCzI2Noa+vj6qVaum9FLf8+fPFT5I3bt3x+rVq9GtWzcYGRkp1FfUpRxAdi/IrVu3FPKfPn3KLQ8NDVW6X3w+nxsMkC8xMVHuD46TkxNevHiBnJwcxMbG4vnz5wr3bWRnZyMqKkour1mzZjAxMeEuaxVWcFoULy8v/PTTT7C3t4e3tzeaN2+Ozp0747vvvity39WRHygWHP1aVm7fvl3kQAlLS0vExMQo/IPx/PnzMm9LYdevX8eOHTswZ84c+Pv7l/sNzfn3H+bL/9I3NTUFAC64K/y5iI+Pl7tcrUz+Jf/Hjx8XWc7U1BTOzs4YN24c6tSpI7dMnelLmjVrBj6fr3L0cv7nIjw8HJs2bcKiRYswceJEXLlyBadOncLevXuL/LyqOgY5OTlyAVl+W1q1asVdHi6s8LRChY8/IOuD/OMPAEuWLMGePXsQGRmJe/fuwdfXF15eXtx3grrfcaoGDllaWuLly5cK3w8Fv4vKmrLv2RcvXmDs2LFlvq3CHj58iKdPn8LBwQG7d+8GILv0GhcXxwXf5ubmMDU1xXfffafy+6xwXyq7d/fnn3/GyZMn8fLlSzx69Aj+/v7w9vbGo0ePVLbP0tISubm5Cu/n2NhYiMVihf5Q5z2ULz+4L9zXFQ0FdVVAQkICdHV1Ub16daXDraOionDhwoVi6yk8XQefLzuR+8MPPyA4OFjpOqmpqdDX11e7rY0bN8aFCxfw7NkzLFy4EJGRkcjKysLgwYOxcOFCbptlqeB+NWzYUOFM2P/+9z+54fzFBS4AkJmZqfDh5vP5iI2NxcSJE5WuUzDYe/r0Ke7evYtJkybB29sbkyZNQmZmJg4dOqTubqnUpk0bAFV7mhFl9PT08L///Q+ALCgyNDQs1yloVI26+5iTfx86dAjdu3fHhg0bEBwcjNTUVPD5fAQEBKj1WeLz+ZBKpRg0aJDS/Sn4ffLDDz/A09MTX331Fezs7PDHH39g6dKl6Nq1K6Kjo0u9L3w+Hw8fPsTChQuVLi981lWd43/48GFcuXIF9vb2sLOzw+LFi/Hjjz9i5MiR8Pf3V/s7rrRUBQICgaDUdavanrL3YVlsz8fHB8uXL0etWrUgkUgwfPhwHDhwgOuP/GPq7e2tcjqqwvftKfucXrlyBU2aNOHebzNnzsT333+PWbNmwd3dvcg2qht4afIZzg/0VP3TUVFQUFcF5I+WtLa2LvK/GE29evUKAJCSklJkUBgXF4e0tDS50Zb5WrRoIfd62LBhMDAwwPDhw+W+pAtfWgFUfzAjIiIU6gWAli1bcstVeffundzoKQAICQlRWV4Tr169Qr9+/XDt2jW1Lvd6eXnB1dUVdevWxYQJE3DmzBmVZwQ0MXnyZEilUpw7d67UdWkqIiICffv2hZGRkdzZOmX9VdZWr16Nzz77DIsWLYKLiwt+++037ikZ2pD/PmzWrJncmQgzMzO50anK5H/22rRpo/KzZ2Jign79+uHnn3/G2rVruXxll6tUfZZevXoFPp8PkUik9AxQYY8fP8bjx4/xyy+/oFu3brh+/TpmzZqFlStXKi1f8BgUHI2po6MDa2truc/eq1ev0K5dO7X+AdXEu3fvsGPHDuzYsQPm5ua4f/8+li9fDn9/f7W/41SJiIhA27ZtwePx5I5x4e+i/LO4BUfBA8rP5BUXkCj7nm3evLncP6tisVjpJcTC2yvJWScfHx+sWrUKo0aNQmxsLIyNjeWmeoqLi0NKSgoEAkGp+zJ/9LynpyeMjIwQFBSEVatWqQzqIiIiIBAI0KxZM7lZBGrXrg1TU9Mi/zYUx9raGnFxcRU+qKN76qqAGzduAJDdv1KW7t27h7CwMPzwww8Kl0mB/+4tkEqlCAgIwIgRI9CwYUNuecuWLRWmGMj/z6jgf0I1atRQel/Vhw8fFL4EAcDX1xdffvklN7oPkM0T9+2330IkEimMWiooMzMTFy5ckEtlEUgBsrMmOjo6Sv/ACQQChcthBw4cAGMMW7duRZMmTbB3795St+HHH3/EgAED4OPjo5Uzdb6+vtDV1YWjoyOXx+fzMXfu3HLdbpcuXfDDDz9gy5YtcHV1xYYNGzBnzhz06tWrXLdblPPnzyMrK0th3xcsWFDsuvfv38fr16+xYMEClZdRlX2WVNWfH2AX/jwdO3YMOTk5KqexyA8+hUKhwlmeR48eITc3t8gz9Xfv3sX79+8xa9Ys6OrqcvnTpk1TuMR16NAhNGjQAN98841CPQYGBqhWrZrK7SjD5/MV7tGNi4vD27dvuTar+x2niq+vLywsLODg4MDlCQQCzJ07FxKJhLsCEBERgZycHIX3o5OTk0Kd+X2lqt9HjBiBevXqca+/+OILdO3aFX5+flzeq1ev0LJlS7n2t23bFj169JCrK/82HGXfs6o8e/YMDx8+hIODAxwcHPD27VsEBQVxy6VSKY4ePYpRo0YpTLUCqH9PWuF/fD58+ICwsLAi32++vr4AFD8D+Wd/C842oKlOnTpxf2srMjpTVwWIRCI8evQI/fr1K9P7iBhjmDlzJvz8/BAaGgoPDw9ER0ejfv366N27N1JSUjB8+HAAsvmCBg4ciCtXrsDNzQ06OjqYO3cuQkND0a5dO67Os2fPIjMzE6dPn8auXbtQvXp1fPPNN3j//r3cFxUg+8J1dHTE8uXLERYWhvfv3yMwMBC//fYbxo8fDz8/P/zxxx9ITEzE1KlTYW1tjVGjRmntnoegoCDs3LkTy5YtQ/v27XH27FlkZ2ejWbNmGDNmDObPn4+jR49y5ePj4+Hv74+xY8dCLBZr9IWjo6PDXeY1MDCApaUlhg8fjnbt2uHixYsq5wgsrUGDBnFnIQq6fv06N+/T1atX8dtvv8HKygpPnjzByJEjlf6BsrS0RHh4eKmnNNHX18eePXvw8uVLLF++HIDs/Ths2DB4eHjg888//6gTQ+eLj4/Hxo0bsWzZMvz777/w9fVFhw4dMGjQIJX3XeZjjMHR0RGnT59GcHAwPDw8EBMTg5YtW6J169YYOHAgFzQsWbIEurq6iI6Ohp2dHTefYkH5txP88ssvOHjwILKzs3H69Gm8fv0aK1as4PrrxIkTkEgksLa2hr29Pf766y9s2rQJffr0wZ9//onDhw/jxYsX0NHRweTJk5Gbmyv3ni4sJycHK1aswF9//YWLFy/Cx8cH1tbWmD59OneWLJ+3tzfGjh2LnTt3onfv3rh27RoEAgFatmyJsWPHYsCAARpNfC0UChEVFYUjR44gJCQEqamp6NevH7p06cL9kdfkO06Zv/76C9999x08PT3RqVMnhIeHY/To0ejZsyfmz5/PXbpNSUnB4cOHMXfuXDDG8OrVKwwdOlTp4wfz9/GPP/5AQEAAcnNz5QYhhIWF4erVq9ixYwf09fW5aWp+//13rszu3buxcOFCBAQEwN3dHbVr18asWbMQGhoqF+jmzxPq4OCAFy9eIDExEY8fP5a7J1kZHx8frFmzBhkZGXB3d1f4zv3pp5/Qu3dv3Lp1C3///TeePHmCmjVromPHjujXr5/CtEjKPHnyBJcuXcK9e/eQmJiIzp07c9PTqPLw4UN4enriu+++g4mJCS5fvowuXbpg2rRpOH78OC5dulTsdpUxNzdH27ZtlT5lpyLS+hBcSqVPCxYsYCkpKQrDwhlTnLaicMofVq5quoJ27dqxI0eOsLi4OJaens5EIhE7ePAg6927t1w5GxsbdufOHZaRkcHCwsLYt99+qzDkHAAbOnQoCw4OZmlpaez169ds8eLFbNq0aQpTLtSuXZudPn2aJScnK0x/YG1tzQ4dOsQSExNZWloau3nzJhs8eLBG+1U45U9V0alTpyLLFTelyMyZM9mdO3fYhw8fWHJyMgsJCWG//fYbq1u3rkLZ0aNHM8YY27lzp9p9nT+lSr7U1FT2+vVrdvjwYTZy5EhuSpeCqTynNGFMfkoGU1NTtmfPHpaUlMTEYjHbs2cPNyVGwXKtW7dmjClODaNpyp9K5IsvvpDL79ixI8vKymLbt28vVf2qpjQp/D5RNm0Fj8djK1euZNHR0ezDhw/s4sWLrFWrVgp1qpryonv37iwgIIAlJycziUTCgoOD5absqFevHjt69ChLTExkYrGY+fj4sLp16zLGFKepWL58OYuMjGQ5OTkKnzV7e3sWFBTEJBIJk0gk7MmTJ2zbtm2sWbNmDACzsrJi//zzD3v58iVLS0tj8fHx7MKFC6xPnz5qHcNZs2axV69esfT0dHb79m3Ws2dPpe9JHR0dtnjxYvbo0SOWnp7OEhIS2J07d9jKlSuZUCgs8r1buK90dXWZi4sLe/DgAXf8Hjx4wGbNmqWwnrrfccqSubk5c3d3Z+/fv2cZGRksJCRE7n2en2rVqsUOHz7MUlNTWUJCAtuxYwdr1aqVwueCz+ezrVu3stjYWJabm8t9fxb8bH7//fcsIiKCpaens8uXL7PPP/9cYXsTJkxgYWFhLCMjg92/f5/1799fYUoTAKxr167c97ay942y1KRJE+6z3717d5XHZdu2bSwiIoJlZmayt2/fsnPnzrGZM2cqvO+VfUcvW7aM3bx5kyUmJrIPHz6wJ0+esKVLlzIdHR2ujLK/LwKBgK1cuZK9evWKZWZmsoiICPbLL78wPT09hfeKsilTlL0vv/vuO5aamspNUVPBk9YbQKkMUo0aNVh8fDybMWOG1ttCSf2UP69bwbmSqmJSNh+Xo6Mjk0gkrHbt2lpvHyVKFT2p+oeLUvmn+/fvM1dXV623Q51E99RVESkpKfj999+xePHijzr6jpTON998g1evXsnNlfSp6N27N/744w+NZsEnhJCPacCAAWjWrBnWr1+v7aaohe6pq0J+//13ufsqSMXl4OCAtm3bYujQoXLP8vyUfIx5tQghpDQCAgLKZSL38kJBHSFacPDgQUgkEvzzzz/c824JIYSQ0uBBdh2WEEIIIYRUYnRPHSGEEEJIFUBBHSGEEEJIFUD31H0E9erVK5eHqxNCCCGk6hEKhXj79q3G61FQV87q1atXJg+7JoQQQsino379+hoHdhTUlRMnJyfMnj0bfL7sCnf9+vXpbJ2WCAQC9O/fH+fOneOel0kqFuqjyoH6qeKjPqr4iusjoVCI6OjoEsUMFNSVEzc3N7i5uUEoFCIlJQUSiYSCOi0RCARIT0+HRCKhL7kKivqocqB+qviojyq+8uwjGihBCCGEEFIFUFBHCCGEEFIF0OVXLdPR0YGFhQV37x0pewKBAGZmZrC0tKTLERUU9VH5kkqliImJQU5OjrabQggpRxTUaVHt2rWxbt06GBgYaLspVZ6hoSH69Omj7WaQIlAfla+MjAwsX74ccXFx2m4KIaScUFCnJTweDzNnzkRqaio2btyIzMxMbTepShMKhTRQpYKjPio/+vr6mDVrFr755husX78ejNHTIQmpiiio0xITExO0bNkSbm5uePHihbabU+UZGxsjOTlZ280gRaA+Kl+HDh2Ck5MTjI2NkZSUpO3mEELKAd3IpSVCoRAA8P79ey23hBDyKcj/rqlRo4aWW0IIKS8U1GkJj8cDALopnBDyUeR/1+R/9xBCqh4K6tRkaGiI8PBwbNiwQdtNyVMNAMtL1bTcFuUeP36MIUOGaLsZhBBCSAk5A1ihZtkVeeW1h4I6NS1fvhw3b97UdjMKKNh1NijPrmzevDlOnTqFuLg4JCcn4+nTp1iyZEmx67Vp0wZnzpwBANja2oIxBolEgpSUFISHh2Pt2rV01oAQQkgFlgtgLYoP7FbkldPu1TcK6tTQtGlTtGzZEn5+ftpuSh57AE8LvPYHEJ6XX/bOnDmDkJAQNGrUCKamphg1ahRev36tcT1JSUkQCoWoUaMGhg4dim+++QZff/11ObSYEEIIKQvrAKzEf4EdH4AtgHF5P/n4L6BbmVdee6p8UGdjY4NTp04hOjoajDF89dVXCmWcnJwgEomQnp6Omzdv4osvvpBbvnHjRixduvRjNbkY9gCOAKhXKL9+Xn7ZBna1atVC06ZNsWvXLqSnp0MqleLJkyc4cuQIANmAj23btiE8PBzJycm4ffs2GjRoAAAQiURKjzcguzR75coVtG3bFvPmzUNgYKDccgcHB4SGhpbpvhBCCCGaKxjYJQK4BOBA3s9EVJSADvgEgjojIyOEhIRg9uzZSpePHTsWrq6uWL16NTp27IiQkBAEBATA3NwcADB8+HC8ePECL1++/JjNVoEPYGuB3wsvA4AtSpaVXEJCAp49ewYPDw+MGTMGjRo1klvu6emJpk2bolu3bjAxMcG3336L9PT0Yutt27YtevXqhfv372Pv3r348ssvYWVlxS2fPn06PDw8ymw/CCGEkJILBSAFYFwo3zgvv2KchKjy89T5+/vD399f5fKFCxfi77//hqenJwBg1qxZGDJkCGbMmAEXFxd07doV48aNw5gxY1C9enXo6uoiJSUFa9euVVqfnp4e9PX1udf5U5cIBAIIBAIuv+Dv6rMB0LCI5XwAjfLKXS5B/cr973//w+LFi+Hs7IyWLVvi+fPnmD9/Ph4+fIiRI0eiUaNGiImJAQAEBwerrMfExARisRiMMbx//x7btm3jjvupU6cwdepUrF69GvXq1YOtrS2mTp1aJu3Pv2+Px+PRpKsVFPXRx1P4u0jTdfl8fonXJ+WP+qjsMcaHVLq1mFJbwOf/Cx5PWmx9xfVRafquygd1RdHV1UWnTp2wfv16Lo8xhvPnz6Nbt24AgGXLlmHZsmUAgKlTp6JNmzYqAzoAWLp0KVatWqWQ379/f7kzWGZmZjA0NIRQKISxceHIX7msrCZQ4yQYDA2bQE8vWK061ZGRkYG1a9di7dq1MDExwQ8//IDjx49j+PDhyMjIQEpKitJ94PP5MDIygrGxMapXr47k5GS5s3EAuPV8fHzg6uqKLVu24Ntvv0VgYCAyMjLUPjbFMTIyKpN6SPmhPipfQqEQhoaG6NWrF+Lj40tUh0AgQMeOHcHj8Wg6pgqK+qjsxce3wc2bxZ9Q6dJlEczMHhdbX3F9ZGhoWOK2ftJBnZmZGXR0dBAbGyuXHxsbi5YtW5aozvXr18PV1ZV7LRQKER0djXPnzsk9AsnS0hJ9+vSBRCLRYBb9V2qVSk9/hfT08pmZPzk5GUuXLsWcOXPw4cMHGBgYQCgUIioqSqGsVCrFhw8fkJycjNTUVDDGVO7riRMnsGXLFrRv3x4ODg5YunRpmT1dIP8sUEpKCp0FqqCoj8qfiYkJ0tPTERQUhIiIiBLVIRAIwBiDv78/BQwVFPVR2ZNK1Zuw+9atN+Dzix9QWVwf5V/hK4lPOqjT1J49e4otk5WVhaysLDg5OWH27Nng82X3t+Xm5sp1Xsk+bFcAREI2KELZfXNSAFF55cqGiYkJFi1ahL179+Lly5fQ19fHwoULkZCQgMePH+PEiRPYuXMnZs6cidjYWLRr1w5v3rxBYmKiRtthjMHDwwNbtmxBzZo18e+//5bZPuQHCRQsVFzURx9P4e8iTUml0lLXQcoX9VFZi1arFGPRah/zovqoNP1W5QdKFCU+Ph45OTmoU6eOXH6dOnXw7t27UtXt5uaG1q1bo0uXLqWqR54UwPwCvxdeBgALlCwruaysLNSvXx++vr5ITk7Gmzdv0KNHDwwaNAhpaWmYOnUqIiMjcffuXSQlJWHnzp0lPnXs4eGBtm3bYu/evcjJySmzfSCEEEJK7gqA4q4cJaEsT6iU1Cd9pi47Oxv37t1D3759cfLkSQCyy0B9+/bFn3/+qeXWqXIcwGgAfwBoUCA/CrKA7niZbi0tLQ0zZsxQuTwlJQWOjo5wdHRUWGZtbc39fvnyZZiamha5rffv3yMtLQ27d+8ueYMJIYSQMrUM/41yBeTPh+XnmeSV0+60JlU+qDMyMkLTpk2519bW1mjXrh0SExMRGRkJV1dX7NmzB3fv3sXt27exYMECGBkZlXo6jcKXX8vWcQDnAOTfozcw73XZnaHThrlz5+LBgwc0Px0hhJAKouDEwqGQTStWcNBE/gmV1nnlAG0GdlU+qOvcuTMuXbrEvd68eTMA2fxq06dPx6FDh2Bubo41a9agbt26CA4OxsCBA/H+/ftSbdfNzQ1ubm4QCoVISUkpVV3KpQKoGo/Y4vP5SEpKQnx8PEaNGqXt5hBCCCF5BJCfWPgkZNOGWQCIgeySqxT/XSXT7lQyVT6ou3z5crHPF92+fTu2b9/+kVpECpNKpahRQ73RRYQQQsjHs7rQaylUzwNLT5SospycnBAaGorbt29ruymEEEII+QRQUFdOymf0KyGEEEKIchTUEUIIIYRUARTUlRO6/EoIIYSQj4mCunJCl18JIYQQ8jFRUFdJVQPA8lI1LbeFEEIIIdpHQV0lVbDjbEAdWRFMnToVDx48KNdtLF26FPv37y+3+r/88kvcuHGj3OoHAJFIhK+++qpc6p4wYQL27t1bLnUTQkhFR7FAOSnPe+rsATwt8NofQHhefnno0aMHfH19kZiYCLFYjODgYCxevBi6urrFruvh4YHMzExIJBKIxWLcuXMHdnZ2cmUK/5Hv3Lkz3r9/j4ULFwIAAgMDYWtrW7Y7VUmtX78eEyZMKLf6XVxc8Msvv8jllab/AwMDMX/+/GLLlZUDBw6gS5cuaN++/UfbJiGEVBQU1JWT8rqnzh7AEQD1CuXXz8sv68BuyJAh8PPzQ0BAAJo1awZTU1M4ODigVatWsLCwUKuO/Cdr1KpVC15eXjhy5IjKyYb79OmDc+fOYcmSJXB1dS3LXSHFaN26NVq0aAFfX18uryz6/2NijGHfvn1wcnLSdlMIIeSjo6CuEuFD9tS5/N8LLwOALUqWlcYff/wBFxcXbN26FQkJCQCA58+fY/r06Xjz5g2OHTsGZ2dnuXV27NgBNzc3hbqkUinc3d0hFArRvHlzheUjRozAsWPHMGPGDHh6eiptj5WVFc6dO4ekpCQkJCTg6tWrMDQ0VFpWKBRi27ZtCA8Px5s3b3D79m00aNAA8+bNQ2BgoFxZBwcH7pmzHTp0wI0bN5CcnIy4uDicOnWKK9ekSRP4+/sjISEBYWFhKs9CLViwABcuXJDLGzt2LJ4+/e8cq4ODA0JCQiAWi3H79m1069ZNaV0FOTs74/hx2eNotmzZAnd3d7nlS5Ysgb+/PwDZWVJ3d3ccP34cEokEISEh6NGjh8q6hw8fjqCgIEil/z1DuDT9v3HjRtjY2MDFxQUSiUQuWGzevDlu3LiBlJQUXLp0CQ0aNOCWFXWM8y9xr1ixArGxsXj37p1CH1y4cAHDhg0r9lgSQkhVxCiVXxIKhYwxxoRCoVy+paUl8/LyYpaWlmrXZQswpkayLaO2N2vWjDHGWOPGjVWWGTJkCHv16hX3Wl9fn4nFYta5c2cGgHl4eLDNmzczAExHR4d9//33LCMjg5mbm3PriEQidujQISYWi1nfvn2LbNO+ffvYjh07mI6ODtPR0WHdunVjurq6SssePXqU+fn5MQsLC2ZiYsLat2/PatWqxWrWrMnS0tKYlZUVV9bf35/98MMPDAC7du0aW7ZsGePxeExPT4/Z2NgwAEwgELCnT58yFxcXpq+vzz7//HMWHR3Nxo8fzwCwqVOnsgcPHjAArHbt2iwzM5M1aNCA28bp06fZsmXLGAA2aNAgFhkZyTp06MB4PB6zt7dn8fHxrGbNmkXuv7OzMzt+/DgDwDp16sSSkpKYgYEBt/zRo0dswoQJ3LFPT09nQ4cOZQKBgH333XcsISGBGRsbK63bx8eHrV69ukz7PzAwkM2fP19uHZFIxEJCQpiVlRXT19dnZ86cYR4eHszY2FitY5yVlcUWLlzIdHR0mK2tLcvKypJrY82aNRljjNWtW7dcPtOVNZXkO6dwEggE3PtJ2/tDifqosqbi+khV3KBOojN1lYi6F7vK6qKYubk5ACA6OlplGT8/P+jr63P3vNnb2yMqKgp3797lyjg6OkIsFiMjIwOrV6/GuHHjEBcXJ1fPgAEDEBoaimvXrhXZpuzsbFhYWMDKygo5OTm4ceMGsrOzFcrVrl0bI0eOxLfffouYmBgwxhAcHIyEhAQkJibi1KlTmDp1KgCgXr16sLW1hbe3N7cNS0tL1KtXD1lZWbhy5QoA2SACCwsLrFixApmZmXj06BH+/PNPTJs2TWH779+/x/nz5zFx4kTuWPbv35/bxuzZs7FhwwY8ePAAjDEcP34cz549w+DBg4vc/4Lu3buHqKgo7n7E9u3bo1GjRtyZPAC4ePEi/v33X+Tm5mLXrl2IjY3F0KFDldZnamqKlJQU7nVZ9b8ybm5uCA8PR2ZmJvbt24dOnToBUO8Yx8fHw9XVFTk5Obh8+TLCw8Pl7qHL3wdTU9Mi20AIIVUNBXXlpDwGSsSUcbnixMfHAwDq16+vsoxUKoWXlxf3R3fatGnYvXu3XJkdO3bA1NQU5ubmuHLlCrp3765Qz7x586Crq4vTp0/DwMBA5fYWL16M6OhonD9/HiKRCM7OzuDxeArlLC0tkZGRgcjISKX17N69G1OmTAEATJkyBWfPnkVsbCwAYMaMGTAwMMC9e/fw9OlTzJ49GwDQoEEDvH37Vi6IfP36tdylw4K8vLwwefJkAMD48eNx/fp1rj1WVlb49ddfIRaLudS+ffsij7Uy3t7ecvtx9OhRpKenc8sjIiLkykdERKjchlgslrvXsaz6X5l3795xv3/48AFCoRCAesc4v5+UrQ+A2wexWFxsOwghpCqhoK6clMdAiSsAIgFIVSyXAniTV64svHjxAiKRCOPGjSuy3O7duzFq1Cg0b94ctra2KqeUEIvFmDlzJhwdHRVGJyYlJaF///6oXr06zpw5o/I+ubi4OMyePRtWVlYYNmwYZs2aBXt7xeEhERERMDAwUBlwnTt3Djo6OrC1tcXUqVPh4eHBLXv9+jWmTp2KunXrYubMmdi4cSM6duyIqKgo1KtXDzo6OlxZKysrREVFKd3GyZMn0aBBA3Ts2BGTJ0/mztIBQGRkJBYtWgRTU1MuVa9eHS4uLkrrUmXfvn3o27cv6tWrh/Hjx8ttA5AFtwU1atRI5Zm34OBgtGzZkntdFv1f8P48dWh6jJVp1aoV3r17Jxc4EkLIp4CCukpECmB+gd8LLwOABUqWlcbcuXPx008/Yc6cOahZsyYAoFmzZvjnn3/QqFEjAEBYWBju378PHx8f+Pn5KVxaLSgmJgaenp5Yu3atwrKUlBTY2dnBwMAAvr6+qFZNcVrlMWPGoGHDhgBkgWBubi5ycnIUyr1//x4nTpzAzp07UbduXfB4PLRv357bB8YYPDw8sGXLFtSsWRP//vsvt+7kyZNRu3ZtbhtSqRS5ubm4ffs2YmNjsWbNGujp6aF169aYO3cu9uzZo3RfMzIycOTIEfzyyy9o1aoVDh8+zC3bvn07Fi9ejI4dOwIADA0N0bdvX43P1EVFReHq1atwd3dHVlaWwgCQPn36YPDgwRAIBJg5cyYsLCxw5swZpXX9+++/sLGxAZ//39dCafs/NjYWTZo0UXt/ND3GyvTp00flPhJCSFVGQV0lcxzAaABvC+VH5eUfV1ijdM6cOYNBgwZhyJAhePXqFcRiMY4cOYJnz54hJua/C73u7u5o37693BkvVX7//XfY2dnhiy++UFgmkUgwYMAA6OjowM/PD0ZGRnLLO3XqhOvXryM1NRU3btyAu7u73OjUgqZOnYrIyEjcvXsXERER2Llzp9wZQA8PD7Rt2xZ79+6VCwz79euHkJAQSCQSnDx5EosXL0ZISAhycnIwdOhQdOrUCe/evcOpU6fg6upa5GTAXl5eGDhwIE6cOIHU1FQu/99//8VPP/2Ev//+G2KxGCKRCPPnz5cLqNSVvw1lZ0j379+Pb775BklJSZg3bx6++uorJCUlKa3n0aNHePnyJQYNGsTllbb/t2zZgn79+kEsFuP06dPF7ktJjnFBPB4PEydOxPbt29UqTwghVY3WR4JU5VSWo18Lpur4b7TrANmIF63up42NDYuJiamwI66Ujfg0NDRkEomEtW7dWuvtK49UcOSxuqlr167sxo0bWul/VaNyNUnjx49ne/fu1fqxr4iJRr9+Gon6qOKn8hz9+t+NK6RSKXiJ9QrK9pKrpnR1dbFo0SL8/fffyM3N1WJLNDN37lw8ePCAm5+OADdv3lRrvryCKlL/HzhwAAcOHNBqGwghRFvo8msllQaAl5fStNiOXr16QSwWw8zMDBs2bNBiS9TH5/ORkpKCWbNmfdRHWKlLIpEoTUuXLtV20xRUxv4nhJCqis7UlRMnJyfMnj27RPdIVSZBQUGoXr26tpuhEalUqvIxZRVBwek5SmP69OllUk9RKmP/E0JIVVW1Iw4tKq9nvxJCCCGEKENBHSGEEEJIFUBBHSGEEEJIFUBBHSGEEEJIFUBBXWVVrRq4meqUPHmBEEIIIZ8WCuoIKUPOzs44fvx4uW5jx44d+O2338qtfgcHB/j4+JRL3ba2thCLxeVSNwAEBASgb9++5VY/IYRUZBTUVVYFp0qxsZF/XcZ69OgBX19fJCYmQiwWIzg4GIsXL4aurm6x63p4eCAzMxMSiQRisRh37tyBnZ2dXBmRSISvvvqKe925c2e8f/8eCxcuBAAEBgbC1ta2bHeqEnN0dMRPP/1ULnXzeDz8+uuvcs/mFYlESEtLg0QiQVxcHE6dOoXGjRsXW5elpSUYYzA2Ni6Xtirzyy+/0Hx5hJBPFgV1lZG9PfD06X+v/f2B8HBZfhkbMmQI/Pz8EBAQgGbNmsHU1BQODg5o1aoVLCws1KrDzc0NQqEQtWrVgpeXF44cOaJynrg+ffrg3LlzWLJkCVxdXctyV4gaBg8ejMTERDx+/Fguf/z48RAKhWjcuDHS0tLg5eWlpRYWLSgoCCYmJujevbu2m0IIIR8dBXXlxMnJCaGhobh9+3bZVmxvDxw5AtSrJ59fv74sv4wDuz/++AMuLi7YunUrEhISAADPnz/H9OnT8ebNGxw7dgzOzs5y6+zYsQNubm4KdUmlUri7u0MoFKJ58+YKy0eMGIFjx45hxowZ8PT0VNoeKysrnDt3DklJSUhISMDVq1dhaGiotKxIJMKyZctw7949vHnzBv7+/lwg6urqqvDw+R9//BG+vr4AgH79+iEkJAQpKSl49+6d3P506tQJV69ehVgsRmhoKMaNG6d0+1u2bIG7u7tc3pIlS+Dv78+9njt3Lp4+fQqxWIzAwEC0bNlSaV0FeXh4YPPmzQCAEydOYOXKlXLL3dzcsHPnTgCys5y///47AgMDkZKSguvXrxe5jeHDh+PixYsql0skEnh7e6Nt27YwMzNDeno6rKysuOX6+vpITExEly5duPd+VFQUJBIJJkyYwJX7+uuv8ebNG8THx8PFxUVuGxMnTsSTJ08gFotx5coVdOjQgVsWGBiIX3/9Ff7+/khJScG9e/fQpk0bufUvXryI4cOHq9wHQgipyrT+cNuqnFQ9mLdED9fm8xnevGHIzWVgTDHl5jJERMjKlUHbmzVrxhhjrHHjxirLDBkyhL169Yp7ra+vz8RiMevcuTMD5B8qr6Ojw77//nuWkZHBzM3NuXVEIhE7dOgQE4vFrG/fvkW2ad++fWzHjh1MR0eH6ejosG7dujFdXV2lZUUiEXv9+jVr0aIFq1u3LvP09GQXLlxgAFjr1q1ZSkoKMzIy4so/ffqUjR49mgFg0dHRbNKkSQwAq1atGuvWrRsDZA+dj4uLY3PmzGE6OjqsV69eTCKRsO7duzMAzNnZmR0/fpwBYJ06dWJJSUnMwMCA28ajR4/YhAkTGADm6OjIgoODWdOmTZlAIGBz585lL1++VLk/+angMR01ahR7/vw5t0xXV5fFx8dz7QkMDGQJCQmsa9euTFdXl61bt449f/5c5YOkb926xaZPn65wHL/66itu/318fNilS5cYAHb48GHm7OzMlR03bhx7/Pgx9x5njDFjY2Nuua2tLcvJyWGbNm1i+vr6rGXLliw1NZXZ2toyY2NjZmNjw1JSUpiNjQ3T0dFh8+fPZ7GxsaxGjRrc/kRGRrK2bdsygUDAdu3axQIDA+Xau3DhQubv76/1z35FSyX6zimU6GHxFT9RH1X8VFwfqYob1El0pq4ysbEBGjZUff8cnw80aiQrVwbMzc0BANHR0SrL+Pn5QV9fn7vnzd7eHlFRUbh79y5XxtHREWKxGBkZGVi9ejXGjRuHuLg4uXoGDBiA0NBQXLt2rcg2ZWdnw8LCAlZWVsjJycGNGzeQnZ2tsvyOHTvw/PlzpKenY8mSJejTpw/q16+P0NBQPHnyBKNHjwYAdO3aFebm5jh16hS3naZNm8LMzAxpaWm4ceMGANnl6Li4OPz555/IyclBUFAQ9u/fj6lTpyps+969e4iKiuLuF2zfvj0aNWrEDaSYPXs2fv75Z4SFhSE3Nxfbtm2DoaEhvvzyyyKPQUGnT5+GmZkZt86QIUMgFotx/fp1rszBgwdx8+ZNZGdnY9WqVahTpw66du2qtD5TU1OkpKQo5O/btw+JiYkIDQ0Fn8/HlClTAADu7u7c7wAwbdo0hTOghfF4PKxYsQKZmZl49uwZrl+/jk6dOgEAJk+ejL179+LKlSvIycnB1q1bIRaLMWTIEG79vXv34uHDh8jNzcWePXu4dfOlpKTA1NS0yDYQQkhVREFdZaLmPWxqlytGfHw8AKB+/foqy0ilUnh5eWHatGkAZH/Ud+/eLVdmx44dMDU1hbm5Oa5cuaL0fqd58+ZBV1cXp0+fhoGBgcrtLV68GNHR0Th//jxEIhGcnZ3B4/FUlo+IiOB+f//+PTIyMrj92b17t1y79+3bh6ysLACy4LRNmzZ4/vw57t+/jzFjxgAAGjRogPDwcLltvH79Gg0aNFC6fW9vby7omTJlCo4ePYr09HQAskvJe/fuhVgs5pKpqanKupTJysrCoUOH5Lbh7e2t8hjk5OQgJiZGZZ+KxWKl9ztOnDgRNWvWRIMGDTBmzBi8efMGgGy0qZ6eHmxtbVGvXj3Y2toqbL+wlJQU7hgAwIcPH7jn3So7viKRSO6YvHv3Tum6+WrUqFGuI2wJIaSioqCuMomJKdtyxXjx4gVEIpHKe8by7d69G6NGjULz5s1ha2uLvXv3Ki0nFosxc+ZMODo6on379nLLkpKS0L9/f1SvXh1nzpxReZ9cXFwcZs+eDSsrKwwbNgyzZs2CfRH3EVpaWnK/m5ubw8DAgDvzeODAAXTu3BmfffYZHBwc5M4wPXjwAKNHj4aZmRnWrl2L/fv3o3bt2oiKipK7hwyQBWdRUVFKt79v3z707dsX9erVw/jx4+UCnsjISIwZMwampqZcMjIywsGDB1XujzLe3t5wcHBAnTp1MGjQIIWgquAx0NHRgYWFhcqzr8HBwWrd15ePMQZPT09MmzYNU6ZMQUBAAN6/fw9AFvBrStPjq0yrVq0QHBys8bYJIaSyo6CuMrlyBYiMBFT9sZRKgTdvZOXKyNy5c/HTTz9hzpw5qFmzJgCgWbNm+Oeff9CoUSMAQFhYGO7fvw8fHx/4+fkpXFotKCYmBp6ennJTZuRLSUmBnZ0dDAwM4Ovri2pKJlUeM2YMGjZsCEAWCObm5iInJ0fl9r777js0b94cBgYGcHFxweXLl7mARiKR4OjRo9i/fz9EIhEXCOjq6mLSpEkwMTEBYwxJSUkAZGe5fH19Ubt2bTg6OkIgEKBnz56YOHGiytGgUVFRuHr1Ktzd3ZGVlYXAwEBu2fbt27FmzRpu0IhQKMTw4cNRvXp1lfujzPXr1yEWi+Hp6Ym7d+9CJBLJLXdwcECXLl2gq6uLn3/+GXFxcbh586bSuk6fPo3evXtrtP3du3dj5MiR+Prrr+XO0sbFxSE3NxdNmjRRu669e/di4sSJ6N69OwQCAebMmYNatWpxA1jU0bt3b/z7778a7QMhhFQFFNRVJlIpMH/+f78XXgYACxaoDvpK4MyZMxg0aBCGDBmCV69eQSwW48iRI3j27BliCpwRdHd3R/v27Yu9nwoAfv/9d9jZ2eGLL75QWCaRSDBgwADo6OjAz88PRkZGcss7deqE69evIzU1FTdu3IC7uzt3H5wyu3fvxoEDB/DixQvUr18fEydOlFuuqt0TJkxAWFgYUlJSsG3bNkyYMAGJiYlISkrCoEGDMGnSJCQkJOCvv/6Co6NjkfcCenl5YeDAgQpnMP/88094enri2LFjSE5OxtOnT+VGiGrC29sbAwcOVBpc7t69Gy4uLkhMTET//v0xYsQI5ObmKq3H19cXZmZmaN26tdrbFolEuHv3LoRCIc6cOcPl599D6efnB7FYjPHjxxdbV1BQEObOnQt3d3ckJCRg3LhxGDRoEJKTk9VqS8+ePZGSkoKrV6+q3X5CCKlKtD4SpCqnMh39mp/s7RkiI+VHvkZEyPK1tJ82NjYsJiamQo24KjxqU1mZhg0bsoyMDFazZk2tt7c8UmBgIJs/f75G64wbN44dPHhQo3Xc3d3Zhg0bStVWVX2kSfL392f9+vXT+nGviIlGv34aifqo4qfyHP2qA1L5HD8OnDsHSCSy1wMHyl6X4Rk6Tejq6mLRokX4+++/VZ4Bqoj4fD5+/PFHHDp0CImJidpuToVx8OBBje7ra9y4MUaPHq0wClUbBg4cqO0mEEKI1tDl12IYGxvjzp07ePDgAR49eoSZM2dqu0kyqakAjydLAQFaC+h69eoFsVgMMzOzSvV4JisrK6SkpMDW1hbLly/XdnPkNGzYEBKJRGkq6eXZ8rJz504EBwfDxcUFYWFh2m4OIYR80uhMXTEkEgl69eqF9PR0VKtWDY8fP8axY8fozE6eoKAgjW/s/1isra1VLgsPD6+w7Y6MjFSYpqOkNB30oKlZs2Zh1qxZ5boNQqouZwC5ANapUXYFAAGA1eXaIlK50Zm6YkilUm5OLX19ffB4vCLnRSOEEELUkwtgLWQBW1FW5JWrPLe3EO2o8kGdjY0NTp06hejoaDDGuNn9C3JycoJIJEJ6ejpu3rypMCrT2NgYwcHBiIqKwoYNG7hnoBJCCCEltw7ASvwX2PEB2AIYl/eTj/8CupVQ74we+ZRV+aDOyMgIISEhmD17ttLlY8eOhaurK1avXo2OHTsiJCQEAQEB3COyACA5ORnt27eHtbU1JkyYgNq1a3+s5hNCCKnSCgZ2iQAuATiQ9zMRFNARTVT5e+r8/f3h7++vcvnChQvx999/w9PTE4DsHqEhQ4ZgxowZcHFxkSv7/v17hISEwMbGBkePHlVan56eHvT19bnX+fdGCQQCCAQCLr/g76R85V8u5/F4YIxpuTVEGeqjj6fwd5Gm6/L5fPr+KmOMPc17AotxoSXGAKTg85+Cx1PvmFMfVXzF9VFp+q7KB3VF0dXVRadOnbB+/XoujzGG8+fPo1u3bgCA2rVrIy0tDampqahRowZ69eqFHTt2qKxz6dKlWLVqlUJ+//795Z53aWZmBkNDQwiFQhgbF/4gk7JWeBJjUvFQH5UvoVAIQ0ND9OrVi3uus6YEAgE6duwIHo9XqaYvqsgY4+PChR3IyFB9r7ae3g707ZsNHq/4WQ6ojyq+4vpI1WMy1fFJB3VmZmbQ0dFBbGysXH5sbCz3/EtLS0v89ddf3ACJbdu24fHjxyrrXL9+PVxdXbnXQqEQ0dHROHfuHCT588rl1dunTx9IJBK1Z8svqJo+8CHviUxGM4C0TI2r+GTknwVKSUkp97NAzs7OaN++fZHPoy2tHTt2IDk5GT/99FO51O/g4ICRI0fCwcGhzOu2tbXFiRMnYGpqKpf/MfuoIhOJRFiwYAFOnjyp8bqWlpbw9/dHu3btkJWVpbDcxMQE6enpCAoKQkRERInaJxAIwBiDv78/BQxlhDFbSKXmRZTgIyPDHH5+qeDxLhdbH/VRxVdcH5Vm9oMqf09dad25cwcdOnRA+/bt0a5dO/z1119Fls/KylKYWwwAcnNzFVJp8Av8U2fTQv51WevRowd8fX2RmJgIsViM4OBgLF68GLq6usWu6+HhgczMTEgkEojFYty5cwd2dnZyZUQikdwAls6dO+P9+/dYuHAhACAwMBC2trYlbn9+kFBVggVHR8dyC+h4PB5+/fVXuWfzikQipKWlQSKRIC4uDqdOnULjxo2LrcvS0hKMMbXORFe0Pspv++3bt+Xy58+fL/f83ookIiICN27cKHaKGWXfRZokqVRa6jooFTye6t2jLZXWpj6qQqm4PiqpTzqoi4+PR05ODurUqSOXX6dOHbx7965UdTs5OSE0NFThj0JZsO8MPC0wz6//j0D4Vll+WRsyZAj8/PwQEBCAZs2awdTUFA4ODmjVqhUsLCzUqsPNzQ1CoRC1atWCl5cXjhw5gho1aigt26dPH5w7dw5LliyRO+NJPo7BgwcjMTFR4Wz0+PHjIRQK0bhxY6SlpSl9xmxFZ2trq3FAZm1tjdGjR5dTi8renj17MGfOHG03g2gkpvgiGpUjn7JPOqjLzs7GvXv30LdvXy6Px+Ohb9++uHHjRqnqdnNzQ+vWrdGlS5fSNlOOfWfgyAKgnvzVK9Q3leWXdWD3xx9/wMXFBVu3buWmcnn+/DmmT5+ON2/e4NixY3B2dpZbZ8eOHXBzc1OoSyqVwt3dHUKhEM2bN1dYPmLECBw7dgwzZszgBq4UZmVlhXPnziEpKQkJCQm4evWqyvsPRCIRli1bhnv37uHNmzfw9/fnAlFXV1d4eHjIlf/xxx/h6+sLAOjXrx9CQkKQkpKCd+/eye1Pp06dcPXqVYjFYoSGhmLcuHFKt79lyxa4u7vL5S1ZskRu4M7cuXPx9OlTiMViBAYGcpf9i+Lh4YHNmzcDAE6cOIGVK1fKLXdzc8POnTsByM5y/v777wgMDERKSgquX79e5DaGDx+OixcvqlwukUjg7e2Ntm3bwszMDOnp6bCysuKW6+vrIzExEV26dOH+oYmKilJ4GsbXX3+NN2/eID4+XmFA0sSJE/HkyROIxWJcuXIFHTp04JYFBgbi119/hb+/P1JSUnDv3j20adOmmCNWcr/++ivWrVun8sZlxhjatWvHvS58Jo8xhtmzZyM0NBSpqanw8vKCiYkJDh48iOTkZNy/fx8tWrSQq7N169a4d+8ekpOT5d6zAODi4oLw8HCkpKQgNDRUIeC8du0aGjRooNb7iFQUVwAUdwtOUl45Qoqn9YfblmcyMjJi7dq1Y+3atWOMMbZgwQLWrl071rBhQwaAjR07lqWnp7MpU6awli1bsp07d7LExERWu3btUm3XycmJhYaGsqdPnyp9MG9JHq7N54G9+QMsdy8Y26eYcr3BIrbKypXFsWvWrBljjLHGjRurLDNkyBD26tUr7rW+vj4Ti8Wsc+fODADz8PBgmzdvZgCYjo4O+/7771lGRgYzNzfn1hGJROzQoUNMLBazvn37Ftmmffv2sR07djAdHR2mo6PDunXrxnR1dZWWFYlE7PXr16xFixasbt26zNPTk124cIEBYK1bt2YpKSnMyMiIK//06VM2evRoBoBFR0ezSZMmMQCsWrVqrFu3bgyQPXQ+Li6OzZkzh+no6LBevXoxiUTCunfvzgAwZ2dndvz4cQaAderUiSUlJTEDAwNuG48ePWITJkxgAJijoyMLDg5mTZs2ZQKBgM2dO5e9fPlS5f7kp4LHdNSoUez58+fcMl1dXRYfH8+1JzAwkCUkJLCuXbsyXV1dtm7dOvb8+XOVD5K+desWmz59usJx/Oqrr7j99/HxYZcuXWIA2OHDh5mzszNXdty4cezx48fce5wxxoyNjbnltra2LCcnh23atInp6+uzli1bstTUVGZra8uMjY2ZjY0NS0lJYTY2NkxHR4fNnz+fxcbGsho1anD7ExkZydq2bcsEAgHbtWsXCwwMVOv9bGtrq3bZ/LbXrFmTPX78mH377bcMAJs/f75cHYwx1q5dO+61suVnz55lpqamzMLCgr17946FhISwHj16MIFAwHbv3s1Onjyp9D1raGgo954FwCZMmMDMzc0Zn89nDg4OLD09nVlZWcm1/eHDh2zcuHFK90nT75zCiR4WXx5pBQMYA3LzEiuQCuatoD6qIqm4PhIKhUrjBjWT9newPJOtrS1TxsPDgysze/ZsFh4ezjIyMtjNmzdZly5dymz7qjqnJF+wtp8pD+YKJ9vPyqbt3bt3Z4wxpq+vr7IMn89nUVFRzNbWlgGyP+qPHj3ilnt4eLCMjAwmFotZTk4OS0lJYSNGjJCrQyQSseTkZHb16lW5AEhZ8vT0ZCdOnGBNmzYttv0ikYgtXryYAbJgpHbt2owxxurXr88AsJs3b7KpU6cyAKxr164sPj6e6enpMQAsPDycrVq1ipmZmcnVOWHCBPbkyRO5vF27drFdu3YxQD6oA8AeP37MHBwcGADWvn17lpyczAwNDbllw4cPl6srKiqK9ezZs8j9KhjU6enpsYSEBPbll18yAGzEiBHs5cuXXNnAwEC2fft27rWOjg5LSkpiPXr0UFr3ixcv2KhRoxSOY2pqKktMTGRRUVHs8OHDrFGjRgwAGzhwoFxQ7+/vzxYtWsS9x5UFdbm5udwxAMDOnj3LFi5cyIyNjdlff/3F3Nzc5Lb/7NkzNn78eG5/1q9fL/ceTUlJUe/zU4KgztjYmA0fPpxFR0czQ0PDEgV1dnZ23GsfHx+2f/9+7vWgQYNYZGSk0vcsAIX3bOH04MED7p+E/HT16lXm6OiodJ8oqKtoKT+gW8EAewa8yXudnyLy8guWoz7SauLzGWxtGcaNk/3k8zWuozyDuip/+fXy5cvcyNWCafr06VyZ7du3w8rKCgYGBujatWu53AdXFixMyrZccfKnPahfv77KMlKpFF5eXpg2bRoAYNq0adi9e7dcmR07dsDU1BTm5ua4cuUKunfvrlDPvHnzoKuri9OnT8PAwEDl9hYvXozo6GicP38eIpEIzs7ORT62reAov/fv3yMjI4Pbn927d8u1e9++fdyoQXt7e7Rp0wbPnz/H/fv3MWbMGABAgwYNEB4eLreN169fo0GDBkq37+3tjSlTpgAApkyZgqNHj3JT21hZWWHv3r0Qi8VcMjU1VVmXMllZWTh06JDcNry9vVUeg5ycHMTExKjsU7FYrPR+x4kTJ6JmzZpo0KABxowZgzdv3gAAAgICoKenB1tbW9SrVw+2trYK2y8sJSVFbnqfDx8+cKO9lB1fkUgkd0wK3u9acF1ltm/fzh3bf//9Fz179pQ73j169CiyrQBw6tQpiEQizJ8/v9iyyhQcXZ+WlqbwuvAziIt6zy5YsACPHz9GUlISxGIx2rRpAzMzM7n1a9SoAbFYXKK2ko9NgP8mFj4OwArA/wCMz/tpnZefP0ExzT2nVfb2QHg4cOkScOCA7Gd4uCy/gqjyQZ22lMdAiZiksi1XnBcvXkAkEqm8Zyzf7t27MWrUKDRv3hy2trbYu3ev0nJisRgzZ86Eo6Mj2rdvL7csKSkJ/fv3R/Xq1XHmzBmV98nFxcVh9uzZsLKywrBhwzBr1qwipw+xtLTkfjc3N4eBgQGio6MBAAcOHEDnzp3x2WefwcHBQe4euwcPHmD06NEwMzPD2rVrsX//ftSuXRtRUVFy95ABsuAsKipK6fb37duHvn37ol69ehg/frxcwBMZGYkxY8bA1NSUS0ZGRjh48KDK/VHG29sbDg4OqFOnDgYNGqQQVBU8Bjo6OrCwsOCOQWHBwcEa3Y/FGIOnpyemTZuGKVOmICAgAO/fvweAvMlUNaPp8S3O7NmzuWM7dOhQXL16Ve54X7t2Ta16fvzxRyxZsgQ1a9aUy09NTUW1atW41+oOHiqKqvdsjx49sGrVKkyZMoVr/+PHj+X+qdHR0UHTpk0RHBxc6naQj2E15J8UIQVwGcDBvJ8FP0Pr8soTrbC3B44cAQr/Q1y/viy/ggR2FNSVk/IYKHHlGRCZAKj6WymVAm/iZeXKyty5c/HTTz9hzpw53B+0Zs2a4Z9//kGjRo0AAGFhYbh//z58fHzg5+eHuLg4lfXFxMTA09NTbsqMfCkpKbCzs4OBgQF8fX3l/ljmGzNmDBo2bAhAFgjm5uYiJydH5fa+++47NG/eHAYGBnBxccHly5e5gEYikeDo0aPYv38/RCIR94dQV1cXkyZNgomJCRhjSEpKAiA7y+Xr64vatWvD0dERAoEAPXv2xMSJE1WOBo2KisLVq1fh7u6OrKwsuZvot2/fjjVr1nCDRoRCIYYPH65w5qY4169fh1gshqenJ+7evQuRSCS33MHBAV26dIGuri5+/vlnxMXF4ebNm0rrOn36NHr37q3R9nfv3o2RI0fi66+/ljtLGxcXh9zcXDRp0kTtuvbu3YuJEyeie/fuEAgEmDNnDmrVqsUNYNGWa9eu4erVq3BycpLLv3//PiZPngyBQIB27dph8uTJpd6WqvdsjRo1kJubi7i4OPD5fEyfPl1hkEj37t0RHR2NZ8/K8EuAkE8dnw9s3frf74WXAcCWLYrLtED7LSBqkzJgvhcAnmJgJ5XK8hd4y8qVlTNnzmDQoEEYMmQIXr16BbFYjCNHjuDZs2eIiflviL27uzvat2+vMKJUmd9//x12dnb44osvFJZJJBIMGDAAOjo68PPzU3jKQKdOnXD9+nWkpqbixo0bcHd3x6lTp1Rua/fu3Thw4ABevHiB+vXrY+LEiXLLVbV7woQJCAsLQ0pKCrZt24YJEyYgMTERSUlJGDRoECZNmoSEhAT89ddfcHR0LPKMj5eXFwYOHKhwBvPPP/+Ep6cnjh07huTkZDx9+lRuhKgmvL29MXDgQKXB5e7du+Hi4oLExET0798fI0aMUDkPkq+vL8zMzNC6dWu1ty0SiXD37l0IhUKcOXOGy8/IyMDq1avh5+cHsViM8ePHF1tXUFAQ5s6dC3d3dyQkJGDcuHEYNGhQiSboLmtLly5VmDR57ty56NatG5KSkuDi4oI9e/aUejv579nY2Fi596y/vz+OHDmCR48e4e3bt2jdurXC+27KlCnYvn17qdtACCnAxgZo2FB10MbnA40aycpVANq/8bAKp7IcKJGf7DuDRW6THxwRsVWWr639tLGxYTExMRXq5tzCozaVlWnYsCHLyMhgNWvW1Hp7yyMFBgay+fPna7TOuHHj2MGDBzVax93dnW3YsKFUbVXVR5TUS40aNWJPnjzhBvsUTjRQ4tNI1EflkMaNY2Cs+KRk1HlJ+qg0AyU+6ceElScnJyfMnj0b/HI4HXv8LnDuMSDJmwJtoAtw7lHZnqHThK6uLhYtWoS///67VDNhf2x8Ph8//vgjDh06hMTERG03p8I4ePCgRvf1NW7cGKNHj0anTp3KsVWkOG/evEGrVq203QxCqp4YNSd+VrdcOaLLr+WkvCYfzpeaAfAmylLAQ+0FdL169YJYLIaZmRk2bNhQ/AoVhJWVFVJSUmBra4vly5druzlyGjZsqPCoufxU0suz5WXnzp0IDg6Gi4sLwsLCtN0cQggpe1euAJGRxdzQ/kZWTsvoTB0plaCgII1v7P9YrK2tVS4LDw+vsO2OjIws1QOdC9J00IOmZs2aVeyzRgkhpFKTSoH582WjXKVS+Xvr8gO9BQtUB30fEZ2pI4QQQggpyvHjwOjRQOHpoKKiZPnHj2unXYXQmbpyUp731BFCCCHkIzt+HDh5UjbK1cJCdg/dlSsV4gxdPgrqyombmxvc3NwgFAqRkpKi7eYQQgghpLSkUuDyZW23QiU6jUQIIYQQUgVQUEcIIYQQUgVQUFdZ6QJYlZd0tdqSSosxhnbt2lWaevPlT3lSo0aNcqmfz+cjJCREo6dKlDVLS0swxmBsbFyi9SdMmKDyGcSEEFJVUVBXTpycnBAaGorbt2+XzwZ4BX5vVOh1GevRowd8fX2RmJgIsViM4OBgLF68GLq6xUeTHh4eyMzMhEQigVgsxp07d2BnZydXRiQS4auvvuJed+7cGe/fv8fChQsBAIGBgbC1tS3bnarE8qc8Ka97NadMmYKXL18iNDQUADB16lQwxhTmITx+/DicnZ3LpQ2ldeDAAXTp0gXt27fXdlMIIeSjoaCunJTr5MOfAZhT4PVkAAvy8svYkCFD4Ofnh4CAADRr1gympqZwcHBAq1atYGFhoVYd+QNGatWqBS8vLxw5ckTlWaY+ffrg3LlzWLJkCVxdXctyV4iaZs+erfAs3MTERDg6OqJBgwZaapVmGGPYt28fnJyctN0UQgj5aCioq2w+AzAWQOG5aWvk5ZdxYPfHH3/AxcUFW7duRUJCAgDg+fPnmD59Ot68eYNjx44pnK3ZsWMH3NzcFOqSSqVwd3eHUChE8+bNFZaPGDECx44dw4wZM+Dp6am0PVZWVjh37hySkpKQkJCAq1evwtDQUGlZkUiExYsX48aNG4iMjMSlS5cUghJbW1s8e/YMYrEYBw8e5IJNPT09uLu7Iy4uDklJSXj06BE6d+4MANDR0cGvv/6KiIgIvH//HgcPHoSZmZnC9s3NzZGZmYlGjRpxeXp6ekhMTETXrl0ByB6xderUKbx//x7h4eFYvnw5eLyiT7sWvDTZvn17pKSkyB2DunXrIjMzE/Xq1YOtrS3EYjHmzJmDt2/fIiYmBqtWrVJZt4WFBTp06IDLhUZ3vXnzBkePHsXq1auVrpe/nYIKnsnLX+7o6IioqCgkJiZi/vz5aNGiBW7evInk5GTs27cP1apVk6tjzJgxEIlEiI+Px/bt27mzw0ZGRjhx4gRiY2ORlJSEy5cvo23btnLrXrhwAcOGDSvyWBJCSFGcRwIrRqhXdsUIWXltoqCuMuEBGFjg98LLkLe8jC7FNmvWDI0bN8aBAwdUlnF3d8eUKVO41/r6+hg3bhx2796tUFZHRwffffcdMjMzERERIbds4sSJ8PDwwKhRo3C80CSOvXv35oKMX375BWFhYTAzM0OdOnWwePFi5OTkqGzfpEmTMH78eDRt2hQfPnzA2rVr5ZZPnjwZvXv3hpWVFUxNTbFlyxYAskuO7dq1Q9OmTWFiYoKRI0fi3bt3AIClS5di6NCh6NmzJ6ytrbmzQoXFxcXh7NmzmDRpEpc3bNgwxMXF4ebNmzA0NMSFCxdw4cIF1K9fHzY2Nhg3bhymT5+ucn8KCw4ORkREBOzt7eWO5eXLl/H27VsAgFAoRMeOHdGkSRP873//w4wZM+T6rKD27dsjOjoaqampCst+/vlnODg44LPPSvafg1AohJWVFaytrTFmzBhs3LgRGzduxOjRo9GwYUNYW1vju+++k1vH3t4e7du3x+eff47u3btj6dKlAGT3/e3fvx/W1taoU6cOHjx4gEOHDsmt++TJE9StWxd169YtUXsJISRXCqwdU3xgt2KErFyulqeso6CuMrEEYAzVQRsvb7ll2WzO3NwcABBdeAbtAvz8/KCvr8/d82Zvb4+oqCjcvXuXK+Po6AixWIyMjAysXr0a48aNQ1xcnFw9AwYMQGhoKK5du1Zkm7Kzs2FhYQErKyvk5OTgxo0byM7OVlnezc0N4eHhyMzMxL59+xQeOv/7778jJiYGycnJWLlyJSZMmAAej4fs7GwIhUJ89tln4PF4ePnyJaKiogDIAsF169YhMjISHz58wMKFC2FnZ6f0crSXlxcmT57MvZ48eTK8vb0ByC5ti8VibN26FdnZ2YiMjMTWrVs1fr6rsm14eXlxrwUCAX788Uekp6fj+fPn+PPPP+XKF2RqaqryXr2IiAj89ddf+PXXXzVqX0HOzs7Izs7GhQsXkJiYiNOnTyMqKgopKSk4d+4cOnbsKFd+1apVSE5ORkxMDNavX8+1WyKR4NChQ0hLS0NmZiacnZ3RokUL1KtXj1s3fz9MTU1L3F5CyKdt3Qlg5eGiA7v8gG7lYVl5baKgrjJR91GlZfRI0/j4eABA/fr1VZaRSqXw8vLCtGnTAADTpk1TOEu3Y8cOmJqawtzcHFeuXEH37t0V6pk3bx50dXVx+vRpGBgYqNze4sWLER0djfPnz0MkEsHZ2bnIy5X5Z9cA4MOHDwrPVC14xjAiIgL6+vowNzeHt7c3PD09sXPnTsTHx8PDwwO1atUCADRo0ADh4eHcejExMcjIyFB6v9mpU6dQt25dfPHFF6hVqxYGDhzIBXVWVlZo06YNxGIxlzZt2qTxmaV9+/ahT58+qFu3Ltq2bYsmTZrg2LFj3PL09HS5IDoiIkJln4rF4iJH1f7yyy/o3bs3d/lYExKJBBkZGdzrtLQ0xMbGyrWz8PN4C/dPfrsNDAywfft2iEQiJCcnc/1R8DJ4/n4UvixMCCGaKCqwq0gBHUBBXbkpl9GvilfESleuGC9evIBIJMK4ceOKLLd7926MGjUKzZs3h62trcqpJMRiMWbOnAlHR0eFUYlJSUno378/qlevjjNnzqi8Ty4uLg6zZ8+GlZUVhg0bhlmzZsldetSUpeV/pzUbNWqEzMxMxMXFITc3F+vXr0f79u3x2WefoVGjRtz9YVFRUbCysuLWq1OnDgwMDLgzeQVlZmbi8OHDmDx5MsaNG4dbt25xgUpkZCTu3bsHU1NTLhkbG6NNmzYa7cPbt29x+fJlTJgwAZMnT8axY8eQlpbGLTc0NOTOuubvp6qzr8HBwahfvz6MjIyULk9ISMCGDRvg4uIil5+amqrQZ+oOpClK4f7Jb/eiRYvQqVMn9OzZE8bGxlx/FAzwW7VqhXfv3skF9oQQUhLKAruKFtABFNSVm3IZ/RoBIBkAU7Gc5S2PULG8BObOnYuffvoJc+bMQc2aNQHI7rX7559/uAEAYWFhuH//Pnx8fODn56dwabWgmJgYeHp6KtzbBsgul9nZ2cHAwAC+vr4KN80DshvnGzZsCEAWCObm5hZ5T11xFi9eDAsLCxgbG2PNmjU4ePAgGGPo3bs32rVrB4FAgA8fPiAjI4Pbzt69e7Fs2TI0aNAARkZGcHV1xblz5xATE6N0G15eXty9cgUvi/7777+oU6cOHB0doa+vDz6fzwXGmvLy8sLUqVMxYcIEuW0A4AJUAwMDNG/eHLNnz1Z6DyAg65/g4OAi27B582Y0a9YMPXv25PJevHiB7OxsTJgwAXw+H+PGjUOHDh003o/Cfv75ZxgbG8PCwgJLly7l2l2jRg1kZGRALBbDyMhI6SXhPn364MyZM6VuAyGEALLAbe1xWSDH9sl+/nyk4gR0AAV1lQsD4F/g98LLkLdcVdBXAmfOnMGgQYMwZMgQvHr1CmKxGEeOHMGzZ8/kghh3d3e0b99eYSoMZX7//XfY2dnhiy++UFgmkUgwYMAA6OjowM/PT+GMUadOnXD9+nWkpqbixo0bcHd3x6lTp0q8f3v37kVgYCAiIiIgkUgwf/58ALKzbwcOHEBSUhJ3iS9/5Of69esREBCAGzduIDw8HLq6unKDIQq7evUqJBIJWrVqhcOHD3P5Hz58QL9+/dC3b1+Eh4cjISEB+/fvL9GN/ceOHYO1tTWkUikuXrwot0wikSA4OBivX79GUFAQvLy8sGfPHpV1bd++vcjBGmlpaVizZo3cpU6JRIJvvvkGv/32GxISEtCjRw8EBARovB+FnTx5EsHBwXj8+DFu3brFBW+urq7Izc1FbGwsHj9+jBs3bsitx+PxMHHiRGzfvr3UbSCEEACw7wxM6yWf901vWX5FwiiVXxIKhYwxxoRCoVy+paUl8/LyYpaWlprX+xkYFoJhVYH0fV6+lvbTxsaGxcTEMIFAoPVjriwZGxtrvQ3aSLa2tkwsFmu0Dp/PZyEhIaxVq1aVto/Gjx/P9u7dq/XjX5FSqb5z8pJAIGBDhw6tsJ9zStRH5ZXsO4Pl7pUltu+/lOsty7PvXHZ9pCpuUCfpgFQ+TwG8ArAs77U3gNeQdakW6OrqYtGiRfj777+Rm5urnUaQMiOVSsv1MWcfw4EDB4qciocQQtTF5wFbp/z3u9wyPiCVAlsmAyfvAVIt/R3m2qPdzZMSy8J/z359Ba0FdL169YJYLIaZmZnCY6RIye3YsQMSiUQhPX78WNtNI4SQT4pNS6BhLcWALh+fDzQyk5XTNjpTR0olKChIYRoKUnqOjo5wdHQsdT2XL1+medoIIaQUnPqpX+7y0/JtS3HoTB0hhBBCiBIrRgBj1ZyWc2xX9R8pVl4oqCOEEEIIUULAl01bEpkgu3dOGakUeBMvKyfQclRFl1/LiZOTE2bPng0+X3kPMya7CU5Hh7qAEFL+8r9r8r97CCHFW533cJ7HkcCRBbIAruCfdakUAA9Y4A0cv6usho+LIopy4ubmBjc3NwiFQqXP0oyLi0N2djbs7e1x/PjxUk2gS4onFAphYmKi7WaQIlAflR8dHR3Y29sjOzu7yMnBCSHKHb8LjN4iGwXbsNZ/+VGJFSegAyio05r09HRs3rwZ33//Pdq2bavt5lR5hoaGSE9P13YzSBGoj8pXdnY2Nm/eTMeYkBI6flc2bYlNS8DCBIhJAq480/40JgVRUKdFjx8/xpw5c2Bubl7kQ+lJ6QgEAvTq1QtBQUE0j14FRX1UvhhjiIuLo4COkFKSMu2PcC0KBXValp6ejjdv3mi7GVWaQCBAfHw8IiIiKGCooKiPCCGk9Gj0KyGEEEJIFUBBHSGEEEJIFUBBHSGEEEJIFUBBHSGEEEJIFUBBHSGEEEJIFUBBXTEaNGiAwMBAhIaGIiQkBKNHj9Z2kwghRA3OAFaoWXZFXnlCSGWm1pQmc+fO1bhiDw8PpKamarxeRZOTk4MFCxYgJCQEderUwb179+Dr64u0tDRtN40QQoqQC2Bt3u/rIPsf3gaABYAYAFcASCEL6NYCWKmFNhJCypJaQd2WLVsQFRWl9vxRDRs2xL///lslgrp3797h3bt3AIDY2FjEx8ejZs2aFNQRQiq4dXk/1wJoBaAngIYFlkcCuApgPGQB3ToQQio3tS+/du7cGY0bN1YrVaRZy21sbHDq1ClER0eDMYavvvpKoYyTkxNEIhHS09Nx8+ZNfPHFF0rr6tixIwQCAaKiosq72YQQUgbWATgAWeBWv9Cy+nn5B0ABHSFVg1pB3erVqzU66/brr78iMTGxxI0qS0ZGRggJCcHs2bOVLh87dixcXV2xevVqdOzYESEhIQgICIC5ublcOVNTU3h5eeHbb7/9GM0mhJAywIfsDJ0Uil/3/Lz8HkqWEUIqI7Uuv65Zs0ajSn/77bcSNaY8+Pv7w9/fX+XyhQsX4u+//4anpycAYNasWRgyZAhmzJgBFxcXAICenh5OnDiB3377DTdu3Chye3p6etDX1+deC4VCALLHIAkEglLuDSkJgUAAPp9Px78Coz4qH4zZQiptWEQJPoBG4PP/Bx7vcrH1UT9VfNRHFV9xfVSavtP42a8GBgbg8XjcJdZGjRrB3t4eT548wblz50rcEG3Q1dVFp06dsH79ei6PMYbz58+jW7duXJ6npycuXryIvXv3Flvn0qVLsWrVKoX8/v37V6jL0p8SgUCAjh07gsfj0XNFKyjqo/IRHd0LDx4UX65du4GoX79aseWonyo+6qPyxcCQIExApm4m9LP1UUtSCzzwNKqjuD4yNDQscfs0DupOnjyJY8eOYdeuXTA2NsatW7eQnZ0NMzMzLFy4EDt37ixxYz42MzMz6OjoIDY2Vi4/NjYWLVu2BAD06NEDDg4OePjwIUaMGAEAmDx5Mh4/fqy0zvXr18PV1ZV7LRQKER0djXPnzkEikZTPjpAiCQQCMMbg7+9PX3IVFPVR+WAsDcDiYsuFhPjj4UP1ztRRP1Vs1Eflh7VkkNpJAeMCmckA/ywfvGfqB3bF9VH+Fb6S0Dio69ixI77//nsAwOjRoxEbG4sOHTpg1KhRWLNmTaUK6tRx7do1jU6FZmVlISsrC05OTpg9ezb4fNm9Krm5ufQB0yKpVEp9UMFRH5WHS5CNcq0P5ffNSQFEQSq9lPd78aifKj7qo3LwGQBl09TWAKSjpcAhAE/Vr66oPipNv2kc1FWrVo0742RnZ4djx46BMYabN2/C0tJSrTr09PTw5ZdfwtLSEtWqVUNcXBwePHiA8PBwTZtTKvHx8cjJyUGdOnXk8uvUqcNNY1JSbm5ucHNzg1AoREpKSqnqIoSQkpHiv2lLCg+WyH99DeoGdIR8apwhm/Fx3cC8jMIn5HgAGICBwIqngADA6o/YvsI0HvIUFhaGESNGoEGDBhgwYADOnj0LAKhdu3axwUv37t3h4+ODpKQkXLx4EVu2bMHKlSuxd+9ehIWF4cWLF/jhhx9QvXr1ku2NhrKzs3Hv3j307duXy+PxeOjbt2+xAyIIIaTiW4H/pi2JLrQsCv9Nd6LukycI+bTkT+G9IhiKAV0+nmz52rzy2qRxULdmzRps3LgR4eHhuHXrFm7evAlAdtbuQRF35J48eRI+Pj4IDw+HnZ0dhEIhzMzM0LBhQxgZGaFZs2ZYt24d+vbtixcvXqBfv34l36sCjIyM0K5dO7Rr1w4AYG1tjXbt2qFhQ9mIMFdXV3zzzTeYMmUKWrZsiR07dsDIyAgeHh6l2q6TkxNCQ0Nx+/btUu8DIYRoruCTIiYAsALwP8iCuP8BsM7LX5lXjgI7QgpbB2BlbWBtILBCxW2nKy7Llq+sXTFmfGSapjp16rD27dszHo/H5X3xxResRYsWKtf59ttvmY6Ojlr1f/bZZ6xPnz4at0tZsrW1Zcp4eHhwZWbPns3Cw8NZRkYGu3nzJuvSpUuZbBsAEwqFjDHGhEJhmdVJSbMkEAjY0KFDmUAg0HpbKFEffbzkzIAVapZdkVee+kmric9nsLVlGDdO9pPP17gO6qNySFZgK3qDMch+YtV/SS7fqmz6qJRxw8c9OHw+n9nY2DBjY2Ptd9RHSBTUaT/Rl1zFT9RHlSNRP5VjsrdnePOGgbH/0ps3snzqI+0mHhi+B1vxP/nAjgvo/idbDl7Z9FFp4gaNB0ro6+tj7ty56N27N2rXrs2N7szXqVOnIteXSqU4e/YsPvvsMyQnJ2u6+Uqj8OhXQgghRCl7e+DIEcX8+vVl+aNHA8ePf/x2ERkGwB9YN1b2cm0gsCII0M8FVv4PWGcL2ehXpr0m5tM4qHN3d4ednR2OHDmC27dvgzHN9+Lx48do3LjxRx/t+jHR6FdCCCHF4vOBrVv/+73wMqkU2LIFOHlS9jvRjqcADgG/DARWXJEFdJkCYF0HaDydSXnSOKgbOnQoBg8ejOvXr5d4oytWrMDGjRuxcuVK3Lt3Dx8+fJBbTpP0EkII+STY2AANi3iUG58PNGokK3e5+AmiSTl6Cix/CugDyOTJArsVmyvG4Ih8Ggd10dHRpQ66fH19AQCnTp2SO9PH4/HAGIOOjsbNqnDo8ishhJBiWViUbTlSbgqOJ1/H/nsNVJzATuPoadGiRXBxccGsWbPw5s2bEm20d+/eJVqvMqHLr4QQQooVE1O25Ui5kAvo8vLyf1akwE7joO7u3bswMDDA69evkZaWhuzsbLnltWrVKraOoKAgTTdLCCGEVD1XrgCRkbJBEcqu7EilQFSUrBzRCmUBXb6KFthpHNQdOHAA9evXx7JlyxAbG1uigRIA0LNnT3z33Xdo3LgxxowZg7dv32LSpEkQiUS4du1aieokhBBCKhWpFJg/XzbKVSqVD+zyB0YsWECDJLSkqIAuX0UK7DQO6rp3745u3brh4cOHJd7oyJEj4e3tjX379qFjx47Q19cHABgbG2PZsmUYMmRIiesmhBBCKpXjx2XTlmzdKj9oIipKFtDRdCZaI0DRAV2+/OWC8m1OsTS+i//Zs2cwNDQs1UZXrFiBWbNm4dtvv5W7fHvt2jV07NixVHVXFPSYMEIIIWo7fhywsgL+9z9g/HjZT2trCui0bDXUP/O2Lq+8Nml8pu6nn37Cpk2bsHz5cjx69Ejhnjp1Rsa2aNFC6X11ycnJMDEx0bRJFRINlCCEEKIRqZSmLSGlonFQ5+/vDwC4cOGCXL4m05G8e/cOTZs2RUREhFx+z5498fr1a02bRAghhBDyydM4qCuL6Uj+/vtvbN26FTNmzABjDPXq1UO3bt2wceNGrF27tvgKCCGEEEKIHI2DurKYjuS3334Dn8/HhQsXUK1aNQQFBSEzMxMbN27En3/+Wer6CSGEEEI+NWoNlPj888/B4/HUrrRVq1YQCIoeA/Lrr7+iZs2aaNOmDbp27Qpzc3P8/PPPam+joqOBEoQQQgj5mNQK6h48eKDWpML5bty4gUaNGqlc7u7ujurVqyM7OxtPnz7FnTt38OHDB1SrVg3u7u5qb6cic3NzQ+vWrdGlSxdtN4UQQgghnwC1Lr/yeDysXbsWaWlpalWqp6dX5PKpU6fip59+Qmpqqly+oaEhpkyZgq+//lqt7RBCCCGEEBm1grqgoCC0aNFC7Upv3LiB9PR0hXyhUAgejwcejwehUIiMjAxumUAgwODBg/H+/Xu1t0MIIYRUVs4jgVwpsO5E8WVXjAAEfGD1sfJuFanM1ArqymLEKwAkJSWBMQbGGF68eKGwnDEGZ2fnMtkWIYQQUpHlSoG1Y2S/FxXYrRghK7fy8MdoFanMNB79Whq9e/cGj8fDxYsXMWrUKCQmJnLLsrKyEBERgZiYmI/ZJEIIIUQr8gO5ogK7ggGdOmf0yKftowZ1+dOhWFtb482bN0rLNGzYEJGRkR+zWeXCyckJs2fPBp+v8ZPYCCGEfCIKBnY8HhD0DLAwAWKSgF4tgTWjKaAj6vuoQV2+169fw8LCAnFxcXL5NWvWhEgkUuupFBUdPSaMEEKIOtadAFrVlwVwhR24TgEdUZ9WTiOpmvOuevXqcoMnCCGEkKrOvjPg0A2QMvl8qVSWb99ZO+0ilc9HPSW2adMmALIBEWvWrJGbIkUgEODLL79EcHDwx2wSIYQQojV8HrB1yn+/yy3jywK7LZOBk/cUgz5CCitRUDdp0iTMmjUL1tbW6NatG968eYP58+dDJBLh1KlTKtfr0KEDANmZus8//xxZWVncsqysLISEhGDjxo0laRIhhBBS6di0BBoWMbc/nw80MpOVu/z047WLKMcHYAPAAkAMgCsApFptkTyNg7pZs2ZhzZo12LJlC5YvX849DiwpKQkLFiwoMqjr06cPAGD37t2YP38+JBJJCZtNCCGEVH4WJmVbjpQfewBbATQskBcJYD6A41ppkSKN76mbO3cuvvnmG/z666/Izc3l8u/evYvPP/9crTpmzJgBiUSCJk2awM7ODgYGBpo2gxBCCKn0YpLKthwpH/YAjgCoXyi/fl6+/UdvkXIaB3XW1tZ48OCBQn5mZiaMjIzUqsPU1BTnz5/Hixcv4OvrCwsLCwCyZ8LS5VdCCCGfil4tZT+lKq7h5efnlyMfHx+yM3T5vxdeBgBblCzTBo3bIBKJ0L59e4X8gQMH4ulT9S74b9myBdnZ2WjUqJHcYAkfHx8MHDhQ0yYRQgghlc6KEbJpTA5cB8BTDOykUln+geuycitGfPw2Etk9dA2hOmDiA2iUV07bNL6nztXVFdu3b4eBgQF4PB66dOmC8ePHY+nSpZg5c6ZaddjZ2WHAgAGIjo6Wy3/58iUsLS01bVKFRJMPE0IIKYqA/9/EwodvyUbBFhw0EZUILPAGjt8FnkTLypOPz6KMy5UnjYM6d3d3pKenY926dahWrRr279+Pt2/fYv78+fDx8VGrDiMjI7kzdPlq1qyJzMxMTZtUIdHkw4QQQoqy+th/vx+/K5u2xKblf0+UuPLsv2lMaAJi7VH34aUV4SGnJZrSZP/+/di/fz8MDQ1RvXp1hSdDFOfKlSuYMmUKfv75ZwCyeet4PB6WLFmCwMDAkjSJEEIIqdSkjKYtqYiuQDbKtT6UX4KVAojKK6dtpZp8OD09Henp6Rqvt2TJEly4cAGdO3eGnp4efv/9d7Ru3Ro1a9ZEjx49StMkQgghhJAyI4Vs2pIjeb/zCy0DgAWoGPPVaXyFvmbNmvjzzz8RGhqKuLg4JCQkyCV1hIaGonnz5rh69SpOnjwJIyMjHDt2DB06dMDr16813glCCCGEkPJyHMBoANGF8qPy8ivKPHUan6nz9vZG06ZN4e7ujtjYWDBWsueWpKSk4Ndffy3RuoQQQgghH9NxACdRxZ4oYWNjg549e+Lhw4dl0oBq1arBwcEBhoaGOHv2LMLCwsqkXkIIIYSQsiQFcFnbjSiCxpdfnz17BkNDwxJtrGHDhrh06RJSUlJw9uxZNGzYEPfv38c///yDbdu2ITg4GDY2FWGmF0IIIYSQykXjoM7JyQm//PILevXqhZo1a0IoFMqlomzcuBF6enqYNWsW0tLSEBAQgJcvX8LCwgJ16tSBn58fVq1aVdJ9IYQQQgj5ZGl8+TUpKQk1atTAxYsX5fJ5PB4YY9DRUV1lr169MHz4cNy5cwd+fn6Ij4/HjBkz8P79ewDA2rVrceHCBU2bVO6OHTuG//3vf7hw4QLGjBmj7eYQomXOAHIBrFOj7AoAAgCry7VFhBBCShDU7du3D9nZ2ZgwYYLGAyVq166NiIgIAIBYLEZaWhpiY2O55e/evYOpqammTSp3W7duxe7duzF16lRtN4WQCiAXwNq834sK7FbklVtZ7i0ihBBSgqCuTZs26NChA168eFGiDRYMAks6cvZju3z5MmxtbbXdDEIqiPxArqjArmBAp84ZPUIIIaWlcVB39+5dNGzYsMRB3Zo1a7hHhOnp6WH58uVITk4GIBsJW9ZsbGywePFidOrUCfXq1cOIESNw8uRJuTJOTk5YvHgx6tati5CQEMydOxd37twp87YQUnUUDOx4AILw3yD/XgDWgAI6Qgj5uDQO6rZt24atW7diw4YNePToEbKzs+WWP3r0SOW6QUFBaNGiBff6+vXraNy4sUKZsmRkZISQkBDs3r0bx48rTg84duxYuLq6YtasWbh16xYWLFiAgIAAtGjRQuPHnxHyaVkHoBVkAVxhB0ABHSGEfFwaB3U+Pj4AgN27d3N5+c9uLW6gRO/evUvQxNLx9/eHv7+/yuULFy7E33//DU9PTwDArFmzMGTIEMyYMQMuLi4fqZWEVEb2AByg/ME5DgAOo+LMs04IIVWfxkGdtbV1ebRDK3R1ddGpUyesX7+ey2OM4fz58+jWrVuJ6tTT04O+vj73On+aF4FAAIFAULoGkxIRCATg8/l0/MsQY3xIpVvzXhWeGYkPWWC3BXz+v+Dxip9vnfqocqB+qviojyq+4vqoNH2ncVD35s2bEm+sojEzM4OOjo7cCFwAiI2NRcuWLbnX586dQ7t27WBkZITIyEiMGTMGN2/eVFrn0qVLlc61179/f6Snp5dp+4l6BAIBOnbsCB6Ph9zcXG03p0qIj2+DmzcbFlGCD6ARunRZBDOzx8XWR31UOVA/VXzURxVfcX1U0gc8AGoGdcOGDYOfnx9ycnIwbNiwIsuePn26xI2pqPr376922fXr18PV1ZV7LRQKER0djXPnzkEikZRH80gxBAIBGGPw9/enL7kyIpXWUKvcrVtvwOf7FVuO+qhyoH6q+KiPKr7i+qi4BzkURa2g7sSJE6hbty7i4uJw4sQJleWKu6euoomPj0dOTg7q1Kkjl1+nTh28e/euRHVmZWUhKysLTk5OmD17Nvh82aWp3Nxc+oBpkVQqpT4oU9FqlWIsWu1jTn1UOVA/VXzURxVfUX1Umn5T6zFhAoEABgYG3O+qUmUK6AAgOzsb9+7dQ9++fbk8Ho+Hvn374saNG6Wq283NDa1bt0aXLl1K20xCKqBeeT9V3S8nLVSOEFIsHgArAG3yfvK02RhSGan97FeRSARzc/My2eiAAQPQo0cP7rWTkxMePHiAffv2wcTEpEy2kc/IyAjt2rVDu3btAMgGerRr1w4NG8ruB3J1dcU333yDKVOmoGXLltixYweMjIzg4eFRpu0gpOpYAdk0JgfyXhcO7PJfH8grt+IjtYuQSuwzAAsATAMwOu/ngrx8QtSkdlDH45XdvwwbNmxAjRqye3LatGmDTZs2wdfXF9bW1nL3o5WFzp07Izg4GMHBwQCAzZs3Izg4GGvWyObWOnToEH744QesWbMGwcHBaN++PQYOHMg9j7aknJycEBoaitu3b5d2FwipYASQTSw8AbK/PoUvxUbl5U/IK0ej8CoEPh+wtQXGjZP95Kv99U/K22cAxgIofKtqjbx8CuyImjS6XlpWj/WytrbGkydPAACjRo3Cv//+i+XLl6NDhw7w9fUtk23ku3z5crEB6fbt27F9+/Yy3a6bmxvc3NwgFAqRkpJSpnUTol2rC/x+HMBJADb474kSV/Df2TqagLhCsLcHtm4FGhYYsRwZCcyfDyiZlJ18RDwAAwv8XngZy1v+LO93QoqgUVC3du1a7hFfqixatKjYerKysrhHgvXr1w9eXl4AgMTERO4MHiGkspACuKztRhBV7O2BI0cU8+vXl+WPHk2BnTZZAjAuYjkvb7klgPCP0SBSmWkU1H3++efIyspSuVzdM3lXr16Fq6srrl27hi5dusDBwQEA0Lx5c0RFRWnSpAqr8OhXQgj56Ph82Rm6/N8LL5NKgS1bgJMnZb+Tj696GZcjnzSNgjp7e/syeR7qnDlz4ObmhtGjR8PR0RFv374FAAwaNKjIR3pVJnT5lRCidTY28pdcC+PzgUaNZOUu09lWrUgt43Lkk6Z2UFdW99MBQGRkpNJJjBcuXFhm2yCEkE+ehUXZliNlLwJAMmSDIpTd/s0ApOSVI6QYagd1pR39KhQKuScqFDdbclV48gJdfiWEaF1MTNmWI2WPAfCHbJQrg3xgl38uxR80SIKoRe2gbvr06UhOTi7xhsRiMSwsLBAXF4ekpCSlZ/54PF6leyqFKnT5lRCidVeuyEa51q+vfAoTqRSIipKVI9rzFMAhyEa5Fhw0kQJZQPdUG40ilZHa0VP+CNWS6tOnDxITEwEAvXv3LlVdhBBC1CCVyqYtOXJE9nvBwC5/YMSCBTRIoiJ4Ctm0JZaQDYpIheySK52hIxr4aKfEgoKClP5OCCGkHB0/Lpu2pPA8dVFRsoCOpjOpOBho2hJSKpX/OmcFRffUEUIqjOPHZdOW2NjIBkXExMguudIZOkKqFArqygndU0cIqVCkUpq2hJAqrkSnkYyNjfH111/j119/hampKQCgQ4cOqFevXpk2jhBCCKmqnAGsULPsirzyhBRF46Du888/x4sXL/Djjz/ihx9+gImJCQBg5MiRWL9+vVp1NGzYEPr6+ppumhBCCKkycgGsRfGB3Yq8crnl3iJS2Wkc1Lm6usLT0xPNmzdHRkYGl+/r64tevXoVuz6Px0NYWBgaFjXLOSGEEFLFrQOwEkUHdvkB3cq88oQUReOg7osvvsCuXbsU8qOjo1G3bt1i12eM4eXLl6hVq5amm65UnJycEBoaitu3b2u7KYQQQiqoogI7CuiIpjQO6jIzM1GjRg2F/ObNm6v9XNiffvoJGzZsQOvWrTXdfKXh5uaG1q1bo0uXLtpuCiGEkApMWWBHAR0pCY1Hv546dQo///wzxo4dC0B25q1hw4ZwcXHB0aNH1arDy8sL1apVQ0hICLKyspCeni63vKqfxSOEEEIKyg/c8gM7fVBARzSncVC3aNEiHDlyBO/fv4ehoSEuX76MunXr4saNG1i+fLladSxYsEDTzRJCCCFV2jr8F9BlggI6ojmNg7qUlBTY2dmhR48eaNu2LapXr4779+/jwoULatdR2keOEUIIKZrzSCBXCqw7UXzZFSMAAR9Yfay8W0WKUjCg0897TYEd0USJJx++du0arl27VuINN27cGNOnT0eTJk0wf/58xMXFYeDAgXjz5g2ePHlS4noJIYTIArq1Y2S/FxXYrRghK7fy8MdoFVGl8D10+a8BCuyI+jQO6ubOnas0nzGGjIwMhIWFISgoCNIiHj/Tq1cv+Pn54dq1a+jVqxeWL1+OuLg4tGvXDl9//TXGjBmjabMIIYQUkB/IFRXYFQzo1DmjR8qHskERBe+xK/iakKJoHNR9//33MDc3R7Vq1SAWiwEApqamSEtLQ2pqKmrXro3Xr1+jd+/eiIqKUlrHb7/9hhUrVmDz5s1yj9C6ePEi5syZU8JdqVjo2a+EEG0rGNjxeEDQM8DCBIhJAnq1BNaMpoBO24oa5UqBHSkJpkkaN24cu3jxImvcuDGX16RJE3b+/Hk2duxYVr9+fXblyhV2+PBhlXVIJBJmZWXFALCUlBRmbW3NADBLS0uWnp6uUXsqehIKhYwxxoRCodbb8qkmgUDAhg4dygQCgdbbQon6SBtp/2wwtk8x7Z9N/aTNtAJgLO9nWZSjPqocqbg+Kk3coPFppHXr1uH777/H69evubxXr17hhx9+wPr16xEdHY0lS5agR48eKutISkqChYWFQn6HDh0QHR2taZMIIYSoYN8ZcOgGSJl8vlQqy7fvrJ12EUAA9aYtyZ/HTlDuLSKVncZBnYWFBXR0FK/a6ujocE+UePv2LYRCoco6Dh48CBcXF9SpUweMMfD5fHTv3h0bN26kkbGEEFJG+Dxg65T/fpdbxgfAgC2TFZeRj2M11L+kui6vPCFF0TioCwwMxK5du9C+fXsur3379tixYwcuXrwIAPj8888hEolU1rFs2TI8e/YMkZGRqF69Op48eYKgoCBcv34d69bRXQOEEFIWbFoCDWupDtr4fKCRmawcIaTy03igxNdffw1vb2/cu3cP2dnZskp0dHDhwgV8/fXXAIDU1FQsWrRIZR3Z2dn49ttvsXbtWrRp0wbVq1fHgwcPEBYWVsLdIIQQUpiFSdmWI+WLD8AGgAWAGABXAKieR4IQRRoHdbH/b+/O46Oq7v+Pv2aGRQgBFzQsEgSRxWhBQL5FCKB8pVj8ClFWa6VF2x8FrSmuYCiyKCrIUiW18lVApXwLSAp8raGgEPlSYgAxhcgmBshGBFnCErbM+f1xJyF7JslMZsn7+Xicx8yce+bez8xJwodz7zk3O5sBAwbQoUMH2rdvD8C+ffvYv39/QZtNmzaVu482bdqQmppKWloaaWlplQ1BRETckHXKs+3Ee6KA+UCrQnVpwDNAnE8ikkBU5cWH9+3bx759+6r03u+++4709HQSEhLYtGkTCQkJHDx4sKqhiIhIKfq4Tqs6na5r6IrJr+/TERL21GxsclUUsLKU+pau+qEosRP3VCmpa9myJQ899BDh4eHUq1evyLbyTrvma9WqFf369aNv37688MILLFy4kMzMTBISEti4cSPvv/9+VcISERGXmCHWOnTL/uWa/VossXM6AZu1fdpQMEbr1fmCHWuELv958W1OYB6wGp2KlYpVOqm77777WLNmDd9//z0dO3Zk9+7d3HLLLdhsNr7++mu39pGZmclf//pX/vrXvwLQrl07Xn75ZX7xi18wcuTIoEjqtPiwiPiSw351YeEVX1mzYFvdcHV7+gmI/gjitsO3GVZ7qXmRFD3lWpwdCHe1S6iRiCSQVTqpmzlzJrNnz+aVV14hJyeHRx55hB9++IGlS5cSHx/v1j4aNGhA79696devH/369eOuu+5i7969vPPOOxVejxcoYmNjiY2NJTQ0tMhdM0REasLUVVefx22H1TusWa75d5TYvPfq2nUaofOdkiu2Vq+d1G6VTuo6derEqFGjALhy5QoNGjTg3Llz/PGPf2T16tW8++67Fe7j1KlTnDx5kqVLl/L666+zefNmTp06VengRUTEPU6j6+b8UZaH20ntVukB93PnzhVcR5eVlcWtt95asK1p06Zu7eMf//gHDoeDkSNHMnLkSIYNG8Ztt91W2VBEREQC2masWa5lXS/nBI642olUpNJJXWJiIr179was5Oytt95i0qRJfPDBByQmJrq1j6ioKG688UYGDhzI1q1bGTBgAJs3byY9PZ2PP/64siGJiIgEJCfWsiX5z4tvA4guZZtIaSp9+nXChAk0atQIgClTptCoUSNGjBjBgQMHmDBhQqX2tWvXLurUqUO9evW45ppr+NnPfsaIESN47LHHKhuWiIhIQIrDWrak+Dp16VgJnZYzEXdVKqmz2+3cfPPN/Pvf/wbg/Pnz/O53v6v0Qf/whz/Qr18/evfuTWhoKMnJyXz55Ze89957bN6sQWYREald4rCWLdEdJaQ6KpXUOZ1O/vnPf9KpUydOnz5d5YOOGjWKhISEgiROs0NFRKS2c6JlS6R6Kn36dffu3bRt25ZDhw5V+aA9evSo8ntFREREpKRKT5SIiYlh9uzZDBo0iGbNmhEaGlqkuKtJkyZMmDCBhQsXsnDhQv7whz/QuHHjyoZTIwYNGsTevXvZv38/TzzxhK/DERERESmh0iN1//jHPwBYs2YNxpiCepvNhjGGOnUq3mW3bt1Yt24dubm5JCUlAdZ1dpMmTWLAgAHs3LmzsmF5jcPhYM6cOdx7772cPn2aHTt2EBcXx4kTJ3wdmoiIiEiBSid19957b7UPOnfuXNasWcNvfvMb8vLyACt5+u///m/mzZtH3759q30MT+nRowcpKSlkZmYC8NlnnzFgwAD+53/+x8eRBaspQB4ww422MYADmOrViERERAJBpZO6L7/8stoH7d69e5GEDiAvL48333yT7du3V3v/hUVGRvL888/TrVs3WrRowZAhQ1i9enWRNuPGjeP555+nWbNmJCcn8/TTT7Nt2zYAWrRoQUZGRkHbjIwMWrZs6dEYpbA8YLrreXmJXYyr3WSvRyQiIhIIqnQL5969e/PRRx+xZcsWWrRoAcBjjz1Gr1693Hp/Tk4O4eHhJepbtWrFmTNnqhJSmUJCQkhOTmb8+PGlbh8+fDhz5sxh6tSpdO3aleTkZNatW8eNN97o0TjEXTOwErXpWIlbaQondO6M6ImIiAS/So/UPfzww3z00UcsXbqUrl27Ur9+fcCa+DBp0iQGDRpU4T7+9re/8f777/Pcc8/xr3/9C4BevXoxa9Ysli1bVtmQyhUfH098fHyZ2/MnayxevBiAsWPHMmjQIMaMGcMbb7xBZmZmkZG5li1bFlwHWJp69eoVfCdAweQRh8OBw+Go5qepLWbidNoxZjo2mwObbTPGNMNmO4oxkRjzCjbbFOz2mVinX8vncDiw2+36/v2Y+igwqJ/8n/rI/1XUR9Xpu0ondTExMYwdO5aPPvqIkSNHFtRv2bKFmJiyRlaKeu655zDG8OGHHxZMrLh8+TJ//vOfeemllyobUpXVrVuXbt26MXPmzII6YwwbNmygZ8+eACQlJXHHHXfQokULTp8+zQMPPMD06dPL2iUTJ07klVdeKVF///33k5ub6/HPELy+5uuvE8jMfIX8+Tj5jy1aJNC169fAA27tyeFw0LVrV2w2W5FT/uI/1EeBQf3k/9RH/q+iPmrQoEGV913ppK5Dhw6lXld3+vRprr32Wrf2cfnyZaKjo5k4cSK33norAAcPHuTSpUvcdNNNZGVlVTasKmnatCl16tQhOzu7SH12djYdO3YErGv9nn32WTZu3IjdbufNN98sd+brzJkzmTNnTsHr0NBQMjIyWL9+vcdPLQczY4bgdEZiLcdZ+CoBJ5mZkRw9+jY229/d2pfD4cAYQ3x8vP7I+Sn1UWBQP/k/9ZH/q6iPKrM8XHGVTuqOHj1Ku3btOHz4cJH63r178/3331dqX7m5uezevbvg9U9+8hO+/vprt5ZFqUlr165l7dq1brW9dOkSly5dYty4cYwfPx673UpI8vLy9AvmNjswt9Dz4tucOJ1zsG6s495NdJxOp/rAz6mPvMwGtAYaAWeBw4Ap9x2lUj/5P/WR/yuvj6rTb5XOnhYuXMj8+fMZM2YMxhhatGhBz549mT17drmnJf3R8ePHuXLlCmFhYUXqw8LCOHr0aLX2HRsbS2xsLKGhoboNWqVFUvS21sXZgXBXO91UR6RCnYCBQJNCdaeBeGCPTyISES+odFL3+uuvY7fb+fzzz2nYsCFffvklFy9eZPbs2bzzzjveiNFrLl++zI4dO+jfv3/BMic2m43+/fsH3GcJLs093E68ym6HyEho3hyysmDzZnDqNuR+oxMwvJT6xq765SixEwkSVTrP+dprrzFr1izatWtHo0aN+Pbbbzl37pynY/OIkJAQ2rVrV/C6TZs2dO7cmRMnTpCWlsacOXNYsmQJ27dvJykpiejoaEJCQli0aFG1jlv89KtUhrvXVNbMtZdSjqgomD8fWhUaWU1Lg2eegbg438UlFhvWCF3+8+LbjGv7Xqp0KlZE/Eulk7pf/OIXrFq1itzcXPbsqdx/7+68885yt3fo0KGy4VSoe/fubNq0qeD13LnWtVqLFy/m17/+NcuXL+fGG29k2rRpNGvWjG+++YaBAwfyww8/VOu4Ov1aHX1cj8UnSVCsvg86/epDUVGwcmXJ+pYtrfqhQ5XY+Vprip5yLc7m2t4aOFQTAYmIN1U6qZs7dy7vvvsua9as4eOPP2bdunU43TzV8s0332CMwWYr/l9GCuoL30/WExISEko9XmELFixgwYIFHj2uVFUMMA1YBoygtNmvlmWudgYtQOwDdrs1Qpf/vPg2pxPmzYPVq3Uq1pcaebidiPi1Sid1zZs3Z+DAgYwaNYrly5dz/vx5VqxYwdKlS9m6dWu5723Tpk2VAw00Ov1aVQ6u3iliBTCfopMm0oForJmv3+LO4sPiBZGRRU+5Fme3Q3i41S5Bo6k+c9bD7UTEr1U6qcvLy+PTTz/l008/pUGDBkRFRfHoo4+yceNG0tPTi1y/VtyRI0eqFWwg0enXqppa6HkcsBprlmtzrGvoNnN1tE4jdD7T3M1JKu62E+84jDXLtTElr6kDa6A7x9VORAJetRaEy83NZd26dVx33XW0bt2aTp06ldm2VatWpKWlub3vFi1akJmZWZ3wJCg40XVzfsjdBcJraCFxKYPBWrZkuOu5rdg2XNs1SUIkKFTp3GCDBg149NFH+fTTT8nIyCA6Opq4uDgiIiLKfM+2bdt499136d69e5ltGjduzJNPPsmuXbt45JFHqhKaiNSEzZutWa5lXS/ndMKRI1Y78a09WMuWFD9hkIOWMxEJMpUeqVu2bBkPPvgg58+fZ/ny5UyfPp3ExMQK33f77bfz8ssvs379ei5cuMCOHTvIzMzkwoULXHfdddx+++1ERETw9ddf88ILL/DZZ59V6QP5C11TJ0HN6bSWLVm50npe+Oc8P9GLjtYkCX+xB2vZEg/cUUJE/FelM468vDyGDx9O8+bNefrpp4skdOWN1J04cYJnn32W5s2b89RTT3HgwAGaNm3KbbfdBsDSpUvp1q0b99xzT8AndGBdUxcREUGPHj18HYqId8TFWcuWZGQUrU9P13Im/shgLVuy2/WohE4k6FR6pO6xxx4r8rpRo0aMGjWKJ598km7dulV439YLFy7wySef8Mknn1T20OIxU4A83JtoEIM1w3RqRQ2lNoqLs5Yt0R0lRER8rsoTJSIjI3niiSd45JFHyMzMZNWqVYwfP96TsYnX5AH59+ktL7GLcbWb7PWIJIA5nVq2RETED1QqqQsLC+NXv/oVTzzxBI0bN2b58uXUr1+fIUOGVPruEsHOv6+py0/kykvsCid0WjpEJNBoPF6k9nE741izZg379u3jJz/5CdHR0bRo0YLf//733owtoPn/NXUzsBK26Vh/0gtTQicS6PLH44v/dheX/9ue5/WIRMTb3B6pe+CBB/jTn/7En//8Z7777jtvxiQ1pvCI3S3ABuA/gSdQQicS2DQeL1L7uD1S17t3b0JDQ9mxYweJiYmMHz+eG264wZuxSY1IwVpy/gms+6k+4Xqd4sugRMQDNB4vUru4ndR99dVX/Pa3v6V58+b85S9/YeTIkWRmZmK327n//vtp1Eh3hA48UcBKILRYfairPqrGIxIRzyotsVNCJxKcKn0V//nz51m0aBGRkZHceeedvPXWW7z00kv88MMPrF692hsxBqRx48aRkpJCUlKSr0Mpgx2YX+h58W0A80rZJiKBpnBidwEldCLBqlr/Yu/fv58XX3yRm2++mVGjRnkqpqDg/xMlIoFWlP0jYAfCXe1EJNDNcT3WBy6ihE4kGHlkGMbpdLJ69WoGDx7sid1JmaZQ8Vy2fDGu9mVp7uZ+3G0ntcWUhyFmiHttY4ZY7cX3JrgeL2Ildu7+JRGRwKFzawHFk4sU/Kebx3S3ndQWeU6YPqzixC5miNUuTzeX8LnC19BdQ9mTJ0QksFX5jhLiC55apCCGq7NcQyk9t3cCOa52h8rZl9Q2M/5uPU4fZj2+thoiO0LzayHrFGzeC5MGW9snr7jaXnyjtL8I7vwlEZHAo6Qu4BT+c2wDvsQ6RZoF9AGmUfEl0A5XmxSsWa5OiiZ2+UMrY4AIV3uRqwonds8NgiYNr247fd56rYTO98r7L54SO5Hgo6TOS7x7m7AZwO1YCVxxy6j4z3PhmwENxZoF26pQXToQDcS5ikhJKengNEUTOrBeO421XXzHnTF7JXYiwUXX1HmJd2e/RgEjuDqils/pqq/M+nJxWHeT6AeMcj22QcmclMdug/mPl9PAwLxfWu3EN/LH4ytK1PKXO9F4vEjg00hdwKlofTkn1vpyqymZ9JXFCSR4IjipJSI7Qqtybihjt0N4U6tdwp6ai0uumlpxkwIaoRMJDhqpCzhaX058r/m1nm0nIiLVp5G6gKP15cT3sk55tp14nx3rv3r506o24/5YvogEBo3UBZwsD7cTqbzNe61ZruU5dc5qJ74XhbUw0SasqVSbXK91d2eR4KKkLuD0cT2W9X9sZ7F2Ip43afDVWa7OYj+KTqdVf22I1U58Kwpr4aKWxepbuuqV2IkEDyV1ASUGaxmTZa7Xpc1+xbV9GlovXrwh/04Rk1fA0HmQcbLo9vQTVv3kFe7deUK8p6JpVWBNq9I/BCLBQdfUBZTCixSsoPz15b5FixSINzjsRRcWXr2j5B0lnAbitl9tL76RP62qLIWnVWn+u0jgU1LnJd5ZfLjwIgVxWMuWlHXpsxYpEO+Yuqroa6cpe9kS3VHCtzStSqR2UVLnJbGxscTGxhIaGkpOTo6XjqL15USkbJpWJVK76MSIiEiQ2gykUf60qiOudiIS+JTUiYgEKSfwTKHnxbeBdRWu1qsTCQ5K6kREglgcMBTIKFaf7qrXXZ5FgoeuqRMRCXIVTasSkeCgpE5EpBbQtCqR4KfTryIiIiJBQEmdiIiISBBQUueGVatWceLECVasWOHrUERERERKpaTODfPnz+fxxx/3dRgiIiIiZVJS54aEhATOnDnj6zBEREREyhTwSV1kZCRr1qwhIyMDYwyDBw8u0WbcuHGkpqaSm5tLYmIid999tw8iFQlSNuAW4A7Xo82XwYiI1F4Bv6RJSEgIycnJfPDBB8TFlVxGc/jw4cyZM4exY8fy1VdfER0dzbp16+jQoQPHjh0DYOfOndSpU/KrGDBgAFlZuiuiSJk6AQOBJoXqTgPxwB6fRCQiUmsFfFIXHx9PfHx8mdsnTJjAwoULWbx4MQBjx45l0KBBjBkzhjfeeAOAu+66qyZCFQkunYDhpdQ3dtUvR4mdiEgNCvikrjx169alW7duzJw5s6DOGMOGDRvo2bOnV45Zr1496tevX/A6NDQUAIfDgcPh8MoxpXwOhwO73a7v34OMzeAc6LofQfHTrTbAAAPBfsCOzVR8PlZ9FBjUT/5PfeT/Kuqj6vRdUCd1TZs2pU6dOmRnZxepz87OpmPHjm7vZ/369XTu3JmQkBDS0tIYNmwYiYmJpbadOHEir7zySon6+++/n9zc3ErFL57hcDjo2rUrNpuNvLw8X4cTFI6HHiexSem/A4CV2DWBHsN60PRM0wr3pz4KDOon/6c+8n8V9VGDBg2qvO+gTuo85f7773e77cyZM5kzZ07B69DQUDIyMli/fr1m0PqIw+HAGEN8fLz+yHmIM8IJHSpu91XKV9hTKp6PpT4KDOon/6c+8n8V9VH+Gb6qCOqk7vjx41y5coWwsLAi9WFhYRw9etQrx7x06RKXLl1i3LhxjB8/Hrvd+gctLy9Pv2A+5HQ61QeelONeM5Nj3P7O1UeBQf3k/9RH/q+8PqpOvwX8kibluXz5Mjt27KB///4FdTabjf79+7N161avHjs2NpaIiAh69Ojh1eOI+MRhrFmupoztxrX9cI1FJCJS6wX8SF1ISAjt2rUreN2mTRs6d+7MiRMnSEtLY86cOSxZsoTt27eTlJREdHQ0ISEhLFq0yIdRiwQ4g7VsyXDXc1uxbbi2l5X0iYiIxwV8Ute9e3c2bdpU8Hru3LkALF68mF//+tcsX76cG2+8kWnTptGsWTO++eYbBg4cyA8//ODVuIqffpUqstshMhKaN4esLNi8GZxOX0clYC1XspyS69TloHXqRER8xKh4r4SGhhpjjAkNDfV5LAFXoqIMR44YjLlajhyx6iuxH4fDYR588EHjcDh8/5mCsdgw3ILhDtejrfL7UB8FRlE/+X9RH/l/qaiPqpM3aBhJ/FNUFKxcCS1bFq1v2dKqj4ryTVxSkgEOAbtdj8aXwYiI1F5K6rxk3LhxpKSkkJSU5OtQAo/dDvPnX31efBvAvHklt4mIiNRi+lfRSzT7tRoiI6FVq7KTNrsdwsOtdiIiIgIoqRN/1Ly5Z9uJiIjUAkrqvESnX6shK8uz7URERGoBJXVeotOv1bB5M6Sllb10idMJR45Y7aTGTQFi3Gwb42ovIiLep6RO/I/TCc88c/V58W0A0dFar85H8oDpVJzYxbja6UZFIiI1Q0md+Ke4OBg6FDIyitanp1v1cXG+iUuYAUym/MQuP6Gb7GovIiLeF/B3lPBXuqOEB8TFwerVuqOEH8pP1KYXew1K6EREfEVJnZfExsYSGxtLaGgoOTk5vg4ncDmdkJDg6yikFKUldkroRER8R0mdiFRZ4cQuBqiPEjoREV/RuUHxK1Mehpgh7rWNGWK1F9+a43qsD1xECZ2IiK8oqRO/kueE6cMqTuxihljt8nR5nc9NcD1exErs3F3uREREPEunX71EEyWqZsbfrcfpw4q+Liw/oZu8ovTtUnOKX0OX/xo0YiciUtOU1HlJQE2UsNv9aoZp4cTOZoMv90LzayHrFPTpCNOGKqHzB6VNiihvVqyIiHiXkrraLioK5s+HVq2u1qWlWYv/+nAtuBl/h9tbWglcccv+pYTO18qb5arETkTEN3RusDaLioKVK6Fly6L1LVta9VFRvokLiOoOI3pevWYuz7genVZ9VHefhVbrubNsiTsLFIuIiGcpqaut7HZrhC7/efFtAPPmldxWA+w2mP84rDoLtxyGi05w2KzHWw7DqjMw75dWO6l5DtxbtiQ/sXN4PSIREQEldbVXZKR1yrWspM1uh/Bwq10Ni+wI2+rD8KPwq8ZQ324ldPXt8OvGMDwbtl9jtZOaNxX3T6nOcLUXERHv0zV1tVXz5lefO/PgyGY4kwWhzSE8EuyOku1qSNi18MwxePl6mH4DTP4RZpyAGNdrgOhj0PPaGg9NRETEbymp85IaWdLEBrQGGgFngcOAcfO9WVnW455VEP8M5KRf3db4Zhg4Hzo9fLVdDdpX1xqhK5zQwdXH6TdYH3Nt3RoPTUphByKB5kAWsBnQ8oEiIjVPSZ2XeH1Jk07AQKBJobrTQDywx433b94Mm9+DL8ZSIhPMyYDlQ+HeP1vtathDnWBasYQuX+HEztYJkr+s8fCkkChgPlBo7jRpwDOA7+ZOi4jUTrqmLhB1AoYDjYvVN3bVd3JjH8ZpjdCVOrTnqlv3B6tdDYoZAtP6lJ7Q5Ztxwto+rY/7txQTz4sCVgLF5k7T0lXvu7nTIiK1k5K6QGPDGqHLf158G67tFc0MbQ3Uu1BOAwP1cq12Nchhh8krYUYqZZ9KNtb2ySut9lLz7FgjdPnPi28DmFfKNhER8R6dfg00rSl6yrU4m2t7a+BQ6U2mPAx5N7o3gzHmZ+A4BlNXVTLOKio4Tv5opKFogpqf6MXDDHdOM4tXRFL0lGtxdiDc1S6hRiISERH9RzrQhLq5OFs57fKcML2PNZu0PDHXW+3yfHHV+x5gOVD8csQcV70SOp9yd050zc+dFhGpvTRSF2ja/gRIdq/drtLbzfg7YIPpQ7FOZZ4s2SbmOtfs05U+vCXXHmAvVZ/hK17j7pzomp87LSJSeympCzQNOkDjH60ZqqVmNzZrSZIGHSgv+ZsRBzSF6f3AZoPphSYlTL7eNft0k6udLxnKPI0svrMZa5ZrS0of7ncC6a52IiJSM3T6NYBMeRhimiVZa8gBZc6UGDiPmGZJTHm4/P2l7ISUi1YCl38qNsaV0KVctLaLlMaJtWxJ/vPi2wCiS9kmIiLeo6TOS8aNG0dKSgpJSUke22eeE6bffYiYE/+CocuhcbHFJBrfDEOXE/PjFqbffajca+Hy76/aqR44jXWq9Uo769FpoFNd3V9VyhcHDAUyitWnu+p9PcgrIlLb6PSrl3hj8eH8a9umD3sLQqcy4+nvIX3L1dt73dyLmG9nMv3IHCavKP9auMiO0OqGonUOVwJntwE2CG9qtUvQpAQpQxywGt1RQkTEHyipCzAFiR1TsOWc4svbHrL+MW0AfRJfZNqRuRUmdADNr3XveO62k9rLiZYtERHxB0rqAtCMv8PtLWEac+HI3CLblv3LvdmqWafcO5a77URERMS3dE1dAIrqDiN6Wte+FeZ0WvVR3Svex+a9cPp8+W1OnbPaiYiIiP9TUhdg8ic45D8vss0OGPcmOEwaDE0aWomhs9gFUE6nVX9tiNVORERE/J+SugCTP8GhrKTNbr86waEsMUNg+jCYvAKGzoOMYosPp5+w6ievsNrFDPFM7CIiIuI9uqYuwHhigoPDTpHJFKt3WElg82uta+g277VG6uK2X20vIiIi/k1JXYDxxASHqauKvnaaspct8dktwkRERKRSNAZTgZtvvpmNGzeSkpJCcnIyQ4cO9Wk8fVynVYtfB5cvv75POadfRUREJPgoqavAlStXiI6OJiIiggEDBjBv3jwaNmzok1hihsC0odayJdhKn+CAzdo+baiuhRMREalNdPq1AkePHuXo0aMAZGdnc/z4ca6//nrOn69gPRAvKHwt3IqvrFmwhe8KkX4Coj+yroX7NkPXwomIiNQmAf/PfmRkJGvWrCEjIwNjDIMHl1yDY9y4caSmppKbm0tiYiJ33313lY7VtWtXHA4H6enp1Q27SqauunqNW9x2uOUZ6DcDRr1jPbaJvjq5YcbfS147JyIiIsEr4EfqQkJCSE5O5oMPPiAuruQtxIcPH86cOXMYO3YsX331FdHR0axbt44OHTpw7NgxAHbu3EmdOiW/igEDBpCVlQXAddddx4cffshvfvMb736gSihvgoOIiIjULgGf1MXHxxMfH1/m9gkTJrBw4UIWL14MwNixYxk0aBBjxozhjTfeAOCuu+4q9xj16tXj73//O6+//jpbt26tsG39+vULXoeGhgLgcDhwOBzufKRa7Y9OJ3nAq/aKB5FfdjpxANMqaOtwOLDb7fr+/Zj6KDCon/yf+sj/VdRH1em7gE/qylO3bl26devGzJkzC+qMMWzYsIGePXu6vZ/FixfzxRdf8PHHH1fYduLEibzyyisl6u+//35yc3PdPmZt1Xb/fh7bv5/bbr2Vv7VvX2a7Ea52H7dvzwPltAPrF6Rr167YbDby8vI8HbJ4gPooMKif/J/6yP9V1EcNGjSo8r6DOqlr2rQpderUITs7u0h9dnY2HTu6t+ZHr169GDFiBP/+978ZMmQIAL/85S/ZvXt3qe1nzpzJnDlzCl6HhoaSkZHB+vXrOXPmTNU+SC3yGXDAZmPq/v0cOHCg1BG7l51OHjOGKTYbrx48CAcPlrtPh8OBMYb4+Hj9kfNT6qPAoH7yf+oj/1dRH+Wf4auKoE7qPGHLli2VGgq9dOkSly5dKlGfl5enXzA3TQOcwHRjcOblMaPQthhgKjAZmGEMuPmdOp1O9YGfUx8FBvWT/1Mf+b/y+qg6/RbUSd3x48e5cuUKYWFhRerDwsIKlinxlnHjxjF+/HjsblwbJiXlJ3LTC72Ocb2eXGi7iIiIWII647h8+TI7duygf//+BXU2m43+/ftXOOGhumJjY4mIiKBHjx5ePU4wm4E1ajcdMCihExERKU/Aj9SFhITQrl27gtdt2rShc+fOnDhxgrS0NObMmcOSJUvYvn07SUlJREdHExISwqJFi7wal0bqPGMK8CJQH7iIEjoREZHymEAuffv2NaVZtGhRQZvx48ebQ4cOmQsXLpjExETTo0ePGosvNDTUGGNMaGioz7+r/DIFTIybbWNc7X0V62QwBswl1+PkKuzD4XCYBx980DgcDp9/9yrqo0Au6if/L+oj/y8V9VF18oaAH6lLSEjAZrOV22bBggUsWLCghiLyf3kUvVatLIWvYfOFvwKjXM/ruh6nAZ2AR30SkYiIiP8K+KTOX/nz6dfSJiEU5+tJCfkJnZOiF346uZroKbETERG5yv8yjiDhjYkSU7CSLXfEuNqXZQZWwja9lH36OqGbTOkJHa7X+Ymdr0YQRURE/JFG6gKIp0+bFh6xuwXYAPwn8AS+S+hisE6xQtn/48ivn4Z1EYEmT4iIiCipCyjFT5u+BkQCzYEsYDMwicqNsqUAp7ESuSdcdadd9b7gAJYDw91ou9zVXkRERJTUeY23rqkrnNg9BzQptO2067W7CV0UsLKU+lBX/VAgrsqRVs1UoC/uJXWxQIJ3wxEREQkYuqbOS7y5+HAK1nVlTYrVN3HVuzPKZgfmF3pefBvAvFK21YTNQBrWZymNEzjiaiciIiIWJXUBpnAyVpZ5VNyxkUCrctrZgXBXu5rmBJ4p9Lz4NoDoUraJiIjUZkrqAoynkrHmbh7P3XaeFod1+jejWH06vjktLCIi4u+U1HnJuHHjSElJISkpyaP79VQy9p9u7sfddt4QhzUrtx/WEib9gDYooRMRESmNJkp4SWxsLLGxsYSGhpKTk+Ox/WZ5oF0M1kzX01iTIkrL7J1AjqvdIXy3bIgTTYYQERFxh5K6ALOZq7Ncy3KK8icROLBmyKZgzXIt7a4NAGOACLRsiIiISCBQUhdgJnF1liuUnoxd62pX1uja1ELPh2JNvGhVqC4dayJCHDrVKSIiEiiU1AWQwneKSKHsZCwC9+48AVbStpqSixhrZqmIiEhgUVLnJd5YfDj/tGl+olZWMhZXqL07dN2aiIhI4FNS5yXemCgxtdjr8pIx3Q9VRESkdtGSJiIiIiJBQEmdiIiISBBQUiciIiISBJTUiYiIiAQBJXVe4q3bhImIiIiURkmdl8TGxhIREUGPHj18HYqIiIjUAkrqRERERIKAkjoRERGRIKCkTkRERCQI6I4SNSQ0NNTXIdRaDoeDBg0aEBoaSl5enq/DkVKojwKD+sn/qY/8X0V9VJ18QUmdl+V3TkZGho8jERERkUARGhrKmTNnKvUeG2C8E47ka9GiRaU7pjKSkpI8Msu2Kvtx9z3utCuvTVnbSqsvXhcaGkpGRgYtW7b0aj+UJxD6yJ22nuqj4vXB1EdV3Zenfpe81Ufg+36qzX1U1jb1UdXe4+//JoWGhpKZmVnRxyhBI3U1oCodUxlOp9Mjv7xV2Y+773GnXXltytpWWn1Zbc+cOeOzhCEQ+sidtp7qo7Lqg6GPqrovT/0uebuPwHf9VJv7qKxt6qOqvcff/02q6neoiRJBYMGCBT7bj7vvcaddeW3K2lZavae+D08KhD5yp62n+qiycdUET8bjy98l9ZH39uXLPiprm/qoau8J1n+TdPpVgl5oaCg5OTk0btzYZ6NAUj71UWBQP/k/9ZH/82YfaaROgt7Fixd55ZVXuHjxoq9DkTKojwKD+sn/qY/8nzf7SCN1IiIiIkFAI3UiIiIiQUBJnYiIiEgQUFInIiIiEgSU1ImIiIgEASV1UuutWrWKEydOsGLFCl+HIqW4+eab2bhxIykpKSQnJzN06FBfhyTFNGnShG3btrFz50527drFk08+6euQpAwNGjTg0KFDzJo1y9ehSClSU1NJTk5m586dfPHFF5V+v2a/Sq3Xt29fQkNDGT16NMOGDfN1OFJMs2bNCAsLIzk5mbCwMHbs2EH79u05f/68r0MTF7vdTv369cnNzaVhw4bs3r2b7t27c+LECV+HJsXMmDGDdu3akZaWxvPPP+/rcKSY1NRU7rjjDs6dO1el92ukTmq9hIQELdLpx44ePUpycjIA2dnZHD9+nOuvv97HUUlhTqeT3NxcAOrXr4/NZsNms/k4KimuXbt2dOzYkc8++8zXoYiXKKmTgBYZGcmaNWvIyMjAGMPgwYNLtBk3bhypqank5uaSmJjI3Xff7YNIay9P9lHXrl1xOBykp6d7O+xaxRN91KRJE7755hvS09OZNWsWP/74Y02FXyt4oo9mz57NxIkTayrkWscTfWSMISEhgaSkJB599NFKx6CkTgJaSEgIycnJjB8/vtTtw4cPZ86cOUydOpWuXbuSnJzMunXruPHGG2s40trLU3103XXX8eGHH/Lb3/62JsKuVTzRR6dPn6ZLly60adOGRx99lJtuuqmmwq8VqttHDz30EPv37+fAgQM1GXat4onfo969e9O9e3ceeughJk2axJ133lnpOIyKSjAUY4wZPHhwkbrExETz9ttvF7y22WwmPT3dvPjii0Xa9e3b16xYscLnnyHYS1X7qF69eiYhIcE89thjPv8MwV6q83uUXxYsWGAeeeQRn3+WYC1V6aPXXnvNHDlyxKSmpppjx46ZU6dOmcmTJ/v8swRr8cTv0ZtvvmlGjx5dqeNqpE6CVt26denWrRsbNmwoqDPGsGHDBnr27OnDyCSfu320ePFivvjiCz7++GNfhFmrudNHN910E40aNQKgcePG9OnTh3379vkk3trInT6aNGkS4eHhtGnThueee46FCxcyffp0X4Vc67jTRw0bNiz4PQoJCeG+++4jJSWlUsep47mQRfxL06ZNqVOnDtnZ2UXqs7Oz6dixY8Hr9evX07lzZ0JCQkhLS2PYsGEkJibWdLi1kjt91KtXL0aMGMG///1vhgwZAsAvf/lLdu/eXdPh1kru9FHr1q157733CiZIvP322+qfGuTu3zrxHXf6KCwsjLi4OAAcDgcLFy5k+/btlTqOkjqp9e6//35fhyDl2LJlCw6Hw9dhSDm2bdvGXXfd5eswxE1LlizxdQhSitTUVLp06VKtfej0qwSt48ePc+XKFcLCworUh4WFcfToUR9FJYWpj/yf+sj/qY/8X031kZI6CVqXL19mx44d9O/fv6DOZrPRv39/tm7d6sPIJJ/6yP+pj/yf+sj/1WQf+XyWiIpKVUtISIjp3Lmz6dy5szHGmOjoaNO5c2fTqlUrA5jhw4eb3Nxc8/jjj5uOHTuad99915w4ccLcdNNNPo+9thT1kf8X9ZH/F/WR/xc/6SPffxEqKlUtffv2NaVZtGhRQZvx48ebQ4cOmQsXLpjExETTo0cPn8ddm4r6yP+L+sj/i/rI/4s/9JHu/SoiIiISBHRNnYiIiEgQUFInIiIiEgSU1ImIiIgEASV1IiIiIkFASZ2IiIhIEFBSJyIiIhIElNSJiIiIBAEldSIiIiJBQEmdiIiISBBQUicibuvQoQNbt24lNzeXnTt3+jqcCi1atIi4uDiv7Hvjxo3MnTvXK/sOBMYYBg8e7OswRKQQJXUiQahp06ZcvHiRhg0bUqdOHc6ePUurVq2qvd+pU6dy7tw5OnToQP/+/Utts2jRIowxGGO4dOkS33//PW+88Qb169ev9vEr65lnnuFXv/pVjR8XYPTo0Zw8ebJS7/HHRHHKlCmlJvDNmjXjs88+8+qx7XY7L774Inv27OH8+fP8+OOPJCYm8sQTTxS08cfvTMRX6vg6ABHxvJ49e5KcnMz58+fp0aMHJ06cIC0trdr7vfXWW/n00085cuRIue0+++wzfv3rX1O3bl26devGkiVLMMbw0ksvVTuGysjJySl3e926dbl8+XINReNfqvvZs7OzPRhN6aZMmcL/+3//j6eeeort27fTuHFjunfvznXXXef1Y4sEKqOiohJcZebMmWbu3LkGMBMmTDDLli2r8D02m81MnjzZpKWlmQsXLpidO3ean/3sZwXbi5syZUqp+1m0aJGJi4srUrdy5UqzY8eOIsd66aWXzPfff2/Onz9vvvnmG/PII48Uec8DDzxg9u3bZ86fP2+++OILM3r0aGOMMU2aNDGAmTJlitm5c2eR9zzzzDMmNTW1zFg2btxo3n77bTN37lxz7Ngx88UXXxjAREREmH/84x/mzJkz5ujRo+bDDz80N9xwQ8H7GjZsaJYsWWLOnDljMjMzzYQJE8zGjRsLvuPSyujRo83JkycLXufH+9hjj5nU1FRz6tQps2zZMtOoUaOCWItr3bq1W/E1atTIfPzxx+bs2bMmMzPTREdHl4gvNTXVxMTEmCVLlpjTp0+bRYsWGcC8/vrrZt++febcuXPm4MGDZtq0aaZOnToFn6G40aNHF/w8DB48uGD/d9xxh/n888/N+fPnzfHjx81f/vIXExISUqIvnn32WZOZmWmOHz9u3nnnnYJjlVZ27txp/vjHP5a5vTrfWf7Pwttvv21OnTpljh07ZqZNm1Zk/7/73e/M/v37TW5urjl69KhZsWKFz3+3VVQqKD4PQEVFxQOlVatW5uTJk+bkyZPm4sWL5vz58+bkyZPmwoULJjc315w8edIsWLCgzPdHR0ebU6dOmREjRpj27dub119/3Vy8eNG0a9fOACYsLMzs2rXLzJo1y4SFhRX5B7twKZ5IRUREmMzMTLN169aCukmTJplvv/3WDBgwwLRp08aMHj3a5Obmmj59+hjA3HzzzSY3N9fMnj3btG/f3jz66KMmKyvLI0ldTk6OeeONN0z79u1N+/btTZMmTUx2drZ59dVXTYcOHUyXLl3MunXrzOeff17wvgULFphDhw6Z++67z9xxxx1mzZo15vTp05VO6nJycszKlStNRESE6d27t8nMzDQzZswwgGncuLHZsmWL+ctf/mLCwsJMWFiYsdvtbsX33nvvmdTUVHPfffeZiIgI88knn5SILz+RnDBhgmnbtq1p27atAczLL79sevbsaVq3bm0efPBBk5WVZZ5//nkDmGuuucbMmjXL7Nq1qyCma665xkDRpK5hw4YmIyOj4LPde++95uDBgwWJY35fnDp1ysTGxpoOHTqYQYMGmbNnz5onn3yyzO/ws88+M5s2bTJNmzYtdXt1vrP8n4W5c+cW/IwVjqdbt27m8uXLZuTIkSY8PNx06dLFPP300z7/PVdRqaD4PAAVFRUPFIfDYVq3bm3uvPNOc/HiRXPnnXeatm3bmpycHBMZGWlat25dZKSieElPTzcTJ04sUvfVV1+Zd955p+D1zp07yxyhyy+LFi0yly9fNmfOnDG5ubnGGGOuXLliHn74YQOYevXqmbNnz5qf/vSnRd63cOFCs3TpUgOYV1991ezevbvI9pkzZ3okqSs8YghWUhMfH1+krmXLlsYYY2677TYTEhJiLly4YIYOHVqw/brrrjPnzp2rdFJ39uzZgpE5wLzxxhtFkt3SRv8qiq9Ro0bm4sWLRUY6GzdubM6ePVsiqVu1alWFP0fPPvus2bZtW5G4i3/PUDSpe/LJJ82PP/5oGjZsWLD9gQceMFeuXDE33XRTQV+kpqYau91e0OZvf/tbuaPInTp1MikpKebKlSsmOTnZ/PnPfzYDBw4s0qYq31n++1JSUkr8jOXXRUVFmVOnThXpLxUVfy+6pk4kSOTl5XH48GGGDRvGtm3b2LVrF/fccw/Z2dls3ry53PeGhobSsmVLtmzZUqR+y5YtdO7cudKxbNy4kd/97neEhITwhz/8gStXrrBq1SoA2rVrR0hICOvXry/ynnr16hVckN+pUye++uqrItu3bt1a6ThKs2PHjiKvO3fuzL333suZM2dKtL311ltp0KAB9evXLxLPyZMn2bdvX6WPfejQIc6ePVvwOisri5tuuqnc97gTX7169UhKSiqoz8nJKTW+7du3l6gbPnw4v//977n11ltp1KgRderUqfBaxOI6depUcA1nvi1btuBwOOjQoQM//PADACkpKTidzoI2WVlZ3HnnnWXud8+ePdxxxx1069aNXr160adPH9auXcvixYv5zW9+U+b7KvrODhw4AEBiYmKRbVu3buXZZ5/Fbrezfv16Dh8+zPfff098fDzx8fHExcWRm5vr3pci4gNK6kSCxO7du2ndujV169bFbrdz5swZ6tSpQ506dThz5gyHDx/mjjvuqJFYzp07x8GDBwEYM2YMycnJjBkzhg8++IBGjRoBMGjQIDIyMoq87+LFi24fw+l0YrPZitTVrVvXrdgKa9SoEWvXruXFF18s0TYrK4t27dq5HVNFik9MMMZgt5e/CIEn4yv+2X/605+ydOlSpkyZwrp16zh9+jQjR47k2WefdXuflVGVz2+MYfv27Wzfvp358+fzi1/8go8//phXX32VQ4cOlfqeir4zd5w9e5auXbvSr18/BgwYwLRp03jllVe4++67OX36tFv7EKlpWtJEJEj8/Oc/p0uXLhw9epTHHnuMLl26sHv3bqKjo+nSpQs///nPy3zvmTNnyMjIoFevXkXqe/XqxbffflutuIwxvPbaa8yYMYNrrrmGb7/9lgsXLhAeHs7BgweLlPT0dMAaoenRo0eR/fz0pz8t8vrYsWM0a9asSF2XLl0qHd/XX39NREQEhw4dKhHP+fPnOXjwIJcuXeI//uM/Ct5z7bXX0r59+0ofqyKXLl3C4XBUKr7vv/+eS5cucffddxe8p3Hjxm7Fd88993D48GFee+01duzYwXfffUfr1q0rjKm4PXv20LlzZxo2bFhQ16tXL/Ly8qo0olme/J/HkJCQMuOr6DvLV7hPwfoZO3DgQMFoYl5eHp9//jkvvvgiP/nJT7jlllu47777PPp5RDxJSZ1IkDhy5Ahnz54lLCyM1atXk5aWRkREBJ988gkHDx6scBmSWbNm8eKLLzJ8+HDat2/PzJkz6dKlC/Pnz692bCtWrCAvL4/x48dz9uxZZs+ezdy5c3n88cdp27Ytd911F0899RSPP/44AO+++y633XYbb775Ju3bt2fUqFEl1pvbtGkTN954Iy+88AJt27Zl3LhxPPDAA5WObcGCBVx//fUsW7aM7t2707ZtWwYMGMAHH3yA3W7n3LlzvP/++8yaNYt7772XiIgIFi9eXOQ0oqccOnSI//iP/6B169bccMMN2Gy2CuM7e/YsS5YsYdasWfTr14/bb7+d999/H6fTiTGm3OMdOHCA8PBwRowYQdu2bXn66aeJiooqEVObNm3o3LkzN9xwA/Xq1Suxn6VLl3LhwgWWLFlCREQE/fr14+233+ajjz4qOPVaFStWrCA6OpoePXoQHh5O3759WbBgAfv27WPv3r1V/s7yhYeH89Zbb9G+fXtGjhzJ008/XfDzPmjQIJ5++mk6d+5MeHg4jz/+OHa73eNJqognKakTCSL9+vVj27ZtXLx4kR49epCens7Ro0fdeu+f/vQn5syZw1tvvcWuXbsYOHAgDz30EN99912148rLy+Odd97hhRdeoGHDhkyePJnp06czceJE9uzZQ3x8PIMGDSI1NRWAtLQ0HnnkEYYMGUJycjJjx45l0qRJRfa5d+9exo0bx/jx40lOTqZHjx7Mnj270rFlZWXRq1cvHA4H//znP9m1axfz5s3j1KlTBYnb888/z+bNm1m7di0bNmzg//7v/0pcm+cJs2fPJi8vj2+//Zbjx48THh7uVnwTJkxg69at/O///i8bNmxgy5Yt7NmzhwsXLpR7vLVr1zJ37lzeeecdvvnmG+655x6mT59epM0nn3xCfHw8Gzdu5Pjx44waNarEfnJzc/nZz37G9ddfz7Zt21i5ciWff/45Tz31VLW+j3Xr1vFf//VfrF27lv3797NkyRL27t3LgAEDyMvLq9Z3BvDhhx/SoEEDkpKSWLBgAfPnz+e9994D4NSpUzz88MN88cUX7Nmzh7FjxzJq1Khqj1yLeJvPZ2uoqKioVFT69u1bZParStmlYcOG5uTJk2bMmDE+j8VfS0XrDKqoBGLRRAkRkQDXpUsXOnbsSFJSEk2aNOGPf/wjAKtXr/ZxZCJSk5TUiYgEgeeee44OHTpw6dIlduzYQWRkJD/++KOvwxKRGmTDGrITERERkQCmiRIiIiIiQUBJnYiIiEgQUFInIiIiEgSU1ImIiIgEASV1IiIiIkFASZ2IiIhIEFBSJyIiIhIElNSJiIiIBAEldSIiIiJB4P8D99cpyS+KRd0AAAAASUVORK5CYII=",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -561,22 +625,31 @@
     "\n",
     "# Plot Results\n",
     "sci_steps = np.asarray(sci_steps)\n",
+    "sci_dense_steps = np.asarray(sci_dense_steps)\n",
     "nb_steps = np.asarray(nb_steps)\n",
     "cysolver_steps = np.asarray(cysolver_steps)\n",
+    "cysolver_dense_steps = np.asarray(cysolver_dense_steps)\n",
     "pysolver_steps = np.asarray(pysolver_steps)\n",
     "pysolver_njit_steps = np.asarray(pysolver_njit_steps)\n",
+    "pysolver_dense_njit_steps = np.asarray(pysolver_dense_njit_steps)\n",
     "\n",
     "sci_times = np.asarray(sci_times)\n",
+    "sci_dense_times = np.asarray(sci_dense_times)\n",
     "nb_times = np.asarray(nb_times)\n",
     "cysolver_times = np.asarray(cysolver_times)\n",
+    "cysolver_dense_times = np.asarray(cysolver_dense_times)\n",
     "pysolver_times = np.asarray(pysolver_times)\n",
     "pysolver_njit_times = np.asarray(pysolver_njit_times)\n",
+    "pysolver_dense_njit_times = np.asarray(pysolver_dense_njit_times)\n",
     "\n",
     "sci_errors = np.asarray(sci_errors)\n",
+    "sci_dense_errors = np.asarray(sci_dense_errors)\n",
     "nb_errors = np.asarray(nb_errors)\n",
     "cysolver_errors = np.asarray(cysolver_errors)\n",
+    "cysolver_dense_errors = np.asarray(cysolver_dense_errors)\n",
     "pysolver_errors = np.asarray(pysolver_errors)\n",
     "pysolver_njit_errors = np.asarray(pysolver_njit_errors)\n",
+    "pysolver_dense_njit_errors = np.asarray(pysolver_dense_njit_errors)\n",
     "\n",
     "fig, ax = plt.subplots()\n",
     "\n",
@@ -585,19 +658,25 @@
     "    ax.errorbar(sci_steps[1:], sci_times[1:], yerr=sci_errors[1:], c='blue', label='SciPy', fmt='o')\n",
     "    ax.errorbar(cysolver_steps[1:], cysolver_times[1:], yerr=cysolver_errors[1:], c='red', label=\"CyRK's cysolve_ivp (Cython)\", fmt='o')\n",
     "    ax.errorbar(pysolver_steps[1:], pysolver_times[1:], yerr=pysolver_errors[1:], c='cyan', label=\"CyRK's pysolve_ivp (Python)\", fmt='o')\n",
-    "    ax.errorbar(pysolver_njit_steps[1:], pysolver_njit_times[1:], yerr=pysolver_njit_errors[1:], c='magenta', label=\"CyRK's pysolve_ivp (Python + Numba)\", fmt='o')\n",
-    "    ax.errorbar(nb_steps[1:], nb_times[1:], yerr=nb_errors[1:], c='green', label=\"CyRK's nbsolve_ivp (Numba)\", fmt='o')    \n",
+    "    ax.errorbar(pysolver_njit_steps[1:], pysolver_njit_times[1:], yerr=pysolver_njit_errors[1:], c='orange', label=\"CyRK's pysolve_ivp (Python + Numba)\", fmt='o')\n",
+    "    ax.errorbar(nb_steps[1:], nb_times[1:], yerr=nb_errors[1:], c='green', label=\"CyRK's nbsolve_ivp (Numba)\", fmt='o')\n",
+    "    ax.errorbar(sci_dense_steps[1:], sci_dense_times[1:], yerr=sci_dense_errors[1:], c='blue', fmt='x', markersize=8)\n",
+    "    ax.errorbar(cysolver_dense_steps[1:], cysolver_dense_times[1:], yerr=cysolver_dense_errors[1:], c='red', fmt='x', markersize=8)\n",
+    "    ax.errorbar(pysolver_dense_njit_steps[1:], pysolver_dense_njit_times[1:], yerr=pysolver_dense_njit_errors[1:], c='orange', fmt='x', markersize=8)\n",
     "else:\n",
     "    ax.errorbar(end_times, sci_times, yerr=sci_errors, c='blue', label='SciPy', fmt='o')\n",
     "    ax.errorbar(end_times, cysolver_times, yerr=cysolver_errors, c='red', label=\"CyRK's cysolve_ivp (Cython)\", fmt='o')\n",
     "    ax.errorbar(end_times, pysolver_times, yerr=pysolver_errors, c='cyan', label=\"CyRK's pysolve_ivp (Python)\", fmt='o')\n",
-    "    ax.errorbar(end_times, pysolver_njit_times, yerr=pysolver_njit_errors, c='magenta', label=\"CyRK's pysolve_ivp (Python + Numba)\", fmt='o')\n",
+    "    ax.errorbar(end_times, pysolver_njit_times, yerr=pysolver_njit_errors, c='orange', label=\"CyRK's pysolve_ivp (Python + Numba)\", fmt='o')\n",
     "    ax.errorbar(end_times, nb_times, yerr=nb_errors, c='green', label=\"CyRK's nbsolve_ivp (Numba)\", fmt='o')\n",
+    "    ax.errorbar(end_times, sci_dense_times, yerr=sci_dense_errors, c='blue', label='SciPy', fmt='x', markersize=8)\n",
+    "    ax.errorbar(end_times, cysolver_dense_times, yerr=cysolver_dense_errors, c='red', fmt='x', markersize=8)\n",
+    "    ax.errorbar(end_times, pysolver_dense_njit_times, yerr=pysolver_dense_njit_errors, c='orange', fmt='x', markersize=8)\n",
     "\n",
     "if use_pendulum:\n",
-    "    title_name = f'CyRK v{version}\\n(Pendulum DiffEq)'\n",
+    "    title_name = f'CyRK v{version}\\n(Pendulum DiffEq; \"x\" indicates dense output version)'\n",
     "else:\n",
-    "    title_name = f'CyRK v{version}\\n(Predator-Prey DiffEq)'\n",
+    "    title_name = f'CyRK v{version}\\n(Predator-Prey DiffEq; \"x\" indicates dense output version)'\n",
     "\n",
     "if plot_vs_steps:\n",
     "    ax.set(ylabel='Average Time [ms]\\n(Lower is Better)', xlabel='# of Required Integration Steps', xscale='log', yscale='log')\n",
@@ -607,7 +686,7 @@
     "ax.grid(alpha=0.3)\n",
     "# ax.set_xlim(ax.get_xlim()[::-1])\n",
     "\n",
-    "ax.legend(loc='best')\n",
+    "ax.legend(loc='best', fontsize=9)\n",
     "ax.set(title=title_name)\n",
     "fig.tight_layout()\n",
     "if use_pendulum:\n",
@@ -629,37 +708,37 @@
      "text": [
       "How much faster X is vs. Y\n",
       "End Time: 1.0e-03\n",
-      "\t nbsolve_ivp = 11.12x SciPy\t nbsolve_ivp =  0.25x cysolve_ivp\n",
-      "\t pysolve_ivp = 16.16x SciPy\t pysolve_ivp =  0.36x cysolve_ivp\n",
-      "\t cysolve_ivp = 44.73x SciPy\t cysolve_ivp =  2.77x pysolve_ivp\n",
+      "\t nbsolve_ivp = 10.35x SciPy\t nbsolve_ivp =  0.21x cysolve_ivp\n",
+      "\t pysolve_ivp = 16.75x SciPy\t pysolve_ivp =  0.33x cysolve_ivp\n",
+      "\t cysolve_ivp = 50.31x SciPy\t cysolve_ivp =  3.00x pysolve_ivp\n",
       "End Time: 1.0e-02\n",
-      "\t nbsolve_ivp = 10.55x SciPy\t nbsolve_ivp =  0.18x cysolve_ivp\n",
-      "\t pysolve_ivp = 20.15x SciPy\t pysolve_ivp =  0.35x cysolve_ivp\n",
-      "\t cysolve_ivp = 57.03x SciPy\t cysolve_ivp =  2.83x pysolve_ivp\n",
+      "\t nbsolve_ivp = 10.51x SciPy\t nbsolve_ivp =  0.21x cysolve_ivp\n",
+      "\t pysolve_ivp = 16.88x SciPy\t pysolve_ivp =  0.33x cysolve_ivp\n",
+      "\t cysolve_ivp = 51.17x SciPy\t cysolve_ivp =  3.03x pysolve_ivp\n",
       "End Time: 1.0e-01\n",
-      "\t nbsolve_ivp = 15.04x SciPy\t nbsolve_ivp =  0.21x cysolve_ivp\n",
-      "\t pysolve_ivp = 20.00x SciPy\t pysolve_ivp =  0.27x cysolve_ivp\n",
-      "\t cysolve_ivp = 72.88x SciPy\t cysolve_ivp =  3.64x pysolve_ivp\n",
+      "\t nbsolve_ivp = 14.80x SciPy\t nbsolve_ivp =  0.21x cysolve_ivp\n",
+      "\t pysolve_ivp = 20.15x SciPy\t pysolve_ivp =  0.28x cysolve_ivp\n",
+      "\t cysolve_ivp = 71.54x SciPy\t cysolve_ivp =  3.55x pysolve_ivp\n",
       "End Time: 1.0e+00\n",
-      "\t nbsolve_ivp = 30.67x SciPy\t nbsolve_ivp =  0.21x cysolve_ivp\n",
-      "\t pysolve_ivp = 29.54x SciPy\t pysolve_ivp =  0.20x cysolve_ivp\n",
-      "\t cysolve_ivp = 148.99x SciPy\t cysolve_ivp =  5.04x pysolve_ivp\n",
+      "\t nbsolve_ivp = 30.43x SciPy\t nbsolve_ivp =  0.22x cysolve_ivp\n",
+      "\t pysolve_ivp = 27.62x SciPy\t pysolve_ivp =  0.20x cysolve_ivp\n",
+      "\t cysolve_ivp = 137.45x SciPy\t cysolve_ivp =  4.98x pysolve_ivp\n",
       "End Time: 1.0e+01\n",
-      "\t nbsolve_ivp = 103.59x SciPy\t nbsolve_ivp =  0.26x cysolve_ivp\n",
-      "\t pysolve_ivp = 39.88x SciPy\t pysolve_ivp =  0.10x cysolve_ivp\n",
-      "\t cysolve_ivp = 404.11x SciPy\t cysolve_ivp = 10.13x pysolve_ivp\n",
+      "\t nbsolve_ivp = 101.84x SciPy\t nbsolve_ivp =  0.25x cysolve_ivp\n",
+      "\t pysolve_ivp = 35.79x SciPy\t pysolve_ivp =  0.09x cysolve_ivp\n",
+      "\t cysolve_ivp = 407.46x SciPy\t cysolve_ivp = 11.39x pysolve_ivp\n",
       "End Time: 1.0e+02\n",
-      "\t nbsolve_ivp = 136.64x SciPy\t nbsolve_ivp =  0.28x cysolve_ivp\n",
-      "\t pysolve_ivp = 41.30x SciPy\t pysolve_ivp =  0.08x cysolve_ivp\n",
-      "\t cysolve_ivp = 486.34x SciPy\t cysolve_ivp = 11.78x pysolve_ivp\n",
+      "\t nbsolve_ivp = 135.56x SciPy\t nbsolve_ivp =  0.27x cysolve_ivp\n",
+      "\t pysolve_ivp = 41.78x SciPy\t pysolve_ivp =  0.08x cysolve_ivp\n",
+      "\t cysolve_ivp = 495.33x SciPy\t cysolve_ivp = 11.86x pysolve_ivp\n",
       "End Time: 1.0e+03\n",
-      "\t nbsolve_ivp = 119.73x SciPy\t nbsolve_ivp =  0.24x cysolve_ivp\n",
-      "\t pysolve_ivp = 41.18x SciPy\t pysolve_ivp =  0.08x cysolve_ivp\n",
-      "\t cysolve_ivp = 505.81x SciPy\t cysolve_ivp = 12.28x pysolve_ivp\n",
+      "\t nbsolve_ivp = 134.88x SciPy\t nbsolve_ivp =  0.27x cysolve_ivp\n",
+      "\t pysolve_ivp = 40.29x SciPy\t pysolve_ivp =  0.08x cysolve_ivp\n",
+      "\t cysolve_ivp = 502.51x SciPy\t cysolve_ivp = 12.47x pysolve_ivp\n",
       "End Time: 1.0e+04\n",
-      "\t nbsolve_ivp = 120.16x SciPy\t nbsolve_ivp =  0.24x cysolve_ivp\n",
-      "\t pysolve_ivp = 42.16x SciPy\t pysolve_ivp =  0.09x cysolve_ivp\n",
-      "\t cysolve_ivp = 491.82x SciPy\t cysolve_ivp = 11.67x pysolve_ivp\n"
+      "\t nbsolve_ivp = 116.16x SciPy\t nbsolve_ivp =  0.25x cysolve_ivp\n",
+      "\t pysolve_ivp = 39.70x SciPy\t pysolve_ivp =  0.09x cysolve_ivp\n",
+      "\t cysolve_ivp = 465.39x SciPy\t cysolve_ivp = 11.72x pysolve_ivp\n"
      ]
     }
    ],
diff --git a/Benchmarks/CyRK_CySolver.pdf b/Benchmarks/CyRK_CySolver.pdf
index 539c5da..e62df6d 100644
Binary files a/Benchmarks/CyRK_CySolver.pdf and b/Benchmarks/CyRK_CySolver.pdf differ
diff --git a/Benchmarks/CyRK_CySolver_DenseOn.pdf b/Benchmarks/CyRK_CySolver_DenseOn.pdf
new file mode 100644
index 0000000..e62df6d
Binary files /dev/null and b/Benchmarks/CyRK_CySolver_DenseOn.pdf differ
diff --git a/Benchmarks/CyRK_PySolver (njit).pdf b/Benchmarks/CyRK_PySolver (njit).pdf
index 4e3cf88..e62df6d 100644
Binary files a/Benchmarks/CyRK_PySolver (njit).pdf and b/Benchmarks/CyRK_PySolver (njit).pdf differ
diff --git a/Benchmarks/CyRK_PySolver.pdf b/Benchmarks/CyRK_PySolver.pdf
index 539c5da..e62df6d 100644
Binary files a/Benchmarks/CyRK_PySolver.pdf and b/Benchmarks/CyRK_PySolver.pdf differ
diff --git a/Benchmarks/CyRK_SciPy_Compare_predprey_v0-11-2.png b/Benchmarks/CyRK_SciPy_Compare_predprey_v0-11-2.png
deleted file mode 100644
index 2e40d70..0000000
Binary files a/Benchmarks/CyRK_SciPy_Compare_predprey_v0-11-2.png and /dev/null differ
diff --git a/Benchmarks/CyRK_SciPy_Compare_predprey_v0-11-3.png b/Benchmarks/CyRK_SciPy_Compare_predprey_v0-11-3.png
new file mode 100644
index 0000000..6d985cd
Binary files /dev/null and b/Benchmarks/CyRK_SciPy_Compare_predprey_v0-11-3.png differ
diff --git a/Benchmarks/CyRK_numba.pdf b/Benchmarks/CyRK_numba.pdf
index 042cc26..8485806 100644
Binary files a/Benchmarks/CyRK_numba.pdf and b/Benchmarks/CyRK_numba.pdf differ
diff --git a/Benchmarks/SciPy.pdf b/Benchmarks/SciPy.pdf
index 30d1571..5184586 100644
Binary files a/Benchmarks/SciPy.pdf and b/Benchmarks/SciPy.pdf differ
diff --git a/Benchmarks/archive/CyRK_SciPy_Compare_predprey_v0-11-2.png b/Benchmarks/archive/CyRK_SciPy_Compare_predprey_v0-11-2.png
new file mode 100644
index 0000000..900dc35
Binary files /dev/null and b/Benchmarks/archive/CyRK_SciPy_Compare_predprey_v0-11-2.png differ
diff --git a/CHANGES.md b/CHANGES.md
index f7e57f5..4ac2cad 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -2,6 +2,27 @@
 
 ## 2024
 
+#### v0.11.3 (2024-11-18)
+
+New:
+* Added helper function to allow users to include CyRK headers during installation. `CyRK.get_include()` this returns a list which must be appended to your include list in "setup.py".
+* Some minor performance improvements when using dense output or t_eval.
+* Added new cysolve_ivp C++ function, `baseline_cysolve_ivp_noreturn`, and cython wrapped version, `cysolve_ivp_noreturn`, that require the storage class as input (then modify it) rather than provide it as output.
+
+C++ Changes:
+* Major rework of the C++ Solver backend
+  * The `CySolverResult` storage structure is now the owner of: the solution data, the dense outputs, _and_ the solver itself (before the solver was stand alone). This ensures that the solver is alive for the dense outputs which, depending on settings, may need to make calls to the solver even after the integration is complete. 
+  * Removed many pointers in favor of direct access of variables. This was due to some variables moving and hanging pointers causing crashes.
+  * Drastically reduced the size of `CySolverDense` and moved its state data to a heap allocated array. This has led to large performance gains when `dense_output=True` for integrations requiring a large number of steps.
+* `num_y` and `num_extra` are now size_t type instead of unsigned ints.
+* `integration method` is not int instead of unsigned int.
+
+Fixes:
+* Fixed issue where if t_eval was less than t_end it could cause an access violation.
+* Fixed issue where dense output was sometimes being created twice when t_eval was provided.
+* Addressed several compile warnings.
+* Fixed issue where when t_eval is provided and dense output = true, cysolver may call a dense solution that has moved (hanging pointer).
+
 #### v0.11.2 (2024-11-12)
 
 New:
diff --git a/CyRK/__init__.pxd b/CyRK/__init__.pxd
index f28c9e1..1ee820f 100644
--- a/CyRK/__init__.pxd
+++ b/CyRK/__init__.pxd
@@ -1,2 +1,2 @@
-from CyRK.cy.cysolver_api cimport cysolve_ivp, cysolve_ivp_gil, DiffeqFuncType, PreEvalFunc, CySolverResult, WrapCySolverResult, CySolverBase, CySolveOutput, RK23_METHOD_INT, RK45_METHOD_INT, DOP853_METHOD_INT
+from CyRK.cy.cysolver_api cimport cysolve_ivp, cysolve_ivp_gil, cysolve_ivp_noreturn, DiffeqFuncType, PreEvalFunc, CySolverResult, WrapCySolverResult, CySolverBase, CySolveOutput, RK23_METHOD_INT, RK45_METHOD_INT, DOP853_METHOD_INT
 from CyRK.cy.helpers cimport interpolate_from_solution_list
\ No newline at end of file
diff --git a/CyRK/__init__.py b/CyRK/__init__.py
index 998a3b7..42419a5 100644
--- a/CyRK/__init__.py
+++ b/CyRK/__init__.py
@@ -14,4 +14,20 @@
 
 # Import python solver
 from CyRK.cy.cysolver_api import WrapCySolverResult
-from CyRK.cy.pysolver import pysolve_ivp
\ No newline at end of file
+from CyRK.cy.pysolver import pysolve_ivp
+
+# Helper function that provides directories to CyRK c++ headers
+def get_include():
+    import os
+    import CyRK
+    cyrk_dir = os.path.dirname(CyRK.__file__)
+
+    cyrk_dirs = list()
+    cyrk_dirs.append(
+        os.path.join(cyrk_dir, 'cy')  # CySolver headers
+    )
+    cyrk_dirs.append(
+        os.path.join(cyrk_dir, 'array')  # Array headers
+    )
+
+    return cyrk_dirs
diff --git a/CyRK/cy/common.cpp b/CyRK/cy/common.cpp
index a9f6d50..c685afd 100644
--- a/CyRK/cy/common.cpp
+++ b/CyRK/cy/common.cpp
@@ -18,8 +18,8 @@ void round_to_2(size_t &initial_value)
 }
 
 MaxNumStepsOutput find_max_num_steps(
-    const int num_y,
-    const int num_extra,
+    const size_t num_y,
+    const size_t num_extra,
     const size_t max_num_steps,
     const size_t max_ram_MB)
 {
@@ -57,8 +57,8 @@ MaxNumStepsOutput find_max_num_steps(
 
 
 size_t find_expected_size(
-    const int num_y,
-    const int num_extra,
+    const size_t num_y,
+    const size_t num_extra,
     const double t_delta_abs,
     const double rtol_min)
     /* Finds an expected size for storage arrays (length of time domain) that is suitable to the provided problem */
diff --git a/CyRK/cy/common.hpp b/CyRK/cy/common.hpp
index 0f83a9e..311569a 100644
--- a/CyRK/cy/common.hpp
+++ b/CyRK/cy/common.hpp
@@ -4,10 +4,10 @@
 #include <limits>
 
 // Pre-processor constants
-static const int Y_LIMIT      = 32;
-static const int DY_LIMIT     = 64;  // dy limit is defined by Y_LIMIT and number of extra output allowed. Typically we allow 2x the Y_LIMIT.
-static const int MESSAGE_SIZE = 128;
-static const int BUFFER_SIZE  = 16;
+static const size_t Y_LIMIT     = 32;
+static const size_t DY_LIMIT    = 64;  // dy limit is defined by Y_LIMIT and number of extra output allowed. Typically we allow 2x the Y_LIMIT.
+static const int MESSAGE_SIZE   = 128;
+static const size_t BUFFER_SIZE = 16;
 
 // Integration Constants
 // Multiply steps computed from asymptotic behaviour of errors by this.
@@ -60,14 +60,14 @@ struct MaxNumStepsOutput
 void round_to_2(size_t& initial_value);
 
 MaxNumStepsOutput find_max_num_steps(
-    const int num_y,
-    const int num_extra,
+    const size_t num_y,
+    const size_t num_extra,
     const size_t max_num_steps,
     const size_t max_ram_MB);
 
 
 size_t find_expected_size(
-    int num_y,
-    int num_extra,
+    size_t num_y,
+    size_t num_extra,
     double t_delta_abs,
     double rtol_min);
diff --git a/CyRK/cy/cysolution.cpp b/CyRK/cy/cysolution.cpp
index 603c3cf..aa5f639 100644
--- a/CyRK/cy/cysolution.cpp
+++ b/CyRK/cy/cysolution.cpp
@@ -10,30 +10,38 @@ CySolverResult::CySolverResult()
 }
 
 CySolverResult::CySolverResult(
-        const int num_y,
-        const int num_extra,
+        const size_t num_y,
+        const size_t num_extra,
         const size_t expected_size,
         const double last_t,
         const bool direction_flag,
         const bool capture_dense_output,
         const bool t_eval_provided) :
             last_t(last_t),
-            num_extra(num_extra),
             capture_dense_output(capture_dense_output),
             t_eval_provided(t_eval_provided),
             direction_flag(direction_flag),
             error_code(0),
-            num_y(num_y)
+            num_y(num_y),
+            num_extra(num_extra)
 {
-    // Round expected size and store it.
-    this->original_expected_size = expected_size;
-    round_to_2(this->original_expected_size);
-
     // num_dy will be larger than num_y if the user wishes to capture extra output during integration.
     this->capture_extra = this->num_extra > 0;
     this->num_dy        = this->num_y + this->num_extra;
     this->num_dy_dbl    = (double)this->num_dy;
+    this->set_expected_size(expected_size);
 
+    // If save dense is true and capture extra is true then the dense solutions need to retain the solver to make
+    // additional calls to the diffeq. Make sure that the solution class does not delete the solver during finalization.
+    if (this->capture_dense_output && this->capture_extra)
+    {
+        this->retain_solver = true;
+    }
+    
+    // Get solution class ready to go
+    this->reset();
+
+    
     // Initialize other parameters
     this->update_message("CySolverResult Initialized.");
 }
@@ -42,27 +50,27 @@ CySolverResult::CySolverResult(
 // Deconstructors
 CySolverResult::~CySolverResult()
 {
-    // Vector header inforamtion is stack allocated, no need to delete them.
-    // The data itself is heap allocated but the vector class will handle that.
+    this->p_delete_heap();
+}
 
-    // Need to delete the heap allocated dense solutions
-    if (this->capture_dense_output)
-    {
-        for (size_t i = 0; i < this->num_interpolates; i++)
-        {
-            if (this->dense_vector[i]) [[likely]]
-            {
-                delete this->dense_vector[i];
-            }
-        }
-    }
+void CySolverResult::p_delete_heap()
+{
+    // Instruct the heap allocated vectors to start deconstructing.
+    this->dense_vec.clear();
+    this->interp_time_vec.clear();
+    this->time_domain_vec.clear();
+    this->time_domain_vec_sorted.clear();
+    this->solution.clear();
+
+    // Need to delete the solver
+    this->solver_uptr.reset();
 }
 
 
 // Protected methods
 void CySolverResult::p_expand_data_storage()
 {
-    double new_storage_size_dbl = std::floor(DYNAMIC_GROWTH_RATE * this->storage_capacity);
+    double new_storage_size_dbl = std::floor(DYNAMIC_GROWTH_RATE * (double)this->storage_capacity);
 
     // Check if this new size is okay.
     if ((new_storage_size_dbl / this->num_dy_dbl) > SIZE_MAX_DBL) [[unlikely]]
@@ -74,13 +82,22 @@ void CySolverResult::p_expand_data_storage()
     {
         this->storage_capacity = (size_t)new_storage_size_dbl;
         // Ensure there is enough new room for the new size.
-        this->storage_capacity = std::max<size_t>(this->storage_capacity, this->size + 1);
+        this->storage_capacity = std::max<size_t>(this->storage_capacity, std::max<size_t>(this->size, this->num_interpolates) + 1);
 
         round_to_2(this->storage_capacity);
         try
         {
-            this->time_domain.reserve(this->storage_capacity);
+            this->time_domain_vec.reserve(this->storage_capacity);
             this->solution.reserve(this->storage_capacity * this->num_dy);
+            if (this->capture_dense_output)
+            {
+                this->dense_vec.reserve(this->storage_capacity);
+            }
+            if (this->t_eval_provided)
+            {
+                this->interp_time_vec.reserve(this->storage_capacity);
+            }
+            
         }
         catch (std::bad_alloc const&)
         {
@@ -90,70 +107,71 @@ void CySolverResult::p_expand_data_storage()
     }
 }
 
-void CySolverResult::p_expand_dense_storage()
+void CySolverResult::p_offload_data()
 {
-    double new_storage_size_dbl = std::floor(DYNAMIC_GROWTH_RATE * this->dense_storage_capacity);
+    /*
+    * Saves integration data that were temporarily held in buffers to heap-allocated vectors.
+    */
 
-    // Check if this new size is okay.
-    if ((new_storage_size_dbl) > SIZE_MAX_DBL) [[unlikely]]
+    this->size += this->current_data_buffer_size;
+
+    if (this->size > this->storage_capacity)
     {
-        this->error_code = -12;
-        this->update_message("Value Error: Requested new vector size is larger than the limits set by the system (specifically the max of size_t).");
+        // There is not enough room in the storage vectors. Expand them.
+        this->p_expand_data_storage();
     }
-    else
-    {
-        this->dense_storage_capacity = (size_t)new_storage_size_dbl;
-        // Ensure there is enough new room for the new size.
-        this->dense_storage_capacity = std::max<size_t>(this->dense_storage_capacity, this->num_interpolates + 1);
 
-        round_to_2(this->dense_storage_capacity);
-        try
-        {
-            this->dense_vector.reserve(this->dense_storage_capacity);
-            if (this->t_eval_provided)
-            {
-                this->interp_time.reserve(this->dense_storage_capacity);
-            }
-        }
-        catch (std::bad_alloc const&)
-        {
-            this->error_code = -22;
-            this->update_message("Memory Error: Malloc failed when reserving additional memory for dense vectors.");
-        }
-    }
+    // Save time results
+    this->time_domain_vec.insert(this->time_domain_vec.end(), this->data_buffer_time_ptr, this->data_buffer_time_ptr + this->current_data_buffer_size);
+
+    // Save y results and any extra output
+    this->solution.insert(this->solution.end(), this->data_buffer_y_ptr, this->data_buffer_y_ptr + (this->num_dy * this->current_data_buffer_size));
+
+    // Reset buffers
+    this->current_data_buffer_size = 0;
 }
 
+
 // Public methods
+void CySolverResult::set_expected_size(size_t expected_size)
+{
+    // Round expected size and store it.
+    this->original_expected_size = expected_size;
+    round_to_2(this->original_expected_size);
+}
+
 void CySolverResult::reset()
 {
-    // Inititalize the storage array
+    // Initialize the storage array
     if (this->reset_called) [[unlikely]]
     {
         // The storage array may have already been set. Delete any data and reset it.
-        this->time_domain.clear();
+        this->time_domain_vec.clear();
         this->solution.clear();
-        if (this->capture_dense_output)
-        {
-            this->dense_vector.clear();
-        }
+
+        // Ensure any previous heap allocated data is deleted
+        this->p_delete_heap();
     }
 
     // Set the storage size to the original expected size.
-    this->storage_capacity       = this->original_expected_size;
-    this->dense_storage_capacity = this->original_expected_size;
+    this->storage_capacity = this->original_expected_size;
+
+    // Reset buffer trackers
+    this->current_data_buffer_size  = 0;
+    this->num_interpolates          = 0;
 
     // Reserve the memory for the vectors
     try
     {
-        this->time_domain.reserve(this->storage_capacity);
+        this->time_domain_vec.reserve(this->storage_capacity);
         this->solution.reserve(this->storage_capacity * this->num_dy);
         if (this->capture_dense_output)
         {
-            this->dense_vector.reserve(this->dense_storage_capacity);
+            this->dense_vec.reserve(this->storage_capacity);
         }
         if (this->t_eval_provided)
         {
-            this->interp_time.reserve(this->dense_storage_capacity);
+            this->interp_time_vec.reserve(this->storage_capacity);
         }
     }
     catch (std::bad_alloc const&)
@@ -162,58 +180,105 @@ void CySolverResult::reset()
         this->update_message("Memory Error: Malloc failed when reserving initial memory for storage vectors.\n");
     }
 
+    // Make sure the solver is back to t=0
+    this->solver_reset_called = false;
+
+    // Mark that we have allocated memory so it can be cleared if reset is called again.
     this->reset_called = true;
 }
 
-void CySolverResult::p_offload_data()
+void CySolverResult::build_solver(
+        DiffeqFuncType diffeq_ptr,
+        const double t_start,
+        const double t_end,
+        const double* y0_ptr,
+        const int method,
+        // General optional arguments
+        const size_t expected_size,
+        const void* args_ptr,
+        const size_t max_num_steps,
+        const size_t max_ram_MB,
+        const bool dense_output,
+        const double* t_eval,
+        const size_t len_t_eval,
+        PreEvalFunc pre_eval_func,
+        // rk optional arguments
+        const double rtol,
+        const double atol,
+        const double* rtols_ptr,
+        const double* atols_ptr,
+        const double max_step_size,
+        const double first_step_size
+    )
 {
-    /*
-    * Saves integration data that were temporarily held in buffers to heap-allocated vectors.
-    */
-
-    this->size += this->current_data_buffer_size;
-
-    if (this->size > this->storage_capacity)
+    // Make sure the solver pointer is empty.
+    if (this->solver_uptr)
     {
-        // There is not enough room in the storage vectors. Expand them.
-        this->p_expand_data_storage();
+        this->solver_uptr.reset();
     }
+    
+    this->integrator_method = method;
 
-    // Save time results
-    this->time_domain.insert(this->time_domain.end(), this->data_buffer_time_ptr, this->data_buffer_time_ptr + this->current_data_buffer_size);
-
-    // Save y results and any extra output
-    this->solution.insert(this->solution.end(), this->data_buffer_y_ptr, this->data_buffer_y_ptr + (this->num_dy * this->current_data_buffer_size));
-
-    // Reset buffers
-    this->current_data_buffer_size = 0;
+    switch (this->integrator_method)
+    {
+    case 0:
+        // RK23
+        this->solver_uptr = std::make_unique<RK23>(
+            // Common Inputs
+            diffeq_ptr, this->shared_from_this(), t_start, t_end, y0_ptr,
+            this->num_y, this->num_extra, args_ptr, max_num_steps, max_ram_MB,
+            this->capture_dense_output, t_eval, len_t_eval, pre_eval_func,
+            // RK Inputs
+            rtol, atol, rtols_ptr, atols_ptr, max_step_size, first_step_size
+        );
+        break;
+    case 1:
+        // RK45
+        this->solver_uptr = std::make_unique<RK45>(
+            // Common Inputs
+            diffeq_ptr, this->shared_from_this(), t_start, t_end, y0_ptr, num_y,
+            this->num_extra, args_ptr, max_num_steps, max_ram_MB,
+            this->capture_dense_output, t_eval, len_t_eval, pre_eval_func,
+            // RK Inputs
+            rtol, atol, rtols_ptr, atols_ptr, max_step_size, first_step_size
+        );
+        break;
+    case 2:
+        // DOP853
+        this->solver_uptr = std::make_unique<DOP853>(
+            // Common Inputs
+            diffeq_ptr, this->shared_from_this(), t_start, t_end, y0_ptr, num_y,
+            this->num_extra, args_ptr, max_num_steps, max_ram_MB,
+            this->capture_dense_output, t_eval, len_t_eval, pre_eval_func,
+            // RK Inputs
+            rtol, atol, rtols_ptr, atols_ptr, max_step_size, first_step_size
+        );
+        break;
+    [[unlikely]] default:
+        this->solver_uptr.reset();
+        this->success    = false;
+        this->error_code = -3;
+        this->update_message("Model Error: Not implemented or unknown CySolver model requested.\n");
+        break;
+    }
 }
 
-void CySolverResult::p_offload_dense()
-{
-    /*
-    * Saves dense solution interpolants that were temporarily held in buffers to heap-allocated vectors.
-    */
-
-    this->num_interpolates += this->current_dense_buffer_size;
-
-    if (this->num_interpolates > this->dense_storage_capacity)
+void CySolverResult::reset_solver()
+{   
+    if (this->solver_uptr.get())
     {
-        // There is not enough room in the storage vectors. Expand them.
-        this->p_expand_dense_storage();
-    }
+        // Prepare solver for integration by setting to t=0
+        this->solver_uptr->reset();
 
-    // Save dense output interpolants
-    this->dense_vector.insert(this->dense_vector.end(), this->data_buffer_dense_ptr, this->data_buffer_dense_ptr + this->current_dense_buffer_size);
+        // Setup a single heap allocated dense solver if it is needed.
+        if (t_eval_provided && !this->capture_dense_output)
+        {
+            this->dense_vec.emplace_back(this->integrator_method, this->solver_uptr.get(), false);
+            this->num_interpolates++;
+        }
 
-    // Offload interpolated times
-    if (this->t_eval_provided)
-    {
-        this->interp_time.insert(this->interp_time.end(), this->data_buffer_interp_time_ptr, this->data_buffer_interp_time_ptr + this->current_dense_buffer_size);
+        this->solver_reset_called = true;
     }
-
-    // Reset buffers
-    this->current_dense_buffer_size = 0;
 }
 
 void CySolverResult::save_data(const double new_t, double* const new_solution_y_ptr, double* const new_solution_dy_ptr)
@@ -229,7 +294,7 @@ void CySolverResult::save_data(const double new_t, double* const new_solution_y_
     this->data_buffer_time_ptr[this->current_data_buffer_size] = new_t;
 
     // Save y
-    unsigned int stride = this->current_data_buffer_size * this->num_dy;  // We have to stride across num_dy even though we are only saving num_y values.
+    size_t stride = this->current_data_buffer_size * this->num_dy;  // We have to stride across num_dy even though we are only saving num_y values.
     std::memcpy(&this->data_buffer_y_ptr[stride], new_solution_y_ptr, sizeof(double) * this->num_y);
 
     // Save extra
@@ -241,25 +306,63 @@ void CySolverResult::save_data(const double new_t, double* const new_solution_y_
     this->current_data_buffer_size++;
 }
 
-void CySolverResult::save_dense(const double sol_t, CySolverDense* dense_output_ptr)
+int CySolverResult::build_dense(bool save)
 {
-    // Check if our data buffer is full
-    if (this->current_dense_buffer_size >= BUFFER_SIZE)
+    if (!this->solver_uptr) [[unlikely]]
     {
-        this->p_offload_dense();
+        return -1;
     }
 
-    // Save data in buffer
-    // Save interpolates
-    this->data_buffer_dense_ptr[this->current_dense_buffer_size] = dense_output_ptr;
+    if (save)
+    {
+        this->num_interpolates++;
+        if (this->num_interpolates > this->storage_capacity)
+        {
+            // There is not enough room in the storage vectors. Expand them.
+            this->p_expand_data_storage();
+        }
 
-    // Save interpolated time (if t_eval was provided)
-    if (this->t_eval_provided)
+        // We need to heap allocate the dense solution
+        this->dense_vec.emplace_back(this->integrator_method, this->solver_uptr.get(), true);
+
+        // Save interpolated time (if t_eval was provided)
+        if (this->t_eval_provided)
+        {
+            this->interp_time_vec.push_back(this->solver_uptr->t_now);
+        }
+
+        return 1;
+    }
+    else
+    {
+        // Don't need to save. Use the single dense vector that is on the heap. 
+        // Need to update its state to match the current solver state.
+        this->dense_vec[0].set_state();
+
+        return 1;
+    }
+}
+
+void CySolverResult::solve()
+{
+    if (!this->reset_called) [[unlikely]]
     {
-        this->data_buffer_interp_time_ptr[this->current_dense_buffer_size] = sol_t;
+        this->reset();
     }
 
-    this->current_dense_buffer_size++;
+    if (this->solver_uptr)
+    {
+        if (!this->solver_reset_called)
+        {
+            this->reset_solver();
+        }
+    
+        // Tell the solver to starting solving the problem!
+        this->solver_uptr->solve();
+        
+        // Call the finalizer on the storage class instance
+        this->finalize();
+    }
 }
 
 void CySolverResult::finalize()
@@ -269,17 +372,13 @@ void CySolverResult::finalize()
     {
         this->p_offload_data();
     }
-    if (this->current_dense_buffer_size > 0)
-    {
-        this->p_offload_dense();
-    }
-    
+
     // Shrink vectors
     if (this->size > 100000)
     {
         // There is a lot of data. Let's make sure the vectors are not eating up too much memory if its not needed.
         // If there is not that much data then its not worth the performance hit of shrinking the arrays.
-        this->time_domain.shrink_to_fit();
+        this->time_domain_vec.shrink_to_fit();
         this->solution.shrink_to_fit();
     }
 
@@ -287,11 +386,11 @@ void CySolverResult::finalize()
     {
         if (this->capture_dense_output)
         {
-            this->dense_vector.shrink_to_fit();
+            this->dense_vec.shrink_to_fit();
         }
         if (this->t_eval_provided)
         {
-            this->interp_time.shrink_to_fit();
+            this->interp_time_vec.shrink_to_fit();
         }
     }
 
@@ -301,11 +400,11 @@ void CySolverResult::finalize()
         // Forward integration. We are already sorted.
         if (this->t_eval_provided)
         {
-            this->time_domain_sorted_ptr = this->interp_time.data();
+            this->time_domain_vec_sorted_ptr = &this->interp_time_vec;
         }
         else
         {
-            this->time_domain_sorted_ptr = this->time_domain.data();
+            this->time_domain_vec_sorted_ptr = &this->time_domain_vec;
         }
     }
     else
@@ -313,15 +412,15 @@ void CySolverResult::finalize()
         // Not sorted. Reverse time domain into new storage.
         if (this->t_eval_provided)
         {
-            this->time_domain_sorted.resize(this->interp_time.size());
-            std::reverse_copy(this->interp_time.begin(), this->interp_time.end(), this->time_domain_sorted.begin());
+            this->time_domain_vec_sorted.resize(this->interp_time_vec.size());
+            std::reverse_copy(this->interp_time_vec.begin(), this->interp_time_vec.end(), this->time_domain_vec_sorted.begin());
         }
         else
         {
-            this->time_domain_sorted.resize(this->time_domain.size());
-            std::reverse_copy(this->time_domain.begin(), this->time_domain.end(), this->time_domain_sorted.begin());
+            this->time_domain_vec_sorted.resize(this->time_domain_vec.size());
+            std::reverse_copy(this->time_domain_vec.begin(), this->time_domain_vec.end(), this->time_domain_vec_sorted.begin());
         }
-        this->time_domain_sorted_ptr = this->time_domain_sorted.data();
+        this->time_domain_vec_sorted_ptr = &this->time_domain_vec_sorted;
     }
 
     // Check if the integrator finished
@@ -329,6 +428,22 @@ void CySolverResult::finalize()
     {
         this->success = true;
     }
+
+    // Delete the solver if we don't need it anymore
+    if (!this->retain_solver && this->solver_uptr)
+    {
+        // Reset the cysolver smart pointer in this class.
+        this->solver_uptr.reset();
+
+        // Make sure that any dense outputs also have their ptr's nulled.
+        if (capture_dense_output)
+        {
+            for (size_t i = 0; i < this->dense_vec.size(); i++)
+            {
+                this->dense_vec[i].solver_ptr = nullptr;
+            }
+        }
+    }
 }
 
 void CySolverResult::update_message(const char* const new_message_ptr)
@@ -345,14 +460,14 @@ void CySolverResult::call(const double t, double* y_interp_ptr)
     }
     else
     {
-        size_t interp_time_len_touse = 0;
+        size_t interp_time_vec_len_touse = 0;
         if (this->t_eval_provided)
         {
-            interp_time_len_touse = this->num_interpolates;
+            interp_time_vec_len_touse = this->num_interpolates;
         }
         else
         {
-            interp_time_len_touse = this->size;
+            interp_time_vec_len_touse = this->size;
         }
         // SciPy uses np.searchedsorted which as far as I can tell works the same as bibnary search with guess
         // Except that it is searchedsorted is 1 more than binary search.
@@ -363,15 +478,16 @@ void CySolverResult::call(const double t, double* y_interp_ptr)
 
         // Check if there are any t_eval steps between this new index and the last index.
         // Get lowest and highest indices
+        double* time_domain_sorted_ptr = this->time_domain_vec_sorted_ptr->data();
         auto lower_i = std::lower_bound(
-            this->time_domain_sorted_ptr,
-            this->time_domain_sorted_ptr + interp_time_len_touse,
-            t) - this->time_domain_sorted_ptr;
+            time_domain_sorted_ptr,
+            time_domain_sorted_ptr + interp_time_vec_len_touse,
+            t) - time_domain_sorted_ptr;
     
         auto upper_i = std::upper_bound(
-            this->time_domain_sorted_ptr,
-            this->time_domain_sorted_ptr + interp_time_len_touse,
-            t) - this->time_domain_sorted_ptr;
+            time_domain_sorted_ptr,
+            time_domain_sorted_ptr + interp_time_vec_len_touse,
+            t) - time_domain_sorted_ptr;
         
         if (lower_i == upper_i)
         {
@@ -392,16 +508,16 @@ void CySolverResult::call(const double t, double* y_interp_ptr)
         // Clean up closest index
         if (this->direction_flag)
         {
-            closest_index = std::min<size_t>(std::max<size_t>(closest_index, 0), interp_time_len_touse - 1);
+            closest_index = std::min<size_t>(std::max<size_t>(closest_index, 0), interp_time_vec_len_touse - 1);
         }
         else
         {
-            closest_index = interp_time_len_touse - closest_index - 1;
-            closest_index = std::min<size_t>(std::max<size_t>(closest_index, 1), interp_time_len_touse - 1);
+            closest_index = interp_time_vec_len_touse - closest_index - 1;
+            closest_index = std::min<size_t>(std::max<size_t>(closest_index, 1), interp_time_vec_len_touse - 1);
         }
 
         // Call interpolant to update y
-        this->dense_vector[closest_index]->call(t, y_interp_ptr);
+        this->dense_vec[closest_index].call(t, y_interp_ptr);
     }
 }
 
diff --git a/CyRK/cy/cysolution.hpp b/CyRK/cy/cysolution.hpp
index 08188e2..fa6c633 100644
--- a/CyRK/cy/cysolution.hpp
+++ b/CyRK/cy/cysolution.hpp
@@ -6,10 +6,12 @@
 #include <algorithm>
 
 #include "common.hpp"
-#include "dense.hpp"
 #include "cy_array.hpp"
+#include "dense.hpp"
+#include "cysolver.hpp"
+#include "rk.hpp"
 
-class CySolverResult {
+class CySolverResult : public std::enable_shared_from_this<CySolverResult>{
 
 // Attributes
 protected:
@@ -19,32 +21,29 @@ class CySolverResult {
     // Current storage information
     size_t original_expected_size = 0;
     size_t storage_capacity       = 0;
-    size_t dense_storage_capacity = 0;
 
     // Buffer
-    unsigned int current_data_buffer_size  = 0;
-    unsigned int current_dense_buffer_size = 0;
-    double* data_buffer_time_ptr           = &data_buffer_time[0];
-    double* data_buffer_y_ptr              = &data_buffer_y[0];
-    double* data_buffer_interp_time_ptr    = &data_buffer_interp_time[0];
-    CySolverDense** data_buffer_dense_ptr  = &data_buffer_dense_output[0];
+    size_t current_data_buffer_size  = 0;
+    double* data_buffer_time_ptr     = &data_buffer_time[0];
+    double* data_buffer_y_ptr        = &data_buffer_y[0];
     
     // Metadata
-    double last_t          = 0;
-    double num_dy_dbl      = 0.0;
-    unsigned int num_extra = 0;
+    double last_t     = 0;
+    double num_dy_dbl = 0.0;
 
 public:
     // Storage for arrays
     bool capture_extra = false;
+    bool retain_solver = false;
     
     // Dense Output
     bool capture_dense_output = false;
     bool t_eval_provided      = false;
 
     // Status information
-    bool success      = false;
-    bool reset_called = false;
+    bool success             = false;
+    bool reset_called        = false;
+    bool solver_reset_called = false;
 
     // Integration direction
     bool direction_flag = true;
@@ -58,9 +57,11 @@ class CySolverResult {
     // -50   : Error calling cython wrapper function from PySolver.
     int error_code = -999;
 
-    // Metadata
-    unsigned int num_y    = 0;
-    unsigned int num_dy   = 0;
+    // Meta data
+    int integrator_method = -1;
+    size_t num_y     = 0;
+    size_t num_extra = 0;
+    size_t num_dy    = 0;
 
     // More status information
     char* message_ptr = &message[0];
@@ -68,47 +69,73 @@ class CySolverResult {
     size_t num_interpolates = 0;
 
     // Pointer to storage arrays
-    std::vector<double> time_domain        = std::vector<double>(0);
-    std::vector<double> time_domain_sorted = std::vector<double>(0);
-    std::vector<double> solution           = std::vector<double>(0);
-    double* time_domain_sorted_ptr         = time_domain.data();
-
+    std::vector<double> time_domain_vec        = std::vector<double>();
+    std::vector<double> time_domain_vec_sorted = std::vector<double>();
+    std::vector<double> solution               = std::vector<double>();
+    std::vector<double>* time_domain_vec_sorted_ptr = nullptr;
+    
     // Dense output array
-    std::vector<CySolverDense*> dense_vector = std::vector<CySolverDense*>(0);
+    std::vector<CySolverDense> dense_vec = std::vector<CySolverDense>();  // Heap allocated dense solutions for when the user needs these saved.
+
+    // Solver storage
+    std::unique_ptr<CySolverBase> solver_uptr = nullptr;
 
     // Interpolant time array (used if t_eval is provided)
-    std::vector<double> interp_time = std::vector<double>(0);
+    std::vector<double> interp_time_vec = std::vector<double>();
 
 private:
     // Put data buffers at the end of memory stack
     double data_buffer_time[BUFFER_SIZE]                 = { };
     double data_buffer_y[BUFFER_SIZE * DY_LIMIT]         = { };
-    CySolverDense* data_buffer_dense_output[BUFFER_SIZE] = { };
-    double data_buffer_interp_time[BUFFER_SIZE]          = { };
 
 
 // Methods
 protected:
+    void p_delete_heap();
     void p_expand_data_storage();
-    void p_expand_dense_storage();
     void p_offload_data();
-    void p_offload_dense();
 
 public:
     virtual ~CySolverResult();
     CySolverResult();
     CySolverResult(
-        const int num_y,
-        const int num_extra,
+        const size_t num_y,
+        const size_t num_extra,
         const size_t expected_size,
         const double last_t,
         const bool direction_flag,
         const bool capture_dense_output,
         const bool t_eval_provided);
     void save_data(const double new_t, double* const new_solution_y_ptr, double* const new_solution_dy_ptr);
-    void save_dense(const double sol_t, CySolverDense* dense_output_ptr);
+    int build_dense(bool save);
+    void solve();
     void finalize();
+    void set_expected_size(size_t expected_size);
     void reset();
+    void reset_solver();
+    void build_solver(
+        DiffeqFuncType diffeq_ptr,
+        const double t_start,
+        const double t_end,
+        const double* y0_ptr,
+        const int method,
+        // General optional arguments
+        const size_t expected_size,
+        const void* args_ptr,
+        const size_t max_num_steps,
+        const size_t max_ram_MB,
+        const bool dense_output,
+        const double* t_eval,
+        const size_t len_t_eval,
+        PreEvalFunc pre_eval_func,
+        // rk optional arguments
+        const double rtol,
+        const double atol,
+        const double* rtols_ptr,
+        const double* atols_ptr,
+        const double max_step_size,
+        const double first_step_size
+    );
     void update_message(const char* const new_message_ptr);
     void call(const double t, double* y_interp_ptr);
     void call_vectorize(const double* t_array_ptr, size_t len_t, double* y_interp_ptr);
diff --git a/CyRK/cy/cysolve.cpp b/CyRK/cy/cysolve.cpp
index 68bccf9..92823f5 100644
--- a/CyRK/cy/cysolve.cpp
+++ b/CyRK/cy/cysolve.cpp
@@ -1,30 +1,31 @@
 #include "cysolve.hpp"
+#include <exception>
 
-
-std::shared_ptr<CySolverResult> baseline_cysolve_ivp(
-    DiffeqFuncType diffeq_ptr,
-    const double* t_span_ptr,
-    const double* y0_ptr,
-    const unsigned int num_y,
-    const unsigned int method,
-    // General optional arguments
-    const size_t expected_size,
-    const unsigned int num_extra,
-    const void* args_ptr,
-    const size_t max_num_steps,
-    const size_t max_ram_MB,
-    const bool dense_output,
-    const double* t_eval,
-    const size_t len_t_eval,
-    PreEvalFunc pre_eval_func,
-    // rk optional arguments
-    const double rtol,
-    const double atol,
-    const double* rtols_ptr,
-    const double* atols_ptr,
-    const double max_step_size,
-    const double first_step_size
-)
+void baseline_cysolve_ivp_noreturn(
+        std::shared_ptr<CySolverResult> solution_sptr,
+        DiffeqFuncType diffeq_ptr,
+        const double* t_span_ptr,
+        const double* y0_ptr,
+        const size_t num_y,
+        const int method,
+        // General optional arguments
+        const size_t expected_size,
+        const size_t num_extra,
+        const void* args_ptr,
+        const size_t max_num_steps,
+        const size_t max_ram_MB,
+        const bool dense_output,
+        const double* t_eval,
+        const size_t len_t_eval,
+        PreEvalFunc pre_eval_func,
+        // rk optional arguments
+        const double rtol,
+        const double atol,
+        const double* rtols_ptr,
+        const double* atols_ptr,
+        const double max_step_size,
+        const double first_step_size
+    )
 {
     // Parse input
     const double t_start       = t_span_ptr[0];
@@ -40,7 +41,7 @@ std::shared_ptr<CySolverResult> baseline_cysolve_ivp(
         if (rtols_ptr)
         {
             // rtol for each y
-            for (unsigned int y_i = 0; y_i < num_y; y_i++)
+            for (size_t y_i = 0; y_i < num_y; y_i++)
             {
                 double rtol_tmp = rtols_ptr[y_i];
                 if (rtol_tmp < EPS_100)
@@ -62,119 +63,154 @@ std::shared_ptr<CySolverResult> baseline_cysolve_ivp(
         expected_size_touse = find_expected_size(num_y, num_extra, std::fabs(t_end - t_start), min_rtol);
     }
 
+    // Set the expected size of the arrays
+    solution_sptr->set_expected_size(expected_size_touse);
+
+    // Setup solver class
+    solution_sptr->build_solver(
+        diffeq_ptr,
+        t_start,
+        t_end,
+        y0_ptr,
+        method,
+        // General optional arguments
+        expected_size,
+        args_ptr,
+        max_num_steps,
+        max_ram_MB,
+        dense_output,
+        t_eval,
+        len_t_eval,
+        pre_eval_func,
+        // rk optional arguments
+        rtol,
+        atol,
+        rtols_ptr,
+        atols_ptr,
+        max_step_size,
+        first_step_size
+    );
+    // Run integrator
+    solution_sptr->solve();
+}
+
+std::shared_ptr<CySolverResult> baseline_cysolve_ivp(
+        DiffeqFuncType diffeq_ptr,
+        const double* t_span_ptr,
+        const double* y0_ptr,
+        const size_t num_y,
+        const int method,
+        // General optional arguments
+        const size_t expected_size,
+        const size_t num_extra,
+        const void* args_ptr,
+        const size_t max_num_steps,
+        const size_t max_ram_MB,
+        const bool dense_output,
+        const double* t_eval,
+        const size_t len_t_eval,
+        PreEvalFunc pre_eval_func,
+        // rk optional arguments
+        const double rtol,
+        const double atol,
+        const double* rtols_ptr,
+        const double* atols_ptr,
+        const double max_step_size,
+        const double first_step_size
+    )
+{
+    const double t_start       = t_span_ptr[0];
+    const double t_end         = t_span_ptr[1];
+    const bool direction_flag  = t_start <= t_end ? true : false;
+    const bool t_eval_provided = t_eval ? true : false;
+
     // Build storage class
-    std::shared_ptr<CySolverResult> solution_ptr =
+    std::shared_ptr<CySolverResult> solution_sptr =
         std::make_shared<CySolverResult>(
             num_y,
             num_extra,
-            expected_size_touse,
+            expected_size,
             t_end,
             direction_flag,
             dense_output,
             t_eval_provided);
 
-    // Build solver class
-    CySolverBase* solver;
-
-    switch (method)
-    {
-    case 0:
-        // RK23
-        solver = new RK23(
-            // Common Inputs
-            diffeq_ptr, solution_ptr, t_start, t_end, y0_ptr, num_y, num_extra, args_ptr, max_num_steps, max_ram_MB,
-            dense_output, t_eval, len_t_eval, pre_eval_func,
-            // RK Inputs
-            rtol, atol, rtols_ptr, atols_ptr, max_step_size, first_step_size
-        );
-        break;
-    case 1:
-        // RK45
-        solver = new RK45(
-            // Common Inputs
-            diffeq_ptr, solution_ptr, t_start, t_end, y0_ptr, num_y, num_extra, args_ptr, max_num_steps, max_ram_MB,
-            dense_output, t_eval, len_t_eval, pre_eval_func,
-            // RK Inputs
-            rtol, atol, rtols_ptr, atols_ptr, max_step_size, first_step_size
-        );
-        break;
-    case 2:
-        // DOP853
-        solver = new DOP853(
-            // Common Inputs
-            diffeq_ptr, solution_ptr, t_start, t_end, y0_ptr, num_y, num_extra, args_ptr, max_num_steps, max_ram_MB,
-            dense_output, t_eval, len_t_eval, pre_eval_func,
-            // RK Inputs
-            rtol, atol, rtols_ptr, atols_ptr, max_step_size, first_step_size
-        );
-        break;
-    [[unlikely]] default:
-        solution_ptr->success = false;
-        solution_ptr->error_code = -3;
-        solution_ptr->update_message("Model Error: Not implemented or unknown CySolver model requested.\n");
-        return solution_ptr;
-        break;
-    }
-
-    // Call reset on solver
-    solver->reset();
-
-    // Run integrator
-    solver->solve();
-
-    // Finalize solution storage
-    solution_ptr->finalize();
-
-    // Delete solver instance
-    delete solver;
+    // Run
+    baseline_cysolve_ivp_noreturn(
+        solution_sptr,
+        diffeq_ptr,
+        t_span_ptr,
+        y0_ptr,
+        num_y,
+        method,
+        // General optional arguments
+        expected_size,
+        num_extra,
+        args_ptr,
+        max_num_steps,
+        max_ram_MB,
+        dense_output,
+        t_eval,
+        len_t_eval,
+        pre_eval_func,
+        // rk optional arguments
+        rtol,
+        atol,
+        rtols_ptr,
+        atols_ptr,
+        max_step_size,
+        first_step_size
+    );
 
     // Return the results
-    return solution_ptr;
+    return solution_sptr;
 }
 
 
 /* Pure Python hook solvers and helpers */
-PySolver::PySolver() { }
+PySolver::PySolver()
+{
+
+}
+
 PySolver::~PySolver()
 {
-    if (this->solver)
-    {
-        delete this->solver;
-    }
+
 }
-PySolver::PySolver(
-    unsigned int integration_method,
-    // Cython class instance used for pyhook
-    PyObject* cython_extension_class_instance,
-    DiffeqMethod cython_extension_class_diffeq_method,
-    // Regular integrator inputs
-    std::shared_ptr<CySolverResult> solution_ptr,
-    const double t_start,
-    const double t_end,
-    const double* y0_ptr,
-    const unsigned int num_y,
-    // General optional arguments
-    const unsigned int num_extra,
-    const void* args_ptr,
-    const size_t max_num_steps,
-    const size_t max_ram_MB,
-    const bool dense_output,
-    const double* t_eval,
-    const size_t len_t_eval,
-    // rk optional arguments
-    const double rtol,
-    const double atol,
-    const double* rtols_ptr,
-    const double* atols_ptr,
-    const double max_step_size,
-    const double first_step_size) :
-        status(0),
-        integration_method(integration_method)
 
-{   
-    // Save reference to solution pointer
-    this->solution_ptr = solution_ptr;
 
+PySolver::PySolver(
+        int integration_method,
+        // Cython class instance used for pyhook
+        PyObject* cython_extension_class_instance,
+        DiffeqMethod cython_extension_class_diffeq_method,
+        // Regular integrator inputs
+        std::shared_ptr<CySolverResult> solution_sptr,
+        const double t_start,
+        const double t_end,
+        const double* y0_ptr,
+        const size_t num_y,
+        // General optional arguments
+        const size_t expected_size,
+        const size_t num_extra,
+        const void* args_ptr,
+        const size_t max_num_steps,
+        const size_t max_ram_MB,
+        const bool dense_output,
+        const double* t_eval,
+        const size_t len_t_eval,
+        // rk optional arguments
+        const double rtol,
+        const double atol,
+        const double* rtols_ptr,
+        const double* atols_ptr,
+        const double max_step_size,
+        const double first_step_size) :
+            status(0),
+            integration_method(integration_method),
+            solution_sptr(solution_sptr)
+
+{ 
     // We need to pass a fake diffeq pointer (diffeq ptr is unused in python-based solver)
     DiffeqFuncType diffeq_ptr = nullptr;
 
@@ -182,19 +218,17 @@ PySolver::PySolver(
     PreEvalFunc pre_eval_func = nullptr;
 
     // Build the solver class. This must be heap allocated to take advantage of polymorphism.
-    switch (this->integration_method)
+    // Setup solver class
+    if (this->solution_sptr) [[likely]]
     {
-    case 0:
-        // RK23
-        this->solver = new RK23(
+        this->solution_sptr->build_solver(
             diffeq_ptr,
-            solution_ptr,
             t_start,
             t_end,
             y0_ptr,
-            num_y,
+            integration_method,
             // General optional arguments
-            num_extra,
+            expected_size,
             args_ptr,
             max_num_steps,
             max_ram_MB,
@@ -208,97 +242,29 @@ PySolver::PySolver(
             rtols_ptr,
             atols_ptr,
             max_step_size,
-            first_step_size);
-        break;
-    case 1:
-        // RK45
-        this->solver = new RK45(
-            diffeq_ptr,
-            solution_ptr,
-            t_start,
-            t_end,
-            y0_ptr,
-            num_y,
-            // General optional arguments
-            num_extra,
-            args_ptr,
-            max_num_steps,
-            max_ram_MB,
-            dense_output,
-            t_eval,
-            len_t_eval,
-            pre_eval_func,
-            // rk optional arguments
-            rtol,
-            atol,
-            rtols_ptr,
-            atols_ptr,
-            max_step_size,
-            first_step_size);
-        break;
-    case 2:
-        // DOP853
-        this->solver = new DOP853(
-            diffeq_ptr,
-            solution_ptr,
-            t_start,
-            t_end,
-            y0_ptr,
-            num_y,
-            // General optional arguments
-            num_extra,
-            args_ptr,
-            max_num_steps,
-            max_ram_MB,
-            dense_output,
-            t_eval,
-            len_t_eval,
-            pre_eval_func,
-            // rk optional arguments
-            rtol,
-            atol,
-            rtols_ptr,
-            atols_ptr,
-            max_step_size,
-            first_step_size);
-        break;
-    [[unlikely]] default:
-        this->status = -1;
-        break;
-    }
+            first_step_size
+        );
 
-    if (this->solver) [[likely]]
-    {
         // Add in python hooks
-        this->solver->set_cython_extension_instance(cython_extension_class_instance, cython_extension_class_diffeq_method);
-
-        // Install solver's state pointers
-        this->state_pointers = PySolverStatePointers(
-            this->solver->dy_now_ptr,
-            this->solver->t_now_ptr,
-            this->solver->y_now_ptr);
+        this->solution_sptr->solver_uptr->set_cython_extension_instance(cython_extension_class_instance, cython_extension_class_diffeq_method);
+    }
+    else
+    {
+        throw std::exception(); // "Solution storage not created. Perhaps memory issue or bad alloc."
     }
 };
 
 
-PySolverStatePointers PySolver::get_state_pointers() const
-{
-    /*
-    The differential equation is called from the python side but it must use and update state pointers in the
-    CySolver class instance. This function returns all required pointers so Python can properly use and update them.
-    */
-    return this->state_pointers;
-}
-
-
 void PySolver::solve()
 {
     // Run integrator
-    if (this->solver) [[likely]]
+    if (this->solution_sptr)
     {
-        this->solver->solve();
+        // Reset solver to t0
+        this->solution_sptr->solve();
+    }
+    else
+    {
+        throw std::exception(); // Solution storage pointer no longer valid
     }
-
-    // Finalize solution storage
-    this->solution_ptr->finalize();
 }
diff --git a/CyRK/cy/cysolve.hpp b/CyRK/cy/cysolve.hpp
index 16de48b..70700c6 100644
--- a/CyRK/cy/cysolve.hpp
+++ b/CyRK/cy/cysolve.hpp
@@ -3,19 +3,43 @@
 #include <memory>
 
 #include "common.hpp"
-#include "cysolver.hpp"
-#include "rk.hpp"
+#include "cysolution.hpp"
 
+void baseline_cysolve_ivp_noreturn(
+    std::shared_ptr<CySolverResult> solution_sptr,
+    DiffeqFuncType diffeq_ptr,
+    const double* t_span_ptr,
+    const double* y0_ptr,
+    const size_t num_y,
+    const int method,
+    // General optional arguments
+    const size_t expected_size,
+    const size_t num_extra,
+    const void* args_ptr,
+    const size_t max_num_steps,
+    const size_t max_ram_MB,
+    const bool dense_output,
+    const double* t_eval,
+    const size_t len_t_eval,
+    PreEvalFunc pre_eval_func,
+    // rk optional arguments
+    const double rtol,
+    const double atol,
+    const double* rtols_ptr,
+    const double* atols_ptr,
+    const double max_step_size,
+    const double first_step_size
+);
 
 std::shared_ptr<CySolverResult> baseline_cysolve_ivp(
     DiffeqFuncType diffeq_ptr,
     const double* t_span_ptr,
     const double* y0_ptr,
-    const unsigned int num_y,
-    const unsigned int method,
+    const size_t num_y,
+    const int method,
     // General optional arguments
     const size_t expected_size = 0,
-    const unsigned int num_extra = 0,
+    const size_t num_extra = 0,
     const void* args_ptr = nullptr,
     const size_t max_num_steps = 0,
     const size_t max_ram_MB = 2000,
@@ -34,16 +58,6 @@ std::shared_ptr<CySolverResult> baseline_cysolve_ivp(
 
 
 /* Pure Python hook solvers and helpers */
-struct PySolverStatePointers
-{
-    double* dy_now_ptr;
-    double* t_now_ptr;
-    double* y_now_ptr;
-    PySolverStatePointers() :
-        dy_now_ptr(nullptr), t_now_ptr(nullptr), y_now_ptr(nullptr) {};
-    PySolverStatePointers(double* dy_now_ptr, double* t_now_ptr, double* y_now_ptr) :
-        dy_now_ptr(dy_now_ptr), t_now_ptr(t_now_ptr), y_now_ptr(y_now_ptr) {};
-};
 
 class PySolver
 {
@@ -52,29 +66,28 @@ class PySolver
     int status = -999;
 
     // Integrator information
-    unsigned int integration_method = 1;
-    CySolverBase* solver = nullptr;
-    PySolverStatePointers state_pointers = PySolverStatePointers();
+    int integration_method = -1;
 
     // Solution information
-    std::shared_ptr<CySolverResult> solution_ptr = std::make_shared<CySolverResult>();
+    std::shared_ptr<CySolverResult> solution_sptr = nullptr;
 
 public:
     PySolver();
     ~PySolver();
     PySolver(
-        unsigned int integration_method,
+        int integration_method,
         // Cython class instance used for pyhook
         PyObject* cython_extension_class_instance,
         DiffeqMethod cython_extension_class_diffeq_method,
         // Regular integrator inputs
-        std::shared_ptr<CySolverResult> solution_ptr,
+        std::shared_ptr<CySolverResult> solution_sptr,
         const double t_start,
         const double t_end,
         const double* y0_ptr,
-        const unsigned int num_y,
+        const size_t num_y,
         // General optional arguments
-        const unsigned int num_extra,
+        const size_t expected_size,
+        const size_t num_extra,
         const void* args_ptr,
         const size_t max_num_steps,
         const size_t max_ram_MB,
@@ -89,6 +102,5 @@ class PySolver
         const double max_step_size,
         const double first_step_size
     );
-    PySolverStatePointers get_state_pointers() const;
     void solve();
 };
diff --git a/CyRK/cy/cysolver.cpp b/CyRK/cy/cysolver.cpp
index 5f81189..188a423 100644
--- a/CyRK/cy/cysolver.cpp
+++ b/CyRK/cy/cysolver.cpp
@@ -1,4 +1,6 @@
 #include "cysolver.hpp"
+#include "dense.hpp"
+#include "cysolution.hpp"
 
 // !!!
 // Uncomment these dummy methods if working outside of CyRK and you just want the program to compile and run for testing/developing the C++ only code.
@@ -27,12 +29,12 @@ void Py_XDECREF(PyObject* x)
 CySolverBase::CySolverBase() {}
 CySolverBase::CySolverBase(
         DiffeqFuncType diffeq_ptr,
-        std::shared_ptr<CySolverResult> storage_ptr,
+        std::shared_ptr<CySolverResult> storage_sptr,
         const double t_start,
         const double t_end,
         const double* const y0_ptr,
-        const unsigned int num_y,
-        const unsigned int num_extra,
+        const size_t num_y,
+        const size_t num_extra,
         const void* const args_ptr,
         const size_t max_num_steps,
         const size_t max_ram_MB,
@@ -50,33 +52,33 @@ CySolverBase::CySolverBase(
             pre_eval_func(pre_eval_func),
             status(0),
             num_y(num_y),
-            storage_ptr(storage_ptr)
+            storage_sptr(storage_sptr)
 {
     // Parse inputs
     this->capture_extra = num_extra > 0;
 
     // Setup storage
-    this->storage_ptr->update_message("CySolverBase Initializing.");
+    this->storage_sptr->update_message("CySolverBase Initializing.");
 
     // Check for errors
     if (this->num_extra > (DY_LIMIT - Y_LIMIT))
     {
         this->status = -9;
-        this->storage_ptr->error_code = -1;
-        this->storage_ptr->update_message("CySolverBase Attribute Error: `num_extra` exceeds the maximum supported size.");
+        this->storage_sptr->error_code = -1;
+        this->storage_sptr->update_message("CySolverBase Attribute Error: `num_extra` exceeds the maximum supported size.");
     }
 
     if (this->num_y > Y_LIMIT)
     {
         this->status = -9;
-        this->storage_ptr->error_code = -1;
-        this->storage_ptr->update_message("CySolverBase Attribute Error: `num_y` exceeds the maximum supported size.");
+        this->storage_sptr->error_code = -1;
+        this->storage_sptr->update_message("CySolverBase Attribute Error: `num_y` exceeds the maximum supported size.");
     }
     else if (this->num_y == 0)
     {
         this->status = -9;
-        this->storage_ptr->error_code = -1;
-        this->storage_ptr->update_message("CySolverBase Attribute Error: `num_y` = 0 so nothing to integrate.");
+        this->storage_sptr->error_code = -1;
+        this->storage_sptr->update_message("CySolverBase Attribute Error: `num_y` = 0 so nothing to integrate.");
     }
 
     // Parse y values
@@ -84,7 +86,7 @@ CySolverBase::CySolverBase(
     this->num_y_sqrt = std::sqrt(this->num_y_dbl);
     this->num_dy     = this->num_y + this->num_extra;
     // Make a copy of y0
-    std::memcpy(this->y0_ptr, y0_ptr, sizeof(double) * this->num_y);
+    std::memcpy(&this->y0[0], y0_ptr, sizeof(double) * this->num_y);
     
     // Parse t_eval
     if ((t_eval) && (this->len_t_eval > 0))
@@ -146,7 +148,6 @@ CySolverBase::CySolverBase(
 // Destructors
 CySolverBase::~CySolverBase()
 {
-    this->storage_ptr = nullptr;
     if (this->deconstruct_python)
     {
         // Decrease reference count on the cython extension class instance
@@ -154,7 +155,6 @@ CySolverBase::~CySolverBase()
     }
 }
 
-
 // Protected methods
 void CySolverBase::p_estimate_error()
 {
@@ -167,11 +167,42 @@ void CySolverBase::p_step_implementation()
 }
 
 // Public methods
+void CySolverBase::offload_to_temp()
+{
+    /* Save "now" variables to temporary arrays so that the now array can be overwritten. */
+    std::memcpy(&this->y_tmp[0], &this->y_now[0], sizeof(double) * this->num_y);
+    std::memcpy(&this->dy_tmp[0], &this->dy_now[0], sizeof(double) * this->num_dy);
+    this->t_tmp = this->t_now;
+}
+
+void CySolverBase::load_back_from_temp()
+{
+    /* Copy values from temporary array variables back into the "now" arrays. */
+    std::memcpy(&this->y_now[0], &this->y_tmp[0], sizeof(double) * this->num_y);
+    std::memcpy(&this->dy_now[0], &this->dy_tmp[0], sizeof(double) * this->num_dy);
+    this->t_now = this->t_tmp;
+}
+
+void CySolverBase::set_Q_order(size_t* Q_order_ptr)
+{
+    // Overwritten by subclasses.
+}
+
+void CySolverBase::set_Q_array(double* Q_ptr)
+{
+    // Overwritten by subclasses.
+}
+
 void CySolverBase::calc_first_step_size()
 {
     // Overwritten by subclasses.
 }
 
+NowStatePointers CySolverBase::get_now_state()
+{
+    return NowStatePointers(&this->t_now, &this->y_now[0], &this->dy_now[0]);
+}
+
 bool CySolverBase::check_status() const
 {
     // If the solver is not in state 0 then that is an automatic rejection.
@@ -181,13 +212,18 @@ bool CySolverBase::check_status() const
     }
 
     // Otherwise, check if the solution storage is in an error state.
-    if (this->storage_ptr) [[likely]]
+    if (this->storage_sptr) [[likely]]
     {
-        if (this->storage_ptr->error_code != 0)
+        if (this->storage_sptr->error_code != 0)
         {
             return false;
         }
     }
+    else
+    {
+        // No storage!
+        return false;
+    }
 
     // If we reach here then we should be good to go.
     return true;
@@ -196,7 +232,7 @@ bool CySolverBase::check_status() const
 void CySolverBase::cy_diffeq() noexcept
 {
     // Call c function
-    this->diffeq_ptr(this->dy_now_ptr, this->t_now_ptr[0], this->y_now_ptr, this->args_ptr, this->pre_eval_func);
+    this->diffeq_ptr(&this->dy_now[0], this->t_now, &this->y_now[0], this->args_ptr, this->pre_eval_func);
 }
 
 void CySolverBase::reset()
@@ -204,38 +240,39 @@ void CySolverBase::reset()
     this->status = 0;
     this->reset_called = false;
 
+    // Reset runtime bools
+    this->skip_t_eval = false;
+
     // Reset time
-    this->t_now_ptr[0] = this->t_start;
+    this->t_now = this->t_start;
     this->t_old = this->t_start;
     this->len_t = 1;
 
     // Reset ys
-    std::memcpy(this->y_now_ptr, this->y0_ptr, sizeof(double) * this->num_y);
-    std::memcpy(this->y_old_ptr, this->y0_ptr, sizeof(double) * this->num_y);
+    std::memcpy(&this->y_now[0], &this->y0[0], sizeof(double) * this->num_y);
+    std::memcpy(&this->y_old[0], &this->y0[0], sizeof(double) * this->num_y);
 
     // Call differential equation to set dy0
     this->diffeq(this);
 
     // Update dys
-    std::memcpy(this->dy_old_ptr, this->dy_now_ptr, sizeof(double) * this->num_y);
-
-    // Initialize storage
-    this->storage_ptr->reset();
-    this->storage_ptr->update_message("CySolverStorage reset, ready for data.");
+    std::memcpy(&this->dy_old[0], &this->dy_now[0], sizeof(double) * this->num_y);
 
     // If t_eval is set then don't save initial conditions. They will be captured during stepping.
     if (!this->use_t_eval)
     {
         // Store initial conditions
-        this->storage_ptr->save_data(this->t_now_ptr[0], this->y_now_ptr, this->dy_now_ptr);
+        this->storage_sptr->save_data(this->t_now, &this->y_now[0], &this->dy_now[0]);
     }
     
     // Construct interpolator using t0 and y0 as its data point
     if (this->use_dense_output)
     {
-        CySolverDense* dense_output_ptr = this->p_dense_output_heap();
-        // Save interpolator
-        this->storage_ptr->save_dense(this->t_now_ptr[0], dense_output_ptr);
+        int built_dense = this->storage_sptr->build_dense(true);
+        if (built_dense < 0)
+        {
+            this->status = -100;
+        }
     }
 
     // Prep for t_eval
@@ -253,18 +290,16 @@ void CySolverBase::reset()
 }
 
 void CySolverBase::take_step()
-{    
+{ 
     if (!this->reset_called) [[unlikely]]
     {
         // Reset must be called first.
         this->reset();
     }
 
-    bool skip_t_eval = false;
-
     if (!this->status)
     {
-        if (this->t_now_ptr[0] == this->t_end) [[unlikely]]
+        if (this->t_now == this->t_end) [[unlikely]]
         {
             // Integration finished
             this->t_old = this->t_end;
@@ -292,47 +327,29 @@ void CySolverBase::take_step()
             this->len_t++;
 
             // Take care of dense output and t_eval
+            int dense_built = 0;
             if (this->use_dense_output)
             {
-                // We need to save many dense interpolators to storage. So let's heap allocate them.
-                CySolverDense* dense_output_heap_ptr = this->p_dense_output_heap();
-                // Save to storage array.
-                this->storage_ptr->save_dense(this->t_now_ptr[0], dense_output_heap_ptr);
+                // We need to save many dense interpolators to storage. So let's heap allocate them (that is what "true" indicates)
+                dense_built = this->storage_sptr->build_dense(true);
+                if (dense_built < 0)
+                {
+                    this->status = -100;
+                }
             }
 
-            if (this->use_t_eval && !skip_t_eval)
+            if (this->use_t_eval && !this->skip_t_eval)
             {
                 // Don't save data at the end
                 save_data = false;
 
-                // We are not saving interpolators to storage but we still need one to work on t_eval. 
-                // We will only ever need 1 interpolator per step. So let's just stack allocate that one.
-                CySolverDense dense_output(
-                    this->integration_method,
-                    this->t_old,
-                    this->t_now_ptr[0],
-                    this->y_old_ptr,
-                    this->num_y,
-                    this->num_extra,
-                    0, // Fake Q order just for consistent constructor call
-                    this,
-                    this->diffeq,
-                    this->cython_extension_class_instance,
-                    this->t_now_ptr,
-                    this->y_now_ptr,
-                    this->dy_now_ptr
-                    );
-
-                // Update the dense output class with integrator-specific data
-                this->p_dense_output_stack(dense_output);
-
                 // Need to step through t_eval and call dense to determine correct data at each t_eval step.
                 // Find the first index in t_eval that is close to current time.
 
                 // Check if there are any t_eval steps between this new index and the last index.
                 // Get lowest and highest indices
-                auto lower_i = std::lower_bound(this->t_eval_vec.begin(), this->t_eval_vec.end(), this->t_now_ptr[0]) - this->t_eval_vec.begin();
-                auto upper_i = std::upper_bound(this->t_eval_vec.begin(), this->t_eval_vec.end(), this->t_now_ptr[0]) - this->t_eval_vec.begin();
+                auto lower_i = std::lower_bound(this->t_eval_vec.begin(), this->t_eval_vec.end(), this->t_now) - this->t_eval_vec.begin();
+                auto upper_i = std::upper_bound(this->t_eval_vec.begin(), this->t_eval_vec.end(), this->t_now) - this->t_eval_vec.begin();
                 
                 size_t t_eval_index_new;
                 if (lower_i == upper_i)
@@ -346,7 +363,7 @@ void CySolverBase::take_step()
                     t_eval_index_new = upper_i;
                     if (t_eval_index_new == this->len_t_eval)
                     {
-                        skip_t_eval = true;
+                        this->skip_t_eval = true;
                     }
                 }
                 else
@@ -355,7 +372,7 @@ void CySolverBase::take_step()
                     t_eval_index_new = lower_i;
                     if (t_eval_index_new == 0)
                     {
-                        skip_t_eval = true;
+                        this->skip_t_eval = true;
                     }
                 }
 
@@ -373,6 +390,13 @@ void CySolverBase::take_step()
                 // ^ In this case do not save any data, we are done with this step.
                 if (t_eval_index_delta > 0)
                 {
+                    if (dense_built == 0)
+                    {
+                        // We are not saving interpolators to storage but we still need one to work on t_eval. 
+                        // We will only ever need 1 interpolator per step. So let's just stack allocate that one.
+                        dense_built = this->storage_sptr->build_dense(false);
+                    }
+
                     // There are steps we need to interpolate over.
                     // Start with the old time and add t_eval step sizes until we are done.
                     // Create a y array and dy_array to use during interpolation
@@ -387,9 +411,9 @@ void CySolverBase::take_step()
                     if (this->capture_extra)
                     {
                         // We need to copy the current state of y, dy, and time
-                        this->t_old = this->t_now_ptr[0];
-                        std::memcpy(this->y_old_ptr, this->y_now_ptr, sizeof(double) * this->num_y);
-                        std::memcpy(this->dy_old_ptr, this->dy_now_ptr, sizeof(double) * this->num_dy);
+                        this->t_old = this->t_now;
+                        std::memcpy(&this->y_old[0], &this->y_now[0], sizeof(double) * this->num_y);
+                        std::memcpy(&this->dy_old[0], &this->dy_now[0], sizeof(double) * this->num_dy);
 
                         // Don't update these again at the end
                         prepare_for_next_step = false;
@@ -408,7 +432,7 @@ void CySolverBase::take_step()
                         }
 
                         // Call the interpolator using this new time value.
-                        dense_output.call(t_interp, y_interp_ptr);
+                        this->storage_sptr->dense_vec.back().call(t_interp, y_interp_ptr);
 
                         if (this->capture_extra)
                         {
@@ -418,14 +442,14 @@ void CySolverBase::take_step()
                             // So for now we have to do a lot of copying of data.
 
                             // Copy the interpreted y onto the current y_now_ptr. Also update t_now
-                            this->t_now_ptr[0] = t_interp;
-                            std::memcpy(this->y_now_ptr, y_interp_ptr, sizeof(double) * this->num_y);
+                            this->t_now = t_interp;
+                            std::memcpy(&this->y_now[0], y_interp_ptr, sizeof(double) * this->num_y);
 
                             // Call diffeq to update dy_now_ptr with the extra output.
                             this->diffeq(this);
                         }
                         // Save interpolated data to storage. If capture extra is true then dy_now holds those extra values. If it is false then it won't hurt to pass dy_now to storage.
-                        this->storage_ptr->save_data(t_interp, y_interp_ptr, this->dy_now_ptr);
+                        this->storage_sptr->save_data(t_interp, y_interp_ptr, &this->dy_now[0]);
                     }
                 }
                 // Update the old index for the next step
@@ -434,15 +458,15 @@ void CySolverBase::take_step()
             if (save_data)
             {
                 // No data has been saved from the current step. Save the integrator data for this step as the solution.
-                this->storage_ptr->save_data(this->t_now_ptr[0], this->y_now_ptr, this->dy_now_ptr);
+                this->storage_sptr->save_data(this->t_now, &this->y_now[0], &this->dy_now[0]);
             }
 
             if (prepare_for_next_step)
             {
                 // Prep for next step
-                this->t_old = this->t_now_ptr[0];
-                std::memcpy(this->y_old_ptr, this->y_now_ptr, sizeof(double) * this->num_y);
-                std::memcpy(this->dy_old_ptr, this->dy_now_ptr, sizeof(double) * this->num_dy);
+                this->t_old = this->t_now;
+                std::memcpy(&this->y_old[0], &this->y_now[0], sizeof(double) * this->num_y);
+                std::memcpy(&this->dy_old[0], &this->dy_now[0], sizeof(double) * this->num_dy);
             }
         }
     }
@@ -452,55 +476,36 @@ void CySolverBase::take_step()
     if (this->status != 0)
     {
         // Update integration message
-        this->storage_ptr->error_code = this->status;
-        this->storage_ptr->success    = false;
+        this->storage_sptr->error_code = this->status;
+        this->storage_sptr->success    = false;
         switch (this->status)
         {
         case 2:
-            this->storage_ptr->update_message("Integration storage changed but integrator was not reset. Call `.reset()` before integrating after change.");
+            this->storage_sptr->update_message("Integration storage changed but integrator was not reset. Call `.reset()` before integrating after change.");
             break;
         case 1:
-            this->storage_ptr->update_message("Integration completed without issue.");
-            this->storage_ptr->success = true;
+            this->storage_sptr->update_message("Integration completed without issue.");
+            this->storage_sptr->success = true;
             break;
         case -1:
-            this->storage_ptr->update_message("Error in step size calculation:\n\tRequired step size is less than spacing between numbers.");
+            this->storage_sptr->update_message("Error in step size calculation:\n\tRequired step size is less than spacing between numbers.");
             break;
         case -2:
-            this->storage_ptr->update_message("Maximum number of steps (set by user) exceeded during integration.");
+            this->storage_sptr->update_message("Maximum number of steps (set by user) exceeded during integration.");
             break;
         case -3:
-            this->storage_ptr->update_message("Maximum number of steps (set by system architecture) exceeded during integration.");
+            this->storage_sptr->update_message("Maximum number of steps (set by system architecture) exceeded during integration.");
             break;
         case -4:
-            this->storage_ptr->update_message("Error in step size calculation:\n\tError in step size acceptance.");
+            this->storage_sptr->update_message("Error in step size calculation:\n\tError in step size acceptance.");
             break;
         case -9:
-            this->storage_ptr->update_message("Error in CySolver initialization.");
+            this->storage_sptr->update_message("Error in CySolver initialization.");
             break;
         default:
-            this->storage_ptr->update_message("Unknown status encountered during integration.");
+            this->storage_sptr->update_message("Unknown status encountered during integration.");
             break;
         }
-        
-        // Call the finalizer on the storage class instance
-        this->storage_ptr->finalize();
-    }
-}
-
-
-void CySolverBase::change_storage(std::shared_ptr<CySolverResult> new_storage_ptr, bool auto_reset)
-{   
-    // Change the storage reference. 
-    this->storage_ptr = new_storage_ptr;
-    
-    // Set status to indicate that storage has changed but reset has not been updated
-    this->status = 2;
-
-    // Changing storage requires a reset
-    if (auto_reset)
-    {
-        this->reset();
     }
 }
 
@@ -514,31 +519,6 @@ void CySolverBase::solve()
     }
 }
 
-/* Dense Output Methods */
-CySolverDense* CySolverBase::p_dense_output_heap()
-{
-    return new CySolverDense(
-        this->integration_method,
-        this->t_old,
-        this->t_now_ptr[0],
-        this->y_old_ptr,
-        this->num_y,
-        this->num_extra,
-        0, // Fake Q order just for consistent constructor call
-        this,
-        this->diffeq,
-        this->cython_extension_class_instance,
-        this->t_now_ptr,
-        this->y_now_ptr,
-        this->dy_now_ptr
-        );
-}
-
-void CySolverBase::p_dense_output_stack(CySolverDense& dense_output_ptr)
-{
-    // Don't do anything. Subclasses will override this method.
-}
-
 
 /* PySolver Methods */
 void CySolverBase::set_cython_extension_instance(PyObject* cython_extension_class_instance, DiffeqMethod py_diffeq_method)
@@ -558,8 +538,8 @@ void CySolverBase::set_cython_extension_instance(PyObject* cython_extension_clas
         {
             this->use_pysolver = false;
             this->status = -1;
-            this->storage_ptr->error_code = -51;
-            this->storage_ptr->update_message("Error encountered importing python hooks.\n");
+            this->storage_sptr->error_code = -51;
+            this->storage_sptr->update_message("Error encountered importing python hooks.\n");
         }
         else
         {
diff --git a/CyRK/cy/cysolver.hpp b/CyRK/cy/cysolver.hpp
index e56e8a6..4ba863b 100644
--- a/CyRK/cy/cysolver.hpp
+++ b/CyRK/cy/cysolver.hpp
@@ -7,8 +7,6 @@
 #include <memory>
 
 #include "common.hpp"
-#include "cysolution.hpp"
-#include "dense.hpp"
 #include "cy_array.hpp"
 
 // !!!
@@ -23,17 +21,32 @@
 #include <Python.h>
 #include "pysolver_cyhook_api.h"
 
+// We need to forward declare the CySolverResult so that the solver can make calls to its methods
+class CySolverResult;
+class CySolverDense;
+
 struct _object;
 typedef _object PyObject;
 
+struct NowStatePointers 
+{
+    double* t_now_ptr;
+    double* y_now_ptr;
+    double* dy_now_ptr;
+    
+    NowStatePointers():
+        t_now_ptr(nullptr), y_now_ptr(nullptr), dy_now_ptr(nullptr) { }
+
+    NowStatePointers(double* t_now_ptr, double* y_now_ptr, double* dy_now_ptr):
+        t_now_ptr(t_now_ptr), y_now_ptr(y_now_ptr), dy_now_ptr(dy_now_ptr) { }
+};
+
 class CySolverBase {
 
 // Methods
 protected:
     virtual void p_estimate_error();
     virtual void p_step_implementation();
-    virtual CySolverDense* p_dense_output_heap();
-    virtual void p_dense_output_stack(CySolverDense& dense_output_ptr);
 
 public:
     CySolverBase();
@@ -41,12 +54,12 @@ class CySolverBase {
     CySolverBase(
         // Input variables
         DiffeqFuncType diffeq_ptr,
-        std::shared_ptr<CySolverResult> const storage_ptr,
+        std::shared_ptr<CySolverResult> storage_sptr,
         const double t_start,
         const double t_end,
         const double* const y0_ptr,
-        const unsigned int num_y,
-        const unsigned int num_extra = 0,
+        const size_t num_y,
+        const size_t num_extra = 0,
         const void* const args_ptr = nullptr,
         const size_t max_num_steps = 0,
         const size_t max_ram_MB = 2000,
@@ -56,15 +69,19 @@ class CySolverBase {
         PreEvalFunc pre_eval_func = nullptr
     );
 
-    void change_storage(std::shared_ptr<CySolverResult> new_storage_ptr, bool auto_reset = true);
     bool check_status() const;
     virtual void reset();
+    void offload_to_temp();
+    void load_back_from_temp();
+    virtual void set_Q_order(size_t* Q_order_ptr);
+    virtual void set_Q_array(double* Q_ptr);
     virtual void calc_first_step_size();
     void take_step();
     void solve();
     // Diffeq can either be the C++ class method or the python hook diffeq. By default set to C++ version.
     void cy_diffeq() noexcept;
     std::function<void(CySolverBase*)> diffeq;
+    NowStatePointers get_now_state();
 
     // PySolver methods
     void set_cython_extension_instance(PyObject* cython_extension_class_instance, DiffeqMethod py_diffeq_method);
@@ -75,9 +92,7 @@ class CySolverBase {
     // ** Attributes **
 
     // Time variables
-    double t_start       = 0.0;
-    double t_end         = 0.0;
-    double t_old         = 0.0;
+    double t_tmp         = 0.0;
     double t_delta       = 0.0;
     double t_delta_abs   = 0.0;
     double direction_inf = 0.0;
@@ -85,18 +100,6 @@ class CySolverBase {
     // Dependent variables
     double num_y_dbl  = 0.0;
     double num_y_sqrt = 0.0;
-    // The size of the stack allocated tracking arrays is equal to the maximum allowed `num_y` (25).
-    double y0[Y_LIMIT]    = { 0.0 };
-    double y_old[Y_LIMIT] = { 0.0 };
-    double y_now[Y_LIMIT] = { 0.0 };
-    // For dy, both the dy/dt and any extra outputs are stored. So the maximum size is `num_y` (25) + `num_extra` (25)
-    double dy_old[DY_LIMIT] = { 0.0 };
-    double dy_now[DY_LIMIT] = { 0.0 };
-
-    // dy_now_ptr and y_now_ptr are declared in public.
-    double* const y0_ptr     = &y0[0];
-    double* const y_old_ptr  = &y_old[0];
-    double* const dy_old_ptr = &dy_old[0];
 
     // Integration step information
     size_t max_num_steps = 0;
@@ -110,11 +113,9 @@ class CySolverBase {
     double* t_eval_ptr       = t_eval_vec.data();
     size_t t_eval_index_old  = 0;
     size_t len_t_eval        = 0;
+    bool skip_t_eval         = false;
     bool use_t_eval          = false;
 
-    // Information on capturing extra information during integration.
-    int num_extra = 0;
-
     // Function to send to diffeq which is called before dy is calculated
     PreEvalFunc pre_eval_func = nullptr;
 
@@ -139,16 +140,27 @@ class CySolverBase {
     int integration_method = -1;
 
     // Meta data
-    unsigned int num_dy = 0;
-    unsigned int num_y  = 0;
+    size_t num_dy    = 0;
+    size_t num_y     = 0;
+    size_t num_extra = 0;
+
+    // The size of the stack allocated tracking arrays is equal to the maximum allowed `num_y` (25).
+    double y0[Y_LIMIT]    = { 0.0 };
+    double y_old[Y_LIMIT] = { 0.0 };
+    double y_now[Y_LIMIT] = { 0.0 };
+    double y_tmp[Y_LIMIT] = { 0.0 };
+    // For dy, both the dy/dt and any extra outputs are stored. So the maximum size is `num_y` (25) + `num_extra` (25)
+    double dy_old[DY_LIMIT] = { 0.0 };
+    double dy_now[DY_LIMIT] = { 0.0 };
+    double dy_tmp[DY_LIMIT] = { 0.0 };
 
     // Result storage
-    std::shared_ptr<CySolverResult> storage_ptr = std::make_shared<CySolverResult>();
+    std::shared_ptr<CySolverResult> storage_sptr = nullptr;
 
     // State attributes
     size_t len_t       = 0;
-    double t_now[1]    = {0.0};
-    double* const t_now_ptr  = &t_now[0];
-    double* const y_now_ptr  = &y_now[0];
-    double* const dy_now_ptr = &dy_now[0];
+    double t_now       = 0.0;
+    double t_start     = 0.0;
+    double t_end       = 0.0;
+    double t_old       = 0.0;
 };
diff --git a/CyRK/cy/cysolver_api.pxd b/CyRK/cy/cysolver_api.pxd
index e0fe4c5..e553525 100644
--- a/CyRK/cy/cysolver_api.pxd
+++ b/CyRK/cy/cysolver_api.pxd
@@ -1,11 +1,12 @@
 from libcpp cimport bool as cpp_bool
+from libcpp.vector cimport vector
+from libcpp.memory cimport shared_ptr, unique_ptr
 
 cimport cpython.ref as cpy_ref
-from CyRK.utils.vector cimport vector
-from CyRK.utils.memory cimport shared_ptr
 from CyRK.cy.pysolver_cyhook cimport DiffeqMethod
 
-cimport numpy as np
+cimport numpy as cnp
+cnp.import_array()
 
 
 # =====================================================================================================================
@@ -14,16 +15,17 @@ cimport numpy as np
 cdef extern from "common.cpp" nogil:
     const double INF
     const double EPS_100
-    const unsigned int Y_LIMIT
-    const unsigned int DY_LIMIT
+    const size_t Y_LIMIT
+    const size_t DY_LIMIT
+    const size_t BUFFER_SIZE
     const double MAX_STEP
 
     ctypedef void (*PreEvalFunc)(void*, double, double*, const void*)
     ctypedef void (*DiffeqFuncType)(double*, double, double*, const void*, PreEvalFunc)
 
     cdef size_t find_expected_size(        
-        int num_y,
-        int num_extra,
+        size_t num_y,
+        size_t num_extra,
         double t_delta_abs,
         double rtol_min)
 
@@ -37,15 +39,20 @@ cdef extern from "dense.cpp" nogil:
         CySolverDense()
         CySolverDense(
             int integrator_int,
-            double t_old,
-            double t_now,
-            double* y_in_ptr,
-            unsigned int num_y,
-            unsigned int Q_order)
+            CySolverBase* solver_ptr,
+            cpp_bool set_state)
+
         int integrator_int
-        unsigned int num_y
+        size_t Q_order
+        size_t num_y
+        CySolverBase* solver_ptr
         double t_old
         double t_now
+        double step
+
+        vector[double] state_data_vec
+
+        void set_state()
         void call(double t_interp, double* y_interped)
 
 
@@ -63,21 +70,58 @@ cdef extern from "cysolution.cpp" nogil:
                 const cpp_bool direction_flag,
                 const cpp_bool capture_dense_output,
                 const cpp_bool t_eval_provided)
+            
+            cpp_bool capture_extra
+            cpp_bool retain_solver
+            cpp_bool capture_dense_output
+            cpp_bool t_eval_provided
             cpp_bool success
             cpp_bool reset_called
-            char* message_ptr
+            cpp_bool solver_reset_called
+            cpp_bool direction_flag
             int error_code
-            size_t size
+            int integrator_method
             size_t num_y
+            size_t num_extra
             size_t num_dy
-            cpp_bool capture_extra
-            cpp_bool capture_dense_output
-            cpp_bool t_eval_provided
-            vector[double] time_domain
+            char* message_ptr
+            size_t size
+            size_t num_interpolates
+            vector[double] time_domain_vec
+            vector[double] time_domain_vec_sorted
             vector[double] solution
+            vector[double]* time_domain_vec_sorted_ptr
+            vector[CySolverDense] dense_vec
+            unique_ptr[CySolverBase] solver_uptr
+            vector[double] interp_time_vec
+
             void save_data(double new_t, double* new_solution_y, double* new_solution_dy)
+            int build_dense(cpp_bool save)
+            void solve()
             void finalize()
             void reset()
+            void reset_solver()
+            void build_solver(
+                DiffeqFuncType diffeq_ptr,
+                const double t_start,
+                const double t_end,
+                const double* y0_ptr,
+                const int method,
+                const size_t expected_size,
+                const void* args_ptr,
+                const size_t max_num_steps,
+                const size_t max_ram_MB,
+                const cpp_bool dense_output,
+                const double* t_eval,
+                const size_t len_t_eval,
+                PreEvalFunc pre_eval_func,
+                const double rtol,
+                const double atol,
+                const double* rtols_ptr,
+                const double* atols_ptr,
+                const double max_step_size,
+                const double first_step_size
+            )
             void update_message(const char* new_message)
             void call(const double t, double* y_interp)
             void call_vectorize(const double* t_array_ptr, size_t len_t, double* y_interp)
@@ -101,6 +145,11 @@ cdef class WrapCySolverResult:
 # Import CySolver Integrator Base Class
 # =====================================================================================================================
 cdef extern from "cysolver.cpp" nogil:
+    struct NowStatePointers:
+        double* t_now_ptr
+        double* y_now_ptr
+        double* dy_now_ptr
+
     cdef cppclass CySolverBase:
         CySolverBase()
         CySolverBase(
@@ -109,8 +158,8 @@ cdef extern from "cysolver.cpp" nogil:
             const double t_start,
             const double t_end,
             const double* y0_ptr,
-            const unsigned int num_y,
-            const unsigned int num_extra,
+            const size_t num_y,
+            const size_t num_extra,
             const void* args_ptr,
             const size_t max_num_steps,
             const size_t max_ram_MB,
@@ -119,21 +168,30 @@ cdef extern from "cysolver.cpp" nogil:
             const size_t len_t_eval,
             PreEvalFunc pre_eval_func
         )
-        
-        shared_ptr[CySolverResult] storage_ptr
+
+        cpp_bool use_pysolver
+        DiffeqMethod py_diffeq_method
+        cpy_ref.PyObject cython_extension_class_instance
         int status
         int integration_method
-        unsigned int num_y
+        size_t num_dy
+        size_t num_y
+        shared_ptr[CySolverResult] storage_ptr
         size_t len_t
         double t_now
-        double* y0
         double* y_now_ptr
         double* dy_now_ptr
+
         cpp_bool check_status()
-        void diffeq()
-        void take_step()
-        void change_storage(shared_ptr[CySolverResult] new_storage_ptr, cpp_bool auto_reset)
+        NowStatePointers get_now_state()
         void reset()
+        void offload_to_temp()
+        void load_back_from_temp()
+        void calc_first_step_size()
+        void take_step()
+        void solve()
+        void cy_diffeq()
+        void diffeq()
         void set_cython_extension_instance(cpy_ref.PyObject* cython_extension_class_instance)
         void py_diffeq()
 
@@ -150,8 +208,8 @@ cdef extern from "rk.cpp" nogil:
             const double t_start,
             const double t_end,
             const double* y0_ptr,
-            const unsigned int num_y,
-            const unsigned int num_extra,
+            const size_t num_y,
+            const size_t num_extra,
             const void* args_ptr,
             const size_t max_num_steps,
             const size_t max_ram_MB,
@@ -172,7 +230,7 @@ cdef extern from "rk.cpp" nogil:
         void calc_first_step_size()
 
 
-    cdef unsigned int RK23_METHOD_INT
+    cdef int RK23_METHOD_INT
     cdef cppclass RK23(RKSolver):
         RK23()
         RK23(
@@ -181,8 +239,8 @@ cdef extern from "rk.cpp" nogil:
             const double t_start,
             const double t_end,
             const double* y0_ptr,
-            const unsigned int num_y,
-            const unsigned int num_extra,
+            const size_t num_y,
+            const size_t num_extra,
             const void* args_ptr,
             const size_t max_num_steps,
             const size_t max_ram_MB,
@@ -199,7 +257,7 @@ cdef extern from "rk.cpp" nogil:
         )
         void reset()
     
-    cdef unsigned int RK45_METHOD_INT
+    cdef int RK45_METHOD_INT
     cdef cppclass RK45(RKSolver):
         RK45()
         RK45(
@@ -208,8 +266,8 @@ cdef extern from "rk.cpp" nogil:
             const double t_start,
             const double t_end,
             const double* y0_ptr,
-            const unsigned int num_y,
-            const unsigned int num_extra,
+            const size_t num_y,
+            const size_t num_extra,
             const void* args_ptr,
             const size_t max_num_steps,
             const size_t max_ram_MB,
@@ -226,7 +284,7 @@ cdef extern from "rk.cpp" nogil:
         )
         void reset()
     
-    cdef unsigned int DOP853_METHOD_INT
+    cdef int DOP853_METHOD_INT
     cdef cppclass DOP853(RKSolver):
         DOP853()
         DOP853(
@@ -235,8 +293,8 @@ cdef extern from "rk.cpp" nogil:
             const double t_start,
             const double t_end,
             const double* y0_ptr,
-            const unsigned int num_y,
-            const unsigned int num_extra,
+            const size_t num_y,
+            const size_t num_extra,
             const void* args_ptr,
             const size_t max_num_steps,
             const size_t max_ram_MB,
@@ -259,14 +317,39 @@ cdef extern from "rk.cpp" nogil:
 # =====================================================================================================================
 cdef extern from "cysolve.cpp" nogil:
     # Pure C++ and Cython implementation
+
+    cdef void baseline_cysolve_ivp_noreturn(
+            shared_ptr[CySolverResult] solution_sptr,
+            DiffeqFuncType diffeq_ptr,
+            const double* t_span_ptr,
+            const double* y0_ptr,
+            const size_t num_y,
+            const int method,
+            const size_t expected_size,
+            const size_t num_extra,
+            const void* args_ptr,
+            const size_t max_num_steps,
+            const size_t max_ram_MB,
+            const cpp_bool dense_output,
+            const double* t_eval,
+            const size_t len_t_eval,
+            PreEvalFunc pre_eval_func,
+            const double rtol,
+            const double atol,
+            const double* rtols_ptr,
+            const double* atols_ptr,
+            const double max_step_size,
+            const double first_step_size
+            )
+
     cdef shared_ptr[CySolverResult] baseline_cysolve_ivp(
             DiffeqFuncType diffeq_ptr,
             const double* t_span_ptr,
             const double* y0_ptr,
-            const unsigned int num_y,
-            const unsigned int method,
+            const size_t num_y,
+            const int method,
             const size_t expected_size,
-            const unsigned int num_extra,
+            const size_t num_extra,
             const void* args_ptr,
             const size_t max_num_steps,
             const size_t max_ram_MB,
@@ -286,16 +369,40 @@ cdef extern from "cysolve.cpp" nogil:
 # =====================================================================================================================
 # Cython-based wrapper for baseline_cysolve_ivp that carries default values.
 # =====================================================================================================================
+cdef void cysolve_ivp_noreturn(
+    shared_ptr[CySolverResult] solution_sptr,
+    DiffeqFuncType diffeq_ptr,
+    const double* t_span_ptr,
+    const double* y0_ptr,
+    const size_t num_y,
+    int method = *,
+    double rtol = *,
+    double atol = *,
+    void* args_ptr = *,
+    size_t num_extra = *,
+    size_t max_num_steps = *,
+    size_t max_ram_MB = *,
+    bint dense_output = *,
+    double* t_eval = *,
+    size_t len_t_eval = *,
+    PreEvalFunc pre_eval_func = *,
+    double* rtols_ptr = *,
+    double* atols_ptr = *,
+    double max_step = *,
+    double first_step = *,
+    size_t expected_size = *
+    ) noexcept nogil
+
 cdef CySolveOutput cysolve_ivp(
     DiffeqFuncType diffeq_ptr,
     const double* t_span_ptr,
     const double* y0_ptr,
-    const unsigned int num_y,
-    unsigned int method = *,
+    const size_t num_y,
+    int method = *,
     double rtol = *,
     double atol = *,
     void* args_ptr = *,
-    unsigned int num_extra = *,
+    size_t num_extra = *,
     size_t max_num_steps = *,
     size_t max_ram_MB = *,
     bint dense_output = *,
@@ -313,12 +420,12 @@ cdef CySolveOutput cysolve_ivp_gil(
     DiffeqFuncType diffeq_ptr,
     const double* t_span_ptr,
     const double* y0_ptr,
-    const unsigned int num_y,
-    unsigned int method = *,
+    const size_t num_y,
+    int method = *,
     double rtol = *,
     double atol = *,
     void* args_ptr = *,
-    unsigned int num_extra = *,
+    size_t num_extra = *,
     size_t max_num_steps = *,
     size_t max_ram_MB = *,
     bint dense_output = *,
diff --git a/CyRK/cy/cysolver_api.pyx b/CyRK/cy/cysolver_api.pyx
index 610ea60..6cf8bac 100644
--- a/CyRK/cy/cysolver_api.pyx
+++ b/CyRK/cy/cysolver_api.pyx
@@ -2,7 +2,8 @@
 # cython: boundscheck=False, wraparound=False, nonecheck=False, cdivision=True, initializedcheck=False
 
 import numpy as np
-np.import_array()
+cimport numpy as cnp
+cnp.import_array()
 
 # =====================================================================================================================
 # Import CySolverResult (container for integration results)
@@ -17,7 +18,7 @@ cdef class WrapCySolverResult:
 
         # Convert solution to pointers and views
         if self.cyresult_ptr.size > 0:
-            self.time_ptr  = &self.cyresult_ptr.time_domain[0]
+            self.time_ptr  = &self.cyresult_ptr.time_domain_vec[0]
             self.y_ptr     = &self.cyresult_ptr.solution[0]
             self.time_view = <double[:self.size]>self.time_ptr
             self.y_view    = <double[:self.size * self.num_dy]>self.y_ptr
@@ -85,7 +86,7 @@ cdef class WrapCySolverResult:
     
     def __call__(self, t):
 
-        if type(t) == np.ndarray:
+        if type(t) == cnp.ndarray:
             return self.call_vectorize(t)
         else:
             return self.call(t).reshape(self.cyresult_ptr.num_dy, 1)
@@ -94,16 +95,63 @@ cdef class WrapCySolverResult:
 # =====================================================================================================================
 # Create Wrapped cysolve_ivp (has various defaults)
 # =====================================================================================================================
+cdef void cysolve_ivp_noreturn(
+            shared_ptr[CySolverResult] solution_sptr,
+            DiffeqFuncType diffeq_ptr,
+            const double* t_span_ptr,
+            const double* y0_ptr,
+            const size_t num_y,
+            int method = 1,
+            double rtol = 1.0e-3,
+            double atol = 1.0e-6,
+            void* args_ptr = NULL,
+            size_t num_extra = 0,
+            size_t max_num_steps = 0,
+            size_t max_ram_MB = 2000,
+            bint dense_output = False,
+            double* t_eval = NULL,
+            size_t len_t_eval = 0,
+            PreEvalFunc pre_eval_func = NULL,
+            double* rtols_ptr = NULL,
+            double* atols_ptr = NULL,
+            double max_step = MAX_STEP,
+            double first_step = 0.0,
+            size_t expected_size = 0
+            ) noexcept nogil:
+    baseline_cysolve_ivp_noreturn(
+        solution_sptr,
+        diffeq_ptr,
+        t_span_ptr,
+        y0_ptr,
+        num_y,
+        method,
+        expected_size,
+        num_extra,
+        args_ptr,
+        max_num_steps,
+        max_ram_MB,
+        dense_output,
+        t_eval,
+        len_t_eval,
+        pre_eval_func,
+        rtol,
+        atol,
+        rtols_ptr,
+        atols_ptr,
+        max_step,
+        first_step
+        )
+
 cdef CySolveOutput cysolve_ivp(
             DiffeqFuncType diffeq_ptr,
             const double* t_span_ptr,
             const double* y0_ptr,
-            const unsigned int num_y,
-            unsigned int method = 1,
+            const size_t num_y,
+            int method = 1,
             double rtol = 1.0e-3,
             double atol = 1.0e-6,
             void* args_ptr = NULL,
-            unsigned int num_extra = 0,
+            size_t num_extra = 0,
             size_t max_num_steps = 0,
             size_t max_ram_MB = 2000,
             bint dense_output = False,
@@ -116,7 +164,6 @@ cdef CySolveOutput cysolve_ivp(
             double first_step = 0.0,
             size_t expected_size = 0
             ) noexcept nogil:
-    
     cdef CySolveOutput result = baseline_cysolve_ivp(
         diffeq_ptr,
         t_span_ptr,
@@ -146,12 +193,12 @@ cdef CySolveOutput cysolve_ivp_gil(
             DiffeqFuncType diffeq_ptr,
             const double* t_span_ptr,
             const double* y0_ptr,
-            const unsigned int num_y,
-            unsigned int method = 1,
+            const size_t num_y,
+            int method = 1,
             double rtol = 1.0e-3,
             double atol = 1.0e-6,
             void* args_ptr = NULL,
-            unsigned int num_extra = 0,
+            size_t num_extra = 0,
             size_t max_num_steps = 0,
             size_t max_ram_MB = 2000,
             bint dense_output = False,
diff --git a/CyRK/cy/dense.cpp b/CyRK/cy/dense.cpp
index 91be4a8..9bbcd1f 100644
--- a/CyRK/cy/dense.cpp
+++ b/CyRK/cy/dense.cpp
@@ -1,57 +1,57 @@
-
 #include "dense.hpp"
+#include "cysolver.hpp"
 
 // Constructors
 CySolverDense::CySolverDense(
         int integrator_int,
-        double t_old,
-        double t_now,
-        double* y_in_ptr,
-        unsigned int num_y,
-        unsigned int num_extra,
-        unsigned int Q_order,
-        CySolverBase* cysolver_instance_ptr,
-        std::function<void (CySolverBase *)> cysolver_diffeq_ptr,
-        PyObject* cython_extension_class_instance,
-        double* cysolver_t_now_ptr,
-        double* cysolver_y_now_ptr,
-        double* cysolver_dy_now_ptr
+        CySolverBase* solver_ptr,
+        bool set_state
         ) :
             integrator_int(integrator_int),
-            num_y(num_y),
-            num_extra(num_extra),
-            cysolver_instance_ptr(cysolver_instance_ptr),
-            cysolver_diffeq_ptr(cysolver_diffeq_ptr),
-            cython_extension_class_instance(cython_extension_class_instance),
-            cysolver_t_now_ptr(cysolver_t_now_ptr),
-            cysolver_y_now_ptr(cysolver_y_now_ptr),
-            cysolver_dy_now_ptr(cysolver_dy_now_ptr),
-            t_old(t_old),
-            t_now(t_now),
-            Q_order(Q_order)
+            num_y(solver_ptr->num_y),
+            solver_ptr(solver_ptr)
 {
-    // Make a copy of the y_in pointer in this Dense interpolator's storage
-    std::memcpy(this->y_stored_ptr, y_in_ptr, sizeof(double) * this->num_y);
-    // Calculate step
-    this->step = this->t_now - this->t_old;
-
-    // Make a strong reference to the python class (if this dense output was built using the python hooks).
-    if (cython_extension_class_instance)
+    // Allocate memory for state vectors (memory allocation should not change since num_y does not change)
+    this->num_y = this->solver_ptr->num_y;
+    this->solver_ptr->set_Q_order(&this->Q_order);
+
+    // Resize state vector based on dimensions. The state vector is a combination of the current y-values and Q
+    // Q is a matrix of solver-specific parameters at the current time.
+    // Q is defined by Q = K.T.dot(self.P)  K has shape of (n_stages + 1, num_y) so K.T has shape of (num_y, n_stages + 1)
+    // P has shape of (4, 3) for RK23; (7, 4) for RK45.. So (n_stages + 1, Q_order)
+    // So Q has shape of (num_y, q_order)
+    // The max size of Q is (7) * num_y for DOP853
+    // state vector is laid out as [y_vector, Q_matrix]
+    this->state_data_vec.resize(this->num_y * (this->Q_order + 1));  // +1 is so we can store y_values in the first spot.
+
+    // Populate values with current state
+    if (set_state)
     {
-        Py_XINCREF(this->cython_extension_class_instance);
-        this->deconstruct_python = true;
+        this->set_state();
     }
-    
 }
 
 // Destructors
 CySolverDense::~CySolverDense()
 {
-    if (this->deconstruct_python)
-    {
-        // Decrease reference count on the cython extension class instance
-        Py_XDECREF(this->cython_extension_class_instance);
-    }
+
+}
+
+void CySolverDense::set_state()
+{
+    // Store time information
+    this->t_old = solver_ptr->t_old;
+    this->t_now = solver_ptr->t_now;
+    
+    // Calculate step
+    this->step = this->t_now - this->t_old;
+
+    // Make a copy of the y_in pointer in the state vector storage
+    std::memcpy(&this->state_data_vec[0], &this->solver_ptr->y_old[0], sizeof(double) * this->num_y);
+
+    // Tell the solver to populate the values of the Q matrix. 
+    // Q starts at the num_y location of the state vector
+    this->solver_ptr->set_Q_array(&this->state_data_vec[this->num_y]);
 }
 
 void CySolverDense::call(double t_interp, double* y_interp_ptr)
@@ -59,65 +59,67 @@ void CySolverDense::call(double t_interp, double* y_interp_ptr)
     double step_factor = (t_interp - this->t_old) / this->step;
 
     // SciPy Step:: p = np.tile(x, self.order + 1) (scipy order is Q_order - 1)
+    // Create pointers to the y and Q sub components of the state vector for ease of reading
+    double* y_stored_ptr = &this->state_data_vec[0];
+    double* Q_ptr        = &this->state_data_vec[this->num_y];
 
     // Q has shape of (n_stages + 1, num_y)
     // y = y_old + Q dot p.
-
     switch (this->integrator_int)
     {
     case 0:
         // RK23
-        for (unsigned int y_i = 0; y_i < this->num_y; y_i++)
+        for (size_t y_i = 0; y_i < this->num_y; y_i++)
         {
-            unsigned int Q_stride = this->Q_order * y_i;
+            const size_t Q_stride = this->Q_order * y_i;
             // P=0
             // Initialize dot product
             double cumulative_prod = step_factor;
-            double temp_double = this->Q_ptr[Q_stride] * cumulative_prod;
+            double temp_double = Q_ptr[Q_stride] * cumulative_prod;
             // P=1
             cumulative_prod *= step_factor;
-            temp_double += this->Q_ptr[Q_stride + 1] * cumulative_prod;
+            temp_double += Q_ptr[Q_stride + 1] * cumulative_prod;
             // P=2
             cumulative_prod *= step_factor;
-            temp_double += this->Q_ptr[Q_stride + 2] * cumulative_prod;
+            temp_double += Q_ptr[Q_stride + 2] * cumulative_prod;
 
             // Finally multiply by step
             temp_double *= this->step;
 
-            y_interp_ptr[y_i] = this->y_stored_ptr[y_i] + temp_double;
+            y_interp_ptr[y_i] = y_stored_ptr[y_i] + temp_double;
         }
         break;
 
     case 1:
         // RK45
-        for (unsigned int y_i = 0; y_i < this->num_y; y_i++)
+        for (size_t y_i = 0; y_i < this->num_y; y_i++)
         {
-            const unsigned int Q_stride = this->Q_order * y_i;
+            const size_t Q_stride = this->Q_order * y_i;
             // P=0
             double cumulative_prod = step_factor;
-            double temp_double = this->Q_ptr[Q_stride] * cumulative_prod;
+            double temp_double = Q_ptr[Q_stride] * cumulative_prod;
             // P=1
             cumulative_prod *= step_factor;
-            temp_double += this->Q_ptr[Q_stride + 1] * cumulative_prod;
+            temp_double += Q_ptr[Q_stride + 1] * cumulative_prod;
             // P=2
             cumulative_prod *= step_factor;
-            temp_double += this->Q_ptr[Q_stride + 2] * cumulative_prod;
+            temp_double += Q_ptr[Q_stride + 2] * cumulative_prod;
             // P=3
             cumulative_prod *= step_factor;
-            temp_double += this->Q_ptr[Q_stride + 3] * cumulative_prod;
+            temp_double += Q_ptr[Q_stride + 3] * cumulative_prod;
             
             // Finally multiply by step
             temp_double *= this->step;
 
-            y_interp_ptr[y_i] = this->y_stored_ptr[y_i] + temp_double;
+            y_interp_ptr[y_i] = y_stored_ptr[y_i] + temp_double;
         }
         break;
 
     case 2:
         // DOP853
-        for (unsigned int y_i = 0; y_i < this->num_y; y_i++)
+        for (size_t y_i = 0; y_i < this->num_y; y_i++)
         {
-            const unsigned int Q_stride = this->Q_order * y_i;
+            const size_t Q_stride = this->Q_order * y_i;
             // This method is different from RK23 and RK45
             // Q is the reverse of SciPy's "F". The size of Q is (Interpolator power (Q_order), num_y)
             // DOP853 interp power is 7
@@ -125,76 +127,68 @@ void CySolverDense::call(double t_interp, double* y_interp_ptr)
             // Odd values are multiplied by 1 - step factor.
 
             // P=0
-            double temp_double = this->Q_ptr[Q_stride];
+            double temp_double = Q_ptr[Q_stride];
             temp_double *= step_factor;
             // P=1
-            temp_double += this->Q_ptr[Q_stride + 1];
+            temp_double += Q_ptr[Q_stride + 1];
             temp_double *= (1.0 - step_factor);
             // P=2
-            temp_double += this->Q_ptr[Q_stride + 2];
+            temp_double += Q_ptr[Q_stride + 2];
             temp_double *= step_factor;
             // P=3
-            temp_double += this->Q_ptr[Q_stride + 3];
+            temp_double += Q_ptr[Q_stride + 3];
             temp_double *= (1.0 - step_factor);
             // P=4
-            temp_double += this->Q_ptr[Q_stride + 4];
+            temp_double += Q_ptr[Q_stride + 4];
             temp_double *= step_factor;
             // P=5
-            temp_double += this->Q_ptr[Q_stride + 5];
+            temp_double += Q_ptr[Q_stride + 5];
             temp_double *= (1.0 - step_factor);
             // P=6
-            temp_double += this->Q_ptr[Q_stride + 6];
+            temp_double += Q_ptr[Q_stride + 6];
             temp_double *= step_factor;
 
-            y_interp_ptr[y_i] = this->y_stored_ptr[y_i] + temp_double;
+            y_interp_ptr[y_i] = y_stored_ptr[y_i] + temp_double;
         }
         break;
 
     [[unlikely]] default:
         // Don't know the model. Just return the input.
-        std::memcpy(y_interp_ptr, this->y_stored_ptr, sizeof(double) * this->num_y);
+        std::memcpy(y_interp_ptr, y_stored_ptr, sizeof(double) * this->num_y);
         break;
     }
 
-    if (this->num_extra > 0)
+    if (this->solver_ptr)
     {
-        // We have interpolated the dependent y-values but have not handled any extra outputs
-        // We can not use the RK (or any other integration method's) fancy interpolation because extra outputs are
-        // not included in the, for example, Q matrix building process.
-        // TODO: Perhaps we could include them in that? 
-        // For now, we will make an additional call to the diffeq using the y0 we just found above and t_interp.
-        
-        size_t num_dy = this->num_y + this->num_extra;
-
-        // Store a copy of dy_now, t_now, and y_now into old vectors so we can make the call non destructively.
-        // y array
-        double y_tmp[Y_LIMIT];
-        double* y_tmp_ptr = &y_tmp[0];
-        memcpy(y_tmp_ptr, this->cysolver_y_now_ptr, sizeof(double) * this->num_y);
-        // dy array
-        double dy_tmp[DY_LIMIT];
-        double* dy_tmp_ptr = &dy_tmp[0];
-        memcpy(dy_tmp_ptr, this->cysolver_dy_now_ptr, sizeof(double) * num_dy);
-        // t
-        double t_tmp = cysolver_t_now_ptr[0];
-
-        // Load new values into t and y
-        memcpy(this->cysolver_y_now_ptr, y_interp_ptr, sizeof(double) * this->num_y);
-        cysolver_t_now_ptr[0] = t_interp;
-        
-        // Call diffeq to update dy_now pointer
-        this->cysolver_diffeq_ptr(this->cysolver_instance_ptr);
-
-        // Capture extra output and add to the y_interp_ptr array
-        // We already have y interpolated from above so start at num_y
-        for (size_t i = this->num_y; i < num_dy; i++)
+        if (this->solver_ptr->num_extra > 0)
         {
-            y_interp_ptr[i] = this->cysolver_dy_now_ptr[i];
-        }
+            // We have interpolated the dependent y-values but have not handled any extra outputs
+            // We can not use the RK (or any other integration method's) fancy interpolation because extra outputs are
+            // not included in the, for example, Q matrix building process.
+            // TODO: Perhaps we could include them in that? 
+            // For now, we will make an additional call to the diffeq using the y0 we just found above and t_interp.
+            
+            size_t num_dy = this->solver_ptr->num_dy;
+
+            // We will be overwriting the solver's now variables so tell it to store a copy that it can be restored back to.
+            this->solver_ptr->offload_to_temp();
 
-        // Reset CySolver state to what it was before
-        cysolver_t_now_ptr[0] = t_tmp;
-        memcpy(this->cysolver_y_now_ptr, y_tmp_ptr, sizeof(double) * num_y);
-        memcpy(this->cysolver_dy_now_ptr, dy_tmp_ptr, sizeof(double) * num_dy);
+            // Load new values into t and y
+            std::memcpy(&this->solver_ptr->y_now[0], y_interp_ptr, sizeof(double) * this->num_y);
+            this->solver_ptr->t_now = t_interp;
+            
+            // Call diffeq to update dy_now pointer
+            this->solver_ptr->diffeq(this->solver_ptr);
+
+            // Capture extra output and add to the y_interp_ptr array
+            // We already have y interpolated from above so start at num_y
+            for (size_t i = this->num_y; i < num_dy; i++)
+            {
+                y_interp_ptr[i] = this->solver_ptr->dy_now[i];
+            }
+
+            // Reset CySolver state to what it was before
+            this->solver_ptr->load_back_from_temp();
+        }
     }
 }
\ No newline at end of file
diff --git a/CyRK/cy/dense.hpp b/CyRK/cy/dense.hpp
index f7d22b8..f53320b 100644
--- a/CyRK/cy/dense.hpp
+++ b/CyRK/cy/dense.hpp
@@ -4,57 +4,44 @@
 * S o by avoiding calls to New we greatly improve performance.
 */
 
+#include <memory>
 #include <functional>
+#include <vector>
 #include <cstring>
 
-#include "Python.h"
 #include "common.hpp"
 
-// We need a pointer to the CySolverBase class. But that file includes this one. So we need to do a forward declaration
 class CySolverBase;
 
 
 class CySolverDense
+/* Many of these dense classes will be built if the integration is long and `dense_output=True`. It needs to be as light weight as possible. 
+Keep in mind that its true size equals the below structure + the size of the state_vector which is heap allocated and size = num_y * Q_order.
+*/
 {
 /* Attributes */
 protected:
 
-    // Q is defined by Q = K.T.dot(self.P)  K has shape of (n_stages + 1, num_y) so K.T has shape of (num_y, n_stages + 1)
-    // P has shape of (4, 3) for RK23; (7, 4) for RK45.. So (n_stages + 1, Q_order)
-    // So Q has shape of (num_y, q_order)
-    // The max size of Q is (7) * num_y. Lets assume this is the max size and stack allocate Q.
-    double Q[Y_LIMIT * 7] = { };
-
 public:
 
     // Integrator info
     int integrator_int = -1;
 
     // y and t state info
-    unsigned int num_y = 0;
-    unsigned int num_extra = 0;
+    // Dense state variables
+    size_t Q_order = 0;
+    size_t num_y   = 0;
 
     // Pointer to the CySolverBase class
-    CySolverBase* cysolver_instance_ptr = nullptr;
-    std::function<void (CySolverBase *)> cysolver_diffeq_ptr = nullptr;
-    double* cysolver_t_now_ptr  = nullptr;
-    double* cysolver_y_now_ptr  = nullptr;
-    double* cysolver_dy_now_ptr = nullptr;
-    PyObject* cython_extension_class_instance = nullptr;
-    bool deconstruct_python = false;
+    CySolverBase* solver_ptr = nullptr;
 
     // Time step info
-    double step = 0.0;
     double t_old = 0.0;
     double t_now = 0.0;
+    double step  = 0.0;
 
-    // Stored y values at interpolation step
-    double y_stored[Y_LIMIT] = { };
-    double* y_stored_ptr     = &y_stored[0];
-
-    // Dense state variables
-    double* Q_ptr = &Q[0];
-    unsigned int Q_order = 0;
+    // Vectors for stored data (stored at each step)
+    std::vector<double> state_data_vec;
 
 /* Methods */
 protected:
@@ -64,19 +51,10 @@ class CySolverDense
     CySolverDense() {};
     CySolverDense(
         int integrator_int,
-        double t_old,
-        double t_now,
-        double* y_in_ptr,
-        unsigned int num_y,
-        unsigned int num_extra,
-        unsigned int Q_order,
-        CySolverBase* cysolver_instance_ptr,
-        std::function<void (CySolverBase *)> cysolver_diffeq_ptr,
-        PyObject* cython_extension_class_instance,
-        double* cysolver_t_now_ptr,
-        double* cysolver_y_now_ptr,
-        double* cysolver_dy_now_ptr
+        CySolverBase* solver_ptr,
+        bool set_state
         );
 
+    virtual void set_state();
     virtual void call(double t_interp, double* y_interp_ptr);
 };
diff --git a/CyRK/cy/pysolver.pxd b/CyRK/cy/pysolver.pxd
index 0e9b443..e92f758 100644
--- a/CyRK/cy/pysolver.pxd
+++ b/CyRK/cy/pysolver.pxd
@@ -3,32 +3,30 @@ cimport cpython.ref as cpy_ref
 
 from CyRK.utils.memory cimport shared_ptr
 from CyRK.cy.pysolver_cyhook cimport DiffeqMethod
-from CyRK.cy.cysolver_api cimport CySolverResult
+from CyRK.cy.cysolver_api cimport CySolverResult, NowStatePointers
 
-cimport numpy as np
+cimport numpy as cnp
+cnp.import_array()
 
 # =====================================================================================================================
 # Import the C++ cysolve_ivp helper function
 # =====================================================================================================================
 cdef extern from "cysolve.cpp" nogil:
     # Python-hook implementation
-    struct PySolverStatePointers:
-        double* dy_now_ptr
-        double* t_now_ptr
-        double* y_now_ptr
 
     cdef cppclass PySolver:
         PySolver()
         PySolver(
-            unsigned int integration_method,
+            int integration_method,
             cpy_ref.PyObject* cython_extension_class_instance,
             DiffeqMethod cython_extension_class_diffeq_method,
-            shared_ptr[CySolverResult] solution_ptr,
+            shared_ptr[CySolverResult] solution_sptr,
             const double t_start,
             const double t_end,
             const double* y0_ptr,
-            const unsigned int num_y,
-            const unsigned int num_extra,
+            const size_t num_y,
+            const size_t expected_size,
+            const size_t num_extra,
             const void* args_ptr,
             const size_t max_num_steps,
             const size_t max_ram_MB,
@@ -41,8 +39,10 @@ cdef extern from "cysolve.cpp" nogil:
             const double* atols_ptr,
             const double max_step_size,
             const double first_step_size)
-        PySolverStatePointers get_state_pointers()
         void solve()
+        int status
+        int integration_method
+        shared_ptr[CySolverResult] solution_sptr
 
 
 cdef class WrapPyDiffeq:
@@ -52,12 +52,12 @@ cdef class WrapPyDiffeq:
     cdef cpp_bool use_args
     cdef cpp_bool pass_dy_as_arg
 
-    cdef unsigned int num_y
-    cdef unsigned int num_dy
+    cdef size_t num_y
+    cdef size_t num_dy
 
-    cdef np.ndarray y_now_arr
+    cdef cnp.ndarray y_now_arr
     cdef double[::1] y_now_view
-    cdef np.ndarray dy_now_arr
+    cdef cnp.ndarray dy_now_arr
     cdef double[::1] dy_now_view
 
     # State attributes
@@ -65,10 +65,6 @@ cdef class WrapPyDiffeq:
     cdef double* t_now_ptr
     cdef double* dy_now_ptr
 
-    cdef void set_state(self,
-        double* dy_ptr,
-        double* t_ptr,
-        double* y_ptr
-        ) noexcept
+    cdef void set_state(self, NowStatePointers* solver_state_ptr) noexcept
     
     cdef void diffeq(self) noexcept
diff --git a/CyRK/cy/pysolver.pyx b/CyRK/cy/pysolver.pyx
index c6d9d12..84c2958 100644
--- a/CyRK/cy/pysolver.pyx
+++ b/CyRK/cy/pysolver.pyx
@@ -8,7 +8,8 @@ from CyRK.utils.memory cimport make_shared
 from CyRK.cy.cysolver_api cimport find_expected_size, WrapCySolverResult, INF, EPS_100, Y_LIMIT, DY_LIMIT
 
 import numpy as np
-np.import_array()
+cimport numpy as cnp
+cnp.import_array()
 
 # =====================================================================================================================
 # PySolver Class (holds the intergrator class and reference to the python diffeq function)
@@ -19,8 +20,8 @@ cdef class WrapPyDiffeq:
             self,
             object diffeq_func,
             tuple args,
-            unsigned int num_y,
-            unsigned int num_dy,
+            size_t num_y,
+            size_t num_dy,
             bint pass_dy_as_arg = False
             ):
         
@@ -47,10 +48,11 @@ cdef class WrapPyDiffeq:
         else:
             self.pass_dy_as_arg = False
     
-    cdef void set_state(self, double* dy_ptr, double* t_ptr, double* y_ptr) noexcept:
-        self.dy_now_ptr = dy_ptr
-        self.t_now_ptr  = t_ptr
-        self.y_now_ptr  = y_ptr
+    cdef void set_state(self, NowStatePointers* solver_state_ptr) noexcept:
+        
+        self.t_now_ptr  = solver_state_ptr.t_now_ptr
+        self.y_now_ptr  = solver_state_ptr.y_now_ptr
+        self.dy_now_ptr = solver_state_ptr.dy_now_ptr
 
         # Create memoryviews of the pointers
         self.y_now_view  = <double[:self.num_y]>self.y_now_ptr
@@ -60,17 +62,17 @@ cdef class WrapPyDiffeq:
         # That is why we use `PyArray_SimpleNewFromData` instead of a more simple `asarray`.
         # Note that it is not safe to return these arrays outside of this class because they may get deallocated while
         # the numpy array still points to the underlying memory.
-        cdef np.npy_intp[1] shape
-        cdef np.npy_intp* shape_ptr = &shape[0]
-        shape_ptr[0] = <np.npy_intp>self.num_y
+        cdef cnp.npy_intp[1] shape
+        cdef cnp.npy_intp* shape_ptr = &shape[0]
+        shape_ptr[0] = <cnp.npy_intp>self.num_y
         
-        self.y_now_arr = np.PyArray_SimpleNewFromData(1, shape_ptr, np.NPY_DOUBLE, self.y_now_ptr)
+        self.y_now_arr = cnp.PyArray_SimpleNewFromData(1, shape_ptr, cnp.NPY_DOUBLE, self.y_now_ptr)
         
         # Do the same for dy if the user provided the appropriate kind of differential equation.
         if self.pass_dy_as_arg:
             self.dy_now_view = <double[:self.num_dy]>self.dy_now_ptr
-            shape[0]         = <np.npy_intp>self.num_dy  # dy may have a larger shape than y
-            self.dy_now_arr  = np.PyArray_SimpleNewFromData(1, shape_ptr, np.NPY_DOUBLE, self.dy_now_ptr)   
+            shape[0]         = <cnp.npy_intp>self.num_dy  # dy may have a larger shape than y
+            self.dy_now_arr  = cnp.PyArray_SimpleNewFromData(1, shape_ptr, cnp.NPY_DOUBLE, self.dy_now_ptr)   
 
     cdef void diffeq(self) noexcept:
         # Run python diffeq
@@ -102,7 +104,7 @@ def pysolve_ivp(
         bint dense_output = False,
         tuple args = None,
         size_t expected_size = 0,
-        unsigned int num_extra = 0,
+        size_t num_extra = 0,
         double first_step = 0.0,
         double max_step = INF,
         rtol = 1.0e-3,
@@ -114,7 +116,7 @@ def pysolve_ivp(
 
     # Parse method
     method = method.lower()
-    cdef unsigned int integration_method = 1
+    cdef int integration_method = 1
     if method == "rk23":
         integration_method = 0
     elif method == "rk45":
@@ -133,7 +135,7 @@ def pysolve_ivp(
     cdef cpp_bool direction_flag = (t_end - t_start) >= 0
 
     # Parse y0
-    cdef unsigned int num_y   = len(y0)
+    cdef size_t num_y   = len(y0)
     cdef const double* y0_ptr = &y0[0]
     if num_y > Y_LIMIT:
         raise AttributeError(
@@ -154,7 +156,7 @@ def pysolve_ivp(
         raise AttributeError(
             f"CyRK can only capture a maximum number of {DY_LIMIT - Y_LIMIT} extra outputs. {num_extra} were provided."
             )
-    cdef unsigned int num_dy = num_y + num_extra
+    cdef size_t num_dy = num_y + num_extra
     
     # Parse rtol
     cdef double* rtols_ptr = NULL
@@ -207,7 +209,7 @@ def pysolve_ivp(
         raise AttributeError("Maximum step size must be a postive float.")
 
     # Build solution storage
-    cdef shared_ptr[CySolverResult] result_ptr = make_shared[CySolverResult](
+    cdef shared_ptr[CySolverResult] solution_sptr = make_shared[CySolverResult](
         num_y,
         num_extra,
         expected_size,
@@ -233,11 +235,12 @@ def pysolve_ivp(
             integration_method,
             <cpy_ref.PyObject*>diffeq_wrap,
             diffeq_func,
-            result_ptr,
+            solution_sptr,
             t_start,
             t_end,
             y0_ptr,
             num_y,
+            expected_size,
             num_extra,
             args_ptr,
             max_num_steps,
@@ -253,13 +256,9 @@ def pysolve_ivp(
             first_step
         )
 
-    # Get pointers to the solver's state variables so that the Python differential equation can use and update them.
-    cdef PySolverStatePointers state_pointers = solver.get_state_pointers()
-    diffeq_wrap.set_state(
-        state_pointers.dy_now_ptr,
-        state_pointers.t_now_ptr,
-        state_pointers.y_now_ptr
-        )
+    # Get pointers to the solver so that the Python differential equation can use and update its state variables (t_now, y_now, dy_now).
+    cdef NowStatePointers solver_state = solver.solution_sptr.get().solver_uptr.get().get_now_state()
+    diffeq_wrap.set_state(&solver_state)
     
     ##
     # Run the integrator!
@@ -268,7 +267,7 @@ def pysolve_ivp(
     
     # Wrap the solution in a python-safe wrapper class
     cdef WrapCySolverResult pyresult = WrapCySolverResult()
-    pyresult.set_cyresult_pointer(result_ptr)
+    pyresult.set_cyresult_pointer(solution_sptr)
 
     del solver
 
diff --git a/CyRK/cy/rk.cpp b/CyRK/cy/rk.cpp
index 4137ee6..56e27ab 100644
--- a/CyRK/cy/rk.cpp
+++ b/CyRK/cy/rk.cpp
@@ -1,4 +1,6 @@
 #include "rk.hpp"
+#include "dense.hpp"
+#include "cysolution.hpp"
 
 // ########################################################################################################################
 // RKSolver (Base)
@@ -8,12 +10,12 @@ RKSolver::RKSolver() {}
 RKSolver::RKSolver(
     // Base Class input arguments
     DiffeqFuncType diffeq_ptr,
-    std::shared_ptr<CySolverResult> const storage_ptr,
+    std::shared_ptr<CySolverResult> const storage_sptr,
     const double t_start,
     const double t_end,
     const double* y0_ptr,
-    const unsigned int num_y,
-    const unsigned int num_extra,
+    const size_t num_y,
+    const size_t num_extra,
     const void* args_ptr,
     const size_t max_num_steps,
     const size_t max_ram_MB,
@@ -30,7 +32,7 @@ RKSolver::RKSolver(
     const double first_step_size) :
         CySolverBase(
             diffeq_ptr,
-            storage_ptr,
+            storage_sptr,
             t_start,
             t_end,
             y0_ptr,
@@ -51,25 +53,24 @@ RKSolver::RKSolver(
     {
         if (this->user_provided_first_step_size < 0.0) [[unlikely]]
         {
-            this->storage_ptr->error_code = -1;
-            this->storage_ptr->update_message("User-provided initial step size must be a positive number.");
+            this->storage_sptr->error_code = -1;
+            this->storage_sptr->update_message("User-provided initial step size must be a positive number.");
         }
         else if (first_step_size > (this->t_delta_abs * 0.5)) [[unlikely]]
         {
-            this->storage_ptr->error_code = -1;
-            this->storage_ptr->update_message("User-provided initial step size must be smaller than 50 % of the time span size.");
+            this->storage_sptr->error_code = -1;
+            this->storage_sptr->update_message("User-provided initial step size must be smaller than 50 % of the time span size.");
         }
     }
 
     // Setup tolerances
     // User can provide an array of relative tolerances, one for each y value.
     // The length of the pointer array must be the same as y0 (and <= 25).
-
     if (rtols_ptr)
     {
         // rtol for each y
         this->use_array_rtols = true;
-        for (unsigned int y_i = 0; y_i < this->num_y; y_i++)
+        for (size_t y_i = 0; y_i < this->num_y; y_i++)
         {
             double temp_double = rtols_ptr[y_i];
             if (temp_double < EPS_100) [[unlikely]]
@@ -108,7 +109,6 @@ RKSolver::~RKSolver()
 
 }
 
-
 // Protected Methods
 void RKSolver::p_estimate_error()
 {   
@@ -118,7 +118,7 @@ void RKSolver::p_estimate_error()
 
     this->error_norm = 0.0;
 
-    for (unsigned int y_i = 0; y_i < this->num_y; y_i++)
+    for (size_t y_i = 0; y_i < this->num_y; y_i++)
     {
         if (this->use_array_rtols)
         {
@@ -131,8 +131,8 @@ void RKSolver::p_estimate_error()
         }
 
         // Dot product between K and E
-        double error_dot = 0.0;
-        const unsigned int stride_K = y_i * this->n_stages_p1;
+        double error_dot      = 0.0;
+        const size_t stride_K = y_i * this->n_stages_p1;
 
         switch (this->n_stages)
         {
@@ -160,7 +160,7 @@ void RKSolver::p_estimate_error()
         [[unlikely]] default:
             // Resort to unrolled loops
             // New or Non-optimized RK method. default to for loop.
-            for (unsigned int j = 0; j < this->n_stages_p1; j++)
+            for (size_t j = 0; j < this->n_stages_p1; j++)
             {
                 error_dot += this->E_ptr[j] * this->K_ptr[stride_K + j];
             }
@@ -168,7 +168,7 @@ void RKSolver::p_estimate_error()
         }
 
         // Find scale of y for error calculations
-        const double scale_inv = 1.0 / (atol + std::fmax(std::fabs(this->y_old_ptr[y_i]), std::fabs(this->y_now_ptr[y_i])) * rtol);
+        const double scale_inv = 1.0 / (atol + std::fmax(std::fabs(this->y_old[y_i]), std::fabs(this->y_now[y_i])) * rtol);
 
         // We need the absolute value but since we are taking the square, it is guaranteed to be positive.
         // TODO: This will need to change if CySolver ever accepts complex numbers
@@ -197,10 +197,10 @@ void RKSolver::p_step_implementation()
     const double* const l_A_ptr = this->A_ptr;
     const double* const l_B_ptr = this->B_ptr;
     const double* const l_C_ptr = this->C_ptr;
-    double* const l_y_now_ptr   = this->y_now_ptr;
-    double* const l_y_old_ptr   = this->y_old_ptr;
-    double* const l_dy_now_ptr  = this->dy_now_ptr;
-    double* const l_dy_old_ptr  = this->dy_old_ptr;
+    double* const l_y_now_ptr   = &this->y_now[0];
+    double* const l_y_old_ptr   = &this->y_old[0];
+    double* const l_dy_now_ptr  = &this->dy_now[0];
+    double* const l_dy_old_ptr  = &this->dy_old[0];
 
     // Determine step size based on previous loop
     // Find minimum step size based on the value of t (less floating point numbers between numbers when t is large)
@@ -232,22 +232,22 @@ void RKSolver::p_step_implementation()
         // Move time forward for this particular step size
         double t_delta_check;
         if (this->direction_flag) {
-            this->step             = this->step_size;
-            this->t_now_ptr[0] = this->t_old + this->step;
-            t_delta_check      = this->t_now_ptr[0] - this->t_end;
+            this->step    = this->step_size;
+            this->t_now   = this->t_old + this->step;
+            t_delta_check = this->t_now - this->t_end;
         }
         else {
-            this->step             = -this->step_size;
-            this->t_now_ptr[0] = this->t_old + this->step;
-            t_delta_check      = this->t_end - this->t_now_ptr[0];
+            this->step    = -this->step_size;
+            this->t_now   = this->t_old + this->step;
+            t_delta_check = this->t_end - this->t_now;
         }
 
         // Check that we are not at the end of integration with that move
         if (t_delta_check > 0.0) {
-            this->t_now_ptr[0] = this->t_end;
+            this->t_now = this->t_end;
 
             // If we are, correct the step so that it just hits the end of integration.
-            this->step = this->t_now_ptr[0] - this->t_old;
+            this->step = this->t_now - this->t_old;
             if (this->direction_flag) {
                 this->step_size = this->step;
             }
@@ -260,17 +260,17 @@ void RKSolver::p_step_implementation()
 
         // t_now must be updated for each loop of s in order to make the diffeq method calls.
         // But we need to return to its original value later on. Store in temp variable.
-        const double time_tmp = this->t_now_ptr[0];
+        const double time_tmp = this->t_now;
 
-        for (unsigned int s = 1; s < this->len_C; s++) {
+        for (size_t s = 1; s < this->len_C; s++) {
             // Find the current time based on the old time and the step size.
-            this->t_now_ptr[0] = this->t_old + l_C_ptr[s] * this->step;
-            const unsigned int stride_A = s * this->len_Acols;
+            this->t_now = this->t_old + l_C_ptr[s] * this->step;
+            const size_t stride_A = s * this->len_Acols;
 
-            for (unsigned int y_i = 0; y_i < this->num_y; y_i++)
+            for (size_t y_i = 0; y_i < this->num_y; y_i++)
             {
                 double temp_double;
-                const unsigned int stride_K = y_i * this->n_stages_p1;
+                const size_t stride_K = y_i * this->n_stages_p1;
                 // Dot Product (K, a) * step
                 switch (s)
                 {
@@ -446,7 +446,7 @@ void RKSolver::p_step_implementation()
                     // Initialize
                     temp_double = 0.0;
 
-                    for (unsigned int j = 0; j < s; j++)
+                    for (size_t j = 0; j < s; j++)
                     {
                         temp_double += l_A_ptr[stride_A + j] * l_K_ptr[stride_K + j];
                     }
@@ -460,20 +460,20 @@ void RKSolver::p_step_implementation()
             this->diffeq(this);
 
             // Update K based on the new dy values.
-            for (unsigned int y_i = 0; y_i < this->num_y; y_i++) {
-                const unsigned int stride_K = y_i * this->n_stages_p1;
+            for (size_t y_i = 0; y_i < this->num_y; y_i++) {
+                const size_t stride_K = y_i * this->n_stages_p1;
                 l_K_ptr[stride_K + s] = l_dy_now_ptr[y_i];
             }
         }
 
         // Restore t_now to its previous value.
-        this->t_now_ptr[0] = time_tmp;
+        this->t_now = time_tmp;
 
         // Dot Product (K, B) * step
-        for (unsigned int y_i = 0; y_i < this->num_y; y_i++)
+        for (size_t y_i = 0; y_i < this->num_y; y_i++)
         {
             double temp_double;
-            const unsigned int stride_K = y_i * this->n_stages_p1;
+            const size_t stride_K = y_i * this->n_stages_p1;
 
             switch (this->n_stages)
             {
@@ -512,7 +512,7 @@ void RKSolver::p_step_implementation()
                 // Initialize
                 temp_double = 0.0;
 
-                for (unsigned int j = 0; j < this->n_stages; j++)
+                for (size_t j = 0; j < this->n_stages; j++)
                 {
                     temp_double += l_B_ptr[j] * l_K_ptr[stride_K + j];
                 }
@@ -527,9 +527,9 @@ void RKSolver::p_step_implementation()
         this->diffeq(this);
 
         // Set last column of K equal to dydt. K has size num_y * (n_stages + 1) so the last column is at n_stages
-        for (unsigned int y_i = 0; y_i < this->num_y; y_i++)
+        for (size_t y_i = 0; y_i < this->num_y; y_i++)
         {
-            const unsigned int stride_K = y_i * this->n_stages_p1;
+            const size_t stride_K = y_i * this->n_stages_p1;
             l_K_ptr[stride_K + this->n_stages] = l_dy_now_ptr[y_i];
         }
 
@@ -634,7 +634,7 @@ void RKSolver::calc_first_step_size()
         // Find the norm for d0 and d1
         d0 = 0.0;
         d1 = 0.0;
-        for (unsigned int y_i = 0; y_i < this->num_y; y_i++)
+        for (size_t y_i = 0; y_i < this->num_y; y_i++)
         {
             if (this->use_array_rtols)
             {
@@ -645,10 +645,10 @@ void RKSolver::calc_first_step_size()
                 atol = this->atols_ptr[y_i];
             }
 
-            y_old_tmp = this->y_old_ptr[y_i];
+            y_old_tmp = this->y_old[y_i];
             scale     = atol + std::fabs(y_old_tmp) * rtol;
             d0_abs    = std::fabs(y_old_tmp / scale);
-            d1_abs    = std::fabs(dy_old_ptr[y_i] / scale);
+            d1_abs    = std::fabs(this->dy_old[y_i] / scale);
             d0       += (d0_abs * d0_abs);
             d1       += (d1_abs * d1_abs);
         }
@@ -666,10 +666,10 @@ void RKSolver::calc_first_step_size()
 
         h0_direction = this->direction_flag ? h0 : -h0;
 
-        this->t_now_ptr[0] = this->t_old + h0_direction;
-        for (unsigned int y_i = 0; y_i < this->num_y; y_i++)
+        this->t_now = this->t_old + h0_direction;
+        for (size_t y_i = 0; y_i < this->num_y; y_i++)
         {
-            this->y_now_ptr[y_i] = this->y_old_ptr[y_i] + h0_direction * this->dy_old_ptr[y_i];
+            this->y_now[y_i] = this->y_old[y_i] + h0_direction * this->dy_old[y_i];
         }
 
         // Update dy
@@ -677,7 +677,7 @@ void RKSolver::calc_first_step_size()
 
         // Find the norm for d2
         d2 = 0.0;
-        for (unsigned int y_i = 0; y_i < this->num_y; y_i++)
+        for (size_t y_i = 0; y_i < this->num_y; y_i++)
         {
             if (this->use_array_rtols)
             {
@@ -688,8 +688,8 @@ void RKSolver::calc_first_step_size()
                 atol = this->atols_ptr[y_i];
             }
 
-            scale  = atol + std::fabs(this->y_old_ptr[y_i]) * rtol;
-            d2_abs = std::fabs((this->dy_now_ptr[y_i] - this->dy_old_ptr[y_i]) / scale);
+            scale  = atol + std::fabs(this->y_old[y_i]) * rtol;
+            d2_abs = std::fabs((this->dy_now[y_i] - this->dy_old[y_i]) / scale);
             d2    += (d2_abs * d2_abs);
         }
 
@@ -708,7 +708,16 @@ void RKSolver::calc_first_step_size()
 
 /* Dense Output Methods */
 
-void RKSolver::p_update_Q(double* Q_ptr)
+void RKSolver::set_Q_order(size_t* Q_order_ptr)
+{
+    // Q's definition depends on the integrators implementation. 
+    // For default RK, it is defined by Q = K.T.dot(self.P)  K has shape of (n_stages + 1, num_y) so K.T has shape of (num_y, n_stages + 1)
+    // P has shape of (4, 3) for RK23; (7, 4) for RK45.. So (n_stages + 1, Q_order)
+    // So Q has shape of (num_y, num_Pcols)
+    Q_order_ptr[0] = this->len_Pcols; 
+}
+
+void RKSolver::set_Q_array(double* Q_ptr)
 {
     // Q's definition depends on the integrators implementation. 
     // For default RK, it is defined by Q = K.T.dot(self.P)  K has shape of (n_stages + 1, num_y) so K.T has shape of (num_y, n_stages + 1)
@@ -720,10 +729,10 @@ void RKSolver::p_update_Q(double* Q_ptr)
 
     case(0):
         // RK23
-        for (unsigned int y_i = 0; y_i < this->num_y; y_i++)
+        for (size_t y_i = 0; y_i < this->num_y; y_i++)
         {
-            const unsigned int stride_Q = y_i * this->len_Pcols;
-            const unsigned int stride_K = y_i * this->n_stages_p1;
+            const size_t stride_Q = y_i * this->len_Pcols;
+            const size_t stride_K = y_i * this->n_stages_p1;
             // len_Pcols == 3; n_stages + 1 == 4
 
             // P = 0
@@ -734,7 +743,7 @@ void RKSolver::p_update_Q(double* Q_ptr)
             Q_ptr[stride_Q] = temp_double;
 
             // P = 1
-            unsigned int stride_P = this->n_stages_p1;
+            size_t stride_P = this->n_stages_p1;
             temp_double = this->K_ptr[stride_K] * this->P_ptr[stride_P];
             temp_double += this->K_ptr[stride_K + 1] * this->P_ptr[stride_P + 1];
             temp_double += this->K_ptr[stride_K + 2] * this->P_ptr[stride_P + 2];
@@ -753,10 +762,10 @@ void RKSolver::p_update_Q(double* Q_ptr)
 
     case(1):
         // RK45
-        for (unsigned int y_i = 0; y_i < this->num_y; y_i++)
+        for (size_t y_i = 0; y_i < this->num_y; y_i++)
         {
-            const unsigned int stride_Q = y_i * this->len_Pcols;
-            const unsigned int stride_K = y_i * this->n_stages_p1;
+            const size_t stride_Q = y_i * this->len_Pcols;
+            const size_t stride_K = y_i * this->n_stages_p1;
 
             // len_Pcols == 4; n_stages + 1 == 7
             // P = 0
@@ -770,7 +779,7 @@ void RKSolver::p_update_Q(double* Q_ptr)
             Q_ptr[stride_Q] = temp_double;
 
             // P = 1
-            unsigned int stride_P = this->n_stages_p1;
+            size_t stride_P = this->n_stages_p1;
             temp_double  = this->K_ptr[stride_K]     * this->P_ptr[stride_P];
             temp_double += this->K_ptr[stride_K + 1] * this->P_ptr[stride_P + 1];
             temp_double += this->K_ptr[stride_K + 2] * this->P_ptr[stride_P + 2];
@@ -811,15 +820,7 @@ void RKSolver::p_update_Q(double* Q_ptr)
         // This method uses the current values stored in K and expands upon them by 3 more values determined by calls to the diffeq.
 
         // We need to save a copy of the current state because we will overwrite the values shortly
-        double dy_now_storage[DY_LIMIT] = { };
-        double* dy_now_storage_ptr = &dy_now_storage[0];
-        std::memcpy(dy_now_storage_ptr, this->dy_now_ptr, sizeof(double) * this->num_dy);
-
-        double y_now_storage[Y_LIMIT] = { };
-        double* y_now_storage_ptr = &y_now_storage[0];
-        std::memcpy(y_now_storage_ptr, this->y_now_ptr, sizeof(double) * this->num_y);
-
-        double time_storage = this->t_now_ptr[0];
+        this->offload_to_temp();
 
         // We also need to store dy_dt so that they can be used in dot products
         double K_extended[Y_LIMIT * 3] = { };
@@ -833,9 +834,9 @@ void RKSolver::p_update_Q(double* Q_ptr)
         double temp_double_3;
         double temp_double_4;
         double K_ni;
-        unsigned int stride_K;
+        size_t stride_K;
 
-        for (unsigned int y_i = 0; y_i < this->num_y; y_i++)
+        for (size_t y_i = 0; y_i < this->num_y; y_i++)
         {
             // Dot Product (K.T dot a) * h
             stride_K = this->n_stages_p1 * y_i;
@@ -843,7 +844,7 @@ void RKSolver::p_update_Q(double* Q_ptr)
             temp_double   = 0.0;
             temp_double_arr[y_i * 2]     = 0.0;
             temp_double_arr[y_i * 2 + 1] = 0.0;
-            for (unsigned int n_i = 0; n_i < this->n_stages_p1; n_i++)
+            for (size_t n_i = 0; n_i < this->n_stages_p1; n_i++)
             {
                 K_ni = K_ptr[stride_K + n_i];
                 temp_double                  += K_ni * DOP853_AEXTRA_ptr[3 * n_i];
@@ -852,17 +853,17 @@ void RKSolver::p_update_Q(double* Q_ptr)
             }
 
             // Update y for diffeq call using the temp_double dot product.
-            this->y_now_ptr[y_i] = this->y_old_ptr[y_i] + temp_double * this->step;
+            this->y_now[y_i] = this->y_old[y_i] + temp_double * this->step;
         }
         // Update time and call the diffeq.
-        this->t_now_ptr[0] = this->t_old + (this->step * DOP853_CEXTRA_ptr[0]);
+        this->t_now = this->t_old + (this->step * DOP853_CEXTRA_ptr[0]);
         this->diffeq(this);
 
         // S (row) == 14
-        for (unsigned int y_i = 0; y_i < this->num_y; y_i++)
+        for (size_t y_i = 0; y_i < this->num_y; y_i++)
         {
             // Store dy from the last call.
-            K_ni = this->dy_now_ptr[y_i];
+            K_ni = this->dy_now[y_i];
             K_extended_ptr[y_i * 3] = K_ni;
 
             // Dot Product (K.T dot a) * h
@@ -871,17 +872,17 @@ void RKSolver::p_update_Q(double* Q_ptr)
             temp_double_arr[y_i * 2 + 1] += K_ni * DOP853_AEXTRA_ptr[3 * 13 + 2];
 
             // Update y for diffeq call
-            this->y_now_ptr[y_i] = this->y_old_ptr[y_i] + temp_double_arr[y_i * 2] * this->step;
+            this->y_now[y_i] = this->y_old[y_i] + temp_double_arr[y_i * 2] * this->step;
         }
         // Update time and call the diffeq.
-        this->t_now_ptr[0] = this->t_old + (this->step * DOP853_CEXTRA_ptr[1]);
+        this->t_now = this->t_old + (this->step * DOP853_CEXTRA_ptr[1]);
         this->diffeq(this);
 
         // S (row) == 15
-        for (unsigned int y_i = 0; y_i < this->num_y; y_i++)
+        for (size_t y_i = 0; y_i < this->num_y; y_i++)
         {
             // Store dy from the last call.
-            K_ni = this->dy_now_ptr[y_i];
+            K_ni = this->dy_now[y_i];
             K_extended_ptr[y_i * 3 + 1] = K_ni;
 
             // Dot Product (K.T dot a) * h            
@@ -889,23 +890,23 @@ void RKSolver::p_update_Q(double* Q_ptr)
             temp_double_arr[y_i * 2 + 1] += K_ni * DOP853_AEXTRA_ptr[3 * 14 + 2];
 
             // Update y for diffeq call
-            this->y_now_ptr[y_i] = this->y_old_ptr[y_i] + temp_double_arr[y_i * 2 + 1] * this->step;
+            this->y_now[y_i] = this->y_old[y_i] + temp_double_arr[y_i * 2 + 1] * this->step;
         }
         // Update time and call the diffeq.
-        this->t_now_ptr[0] = this->t_old + (this->step * DOP853_CEXTRA_ptr[2]);
+        this->t_now = this->t_old + (this->step * DOP853_CEXTRA_ptr[2]);
         this->diffeq(this);
 
 
         // Done with diffeq calls. Now build up Q matrix.
-        for (unsigned int y_i = 0; y_i < this->num_y; y_i++)
+        for (size_t y_i = 0; y_i < this->num_y; y_i++)
         {
             // Store dy from the last call.
-            K_extended_ptr[y_i * 3 + 2] = this->dy_now_ptr[y_i];
+            K_extended_ptr[y_i * 3 + 2] = this->dy_now[y_i];
 
             // SciPy builds up a "F" matrix. Then in the dense interpolator this is reversed.
             // To keep consistency we will build F pre-reversed into Q. 
             // F (and Q) have the shape of (Interpolator Power, y_len); Interpolator power is 7
-            const unsigned int stride_Q = y_i * this->len_Pcols;
+            const size_t stride_Q = y_i * this->len_Pcols;
             // F in normal direction is:
             // F[0] = delta_y
             // F[1] = h * f_old - delta_y
@@ -926,7 +927,7 @@ void RKSolver::p_update_Q(double* Q_ptr)
             temp_double_4 = 0.0;
 
             // First add up normal K
-            for (unsigned int n_i = 0; n_i < this->n_stages_p1; n_i++)
+            for (size_t n_i = 0; n_i < this->n_stages_p1; n_i++)
             {
                 K_ni = this->K_ptr[stride_K + n_i];
                 // Row 1
@@ -967,8 +968,8 @@ void RKSolver::p_update_Q(double* Q_ptr)
             // f_old = K[0]
             // delta_y requires the current y and last y, but the current y was just overwritten to find
             // K_extended. So we need to pull from the values we saved in temporary variables. Same thing with dy
-            const double delta_y = y_now_storage_ptr[y_i] - this->y_old_ptr[y_i];
-            const double sum_dy  = dy_now_storage_ptr[y_i] + this->K_ptr[stride_K];
+            const double delta_y = this->y_tmp[y_i] - this->y_old[y_i];
+            const double sum_dy  = this->dy_tmp[y_i] + this->K_ptr[stride_K];
             Q_ptr[stride_Q + 4] = 2.0 * delta_y - this->step * sum_dy;
 
             // F[5] = h * f_old - delta_y
@@ -980,26 +981,24 @@ void RKSolver::p_update_Q(double* Q_ptr)
         }
 
         // Return values that were saved in temp variables back to state variables.
-        std::memcpy(this->dy_now_ptr, dy_now_storage_ptr, sizeof(double) * this->num_dy);
-        std::memcpy(this->y_now_ptr, y_now_storage_ptr, sizeof(double) * this->num_y);
-        this->t_now_ptr[0] = time_storage;
+        this->load_back_from_temp();
         }
         break;
 
     [[unlikely]] default:
-        for (unsigned int y_i = 0; y_i < this->num_y; y_i++)
+        for (size_t y_i = 0; y_i < this->num_y; y_i++)
         {
-            const unsigned int stride_K = this->n_stages_p1 * y_i;
-            const unsigned int stride_Q = y_i * this->len_Pcols;
+            const size_t stride_K = this->n_stages_p1 * y_i;
+            const size_t stride_Q = y_i * this->len_Pcols;
 
-            for (unsigned int P_i = 0; P_i < this->len_Pcols; P_i++)
+            for (size_t P_i = 0; P_i < this->len_Pcols; P_i++)
             {
-                const unsigned int stride_P = P_i * this->n_stages_p1;
+                const size_t stride_P = P_i * this->n_stages_p1;
                 // Initialize dot product
                 double temp_double = 0.0;
 
 
-                for (unsigned int n_i = 0; n_i < this->n_stages_p1; n_i++)
+                for (size_t n_i = 0; n_i < this->n_stages_p1; n_i++)
                 {
                     temp_double += this->K_ptr[stride_K + n_i] * this->P_ptr[stride_P + n_i];
                 }
@@ -1012,40 +1011,6 @@ void RKSolver::p_update_Q(double* Q_ptr)
     }
 }
 
-CySolverDense* RKSolver::p_dense_output_heap()
-{
-    // Build dense output object instance
-    CySolverDense* dense_output = new CySolverDense(
-        this->integration_method,
-        this->t_old,
-        this->t_now_ptr[0],
-        this->y_old_ptr,
-        this->num_y,
-        this->num_extra,
-        this->len_Pcols,
-        this,
-        this->diffeq,
-        this->cython_extension_class_instance,
-        this->t_now_ptr,
-        this->y_now_ptr,
-        this->dy_now_ptr);
-
-    // Update Q
-    this->p_update_Q(dense_output->Q_ptr);
-
-    return dense_output;
-}
-
-void RKSolver::p_dense_output_stack(CySolverDense& dense_output_ptr)
-{
-    // Update integration method specific items
-    dense_output_ptr.Q_order = this->len_Pcols;
-    
-    // Update Q
-    this->p_update_Q(dense_output_ptr.Q_ptr);
-}
-
-
 // ########################################################################################################################
 // Explicit Runge - Kutta 2(3)
 // ########################################################################################################################
@@ -1139,7 +1104,7 @@ void DOP853::p_estimate_error()
     double rtol = this->rtols_ptr[0];
     double atol = this->atols_ptr[0];
 
-    for (unsigned int y_i = 0; y_i < this->num_y; y_i++)
+    for (size_t y_i = 0; y_i < this->num_y; y_i++)
     {
         if (this->use_array_rtols)
         {
@@ -1151,7 +1116,7 @@ void DOP853::p_estimate_error()
             atol = this->atols_ptr[y_i];
         }
 
-        const unsigned int stride_K = y_i * this->n_stages_p1;
+        const size_t stride_K = y_i * this->n_stages_p1;
 
         // Dot product between K and E3 & E5 (sum over n_stages + 1; for DOP853 n_stages = 12
         // n = 0
@@ -1220,7 +1185,7 @@ void DOP853::p_estimate_error()
         error_dot5 += this->E5_ptr[12] * temp_double;
 
         // Find scale of y for error calculations
-        const double scale_inv = 1.0 / (atol + std::fmax(std::fabs(this->y_old_ptr[y_i]), std::fabs(this->y_now_ptr[y_i])) * rtol);
+        const double scale_inv = 1.0 / (atol + std::fmax(std::fabs(this->y_old[y_i]), std::fabs(this->y_now[y_i])) * rtol);
 
         // We need the absolute value but since we are taking the square, it is guaranteed to be positive.
         // TODO: This will need to change if CySolver ever accepts complex numbers
@@ -1243,8 +1208,3 @@ void DOP853::p_estimate_error()
         this->error_norm = this->step_size * error_norm5 / std::sqrt(error_denom * this->num_y_dbl);
     }
 }
-
-
-// ########################################################################################################################
-// Dense Output Implementations
-// ########################################################################################################################
diff --git a/CyRK/cy/rk.hpp b/CyRK/cy/rk.hpp
index d42c957..6ad5390 100644
--- a/CyRK/cy/rk.hpp
+++ b/CyRK/cy/rk.hpp
@@ -11,14 +11,14 @@
 // #####################################################################################################################
 // Runge - Kutta 2(3)
 // #####################################################################################################################
-const unsigned int RK23_METHOD_INT            = 0;
-const unsigned int RK23_order                 = 3;
-const unsigned int RK23_n_stages              = 3;
-const unsigned int RK23_len_Arows             = 3;
-const unsigned int RK23_len_Acols             = 3;
-const unsigned int RK23_len_C                 = 3;
-const unsigned int RK23_len_Pcols             = 3;
-const unsigned int RK23_error_estimator_order = 2;
+const int RK23_METHOD_INT               = 0;
+const size_t RK23_order                 = 3;
+const size_t RK23_n_stages              = 3;
+const size_t RK23_len_Arows             = 3;
+const size_t RK23_len_Acols             = 3;
+const size_t RK23_len_C                 = 3;
+const size_t RK23_len_Pcols             = 3;
+const size_t RK23_error_estimator_order = 2;
 const double RK23_error_exponent = 1.0 / (2.0 + 1.0);  // Defined as 1 / (error_order + 1)
 
 const double RK23_A[9] = {
@@ -84,14 +84,14 @@ const double* const RK23_P_ptr = &RK23_P[0];
 // #####################################################################################################################
 // Runge - Kutta 4(5)
 // #####################################################################################################################
-const unsigned int RK45_METHOD_INT            = 1;
-const unsigned int RK45_order                 = 5;
-const unsigned int RK45_n_stages              = 6;
-const unsigned int RK45_len_Arows             = 6;
-const unsigned int RK45_len_Acols             = 5;
-const unsigned int RK45_len_C                 = 6;
-const unsigned int RK45_len_Pcols             = 4;
-const unsigned int RK45_error_estimator_order = 4;
+const int RK45_METHOD_INT               = 1;
+const size_t RK45_order                 = 5;
+const size_t RK45_n_stages              = 6;
+const size_t RK45_len_Arows             = 6;
+const size_t RK45_len_Acols             = 5;
+const size_t RK45_len_C                 = 6;
+const size_t RK45_len_Pcols             = 4;
+const size_t RK45_error_estimator_order = 4;
 const double RK45_error_exponent = 1.0 / (4.0 + 1.0);  // Defined as 1 / (error_order + 1)
 
 const double RK45_A[30] = {
@@ -210,18 +210,18 @@ const double* const RK45_P_ptr = &RK45_P[0];
 // #####################################################################################################################
 // Runge - Kutta DOP 8(5; 3)
 // #####################################################################################################################
-const unsigned int DOP853_METHOD_INT            = 2;
-const unsigned int DOP853_order                 = 8;
-const unsigned int DOP853_n_stages              = 12;
-const unsigned int DOP853_nEXTRA_stages         = 16;
-const unsigned int DOP853_A_rows                = 12;
-const unsigned int DOP853_A_cols                = 12;
-const unsigned int DOP853_AEXTRA_rows           = 3;
-const unsigned int DOP853_AEXTRA_cols           = 16;
-const unsigned int DOP853_len_C                 = 12;
-const unsigned int DOP853_len_CEXTRA            = 3;
-const unsigned int DOP853_INTERPOLATOR_POWER    = 7;
-const unsigned int DOP853_error_estimator_order = 7;
+const int DOP853_METHOD_INT               = 2;
+const size_t DOP853_order                 = 8;
+const size_t DOP853_n_stages              = 12;
+const size_t DOP853_nEXTRA_stages         = 16;
+const size_t DOP853_A_rows                = 12;
+const size_t DOP853_A_cols                = 12;
+const size_t DOP853_AEXTRA_rows           = 3;
+const size_t DOP853_AEXTRA_cols           = 16;
+const size_t DOP853_len_C                 = 12;
+const size_t DOP853_len_CEXTRA            = 3;
+const size_t DOP853_INTERPOLATOR_POWER    = 7;
+const size_t DOP853_error_estimator_order = 7;
 const double DOP853_error_exponent              = 1.0 / (7.0 + 1.0);  // Defined as 1 / (error_order + 1)
 
 // Note both A and C are the _reduced_ versions.The full A and C are not shown.
@@ -656,14 +656,14 @@ class RKSolver : public CySolverBase {
     const double max_step_factor = MAX_FACTOR;
 
     // RK constants
-    unsigned int order = 0;
-    unsigned int error_estimator_order = 0;
-    unsigned int n_stages     = 0;
-    unsigned int n_stages_p1  = 0;
-    unsigned int len_Acols    = 0;
-    unsigned int len_C        = 0;
-    unsigned int len_Pcols    = 0;
-    unsigned int nstages_numy = 0;
+    size_t order = 0;
+    size_t error_estimator_order = 0;
+    size_t n_stages     = 0;
+    size_t n_stages_p1  = 0;
+    size_t len_Acols    = 0;
+    size_t len_C        = 0;
+    size_t len_Pcols    = 0;
+    size_t nstages_numy = 0;
     double error_exponent     = 0.0;
 
     // Pointers to RK constant arrays
@@ -704,9 +704,6 @@ class RKSolver : public CySolverBase {
 protected:
     virtual void p_estimate_error() override;
     virtual void p_step_implementation() override;
-    virtual CySolverDense* p_dense_output_heap() override;
-    virtual void p_dense_output_stack(CySolverDense& dense_output_ptr) override;
-    virtual void p_update_Q(double* Q_ptr);
 
 public:
     RKSolver();
@@ -714,12 +711,12 @@ class RKSolver : public CySolverBase {
     RKSolver(
         // Base Class input arguments
         DiffeqFuncType diffeq_ptr,
-        std::shared_ptr<CySolverResult> const storage_ptr,
+        std::shared_ptr<CySolverResult> const storage_sptr,
         const double t_start,
         const double t_end,
         const double* y0_ptr,
-        const unsigned int num_y,
-        const unsigned int num_extra = 0,
+        const size_t num_y,
+        const size_t num_extra = 0,
         const void* args_ptr = nullptr,
         const size_t max_num_steps = 0,
         const size_t max_ram_MB = 2000,
@@ -737,6 +734,8 @@ class RKSolver : public CySolverBase {
     );
     virtual void reset() override;
     virtual void calc_first_step_size() override;
+    virtual void set_Q_order(size_t* Q_order_ptr) override;
+    virtual void set_Q_array(double* Q_ptr) override;
 };
 
 
diff --git a/Documentation/C++ API.md b/Documentation/C++ API.md
index dc49e2c..f5c4066 100644
--- a/Documentation/C++ API.md
+++ b/Documentation/C++ API.md
@@ -30,11 +30,11 @@ baseline_cysolve_ivp(
     DiffeqFuncType diffeq_ptr,
     const double* t_span_ptr,
     const double* y0_ptr,
-    const unsigned int num_y,
-    const unsigned int method,
+    const size_t num_y,
+    const int method,
     // General optional arguments
     const size_t expected_size = 0,
-    const unsigned int num_extra = 0,
+    const size_t num_extra = 0,
     const double* args_ptr = nullptr,
     // rk optional arguments
     const size_t max_num_steps = 0,
@@ -52,7 +52,7 @@ baseline_cysolve_ivp(
 class PySolver
 {
     PySolver(
-        unsigned int integration_method,
+        int integration_method,
         // Cython class instance used for pyhook
         PyObject* cython_extension_class_instance,
         DiffeqMethod cython_extension_class_diffeq_method,
@@ -61,9 +61,9 @@ class PySolver
         const double t_start,
         const double t_end,
         const double* y0_ptr,
-        const unsigned int num_y,
+        const size_t num_y,
         // General optional arguments
-        const unsigned int num_extra,
+        const size_t num_extra,
         const double* args_ptr,
         // rk optional arguments
         const size_t max_num_steps,
diff --git a/Performance/cyrk_performance-DOP853.csv b/Performance/cyrk_performance-DOP853.csv
index cc9ae29..7afd8a0 100644
--- a/Performance/cyrk_performance-DOP853.csv
+++ b/Performance/cyrk_performance-DOP853.csv
@@ -24,3 +24,4 @@ CyRK Version, Run-on Date, cython (avg), cython (std),CySolver (avg),CySolver (s
 "After 0.11.0 Changes were made to functions: ""cython"" was `cyrk_ode` now is `pysolve_ivp`. ""CySolver"" was `CySolver` class method now is `cysolve_ivp`. Numba did not change.",,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
 0.11.0, 08/11/2024 13:34:31, 1.0405, 0.0220, 0.0440, 0.0004, 0.1653, 0.0037, 10.6848, 0.0518, 0.4168, 0.0055, 1.5772, 0.0952, 0.4697, 0.0056, 0.0350, 0.0010, 0.1027, 0.0017, 4.5382, 0.0695, 0.2962, 0.0080, 0.8286, 0.0180, 1.5190, 0.0184, 0.0886, 0.0108, 0.3325, 0.1084, 21.0697, 0.8173, 1.0653, 0.0440, 3.3296, 0.0833, 1.7694, 0.0377, 0.0796, 0.0011, 0.5066, 0.0051, 24.3005, 0.1841, 1.0867, 0.0503, 6.9565, 0.2617
 0.11.2, 13/11/2024 09:47:14, 1.0383, 0.0482, 0.0459, 0.0011, 0.1791, 0.0065, 10.4672, 0.3348, 0.4292, 0.0054, 1.5538, 0.0164, 0.4595, 0.0036, 0.0361, 0.0011, 0.1058, 0.0015, 4.6616, 0.1080, 0.3028, 0.0064, 0.8637, 0.0168, 1.4801, 0.0422, 0.0815, 0.0003, 0.2740, 0.0060, 20.1617, 0.3500, 1.0886, 0.0310, 3.4030, 0.0480, 1.7564, 0.0416, 0.0840, 0.0008, 0.5297, 0.0179, 23.9814, 0.4823, 1.1206, 0.0153, 6.7479, 0.0770
+0.11.3, 18/11/2024 22:01:05, 1.0395, 0.0643, 0.0446, 0.0007, 0.1775, 0.0072, 10.4019, 0.4997, 0.4034, 0.0051, 1.5558, 0.0211, 0.4460, 0.0060, 0.0335, 0.0003, 0.1022, 0.0008, 4.4008, 0.0505, 0.2929, 0.0032, 0.8257, 0.0232, 1.4250, 0.0155, 0.0852, 0.0005, 0.2547, 0.0017, 20.6687, 0.6711, 1.1036, 0.0036, 3.4398, 0.3229, 1.6677, 0.0198, 0.0893, 0.0052, 0.5148, 0.0099, 25.7176, 2.5321, 1.1436, 0.0118, 6.8288, 0.1691
diff --git a/Performance/cyrk_performance-RK23.csv b/Performance/cyrk_performance-RK23.csv
index 4702a9f..04759c6 100644
--- a/Performance/cyrk_performance-RK23.csv
+++ b/Performance/cyrk_performance-RK23.csv
@@ -24,3 +24,4 @@ CyRK Version, Run-on Date, cython (avg), cython (std),CySolver (avg),CySolver (s
 "After 0.11.0 Changes were made to functions: ""cython"" was `cyrk_ode` now is `pysolve_ivp`. ""CySolver"" was `CySolver` class method now is `cysolve_ivp`. Numba did not change.",,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
 0.11.0, 08/11/2024 13:32:05, 5.2024, 0.4024, 0.2878, 0.0104, 0.8329, 0.0146, 48.9279, 1.0915, 2.8651, 0.0911, 9.6346, 0.4435, 3.0034, 0.0548, 0.2512, 0.0073, 0.6391, 0.0091, 30.1886, 1.3712, 2.5126, 0.0594, 6.1286, 0.1974, 5.0243, 0.0111, 0.3568, 0.0029, 0.9418, 0.0134, 81.3716, 0.9542, 6.0864, 0.2366, 21.4152, 0.6340, 5.8757, 0.0795, 0.3821, 0.0257, 1511.3296, 2614.5716, 103.0198, 4.8289, 6.7153, 0.1536, 40.7782, 2.6646
 0.11.2, 13/11/2024 09:44:47, 58.5798, 92.5131, 0.3027, 0.0073, 0.9652, 0.0611, 50.2554, 3.1065, 3.0509, 0.1734, 11.0730, 0.5532, 3.0001, 0.0297, 0.2962, 0.0300, 0.6303, 0.0107, 29.3821, 0.6157, 2.4788, 0.0442, 8.6115, 2.1469, 54.1616, 85.1339, 0.3808, 0.0043, 1.1505, 0.0435, 83.2819, 0.6580, 6.1863, 0.0625, 22.4879, 0.1939, 59.9757, 93.5368, 0.3924, 0.0084, 1633.8436, 2826.6269, 105.4013, 5.7465, 7.0494, 0.0526, 41.1053, 0.3990
+0.11.3, 18/11/2024 21:58:42, 53.8381, 85.1332, 0.2844, 0.0053, 0.8357, 0.0040, 44.6139, 0.5691, 2.7175, 0.0170, 9.6441, 0.2775, 2.8966, 0.0745, 0.2544, 0.0105, 0.6118, 0.0154, 27.6303, 0.0867, 2.4112, 0.0748, 6.5003, 0.2024, 4.8056, 0.0730, 0.3556, 0.0063, 0.9397, 0.0079, 78.8993, 0.7616, 5.7215, 0.0496, 20.2977, 0.1102, 5.7503, 0.0931, 0.3808, 0.0202, 1430.3917, 2474.4326, 96.3635, 0.9127, 6.3773, 0.0910, 39.3835, 1.9905
diff --git a/Performance/cyrk_performance-RK45.csv b/Performance/cyrk_performance-RK45.csv
index 58ca5b3..344b4f2 100644
--- a/Performance/cyrk_performance-RK45.csv
+++ b/Performance/cyrk_performance-RK45.csv
@@ -24,3 +24,4 @@ CyRK Version, Run-on Date, cython (avg), cython (std),CySolver (avg),CySolver (s
 "After 0.11.0 Changes were made to functions: ""cython"" was `cyrk_ode` now is `pysolve_ivp`. ""CySolver"" was `CySolver` class method now is `cysolve_ivp`. Numba did not change.",,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
 0.11.0, 08/11/2024 13:33:35, 1.4157, 0.1032, 0.0647, 0.0010, 0.2163, 0.0069, 13.2409, 0.2058, 0.5789, 0.0121, 1.9120, 0.1314, 0.8558, 0.0112, 0.0684, 0.0049, 0.1836, 0.0083, 8.6953, 0.4141, 0.5989, 0.0051, 1.5423, 0.0157, 1.6548, 0.0253, 0.0998, 0.0011, 0.3134, 0.0323, 24.1535, 0.2564, 1.4176, 0.0167, 4.1044, 0.1653, 2.0023, 0.0453, 0.1063, 0.0046, 0.5995, 0.0094, 29.3136, 0.4531, 1.4513, 0.0394, 8.1298, 0.0426
 0.11.2, 13/11/2024 09:46:20, 1.2497, 0.0190, 0.0645, 0.0006, 0.2333, 0.0074, 12.5791, 0.2532, 0.6023, 0.0184, 2.0329, 0.0377, 0.8824, 0.0160, 0.0676, 0.0001, 0.1932, 0.0074, 8.4859, 0.0106, 0.6328, 0.0072, 1.5491, 0.0287, 1.7246, 0.0188, 0.1056, 0.0016, 0.3201, 0.0090, 25.1528, 0.5846, 1.4855, 0.0071, 4.6009, 0.1266, 2.0235, 0.0174, 0.1135, 0.0025, 0.6057, 0.0057, 29.2690, 0.5148, 1.5547, 0.0225, 8.8452, 0.2573
+0.11.3, 18/11/2024 22:00:10, 1.1977, 0.0041, 0.0614, 0.0006, 0.2097, 0.0059, 11.8970, 0.1254, 0.5723, 0.0119, 1.9069, 0.0544, 0.8432, 0.0066, 0.0659, 0.0009, 0.1745, 0.0030, 8.4187, 0.3196, 0.6140, 0.0064, 1.7302, 0.1918, 1.7725, 0.0502, 0.1088, 0.0022, 0.3057, 0.0097, 24.8389, 1.0028, 1.6105, 0.0791, 4.4626, 0.1301, 2.0433, 0.0796, 0.1261, 0.0023, 0.6580, 0.0422, 29.5806, 1.1944, 1.6120, 0.0302, 9.2682, 0.4399
diff --git a/README.md b/README.md
index 96fa20d..d45fdd0 100644
--- a/README.md
+++ b/README.md
@@ -11,7 +11,7 @@
 
 ---
 
-<a href="https://github.com/jrenaud90/CyRK/releases"><img src="https://img.shields.io/badge/CyRK-0.11.2 Alpha-orange" alt="CyRK Version 0.11.2 Alpha" /></a>
+<a href="https://github.com/jrenaud90/CyRK/releases"><img src="https://img.shields.io/badge/CyRK-0.11.3 Alpha-orange" alt="CyRK Version 0.11.3 Alpha" /></a>
 
 
 **Runge-Kutta ODE Integrator Implemented in Cython and Numba**
@@ -28,7 +28,7 @@ The [cython-based](https://cython.org/) `cysolver_ivp` function that works with
 An additional benefit of the two cython implementations is that they are pre-compiled. This avoids most of the start-up performance hit experienced by just-in-time compilers like numba.
 
 
-<img style="text-align: center" src="https://github.com/jrenaud90/CyRK/blob/main/Benchmarks/CyRK_SciPy_Compare_predprey_v0-11-2.png" alt="CyRK Performance Graphic" />
+<img style="text-align: center" src="https://github.com/jrenaud90/CyRK/blob/main/Benchmarks/CyRK_SciPy_Compare_predprey_v0-11-3.png" alt="CyRK Performance Graphic" />
 
 ## Installation
 
@@ -192,7 +192,7 @@ def pysolve_ivp(
         bint dense_output = False,   # If True, then dense interpolators will be saved to the solution. This allows a user to call solution as if a function (in time).
         tuple args = None,           # Python Tuple of additional args passed to the differential equation. These can be any python object.
         size_t expected_size = 0,    # Expected size of the solution. There is a slight performance improvement if selecting the the exact or slightly more time steps than the adaptive stepper will require (if you happen to know this ahead of time).
-        unsigned int num_extra = 0,  # Number of extra outputs you want to capture during integration. There is a performance hit if this is used in conjunction with t_eval or dense_output.
+        size_t num_extra = 0,  # Number of extra outputs you want to capture during integration. There is a performance hit if this is used in conjunction with t_eval or dense_output.
         double first_step = 0.0,     # Initial step size. If set to 0.0 then CyRK will guess a good step size.
         double max_step = INF,       # Maximum allowed step size.
         rtol = 1.0e-3,               # Relative tolerance used to control integration error. This can be provided as a numpy array if you'd like a different rtol for each y.
@@ -266,7 +266,7 @@ def run_cysolver(tuple t_span, double[::1] y0):
     
     # Convert the python user input to pure C types
     cdef double* y0_ptr       = &y0[0]
-    cdef unsigned int num_y   = len(y0)
+    cdef size_t num_y   = len(y0)
     cdef double[2] t_span_arr = [t_span[0], t_span[1]]
     cdef double* t_span_ptr   = &t_span_arr[0]
 
@@ -323,6 +323,30 @@ ax.plot(result.t, 100*result.y[3], c='purple', ls=':')
 
 There is a lot more you can do to interface with CyRK's C++ backend and fully optimize the integrators to your needs. These details will be documented in "Documentation/Advanced CySolver.md".
 
+#### No Return `cysolve_ivp_noreturn`
+The example above shows using `cysolve_ivp` functions that return an output (which is a c++ shared pointer): `cdef CySolveOutput result = cysolve_ivp(...)`. CyRK also provides a function that takes the output as an input if you prefer to manage your own memory:
+```cython
+
+from libcpp.memory cimport make_shared, shared_ptr
+
+from CyRK cimport CySolverResult, cysolve_ivp_noreturn
+
+# Make our own stroage
+cdef shared_ptr[CySolverResult] solution_sptr =
+    make_shared[CySolverResult](
+        num_y,
+        num_extra,
+        expected_size,
+        t_end,
+        direction_flag,
+        dense_output,
+        t_eval_provided);
+
+# Pass it to the noreturn version of the solver for it to update.
+cysolve_ivp_noreturn(solution_sptr, <other inputs>)
+
+```
+
 #### `cysolve_ivp` and `cysolve_ivp_gil` Arguments
 
 ```cython
@@ -330,12 +354,12 @@ cdef shared_ptr[CySolverResult] cysolve_ivp(
     DiffeqFuncType diffeq_ptr,        # Differential equation defined as a cython function
     double* t_span_ptr,               # Pointer to array (size 2) of floats defining the start and stop points for integration
     double* y0_ptr,                   # Pointer to array defining initial y0 conditions.
-    unsigned int num_y,               # Size of y0_ptr array.
-    unsigned int method = 1,          # Integration method. Current options: 0 == RK23, 1 == RK45, 2 == DOP853
+    size_t num_y,                     # Size of y0_ptr array.
+    int method = 1,                   # Integration method. Current options: 0 == RK23, 1 == RK45, 2 == DOP853
     double rtol = 1.0e-3,             # Relative tolerance used to control integration error.
     double atol = 1.0e-6,             # Absolute tolerance (near 0) used to control integration error.
     void* args_ptr = NULL,            # Pointer to array of additional arguments passed to the diffeq. See "Advanced CySolver.md" for more details.
-    unsigned int num_extra = 0,       # Number of extra outputs you want to capture during integration. There is a performance hit if this is used in conjunction with t_eval or dense_output.
+    size_t num_extra = 0,             # Number of extra outputs you want to capture during integration. There is a performance hit if this is used in conjunction with t_eval or dense_output.
     size_t max_num_steps = 0,         # Maximum number of steps allowed. If exceeded then integration will fail. 0 (the default) turns this off.
     size_t max_ram_MB = 2000,         # Maximum amount of system memory the integrator is allowed to use. If this is exceeded then integration will fail.
     bint dense_output = False,        # If True, then dense interpolators will be saved to the solution. This allows a user to call solution as if a function (in time).
diff --git a/_build_cyrk.py b/_build_cyrk.py
index 70771f6..5bbcce9 100644
--- a/_build_cyrk.py
+++ b/_build_cyrk.py
@@ -40,7 +40,7 @@
         if install_platform.lower() == 'windows':
             specific_compile_args = extra_compile_args + ext_data['compile_args'] + ["/std:c++20"]
         else:
-            specific_compile_args = extra_compile_args + ext_data['compile_args'] + ["-std=c++14"]
+            specific_compile_args = extra_compile_args + ext_data['compile_args'] + ["-std=c++20"]
     else:
         specific_compile_args = extra_compile_args + ext_data['compile_args']
 
diff --git a/pyproject.toml b/pyproject.toml
index 0cf44a1..8fd0758 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -1,6 +1,6 @@
 [project]
 name='CyRK'
-version = '0.11.2'
+version = '0.11.3'
 description='Runge-Kutta ODE Integrator Implemented in Cython and Numba.'
 authors= [
     {name = 'Joe P. Renaud', email = 'joe.p.renaud@gmail.com'}
diff --git a/setup.py b/setup.py
index 3bbbd6a..2504a09 100644
--- a/setup.py
+++ b/setup.py
@@ -33,7 +33,7 @@
         if install_platform.lower() == 'windows':
             specific_compile_args = extra_compile_args + ext_data['compile_args'] + ["/std:c++20"]
         else:
-            specific_compile_args = extra_compile_args + ext_data['compile_args'] + ["-std=c++14"]
+            specific_compile_args = extra_compile_args + ext_data['compile_args'] + ["-std=c++20"]
     else:
         specific_compile_args = extra_compile_args + ext_data['compile_args']
 


Test patch:
diff --git a/CyRK/cy/cysolver_test.pyx b/CyRK/cy/cysolver_test.pyx
index 6bee85a..9669d13 100644
--- a/CyRK/cy/cysolver_test.pyx
+++ b/CyRK/cy/cysolver_test.pyx
@@ -229,7 +229,7 @@ def cytester(
         len_t_eval = len(t_eval)
         t_eval_ptr = &t_eval[0]
 
-    cdef unsigned int num_y
+    cdef size_t num_y
     cdef double[10] y0_arr
     cdef double* y0_ptr = &y0_arr[0]