diff --git a/docs/cycle/Linear and Cyclical Workflows using Functions and States.ipynb b/docs/cycle/Linear and Cyclical Workflows using Functions and States.ipynb
new file mode 100644
index 00000000..d9473ab7
--- /dev/null
+++ b/docs/cycle/Linear and Cyclical Workflows using Functions and States.ipynb	
@@ -0,0 +1,1101 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Linear And Cyclical Workflows Using Functions And States"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Using the functions in `autora.state`, we can build flexible pipelines and cycles which operate on state objects.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from typing import Optional\n",
+    "from dataclasses import field, dataclass\n",
+    "\n",
+    "import numpy as np\n",
+    "from matplotlib import pyplot as plt\n",
+    "import pandas as pd\n",
+    "from sklearn.base import BaseEstimator\n",
+    "from sklearn.linear_model import LinearRegression\n",
+    "from sklearn.pipeline import make_pipeline\n",
+    "from sklearn.preprocessing import PolynomialFeatures\n",
+    "\n",
+    "from autora.state.delta import State, Delta, wrap_to_use_state\n",
+    "from autora.state.wrapper import theorist_from_estimator, experiment_runner_from_x_to_y_function\n",
+    "from autora.variable import VariableCollection, Variable\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Experiment Runner And Theorist"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We define a two part AER pipeline consisting of an experiment runner and a theorist (we use the seed conditions\n",
+    "always).\n",
+    "\n",
+    "The key part here is that both experiment runner and theorist are functions which:\n",
+    "- operate on the `State`, and\n",
+    "- return a modified object of the **same type** `State`.\n",
+    "\n",
+    "### Defining The State\n",
+    "\n",
+    "We define the state as a dataclass, subclassed from `autora.state.delta.State` with fields representing the variables,\n",
+    "parameters, experimental data, (possibly) conditions, and (possibly) a model.\n",
+    "\n",
+    "This state has no \"history\"; it represents a snapshot of the data at one time. Other exemplar state objects are\n",
+    "available in the subpackage `autora.state` and include some with in-built histories."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "@dataclass(frozen=True)\n",
+    "class Snapshot(State):\n",
+    "    variables: VariableCollection = field(metadata={\"delta\": \"replace\"})\n",
+    "    params: dict = field(metadata={\"delta\": \"replace\"})\n",
+    "    experiment_data: pd.DataFrame = field(metadata={\"delta\": \"extend\"})\n",
+    "    conditions: pd.Series = field(default=None, metadata={\"delta\": \"replace\"})\n",
+    "    model: Optional[BaseEstimator] = field(default=None, metadata={\"delta\": \"replace\"})\n",
+    "\n",
+    "s = Snapshot(\n",
+    "    variables=VariableCollection(independent_variables=[Variable(\"x\", value_range=(-15,15))],\n",
+    "                                 dependent_variables=[Variable(\"y\")]),\n",
+    "    params={},\n",
+    "    conditions=pd.DataFrame({\"x\": np.linspace(-15,15,101)}),\n",
+    "    experiment_data = pd.DataFrame(columns=[\"x\",\"y\"]),\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Snapshot(variables=VariableCollection(independent_variables=[Variable(name='x', value_range=(-15, 15), allowed_values=None, 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=[]), params={}, experiment_data=Empty DataFrame\n",
+       "Columns: [x, y]\n",
+       "Index: [], conditions=        x\n",
+       "0   -15.0\n",
+       "1   -14.7\n",
+       "2   -14.4\n",
+       "3   -14.1\n",
+       "4   -13.8\n",
+       "..    ...\n",
+       "96   13.8\n",
+       "97   14.1\n",
+       "98   14.4\n",
+       "99   14.7\n",
+       "100  15.0\n",
+       "\n",
+       "[101 rows x 1 columns], model=None)"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "s"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Defining The Experiment Runner\n",
+    "\n",
+    "For this example, we'll use a polynomial of degree 3 as our \"ground truth\" function. We're also using pandas\n",
+    "DataFrames and Series as our data interchange format."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "coefs = [432, -144, -3, 1] # from https://www.maa.org/sites/default/files/0025570x28304.di021116.02p0130a.pdf\n",
+    "\n",
+    "def ground_truth(x: pd.Series) -> pd.Series:\n",
+    "    y = pd.Series(coefs[0] + coefs[1] * x + coefs[2] * x**2 + coefs[3] * x**3, name=\"y\")\n",
+    "    return y\n",
+    "\n",
+    "def noisy_observation(x: pd.Series, std=1000, rng=None) -> pd.Series:\n",
+    "    if rng is None:\n",
+    "        rng = np.random.default_rng()\n",
+    "    y = ground_truth(x) + rng.normal(0, std, len(x))\n",
+    "    return y\n",
+    "\n",
+    "def noisy_observation_df(df: pd.DataFrame, std=1000, rng=None) -> pd.DataFrame:\n",
+    "    y = pd.DataFrame({\"y\": noisy_observation(df[\"x\"], std=std, rng=rng)})    \n",
+    "    return y"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Given this state, we define a two part AER pipeline consisting of an experiment runner and a theorist. We'll just\n",
+    "reuse the initial seed `conditions` in this example.\n",
+    "\n",
+    "First we define and test the experiment runner.\n",
+    "\n",
+    "The key part here is that both the experiment runner and the theorist are functions which operate on the `State`. Therefore, we use a wrapper function `experiment_runner_from_x_to_y_function` that wraps the previously defined `noisy_observation_df` function and returns a function with the same functionality, but operating on the `State`. In this case, we want to use the `State` field `conditions` as input and extend the `State` field `experiment_data`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "experiment_runner = experiment_runner_from_x_to_y_function(noisy_observation_df)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "When we run the experiment runner, we can see the updated state object which is returned – it has new experimental data."
+   ]
+  },
+  {
+   "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>-15.0</td>\n",
+       "      <td>-1457.368847</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>-14.7</td>\n",
+       "      <td>-1276.238863</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>-14.4</td>\n",
+       "      <td>-1101.204891</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>-14.1</td>\n",
+       "      <td>-938.114081</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>-13.8</td>\n",
+       "      <td>-780.385208</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>...</th>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>96</th>\n",
+       "      <td>13.8</td>\n",
+       "      <td>501.515831</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>97</th>\n",
+       "      <td>14.1</td>\n",
+       "      <td>608.036899</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>98</th>\n",
+       "      <td>14.4</td>\n",
+       "      <td>722.340558</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>99</th>\n",
+       "      <td>14.7</td>\n",
+       "      <td>844.702516</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>100</th>\n",
+       "      <td>15.0</td>\n",
+       "      <td>972.762139</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "<p>101 rows × 2 columns</p>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "        x            y\n",
+       "0   -15.0 -1457.368847\n",
+       "1   -14.7 -1276.238863\n",
+       "2   -14.4 -1101.204891\n",
+       "3   -14.1  -938.114081\n",
+       "4   -13.8  -780.385208\n",
+       "..    ...          ...\n",
+       "96   13.8   501.515831\n",
+       "97   14.1   608.036899\n",
+       "98   14.4   722.340558\n",
+       "99   14.7   844.702516\n",
+       "100  15.0   972.762139\n",
+       "\n",
+       "[101 rows x 2 columns]"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "experiment_runner(s, std=1).experiment_data"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Defining The Theorist\n",
+    "\n",
+    "Now we define a theorist, which does a linear regression on the polynomial of degree 5. We define a regressor and a\n",
+    "method to return its feature names and coefficients, and then the theorist to handle it. Here, we use a different wrapper `theorist_from_estimator` that wraps the regressor and returns a function with the same functionality, but operating on `State` fields. In this case, we want to use the `State` field `experiment_data` and extend the `State` field `models`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Completely standard scikit-learn pipeline regressor\n",
+    "regressor = make_pipeline(PolynomialFeatures(degree=5), LinearRegression())\n",
+    "theorist = theorist_from_estimator(regressor)\n",
+    "\n",
+    "def get_equation(r):\n",
+    "    t = r.named_steps['polynomialfeatures'].get_feature_names_out()\n",
+    "    c = r.named_steps['linearregression'].coef_\n",
+    "    return pd.DataFrame({\"t\": t, \"coefficient\": c.reshape(t.shape)})\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Directly Chaining State Based Functions\n",
+    "\n",
+    "Now we run the theorist on the result of the experiment_runner (by chaining the two functions)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "t = theorist(experiment_runner(s, rng=np.random.default_rng(1)))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The fitted coefficients are:"
+   ]
+  },
+  {
+   "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>t</th>\n",
+       "      <th>coefficient</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>1</td>\n",
+       "      <td>0.000000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>x</td>\n",
+       "      <td>-161.235264</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>x^2</td>\n",
+       "      <td>-2.092934</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>x^3</td>\n",
+       "      <td>1.487881</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>x^4</td>\n",
+       "      <td>-0.002423</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>5</th>\n",
+       "      <td>x^5</td>\n",
+       "      <td>-0.002523</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "     t  coefficient\n",
+       "0    1     0.000000\n",
+       "1    x  -161.235264\n",
+       "2  x^2    -2.092934\n",
+       "3  x^3     1.487881\n",
+       "4  x^4    -0.002423\n",
+       "5  x^5    -0.002523"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "get_equation(t.model)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Creating A Pipeline With State Based Functions\n",
+    "\n",
+    "Now we can define the simplest pipeline which runs the experiment runner and theorist in sequence and returns the\n",
+    "updated state:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def pipeline(state: State, rng=None) -> State:\n",
+    "    s_ = state\n",
+    "    t_ = experiment_runner(s_, rng=rng)\n",
+    "    u_ = theorist(t_)\n",
+    "    return u_"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Running this pipeline is the same as running the individual steps – just pass the state object."
+   ]
+  },
+  {
+   "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>t</th>\n",
+       "      <th>coefficient</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>1</td>\n",
+       "      <td>0.000000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>x</td>\n",
+       "      <td>-161.235264</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>x^2</td>\n",
+       "      <td>-2.092934</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>x^3</td>\n",
+       "      <td>1.487881</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>x^4</td>\n",
+       "      <td>-0.002423</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>5</th>\n",
+       "      <td>x^5</td>\n",
+       "      <td>-0.002523</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "     t  coefficient\n",
+       "0    1     0.000000\n",
+       "1    x  -161.235264\n",
+       "2  x^2    -2.092934\n",
+       "3  x^3     1.487881\n",
+       "4  x^4    -0.002423\n",
+       "5  x^5    -0.002523"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "u = pipeline(s, rng=np.random.default_rng(1))\n",
+    "get_equation(u.model)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Since the pipeline function operates on the `State` itself and returns a `State`, we can chain these pipelines in the same fashion as we chain the theorist and experiment_runner:"
+   ]
+  },
+  {
+   "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>t</th>\n",
+       "      <th>coefficient</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>1</td>\n",
+       "      <td>0.000000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>x</td>\n",
+       "      <td>-169.149674</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>x^2</td>\n",
+       "      <td>2.803475</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>x^3</td>\n",
+       "      <td>1.617091</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>x^4</td>\n",
+       "      <td>-0.022233</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>5</th>\n",
+       "      <td>x^5</td>\n",
+       "      <td>-0.002868</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "     t  coefficient\n",
+       "0    1     0.000000\n",
+       "1    x  -169.149674\n",
+       "2  x^2     2.803475\n",
+       "3  x^3     1.617091\n",
+       "4  x^4    -0.022233\n",
+       "5  x^5    -0.002868"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "u_ = pipeline(pipeline(s, rng=np.random.default_rng(1)))\n",
+    "get_equation(u_.model)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "To show what's happening, we'll show the data, best fit model and ground truth:"
+   ]
+  },
+  {
+   "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>t</th>\n",
+       "      <th>coefficient</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>1</td>\n",
+       "      <td>0.000000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>x</td>\n",
+       "      <td>-169.149674</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>x^2</td>\n",
+       "      <td>2.803475</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>x^3</td>\n",
+       "      <td>1.617091</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>x^4</td>\n",
+       "      <td>-0.022233</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>5</th>\n",
+       "      <td>x^5</td>\n",
+       "      <td>-0.002868</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "     t  coefficient\n",
+       "0    1     0.000000\n",
+       "1    x  -169.149674\n",
+       "2  x^2     2.803475\n",
+       "3  x^3     1.617091\n",
+       "4  x^4    -0.022233\n",
+       "5  x^5    -0.002868"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "def show_best_fit(state):\n",
+    "    state.experiment_data.plot.scatter(\"x\", \"y\", s=1, alpha=0.5, c=\"gray\")\n",
+    "\n",
+    "    observed_x = state.experiment_data[[\"x\"]].sort_values(by=\"x\")\n",
+    "    observed_x = pd.DataFrame({\"x\": np.linspace(observed_x[\"x\"].min(), observed_x[\"x\"].max(), 101)})\n",
+    "\n",
+    "    plt.plot(observed_x, state.model.predict(observed_x), label=\"best fit\")\n",
+    "    \n",
+    "    allowed_x = pd.Series(np.linspace(*state.variables.independent_variables[0].value_range, 101), name=\"x\")\n",
+    "    plt.plot(allowed_x, ground_truth(allowed_x), label=\"ground truth\")\n",
+    "    \n",
+    "    plt.legend()\n",
+    "\n",
+    "def show_coefficients(state):\n",
+    "    return get_equation(state.model)\n",
+    "\n",
+    "show_best_fit(u)\n",
+    "show_coefficients(u)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We can use this pipeline to make a trivial cycle, where we keep on gathering data until we reach 1000 datapoints. Any\n",
+    " condition defined on the state object could be used here, though."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlAAAAGwCAYAAABmTltaAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAACHwUlEQVR4nO3deXgURfrA8e/kPshBQk4IkBDkDARRIIgKyo+grIqii8cqKuqK4Ip44oHiheuFt7iHwHqurooKyCGKCgSQYCCAICGBACHhziQBcvbvjzGjGYbQ0+mZ7pm8n+eZR8n0dFdfVW9VV1dZFEVREEIIIYQQqvkZnQAhhBBCCG8jAZQQQgghhIskgBJCCCGEcJEEUEIIIYQQLpIASgghhBDCRRJACSGEEEK4SAIoIYQQQggXBRidAF/U0NBASUkJERERWCwWo5MjhBBCCBUURaGiooLk5GT8/JpvY5IAyg1KSkpISUkxOhlCCCGE0GD37t106NCh2WUkgHKDiIgIwHYCIiMjDU6NEEIIIdSwWq2kpKTYy/HmSADlBo2P7SIjIyWAEkIIIbyMmu430olcCCGEEMJFEkAJIYQQQrhIAighhBBCCBdJHyghhBA+p76+ntraWqOTIUwmMDAQf39/XdYlAZQQQgifoSgKpaWlHD161OikCJOKjo4mMTGxxeM0SgAlhBDCZzQGT/Hx8YSFhclgxsJOURSOHTvG/v37AUhKSmrR+iSAEkII4RPq6+vtwVNsbKzRyREmFBoaCsD+/fuJj49v0eM86UQuhBDCJzT2eQoLCzM4JcLMGq+PlvaRkwBKCCGET5HHdqI5el0fEkAJIYQQQrhIAighhBBCCBd5bQD17LPPYrFYmDx5sv1vJ06cYOLEicTGxtKmTRvGjBlDWVlZk98VFxczatQowsLCiI+P57777qOurq7JMsuXL+fMM88kODiY9PR05syZ44E9EkII0VoNHTq0SXlmpHnz5pGeno6/vz+TJ09mzpw5REdHG50s0/HKAOqnn37i7bffpk+fPk3+fvfdd/PVV1/xySef8P3331NSUsIVV1xh/76+vp5Ro0ZRU1PDqlWrmDt3LnPmzGHatGn2ZYqKihg1ahTDhg0jLy+PyZMnc8stt7B48WKP7Z8QQgihp+XLl2OxWFSNj/XXv/6VK6+8kt27d/Pkk08yduxYfv31V/v3jz/+OJmZme5LrJfwugCqsrKS6667jn/+85+0bdvW/vfy8nL+/e9/89JLL3HBBRfQv39/Zs+ezapVq1i9ejUAS5YsYcuWLbz33ntkZmZy0UUX8eSTT/LGG29QU1MDwKxZs0hNTeXFF1+kR48eTJo0iSuvvJKZM2casr/Ct5SUlLBixQpKSkqMTooQQpyksrKS/fv3k52dTXJyMhEREYSGhhIfH2900kzH6wKoiRMnMmrUKIYPH97k77m5udTW1jb5e/fu3enYsSM5OTkA5OTkkJGRQUJCgn2Z7OxsrFYrmzdvti/juO7s7Gz7Opyprq7GarU2+QjhTGFhIQUFBRQWFhqdFCFaBUVROFZTZ8hHURSX0lpXV8ekSZOIioqiXbt2PProo03WUV1dzb333kv79u0JDw9n4MCBLF++3P79rl27uOSSS2jbti3h4eH06tWLhQsXsnPnToYNGwZA27ZtsVgs3HjjjSdtf/ny5URERABwwQUXYLFYWL58eZNHeHPmzGH69Ols2LABi8WCxWJptd1cvGogzY8++oj169fz008/nfRdaWkpQUFBJz2nTUhIoLS01L7MH4Onxu8bv2tuGavVyvHjx+2DcP3RjBkzmD59uub9Eq1HWlpak/8KIdzreG09PacZ0wVjyxPZhAWpL2bnzp3L+PHjWbt2LevWreO2226jY8eO3HrrrQBMmjSJLVu28NFHH5GcnMznn3/OyJEjyc/Pp2vXrkycOJGamhp++OEHwsPD2bJlC23atCElJYVPP/2UMWPGsG3bNiIjI52WZYMHD2bbtm1069aNTz/9lMGDBxMTE8POnTvty4wdO5ZNmzaxaNEivvnmGwCioqJadqC8lNcEULt37+auu+5i6dKlhISEGJ2cJqZOncqUKVPs/7ZaraSkpBiYIiGEEN4mJSWFmTNnYrFY6NatG/n5+cycOZNbb72V4uJiZs+eTXFxMcnJyQDce++9LFq0iNmzZ/PMM89QXFzMmDFjyMjIAJpW1GJiYgCIj48/ZYfwoKAg+6O6mJgYEhMTT1omNDSUNm3aEBAQ4PT71sRrAqjc3Fz279/PmWeeaf9bfX09P/zwA6+//jqLFy+mpqaGo0ePNrk4ysrK7Cc5MTGRtWvXNllv41t6f1zG8c29srKyU0bsAMHBwQQHB7d4H4Xva3yEB9gzQSGE+4QG+rPliWzDtu2KQYMGNRnkMSsrixdffJH6+nry8/Opr6/njDPOaPKb6upq+7Q1f/vb35gwYQJLlixh+PDhjBkz5qSXrYR+vCaAuvDCC8nPz2/yt5tuuonu3bvzwAMPkJKSQmBgIMuWLWPMmDEAbNu2jeLiYrKysgDbxfj000/b58ABWLp0KZGRkfTs2dO+zMKFC5tsZ+nSpfZ1CNES8ghPCM+yWCwuPUYzq8rKSvz9/cnNzT1p/rY2bdoAcMstt5Cdnc2CBQtYsmQJM2bM4MUXX+TOO+80Isk+z2uuqoiICHr37t3kb+Hh4cTGxtr/Pn78eKZMmUJMTAyRkZHceeedZGVlMWjQIABGjBhBz549uf7663nuuecoLS3lkUceYeLEifYWpNtvv53XX3+d+++/n5tvvplvv/2Wjz/+mAULFnh2h4VPSk5OlpYnIYRTa9asafLv1atX07VrV/z9/enXrx/19fXs37+fc88995TrSElJ4fbbb+f2229n6tSp/POf/+TOO+8kKCgIsD25aamgoCBd1uPtvO4tvObMnDmTP/3pT4wZM4bzzjuPxMREPvvsM/v3/v7+zJ8/H39/f7KysvjLX/7CDTfcwBNPPGFfJjU1lQULFrB06VL69u3Liy++yL/+9S+ys41pAhZCCNE6FBcXM2XKFLZt28aHH37Ia6+9xl133QXAGWecwXXXXccNN9zAZ599RlFREWvXrmXGjBn2Cv7kyZNZvHgxRUVFrF+/nu+++44ePXoA0KlTJywWC/Pnz+fAgQNUVlZqTmfnzp0pKioiLy+PgwcPUl1d3fKd90aK0F15ebkCKOXl5UYnRQghWo3jx48rW7ZsUY4fP250Ulx2/vnnK3fccYdy++23K5GRkUrbtm2Vhx56SGloaLAvU1NTo0ybNk3p3LmzEhgYqCQlJSmXX365snHjRkVRFGXSpElKly5dlODgYCUuLk65/vrrlYMHD9p//8QTTyiJiYmKxWJRxo0b5zQdR44cUQDlu+++s/9t9uzZSlRUlP3fJ06cUMaMGaNER0crgDJ79mw9D4XbNXeduFJ+WxTFxYEqxGlZrVaioqIoLy8nMjLS6OQIIUSrcOLECYqKikhNTTXd29rCPJq7Tlwpv33qEZ4QQgghhCdIACWEEEII4SIJoIQQQgghXCQBlBBCCCGEiySAEkIIIYRwkQRQQgghhBAukgBKCCGEEMJFEkAJIYQQQrhIAighhBBCuGzOnDlER0cbnQxuvPFGRo8e7fHtSgAlhBBCCN3t3LkTi8VCXl6eKdfXUhJACSGEEF6opqbG6CTowlv3QwIoIVQoKSlhxYoVlJSUGJ0UIYQPqqio4LrrriM8PJykpCRmzpzJ0KFDmTx5sn2Zzp078+STT3LDDTcQGRnJbbfdBsCnn35Kr169CA4OpnPnzrz44otN1m2xWJg3b16Tv0VHRzNnzhzg95adzz77jGHDhhEWFkbfvn3Jyclp8ps5c+bQsWNHwsLCuPzyyzl06FCz+5SamgpAv379sFgsDB06FPj9kdvTTz9NcnIy3bp1U5XOU62v0QsvvEBSUhKxsbFMnDiR2traZtPXUgFuXbsQPqKwsJCCggIAkpOTDU6NEEI1RYHaY8ZsOzAMLBZVi06ZMoWVK1fy5ZdfkpCQwLRp01i/fj2ZmZlNlnvhhReYNm0ajz32GAC5ubn8+c9/5vHHH2fs2LGsWrWKO+64g9jYWG688UaXkvvwww/zwgsv0LVrVx5++GGuueYaCgoKCAgIYM2aNYwfP54ZM2YwevRoFi1aZE/Dqaxdu5YBAwbwzTff0KtXL4KCguzfLVu2jMjISJYuXao6fc2t77vvviMpKYnvvvuOgoICxo4dS2ZmJrfeeqtLx8AVEkAJoUJaWlqT/wohvETtMXjGoErPQyUQFH7axSoqKpg7dy4ffPABF154IQCzZ892Wlm74IILuOeee+z/vu6667jwwgt59NFHATjjjDPYsmULzz//vMsB1L333suoUaMAmD59Or169aKgoIDu3bvzyiuvMHLkSO6//377dlatWsWiRYtOub64uDgAYmNjSUxMbPJdeHg4//rXv5oEQafT3Pratm3L66+/jr+/P927d2fUqFEsW7bMrQGUPMITQoXk5GSGDBkirU9CCN0VFhZSW1vLgAED7H+LioqyP9r6o7POOqvJv3/55RfOOeecJn8755xz2L59O/X19S6lo0+fPvb/T0pKAmD//v327QwcOLDJ8llZWS6t/48yMjJcCp5Op1evXvj7+9v/nZSUZE+7u0gLlBBCCN8VGGZrCTJq2zoLDz99i5Yji8WCoihN/uasf1BgYGCT3wA0NDS4vD01nO2H2nQ688e0N67LXWlvJAGUEEII32WxqHqMZqS0tDQCAwP56aef6NixIwDl5eX8+uuvnHfeec3+tkePHqxcubLJ31auXMkZZ5xhb5GJi4tj37599u+3b9/OsWOu9Qvr0aMHa9asafK31atXN/ubxhYmtS1hp0unq+tzNwmghBBCCANFREQwbtw47rvvPmJiYoiPj+exxx7Dz8/P3hJ0Kvfccw9nn302Tz75JGPHjiUnJ4fXX3+dN998077MBRdcwOuvv05WVhb19fU88MADJ7XYnM7f/vY3zjnnHF544QUuu+wyFi9e3Gz/J4D4+HhCQ0NZtGgRHTp0ICQkhKioqFMuf7p0uro+d5M+UEIIIYTBXnrpJbKysvjTn/7E8OHDOeecc+jRowchISHN/u7MM8/k448/5qOPPqJ3795MmzaNJ554okkH8hdffJGUlBTOPfdcrr32Wu69917Cwlx7vDho0CD++c9/8sorr9C3b1+WLFnCI4880uxvAgICePXVV3n77bdJTk7msssua3b506XT1fW5m0VxfOAoWsxqtRIVFUV5eTmRkZFGJ0cIIVqFEydOUFRURGpq6mkDD7Orqqqiffv2vPjii4wfP97o5PiU5q4TV8pveYQnhBBCGOznn39m69atDBgwgPLycp544gkAw1tZxKlJACWEEEKYwAsvvMC2bdsICgqif//+/Pjjj7Rr187oZIlTkABKCCGEMFi/fv3Izc01OhnCBdKJXAghhBDCRRJACSGE8CnybpRojl7XhwRQQgghfELjmEGuDhIpWpfG68PVsbAcSR8oIYQQPsHf35/o6Gj7HGhhYWGnHYhStB6KonDs2DH2799PdHR0k7nztJAASghhaiUlJRQWFpKWliaTOYvTSkxMBHD7RLLCe0VHR9uvk5aQAEq0OlIge5fCwkIKCgoA5HyJ07JYLCQlJREfH696IlrRegQGBra45amRBFCi1ZEC2bukpaU1+a8Qavj7++tWUArhjARQotWJiIggICCAiIgIo5MiVEhOTpZAVwhhOvIWnmh1KioqqKuro6KiwuikCCGEVyopKWHFihWUlJQYnRTDSAuUaHVa8yMh6f8lhNCDdIWQAEq0Qq35kZBkekIIPbTmimgjCaCEaEUk02tKWuSE0KY1V0QbSQAlhGi1pEVOCKGV13Qif+utt+jTpw+RkZFERkaSlZXF119/bf/+xIkTTJw4kdjYWNq0acOYMWMoKytrso7i4mJGjRpFWFgY8fHx3HfffdTV1TVZZvny5Zx55pkEBweTnp7OnDlzPLF7QnhEY8BQWFhodFJMIS0tjfT0dGmRE0K4zGsCqA4dOvDss8+Sm5vLunXruOCCC7jsssvYvHkzAHfffTdfffUVn3zyCd9//z0lJSVcccUV9t/X19czatQoampqWLVqFXPnzmXOnDlMmzbNvkxRURGjRo1i2LBh5OXlMXnyZG655RYWL17s8f0Vwh0kYGgqOTmZIUOGSOuTEMJlFsWLp62OiYnh+eef58orryQuLo4PPviAK6+8EoCtW7fSo0cPcnJyGDRoEF9//TV/+tOfKCkpISEhAYBZs2bxwAMPcODAAYKCgnjggQdYsGABmzZtsm/j6quv5ujRoyxatOiU6aiurqa6utr+b6vVSkpKCuXl5URGRrpp74UQQgihJ6vVSlRUlKry22taoP6ovr6ejz76iKqqKrKyssjNzaW2tpbhw4fbl+nevTsdO3YkJycHgJycHDIyMuzBE0B2djZWq9XeipWTk9NkHY3LNK7jVGbMmEFUVJT9k5KSoteuCqErGbtFCCH04VUBVH5+Pm3atCE4OJjbb7+dzz//nJ49e1JaWkpQUBDR0dFNlk9ISKC0tBSA0tLSJsFT4/eN3zW3jNVq5fjx46dM19SpUykvL7d/du/e3dJdFcItpA+UEELow6vewuvWrRt5eXmUl5fzv//9j3HjxvH9998bnSyCg4MJDg42OhlCnJaRwxh4csgAGZ5ACOFuXhVABQUFkZ6eDkD//v356aefeOWVVxg7diw1NTUcPXq0SStUWVkZiYmJACQmJrJ27dom62t8S++Pyzi+uVdWVkZkZCShoaHu2i0hPMbIsVs8OWSADE8ghHA3r3qE56ihoYHq6mr69+9PYGAgy5Yts3+3bds2iouLycrKAiArK4v8/Hz2799vX2bp0qVERkbSs2dP+zJ/XEfjMo3rEMITfLWfkiffAJS3DYUQ7uY1LVBTp07loosuomPHjlRUVPDBBx+wfPlyFi9eTFRUFOPHj2fKlCnExMQQGRnJnXfeSVZWFoMGDQJgxIgR9OzZk+uvv57nnnuO0tJSHnnkESZOnGh//Hb77bfz+uuvc//993PzzTfz7bff8vHHH7NgwQIjd120Mr7aeuLJ1i8ZJVkI4W5eE0Dt37+fG264gX379hEVFUWfPn1YvHgx//d//wfAzJkz8fPzY8yYMVRXV5Odnc2bb75p/72/vz/z589nwoQJZGVlER4ezrhx43jiiSfsy6SmprJgwQLuvvtuXnnlFTp06MC//vUvsrOzPb6/ovWS6VZEc6R/lxDm4NXjQJmVK+NICN8mhZ3Q24oVKygoKCA9PZ0hQ4YYnRwhfIor5bfXtEAJ4Y184XGcBIHmIi2UQpiDBFBCuJEvFHa+EAT6EunfJYQ5SAAlhBv5QmHnC0GgEELoTQIoIUSzfCEIFEIIvXn1OFBCCCGEEEaQAEoIIYQQwkUSQAkhhBBCuEgCKCGEEEIIF0kAJYQQQgjhIgmghBCm5quTKwshvJsEUEIIt9Ar8GkcyLOwsFCnlAkhzMKbK0gyDpQQwi30GsFcBvIUwnd580wHEkAJIdxCr8BHBvIUwnd5cwVJAighnHCcQFfNhLoy6W5TEvgIIU7Hm/MJCaCEcMKxWVlNM7M3N0ULIYRwjQRQQjjh2KysppnZ6KZoaQETQgjPkQBKCCccm5XVNDMb3RQtLWBCeJZUWlo3CaCE8BFqWsAkwxdCP1Jpad0kgBKtnjcGFc7SrKYFzF0ZvjceQ+GbPHktGv3YXhhLAijR6nljLVJrmt2V4XvjMRS+yZPXotGP7YWxJIASPkVL7dMba5Fa0+yuDF+vYygtWb5JWoWEnsyST0gAJXyKltqnN9YizZZmvdIjLVm+SVqFhJ7Mkk9IACV8itQ+vZvW82eWGqlwTu5LoSezXE8SQAmfIrVP76b1/JmlRiqck/tS6Mks15MEUEIIr2eWGqkQovWQAEoI4fWMrpHKI0QhWh8/oxMghDi9kpISVqxYQUlJSYuWEe7R+AixsLDQ6KQIITxEWqCEcCO9Wia0TGbsq60iZtwveYQoROsjAZQQbqSlc7OzAEHLZMa+2rHajPtl5CNEMwaUQqjlzdevBFBCuJGWlglnAYKWyYx9tVXEV/dLKzMGlEKo5c3XrwRQwqeYrTajpWVCrwDB6I7V7uKr+6WVBJTCm3nz9SsBlPApeXl5bN++HavV2qJC1shATAIE4Qq5XoQ38+brV97CE8IJeatKmIG8WSl8nTdf49ICJXxKZmYmkZGRLW4OVtOsbLbHhVrSo3UfzLbvvsqb+4cIoYY3X+MSQAmfoldzsJr1mO3G15Ierftgtn33Vd7cP0T4Nr0qUd58jUsAJUzJG1o4zHbja0mP1n0w2777Km/uHyJ8m16VKDXXuFnLA6/pAzVjxgzOPvtsIiIiiI+PZ/To0Wzbtq3JMidOnGDixInExsbSpk0bxowZQ1lZWZNliouLGTVqFGFhYcTHx3PfffdRV1fXZJnly5dz5plnEhwcTHp6OnPmzHH37gkH3tAHKTk5mSFDhpjmhtaSHq37YLZ9V8Ob+1oI9eQ8e0ZaWhrp6em6V6KcnT+zlgdeE0B9//33TJw4kdWrV7N06VJqa2sZMWIEVVVV9mXuvvtuvvrqKz755BO+//57SkpKuOKKK+zf19fXM2rUKGpqali1ahVz585lzpw5TJs2zb5MUVERo0aNYtiwYeTl5TF58mRuueUWFi9e7NH9be0iIiIICAggIiKiReuRzNT3aD2neXl55ObmkpeX556ECVMwa2Hra9xViXJ2/twVrLWU1zzCW7RoUZN/z5kzh/j4eHJzcznvvPMoLy/n3//+Nx988AEXXHABALNnz6ZHjx6sXr2aQYMGsWTJErZs2cI333xDQkICmZmZPPnkkzzwwAM8/vjjBAUFMWvWLFJTU3nxxRcB6NGjBytWrGDmzJlkZ2d7fL99kZrm2IqKCurq6qioqGjRtszWV0evpmizNml7gtnOqTAXebxsHlryKWfnz6yPsr0mgHJUXl4OQExMDAC5ubnU1tYyfPhw+zLdu3enY8eO5OTkMGjQIHJycsjIyCAhIcG+THZ2NhMmTGDz5s3069ePnJycJutoXGby5MmnTEt1dTXV1dX2f1utVj120WepKQD1ygTNlpnqVfi35iBC6znV6w1NYW5mLWxbIy35lDedP68MoBoaGpg8eTLnnHMOvXv3BqC0tJSgoCCio6ObLJuQkEBpaal9mT8GT43fN37X3DJWq5Xjx48TGhp6UnpmzJjB9OnTddm31kBNAejJt+k8yZOBoTtbqbxxoFG9roXW3PonhCvMVoHVm1cGUBMnTmTTpk2sWLHC6KQAMHXqVKZMmWL/t9VqJSUlxcAUmZvZghpPFohmG2ZB677r1QJmdDCiZfutufVPtJzR17wnmS2v15vXBVCTJk1i/vz5/PDDD3To0MH+98TERGpqajh69GiTVqiysjISExPty6xdu7bJ+hrf0vvjMo5v7pWVlREZGem09QkgODiY4ODgFu+b+J0nMxlfLRDV1P6c7buaY69XzdLoY69l+75eqxbuZfQ1L/TjNQGUoijceeedfP755yxfvpzU1NQm3/fv35/AwECWLVvGmDFjANi2bRvFxcVkZWUBkJWVxdNPP83+/fuJj48HYOnSpURGRtKzZ0/7MgsXLmyy7qVLl9rXITzDk5mMrxaIamp/zvZdzbHXq2Zp9LHXsn1fr1UL9zL6mtdLa2pJOxWLoiiK0YlQ44477uCDDz7giy++oFu3bva/R0VF2VuGJkyYwMKFC5kzZw6RkZHceeedAKxatQqwDWOQmZlJcnIyzz33HKWlpVx//fXccsstPPPMM4BtGIPevXszceJEbr75Zr799lv+9re/sWDBAtVv4VmtVqKioigvLycyMlLPw9BqyM1pHDn2QojTWbFiBQUFBaSnpzNkyBC3bsuTeZIr5bfXBFAWi8Xp32fPns2NN94I2AbSvOeee/jwww+prq4mOzubN9980/54DmDXrl1MmDCB5cuXEx4ezrhx43j22WcJCPi9MW758uXcfffdbNmyhQ4dOvDoo4/at6GGBFBCuI8EeJ4jx1qciievDU8Gaz4ZQHkTCaCEGfjqRMGezExbOznWwgzM2gLlNX2ghHcwe+HbmvjqRMG+0ofEG8ixFmZg1n6HEkD5ICODGLMXvq2Jr04UbNbM1Ns5yzfkWAszMGvFXAIoH2RkEGP2wrc10WvASbNmXuLUZHwr4UvMem1KAOWDjAxipMbaPG8MRsyaeYlTk/GthLt5Mi9zvDbNko9KAOWDJIgxL28MRqRg9T4yvpVwN0/mZY7XplnyUQmghE8xS83kVPQKRsw2/YzZj3trI8GQaAlPzkaghVkqdRJACZ/iWDPRq2DXaz16FWxmqYE10pqeDRs2kJ+fT0ZGBn379nVX8oQQLvDkbARamKWCIAGU8CmONRO9Ag2zBSxaa2DuainSmp78/Hz27NkDcMoASlq3hPAss7TwmJ0EUMKnONZM9MoIzJahaK2B5eXlsX37dqxW6yl/ryVg0fqYLyMjo8l/nVETvEqQJYR+tOQvrfEelABK+DS9mnrN0mTcyJ2Zlbta25ytt2/fvqd9dKcmeJUgyzhajqs3ngtvTLMaeu2X2VrpPUECKCE8yOjMKjMzk8jIyGaDEXe1tmldr5rgVa8gSzSl5nrVcly98Vx4Y5rV0Gu/zNZK7wkSQAnhQc4yKy0dqd0ZjLirtc3oVjxnx8xXWxX0oqZw1XItRkREEBAQQERERMsT6SG+GiDotV+t8W1dCaCEx/naTeQKZ5mVmo7Uonm+Mu+f2e4NNYWrlsC4oqKCuro6KioqWpQ+TzK6AuAuntwvX3vULgGUaBFfmDLC6DGV1HSkdmS2Y2g0NSMVOztm7mpV0HpNme28uqtw9dXWHNE8X3vULgGUaBFfmDLC6BtWTUdqR2Y7hkZTM1Kxs2OmV4DgGDBpvaZay3k1ujXHm1o5fIle/RnNcv4kgBIt4gtTRphtTCU123J2DN01aKhZMqtTpc8ZdwZLzjgGTO7so6aGmmNk5Hk1+poyutLUWqk572ruATXDsXiCBFCiRcwWDGmhdR/0yoT1etPJXYOGmq2wMeMoyY4Bk9H3hSevFy2cbdvIyWmFZ5gtL2kpCaCE0EivTFjN9DNqtuWuQUPNNn+fGQs/x4DJ6BYWT14vWjjbtpGT0wrP0OuaUzMciydIACWETrQWmo6ZitaCRK9CwWz9gvTYtqcZXdM2crgKNZxt24yBsdCX2fKolpIASgiN9HrU5ZgZGF07d6TXEAHuarFzxtN9JBwDNgkGXGeWQlF4ltGVnZaQAEoIjdz1qEvNtrTSkllp3ba7+gWZMThpTa1rp2P29AlzMbq1tiUkgBJCI8eAQK8AwVmG4s51n47ZWgbUpKd9+/YcPnyY9u3b6759NX3U3FkomL3AMXv6hLmYsUKklgRQQpiMr7RkGVmQunOkazUBrjecQ3cxe/qEuZjtBQxXSAAlhMm4s8VHr8zKXXOk6cXoAMaT59BszJ4+X+FNgYYrvKkFUwIo4bV8NQPxJK1zU6mZOsVsb3kZvW65XoWe1Lwo4Y3XnIxELoQHeFNNxay0zk3lGETIuTg9LcfILAWF8E7eeF+qqaCYZb8kgBJeS/patJyzzMqx0I6IiCAgIICIiIhTrscbzoXRwYiWY2SWgkKYj5rBJL3hvtTCLPslAZTwWtLXwj0cHw2o6ZDtDefC6GBEyzEyS0EhzMfsg6W6k1n2SwIoIUSzfKUQ98b9MEtBIYQWRrf6upsEUELoxBszC2dpdnw04K6pXTxNgpGWM/oc+oLWdAyNbvV1NwmghNcyW0bkDaNRq5mfzl2BhtY3/oTr3HUcfb1A9AS9jqE33Ctmm4hcbxJACY/T62YwW2buyUdEZpufTg2tb/zpxayZsDu46zh642NQs/HknJBGM3IGBU+QAEp4nLObwbFwU1PYebJ2o2YZTz4iMnp+Oi3BiJptqXnjT6vWFJy5K9DxxjGwzHZu9MonWlMwa9Z9lQBKeJyzm8GxcFMzSJyaV/DVUFOwai189QrOHGnNhD05ErkW7pyCxdl1Z/bWUK3pM1t/LyNbEHz10bHZzrE3HsOWkgBKeJyzG9/IZm0129baMuLO4EwPWrftrhqhO4McZ/Q69lqOh9nnE9ST2af1Mdtx9sZgxJ0jo5vt/DSSAEqYgmNQpWaQODVTjGjZtrN1a20Z8eQglFoyJ63bdlft19l69co8na1Hr2Ov5XiYfT5BPRnZWqJm22Y7zmYLGIxuqTXb+WkkAZQwJTWZnjvfIHNct9YWKE8OQqklczL6MYAn+7o5W4+79l+v/dLrMbXWNPoCs/VfVEPNteFsv4x8+9KdI6Ob7fw08jM6Aa744YcfuOSSS0hOTsZisTBv3rwm3yuKwrRp00hKSiI0NJThw4ezffv2JsscPnyY6667jsjISKKjoxk/fjyVlZVNltm4cSPnnnsuISEhpKSk8Nxzz7l714QGaWlppKenu6VW4hgwqQmESkpKWLFiBSUlJR5JoyNPbksvjRlzYWHhKZdJTk5myJAhzWagGzZs4L333mPDhg0tWo8zjufV2Xl2/Jte++WMmnV7cj2e5OzYn4437qeaa8PZfrlrX9XkLWrSrPWaNyuvaoGqqqqib9++3HzzzVxxxRUnff/cc8/x6quvMnfuXFJTU3n00UfJzs5my5YthISEAHDdddexb98+li5dSm1tLTfddBO33XYbH3zwAQBWq5URI0YwfPhwZs2aRX5+PjfffDPR0dHcdtttHt1f0Tx31kocAyat/Sg8WXMyspamtearV+tSfn4+e/bsAaBv374tWpcjx/Pq7DyrGR5Cr9YBd7bImZ27+jh6I2f7Zba3L92prr6BAH9j24C8KoC66KKLuOiii5x+pygKL7/8Mo888giXXXYZAP/5z39ISEhg3rx5XH311fzyyy8sWrSIn376ibPOOguA1157jYsvvpgXXniB5ORk3n//fWpqanjnnXcICgqiV69e5OXl8dJLL0kA5UFGP17Q8rq/pztAm4nRgwNmZGQ0+a+eHM+rmoLL2fWiVydbLYWZs/XqVSh68hp3PM5aj5cv3JfO9suMgY47rC8+wt3/zWPm2EzO7NjWsHR4VQDVnKKiIkpLSxk+fLj9b1FRUQwcOJCcnByuvvpqcnJyiI6OtgdPAMOHD8fPz481a9Zw+eWXk5OTw3nnnUdQUJB9mezsbP7+979z5MgR2rY9+WRVV1dTXV1t/7fVanXTXnqnDRs2kJ+fT0ZGhurWAaNfPdaSEWntAH2q/VAUhSPHaik5epzS8hMcPlZD+bFajh6v4eixWipO1FFdV09NXQPVdQ3U1DWgAH4WsFgs+FkgwM+PsCB/woMDCA3yJzzIn6jQQNqGBxEbHkTbsCBi2wSTFBVCeLD67MAxzVprvmpad9To27ev7i1PjRzPq5qCS8s1D+7rPOzOTsme7PDseJz1GlBWmNsf85vQqHZMei+XiIrtzFkZLQGUHkpLSwFISEho8veEhAT7d6WlpcTHxzf5PiAggJiYmCbLpKamnrSOxu+cBVAzZsxg+vTp+uzIaXhjzUnL4xV3vnpsZI3ZmbxfCli7bTeWXdVYIo+yY/ceag8UEVp7iFjlMIkcIdFymGhLJclUEWk5RiTHCLccJ4g6AqgngHoCqUcB6gigFn9qCaCGACqVUCoIpUIJo4IwjigRHCCKLUo0B5QoypS27FHiqA2JITk6jKSoEFJiwugcG05qu3A6twunQ9tQAv/QXO547LXWfNW07ngjZ9e8mk62jn3v9BpHzBseKXpy22a7zrQG3I68sXxQozG/aVAUZhfs4YKq+UwPnktdwoNAP8PS5TMBlJGmTp3KlClT7P+2Wq2kpKS4ZVtG1pw8+XjFna8eG1ljLj9ey8/FR9i0t5xtxfuo3buBxGO/km7ZS+q+UtL89pFkOWxbWOPd6U8twdTa/51gOarqd1VKMHsOx7H7UBxFO5LYprRnfkN7CpRkjvlFkBYXTrfESLonRhAXGEt0+4aTKhvNUfMYyRseQai5D5xd82r2zbHvnV7jiGltHTU7rdeL2a4zvfrw+cI5bW54mhWHw9j36xpmBb2HPw34h+o/Y4ErfCaASkxMBKCsrIykpCT738vKysjMzLQvs3///ia/q6ur4/Dhw/bfJyYmUlZW1mSZxn83LuMoODiY4OBgXfbjdNxVc3LnoH7ueryiV6uHVmpqjeXHalm78zCrdxxg3/afiTv0E/38tnORpYg7LKX4WRQIPPl3J/wjaIhIIrhdJ/wjk7FaIthfWU9s+zTaJnaGkEgIjgD/IPALAP9A8AsEFKivhfoa/vfxRxw5WEpSTBv+NPw8OGGFaitUHYTKMqjcb/uvtQSlYh/hlmq6WfbQjT3Az03SU6ZEs+VwJzYdSiU/vzOblM7sUeKIXb2F3u330qdDFBntozizU1vatXF+L/hC5g7q9kPrNa+lRc7oVhhfOa9G0qsPn9la1rQ41cs4xSeCeXfBcr4IfJVgSy2cMRIGTTAyqb4TQKWmppKYmMiyZcvsAZPVamXNmjVMmGA7yFlZWRw9epTc3Fz69+8PwLfffktDQwMDBw60L/Pwww9TW1tLYKCtZFu6dCndunVz+vjO09xVc5JB/VznrNaoKAoF+ytZtnU/m/PzaFe6nEGWLUz020qMpfKkYKkmLBG/5EwCknpBbFeITYfYLoSExTRZLvK3jyu6Dv4T+fn5pGRkQLfmC3NLXTUc3Q1Hd8KRnXCwAA5ugwPbwLqXBMtREvyPMozfhwk4rLRhfU1X1u/oyrqCrvy7oQvHCKFzbBhndmrLWZ1iOLtzW9Lj22CxWLzi+lEzto4790NLi5wnW2H0GrxWL0Y/stJr+3pVMtWcU7OPI+ZszL0DFdX87cOfmeb/H9L9SlAikrBc9iZYLLptVwuvCqAqKyvthTzYOo7n5eURExNDx44dmTx5Mk899RRdu3a1D2OQnJzM6NGjAejRowcjR47k1ltvZdasWdTW1jJp0iSuvvpq+wVw7bXXMn36dMaPH88DDzzApk2beOWVV5g5c6YRu+wxWgf108LoTE8vjbXF3r17s2lvOfPzitm7cTm9q3IY7vczt/uVNLnD6vxDaegwgKDUc6D9mZDUl6A28adYe8u5lCkHBEO7dNvH0QkrHNgK+zZA6Ubbf8u2ENNQyXD/nxnub2utqsePjQ1prC7vQU5eT55a341jhBATFsDg9Dh6xgYQp9STqig67qW+1AxRYLbHP55k9FAdatLTmravhTtH9tfidLM+1NU3cNdHPzOo6lvGBi1HsfhhGfMvCI/VvE29eFUAtW7dOoYNG2b/d2O/o3HjxjFnzhzuv/9+qqqquO222zh69ChDhgxh0aJF9jGgAN5//30mTZrEhRdeiJ+fH2PGjOHVV1+1fx8VFcWSJUuYOHEi/fv3p127dkybNs3nhzDwZCZotkxHa0AX3SGdwwdCmL14Gf0rnuIW/zW0s1jtd1WDJYCa9oMI6T4cOg0hIDnT9qjN24REQsoA26dRXQ2U5sPuNbBnLexei791L/38CujnV8AEvqIOf/IauvB9dR9+yO/DQiWNBvyIXbOBERmHOLdrHOd0aUdUmHmOiSfH1jGaJ6f+cRej02Nklwqt3DWOmF7z3Dmu99mvt7K3cDP/DPo3AJbz7ofOQ1qUdr1YFMXE1UEvZbVaiYqKory8nMhIVx+8+D6ztUAtXLiQ7du307VrVy6++OJml62pa2DJllK+XZlD172fc4l/Dh0sB3//PigayxnZBPa4CLpcACFRuqTR8ZiZ7RgCcLQYdq6wfYp+hPLiJl9bLRF8X9ebb+r7sbwhk3La4GeBfh3bckH3eC7sEU+3hAgsDs3yntxXT06PYbQVK1ZQUFBAeno6Q4aYo0DyFLM/xvLGc6Mmza7eX5+t38PUj3/ik6Dp9PErgk7nwA1fgr/72n5cKb+9qgVK+AZvfASSu3Un7/7wC0Elq7msfikv+W+23z01/mHQ4xKC+v6ZoLTz3dLKpNd4SY50LQCiO0LmtbYP2PpS7fgOdiyDwu+JrLZyiX8Ol/jn0IA/+f49+OpEX5YW9+f5XUd4fvE22keHckH3eEb0SmBQWiyB/n4ebbFU8whPK7MFYka33hjJbI+xHHnjudE69MypyoONe47y4Gf5PB7wH1vwFBoDV/zTrcGTq8yTEtGq6TXejRbOxudp3FZdRCJL84tJ3DqXh/2/Jc5iBX9QsFDW9kx+CehDcO9LGHz+hbqlxxk1b2dpOT5uDU7adoazbrJ96mthzzrYvgR+XYTf/i30rd9E38BNPML77A5M47MT/fmq/GzeXX2cd1fvIjIkgAt7JHBWUgwdOndxqTDROq6OOx/hme3RtTdWZPTirsdYzmi5L73x3DhLs9YXMA5UVPPXd3O5TPmWawO/RcFi6/cU1d5t6ddCAihhCnqNd6NHZqUoCl+u+ZVVG39hZO2LTPP/keAA27hKx4LaETzgRvzPGkfDsQACCwvp7IH+D2rezlIzVYgjj9V0/QOhU5btM/wxW+vUtkWwbSHsXEFKbSF3+Rdyl/8n7A/uxLyaAXx0YiCf/1zH5z9DSKAfF+4t5eIMC8O6xxEW1HzWpXVcHWfHVa/CzBtbFbQwW0ubM3qdUzXrMVvg7Mid50vLCxg1dQ1MeC+XGOsvPB08GwDLsIch3b2VVC0kgBK6cuekslqaiF1Nz+rCQ/xvwdcM3z+H2/zW4Rdg6yJ4LC6TsKGTCev+J/sjuuRo92SIzjJcd2Vy7qzpNpvmtp1h0O22z7HDtkBqyxew4zviq3dxG7u4LfgT9oWdwee1g3i34mwW5DewIH8foYH+XNAjnkv6JDO0Wxwhgf4nbdudc+NpZWSrgieDGrMHDJ5m9sDZnefL1X1XFIVH522iYFcx84NfJojfxns69x5d06UXCaCErrTejHqNd+N4w6pNz8/FR/ho4Tecu/efvOC/Bn4rk493/j9Ch95NWKfBHhtzxFmmo2Y/HB9FGt0S4NrkuReQ3O8vcKIcti6ETZ9C4XckHfuVO/iVCSHvsiuyPx+cyOJ9ayYLNtazYOM+IkICuKh3Ipf2bU9Wl1j8/WznyJ1z4+nFV4MaswcMnubJwNnb36x8c/kOPlm3i9lBb9DBcsBW0br8bUpKS03ZqikBlNCV0TejY2Z1uvQUHzrG2198y5lFb/GM30r8/RUasFDd7TJCL5xKaHx3j6T7j5xluFrG6fKGloCT0hgSBZnX2D5Vh+CXLyD/Uyy7VtDZuo6HWMeD4SFsiT6ff1gH8VVFVz5et4eP1+0hPiKYyzKTueLMDvRI8uzbr6brf+bA6PtS6M/ZNaflmnJngOdKer7cUMLzi7dxT8D/ON9vIwSEwNj3IDSawtxNpszLJIASuvKWzo+V1XX8a2keYWteYZrfQoL96wA41uUiwkY8SmhCL4+lRU3hq+W4Gl1oqpk897RjyZx1s+1ztBg2fgwbPsLv0HZ6H1rMqyzm+dj2/Ngmmxf3n8UvFdH888ci/vljET2SIrmiX3su65dMfETIKbevF0/2P9OrU7K7WsDMFrgb3RLrLs6Os9H3vCO16Vm38zD3frKBS/1WcWfAPACODHmctokZLq3H0ySAEqoZ+aacWo7bd8xkFEXh09xifvn6LW6v+4A4/3IAqjqcR/jFTxCW7PmZvd1V4BgdzGp5LHvKYxHdEc6719YXYu96yHsf8v9HcNVehle9w4XM5lCnwXzGcF7Z05Vf9ll5ep+VZxdtZVi3OK7sn0KPqDp279rp9QWplutFr9YKNcxW2Lnr5RO13LVuZ8dZzT3nyTzaMT3Otr3zYBW3/mcdPep/5cWQt0GB/MgLKA/IYMgp1mMWEkAJ1fR6U86dmhvVtuhgFf/86BOu2T+TK/12ggWq2nQm7JJnCT9jpGHzKjmb++l0tL6mb3anLXwtFujQ3/bJfhp+mQ8/v4ul6Hvala3kNlZyS3QcW+Iv5Y3ywXxdEso3v+znm1/2ExFkoVd4FaMr6rla52tTTWubI9f6iLVs7jk1rRVaC1bH32kt7Nw1uKXW8Yn0YrYKkpHjmjlu+2BlNTfN+YmgY2XMDnuZwIZaTnQ8n/Kuk00TgDdHAiihml5vyrmT4/aTk5OJS0hk9nebCPphCk9aFuHvp1Dt3wb/YQ8QPuh2CAgyJK2NHOd+csYxs9L6mr7ZuVQoBIZCn6tsnyM7Yf1/4Of38Ksso3fRv3mLf1PV9XwWho7ihcLOlFXWsbomjNXfV/Jx0UquPrsjo/okER7c8mzQXTVkveaeU9NaobVgNduglFpenXdnvqXXuvUKMI0c1+yPlcWKE7WMe2ct+w4eZl7oTGIaDkNcD0KufY8hId4xg4cEUEJXRje1Om4/f085n3z4L26rfJMOfrYpV6q6jSH8kr9Dm7gWbUtLhqa1RcExszLja/qGatsZLpwGQ6fCr4sgdw4ULCN89/dcxfdcGdWBwh5X8ZZ1MPO217G++Cjri48y/avNXJrZnmsHdCSjQ5RbH1M7thpq6SOmlV5BhJrrV6+hTLROq2N0Jc6RljzR2X5q6WenV3qc0XKcGyuLh45aeWbuOraUHOXt0H/SXdlhG2n8mg9tc296CQmghGpGP55zRV19A7O/+Zn4FY/yhP9K2+O6sPaEXf4q4V2H67INLcdDa4uCY2Zlttf0TdM/zj8Qelxi+xwugtzZsP5dLOV76JI/kxf83+CpvpeyMOxSXtsWRdHBKj5cW8yHa4vJaB/F2TE1JJzYDej/mNqx1VBLHzF3UrMtZ4W4u97+1DqtjpZjZra8zWzpcUZLf6uIiAgs/gHM2ljD2r1WpgV/zAhlFfgFwNh3ISbVQ6nXhwRQQjVP1uxaUtgWHzrGO+/O5rYjL5Dsf5gG/Kg+63bCRzwCQeG6pVFN3yWtUxk4Mrpl73RM2T8uJhX+7wkY+hBsmQdr/wl71xHyy/+4gv9xefv+FPS9jjcPZLBg8yHy95aTvxeC/WK5QKmjXbqV7okn14adnUM112traTXUeo0313+xpes+HbO1WjlLj5Z+dkZzPKflViuf7Q5lg/UENwcu4WbLl7YFL30NOnvHpMl/JAGUUM2ThbiWwlZRFD7/aQeVCx7lcctCsEBFeCfaXP1vQlPO1j2NavouaemP4Y3UBJNaHxG1WGAI9L3a9tmbC2v+AZs/w7I3l657c5nZJoGnh97Ep5b/442cA5RWNfB1QRVfv/wj/Tu15S+DOnJR7yT7iOfOzqGa69Wx1dDoN1a1aN++PYcPH6Z9+1PPSab1GnfWf9FxPe66f8x2X3py393pj+dUURS+3B3EBmsIF/n/xKP+c20LDXvk9wnIvYwEUMLj9OrH8Mf1tG2XwGsffsHoHY9wht9eACozxhFxyYyTWp082RnTXW86mY2zYFLL21laW6lUH5/2/eGKt2HEk5A7F376F1SWErbyWa73n8kVXUax0HI+C6u68mNhObm7jpC76wjTPt/IZRlx/PXCXqTEhJ20Wr3ejDM7NZUGrbwxQBDNazyniqIw/ast/G/jQfr7/crrwW9iaVCg/4224Um8lMsB1Lhx4xg/fjznnXeeO9IjWgG9+jE0rmdfZT07N7zNncfeJNSvhqOWKHb3uZuMy+/WvH01tPRh0doR1OyFrbMAQkua9Xr8c1pt4uH8++Ccu2xz8K1+A0p+JvzXz7iKz7ik/WBOjL2Tdw90ZfaKAg6fUHgvdz/vr9/PBd3iuT6rE+d1jcPvt6lj9Hozzuy8Mc3CWIqi8MT8LcxZtZM0SwkfhM/Ev7baNsfdxS8aNnyMHlwOoMrLyxk+fDidOnXipptuYty4cc025wrhSGsm7Kw/0fq9lbRZNZP7/L4DCxxoN5AdPe+iY/dTD4hptkLAG98scuQsgNCSZr0e/6gWEGQbBiHjSti9lgPznyB2/0pC9q4i5PNV3BnXnWuHXMsHh7vzw4FQftpdwbKt+1m2dT+dY8P4y6BOXHVWClGhgS6n2RtbXLwxzVqZvdXXaGqOj6IoPDn/F2av3El7DvBV1AsEnyiH5DPhynfA37sfglkURVFc/dGBAwd49913mTt3Llu2bGH48OGMHz+eyy67jMBA1zMSX2O1WomKiqK8vJzISO95JdPsFi5cyPbt2+natSvZIy/iH/OWMDTvXnr4FdOAhWOD76fN8AfAz9/opNo5ZjLOMp0VK1ZQUFBAeno6Q4YM8dnHfN6gpKSEvZtz6FG+nDa/fgY1lbYvwuNgwF8pShvLf/Iq+F/uHipO2Kb/CQ30Z3S/9owb3Mlpp3NXty/n0EbrMAZ6cbwvPckbroPTHR9FUXhm4S/888ci4jjKtzHPEnGsGGK7wk1fuzSMjCePhyvlt5+WDcTFxTFlyhQ2bNjAmjVrSE9P5/rrryc5OZm7776b7du3a0q4EGocr1N4+e1ZXLfhRnr4FVMV0BblL5/TZsRDpgqe4PdHS4WFhadcJi0tjfT0dHvrSV5eHrm5ueTl5em+LbMrKSlhxYoVlJSUGJaG6tAErIOnwpQtMOIpiGwPVQfgu6dI/c9AHvOfw5rbu/D05b3pnhjB8dp6PlxbzMiXf2Ts2zl8nb+PuvoGTdt2PIdmOB5GcXY9e/Iad7wvPUlrHuBJzR2f+gaFR+Zt4p8/FhFFJUvbvWQLnqI7wg1fuDwGn1nvixa1n+3bt4+lS5eydOlS/P39ufjii8nPz6dnz54899xz3H238z4oQmiRmZlJtX84e3PnMbl6Nv4WhcMx/Yi58UOITNJ1W+7qaK7XyNJqtuWNjO7r1XT7Q2DwnZR0vJSKnP+QVrqAwEO/wNp/EPbTv7iu52Vce9XfWFvdi//k7GLR5lLWFB1mTdFhYsP8OTOikhvOSePcAWeq3r6a66W18OQwBs548nGlJ1tYtIzZ5uw3pzo+tfUN3PPxBr7cUEIby3G+jX+V6PICaJNoC56iXO/yY9b7wuUAqra2li+//JLZs2ezZMkS+vTpw+TJk7n22mvtzV2ff/45N998swRQQlf7jvvB6leYpCwDCxzqehWxY9+AgGDdt+WujuZqCgCt470Y2T9Fr8ctWsdY0ovTzvA7d1NQlcKBzOcZ0r4eVr4KO5bB5s+xbP6cgZ3PZeA5k9k3aijvr9nNh2uLOVRVw9JjoXz3eQmX7/Jn3ODO9G4fddrtq7levOHxjh58pb+VmvPlmN/oNeaTmkmk1SyjNj88UVvPHe+v59ut+4nwq+a75FnEHtxkG2X8hnkQo21/HK8FLfOHuoPLAVRSUhINDQ1cc801rF27lszMzJOWGTZsGNHR0TokTxjJTBn14p82E/PVzVzut5V6/Kg6bxqxwya77Q0Od9V0tby55w20jhrtyNm+6zWFhdbtN7kWkpMhbSiUboJVr8Gm/8HOH2HnjyQl9Obec+5i0n2X8tai9XySd4CSEwF8kruHT3L3cFanttx4TmeyeyUS6K+u94TWMad8lTfuu5o0qxkDS69tq2nNcVxGTX5YcaKW8XPXsbboMG0Davg26S3aHvgJgiLg+s8gvkeL98e+LTcOp+EKlwOomTNnctVVVxESEnLKZaKjoykqKmpRwoTx1NRUHLljSo9Pv11J5vLxdPHbx3FLOJY/v0Nkj5Gq9kFry4iaDMw005e0IH16Mfpxizs5vRYSe9vGk7rwUVj9lm3uvbJN8NmthEQ9yd1ZE5k89S+sL61l7qqdLMzfx7pdR1i36wiJkSH8ZVBHrhnQkdg2zbeeunPuOU/S614xS8uDK4y8D5xtW01rjqsB3L7y49w0+ye2llaQEFzLNwmvE7F/HQRHwl8+g+RTvxWthVnyFpcDqOuvv94d6RAmpOW5s55TeiiKwnvz5pOdN4l4v6McDYwn4pYv8U9QX5PRq2VE7bq1LOMunty2swxXr1q0qaewiOoA2U/bBgP86d+wZhaUF8OiB7B8/3f6D7iN/pfexsOjevD+mmI+WLOLUusJXljyK69+W8AlfZK56ZxTP95T02fO6FYZLY+o1Dw2csYsLQ+uUHMf6HUOtQxeq2VGhT/aXFLOzXN+osxaTafweha2e5XwslwIjoLrP4cO/U+ZPq3M0krv3YMwCLfS0n9Hr2XqGxRmvzuHsYVTibAc50BYV9r99Qssf+iAqHX8JL1qL3rtq7uYpZbWUo7XodEtLk63H9rWFkRlTYS8D2yP944UwffPwqpXSTjzBqZkTWTisAtYmL+P2St3snFPOZ+u38On622P98YN7kzfGIXiXUVNxjqD5s+hsxYENZ2A9TqOWh5ROXssa/b7yRlPzmqghl6D1zqbBNhZy9932/Yz6f31VNXU0zfOwsdhMwkuWw8hUXD9PGjf9AUKo4N9vUkAJVRzFvVrqfGcbpmaugbe+9cL3LDvWYIs9ZTGnE3ibZ/abso/0DqiuV61F7P3ZzJLLU1vRmfCzW4/MBTOHm+bomLLF7DyZdi3wdYytfafBGdcyeXn3MXoiefw8+6jzF21kwUbf3+81zbYQmZEJVdWN7SoBUFNJ2C9jqOawl+ve0VLMO3OgFtN/zy9ugyooSUQU9PPbu/evRw6dIi9e/fa53N8f80upn2xmfoGhZGd/Xij4Wn8y/JtlYnr50Fypm6TqZuVBFCiRdQ0zbuSgVXX1fPRrKe48cBM/CwKJR0uJvnGOU7ftPO1m7E5raUvlRpGn3dV2/fzh95XQK/LoXA5rJgJRd/Dxv/Cxv9i6ZrNmUPu5syrs3j4YtvjvffXFHOwsprvqsNZsaySbw7mMW5wZzJTol1Oj+PfnLUg6HUctQQ1ej2W9eRjdK33gdGP0rVo7tqoqWvgifmbeW91MQC39vbjoUMPYTlSaBtw9vrPITED0G8ydbPlQY0kgBItoqaflCuvwP7vzUcZd+QNsMDertfR/prXwc/5G0u+2sLijJGFgJptb9iwgfz8fDIyMuw1VHfxqvNusUCXYbbP3vW2FqktX8L2xbZPykDiz5nM3ReOZOKwdBbm72Nuzk5+Lj7K5z/v5fOf99I3JZpxWZ24OCOJkMCTB4pV08rqrJXKXcdRa8uwFno99lNT8XO2X46BoJpO/0bT0iLWuJ9RCSlc+8/VrNt1BAtwZ+o+7to7A8vxg7ZBMq+fB7Fd7L/Tq9O/0a3OpyIBlGgRNf2k1GQgJ2rrmff6/fyl/F8A7Okxng5/ds9Ek2atzTTHk30ktDS75+fns2fPHgC3B1BGc3YMVV1T7c+EP/8HDhbAqldhw4ewew18dA3EdSdo8N8YnXEVo/u1Z+Oeo8xZtZP5G/axYfdRpuw+ytMLfuHqASlcN7ATydGhLqXZk4W4J7elpluBGmoqfmreaNNroFx35lFahxcprQvllvdyKbNWExESwGNpBVxa9CT+ynGI72l7285hQGO9Ov2bLQhtJAGUcLvTZSDHq+tY+PpdXF3xHgB7Mu6kwxVPum2MJ7PWZprjrhq7mreh1Gy7Q4cOHDlyhA4dOrQ4jWbnLDN36Zpqlw6XvgrDHrINgbDuHTiwFb64A757GgbdQZ/+43jpz5k8dHEP/vvTbt5bvYt95Sd447sdvLV8B8N7JHBDVmfOSY/FouI+8WSrndEthFoGgVRT8VOzX0Z2BnfGWcuwq2lUFIX3Vu/iiflbqK1X6BrfhvezSoj7ZjoWpZrqhDMJvvEzW98nB1qOhyujnhtNAigBePaNnD+qrqtn0Rt3Mea34Gn3mfeRcukjmrevhllrM56gpsas5ZFHYzN9QIDvZynOMnNN11REIvzfdDh3CqybDavfBOteWPIw/PAcnH0L7QbezsRh6fz1vDS++aWMuat2kVN4iCVbyliypYy0uHD+MrATY/p3ICrUHBO5G93C63gutHZy11JoG9kZ3BlnLcOupPHosRoe+HQjizeXAXBRrwRebv8NwYtn2BY4YyTBV86GoDCnv9dyPLS0khvF93M7H2dU4HMqrtz4dfUNfP3m/Vxu/S14OvthUkbdr3pbWvfdrLUZI2jNqNU83jAbrdeLlj4jLr1MERIFQybDoAmw4SPb471DBfDji7Dqdci8loDBdzKydxdG9k5ie1kF767exWfr91J4oIon5m/h+cXbuCwzmesGdiKjw8ljSnmywDG6hdfxXJjtfvfkW3kZGRlN/uuKdTsP87cPf6ak/ASB/hamjkjjpkMvYfnhv7YFBt1hm2xb5wnc1eQlRl9jjSSA8nLuDHy0ZLpqbvySkhIKduygbP1XXHXE1uepKPM+Ul0InsA8N5GvcdfUE0bXGrVeL1p+p+llioBgSpL+j8LMVHr6FRGz5T+wdx3kzraNdN59FJwzma4pZ/PEZb25f2R3Pv95L7N/LKDw0Ak++mk3H/20m74dorhuUCcu6ZNMaJB/i/ZdC28Ipo3kyXPRt2/f0/ZJdLwv6+obeGv5Dl5etp36BoXOsWG8eXlnev5wBxSvAos/XPy8bbgON/Dko9KWkgDKy7nrVWRw342+Y8cOtn3/EbfW2VqeCnreSfpo1x/bmeUm8mbOzrGaN2fc1TSvlZqBI7VeL1p+p/VlisLCQgp2FEJ6OkNu+QZ2rbK1SP26CLbOh63zqU7sz46Ei4kecDXXD+pE59pivs0vZVtdHOvK6tmwp5wN/9vIk/O3cEW/9lw7sJPmN9G00Np64sk3OR2p2Xe90me2fOuP92WVfwT3frKBDXvKAbi8X3ueHlhL2OeXQPlu2+jif54DXS7waBq1jDfoCRJAeTl3XkjuutEPbP3eHjz92vUWzrjqSU3rMctNZBZaCkBn59hd02W4s+BQ03FYrze21NDap6bJMbJYoPM5ts/+rbbRzTf+l+DSXHqW5nJs+ztwwb106TQUi8XCrWlpBEXG8sm6PXywdhe7Dx9nbs4u5ubson+ntlwzoDP92yWccttGt+ga+Sanmn13Z/qWL19uD86GDh2q67pPJy0tjfoGhZWHw/n3qyuoqW8gIiSA6Zf24gq+hXfvhfpqiEmDqz+E+O6AukqLGmoCU6OvzVORAEqckl4Byh9vrK0/LeGyPS+ABX7p/Bd6XPuC2962a220vp6spUO0ux7vaqWl4zCoO2ZqRpvWyymPUXx3GP0GXPAwFcteIHTzR4Qd2wvz7yY5LJbks2+FyG7QJpgJQ7vw1/PSWLnjIB+sKWbpljJydx0hd9cRpn+5mUszk7n67I70bh/Z5A0+oyfqbUl/nZZSs+96pc/ZNZefn8+RI0fIz8/3eABV6R/BzHw/8naXADCsWxx3D4oi/scpULLYtlC3i+HyWU1mg9DytqMzagJTs7XaNZIASrhdYwFUuGUtf977DP4Whc0Jl9Jr3OsSPOnInY9zHXkyqFBDa8dhvV6z9pjIZCIufwkung4/vwc5b9omL/7+Wdto533+DIPuwC+hJ+d2jePcrnHsrzjBJ+v28N+fdlN8+Jh91POeSZGMPTuFyzKTiQ4LMnyiXjX9dfTieA7V7Lte6XN2zWVkZNhbYVrClWuzqrqOV5dt598riqhrUIgICWDan3pyZWoNlXP+TERFAQp+WC58BM65+6QBjbVUWpylT01gatanDRZFURSjE2FGb7zxBs8//zylpaX07duX1157jQEDBqj6rdVqJSoqivLyciIjI92cUvNbuHAhW/PXMv7Y20RZjrEl4hx6TP4Ci7/7X7vWq7AzugO02SxcuJDt27fTtWtXLr74YlW/MfoY6vUW3ooVKygoKCA9PZ0hQ4a4McUq1NfBL19AzhuwN/f3v6cNs01s3OVCe8HX0KCwuvAQH/20m0WbSqmpbwAg0M/CiF6JXJAaSlz9QdK7dPH5a9zxHBo9p55e1FybiqKwaFMpT8zfwr7yEwCM6JnA9Et7klT0OSy8D2qrqA2MxPp/LxE74CqPps9orpTf0gLlxH//+1+mTJnCrFmzGDhwIC+//DLZ2dls27aN+Ph4o5PndZLjoul/bC5RlmMUBPfkjIkfeyR4Av1aSrxpbBJP0DKXmTuPoZrfaX3E4Fj7defjBJf33z8Aeo+BXlfA7rWQ87qts3nhd7ZPbDoMvB36XoNfcBsGp7djcHo7jlTV8NJnP7K0oILS6kAW5O9jQT4kRAYzuqKcK/wi6JZozKM8T3B8ZKemhcOs/XD+6HTX5rbSCp5e+As//HoAgJSYUKZf2osLOgXD/Dtg8+e2BTufS+Dls4iN0ndgXLM+itNKAignXnrpJW699VZuuukmAGbNmsWCBQt45513ePDBB09avrq6murqavu/rVarx9LqTnoEBEcOlhG98FYSLIcp9k8hacKXBIS00TmlLaNmP71hbBJPBnBamtTdeQy1jjathTsfJ2gOMi0W6DjQ9jmyE9a8bXvEd6gAFt4Ly56EM6+3vXoek0bb8CAmXNiD7NRC6iISWb6rmnl5eymzVvP2D4W8/UMhvZIjueLMDlzSN4n4iBC37G9z3Hk9a3lc6Q2F/6muzdLyE7y0dBv/y91DgwJB/n7cfn4adwxLp3LDV5x45V5CThwAvwDbCPnnTNZ9fKfm0uetJIByUFNTQ25uLlOnTrX/zc/Pj+HDh5OTk+P0NzNmzGD69OmeSqLHtDQgqKk+Qck/xtBL2UOZJZawm78gPDpO72Q2S01LiV6Tn+o1lpZWRgdwp+PO8V20jjZtNroEmW07w8gZtoIw7wNYMwsOF9pap3LegK4jYMBtJHe5wP77oX1h6sXd+W7rAT5bv4fvtu1nc4mVzSVbeHrBFs5Jb8elfZPJ7p1IZIhnWo/deT1ruc684fpxZD1Ryz++L+RfKwo5UWt7ZHtxRiL3Z3enc5t6WHwvIeveAaAqOIHw6z+EDv1Vrbs1tbifigRQDg4ePEh9fT0JCU1f901ISGDr1q1OfzN16lSmTJli/7fVaiUlJcWt6fSEltS4lIYGNs66ibNq8qlUQjnx54/o1L7LKZd318144MABdu7cSUREhH29WibL1UoGMHSN1kLKGws3Z3QNMoMjYOBf4exboWAprP0HFHwD2xfbPjFdbC1Sfa+BsBiCA/wZ2TuRkb0TOVJVw/yNJXy6fi95u4/y4/aD/Lj9IA/P28QF3eL5U98kLugeT1iQuiJEryE2WnOh7cq+lx+r5Z2VRcxeWYT1RB0AZ3Vqy0OjenBmx7aw/Rv4z11gtb39lh90FiW97yBbZfAE5q+weYIEUDoIDg4mODjY6GS4xN3TCeR+OJ2zjiykXrGwY+jr9O3ZfAd8d92Mzl6R1TJZrhpa55XTwpsm3BT6UnOeT7o+zsi2fQ4WwLp/2x7vHd4Bix+CZU9Arys4kHop2yrakPZbJ/LrszpzfVZndh2q4qsNJczLK6FgfyWLNpeyaHMpIYF+XNg9gYszkhjWPa7ZYEqvITb0yie8sfB37M/pLA84XFXDv1cUMnfVLiqrbYFT1/g23JvdjRE9E7BUHeTYB+MI+3WebaVtO3PwnMcpPxFHhgcGmPU1EkA5aNeuHf7+/pSVlTX5e1lZGYmJiQalyjVqgiN3vob+y7fvc+avr4AFcs64jyHDrjztb9w19pCzV2TdtS1n63VXUOONBYDwnFNeH+3Sf3u89zDkfww/vQNl+bDhA+I2fIBfUAeO7L0URj9oH/OnU2w4ky7oysRh6WzZZ2XBxn3M37iP4sPHfut8vo+QQD/O6xpHdq9ELuwRT3RYUJP0ON4bWluS9Cq0faHw/+M5PhYQweyVO/ls/V6O19YD0D0xgr9d2JWRvRLxU+ptLZDfPk1YdTkKFko6Xkb7v7xJu6BwtLwPZ2SFzSwtkRJAOQgKCqJ///4sW7aM0aNHA9DQ0MCyZcuYNGmSsYlTycjCde+WHDr/MBk/i8KPbS9nyLUPqfqdXmMPOd5YzsZucdcbN57MUDxZAJgls3IHX923014fwW3grJuh/02wZx2s+zfKpk+JrdlD7NY34cU50Oty6H8jdDgbLBYsFgu9kqPolRzFfdnd2LTX+lsAVcLuw8dZsqWMJVvK8LdA91h/hvdMZMzAM+gYG3bSveHs/vLkJLvuulfdORyCY3/OzqmpbNhfy2sbG1gz/wf7cp2j/PjrkE6MPacHfn4W2LnSNjTB/s0A1LTryS+p44nrdzEEhbdgb41jlgqkBFBOTJkyhXHjxnHWWWcxYMAAXn75Zaqqquxv5ZmdmsJVy2vop3Ps0F6CPrmOUGrIDezP2be/3WSkY0/Q61V5s9dQPRmsmSWzcgez75vWwlb19WGxQMrZkHI2luxnYMNHsH4uHNgKee/bPu26Qea10PdqiEj87WcWMjpEkdEhigdGduOXfRUs3lzK4s2lbC2tYPPBejb/sJdXfthLenwbLuwez9Bu8fTv1JagAD+n95e7zoXZXuRo6XAae44c45VvtvNJ7m72HDkO2E7j//VI4KzISgKP7CTFEoHf4R3w7ZOwZZ5tBaFt4cJpBJ05jr5ueMPOk4weNb+RBFBOjB07lgMHDjBt2jRKS0vJzMxk0aJFJ3UsNysjmlaVumr2/WssXZRDFNKBjrd9RMhv/cK0TMLp7Ddqgj69XpWX5unfmT2YbAmz75tHA7ywGMi6AwZNsI0ptX4ubPoMDm6Dbx6DZdMhfbgtmDrjIgi0DW1gsVjomRxJz+RI7v6/M1i7pYgv1hXyizWADSVVFOyvpGB/JW//UEh4kD9ZXWI574w4zu3ej6TYMPvm3TUqvNZj6K6O71r2s7K6jm+2lPG/3D2s3HGQxuGvI4ID+PPZKYzL6kzH2DBKSkrYs+UovfbMhWWfglKPgoVjPf5M+CXP2s6xgfTK24weNb+RBFCnMGnSJK95ZKeF3oMabvvP3+h+PJ8KJZTKK+aSFvf7gKNaJuF09hs1QY07X5XXQkuGYbZWEV/unG72fTMkwPvjmFIjn7UNrpj3PuxeA9uX2D7BUdDrMugzFjoObjLNx4CeqQzomQpA+fFafvj1AN9u3c8Pvx7gUFUN3/yyn29+2Q9AUlQIWV1iGdylHVldYpuMTq1XcKS1z6OWfqJqOr6rveasJ2pZ9ksZC/NL+f7XA9TUNdi/G9wllqvO6sDIXkmEBv3WmlR5gOTNs0he8zbU2UYYP9RuAD8GDaNd+/MYYnDwBPrlbWap+EgA1UrpOajhrmX/oHvxRwDk9J3BiL5nNfleyySc7pxY1OyPv8ySOZiF2Vrk9OLJPj9qtu80PSGR0H+c7XNwuy2Q2vgxWPfC+v/YPpEdoPcVtk9SJiX79jVZzyV9k+kfB5cnV1AfkcqWI/DDrwdYX3yEfeUn+Gz9Xj5bvxeA9tGhnNW5LWd1jsH/8E5OlBXZj4Mzeo3/5c5WKrX3s6IoFOyv5PtfD/D9rwdYU3jYPt0OQGq7cC7pm8xV/TuQEvN7yx1Hd8Oq12wthr8FTqQMguGPUx3YiXa/pc8M9HqBxywVHwmgWim9WmrKd6wl8UdbR/H5MeMYdfmNJy2jZRJOT04sqoYn3xoyS+bgCe58BOMuegV0WjtS68Vx+6c9zu26wvDH4YJpsGslbPwvbPnCNpbQqldtn5g06iPP4lBNZ1AU+3oKCwsp3LGD9HQLE4cNYeKwdI7V1JG76wg5Ow6xasch8veWs/focfbmHeeLvBIAQgLi6FlZz4/WX+jTIZo+HaLo0DbU3rdSr3vF2X3qrkF4G89xamoqtcHRrNt1hJ+KDrOi4CB7jx5v8tsuceGMykjioowkuidGNOlTun/T9ygrXyO+9Dssim3IAtr3h/Putw1ZYbGQ3Ey6jODsfDle82a735sjAZQ4pdNlTvUVB6j94FqiqGWV/9mcf+vzHu80rgdPzqPmq60pWnlyChZnjHzE6smO1Gq2r7pjrp8fpJ5r+1z8Avy6yPaY79fFcLiQlMOFpAB1lR/B8cug+yWkpXZusi2AsKAAzu0ax7ldbbMTVFbXkVd8lHW7DrNu5xF+Lj5CVU096/dWsn5v5e+/C4Cu8eH07dSObokRdE+MIK1dG9qGNx06wRXO8jq9KpklJSXs2LGDqMSOHGoI5eucLeTvsVKy1Ep5tdJk2aAAPwamxtAvMZj2fuUM6ZNO+/bt7espKviVHn5FxBR8SvzOH3//Yep5cO49kHq+7RFsC2m5L7TmbY7XvDe1wEsAJU6p2RuioYG97/yFjvUHKFKSiLthLhGh2gcTNTKwUNPXQa+b2ptqV56g1yMYrYx8xOpsvzz5dpHj9p11zD3tfRkYAr1G2z7Vlb8HUwXfEGAttj1aWvUayW0SST4jG9plQ7sop6/PWw/th7JC/twzjcnDz6CuvoHt+yvZuOcoG/eUs3FPOVtKyjlWBxtKqthQUtXk99FhgaS1Cye1XRtSYkJpHx1K+7a2/yZGhRAc4N653RRFobK6jn3lJ9h5sIpdh46x81AVeTv2UnSklmP11j/8MhhQCPL3o0+HKPp3bsugtFgGpcYSGuTPihUrKCgooqjI3xZAHdlF7Td/J3PXfMLry23bs/hxqN0glMF32oYk0NHKlSspLCxk3759XHXVVap+ozVvc7yfvKkFXgIocUrNBRZ75z9DxyOrOa4EsX3oW4zo1L5F29Jy85l98lxnvKl21cidx9nozFLLAI/uTLOWt4v0Oj/OgjeX7svgNpBxpe1TXQk7lsEvX9lapipLbX101s8F/2DoPMQ2J1+XC2yPBi2Wk7YV4O9Hj6RIeiRFMvZs2yZ27d7DyvwdnAiJpeyEP1tLK9heVkFJ+QmOHqtlffFR1hcfdZq8yJAA2rUJJrZNELHhwUSGBtAmOJA2IQG0CfYnLCiAQH8L/n5+BPpbCPDzo15RqKtvoK5eobahgeraBipO1FFxotb23+paDlbUsL/iBPsrqjlWU3+Kg+OHnwW6xLWhR5LtjcWzOrWld/soQgJPDuzS0tLwr6uiR816mP0M7FpJp9++qw+Nxf+sm7CcdRPtojo0f040OnDgANXV1Rw4cED1b7TmbUbnAS0hAZRwWdWv35O4/kUAPk+6m2uGDm3xOrXcfHq15rhjTKxT8cbMwpdbzRzPhyf31VngY+R94Cx40xzwB7eBnpfZPnU1sPMH+HWJrYXq6C5bcLVjmW3ZyA6QNpReMZkEpiSQ0sy2OqV0oFPKyUHD8Zp6ig5WUXSwisIDlba+VL99So4e50RtA9YTdVhP1FF4sMrJmvUTERJA59hwOrcLp3NsGNWH9qIcLSGrZycuOP9c+3lPDgolJNDhzbhjh+HXxSRvnU9ywTe/dwrHYntk2u96/HteBgHqWvu1BtdxcXFYrVbi4tRP/q6mf5OvkQBKnJKzwEKp3E/txzcTTgNf+w/l7BF/YeXKlS2+QbQEFu58lCJ+p9djJW/ITD3ZQugs8DHyPnC2Hl3ujYAg2/hR6cPhor/DwV9tgVTBN1C82tYJPe892vIeAwG2pEOnwdDpHOiYBdEdT9uvJzTI3z4WlSNFUSg/XsvByhoOVlZz6Lf/VpyopbK6nsrqWqqq6zlWU0ddvUJdg0JdQwNVx6qpqT5Om/Aw2oSFEuBnISjAj4iQQCJDAmgTHEBESACxbYJJiAwhPiKY+Mjgk+YELCmJoLAwyH5cm5z3pCTboKU7voNtC2HXKlD+0IoV1902VESfP4OG1iatwfU555xDUlKSdFk4DQmgxCmdlHk2NFA2dxyJdQcpUNqTfO2blJUUGXaDGB34qHoN3Ado6hvjhK9npq4yWwXAI/eTxQJx3Wyfc+6CmmNQnAOF30HhcijdBIcKbJ/1/7H9Jjze9nZZh/7Q/ixI6uvSgJAWi4XosCCiw4JIj2/jdBln17OtH1Ip6enpDBlytuZdbnJcFYWusX7ElxTRYedSWH0zVDadd5WE3lS0P4+CwO4k9BlOcnvt3SPUDOypZmJyo+cuNCsJoIRqhxc/S+KBVRxXgvjp7Je4pkt7SkJtNUNfvUGa4/Jr4Cag1+jK7up8bXQQ6slzaLYKgCHrCQqD9AttH4DjR22tUrtW2j77NkDVfvj1a9unUWR7SOgNib0hoRfEdoXYdAgK01SxcXbetfSPa6KhAcqLYf9WKFlvm3Nwby4JJ47SZE6LgBBbS1v6cOg+CmJS+XHhQrb/up2uyoYWBVDOrjHHvq2emH7GV0kA5YPcUQjVFa8las3zAPyn7SRuuTgb8P0bpDmOGaw31Lb0miTZXeNbeXLaDWfMMseWJ+gVLGqZ5PuUQqOh20jbB6D2OOzbCHtzYa8tAOHITttAnta9sH1x099HdiA0oB1xNaHUFqZD3yEcLD5CWWkV/nXHbI/MnDwOVPP40unxqqu2paN8j21Ay/LdcLjI9lju4K9Qe+zkffQPhuRM6HwupA2FlAGq+jS5q3Kh5l72hrzNCBJA+SDda9HVFVR+cBPRNLCIwVx24/34+znvk2B0C4InOWaw3hBMmu2xkSOt6XNnR2pfpeVY6zXWj2qBob9PK9PoRDmUbYGyTVCa/1uwsh2OHwbrHtqyh7YAlTlQ+C59gD4Ae4EfgyG8HYTFQshvwykEhpEcFE5yYChs8IONfoDFFmjV10Ldcag9Qf+KI/SyHiI8rxrWVdg6fNdUOkn0H/gHQbszIDHjt8eQZ0F8L1u/sGY463/qrpdm1NzLnszbvKkMkQDKB+ldWzj86T3EnNjDXiUW5U8zSYwOPeWyRo+uLJpntiDP8drQmj53dqT2Ru4ajsHZ/a3XJN+qhURBpyzb54+OHYaD2zmy4ycqijfTLvAEYbWHbK1D1hJbIFRf/XvrlYtCf/ucJCAEolJsnbyjU2yd3uO6Q1wPaNsZ/F0vZvVq9VW7bjPxhq4QjSSA8kF63iA1+fOI+fW/NCgWPk55hLvP7t7s8kaPriy8i5YJW53xqo7UHqDXPecYiGl9U88jxzUsBjoOZHNxLQVKG9I7pjeZnJiaKqg6CMcOQtUhqKmw/a3mmK0lqfY4oIDSAMpv//UPhIBQ24ChASEQGGZrvQqLsf03tK3t44UzMJiVN1ViJIDyMp4cYh9rCfXz7gTgP36XMe6av2hJskcfFejF6O0LY/jKefeFkfN1f/MrKNz2advJya9cSE+C/teGN84J6S7eVImRAMrLaLmJNN14DQ0c/M842tVbyW/oTMpVTxGjYq4pvca2MTqzMHr7evCGYMCTg5iq4QvnHfQrhBw71Xvy+KjZlppX8D2ZHneu2+wtM96Q3+hNAigvo+Um0vKb6lVv0e7gWo4rQbwXO5m/Z6S4bVvuXI8zam50s7WaaVm3rm9HuYle483oxeyFlFp6jVHm2Kle6/HRa/gMx/UYOfmyp9dt9pYZX6l8uEICKC/jkZvo0A78lk0H4BXLdYy/dLjqn3pDXxQ1N7rZWs3ctW6zZXqeTs+GDRvIz88nIyODvn37mr6QUkuvMcocC3atx0ev4TMc1+PJgNed14YvXHe+UvlwhQRQrYCzlohT1ggbGqj8+K+0UapZWd+LwX+ZyhmpCadYs7EtBnr1kdBrH4yuoTry+NtRDvRqdXCn/Px89uzZA0Dfvn09sk1P0GuMMr0Kdne1TJst8DC6BdVIZjsXniABVCt1qsc7dTlv0absJyqVEBZ2vI+LDmynJKL+lI8B3PW2jxp6jY6r1z6YrYZq9NtRerU6uFNGRkaT//oKx+PozuPqriET3LkedzFbi65wLwmgWgHVHXUP7UBpfHTndwNDusSe9jGAXjVLLf11vKG/VWvmDce1b9++Hmt58tXWCXcFDWbrU6iG0de8r15jZiUBVCvgrNZ2UlDVUM/xT/5KaEM1P9b3pvcVd9E3wY/CIL8WPwbQi2NG7Su1Wl/N9Iw+rmaj15hXZuOuFy68sU+h0bwxmPVmEkC1Uo6FW0POm4SW/kSFEsoXHR/k+cz2WCyW0z4GcNf0As40vg1UV1eneTvu5PFpLoTA+MJNS6CsJph05xt/jsMz6HUMPRkkO0uzuyq5kkc5JwFUK3DazOFwIfXLnsQPeF65jruvGo5F5ci6npxeYM+ePVRVVdk7/ZqNXm86Cd/Uvn17Dh8+TPv27U+5jCf7ApqdO9/4cxyewRuPoV5j7qnhyeErvIkEUK1As/PTpabSbslkghpsb93R9SLaNzPXnSO9blg1N1qHDh04cuQIHTp0aPH23MHoN5208PUMzkzUTFSspSB3bE3xBu4cQFXNfajmLUUt94YnB4b1hiEcvDEwdYUEUF5Gr1fDGy/suH3fkrzre04ogbwVehszLujhlnSfjpobrbGQCAgw52XrjX1+fD2DMxMtBbsaagIzszH6jVU1byl6w1uknqL7tDo+wpwlkTglvW7qtLQ0AmrKSc2ZBsCr9Vdw/w2jSekQ3aL0ufNGU7OMXiMwe5KRafTGDM4bzqkz7hpWwhvPoTfQMl6cJ69Nd1Z+9Brx3VcDykYSQHkZPfscJa6ejl9tOVsbUqjsP4E+LQyeQL+xmbQuo9cIzJ5kZBq9MYPzhnPqSd54Dr2B43FVc901213Ci4ZMMHLEd28iAZSX0S2z3PEtfhs/okGx8EzABF7N7tXydWJ8bVivEZgdubNmafQx8zZyvIQnaBl3rrnuEqBvwO/OwNnsI76bhQRQrVHNMeq+nEwAMLd+BH+65FKOHT3IpvUtDxCc3WiebNZW07dBC3e2ekjm5Bo5XqfnrY85zUTLuHPOlvFkJ3/HuR21kntMHQmgWoGTMtMfXyCgfBclSgzfJN3Gu2d2YNWqlYYOWmf2DF9aPbyL2a8ndzNyiiVfodc978lO/r46t6NZSQDVCjTJTIOO0bDyVfyAJ+rG8fDlA/Dzs7h1nA81nTHN1q/FMY1SI3OdkYWv2a4nZ7QeHy33nFZajqOvBF163fOerHz56tyOZiUBVCtgv4FTU2lYOAm/hlq+q+9L4oAr6ZkcCWjPLNSMvKumM6bZWni8oQA2OyOPoZ7Xk7sCAq3HR83vHO85T76GLvdOU56sfGmZ29FXAl4jSADlg07ZerLlCyj8lmolgJkB43n3/7qd8jfu5CxTNlsLj9kCOm9k5DHU83pyV0Cg9fh4MqjREoh5w4sb4ncS8GonAZSXccxUnHUadHpD1FTR8PWD+AGz6i/hqpHnExUWaF+v1ptIzfQUjowOltRkzEan0Rf4yjF0VyCo9fio+Z3jNa5XR2YtrV/u3JYn+WpAJ5VF7SSA8jKOmYqzToNOb4gfnsevooTdDXF8E3Mtnw/o2GS9Wm8ibxwF2WwZszA3bwwEHa9xrfepllf59WK2lizJN4QjCaC8jGOm4qzT4EkZ/sHtKKtexwJMr7uB+y/pR4C/32m35cnmek/yxjT7Kl+t1RtNr/HQtLzKrxeztWT5Sr6h1yjjp1uvWnoNvWAECaC8jGOmctpOg4rCic//RkhDLcvq+8EZIzm3a9xJizm7iTzZXO9J3phmX9Wa3/JyJy3joTk7rr4QNOg5e4OW681s16u7RhnXGoh589ALp2+GMImnn36awYMHExYWRnR0tNNliouLGTVqFGFhYcTHx3PfffdRV1fXZJnly5dz5plnEhwcTHp6OnPmzDlpPW+88QadO3cmJCSEgQMHsnbtWjfskT5KSkpYsWIFJSUlzhfY9jUhe1dRrQTyVN0NPDSqp9PF0tLSSE9Pb3ITOfubEHrSco01ZtSFhYVuTJl5nfae18jZcU1OTmbIkCGmKPi10roPeh1ns12vjvecs+OjZd+1lhcZGRl06NDBK4de8JoWqJqaGq666iqysrL497//fdL39fX1jBo1isTERFatWsW+ffu44YYbCAwM5JlnngGgqKiIUaNGcfvtt/P++++zbNkybrnlFpKSksjOzgbgv//9L1OmTGHWrFkMHDiQl19+mezsbLZt20Z8fLxH91mNZqP+uhqUJQ9jAf5VfxEDM3uTFtcGUDfOkbTUCHfTco35QqtIS5jtrUBP8uSEvr766E/NPafXpPVqaBl6wSy8JoCaPn06gNMWI4AlS5awZcsWvvnmGxISEsjMzOTJJ5/kgQce4PHHHycoKIhZs2aRmprKiy++CECPHj1YsWIFM2fOtAdQL730Erfeeis33XQTALNmzWLBggW88847PPjgg063XV1dTXV1tf3fVqtVr90+rWZvzrVvYzlcyH4lmvcDr+TrS/vZv3K8QczWzCxEI28Y1NToYUC08Ibj6kjrhL5auOvRn7NrxZPXj9mHovCmsshrAqjTycnJISMjg4SEBPvfsrOzmTBhAps3b6Zfv37k5OQwfPjwJr/Lzs5m8uTJgK2VKzc3l6lTp9q/9/PzY/jw4eTk5Jxy2zNmzLAHeJ52ykyv6iDK93/HAjxf92duHplBVOjvwxY43iDyhokwK2/oJ+XJ+8dsnas9SU3BrteQDe4KKLX2N9WLlsGPtdKyX950XfpMAFVaWtokeALs/y4tLW12GavVyvHjxzly5Aj19fVOl9m6desptz116lSmTJli/7fVaiUlJaVF+9Ni3z6FpbqC/IbOrI7I5qmsTs0ubrZmZiEaecNo2Ga7f3z1DVo1BbvZh1Zxdty98VyooWW/vOlYGBpAPfjgg/z9739vdplffvmF7t27eyhF2gQHBxMcHGx0Mn5Xugll/VwswBO1N3BPdg+CA/ybLGLk68newJuakfVmtn33hn5SZrt/fPUNWjXMXgAb3d80MzOTyMhIjxwfLfvlTdeloQHUPffcw4033tjsMmpPcmJi4klvy5WVldm/a/xv49/+uExkZCShoaH4+/vj7+/vdJnGdZjNSYWdosDih7AoDcyvH8ixpAFc2vfki9GTmYzZCmQ1vKkZWW++sO/elAm7g9mDCHdq7ef+dOT46MfQACouLo64uJPHJNIiKyuLp59+mv3799vfllu6dCmRkZH07NnTvszChQub/G7p0qVkZWUBEBQURP/+/Vm2bBmjR48GoKGhgWXLljFp0iRd0qm3kwq7bV9D0fdUK4E8W3ctMy7qjp+f5aTfefImcleB7M7ArDUXQK15331FaykkvbFy5o3kODvnNX2giouLOXz4MMXFxdTX15OXlwdAeno6bdq0YcSIEfTs2ZPrr7+e5557jtLSUh555BEmTpxof7x2++238/rrr3P//fdz88038+233/Lxxx+zYMEC+3amTJnCuHHjOOussxgwYAAvv/wyVVVV9rfyzKZJYVdfB988BtiGLejcpYfTQTM9zV0FsjtbSlpLAeRMa9530ZS7Ck6zDTXgjDcGDe5Ksy+0SruD1wRQ06ZNY+7cufZ/9+tneyX/u+++Y+jQofj7+zN//nwmTJhAVlYW4eHhjBs3jieeeML+m9TUVBYsWMDdd9/NK6+8QocOHfjXv/5lH8IAYOzYsRw4cIBp06ZRWlpKZmYmixYtOqljuVk0KezWzYaDv3JIiWBW3aV8eJE5+o65q0CWlhLhCd5YkOpFzRtbWphtqAFn1KTRbNdGax4jzAheE0DNmTPnlGNANerUqdNJj+gcDR06lJ9//rnZZSZNmmTaR3anVFMFy2cA8Frd5fROjiLGUgVEaR58zmyZgzeOWyNazujrUGrf+tNaIHsyD1CTRrNdG+4KdCSvdc5rAihxGjlvQGUZuxri+bBhOLeFlFJYGEZysvPJItVMKOnJzEFNIWm2zEp4htHnvTXXvj35xpYanmwVUhM0mO1lHDWDdgr9SADlCyoPwMpXAHi+biwjeiQwMC3WflM7G1hOzYSSnswc1GSMrbkga82MPu+tufbtycEkHWmd3NhsQZZefH1QSm8kAZQv+P7vUFPJhoY0llgG8e0lfejQNsz+tbOB5RwzIqPHJlGTMbaWgkxqjU356nnXa143T84Pp5Xj9rUGQnq1CrWWN4ONrnz4OgmgvN2hHSi5s7EAz9Zdw9gBnZsET+C8BcrIQslZJuOrhaQWUmtsntHBgF70mtfNk/PDaaVl4F6thb+Rj97M9maw5KvuJQGUt1s2HUtDHd/V9yXXL4OZw9JPWsRsUxsYnZmbndQam+cr14+a8+zJZdxJy/bdWfjLm8FCDxZFURSjE+FrrFYrUVFRlJeXExkZ6b4NlfwM/xhKAxYurp7B4MHnM+2SnicvZrImfl9pQRDGkOtHCOEurpTf0gLlZZoUHt8+BcC8+nPYFZDKu0O7OP2NmtqWr9Tqhe8z+rGErwZwvrpfQriLBFBepjHQiTy6meSCb6jHj1fqrmDceZ2Ji9A+obHZ3rgTwqx89fr11f1yxjFY9Ibg0RvT7OskgPIyERERBPj7k1b0PgD/rTufg4Ht+et5LQt8zPbGnRBm5avXr6/ulzOOwaI3BI/emGZfJwGUl6moqCC+cjNtDm2glgBeq7uCG4Z2pm14UIvW68l+UkY/ghGiJXz1+vXV/XLGMVj0huDRG9Ps6ySA8jJpqalErP0GgHfrhnM0MJ5bhqS2eL1qajPumhdLCOHbzPa4yTFY9Ibg0RvT7OskgPIyyRV5YN3OCYJ5s+4yrhvSkdg22vs+NZLajBDCXbxxYl4hTkcCKG/S0ADfPg3Av+uysQa05bYW9n1qpKY2o2ZeLMkEhRCOvHFiXi3MNmSMcC8JoLzJ5s9g/2aqLOG8XfcnrslKIT4yxGObl+EQhBCOtExy64wvtIJ7w6jwQj8SQHmTQwUoFn/eqrmY4/4R/PV85+M+GVnD8YVMUAiz8IbWCr0CAnf16fHkMfSGUeGFfiSA8iZDH+S+rWfw9c4GrhyQQnJ0qNPFjKzhaM0EvaGgEMLTjG6tUHNfOptr00w8eQzV5H/S+dt3SADlRfJ2H+V/O4Px97NwxylGHQfvrOEYXVAIYUZG38tq7kuzzbXpSK9jKJU84UgCKC/ybs4uAC7v156UmLBTLueNNRyjCwohzMjoe9kXHknpdQylkiccyWTCbuCuyYSr6+r5X+4eBndpR2q7cN3WK4SrpDYuWhu55lsHmUzYRwUH+HPdwE5GJ0MIqY2LVsfo1kBhPhJACSFcZvbHNkI0kpYj4S4SQAkhXCa1ceEtpLVUuIsEUF7O6NqV0dsXQojmtObWUsmf3UsCKC9ndO3K6O0LIXyTXoV/a24tlfzZvSSA8nJG166M3r5ofaRW3Tq05sJfr2vck/lza7wvJYDyckbXrozevmh9WnPB2pqoGeHcVwtts0+P40xrvC8lgPJyRmcgRm9ftD6+0uop907z1Ixw7quFtjde42af0scdJIDycnl5eWzfvh2r1Sp9oESr4CutnnLvNM8XRkHXyhuvcbNP6eMOEkCJFvHVDEwLaVEQrvDGe8eT17hMzOtdvPF6bikJoLxcZmYmkZGRhl20koH9TloUhCu88d4x2zUulRbz8MbruaUkgPIyjhmGmotWMhnPaI01MNG6mO0al4BOGEkCKC+jpc+T2TIZX9Uaa2CidTFbhc1sHZclr21dJIBqBcxWaxRC+C5PBhFm67gseW3rIgGUl9HS50laRoSva02PTsy+r54MIswWsEhe27pIAOVl5AYV4mSt6dGJ2ffVk3mU0fmh2YNZ4V4SQAkhvJ7ZWiLcqTXtq5HUBEdmD2aFe/kZnQA1du7cyfjx40lNTSU0NJQuXbrw2GOPUVNT02S5jRs3cu655xISEkJKSgrPPffcSev65JNP6N69OyEhIWRkZLBw4cIm3yuKwrRp00hKSiI0NJThw4ezfft2t+6fK0pKSlixYgUlJSVGJ0UI00hOTmbIkCGtohBrTftqpMbgqLCw8JTLpKWlkZ6eLsFsK+UVAdTWrVtpaGjg7bffZvPmzcycOZNZs2bx0EMP2ZexWq2MGDGCTp06kZuby/PPP8/jjz/OP/7xD/syq1at4pprrmH8+PH8/PPPjB49mtGjR7Np0yb7Ms899xyvvvoqs2bNYs2aNYSHh5Odnc2JEyc8us+nouamFkII0TJqgiMJZls3i6IoitGJ0OL555/nrbfesgcSb731Fg8//DClpaUEBQUB8OCDDzJv3jy2bt0KwNixY6mqqmL+/Pn29QwaNIjMzExmzZqFoigkJydzzz33cO+99wJQXl5OQkICc+bM4eqrr1aVNqvVSlRUFOXl5URGRuq52/LMXQghhHATV8pvr2iBcqa8vJyYmBj7v3NycjjvvPPswRNAdnY227Zt48iRI/Zlhg8f3mQ92dnZ5OTkAFBUVERpaWmTZaKiohg4cKB9GWeqq6uxWq1NPu4iNR4hhBDCeF4ZQBUUFPDaa6/x17/+1f630tJSEhISmizX+O/S0tJml/nj93/8nbNlnJkxYwZRUVH2T0pKisY9MzfpfyWEEELYGBpAPfjgg1gslmY/jY/fGu3du5eRI0dy1VVXceuttxqU8qamTp1KeXm5/bN7926jk+QW0v9KCHWksiGE7zN0GIN77rmHG2+8sdll/tiBr6SkhGHDhjF48OAmncMBEhMTKSsra/K3xn8nJiY2u8wfv2/8W1JSUpNlMjMzT5nG4OBggoODm90PXyCvTwtf464+hfJ6uzAD6TPrXoYGUHFxccTFxaladu/evQwbNoz+/fsze/Zs/PyaNp5lZWXx8MMPU1tbS2BgIABLly6lW7dutG3b1r7MsmXLmDx5sv13S5cuJSsrC4DU1FQSExNZtmyZPWCyWq2sWbOGCRMmtHBvvZ/Rg9YJoTd3BTpS2RCuMHsgL4GYc14xkObevXsZOnQonTp14oUXXuDAgQP27xpbja699lqmT5/O+PHjeeCBB9i0aROvvPIKM2fOtC971113cf755/Piiy8yatQoPvroI9atW2dvzbJYLEyePJmnnnqKrl27kpqayqOPPkpycjKjR4/26D4LIdzPXYGOVDaEK9QEOlqCGL2ub2lRdc4rAqilS5dSUFBAQUEBHTp0aPJd4ygMUVFRLFmyhIkTJ9K/f3/atWvHtGnTuO222+zLDh48mA8++IBHHnmEhx56iK5duzJv3jx69+5tX+b++++nqqqK2267jaNHjzJkyBAWLVpESEiIZ3ZWCOExEugIM1AT6GgJYvS6vqVF1TmvHQfKzNw5DpQQQvgieUzUPDk+nuFK+e0VLVBCCCF8mzwmap60lpqPBFBCCCEMJ4+JhLeRAEoIIYThtLSwyGMtYSQJoIQQQngleewnjCQBlJdzVgOTWpkQojWQx37CSBJAeTlnNTCplQkhWgPpWC2MJAGUl3NWA5NamRBCCOFeEkB5OWc1MKmVCSHcQboHCPE7v9MvInyRzBYvhHBVY/eAwsJCo5MihOGkBaqVkn5SQghXSfeAlvNkK560GLqXBFCtlGSEQghXSfeAlvNk5VUqyu4lAVQrJRmhEEJ4nicrr1JRdi8JoIRq0hwshBC/05InerLyKhVl95IASqgmzcFCCC18tfIleWLrJgGUUE2ag4UQWvhqoCF5YusmAZRQTZqDhRBa+GqgIXli6yYBlBBCCLeSQEP4IhlIUwghhBDCRRJACSGEF5NZBYQwhjzCE0IIL+arHbSFMDsJoIQQwov5agdtb+CrwzMIdSSAEkIILyYdtI0jrX+tmwRQQgghhAbS+te6SQDlg6RZWQgh3E9a/1o3CaB8kDQrCyGEEO4lAZQPkmZlIYQQwr0kgPJB0qwshBBCuJcMpCmEEEII4SIJoIQQQgghXCQBlBBCCCGEiySAEkIIIYRwkQRQQgghhA5kYufWRd7CE0IIIXQgY/C1LhJACSGEEDqQMfhaFwmghBBCCB3IGHyti/SBEkIIIYRwkQRQQgghhBAu8poA6tJLL6Vjx46EhISQlJTE9ddff9KbDhs3buTcc88lJCSElJQUnnvuuZPW88knn9C9e3dCQkLIyMhg4cKFTb5XFIVp06aRlJREaGgow4cPZ/v27W7dN28hb5gIIYQQNl4TQA0bNoyPP/6Ybdu28emnn7Jjxw6uvPJK+/dWq5URI0bQqVMncnNzef7553n88cf5xz/+YV9m1apVXHPNNYwfP56ff/6Z0aNHM3r0aDZt2mRf5rnnnuPVV19l1qxZrFmzhvDwcLKzszlx4oRH99eMGt8wKSwsNDopQgghhKEsiqIoRidCiy+//JLRo0dTXV1NYGAgb731Fg8//DClpaUEBQUB8OCDDzJv3jy2bt0KwNixY6mqqmL+/Pn29QwaNIjMzExmzZqFoigkJydzzz33cO+99wJQXl5OQkICc+bM4eqrr1aVNqvVSlRUFOXl5URGRuq856dXUlJCYWEhaWlpunZodNd6hRBCCDNwpfz2mhaoPzp8+DDvv/8+gwcPJjAwEICcnBzOO+88e/AEkJ2dzbZt2zhy5Ih9meHDhzdZV3Z2Njk5OQAUFRVRWlraZJmoqCgGDhxoX8aZ6upqrFZrk4+7OD5Gc/ZYzV0tRcnJyQwZMkSCJyGEEK2eVwVQDzzwAOHh4cTGxlJcXMwXX3xh/660tJSEhIQmyzf+u7S0tNll/vj9H3/nbBlnZsyYQVRUlP2TkpKicQ9PzzE4chYsRUREEBAQQEREhNvSIYQQQrRmhgZQDz74IBaLpdlP4+M3gPvuu4+ff/6ZJUuW4O/vzw033IAZnkBOnTqV8vJy+2f37t1u21ZaWhrp6elNBmz7478BKioqqKuro6Kiwm3pEEIIIVozQwfSvOeee7jxxhubXeaPgUG7du1o164dZ5xxBj169CAlJYXVq1eTlZVFYmIiZWVlTX7b+O/ExET7f50t88fvG/+WlJTUZJnMzMxTpjE4OJjg4ODmd1YnjgO1ORu4TUbDFUIIIdzL0AAqLi6OuLg4Tb9taGgAbP2PALKysnj44Yepra2194taunQp3bp1o23btvZlli1bxuTJk+3rWbp0KVlZWQCkpqaSmJjIsmXL7AGT1WplzZo1TJgwQVM6jSCj4QohhBDu5RV9oNasWcPrr79OXl4eu3bt4ttvv+Waa66hS5cu9uDn2muvJSgoiPHjx7N582b++9//8sorrzBlyhT7eu666y4WLVrEiy++yNatW3n88cdZt24dkyZNAsBisTB58mSeeuopvvzyS/Lz87nhhhtITk5m9OjRRuy6EEIIIUzIK+bCCwsL47PPPuOxxx6jqqqKpKQkRo4cySOPPGJ/dBYVFcWSJUuYOHEi/fv3p127dkybNo3bbrvNvp7BgwfzwQcf8Mgjj/DQQw/RtWtX5s2bR+/eve3L3H///VRVVXHbbbdx9OhRhgwZwqJFiwgJCfH4fgshhBDCnLx2HCgzM3ocKCGEEEK4zufHgRJCCCGEMJIEUEIIIYQQLpIASgghhBDCRRJACSGEEEK4SAIoIYQQQggXSQAlhBBCCOEiCaCEEEIIIVwkAZQQQgghhIskgBJCCCGEcJEEUEIIIYQQLvKKufC8TePsOFar1eCUCCGEEEKtxnJbzSx3EkC5QUVFBQApKSkGp0QIIYQQrqqoqCAqKqrZZWQyYTdoaGigpKSEiIgILBaLruu2Wq2kpKSwe/dumaj4NORYqSfHSj05VurJsVJPjpV67jxWiqJQUVFBcnIyfn7N93KSFig38PPzo0OHDm7dRmRkpNxkKsmxUk+OlXpyrNSTY6WeHCv13HWsTtfy1Eg6kQshhBBCuEgCKCGEEEIIF0kA5WWCg4N57LHHCA4ONjoppifHSj05VurJsVJPjpV6cqzUM8uxkk7kQgghhBAukhYoIYQQQggXSQAlhBBCCOEiCaCEEEIIIVwkAZQQQgghhIskgPISTz/9NIMHDyYsLIzo6Giny1gslpM+H330kWcTahJqjldxcTGjRo0iLCyM+Ph47rvvPurq6jybUBPq3LnzSdfRs88+a3SyTOONN96gc+fOhISEMHDgQNauXWt0kkzn8ccfP+ka6t69u9HJMoUffviBSy65hOTkZCwWC/PmzWvyvaIoTJs2jaSkJEJDQxk+fDjbt283JrEGO92xuvHGG0+6zkaOHOmx9EkA5SVqamq46qqrmDBhQrPLzZ49m3379tk/o0eP9kwCTeZ0x6u+vp5Ro0ZRU1PDqlWrmDt3LnPmzGHatGkeTqk5PfHEE02uozvvvNPoJJnCf//7X6ZMmcJjjz3G+vXr6du3L9nZ2ezfv9/opJlOr169mlxDK1asMDpJplBVVUXfvn154403nH7/3HPP8eqrrzJr1izWrFlDeHg42dnZnDhxwsMpNd7pjhXAyJEjm1xnH374oecSqAivMnv2bCUqKsrpd4Dy+eefezQ9Zneq47Vw4ULFz89PKS0ttf/trbfeUiIjI5Xq6moPptB8OnXqpMycOdPoZJjSgAEDlIkTJ9r/XV9fryQnJyszZswwMFXm89hjjyl9+/Y1Ohmm55hnNzQ0KImJicrzzz9v/9vRo0eV4OBg5cMPPzQghebhrHwbN26cctlllxmSHkVRFGmB8jETJ06kXbt2DBgwgHfeeQdFhvlyKicnh4yMDBISEux/y87Oxmq1snnzZgNTZg7PPvsssbGx9OvXj+eff14ebWJr1czNzWX48OH2v/n5+TF8+HBycnIMTJk5bd++neTkZNLS0rjuuusoLi42OkmmV1RURGlpaZNrLCoqioEDB8o1dgrLly8nPj6ebt26MWHCBA4dOuSxbctkwj7kiSee4IILLiAsLIwlS5Zwxx13UFlZyd/+9jejk2Y6paWlTYInwP7v0tJSI5JkGn/7298488wziYmJYdWqVUydOpV9+/bx0ksvGZ00Qx08eJD6+nqn183WrVsNSpU5DRw4kDlz5tCtWzf27dvH9OnTOffcc9m0aRMRERFGJ8+0GvMeZ9dYa8+XnBk5ciRXXHEFqamp7Nixg4ceeoiLLrqInJwc/P393b59CaAM9OCDD/L3v/+92WV++eUX1Z0vH330Ufv/9+vXj6qqKp5//nmfCaD0Pl6tiSvHbsqUKfa/9enTh6CgIP76178yY8YMw6dOEN7hoosusv9/nz59GDhwIJ06deLjjz9m/PjxBqZM+JKrr77a/v8ZGRn06dOHLl26sHz5ci688EK3b18CKAPdc8893Hjjjc0uk5aWpnn9AwcO5Mknn6S6utonCj49j1diYuJJb0+VlZXZv/M1LTl2AwcOpK6ujp07d9KtWzc3pM47tGvXDn9/f/t10qisrMwnrxk9RUdHc8YZZ1BQUGB0Ukyt8ToqKysjKSnJ/veysjIyMzMNSpX3SEtLo127dhQUFEgA5evi4uKIi4tz2/rz8vJo27atTwRPoO/xysrK4umnn2b//v3Ex8cDsHTpUiIjI+nZs6cu2zCTlhy7vLw8/Pz87MeptQoKCqJ///4sW7bM/nZrQ0MDy5YtY9KkScYmzuQqKyvZsWMH119/vdFJMbXU1FQSExNZtmyZPWCyWq2sWbPmtG9gC9izZw+HDh1qEny6kwRQXqK4uJjDhw9TXFxMfX09eXl5AKSnp9OmTRu++uorysrKGDRoECEhISxdupRnnnmGe++919iEG+R0x2vEiBH07NmT66+/nueee47S0lIeeeQRJk6c6DMBpxY5OTmsWbOGYcOGERERQU5ODnfffTd/+ctfaNu2rdHJM9yUKVMYN24cZ511FgMGDODll1+mqqqKm266yeikmcq9997LJZdcQqdOnSgpKeGxxx7D39+fa665xuikGa6ysrJJS1xRURF5eXnExMTQsWNHJk+ezFNPPUXXrl1JTU3l0UcfJTk5uVUOSdPcsYqJiWH69OmMGTOGxMREduzYwf333096ejrZ2dmeSaBh7/8Jl4wbN04BTvp89913iqIoytdff61kZmYqbdq0UcLDw5W+ffsqs2bNUurr641NuEFOd7wURVF27typXHTRRUpoaKjSrl075Z577lFqa2uNS7QJ5ObmKgMHDlSioqKUkJAQpUePHsozzzyjnDhxwuikmcZrr72mdOzYUQkKClIGDBigrF692ugkmc7YsWOVpKQkJSgoSGnfvr0yduxYpaCgwOhkmcJ3333nNG8aN26coii2oQweffRRJSEhQQkODlYuvPBCZdu2bcYm2iDNHatjx44pI0aMUOLi4pTAwEClU6dOyq233tpkaBp3syiKvOcuhBBCCOEKGQdKCCGEEMJFEkAJIYQQQrhIAighhBBCCBdJACWEEEII4SIJoIQQQgghXCQBlBBCCCGEiySAEkIIIYRwkQRQQgghhBAukgBKCCGEEMJFEkAJIYQQQrhIAighhBBCCBdJACWEEKdx4MABEhMTeeaZZ+x/W7VqFUFBQSxbtszAlAkhjCKTCQshhAoLFy5k9OjRrFq1im7dupGZmclll13GSy+9ZHTShBAGkABKCCFUmjhxIt988w1nnXUW+fn5/PTTTwQHBxudLCGEASSAEkIIlY4fP07v3r3ZvXs3ubm5ZGRkGJ0kIYRBpA+UEEKotGPHDkpKSmhoaGDnzp1GJ0cIYSBpgRJCCBVqamoYMGAAmZmZdOvWjZdffpn8/Hzi4+ONTpoQwgASQAkhhAr33Xcf//vf/9iwYQNt2rTh/PPPJyoqivnz5xudNCGEAeQRnhBCnMby5ct5+eWXeffdd4mMjMTPz493332XH3/8kbfeesvo5AkhDCAtUEIIIYQQLpIWKCGEEEIIF0kAJYQQQgjhIgmghBBCCCFcJAGUEEIIIYSLJIASQgghhHCRBFBCCCGEEC6SAEoIIYQQwkUSQAkhhBBCuEgCKCGEEEIIF0kAJYQQQgjhIgmghBBCCCFc9P9JCv4Ud7rk3AAAAABJRU5ErkJggg==",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "v = s\n",
+    "while len(v.experiment_data) < 1_000:  # any condition on the state can be used here.\n",
+    "    v = pipeline(v)\n",
+    "show_best_fit(v)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Creating Generators With State Based Functions\n",
+    "\n",
+    "We can redefine the pipeline as a generator, which can be operated on using iteration tools:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "def cycle(state: State) -> State:\n",
+    "    s_ = state\n",
+    "    while True:\n",
+    "        s_ = experiment_runner(s_)\n",
+    "        s_ = theorist(s_)\n",
+    "        yield s_\n",
+    "\n",
+    "cycle_generator = cycle(s)\n",
+    "\n",
+    "for i in range(1000):\n",
+    "    t = next(cycle_generator)\n",
+    "show_best_fit(t)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "You can also define a cycle (or a sequence of steps) which yield the intermediate results."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "v0 = s\n",
+    "def cycle(state: State) -> State:\n",
+    "    s_ = state\n",
+    "    while True:\n",
+    "        print(\"#-- running experiment_runner --#\\n\")\n",
+    "        s_ = experiment_runner(s_)\n",
+    "        yield s_\n",
+    "        print(\"#-- running theorist --#\\n\")\n",
+    "        s_ = theorist(s_)\n",
+    "        yield s_\n",
+    "\n",
+    "cycle_generator = cycle(v0)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "At the outset, we have no model and an emtpy experiment_data dataframe."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "v0.model=None, \n",
+      "v0.experiment_data.shape=(0, 2)\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(f\"{v0.model=}, \\n{v0.experiment_data.shape=}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "In the first `next`, we only run the \"experiment_runner\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "#-- running experiment_runner --#\n",
+      "\n",
+      "v1.model=None, \n",
+      "v1.experiment_data.shape=(101, 2)\n"
+     ]
+    }
+   ],
+   "source": [
+    "v1 = next(cycle_generator)\n",
+    "print(f\"{v1.model=}, \\n{v1.experiment_data.shape=}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "In the next step, we run the theorist on that data, but we don't add any new data:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "#-- running theorist --#\n",
+      "\n",
+      "v2.model=Pipeline(steps=[('polynomialfeatures', PolynomialFeatures(degree=5)),\n",
+      "                ('linearregression', LinearRegression())]), \n",
+      "v2.experiment_data.shape=(101, 2)\n"
+     ]
+    }
+   ],
+   "source": [
+    "v2 = next(cycle_generator)\n",
+    "print(f\"{v2.model=}, \\n{v2.experiment_data.shape=}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "In the next step, we run the experiment runner again and gather more observations:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "#-- running experiment_runner --#\n",
+      "\n",
+      "v3.model=Pipeline(steps=[('polynomialfeatures', PolynomialFeatures(degree=5)),\n",
+      "                ('linearregression', LinearRegression())]), \n",
+      "v3.experiment_data.shape=(202, 2)\n"
+     ]
+    }
+   ],
+   "source": [
+    "v3 = next(cycle_generator)\n",
+    "print(f\"{v3.model=}, \\n{v3.experiment_data.shape=}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Adding The Experimentalist\n",
+    "Modifying the code to use a custom experimentalist is simple.\n",
+    "We define an experimentalist which adds four observations each cycle:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Snapshot(variables=VariableCollection(independent_variables=[Variable(name='x', value_range=(-15, 15), allowed_values=None, 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=[]), params={}, experiment_data=Empty DataFrame\n",
+       "Columns: [x, y]\n",
+       "Index: [], conditions=          x\n",
+       "0  2.281691, model=None)"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "experimentalist_rng = np.random.default_rng(180)\n",
+    "@wrap_to_use_state\n",
+    "\n",
+    "def experimentalist(variables: VariableCollection, n_samples=1):\n",
+    "    names = [v.name for v in variables.independent_variables]\n",
+    "    low = [v.value_range[0] for v in variables.independent_variables]\n",
+    "    high = [v.value_range[1] for v in variables.independent_variables]\n",
+    "    x_range = experimentalist_rng.uniform(low, high, size=n_samples)\n",
+    "    conditions = pd.DataFrame({\"x\": x_range})\n",
+    "    return Delta(conditions=conditions)\n",
+    "\n",
+    "experimentalist(s)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlAAAAHHCAYAAABwaWYjAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABzAklEQVR4nO3dd1yV5f/H8ddhCwiILFEcuPdMRLPSSDQblpWalZYtc2Q2/Vbatl9771Jb2rQyzTLTTMWRSm4TUVERcAGCsu/fH3eS5OIocJ9zeD8fj/M46z73/TlH5Ly5ruu+LpthGAYiIiIiUm5uVhcgIiIi4mwUoERERETspAAlIiIiYicFKBERERE7KUCJiIiI2EkBSkRERMROClAiIiIidlKAEhEREbGTApSIiIiInRSgRKRamzp1KjabjR07dlhdiog4EQUoEZEK8MsvvzBixAjatGmDu7s7DRs2tLokEalENq2FJyLVWXFxMYWFhXh7e2Oz2c56P8OHD+eLL76gU6dOpKSk4O7urlYtERemACUiUgFSU1MJDQ3F09OTyy67jPXr1ytAibgwdeGJSLVWUWOgIiMj8fT0rJiiRMTheVhdgIiII8nJySEvL++M23l6ehIYGFgFFYmII1KAEhE5zujRo5k2bdoZt7vwwgtZuHBh5RckIg5JAUpE5DgPPPAAN9xwwxm3q1WrVhVUIyKOSgFKROQ4rVq1olWrVlaXISIOTgFKROQ4WVlZHD169IzbeXl5ERwcXAUViYgjUoASETnO3XffrTFQInJGClAiIsfRGCgRKQ8FKBGR45ztGKi1a9fyww8/AJCUlERWVhZPPfUUAO3bt+fyyy+v0DpFxFoKUCIiFWD16tU8+uijZR47dn/YsGEKUCIuRku5iIiIiNhJS7mIiIiI2EkBSkRERMROClAiIiIidlKAEhEREbGTApSIiIiInRSgREREROzkNPNATZ48mW+//ZbNmzdTo0YNunfvzv/93//RvHnz0m3y8vK49957mTFjBvn5+cTHx/PWW28RHh5euk1KSgojR45kwYIF+Pv7M2zYMCZPnoyHx78fxcKFCxk/fjwbNmwgKiqKRx55hOHDh5e71pKSElJTU6lZsyY2m61C3r+IiIhULsMwOHz4MJGRkbi5naGNyXAS8fHxxpQpU4z169cbiYmJxqWXXmrUr1/fyMnJKd3mzjvvNKKiooz58+cbf/75p9GtWzeje/fupc8XFRUZbdq0MeLi4ow1a9YYc+bMMUJCQowJEyaUbpOcnGz4+voa48ePNzZu3Gi8/vrrhru7uzF37txy17pr1y4D0EUXXXTRRRddnPCya9euM37XO+1Emvv27SMsLIzff/+dCy64gKysLEJDQ/n888+55pprANi8eTMtW7YkISGBbt268dNPP3HZZZeRmppa2ir1zjvv8OCDD7Jv3z68vLx48MEHmT17NuvXry891uDBg8nMzGTu3Lnlqi0rK4ugoCB27dpFQEBAxb95ERERqXDZ2dlERUWRmZlJYGDgabd1mi68/8rKygIgODgYgFWrVlFYWEhcXFzpNi1atKB+/fqlASohIYG2bduW6dKLj49n5MiRbNiwgY4dO5KQkFBmH8e2GTduXLlrO9ZtFxAQoAAlIiLiZMoz/MYpA1RJSQnjxo2jR48etGnTBoC0tDS8vLwICgoqs214eDhpaWml2xwfno49f+y5022TnZ3N0aNHqVGjxgn15Ofnk5+fX3o/Ozv73N6giIiIODSnPAtv1KhRrF+/nhkzZlhdCmAOcA8MDCy9REVFWV2SiIiIVCKnC1CjR4/mxx9/ZMGCBdSrV6/08YiICAoKCsjMzCyzfXp6OhEREaXbpKenn/D8sedOt01AQMBJW58AJkyYQFZWVull165d5/QeRURExLE5TReeYRiMGTOGmTNnsnDhQho1alTm+c6dO+Pp6cn8+fMZOHAgAFu2bCElJYXY2FgAYmNjefrpp8nIyCAsLAyAefPmERAQQKtWrUq3mTNnTpl9z5s3r3QfJ+Pt7Y23t3eFvVcRETk3xcXFFBYWWl2GOBhPT0/c3d0rZF9OcxbeXXfdxeeff873339fZu6nwMDA0pahkSNHMmfOHKZOnUpAQABjxowBYOnSpYD5H6pDhw5ERkby3HPPkZaWxo033sitt97KM888A8D27dtp06YNo0aN4pZbbuG3335j7NixzJ49m/j4+HLVmp2dTWBgIFlZWRpELiJShQzDIC0t7YTeCJFjgoKCiIiIOOlAcXu+v50mQJ1qRPyUKVNKJ7k8NpHm9OnTy0ykeax7DmDnzp2MHDmShQsX4ufnx7Bhw3j22WdPmEjznnvuYePGjdSrV49HH33Urok0FaBERKyxd+9eMjMzCQsLw9fXV5MZSynDMDhy5AgZGRkEBQVRp06dE7ZxyQDlTBSgRESqXnFxMX///TdhYWHUrl3b6nLEQR04cICMjAyaNWt2QneePd/fTjeIXERE5GSOjXny9fW1uBJxZMd+Ps51jJwClIiIuBR128npVNTPhwKUiIiIiJ0UoERERCx20UUX2bVkWGX67rvvaNKkCe7u7owbN46pU6eesMqHKECJiIi4vIULF2Kz2co1vcMdd9zBNddcw65du3jyyScZNGgQf//9d+nzjz32GB06dKi8Yp2E00ykKSIiIpUrJyeHjIwM4uPjiYyMLH38VCtxVGdqgRJxAampqSxevJjU1FSrSxGRs1RUVMTo0aMJDAwkJCSERx99lONnGsrPz+e+++6jbt26+Pn5ERMTw8KFC0uf37lzJ5dffjm1atXCz8+P1q1bM2fOHHbs2EGvXr0AqFWrFjab7aRzGy5cuJCaNWsC0Lt3b2w2GwsXLizThTd16lQef/xx/vrrL2w2GzabjalTp1bWR+LQ1AIl4gKSk5NJSkoCKPNXo0h1ZxgGRwuLLTl2DU93u874mjZtGiNGjGDFihX8+eef3H777dSvX5/bbrsNMNeC3bhxIzNmzCAyMpKZM2fSt29f1q1bR9OmTRk1ahQFBQUsWrQIPz8/Nm7ciL+/P1FRUXzzzTcMHDiQLVu2nHJt1+7du7NlyxaaN2/ON998Q/fu3QkODmbHjh2l2wwaNIj169czd+5cfv31V8BcEaQ6UoAScQHR0dFlrkXEdLSwmFYTf7bk2BufiMfXq/xfs1FRUbz88svYbDaaN2/OunXrePnll7nttttISUlhypQppKSklP6RdN999zF37lymTJnCM888Q0pKCgMHDqRt27ZA2d8HwcHBAISFhZ1yQLiXl1fpOrHBwcFlVvE4pkaNGvj7++Ph4XHS56sTBSgRFxAZGamWJxEn161btzItVrGxsbz44osUFxezbt06iouLadasWZnX5Ofnl866PnbsWEaOHMkvv/xCXFwcAwcOpF27dlX6HqoTBSgREXFZNTzd2fhE+RaCr4xjV5ScnBzc3d1ZtWrVCcuP+Pv7A3DrrbcSHx/P7Nmz+eWXX5g8eTIvvvgiY8aMqbA65F8KUCIi4rJsNptd3WhWWr58eZn7y5Yto2nTpri7u9OxY0eKi4vJyMigZ8+ep9xHVFQUd955J3feeScTJkzg/fffZ8yYMXh5eQHmeoHnysvLq0L24+x0Fp6IiIgDSElJYfz48WzZsoXp06fz+uuvc/fddwPQrFkzhg4dyk033cS3337L9u3bWbFiBZMnT2b27NkAjBs3jp9//pnt27ezevVqFixYQMuWLQFo0KABNpuNH3/8kX379pGTk3PWdTZs2JDt27eTmJjI/v37yc/PP/c374QUoERERBzATTfdxNGjR+natSujRo3i7rvv5vbbby99fsqUKdx0003ce++9NG/enAEDBrBy5Urq168PmK1Lo0aNomXLlvTt25dmzZrx1ltvAVC3bl0ef/xxHnroIcLDwxk9evRZ1zlw4ED69u1Lr169CA0NZfr06ef2xp2UzTh+kgmpENnZ2QQGBpKVlUVAQIDV5YiIVAt5eXls376dRo0a4ePjY3U54qBO93Niz/e3WqBERERE7KQAJSIiImInBSgREREROylAiYiIiNhJAUpERETETgpQIiIiInZSgBIRERGxkwKUiIiIiJ0UoERERETspAAlIiIidps6dSpBQUFWl8Hw4cMZMGBAlR9XAUpEREQq3I4dO7DZbCQmJjrk/s6VApSIiIgTKigosLqECuGs70MBSkRExGKHDx9m6NCh+Pn5UadOHV5++WUuuugixo0bV7pNw4YNefLJJ7npppsICAjg9ttvB+Cbb76hdevWeHt707BhQ1588cUy+7bZbHz33XdlHgsKCmLq1KnAvy073377Lb169cLX15f27duTkJBQ5jVTp06lfv36+Pr6ctVVV3HgwIHTvqdGjRoB0LFjR2w2GxdddBHwb5fb008/TWRkJM2bNy9Xnafa3zEvvPACderUoXbt2owaNYrCwsLT1neuPCp17yIiIlYyDCg8Ys2xPX3BZivXpuPHj2fJkiX88MMPhIeHM3HiRFavXk2HDh3KbPfCCy8wceJEJk2aBMCqVau47rrreOyxxxg0aBBLly7lrrvuonbt2gwfPtyuch9++GFeeOEFmjZtysMPP8yQIUNISkrCw8OD5cuXM2LECCZPnsyAAQOYO3duaQ2nsmLFCrp27cqvv/5K69at8fLyKn1u/vz5BAQEMG/evHLXd7r9LViwgDp16rBgwQKSkpIYNGgQHTp04LbbbrPrM7CHApSIiLiuwiPwTKQ1x/5fKnj5nXGzw4cPM23aND7//HMuvvhiAKZMmUJk5Il19+7dm3vvvbf0/tChQ7n44ot59NFHAWjWrBkbN27k+eeftztA3XffffTv3x+Axx9/nNatW5OUlESLFi149dVX6du3Lw888EDpcZYuXcrcuXNPub/Q0FAAateuTURERJnn/Pz8+OCDD8qEoDM53f5q1arFG2+8gbu7Oy1atKB///7Mnz+/UgOUuvBEREQslJycTGFhIV27di19LDAwsLRr63hdunQpc3/Tpk306NGjzGM9evRg69atFBcX21VHu3btSm/XqVMHgIyMjNLjxMTElNk+NjbWrv0fr23btnaFpzNp3bo17u7upffr1KlTWntlUQuUiIi4Lk9fsyXIqmNXMD+/M7do/ZfNZsMwjDKPnWx8kKenZ5nXAJSUlNh9vPI42fsob50nc3ztx/ZVWbUfowAlIiKuy2YrVzealaKjo/H09GTlypXUr18fgKysLP7++28uuOCC0762ZcuWLFmypMxjS5YsoVmzZqUtMqGhoezdu7f0+a1bt3LkiH3jwlq2bMny5cvLPLZs2bLTvuZYC1N5W8LOVKe9+6tsClAiIiIWqlmzJsOGDeP+++8nODiYsLAwJk2ahJubW2lL0Knce++9nHfeeTz55JMMGjSIhIQE3njjDd56663SbXr37s0bb7xBbGwsxcXFPPjggye02JzJ2LFj6dGjBy+88AJXXnklP//882nHPwGEhYVRo0YN5s6dS7169fDx8SEwMPCU25+pTnv3V9k0BkpERMRiL730ErGxsVx22WXExcXRo0cPWrZsiY+Pz2lf16lTJ7788ktmzJhBmzZtmDhxIk888USZAeQvvvgiUVFR9OzZk+uvv5777rsPX1/7uhe7devG+++/z6uvvkr79u355ZdfeOSRR077Gg8PD1577TXeffddIiMjufLKK0+7/ZnqtHd/lc1m/LfDUc5ZdnY2gYGBZGVlERAQYHU5IiLVQl5eHtu3b6dRo0ZnDB6OLjc3l7p16/Liiy8yYsQIq8txKaf7ObHn+1tdeCIiIhZbs2YNmzdvpmvXrmRlZfHEE08AWN7KIqemACUiIuIAXnjhBbZs2YKXlxedO3fmjz/+ICQkxOqy5BQUoERERCzWsWNHVq1aZXUZYgenGkS+aNEiLr/8ciIjI0+6Zs7w4cOx2WxlLn379i2zzcGDBxk6dCgBAQEEBQUxYsQIcnJyymyzdu1aevbsiY+PD1FRUTz33HOV/dZERETEiThVgMrNzaV9+/a8+eabp9ymb9++7N27t/Qyffr0Ms8PHTqUDRs2MG/ePH788UcWLVpUuiAjmAPI+vTpQ4MGDVi1ahXPP/88jz32GO+9916lvS8REak4OjdKTqeifj6cqguvX79+9OvX77TbeHt7n7BGzjGbNm1i7ty5rFy5snQ6/Ndff51LL72UF154gcjISD777DMKCgr46KOP8PLyonXr1iQmJvLSSy+VCVoiIuJYjs0ZdOTIEWrUqGFxNeKojk3Oae9cWP/lVAGqPBYuXEhYWBi1atWid+/ePPXUU9SuXRuAhIQEgoKCyqwlFBcXh5ubG8uXL+eqq64iISGBCy64oMwaPfHx8fzf//0fhw4dolatWiccMz8/n/z8/NL72dnZlfgORUTkZNzd3QkKCipdA83X1/eME1FK9WEYBkeOHCEjI4OgoKAya+edDZcKUH379uXqq6+mUaNGbNu2jf/973/069ePhIQE3N3dSUtLIywsrMxrPDw8CA4OJi0tDYC0tDQaNWpUZpvw8PDS504WoCZPnszjjz9eSe9KRETK61gPRGUvJCvOKygo6JQ9VfZwqQA1ePDg0ttt27alXbt2NG7cmIULF3LxxRdX2nEnTJjA+PHjS+9nZ2cTFRVVaccTEZGTs9ls1KlTh7CwsHIvRCvVh6en5zm3PB3jUgHqv6KjowkJCSEpKYmLL76YiIiIE/4qKSoq4uDBg6VpNCIigvT09DLbHLt/qsTq7e2Nt7d3JbwDERE5G+7u7hX2RSlyMk51Fp69du/ezYEDB6hTpw4AsbGxZGZmlplr47fffqOkpISYmJjSbRYtWlTmL5d58+bRvHnzk3bfiYiISPXjVAEqJyeHxMREEhMTAdi+fTuJiYmkpKSQk5PD/fffz7Jly9ixYwfz58/nyiuvpEmTJsTHxwPQsmVL+vbty2233caKFStYsmQJo0ePZvDgwURGRgJw/fXX4+XlxYgRI9iwYQNffPEFr776apkuOhEREanenGox4YULF9KrV68THh82bBhvv/02AwYMYM2aNWRmZhIZGUmfPn148sknSweBgzmR5ujRo5k1axZubm4MHDiQ1157DX9//9Jt1q5dy6hRo1i5ciUhISGMGTOGBx98sNx1ajFhERER52PP97dTBShnoQAlIiLifOz5/naqLjwRERERR6AAJSIiImInBSgREREROylAiYiIiNhJAUpERETETgpQIiIiInZSgBIRERGxkwKUiIiIiJ0UoERERETspAAlIiIiYicFKBERERE7KUCJiIiI2EkBSkRERMROClAiIiIidlKAEhEREbGTApSIiIiInRSgREREROykACUiIiJiJwUoERERETspQEm1kpqayuLFi0lNTbW6FBERcWIeVhcgUpWSk5NJSkoCIDIy0uJqRETEWSlASbUSHR1d5lpERORsKEBJtRIZGamWJxEROWcaAyUiIiJiJwUoERERETspQImIiIjYSQFKRERExE4KUCIiIiJ2UoASERERsZMClIiIiIidFKBERERE7KQAJSIiImInBSgREREROylAiYiIiNhJAUpERETETgpQIiIiInZSgBIRERGxkwKUiIiIiJ2cKkAtWrSIyy+/nMjISGw2G999912Z5w3DYOLEidSpU4caNWoQFxfH1q1by2xz8OBBhg4dSkBAAEFBQYwYMYKcnJwy26xdu5aePXvi4+NDVFQUzz33XGW/NREREXEiThWgcnNzad++PW+++eZJn3/uued47bXXeOedd1i+fDl+fn7Ex8eTl5dXus3QoUPZsGED8+bN48cff2TRokXcfvvtpc9nZ2fTp08fGjRowKpVq3j++ed57LHHeO+99yr9/YmIiIiTMJwUYMycObP0fklJiREREWE8//zzpY9lZmYa3t7exvTp0w3DMIyNGzcagLFy5crSbX766SfDZrMZe/bsMQzDMN566y2jVq1aRn5+fuk2Dz74oNG8efNy15aVlWUARlZW1tm+PREREali9nx/O1UL1Ols376dtLQ04uLiSh8LDAwkJiaGhIQEABISEggKCqJLly6l28TFxeHm5sby5ctLt7ngggvw8vIq3SY+Pp4tW7Zw6NChKno3IiIi4sg8rC6goqSlpQEQHh5e5vHw8PDS59LS0ggLCyvzvIeHB8HBwWW2adSo0Qn7OPZcrVq1Tjh2fn4++fn5pfezs7PP8d2IiIiII3OZFigrTZ48mcDAwNJLVFSU1SWJiIhIJXKZFqiIiAgA0tPTqVOnTunj6enpdOjQoXSbjIyMMq8rKiri4MGDpa+PiIggPT29zDbH7h/b5r8mTJjA+PHjS+9nZ2crREnlMAzI3Q+ZOyE7FQpyofCIeSk4Am5u4OkHXr7g6QveNSGgLgRFgU8Q2GxWvwMRkXOTsgw2fAftB0NkB8vKcJkA1ahRIyIiIpg/f35pYMrOzmb58uWMHDkSgNjYWDIzM1m1ahWdO3cG4LfffqOkpISYmJjSbR5++GEKCwvx9PQEYN68eTRv3vyk3XcA3t7eeHt7V/I7lGqnIBdS18DulbD7TziwzQxOhUfObn9e/hAYBSFNzV86ddpDnQ7gF1KRVYuIVK41n8KaT8zfhVe8ZlkZThWgcnJySEpKKr2/fft2EhMTCQ4Opn79+owbN46nnnqKpk2b0qhRIx599FEiIyMZMGAAAC1btqRv377cdtttvPPOOxQWFjJ69GgGDx5MZGQkANdffz2PP/44I0aM4MEHH2T9+vW8+uqrvPzyy1a8ZalOSkpgz5+w+UfY9hukbwSj+CQb2qBmHQisB97+ZkuTp6/Z6lRSDIVH/2mRyoW8LMjaDUf2Q0EO7NtkXjb98O/uAqOgYU9o3AuiLwL/sJMcU0TEARTmwcZ/fn+1u87SUmyGYRiWVmCHhQsX0qtXrxMeHzZsGFOnTsUwDCZNmsR7771HZmYm559/Pm+99RbNmjUr3fbgwYOMHj2aWbNm4ebmxsCBA3nttdfw9/cv3Wbt2rWMGjWKlStXEhISwpgxY3jwwQfLXWd2djaBgYFkZWUREBBwbm9aXFtJMSQvgE2zYPMcyC3bxUxAXajXBeqdB2EtIaih2R3nYWeLZ+FRM0hl7jSD2d5E2PsXHEg6cdvwNtC0D7S+CiLaqttPRBzHxh/gyxvN343j1pvDFiqQPd/fThWgnIUClJxRzj5Y8zGsmgqZKf8+7h0AzeKhWV+oHwuBdSu3jrxss9Vr2wJIXghpa8s+X7uJGaRaXw3hrSq3FhGRM/niRrMFvftY6PNkhe9eAcpiClBySntWQcKb5l9RJYXmYz5B0OZqaHGZ2ZXm4XXaXVSq3P1mmNr0PWydB0X/zuJPZCfocotZq5efdTWKSPWUlwXPN4XifLjjD6jTrsIPoQBlMQUoOcHetbDgGfj7p38fq9sZuowwA4lnDetqO5X8w/D3z7D+W9j6y7+BzzsA2g2C826FsBbW1igi1ceaT+H7URDaAu5aVinDC+z5/naqQeQiTidjkxmcjg3atrlB2+ug20hLT78tF++a0PYa85KzDxI/M7scD22Hle+bl2Z9occ4aBBrdbUi4urWfmlet73GIcZmqgWqEqgFSsjLhgVPw4r3wCgBbNBmIFz0kDmNgLMqKYHtv8PKD2DzbOCfXx9RMWaQat7PIX6xiYiLOZwGL7YADLj7L6jVsFIOoxYoEasYBmyYCXMnQI65PBAtL4eL/ucag7Dd3MzpDhr3gv1JsPQ1+Gs67FoOM4aY80pd/Cg0vlhBSkQqzvpvAAPqda208GQvLeUiUlEObodPB8LXN5vhKbgx3PgdDPrUNcLTf4U0MSexG7fObH3y8jenR/h0IEztDzsTrK5QRFzFuq/Ma4vnfjqeApRIRfjrC3jnfNg2H9y94KIJMHKp2VLj6mpGwCWPm83qsaPB3Rt2LoEpfeGz62D/VqsrFBFntj/JXJXB5g6tBlhdTSkFKJFzkZcN394OM283Z/quH2ueHXLRQ+DpY3V1VcsvBOKfhrFroPNw85fd1p/hrW7w88NwNNPqCkXEGR1rfWrcG/xDra3lOApQImdrzyp49wJY+4V5dt1F/4Phs6F2Y6srs1ZgXbj8VRi1HJrGQ0kRJLwBr3c2z+IrOdnyNCIiJ2EYDtl9BwpQImdn1VT4sI95Sn9gFNz8E1z0ILi5W12Z4whpCkO/hKHfQEgzcz2+WXebn1vaequrExFnsPtPOLjNXO+z+aVWV1OGApSIPUqKzTPsZt1ttqy0vALu/APqd7O6MsfVNM4cDxY/2ZyEc8+fZsvdvIlQcMTq6kTEkSV+al63utJcPN2BKECJS0tNTWXx4sWkpqae+87ysuHzQbDsLfN+r4fhuo+hRq1z37erc/eE2Ltg1AozdBrFsORVc3xU0nyrqxMRR1R41FwJAaDD9dbWchIKUOLSkpOTSUpKIjk5+dx2dGgHfHgJJM0Djxpw7TS48AHNdWSvgDow6BMYMgMC6kHmTvj0avhhrLl0jIjIMZtnQ342BNaHBudbXc0JFKDEpUVHR9OkSROio6PPfifpG81xO/s2Q806cMtP0HpAhdVYLTXvB6OWQdc7zPurp8Hb3WH7ImvrEhHHkfiZed1hiDmJr4NxvIpEKlBkZCQdzutGZGTk2e1gz2qYeinkpEN4G7htAUR2rNgiqyvvmnDpczDsRwiqD5kpMO1ymPOAxkaJVHdZe2DbAvN2+8HW1nIKClDisg7lFjBuxhr6vrKIvMKzOHV+ZwJMuwKOHoK6nWHYLLMLSipWo57mIPPOw837K96F9y6CtHVWViUiVlo7AzCgQQ8IPocehEqkACUuy8fTneXbD7L70FE+WrLdvhdv+w0+uQoKDpt97zd9D77BlVOomK1Rl78KN3wD/hGwfwu83xuWvW3OA1ONVOiJDyLOyDAg8XPztgMOHj9GAUpcVg0vd+6Pbw7AWwu2cSAnv3wvTJpvnm1XdBSaxMHQr8wveKl8TeJg5BJo1g+KC2DuQ/DZtZCzz+rKqkyFnfgg4qx2rYADSebcT62utLqaU1KAEpc2oENd2tYNJCe/iFd+LceabCnL4YsbzC/vFpfB4M/By7fyC5V/+YXAkOlw6QvmunpJ8+CdHrD9D6srqxIVcuKDiDM7Nni81ZUO/cerApS4NDc3G/+7tCUAn69IISnjNKfKp60zWzsKj5gtIddMAQ/vKqpUyrDZoOttcPtCCG1pDuL/+ApY9AKUlFhdXaWKjIzk/PPPP/sTH0ScWcER2DDTvO3A3XegACXVQGzj2sS1DKe4xODZnzaffKMD28wxT/lZENUNrvsEPLyqtlA5UXgruO03aH89GCXw25Pw+XVw5KDVlYlIZTg291OQY879dDwFKKkWJlzaAg83G79uymDptv1ln8zaDR9fCbn7IKItXP+Fuu0ciZcvDHgLrngDPHz+6dLrCbtXWV2ZiFS01dPM6/aOOffT8Ry7OpEK0jjUn6Ex9QF46sdNFJf8c2ZXXjZ8eg1k7YLgxnDDt1AjyLpC5eRsNuh0I9z6q3lKc/ZumNIP1nxqdWUiUlH2J8GOPwAbdLzR6mrOSAFKqo2745pR08eDjXuz+Xb1bigugq9vgX2bzFPnb/oO/MOsLlNOJ6It3P47NO8Pxfnw/SiYfS8UFVhdmYicq2OtT00vgaAoa2spBwUoqTaC/bwY07sJAM//vIXCuf/7d227IdPNPndxfD4BMOhTczFnbLDyA3MG88PpVlcmImerKP/fs++OTarr4BSgpFoZ1r0hUcE1iDsyB8+V75oPXvUO1O1kbWFiHzc3czHnITPAOwB2LYP3LjSX3hER57N5Nhw5YK432jTe6mrKRQFKqhVvD3ee75TF4x5TATjc/UEtDOzMmvc11ycMaQ6H98KUS2H9t1ZXJSL2WjXVvO54I7h7WFpKeSlASfVyMJmYP8fhaStmZnEPHs+81OqK5FyFNIFb50GTS8zZ47++GRZMdvn5okRcxoFtsP134J+TRZyEApRUH4V58OVN2PIyyQ3tyEOFt/HNmj2s35NldWVyrnwCzeknYkeb939/Fr4ebk7KJyKO7djg8SZxTjUWVQFKqo+5D5mzjfvWxu+Gz+jboSGGAU/8uBGjmi1Y65Lc3CH+abjidXDzhI3fw9RLNbhcxJEVFcAa5xo8fowClFQPa7+EVVMAG1z9PgTW5YG+LfD2cGPF9oPMXZ9mdYVSUTrdBMN+gBrBkLoGPrgYMjZZXZVlUlNTWbx4MampqVaXInKiLbPhyH5zKplmfa2uxi4KUOL6MjbDrLvN2xc+AE0uBqBuUA3uuMBcsPWZnzaRV1hsVYVS0Rp0/2fSzcbmJKkf9oFtC6yuyhLJyckkJSWRnJxsdSkiJzo2eLyT8wweP0YBSlxbQS58NcxcILjRhXDhg2WevuPCxoQHeLPr4FGmLt1hTY1SOWo3NkNU/Vhzba3ProHVH1tdVZWLjo6mSZMmREdHW12KSFkHtkHyQpxl5vH/UoAS1zbnfti32WweHviBOU7mOH7eHjwQ3wKAN35LYt/hfCuqlMriGww3fQ9tr4OSIvhhDCx4BqrRmLfIyEjOP/98IiMjrS5FpKwV75nXTftArQbW1nIWFKDEdW383pzZ1uYG13x4ymVarupYl3b1AsnJL+KleVuquEipdB7ecPV7cMH95v3f/w++Hw3FhdbWJVKd5R/+d/B4zO3W1nKWFKDENR1Oh1njzNs9xkHD80+5qZubjYmXtQJgxspdbEjVtAYux2aD3o/AZS+bgTrxU5g+GPJzrK5MpHr6awYUHIbaTSC6t9XVnBUFKHE9hmF21Rw9aC4+e9GEM76kS8NgrmgfiWHA4z9oWgOX1eUWGPy5uf5h0q/mNAc5GVZXJVK9GMa/3XddbzeXZnJCzlm1yOmsngZbfwZ3L7jqPfDwKtfLHurXAh9PN1bsOMjsdXsruUixTPN+MHw2+NaGvX+ZZ+gd1BlqIlUmeQHs/xu8/KH9EKurOWsKUOJaDibD3P+Zty+eCOGtyv3SyKAajLywCQDPzN7E0QJNa+Cy6nWGEfOgVkM4tB0+jDfDlIhUvuX/tD51uB58Aqyt5Ry4VIB67LHHsNlsZS4tWrQofT4vL49Ro0ZRu3Zt/P39GThwIOnpZWcpTklJoX///vj6+hIWFsb9999PUVFRVb8VORslxTBzJBTmQoPzodsou3dxx4XR1A2qQWpWHu/8vq0SihSHUbsx3PILhLeF3AyY0h+2L7K6KhHXdnA7/D3XvN3VOQePH+NSAQqgdevW7N27t/SyePHi0ufuueceZs2axVdffcXvv/9OamoqV199denzxcXF9O/fn4KCApYuXcq0adOYOnUqEydOtOKtiL2WvwO7loFXTbjq7bPqV/fxdOd/l7YE4J3ft7H7kNZSc2k1w+Hm2dCwpzmg9dOBsOE7q6sScV0rPwAMaNwbQppaXc05cbkA5eHhQUREROklJCQEgKysLD788ENeeuklevfuTefOnZkyZQpLly5l2bJlAPzyyy9s3LiRTz/9lA4dOtCvXz+efPJJ3nzzTQoKCqx8W3Imh3bCb0+Zt+OfOqcFKS9tG0FMo2Dyi0p4Zk71XQKk2vAJhKFfQ8vLobgAvhr+7+zIIlJxCnJhzSfm7a53WFtLBXC5ALV161YiIyOJjo5m6NChpKSkALBq1SoKCwuJi4sr3bZFixbUr1+fhIQEABISEmjbti3h4eGl28THx5Odnc2GDRtOecz8/Hyys7PLXKQKGQbMvtecbbxBD+h40zntzmaz8dgVrXGzwZx1aSxJ2l9BhYrD8vSBa6f9s5ipYS79s/hlq6sScS1rv4S8LHPsYdNLrK7mnLlUgIqJiWHq1KnMnTuXt99+m+3bt9OzZ08OHz5MWloaXl5eBAUFlXlNeHg4aWnmQrJpaWllwtOx5489dyqTJ08mMDCw9BIVFVWxb0xOb8O3kDTPPOvuslcq5JTYlnUCuCm2IQCTfthAYXHJOe9THJybu/nzc/548/6vj8G8idVq1nKRSlNSAsveMm+fd9sJq0I4I5cKUP369ePaa6+lXbt2xMfHM2fOHDIzM/nyyy8r9bgTJkwgKyur9LJr165KPZ4c5+gh+Omf9e163gehzSps1/dc0ozafl4kZeQwTevkVQ82G8RNgkueNO8veRVmjTVPUBCRs7f1F3PqAu8A6HRuvQSOwqUC1H8FBQXRrFkzkpKSiIiIoKCggMzMzDLbpKenExERAUBERMQJZ+Udu39sm5Px9vYmICCgzEWqyLyJkLsPQprB+eMqdNeBNTx5sK95Fucrv24lIzuvQvcvDqzHWLjidXPW8tUfw9e3QJHGQYqctaWvmdedhzv11AXHc+kAlZOTw7Zt26hTpw6dO3fG09OT+fPnlz6/ZcsWUlJSiI2NBSA2NpZ169aRkfHvzMTz5s0jICCAVq3KP5+QVJEdi80vN4DLXzXXPKtg13SuR/uoIHLyi5j80+YK3784sE43wbVTwc0TNn4HM66HAp2VKWK33atg5xJw84BuI62upsK4VIC67777+P3339mxYwdLly7lqquuwt3dnSFDhhAYGMiIESMYP348CxYsYNWqVdx8883ExsbSrVs3APr06UOrVq248cYb+euvv/j555955JFHGDVqFN7eFf/lLOeguBB+/GesSufh0KB7pRzGzc3Gk1e2xmaDmWv2sCz5QKUcRxxUqyvh+hn/LP0yDz67BvJ0koiIXY61PrW9FgIira2lArlUgNq9ezdDhgyhefPmXHfdddSuXZtly5YRGhoKwMsvv8xll13GwIEDueCCC4iIiODbb78tfb27uzs//vgj7u7uxMbGcsMNN3DTTTfxxBNPWPWW5FRWvA/7t5jLccQ9Vu6XpaamsnjxYlJTU8v9mnb1ghjS1ZwW4dHv1mtAeXXTJA5unGmO3di5BD6+Ao4ctLoqEedwcDts+sG83X2MtbVUMJuhVVMrXHZ2NoGBgWRlZWk8VGXI2Qevd4L8bLPrrvPwcr908eLFJCUl0aRJE84///xyvy7rSCG9X1zIgdwCHurXgjsvbHwWhYtTS02ET6+GIwcgtCXc9B3UPPXYSBEB5txvLhzc+GK48dszb28xe76/XaoFSqqJ354ww1Od9tDxRrteGh0dTZMmTYiOjrbrdYG+nkz4Z4byV3/dyp7Mo3a9XlxAZAe4+SeoGQn7NsGUfpCpM25FTunIQVjzqXm7x1hra6kEClDiXFLXwOp/ZrLt95zdc4lERkZy/vnnExlpfz/8wE516dowmKOFxTwx69QTq4oLC20ON88xZ7o/mGyGqANaM1HkpFZ+aE5wHNEWGl1odTUVTgFKnIdhwE8PAYY5GLF+tyo9vM1m48kBbfBws/HzhnTmb0o/84vE9QQ3gpvnQu0mkLXLDFEZWvJHpIzCo7DiXfN297vNOdZcjAKUOI91X5uLBXv6QtzjlpTQPKImI85vBMDE7zeQm19kSR1iscC6ZndeWGvISYcpl8Lev6yuSsRxrP7EnKMvMApaD7C6mkqhACXOIT/HnDQToOd48wvMInfHNaVuUA32ZB7l5Xl/W1aHWMw/DIb/CJGd4OhBmHo57FppdVUi1ivKhyWvmLfPHwfunlZWU2kUoMQ5JLwJh1MhqAHEWnsqrK+XB09d1QaAj5ZsZ/2eLEvrEQv5BsNN30P9WMjPgk8GwI4lVlclYq3EzyF7D9SsAx1usLqaSqMAJY4vZ9+/E7HFPQaePpaWA9CreRiXt4+kxICHvl1LkeaGqr58AuCGb6DRBVCQA58OhG0LrK5KxBrFhbD4JfN2j7sd4vd1ZVGAEse36HnziymyI7QaYHU1pSZe1ooAHw/W78lmqhYbrt68/OD6L6HJJVB0FD4fBFvmWl2VSNVb9xVkpoBfKHQaZnU1lUoBShzbwWT48yPzdtzj4OY4P7KhNb353z9zQ7007292HdQ6adWaZw0Y/Bm0uAyK8+GLobDxe6urEqk6JcXwx4vm7e5jwMvX2noqmeN8G4mczG9PQ0mhOYtttOPNI3JdlyhiGgVzpKCYCd+uQxP7V3Me3uYCxG0GQkkRfHUzrP3K6qpEqsaGmXAgCWrUgi4jrK6m0ilAieNKTYT1X5u37VjvrkIOXc4189zcbDw7sB3eHm4sTtrPl39qZupqz90Trn4f2l8PRjHGt7fx95eT7Fp/UcTplJTAohfM291Ggbe/tfVUAQUocVy/PmZet70O6rSr0kMnJyeTlJREcnLyGbdtFOLHfX2aA/DU7E2kZeVVdnnn7GwWVRY7uLnDlW9C5+HYMGi28RWOLHrT6qpEKs/mWeYSR96BEHO71dVUCQUocUzbfoPkBeDmCb0frvLD27tm3i3nN6J9VBCH84p4eKbjd+XZExDlLLm5wWWvkNPGXK+xyeY3YNnbFhclUglKimHBZPN2zB3gE2htPVVEAUocj2HA/CfM2+eNgFoNq7wEe9fMc3ez8fw17fB0tzF/cwbfJzp2y87ZLqosdrLZ8B/4OvQYZ96f+xAsftnSkkQq3LqvzdYnnyCIHWV1NVVGAUocz98/m4sGe/pCz/usrqbcmoXXZGzvpgBM+mED6dmO25V3Losqi51sNnMM34UPmfd/fQwW/p/5h4KIsysqgAVPm7fPHwc1gqyspkopQIljMQxY+E9TcNfbwD/U2nrsdOdFjWlbN5Cso4U8+M1ah+/Kkypis0GvCdD7UfP+wmfgtycVosT5rZ4GmTvBPxy63mF1NVVKAUocy98/w95Es/Wp+1irq7Gbp7sbL13XHi8PNxZu2cf0FTorT45zwX3Q55+/1v94EX55RCFKnFfBEXOiY4AL7nf5eZ/+SwFKHMd/W5/8Qqyt5yw1Da/JA/HHzsrbSMoBTbApx+k+Gi7953TvhDdgzn3mKeAizmbFu5CTDkH1XX7W8ZNRgBLH4eStT8e7pUcjuv4zweZ9X/1FcYlaGeQ4XW+Dy18DbLDyA5g11jyTScRZHM2Exa+Yty/6H3h4WVmNJRSgxDE4cOvT2cyZ5OZm48Vr2+Pn5c6KHQd5b5GmC5D/6DwMrnoXbG6w5hOYeScUF1ldlUj5LH0d8jIhtAW0u87qaiyhACWOwYFbn852zqSoYF8mXd4agBd/2cLa3ZmVUJ04tfaD4JqPwM0D1n0J39xintUk4sgOp/87p1nvR8yJY6shBSixngO3PsG5zZl0bZd6XNo2gqISg7HT15CbrxYG+Y/WV8F1n4C7l7n48Jc3QaHjToEhwm9PQmEu1O1iLp5dTSlAifW2/uKwrU9wbnMm2Ww2Jl/VjshAH3YcOMJjP2yohArF6bW4FAZPBw8f+PsnmD7YPMNJnJpLLpm09y9Y86l5u+9kc4qOasrD3hcMGzaMESNGcMEFF1RGPVIdHZuZ+bwRDtf6VBECfT15aVAHhry/jK9W7ebC5qFc1k4TWMp/NI2DoV/B54PNZYw+uwau/wK8a1bK4fbn5PN32mGS9+eyN+soezPz2JuVR+bRQg7nFZKTX8SRgmJsmN+RbjYbNTzdCfT1JKiGJ7V8vahbqwb1g32pH+xL4zB/GtX2w82t+n6h/tex7n/ANSatNQz4+WHAgDYDIaqr1RVZyu4AlZWVRVxcHA0aNODmm29m2LBh1K1btzJqk+ogZRmkJJjdF91cdwmAbtG1GXVRE95YkMSEb9fRtm4gDWr7WV2WOJpGF8CNM83wtHMJfDwAbvjmnGd3PphbwOqdh1idcojEXZlsSTvMgVz7x1odKSg+7ev8vT1oFRlAu7qBnNcomNjGtQnw8TyX0p3asW5/l1kyafNs2PGH2VIa95jV1VjOZpzFVMn79u3jk08+Ydq0aWzcuJG4uDhGjBjBlVdeiadn9f3Pckx2djaBgYFkZWUREBBgdTmO7fPBZpdFxxvhyjesrqZSFRaXMPi9ZazaeYg2dQP4+s7u+HhWz8GXcgapa+CTq+DoIYhoZ4YqO1pnjxQUsXz7QRb9vY8/tu4nKSPnhG1sNmgQ7EvjUH/q1qpBncAaRAb5UMvXi5o+HtT08Sj9+TQMKDEMjhQUk3W0kMwjhRzMLWDXoSOkHDxCyoEjbM04TF5h2fms3N1sdIgK4oKmoVzaNoKm4ZXTmiZVoCgf3oyBQ9uh571w8USrK6oU9nx/n1WAOt7q1auZMmUKH3zwAf7+/txwww3cddddNG3a9Fx269QUoMopYxO81Q2wweiVEOL6PzOpmUfp/9ofHDpSyI3dGvDkgDZWlySOKn0DfHwl5O6DkOZw0/cQUOeUmx/MLeDXjenM3ZDG4qT9FBSVDTNNwvzpVD+ITvVr0ToykCZh/tTwqrgAX1RcwrZ9uazdnUnirkyWbjvA9v25ZbZpFu5P/7aRDOgYqRZYZ7P0dXPmfP9wGLOq0rqWrVZlAWrv3r18/PHHTJkyhd27dzNw4ED27NnD77//znPPPcc999xztrt2agpQ5TRzJPz1uXkWx+DPrK6myizcksHwKSsBeG1IR65o7wJjI6Ry7N9qhqjsPVCrIdz0A9RqUPp0Tn4Rc9enMXPNbpYlHywzYWvdoBpc0CyEnk1D6d64NkG+VT/R4e5DR1iStJ95G9P5/e99FBb/W1/PpiEMjanPxS3D8XTX+UwOLXc/vNYJ8rPgijeg041WV1RpKjVAFRYW8sMPPzBlyhR++eUX2rVrx6233sr1119ferCZM2dyyy23cOjQobN/F05MAaocsnbDq+2hpAhunQ/1ulhdUZV6/ufNvLlgG35e7vww5nwah/pbXZI4qkM74eMr4NAOqBmJcdP3JGQF8+Wfu5i7Ia1Mt1mrOgH0axNBfJsImob5Y3OgM6Syjhby68Z0vv8rlT+27itdAjA8wJubezRiaEx9albj8VIObdY4WDUFItrC7b+79LxPlRqgQkJCKCkpYciQIdx222106NDhhG0yMzPp2LEj27dvt6twV6EAVQ5zJ8Cyt6BhTxj+o9XVVLmi4hKGfrCc5dsP0jjUj+9G9dCXh5xa9l6Kp12B+4G/OWgLZGjeQ2wyzJao6BA/rupYlys6OE+32K6DR5i+IoUv/9zF/hxzUHqAjwc3xTbk5h4Nqe3vbXGFUmr3n/BBHGDA8NnQ8HyrK6pUlRqgPvnkE6699lp8fHzOqUhXpgB1BkcOwsttzInYhn5jnr5dDWUczuOK15eQlp1HXMtw3ruxs04BlxNsTstmyuIdLEzcxIduz9DGbQdZhh/Tm75IzAV96RAV5FAtTfYoKCrhh79SeXthEtv2meOl/Lzcuf2CxtzasxF+3nafKC4VqbgI3r8I0tZB+yFw1TtWV1TpqnQQuZxIAeoMfn8OFjwN4W3hzj+q9URsf+3K5Np3EygoKmFcXFPGxTWzuiRxAIZh8Pvf+/jgj+0sTtpf+njXCDfetD1L6KFE8PQzxw427mVdoRWkpMTgl41pvLEgifV7sgEI8ffm7rimDD4vSmOkrLLsbZj7EPgEweg/wT/U6ooqnQKUxRSgTqMwD15uDUf2w9UfQLtrra7Icl/9uYv7v14LwHs3dqZP6wiLKxKrFBWXMGd9Gm8v3MamvWaQcLNB3zYR3NKjEZ0b1MJWeARmDDUn23T3gmumQEvXWE7DMAxmr9vL8z9vYecBcyb25uE1eeqqNpzXMNji6qqZ7FR44zwoyIHLXoEuN1tdUZVQgLKYAtRprPkUvh8FAfXg7r/AXU30AI/9sIGpS3fg5+XO1yO707KOfm6qk8LiEr5dvZu3Fm4rDQ6+Xu4M6Vqf4d0bEhXsW/YFRfnwzQjYNAts7nDlm9BhiAWVV46CohJmrEzh5Xl/c+hIIQDXdK7HQ/1aEKLxUYC5TExycjLR0dGVM8v5l8Ng43dQ7zy45Rdwqx6tgPZ8f1ePT0Qcg2HAsn/60LveqvB0nIf7tyQ2uja5BcWMmLqSjGwtJlsdFBSVMGNFCr1eWMiD36xj54Ej1PL15J64Zix9qDePXtbqxPAE4OEN10yFDkPBKIbv7vz3/5YL8PJw46bYhvx270UM6RoFwNerdnPxi7/z3Zo96O/+f5eJSU5Orvidb/3VDE82d7js5WoTnuylFqhKoBaoU9ixGKb2B48aMH4j+KpJ/nhZRwq56u0lJO/LpW3dQL64oxu+XgqZrqiouISZa/bw6vyt7D50FIAQfy/uvLAx18fUL/+/e0kJ/Pw/WP62ef+CB6DX/1xuXOGalEM88t16NqSa3Zp9WoXz9FVtCa1ZfVujKq0FquAIvB1rTpsROxrin664fTsBdeFZTAHqFGYMhc0/Queb4fJXrK7GIe08kMtVby3lYG4Bl7QK550bOuOuM/NcRkmJwZz1e3lp3t8k/3PWWYi/N3deGM3QmAZnNzO4YcCiF2DBU+b9LiPg0uddbq6ewuIS3lm4jdd+20phsUEtX0+euaot/dqeenZ2OQvHppipGQmjV7jsjOOnogBlMQWokzi0A17tABhw13IIa2FxQY5r1c6DDHl/OQVFJQzv3pBJl7dy2tPUxWQYBn9s3c//zd1c2ooS5OvJyAsbc1Nsw4pZUmXlBzD7PsCA1lfDVe+CR9XPPl7ZNqZmc+9Xf5UOsr+hW30e6d9K60pWhJ1LYcqlgAFDv4aml1hdUZXTGChxPCveBwyI7qXwdAadGwTz4rXtAZi6dAev/5ZkcUVyLtbuzuSGD5dz00cr2JCajb+3B+PimvLHA72448LGFbce3Xm3wjUfgpsnbPgWPr8O8g9XzL4dSKvIAL4f1YM7L2wMwKfLUhjw5hKSMlzvvVapglz47i7AMBd3r4bhyV4KUKfw5ptv0rBhQ3x8fIiJiWHFihVWl+S88g/D6o/N293usrYWJ3F5+0gmXd4KgJfm/c0ny3ZaXJHYa9fBI4yZvoYr3ljCkqQDeLm7cUuPRix6oBfj4ppVzszzbQbC9TPMOaKSF8DUyyBnX8Ufx2JeHm481K8FH9/SlRB/LzanHeby15fwfeIeq0tzXr8+Doe2m2dIV7NxT2dLAeokvvjiC8aPH8+kSZNYvXo17du3Jz4+noyMDKtLc06J0yE/G2o3gSbVc9bxs3Fzj0aM7d0EgInfr2fWX6kWVyTlkXmkgKd+3MjFL/7OrL9Ssdng6o51mX/vhUy8vBXBfpXcrdYkDobNAt/asDcRPrwEDlbCmVoO4IJmocy5uyfnNwnhaGExd89I5KkfN1JUXHLmF8u/tv8BK941b1/5OvgEWluPk9AYqJOIiYnhvPPO44033gCgpKSEqKgoxowZw0MPPXTG12sM1HFKSuCNLnBwG1z6AnS9zeqKnIphGDz6/Xo+XZaCp7uNt4Z25pJW4VaXJSeRX1TMJwk7eW3+VrLzigA4v0kIEy5tQetIC76Q9ifBp1dBZgr4hcIN30Cd9lVfRxUoLjF48ZctvLVwGwCx0bV54/qOWlOvPPJz4O3ukLkTOg+Hy1+1uiJLaQzUOSgoKGDVqlXExf3bUuLm5kZcXBwJCQknfU1+fj7Z2dllLvKPpF/N8OQdaK6lJHax2Ww8fkUbrmgfSWGxwV2freLXjelWlyXHMQyD2Wv3cslLi3hq9iay84poEVGTabd05ZMRXa0JTwAhTWDEPHPJpNx95uDgpPnW1FLJ3N1sPNC3BW8P7YSvlzsJyQe44o0l/J2ucVFn9MvDZngKrA99nrK6GqeiAPUf+/fvp7i4mPDwsn/lh4eHk5aWdtLXTJ48mcDAwNJLVFRUVZTqHP780LzuOBS8/a2txUm5u9l46br29G9Xh8Jig5GfrWL+JoUoR7Am5RDXvJPAqM9Xk3LwCKE1vfm/gW2ZPbYnFzYLtf7syZoRcPNsaNjTXJLj8+tgzWfW1lSJ+rWtw/ejetCwti97Mo8y8K2lLPrb9caAVZgNM2HVVMAGV75R7aYsOFcKUBVgwoQJZGVllV527dpldUmOITMF/v7ZvN3lFmtrcXIe7m68OqgD/dv+E6I+Xa0QZaHdh44wdvoarnprKat2HsLH042xFzdl4X0XMei8+o41d5dPoNl91/Y6KCmC7++Chc+a80e5oKbhNfn2rh50bRjM4fwibp66ks+W6ySMExzaAT/cbd7uOR6iL7S0HGekAPUfISEhuLu7k55e9sspPT2diIiTL/Lq7e1NQEBAmYsAq6YBBjS6AEKaWl2N0/Nwd+OVwR24tG0EBcUl3PHJKr5bo7OOqlJ2XiHP/rSZ3i/+zg//DBC/pnM9Ft7Xi/GXNMPP20Fnjvfwhqvfg/PHm/cXTobvR0NxobV1VZJgPy8+ubUrV3eqS3GJwcMz1/N/czdrCZhjigvh6xGQnwVRMXDRBKsrckoKUP/h5eVF586dmT//37ECJSUlzJ8/n9jYWAsrczLFhf9OXaDWpwrj6e7Gq4M7clXHuhSVGIz7IpEpS7ZbXZbLKywu4ZOEHVz0/ELe+X0bBUUlxEbXZtbo83nh2vZEBPpYXeKZ2WwQN8lc28zmBomfwmfXwNFMqyurFN4e7rx4bXvuvaQZAG8v3Mb9X6+lUGfowW9Pwp4/zdbJgR+AeyVMqVENOOifS9YaP348w4YNo0uXLnTt2pVXXnmF3Nxcbr75ZqtLcx6bf4TcDPAPhxaXWV2NS/F0d+PFa9sTWMOTqUt38PisjRzMLWD8Jc2sH3PjYgzD4JeN6fzf3M2lS680DvXjf5e2pHeLMOf8vLvcAgF14aubIXkhfNgHhn4JtRpaXVmFs9lsjLm4KeEBPkyYuY6vV+3mQE4+bw7tVH3XmUz6FZb8c6bdFW9AUH1r63Fi1fQn6PQGDRrEvn37mDhxImlpaXTo0IG5c+eeMLBcTuPPj8zrjjfqr5tK4OZmY9Llrajt58WL8/7m9d+S2HPoKM9c3VZLWlSQNSmHmDxnMyt2HASgtp8X4+KaMrhrfTzdnbzxvlk83PITfD4Y9m+B9y+GwZ9D/RirK6sU150XRbCfF6M+X82CLfsY+sFypg7vSqBvNfvdlLUHZt5p3j7vVmh1hbX1ODnNA1UJqv08UPu3mnM/2dzg7rUQpLMSK9Nny3cy8fsNFJcYdKofxLs3dqnWq9Sfq+R9ObzwyxbmrDPPuvX2cOPWno2488LGlTN7uJWyU+HzQZC2Fty9YcBb0PYaq6uqNKt2HuSWqX+SdbSQVnUC+GRE1+ozV1ThUZjSD1LXmFNb3PoreDpB13MV0zxQYq0/p5jXTfsoPFWBoTENmHrzeQT4eLA6JZMBby4pXWhVyi8jO49HvlvHJS8vYs66tH8HiN9/EffHt3C98AQQEAm3zIXm/aE4H74ZAb89ZU6A64I6Nwhmxu3dCPH3YuPebAa9t4z07Dyry6p8hgGz7jbDU41gGPypwlMFUAtUJajWLVCFR+HFFpCXCdd/aXYVSJXYti+HW6f9yfb9ufh4uvHElW24rosC7JlkHingnd+Tmbp0O3mFZnDo3SKMB/o2p0VE1fz/TU1NJTk5mejoaCIjI6vkmGWUFMOvj8HS18z7zfvD1e+67LxAyftyGPrBcvZm5VE/2JfPbo0hKtjX6rIqz9I3zAkzbe5w40xNWXAaaoES62z4zgxPgfW17l0Vaxzqz8y7utOzaQh5hSU88PVa7v3yL44UFFldmkM6nFfIa/O30vP/FvDO79vIKyyhY/0gZtzejY+Gn1dl4QkgOTmZpKQkkpMtWrPOzR36PAlXvWt25W2ZDR9cAgdd8wzP6FB/vrwjlvrBvqQcPMLg95ax6+ARq8uqHNt+g3mPmrfjn1F4qkBqgaoE1boF6oNLYPcK6P0oXHCf1dVUSyUlBm8tTOKleX9TYkCTMH9eHdzBuiVFHMzhvEKmLtnBB4u3k3XUnAepRURN7o9vbtmZdZa3QB1v958wYyjkpEGNWnDtNJf90k3LymPI+8vYvj+XukE1mHF7N9dqiTqYDO/1Mv+o7XCDOdu4M545WoXs+f5WgKoE1TZAZWyGt2LMZuLxm6Cmzlq00rLkA4ydvoaMw/l4uNkY1asJo3o1wcujejY8Zx0pZFrCDj5asp3MI2Zwahzqx91xzbisbR3cHGn2cKtlp8KM680xMzY3iHscuo9xyS/f9Ow8hry3jGRXC1G5+80pKg5ug3rnwfDZ5oSqcloKUBartgHql0dg6evm+Ikhn1tdjQD7c/J5ZOZ65m4wzyhrWSeA569pR5u61ac1KiM7jw8Xb+fTZTvJLSgGzOA09uKmXNYu0rGWXXEkhUfhx3vgr+nm/VYDXHa9NJcLUfk5MO1ySF1tDqe4dZ65LqKckQKUxaplgCouhJdamqu+D54OLS61uiL5h2EY/Lh2LxO/X8+hI4W42cwz98Zf0oxafl5Wl1dpNqdl8+Ef2/k+MZWCf2afbhFRk5EXNVZwKi/DgJUfwNwJUFIIIc1h8GcuuTRTRnYeg99fRvK+XOoH+/LlHbHOMcP8fxUXwvQhkDTPPONuxC8u+e9VWRSgLFYtA9Tm2WaTv18YjN+oyTMd0L7D+Tw2awOz1+4FILCGJ+MvacbQmPp4OPvEkP8oLjH4/e8MpizZwR9b95c+3ql+EKN7N6FXcyedPdxqu1bAlzfB4b3g5Q+Xv+qS80WlZeVx3bsJpBw8QnSoH1/cHutcc6oZBnw30mw19KgBw2ZB1HlWV+VUFKAsVi0D1OeD4e+foPtY82wecVgJ2w7w+KwNbE47DED9YF9G927CVR3rOu0M2xmH8/jqz918vjyFPZlHAXCzQd82EYw4P5rODWpZXKELOJwOX98MO5eY9zvfDH0ng2cNa+uqYLsPHeG6dxJIzcqjeXhNpt/ejWBnaamdNwmWvGKOQx0yXdPInAUFKItVuwB1OA1eagVGMYxaAaHNra5IzqCouIQZK3fx8ry/OZBbAEBUcA3uuqgJAzrUpYaX4y8Hk19UzILNGXyzeg8LNmdQVGL+Kgus4cm1nesxrHtD5x7H4oiKi2DhM/DHS4AB4W3g2qku10W0Y38u172bQMbhfNrWDeTz22IcfyLVBZPh92fN21e+CR1vsLYeJ6UAZbFqF6AWvwK/ToJ6Xc3BiuI0jhQU8dmyFN5dtI39OWaQOhZAhnZrQKMQP4srLKuwuISEbQf4aX0ac9btLZ2GAMxuuqExDejfro7WA6xsSfPh29vhyH7w9IPLXoJ2g1zqLL2kjMNc9+4yDuYW0LVRMB/f0tUxf64MAxY8A4ueM+9f8iT0GGttTU5MAcpi1SpAGQa8cR4c2ApXvA6dbrK6IjkLRwuK+Wz5TqYu3cHuQ0dLH+/aMJj+7erQr00EYQHWDKg9mFvAkqT9LNiSwa8b08nO+3di0IgAHwZ0rMvATnVpGu56Z4c5tOy98M2tsHOxeb/NQOj/ojl3lItYvyeLIe8t43B+Eb1bhPHujZ0dq5vbMOC3J+GPF837fZ6G7qOtrcnJKUBZrFoFqJTl8FEf8PSF+/52yVOcq5Njg7A/SdjJwr/3cey3g80GXRrU4vwmocQ2rk2HqKBKm09q3+F81qQcYnVKJku37WfdniyO/y0V4u9Fn9YRXNqmDrGNa+tsOisVF8Hil2Dhs2YXfkA9uOodaNTT6soqzIrtB7nxw+XkF5VweftIXhnUwTF+5gzDXH5nySvm/fjJEHuXlRW5BAUoi1WrAPX9aFjzCXQYaq7kLi4jNfMoc9btZfa6vaxJySzzXA1Pd9rWDaR5RE1a1KlJ8/Ca1AmqQVhN73L9hV5UXMKB3ALSsvJI3p/D1vQckjJy2Lg3u0wL2DEtImpyfpMQ+rSOoHODWo7xBSb/2v0nfHubOfM1NrMLqdfDLjNx44LNGdz28Z8UlRjcFNuAx69obe3ZnCXF8PPDsPxt837f/4Nud1pXjwtRgLJYtQlQ+TnwYnMoyIGbf4IG3a2uSCrJnsyjLNicQULyAZZtO1A68Py/bDao7edNLV9PvD3d8PZwx8vdjcLiEo4WFpNXWEx2XhH7c/I51W8emw2ahdWkY/0gujQMpmfTEMIt6j4UO+TnwM8TYPXH5v2Q5uYfVfW6WFtXBfnhr1TunrEGw4B74ppxd5xFA+cLj5phddMs836/5yHmdmtqcUEKUBarNgEq8XNzzpHgaBiz2qUGkMqpGYZBUkYOG1Kz2ZSWzZa0w2xNzyHjcB6FxeX/deLuZiPE34sGtf1oGuZvXsJr0rZeIAGOfsaTnNrm2TBrHORmmMvAxI6GXv9ziekOpi3dwaQfNgDw1IA23NCtQdUWkLsfpg+G3SvB3QsGvO2S83FZyZ7vb48qqklc0V8zzOv21ys8VSM2m42m4TVpGl6TAdQtfbykxODQkQLSsvPIPlpEflExeYUlFBSX4OVuw9vTHR8Pd2r6eBAW4E1tP291xbmiFv2hfizMfQjWfgFLX4Mtc8yTTJy8lXpY94YcyC3gtflbefT79QT7eXFp2zpVc/AD2+DTgXBoO/gEweDPoWGPqjm2nJRaoCpBtWiByk41537CgLv/gloNra5IRBzNlp/M9fQOm7Pf0+EGuORx8Auxtq5zYBgGj3y3ns+Wp+Dl7sbUW86je+NKfj9J880zHo8ehKD6MPQbCG1Wucespuz5/nag8zHFqaz7CjDMvzQVnkTkZJr3g7uWQadh5v3ET+H1zrBqKpSUWFra2bLZbDxxZRv6tYmgoLiEOz5excbU7Mo5WEkx/Pa02fJ09CBEdoJb5ys8OQgFKDk7a780r9sNsrYOEXFsNYLgitdgxK8Q3hbyMmHW3fDhJbBrpdXVnRV3NxsvD+pA10bBHM4vYviUFew6eKRiD5KTAZ9c9c8EmQZ0ucU8Wcc/rGKPI2dNAUrsl7Ye0tebgxhbD7C6GhFxBlHnwe0LzfmKvPxhz5/wYRx8fQsc2ml1dXbz8XTn/Zu60Dy8JhmH8xn20QoOnuLsVLsl/w7v9ITtv5szvV/9AVz2MnjqbFRHogAl9lv7hXndtI9LzTosIpXM3cOc7HH0n+Z4KGyw/htzNYN5E+FoptUV2iWwhifTbulK3aAaJO/PZcS0lRwtKD77HeZlwQ9j4eMrICcNQlvA7Qug3bUVV7RUGAUosU9JMaz72rzdfrC1tYiIcwqoAwPehDsWQaMLoDgflrwKr7aD35+DvEoaU1QJIgJ9mHbLeQTW8GRNSiZjpq+hqPgsxndtmQtvdoPV08z7XW6B237T4uwOTAFK7LNjMRxOBZ9AswVKRORs1WkHN/0AQ74wW1vysmDB0/BKW1j0POQftrrCcmkSVpMPh3XB28ONXzel8+j3Gyj3Ce5Zu81uzOmDzN+twdEwfLbZZeflWIt5S1kKUGKfY913ra9ymWUaRMRCNhs07wsjl8LAD6F2U3Og+W9PwcttYP4T5sLFDq5Lw2BeHdwRmw2mr0jh9d+STv+Co5lmt+VrncxuTJsbdB8Ldy6BhudXSc1ybjQPVCVw2XmgCo7AC82g4LCWbhGRylFSbAaK3/8PDvwTQtw8zRm3u91ltlo5sI8TdjDxe3O28ueuacd1XaLKblCUDys/MFvYjh4yH2twPsQ/BZEdq7ha+S/NRC6V4++fzPAUVB+iulldjYi4Ijd3aHcdtBloLguz7C1ISYC/ppuXqG7Q8QbzDGDvmlZXe4KbYhuSlpXHWwu3MeHbdYT6e9OrRZi5DMufH8GK981lbsDstox7HJrFazUHJ6QWqErgsi1Qn10HW3+GnvfBxY9aXY2IVBe7V8GyN2HDd2D8c5abp585lKDD9VC/mxm8HIRhGNz71V98u3oPbTz3Mq3VKmpv+xaK8swNAurCRQ+Zy2C5qx3DkWgxYYu5ZIA6chBeaAolRTBqhc4MKafU1FSSk5OJjo4mMjLS6nJEnFv2Xlg7A9Z8+m/3HoBfKDS/FFpebp7VZ/X4zMwUitd9w65Fn9Kw8Lg6Izuaiyu3uhLctWC2I1IXnlS8TbPM8BTeVuHJDsnJySQlmb9AFaBEzlFAHTj/HugxDnYthzWfwMZZkLvPPP1/9TTwqgmNekKDHuZiu+FtK7+Vp7gQUtfAjj/g759h13LcgYZAEe78WtyJH/2u4rEhIwipqckwXYUClJTP+m/M6zZXWVuHk4mOji5zLSIVwGYzu+3qd4P+L8POxeZ4qc2zzYWLt8wxL2AGqqjzILw1hLWCsJYQ0hy8fM/u2EUFcDAZ9m+BfVvM8Vkpy6Dw+KVcbOaZdG0GciiqD09P28Kug0fZOfVPZtzeDT9vffW6AnXhVQKX68LLyYAXm4NRAmMTIbiR1RWJiJyopAT2JpotQTuWmMEmP+skG9rMNeX8w8A/HPwjwLeWebafmzu4eYDNHQpyzDPljl0O74WD2/8dh3W8GsFmi1fDC8yuxIA6pU8l78vhmncSOJhbwAXNQvlwWBc83TWLkCPSGCiLuVyAWvE+zLnP7L+/faHV1YiIlE9Jsblu5+4/Yd9myNgE6Rvg6MFz269XTQhpag5niOxotjaFtgS3U4eixF2ZDHlvGUcLi7m6Y11evK49Np1553A0Bkoq1oaZ5nXrq62tQ0TEHm7uUKe9eTnGMMwpBQ6nmq3rOenm5chBs5W9pMgMXiVF5qLHNWpBjSDz2i/UDE4169g97UCHqCDeGtqJWz/+k2/X7CG0pjcTLm1Zse9XqpQClJxe9l7YudS83Vrjn0TEydls4B9qXqpYrxZh/N/Adtz31V+8uyiZ2v5e3H5B4yqvQyqGOmHl9DZ+BxgQFQNBUWfaWkRETuOazvWY0K8FAM/M2cw3q3ZbXJGcLQUoOb3135rX6r4TEakQd1zYmNt6mifjPPDNWuZvSre4IjkbClByapm7YPcKwGZO/CYiIhViQr+WXN2xLsUlBnd9tprlyQesLkns5FIBqmHDhthstjKXZ599tsw2a9eupWfPnvj4+BAVFcVzzz13wn6++uorWrRogY+PD23btmXOnDlV9RYcy7HB4w16lDklV0REzo2bm43/u6YdcS3DyC8qYcS0P1m3+2RTLoijcqkABfDEE0+wd+/e0suYMWNKn8vOzqZPnz40aNCAVatW8fzzz/PYY4/x3nvvlW6zdOlShgwZwogRI1izZg0DBgxgwIABrF+/3oq3Y60N/3TfafJMEZEK5+nuxhvXd6JbdDA5+UXc9NFytqYftrosKSeXC1A1a9YkIiKi9OLn51f63GeffUZBQQEfffQRrVu3ZvDgwYwdO5aXXnqpdJtXX32Vvn37cv/999OyZUuefPJJOnXqxBtvvGHF27HOwWRzaQKbO7RU952ISGXw8XTng2Hn0b5eIIeOFHLDh8tJOXDkzC8Uy7lcgHr22WepXbs2HTt25Pnnn6eoqKj0uYSEBC644AK8vLxKH4uPj2fLli0cOnSodJu4uLgy+4yPjychIaFq3oCj2PCded3oAktO9xURqS78vT2YenNXmoX7k56dz5D3l7H7kEKUo3OpADV27FhmzJjBggULuOOOO3jmmWd44IEHSp9PS0sjPDy8zGuO3U9LSzvtNseeP5n8/Hyys7PLXJzeplnmtQaPi4hUulp+Xnw6IoboED/2ZB7l+veXszfrqNVlVQpXWQDF4QPUQw89dMLA8P9eNm/eDMD48eO56KKLaNeuHXfeeScvvvgir7/+Ovn5+ZVa4+TJkwkMDCy9REU5+XxJmbsgdTVggxb9ra5GRKRaCAvw4fPbulE/2JeUg0cY+v5yMrLzrC6rQiVsO8DAt5eyOc35GxocPkDde++9bNq06bSXU610HxMTQ1FRETt27AAgIiKC9PSy820cux8REXHabY49fzITJkwgKyur9LJr166zfbuOYfOP5nWD7uZimyIiUiUiAn34/LYY6gbVIHl/LkPeX0a6i4SovMJiHp65jtUpmXy6bKfV5Zwzh1/KJTQ0lNDQsxuDk5iYiJubG2FhZgiIjY3l4YcfprCwEE9PTwDmzZtH8+bNqVWrVuk28+fPZ9y4caX7mTdvHrGxsac8jre3N97e3mdVo0Pa+IN53fJya+sQEamG6tXyZfpt3Rj0XgLb9uUy6N0EPr+tG5FBNawu7Zy8tSCJ5P25hNX05v74FlaXc84cvgWqvBISEnjllVf466+/SE5O5rPPPuOee+7hhhtuKA1H119/PV5eXowYMYINGzbwxRdf8OqrrzJ+/PjS/dx9993MnTuXF198kc2bN/PYY4/x559/Mnr0aKveWtXKyYCUfwbMK0CJiFiifm1fvrwjlnq1arDjwBGuezeBXQedd2D51vTDvP37NgAeu6I1gTU8La7o3LlMgPL29mbGjBlceOGFtG7dmqeffpp77rmnzBxPgYGB/PLLL2zfvp3OnTtz7733MnHiRG6//fbSbbp3787nn3/Oe++9R/v27fn666/57rvvaNOmjRVvq+pt/hEwILITBNazuhoRkWorKtgMUQ1r+7L70FGuezeB5H05Vpdlt5ISg//NXEdhsUFcyzD6tTn1kBhnYjNcZTi8A8nOziYwMJCsrCwCAgKsLsc+n1wF236DuMfg/HusrkZEpNpLz87j+veXsW1fLsF+XkwZfh7to4KsLqvcPl+ewv9mrsPXy5154y+krgN3Rdrz/e0yLVBSAY4egu2LzNst1H0nIuIIwgN8+OKOWNrWDeRgbgFD3l/Gor/3WV1WuezJPMqzP20C4L4+zbEdOcTixYtJTU21uLJzpwAl/9oyF0qKIKwVhDSxuhoREflHiL8302/vRs+mIRwpKOaWqSv5bs0eq8s6rbzCYu78ZBXZeUW0jwpiWPeGJCcnk5SURHJystXlnTMFKPnXsckzW15hbR0iInICf28PPhx2Hle0j6SoxGDcF4m89MsWSkocbySOYRg88t161u3JopavJ29e3xF3NxvR0dE0adLklNMPOROHn8ZAqkh+Dmybb97W2XfiAlJTU0lOTiY6OprIyEiry6m29O9Qsbw83HhlUAfqBPrw7qJkXvstiS3ph3npug74eTvOV/qny3by9arduNng9SGdqFfLF4DIyEiX+TlQC5SYkuZBUR4ER0N4a6urETlnrtRV4Mz071Dx3NxsTLi0JS9c2x4vdzd+3pDOwLeXOsw0B3/uOMjjszYC8GDfFpzfNMTiiiqHApSYjp8802azthaRCuBKXQXOTP8OleeazvWYfns3Qvy92Zx2mEtf/YNZf1k7OHt1yiFunrqSohKD/u3qcPsFrvvvrmkMKoHTTWNQlA/PRUNBDtw6H+p1sboiEREpp9TMo4ydvoY/dx4C4Lou9Xjsitb4elVtl97y5APcMnUluQXFdGlQi2m3dHWobsXy0DQGYp8df5jhyT/CnEBTREScRmRQDWbc3o2xvZtgs8GXf+6m/2uLWbptf5XVsHjrfoZNWUFuQTHdG9fm4xHOF57spQAlsOUn87p5X3DTj4SIiLPxcHdjfJ/mfH5rNyICfNi+P5fr31/OPV8ksu9wfqUd1zAMPk7YwS3TVpJXWMJFzUP5aPh5Vd76ZQV9W1Z3hnFcgLrU2lpEROScxDauzc/3XMCN3Rpgs8HMNXu4+MWFvL8omSMFRRV6rPTsPIZNWcnE7zdQUFRCfOtw3r2xMz6e7hV6HEelMVCVwKnGQO39C969ADx94YFk8HTcKfZFRKT8Endl8vDMdWxIzQYg2M+LEec34qbYBtT0OfvFfAuKSvhuzR6enrOJrKOFeHu48VC/FgyLbYibm3OfhGTP97frt7HJ6R1rfWrcW+FJRMSFdIgK4vtRPfhm9W7eWriNnQeO8PzPW3hn4Tb6tI7gsvZ16NE4BC+P8nVGHcot4LPlO/k4YScZ/3QLtq0byMuD2tMkrGZlvhWHpABV3W2ZY14372dtHSIiUuE83N0YdF59Bnaqx6y1qbzxWxLb9uXyzerdfLN6N4E1PImNrk3ziJq0iKhJo1A/3G02ig2D4hKDnQeOkLgrk8SUTBJ3Z1JQVAJAeIA3t/RoxC3nN8LTvXqOBlIXXiVwmi68rN3wcmvABvcngZ9rTnYmIiKmkhKDP3ce4se1qcxZl8b+HPsGmLeODODWno3o3zay3C1XzkRdeFI+x7rvomIUnkREqgE3NxtdGwXTtVEwky5vzZ87DrJuTxZb0g7zd/phUv6ZzdzdzYabzUZoTW86RAXRISqIjvVr0TjUD5smWwYUoKq30rPv1H0nIlLduLvZiImuTUx0batLcUqu1/4m5ZOXDdsXmbc1fYGIiIhdFKCqq22/QUkhBDeGkKZWVyMiIuJUFKCqq+O779SfLSIiYhcFqOqouAi2/mzeVvediIiI3RSgqqNdy+HoIahRyzwDT0REROyiAFUd/T3XvG7aB9x1IqaIiIi9FKCqo62/mNfN4q2tQ+QkUlNTWbx4MampqVaXIiJySmp+qG4O7YR9m8HmZq5/J+JgkpOTSUpKAiAyMtLiakRETk4BqrpJmmdeR8WYY6BEHEx0dHSZaxERR6QAVd1s/SdANb3E2jpETiEyMlItTyLi8DQGqjopzIPk383bTftYW4uIiIgTU4CqTnYuhqKjUDMSwttYXY2IiIjTUoCqTo7vvtPs4yIiImdNAao6OTZ9gbrvREREzokCVHVxYBscTAY3T4i+0OpqREREnJoCVHXx9z9r3zXoDt41ra1FRETEySlAVRfqvhMREakwClDVQX4O7Fxi3laAEhEROWcKUNXB9kVQXAC1GkJIU6urERERcXoKUNXB8d13mr5ARETknClAuTrDOG7+J3XfiYiIVAQFKFe3/2/I3g3u3tCgh9XViIiIuAQFKFe37TfzukF38PK1thYREREX4TQB6umnn6Z79+74+voSFBR00m1SUlLo378/vr6+hIWFcf/991NUVFRmm4ULF9KpUye8vb1p0qQJU6dOPWE/b775Jg0bNsTHx4eYmBhWrFhRCe+oiiTNN68b97a2DhERERfiNAGqoKCAa6+9lpEjR570+eLiYvr3709BQQFLly5l2rRpTJ06lYkTJ5Zus337dvr370+vXr1ITExk3Lhx3Hrrrfz888+l23zxxReMHz+eSZMmsXr1atq3b098fDwZGRmV/h4rXFE+7Fhs3m5ysbW1iIiIuBCbYRiG1UXYY+rUqYwbN47MzMwyj//0009cdtllpKamEh4eDsA777zDgw8+yL59+/Dy8uLBBx9k9uzZrF+/vvR1gwcPJjMzk7lz5wIQExPDeeedxxtvvAFASUkJUVFRjBkzhoceeqhcNWZnZxMYGEhWVhYBAQEV8K7PUvJC+PhK8I+AezfrDDwREZHTsOf722laoM4kISGBtm3bloYngPj4eLKzs9mwYUPpNnFxcWVeFx8fT0JCAmC2cq1atarMNm5ubsTFxZVuczL5+flkZ2eXuTiEY+OfGvdWeBIREalALhOg0tLSyoQnoPR+WlraabfJzs7m6NGj7N+/n+Li4pNuc2wfJzN58mQCAwNLL1FRURXxls5d0nEBSkRERCqMpQHqoYcewmaznfayefNmK0sslwkTJpCVlVV62bVrl9UlweF0SF9n3m7cy9paREREXIyHlQe/9957GT58+Gm3iY6OLte+IiIiTjhbLj09vfS5Y9fHHjt+m4CAAGrUqIG7uzvu7u4n3ebYPk7G29sbb2/vctVZZZIXmNd12oNfiLW1iIiIuBhLA1RoaCihoaEVsq/Y2FiefvppMjIyCAsLA2DevHkEBATQqlWr0m3mzJlT5nXz5s0jNjYWAC8vLzp37sz8+fMZMGAAYA4inz9/PqNHj66QOqvMNnXfiYiIVBanGQOVkpJCYmIiKSkpFBcXk5iYSGJiIjk5OQD06dOHVq1aceONN/LXX3/x888/88gjjzBq1KjS1qE777yT5ORkHnjgATZv3sxbb73Fl19+yT333FN6nPHjx/P+++8zbdo0Nm3axMiRI8nNzeXmm2+25H2flZIS2PZPC1RjTV8gIiJS4QwnMWzYMAM44bJgwYLSbXbs2GH069fPqFGjhhESEmLce++9RmFhYZn9LFiwwOjQoYPh5eVlREdHG1OmTDnhWK+//rpRv359w8vLy+jatauxbNkyu2rNysoyACMrK+ts3uq5S/3LMCYFGMZTdQyjMN+aGkRERJyMPd/fTjcPlDOwfB6oxa/Ar5OgWV+4/ouqP76IiIgTqpbzQMlxtmn5FhERkcqkAOVqCnIhZZl5W+OfREREKoUClKvZsQSKCyCwPtRubHU1IiIiLkkBytUcm/+p8UVavkVERKSSKEC5muTfzevoiywtQ0RExJUpQLmSnH2QYS6cTKMLra1FRETEhSlAuZLt/7Q+hbfV8i0iIiKVSAHKlRwLUNFqfRIREalMClCu5Nj4J3XfiYiIVCoFKFdxaAdk7gQ3D2jQ3epqREREXJoClKs41vpUtwt4+1tbi4iIiItTgHIVGv8kIiJSZRSgXIFhwPZF5m2NfxIREal0ClCuIGMj5O4DT1+od57V1YiIiLg8BShXcGz8U4Pu4OFlbS0iIiLVgAKUK0heaF6r+05ERKRKKEA5u+JC2LnEvK0B5CIiIlVCAcrZ7VkNBTlQI9hcwkVEREQqnQKUszs2fUGjnuCmf04REZGqoG9cZ6flW0RERKqcApQzKzwKu1eYt6MvsrQUERGR6kQBypntXgnFBVAzEoKjra5GRESk2lCAcmY7FpvXDc8Hm83aWkRERKoRBShndnyAEhERkSqjAOWsCo+aXXigACUiIlLFFKCclcY/iYiIWEYByllp/JOIiIhlFKCclcY/iYiIWEYByhlp/JOIiIilFKCckcY/iYiIWEoByhlp/JOIiIilFKCckcY/iYiIWEoBytlo/JNUgNTUVBYvXkxqaqrVpYiIOCUPqwsQO5WOf6qj8U9y1pKTk0lKSgIgMjLS4mpERJyPApSz0fgnqQDR0dFlrkVExD4KUM5G45+kAkRGRqrlSUTkHGgMlDMpM/6pp7W1iIiIVGMKUM5E459EREQcgtMEqKeffpru3bvj6+tLUFDQSbex2WwnXGbMmFFmm4ULF9KpUye8vb1p0qQJU6dOPWE/b775Jg0bNsTHx4eYmBhWrFhRCe/oLGj8k4iIiENwmgBVUFDAtddey8iRI0+73ZQpU9i7d2/pZcCAAaXPbd++nf79+9OrVy8SExMZN24ct956Kz///HPpNl988QXjx49n0qRJrF69mvbt2xMfH09GRkZlvbXya9wbYkdD66usrkRERKRasxmGYVhdhD2mTp3KuHHjyMzMPOE5m83GzJkzy4Sm4z344IPMnj2b9evXlz42ePBgMjMzmTt3LgAxMTGcd955vPHGGwCUlJQQFRXFmDFjeOihh8pVY3Z2NoGBgWRlZREQEGDfGxQRERFL2PP97TQtUOU1atQoQkJC6Nq1Kx999BHH58OEhATi4uLKbB8fH09CQgJgtnKtWrWqzDZubm7ExcWVbiMiIiLiUtMYPPHEE/Tu3RtfX19++eUX7rrrLnJychg7diwAaWlphIeHl3lNeHg42dnZHD16lEOHDlFcXHzSbTZv3nzK4+bn55Ofn196Pzs7uwLflYiIiDgaS1ugHnrooZMO/D7+crrg8l+PPvooPXr0oGPHjjz44IM88MADPP/885X4DkyTJ08mMDCw9BIVFVXpxxQRERHrWNoCde+99zJ8+PDTbnMuMyXHxMTw5JNPkp+fj7e3NxEREaSnp5fZJj09nYCAAGrUqIG7uzvu7u4n3SYiIuKUx5kwYQLjx48vvZ+dna0QJSIidktNTSU5OZno6GhNduvgLA1QoaGhhIaGVtr+ExMTqVWrFt7e3gDExsYyZ86cMtvMmzeP2NhYALy8vOjcuTPz588vHYheUlLC/PnzGT169CmP4+3tXXoMERGRs6V1Kp2H04yBSklJ4eDBg6SkpFBcXExiYiIATZo0wd/fn1mzZpGenk63bt3w8fFh3rx5PPPMM9x3332l+7jzzjt54403eOCBB7jlllv47bff+PLLL5k9e3bpNuPHj2fYsGF06dKFrl278sorr5Cbm8vNN99c1W9ZRESqGa1T6UQMJzFs2DADOOGyYMECwzAM46effjI6dOhg+Pv7G35+fkb79u2Nd955xyguLi6znwULFhgdOnQwvLy8jOjoaGPKlCknHOv111836tevb3h5eRldu3Y1li1bZletWVlZBmBkZWWd7dsVERGRKmbP97fTzQPlDDQPlIiIiPOp1vNAiYiIiFQ2BSgREREROylAiYiIiNhJAUpERETETgpQIiIiInZSgBIRERGxkwKUiIiIiJ0UoERERETspAAlIiIiYicFKBERERE7KUCJiIiI2EkBSkRERMROHlYX4IqOrc+cnZ1tcSUiIiJSXse+t499j5+OAlQlOHz4MABRUVEWVyIiIiL2Onz4MIGBgafdxmaUJ2aJXUpKSkhNTaVmzZrYbLYK3Xd2djZRUVHs2rWLgICACt23q9FnVX76rMpPn1X56bMqP31W5VeZn5VhGBw+fJjIyEjc3E4/ykktUJXAzc2NevXqVeoxAgIC9J+snPRZlZ8+q/LTZ1V++qzKT59V+VXWZ3WmlqdjNIhcRERExE4KUCIiIiJ2UoByMt7e3kyaNAlvb2+rS3F4+qzKT59V+emzKj99VuWnz6r8HOWz0iByERERETupBUpERETETgpQIiIiInZSgBIRERGxkwKUiIiIiJ0UoJzE008/Tffu3fH19SUoKOik29hsthMuM2bMqNpCHUR5Pq+UlBT69++Pr68vYWFh3H///RQVFVVtoQ6oYcOGJ/wcPfvss1aX5TDefPNNGjZsiI+PDzExMaxYscLqkhzOY489dsLPUIsWLawuyyEsWrSIyy+/nMjISGw2G999912Z5w3DYOLEidSpU4caNWoQFxfH1q1brSnWYmf6rIYPH37Cz1nfvn2rrD4FKCdRUFDAtddey8iRI0+73ZQpU9i7d2/pZcCAAVVToIM50+dVXFxM//79KSgoYOnSpUybNo2pU6cyceLEKq7UMT3xxBNlfo7GjBljdUkO4YsvvmD8+PFMmjSJ1atX0759e+Lj48nIyLC6NIfTunXrMj9Dixcvtrokh5Cbm0v79u158803T/r8c889x2uvvcY777zD8uXL8fPzIz4+nry8vCqu1Hpn+qwA+vbtW+bnbPr06VVXoCFOZcqUKUZgYOBJnwOMmTNnVmk9ju5Un9ecOXMMNzc3Iy0trfSxt99+2wgICDDy8/OrsELH06BBA+Pll1+2ugyH1LVrV2PUqFGl94uLi43IyEhj8uTJFlbleCZNmmS0b9/e6jIc3n9/Z5eUlBgRERHG888/X/pYZmam4e3tbUyfPt2CCh3Hyb7fhg0bZlx55ZWW1GMYhqEWKBczatQoQkJC6Nq1Kx999BGGpvk6qYSEBNq2bUt4eHjpY/Hx8WRnZ7NhwwYLK3MMzz77LLVr16Zjx448//zz6trEbNVctWoVcXFxpY+5ubkRFxdHQkKChZU5pq1btxIZGUl0dDRDhw4lJSXF6pIc3vbt20lLSyvzMxYYGEhMTIx+xk5h4cKFhIWF0bx5c0aOHMmBAweq7NhaTNiFPPHEE/Tu3RtfX19++eUX7rrrLnJychg7dqzVpTmctLS0MuEJKL2flpZmRUkOY+zYsXTq1Ing4GCWLl3KhAkT2Lt3Ly+99JLVpVlq//79FBcXn/TnZvPmzRZV5ZhiYmKYOnUqzZs3Z+/evTz++OP07NmT9evXU7NmTavLc1jHfvec7Gesuv9eOpm+ffty9dVX06hRI7Zt28b//vc/+vXrR0JCAu7u7pV+fAUoCz300EP83//932m32bRpU7kHXz766KOltzt27Ehubi7PP/+8ywSoiv68qhN7Prvx48eXPtauXTu8vLy44447mDx5suVLJ4hz6NevX+ntdu3aERMTQ4MGDfjyyy8ZMWKEhZWJKxk8eHDp7bZt29KuXTsaN27MwoULufjiiyv9+ApQFrr33nsZPnz4abeJjo4+6/3HxMTw5JNPkp+f7xJffBX5eUVERJxw9lR6enrpc67mXD67mJgYioqK2LFjB82bN6+E6pxDSEgI7u7upT8nx6Snp7vkz0xFCgoKolmzZiQlJVldikM79nOUnp5OnTp1Sh9PT0+nQ4cOFlXlPKKjowkJCSEpKUkBytWFhoYSGhpaaftPTEykVq1aLhGeoGI/r9jYWJ5++mkyMjIICwsDYN68eQQEBNCqVasKOYYjOZfPLjExETc3t9LPqbry8vKic+fOzJ8/v/Ts1pKSEubPn8/o0aOtLc7B5eTksG3bNm688UarS3FojRo1IiIigvnz55cGpuzsbJYvX37GM7AFdu/ezYEDB8qEz8qkAOUkUlJSOHjwICkpKRQXF5OYmAhAkyZN8Pf3Z9asWaSnp9OtWzd8fHyYN28ezzzzDPfdd5+1hVvkTJ9Xnz59aNWqFTfeeCPPPfccaWlpPPLII4waNcplAufZSEhIYPny5fTq1YuaNWuSkJDAPffcww033ECtWrWsLs9y48ePZ9iwYXTp0oWuXbvyyiuvkJuby80332x1aQ7lvvvu4/LLL6dBgwakpqYyadIk3N3dGTJkiNWlWS4nJ6dMS9z27dtJTEwkODiY+vXrM27cOJ566imaNm1Ko0aNePTRR4mMjKyWU9Kc7rMKDg7m8ccfZ+DAgURERLBt2zYeeOABmjRpQnx8fNUUaNn5f2KXYcOGGcAJlwULFhiGYRg//fST0aFDB8Pf39/w8/Mz2rdvb7zzzjtGcXGxtYVb5Eyfl2EYxo4dO4x+/foZNWrUMEJCQox7773XKCwstK5oB7Bq1SojJibGCAwMNHx8fIyWLVsazzzzjJGXl2d1aQ7j9ddfN+rXr294eXkZXbt2NZYtW2Z1SQ5n0KBBRp06dQwvLy+jbt26xqBBg4ykpCSry3IICxYsOOnvpmHDhhmGYU5l8Oijjxrh4eGGt7e3cfHFFxtbtmyxtmiLnO6zOnLkiNGnTx8jNDTU8PT0NBo0aGDcdtttZaamqWw2w9B57iIiIiL20DxQIiIiInZSgBIRERGxkwKUiIiIiJ0UoERERETspAAlIiIiYicFKBERERE7KUCJiIiI2EkBSkRERMROClAiIiIidlKAEhEREbGTApSIyBns27ePiIgInnnmmdLHli5dipeXF/Pnz7ewMhGxitbCExEphzlz5jBgwACWLl1K8+bN6dChA1deeSUvvfSS1aWJiAUUoEREymnUqFH8+uuvdOnShXXr1rFy5Uq8vb2tLktELKAAJSJSTkePHqVNmzbs2rWLVatW0bZtW6tLEhGLaAyUiEg5bdu2jdTUVEpKStixY4fV5YiIhdQCJSJSDgUFBXTt2pUOHTrQvHlzXnnlFdatW0dYWJjVpYmIBRSgRETK4f777+frr7/mr7/+wt/fnwsvvJDAwEB+/PFHq0sTEQuoC09E5AwWLlzIK6+8wieffEJAQABubm588skn/PHHH7z99ttWlyciFlALlIiIiIid1AIlIiIiYicFKBERERE7KUCJiIiI2EkBSkRERMROClAiIiIidlKAEhEREbGTApSIiIiInRSgREREROykACUiIiJiJwUoERERETspQImIiIjYSQFKRERExE7/D5D/6sSr/ogsAAAAAElFTkSuQmCC",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "u0 = s\n",
+    "for i in range(5):\n",
+    "    u0 = experimentalist(u0, n_samples=10)\n",
+    "    u0 = experiment_runner(u0)\n",
+    "    u0 = theorist(u0)\n",
+    "    show_best_fit(u0)\n",
+    "    plt.title(f\"{i=}\")\n"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 1
+}
diff --git a/mkdocs.yml b/mkdocs.yml
index b9a35944..dd9f7238 100644
--- a/mkdocs.yml
+++ b/mkdocs.yml
@@ -20,4 +20,5 @@ nav:
       - Random:
           - Home: 'experimentalists/sampler/random/index.md'
           - Quickstart: 'experimentalists/sampler/random/quickstart.md'
