diff --git a/docs/cli/basic-usage/.gitignore b/docs/cli/basic-usage/.gitignore
new file mode 100644
index 00000000..13974321
--- /dev/null
+++ b/docs/cli/basic-usage/.gitignore
@@ -0,0 +1 @@
+*.pkl
diff --git a/docs/cli/basic-usage/README.md b/docs/cli/basic-usage/README.md
new file mode 100644
index 00000000..0470d14b
--- /dev/null
+++ b/docs/cli/basic-usage/README.md
@@ -0,0 +1,145 @@
+# Basic usage
+
+The command line interface allows us to load and save `States` and run arbitrary functions on them.
+
+## Setup
+
+To use the command line, we first define a package `example` containing the functions we want to run on the State:
+
+```python title="example/__init__.py"
+--8<-- "https://raw.githubusercontent.com/AutoResearch/autora-core/main/docs/cli/basic-usage/example/__init__.py"
+```
+
+
+```python title="example/lib.py"
+--8<-- "https://raw.githubusercontent.com/AutoResearch/autora-core/main/docs/cli/basic-usage/example/lib.py"
+```
+
+We can run the pipeline of initialization, condition generation, experiment and theory building as follows.
+
+First we create an initial state file:
+
+```shell
+python -m autora.workflow example.lib.initial_state --out-path initial.pkl
+```
+
+Next we run the condition generation:
+
+
+```shell
+python -m autora.workflow example.lib.experimentalist --in-path initial.pkl --out-path conditions.pkl
+```
+
+We run the experiment:
+
+
+```shell
+python -m autora.workflow example.lib.experiment_runner --in-path conditions.pkl --out-path experiment_data.pkl
+```
+
+And then the theorist:
+
+
+```shell
+python -m autora.workflow example.lib.theorist --in-path experiment_data.pkl --out-path model.pkl
+```
+
+We can interrogate the results by loading them into the current session.
+
+
+```python
+#!/usr/bin/env python
+from autora.workflow.__main__ import load_state
+state = load_state("model.pkl")
+print(state)
+# state = 
+# StandardState(
+#     variables=VariableCollection(
+#         independent_variables=[
+#             Variable(name='x',
+#                      value_range=None, 
+#                      allowed_values=array([-10.  ,  -9.98,  -9.96, ...,   9.96,   9.98,  10.  ]), 
+#                      units='', 
+#                      type=<ValueType.REAL: 'real'>, 
+#                      variable_label='', 
+#                      rescale=1, 
+#                      is_covariate=False)
+#             ], 
+#         dependent_variables=[
+#             Variable(name='y', 
+#                      value_range=None, 
+#                      allowed_values=None, 
+#                      units='', 
+#                      type=<ValueType.REAL: 'real'>, 
+#                      variable_label='', 
+#                      rescale=1, 
+#                      is_covariate=False)
+#         ], 
+#         covariates=[]
+#     ), 
+#     conditions=        x
+#                342 -3.16
+#                869  7.38
+#                732  4.64
+#                387 -2.26
+#                919  8.38
+#                949  8.98
+#                539  0.78
+#                563  1.26
+#                855  7.10
+#                772  5.44, 
+#     experiment_data=      x           y
+#                     0 -3.16    1.257587
+#                     1  7.38  153.259915
+#                     2  4.64   54.291348
+#                     3 -2.26   10.374509
+#                     4  8.38  155.483778
+#                     5  8.98  183.774472
+#                     6  0.78    3.154024
+#                     7  1.26   14.033608
+#                     8  7.10  103.032008
+#                     9  5.44   94.629911, 
+#     models=[
+#         GridSearchCV(
+#             estimator=Pipeline(steps=[
+#                 ('polynomialfeatures', PolynomialFeatures()),
+#                 ('linearregression', LinearRegression())]),
+#             param_grid={'polynomialfeatures__degree': [0, 1, 2, 3, 4]}, 
+#             scoring='r2'
+#         )
+#     ]
+# )
+```
+
+`state` is the following object which, once loaded, can be treated like any other `State` object.
+For instance, we can plot the results:
+
+```python title="example/plot.py"
+--8<-- "https://raw.githubusercontent.com/AutoResearch/autora-core/main/docs/cli/basic-usage/example/plot.py"
+```
+    
+```shell
+python -m example.plot model.pkl
+```
+
+
+![png](img/after-one-cycle.png)
+
+If we instead run the experiment for 4 cycles, we can get results closer to the ground truth.
+
+```shell
+set -x  # echo each command 
+
+python -m autora.workflow example.lib.initial_state --out-path "result.pkl"
+
+for i in {1..4}
+do
+    python -m autora.workflow example.lib.experimentalist --in-path "result.pkl" --out-path "result.pkl"
+    python -m autora.workflow example.lib.experiment_runner --in-path "result.pkl" --out-path "result.pkl"
+    python -m autora.workflow example.lib.theorist --in-path "result.pkl" --out-path "result.pkl"
+done
+
+python example.plot result.pkl
+```
+
+![png](img/after-four-cycles.png)
diff --git a/docs/cli/basic-usage/Readme.ipynb b/docs/cli/basic-usage/Readme.ipynb
deleted file mode 100644
index de71cfe0..00000000
--- a/docs/cli/basic-usage/Readme.ipynb
+++ /dev/null
@@ -1,643 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Basic usage\n",
-    "\n",
-    "The command line interface `python -m autora.workflow` allows us to load and save `States` and run arbitrary \n",
-    "functions on them."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "import numpy as np\r\n",
-      "import pandas as pd\r\n",
-      "from sklearn.linear_model import LinearRegression\r\n",
-      "\r\n",
-      "from autora.experimentalist.grid import grid_pool\r\n",
-      "from autora.state import StandardState, estimator_on_state, on_state\r\n",
-      "from autora.variable import Variable, VariableCollection\r\n",
-      "from sklearn.model_selection import GridSearchCV\r\n",
-      "from sklearn.pipeline import make_pipeline\r\n",
-      "from sklearn.preprocessing import PolynomialFeatures\r\n",
-      "\r\n",
-      "rng = np.random.default_rng()\r\n",
-      "\r\n",
-      "\r\n",
-      "def initial_state(_):\r\n",
-      "    state = StandardState(\r\n",
-      "        variables=VariableCollection(\r\n",
-      "            independent_variables=[\r\n",
-      "                Variable(name=\"x\", allowed_values=np.linspace(-10, +10, 1001))\r\n",
-      "            ],\r\n",
-      "            dependent_variables=[Variable(name=\"y\")],\r\n",
-      "            covariates=[],\r\n",
-      "        ),\r\n",
-      "        conditions=None,\r\n",
-      "        experiment_data=pd.DataFrame({\"x\": [], \"y\": []}),\r\n",
-      "        models=[],\r\n",
-      "    )\r\n",
-      "    return state\r\n",
-      "\r\n",
-      "\r\n",
-      "@on_state(output=[\"conditions\"])\r\n",
-      "def experimentalist(variables):\r\n",
-      "    conditions: pd.DataFrame = grid_pool(variables)\r\n",
-      "    selected_conditions = conditions.sample(10, random_state=rng)\r\n",
-      "    return selected_conditions\r\n",
-      "\r\n",
-      "\r\n",
-      "coefs = [2.0, 3.0, 1.0]\r\n",
-      "noise_std = 10.0\r\n",
-      "\r\n",
-      "\r\n",
-      "def ground_truth(x, coefs_=coefs):\r\n",
-      "    return coefs_[0] * x**2.0 + coefs_[1] * x + coefs_[2]\r\n",
-      "\r\n",
-      "\r\n",
-      "@on_state(output=[\"experiment_data\"])\r\n",
-      "def experiment_runner(conditions, coefs_=coefs, noise_std_=noise_std, rng=rng):\r\n",
-      "    experiment_data = conditions.assign(\r\n",
-      "        y=(\r\n",
-      "            ground_truth(conditions[\"x\"], coefs_=coefs_)\r\n",
-      "            + rng.normal(0.0, noise_std_, size=conditions[\"x\"].shape)\r\n",
-      "        )\r\n",
-      "    )\r\n",
-      "    return experiment_data\r\n",
-      "\r\n",
-      "\r\n",
-      "theorist = estimator_on_state(\r\n",
-      "    GridSearchCV(\r\n",
-      "        make_pipeline(PolynomialFeatures(), LinearRegression()),\r\n",
-      "        param_grid={\"polynomialfeatures__degree\": [0, 1, 2, 3, 4]},\r\n",
-      "        scoring=\"r2\",\r\n",
-      "    )\r\n",
-      ")\r\n"
-     ]
-    }
-   ],
-   "source": [
-    "%cat lib.py"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "We can run the pipeline of initialization, condition generation, experiment and theory building as follows.\n",
-    "\n",
-    "First we create an initial state file:  "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "!python -m autora.workflow lib.initial_state --out-path initial.pkl"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Next we run the condition generation:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "!python -m autora.workflow lib.experimentalist --in-path initial.pkl --out-path conditions.pkl"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "We run the experiment:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "!python -m autora.workflow lib.experiment_runner --in-path conditions.pkl --out-path experiment_data.pkl"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "And then the theorist:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "!python -m autora.workflow lib.theorist --in-path experiment_data.pkl --out-path model.pkl"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "We can interrogate the results by loading them into the current session."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "StandardState(variables=VariableCollection(independent_variables=[Variable(name='x', value_range=None, allowed_values=array([-10.  ,  -9.98,  -9.96, ...,   9.96,   9.98,  10.  ]), units='', type=<ValueType.REAL: 'real'>, variable_label='', rescale=1, is_covariate=False)], dependent_variables=[Variable(name='y', value_range=None, allowed_values=None, units='', type=<ValueType.REAL: 'real'>, variable_label='', rescale=1, is_covariate=False)], covariates=[]), conditions=        x\n",
-       "342 -3.16\n",
-       "869  7.38\n",
-       "732  4.64\n",
-       "387 -2.26\n",
-       "919  8.38\n",
-       "949  8.98\n",
-       "539  0.78\n",
-       "563  1.26\n",
-       "855  7.10\n",
-       "772  5.44, experiment_data=      x           y\n",
-       "0 -3.16    1.257587\n",
-       "1  7.38  153.259915\n",
-       "2  4.64   54.291348\n",
-       "3 -2.26   10.374509\n",
-       "4  8.38  155.483778\n",
-       "5  8.98  183.774472\n",
-       "6  0.78    3.154024\n",
-       "7  1.26   14.033608\n",
-       "8  7.10  103.032008\n",
-       "9  5.44   94.629911, models=[GridSearchCV(estimator=Pipeline(steps=[('polynomialfeatures',\n",
-       "                                        PolynomialFeatures()),\n",
-       "                                       ('linearregression',\n",
-       "                                        LinearRegression())]),\n",
-       "             param_grid={'polynomialfeatures__degree': [0, 1, 2, 3, 4]},\n",
-       "             scoring='r2')])"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "from autora.workflow.__main__ import load_state\n",
-    "s = load_state(\"model.pkl\")\n",
-    "s"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "We have three new fields in the state. The first is the conditions, a sample of ten values from between -10 and 10."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/html": [
-       "<div>\n",
-       "<style scoped>\n",
-       "    .dataframe tbody tr th:only-of-type {\n",
-       "        vertical-align: middle;\n",
-       "    }\n",
-       "\n",
-       "    .dataframe tbody tr th {\n",
-       "        vertical-align: top;\n",
-       "    }\n",
-       "\n",
-       "    .dataframe thead th {\n",
-       "        text-align: right;\n",
-       "    }\n",
-       "</style>\n",
-       "<table border=\"1\" class=\"dataframe\">\n",
-       "  <thead>\n",
-       "    <tr style=\"text-align: right;\">\n",
-       "      <th></th>\n",
-       "      <th>x</th>\n",
-       "    </tr>\n",
-       "  </thead>\n",
-       "  <tbody>\n",
-       "    <tr>\n",
-       "      <th>342</th>\n",
-       "      <td>-3.16</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>869</th>\n",
-       "      <td>7.38</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>732</th>\n",
-       "      <td>4.64</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>387</th>\n",
-       "      <td>-2.26</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>919</th>\n",
-       "      <td>8.38</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>949</th>\n",
-       "      <td>8.98</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>539</th>\n",
-       "      <td>0.78</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>563</th>\n",
-       "      <td>1.26</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>855</th>\n",
-       "      <td>7.10</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>772</th>\n",
-       "      <td>5.44</td>\n",
-       "    </tr>\n",
-       "  </tbody>\n",
-       "</table>\n",
-       "</div>"
-      ],
-      "text/plain": [
-       "        x\n",
-       "342 -3.16\n",
-       "869  7.38\n",
-       "732  4.64\n",
-       "387 -2.26\n",
-       "919  8.38\n",
-       "949  8.98\n",
-       "539  0.78\n",
-       "563  1.26\n",
-       "855  7.10\n",
-       "772  5.44"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "s.conditions"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "We have experiment data corresponding to those conditions:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/html": [
-       "<div>\n",
-       "<style scoped>\n",
-       "    .dataframe tbody tr th:only-of-type {\n",
-       "        vertical-align: middle;\n",
-       "    }\n",
-       "\n",
-       "    .dataframe tbody tr th {\n",
-       "        vertical-align: top;\n",
-       "    }\n",
-       "\n",
-       "    .dataframe thead th {\n",
-       "        text-align: right;\n",
-       "    }\n",
-       "</style>\n",
-       "<table border=\"1\" class=\"dataframe\">\n",
-       "  <thead>\n",
-       "    <tr style=\"text-align: right;\">\n",
-       "      <th></th>\n",
-       "      <th>x</th>\n",
-       "      <th>y</th>\n",
-       "    </tr>\n",
-       "  </thead>\n",
-       "  <tbody>\n",
-       "    <tr>\n",
-       "      <th>0</th>\n",
-       "      <td>-3.16</td>\n",
-       "      <td>1.257587</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>1</th>\n",
-       "      <td>7.38</td>\n",
-       "      <td>153.259915</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2</th>\n",
-       "      <td>4.64</td>\n",
-       "      <td>54.291348</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>3</th>\n",
-       "      <td>-2.26</td>\n",
-       "      <td>10.374509</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>4</th>\n",
-       "      <td>8.38</td>\n",
-       "      <td>155.483778</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>5</th>\n",
-       "      <td>8.98</td>\n",
-       "      <td>183.774472</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>6</th>\n",
-       "      <td>0.78</td>\n",
-       "      <td>3.154024</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>7</th>\n",
-       "      <td>1.26</td>\n",
-       "      <td>14.033608</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>8</th>\n",
-       "      <td>7.10</td>\n",
-       "      <td>103.032008</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>9</th>\n",
-       "      <td>5.44</td>\n",
-       "      <td>94.629911</td>\n",
-       "    </tr>\n",
-       "  </tbody>\n",
-       "</table>\n",
-       "</div>"
-      ],
-      "text/plain": [
-       "      x           y\n",
-       "0 -3.16    1.257587\n",
-       "1  7.38  153.259915\n",
-       "2  4.64   54.291348\n",
-       "3 -2.26   10.374509\n",
-       "4  8.38  155.483778\n",
-       "5  8.98  183.774472\n",
-       "6  0.78    3.154024\n",
-       "7  1.26   14.033608\n",
-       "8  7.10  103.032008\n",
-       "9  5.44   94.629911"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "s.experiment_data"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "We have a best-fit linear model."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/html": [
-       "<style>#sk-container-id-1 {color: black;}#sk-container-id-1 pre{padding: 0;}#sk-container-id-1 div.sk-toggleable {background-color: white;}#sk-container-id-1 label.sk-toggleable__label {cursor: pointer;display: block;width: 100%;margin-bottom: 0;padding: 0.3em;box-sizing: border-box;text-align: center;}#sk-container-id-1 label.sk-toggleable__label-arrow:before {content: \"▸\";float: left;margin-right: 0.25em;color: #696969;}#sk-container-id-1 label.sk-toggleable__label-arrow:hover:before {color: black;}#sk-container-id-1 div.sk-estimator:hover label.sk-toggleable__label-arrow:before {color: black;}#sk-container-id-1 div.sk-toggleable__content {max-height: 0;max-width: 0;overflow: hidden;text-align: left;background-color: #f0f8ff;}#sk-container-id-1 div.sk-toggleable__content pre {margin: 0.2em;color: black;border-radius: 0.25em;background-color: #f0f8ff;}#sk-container-id-1 input.sk-toggleable__control:checked~div.sk-toggleable__content {max-height: 200px;max-width: 100%;overflow: auto;}#sk-container-id-1 input.sk-toggleable__control:checked~label.sk-toggleable__label-arrow:before {content: \"▾\";}#sk-container-id-1 div.sk-estimator input.sk-toggleable__control:checked~label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-1 div.sk-label input.sk-toggleable__control:checked~label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-1 input.sk-hidden--visually {border: 0;clip: rect(1px 1px 1px 1px);clip: rect(1px, 1px, 1px, 1px);height: 1px;margin: -1px;overflow: hidden;padding: 0;position: absolute;width: 1px;}#sk-container-id-1 div.sk-estimator {font-family: monospace;background-color: #f0f8ff;border: 1px dotted black;border-radius: 0.25em;box-sizing: border-box;margin-bottom: 0.5em;}#sk-container-id-1 div.sk-estimator:hover {background-color: #d4ebff;}#sk-container-id-1 div.sk-parallel-item::after {content: \"\";width: 100%;border-bottom: 1px solid gray;flex-grow: 1;}#sk-container-id-1 div.sk-label:hover label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-1 div.sk-serial::before {content: \"\";position: absolute;border-left: 1px solid gray;box-sizing: border-box;top: 0;bottom: 0;left: 50%;z-index: 0;}#sk-container-id-1 div.sk-serial {display: flex;flex-direction: column;align-items: center;background-color: white;padding-right: 0.2em;padding-left: 0.2em;position: relative;}#sk-container-id-1 div.sk-item {position: relative;z-index: 1;}#sk-container-id-1 div.sk-parallel {display: flex;align-items: stretch;justify-content: center;background-color: white;position: relative;}#sk-container-id-1 div.sk-item::before, #sk-container-id-1 div.sk-parallel-item::before {content: \"\";position: absolute;border-left: 1px solid gray;box-sizing: border-box;top: 0;bottom: 0;left: 50%;z-index: -1;}#sk-container-id-1 div.sk-parallel-item {display: flex;flex-direction: column;z-index: 1;position: relative;background-color: white;}#sk-container-id-1 div.sk-parallel-item:first-child::after {align-self: flex-end;width: 50%;}#sk-container-id-1 div.sk-parallel-item:last-child::after {align-self: flex-start;width: 50%;}#sk-container-id-1 div.sk-parallel-item:only-child::after {width: 0;}#sk-container-id-1 div.sk-dashed-wrapped {border: 1px dashed gray;margin: 0 0.4em 0.5em 0.4em;box-sizing: border-box;padding-bottom: 0.4em;background-color: white;}#sk-container-id-1 div.sk-label label {font-family: monospace;font-weight: bold;display: inline-block;line-height: 1.2em;}#sk-container-id-1 div.sk-label-container {text-align: center;}#sk-container-id-1 div.sk-container {/* jupyter's `normalize.less` sets `[hidden] { display: none; }` but bootstrap.min.css set `[hidden] { display: none !important; }` so we also need the `!important` here to be able to override the default hidden behavior on the sphinx rendered scikit-learn.org. See: https://github.com/scikit-learn/scikit-learn/issues/21755 */display: inline-block !important;position: relative;}#sk-container-id-1 div.sk-text-repr-fallback {display: none;}</style><div id=\"sk-container-id-1\" class=\"sk-top-container\"><div class=\"sk-text-repr-fallback\"><pre>GridSearchCV(estimator=Pipeline(steps=[(&#x27;polynomialfeatures&#x27;,\n",
-       "                                        PolynomialFeatures()),\n",
-       "                                       (&#x27;linearregression&#x27;,\n",
-       "                                        LinearRegression())]),\n",
-       "             param_grid={&#x27;polynomialfeatures__degree&#x27;: [0, 1, 2, 3, 4]},\n",
-       "             scoring=&#x27;r2&#x27;)</pre><b>In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook. <br />On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.</b></div><div class=\"sk-container\" hidden><div class=\"sk-item sk-dashed-wrapped\"><div class=\"sk-label-container\"><div class=\"sk-label sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-1\" type=\"checkbox\" ><label for=\"sk-estimator-id-1\" class=\"sk-toggleable__label sk-toggleable__label-arrow\">GridSearchCV</label><div class=\"sk-toggleable__content\"><pre>GridSearchCV(estimator=Pipeline(steps=[(&#x27;polynomialfeatures&#x27;,\n",
-       "                                        PolynomialFeatures()),\n",
-       "                                       (&#x27;linearregression&#x27;,\n",
-       "                                        LinearRegression())]),\n",
-       "             param_grid={&#x27;polynomialfeatures__degree&#x27;: [0, 1, 2, 3, 4]},\n",
-       "             scoring=&#x27;r2&#x27;)</pre></div></div></div><div class=\"sk-parallel\"><div class=\"sk-parallel-item\"><div class=\"sk-item\"><div class=\"sk-label-container\"><div class=\"sk-label sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-2\" type=\"checkbox\" ><label for=\"sk-estimator-id-2\" class=\"sk-toggleable__label sk-toggleable__label-arrow\">estimator: Pipeline</label><div class=\"sk-toggleable__content\"><pre>Pipeline(steps=[(&#x27;polynomialfeatures&#x27;, PolynomialFeatures()),\n",
-       "                (&#x27;linearregression&#x27;, LinearRegression())])</pre></div></div></div><div class=\"sk-serial\"><div class=\"sk-item\"><div class=\"sk-serial\"><div class=\"sk-item\"><div class=\"sk-estimator sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-3\" type=\"checkbox\" ><label for=\"sk-estimator-id-3\" class=\"sk-toggleable__label sk-toggleable__label-arrow\">PolynomialFeatures</label><div class=\"sk-toggleable__content\"><pre>PolynomialFeatures()</pre></div></div></div><div class=\"sk-item\"><div class=\"sk-estimator sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-4\" type=\"checkbox\" ><label for=\"sk-estimator-id-4\" class=\"sk-toggleable__label sk-toggleable__label-arrow\">LinearRegression</label><div class=\"sk-toggleable__content\"><pre>LinearRegression()</pre></div></div></div></div></div></div></div></div></div></div></div></div>"
-      ],
-      "text/plain": [
-       "GridSearchCV(estimator=Pipeline(steps=[('polynomialfeatures',\n",
-       "                                        PolynomialFeatures()),\n",
-       "                                       ('linearregression',\n",
-       "                                        LinearRegression())]),\n",
-       "             param_grid={'polynomialfeatures__degree': [0, 1, 2, 3, 4]},\n",
-       "             scoring='r2')"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "s.model"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "... which we can plot:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/jholla10/Developer/autora-workflow/.venv/lib/python3.8/site-packages/sklearn/base.py:464: UserWarning: X does not have valid feature names, but PolynomialFeatures was fitted with feature names\n",
-      "  warnings.warn(\n"
-     ]
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 640x480 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "import numpy as np\n",
-    "from matplotlib import pyplot as plt\n",
-    "\n",
-    "from lib import ground_truth, noise_std\n",
-    "\n",
-    "def plot_results(state):\n",
-    "    x = np.linspace(-10, 10, 100).reshape((-1, 1))\n",
-    "    plt.plot(x, ground_truth(x), label=\"ground_truth\", c=\"orange\")\n",
-    "    plt.fill_between(x.flatten(), ground_truth(x).flatten() + noise_std, ground_truth(x).flatten() - noise_std,\n",
-    "                     alpha=0.3, color=\"orange\")\n",
-    "    \n",
-    "    xi, yi = state.experiment_data[\"x\"], state.experiment_data[\"y\"]\n",
-    "    plt.scatter(xi, yi, label=f\"observations\")\n",
-    "    \n",
-    "    plt.plot(x, state.model.predict(x), label=\"model\")\n",
-    "    \n",
-    "    plt.legend()\n",
-    "\n",
-    "plot_results(s)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "If we run the experiment for another 3 cycles, we can get results closer to the ground truth. In this example, we overwrite the results file each time the CLI is called."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "!cp \"model.pkl\" \"result.pkl\"\n",
-    "for i in range(3):\n",
-    "    !python -m autora.workflow lib.experimentalist --in-path \"result.pkl\" --out-path \"result.pkl\"\n",
-    "    !python -m autora.workflow lib.experiment_runner --in-path \"result.pkl\" --out-path \"result.pkl\"\n",
-    "    !python -m autora.workflow lib.theorist --in-path \"result.pkl\" --out-path \"result.pkl\"\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/jholla10/Developer/autora-workflow/.venv/lib/python3.8/site-packages/sklearn/base.py:464: UserWarning: X does not have valid feature names, but PolynomialFeatures was fitted with feature names\n",
-      "  warnings.warn(\n"
-     ]
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 640x480 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "state_after_three_more_cycles = load_state(\"result.pkl\")\n",
-    "plot_results(state_after_three_more_cycles)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "We can continue to run for as long as we like, e.g. another 10 cycles:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/jholla10/Developer/autora-workflow/.venv/lib/python3.8/site-packages/sklearn/base.py:464: UserWarning: X does not have valid feature names, but PolynomialFeatures was fitted with feature names\n",
-      "  warnings.warn(\n"
-     ]
-    },
-    {
-     "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAigAAAGdCAYAAAA44ojeAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAACnt0lEQVR4nOzdeXxU5dXA8d+dJZmskz2TQICwE8KugQgoCkhQEZdWRVxrbUtx36qtNUbbUrXWan2F1lqXWte6UKxEERQBA2ERMYAsIazZyDbZk8nMff+4ySSTmckC2SDn+/lEydxl7kAyc+7znOccRVVVFSGEEEKIPkTX2xcghBBCCNGaBChCCCGE6HMkQBFCCCFEnyMBihBCCCH6HAlQhBBCCNHnSIAihBBCiD5HAhQhhBBC9DkSoAghhBCizzH09gWcCofDQW5uLkFBQSiK0tuXI4QQQogOUFWViooKYmNj0enaHiM5IwOU3Nxc4uLievsyhBBCCHEKjh07xsCBA9vcp1MByrJly/jwww/54Ycf8PPz47zzzuOpp55i1KhRzn1mzZrF+vXrXY77+c9/zooVK5zfHz16lCVLlvDll18SGBjIzTffzLJlyzAYOnY5QUFBgPYCg4ODO/MShBBCCNFLysvLiYuLc36Ot6VTAcr69etZunQp5557Lg0NDfz617/m4osvZs+ePQQEBDj3u/3223niiSec3/v7+zv/bLfbufTSS7FYLHzzzTfk5eVx0003YTQa+cMf/tCh62ia1gkODpYARQghhDjDdCQ9QzmdZoEnT54kKiqK9evXc/755wPaCMrEiRP5y1/+4vGY1atXc9lll5Gbm0t0dDQAK1as4Fe/+hUnT57Ex8en3ectLy/HbDZjtVolQBFCCCHOEJ35/D6tVTxWqxWAsLAwl8f//e9/ExERQWJiIo888gjV1dXObRkZGYwbN84ZnADMmzeP8vJydu/e7fF56urqKC8vd/kSQgghxNnrlJNkHQ4H99xzD9OnTycxMdH5+PXXX8/gwYOJjY1l165d/OpXv2Lfvn18+OGHAOTn57sEJ4Dz+/z8fI/PtWzZMtLS0k71UoUQQghxhjnlAGXp0qVkZWWxceNGl8d/9rOfOf88btw4YmJimD17NtnZ2QwbNuyUnuuRRx7hvvvuc37flGTTFlVVaWhowG63n9Jziv5Br9djMBhkuboQQvQxpxSg3HHHHXzyySd8/fXX7S4Tmjp1KgAHDx5k2LBhWCwWMjMzXfYpKCgAwGKxeDyHr68vvr6+Hb6++vp68vLyXKaWhPDG39+fmJiYDuU/CSGE6BmdClBUVeXOO+/ko48+4quvviI+Pr7dY3bu3AlATEwMAMnJyfz+97+nsLCQqKgoANasWUNwcDAJCQmdvHx3DoeDnJwc9Ho9sbGx+Pj4yN2x8EhVVerr6zl58iQ5OTmMGDGi3cJBQgghekanApSlS5fy1ltvsXLlSoKCgpw5I2azGT8/P7Kzs3nrrbe45JJLCA8PZ9euXdx7772cf/75jB8/HoCLL76YhIQEbrzxRp5++mny8/N59NFHWbp0aadGSbypr6/H4XAQFxfnsrxZCE/8/PwwGo0cOXKE+vp6TCZTb1+SEEIIOrmKZ/ny5VitVmbNmkVMTIzz69133wXAx8eHL774gosvvpjRo0dz//33c/XVV7Nq1SrnOfR6PZ988gl6vZ7k5GRuuOEGbrrpJpe6KV3ywuROWHSQ/KwIIUTf0+kpnrbExcW5VZH1ZPDgwXz66aedeWohhBBC9CNy6yiEEEKIPkcCFHHKXnvtNUJCQnr7MlwoisLHH3/c25chhBDiNEmAInrE448/zsSJE/vs+YQQQvQtEqCcwerr63v7ErqczWbr7UsQQgjRB/SPAEVVoaGq57862YexoqKCxYsXExAQQExMDM899xyzZs3innvuAWDIkCE8+eST3HTTTQQHBzur9n7wwQeMHTsWX19fhgwZwrPPPutyXk/THiEhIbz22msAHD58GEVR+PDDD7nwwgvx9/dnwoQJZGRkuBzz2muvMWjQIPz9/bnyyispLi7u0Ot67bXXSEtL47vvvkNRFBRFcT63oigsX76cyy+/nICAAH7/+997nDr6+OOPnfVs2jofQFFREVdeeSX+/v6MGDGC//73vx26TiGEEI2qc6HqWK9ewimXuj+j2KvhvcCef95rKsEQ0OHd77vvPjZt2sR///tfoqOjeeyxx9ixY4fLVMaf/vQnHnvsMVJTUwHYvn0711xzDY8//jjXXnst33zzDb/85S8JDw/nlltu6dTl/uY3v+FPf/oTI0aM4De/+Q2LFi3i4MGDGAwGtmzZwm233cayZcu44oorSE9Pd15De6699lqysrJIT0/niy++ALTaOU0ef/xx/vjHP/KXv/wFg8HAunXrTut8aWlpPP300zzzzDP89a9/ZfHixRw5csStqaUQQggPVAeUbAWfUAhou61Md+ofAcoZoKKigtdff5233nqL2bNnA/Dqq68SGxvrst9FF13E/fff7/x+8eLFzJ49m9/+9rcAjBw5kj179vDMM890OkB54IEHuPTSSwHtQ37s2LEcPHiQ0aNH8/zzz5OSksJDDz3kfJ5vvvmG9PT0ds/r5+dHYGAgBoPBYzuD66+/nltvvbXD19ne+W655RYWLVoEwB/+8AdeeOEFMjMzSUlJ6fBzCCFEv1VboI2e+IT26mX0jwBF76+NZvTG83bQoUOHsNlsJCUlOR8zm82MGjXKZb9zzjnH5fu9e/eycOFCl8emT5/OX/7yF+x2O3q9vsPX0FTtF5pbExQWFjJ69Gj27t3LlVde6bJ/cnJyhwKU9rR+Taer5esICAggODiYwsLCLn0OIYQ4a1VkQ11Rb19FPwlQFKVTUy19WUBA51+HoihuRfY8JaMajUaXY0DrbdTdWr8mnU7Xoev1puXrAO219MTrEEKIM15DFVTsBzqXQ9kd+keS7Blg6NChGI1Gtm7d6nzMarWyf//+No8bM2YMmzZtcnls06ZNjBw50jl6EhkZSV5ennP7gQMHOt3pecyYMWzZssXlsc2bN3f4eB8fH+x2e4f2jYyMpKKigqqqKudjTU0nT+V8QgghOqjyMNSXgNHc7q7drX+MoJwBgoKCuPnmm3nwwQcJCwsjKiqK1NRUdDpdm92Y77//fs4991yefPJJrr32WjIyMnjxxRd56aWXnPtcdNFFvPjiiyQnJ2O32/nVr37lNsrQnrvuuovp06fzpz/9iYULF/LZZ591anpnyJAh5OTksHPnTgYOHEhQUJDX5pBTp07F39+fX//619x1111s2bLFZZVOZ88nhBCiAxx27GV7ySwIpbBKJaq6gaQIFb3O+2dQd5IRlD7kz3/+M8nJyVx22WXMmTOH6dOnM2bMmDY77E6ePJn33nuPd955h8TERB577DGeeOIJlwTZZ599lri4OGbOnMn111/PAw880OlOz9OmTePll1/m+eefZ8KECXz++ec8+uijHT7+6quvJiUlhQsvvJDIyEjefvttr/uGhYXx5ptv8umnnzJu3DjefvttHn/88VM+nxBCiPalf7uXGW8YWJRu4e4NMSx6v4YZT60jPSuv/YO7gaK21wGwDyovL8dsNmO1WgkODnbZVltbS05ODvHx8W1+sJ8JqqqqGDBgAM8++yy33XZbb1/OWets+pkRQohTkZ6Vx5I3d6CiAs0jJk1/Wn7DZFISY077edr6/G5NRlD6kG+//Za3336b7OxsduzYweLFiwHcVukIIYQQXcXuUEn7b5ZbcALNqbJpq/Zgd/TseIYEKH3Mn/70JyZMmMCcOXOoqqpiw4YNRERE9PZltWvs2LEEBgZ6/Pr3v//d25cnhBDCi8ycEvLK62kdnDRRgTxrLZk5JT16XZIk24dMmjSJ7du39/ZlnJJPP/3U61Lg6OjoHr4aIYQQHVVY3rFVnYUVtd18Ja4kQBFdYvDgwb19CUIIIU5BlLHc5fuhPsdBUfFT6thdO7x5v6CezdGTKR4hhBCiH0sKOUaMvw2lMePEbKjgUF0cAboaQJv4iTGbSIrv2X5mEqAIIYQQ/VVtEfqaHFKn1wMQqFSSVaONmpTbA5xZKakLEnq8HooEKEIIIUR/VXkIbJWkjPJj+XyVCUFHsKlGhvse5Ye6eCxmU5ctMe4syUERQggh+iN7LZTvBWMIABfHqyxbFwlASmwu088ZRdKkC3utkqwEKEIIIUQ/YXeoZOaUUFhRS5S+kCTlJPrgYQBs+OEIR+qGEqSr4pdTA/GPNUAvBScgAcoZ46uvvuLCCy+ktLSUkJCQ3r6cLnHLLbdQVlbGxx9/3NuXIoQQZ730rDzSVu0hz9q8XDjGfwSpF+hIGQb/2qU1YL164AH8fQO8nabHSIAiut3hw4eJj4/n22+/ZeLEic7Hn3/+ec7ATgtCCHHGaS5l7yq/Ws+S1fD0zDLWFQ0F4IbJIYDnulY9SQIUL1yGwYK05VW9NQ/XW+rr6/Hx8em285vNvd/OWwghznZ2h0raqj1uwQmAioKCyoc783AQSrL5AMMHDoOK7B6/ztZkFY8H6Vl5zHhqHYte3szd7+xk0cube6SjY11dHXfddRdRUVGYTCZmzJjB1q1bXfbZtGkT48ePx2QyMW3aNLKyspzbjhw5woIFCwgNDSUgIICxY8fy6aefOrdnZWUxf/58AgMDiY6O5sYbb6SoqMi5fdasWdxxxx3cc889REREMG/ePK6//nquvfZal2uw2WxERETwxhtvAJCens6MGTMICQkhPDycyy67jOzs5h/u+Ph4QKuUqygKs2bNArQpniuuuKLDr/+rr75CURTWrl3LOeecg7+/P+eddx779u1z7vPdd99x4YUXEhQURHBwMFOmTGHbtm2d/acQQoizRmZOicu0jjsH+6oHAHDDmI5Vle0JEqC00jQM1vofM99ay5I3d3RrkPLQQw/xwQcf8Prrr7Njxw6GDx/OvHnzKClp7n/w4IMP8uyzz7J161YiIyNZsGCBs8T80qVLqaur4+uvv+b777/nqaeeIjAwEICysjIuuugiJk2axLZt20hPT6egoIBrrrnG5Rpef/11fHx82LRpEytWrGDx4sWsWrWKyspK5z6fffYZ1dXVXHnllYDWdfm+++5j27ZtrF27Fp1Ox5VXXonD4QAgMzMTgC+++IK8vDw+/PDDU379AL/5zW949tln2bZtGwaDgZ/85CfObYsXL2bgwIFs3bqV7du38/DDD2M0Gk/p30MIIc4G7ZWoH2PKocRuJtJQysXjR/bQVbVPpnhaaHsYTKuml7ZqD3MTLF0+3VNVVcXy5ct57bXXmD9/PgAvv/wya9as4ZVXXuHcc88FIDU1lblz5wJaMDFw4EA++ugjrrnmGo4ePcrVV1/NuHHjABg6dKjz/C+++CKTJk3iD3/4g/Oxf/7zn8TFxbF//35GjtR+KEeMGMHTTz/t3GfYsGEEBATw0UcfceONNwLw1ltvcfnllxMUFATA1Vdf7fJa/vnPfxIZGcmePXtITEwkMlJbthYeHo7FYjml1//ggw869/3973/PBRdcAMDDDz/MpZdeSm1tLSaTiaNHj/Lggw8yevRo5+sRQoj+rL0S9fbGUODSmByMPhN74Io6RkZQWmhvGKw7OzpmZ2djs9mYPn268zGj0UhSUhJ79+51PpacnOz8c1hYGKNGjXJuv+uuu/jd737H9OnTSU1NZdeuXc59v/vuO7788kuXLsNNH+Itp2OmTJnicl0Gg4FrrrnG2ZG4qqqKlStXsnjxYuc+Bw4cYNGiRQwdOpTg4GCGDBkCwNGjR7v89QOMHz/e+eeYGK14UGFhIQD33XcfP/3pT5kzZw5//OMfXV6bEEL0R0nxYcSYTR57FUcZitlXOwQddm6b1rcau0qA0kJHOzX2dEfHjvrpT3/KoUOHuPHGG/n+++8555xz+Otf/wpAZWUlCxYsYOfOnS5fBw4c4Pzzz3eeIyDAfWnZ4sWLWbt2LYWFhXz88cf4+fmRkpLi3L5gwQJKSkp4+eWX2bJlC1u2bAG0JNvu0HLKRlG0X7mm6aTHH3+c3bt3c+mll7Ju3ToSEhL46KOPuuU6hBCir2ta8DE/0eKcCWhpgI92c3d+yD7ionu+WmxbJEBpoaOdGrujo+OwYcOcuR9NbDYbW7duJSEhwfnY5s2bnX8uLS1l//79jBkzxvlYXFwcv/jFL/jwww+5//77efnllwGYPHkyu3fvZsiQIQwfPtzly1NQ0tJ5551HXFwc7777Lv/+97/58Y9/7AwSiouL2bdvH48++iizZ89mzJgxlJaWuhzftBLIbref9uvviJEjR3Lvvffy+eefc9VVV/Hqq6926nghhDgbtFzw8c9NhwFQlOYkBiM29tUOAeCnE1u/P/d+CQgJUFpoaxgMurejY0BAAEuWLOHBBx8kPT2dPXv2cPvtt1NdXc1tt93m3O+JJ55g7dq1ZGVlccsttxAREeFcCXPPPffw2WefkZOTw44dO/jyyy+dwcvSpUspKSlh0aJFbN26lezsbD777DNuvfXWNgOHJtdffz0rVqxgzZo1LtM7oaGhhIeH8/e//52DBw+ybt067rvvPpdjo6Ki8PPzcybmWq3WU379bampqeGOO+7gq6++4siRI2zatImtW7e6BHBCCNEfeFvw4VABVG6b4ODnIw9R7fBjqCmP6Qmjm3dS7dqXb0SPXnNrEqC0oNcppC7Q7tZbByk90dHxj3/8I1dffTU33ngjkydP5uDBg3z22WeEhoa67HP33XczZcoU8vPzWbVqlcsIxdKlSxkzZgwpKSmMHDmSl156CYDY2Fg2bdqE3W7n4osvZty4cdxzzz2EhISg07X/Y7B48WL27NnDgAEDXPJEdDod77zzDtu3bycxMZF7772XZ555xuVYg8HACy+8wN/+9jdiY2NZuHDhKb/+tuj1eoqLi7npppsYOXIk11xzDfPnzyctLa1DxwshxNmgrQUfoKAA/zuokH5Mq0V10/ATKDp98y51JeAbBgGDe+BqvVPUM7CUZ3l5OWazGavVSnBwsMu22tpacnJyiI+Px2Q6takYj+WAzSZSFyT0SkdH0b264mdGCCH6iozsYha9vLnNfQb7nOBI/QACdDVsvqmGoMCQ5o3l+yAiGaKmez3+VLX1+d2aLDP2ICUxhrkJln5fSVYIIcSZpyMLOQL1NQBcGbOXoMCJzRsaqkBvgqBh3XR1HScBihd6nULysPDevgwhhBCiU9pbyBGoq+KHGq3C902Tg1w31hZC4BAw9f6SY8lBEUIIIc4i7S34GO57DDt6pgXvZ+Sg5oKeqHZw1EPwKFB6f8ZAAhQhhBDiLNL2gg87R+pjAbhpTKVrIFJXBKbIXk+ObSIBihBCCHGWSUmMYfkNk7EEun7MTw46Qqk9GIuxmLkTRrkeVF8KwaO1HJQ+QHJQhBBCiLNQyuhg5l6bR2aekcKGEKL84em1WpHN6wcfwujTorWJrQIMgRA41MvZep4EKEIIIcTZqPIw+oYSkuOHgwLfHS3m24o4fBQbi86Ndd23thCCR/Z6cbaWJEARQgghznBNPXecpTEGB6O37gZ9AChaEbbXtpUBkVwUupuDNeMJc4BeBzhsgKPPJMc2kQBFCCGEOIN5LC4aZCB1ipWUhCgAPsiq5ZO8IQCcrPVh0cc6YgJVUmeqpMSeBFMU+Mf1xuV7JUmy/dCsWbO45557Orz/a6+9RkhISLddjxBCiFPjredOfkUDS76KIT3Hh/RseG3LcWyqkQRTNt9Wa8mx+ZWwZLVC+kEVghNA79MbL8ErGUERQgghzkBt9dxR0ZYYp21QcDhUbPXaSEqUoYQ9DGvcR0FBJW1bDHMvjEfv4Ty9SUZQhBBCiDNQZk6J28hJSyoKeZUKQfZjlNhDiDCUsr1qjPs+VQYyTzi6+3I7rV8EKKqqUl3f0ONfne3DOGvWLO68807uueceQkNDiY6O5uWXX6aqqopbb72VoKAghg8fzurVq53HrF+/nqSkJHx9fYmJieHhhx+moaHBub2qqoqbbrqJwMBAYmJiePbZZ92et66ujgceeIABAwYQEBDA1KlT+eqrr07571sIIUT360jPHQCHqn3Uj/fbT4UaeFrn6kn9YoqnxmYn4bHPevx59zwxD3+fzv0Vv/766zz00ENkZmby7rvvsmTJEj766COuvPJKfv3rX/Pcc89x4403cvToUUpLS7nkkku45ZZbeOONN/jhhx+4/fbbMZlMPP744wA8+OCDrF+/npUrVxIVFcWvf/1rduzYwcSJE53Peccdd7Bnzx7eeecdYmNj+eijj0hJSeH7779nxIgRXfg3IoQQoqu013MHIMJQyqH6OIyKjcN1sV7368i5elq/GEE5k0yYMIFHH32UESNG8Mgjj2AymYiIiOD2229nxIgRPPbYYxQXF7Nr1y5eeukl4uLiePHFFxk9ejRXXHEFaWlpPPvsszgcDiorK3nllVf405/+xOzZsxk3bhyvv/66ywjL0aNHefXVV3n//feZOXMmw4YN44EHHmDGjBm8+uqrvfg3IYQQoi3t9dxRUBnoU6ztG7CbQ/Xuq3QUIMZsIik+rPsu9BT1ixEUP6OePU/M65Xn7azx48c7/6zX6wkPD2fcuHHOx6KjtQ6ThYWF7N27l+TkZJQW69anT59OZWUlx48fp7S0lPr6eqZOnercHhYWxqhRzeWNv//+e+x2OyNHjnS5jrq6OsLDpZuzEEL0VU09d5a8uQMFXJJlFVSM1LO7RuurY3doCbFqi3BGaUylTV2QgF7Xd+qfNOkXAYqiKJ2eauktRqPR5XtFUVweawpGHI6uSWiqrKxEr9ezfft29HrXgCow0PNcpRBCiL6hqedO6zoolkC4MPwYbx0ZzoSAQ9w6M4EjGyGvsvlYS5CO1IWTSEmM6YUrb9+Z8aktPBozZgwffPABqqo6A5dNmzYRFBTEwIEDCQsLw2g0smXLFgYNGgRAaWkp+/fv54ILLgBg0qRJ2O12CgsLmTlzZq+9FiGEEKcmJTGGuUMayNy6msKGcCICfbA1qDzwWSQAt4wqZN7wIcwZqpKZq2rVZn3KSTrnUvQBll6+eu8kB+UM9stf/pJjx45x55138sMPP7By5UpSU1O577770Ol0BAYGctttt/Hggw+ybt06srKyuOWWW9Dpmv/ZR44cyeLFi7npppv48MMPycnJITMzk2XLlvG///2vF1+dEEKIjtJX7CfZUoGvjw8PrFV4Yk0uRQ1mogzFLD+QQHq2VtY+eSAsjDtB8nALev/o3r7sNskIyhlswIABfPrppzz44INMmDCBsLAwbrvtNh599FHnPs888wyVlZUsWLCAoKAg7r//fqxWq8t5Xn31VX73u99x//33c+LECSIiIpg2bRqXXXZZT78kIYQQnVVXDJUHSc8dyJI1WmbJoMa0hon++1lTPo0lq2H5fJWUeBuoDgge3af67niiqJ0o1rFs2TI+/PBDfvjhB/z8/DjvvPN46qmnXJIua2truf/++3nnnXeoq6tj3rx5vPTSS87kTtBWjixZsoQvv/ySwMBAbr75ZpYtW4bB0LF4qby8HLPZjNVqJTg42GVbbW0tOTk5xMfHYzL1vWVTou+RnxkhxBmtaAv2/K+Z8fEY8iohUl/KSXsYvkodA4yFHKqPQ0HFEggbf3wCvW8wDPoR6Iztn7uLtfX53VqnpnjWr1/P0qVL2bx5M2vWrMFms3HxxRdTVVXl3Ofee+9l1apVvP/++6xfv57c3Fyuuuoq53a73c6ll15KfX0933zzDa+//jqvvfYajz32WCdfphBCCNHPNVSBdTeZJRbyKhVAIcyojZInB3zvXFrcVFU284QNgsf0SnDSWZ2a4klPT3f5/rXXXiMqKort27dz/vnnY7VaeeWVV3jrrbe46KKLAG36YMyYMWzevJlp06bx+eefs2fPHr744guio6OZOHEiTz75JL/61a94/PHH8fHpW82KhBBCiD6rMgfqiim0aaUiTEotB2q1pcXVDl+33QttIRA0tCev8JSdVpJsUy5DWJhW4GX79u3YbDbmzJnj3Gf06NEMGjSIjIwMADIyMhg3bpzLlM+8efMoLy9n9+7dHp+nrq6O8vJyly8hhBCiX3PYoOx7MAQSFaB9nMf7nsCBjin+e9haPdbtkKjwGDC2PbXSV5xygOJwOLjnnnuYPn06iYmJAOTn5+Pj40NISIjLvtHR0eTn5zv3aRmcNG1v2ubJsmXLMJvNzq+4OPdqeEIIIUS/UnUUavLAFE1SLFgC7Byr15YNh+grUFt8xCuoxAQ0kDR6dG9dbaedcoCydOlSsrKyeOedd7ryejx65JFHsFqtzq9jx461e0xnG/WJ/kt+VoQQZxzVAdbdoOhBZ0Svg8sGHKPSEcAgnzw2VzZXIFcaa8ymnq+gD+ibRdk8OaUA5Y477uCTTz7hyy+/ZODAgc7HLRYL9fX1lJWVuexfUFCAxWJx7lNQUOC2vWmbJ76+vgQHB7t8edNUdbW6urrTr0v0T00/K62r+AohRJ9VkwuVh8GkfW46VFh7TKv+PTHgEFWqv3NXSyAsn5VLyqQxoJw55c86lSSrqip33nknH330EV999RXx8fEu26dMmYLRaGTt2rVcffXVAOzbt4+jR4+SnJwMQHJyMr///e8pLCwkKioKgDVr1hAcHExCQsJpvyC9Xk9ISAiFhYUA+Pv7u/SqEaKJqqpUV1dTWFhISEiIW6l/IYTos6x7QW0AgxaIrNtXRE5NFEG6Sn53aTyLKh0UVkOUPySF5qH38YeAQb180Z3TqQBl6dKlvPXWW6xcuZKgoCBnzojZbMbPzw+z2cxtt93GfffdR1hYGMHBwdx5550kJyczbdo0AC6++GISEhK48cYbefrpp8nPz+fRRx9l6dKl+Pq6ZxyfiqaRmKYgRYi2hISEeB29E0KIPqe2CCoPgqk5n/OV7XUAXD9wF8Eh00gOadygqlBhheBzQN81n7E9pVMByvLlywGYNWuWy+Ovvvoqt9xyCwDPPfccOp2Oq6++2qVQWxO9Xs8nn3zCkiVLSE5OJiAggJtvvpknnnji9F5JC4qiEBMTQ1RUFDabrcvOK84+RqNRRk6EEGeWiv1gqwQ/LcUiK6+KjNI49Ni5eUqo6762MjCaz5ilxS11qpJsX9GZSnRCCCFEX2N3qGTmlGiN+4JMJMWHodd1IB3BVgFH3wN04BsBwH0fH+HD4/FcHrGdF66d6FrCvnw/hE+B6Fnd8TI6rTOf39KLRwghhOhB6Vl5pK3aQ5611vlYjNlE6oIEUhLbWWVTcVDrvROktZjJL7fx3xNa6Y2fTnA4gxO7AzKP1VFYHkoUFpIi1Y4FQH2IBChCCCFED0nPymPJmztoPXWRb61lyZs7WH7DZO9Bir1WW1psDHGuxnkjM5cGNZ6kwB8YP2q89hzZkLZBIa/SD/ADsokxn+hYANSHnDnrjYQQQogzmN2hkrZqj1twAjgfS1u1B7vDS+ZF5WGozQffSACq61X+fUBbDXvbmCLQGUnPhiWrFfIqXQ9tCoDSs/K65LX0BAlQhBBCiB6QmVPiMq3TmgrkWWvJzClx3+hoAOv3oPMDnTb58cG3uVjtAQzyyWfOxHHYHdrIiRbeuE7ndCgA6mMkQBFCCCF6QGGF9+Ck3f2qj0LVcefSYocK/8zSaqD8ZOh+9L5BZObi7GjsSZsBUB8kAYoQQgjRA6KCTKe2n+oA6x4tAbaxlsnafcXk1IQTpKvkx+dqRVMLO1hAvaOBUm+TAEUIIYToAUnxYcSYTV7GN7RxjxiztuTYRU0uVBwCU3OC69+3aTW+rh/wHQHmAYBWNbYjOhoo9TYJUIQQQogeoNcppC7QWrq0DlKavk9dkOC+HLhVWfsdxyrZWhaLUbFx67nNhdmSYiEmwOFsDtia1wCoj5IARQghhOghKYkxLL9hMhaz6yiGxWzyvMS4tlCrfdKirP0/MssAuDziWywxo5yP63WQmpQPKJ0LgPooqYMihBBC9KCUxBjmJlg6Vkm2/AdoqAJ/raz9kZJ60vO0P48MV/jTFoXkATBtAOipJ2VQBct/NIC0NcUuK4YsHS0E14dIqXshhBCiL6ovg6Pvg+IDvtq0zNIPj/G/3MFMDdjFtqqx2NF6iYWYVP54XhEpo/wh7irs6E+tlH43k1L3QgghxJmufD/Ul0LQaAD+s8fBF3naCEiYvtwZnACU1cIv1kWwwhxFymADeiB5WHhvXHWXkRwUIYQQoq9pqNLK2vuEg6Jgd8A/N+dRp/ow2pTD+orJrQ7QRkceX2s9YwqxtUcCFCGEEKKvqciGuiJnx+KNx+B4rbZiZ4TvUapVT2uKFfLL68+YQmztkQBFCCGE6EvstVC2C4zBzqaAX+0vpNwRSIzxJJlVY9s8/EwpxNYeCVCEEEKIvqTyUGNTQK0RoEOFdUeMAJwbkEVBQ0Sbh58phdjaIwGKEEII0Vc4bFD2Pej9nU0BP/+hjCO14QTrK/mhZkibh1uCfc+YQmztkQCltcpDULAezrzV10IIIc50lYeh+gSYLID2UbSisaz91VHb2V83BLxUigV4/PKxfWI5cVeQAKW1hhqoPAi1Bb19JUIIIfoRe0MDGXuyWHk4hIxcI3YHbDlaxU5rND5KPb9MDmPFfJUQDzM4If5GVniqRHsGkzoordgdKpk5VRQe20VUnLHPFLcRQghx9krPyiNt5S7yKnwArax9TKBKnLEcCOJHUVuJjJlGigJz41U2n1DJOFwBel+SJ05n2vDos+6zSgKUFrQfkOPkVQwDbMBmYs7A8sBCCCHODHaHyovrDvDcFwfQpm6ag4ySyjryGIAOOz+bYgRF26bXwfSBdqaH5EJMCoRYeufiu5lM8TRKz8pjyZs7yKuwuzyeb61lyZs7SM/K66UrE0IIcTZKz8pj+h/XNQYn0LrHcaxPEQAXBO0gbvAk14PrisA3EgKH9sCV9g4JUNAi2LRVezymHTU9lrZqz1lTnU8IIUTvaropzi/3XLNEh52j9drIvUlXR2Zec1l7VFUrgW9OAIOngm1nBwlQgMycEpeuj62pQJ619qypzieEEKL3tHVT3GSwTx529Jzrn8W68nMprG6x0VYGRjMEDe/mK+1dEqDQ8ap7Z0t1PiGEEL2nvZtiUMm1RQIQazxJnepLVMuBkrpCCB4FPqHdep29TQIUOl5172ypzieEEKL3tHezG+eTT53qy2jTIb6qmExMoEpSbONGWyXo/bQA5SwnAQqQFB9GjNmEtwVaCiox5rOnOp8QQoje097NbkmDGYCxfoewOoK5fISKvunTui4fAoaCKbqbr7L3SYAC6HUKqQsSgNY51FpwApB6YcBZt8ZcCCFEz2vrpjjWUEiVw5/BPrl8UzEegP8eULA7AHsdoEBIgnPJ8dlMApRGKYkxLL9hMsOCawnSVTkftwTC8tklpEQf1KrMCiGEEKeh5U1x67L1VaofAEkBu8lriAIU8ioVMnPRGgj6DwK/gT16vb1FCrW1kGL6hHnD7+eEaQbbA5cQ5Q9JsaBXgrXy95UHIWRcb1+mEEKIM1zKSD+Wzy7h4Y0hlNVpoyGRhhJONoRhMRSxvWq0y/6FVQ4IroOQsaDTezrlWUdGUFryDaeuvo6wym9YOLSa5IFaxT4UPRiCoPQ7sMtKHiGEEKepfB8pA/L4v5TmERS1cdJnRtC3HKqPc9k9ylgKfjEQEN+jl9mbJEBp4cPCc5mx7zVeKUiBvNWuG32joKYAu/UgGdnFrNx5gozsYineJoQQonNs5WDNAp8Ipg1QiAlUCdWXUdQQSoi+nB9qBjt3VVC1VTxhJyF0HOh9evHCe5ZM8bRgMOgpsgXzStFCfnLkHgJiLwO9r7ZRZyD9eDhpH+SQV3XEeYz06hFCCNEp5fuhrhiCRqFX4LEZKo9/0QDA7KBMPiibA7RYpDG1DL1/FAQO67VL7g0ygtLCpeNiiA/VU2YP5q2C6VCw1rktPRuWrIsgr8o1c1p69QghhOgwWyWU7QKfcFC0j2ATVRQ0RBCgq+aYrXn5sCUQlqc4SBmQe9aXtfdEApQW9DqFJdNCAPj7ySupPfJfcDRgd0DahqZY1jVAkV49QgghWrI7VO+pAOX7Ghv9RQBaW52XMrU69tdbNnPvnASev9jB21c42HiTSkpcCfiEQdDI3ngpvUqmeFq5IjGQv6zPI7c6jPfzJ3Djya/JtF1EXqX3Necte/UkDwvvuYsVQgjRp6Rn5ZG2ao9LKXtnKsDoYLB+rwUcjaMnW47VsrUkGh/Fxk/PCSQ6rtVnTd1JiEgGH3NPvow+QUZQWvHRK/w8UWsKuKLwR9gOf6gt7+oA6dUjhBD9V1OH4tZ9dpypANu+g9qT4Bvp3PZiRgUA10R+Q3TcJNcT2srBGNgvytp7IgGKB9eOsBLh5+CELZqP80agL9ncoeOkV48QQvRPbXUodqYCrCnCrg9xjp7sOFHPxpPRGGjg5+cYtJIWLdXmQ+BwMEXSH0mA4oHJoHJ7YyC7vPDHDCn/AGh7FMUSLL16hBCiv2qvQ7EK5FXpySyNcj72fxllAFwZsZm4+CTXAxqqQeejJcf2UxKgeLE4Ecy+Dg7VD+RwXTTnB37b5v6LkgZJrx4hhOinOjrFX1itfexmFTSwNt+CDjtLJtk9jJ7kQWC8Vpytn5IAxYtAH7h1gvbnFwuvZWnUu7TumdDSkIiAnrkwIYQQfU5Hp/ijGlcKv/RNMQCXhWUydMQ0153sddr/zWOd00H9Uf995R1wy3gw6R38UBtPuT2QqQFZXveV/BMhhOi/2upQrGmsCBsLB4rtrD6h1Tu5Y2IV6Iyuu9bkQsAgrTFgPyYBShtCTHDLeO3H7a+F13FH5Dtu+2hliB0kDQ7u6csTQgjRR7TsUOw5SFGoaYA1OfDSpiJUdKSEZDJy1HmuuzlsoDaAeVy/aQrojQQorSk6rXKOqiXF3j5ZxUfnYFfNSBowMNl/b/OuTWWIz8lDX324N65WCCFEH5GSGMPyGyZj9jd63G6thSWrVVYebRw9GV8G+laj77X54D8QAod078WeASRAac1/APiGQr1WCyXcD26ZoMXDzxcuYmnku85dLYGwfL5KSnwdlH0PjoZeuWQhhBB9w9wECyaD549WFYVYYxEOdMwK/pbEhGTXHRwNYK+GkHHu0z79kFSSbc0YrCUmFW5o7JWgcPskldd3wc7q0fjoGnjtwv34moeTFAt6HWCPgeojUJkDwSN6+xUIIYToJZk5JeSX13nZqpJv00rcXzc0HwwTsDsgMxcKqyHKYCVpgAV9YHzPXXAfJiMongSPAqMZ6ksBiPTXlh0DPF+wiAvU90ge2BicgNbxWDFA2XcyiiKEEP1YvrXG67ZY40ns6DkvYCeOiPNIz4YZbygs+ljH3Z/rWPRpJDPeiSB9b2kPXnHfJQGKJz6hYB6t9UBo9PNJKj56lW3VY8k4WgVVh12P8YuFqqNQeahnr1UIIUSfkJ6Vx5P/2+tlq0qBTevVNsQ3lwPlQSxZrZBX6bpXfoVdK4uflde9F3sGkADFm+AxWg+EeisA0YGwqLGg3wsFi+Do+67763xA59s4imLr4YsVQgjRXdrsTtyoqQ9PSVW9x3M0jZ4kB3zHjobzeCuraZmF65ofZ1n8VXs8Pk9/Ijko3pgiIWgUlGx3dpH8xRSVt3fD5qrxbMl5i6mDjmpr1Zv4xWgjK5WH+m1zJyGEOJu02Z04Uavy2lYfHo1KoU1rhTLU9zjWsHF8crCtiimQZ60lM6eE5GHhXfNCzkAygtIW8xgw+IFN6zYZEwg/bhpFKbwOjr7nur/OqI2ilH4Hds9RtBBCiDNDu92JG6dh2uvDE2MoogEDUwO+J2pQcpvBSUsdLZ9/tpIApS2maAgcjr06n4zjsHI/TI1VMepUNlVOJPNwMVQfc+5ud0BGSSwrs8rI2J3V74fnhBDiTNWh7sSN0zBtBxIqJxtCAfjxoMO8czC0w9fQ3yuUyxRPWxSF9LwBpP2vlrzq5ljO36Bic8Bz+dfz9pH3YMz9pGdD2gaFvEofYACQR0xwCamXj3UOAwohhDgzdKg7ceM0TFuBhMVYRL4tknP9s6gPSSZvb8dGT2LMJpLiwzp72WeVTo+gfP311yxYsIDY2FgUReHjjz922X7LLbegKIrLV0pKiss+JSUlLF68mODgYEJCQrjtttuorGyVytwHpGflseT9I+RVu8Zx1Q1aFdmMqglszilhww/HPWdjl9ex5M0dfLorr90EKyGEEH1Hh7sTV9RqfXiCfZzVxZupFNm0EZNJQTn4BXY84EhdkIBe17Fg5mzV6RGUqqoqJkyYwE9+8hOuuuoqj/ukpKTw6quvOr/39fV12b548WLy8vJYs2YNNpuNW2+9lZ/97Ge89dZbnb2cbtN20pOC2rjluYLruVV9D5X78ZaNfcfbO2gZk7ROsBJCCNG3dLg7cZBJ68Mzy4cl/61r/HTQPguiDcUUNERwrn8W08ZPw6+DTe/vnTNCPh84hRGU+fPn87vf/Y4rr7zS6z6+vr5YLBbnV2ho85zb3r17SU9P5x//+AdTp05lxowZ/PWvf+Wdd94hNzf31F5FN2hveA8UFFS2VI0jkFKG+p7wumfrAZPWCVZCCCH6lva6Eyu0mIapLyUlaj/L55RjCWzaQ6WoIQSAG4Yc5KJR4STFQkyg6mGkpVmM2cQdF0lFcuimJNmvvvqKqKgoRo0axZIlSyguLnZuy8jIICQkhHPOOcf52Jw5c9DpdGzZssXj+erq6igvL3f56m4dGd5ripJfaNWjp/3jNLLOXQgh+qa2uhM3fe+chinbA/VlpIwKZONNKm9f4eDCmCLsGDgvcBcLp09vPCekzmyqfqK6nVNBpnZa6vIAJSUlhTfeeIO1a9fy1FNPsX79eubPn4/dbgcgPz+fqKgol2MMBgNhYWHk5+d7POeyZcswm83Or7i4uK6+bDcdHd4zKA4yqxKJNJYy1Pd4h8/fMsFKCCFE39PUndhidv08sJhNLL9hsjYNU1cM1ixt1aeioNfBgECVDflavsm9Y3PAt7mWScowWD63Bou/3fs5BdANq3iuu+4655/HjRvH+PHjGTZsGF999RWzZ88+pXM+8sgj3Hfffc7vy8vLuz1IaRrey7fWehyMU1CxBMKcIQr/ytKqy94Z+Tb3Hn+wU8/T39e5CyFEX5aSGMPcBAuZOSUUVtQSFaRN6zhHOcqywFautTtp9NdvSmlQI5gZ9C3njp/ufs7YY8y9bSyZtVMorKhzP6cAemCZ8dChQ4mIiODgwYPMnj0bi8VCYWGhyz4NDQ2UlJRgsVg8nsPX19ct0ba7NQ3vLXlzBwq4BClNQ3OpM1UmRcM7e7QePXdGvcNw36McrBvk8Zye9Pd17kII0dfpdYpLRdem0veFJYVE1WSTFGtB37jtcKnKh4e0vMt7xx4F3wmuJ2uoBJ0P+tBEkv0jeugVnJm6vVDb8ePHKS4uJiZGG7ZKTk6mrKyM7du3O/dZt24dDoeDqVOndvfldIrX4T3/BpbPs5EyTOvRc8M4Lep9rnAxd0e97dxPp6jgdR2QrHMXQogzTXpWHjOeWseilzdz9weHWPRpNDPeCSU9W9v+wjel2NFzYfB2Jo+f4X6CmnwIGu4y4iI86/QISmVlJQcPHnR+n5OTw86dOwkLCyMsLIy0tDSuvvpqLBYL2dnZPPTQQwwfPpx58+YBMGbMGFJSUrj99ttZsWIFNpuNO+64g+uuu47Y2L73D+Y2vBdoIMnwNfq6QkAbKfnlFJV3dqvsrB6Nf9S7vHphNiZzPKW1sDRdG39RW6RZuSVYCSGE6POaSt+3vu3Mr4QlqxVSZzj4OEe76bwn8Rj4THLdsaEKdAYISQRF3vvb0+kRlG3btjFp0iQmTdL+4u+77z4mTZrEY489hl6vZ9euXVx++eWMHDmS2267jSlTprBhwwaXKZp///vfjB49mtmzZ3PJJZcwY8YM/v73v3fdq+piTcN7CycOIHl4NPqw8WCvdXYtjvSHW8ZrP2zP5t/ABerbJA+ES4bD8vlqi2VnGkmGEkKIM0vbpe+19/9XtpbiQMec4K1MSDzffceaPAgcDn4DuvdizxKKqqpn3DrX8vJyzGYzVquV4ODgnr8Ahw2OfQi1Rc5uxmW1MPN1qLDpeGnQMi658EcQNAzQevRk5qoUFucRFT2cpMkXyciJEEKcQTKyi1n08uY29nDQdM//yfSPSZx0uevmhmqoLYC4KyGg+1ei9lWd+fyWZoGnQmeEkAkuoyghJritcTTvzwWLsR9uzkXR6yB5oMLCMf4km/c3Tg8JIYQ4U7S34jLKUArAfPM3JCbOct+hNle7afWX0ZOOkgDlVAUOhYCBUNtcu+UnEyDE187BukH895A/lO93PcYnBGxVUPYdnHkDV0II0W+1teJSwU5hQzg67CweUQTGViMDDdWADkLGgSIfux0lf1OnSu+jjaI0VDtHUYJ94eeTtambvxRcjy3nbffj/AZA+T6o8V4aXwghRN+iNQT09VimPsJgBeCykI0kT57lfnBtXuPoycBuvsqziwQopyNwqDaX2GIU5ebxEGGyc6Q+lg8OhYN1t+sxxkAtoCndCaqjZ69XCCFEhzTVOmnqQg+QOicEcC1Tr6eBkw1hGBUbVw+vQO/TalWEvUb7v4yedJr8bZ0OD6Mo/kb45bnaKMrzhYuozX7bfTrHfyBUHISqwz18wUIIIdrjUuvknZ0senkzM/64FipzWH7RSZeVmaGGCgB+FPYVF5x7ofvJanK1uif+/Tcx9lRJgHK6AodqSU8tRlGuGwPhJjt5tkjezInHXrLD9Ri9H6CDkp3gaOjRyxVCCOFdU62T1t3s88vrWPK5HxhDnQ0BfzHJRlFDKL5KHfec09D43t5CQzWgyOjJKZK/sdOl94HQidownsNGejbMfkuhuFYrfPxS4TV8t+190g+2HkUZAFU5UJnd89cshBDCTdu1TjRpmwxsPgEFVbD2QBUAN0WtI3qYh9ETZ+6JjJ6cim7vxdMvBA4Dv1jSf7CyZF2k8wdZh50Su5mvyyew75sMUM4jZVjTRh/QmaBkBwQMAX3P9hoSQgjhKjOnxG3kpCUVhbxKWLxSwUg9NkII0FVz4VC99p7eknPlzngZPTlF8rfWFfQ+2M0TSdsc2hicaDkojsb2US+fvJLbIj7myQ0O7C3zYv1iofoEWH/o6SsWQgjRSme6y/vr6wC4Nuxzbtk8y9mLx8lZ90RW7pwqCVC6SGZRKHnVRsC1QqwOO1UOf1aXz2CacT2ZuS03GrT18mU7wVbZk5crhBCilY52lzcptVjtQYTprRTaQrGpRtI2KM03oA3VgF5yT06T/M11kfxKu8fHm0ZR/lV8CYvCVlNQaXPdwRStlT9uvRxZCCFEj0qKDyPGbKK9RiQGRXu/vyb0cz61zmic+lGab0BrTsjoSReQAKWLlFTWed2m4KBe9eH9krlEWT9vtVEHvlFQtgvqSrr5KoUQQnij1ymkLkgAWo+FNwvQVVPpCGCAsYB9tYOdN6EAhdVooyeKQXJPuoD87XWRsAAfr9vUxr/m90vnEFKxvrlwTxOfMKgv04IUIYQQvSYlMYblN0zGEuR5DYlD1d7Prwpdx5eV57psi/Knse7JCBk96QISoHQRi9mvze0KDhzoeSH3Sji+stVGRUuYte6G6lzPJxBCCNEjUhIi2XhDNW/PO87zFzv490IHlgAVs66CGtXESN8jbK4cR/M4i0qISSUpqlLLLQwdp72vi9MiAUoXaZq79EZFQUElvXw6O/ZlQb3VdQdjMNjroPQ7KYEvhBC9qeIg+upDJA8NZ+FImB4H9yapVKvae3yKeRNbqxNdDimrhTX7yyFopNZzTZw2CVC6SNPcpeeYWUUBkgdoi5D/eOJ61KPvu+/mNwAq9ksJfCGE6C32Wij9FvT+LvWpvjtRgU01MsV/D19Yp7Y6SEEB0rZasJtl9KSrSIDShZrmLluPpMQEwvL5Ks/OBV+9g8yqRNbtK4TaQtcTGPwBBUq+dfb2EUII0YOse6H6OPjFOB/KLoV39wcBMD1wJ3vqhrkdpqKQV2UgM997PqLoHKkk28VSEmOYm2Ah89BJCo9uJkrJJ2lYDPrGUPDWCbBiBzyVeyOzct5CP+Ye1xP4D4DKHCjfDyFje/z6hRCi36q3aqMnPqGgNK/OefrrcuyEcFFQJivLZrV5isIK7ys6RefICEo30OsUkodHsTBpPMkx1egd1c5tS6aA2cfO/rrBfLBP7z6do/MBY5D2S9JQ1bMXLoQQ/VnZLqgr0ko/NNqeq/LZsRB02BljOsSR+tg2T9HRYm+ifRKgdKeAQdpys5rmlTlmX7jjXG1+8s8Fi6k9+Lb7caZoqMmDMineJoQQPaKmAKxZYLI4c0hUFf6wXqvy/ePwL/mybh6Kx1aC2nqeGLOJpPiwnrris54EKN1J0UHoBG3ZWUNzKfsbx8GAgAbybRG8eiAWyrJaHacH30go+w7qinv4ooUQop9RVSjdCbZqbXqn0WfZdrYXmzEptdw3uYK7ppsB3IKUppTY1AUJ6HWSINtVJEDpbn4DtGVnLUZRTAa4L1n7q3+p8MeU7n9X+wVpySescT70O/dtQgghuk7VYSj/QcsBbGSzw9MbtXyS26PTiR5+MSnDtAUPlkDXwy3BPiy/YTIpiTGIriNJst1NUSB0PFQeBFu5Vu8EuGIk/OPbBvYWB/LCoSRSh2yEqJmux/nFgnUPBI+UqoRCCNEdHDYo2Q4oYAhwPvxuVj2HKgMJ01v52bl+oNeKcaYMg7nxKpm5DgqLc4mKGUvSxBkyctINZASlJ/jFQNBoqM1zPqTXwW9maH/9/yq6lJwf0t2XFhuDQLVByQ5weG5GKIQQ4jSUN9aeanETWFUPf8nURq5/GfspX9ZeSMZxnN2K9TpIjjjJwtE+JI+bIMFJN5EApaeEjgdDINSXOh+aEQezBtlpwMDTRy6D3E+xOyDjOKzcr/3f7hsHFQehMrsXL14IIc4udodKxv7jrMzcRcbJCOwYndv+tq2Wojo/BvvksqVsCHet8WHRxzpmvKGQng2odqgvgZAJzlFx0fVkiqenmCLBnABFW8AY4swSf2S6wtdHVVZbp5ORlcpj6+ZwoDzIeVhMoInUpFBS/LaDfxwY2u75I4QQom3pWXmkrdpDnrUW0AKMmECV1JkqE6Lhbzu1YOWa0M95puBm53H5lbBktcLy2eWkDIsG8+jeuPx+Q0ZQuondoZKRXczKnSfIyC7G7lAhZBz4hGiRd6NR4XBtgjaU+FTuIq7y+4/LefIrYcm6SNL3lmnNBIUQQpyy9Kw8lry5ozE4adYUfDyQXkWdw8i5/rv5onwqtGhgojb+OS0jmPrgCWQcqXV9jxddSkZQuoFrdK6JMZtIXZBAimU8FK5vrFSoxYd3nQvv7bWzs3o0N4d/QqyxkFybViioqclg2rYBzB22E33gUPCVdfZCCNFZdodK2qo9HiuZaMGHyqZ8bQT7wqCtPF1wi8f98qqNTFteQEnVcefjzvd4WcnTZWQEpYt5jc6ttSx5cwfpx6PAFOXSh+ewFeyq9k/xbP4N3Bv9b5djtR4PejKP12t9emTZsRBCdFpmTonbe3NLZr1Wr2qBeT3vlM5r81wlVa6LGpzv8Vl5Xo4QnSUBShdqOzrXpK0+hD14PNhKtUQroLAaQMFAA8dtFkrtwYz32+92jkJ7JJTvgepj3fUShBDirFVY4T04UbBjtQfho9Qz2CeXo/WdGwlxvsev2iPTPV1EApQu1F50rgJ51loySyxajZOafACi/LXtDY0zbn8tuI67ot+GVqFORKBJC2pKtku3YyGE6KS2+uQE6rT37hvCPuWTqku9lrRvi/M9Pqek3X1F+yRA6UJtRecu+1WrEDoJ7JXgsJEUq2WQg4oBGxWOAL4sP5eU4G9cjrv/C4X0vMFQcUhbuy+EEKLDkgboiQmwuwUfRqWeCkcAEYZSTD56HjpfKxXrHqR0LGjp6GeBaJsEKF2oo10so4JMWhNB/0FQk4teB6kztRStplGUt0vmcU3Y5/gozSMlBVWw5DMj6ScitFEUW6WXZxBCCNGa3vodqedobUdaBh/6xj/fFP4JEyZczCXDPZe0D/Pv2LoS6WjcNSRA6UJJ8WHEmE14qyno0u1S76ONoqg2sNc193gIAD12HOj5Z9EV3Bi2ynm8c4nblnDs1flanx4hhBDtqz4BZVmkjA5yCT78ddXUqr6MMh3mvFGDmTdcq4GSMgw23qTy9hUOnp95grev1rP5kbkdf48Xp00ClC6k1ymkLkgAcPsB9tjtMnAoBA6DGm2pWsoweHaOih09OhxsrJzExIADhOqtzvOoKORVKmSWDYSyXVAjGeNCCNEmRwOUbAO1HozBzuDjT7Md1Dm00Y5Hh3/OOeOmuxym10FyVBkLR9pJTpyEj1Hfufd4cVokQOliKYkxLL9hMhaz6xCfxWxy73ap00PoREAHDdp0TVGNtqmx5QPP5S9madS7bs9TWB8E9prGhFnp0yOEEF5VHICKbPCLcz6k18GqvdXY0TEneDMzp8xyVvh2UlWozQfzWPCLBjr5Hi9OixRq6wYpiTHMTbCQmVNCYUUtUUHakJ/HqNo/TiuXXLoLgkc5V/SADiM2DtUPREXHcN+jHKwb5Dwsyr/x2PL9Wj5L8KieeGlCCHFmaajSbuT0/qD3dT78ZY7K+txAjIqN3yTuhaCb3Y+tK9KKaoaMc3m4U+/x4pRJgNJN9DqF5GHh7e+oKFrDqcpsqC8lKTaUEJNKWS3YGptX/bXwOpYN+CtLjz4MQKgJkmIBnUlrAV68VevE2aJVuBBCCKBkJ9TkQtBI50M2Ozz5dS0QwK0RnxI/doH7caoD6osh6gItSGmlw+/x4pTJFE9f4BcN5kSoLXCrEmtUbJTbA/mmcgIXBW0FWi1084vR8lDKvu+56xVCiDNBTZ6Wq2eygKJ3PvzGdw0cqgggXF/GHec0eG4fUlugVf0OGduDFyxakgClrwgZD75hZB6xUlar0JRyZVO1UZS3SlK4Liwdo9JAWa1CZm7jcYoefKO0FT01Bb1z7UII0dc4GrTRZXutywhISQ08v1W7zXsg7mOC4y/1cKwNbBUQNkVGpnuRBCh9hY8ZQiZSWFHltklPAyo6Xj55NTc3LjvWyuM38g1rnGfdJgmzQggBjYmxB7RcvRae2VRHuc2XMaZDXHPuUND5uB9bkwsBcS7TQqLnSYDSl5jHEBUS4vawHQN67GytHstwv2NEGEpbJNM28o+D8n3aL6QQQvRntgoozgRDoEti7PeF8M4P2uqbx0d8hj5quvux9lpQGyBsslavSvQaCVD6EoM/SQnjiPG3uZVYtjdO+fylYDEPxb6tJcm2pG9MmC3ZJhVmhRD9W+nOxhwSi/Mhhwqp62pQUbg8ZD1Tp8xxLiu2OyDjOKzcDxmHirEHDNfqVIleJQFKH6M3jyR1pvZn1yBFh49ST74tgiO14eirst0P9ovRhiZLd/bEpQohRLexO1QysotZufMEGdnFHe8QXH2iMTE2FpTmj7iPfnCwoygAf10Nv55wSCuSCaRnw4w3FBZ9rOPuz3Us+iyOGf/yIX235PT1NglQ+hqdkZRzJ7D8wnwsAa6/kAG+WsLsyyev4kjWf9xW/KDowRSj/XJWn+ipKxZCiC6VnpXHjKfWsejlzdz9zk4WvbyZGU+tIz2rncrZDpuWGOuo1/L6GlXUw7KNDQDcafkIy+grtefJhiWrFfJaDTrnl9tY8uaO9p9PdCsJUPqigMGkjItj45X7tT4QFzt4+woHW29VmTmgnnrVyJP7L4LCr9yP9QkBR13jL6nNfbsQQvRh6Vl5LHlzB3lW147A+dba9oMG616oPKg1Ym3hhc31FNWZiPc5wU/ONYMxGLsD0jY0jVO7FlhruvVLW7Wn4yM3ostJgNIXKToInYje15/kqFIWjoTkgWDQQ+oFBgyKgy8qprJ2x7fQUO1+vF8cVBzUkmaFEOIMYXeopK3ag6eQoN2gob5Uy8EzmF1W5hwsgVe/10afHxv6Mb4DLwYgMxfyKptLOnh6vjxrLZk5Jaf+gsRpkQClr/KLBvN4rQ+E6nA+PDwMbpugff/4sRuoPfSe+7F6XzAGa7+s9WU9dMFCCHF6MnNK3EZOWvIaNKgqFG+DumIwRbs8nPZVLQ2qnjlBW7jwnJnOgm2FHu7tPCms8H49ontJgNKXhY4D3wioLXR5+M4kHRa/eo7VW1jxnQmqjrofa4qG2pNQvN09V0UIIfqgjgYDbvtVHgLrHq3lR4uGf6sPqmzI9cdHqee3iTshJNG5za1UgxdRQab2dxLdQgKUvswYDKGTwVamVUVsFOgDj56vtVF6qfBHHP3+PQ8Jszrtl9WaBVU5PXjRQghxajoaDLjs11Cj1TxR9Frdk0aV9fDE11oe3pKojxg89gqXcyTFQkyg6lbSoaUYs9YEUPQOCVD6OvMYCBikLR9u4dLhMD22jnrVh7R9s6Bok/uxhkDtl7Zoi/ZLLIQQfVhSfBgxZpOXrBAtW8QtaCjbBdXHtBuyFl7YYiO/xsQgnzyWnGMAU6TLdr0OUs+rcZ7XkxqbnTV78k/txYjTJgFKX6f31fpBqDaXhFhFgbQLjRgVO2srkvhi+3awewhC/Adqv7xl3/XgRQshROfpdQqpCxIA96Ch6fvUBQnodY3f1eRD6bfgG+3SDHBfMfxzlzbKnBb/H0yDL/P4fCkxR1h+qRGzv9Hjdmu1LDfuTRKgnAkCh2o9IWqOuzw8PBRum9iYMHtkEbWH/uN+rKLXqimWfqt19hRCiD4sJTGG5TdMxmJ2ne6xmE0sv2EyKYkx2gMOmza101Dt0o1YVeG367TE2IuDM7jwnOmg8xCA1BWDIZi5UyZjMnj+KJTlxr3L0NsXIDpA0Wl9IaqPaEvpWnTmvPNcPSv31XG82sKL3/rxQOwRCBjserxPKFQUa7/MsZd4/mUVQog+IiUxhrkJFjJzSiisqCUqSJvWcY6cAJTtgYr9EBDvcuxH+1QyC/wxKbU8lvgthP7C/QlUO9QVQtQFZObpyC+v83otLVcOJQ8L76JXKDqi0yMoX3/9NQsWLCA2NhZFUfj4449dtquqymOPPUZMTAx+fn7MmTOHAwdcG9iVlJSwePFigoODCQkJ4bbbbqOyUvrHtMnP4nHZcYAPpF6gBRx/O3klB7/7wPOqnYBBWiPBsj09dcVCCHHK9DqF5GHhLJw4gORh4a7BSV0xlGwFY4hLzRNrHfxhQ1PF2A8YOPbHnk9ekw9+sRCSeOorh0S363SAUlVVxYQJE/i///s/j9uffvppXnjhBVasWMGWLVsICAhg3rx51NY2/+MuXryY3bt3s2bNGj755BO+/vprfvazn536q+gvQsc3Lh927RExbyjMjqvDphr5zb55qAVfuh+r89F+mUu2ar/cQghxJlIdWqXs+jLwjXLZ9KdNNorqfBnqe4zbz/UDXw8jHvY6sFdro9KGgFNbOSR6RKcDlPnz5/O73/2OK6+80m2bqqr85S9/4dFHH2XhwoWMHz+eN954g9zcXOdIy969e0lPT+cf//gHU6dOZcaMGfz1r3/lnXfeITc31+2cogVjkJYw21DuUsZeUeCxC4z46hrYUjWO9zMPYK+rcD/eN0pbslyUCQ57z123EEJ0lfL9UL4X/ONcap7syIc392ijKb8b+gE+Az0nxlJzvDmvj1NcOSR6RJcmyebk5JCfn8+cOXOcj5nNZqZOnUpGRgYAGRkZhISEcM455zj3mTNnDjqdji1btng8b11dHeXl5S5f/VbwKAgYAtXNCbPp2XDdxwo2h/Yr9scT1/NW+vukt254rChaj4ryvdrcrRBCnEls5Vounc4EhuZKazY7/HptPSoKV4WuxRF9ERm5BuwOD8crRgg/B3RaCmanVw6JHtOlAUp+vrZePDo62uXx6Oho57b8/HyiolyH5QwGA2FhYc59Wlu2bBlms9n5FRcX15WXfWbRGSGsMbhrqOTTA/CLxm6cDvT4KbWU2M1kVcax4qsD7kGK3g8MAdoveb21xy9fCCFOiapqlbFrG/NHWnh1p4MfSk2E6MtJNB3khq/Gs+hjHTPeUJrfA1VVW8kYMhb8Brgc3+GVQ6JHnRGreB555BHuu+8+5/fl5eX9O0gJGAzmMXz67SHu2BBEy7i/RtV+wd4tncfTA5/jdxvuZG68Dn3LUNRk0UZQireC5SJtlZAQQvRllYe0omx+cS7vWcfK4dnGwfe7ot7mr4XXObflV8KS1QrL56ukxBZoy5FDJ7lMDTXp0Moh0aO69JPJYrEAUFDgmsRZUFDg3GaxWCgsdO0t09DQQElJiXOf1nx9fQkODnb56tcUhfT8Ifzy6wE4VPdfHl9FWzL3j5NXMcf3EzJbp/YoOm3+1poFFa2HWIQQovvZHSoZ2cWs3HmCjOzituuM2CqhaDMoBjA2l7PXap7UU+cwkBTwPbtrhlFqNzdvb7x5S9ugYK+zaq1DfMxup2/S5soh0eO6NECJj4/HYrGwdu1a52Pl5eVs2bKF5ORkAJKTkykrK2P79u3OfdatW4fD4WDq1KldeTlnLbtDJS39KN4KNNepvvgq9eyvG0ywvpqKikL3nQwB2sqe4i1g85BQK4QQ3SQ9K48ZT61j0cubufudnSx6eTMznlrnuWKrqmIv2kZGTikrjw8k4zjO3JLVB1W+Om7CqNi4NvRzPiib7X44CnmVCpkV8WBO6OZXJrpSp6d4KisrOXjwoPP7nJwcdu7cSVhYGIMGDeKee+7hd7/7HSNGjCA+Pp7f/va3xMbGcsUVVwAwZswYUlJSuP3221mxYgU2m4077riD6667jtjYWC/PKlpqryU5QJ2q1UZZcfLHvFu0AtRfug1r2n0HkJl9nMIjm4mKm0RSvNwxCCG6V3pWHkve3OHWoi/fWsuSN3e45Xykb99F2qdW8qqbC7LFBKo8NE3lj5saAD0/i/iQl05eg/euOlCoDAO9j9ftou/pdICybds2LrzwQuf3TbkhN998M6+99hoPPfQQVVVV/OxnP6OsrIwZM2aQnp6OydScfPTvf/+bO+64g9mzZ6PT6bj66qt54YUXuuDl9A8dKxik4KfUUKP6sezgLP49chPG6BnOrenZkLZBT17lEKAe2EKM2UTqggRJCBNCdAu7QyVt1R6P/YNVtPAibdUe5iZY0OsU0r87zJL/HENF77JvfiU89IUdG74M8clFrzSQXdd2XmJU5MA2t4u+R1FVT2VH+7by8nLMZjNWq7Vf5qNkZBez6OXNHdrXQAMNGPhNzCvEj/8xc0YEkp6tJY5p//DNdxxNf5KsdSFEd+joe9fbt08jaUgoM5alk1fpoK2RkbdHP80jJ+7iSIWvM+ekJQUVS7AvGx+eIyPEfUBnPr9l+cYZqL3CQhq1xX/hhYJrOfDdB3x6QEsYax2ctNxXGmMJIbpDZ8rKZ+7dS15l07iKq6aFAIvC0gkefDEPz9CmbpRWYzNK47hM6uWJLsFJpxJ0Ra85I5YZC1dNhYWWvLkDBVr9SjZ9p/0y2jEQoKumwhHI9zUj2Jq5l7zKsV7PLY2xhBDdpcNl5f1VCo/sAfzdtumwU6f6EmUoZpQph4PqxSwcBsvnq6Rt0GpCNbEEqqRePsE1pyUrj7RVe1zy+GR6u2+SEZQzlLfCQlpg4nrHUeXwR4eDT60zuMDva3yV+nbPL42xhBBdrcNl5YMOEqX3sPrQuRc8EP0vniu4gajGGCZlGGy8SeXtKxw8P7uat+edYONdiaSMb85NaUrQbb3IoClB1+MqItFrJEA5g6UkxrDxVxfx9u3TeP66idwx3fuIh0HROnz+X+E13BbxUbvnjgqSbHchRNfqUFn5OeHorbtIGhxKTKDqMm3jq9ThQMd88ybWV07B3y+QpBaLP/U6SB6gsnDAYZJHD0MfNMS5rb0EXZDp7b5GApQzXMvCQtMThnvdr171IUBXTWFDOAUN4SSYDnncT0Elxt9GUrh0PBZCdL02y8pfl0BKRBYoevS+QaTObMqWUwEHdaovQbpKZgdt4VPrdFJnqq5VsgHqCrWKseGTXUortFeeoeX0tugbJAflLJIUH05MsA/55XUes9mrHH4oqHxQOofHY1bwu7yf0tDiR6DpTiV1mhV9yRbwt4BPSE9dvhCin/BYVn5ICPrCr6A0F4JGafs15pb8dr1CSbWKHbjf8i/eqLiR5fO17S4cNq3HmGU2+IS6bOpMgq7oG2QE5Syi12nZ6qB4zGZXgNmDtF++l4uuYknM/1z2CfODWyeoBAWGsimnipWbMsg4WChDnkKILudWVr4qG6zfa204WvTamRsPgwLrsaNnZuAOZo4cyEeLw92DE4DqoxAUrzUEbKXDCbod3E90PxlBOcukJMaw/PrxpK38jryq5sctgZA6U+X8Qb7Me7OaY1VRlNp8+OjS43xyPJaP9ikU1yj88zuFf34HMBhwAFslw10I0b3qy6AoA3S+YAh02fT6Lthe6EuArpplYz5j4NgHPZdFqbdq3d7Dk7T/t9KUoJtvrfWYh6KgTTMlxYd1xSsSXUBGUM5CKePj2HjPON5OyeP52VW8fYWDjTeppAwDfyP8cbYvAG8Wzafo4P949TuVkjZGNSXDXQjRbRx2rRFg7Unwc213crgMns7QwolHYt9g4PgbPXdfV+1Qmwsh48Hfc8XYDiXoLkiQYm59iAQoZyl90GCSE0Zq2ewD7C6JZNMHKSwapQ2vPJlzOdeEfU5blRolw10I0W3KsqBsNwQMdgk+HCo89EUDtXY95wV+x/VTot0CGKeaPG1b6KQ2n6rNBF2poN3nyBTP2Sx0MlQd1X55W91VPHK+H2sP13C0LoYZ7CTOJ59j9Ravp5ICbkKILldTACWZWjK+3jVoePN7yMz3wV9Xw1Oj/4du4IOez2GvAUcthF8ExkDP+7TgMUE3PkxGTvogGUE5mxkDIfxc7Ze3odplU7Av/GisVuvkrZL53BS+CgVHu6eUDHchRJew10HRN2CrAFOUy6ajVvjjJu396Fcx/yJu/A2g6D2dBaqPQdBoCBrR4ad2S9CV4KRPkgDlbBc0AoLHQM0xaNUXcuYghQCdFri8VrSQa0M/a/d0Uf4yxSOE6AKl30LFQQgY4vKw3QEPrGmg2m5gasD33Dgl1GteCbUnwRgM4ed4zk0RZzT5Fz3bKTptFMUYAnUnXTYlxUKgnx+BuipO2KJowMAgH8+JsFoBt3qSgg64BTpCCNEpVUegZDuYot1W3Pxzpza1E6Cr5k+jPkIXd4XnczhsUF8CYeeAKbLbL1n0PAlQ+gPfcAibAvWl2i91I70O0s5XqXKYUHDwn9K5LApb7TbV4yzgNr0BvfU7qNjfo5cvhDiL2CqgcJO2eqdVMbX9xfDMZu395tHY14ibcFMbUztHIWgomL03PxVnNglQ+gvzWO2Xufqoy8NapUaFSN/mqZ7rWk31WAK1ao4po0ygM2n1CuqkHLQQopOalhTXnICAQS6bbHa473M79Q49s4K2cd2UaLd9nOpLtZop4VNBL33Dzlayiqe/0Ptov8w1BVBfit0QSmYuFFZDlD98caM/l7xVyfHqcCrVAD6cf5Rj9oFE+WtTQc5lyn6xULlfS26LmeexIJIQQnhk3Q1l34P/ILeRkf/bppJVbMSsr+Cp0ekoA3/l+RyqHWrzIXIG+A/ogYsWvUUClP7EfwCETSJ9607StoWRV9WcuR4TqHLTeD/+tNnOqrLzmXPwDRbOvQ50rX5EFAX8h4D1B/CNgogk5ya7Q5Wle0IIz2ryoXiLltRq8HfZ9H0hvLhNe694YuA/iB5/a9urdvwHtVvzRJz5JEDpZ9JzY1myvsit1HN+JTy9WcflQ6tZeSiA3x66inP3/4/Y0QvdT6L3Bd9IKNmqLQ8MHEJ6Vh5pq/a4dAuVEvlCCADstXByE9gqIci163qNDe75zE6DauRS8wYunzwC/NzfM+wOyDxWTaE1gKhBiSTpTHgJYcRZQnJQ+hG7QyXtfwca2wa6jmw0dT/eUuDPhLByyu2BPLg5Hkf5Ac8n8w0D1QEnN5G+8xBL3tzh1spcSuQLIVBVKN4KldlatdhWlm1SybYaiTIU82TCBpTY+W77pGfDjNcVFq0K5O6vo1n05hFmPLVO3lvOchKg9COZOSVuQURLKgr5VQo3Tw7ET1fPpsqJvPrVd1pBJU/8B2GvyiXtk70em29JiXwhBBX7oWQH+A1wy1n78jC8kaWNgzwz+G+Ejb1Nm0ZuIT0blqxWXJqfgtwA9QcSoPQjHa0Cq9fBb6Y3APDUsSvY+90qMo7Dyv2QcVwbagVA0ZFZHk9epfdztSyRL4ToZ2qLtKkdna+We9JCUTU8+IX2ZnJL+H+5YMp5bvVM7A5I29BU6KD1qK9GboDOXpKD0o9EBZna3wltVc/lI0yszS7jy9wQ7ttxDmH679hUpSWlxQSqpM7UuiMX1vp26JxSIl+IfsZeByc3aEuCA13L0KsqPLzOQVGtgZG+R3h4XDZE3e12isxcyKtsu5Gp9Ag7e8kISj+SFB9GjNnktW+xgkpMoEpSrDbKmjI6GH9dDXtrhzLIN59QvRXQEmqXrFZIz9aCmY7oaHAkhDgLqCoUZzaWso93m7Z5Zw98cdiAj2LjL8P/gWn0bR5PU1jt8WH3/eQG6KwkAUo/otcppC5I8Jgv4qwWO1NFr9OGVv+SqWBzaD8ib5fM58bw/wGqM6E2bYPCFIs2oqJ4PKs2KBtj1pYcCyH6CWfeSaxb3smhUnjia+394kHLGyRM+hEYPHchjvL1kv/Wej+5ATorSYDSD4X4uxdXM/vYWT63hpRh2vdNQ6s2fJ0jJ2+VzOeKkC8BLaE2r1Jhe74W1ABuQUrTPVPqggSphyJEf1F7Uss70Zvc8k7q7HBnuoMau57zAr/jtolAyDjP51EdJJlziAlsnX3STG6Azm4SoPQj6Vl5LHlzB2XVNrdt1noD1BdrVRpxHVottZsJ1VspagiluCGEoT7HnNsKq5vK5atYWt0EWcwmlt8wWeqgCNFfNNQ0552Y3H/vn/oGdhcbCNVbeW7Ue+jib/B+rpo89P5RpF42GnAPUuQG6OwnSbL9hN2hkrZqj5eJGE3atgFcNOgo2ysGcaDVoptSexBGxcaGysn8NOJDjhVbsKlGZw5KyjCYG6+SmatSWHqSqGB/kqach94U6v5EQoizj+rQ+uxUHITA4W55J+sOwz+/0+6J/zToRaIn/Mx7q4yGKrDXgOVCUoYOY7nB360QpEUKQZ71JEDpJ9qvgQJ5VTqmvTeQkjpdqy0KoMNXqcamGnmjeAE3hX/Cp7VXkBTbvKdeB8kDgQHhUHEAijeB5WJp5iVEf1CWBaXfgn+cW+BRUAkPrHEAOm6NWMnsyVO0/TxRHVB1FMImQ5C2+iclMYa5CRZppdHPSIDST3Q0y72kztOPhBakVDoCiTSUcLIhjHXlSTw9dQd6nYd+GIoOAoaAdS8YQyHyPOwq8uYixNmq+rjW5dxodkt4tTvg3jUOSuoMJJiyeThxH1ju936umhPgH6v1+VKab5b0OkWWEvczEqD0E6ee5a5Ai4mhkw1hmPWV5NQP4D+7DzNjVDGKycObht5Xm4Mu2Ub6YV/S1lqlT48QZyNbORRu0PrtBA5127xiB3xzwoCfUstfh/8D39GPuE3/NJ+rEhw2rfN6qwRb0f9Ikmw/0V4NlLZpR91xjoO3r3Dw98uM6LGzsmQ6763/2plY68bHTPqxEJZ8mC99eoQ4GzlsULhJG0Hx0GcnMxf+vEX7c9qAvzFs0mKvS4pR7VBzDEInuDUUFP2TBCj9RFMNFPC+ZK89I8K0HJOpcUbun1IBQOrBS9mXtcbj/nYHpG0Jlz49QpyNVBWKMsGa1ViMzbW3cFG1tqTYruq4MmQdP54YCeYE7+erPg5+AyHsHO8jLKJfkQClH0lJjGH5DZOxmF2ne8ICvGTSt9KyauwvpgVzgaWIWtXE0s2JVBftcdu/uUy15zcb6dMjxBms/Aco2aZN5epdW144VLh3jUpBtYFhvsf4XcJ6lME/9n6uequWHBs5DYxeRlhEvyM5KP2Mp2z4KYNDueCZL8m31nqtMmsJxGXFjk6BP18axiVvVnCwbhC/XbORZ39U7jJvLGWqhThLVZ+AkxtB7wc+ZrfNL22HDcf0mJRaXhr2fwQkPug2wuLksEFtLkRM10ZihGgkIyj9UFM2/MKJA0geFo6PQed1+sdZDGm6DX2rn5ZwP3hhnh4dDj4onsG7X36p3QU1kj49QpyF6q3Y878m45iDlcdiXDuco3U8//Nm7Z3jyQErGDXpWvBpox5S9REtuTZ8ikztCBcSoAjA+/SPxezL8vkOUiyHtDnnVqYOMnH/5FIAfnvgUrJ2feHclhQrfXqEOKvY60nP2MCMN/1Y9NlA7v5cx6KPdcx4Q2seerIa7vpMxYHCj0LX8OOJEVrSqze1J0HvD5HTtdL4QrSgqKqHT50+rry8HLPZjNVqJThYlqJ1JbtDda9XUl8Ex1dqAYqfxe0Yhwq3f1jM2rxI4nzy+eTyQsyWRADSs7XOx4CzySA09e1RpBS+EGcIu93Oi5+s5bmM+sZHXH+fVWBkqIP9pXpG+h5h5Tn/xG/io96ndux1UH0YomdDmId6SuKs1JnPbxlBES5aT//odQqYIiEiGRoqoME9sUTLRwknzs/KsXoL961pwFFbDLTRp8e/QRuZGSOjJ0L0delZeUxf9jnPZdjQAhPXqZimm4/9pXoCddW8NPxF/Mbe5T04UVUtOAke471ZoOj3JElWdIx5DNTkQekOCBrp9sZjNsHyS3256gMba62TWb4mnaWXzQZF79qnp1rLTUmy2NFXH4CiIIg636VipBCi72hqMqo62154o217Ju55hk9a3HbeSW0e+IRrNz46+RgSnsmngugYRQcRU8FvAFQf87hLosWHJ6dr9VGePTKXTVub81Ga+vQsHKn9X2/wAf+BULIdSr7tkZcghOgcu0Ml7b/ftxuc6NCyZH8e+QGDBgyHkPHeT2qr1BoBRiSDr4ygCu8kQBEdZwzSktnQae3UPbh2YgjXxOfjQM8d28/j2OHt3s9nCNTuok5ugvJ93XPNQohTlnnwGHnlTdM6numw40DHtIBdjPfbR3nkVd5P6GhorBY7EYJHdfn1irOLBCiicwKHaMsBawvAUe9xlyfmRTEu+CSldjM/XxtBjdXziAsAvuFakafCr7VKkkKIvsFeR+GJXe3s5MCBHouxiActr/Nc6V0kDWhjGqj6CATGQ3iSLCkW7ZIARXRe6GTt7qfysMelxyYD/O2KEMKNleypiefhT/NRbVXez+cXqyXfFnwFdVJVVohe57DDyU1EqUfa2VGHUbHx57hn+fXxO3lghr9bvSSn2pNaYbeI6WDoYJEk0a9JgCI6T++jTfX4hkFNrsddYoP1/N88FYPSwMriqbzyRYZLETc3AUOgJl8LUhraCGaEEN1LVaFkK5R+S9KQ8DZqGWmPpcWuIL3qYu69aBApw7yc014D9SUQPhW7KYaM7GJW7jxBRnax9OISXkkdFHHqyvdB7mrwjfTaGv21zJM8nhmNDjtvJq/nvCmzvJ/P0QCVB8GcCJbZWiAkhOhZpbugYJ2WH+YT4rGWkQ4HDnQsDvuUHw0+xvjk272PnKgOqNgPIeNJL0ok7X8/uHQ3jzGbSF2QIPWQ+gmpgyJ6RtBICJsMNSe0fhoe3HxuJFcPPoEDPUszz+HYkTbmtHUGrReHNUtLnHXYPe5md6hyByZEd6jI1nrsGILAJwRwr2XUFJwkBWRxZ3wGk877iffgBKD6KPjFkF44giVv7XQJTgDyrbUseXMH6Vl53fOaxBlLRlDEKbM7VDKz8yk8uoUoXR5JwwZ6fKOqbYBr3jrJrvJoRpqO8sGPIChkoPcTN1RpQU/kdAif6pJMl56VR9qqPXIHJkRXq8mD3E/BXq+VAGilvgGu+Qh2FuiINRbyzsjfUzA0jclxwd4DlLpisFdjj7mEGS9muwUnTRTAYjax8VcXacUhxVlLRlBEt0vPymPGU+tY9MoO7l5jZNFng5jxuoP0bPd9TQb4+xUhRPmUs792EHevKsNeV+H95IYA8I2Gos1Q+p3Lcy55c4fcgQnR1eqKIX8t2Cq0WkcePJupsLNAh69Sx/ODnuHn2Xfz41Uhzj48buy1UF8E4UlkFgZ5DU5Ay2bJs9aSmSNJ8qKZBCii07wFCnlVepas9vxmZQk28vIl4KvUs846nqdXfweq5ykcQGvhbghurJGyXysYtWpPG6l6kLZqj0z3CNFZtnItOKkt0KZYPSz/fW8P/G2H9vjTA5/ntaLL2Vs7FID8Stx/71UHVB2G4LEQOpHCCu/BSUsd3U/0DxKgiE5pK1BoagH4yJeKS/v1JhMGBvLMTK3A29+On8/7X29qPKfWon3lflxbt5sitbyUgq/I3LtH7sCE6GoNVZC/DqqOQuAwjy0nNp+A33ylBSd3Rb3NCVsU/7POdG5vSpxN29Di9776qFY+IGo66AxEBXWsU3FH9xP9gzRBEJ2SmVPSZqAACqW18OJWB3dPdb8Tu3x8JAeLj/LC7kH8Oms6dl0mz2dPJa+yed+YQJXUmaq2ZNEvFqqOUHj8O8Dc7vXJHZgQHWSvg4KvtRU2gcM9NvY7YoVffAo2h8Kl5g0kmLJZcvTXbvupKORVQmauSnJksXauqBnO1X1J8WHEmE3kW2s93tw05aAkxUvpe9FMRlBEp3Q0AHh1Fx5HUQDumTWQ+TFHsalGnsoag8X+g8t2tyFj/0FE+bSRs9JCZ+/AZEWQ6JccDVC4UVsxFzAUdEa3Xax18JNVUFanY4Lffm6L+Ij7jt+P2sbHRmFFPdQVacntAYOdj+t1CqkLEgD3ovlN36cuSJAEWeFCAhTRKR0NAMrq9GQe9VxwTafA05cOYLBPPqV2MyV2M4N9mgu+uQ0ZKwpJQy3E+Nu8FIzS3uRiOnkH5kz0fXkzd7+zk0Uvb2bGU+sk2Vac3RqrxFL6LfgP0lpNtGKzwx3pkF2mI8Z4kv8b9gJLjz5CtcOvzVNH6fMhdLzWa6eVlMQYlt8wGYvZ9T3EYjax/IbJsgpPuOnyAOXxxx9HURSXr9GjRzu319bWsnTpUsLDwwkMDOTqq6+moKCgqy9DdJOk+DBC/NzvtjwptFq1YWQPsooU8urDiDCUcqQ+FrO+khCd1bldGzJWyGyMW/R6Hanna4FL6yDlVO7AZEWQ6JdUh7Y6rnirtlrHQ8l5VdVyTjYc0+Gn1PLykGXETFoKvhFt3CCoxPjbSIqP1MoD6Nyni0ALUjb+6iLevn0az183kbdvn8bGX10kwYnwqFtGUMaOHUteXp7za+PGjc5t9957L6tWreL9999n/fr15ObmctVVbXS/FH2KXqdw6/T4Du0bFTFAy+T3UOK+sBrq8cHm0BOgq2ZXzUjG+h/CiM1tvyYpw3Usn9eAxb/BZZ/O3oHJiiDRL6mqFpgUbwG/GDAGetztr9vgvb0KOuy8OPgpEiddjt48itSZ2u+D+w2C9n1qcgV6y/lamYA26HUKycPCWThxAMnDwmVaR3jVLUmyBoMBi8Xi9rjVauWVV17hrbfe4qKLLgLg1VdfZcyYMWzevJlp06Z1x+WILnbHRcN59Zscyqo9V491JrxNmAJ5Vqhq7GDaQlTjjZvVEUyssZA6hw+bKicxNziDNeXTaBoXiWp1g5cyQs/ceBuZh3IoZDBRAyeTNDy2U29y7SX6tlwRlDwsvMPnFeJU2R0qmTklFFbUEhWkTVV26Qe3qkLJt3DyG/CN8Nqa4j974c9btPvWJwasYPa4ERB1PtBcUTZtg5YQ28QSoJKalE9K0gzwc3/fF+JUdUuAcuDAAWJjYzGZTCQnJ7Ns2TIGDRrE9u3bsdlszJkzx7nv6NGjGTRoEBkZGV4DlLq6OurqmqcKysvLu+OyRQfpdQp/vGocv3hzh9s2l+kWU4j25pb7P6gtBFMUdgdk5kJ+FYSZVEpqIdcWxXDfIxysG8ya8mTmBm/mi/KpWAIhKdbD8xuMJA+Pgcq9EKADRxjo2p4bb0lqMoi+pEeqI5fugqKN4BOqfXmw6Rg8vE77Df5F5PvckGCDQde67JMyDObGq2TmqhRWQ5RfA0lBB9BHJUPwaE+nFeKUdfkUz9SpU3nttddIT09n+fLl5OTkMHPmTCoqKsjPz8fHx4eQkBCXY6Kjo8nPz/d6zmXLlmE2m51fcXFxXX3ZopNSEmNYccNkYtpLeAuIg4jzwGYlfV8tM95QWPSxjnvX6CipbQpnVA7WDSbBpC3bWVt+LjMDd5A6U/VeQlvno60+sO7ROiDb2w8mmlbsHCiobHdfkJoMovv1SC5U6S4oXA/6QPD1PCL4Q5G2nLhBVVhgXs9Do3fBiF96LNqm10HyQFg4wkGyORt9yBgIT/K4rxCno8tHUObPn+/88/jx45k6dSqDBw/mvffew8+v43e5LT3yyCPcd999zu/Ly8slSOkDUhJjmJtgaX9oOiSR9N2FLFnjuQZCkz21w0gwZbOndhhbqhK527YXGOP9AL1vY3PB77UCU9GzPK5IAM93qd5ITQbRE9rLhVLQcqHmJlhOfbqnLEsL4A2BWuFDD46Vw83/hQqb1gDwmdEfohv7e61IYluqDmu5LFEzvf7eCXE6ur1QW0hICCNHjuTgwYPMnTuX+vp6ysrKXEZRCgoKPOasNPH19cXXV34B+qKmhLe22FWFtK+bElDdqyAoqIT5qTw6QyXCNIRXvjnEV8VDue3LQfzH/zDDBw1p4wIag5Syxp490ReA3nXko+kutSMpr1KTQfSUbs+FKtsNBV9qSategpPiGrh5JRRU6xjpe4S/j3gJ0/jHPa7ucVGTr/2eRV/g7HosRFfr9joolZWVZGdnExMTw5QpUzAajaxdu9a5fd++fRw9epTk5OTuvhTRSzJzSsgrr8M9ONGoKBTXKFgCYOZghZeuGsjEoGOU2YO4aXUw+UXep/8A7Y2yKUhpNd3Tdml+d1KTQfSUbs2FKtsNBetA7w+mKI+7VNbDravgkFXHAGMhbwz/AyET79eSaNtiKwd7FUTO8Nj1WIiu0uUjKA888AALFixg8ODB5Obmkpqail6vZ9GiRZjNZm677Tbuu+8+wsLCCA4O5s477yQ5OVlW8JzFOvxG3Lik2N/XwD+vDuNH7xZwqCaam1ae4N0flRJq9pzcB7QIUnZpKxYsF4Le1IHS/Jo7LhzG9OGRXb96Qggvuq0/TdO0jt7Pa3BSZ4dffKqwq1AhTG/ljaFpWCYtdVtt58ZeBzW5EJEM5oTOXZcQndTlIyjHjx9n0aJFjBo1imuuuYbw8HA2b95MZKQ2xPjcc89x2WWXcfXVV3P++edjsVj48MMPu/oyRB/S4TfiFqPKYYF+vHGFD9HGUvbXDOCWDyuorGonuVVvakyc/R7yv4SGmg4HRyOig6Qmg+hRTf1pvP3Edbo6sqpCyU6t+Z/eD0zRHnezO+D+LxQ2Hlfw19XwanwawyYtgpDEds5vh6ocLTCRpFjRAxRVVc+4alTl5eWYzWasVivBwZ7X84u+w+5QmfHUujYahalYAmHjTe6rdg7kFnHNf/0obQhimvkgr10Ti8m3nYDHXgdVh8A8loyqCSz653ftXuPbt0+TmieixzXlRwEuvxtNH/0dnm501jnZAIYgrzknqqp1G39nj4JRsfHKkCc4f3IyxKS0f/7Kg9qUTux8MAa1f01CeNCZz2/pxSO6XduNwhqrUHpZUjwiNoLX51sJ1FWz2TqcOz48is3muUBc8xP6No6k7CbJtJ2YYJ+uu0sVogt1SX8a1aFViC1cD0Zzm8HJkxu14ESHnefinuX8xDHtBycA1ce0+inRsyQ4ET1GRlBEj/FYkCrQQeo5uaSMtWhLhb3YvP8oN6+JoU715fLoPTx31Qj0es/9PpwcNqjMJr1gOEs+8wFO8y5ViG5yypVkHXYo2dpcIdZLETaAP29ReGGrds5nBj7HjxP9YNjtHqdqmgoqFlZDlKGMpKgK9ANTIHDoKb9GIaBzn98SoIge5fZGHONAn78a6svaTdBb9/1BfrZ+KA0YuHbAbpYtHI2uvTdxR0NjkBJPWkYweeX1zk1dXq1TiJ7ksGmBSfE2Ld/Ex+x11xU74I/faDcAabEruHlsDYy80+NNQXo2jeXsm3+3YoL0pC6cIL8r4rRJgCLOLFXHIPdTQNduL49V2/dxd8ZIHOhZHLeb3y0YjdJekKLaoSIbu6+FzPokCuv8u6ffiRA9xV4LhRugdCf4DfTa+A/gjV3w2NdaIPKQ5TV+mZALYx4ExX0EMj0blqxW3GoWyWij6CqSgyLOLAFxEHUB2GugvtRlk90BGcdh5X7t/5dMGsWzSXtRcPDvY2N5/H8/oLbXdVjRQ9Bw9LZCkn03sXCEXVbsiDNXQxXkr4XSb8F/UJvByb++bw5Olka9yy9HH4bR93sMTuwObeTEU0FF6fIteoMEKKJvCB4FEdOg9qT2Box2N9fUu+fuz3Us+ljHjDcU/MITeHrK9yg4eP3IWH63ej/tjgMqOggYBrYKyF0N5fu6/zUJ0dXqrZD3mdaDKmBomxVf38yC367X3uJ/FvEBD4zcCWN+BTqjx/0zc2mc1vFWULG5sq0QPUECFNE3KAqETYHwKVB9jPQDNpasdm3rDpBfqQ1BB0WNY9kkbfnwKzlj+GP6vg4EKQoEDNH+nLdGqxlx5s1wiv6qpkCbCq04BIHD2ux/8+8sePQr7e399ogPeWRUBkrib9o8pqlQYnuky7foKRKgiL5Dp4eI87AHjSVtg87LULP2fdoGhR8nT+DJ8dsB+Fv2mI6NpAD4xWolwAu+hOItWiKtEL2kqcv2yp0nyMgu9jyFUnkY8lZrPXCChnsdBQF4Kwt+0xic/DTiI3496huUcY+3218nqp32O879pMu36CHd3ixQiE7R+5BZM568au/F1VS0kZXMXJUbz58E6jZ++/05vHJoNLb/7efxS4fTbnqJKRJ0PnByI9gqIXI6GE6t27YQp8rT0vsQPyO3To/njouGo1eA8r1Q+LW2pDhwWJsVXP/1ffO0zm0RH/ObkRtRxqW13/wPSAorIMY/kvxqg5eCitLlW/QsGUERfU5hdceSV5uGpG+8YDJPTdiKgoM3Do/k1//NxtGRRD4fM/jFQekObV6/vuzUL1qITmqqItu6V1RZjY3nvtjPlCc/Jz1jozYdiR4CBrUZnCzf3hyc/DTiI34z4muUjnQmBqgrQe+oInWetkLHvaCiRrp8i54kAYroc06ld8+1M6fw7ORt6LDzzrERPPjfHOz2DgQpBn8IHA4VB7Xk2Zq8U7xqITquI122y2oa+MV/raSfiG5z+b2qwh3p8FSG9nZ+R9Q7XGr+mnm700g/EtD+xdjKob4YImeQknTu6Ve2FaKLSB0U0eecTu+eVZu3cs+2c7Cj51LLIZ67YjA+hg7c8al2qDqslfGOPF+b55dmaKKbZGQXs+jlzR3YUyXGy886aMHJzz5VWJOj/aw+aHmdpIDd/CQnlUqHFsEvn6+SMszL6RuqoOY4hCdDZLKzcNspV7YVoh1SB0Wc0U6nd8+Caefyf1O34aPY+F/+UG57/wTV9fb2n1TRa8s27fXaSEpxpiTPim7T8ZUwWkXXzFz3LXYH/HZ9c3Dy25i/M9FvHzfnpFHhCHBJKLc7PJzaXqv12AmdAhFTXarK6nUKycPCWThxgNQMEr1GAhTRJ3ltohbgaPuOEEg591z+OX0n/roaNhQPYvE7Jymr7kCwoShat1afEK0rbME6Z00WIbpSZ1fCtF4CXGeHuz5XeDNLQcHBHwb8lXjfXH5yOJVqR3Oyt+otwHHYoCoHQsZpCeI6WS8h+h75qRR9VkpiDHMTLM1DzRwjyZiB3i8c8NwUranJWbH/FJZN2cljO0bwbXks175bwBtXBxMd7L0OhJNPKOhNWhlxm1WrcmuK6tLXJvq3pPgwYswmtwRZb1rmW1XWwy9WK2w8pmBUbDwb9xxGpYGfH/kNNtXz8mOXAMdh03KuzKO1n229z2m8EiG6jwQook9rGmoGQI2FYkVbGqzoweg6f+ne5Gwyc0K/Z1fFAPZVRXP1uyW8fqWDYREdWE6s94PAEdpd5olVEDFdq3YreSmiCzRNY/7izR1oNVo9/1w15VslxWrfF9fArasUdhUq+OtqWDH4D5y0hXLv8fux4727tzPAUe1QeQiCh0P0RbK0XvRpMsUjzhyKAuHnQngS1OZp9UsaNTU5a115dm1pIrHGAgb55HO8Lowf/Udl+9Hyjj2fzqCt8HE0QF66Nu1jlyqaoovUFECb63hc862OlcOPP9CCk1C9lbeG/oYZowfzbNndOLy8lSuoxASqTLFAxnEHK3cVkmGNxx41u80ePkL0BbKKR5x5HA1wchMUbwX/gdh1Acx4oyk4cb8TVVCZFpJDVb3Kruph+Cr1PH+hlZSE8I4/p60canIhaAREzgBTRJe9HNHP2OuxF21jxt9Okletx9voiU5ReXGeyiXDYWcB/PQThaIahQHGQl6Pf4zhY+ZA3FXO4ByaKy1Dc0L5zyap/He/Ql5V87YYs4nUBQmybFj0OFnFI85uOoOW2Bem9e3JPFbXTpMzhYyyoTw80585ITupU31Ysi6cV7cUdvw5jcFaFc/KQ3Div1qzwTMvthe9rbYI8laTuftb8qoNePuZBXCoCqEmbXTwuo+04CTBlM0Hwx9i+PirIO4qAFKGaUuJLa0GRCyBWnDy928V8lrleudba1ny5g7Ss6Tuj+i7JAdFnJl0BoiaAaqdwpxsYGC7h5xUo1nxIxOPf7KRN/NnkLbVwlFrHo/Oifa4ZNn9OY3alE9NrrYUOTRPm3IydKAYluhzurPWh9u5h4SgrzwARd9AXSmF6tAOnee9vfDxPgUVhVlB23hxyJ8JTLwTwqe67JcyDObGq2TmqhRWazknUyxwwb8ULz2ttEfSVu1hboJFlhGLPkkCFHHm0hkh6nyiohqA9mudRPmDwWTmySsmE/vZFzydM4dX98eQY83nhQWRBJs68CatKOA/QMt/Kc6E2gKIOA8C4k7/9Yge46kHTmemPdoKbjyeO1Ah9dwTpAx1QNAIoso7FhB8tE+LnBeHfUrakHcwjEvVphk90OsguUWcnnFcJa/Ke+StAnnWWjJzSpoT0YXoQyQHRZzx7LZaZjy1lvxK1WUOvonHyrOOBj7dtJb7dl1IrWpiREAxr1wRxKDQTsTsqh2qjmhNB8OmQOhEWbJ5BmjqgdP6ja/pJ6e9ku5tBTeAl3NrjzTV8LE7YMYbCvmVePyZbbmy5xHLP/nZ4K0o4x4DU3THXqSqsvL7Qu7+uv1g6/nrJrJw4oCOnVeI0yQ5KKJf0RtNpF4+HlCcHwRNvFae1Rm4ZMbFvHd+BtGGYg5UhbPwXRtbjtZgd0DGcVi5X/u/xyqcoC11DhyqLUkuXA+5n0C1h5Kfos9oqwdO02Npq/Zg99Js0luDv6acjoc//N7LuV2ruup12s8k4PYz2xScaMuIf8/PRxxAmfhUp4ITqg4RFdyBJoF0vmicED1FAhRxVkgZH8fy68djCXS9G7UEttGLRFEYP+4CVl56mHF+2ZQ2BLB4lS8XvWpl0cc67v5cx6KPdcx4QyE9u40n9w3XEmirjmgJtEWZYK/D7lDJyC5m5c4TZGQXe/3QEz0nM6ekzeJoLac9WmsvuFGBsmpbG+d2rerqOblVC04GGAv4YNiDpIz0g3GPd3xJsOqAqkPgE0rSpFnEmE1e03AVtJGfpPiwjp1biB4mOSjirJEyPo65Y6LI3PkVhYU5RIVEkBTn224CrCVuEu9dncO9n2whvWwqR2pCsRhOkt8QCUB+pbaMs80S+00JtHXFULie9O9zScvwJ6+8+QNLlnb2vo72wPG0X3vBTYevoUVV15RhMHuIyq+/UvnPXi0ZNinge5YPforwkVfDgMs7XhxQdUBltlb12DIHvZ+F1AUKS97c4bZr0xlTFyRIgqzos2QERZxV9EZfkidfyMLJw0kOzUHvqGz/IMAnOJ4j9hHcGPYJOuzkN0QSaSgBVLfh+Tb5hpNeMIIlnxnIK6932SRLO3tfR6czPO3X8QZ/7Zy7xcyLtRZ+/qnC+3t1qChcH7aaN4cvI3zi3TBwYSeCEztUHtSmgWIuBj+Lc5PZ3738fYi/sd1cGyF6mwQo4uyj94HoC7QlwDUntCJr7XhxG+ytCOOd0nncHP4JYXorJxvCCNDV4KvUeW+61qgpb+WjffDr9QavSzuh7RwH0b2aeuCcyrRHx3M1vP3bahNBpTXad1mFcNl7CuuOKPgo9Tw98Hn+MOJjfKb8UUu67ijVrvXW8YuF2BRn36imfBlP006lbUxFCdFXSIAizk46o1bxNXwa1OZDfZnXXdOz4blM7SPLphp5tXgh0wO/JdHvAFUOf+pVI6F6K+DeVbbp+BlvKCz6WMe9a3SU1LZVNM57joPofk09cMD9X6i9aY/2gxuVUFNTcOIpSNGOfGKjwttZcNUHCsfKFeJ88vlw+ANcM9wKk57ROmp3VFPjv4BBWnDiqy0XbitfpulKJFAWfZ0EKOLspTNA5HlaoFJfpOWHtGJ3aFM3ra2yzsKAnStD1qGio9RuJtxQxqES11U93noAtaewrLSTL0Z0BbtDxeznw63ThxAa4Lok3GI2tTntodcppF46GnBfedP0/S3jm5YHew9j8qsUHvlKR71d4aKgTD4Zfi+JY6bD2F+DoRP9cex12rRO0FCImad14W50OsnAQvQVkiQrzm6KTpvqUQxaF2TV7hwCB8jMpUX3Y1c7a0ZzrN7CLyPf5Y3iBRQ3hPDyjhre3q3jiVlG5sZrwY2n6Zz2FB3bjn1wJfrQMaD3PfXX1w26s8Jqb/JUvyQswMiVEwcwJ8HS9utUVag+RkrYTpbPyictM7qxVL3GEqgtG65rv14gAHrs3Gd5kyWxa9CNeQi7eQKZJ3BWgU2Kpe3kbnsNVB0GcwJEX+hWzfh0koGF6CskQBFnP0UHYZO1gmonN0D1cecwuqcpm5aK7SGsOPkjFod9yrfVY8iqHU51DTz8WTlZkwK9BjfteXJzIC/vOszjMw+SMmWcVk9F557M2NNOt8JqX+WtOFtplY1/bjrMua2CE5cgzbeapKBs9JX7AQcpYwYyN0FHZq7DLaDION7WVTQvIX5h0DNMiQHG/Jn04xGkrVRcfpZiAlVSZ3pZNdZQqf0Mh06EqPNB754bczrJwEL0FVJJVvQvFQeh4CtoqIaAIWSc0HJHOmKq/y6G+Obxbuk8AEL0FZTZA+n46ElzddDm72HFrBNaZ+XQiRAQDzp9B8/XtU63wmprfWUkxu5QmfHUOq9THgra9M7GX12EXqd4DtL8baTOaCBlZNujXe1ViL3U/DW/H/ASwUPmoxuyiPQcA0tWu4/Cta4861RfprVXCD9Xm770EtQ2veZ8a63XbJiWr1mIntKZz28JUET/U30c8tdCXTF2/6HM+JehjZLjriINpdwY9glvllxCYUM4euz46uqpdvid4sWohJpg27U56GnQ8glCxoH/4B4NVDr7Id6evjQSk5FdzKKXN7e739u3T8NaU9+hUvVtSc+GX6xu+Xek4KfUkhr7d2YFbeNozL0kjZ3gDGa0/KUOtGioPQkN5RAxDcLObffnoyngBNeU3VMNOIXoClLqXoi2+A+E2EvALxZ91UFSpzcAnkqOuzvZEMqfC2/gwqCtzAv+Bjt6qh1+BOs6mSXrpFBaq7C5bAj4x0HlYTi2Eo6vhPID2iqNHtCVSZXtlYPv6TowHc2zyC/KJ+3jb1E9/Bx0phbOZAuMi4SmZNlz/HezeuSdxPmVsHvQ8ySNnQC0zH/ytuKraWm7qgXVjlqIvkjrZNyB4DUlMYblN0zGYnadxmkvGViIvkJyUET/ZIqE2PlQuJ4UfmD5xUNJ+8bUwdU4Cu+WpjDC5zBPDHqNZ47/mHJHIHoaMCh26tTOJ71uOg7T43y1XBR7nVa/peqwFkyFJGpTP4ZTHaVpX1ckVdodKpsPFfPwB9760TQvb52bYOmxqYWO5lms35VFXqX3KTstYIDMXNWla7Bzuwr/+QF+v1GhrE7BR7Fxf/S/uCVqNScibmbaqPno9c3nbi//yblfSSFE+kDULAhqZ/imlZTEGOYmWPrEVJsQnSUBiui/fMxa1U29PynKTuZeF01mUQiF1RDhB/d/oVBQ5XnqR0Gl0mcwiy+5jtFbP2LF/mGsq0jCrhoI1FVR6Qjw8ITe5Va0+EbvCwFDtNGT2nw4sRpMERA8RvuAaqx10ZVON6nS05SOJy1HYpKHdf3r8KSpfom3fIym0Onj7I4t8fUUWByxwq+/VNh0XPtZGWs6yJ8HPceoKD8Y9RxD/WLdjonqWC8/osxBEHs++J3aiIdep/TY37UQXUmmeET/pjdB9CyInIG+oYTk8HwWjoTpcfD4+Z67zbp0SDb4kJR8LSsWBPKbmFcI1VupdASgw4GvUtfhyxgQ5OFBnVGb9gkapgUrhevh6PuQt0ZrTNg4/dMVTQlPp8KqtymdtvTk8ta2irN5r/rqXcvAwmaH5dvh4re04MRXqedhy6t8PPJXjBozCyYs0yq8epAUq63W8Ta1qKASE6iSNGXuKQcnQpzJZARFCJ1Bm9c3BGm1UipzIGAwKcN0LJ+vkrbBtRBbU82LlsmSPmGjGTxhKDfs+JCcuoF8Yj2fOtUXk1JLrepDe/cC57VVPFTRaz1WTNFQb4Wy78G6G3wjSc8fQtqX1S59f04lGbXpQ3zJmztQ8JxU6anCansVS73p0eWtDdWkDKpk+XxIW9/gUr9E07Hpjqak1aTGeCPjODz+tcK+Eu346YE7+cOAFxkcGQIjntWqu7ZBr9N+jpasVlBa9Hxqei5QSF2QiN4k3YZF/ySreIRoqeooFH6tTa0ExIPOB7tDS2jsSBGt9Gx4P/MAF/p+wStFV5BTPwAAf12Nl5U+jat4fqJ6PafH56ee9H2VLFkb7mGJquZUEiHbW33Teumww6Gy+JUtnXqOUH8j2x6d2715EPZ6qM3Tko4rs6GuFHR67MYoMk8Gsek4vLit4wPILVfxjI+C329S+N9B7fpD9eX8OuYVrgj7Bv2wm9HFpmi1dzooPZvGILhFHZQgHakLxpMyfkCHzyPEmUCWGQtxOupLoXADlP8AfnFg7ET5cRoDihN2TIX/4+ucGl4quIo61RcFBwbs2GiqXdFYB6WNpaseP7wCVX47Q+XJjW0tUQVLsA8bfzUbvZfIx1udEm+PewpeQvyMlNV0fqXRiu5YRWKvhZp8qD4BlYegrghQwScMfEK0kahGK/fD3Z93PIiICVR55DyVY+Xw4jaFmgYFHQ4Wh3/K/dFvklmVyGO5v0DxDfdeYK2tS7fbyTxUQGF9AFGxiSQljPf67ybEmUwCFCFOl70WirZAyXYwhmirfk5F7UmO7X6fJ3ZPYU15MgBGxUaDqic6QOHx810/zFqOlhwua25i2LqIV0fL67+90Eby6CHgG6W9hsbCXp2tU+KtiNup8FRT5ZSKuqkOrXBZXZG2DLfqcHNTSGMw+IRhx8jmE5BxQns4eQBMG6D9HXekQN8d5zhIHgDHK+Avmc2B4rn+u3l8wAoCdTU8mXc7X5QnAUqn6qU4NVRD9VEIGAxRMyXfRJzVOvP5LTkoQniiN2kfFsYQKM7Q7sgDBrvchXeIKZK4Kb/k5fjtfLPjz/z+8OXsrh0OgIE6qmxG7A5tysjTaIl79dmmVUUdCxUKy8og7wutzL9PCPgPJP1IIEs+Oul2hqY6Ja2nhk41z8Sb1it5OhwsqQ6wlUN9CdQWaonCdSXaB7xOr/1bBcRrOUVof58Pf6lQVtv89/fiNggxqfzhAi0B1VuBPgWV6ACYFA1PblT4oVjbZ4CxkActbzAv+Bv+7+Q1vHzyKurU5qaDamOQkrZBYW6892k7p7piLcAKnQAR53V6tE6Is5mMoAjRnurj2pRP9XEtSNGfYj0SRwOO3NV89O1xnsm9lnxbBADDzPVcGG/gHzvdR0tO178XOpgeB9jrsNeVs/mYjaXrLZTV6z0+j6fRjY5WYu2s56+biK9B13Z5/R8P0UYi6oq0qZuGcmio0qIcY6A2UqIPAMX1tbhWc239OrVn+/kklb9/qzQ+4t6CYEQoHCjVHg/WV3JH1LvcFP4JlUFJXL7t/9u79+imyrxf4N/sNJfekt6bFtpSKhSkgCC2tHinQhEVHF9HEUdHGVQEB4XxCHNereCawUGWqMhCPEdh3pc5KrhUdFR4QQUGKeUuUijQ2sIUmpa2tk2vabN/549NQtPcdkraJuX3WStrJjt77zxPHmJ+fS6/Zw4udsTBnY9mik7zpUhvIQIt/5bKHT1R2uagn7Y4YKwvcQ8KYz5wZdhBgbiQm5GpK4Ky8YSUh0QT4/0NhSAIg+/FA/GNuPuXT7HxhArrq+9HaYMOpccAtcIMc5e/xn1pW7kGy/4V53FzQ1vvxtHdUu6MoDBU17bKeg9v56PEhKrwpy3H3SR1Iyz7+izueqAESkEJBIUBQXpAm2CbhCrN97GfQAxIq2skzuor9UBtPaPA2ryuc3kkagEwiwqc/RVQKzrw++gv8WzcFkREJQND/4LtxhG42OF5eMhlIjZLmzQcFZwAxN4MhA3xeC/GrkUcoDDmhNNhB50G+XdkIy/6eM+HfABApUNw+pOYl3wRj5ZuwIenYvB/L82E6XJyN5WiAx3km52NvysHTGZ02ZBOnmrjWSDkMAAgrjkcgOfVJGtnREJQKGBssuC1nXWoa3WeE15arktA5U5UNupd3o+gQGWLCgdM6U57IlxNIH74eoKx2VMvlALGZiBSS9jzO8L7RwmfFStQWq+AWZSywM6K2oZnYj9FQkQIkLoQiMoEFArENXr8KAC4SMTWXgOYawF9hrTZn9qx/v6yySJj/Y0DFMa6cTUh1NjYjnlb27HuP25BXswJwHSmR6t8bIITEZ7xHEYryrH87DqUmgfj7zX3wCRK9wtCJzpdfkUd56Y48+FPCnx2GrIn1VrFRRuAcANAhMzUDiSEijA2K1zO1zCEdGKiao805yISCM4Kw7xdgy6X1H74hADcndKMgovygjtnPRHbSp0HXcamrhOLPdt6Bnh5twIll4dy7AITnQpIng3E32EXiFoTrLneYJIQoQFEgm1+EcgizZlRqoG4O4HIMba5Mnb18qNNFhnrbzwHhbEuZO/quzgLyrqDQP1PgKCVsoUqevZXbkGFtKJkbPBpzIn5AsZOqUelulNKTy7AAhECrAGGN6t45AYyXc9P6LqD7mXWgEA6o3tCMeerVpz1cAgKgkjefU7d53J42gXY+zoD4UILZkV9iydjv4QhXAUkPyRlGHbRQ+bq8+j+3glhhPzsFuQllEs9brGTpP2VnN3TRWDMuw+zgYSXGTPWQ3InhH40dyKyh0YCprNATYHUdR+SIq3+8ZL1B9f6F3m6thxzYz6DmVT4oGYmStuTbOcKsECrEtDSAfhyMu0V5DIvi6shFXd5P6zLpneUSb05EscJqc4n7EqZW7sHS9aATk5dPAUwiapLeDJmKx6K2o7w8Bgg6QEg7jZZQ3dyVl3ZArh7gpE3cSIQ5HyPJtmBcZfJy4wFIp4ky1gPebWrr0IAdOmAJhao2S8ldgsKl1LSe9Gb0j3l+em2IfhTxSKkqC9iTvTnGKS5hE/qpmJnYyZEKNHSYe1V8f2qjzljXQcbeWnAXamEAxdJVlZda90yE4FFO11NWrUumXb+w55/i+NSXbm7AEucBSkKZIaewOyob3B3xI9oDsnACe3/AiLGIzNWAaXMprN+HvsvEOZvU6C+3Vqfru+ukHZw/hdwV06IyxY7UFbndi+j/thkkbH+xgEKY130aFdfTRSQMFXae6X2ANB0BghJ9mo5cl4aHPb9OWdOxDrTs3htjAnvB+9AxS9L8I/KTHz662Rc6ryyP4sCIsjjvp/yhj1yU92/rhTgeumsCwcuwsPqIcfXnO13ZCV3F+Du9w0TWvAfkTvxSPQ2pGkrYQy+GXPOvok9dVfexFOPUHdKARAUQH276/rJCS68CowZu0ZwgMJYF9ZdfY0NbU5XvVi72h129RWUQESGNBelphBoPCkti9UaZO/L4rqHIgzA/Rg86D7c/vNBjD/3LhQgfF5/J3Y0ToTZbsWPY09EhBb4tc3xNft62W+E50tyezwWTBAxLMpzz4ycSarWegoQMSnsGGZG7sI0/Y9oU8YgYkgefmi7E3/YrnM6yXbetwqvMsHKrZ+74KJHgTFjAxwHKIx10dNdfW00UUDCFKk3pe7Q5ZU+gwBVuO0Ud5sPuu2hUCghRk3E3D05iA+qwQOR3+PTtD/heOtwfNNwM/Y3ZdgN+1gn0z4yipAeDbyyR4F6J7+R7oZTfEFuj8ekwfJ6Z5QC8L8nERZst7aQ4xDOKG0J7o/chXsj9iBMaMH2xmw8WZaPc4oM7M4G/nOTtdbOs/S+ukdmJlgAccEWeNqtGnAfXPQ4MGZsAONJsow54ZPlnuYGoO4IUP+z9DxkMLaVqbyeaNpV9wm1AGFCyEncE/Ev5IT+hMMt1+ObhkkoaBpjt0RZrSSMl1YN48QloLnD9ft7s3uzHI5l7k5alrtmCkEQgJpWx/dttwAnqoEjRmBfhQKFF4GWjq49RSImhJzCVH0BpugKkKi+hD2m8fii/g7saMhCK10JDl6eJOK1Hz1X6IVMEQsz3ZxABLTXwNJWg5s/Hwljs+A2uPA0wdW6ikf6ROyvB3gVDxsYeBUPYz7gk4RZRNJGcLUHsK2oFvN2D3b4y93bDeZcLXEV0InM0JN4avAejFIdxzFTMnaZbsRu040OadkFBWFQODA8Crg9mZARB4yMAXad836lTnfOApwdZfKW5Xal1xAmJAB1rUDRJSm7a1fRQfWYFHYMN4cdwx3hhxChasGuhnH4n8YsfNeYhTqL8yRwj40W8V8/y1sF5HKn6c4mKfW+OgKIHIdtF2Ix7//9bKuRlbfBBedBYQNdwAQoa9euxRtvvAGj0YixY8dizZo1yMx09yeLhAMUFmgsHW24eeUPqDRZ4M2SWlc85RhRQMStUaX4z5EHcR0dQmlNK/Y3Z+BQ8/U42DwKF5zsI3Mlvwq6lVE6+sQYwpSh7ntU3C1FBuRthuhKdFA9xoUUIzO0CDeHHcMIbTkEbTQQcQMQfRMKW8bhoS89jyfJ7UFxmhNG7JD2ZAIA/fVA1HhpWA++Cy44kywbyAIiQPnkk0/w2GOP4b333kNWVhbeeustbNmyBadPn0ZcnPtNuDhAYf7K1Y+L7Pwq7jaYc3gv9zlG7HpmkhuBhhMoP1cEc10RgtGEn1qHo6g1DUWtQ3GybShqOiNlva9KIKRFAil6IEwNhKmklSw/XR6C6V4Oa4CTqgc6CahuBtot7n9wdUITRgSXY4S2HONCijE+pBjJaiMUar0UGESMlTbY0ybYlnR7GkqyBoHfP0IY9X8UEKl7OZ37aKaI7EEWoLVS2qgwbAgQNeHyVgf213NwwZh7ARGgZGVl4aabbsK7774LABBFEUlJSXjuueewZMkSu3Pb29vR3t5ue97Y2IikpCQOUJhfcfcXdHuniIUfH/N4j7eniJgxXP57esqq2rVnxjrMQgB0ymaMDylGRnAJRgeXYJS2BCpBRGn7YJS1J6KsfRDK2xNxzmxAdWcUGizhDve+WlpFO5LURiSpq5CsNmKwugppmgqM0JbDoKpFsxiMs23JONY6HJOuH47hQ0YAmji3OWbkZLzVa+QmepO8fcevmJFUKa3QihoPhF8HCL7ZK4mxa43fJ2ozm804fPgwli5dajsmCAJyc3NRUFDgcP6KFSuwbNmyviwiY15xuX9PQxvmbTqC53PlRR1xwZ3w5mvpKccIQQpe9l+QcqxY5780WsKwyzQBu0wTbGdGKRsxTHseQzUXMFRTgeyw4xiiroRBVQOlQsSlzkhUd0TiV4sOTZYQNInBaLKEoFkMhoUEiFCAIIBIiiG0inYEC9JDK7QjQmlCTFA9ooMaEB1UjzChFRYIqOyIRYU5DhfMcTjQnIH/rp2OM20puNARa8vv8naGiOEyVtg6yycD2OdV2XpG9scLAIgLIcCQC+hGAEHyc9swxq5OvwQoNTU1sFgsiI+PtzseHx+P4uJih/OXLl2KRYsW2Z5be1AY8wcWkbDsq5NOV3BYZ1h8fPA8DDoNqhrbXa/0CBORGf4L0KwFgg2AoPb43nJzcBRc8Jwsrc6iR2HzaBQ2j3aoRbjQgnhVLRJUNYgMaoRO2Qyd0IxYTTPCqBZBCguUECEoLAiCtItxG6nRJqrRTmo0doTibFsS7h6pQ2uwDo/+S4+azkgYO6JhkZERV35yNs8Zb+Xfi5AQrkRm5n2AxvWuy4yx3hEQeVA0Gg00Gk1/F4Mxp+SmKX8hdxje2nnWdX6V+8ZBmTQMaPhZ2vlWESQNKyhd/9v35odbHud5RUxiKEztoShpT76qu0+OFjE2Eajep4Cx1dWy467v3LMEcu7yyXhO9GZ9bwXyZ9wAJQcnjPWLXkjL5FlMTAyUSiWqqqrsjldVVcFgMPRHkRjrMbnpx4fEhGLdo+Nh0NuPVRj0WmkZ6pjBgH4EMPh+YPB9QOhgoLUCaCoFOpqc3tP6Y6tw2i8j/cAnhBGyB8mvj6t7XQ1rOaw9GdZVPe7eq7cSyMl5/8gQlcelwRaRUFBai63HLqCgtBYWMeAyNjDm1/qlB0WtVuPGG2/Ed999h5kzZwKQJsl+9913WLBgQX8UibEe8yZNeXZaNO663uB+pYcQJE3EDE2Vcqg0nASay4HWC4AmBlBH2tLnd99o0NnE0PxbCBMHue81sPZUvHwz4bW99vM3XJO7RNgx0HA1V6Qrd/vxXK28lGasu6MZywqjUdlyZcJrRLAKT0waggV3DvOYVI3zlTDWu/p1mfHjjz+O9evXIzMzE2+99RY2b96M4uJih7kp3fEyY+ZPLCLh5r997zFNuadMoi4RAW3VgKkEMBUD7XXSPj+aGEApBUfu8o9Yf+DlrHDJS7uyfHlnGfCBk+XL3Qrn4XXAEEp49VbngUbXpG4xl+efOssk6xNkkT47c520kWNoEixhI3CgRo/qpk7Zy4JdTYjmjK+MeRYQy4wB4N1337UlarvhhhvwzjvvICsry+N1HKAwf9Nnaco7TFJvSkOxlJdDNAOaaEAdCQspPaaolxPIdPX2AWD1AXlJzZzlPnkhk7Bggo8DDW91mID2GkDsgEUViQOmNFR3xiIuOg6ZqdFeBY3WYNTVnKOrDkYZG+ACJkDpKQ5QmD/q025/0QK0GYGmXwDTWcD8KwCllNVUpXe7g7I3e+1sPQMs/B/P0UWEhlDf3vP0+D5naQXaa6WU9EFhQMggbLuYiGU761HZeCWnkrftIzvh3tyJyE6L7nHxGRuo/D4PCmMDUV5Gguf5Jb4iKIGQQbBoE3Ggfiiq642IC7qETGUFlO1npRVA6ihApQMU9st43e6Y3I3cVUJr8wiCwvmy3j5BJGV57fhV+l+lFtAagNgcaZPGM2bM+8x1nhq5PVxyJ0TLPY8x5hoHKIz5kFJQ9Nlfzk57bHQpyM8dh7zBl6Q9Y5p+kX68VTpArZfmXnjB05Jc6+TaiYP6YRhH7AA6GqWHaAaCQgFtPBCeJgUn2jhAIUh5av75vds8Ncu+Oom7rjd4DCa9mRDNGLs6HKAwFoBcZq5tNGPeZ0apR2DErUBbFdByUZq30lYNWNqkHhVVOBAULgUsblLHy10l1CfBiWi+3EtikoZwhCAp8NKlAyGDpeR26iiH+sjNU3OgrM5jcJmZGoUEvdbjhOjM1Cjv68cYs8MBCmMBRk7mWqlH4E4ow1KBsFRAnAiYa6V5GW1VQPO/L08cbZUuUgZLPRBBIYCgtfuRl5M+3udEM9DZIgUinc0ALIBCBajCgNBBQEgKoI21W8nkii+HZZSCAvn3Xo95m464Trh37/U8QZYxH+AAhbEA06MeAUEpDXlo4wD9SGmSrbkOMNdLj7bKy8HLJUBshy3UETSAUou8JBXuekSNA1UaVLcEIS70KueZkAUQO6X3srRLAYnYDlAHQAppM76gEKmnR5cuBSPqSOnhISDpztfDMnkZCVj36HiH4TUD50FhzKc4QGEswPikR0BQSj/62tgrxyxmaT5HZ5P06GiUghZzPUBmKC3NyI40AxGd0vlNkLoNiLqsGlLgSl8CASTaPb1yilKayCuopYc27nIAopeGnlTh0vCNhyEoOXpjWKZPJ0Qzdo3iAIWxANNrEzWVakAZAyDG/jjR5Z6OtisPsUPq7RA7AOqUekNIhBSUWHB53EiaJyIEARAu/3+1/UMZLD0EzxsG9lRvDcv05YRoxq5FHKAwFmD6fKKmQiENq3g5tOJPeFiGscDDAQpjAcZdjwAuP395Ok/U7I6HZRgLLBygMBaAXPUIWL329UkIArhnoBselmEscPTnDhmMsauQl5GAl6ePdPqaNUPqthOVfVwqxhjzDQ5QGAtQFpHw2tennL5mHfZZ9tVJWET/3m7LIhIKSmux9dgFFJTW+n15GWN9g4d4GAtQvsyQ2l/6dINFxlhA4R4UxgJUoG9cZ03X3z3I4uEpxhjAAQpjASuQN67zlK4fCIzhKcZY7+EAhbEAZc2H4mqRrALScIk/blznzfAUY+zaxAEKYwHKmg8FgEOQ4u8b1wX68BRjrPdxgMJYALPmQzHo7YdxDHot1j063m8nmgby8BRjrG/wKh7GAlwgZkjt83T9jLGAwwEKYwNAoGVI7a0N/BhjAwcP8TDG+kWgDk8xxvoG96AwxvpNIA5PMcb6BgcojLF+FWjDU4yxvsFDPIwxxhjzOxygMMYYY8zvcIDCGGOMMb/DAQpjjDHG/A4HKIwxxhjzOxygMMYYY8zvcIDCGGOMMb/DAQpjjDHG/A4HKIwxxhjzOwGZSZZI2lqssbGxn0vCGGOMMbmsv9vW33F3AjJAMZlMAICkpKR+LgljjDHGvGUymaDX692eoyA5YYyfEUURFy9eRHh4OBQK324q1tjYiKSkJPz73/+GTqfz6b39Adcv8A30OnL9At9Ar+NArx/Qe3UkIphMJiQmJkIQ3M8yCcgeFEEQMHjw4F59D51ON2D/4QFcv4FgoNeR6xf4BnodB3r9gN6po6eeEyueJMsYY4wxv8MBCmOMMcb8Dgco3Wg0GuTn50Oj0fR3UXoF1y/wDfQ6cv0C30Cv40CvH+AfdQzISbKMMcYYG9i4B4UxxhhjfocDFMYYY4z5HQ5QGGOMMeZ3OEBhjDHGmN/hAIUxxhhjfueaC1D+8pe/ICcnByEhIYiIiHB6zvnz5zF9+nSEhIQgLi4OL774Ijo7O93et66uDrNnz4ZOp0NERATmzJmDpqamXqiBd3bt2gWFQuH0cfDgQZfX3X777Q7nP/PMM31YcvmGDBniUNbXX3/d7TVtbW2YP38+oqOjERYWhgceeABVVVV9VGL5ysvLMWfOHKSmpiI4OBhpaWnIz8+H2Wx2e52/t9/atWsxZMgQaLVaZGVl4cCBA27P37JlC0aMGAGtVovRo0fjm2++6aOSem/FihW46aabEB4ejri4OMycOROnT592e83GjRsd2kur1fZRib3z6quvOpR1xIgRbq8JpPZz9t8ThUKB+fPnOz0/ENpuz549uPfee5GYmAiFQoEvvvjC7nUiwiuvvIKEhAQEBwcjNzcXZ8+e9Xhfb7/H3rrmAhSz2YwHH3wQ8+bNc/q6xWLB9OnTYTabsW/fPvz973/Hxo0b8corr7i97+zZs1FUVIQdO3bgn//8J/bs2YOnnnqqN6rglZycHFRWVto9/vCHPyA1NRUTJkxwe+3cuXPtrlu5cmUfldp7y5cvtyvrc8895/b8F154AV999RW2bNmC3bt34+LFi/jNb37TR6WVr7i4GKIoYv369SgqKsLq1avx3nvv4c9//rPHa/21/T755BMsWrQI+fn5OHLkCMaOHYupU6eiurra6fn79u3DrFmzMGfOHBw9ehQzZ87EzJkzceLEiT4uuTy7d+/G/PnzsX//fuzYsQMdHR2YMmUKmpub3V6n0+ns2uvcuXN9VGLvjRo1yq6se/fudXluoLXfwYMH7eq2Y8cOAMCDDz7o8hp/b7vm5maMHTsWa9eudfr6ypUr8c477+C9995DYWEhQkNDMXXqVLS1tbm8p7ff4x6ha9SGDRtIr9c7HP/mm29IEAQyGo22Y+vWrSOdTkft7e1O73Xy5EkCQAcPHrQd+/bbb0mhUNCFCxd8XvarYTabKTY2lpYvX+72vNtuu40WLlzYN4W6SikpKbR69WrZ59fX15NKpaItW7bYjp06dYoAUEFBQS+U0LdWrlxJqampbs/x5/bLzMyk+fPn255bLBZKTEykFStWOD3/t7/9LU2fPt3uWFZWFj399NO9Wk5fqa6uJgC0e/dul+e4+u+RP8rPz6exY8fKPj/Q22/hwoWUlpZGoig6fT2Q2o6ICAB9/vnntueiKJLBYKA33njDdqy+vp40Gg199NFHLu/j7fe4J665HhRPCgoKMHr0aMTHx9uOTZ06FY2NjSgqKnJ5TUREhF2PRG5uLgRBQGFhYa+X2Rtffvklamtr8cQTT3g89x//+AdiYmKQkZGBpUuXoqWlpQ9K2DOvv/46oqOjMW7cOLzxxhtuh+QOHz6Mjo4O5Obm2o6NGDECycnJKCgo6IviXpWGhgZERUV5PM8f289sNuPw4cN2n70gCMjNzXX52RcUFNidD0jfyUBoK0BqLwAe26ypqQkpKSlISkrCjBkzXP73xh+cPXsWiYmJGDp0KGbPno3z58+7PDeQ289sNmPTpk148sknoVAoXJ4XSG3XXVlZGYxGo10b6fV6ZGVluWyjnnyPeyIgdzPuTUaj0S44AWB7bjQaXV4TFxdndywoKAhRUVEur+kvH3zwAaZOnepxN+hHHnkEKSkpSExMxPHjx/HSSy/h9OnT+Oyzz/qopPL98Y9/xPjx4xEVFYV9+/Zh6dKlqKysxJtvvun0fKPRCLVa7TAHKT4+3u/aq7uSkhKsWbMGq1atcnuev7ZfTU0NLBaL0+9YcXGx02tcfSf9va0AQBRFPP/885g0aRIyMjJcnpeeno4PP/wQY8aMQUNDA1atWoWcnBwUFRX1+s7t3srKysLGjRuRnp6OyspKLFu2DLfccgtOnDiB8PBwh/MDuf2++OIL1NfX4/e//73LcwKp7ZyxtoM3bdST73FPDIgAZcmSJfjb3/7m9pxTp055nMgVSHpS54qKCmzfvh2bN2/2eP+u82dGjx6NhIQETJ48GaWlpUhLS+t5wWXypn6LFi2yHRszZgzUajWefvpprFixwm/3yuhJ+124cAF5eXl48MEHMXfuXLfX9nf7Mcn8+fNx4sQJt3M0ACA7OxvZ2dm25zk5ORg5ciTWr1+P1157rbeL6ZVp06bZ/v+YMWOQlZWFlJQUbN68GXPmzOnHkvneBx98gGnTpiExMdHlOYHUdoFmQAQoixcvdhvhAsDQoUNl3ctgMDjMRLau7jAYDC6v6T4xqLOzE3V1dS6vuVo9qfOGDRsQHR2N++67z+v3y8rKAiD9Bd8XP3BX06ZZWVno7OxEeXk50tPTHV43GAwwm82or6+360Wpqqrqtfbqztv6Xbx4EXfccQdycnLw/vvve/1+fd1+rsTExECpVDqsmHL32RsMBq/O9xcLFiywTZj39i9plUqFcePGoaSkpJdK5zsREREYPny4y7IGavudO3cOO3fu9LrXMZDaDrjyu1ZVVYWEhATb8aqqKtxwww1Or+nJ97hHfDabJcB4miRbVVVlO7Z+/XrS6XTU1tbm9F7WSbKHDh2yHdu+fbtfTZIVRZFSU1Np8eLFPbp+7969BIB++uknH5fM9zZt2kSCIFBdXZ3T162TZD/99FPbseLiYr+dJFtRUUHDhg2jhx9+mDo7O3t0D39qv8zMTFqwYIHtucVioUGDBrmdJHvPPffYHcvOzvbbSZaiKNL8+fMpMTGRzpw506N7dHZ2Unp6Or3wwgs+Lp3vmUwmioyMpLffftvp64HWflb5+flkMBioo6PDq+v8ve3gYpLsqlWrbMcaGhpkTZL15nvco7L67E4B4ty5c3T06FFatmwZhYWF0dGjR+no0aNkMpmISPrHlZGRQVOmTKFjx47Rtm3bKDY2lpYuXWq7R2FhIaWnp1NFRYXtWF5eHo0bN44KCwtp7969NGzYMJo1a1af18+VnTt3EgA6deqUw2sVFRWUnp5OhYWFRERUUlJCy5cvp0OHDlFZWRlt3bqVhg4dSrfeemtfF9ujffv20erVq+nYsWNUWlpKmzZtotjYWHrsscds53SvHxHRM888Q8nJyfT999/ToUOHKDs7m7Kzs/ujCm5VVFTQddddR5MnT6aKigqqrKy0PbqeE0jt9/HHH5NGo6GNGzfSyZMn6amnnqKIiAjbyrnf/e53tGTJEtv5P/74IwUFBdGqVavo1KlTlJ+fTyqVin7++ef+qoJb8+bNI71eT7t27bJrr5aWFts53eu4bNky2r59O5WWltLhw4fp4YcfJq1WS0VFRf1RBbcWL15Mu3btorKyMvrxxx8pNzeXYmJiqLq6mogCv/2IpB/b5ORkeumllxxeC8S2M5lMtt86APTmm2/S0aNH6dy5c0RE9Prrr1NERARt3bqVjh8/TjNmzKDU1FRqbW213ePOO++kNWvW2J57+h77wjUXoDz++OMEwOHxww8/2M4pLy+nadOmUXBwMMXExNDixYvtougffviBAFBZWZntWG1tLc2aNYvCwsJIp9PRE088YQt6/MGsWbMoJyfH6WtlZWV2n8H58+fp1ltvpaioKNJoNHTdddfRiy++SA0NDX1YYnkOHz5MWVlZpNfrSavV0siRI+mvf/2rXW9X9/oREbW2ttKzzz5LkZGRFBISQvfff7/dj76/2LBhg9N/r107PwOx/dasWUPJycmkVqspMzOT9u/fb3vttttuo8cff9zu/M2bN9Pw4cNJrVbTqFGj6Ouvv+7jEsvnqr02bNhgO6d7HZ9//nnb5xEfH0933303HTlypO8LL8NDDz1ECQkJpFaradCgQfTQQw9RSUmJ7fVAbz8iqQccAJ0+fdrhtUBsO+tvVveHtR6iKNLLL79M8fHxpNFoaPLkyQ51T0lJofz8fLtj7r7HvqAgIvLdgBFjjDHG2NXjPCiMMcYY8zscoDDGGGPM73CAwhhjjDG/wwEKY4wxxvwOByiMMcYY8zscoDDGGGPM73CAwhhjjDG/wwEKY4wxxvwOByiMMcYY8zscoDDGGGPM73CAwhhjjDG/8/8BfICZnKsbNqYAAAAASUVORK5CYII=",
-      "text/plain": [
-       "<Figure size 640x480 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "!cp \"result.pkl\" \"result-10.pkl\"\n",
-    "for i in range(10):\n",
-    "    !python -m autora.workflow lib.experimentalist --in-path \"result-10.pkl\" --out-path \"result-10.pkl\"\n",
-    "    !python -m autora.workflow lib.experiment_runner --in-path \"result-10.pkl\" --out-path \"result-10.pkl\"\n",
-    "    !python -m autora.workflow lib.theorist --in-path \"result-10.pkl\" --out-path \"result-10.pkl\"\n",
-    "\n",
-    "state_after_ten_more_cycles = load_state(\"result-10.pkl\")\n",
-    "\n",
-    "plot_results(state_after_ten_more_cycles)"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 2
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython2"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 0
-}
diff --git a/docs/cli/basic-usage/example/__init__.py b/docs/cli/basic-usage/example/__init__.py
new file mode 100644
index 00000000..9fe79be5
--- /dev/null
+++ b/docs/cli/basic-usage/example/__init__.py
@@ -0,0 +1 @@
+# This __init__.py file is required to allow `plot` to import from `.lib`
diff --git a/docs/cli/basic-usage/lib.py b/docs/cli/basic-usage/example/lib.py
similarity index 100%
rename from docs/cli/basic-usage/lib.py
rename to docs/cli/basic-usage/example/lib.py
diff --git a/docs/cli/basic-usage/example/plot.py b/docs/cli/basic-usage/example/plot.py
new file mode 100644
index 00000000..4ccb4f48
--- /dev/null
+++ b/docs/cli/basic-usage/example/plot.py
@@ -0,0 +1,48 @@
+#!/usr/bin/env python
+import pathlib
+
+import numpy as np
+import pandas as pd
+import typer
+from matplotlib import pyplot as plt
+from sklearn.model_selection import GridSearchCV
+
+from autora.state import StandardState
+from autora.workflow.__main__ import load_state
+
+from .lib import ground_truth, noise_std
+
+
+def plot_results(state: StandardState):
+    x = np.linspace(-10, 10, 100).reshape((-1, 1))
+    plt.plot(x, ground_truth(x), label="ground_truth", c="orange")
+    plt.fill_between(
+        x.flatten(),
+        ground_truth(x).flatten() + noise_std,
+        ground_truth(x).flatten() - noise_std,
+        alpha=0.3,
+        color="orange",
+    )
+
+    assert isinstance(state.experiment_data, pd.DataFrame)
+    xi, yi = state.experiment_data["x"], state.experiment_data["y"]
+    plt.scatter(xi, yi, label="observations")
+
+    assert isinstance(state.models[-1], GridSearchCV)
+    plt.plot(x, state.models[-1].predict(x), label="model")
+
+    plt.xlabel("x")
+    plt.ylabel("y")
+
+    plt.legend()
+    plt.show()
+
+
+def main(filename: pathlib.Path):
+    state = load_state(filename)
+    assert isinstance(state, StandardState)
+    plot_results(state)
+
+
+if __name__ == "__main__":
+    typer.run(main)
diff --git a/docs/cli/basic-usage/img/after-four-cycles.png b/docs/cli/basic-usage/img/after-four-cycles.png
new file mode 100644
index 00000000..75d36d29
Binary files /dev/null and b/docs/cli/basic-usage/img/after-four-cycles.png differ
diff --git a/docs/cli/basic-usage/img/after-one-cycle.png b/docs/cli/basic-usage/img/after-one-cycle.png
new file mode 100644
index 00000000..b98dd87f
Binary files /dev/null and b/docs/cli/basic-usage/img/after-one-cycle.png differ
diff --git a/mkdocs.yml b/mkdocs.yml
index e16c828a..5aee1786 100644
--- a/mkdocs.yml
+++ b/mkdocs.yml
@@ -28,7 +28,7 @@ nav:
 - Cycle:
   - Functional: 'cycle/Linear and Cyclical Workflows using Functions and States.ipynb'
 - "Command Line Interface":
-  - "Basic Usage": "cli/basic-usage/Readme.ipynb"
+  - "Basic Usage": "cli/basic-usage/README.md"
   - "Using Cylc": "cli/cylc-pip/README.md"
   - "Using Cylc and Slurm": "cli/cylc-slurm-pip/README.md"