-
+- Cycle:
+  - Functional: 'cycle/Linear and Cyclical Workflows using Functions and States.ipynb'
diff --git a/src/autora/state/delta.py b/src/autora/state/delta.py
new file mode 100644
index 00000000..1a6fefaf
--- /dev/null
+++ b/src/autora/state/delta.py
@@ -0,0 +1,321 @@
+"""Classes to represent cycle state $S$ as $S_n = S_{0} + \\sum_{i=1}^n \\Delta S_{i}"""
+from __future__ import annotations
+
+import dataclasses
+import inspect
+from collections import UserDict
+from dataclasses import dataclass, fields, replace
+from functools import singledispatch, wraps
+from typing import Generic, List, TypeVar
+
+import numpy as np
+import pandas as pd
+
+S = TypeVar("S")
+T = TypeVar("T")
+
+
+@dataclass(frozen=True)
+class State:
+    """
+    Base object for dataclasses which use the Delta mechanism.
+
+    Examples:
+        >>> from dataclasses import dataclass, field
+
+        We define a dataclass where each field (which is going to be delta-ed) has additional
+        metadata "delta" which describes its delta behaviour.
+        >>> @dataclass(frozen=True)
+        ... class ListState(State):
+        ...    l: List = field(default_factory=list, metadata={"delta": "extend"})
+        ...    m: List = field(default_factory=list, metadata={"delta": "replace"})
+
+        Now we instantiate the dataclass...
+        >>> l = ListState(l=list("abc"), m=list("xyz"))
+        >>> l
+        ListState(l=['a', 'b', 'c'], m=['x', 'y', 'z'])
+
+        ... and can add deltas to it. `l` will be extended:
+        >>> l + Delta(l=list("def"))
+        ListState(l=['a', 'b', 'c', 'd', 'e', 'f'], m=['x', 'y', 'z'])
+
+        ... wheras `m` will be replaced:
+        >>> l + Delta(m=list("uvw"))
+        ListState(l=['a', 'b', 'c'], m=['u', 'v', 'w'])
+
+        ... they can be chained:
+        >>> l + Delta(l=list("def")) + Delta(m=list("uvw"))
+        ListState(l=['a', 'b', 'c', 'd', 'e', 'f'], m=['u', 'v', 'w'])
+
+        ... and we update multiple fields with one Delta:
+        >>> l + Delta(l=list("ghi"), m=list("rst"))
+        ListState(l=['a', 'b', 'c', 'g', 'h', 'i'], m=['r', 's', 't'])
+
+        Passing a nonexistent field will cause an error:
+        >>> l + Delta(o="not a field")
+        Traceback (most recent call last):
+        ...
+        AttributeError: key=`o` is missing on ListState(l=['a', 'b', 'c'], m=['x', 'y', 'z'])
+
+        We can also use the `.update` method to do the same thing:
+        >>> l.update(l=list("ghi"), m=list("rst"))
+        ListState(l=['a', 'b', 'c', 'g', 'h', 'i'], m=['r', 's', 't'])
+
+        We can also define fields which `append` the last result:
+        >>> @dataclass(frozen=True)
+        ... class AppendState(State):
+        ...    n: List = field(default_factory=list, metadata={"delta": "append"})
+
+        >>> m = AppendState(n=list("ɑβɣ"))
+        >>> m
+        AppendState(n=['ɑ', 'β', 'ɣ'])
+
+        `n` will be appended:
+        >>> m + Delta(n="∂")
+        AppendState(n=['ɑ', 'β', 'ɣ', '∂'])
+
+    """
+
+    def __add__(self, other: Delta):
+        updates = dict()
+        for key, other_value in other.data.items():
+            try:
+                self_field = next(filter(lambda f: f.name == key, fields(self)))
+            except StopIteration:
+                raise AttributeError("key=`%s` is missing on %s" % (key, self))
+            delta_behavior = self_field.metadata["delta"]
+            self_value = getattr(self, key)
+            if delta_behavior == "extend":
+                extended_value = extend(self_value, other_value)
+                updates[key] = extended_value
+            elif delta_behavior == "append":
+                appended_value = append(self_value, other_value)
+                updates[key] = appended_value
+            elif delta_behavior == "replace":
+                updates[key] = other_value
+            else:
+                raise NotImplementedError(
+                    "delta_behaviour=`%s` not implemented" % (delta_behavior)
+                )
+
+        new = replace(self, **updates)
+        return new
+
+    def update(self, **kwargs):
+        return self + Delta(**kwargs)
+
+
+class Delta(UserDict, Generic[S]):
+    """
+    Represents a delta where the base object determines the extension behavior.
+
+    Examples:
+        >>> from dataclasses import dataclass
+
+        First we define the dataclass to act as the basis:
+        >>> from typing import Optional, List
+        >>> @dataclass(frozen=True)
+        ... class ListState:
+        ...     l: Optional[List] = None
+        ...     m: Optional[List] = None
+        ...
+    """
+
+    pass
+
+
+Result = Delta
+"""`Result` is an alias for `Delta`."""
+
+
+@singledispatch
+def extend(a, b):
+    """
+    Function to extend supported datatypes.
+
+    """
+    raise NotImplementedError("`extend` not implemented for %s, %s" % (a, b))
+
+
+@extend.register(list)
+def extend_list(a, b):
+    """
+    Examples:
+        >>> extend([], [])
+        []
+
+        >>> extend([1,2], [3])
+        [1, 2, 3]
+    """
+    return a + b
+
+
+@extend.register(pd.DataFrame)
+def extend_pd_dataframe(a, b):
+    """
+    Examples:
+        >>> extend(pd.DataFrame({"a": []}), pd.DataFrame({"a": []}))
+        Empty DataFrame
+        Columns: [a]
+        Index: []
+
+        >>> extend(pd.DataFrame({"a": [1,2,3]}), pd.DataFrame({"a": [4,5,6]}))
+           a
+        0  1
+        1  2
+        2  3
+        3  4
+        4  5
+        5  6
+    """
+    return pd.concat((a, b), ignore_index=True)
+
+
+def append(a: List[T], b: T) -> List[T]:
+    # TODO: add DOCTESTS
+    return a + [b]
+
+
+@extend.register(np.ndarray)
+def extend_np_ndarray(a, b):
+    """
+    Examples:
+        >>> extend(np.array([(1,2,3), (4,5,6)]), np.array([(7,8,9)]))
+        array([[1, 2, 3],
+               [4, 5, 6],
+               [7, 8, 9]])
+    """
+    return np.row_stack([a, b])
+
+
+@extend.register(dict)
+def extend_dict(a, b):
+    """
+    Examples:
+        >>> extend({"a": "cats"}, {"b": "dogs"})
+        {'a': 'cats', 'b': 'dogs'}
+    """
+    return dict(a, **b)
+
+
+def wrap_to_use_state(f):
+    """Decorator to make target `f` into a function on a `State` and `**kwargs`.
+
+    This wrapper makes it easier to pass arguments to a function from a State.
+
+    It was inspired by the pytest "fixtures" mechanism.
+
+    Args:
+        f:
+
+    Returns:
+
+    Examples:
+        >>> from autora.state.delta import State, Delta
+        >>> from dataclasses import dataclass, field
+        >>> import pandas as pd
+        >>> from typing import List, Optional
+
+        The `State` it operates on needs to have the metadata described in the state module:
+        >>> @dataclass(frozen=True)
+        ... class S(State):
+        ...     conditions: List[int] = field(metadata={"delta": "replace"})
+
+        We indicate the inputs required by the parameter names.
+        The output must be a `Delta` object.
+        >>> from autora.state.delta import Delta
+        >>> @wrap_to_use_state
+        ... def experimentalist(conditions):
+        ...     new_conditions = [c + 10 for c in conditions]
+        ...     return Delta(conditions=new_conditions)
+
+        >>> experimentalist(S(conditions=[1,2,3,4]))
+        S(conditions=[11, 12, 13, 14])
+
+        >>> experimentalist(S(conditions=[101,102,103,104]))
+        S(conditions=[111, 112, 113, 114])
+
+        >>> from autora.variable import VariableCollection, Variable
+        >>> from sklearn.base import BaseEstimator
+        >>> from sklearn.linear_model import LinearRegression
+
+        >>> @wrap_to_use_state
+        ... def theorist(experiment_data: pd.DataFrame, variables: VariableCollection, **kwargs):
+        ...     ivs = [v.name for v in variables.independent_variables]
+        ...     dvs = [v.name for v in variables.dependent_variables]
+        ...     X, y = experiment_data[ivs], experiment_data[dvs]
+        ...     new_model = LinearRegression(fit_intercept=True).set_params(**kwargs).fit(X, y)
+        ...     return Delta(model=new_model)
+
+        >>> @dataclass(frozen=True)
+        ... class T(State):
+        ...     variables: VariableCollection  # field(metadata={"delta":... }) omitted ∴ immutable
+        ...     experiment_data: pd.DataFrame = field(metadata={"delta": "extend"})
+        ...     model: Optional[BaseEstimator] = field(metadata={"delta": "replace"}, default=None)
+
+        >>> t = T(
+        ...     variables=VariableCollection(independent_variables=[Variable("x")],
+        ...                                  dependent_variables=[Variable("y")]),
+        ...     experiment_data=pd.DataFrame({"x": [0,1,2,3,4], "y": [2,3,4,5,6]})
+        ... )
+        >>> t_prime = theorist(t)
+        >>> t_prime.model.coef_, t_prime.model.intercept_
+        (array([[1.]]), array([2.]))
+
+        Arguments from the state can be overridden by passing them in as keyword arguments (kwargs):
+        >>> theorist(t, experiment_data=pd.DataFrame({"x": [0,1,2,3], "y": [12,13,14,15]}))\\
+        ...     .model.intercept_
+        array([12.])
+
+        ... and other arguments supported by the inner function can also be passed
+        (if and only if the inner function allows for and handles `**kwargs` arguments alongside
+        the values from the state).
+        >>> theorist(t, fit_intercept=False).model.intercept_
+        0.0
+
+        Any parameters not provided by the state must be provided by default values or by the
+        caller. If the default is specified:
+        >>> @wrap_to_use_state
+        ... def experimentalist(conditions, offset=25):
+        ...     new_conditions = [c + offset for c in conditions]
+        ...     return Delta(conditions=new_conditions)
+
+        ... then it need not be passed.
+        >>> experimentalist(S(conditions=[1,2,3,4]))
+        S(conditions=[26, 27, 28, 29])
+
+        If a default isn't specified:
+        >>> @wrap_to_use_state
+        ... def experimentalist(conditions, offset):
+        ...     new_conditions = [c + offset for c in conditions]
+        ...     return Delta(conditions=new_conditions)
+
+        ... then calling the experimentalist without it will throw an error:
+        >>> experimentalist(S(conditions=[1,2,3,4]))
+        Traceback (most recent call last):
+        ...
+        TypeError: experimentalist() missing 1 required positional argument: 'offset'
+
+        ... which can be fixed by passing the argument as a keyword to the wrapped function.
+        >>> experimentalist(S(conditions=[1,2,3,4]), offset=2)
+        S(conditions=[3, 4, 5, 6])
+
+    """
+    # Get the set of parameter names from function f's signature
+    parameters_ = set(inspect.signature(f).parameters.keys())
+
+    @wraps(f)
+    def _f(state_: S, /, **kwargs) -> S:
+        # Get the parameters needed which are available from the state_.
+        # All others must be provided as kwargs or default values on f.
+        assert dataclasses.is_dataclass(state_)
+        from_state = parameters_.intersection(
+            {i.name for i in dataclasses.fields(state_)}
+        )
+        arguments_from_state = {k: getattr(state_, k) for k in from_state}
+        arguments = dict(arguments_from_state, **kwargs)
+        delta = f(**arguments)
+        new_state = state_ + delta
+        return new_state
+
+    return _f
diff --git a/src/autora/state/history.py b/src/autora/state/history.py
new file mode 100644
index 00000000..fbb33944
--- /dev/null
+++ b/src/autora/state/history.py
@@ -0,0 +1,722 @@
+""" Classes for storing and passing a cycle's state as an immutable history. """
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Dict, Iterable, List, Optional, Sequence, Set, Union
+
+from numpy.typing import ArrayLike
+from sklearn.base import BaseEstimator
+
+from autora.state.delta import Delta
+from autora.state.protocol import (
+    ResultKind,
+    SupportsControllerStateHistory,
+    SupportsDataKind,
+)
+from autora.state.snapshot import Snapshot
+from autora.variable import VariableCollection
+
+
+class History(SupportsControllerStateHistory):
+    """
+    An immutable object for tracking the state and history of an AER cycle.
+    """
+
+    def __init__(
+        self,
+        variables: Optional[VariableCollection] = None,
+        params: Optional[Dict] = None,
+        conditions: Optional[List[ArrayLike]] = None,
+        observations: Optional[List[ArrayLike]] = None,
+        models: Optional[List[BaseEstimator]] = None,
+        history: Optional[Sequence[Result]] = None,
+    ):
+        """
+
+        Args:
+            variables: a single datum to be marked as "variables"
+            params: a single datum to be marked as "params"
+            conditions: an iterable of data, each to be marked as "conditions"
+            observations: an iterable of data, each to be marked as "observations"
+            models: an iterable of data, each to be marked as "models"
+            history: an iterable of Result objects to be used as the initial history.
+
+        Examples:
+            Empty input leads to an empty state:
+            >>> History()
+            History([])
+
+            ... or with values for any or all of the parameters:
+            >>> from autora.variable import VariableCollection
+            >>> History(variables=VariableCollection()) # doctest: +ELLIPSIS
+            History([Result(data=VariableCollection(...), kind=ResultKind.VARIABLES)])
+
+            >>> History(params={"some": "params"})
+            History([Result(data={'some': 'params'}, kind=ResultKind.PARAMS)])
+
+            >>> History(conditions=["a condition"])
+            History([Result(data='a condition', kind=ResultKind.CONDITION)])
+
+            >>> History(observations=["an observation"])
+            History([Result(data='an observation', kind=ResultKind.OBSERVATION)])
+
+            >>> from sklearn.linear_model import LinearRegression
+            >>> History(models=[LinearRegression()])
+            History([Result(data=LinearRegression(), kind=ResultKind.MODEL)])
+
+            Parameters passed to the constructor are included in the history in the following order:
+            `history`, `variables`, `params`, `conditions`, `observations`, `models`
+            >>> History(models=['m1', 'm2'], conditions=['c1', 'c2'],
+            ...     observations=['o1', 'o2'], params={'a': 'param'},
+            ...     variables=VariableCollection(),
+            ...     history=[Result("from history", ResultKind.VARIABLES)]
+            ... )  # doctest: +ELLIPSIS +NORMALIZE_WHITESPACE
+            History([Result(data='from history', kind=ResultKind.VARIABLES),
+                                    Result(data=VariableCollection(...), kind=ResultKind.VARIABLES),
+                                    Result(data={'a': 'param'}, kind=ResultKind.PARAMS),
+                                    Result(data='c1', kind=ResultKind.CONDITION),
+                                    Result(data='c2', kind=ResultKind.CONDITION),
+                                    Result(data='o1', kind=ResultKind.OBSERVATION),
+                                    Result(data='o2', kind=ResultKind.OBSERVATION),
+                                    Result(data='m1', kind=ResultKind.MODEL),
+                                    Result(data='m2', kind=ResultKind.MODEL)])
+        """
+        self.data: List
+
+        if history is not None:
+            self.data = list(history)
+        else:
+            self.data = []
+
+        self.data += _init_result_list(
+            variables=variables,
+            params=params,
+            conditions=conditions,
+            observations=observations,
+            models=models,
+        )
+
+    def update(
+        self,
+        variables=None,
+        params=None,
+        conditions=None,
+        observations=None,
+        models=None,
+        history=None,
+    ):
+        """
+        Create a new object with updated values.
+
+        Examples:
+            The initial object is empty:
+            >>> h0 = History()
+            >>> h0
+            History([])
+
+            We can update the variables using the `.update` method:
+            >>> from autora.variable import VariableCollection
+            >>> h1 = h0.update(variables=VariableCollection())
+            >>> h1  # doctest: +ELLIPSIS +NORMALIZE_WHITESPACE
+            History([Result(data=VariableCollection(...), kind=ResultKind.VARIABLES)])
+
+            ... the original object is unchanged:
+            >>> h0
+            History([])
+
+            We can update the variables again:
+            >>> h2 = h1.update(variables=VariableCollection(["some IV"]))
+            >>> h2._by_kind  # doctest: +ELLIPSIS
+            Snapshot(variables=VariableCollection(independent_variables=['some IV'],...), ...)
+
+            ... and we see that there is only ever one variables object returned.
+
+            Params is treated the same way as variables:
+            >>> hp = h0.update(params={'first': 'params'})
+            >>> hp
+            History([Result(data={'first': 'params'}, kind=ResultKind.PARAMS)])
+
+            ... where only the most recent "params" object is returned from the `.params` property.
+            >>> hp = hp.update(params={'second': 'params'})
+            >>> hp.params
+            {'second': 'params'}
+
+            ... however, the full history of the params objects remains available, if needed:
+            >>> hp  # doctest: +NORMALIZE_WHITESPACE
+            History([Result(data={'first': 'params'}, kind=ResultKind.PARAMS),
+                                    Result(data={'second': 'params'}, kind=ResultKind.PARAMS)])
+
+            When we update the conditions, observations or models, a new entry is added to the
+            history:
+            >>> h3 = h0.update(models=["1st model"])
+            >>> h3  # doctest: +NORMALIZE_WHITESPACE
+            History([Result(data='1st model', kind=ResultKind.MODEL)])
+
+            ... so we can see the history of all the models, for instance.
+            >>> h3 = h3.update(models=["2nd model"])  # doctest: +NORMALIZE_WHITESPACE
+            >>> h3  # doctest: +NORMALIZE_WHITESPACE
+            History([Result(data='1st model', kind=ResultKind.MODEL),
+                                    Result(data='2nd model', kind=ResultKind.MODEL)])
+
+            ... and the full history of models is available using the `.models` parameter:
+            >>> h3.models
+            ['1st model', '2nd model']
+
+            The same for the observations:
+            >>> h4 = h0.update(observations=["1st observation"])
+            >>> h4
+            History([Result(data='1st observation', kind=ResultKind.OBSERVATION)])
+
+            >>> h4.update(observations=["2nd observation"]
+            ... )  # doctest: +ELLIPSIS +NORMALIZE_WHITESPACE
+            History([Result(data='1st observation', kind=ResultKind.OBSERVATION),
+                                    Result(data='2nd observation', kind=ResultKind.OBSERVATION)])
+
+
+            The same for the conditions:
+            >>> h5 = h0.update(conditions=["1st condition"])
+            >>> h5
+            History([Result(data='1st condition', kind=ResultKind.CONDITION)])
+
+            >>> h5.update(conditions=["2nd condition"])  # doctest: +NORMALIZE_WHITESPACE
+            History([Result(data='1st condition', kind=ResultKind.CONDITION),
+                                    Result(data='2nd condition', kind=ResultKind.CONDITION)])
+
+            You can also update with multiple conditions, observations and models:
+            >>> h0.update(conditions=['c1', 'c2'])  # doctest: +NORMALIZE_WHITESPACE
+            History([Result(data='c1', kind=ResultKind.CONDITION),
+                                    Result(data='c2', kind=ResultKind.CONDITION)])
+
+            >>> h0.update(models=['m1', 'm2'], variables={'m': 1}
+            ... ) # doctest: +NORMALIZE_WHITESPACE
+            History([Result(data={'m': 1}, kind=ResultKind.VARIABLES),
+                     Result(data='m1', kind=ResultKind.MODEL),
+                     Result(data='m2', kind=ResultKind.MODEL)])
+
+            >>> h0.update(models=['m1'], observations=['o1'], variables={'m': 1}
+            ... )  # doctest: +NORMALIZE_WHITESPACE
+            History([Result(data={'m': 1}, kind=ResultKind.VARIABLES),
+                     Result(data='o1', kind=ResultKind.OBSERVATION),
+                     Result(data='m1', kind=ResultKind.MODEL)])
+
+            We can also update with a complete history:
+            >>> History().update(history=[Result(data={'m': 2}, kind=ResultKind.VARIABLES),
+            ...                           Result(data='o1', kind=ResultKind.OBSERVATION),
+            ...                           Result(data='m1', kind=ResultKind.MODEL)],
+            ...                  conditions=['c1']
+            ... )  # doctest: +NORMALIZE_WHITESPACE
+            History([Result(data={'m': 2}, kind=ResultKind.VARIABLES),
+                     Result(data='o1', kind=ResultKind.OBSERVATION),
+                     Result(data='m1', kind=ResultKind.MODEL),
+                     Result(data='c1', kind=ResultKind.CONDITION)])
+
+        """
+
+        if history is not None:
+            history_extension = history
+        else:
+            history_extension = []
+
+        history_extension += _init_result_list(
+            variables=variables,
+            params=params,
+            conditions=conditions,
+            observations=observations,
+            models=models,
+        )
+        new_full_history = self.data + history_extension
+
+        return History(history=new_full_history)
+
+    def __add__(self, other: Delta):
+        """The initial object is empty:
+        >>> h0 = History()
+        >>> h0
+        History([])
+
+        We can update the variables using the `.update` method:
+        >>> from autora.variable import VariableCollection
+        >>> h1 = h0 + Delta(variables=VariableCollection())
+        >>> h1  # doctest: +ELLIPSIS +NORMALIZE_WHITESPACE
+        History([Result(data=VariableCollection(...), kind=ResultKind.VARIABLES)])
+
+        ... the original object is unchanged:
+        >>> h0
+        History([])
+
+        We can update the variables again:
+        >>> h2 = h1 + Delta(variables=VariableCollection(["some IV"]))
+        >>> h2._by_kind  # doctest: +ELLIPSIS
+        Snapshot(variables=VariableCollection(independent_variables=['some IV'],...), ...)
+
+        ... and we see that there is only ever one variables object returned.
+
+        Params is treated the same way as variables:
+        >>> hp = h0 + Delta(params={'first': 'params'})
+        >>> hp
+        History([Result(data={'first': 'params'}, kind=ResultKind.PARAMS)])
+
+        ... where only the most recent "params" object is returned from the `.params` property.
+        >>> hp = hp + Delta(params={'second': 'params'})
+        >>> hp.params
+        {'second': 'params'}
+
+        ... however, the full history of the params objects remains available, if needed:
+        >>> hp  # doctest: +NORMALIZE_WHITESPACE
+        History([Result(data={'first': 'params'}, kind=ResultKind.PARAMS),
+                                Result(data={'second': 'params'}, kind=ResultKind.PARAMS)])
+
+        When we update the conditions, observations or models, a new entry is added to the
+        history:
+        >>> h3 = h0 + Delta(models=["1st model"])
+        >>> h3  # doctest: +NORMALIZE_WHITESPACE
+        History([Result(data='1st model', kind=ResultKind.MODEL)])
+
+        ... so we can see the history of all the models, for instance.
+        >>> h3 = h3 + Delta(models=["2nd model"])  # doctest: +NORMALIZE_WHITESPACE
+        >>> h3  # doctest: +NORMALIZE_WHITESPACE
+        History([Result(data='1st model', kind=ResultKind.MODEL),
+                                Result(data='2nd model', kind=ResultKind.MODEL)])
+
+        ... and the full history of models is available using the `.models` parameter:
+        >>> h3.models
+        ['1st model', '2nd model']
+
+        The same for the observations:
+        >>> h4 = h0 + Delta(observations=["1st observation"])
+        >>> h4
+        History([Result(data='1st observation', kind=ResultKind.OBSERVATION)])
+
+        >>> h4 + Delta(observations=["2nd observation"]
+        ... )  # doctest: +ELLIPSIS +NORMALIZE_WHITESPACE
+        History([Result(data='1st observation', kind=ResultKind.OBSERVATION),
+                                Result(data='2nd observation', kind=ResultKind.OBSERVATION)])
+
+
+        The same for the conditions:
+        >>> h5 = h0 + Delta(conditions=["1st condition"])
+        >>> h5
+        History([Result(data='1st condition', kind=ResultKind.CONDITION)])
+
+        >>> h5 + Delta(conditions=["2nd condition"])  # doctest: +NORMALIZE_WHITESPACE
+        History([Result(data='1st condition', kind=ResultKind.CONDITION),
+                                Result(data='2nd condition', kind=ResultKind.CONDITION)])
+
+        You can also update with multiple conditions, observations and models:
+        >>> h0 + Delta(conditions=['c1', 'c2'])  # doctest: +NORMALIZE_WHITESPACE
+        History([Result(data='c1', kind=ResultKind.CONDITION),
+                                Result(data='c2', kind=ResultKind.CONDITION)])
+
+        >>> h0 + Delta(models=['m1', 'm2'], variables={'m': 1}
+        ... ) # doctest: +NORMALIZE_WHITESPACE
+        History([Result(data={'m': 1}, kind=ResultKind.VARIABLES),
+                 Result(data='m1', kind=ResultKind.MODEL),
+                 Result(data='m2', kind=ResultKind.MODEL)])
+
+        >>> h0 + Delta(models=['m1'], observations=['o1'], variables={'m': 1}
+        ... )  # doctest: +NORMALIZE_WHITESPACE
+        History([Result(data={'m': 1}, kind=ResultKind.VARIABLES),
+                 Result(data='o1', kind=ResultKind.OBSERVATION),
+                 Result(data='m1', kind=ResultKind.MODEL)])
+
+        We can also update with a complete history:
+        >>> History() + Delta(history=[Result(data={'m': 2}, kind=ResultKind.VARIABLES),
+        ...                           Result(data='o1', kind=ResultKind.OBSERVATION),
+        ...                           Result(data='m1', kind=ResultKind.MODEL)],
+        ...                  conditions=['c1']
+        ... )  # doctest: +NORMALIZE_WHITESPACE
+        History([Result(data={'m': 2}, kind=ResultKind.VARIABLES),
+                 Result(data='o1', kind=ResultKind.OBSERVATION),
+                 Result(data='m1', kind=ResultKind.MODEL),
+                 Result(data='c1', kind=ResultKind.CONDITION)])
+        """
+        return self.update(**other)
+
+    def __repr__(self):
+        return f"{type(self).__name__}({self.history})"
+
+    @property
+    def _by_kind(self):
+        return _history_to_kind(self.data)
+
+    @property
+    def variables(self) -> VariableCollection:
+        """
+
+        Examples:
+            The initial object is empty:
+            >>> h = History()
+
+            ... and returns an emtpy variables object
+            >>> h.variables
+            VariableCollection(independent_variables=[], dependent_variables=[], covariates=[])
+
+            We can update the variables using the `.update` method:
+            >>> from autora.variable import VariableCollection
+            >>> h = h.update(variables=VariableCollection(independent_variables=['some IV']))
+            >>> h.variables  # doctest: +ELLIPSIS
+            VariableCollection(independent_variables=['some IV'], ...)
+
+            We can update the variables again:
+            >>> h = h.update(variables=VariableCollection(["some other IV"]))
+            >>> h.variables  # doctest: +ELLIPSIS
+            VariableCollection(independent_variables=['some other IV'], ...)
+
+            ... and we see that there is only ever one variables object returned."""
+        return self._by_kind.variables
+
+    @property
+    def params(self) -> Dict:
+        """
+
+        Returns:
+
+        Examples:
+            Params is treated the same way as variables:
+            >>> h = History()
+            >>> h = h.update(params={'first': 'params'})
+            >>> h.params
+            {'first': 'params'}
+
+            ... where only the most recent "params" object is returned from the `.params` property.
+            >>> h = h.update(params={'second': 'params'})
+            >>> h.params
+            {'second': 'params'}
+
+            ... however, the full history of the params objects remains available, if needed:
+            >>> h  # doctest: +NORMALIZE_WHITESPACE
+            History([Result(data={'first': 'params'}, kind=ResultKind.PARAMS),
+                                    Result(data={'second': 'params'}, kind=ResultKind.PARAMS)])
+        """
+        return self._by_kind.params
+
+    @property
+    def conditions(self) -> List[ArrayLike]:
+        """
+        Returns:
+
+        Examples:
+            View the sequence of models with one conditions:
+            >>> h = History(conditions=[(1,2,3,)])
+            >>> h.conditions
+            [(1, 2, 3)]
+
+            ... or more conditions:
+            >>> h = h.update(conditions=[(4,5,6),(7,8,9)])  # doctest: +NORMALIZE_WHITESPACE
+            >>> h.conditions
+            [(1, 2, 3), (4, 5, 6), (7, 8, 9)]
+
+        """
+        return self._by_kind.conditions
+
+    @property
+    def observations(self) -> List[ArrayLike]:
+        """
+
+        Returns:
+
+        Examples:
+            The sequence of all observations is returned
+            >>> h = History(observations=["1st observation"])
+            >>> h.observations
+            ['1st observation']
+
+            >>> h = h.update(observations=["2nd observation"])
+            >>> h.observations  # doctest: +ELLIPSIS
+            ['1st observation', '2nd observation']
+
+        """
+        return self._by_kind.observations
+
+    @property
+    def models(self) -> List[BaseEstimator]:
+        """
+
+        Returns:
+
+        Examples:
+            View the sequence of models with one model:
+            >>> s = History(models=["1st model"])
+            >>> s.models  # doctest: +NORMALIZE_WHITESPACE
+            ['1st model']
+
+            ... or more models:
+            >>> s = s.update(models=["2nd model"])  # doctest: +NORMALIZE_WHITESPACE
+            >>> s.models
+            ['1st model', '2nd model']
+
+        """
+        return self._by_kind.models
+
+    @property
+    def history(self) -> List[Result]:
+        """
+
+        Examples:
+            We initialze some history:
+            >>> h = History(models=['m1', 'm2'], conditions=['c1', 'c2'],
+            ...     observations=['o1', 'o2'], params={'a': 'param'},
+            ...     variables=VariableCollection(),
+            ...     history=[Result("from history", ResultKind.VARIABLES)])
+
+            Parameters passed to the constructor are included in the history in the following order:
+            `history`, `variables`, `params`, `conditions`, `observations`, `models`
+
+            >>> h.history  # doctest: +ELLIPSIS +NORMALIZE_WHITESPACE
+            [Result(data='from history', kind=ResultKind.VARIABLES),
+             Result(data=VariableCollection(...), kind=ResultKind.VARIABLES),
+             Result(data={'a': 'param'}, kind=ResultKind.PARAMS),
+             Result(data='c1', kind=ResultKind.CONDITION),
+             Result(data='c2', kind=ResultKind.CONDITION),
+             Result(data='o1', kind=ResultKind.OBSERVATION),
+             Result(data='o2', kind=ResultKind.OBSERVATION),
+             Result(data='m1', kind=ResultKind.MODEL),
+             Result(data='m2', kind=ResultKind.MODEL)]
+
+            If we add a new value, like the params object, the updated value is added to the
+            end of the history:
+            >>> h = h.update(params={'new': 'param'})
+            >>> h.history  # doctest: +ELLIPSIS +NORMALIZE_WHITESPACE
+            [..., Result(data={'new': 'param'}, kind=ResultKind.PARAMS)]
+
+        """
+        return self.data
+
+    def filter_by(self, kind: Optional[Set[Union[str, ResultKind]]] = None) -> History:
+        """
+        Return a copy of the object with only data belonging to the specified kinds.
+
+        Examples:
+            >>> h = History(models=['m1', 'm2'], conditions=['c1', 'c2'],
+            ...     observations=['o1', 'o2'], params={'a': 'param'},
+            ...    variables=VariableCollection(),
+            ...     history=[Result("from history", ResultKind.VARIABLES)])
+
+            >>> h.filter_by(kind={"MODEL"})   # doctest: +NORMALIZE_WHITESPACE
+            History([Result(data='m1', kind=ResultKind.MODEL),
+                                    Result(data='m2', kind=ResultKind.MODEL)])
+
+            >>> h.filter_by(kind={ResultKind.OBSERVATION})  # doctest: +NORMALIZE_WHITESPACE
+            History([Result(data='o1', kind=ResultKind.OBSERVATION),
+                                    Result(data='o2', kind=ResultKind.OBSERVATION)])
+
+            If we don't specify any filter criteria, we get the full history back:
+            >>> h.filter_by()   # doctest: +NORMALIZE_WHITESPACE +ELLIPSIS
+            History([Result(data='from history', kind=ResultKind.VARIABLES),
+                     Result(data=VariableCollection(...), kind=ResultKind.VARIABLES),
+                     Result(data={'a': 'param'}, kind=ResultKind.PARAMS),
+                     Result(data='c1', kind=ResultKind.CONDITION),
+                     Result(data='c2', kind=ResultKind.CONDITION),
+                     Result(data='o1', kind=ResultKind.OBSERVATION),
+                     Result(data='o2', kind=ResultKind.OBSERVATION),
+                     Result(data='m1', kind=ResultKind.MODEL),
+                     Result(data='m2', kind=ResultKind.MODEL)])
+
+        """
+        if kind is None:
+            return self
+        else:
+            kind_ = {ResultKind(s) for s in kind}
+            filtered_history = _filter_history(self.data, kind_)
+            new_object = History(history=filtered_history)
+            return new_object
+
+
+@dataclass(frozen=True)
+class Result(SupportsDataKind):
+    """
+    Container class for data and variables.
+
+    Examples:
+        >>> Result()
+        Result(data=None, kind=None)
+
+        >>> Result("a")
+        Result(data='a', kind=None)
+
+        >>> Result(None, "MODEL")
+        Result(data=None, kind=ResultKind.MODEL)
+
+        >>> Result(data="b")
+        Result(data='b', kind=None)
+
+        >>> Result("c", "OBSERVATION")
+        Result(data='c', kind=ResultKind.OBSERVATION)
+    """
+
+    data: Optional[Any] = None
+    kind: Optional[ResultKind] = None
+
+    def __post_init__(self):
+        if isinstance(self.kind, str):
+            object.__setattr__(self, "kind", ResultKind(self.kind))
+
+
+def _init_result_list(
+    variables: Optional[VariableCollection] = None,
+    params: Optional[Dict] = None,
+    conditions: Optional[Iterable[ArrayLike]] = None,
+    observations: Optional[Iterable[ArrayLike]] = None,
+    models: Optional[Iterable[BaseEstimator]] = None,
+) -> List[Result]:
+    """
+    Initialize a list of Result objects
+
+    Returns:
+
+    Args:
+        variables: a single datum to be marked as "variables"
+        params: a single datum to be marked as "params"
+        conditions: an iterable of data, each to be marked as "conditions"
+        observations: an iterable of data, each to be marked as "observations"
+        models: an iterable of data, each to be marked as "models"
+
+    Examples:
+        Empty input leads to an empty state:
+        >>> _init_result_list()
+        []
+
+        ... or with values for any or all of the parameters:
+        >>> from autora.variable import VariableCollection
+        >>> _init_result_list(variables=VariableCollection()) # doctest: +ELLIPSIS
+        [Result(data=VariableCollection(...), kind=ResultKind.VARIABLES)]
+
+        >>> _init_result_list(params={"some": "params"})
+        [Result(data={'some': 'params'}, kind=ResultKind.PARAMS)]
+
+        >>> _init_result_list(conditions=["a condition"])
+        [Result(data='a condition', kind=ResultKind.CONDITION)]
+
+        >>> _init_result_list(observations=["an observation"])
+        [Result(data='an observation', kind=ResultKind.OBSERVATION)]
+
+        >>> from sklearn.linear_model import LinearRegression
+        >>> _init_result_list(models=[LinearRegression()])
+        [Result(data=LinearRegression(), kind=ResultKind.MODEL)]
+
+        The input arguments are added to the data in the order `variables`,
+        `params`, `conditions`, `observations`, `models`:
+        >>> _init_result_list(variables=VariableCollection(),
+        ...                  params={"some": "params"},
+        ...                  conditions=["a condition"],
+        ...                  observations=["an observation", "another observation"],
+        ...                  models=[LinearRegression()],
+        ... ) # doctest: +NORMALIZE_WHITESPACE +ELLIPSIS
+        [Result(data=VariableCollection(...), kind=ResultKind.VARIABLES),
+         Result(data={'some': 'params'}, kind=ResultKind.PARAMS),
+         Result(data='a condition', kind=ResultKind.CONDITION),
+         Result(data='an observation', kind=ResultKind.OBSERVATION),
+         Result(data='another observation', kind=ResultKind.OBSERVATION),
+         Result(data=LinearRegression(), kind=ResultKind.MODEL)]
+
+    """
+    data = []
+
+    if variables is not None:
+        data.append(Result(variables, ResultKind.VARIABLES))
+
+    if params is not None:
+        data.append(Result(params, ResultKind.PARAMS))
+
+    for seq, kind in [
+        (conditions, ResultKind.CONDITION),
+        (observations, ResultKind.OBSERVATION),
+        (models, ResultKind.MODEL),
+    ]:
+        if seq is not None:
+            for i in seq:
+                data.append(Result(i, kind=kind))
+
+    return data
+
+
+def _history_to_kind(history: Sequence[Result]) -> Snapshot:
+    """
+    Convert a sequence of results into a Snapshot instance:
+
+    Examples:
+        History might be empty
+        >>> history_ = []
+        >>> _history_to_kind(history_) # doctest: +NORMALIZE_WHITESPACE +ELLIPSIS
+        Snapshot(variables=VariableCollection(...), params={},
+                        conditions=[], observations=[], models=[])
+
+        ... or with values for any or all of the parameters:
+        >>> history_ = _init_result_list(params={"some": "params"})
+        >>> _history_to_kind(history_) # doctest: +NORMALIZE_WHITESPACE +ELLIPSIS
+        Snapshot(..., params={'some': 'params'}, ...)
+
+        >>> history_ += _init_result_list(conditions=["a condition"])
+        >>> _history_to_kind(history_) # doctest: +NORMALIZE_WHITESPACE +ELLIPSIS
+        Snapshot(..., params={'some': 'params'}, conditions=['a condition'], ...)
+
+        >>> _history_to_kind(history_).params
+        {'some': 'params'}
+
+        >>> history_ += _init_result_list(observations=["an observation"])
+        >>> _history_to_kind(history_) # doctest: +NORMALIZE_WHITESPACE +ELLIPSIS
+        Snapshot(..., params={'some': 'params'}, conditions=['a condition'],
+                        observations=['an observation'], ...)
+
+        >>> from sklearn.linear_model import LinearRegression
+        >>> history_ = [Result(LinearRegression(), kind=ResultKind.MODEL)]
+        >>> _history_to_kind(history_) # doctest: +ELLIPSIS
+        Snapshot(..., models=[LinearRegression()])
+
+        >>> from autora.variable import VariableCollection, IV
+        >>> variables = VariableCollection(independent_variables=[IV(name="example")])
+        >>> history_ = [Result(variables, kind=ResultKind.VARIABLES)]
+        >>> _history_to_kind(history_) # doctest: +ELLIPSIS
+        Snapshot(variables=VariableCollection(independent_variables=[IV(name='example', ...
+
+        >>> history_ = [Result({'some': 'params'}, kind=ResultKind.PARAMS)]
+        >>> _history_to_kind(history_) # doctest: +ELLIPSIS
+        Snapshot(..., params={'some': 'params'}, ...)
+
+    """
+    namespace = Snapshot(
+        variables=_get_last_data_with_default(
+            history, kind={ResultKind.VARIABLES}, default=VariableCollection()
+        ),
+        params=_get_last_data_with_default(
+            history, kind={ResultKind.PARAMS}, default={}
+        ),
+        observations=_list_data(
+            _filter_history(history, kind={ResultKind.OBSERVATION})
+        ),
+        models=_list_data(_filter_history(history, kind={ResultKind.MODEL})),
+        conditions=_list_data(_filter_history(history, kind={ResultKind.CONDITION})),
+    )
+    return namespace
+
+
+def _list_data(data: Sequence[SupportsDataKind]):
+    """
+    Extract the `.data` attribute of each item in a sequence, and return as a list.
+
+    Examples:
+        >>> _list_data([])
+        []
+
+        >>> _list_data([Result("a"), Result("b")])
+        ['a', 'b']
+    """
+    return list(r.data for r in data)
+
+
+def _filter_history(data: Iterable[SupportsDataKind], kind: Set[ResultKind]):
+    return filter(lambda r: r.kind in kind, data)
+
+
+def _get_last(data: Sequence[SupportsDataKind], kind: Set[ResultKind]):
+    results_new_to_old = reversed(data)
+    last_of_kind = next(_filter_history(results_new_to_old, kind=kind))
+    return last_of_kind
+
+
+def _get_last_data_with_default(data: Sequence[SupportsDataKind], kind, default):
+    try:
+        result = _get_last(data, kind).data
+    except StopIteration:
+        result = default
+    return result
diff --git a/src/autora/state/param.py b/src/autora/state/param.py
new file mode 100644
index 00000000..1fca3cfc
--- /dev/null
+++ b/src/autora/state/param.py
@@ -0,0 +1,143 @@
+""" Functions for handling cycle-state-dependent parameters. """
+from __future__ import annotations
+
+import copy
+import logging
+from typing import Dict, Mapping
+
+import numpy as np
+
+from autora.state.protocol import SupportsControllerState
+from autora.utils.deprecation import deprecate as deprecate
+from autora.utils.dictionary import LazyDict
+
+_logger = logging.getLogger(__name__)
+
+
+def _get_state_dependent_properties(state: SupportsControllerState):
+    """
+    Examples:
+        Even with an empty data object, we can initialize the dictionary,
+        >>> from autora.state.snapshot import Snapshot
+        >>> state_dependent_properties = _get_state_dependent_properties(Snapshot())
+
+        ... but it will raise an exception if a value isn't yet available when we try to use it
+        >>> state_dependent_properties["%models[-1]%"] # doctest: +ELLIPSIS
+        Traceback (most recent call last):
+        ...
+        IndexError: list index out of range
+
+        Nevertheless, we can iterate through its keys no problem:
+        >>> [key for key in state_dependent_properties.keys()] # doctest: +NORMALIZE_WHITESPACE
+        ['%observations.ivs[-1]%', '%observations.dvs[-1]%', '%observations.ivs%',
+         '%observations.dvs%', '%experiment_data.conditions[-1]%',
+         '%experiment_data.observations[-1]%', '%experiment_data.conditions%',
+         '%experiment_data.observations%', '%models[-1]%', '%models%']
+
+    """
+
+    n_ivs = len(state.variables.independent_variables)
+    n_dvs = len(state.variables.dependent_variables)
+    state_dependent_property_dict = LazyDict(
+        {
+            "%observations.ivs[-1]%": deprecate(
+                lambda: np.array(state.observations[-1])[:, 0:n_ivs],
+                "%observations.ivs[-1]% is deprecated, "
+                "use %experiment_data.conditions[-1]% instead.",
+            ),
+            "%observations.dvs[-1]%": deprecate(
+                lambda: np.array(state.observations[-1])[:, n_ivs:],
+                "%observations.dvs[-1]% is deprecated, "
+                "use %experiment_data.observations[-1]% instead.",
+            ),
+            "%observations.ivs%": deprecate(
+                lambda: np.row_stack(
+                    [np.empty([0, n_ivs + n_dvs])] + list(state.observations)
+                )[:, 0:n_ivs],
+                "%observations.ivs% is deprecated, use %experiment_data.conditions% instead.",
+            ),
+            "%observations.dvs%": deprecate(
+                lambda: np.row_stack(state.observations)[:, n_ivs:],
+                "%observations.dvs% is deprecated, "
+                "use %experiment_data.observations% instead",
+            ),
+            "%experiment_data.conditions[-1]%": lambda: np.array(
+                state.observations[-1]
+            )[:, 0:n_ivs],
+            "%experiment_data.observations[-1]%": lambda: np.array(
+                state.observations[-1]
+            )[:, n_ivs:],
+            "%experiment_data.conditions%": lambda: np.row_stack(
+                [np.empty([0, n_ivs + n_dvs])] + list(state.observations)
+            )[:, 0:n_ivs],
+            "%experiment_data.observations%": lambda: np.row_stack(state.observations)[
+                :, n_ivs:
+            ],
+            "%models[-1]%": lambda: state.models[-1],
+            "%models%": lambda: state.models,
+        }
+    )
+    return state_dependent_property_dict
+
+
+def _resolve_properties(params: Dict, state_dependent_properties: Mapping):
+    """
+    Resolve state-dependent properties inside a nested dictionary.
+
+    In this context, a state-dependent-property is a string which is meant to be replaced by its
+    updated, current value before the dictionary is used. A state-dependent property might be
+    something like "the last theorist available" or "all the experimental results until now".
+
+    Args:
+        params: a (nested) dictionary of keys and values, where some values might be
+            "cycle property names"
+        state_dependent_properties: a dictionary of "property names" and their "real values"
+
+    Returns: a (nested) dictionary where "property names" are replaced by the "real values"
+
+    Examples:
+
+        >>> params_0 = {"key": "%foo%"}
+        >>> cycle_properties_0 = {"%foo%": 180}
+        >>> _resolve_properties(params_0,cycle_properties_0)
+        {'key': 180}
+
+        >>> params_1 = {"key": "%bar%", "nested_dict": {"inner_key": "%foobar%"}}
+        >>> cycle_properties_1 = {"%bar%": 1, "%foobar%": 2}
+        >>> _resolve_properties(params_1,cycle_properties_1)
+        {'key': 1, 'nested_dict': {'inner_key': 2}}
+
+        >>> params_2 = {"key": "baz"}
+        >>> _resolve_properties(params_2,cycle_properties_1)
+        {'key': 'baz'}
+
+    """
+    params_ = copy.copy(params)
+    for key, value in params_.items():
+        if isinstance(value, dict):
+            params_[key] = _resolve_properties(value, state_dependent_properties)
+        elif isinstance(value, str) and (
+            value in state_dependent_properties
+        ):  # value is a key in the cycle_properties dictionary
+            params_[key] = state_dependent_properties[value]
+        else:
+            _logger.debug(f"leaving {params=} unchanged")
+
+    return params_
+
+
+def resolve_state_params(params: Dict, state: SupportsControllerState) -> Dict:
+    """
+    Returns the `params` attribute of the input, with `cycle properties` resolved.
+
+    Examples:
+        >>> from autora.state.history import History
+        >>> params = {"experimentalist": {"source": "%models[-1]%"}}
+        >>> s = History(models=["the first model", "the second model"])
+        >>> resolve_state_params(params, s)
+        {'experimentalist': {'source': 'the second model'}}
+
+    """
+    state_dependent_properties = _get_state_dependent_properties(state)
+    resolved_params = _resolve_properties(params, state_dependent_properties)
+    return resolved_params
diff --git a/src/autora/state/protocol.py b/src/autora/state/protocol.py
new file mode 100644
index 00000000..e1a16be7
--- /dev/null
+++ b/src/autora/state/protocol.py
@@ -0,0 +1,158 @@
+from enum import Enum
+from typing import (
+    Any,
+    Dict,
+    Generic,
+    Mapping,
+    Optional,
+    Protocol,
+    Sequence,
+    Set,
+    TypeVar,
+    Union,
+    runtime_checkable,
+)
+
+from numpy.typing import ArrayLike
+from sklearn.base import BaseEstimator
+
+from autora.variable import VariableCollection
+
+State = TypeVar("State")
+
+
+class ResultKind(str, Enum):
+    """
+    Kinds of results which can be held in the Result object.
+
+    Examples:
+        >>> ResultKind.CONDITION is ResultKind.CONDITION
+        True
+
+        >>> ResultKind.CONDITION is ResultKind.VARIABLES
+        False
+
+        >>> ResultKind.CONDITION == "CONDITION"
+        True
+
+        >>> ResultKind.CONDITION == "VARIABLES"
+        False
+
+        >>> ResultKind.CONDITION in {ResultKind.CONDITION, ResultKind.PARAMS}
+        True
+
+        >>> ResultKind.VARIABLES in {ResultKind.CONDITION, ResultKind.PARAMS}
+        False
+    """
+
+    CONDITION = "CONDITION"
+    OBSERVATION = "OBSERVATION"
+    MODEL = "MODEL"
+    PARAMS = "PARAMS"
+    VARIABLES = "VARIABLES"
+
+    def __repr__(self):
+        cls_name = self.__class__.__name__
+        return f"{cls_name}.{self.name}"
+
+
+class SupportsDataKind(Protocol):
+    """Object with attributes for `data` and `kind`"""
+
+    data: Optional[Any]
+    kind: Optional[ResultKind]
+
+
+class SupportsStateParamsField(Protocol):
+    """Support a state with a params property."""
+
+    params: Dict
+
+
+class SupportsStateParamsProperty(Protocol):
+    """Support a state with a params property."""
+
+    @property
+    def params(self) -> Dict:
+        ...
+
+
+SupportsStateParams = Union[SupportsStateParamsField, SupportsStateParamsProperty]
+
+
+class SupportsControllerStateFields(Protocol):
+    """Support representing snapshots of a controller state as mutable fields."""
+
+    variables: VariableCollection
+    params: Dict
+    conditions: Sequence[ArrayLike]
+    observations: Sequence[ArrayLike]
+    models: Sequence[BaseEstimator]
+
+    def update(self: State, **kwargs) -> State:
+        ...
+
+
+class SupportsControllerStateProperties(Protocol):
+    """Support representing snapshots of a controller state as immutable properties."""
+
+    def update(self: State, **kwargs) -> State:
+        ...
+
+    @property
+    def variables(self) -> VariableCollection:
+        ...
+
+    @property
+    def params(self) -> Dict:
+        ...
+
+    @property
+    def conditions(self) -> Sequence[ArrayLike]:
+        ...
+
+    @property
+    def observations(self) -> Sequence[ArrayLike]:
+        ...
+
+    @property
+    def models(self) -> Sequence[BaseEstimator]:
+        ...
+
+
+SupportsControllerState = Union[
+    SupportsControllerStateFields, SupportsControllerStateProperties
+]
+
+
+class SupportsControllerStateHistory(SupportsControllerStateProperties, Protocol):
+    """Represents controller state as a linear sequence of entries."""
+
+    def __init__(self, history: Sequence[SupportsDataKind]):
+        ...
+
+    def filter_by(self: State, kind: Optional[Set[Union[str, ResultKind]]]) -> State:
+        ...
+
+    @property
+    def history(self) -> Sequence[SupportsDataKind]:
+        ...
+
+
+class Executor(Protocol, Generic[State]):
+    """A Callable which, given some state, and some parameters, returns an updated state."""
+
+    def __call__(self, __state: State, params: Dict) -> State:
+        ...
+
+
+ExecutorCollection = Mapping[str, Executor]
+
+
+@runtime_checkable
+class SupportsLoadDump(Protocol):
+    def dump(self, data, file) -> None:
+        ...
+
+    def load(self, file) -> Any:
+        ...
diff --git a/src/autora/state/snapshot.py b/src/autora/state/snapshot.py
new file mode 100644
index 00000000..21be8171
--- /dev/null
+++ b/src/autora/state/snapshot.py
@@ -0,0 +1,201 @@
+""" Classes for storing and passing a cycle's state as an immutable snapshot. """
+from dataclasses import dataclass, field
+from typing import Dict, List
+
+from numpy.typing import ArrayLike
+from sklearn.base import BaseEstimator
+
+from autora.state.delta import Delta
+from autora.state.protocol import SupportsControllerStateFields
+from autora.variable import VariableCollection
+
+
+@dataclass(frozen=True)
+class Snapshot(SupportsControllerStateFields):
+    """An object passed between and updated by processing steps in the Controller."""
+
+    # Single values
+    variables: VariableCollection = field(default_factory=VariableCollection)
+    params: Dict = field(default_factory=dict)
+
+    # Sequences
+    conditions: List[ArrayLike] = field(default_factory=list)
+    observations: List[ArrayLike] = field(default_factory=list)
+    models: List[BaseEstimator] = field(default_factory=list)
+
+    def update(
+        self,
+        variables=None,
+        params=None,
+        conditions=None,
+        observations=None,
+        models=None,
+    ):
+        """
+        Create a new object with updated values.
+
+        Examples:
+            The initial object is empty:
+            >>> s0 = Snapshot()
+            >>> s0  # doctest: +ELLIPSIS +NORMALIZE_WHITESPACE
+            Snapshot(variables=VariableCollection(...), params={}, conditions=[],
+                            observations=[], models=[])
+
+            We can update the params using the `.update` method:
+            >>> s0.update(params={'first': 'params'})  # doctest: +ELLIPSIS +NORMALIZE_WHITESPACE
+            Snapshot(..., params={'first': 'params'}, ...)
+
+            ... but the original object is unchanged:
+            >>> s0  # doctest: +ELLIPSIS +NORMALIZE_WHITESPACE
+            Snapshot(..., params={}, ...)
+
+            For params, only one object is returned from the respective property:
+            >>> s0.update(params={'first': 'params'}).update(params={'second': 'params'}).params
+            {'second': 'params'}
+
+            ... and the same applies to variables:
+            >>> from autora.variable import VariableCollection, IV
+            >>> (s0.update(variables=VariableCollection([IV("1st IV")]))
+            ...    .update(variables=VariableCollection([IV("2nd IV")]))).variables
+            VariableCollection(independent_variables=[IV(name='2nd IV',...)], ...)
+
+            When we update the conditions, observations or models, the respective list is extended:
+            >>> s3 = s0.update(models=["1st model"])
+            >>> s3
+            Snapshot(..., models=['1st model'])
+
+            ... so we can see the history of all the models, for instance.
+            >>> s3.update(models=["2nd model"])
+            Snapshot(..., models=['1st model', '2nd model'])
+
+            The same applies to observations:
+            >>> s4 = s0.update(observations=["1st observation"])
+            >>> s4
+            Snapshot(..., observations=['1st observation'], ...)
+
+            >>> s4.update(observations=["2nd observation"])  # doctest: +ELLIPSIS
+            Snapshot(..., observations=['1st observation', '2nd observation'], ...)
+
+
+            The same applies to conditions:
+            >>> s5 = s0.update(conditions=["1st condition"])
+            >>> s5
+            Snapshot(..., conditions=['1st condition'], ...)
+
+            >>> s5.update(conditions=["2nd condition"])  # doctest: +ELLIPSIS +NORMALIZE_WHITESPACE
+            Snapshot(..., conditions=['1st condition', '2nd condition'], ...)
+
+            You can also update with multiple conditions, observations and models:
+            >>> s0.update(conditions=['c1', 'c2'])
+            Snapshot(..., conditions=['c1', 'c2'], ...)
+
+            >>> s0.update(models=['m1', 'm2'], variables={'m': 1})
+            Snapshot(variables={'m': 1}, ..., models=['m1', 'm2'])
+
+            >>> s0.update(models=['m1'], observations=['o1'], variables={'m': 1})
+            Snapshot(variables={'m': 1}, ..., observations=['o1'], models=['m1'])
+
+
+            Inputs to models, observations and conditions must be Lists
+            which can be cast to lists:
+            >>> s0.update(models='m1')  # doctest: +ELLIPSIS
+            Traceback (most recent call last):
+            ...
+            AssertionError: 'm1' must be a list, e.g. `['m1']`?)
+
+        """
+
+        def _coalesce_lists(old, new):
+            assert isinstance(
+                old, List
+            ), f"{repr(old)} must be a list, e.g. `[{repr(old)}]`?)"
+            if new is not None:
+                assert isinstance(
+                    new, List
+                ), f"{repr(new)} must be a list, e.g. `[{repr(new)}]`?)"
+                return old + list(new)
+            else:
+                return old
+
+        variables_ = variables or self.variables
+        params_ = params or self.params
+        conditions_ = _coalesce_lists(self.conditions, conditions)
+        observations_ = _coalesce_lists(self.observations, observations)
+        models_ = _coalesce_lists(self.models, models)
+        return Snapshot(variables_, params_, conditions_, observations_, models_)
+
+    def __add__(self, other: Delta):
+        """
+        Add a delta to the object.
+
+        Examples:
+            The initial object is empty:
+            >>> s0 = Snapshot()
+            >>> s0  # doctest: +ELLIPSIS +NORMALIZE_WHITESPACE
+            Snapshot(variables=VariableCollection(...), params={}, conditions=[],
+                            observations=[], models=[])
+
+            We can update the params using the `+` operator:
+            >>> from autora.state.delta import Delta
+            >>> s0 + Delta(params={'first': 'params'})  # doctest: +ELLIPSIS +NORMALIZE_WHITESPACE
+            Snapshot(..., params={'first': 'params'}, ...)
+
+            ... but the original object is unchanged:
+            >>> s0  # doctest: +ELLIPSIS +NORMALIZE_WHITESPACE
+            Snapshot(..., params={}, ...)
+
+            For params, only one object is returned from the respective property:
+            >>> (s0 + Delta(params={'first': 'params'}) + Delta(params={'second':'params'})).params
+            {'second': 'params'}
+
+            ... and the same applies to variables:
+            >>> from autora.variable import VariableCollection, IV
+            >>> (s0 + Delta(variables=VariableCollection([IV("1st IV")])) +
+            ...    Delta(variables=VariableCollection([IV("2nd IV")]))).variables
+            VariableCollection(independent_variables=[IV(name='2nd IV',...)], ...)
+
+            When we update the conditions, observations or models, the respective list is extended:
+            >>> s3 = s0 + Delta(models=["1st model"])
+            >>> s3
+            Snapshot(..., models=['1st model'])
+
+            ... so we can see the history of all the models, for instance.
+            >>> s3 + Delta(models=["2nd model"])
+            Snapshot(..., models=['1st model', '2nd model'])
+
+            The same applies to observations:
+            >>> s4 = s0 + Delta(observations=["1st observation"])
+            >>> s4
+            Snapshot(..., observations=['1st observation'], ...)
+
+            >>> s4 + Delta(observations=["2nd observation"])  # doctest: +ELLIPSIS
+            Snapshot(..., observations=['1st observation', '2nd observation'], ...)
+
+
+            The same applies to conditions:
+            >>> s5 = s0 + Delta(conditions=["1st condition"])
+            >>> s5
+            Snapshot(..., conditions=['1st condition'], ...)
+
+            >>> s5 + Delta(conditions=["2nd condition"])  # doctest: +ELLIPSIS +NORMALIZE_WHITESPACE
+            Snapshot(..., conditions=['1st condition', '2nd condition'], ...)
+
+            You can also update with multiple conditions, observations and models:
+            >>> s0 + Delta(conditions=['c1', 'c2'])
+            Snapshot(..., conditions=['c1', 'c2'], ...)
+
+            >>> s0 + Delta(models=['m1', 'm2'], variables={'m': 1})
+            Snapshot(variables={'m': 1}, ..., models=['m1', 'm2'])
+
+            >>> s0 + Delta(models=['m1'], observations=['o1'], variables={'m': 1})
+            Snapshot(variables={'m': 1}, ..., observations=['o1'], models=['m1'])
+
+
+            Inputs to models, observations and conditions must be Lists
+            which can be cast to lists:
+            >>> s0 + Delta(models='m1')  # doctest: +ELLIPSIS
+            Traceback (most recent call last):
+            ...
+            AssertionError: 'm1' must be a list, e.g. `['m1']`?)
+        """
+        return self.update(**other)
diff --git a/src/autora/state/wrapper.py b/src/autora/state/wrapper.py
new file mode 100644
index 00000000..13bf5528
--- /dev/null
+++ b/src/autora/state/wrapper.py
@@ -0,0 +1,87 @@
+"""Utilities to wrap common theorist, experimentalist and experiment runners as `f(State)`.
+so that $n$ processes $f_i$ on states $S$ can be represented as
+$$f_n(...(f_1(f_0(S))))$$
+"""
+from __future__ import annotations
+
+from typing import Callable, Iterable, TypeVar
+
+import numpy as np
+import pandas as pd
+from sklearn.base import BaseEstimator
+
+from autora.experimentalist.pipeline import Pipeline
+from autora.state.delta import Delta, State, wrap_to_use_state
+from autora.variable import VariableCollection
+
+S = TypeVar("S")
+X = TypeVar("X")
+Y = TypeVar("Y")
+XY = TypeVar("XY")
+Executor = Callable[[State], State]
+
+
+def theorist_from_estimator(estimator: BaseEstimator) -> Executor:
+    """
+    Convert a scikit-learn compatible estimator into a function on a `State` object.
+
+    Supports passing additional `**kwargs` which are used to update the estimator's params
+    before fitting.
+    """
+
+    @wrap_to_use_state
+    def theorist(
+        experiment_data: pd.DataFrame, variables: VariableCollection, **kwargs
+    ):
+        ivs = [v.name for v in variables.independent_variables]
+        dvs = [v.name for v in variables.dependent_variables]
+        X, y = experiment_data[ivs], experiment_data[dvs]
+        new_model = estimator.set_params(**kwargs).fit(X, y)
+        return Delta(model=new_model)
+
+    return theorist
+
+
+def experiment_runner_from_x_to_y_function(f: Callable[[X], Y]) -> Executor:
+    """Wrapper for experiment_runner of the form $f(x) \rarrow y$, where `f` returns just the $y$
+    values"""
+
+    @wrap_to_use_state
+    def experiment_runner(conditions: pd.DataFrame, **kwargs):
+        x = conditions
+        y = f(x, **kwargs)
+        experiment_data = pd.DataFrame.merge(x, y, left_index=True, right_index=True)
+        return Delta(experiment_data=experiment_data)
+
+    return experiment_runner
+
+
+def experiment_runner_from_x_to_xy_function(f: Callable[[X], XY]) -> Executor:
+    """Wrapper for experiment_runner of the form $f(x) \rarrow (x,y)$, where `f`
+    returns both $x$ and $y$ values in a complete dataframe."""
+
+    @wrap_to_use_state
+    def experiment_runner(conditions: pd.DataFrame, **kwargs):
+        x = conditions
+        experiment_data = f(x, **kwargs)
+        return Delta(experiment_data=experiment_data)
+
+    return experiment_runner
+
+
+def experimentalist_from_pipeline(pipeline: Pipeline) -> Executor:
+    """Wrapper for experimentalists of the form $f() \rarrow x$, where `f`
+    returns both $x$ and $y$ values in a complete dataframe."""
+
+    @wrap_to_use_state
+    def experimentalist(params):
+        conditions = pipeline(**params)
+        if isinstance(conditions, (pd.DataFrame, np.ndarray, np.recarray)):
+            conditions_ = conditions
+        elif isinstance(conditions, Iterable):
+            conditions_ = np.array(list(conditions))
+        else:
+            raise NotImplementedError("type `%s` is not supported" % (type(conditions)))
+        return Delta(conditions=conditions_)
+
+    return experimentalist