diff --git a/CHANGES.rst b/CHANGES.rst
index ad985a090..378c473b7 100644
--- a/CHANGES.rst
+++ b/CHANGES.rst
@@ -65,6 +65,10 @@ releases are available on `Anaconda.org
   the data preparation.
 - :gh:`300` aligns respy functions with the new data in :gh:`299`
   (:ghuser:`tobiasraabe`).
+- :gh:`310` introduces the separation between a core state space and dense dimensions of
+  the state space which reduces memory consumption by a lot and makes respy scalable.
+  :gh:`312` and :gh:`313` include changes to the simulation or maximum likelihood
+  estimation which pave the way for :gh:`310`. (:ghuser:`tobiasraabe`)
 - :gh:`314` fixes two parameters in KW97 and KW2000 (:ghuser:`tostenzel`,
   :ghuser:`tobiasraabe`).
 - :gh:`316` changes the invalid index value for the indexer to prevent silent errors
@@ -76,6 +80,10 @@ releases are available on `Anaconda.org
 - :gh:`323` adds an informative message if simulated individuals cannot be mapped to
   states in the state space (:ghuser:`mo2561057`, :ghuser:`tobiasraabe`).
 
+
+*Releases prior to the second version were published on PyPI, but deleted later. You can
+still checkout the following releases with the corresponding tags.*
+
 1.2.1 - 2019-05-19
 ------------------
 
diff --git a/LICENSE b/LICENSE
index 787231be1..e0454915e 100644
--- a/LICENSE
+++ b/LICENSE
@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2015-2019
+Copyright (c) 2015-2020
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/README.rst b/README.rst
index b94af6156..e0e67df42 100644
--- a/README.rst
+++ b/README.rst
@@ -21,7 +21,7 @@ respy
 
 .. image:: https://img.shields.io/badge/code%20style-black-000000.svg
     :target: https://github.com/psf/black
-    
+
 
 ``respy``  is an open-source Python package for the simulation and estimation of a
 prototypical finite-horizon discrete choice dynamic programming model. We build on the
diff --git a/development/testing/regression.py b/development/testing/regression.py
index 1712d94a4..8ffbc89fc 100644
--- a/development/testing/regression.py
+++ b/development/testing/regression.py
@@ -112,11 +112,13 @@ def _check_single(test, strict):
     """Check a single test."""
     params, options, exp_val = test
 
-    crit_val = calc_crit_val(params, options)
-
-    is_success = np.isclose(
-        crit_val, exp_val, rtol=TOL_REGRESSION_TESTS, atol=TOL_REGRESSION_TESTS
-    )
+    try:
+        crit_val = calc_crit_val(params, options)
+        is_success = np.isclose(
+            crit_val, exp_val, rtol=TOL_REGRESSION_TESTS, atol=TOL_REGRESSION_TESTS
+        )
+    except Exception:
+        is_success = False
 
     if strict is True:
         assert is_success, "Failed regression test."
diff --git a/docs/api.rst b/docs/api.rst
index a7c665a91..9852e2672 100644
--- a/docs/api.rst
+++ b/docs/api.rst
@@ -1,7 +1,6 @@
 API
 ===
 
-
 User
 ----
 
@@ -24,6 +23,7 @@ solve
 .. autosummary::
     :toctree: _generated/
 
+    get_solve_func
     solve
 
 simulate
@@ -58,31 +58,3 @@ likelihood
 
     get_crit_func
     log_like
-
-
-Developer
----------
-
-config
-~~~~~~
-
-.. currentmodule:: respy.config
-
-.. autosummary::
-    :toctree: _generated/
-
-    INDEXER_DTYPE
-    INDEXER_INVALID_INDEX
-
-state space
-~~~~~~~~~~~
-
-.. currentmodule:: respy.state_space
-
-.. autosummary::
-    :toctree: _generated/
-
-    StateSpace
-    StateSpace.get_attribute_from_period
-    StateSpace.get_continuation_values
-    StateSpace.update_systematic_rewards
diff --git a/docs/conf.py b/docs/conf.py
index 2c29c0137..3f1166f80 100644
--- a/docs/conf.py
+++ b/docs/conf.py
@@ -18,8 +18,8 @@ def setup(app):
 # -- Project information -----------------------------------------------------
 
 project = "respy"
-copyright = "2015-2019, Philipp Eisenhauer"  # noqa: A001
-author = "Philipp Eisenhauer"
+copyright = "2015-2020, The respy Development Team"  # noqa: A001
+author = "The respy Development Team"
 
 # The full version, including alpha/beta/rc tags.
 release = "2.0.0dev2"
@@ -49,6 +49,7 @@ def setup(app):
 autodoc_mock_imports = [
     "chaospy",
     "estimagic",
+    "joblib",
     "numba",
     "numpy",
     "pandas",
@@ -106,7 +107,7 @@ def setup(app):
 
     .. nbinfo::
 
-        Download the notebook :download:`here <https://github.com/OpenSourceEconomics/respy/blob/{{ env.config.release }}/{{ docname }}>`!
+        View and download the notebook `here <https://nbviewer.jupyter.org/github/OpenSourceEconomics/respy/tree/v{{ env.config.release }}/{{ docname }}>`_!
 
 """
 
@@ -117,7 +118,6 @@ def setup(app):
 # Configuration for autodoc
 autosummary_generate = True
 
-
 # -- Options for HTML output ----------------------------------------------
 
 # The theme to use for HTML and HTML Help pages.  See the documentation for
diff --git a/docs/development/randomness-and-reproducibility.rst b/docs/development/randomness-and-reproducibility.rst
index e36ce5846..ae646116d 100644
--- a/docs/development/randomness-and-reproducibility.rst
+++ b/docs/development/randomness-and-reproducibility.rst
@@ -59,16 +59,16 @@ parameters.
 respy.solve
 -----------
 
-.. currentmodule:: respy.solve
-
 Routines under ``respy.solve`` use a seed from the sequence initialized by
 ``options["solution_seed"]`` to control randomness. Apart from the draws,
 :func:`~respy.solve.solve` relies on the following function.
 
+.. currentmodule:: respy.interpolate
+
 .. autosummary::
     :toctree: ../_generated/
 
-    get_not_interpolated_indicator
+    _get_not_interpolated_indicator
 
 
 respy.simulate
diff --git a/docs/development/releases.rst b/docs/development/releases.rst
index 82f337c7f..dc75d7f38 100644
--- a/docs/development/releases.rst
+++ b/docs/development/releases.rst
@@ -24,28 +24,21 @@ How to release a new version?
 2. Second, we need to create a final PR to prepare everything for the new version. The
    name of the PR and the commit message will be "Release vx.y.z". We need to
 
-   - update all references of the old version number (``setup.py``,
-     ``respy/__init__.py``, ``docs/conf.py``).
+   - use ``bumpversion part <dev|patch|minor|major>`` to increment the correct part of
+     the version number in all files.
    - update information in ``CHANGES.rst`` to have summary of the changes which
      can also be posted in the Github repository under the tag.
 
-   Merge the PR into master.
+3. Run ``python release.py`` and check whether you can actually release a new version.
+   If you experience errors, fix them here.
 
-3. After that, revisit the draft of the release. Make sure everything is fine. Now, you
-   click on "Publish release" which creates a version tag on the latest commit of the
-   specified branch. The tag will trigger a build on Travis-CI which will publish the
-   release on PypI.
-
-4. Make sure that the new release was indeed published by checking `PyPI
-   <https://pypi.org/project/respy/>`_.
-
-5. Spread the word!
+4. Merge the PR into master.
 
+5. After that, revisit the draft of the release. Make sure everything is fine. Now, you
+   click on "Publish release" which creates a version tag on the latest commit of the
+   specified branch. Make sure to target the master branch.
 
-Notes
------
+6. Visit `Anaconda.org <https://anaconda.org/OpenSourceEconomics/respy>`_ and check
+   whether the release is available.
 
-- Travis-CI only builds tags if "Build pushed branches" is active.
-- If you publish a release on PyPI, the same version number cannot be reused even if you
-  delete the release. This is a safety measure. If you are not sure whether the release
-  will work, create a release candidate instead and publish the real version later.
+7. Spread the word!
diff --git a/docs/getting_started/index.rst b/docs/getting_started/index.rst
index 07e620097..51890accf 100644
--- a/docs/getting_started/index.rst
+++ b/docs/getting_started/index.rst
@@ -11,6 +11,5 @@ Getting Started
    tutorial-robinson-crusoe.ipynb
    tutorial-simulation.ipynb
    tutorial-initial-conditions
-   tutorial-model-with-observables.ipynb
    tutorial-finite-mixture.ipynb
    tutorial-msm.ipynb
diff --git a/docs/getting_started/tutorial-finite-mixture.ipynb b/docs/getting_started/tutorial-finite-mixture.ipynb
index a6c29e243..62191c27e 100644
--- a/docs/getting_started/tutorial-finite-mixture.ipynb
+++ b/docs/getting_started/tutorial-finite-mixture.ipynb
@@ -218,7 +218,7 @@
        "    <tr>\n",
        "      <th>initial_exp_fishing_2</th>\n",
        "      <th>probability</th>\n",
-       "      <td>0.33</td>\n",
+       "      <td>0.34</td>\n",
        "    </tr>\n",
        "  </tbody>\n",
        "</table>\n",
@@ -229,7 +229,7 @@
        "category              name              \n",
        "initial_exp_fishing_0 probability   0.33\n",
        "initial_exp_fishing_1 probability   0.33\n",
-       "initial_exp_fishing_2 probability   0.33"
+       "initial_exp_fishing_2 probability   0.34"
       ]
      },
      "execution_count": 3,
@@ -242,7 +242,7 @@
     "category,name,value\n",
     "initial_exp_fishing_0,probability,0.33\n",
     "initial_exp_fishing_1,probability,0.33\n",
-    "initial_exp_fishing_2,probability,0.33\n",
+    "initial_exp_fishing_2,probability,0.34\n",
     "\"\"\"), index_col=[\"category\", \"name\"])\n",
     "initial_exp_fishing"
    ]
@@ -565,7 +565,7 @@
        "    <tr>\n",
        "      <th>initial_exp_fishing_2</th>\n",
        "      <th>probability</th>\n",
-       "      <td>0.3300</td>\n",
+       "      <td>0.3400</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th rowspan=\"2\" valign=\"top\">wage_fishing</th>\n",
@@ -620,7 +620,7 @@
        "lagged_choice_1_hammock constant                  1.0000\n",
        "initial_exp_fishing_0   probability               0.3300\n",
        "initial_exp_fishing_1   probability               0.3300\n",
-       "initial_exp_fishing_2   probability               0.3300\n",
+       "initial_exp_fishing_2   probability               0.3400\n",
        "wage_fishing            type_1                    0.2000\n",
        "                        type_2                    0.4000\n",
        "type_1                  initial_exp_fishing_0   -90.0000\n",
@@ -689,18 +689,7 @@
    "cell_type": "code",
    "execution_count": 9,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "C:\\Users\\tobia\\git\\respy\\respy\\pre_processing\\model_processing.py:599: UserWarning: The probabilities for parameter group \\binitial_exp_fishing_([0-9]+)\\b do not sum to one.\n",
-      "  category=UserWarning,\n",
-      "C:\\Users\\tobia\\git\\respy\\respy\\pre_processing\\model_processing.py:599: UserWarning: The probabilities for parameter group \\binitial_exp_fishing_([0-9]+)\\b do not sum to one.\n",
-      "  category=UserWarning,\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "simulate = rp.get_simulate_func(params, options)\n",
     "df = simulate(params)"
@@ -753,14 +742,14 @@
        "    <tr>\n",
        "      <th>1</th>\n",
        "      <td>0.000000</td>\n",
-       "      <td>0.659223</td>\n",
-       "      <td>0.340777</td>\n",
+       "      <td>0.656887</td>\n",
+       "      <td>0.343113</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>2</th>\n",
-       "      <td>0.000302</td>\n",
-       "      <td>0.337564</td>\n",
-       "      <td>0.662134</td>\n",
+       "      <td>0.000296</td>\n",
+       "      <td>0.338958</td>\n",
+       "      <td>0.660746</td>\n",
        "    </tr>\n",
        "  </tbody>\n",
        "</table>\n",
@@ -770,8 +759,8 @@
        "Type                       0         1         2\n",
        "Experience_Fishing                              \n",
        "0                   1.000000  0.000000  0.000000\n",
-       "1                   0.000000  0.659223  0.340777\n",
-       "2                   0.000302  0.337564  0.662134"
+       "1                   0.000000  0.656887  0.343113\n",
+       "2                   0.000296  0.338958  0.660746"
       ]
      },
      "execution_count": 10,
@@ -828,18 +817,18 @@
        "  <tbody>\n",
        "    <tr>\n",
        "      <th>0</th>\n",
-       "      <td>0.438767</td>\n",
-       "      <td>0.561233</td>\n",
+       "      <td>0.440916</td>\n",
+       "      <td>0.559084</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>1</th>\n",
-       "      <td>0.590465</td>\n",
-       "      <td>0.409535</td>\n",
+       "      <td>0.591656</td>\n",
+       "      <td>0.408344</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>2</th>\n",
-       "      <td>0.705991</td>\n",
-       "      <td>0.294009</td>\n",
+       "      <td>0.700927</td>\n",
+       "      <td>0.299073</td>\n",
        "    </tr>\n",
        "  </tbody>\n",
        "</table>\n",
@@ -848,9 +837,9 @@
       "text/plain": [
        "Choice   fishing   hammock\n",
        "Type                      \n",
-       "0       0.438767  0.561233\n",
-       "1       0.590465  0.409535\n",
-       "2       0.705991  0.294009"
+       "0       0.440916  0.559084\n",
+       "1       0.591656  0.408344\n",
+       "2       0.700927  0.299073"
       ]
      },
      "execution_count": 11,
@@ -879,7 +868,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.7.3"
+   "version": "3.7.6"
   }
  },
  "nbformat": 4,
diff --git a/docs/getting_started/tutorial-initial-conditions.ipynb b/docs/getting_started/tutorial-initial-conditions.ipynb
index 04a41c865..7a72ccef6 100644
--- a/docs/getting_started/tutorial-initial-conditions.ipynb
+++ b/docs/getting_started/tutorial-initial-conditions.ipynb
@@ -170,7 +170,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 921.6x345.6 with 2 Axes>"
       ]
@@ -351,7 +351,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 921.6x345.6 with 2 Axes>"
       ]
@@ -539,9 +539,9 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "C:\\Users\\tobia\\git\\respy\\respy\\pre_processing\\model_processing.py:475: UserWarning: The distribution of initial lagged choices is insufficiently specified in the parameters. Covariates require 1 lagged choices and parameters define 0. Missing lags have equiprobable choices.\n",
+      "C:\\Users\\tobia\\git\\respy\\respy\\pre_processing\\model_processing.py:438: UserWarning: The distribution of initial lagged choices is insufficiently specified in the parameters. Covariates require 1 lagged choices and parameters define 0. Missing lags have equiprobable choices.\n",
       "  category=UserWarning,\n",
-      "C:\\Users\\tobia\\git\\respy\\respy\\pre_processing\\model_processing.py:475: UserWarning: The distribution of initial lagged choices is insufficiently specified in the parameters. Covariates require 1 lagged choices and parameters define 0. Missing lags have equiprobable choices.\n",
+      "C:\\Users\\tobia\\git\\respy\\respy\\pre_processing\\model_processing.py:438: UserWarning: The distribution of initial lagged choices is insufficiently specified in the parameters. Covariates require 1 lagged choices and parameters define 0. Missing lags have equiprobable choices.\n",
       "  category=UserWarning,\n"
      ]
     }
@@ -555,6 +555,8 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
+    "The warning is raised because we forgot to specify what individuals in period 0 have been doing in the previous period. As a default, `respy` assumes that all choices have the same probability for being the previous choice. Note that, it might lead to inconsistent states where an individual should have accumulated experience in the previous period, but still starts with zero experience.\n",
+    "\n",
     "Below we see the choice probabilities on the left-hand-side and the shares of lagged choices on the right-hand-side. Without further information, ``respy`` makes all previous choices in the first period equiprobable.\n",
     "\n",
     "If we had set the covariate with the lagged choice but not added a parameter using the covariate, ``respy`` would have discarded the covariate and created a model without lagged choices."
@@ -567,7 +569,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 921.6x345.6 with 2 Axes>"
       ]
@@ -839,7 +841,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 921.6x345.6 with 3 Axes>"
       ]
@@ -1097,7 +1099,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAu8AAAFiCAYAAABGRTbKAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8li6FKAAAgAElEQVR4nO3de5wU5Z3v8e93ZgAFRFHwAoigzgwOKiiIN0w0RgPJRjfRrCjRNVkkmBg1atTj5mRN1BzdLNmEqEFFjtGImqjxfj0mq9moq+AFGW6OCIKIgncuIgO/80fXYNv00A0001Mzn/frxes1XfVU9a+b6ae+/dRTNY4IAQAAAGj9KspdAAAAAIDiEN4BAACAlCC8AwAAAClBeAcAAABSgvAOAAAApAThHQAAAEgJwjs2i+1Lbf9hM7edaPt/l7qmUrHdz3bYrtrM7cP23s2sG237sXxtC70vti+xPWlzagKAzbElfX1LKVSj7fm2v7wVn3+57T1LtK/1/fyWHovy7LtvUmtlKfaH8iG8o1m2T7E9Nfmwv2X7YdvDt3S/ETEuIi4rRY1Nks57TVLrB7aftn1oKZ+jFCLi1og4tpl1698X20faXpSz/hcRMaYl6gTQPtg+3fYrtlfaXmL7d7Z3KHddrUHSD69LjivLbS+y/UfbB2W3i4iuETGviH0t2libZF8l6+dzv7RExBtJrWtLsX+UD+Ededk+T9KvJf1C0i6S+kq6VtLx5ayrgDsioquknpL+W9Ldtp3bqFSjGACQZrbPl3SVpB9L2l7SIZL2kPS47Y4tWEdr7pMXJ8eV7ZR5f2ZL+pvto0v9RK38fUArQnjHBmxvL+nnkn4QEXdHxIqIWBMR90fEj7OadrR9s+2PbdfbHpq1j31s/1cyCl5v+7isdTfZvjzr8fG2X7L9ke3XbI9oqsP2jcmo/5u2Ly/mdF9ErJH0e0m7StopGVn6u+3/tP2epEttV9j+ie0Ftt9JXsf2Obv6ru3FyfOfn1XvMNvPJK/tLdtX5znQfdX2PNvLbP/SdkWy7em2/7uZ9/2m5DV2kfSwpF5ZIz69ck8N2z4kOcPwge2XbR+Zte705Pk/tv267dGF3jcA7YftbpJ+JumHEfFI0sfPl/RPygT4b2c138b2HUl/8oLtQVn7uSjpnz+2Pacp1CZ97MVJn/5uMmK9Y7KuaTrIv9h+Q9JfbD9i+6ycGl+2/c3k59/YXpgcJ6bZPiLnJTVbY84+m61rYyJjUUT8VNIkZb70NO0ze/rjV23PTOp40/YFBfr0O23/wfZHkk7P7ecTzR2Lco+l60f3bd+izKDb/cnzXeicaThJDffZfs92g+0zsvZ1afLe5D3Go7wI78jnUEnbSPpzgXbHSbpd0g6S7pN0tSTZ7iDpfkmPSdpZ0g8l3Wq7NncHtodJulmZkZ8dJH1B0vxk9e8lNUraW9IBko6VVPB0ou1Okk6XtCgiliWLD5Y0L6nnimT96ZKOkrSnpK5N9Wc5SlJ18rwX+7PTj2sl/UhSD2Xeq6MlfT9n229IGirpQGXOVny3UN1NImKFpJFKRnySf4tzXmNvSQ9KulzSjpIukHSX7Z7JgWKCpJERsZ2kwyS9VOzzA2gXDlOmn787e2FELFcmaB6Ttfh4SX9Spq+ZIuke2x2SPv0sSQclfc1X9Fn/fbakf5T0RUm9JL0v6ZqcGr4oaZ9kuymSTm5aYbtOmS8RDyaLnpc0OKuGP9neplCNeV53MXUVcrekA5O+NteNkr6XvB/7SvpLgT79eEl3KnP8u7WZ52vuWNSsiDhV0huSvp4837/naXabpEXKvA8nSvqFP39GIe8xHuVHeEc+O0laFhGNBdr9d0Q8lMyfu0VS00jHIcqE4Ssj4tOI+IukB5TVMWf5F0mTI+LxiFgXEW9GxGzbuyjT2Z2bjPy/I+k/JY3aSD3/ZPsDSQslDVGmg26yOCJ+GxGNEbFK0mhJv4qIecnB6n9JGuXPn7b8WfLcr0j6v031R8S0iHg22dd8SdcpcyDIdlVEvBcRbygz/Sjfa98S35b0UPL+r4uIxyVNlfTVZP06Sfva3jYi3oqI+hI/P4B066Hm+/m3kvVNpkXEnclZzV8pE/oPUWYgo5OkOtsdImJ+RLyWbPM9Sf+ajFavlnSppBNz+thLkz52lTKDRYNt75GsGy3p7mRbRcQfIuLdpN8dnzxv9oBQczXmKqauQhZLsjKhNtea5P3oFhHvR8QLBfb1TETck/Tjq5ppk/dYtCVs7y5puKSLIuKTiHhJmTMKp2Y1a+4YjzIjvCOfdyX1KKIzW5L180plTltWKfMtfmFErMtav0BS7zz72F3Sa3mW7yGpg6S3kmkhHygTknfeSD1/jIgdImLniPhSREzLWrcwp22vpKbs+qqUmd+fb5sFyTayXWP7AWcu7vpImesCsg90zW5bQntI+lbTe5O8P8Ml7ZaM8pwkaZwy79+DtgeU+PkBpNsyNd/P75asb7K+P0v69UWSekVEg6RzlQnA79i+3XZTX7eHpD9n9U+zlAn7efvYiPhYmVH2pgGaUcoaibZ9vu1Ztj9M9re9Pt/v5q0xz2srpq5CeksKSR/kWXeCMoMoC2w/6cI3Tsg9NhVqU6rjSS9J7yXve/a+s4/TzR3jUWaEd+TzjKRP9PmR602xWNLuTuZ5J/pKejNP24WS9mpm+WpJPZJAvkNEdIuIgZtZU+SpcY+sx32VmaLzdtay3XPWN53m/J0yFy1VR0Q3SZcoMwqjIrbd3HpzLZR0S9Z7s0NEdImIKyUpIh6NiGOUOQjPlnTDJj4/gLbtGWX62G9mL0ymgoyU9ETW4t2z1ldI6qOkT4uIKRExXJn+NPTZXPCFykzdy+6jtomI7ONAbj93m6STk8C7raS/Js95hKSLlJmP3z0idpD0oT7f7zZbY45i6irkG5JeSAZKPicino+I45UZaLpH0h+bea0qsDxbc8eTFZI6Z63bdRP2vVjSjra3y9n3prwPKBPCOzYQER9K+qmka2z/o+3OyfzGkbbzzZvL9T/KdCoXJtsdKenrysydy3WjpO/YPjq5kKi37QER8ZYyc+bH2+6WrNvLdu70lM11m6Qf2e5vu6syo+d35JxC/t/Jax8o6TuS7kiWbyfpI0nLkxHtM/Ps/8e2uyenJs/J2rZYbytzsW3uRbRN/iDp67a/YrvS9jbJxUp9bO9i+7jkILxa0nJlRpYAQNL6fv5nkn5re0TSV/dTZt74ImWmSTQZYvubyajrucr0K8/arrX9peQ6o08krdJnfc1ESVc0TYNJrscpdLeyh5T5EvBzZfrjprO32ykzuLJUUpXtn0rqlrNt3hrzPMfm1CVn9Lb9b8pce3VJnjYdnflbHtsn03c+0mfvR6E+fWOaOxa9pMzNEXa0vasyrzvb28pc07WBiFgo6WlJ/yc5fuyvzDTW5ubdoxUhvCOviPiVpPMk/USZDnOhMhcm3VPEtp8qc6HLSGVOvV4r6bSImJ2n7XPKdEb/qcxIypP6bET8NEkdJc1U5qKiO5UZSS6FycocnJ6S9LoyB54f5rR5UlKDMiNQ/xERTX9c6QJJp0j6WJkR7XzB/F5J05TpXB9U5ktK0ZL36jZJ85LTu71y1i9U5kKnS/TZ/8+PlflMV0g6X5mRlfeUmY+fe0EtgHYuuYjxEkn/oUzQ/B9l+pKjm+aaJ+5VZire+8rMif5mEk47SbpSmX5+iTKjzU2h9jfKXOT4mO2PlQnSBxeoZ7UyF4N+WZmLTps8qsxFtHOVmdrxiTacbtJcjbk2ta5etpcrMwjyvKT9JB2ZdTzIdaqk+cmUynFK7tpTqE8voLlj0S2SXlbmIuHHtOGx6P9I+knyfBfk2e/Jkvopc6z4s6R/S66fQivniGLO2AAAAAAoN0beAQAAgJQgvAMAAAApQXgHAAAAUoLwDgAAAKQE4R0AAABIibL9pawePXpEv379yvX0ANCqTJs2bVlE9Cx3HeXEcQEAMjZ2TChbeO/Xr5+mTp1arqcHgFbF9oJy11BuHBcAIGNjxwSmzQAAAAApQXgHAAAAUoLwDgAAAKQE4R0AAABICcI7AAAAkBKEdwAAACAlCO8AAABAShQM77Yn237H9oxm1tv2BNsNtqfbPrD0ZQIAAAAoZuT9JkkjNrJ+pKTq5N9YSb/b8rIAAAAA5CoY3iPiKUnvbaTJ8ZJujoxnJe1ge7dSFQgAAAAgo6oE++gtaWHW40XJsrdyG9oeq8zovPr27VuCp97KLt2+3BWk36UflruC9OP3cMvxe1hStkdI+o2kSkmTIuLKnPVHSrpX0uvJorsj4uctWuRW0O/iB8tdQpsw/8qvlbsEINVKEd6dZ1nkaxgR10u6XpKGDh2atw0AoPWyXSnpGknHKDNY87zt+yJiZk7Tv0XEP7R4gQDQxpXibjOLJO2e9biPpMUl2C8AoPUZJqkhIuZFxKeSbldm+iQAoAWUIrzfJ+m05K4zh0j6MCI2mDIDAGgTmpsqmetQ2y/bftj2wJYpDQDavoLTZmzfJulIST1sL5L0b5I6SFJETJT0kKSvSmqQtFLSd7ZWsQCAsitmquQLkvaIiOW2vyrpHmXuSLbhztJ2LRQAlFnB8B4RJxdYH5J+ULKKAACtWcGpkhHxUdbPD9m+1naPiFiWuzOuhQKATcNfWAUAbIrnJVXb7m+7o6RRykyfXM/2rrad/DxMmWPNuy1eKQC0QaW42wwAoJ2IiEbbZ0l6VJlbRU6OiHrb45L1EyWdKOlM242SVkkalZylBVAC3LZ0y6X5lqWEdwDAJomIh5S53il72cSsn6+WdHVL1wUA7QHTZgAAAICUILwDAAAAKUF4BwAAAFKC8A4AAACkBOEdAAAASAnCOwAAAJAShHcAAAAgJQjvAAAAQEoQ3gEAAICUILwDAAAAKUF4BwAAAFKC8A4AAACkBOEdAAAASAnCOwAAAJAShHcAAAAgJQjvAAAAQEoQ3gEAAICUILwDAAAAKUF4BwAAAFKC8A4AAACkBOEdAAAASAnCOwAAAJAShHcAAAAgJQjvAAAAQEoQ3gEAAICUILwDAAAAKUF4BwAAAFKC8A4AAACkBOEdAAAASAnCOwAAAJAShHcAAAAgJQjvAAAAQEoQ3gEAAICUILwDAAAAKUF4BwAAAFKC8A4AAACkBOEdAAAASImiwrvtEbbn2G6wfXGe9dvbvt/2y7brbX+n9KUCAAAA7VvB8G67UtI1kkZKqpN0su26nGY/kDQzIgZJOlLSeNsdS1wrAAAA0K4VM/I+TFJDRMyLiE8l3S7p+Jw2IWk725bUVdJ7khpLWikAAADQzhUT3ntLWpj1eFGyLNvVkvaRtFjSK5LOiYh1JakQANCqFJpKmdXuINtrbZ/YkvUBQFtWTHh3nmWR8/grkl6S1EvSYElX2+62wY7ssban2p66dOnSTS4WAFBeRU6lbGp3laRHW7ZCAGjbignviyTtnvW4jzIj7Nm+I+nuyGiQ9LqkAbk7iojrI2JoRAzt2bPn5tYMACifYqZSStIPJd0l6Z2WLA4A2rpiwvvzkqpt908uQh0l6b6cNm9IOlqSbO8iqVbSvFIWCgBoFQpOpbTdW9I3JE1swboAoF2oKtQgIhptn6XMqc9KSZMjot72uGT9REmXSbrJ9ivKTLO5KCKWbcW6AQDlUcxUyl8rcxxYm7mPwUZ2Zo+VNFaS+vbtW5ICAaAtKxjeJSkiHpL0UM6yiVk/L5Z0bGlLAwC0QsVMpRwq6fYkuPeQ9FXbjRFxT+7OIuJ6SddL0tChQ3O/BAAAchQV3gEASKyfSinpTWWmUp6S3SAi+jf9bPsmSQ/kC+4AgE1HeAcAFK3IqZQAgK2E8A4A2CSFplLmLD+9JWoCgPaC8A60cv0+mVLuElJvfrkLAACgRIq5VSQAAACAVoDwDgAAAKQE4R0AAABICcI7AAAAkBKEdwAAACAlCO8AAABAShDeAQAAgJQgvAMAAAApQXgHAAAAUoLwDgAAAKQE4R0AAABICcI7AAAAkBKEdwAAACAlCO8AAABAShDeAQAAgJQgvAMAAAApQXgHAAAAUoLwDgAAAKQE4R0AAABICcI7AAAAkBKEdwAAACAlCO8AAABAShDeAQAAgJQgvAMAAAApUVXuAlqzfp9MKXcJqTe/3AUAAAC0IYy8AwAAAClBeAcAAABSgvAOAAAApAThHQAAAEgJwjsAAACQEoR3AAAAICUI7wAAAEBKEN4BAACAlCC8AwAAAClBeAcAAABSgvAOAAAApAThHQAAAEiJosK77RG259husH1xM22OtP2S7XrbT5a2TAAAAABVhRrYrpR0jaRjJC2S9Lzt+yJiZlabHSRdK2lERLxhe+etVTAAAADQXhUz8j5MUkNEzIuITyXdLun4nDanSLo7It6QpIh4p7RlAgBai0JnY20fb3t6cjZ2qu3h5agTANqiYsJ7b0kLsx4vSpZlq5HU3fZ/2Z5m+7RSFQgAaD2yzsaOlFQn6WTbdTnNnpA0KCIGS/qupEktWyUAtF0Fp81Icp5lkWc/QyQdLWlbSc/YfjYi5n5uR/ZYSWMlqW/fvpteLQCg3NafjZUk201nY9dPpYyI5Vntu2jDYwYAYDMVM/K+SNLuWY/7SFqcp80jEbEiIpZJekrSoNwdRcT1ETE0Iob27Nlzc2sGAJRPMWdjZfsbtmdLelCZ0XcAQAkUE96fl1Rtu7/tjpJGSbovp829ko6wXWW7s6SDJc0qbakAgFagmLOxiog/R8QASf8o6bJmd2aPTebFT126dGkJywSAtqlgeI+IRklnSXpUmUD+x4iotz3O9rikzSxJj0iaLuk5SZMiYsbWKxsAUCbFnI1dLyKekrSX7R7NrOeMLABsgmLmvCsiHpL0UM6yiTmPfynpl6UrDQDQCq0/GyvpTWXOxp6S3cD23pJei4iwfaCkjpLebfFKAaANKiq8AwAgZc7G2m46G1spaXLT2dhk/URJJ0g6zfYaSasknRQRXLQKACVAeAcAbJJCZ2Mj4ipJV7V0XQDQHhRzwSoAAACAVoDwDgAAAKQE4R0AAABICcI7AAAAkBKEdwAAACAlCO8AAABAShDeAQAAgJQgvAMAAAApQXgHAAAAUoLwDgAAAKQE4R0AAABICcI7AAAAkBKEdwAAACAlCO8AAABAShDeAQAAgJQgvAMAAAApQXgHAAAAUoLwDgAAAKQE4R0AAABICcI7AAAAkBKEdwAAACAlCO8AAABAShDeAQAAgJQgvAMAAAApQXgHAAAAUoLwDgAAAKQE4R0AAABICcI7AAAAkBKEdwAAACAlCO8AAABAShDeAQAAgJQgvAMAAAApQXgHAAAAUoLwDgAAAKQE4R0AAABICcI7AAAAkBKEdwAAACAlCO8AAABAShDeAQAAgJQoKrzbHmF7ju0G2xdvpN1BttfaPrF0JQIAAACQigjvtislXSNppKQ6SSfbrmum3VWSHi11kQCA1qPQgI7t0banJ/+etj2oHHUCQFtUzMj7MEkNETEvIj6VdLuk4/O0+6GkuyS9U8L6AACtSJEDOq9L+mJE7C/pMknXt2yVANB2FRPee0tamPV4UbJsPdu9JX1D0sSN7cj2WNtTbU9dunTpptYKACi/ggM6EfF0RLyfPHxWUp8WrhEA2qxiwrvzLIucx7+WdFFErN3YjiLi+ogYGhFDe/bsWWyNAIDWo+CATo5/kfTwVq0IANqRqiLaLJK0e9bjPpIW57QZKul225LUQ9JXbTdGxD0lqRIA0FoUM6CTaWgfpUx4H97szuyxksZKUt++fUtRHwC0acWMvD8vqdp2f9sdJY2SdF92g4joHxH9IqKfpDslfZ/gDgBtUjEDOrK9v6RJko6PiHeb2xlnZAFg0xQM7xHRKOksZe4iM0vSHyOi3vY42+O2doEAgFal4ICO7b6S7pZ0akTMLUONANBmFTNtRhHxkKSHcpblvTg1Ik7f8rIAAK1RRDTabhrQqZQ0uWlAJ1k/UdJPJe0k6dpkOmVjRAwtV80A0JYUFd4BAGhSaEAnIsZIGtPSdQFAe1DUX1gFAAAAUH6EdwAAACAlCO8AAABAShDeAQAAgJQgvAMAAAApQXgHAAAAUoLwDgAAAKQE4R0AAABICcI7AAAAkBKEdwAAACAlCO8AAABAShDeAQAAgJQgvAMAAAApQXgHAAAAUoLwDgAAAKQE4R0AAABICcI7AAAAkBKEdwAAACAlCO8AAABAShDeAQAAgJQgvAMAAAApQXgHAAAAUoLwDgAAAKQE4R0AAABICcI7AAAAkBKEdwAAACAlCO8AAABAShDeAQAAgJQgvAMAAAApQXgHAAAAUoLwDgAAAKQE4R0AAABICcI7AAAAkBKEdwAAACAlCO8AAABAShDeAQAAgJQgvAMAAAApQXgHAAAAUoLwDgAAAKREUeHd9gjbc2w32L44z/rRtqcn/562Paj0pQIAAADtW8HwbrtS0jWSRkqqk3Sy7bqcZq9L+mJE7C/pMknXl7pQAEDrUMSAzgDbz9hebfuCctQIAG1VMSPvwyQ1RMS8iPhU0u2Sjs9uEBFPR8T7ycNnJfUpbZkAgNagyAGd9ySdLek/Wrg8AGjzignvvSUtzHq8KFnWnH+R9PCWFAUAaLWKGdB5JyKel7SmHAUCQFtWVUQb51kWeRvaRykT3oc3s36spLGS1Ldv3yJLBAC0IvkGdA4uUy0A0O4UM/K+SNLuWY/7SFqc28j2/pImSTo+It7Nt6OIuD4ihkbE0J49e25OvQCA8ip6QKeondljbU+1PXXp0qVbUBYAtA/FhPfnJVXb7m+7o6RRku7LbmC7r6S7JZ0aEXNLXyYAoJUoakCnWAzqAMCmKThtJiIabZ8l6VFJlZImR0S97XHJ+omSfippJ0nX2pakxogYuvXKBgCUyfoBHUlvKjOgc0p5SwKA9qOYOe+KiIckPZSzbGLWz2MkjSltaQCA1qaYAR3bu0qaKqmbpHW2z5VUFxEfla1wAGgjigrvAAA0KWJAZ4m4ZTAAbBVF/YVVAAAAAOVHeAcAAABSgvAOAAAApAThHQAAAEgJwjsAAACQEoR3AAAAICUI7wAAAEBKEN4BAACAlCC8AwAAAClBeAcAAABSgvAOAAAApAThHQAAAEgJwjsAAACQEoR3AAAAICUI7wAAAEBKEN4BAACAlCC8AwAAAClBeAcAAABSgvAOAAAApAThHQAAAEgJwjsAAACQEoR3AAAAICUI7wAAAEBKEN4BAACAlCC8AwAAAClBeAcAAABSgvAOAAAApAThHQAAAEgJwjsAAACQEoR3AAAAICUI7wAAAEBKEN4BAACAlCC8AwAAAClBeAcAAABSgvAOAAAApAThHQAAAEgJwjsAAACQEoR3AAAAICUI7wAAAEBKEN4BAACAlCgqvNseYXuO7QbbF+dZb9sTkvXTbR9Y+lIBAK0BxwQAKJ+C4d12paRrJI2UVCfpZNt1Oc1GSqpO/o2V9LsS1wkAaAU4JgBAeRUz8j5MUkNEzIuITyXdLun4nDbHS7o5Mp6VtIPt3UpcKwCg/DgmAEAZFRPee0tamPV4UbJsU9sAANKPYwIAlFFVEW2cZ1lsRhvZHqvMKVRJWm57ThHPj+b1kLSs3EVsjK8qdwVoIa36dzElv4d7lLuAIpXsmCBxXNgKWvVnUUrN5xFbht/DLdfsMaGY8L5I0u5Zj/tIWrwZbRQR10u6vojnRBFsT42IoeWuA+B3sV0p2TFB4rhQanwW0Rrwe7h1FTNt5nlJ1bb72+4oaZSk+3La3CfptOQOA4dI+jAi3ipxrQCA8uOYAABlVHDkPSIabZ8l6VFJlZImR0S97XHJ+omSHpL0VUkNklZK+s7WKxkAUC4cEwCgvByRdxoiUsD22OSUM1BW/C4CrQOfRbQG/B5uXYR3AAAAICWK+gurAAAAAMqP8A5gk9h+yPYOG1l/k+0TW7ImoD3iswi0T8XcKhJtgO3KiFhb7jqQbrYt6R8iYl25awHaMz6LaCvIJ5uOkfdWyHY/27Nt/972dNt32u5s+2jbL9p+xfZk252S9s0tn2/7p7b/W9K3yvqikFrJ7+Ms29dKekHSWts9knWnJb+jL9u+JWuzL9h+2vY8Rv6A0uCziHIjn7QOhPfWq1bS9RGxv6SPJJ0n6SZJJ0XEfsqcNTnT9jb5lmft55OIGB4Rt7dk8WhzaiXdHBEHSFogSbYHSvpXSV+KiEGSzslqv5uk4ZL+QdKVLVwr0JbxWUS5kU/KjPDeei2MiL8nP/9B0tGSXo+Iucmy30v6gjIfonzLm9zREsWizVsQEc/mLPuSpDsjYpkkRcR7WevuiYh1ETFT0i4tVSTQDvBZRLmRT8qM8N56FXsPTxdYv2JLCwGU//fIav73dHVOOwClwWcR5UY+KTPCe+vV1/ahyc8nS/p/kvrZ3jtZdqqkJyXNbmY5sLU9IemfbO8kSbZ3LHM9QHvFZxEtiXxSZoT31muWpH+2PV3SjpL+U5k/Mf4n269IWidpYkR8km95mWpGOxIR9ZKukPSk7Zcl/arMJQHtEp9FtDDySZnxF1ZbIdv9JD0QEfuWuRQAAABJ5JPWgpF3AAAAICUYeQcAAABSgpF3AAAAICUI7wAAAEBKEN4BAACAlCC8AwAAAClBeMdWZXut7Zey/vWzPdT2hI1sc6TtB5pZN8l2XYlrrLb9gO3XbE+z/VfbXyi8ZWnZXt7SzwkAANKlqtwFoM1bFRGDc5bNlzR1c3YWEWO2uKIstreR9KCkCyLivmTZvpKGSnoqp21VRDSW8vkBAAA2BSPvaHHZI+u2v5g1Kv+i7e2SZl1t32l7tu1bbTtp/1+2hyY/L7d9he2XbT9re5dk+V7J4+dt/7zAiPZoSc80BXdJiogZEXFTsq9LbV9v+zFJN9vexvb/tf1KUu9RSbvTbV+d9RofsH1kgTr7234mqfOyrG13s/1U8p7MsH3Elr3jAACgrSC8Y2vbNiuc/znP+gsk/SAZnT9C0qpk+QGSzpVUJ2lPSYfn2baLpGcjYpAyo+RnJMt/I+k3EXGQpMUF6hso6YUCbYZIOj4iTpH0A0mKiP0knSzp98no/cZsrM7fJXUuyWp/iqRHk/dkkKSXCuwfAK6Jo9QAAA9kSURBVAC0E4R3bG2rImJw8u8bedb/XdKvbJ8taYesaSnPRcSiiFinTHjtl2fbTyU1zY2fltXmUEl/Sn6esinF2v5zMtp9d9bi+yKi6UvFcEm3SFJEzJa0QFJNgd02V+fhkm5Lfr4lq/3zkr5j+1JJ+0XEx5vyGgAAQNtFeEdZRcSVksZI2lbSs7YHJKtWZzVbq/zXZ6yJz/5EcHNtCqmXdGBWPd+QdLqkHbParMj62c3sp1Gf/zxlj8ZvrM4N/sRxRDwl6QuS3pR0i+3TNv4SAABAe0F4R1nZ3isiXomIq5S5iHVAoW2K8KykE5KfRxVoO0XS4baPy1rWeSPtn1Jmnrxs10jqK2mOMhfhDrZdYXt3ScOKqPPvWfWNblpoew9J70TEDZJuVNaXCwAA0L4R3lFu5ybTVF5WZr77w6XYp6TzbD8naTdJHzbXMJkO8w+SxtmeZ/sZST+RdHkzm1wrqdL2K5LukHR6RKxWJoi/LukVSf+hwvPoJekcST+w/byk7bOWHynpJdsvKvMl5DdF7AsAALQD/uxsPtA22O6szFz7sD1K0skRcXy56wIAANhS3OcdbdEQSVcnt5f8QNJ3y1wPAABASTDyjnbB9n76/B1dJGl1RBxcjnoAAAA2B+EdAAAASAkuWAUAAABSgvAOAAAApAThHQAAAEgJwjsAAACQEoR3AAAAICUI7wAAAEBKEN4BAACAlCC8AwAAAClBeAcAAABSgvAOAAAApERVuQvApps2bdrOVVVVkyTtK76AoXVYJ2lGY2PjmCFDhrxT7mIAlBbHnTaJfjulCO8pVFVVNWnXXXfdp2fPnu9XVFREuesB1q1b56VLl9YtWbJkkqTjyl0PgNLiuNP20G+nF9+e02nfnj17fkQHitaioqIievbs+aEyo3IA2h6OO20M/XZ6Ed7TqYIOFK1N8jtJnwK0TRx32iD67XTiPwyb5fLLL995zz33HNitW7fBl1xyya7NtZswYcJOp512Wt986774xS/uvWzZssqtV2XrN2fOnI7V1dUDy11HMXr37r3fW2+9xVQ7AADKiANxG9Dv4geHlHJ/86/82rRCbW688caeDz/88KsDBgz4dHOf58knn2zY3G23iku3L+n7qEs/LPg+AkAaleO4U1lZOaS6unpV0+N777234e23366aPHnyTjfddNPCfNs88MAD240fP36Xv/71rxscb0466aQ9LrzwwreHDBnyyZZV/5lXXnml09lnn717Q0PDNt26dVvbtWvXtZdeeunikSNHLi/VcxSjc+fOB6xcufLFlnxOtBxG3rHJTjnllL6LFi3qdNxxx+39s5/9bOemkfXJkyd3r66uHlhbW1s3dOjQ2qb2S5Ys6XDEEUdU77HHHvuOGzeuT9PyppHcOXPmdNxzzz0Hjho1ao+999574OGHH169fPlyS9KTTz7Zuaampm7w4MEDvve97/VJyyj1pli7dq1yX/v48eN77LvvvvvU1tbWfeUrX9nr448/rpCkE044od/o0aP7HnzwwTV9+vTZ78EHH+z6rW99q9+ee+458IQTTujXtM/OnTsfcOaZZ/YeOHDgPocddljNX//6187Dhg2r7dOnz3633nrr9pK0cuVKn3jiif1qamrq9tlnn7r7779/O0lqbGzU2LFj+9TU1NTV1NTUXXHFFTtn17t8+XIfccQR1ePHj+/Rgm8TgHauU6dO62bPnj2z6V9tbe2nX/jCF1Y2F9wLueOOOxaUMrivXLnSX//616vHjBmzdOHChTPq6+tnXX311W+8+uqrnXLbrlmzplRPi3aI8I5NNmXKlDd23nnnNU8++eTc7t27r21afuWVV+722GOPzZ0zZ87MRx55ZP0ox8yZMzvfc88982bNmlV/3333dW9oaOiQu8833nhjm7PPPvudhoaG+u23337tzTff3F2SxowZ0/+aa65Z8NJLL82urKxsk/Mt87320aNHvz9jxoxZc+bMmVlbW7tqwoQJ64Pyhx9+WPXMM8/MvfLKKxeedNJJ1T/+8Y/ffvXVV+tnz5697dNPP72tJK1atariqKOO+ri+vn5Wly5d1v7kJz/p/be//W3un/70p4bLLrustyRdddVVO0vS3LlzZ06ZMmXe2LFj+61cudLjx4/vuWDBgk719fUz586dO3PMmDHvNj33Rx99VHHsscdWn3TSSe+df/75y1r6vQKAbA888MB2Rx111N6S9OCDD3YdMGBA3YABA+r22Wefuvfff79CklasWFE5YsSIPfv37z/wuOOO679u3TpJ0rBhw2qfeuqpzlJmwOOHP/xh79ra2rpBgwYNWLhwYZUk1dfXdxo0aNCAfffdd59zzz23V+fOnQ9orpbrrrtupwMPPHD56NGjP2xadtBBB31y9tlnvytJ5513Xq+TTz55j8MPP7z6m9/8Zv/mBlByp5seddRRez/wwAPbbazO2bNndxw8ePCAfffdd59zzjmnV9O2CxYs6DB06NDaAQMG1FVXVw985JFHupborUcZEd5RMkOHDl0+evTofuPHj+/R2Ni4fvnw4cM/2mmnndZ27tw59t57709ee+21DUYhevfuvfqwww5bJUkHHHDAyvnz53datmxZ5YoVKyqOOeaYFZL0z//8z++12ItpQfle+7Rp07YdMmRIbU1NTd1dd921U319/TZN7b/2ta99UFFRoQMPPHDlTjvttGbYsGGrKisrVVNTs6rpve3QoUOceOKJH0nSwIEDVw0fPvzjTp06xbBhw1a9+eabHSXp6aef7nraaae9mzzvJ7169fr0lVde2eYvf/lLt3Hjxi3t0CHzHWuXXXZZ/wXtuOOO2/vUU09ddtZZZ60P9ADQElavXl3RFM6POeaYvXLXjx8/ftcJEyYsmD179sxnn312dteuXddJ0qxZs7a95pprFjY0NNS/8cYbnR5//PENAuyqVasqDj300OVz5syZeeihhy7/7W9/21OSzjrrrN2///3vvzNjxoxZvXr12uhweX19/TYHHHDAyo21mT59eudHH3204f7773+9uQGUjW3fXJ3f//73+44ZM2bpjBkzZu26667r65w8efKORx999IezZ8+eOWvWrPqDDz54o/UhHQjvKJkpU6a8cfnlly9euHBhx8GDBw9csmRJpSR17Nhx/Yh5ZWVlrFmzZoPOKbdNY2OjI9rkQPsG8r32sWPH9r/66qvfmDt37syLLrpo8erVq9d/VrfZZptI2n5u24qKCjU2NlqSqqqqoqKiYv3yTp06rd9m7dq1lqTm3t+IkO28Kw866KDljzzyyPZNI1cA0FKyp808/vjjr+WuP+SQQ5ZfcMEFu19++eU7L1u2rLJpAGK//fZbsddee62prKzUwIEDV7722msdc7ft0KFDjBo16kNJGjJkyIoFCxZ0lKQXX3yx63e/+933JCn7LGQxjjnmmL2qq6sHHnvsseu/aIwYMeKDrl27htT8AMrG9tlcnS+88ELXM8444z1J+t73vre+zkMOOWTFbbfd1uO8887r9dxzz23bvXt3Ou82gPCOkqmvr+/0pS99acWvf/3rxd27d2+cN2/eBh3kpujZs+faLl26rHviiSe6SNItt9yyY2kqbf1WrlxZ0bdv3zWrV6/27bffvlVe9/Dhw5f/4Q9/2FGSpk+f3umtt97quP/++3/y5S9/+aOJEyf2bJqT+fbbb6+/I9Avf/nLxTvuuGPjqaeemvcOQgBQLr/4xS+WTJo0acGqVasqDjvssH1efPHFbSStH7yQMgMYTYMc2bIHPKqqqvK2KWTgwIGfvPjii52bHj/++OOv3Xjjja9/8MEH628O0qVLl/XhubkBlKqqqsgeIMkevNlYnflu5Tly5MjlTz311JzevXt/evrpp/e/+uqrd9rU14XWh/COkvnRj37Up6ampq66unrgIYcc8vEhhxyyqvBWG3fdddfNP/PMM/cYPHjwgIjQdtttt7bwVul38cUXLx42bNg+RxxxRE11dXXJLqjKduGFF76zdu1a19TU1J100kl7XXfddfO33Xbb+NGPfrS0T58+nw4YMGBgbW1t3Y033vi5Lw833njjwtWrV1dkX3wMAOVWX1/fadiwYauuuOKKJfvtt9+KGTNmbHQUuxiDBw9eftNNN3WXMlNQNtb2jDPOeHfq1Kldm24KIEkrVqxoNmc1N4Cy1157fVpfX9957dq1amho6DB9+vQuheo88MADl99www07StINN9ywPqDPnTu3Y+/evdecf/75y7797W8ve+GFFzo3vxekBbeKbAOKucVWqb355puvSFJyIc67kvTYY49tcBoze70kZd+uq2kfu+22m1599dX6puU///nP3276eciQIavmzp07U5IuueSSXQcNGrSi9K8mUYZbO9bW1n7a3Gu/6KKLlua2v+uuu+Y3t232uuxbhP3qV79anL2PpnWdO3eO7G2adOjQQZMmTVokaVH28qb/L0m68847N9gOQPtRjuNOIf/+7/++89NPP92toqIiampqVp144okfPvHEE1t0geZvf/vbhaNHj+4/YcKEXY899tgPunbt2uwAUteuXePee+9tOPfcc/tcdNFFfXv06LGmS5cuay+55JLF+dpfeOGF75x66ql71NTU1FVWVqppAOWYY45Zfs0116yura0dWFtbu6qurq7gPPVrr732jVGjRu157bXX7nLccce937T80Ucf3W7ChAm7VlVVRefOndfeeuutr2/eO4HWpN3MK25LXn755fmDBg1qF3f6uOGGG7qPHz9+t7Vr17p3796rp0yZMr9Xr16NhbdEObz88ss9Bg0a1K/cdQAorfZ03Mn28ccfV3Tp0mVdRUWFrr/++u533HHHjk888cQGA1VpRr+dPoy8o1U744wz3j/jjDPeL9wSAIDS+vvf/975nHPO6RsR6tat29qbbrppfrlrAgjvAAAAeYwYMWL5nDlzZmYve+6557Y97bTT+mcv69ix47rp06fPbtnq0F4R3tNp3bp165zvynKgXNatW2dJ3IYMQJs2bNiwVbNnz55ZuCWwdXC3mXSasXTp0u2TsASU3bp167x06dLtJc0ody0Atop1HHPaHgZd0omR9xRqbGwcs2TJkklLlizZV3wBQ+uwTtKMxsbGMeUuBMBWMWPp0qV1PXv2/JCzvm0Dgy7pxd1mAADARk2bNm3nqqqqSZIYNGo71g+6DBky5J1yF4PiEd4BAACAlODbMwAAAJAShHcAAAAgJQjvAAAAQEoQ3gEAAICUILwDAAAAKfH/AdqKGxfzwxkSAAAAAElFTkSuQmCC\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 921.6x345.6 with 2 Axes>"
       ]
@@ -1157,7 +1159,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.7.3"
+   "version": "3.7.6"
   }
  },
  "nbformat": 4,
diff --git a/docs/getting_started/tutorial-model-with-observables.ipynb b/docs/getting_started/tutorial-model-with-observables.ipynb
deleted file mode 100644
index 75da07859..000000000
--- a/docs/getting_started/tutorial-model-with-observables.ipynb
+++ /dev/null
@@ -1,788 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Implementing a model with observed state space components\n",
-    "\n",
-    "This notebook shows how to introduce observable characteristics of an individual to the state space. A potential source of unobserved heterogeneity in the models of Keane and Wolpin (1994) and Keane and Wolpin (1997) stems from the fact that individual ability is not observed. The authors try to mitigate the influence by using a finite fixture model with four different types as the years of schooling at the start of the model horizon are potentially not exogenous. If we had data on ability, we could probably shift some of the explanatory power of types to an ability covariate. Furthermore, making type probabilities dependent on the ability level, types become more economically interpretable."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "%matplotlib inline\n",
-    "\n",
-    "import numpy as np\n",
-    "import pandas as pd\n",
-    "import respy as rp"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Parameters, options and data\n",
-    "\n",
-    "As we have no ability measure in the original data of Keane and Wolpin (1997), we assume that the initial years of schooling serve as a five point scale ability measure. The measure should start at 0 which makes it more suitable to the model."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "C:\\Users\\tobia\\git\\respy\\respy\\pre_processing\\model_processing.py:204: UserWarning: The shares of initial experiences for choice 'school' do not sum to one. Shares are divided by their sum for normalization.\n",
-      "  category=UserWarning,\n"
-     ]
-    }
-   ],
-   "source": [
-    "params, options, df = rp.get_example_model(\"kw_97_base\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "df[\"Ability\"] = (\n",
-    "    df.groupby(\"Identifier\").Experience_School.transform(\"first\")\n",
-    "    .subtract(7)\n",
-    "    .astype(np.uint8)\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Furthermore, we include covariates of our new ability measure in the parameter specification and define the covariates in the options. For simplification, we treat our ability measure similar to IQ which was originally used to determine basic mental capabilities. Our single covariate is thus having an ability level higher than zero. Still, we keep the five point scale instead of a simpler two point scale to determine the impact on the size of the state space.\n",
-    "\n",
-    "The new covariate enters the wage component of working alternatives and the non-pecuniary component of non-working alternatives positively. "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Add ability parameters to wage components.\n",
-    "for category in [\"wage_white_collar\", \"wage_blue_collar\", \"wage_military\"]:\n",
-    "    params.loc[(category, \"at_least_one_ability\"), :] = [\n",
-    "        0.1, \"return to having at least ability level one\"\n",
-    "    ]\n",
-    "\n",
-    "# Add ability parameters to non-pecuniary components.\n",
-    "for category in [\"nonpec_school\", \"nonpec_home\"]:\n",
-    "    params.loc[(category, \"at_least_one_ability\"), :] = [\n",
-    "        2000, \"return to having at least ability level one\"\n",
-    "    ]\n",
-    "\n",
-    "# Add ability parameters to type proobabilities.\n",
-    "for category in [\"type_2\", \"type_3\", \"type_4\"]:\n",
-    "    params.loc[(category, \"at_least_one_ability\"), :] = [\n",
-    "        0.1, \"return to having at least ability level one\"\n",
-    "    ]\n",
-    "\n",
-    "# Define the probability for ability levels for the simulation.\n",
-    "for name, val in zip(\n",
-    "    [f\"ability_{i}\" for i in range(5)], [0.0098, 0.0431, 0.201, 0.6702, 0.0759]\n",
-    "):\n",
-    "    params.loc[(\"observables\", name), :] = [\n",
-    "        val, \"Probability of having the specified ability level\"\n",
-    "    ]"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "As the ``\"name\"`` column in the parameter dataframe is matched to covariates, we have to define ``\"at_least_one_ability\"``. The string under ``options[\"covariates\"][\"at_least_one_ability\"]`` is evaluated using [pandas.DataFrame.eval()](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.eval.html). Under ``options[\"observables\"][\"ability\"]`` we store the range of ability levels which is five."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "options[\"covariates\"][\"at_least_one_ability\"] = \"ability >= 1\""
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# For simplification we restrict the model to 11 periods.\n",
-    "options[\"n_periods\"] = 11"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Here, we solve the model."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "state_space = rp.solve(params, options)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "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></th>\n",
-       "      <th>value</th>\n",
-       "      <th>comment</th>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>category</th>\n",
-       "      <th>name</th>\n",
-       "      <th></th>\n",
-       "      <th></th>\n",
-       "    </tr>\n",
-       "  </thead>\n",
-       "  <tbody>\n",
-       "    <tr>\n",
-       "      <th>delta</th>\n",
-       "      <th>delta</th>\n",
-       "      <td>0.7870</td>\n",
-       "      <td>discount factor</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th rowspan=\"4\" valign=\"top\">wage_white_collar</th>\n",
-       "      <th>constant</th>\n",
-       "      <td>8.8043</td>\n",
-       "      <td>log of rental price if the base skill endowmen...</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>exp_school</th>\n",
-       "      <td>0.0938</td>\n",
-       "      <td>linear return to an additional year of schooli...</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>exp_white_collar</th>\n",
-       "      <td>0.1170</td>\n",
-       "      <td>return to experience, same sector, linear (wage)</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>exp_white_collar_square</th>\n",
-       "      <td>-0.0461</td>\n",
-       "      <td>return to experience, same sector, quadratic (...</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>...</th>\n",
-       "      <th>...</th>\n",
-       "      <td>...</td>\n",
-       "      <td>...</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th rowspan=\"5\" valign=\"top\">observables</th>\n",
-       "      <th>ability_0</th>\n",
-       "      <td>0.0098</td>\n",
-       "      <td>Probability of having the specified ability level</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>ability_1</th>\n",
-       "      <td>0.0431</td>\n",
-       "      <td>Probability of having the specified ability level</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>ability_2</th>\n",
-       "      <td>0.2010</td>\n",
-       "      <td>Probability of having the specified ability level</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>ability_3</th>\n",
-       "      <td>0.6702</td>\n",
-       "      <td>Probability of having the specified ability level</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>ability_4</th>\n",
-       "      <td>0.0759</td>\n",
-       "      <td>Probability of having the specified ability level</td>\n",
-       "    </tr>\n",
-       "  </tbody>\n",
-       "</table>\n",
-       "<p>79 rows × 2 columns</p>\n",
-       "</div>"
-      ],
-      "text/plain": [
-       "                                            value  \\\n",
-       "category          name                              \n",
-       "delta             delta                    0.7870   \n",
-       "wage_white_collar constant                 8.8043   \n",
-       "                  exp_school               0.0938   \n",
-       "                  exp_white_collar         0.1170   \n",
-       "                  exp_white_collar_square -0.0461   \n",
-       "...                                           ...   \n",
-       "observables       ability_0                0.0098   \n",
-       "                  ability_1                0.0431   \n",
-       "                  ability_2                0.2010   \n",
-       "                  ability_3                0.6702   \n",
-       "                  ability_4                0.0759   \n",
-       "\n",
-       "                                                                                     comment  \n",
-       "category          name                                                                        \n",
-       "delta             delta                                                      discount factor  \n",
-       "wage_white_collar constant                 log of rental price if the base skill endowmen...  \n",
-       "                  exp_school               linear return to an additional year of schooli...  \n",
-       "                  exp_white_collar          return to experience, same sector, linear (wage)  \n",
-       "                  exp_white_collar_square  return to experience, same sector, quadratic (...  \n",
-       "...                                                                                      ...  \n",
-       "observables       ability_0                Probability of having the specified ability level  \n",
-       "                  ability_1                Probability of having the specified ability level  \n",
-       "                  ability_2                Probability of having the specified ability level  \n",
-       "                  ability_3                Probability of having the specified ability level  \n",
-       "                  ability_4                Probability of having the specified ability level  \n",
-       "\n",
-       "[79 rows x 2 columns]"
-      ]
-     },
-     "execution_count": 8,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "params"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Here, we calculate the likelihood value of the data."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "C:\\Users\\tobia\\git\\respy\\respy\\pre_processing\\model_processing.py:204: UserWarning: The shares of initial experiences for choice 'school' do not sum to one. Shares are divided by their sum for normalization.\n",
-      "  category=UserWarning,\n"
-     ]
-    }
-   ],
-   "source": [
-    "criterion = rp.get_crit_func(params, options, df)\n",
-    "crit_val = criterion(params)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 10,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "-55.39840900556615"
-      ]
-     },
-     "execution_count": 10,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "crit_val"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Here, we simulate a new data set given the proportions of ability levels specified in ``params`` under ``\"ability\"``."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 11,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "simulate = rp.get_simulate_func(params, options)\n",
-    "df = simulate(params)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 13,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "array([0.2, 0.4, 0.6])"
-      ]
-     },
-     "execution_count": 13,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "[1, 2, 3] / np.sum(5)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 12,
-   "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>Identifier</th>\n",
-       "      <th>Period</th>\n",
-       "      <th>Choice</th>\n",
-       "      <th>Wage</th>\n",
-       "      <th>Experience_Blue_Collar</th>\n",
-       "      <th>Experience_Military</th>\n",
-       "      <th>Experience_White_Collar</th>\n",
-       "      <th>Experience_School</th>\n",
-       "      <th>Ability</th>\n",
-       "      <th>Type</th>\n",
-       "    </tr>\n",
-       "  </thead>\n",
-       "  <tbody>\n",
-       "    <tr>\n",
-       "      <th>0</th>\n",
-       "      <td>0</td>\n",
-       "      <td>0</td>\n",
-       "      <td>school</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>0</td>\n",
-       "      <td>0</td>\n",
-       "      <td>0</td>\n",
-       "      <td>10</td>\n",
-       "      <td>3</td>\n",
-       "      <td>2</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>1</th>\n",
-       "      <td>0</td>\n",
-       "      <td>1</td>\n",
-       "      <td>white_collar</td>\n",
-       "      <td>12175.733209</td>\n",
-       "      <td>0</td>\n",
-       "      <td>0</td>\n",
-       "      <td>0</td>\n",
-       "      <td>11</td>\n",
-       "      <td>3</td>\n",
-       "      <td>2</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2</th>\n",
-       "      <td>0</td>\n",
-       "      <td>2</td>\n",
-       "      <td>white_collar</td>\n",
-       "      <td>28774.143565</td>\n",
-       "      <td>0</td>\n",
-       "      <td>0</td>\n",
-       "      <td>1</td>\n",
-       "      <td>11</td>\n",
-       "      <td>3</td>\n",
-       "      <td>2</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>3</th>\n",
-       "      <td>0</td>\n",
-       "      <td>3</td>\n",
-       "      <td>blue_collar</td>\n",
-       "      <td>18002.634757</td>\n",
-       "      <td>0</td>\n",
-       "      <td>0</td>\n",
-       "      <td>2</td>\n",
-       "      <td>11</td>\n",
-       "      <td>3</td>\n",
-       "      <td>2</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>4</th>\n",
-       "      <td>0</td>\n",
-       "      <td>4</td>\n",
-       "      <td>school</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>1</td>\n",
-       "      <td>0</td>\n",
-       "      <td>2</td>\n",
-       "      <td>11</td>\n",
-       "      <td>3</td>\n",
-       "      <td>2</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>5</th>\n",
-       "      <td>0</td>\n",
-       "      <td>5</td>\n",
-       "      <td>white_collar</td>\n",
-       "      <td>39528.738378</td>\n",
-       "      <td>1</td>\n",
-       "      <td>0</td>\n",
-       "      <td>2</td>\n",
-       "      <td>12</td>\n",
-       "      <td>3</td>\n",
-       "      <td>2</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>6</th>\n",
-       "      <td>0</td>\n",
-       "      <td>6</td>\n",
-       "      <td>white_collar</td>\n",
-       "      <td>35261.999311</td>\n",
-       "      <td>1</td>\n",
-       "      <td>0</td>\n",
-       "      <td>3</td>\n",
-       "      <td>12</td>\n",
-       "      <td>3</td>\n",
-       "      <td>2</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>7</th>\n",
-       "      <td>0</td>\n",
-       "      <td>7</td>\n",
-       "      <td>home</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>1</td>\n",
-       "      <td>0</td>\n",
-       "      <td>4</td>\n",
-       "      <td>12</td>\n",
-       "      <td>3</td>\n",
-       "      <td>2</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>8</th>\n",
-       "      <td>0</td>\n",
-       "      <td>8</td>\n",
-       "      <td>white_collar</td>\n",
-       "      <td>24256.351658</td>\n",
-       "      <td>1</td>\n",
-       "      <td>0</td>\n",
-       "      <td>4</td>\n",
-       "      <td>12</td>\n",
-       "      <td>3</td>\n",
-       "      <td>2</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>9</th>\n",
-       "      <td>0</td>\n",
-       "      <td>9</td>\n",
-       "      <td>home</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>1</td>\n",
-       "      <td>0</td>\n",
-       "      <td>5</td>\n",
-       "      <td>12</td>\n",
-       "      <td>3</td>\n",
-       "      <td>2</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>10</th>\n",
-       "      <td>0</td>\n",
-       "      <td>10</td>\n",
-       "      <td>white_collar</td>\n",
-       "      <td>46614.217906</td>\n",
-       "      <td>1</td>\n",
-       "      <td>0</td>\n",
-       "      <td>5</td>\n",
-       "      <td>12</td>\n",
-       "      <td>3</td>\n",
-       "      <td>2</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>11</th>\n",
-       "      <td>1</td>\n",
-       "      <td>0</td>\n",
-       "      <td>school</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>0</td>\n",
-       "      <td>0</td>\n",
-       "      <td>0</td>\n",
-       "      <td>9</td>\n",
-       "      <td>1</td>\n",
-       "      <td>2</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>12</th>\n",
-       "      <td>1</td>\n",
-       "      <td>1</td>\n",
-       "      <td>school</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>0</td>\n",
-       "      <td>0</td>\n",
-       "      <td>0</td>\n",
-       "      <td>10</td>\n",
-       "      <td>1</td>\n",
-       "      <td>2</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>13</th>\n",
-       "      <td>1</td>\n",
-       "      <td>2</td>\n",
-       "      <td>school</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>0</td>\n",
-       "      <td>0</td>\n",
-       "      <td>0</td>\n",
-       "      <td>11</td>\n",
-       "      <td>1</td>\n",
-       "      <td>2</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>14</th>\n",
-       "      <td>1</td>\n",
-       "      <td>3</td>\n",
-       "      <td>white_collar</td>\n",
-       "      <td>10299.312069</td>\n",
-       "      <td>0</td>\n",
-       "      <td>0</td>\n",
-       "      <td>0</td>\n",
-       "      <td>12</td>\n",
-       "      <td>1</td>\n",
-       "      <td>2</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>15</th>\n",
-       "      <td>1</td>\n",
-       "      <td>4</td>\n",
-       "      <td>white_collar</td>\n",
-       "      <td>13755.199980</td>\n",
-       "      <td>0</td>\n",
-       "      <td>0</td>\n",
-       "      <td>1</td>\n",
-       "      <td>12</td>\n",
-       "      <td>1</td>\n",
-       "      <td>2</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>16</th>\n",
-       "      <td>1</td>\n",
-       "      <td>5</td>\n",
-       "      <td>blue_collar</td>\n",
-       "      <td>14896.242901</td>\n",
-       "      <td>0</td>\n",
-       "      <td>0</td>\n",
-       "      <td>2</td>\n",
-       "      <td>12</td>\n",
-       "      <td>1</td>\n",
-       "      <td>2</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>17</th>\n",
-       "      <td>1</td>\n",
-       "      <td>6</td>\n",
-       "      <td>white_collar</td>\n",
-       "      <td>45155.814238</td>\n",
-       "      <td>1</td>\n",
-       "      <td>0</td>\n",
-       "      <td>2</td>\n",
-       "      <td>12</td>\n",
-       "      <td>1</td>\n",
-       "      <td>2</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>18</th>\n",
-       "      <td>1</td>\n",
-       "      <td>7</td>\n",
-       "      <td>white_collar</td>\n",
-       "      <td>36767.647913</td>\n",
-       "      <td>1</td>\n",
-       "      <td>0</td>\n",
-       "      <td>3</td>\n",
-       "      <td>12</td>\n",
-       "      <td>1</td>\n",
-       "      <td>2</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>19</th>\n",
-       "      <td>1</td>\n",
-       "      <td>8</td>\n",
-       "      <td>white_collar</td>\n",
-       "      <td>35646.102128</td>\n",
-       "      <td>1</td>\n",
-       "      <td>0</td>\n",
-       "      <td>4</td>\n",
-       "      <td>12</td>\n",
-       "      <td>1</td>\n",
-       "      <td>2</td>\n",
-       "    </tr>\n",
-       "  </tbody>\n",
-       "</table>\n",
-       "</div>"
-      ],
-      "text/plain": [
-       "    Identifier  Period        Choice          Wage  Experience_Blue_Collar  \\\n",
-       "0            0       0        school           NaN                       0   \n",
-       "1            0       1  white_collar  12175.733209                       0   \n",
-       "2            0       2  white_collar  28774.143565                       0   \n",
-       "3            0       3   blue_collar  18002.634757                       0   \n",
-       "4            0       4        school           NaN                       1   \n",
-       "5            0       5  white_collar  39528.738378                       1   \n",
-       "6            0       6  white_collar  35261.999311                       1   \n",
-       "7            0       7          home           NaN                       1   \n",
-       "8            0       8  white_collar  24256.351658                       1   \n",
-       "9            0       9          home           NaN                       1   \n",
-       "10           0      10  white_collar  46614.217906                       1   \n",
-       "11           1       0        school           NaN                       0   \n",
-       "12           1       1        school           NaN                       0   \n",
-       "13           1       2        school           NaN                       0   \n",
-       "14           1       3  white_collar  10299.312069                       0   \n",
-       "15           1       4  white_collar  13755.199980                       0   \n",
-       "16           1       5   blue_collar  14896.242901                       0   \n",
-       "17           1       6  white_collar  45155.814238                       1   \n",
-       "18           1       7  white_collar  36767.647913                       1   \n",
-       "19           1       8  white_collar  35646.102128                       1   \n",
-       "\n",
-       "    Experience_Military  Experience_White_Collar  Experience_School  Ability  \\\n",
-       "0                     0                        0                 10        3   \n",
-       "1                     0                        0                 11        3   \n",
-       "2                     0                        1                 11        3   \n",
-       "3                     0                        2                 11        3   \n",
-       "4                     0                        2                 11        3   \n",
-       "5                     0                        2                 12        3   \n",
-       "6                     0                        3                 12        3   \n",
-       "7                     0                        4                 12        3   \n",
-       "8                     0                        4                 12        3   \n",
-       "9                     0                        5                 12        3   \n",
-       "10                    0                        5                 12        3   \n",
-       "11                    0                        0                  9        1   \n",
-       "12                    0                        0                 10        1   \n",
-       "13                    0                        0                 11        1   \n",
-       "14                    0                        0                 12        1   \n",
-       "15                    0                        1                 12        1   \n",
-       "16                    0                        2                 12        1   \n",
-       "17                    0                        2                 12        1   \n",
-       "18                    0                        3                 12        1   \n",
-       "19                    0                        4                 12        1   \n",
-       "\n",
-       "    Type  \n",
-       "0      2  \n",
-       "1      2  \n",
-       "2      2  \n",
-       "3      2  \n",
-       "4      2  \n",
-       "5      2  \n",
-       "6      2  \n",
-       "7      2  \n",
-       "8      2  \n",
-       "9      2  \n",
-       "10     2  \n",
-       "11     2  \n",
-       "12     2  \n",
-       "13     2  \n",
-       "14     2  \n",
-       "15     2  \n",
-       "16     2  \n",
-       "17     2  \n",
-       "18     2  \n",
-       "19     2  "
-      ]
-     },
-     "execution_count": 12,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "df.loc[:, :\"Type\"].head(20)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## References\n",
-    "\n",
-    "> Keane, M. P. and  Wolpin, K. I. (1994). [The Solution and Estimation of Discrete Choice Dynamic Programming Models by Simulation and Interpolation: Monte Carlo Evidence](https://doi.org/10.2307/2109768). *Federal Reserve Bank of Minneapolis*, No. 181.\n",
-    ">\n",
-    "> Keane, M. P. and Wolpin, K. I. (1997). [The Career Decisions of Young Men](https://doi.org/10.1086/262080>). *Journal of Political Economy*, 105(3): 473-522."
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.7.3"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 4
-}
diff --git a/docs/getting_started/tutorial-msm.ipynb b/docs/getting_started/tutorial-msm.ipynb
index a87dccebf..f448ac74a 100644
--- a/docs/getting_started/tutorial-msm.ipynb
+++ b/docs/getting_started/tutorial-msm.ipynb
@@ -22,10 +22,7 @@
    "outputs": [],
    "source": [
     "import pandas as pd \n",
-    "import respy as rp\n",
-    "\n",
-    "from respy.method_of_simulated_moments import get_diag_weighting_matrix\n",
-    "from respy.method_of_simulated_moments import get_flat_moments"
+    "import respy as rp"
    ]
   },
   {
@@ -413,7 +410,7 @@
        " 'simulation_agents': 1000,\n",
        " 'simulation_seed': 132,\n",
        " 'solution_draws': 500,\n",
-       " 'solution_seed': 1,\n",
+       " 'solution_seed': 3,\n",
        " 'monte_carlo_sequence': 'random',\n",
        " 'core_state_space_filters': [\"period > 0 and exp_{i} == period and lagged_choice_1 != '{i}'\",\n",
        "  \"period > 0 and exp_a + exp_b + exp_edu == period and lagged_choice_1 == '{j}'\",\n",
@@ -584,48 +581,48 @@
        "  <tbody>\n",
        "    <tr>\n",
        "      <th>0</th>\n",
-       "      <td>0.442</td>\n",
+       "      <td>0.409</td>\n",
        "      <td>0.093</td>\n",
-       "      <td>0.453</td>\n",
-       "      <td>0.012</td>\n",
-       "      <td>16786.328202</td>\n",
-       "      <td>2733.477206</td>\n",
+       "      <td>0.488</td>\n",
+       "      <td>0.010</td>\n",
+       "      <td>16930.457137</td>\n",
+       "      <td>2682.867279</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>1</th>\n",
-       "      <td>0.474</td>\n",
-       "      <td>0.184</td>\n",
-       "      <td>0.293</td>\n",
-       "      <td>0.049</td>\n",
-       "      <td>16176.825079</td>\n",
-       "      <td>3138.869021</td>\n",
+       "      <td>0.435</td>\n",
+       "      <td>0.188</td>\n",
+       "      <td>0.341</td>\n",
+       "      <td>0.036</td>\n",
+       "      <td>16286.178001</td>\n",
+       "      <td>3120.941623</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>2</th>\n",
-       "      <td>0.490</td>\n",
-       "      <td>0.228</td>\n",
-       "      <td>0.244</td>\n",
+       "      <td>0.460</td>\n",
+       "      <td>0.238</td>\n",
+       "      <td>0.264</td>\n",
        "      <td>0.038</td>\n",
-       "      <td>16249.622976</td>\n",
-       "      <td>3267.884944</td>\n",
+       "      <td>16578.402709</td>\n",
+       "      <td>3385.400488</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>3</th>\n",
-       "      <td>0.473</td>\n",
-       "      <td>0.261</td>\n",
-       "      <td>0.227</td>\n",
-       "      <td>0.039</td>\n",
-       "      <td>16800.603663</td>\n",
-       "      <td>3588.776974</td>\n",
+       "      <td>0.445</td>\n",
+       "      <td>0.279</td>\n",
+       "      <td>0.244</td>\n",
+       "      <td>0.032</td>\n",
+       "      <td>16608.887328</td>\n",
+       "      <td>3461.618469</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>4</th>\n",
-       "      <td>0.473</td>\n",
-       "      <td>0.292</td>\n",
-       "      <td>0.197</td>\n",
-       "      <td>0.038</td>\n",
-       "      <td>16797.209380</td>\n",
-       "      <td>3549.389371</td>\n",
+       "      <td>0.423</td>\n",
+       "      <td>0.322</td>\n",
+       "      <td>0.220</td>\n",
+       "      <td>0.035</td>\n",
+       "      <td>16775.353763</td>\n",
+       "      <td>3542.164993</td>\n",
        "    </tr>\n",
        "  </tbody>\n",
        "</table>\n",
@@ -634,11 +631,11 @@
       "text/plain": [
        "            a      b    edu   home          mean          std\n",
        "Period                                                       \n",
-       "0       0.442  0.093  0.453  0.012  16786.328202  2733.477206\n",
-       "1       0.474  0.184  0.293  0.049  16176.825079  3138.869021\n",
-       "2       0.490  0.228  0.244  0.038  16249.622976  3267.884944\n",
-       "3       0.473  0.261  0.227  0.039  16800.603663  3588.776974\n",
-       "4       0.473  0.292  0.197  0.038  16797.209380  3549.389371"
+       "0       0.409  0.093  0.488  0.010  16930.457137  2682.867279\n",
+       "1       0.435  0.188  0.341  0.036  16286.178001  3120.941623\n",
+       "2       0.460  0.238  0.264  0.038  16578.402709  3385.400488\n",
+       "3       0.445  0.279  0.244  0.032  16608.887328  3461.618469\n",
+       "4       0.423  0.322  0.220  0.035  16775.353763  3542.164993"
       ]
      },
      "execution_count": 8,
@@ -678,7 +675,7 @@
    },
    "outputs": [],
    "source": [
-    "weighting_matrix = get_diag_weighting_matrix(empirical_moments)"
+    "weighting_matrix = rp.get_diag_weighting_matrix(empirical_moments)"
    ]
   },
   {
@@ -1068,17 +1065,17 @@
     {
      "data": {
       "text/plain": [
-       "a_0           0.442000\n",
-       "a_1           0.474000\n",
-       "a_2           0.490000\n",
-       "a_3           0.473000\n",
-       "a_4           0.473000\n",
+       "a_0           0.409000\n",
+       "a_1           0.435000\n",
+       "a_2           0.460000\n",
+       "a_3           0.445000\n",
+       "a_4           0.423000\n",
        "              ...     \n",
-       "std_35    13217.343152\n",
-       "std_36    12693.606573\n",
-       "std_37    13016.135077\n",
-       "std_38    13314.644165\n",
-       "std_39    13567.728207\n",
+       "std_35    12756.763553\n",
+       "std_36    12146.297978\n",
+       "std_37    13293.128148\n",
+       "std_38    13236.160871\n",
+       "std_39    13933.439538\n",
        "Length: 240, dtype: float64"
       ]
      },
@@ -1088,7 +1085,7 @@
     }
    ],
    "source": [
-    "flat_empirical_moments = get_flat_moments(empirical_moments)\n",
+    "flat_empirical_moments = rp.get_flat_moments(empirical_moments)\n",
     "flat_empirical_moments"
    ]
   },
@@ -1199,7 +1196,7 @@
     {
      "data": {
       "text/plain": [
-       "3261729527.428732"
+       "3603224859.124363"
       ]
      },
      "execution_count": 14,
@@ -1235,17 +1232,17 @@
     {
      "data": {
       "text/plain": [
-       "a_0          0.174000\n",
-       "a_1          0.200000\n",
-       "a_2          0.207000\n",
-       "a_3          0.144000\n",
-       "a_4          0.137000\n",
+       "a_0          0.130000\n",
+       "a_1          0.152000\n",
+       "a_2          0.151000\n",
+       "a_3          0.136000\n",
+       "a_4          0.095000\n",
        "             ...     \n",
-       "std_35    8710.017774\n",
-       "std_36    7907.238080\n",
-       "std_37    8275.432439\n",
-       "std_38    8738.437200\n",
-       "std_39    8713.130254\n",
+       "std_35    8112.352899\n",
+       "std_36    7292.742834\n",
+       "std_37    8414.066029\n",
+       "std_38    8509.249336\n",
+       "std_39    9398.821013\n",
        "Length: 240, dtype: float64"
       ]
      },
@@ -1364,8 +1361,8 @@
    },
    "outputs": [],
    "source": [
-    "params, options, df_emp = rp.get_example_model(\"kw_94_one\")\n",
-    "empirical_moments = [calc_choice_freq(df_emp), calc_wage_distr(df_emp), calc_final_edu(df_emp)]\n",
+    "params, options, df = rp.get_example_model(\"kw_94_one\")\n",
+    "empirical_moments = [calc_choice_freq(df), calc_wage_distr(df), calc_final_edu(df)]\n",
     "\n",
     "empirical_moments = [fill_nans_zero(df) for df in empirical_moments]"
    ]
@@ -1384,7 +1381,7 @@
    },
    "outputs": [],
    "source": [
-    "weighting_matrix = get_diag_weighting_matrix(empirical_moments)"
+    "weighting_matrix = rp.get_diag_weighting_matrix(empirical_moments)"
    ]
   },
   {
@@ -1455,7 +1452,7 @@
     {
      "data": {
       "text/plain": [
-       "3261729527.8596244"
+       "3603224859.597081"
       ]
      },
      "execution_count": 21,
@@ -1483,16 +1480,16 @@
     {
      "data": {
       "text/plain": [
-       "a_0                  0.174\n",
-       "a_1                  0.200\n",
-       "a_2                  0.207\n",
-       "a_3                  0.144\n",
-       "a_4                  0.137\n",
+       "a_0                  0.130\n",
+       "a_1                  0.152\n",
+       "a_2                  0.151\n",
+       "a_3                  0.136\n",
+       "a_4                  0.095\n",
        "                     ...  \n",
-       "Experience_Edu_16    0.078\n",
-       "Experience_Edu_17    0.052\n",
-       "Experience_Edu_18    0.029\n",
-       "Experience_Edu_19    0.016\n",
+       "Experience_Edu_16    0.075\n",
+       "Experience_Edu_17    0.059\n",
+       "Experience_Edu_18    0.051\n",
+       "Experience_Edu_19    0.020\n",
        "Experience_Edu_20    0.010\n",
        "Length: 251, dtype: float64"
       ]
@@ -1524,7 +1521,7 @@
     "\n",
     "> Keane, M. P. and  Wolpin, K. I. (1994). [The Solution and Estimation of Discrete Choice Dynamic Programming Models by Simulation and Interpolation: Monte Carlo Evidence](https://doi.org/10.2307/2109768). *The Review of Economics and Statistics*, 76(4): 648-672.\n",
     "\n",
-    "> McFadden, D. (1989). [A Method of Simulated Moments for Estimation of Discrete Response Models without Numerical Integration](https://www.jstor.org/stable/1913621?seq=1). *Econometrica: Journal of the Econometric Society*, 995-1026.\n"
+    "> McFadden, D. (1989). [A Method of Simulated Moments for Estimation of Discrete Response Models without Numerical Integration](https://jstor.org/stable/1913621). *Econometrica: Journal of the Econometric Society*, 995-1026.\n"
    ]
   }
  ],
diff --git a/docs/getting_started/tutorial-robinson-crusoe.ipynb b/docs/getting_started/tutorial-robinson-crusoe.ipynb
index 24fd6b623..b4d81c928 100644
--- a/docs/getting_started/tutorial-robinson-crusoe.ipynb
+++ b/docs/getting_started/tutorial-robinson-crusoe.ipynb
@@ -347,415 +347,532 @@
        "  <thead>\n",
        "    <tr style=\"text-align: right;\">\n",
        "      <th></th>\n",
-       "      <th>Identifier</th>\n",
-       "      <th>Period</th>\n",
-       "      <th>Choice</th>\n",
-       "      <th>Wage</th>\n",
+       "      <th></th>\n",
        "      <th>Experience_Fishing</th>\n",
        "      <th>Lagged_Choice_1</th>\n",
-       "      <th>Type</th>\n",
+       "      <th>Shock_Reward_Fishing</th>\n",
+       "      <th>Meas_Error_Wage_Fishing</th>\n",
+       "      <th>Shock_Reward_Hammock</th>\n",
+       "      <th>Meas_Error_Wage_Hammock</th>\n",
+       "      <th>Choice</th>\n",
+       "      <th>Wage</th>\n",
+       "      <th>Discount_Rate</th>\n",
        "      <th>Nonpecuniary_Reward_Fishing</th>\n",
-       "      <th>Nonpecuniary_Reward_Hammock</th>\n",
        "      <th>Wage_Fishing</th>\n",
        "      <th>Flow_Utility_Fishing</th>\n",
-       "      <th>Flow_Utility_Hammock</th>\n",
        "      <th>Value_Function_Fishing</th>\n",
+       "      <th>Continuation_Value_Fishing</th>\n",
+       "      <th>Nonpecuniary_Reward_Hammock</th>\n",
+       "      <th>Wage_Hammock</th>\n",
+       "      <th>Flow_Utility_Hammock</th>\n",
        "      <th>Value_Function_Hammock</th>\n",
-       "      <th>Shock_Reward_Fishing</th>\n",
-       "      <th>Shock_Reward_Hammock</th>\n",
-       "      <th>Discount_Rate</th>\n",
+       "      <th>Continuation_Value_Hammock</th>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Identifier</th>\n",
+       "      <th>Period</th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
        "    </tr>\n",
        "  </thead>\n",
        "  <tbody>\n",
        "    <tr>\n",
+       "      <th rowspan=\"10\" valign=\"top\">0</th>\n",
        "      <th>0</th>\n",
        "      <td>0</td>\n",
-       "      <td>0</td>\n",
-       "      <td>fishing</td>\n",
-       "      <td>2.048628</td>\n",
-       "      <td>0</td>\n",
        "      <td>hammock</td>\n",
-       "      <td>0</td>\n",
-       "      <td>-1.0</td>\n",
-       "      <td>1.5</td>\n",
-       "      <td>1.000000</td>\n",
-       "      <td>1.048628</td>\n",
-       "      <td>2.366250</td>\n",
-       "      <td>19.630892</td>\n",
-       "      <td>19.336065</td>\n",
        "      <td>2.048628</td>\n",
+       "      <td>1</td>\n",
        "      <td>0.866250</td>\n",
+       "      <td>1</td>\n",
+       "      <td>fishing</td>\n",
+       "      <td>2.048628</td>\n",
        "      <td>0.95</td>\n",
+       "      <td>-1</td>\n",
+       "      <td>2.048628</td>\n",
+       "      <td>1.048628</td>\n",
+       "      <td>19.513202</td>\n",
+       "      <td>19.436393</td>\n",
+       "      <td>1.5</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>2.366250</td>\n",
+       "      <td>19.233744</td>\n",
+       "      <td>17.755256</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>1</th>\n",
-       "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>fishing</td>\n",
-       "      <td>2.814534</td>\n",
+       "      <td>0.147087</td>\n",
        "      <td>1</td>\n",
-       "      <td>fishing</td>\n",
-       "      <td>0</td>\n",
-       "      <td>-1.0</td>\n",
-       "      <td>2.5</td>\n",
-       "      <td>1.105171</td>\n",
-       "      <td>1.814534</td>\n",
-       "      <td>2.317108</td>\n",
-       "      <td>19.667179</td>\n",
-       "      <td>18.563510</td>\n",
-       "      <td>2.546696</td>\n",
-       "      <td>-0.182892</td>\n",
+       "      <td>1.421523</td>\n",
+       "      <td>1</td>\n",
+       "      <td>hammock</td>\n",
+       "      <td>NaN</td>\n",
        "      <td>0.95</td>\n",
+       "      <td>-1</td>\n",
+       "      <td>0.162556</td>\n",
+       "      <td>-0.837444</td>\n",
+       "      <td>16.864110</td>\n",
+       "      <td>18.633215</td>\n",
+       "      <td>2.5</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>3.921523</td>\n",
+       "      <td>20.032537</td>\n",
+       "      <td>16.958962</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>2</th>\n",
-       "      <td>0</td>\n",
-       "      <td>2</td>\n",
-       "      <td>fishing</td>\n",
-       "      <td>3.943674</td>\n",
-       "      <td>2</td>\n",
+       "      <td>1</td>\n",
+       "      <td>hammock</td>\n",
+       "      <td>0.903027</td>\n",
+       "      <td>1</td>\n",
+       "      <td>-0.351595</td>\n",
+       "      <td>1</td>\n",
        "      <td>fishing</td>\n",
-       "      <td>0</td>\n",
-       "      <td>-1.0</td>\n",
-       "      <td>2.5</td>\n",
-       "      <td>1.221403</td>\n",
-       "      <td>2.943674</td>\n",
-       "      <td>2.974046</td>\n",
-       "      <td>19.839016</td>\n",
-       "      <td>18.322118</td>\n",
-       "      <td>3.228807</td>\n",
-       "      <td>0.474046</td>\n",
+       "      <td>0.998000</td>\n",
        "      <td>0.95</td>\n",
+       "      <td>-1</td>\n",
+       "      <td>0.998000</td>\n",
+       "      <td>-0.002000</td>\n",
+       "      <td>15.655857</td>\n",
+       "      <td>16.481955</td>\n",
+       "      <td>1.5</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>1.148405</td>\n",
+       "      <td>15.352842</td>\n",
+       "      <td>14.952039</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>3</th>\n",
-       "      <td>0</td>\n",
-       "      <td>3</td>\n",
+       "      <td>2</td>\n",
+       "      <td>fishing</td>\n",
+       "      <td>0.339405</td>\n",
+       "      <td>1</td>\n",
+       "      <td>-0.930422</td>\n",
+       "      <td>1</td>\n",
        "      <td>hammock</td>\n",
        "      <td>NaN</td>\n",
-       "      <td>3</td>\n",
-       "      <td>fishing</td>\n",
-       "      <td>0</td>\n",
-       "      <td>-1.0</td>\n",
-       "      <td>2.5</td>\n",
-       "      <td>1.349859</td>\n",
-       "      <td>1.096816</td>\n",
-       "      <td>2.676218</td>\n",
-       "      <td>16.868733</td>\n",
-       "      <td>16.916543</td>\n",
-       "      <td>1.553359</td>\n",
-       "      <td>0.176218</td>\n",
        "      <td>0.95</td>\n",
+       "      <td>-1</td>\n",
+       "      <td>0.414550</td>\n",
+       "      <td>-0.585450</td>\n",
+       "      <td>13.941609</td>\n",
+       "      <td>15.291641</td>\n",
+       "      <td>2.5</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>1.569578</td>\n",
+       "      <td>14.680286</td>\n",
+       "      <td>13.800745</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>4</th>\n",
-       "      <td>0</td>\n",
-       "      <td>4</td>\n",
-       "      <td>hammock</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>3</td>\n",
+       "      <td>2</td>\n",
        "      <td>hammock</td>\n",
-       "      <td>0</td>\n",
-       "      <td>-1.0</td>\n",
-       "      <td>1.5</td>\n",
-       "      <td>1.349859</td>\n",
-       "      <td>-0.875144</td>\n",
-       "      <td>0.493640</td>\n",
-       "      <td>12.590524</td>\n",
-       "      <td>12.611304</td>\n",
-       "      <td>0.092495</td>\n",
-       "      <td>-1.006360</td>\n",
+       "      <td>2.822820</td>\n",
+       "      <td>1</td>\n",
+       "      <td>-0.420713</td>\n",
+       "      <td>1</td>\n",
+       "      <td>fishing</td>\n",
+       "      <td>3.447800</td>\n",
        "      <td>0.95</td>\n",
+       "      <td>-1</td>\n",
+       "      <td>3.447800</td>\n",
+       "      <td>2.447800</td>\n",
+       "      <td>14.749573</td>\n",
+       "      <td>12.949235</td>\n",
+       "      <td>1.5</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>1.079287</td>\n",
+       "      <td>12.114100</td>\n",
+       "      <td>11.615592</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>5</th>\n",
-       "      <td>0</td>\n",
-       "      <td>5</td>\n",
-       "      <td>hammock</td>\n",
-       "      <td>NaN</td>\n",
        "      <td>3</td>\n",
+       "      <td>fishing</td>\n",
+       "      <td>2.015148</td>\n",
+       "      <td>1</td>\n",
+       "      <td>2.056790</td>\n",
+       "      <td>1</td>\n",
        "      <td>hammock</td>\n",
-       "      <td>0</td>\n",
-       "      <td>-1.0</td>\n",
-       "      <td>1.5</td>\n",
-       "      <td>1.349859</td>\n",
-       "      <td>-0.366008</td>\n",
-       "      <td>1.080653</td>\n",
-       "      <td>10.680733</td>\n",
-       "      <td>10.904368</td>\n",
-       "      <td>0.469673</td>\n",
-       "      <td>-0.419347</td>\n",
+       "      <td>NaN</td>\n",
        "      <td>0.95</td>\n",
+       "      <td>-1</td>\n",
+       "      <td>2.720165</td>\n",
+       "      <td>1.720165</td>\n",
+       "      <td>12.341990</td>\n",
+       "      <td>11.180868</td>\n",
+       "      <td>2.5</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>4.556790</td>\n",
+       "      <td>13.991270</td>\n",
+       "      <td>9.931031</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>6</th>\n",
-       "      <td>0</td>\n",
-       "      <td>6</td>\n",
-       "      <td>fishing</td>\n",
-       "      <td>2.475731</td>\n",
        "      <td>3</td>\n",
        "      <td>hammock</td>\n",
-       "      <td>0</td>\n",
-       "      <td>-1.0</td>\n",
-       "      <td>1.5</td>\n",
-       "      <td>1.349859</td>\n",
-       "      <td>1.475731</td>\n",
-       "      <td>0.501567</td>\n",
-       "      <td>9.867073</td>\n",
-       "      <td>7.852518</td>\n",
-       "      <td>1.834067</td>\n",
-       "      <td>-0.998433</td>\n",
+       "      <td>5.802097</td>\n",
+       "      <td>1</td>\n",
+       "      <td>-0.090973</td>\n",
+       "      <td>1</td>\n",
+       "      <td>fishing</td>\n",
+       "      <td>7.832012</td>\n",
        "      <td>0.95</td>\n",
+       "      <td>-1</td>\n",
+       "      <td>7.832012</td>\n",
+       "      <td>6.832012</td>\n",
+       "      <td>14.963155</td>\n",
+       "      <td>8.559098</td>\n",
+       "      <td>1.5</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>1.409027</td>\n",
+       "      <td>8.503160</td>\n",
+       "      <td>7.467509</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>7</th>\n",
-       "      <td>0</td>\n",
-       "      <td>7</td>\n",
-       "      <td>hammock</td>\n",
-       "      <td>NaN</td>\n",
        "      <td>4</td>\n",
        "      <td>fishing</td>\n",
-       "      <td>0</td>\n",
-       "      <td>-1.0</td>\n",
-       "      <td>2.5</td>\n",
-       "      <td>1.491825</td>\n",
-       "      <td>-0.099928</td>\n",
-       "      <td>2.178192</td>\n",
-       "      <td>6.065739</td>\n",
-       "      <td>7.419904</td>\n",
-       "      <td>0.603336</td>\n",
-       "      <td>-0.321808</td>\n",
+       "      <td>0.429942</td>\n",
+       "      <td>1</td>\n",
+       "      <td>1.443708</td>\n",
+       "      <td>1</td>\n",
+       "      <td>hammock</td>\n",
+       "      <td>NaN</td>\n",
        "      <td>0.95</td>\n",
+       "      <td>-1</td>\n",
+       "      <td>0.641398</td>\n",
+       "      <td>-0.358602</td>\n",
+       "      <td>5.609535</td>\n",
+       "      <td>6.282250</td>\n",
+       "      <td>2.5</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>3.943708</td>\n",
+       "      <td>9.014635</td>\n",
+       "      <td>5.337817</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>8</th>\n",
-       "      <td>0</td>\n",
-       "      <td>8</td>\n",
-       "      <td>hammock</td>\n",
-       "      <td>NaN</td>\n",
        "      <td>4</td>\n",
        "      <td>hammock</td>\n",
-       "      <td>0</td>\n",
-       "      <td>-1.0</td>\n",
-       "      <td>1.5</td>\n",
-       "      <td>1.491825</td>\n",
-       "      <td>0.164102</td>\n",
-       "      <td>1.257459</td>\n",
-       "      <td>3.413636</td>\n",
-       "      <td>3.665488</td>\n",
-       "      <td>0.780321</td>\n",
-       "      <td>-0.242541</td>\n",
+       "      <td>0.216153</td>\n",
+       "      <td>1</td>\n",
+       "      <td>-0.298857</td>\n",
+       "      <td>1</td>\n",
+       "      <td>hammock</td>\n",
+       "      <td>NaN</td>\n",
        "      <td>0.95</td>\n",
+       "      <td>-1</td>\n",
+       "      <td>0.322463</td>\n",
+       "      <td>-0.677537</td>\n",
+       "      <td>2.612370</td>\n",
+       "      <td>3.463061</td>\n",
+       "      <td>1.5</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>1.201143</td>\n",
+       "      <td>3.663504</td>\n",
+       "      <td>2.591958</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>9</th>\n",
-       "      <td>0</td>\n",
-       "      <td>9</td>\n",
-       "      <td>fishing</td>\n",
-       "      <td>10.234951</td>\n",
        "      <td>4</td>\n",
        "      <td>hammock</td>\n",
-       "      <td>0</td>\n",
-       "      <td>-1.0</td>\n",
-       "      <td>1.5</td>\n",
-       "      <td>1.491825</td>\n",
-       "      <td>9.234951</td>\n",
-       "      <td>1.501487</td>\n",
-       "      <td>9.234951</td>\n",
-       "      <td>1.501487</td>\n",
-       "      <td>6.860693</td>\n",
-       "      <td>0.001487</td>\n",
+       "      <td>7.604617</td>\n",
+       "      <td>1</td>\n",
+       "      <td>-0.666748</td>\n",
+       "      <td>1</td>\n",
+       "      <td>fishing</td>\n",
+       "      <td>11.344756</td>\n",
        "      <td>0.95</td>\n",
+       "      <td>-1</td>\n",
+       "      <td>11.344756</td>\n",
+       "      <td>10.344756</td>\n",
+       "      <td>10.344756</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>1.5</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>0.833252</td>\n",
+       "      <td>0.833252</td>\n",
+       "      <td>0.000000</td>\n",
        "    </tr>\n",
        "    <tr>\n",
-       "      <th>10</th>\n",
-       "      <td>1</td>\n",
-       "      <td>0</td>\n",
-       "      <td>hammock</td>\n",
-       "      <td>NaN</td>\n",
+       "      <th rowspan=\"5\" valign=\"top\">1</th>\n",
+       "      <th>0</th>\n",
        "      <td>0</td>\n",
        "      <td>hammock</td>\n",
-       "      <td>0</td>\n",
-       "      <td>-1.0</td>\n",
-       "      <td>1.5</td>\n",
-       "      <td>1.000000</td>\n",
-       "      <td>-0.852913</td>\n",
-       "      <td>2.921523</td>\n",
-       "      <td>17.729351</td>\n",
-       "      <td>19.891338</td>\n",
-       "      <td>0.147087</td>\n",
-       "      <td>1.421523</td>\n",
+       "      <td>1.247475</td>\n",
+       "      <td>1</td>\n",
+       "      <td>-2.189594</td>\n",
+       "      <td>1</td>\n",
+       "      <td>fishing</td>\n",
+       "      <td>1.247475</td>\n",
        "      <td>0.95</td>\n",
+       "      <td>-1</td>\n",
+       "      <td>1.247475</td>\n",
+       "      <td>0.247475</td>\n",
+       "      <td>18.712048</td>\n",
+       "      <td>19.436393</td>\n",
+       "      <td>1.5</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>-0.689594</td>\n",
+       "      <td>16.177899</td>\n",
+       "      <td>17.755256</td>\n",
        "    </tr>\n",
        "    <tr>\n",
-       "      <th>11</th>\n",
-       "      <td>1</td>\n",
+       "      <th>1</th>\n",
        "      <td>1</td>\n",
        "      <td>fishing</td>\n",
-       "      <td>8.465755</td>\n",
-       "      <td>0</td>\n",
+       "      <td>0.802887</td>\n",
+       "      <td>1</td>\n",
+       "      <td>0.931514</td>\n",
+       "      <td>1</td>\n",
        "      <td>hammock</td>\n",
-       "      <td>0</td>\n",
-       "      <td>-1.0</td>\n",
-       "      <td>1.5</td>\n",
-       "      <td>1.000000</td>\n",
-       "      <td>7.465755</td>\n",
-       "      <td>0.400790</td>\n",
-       "      <td>24.238470</td>\n",
-       "      <td>15.680288</td>\n",
-       "      <td>8.465755</td>\n",
-       "      <td>-1.099210</td>\n",
+       "      <td>NaN</td>\n",
        "      <td>0.95</td>\n",
+       "      <td>-1</td>\n",
+       "      <td>0.887327</td>\n",
+       "      <td>-0.112673</td>\n",
+       "      <td>17.588881</td>\n",
+       "      <td>18.633215</td>\n",
+       "      <td>2.5</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>3.431514</td>\n",
+       "      <td>19.542528</td>\n",
+       "      <td>16.958962</td>\n",
        "    </tr>\n",
        "    <tr>\n",
-       "      <th>12</th>\n",
+       "      <th>2</th>\n",
        "      <td>1</td>\n",
-       "      <td>2</td>\n",
        "      <td>hammock</td>\n",
-       "      <td>NaN</td>\n",
+       "      <td>0.213228</td>\n",
        "      <td>1</td>\n",
-       "      <td>fishing</td>\n",
-       "      <td>0</td>\n",
-       "      <td>-1.0</td>\n",
-       "      <td>2.5</td>\n",
-       "      <td>1.105171</td>\n",
-       "      <td>0.024021</td>\n",
-       "      <td>3.110792</td>\n",
-       "      <td>15.853940</td>\n",
-       "      <td>17.503773</td>\n",
-       "      <td>0.926573</td>\n",
-       "      <td>0.610792</td>\n",
+       "      <td>1.803811</td>\n",
+       "      <td>1</td>\n",
+       "      <td>hammock</td>\n",
+       "      <td>NaN</td>\n",
        "      <td>0.95</td>\n",
+       "      <td>-1</td>\n",
+       "      <td>0.235653</td>\n",
+       "      <td>-0.764347</td>\n",
+       "      <td>14.893510</td>\n",
+       "      <td>16.481955</td>\n",
+       "      <td>1.5</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>3.303811</td>\n",
+       "      <td>17.508248</td>\n",
+       "      <td>14.952039</td>\n",
        "    </tr>\n",
        "    <tr>\n",
-       "      <th>13</th>\n",
+       "      <th>3</th>\n",
        "      <td>1</td>\n",
-       "      <td>3</td>\n",
-       "      <td>fishing</td>\n",
-       "      <td>0.592936</td>\n",
+       "      <td>hammock</td>\n",
+       "      <td>1.824770</td>\n",
+       "      <td>1</td>\n",
+       "      <td>0.998793</td>\n",
        "      <td>1</td>\n",
        "      <td>hammock</td>\n",
-       "      <td>0</td>\n",
-       "      <td>-1.0</td>\n",
-       "      <td>1.5</td>\n",
-       "      <td>1.105171</td>\n",
-       "      <td>-0.407064</td>\n",
-       "      <td>0.844335</td>\n",
-       "      <td>13.453224</td>\n",
-       "      <td>13.362810</td>\n",
-       "      <td>0.536511</td>\n",
-       "      <td>-0.655665</td>\n",
+       "      <td>NaN</td>\n",
        "      <td>0.95</td>\n",
+       "      <td>-1</td>\n",
+       "      <td>2.016682</td>\n",
+       "      <td>1.016682</td>\n",
+       "      <td>14.671037</td>\n",
+       "      <td>14.373005</td>\n",
+       "      <td>1.5</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>2.498793</td>\n",
+       "      <td>14.820062</td>\n",
+       "      <td>12.969757</td>\n",
        "    </tr>\n",
        "    <tr>\n",
-       "      <th>14</th>\n",
+       "      <th>4</th>\n",
        "      <td>1</td>\n",
-       "      <td>4</td>\n",
-       "      <td>fishing</td>\n",
-       "      <td>4.140511</td>\n",
-       "      <td>2</td>\n",
-       "      <td>fishing</td>\n",
-       "      <td>0</td>\n",
-       "      <td>-1.0</td>\n",
-       "      <td>2.5</td>\n",
-       "      <td>1.221403</td>\n",
-       "      <td>3.140511</td>\n",
-       "      <td>2.861062</td>\n",
-       "      <td>15.765453</td>\n",
-       "      <td>14.212800</td>\n",
-       "      <td>3.389964</td>\n",
-       "      <td>0.361062</td>\n",
+       "      <td>hammock</td>\n",
+       "      <td>0.602507</td>\n",
+       "      <td>1</td>\n",
+       "      <td>0.905523</td>\n",
+       "      <td>1</td>\n",
+       "      <td>hammock</td>\n",
+       "      <td>NaN</td>\n",
        "      <td>0.95</td>\n",
+       "      <td>-1</td>\n",
+       "      <td>0.665873</td>\n",
+       "      <td>-0.334127</td>\n",
+       "      <td>11.258946</td>\n",
+       "      <td>12.203234</td>\n",
+       "      <td>1.5</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>2.405523</td>\n",
+       "      <td>12.794276</td>\n",
+       "      <td>10.935529</td>\n",
        "    </tr>\n",
        "  </tbody>\n",
        "</table>\n",
        "</div>"
       ],
       "text/plain": [
-       "    Identifier  Period   Choice       Wage  Experience_Fishing  \\\n",
-       "0            0       0  fishing   2.048628                   0   \n",
-       "1            0       1  fishing   2.814534                   1   \n",
-       "2            0       2  fishing   3.943674                   2   \n",
-       "3            0       3  hammock        NaN                   3   \n",
-       "4            0       4  hammock        NaN                   3   \n",
-       "5            0       5  hammock        NaN                   3   \n",
-       "6            0       6  fishing   2.475731                   3   \n",
-       "7            0       7  hammock        NaN                   4   \n",
-       "8            0       8  hammock        NaN                   4   \n",
-       "9            0       9  fishing  10.234951                   4   \n",
-       "10           1       0  hammock        NaN                   0   \n",
-       "11           1       1  fishing   8.465755                   0   \n",
-       "12           1       2  hammock        NaN                   1   \n",
-       "13           1       3  fishing   0.592936                   1   \n",
-       "14           1       4  fishing   4.140511                   2   \n",
+       "                   Experience_Fishing Lagged_Choice_1  Shock_Reward_Fishing  \\\n",
+       "Identifier Period                                                             \n",
+       "0          0                        0         hammock              2.048628   \n",
+       "           1                        1         fishing              0.147087   \n",
+       "           2                        1         hammock              0.903027   \n",
+       "           3                        2         fishing              0.339405   \n",
+       "           4                        2         hammock              2.822820   \n",
+       "           5                        3         fishing              2.015148   \n",
+       "           6                        3         hammock              5.802097   \n",
+       "           7                        4         fishing              0.429942   \n",
+       "           8                        4         hammock              0.216153   \n",
+       "           9                        4         hammock              7.604617   \n",
+       "1          0                        0         hammock              1.247475   \n",
+       "           1                        1         fishing              0.802887   \n",
+       "           2                        1         hammock              0.213228   \n",
+       "           3                        1         hammock              1.824770   \n",
+       "           4                        1         hammock              0.602507   \n",
+       "\n",
+       "                   Meas_Error_Wage_Fishing  Shock_Reward_Hammock  \\\n",
+       "Identifier Period                                                  \n",
+       "0          0                             1              0.866250   \n",
+       "           1                             1              1.421523   \n",
+       "           2                             1             -0.351595   \n",
+       "           3                             1             -0.930422   \n",
+       "           4                             1             -0.420713   \n",
+       "           5                             1              2.056790   \n",
+       "           6                             1             -0.090973   \n",
+       "           7                             1              1.443708   \n",
+       "           8                             1             -0.298857   \n",
+       "           9                             1             -0.666748   \n",
+       "1          0                             1             -2.189594   \n",
+       "           1                             1              0.931514   \n",
+       "           2                             1              1.803811   \n",
+       "           3                             1              0.998793   \n",
+       "           4                             1              0.905523   \n",
+       "\n",
+       "                   Meas_Error_Wage_Hammock   Choice       Wage  Discount_Rate  \\\n",
+       "Identifier Period                                                               \n",
+       "0          0                             1  fishing   2.048628           0.95   \n",
+       "           1                             1  hammock        NaN           0.95   \n",
+       "           2                             1  fishing   0.998000           0.95   \n",
+       "           3                             1  hammock        NaN           0.95   \n",
+       "           4                             1  fishing   3.447800           0.95   \n",
+       "           5                             1  hammock        NaN           0.95   \n",
+       "           6                             1  fishing   7.832012           0.95   \n",
+       "           7                             1  hammock        NaN           0.95   \n",
+       "           8                             1  hammock        NaN           0.95   \n",
+       "           9                             1  fishing  11.344756           0.95   \n",
+       "1          0                             1  fishing   1.247475           0.95   \n",
+       "           1                             1  hammock        NaN           0.95   \n",
+       "           2                             1  hammock        NaN           0.95   \n",
+       "           3                             1  hammock        NaN           0.95   \n",
+       "           4                             1  hammock        NaN           0.95   \n",
+       "\n",
+       "                   Nonpecuniary_Reward_Fishing  Wage_Fishing  \\\n",
+       "Identifier Period                                              \n",
+       "0          0                                -1      2.048628   \n",
+       "           1                                -1      0.162556   \n",
+       "           2                                -1      0.998000   \n",
+       "           3                                -1      0.414550   \n",
+       "           4                                -1      3.447800   \n",
+       "           5                                -1      2.720165   \n",
+       "           6                                -1      7.832012   \n",
+       "           7                                -1      0.641398   \n",
+       "           8                                -1      0.322463   \n",
+       "           9                                -1     11.344756   \n",
+       "1          0                                -1      1.247475   \n",
+       "           1                                -1      0.887327   \n",
+       "           2                                -1      0.235653   \n",
+       "           3                                -1      2.016682   \n",
+       "           4                                -1      0.665873   \n",
        "\n",
-       "   Lagged_Choice_1  Type  Nonpecuniary_Reward_Fishing  \\\n",
-       "0          hammock     0                         -1.0   \n",
-       "1          fishing     0                         -1.0   \n",
-       "2          fishing     0                         -1.0   \n",
-       "3          fishing     0                         -1.0   \n",
-       "4          hammock     0                         -1.0   \n",
-       "5          hammock     0                         -1.0   \n",
-       "6          hammock     0                         -1.0   \n",
-       "7          fishing     0                         -1.0   \n",
-       "8          hammock     0                         -1.0   \n",
-       "9          hammock     0                         -1.0   \n",
-       "10         hammock     0                         -1.0   \n",
-       "11         hammock     0                         -1.0   \n",
-       "12         fishing     0                         -1.0   \n",
-       "13         hammock     0                         -1.0   \n",
-       "14         fishing     0                         -1.0   \n",
+       "                   Flow_Utility_Fishing  Value_Function_Fishing  \\\n",
+       "Identifier Period                                                 \n",
+       "0          0                   1.048628               19.513202   \n",
+       "           1                  -0.837444               16.864110   \n",
+       "           2                  -0.002000               15.655857   \n",
+       "           3                  -0.585450               13.941609   \n",
+       "           4                   2.447800               14.749573   \n",
+       "           5                   1.720165               12.341990   \n",
+       "           6                   6.832012               14.963155   \n",
+       "           7                  -0.358602                5.609535   \n",
+       "           8                  -0.677537                2.612370   \n",
+       "           9                  10.344756               10.344756   \n",
+       "1          0                   0.247475               18.712048   \n",
+       "           1                  -0.112673               17.588881   \n",
+       "           2                  -0.764347               14.893510   \n",
+       "           3                   1.016682               14.671037   \n",
+       "           4                  -0.334127               11.258946   \n",
        "\n",
-       "    Nonpecuniary_Reward_Hammock  Wage_Fishing  Flow_Utility_Fishing  \\\n",
-       "0                           1.5      1.000000              1.048628   \n",
-       "1                           2.5      1.105171              1.814534   \n",
-       "2                           2.5      1.221403              2.943674   \n",
-       "3                           2.5      1.349859              1.096816   \n",
-       "4                           1.5      1.349859             -0.875144   \n",
-       "5                           1.5      1.349859             -0.366008   \n",
-       "6                           1.5      1.349859              1.475731   \n",
-       "7                           2.5      1.491825             -0.099928   \n",
-       "8                           1.5      1.491825              0.164102   \n",
-       "9                           1.5      1.491825              9.234951   \n",
-       "10                          1.5      1.000000             -0.852913   \n",
-       "11                          1.5      1.000000              7.465755   \n",
-       "12                          2.5      1.105171              0.024021   \n",
-       "13                          1.5      1.105171             -0.407064   \n",
-       "14                          2.5      1.221403              3.140511   \n",
+       "                   Continuation_Value_Fishing  Nonpecuniary_Reward_Hammock  \\\n",
+       "Identifier Period                                                            \n",
+       "0          0                        19.436393                          1.5   \n",
+       "           1                        18.633215                          2.5   \n",
+       "           2                        16.481955                          1.5   \n",
+       "           3                        15.291641                          2.5   \n",
+       "           4                        12.949235                          1.5   \n",
+       "           5                        11.180868                          2.5   \n",
+       "           6                         8.559098                          1.5   \n",
+       "           7                         6.282250                          2.5   \n",
+       "           8                         3.463061                          1.5   \n",
+       "           9                         0.000000                          1.5   \n",
+       "1          0                        19.436393                          1.5   \n",
+       "           1                        18.633215                          2.5   \n",
+       "           2                        16.481955                          1.5   \n",
+       "           3                        14.373005                          1.5   \n",
+       "           4                        12.203234                          1.5   \n",
        "\n",
-       "    Flow_Utility_Hammock  Value_Function_Fishing  Value_Function_Hammock  \\\n",
-       "0               2.366250               19.630892               19.336065   \n",
-       "1               2.317108               19.667179               18.563510   \n",
-       "2               2.974046               19.839016               18.322118   \n",
-       "3               2.676218               16.868733               16.916543   \n",
-       "4               0.493640               12.590524               12.611304   \n",
-       "5               1.080653               10.680733               10.904368   \n",
-       "6               0.501567                9.867073                7.852518   \n",
-       "7               2.178192                6.065739                7.419904   \n",
-       "8               1.257459                3.413636                3.665488   \n",
-       "9               1.501487                9.234951                1.501487   \n",
-       "10              2.921523               17.729351               19.891338   \n",
-       "11              0.400790               24.238470               15.680288   \n",
-       "12              3.110792               15.853940               17.503773   \n",
-       "13              0.844335               13.453224               13.362810   \n",
-       "14              2.861062               15.765453               14.212800   \n",
+       "                   Wage_Hammock  Flow_Utility_Hammock  Value_Function_Hammock  \\\n",
+       "Identifier Period                                                               \n",
+       "0          0                NaN              2.366250               19.233744   \n",
+       "           1                NaN              3.921523               20.032537   \n",
+       "           2                NaN              1.148405               15.352842   \n",
+       "           3                NaN              1.569578               14.680286   \n",
+       "           4                NaN              1.079287               12.114100   \n",
+       "           5                NaN              4.556790               13.991270   \n",
+       "           6                NaN              1.409027                8.503160   \n",
+       "           7                NaN              3.943708                9.014635   \n",
+       "           8                NaN              1.201143                3.663504   \n",
+       "           9                NaN              0.833252                0.833252   \n",
+       "1          0                NaN             -0.689594               16.177899   \n",
+       "           1                NaN              3.431514               19.542528   \n",
+       "           2                NaN              3.303811               17.508248   \n",
+       "           3                NaN              2.498793               14.820062   \n",
+       "           4                NaN              2.405523               12.794276   \n",
        "\n",
-       "    Shock_Reward_Fishing  Shock_Reward_Hammock  Discount_Rate  \n",
-       "0               2.048628              0.866250           0.95  \n",
-       "1               2.546696             -0.182892           0.95  \n",
-       "2               3.228807              0.474046           0.95  \n",
-       "3               1.553359              0.176218           0.95  \n",
-       "4               0.092495             -1.006360           0.95  \n",
-       "5               0.469673             -0.419347           0.95  \n",
-       "6               1.834067             -0.998433           0.95  \n",
-       "7               0.603336             -0.321808           0.95  \n",
-       "8               0.780321             -0.242541           0.95  \n",
-       "9               6.860693              0.001487           0.95  \n",
-       "10              0.147087              1.421523           0.95  \n",
-       "11              8.465755             -1.099210           0.95  \n",
-       "12              0.926573              0.610792           0.95  \n",
-       "13              0.536511             -0.655665           0.95  \n",
-       "14              3.389964              0.361062           0.95  "
+       "                   Continuation_Value_Hammock  \n",
+       "Identifier Period                              \n",
+       "0          0                        17.755256  \n",
+       "           1                        16.958962  \n",
+       "           2                        14.952039  \n",
+       "           3                        13.800745  \n",
+       "           4                        11.615592  \n",
+       "           5                         9.931031  \n",
+       "           6                         7.467509  \n",
+       "           7                         5.337817  \n",
+       "           8                         2.591958  \n",
+       "           9                         0.000000  \n",
+       "1          0                        17.755256  \n",
+       "           1                        16.958962  \n",
+       "           2                        14.952039  \n",
+       "           3                        12.969757  \n",
+       "           4                        10.935529  "
       ]
      },
      "execution_count": 7,
@@ -781,7 +898,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAaQAAAERCAYAAAA0S9PzAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8li6FKAAAXeklEQVR4nO3debycV33f8c/XlvEiWcaLEDEgxGJTMI2dohQKddiXFAhO3VBiYQwNcV52SAuBUpIXrteGpSwNYJy4wTZgMEsxYGwgLMaJnVBAhJpWISgYJONFtrwgS8ILVn7943kE4+ure+daczVHo8/79ZqX7jxz5pnfnbma7zxnznNOqgpJksZtj3EXIEkSGEiSpEYYSJKkJhhIkqQmGEiSpCYsGHcBAIccckgtX7583GVIkubZt7/97Vuqasl0tzURSMuXL2fVqlXjLkOSNM+SrNvebXbZSZKaYCBJkppgIEmSmmAgSZKaYCBJkpowVCAleU2SVUnuTnLBLG1fl2R9ko1Jzkuy90gqlSRNtGGPkG4AzgLOm6lRkucDbwKeDSwHHg2cvgP1SZJ2E0MFUlVdXFWfAW6dpekJwAeqanVV3Q6cCbxyx0qUJO0ORn1i7BHAZweuXw0sTXJwVd0nzJKcCJwIsGzZsuH2ftoBo6kS4LSNI9yXdc1tX9Y1t31Z19z2ZV1z21c7dY16UMMiYLCibT/vP7VhVZ1bVSuqasWSJdPOIiFJ2o2MOpA2A4sHrm/7edOIH0eSNGFGHUirgSMHrh8J3DS1u06SpKmGHfa9IMk+wJ7Ankn2STLd908fAn4nyROSHAi8GbhgZNVKkibWsEdIbwbupBvS/fL+5zcnWZZkc5JlAFX1ReDtwNeAdf3l1JFXLUmaOEONsquq04DTtnPzoilt3wW8a4eqkiTtdpw6SJLUBANJktQEA0mS1AQDSZLUBANJktQEA0mS1AQDSZLUBANJktQEA0mS1AQDSZLUBANJktQEA0mS1AQDSZLUBANJktQEA0mS1AQDSZLUBANJktQEA0mS1AQDSZLUBANJktQEA0mS1AQDSZLUBANJktQEA0mS1AQDSZLUBANJktQEA0mS1AQDSZLUBANJktQEA0mS1IShAinJQUk+nWRLknVJjttOuyQ5K8n1STYmuSLJEaMtWZI0iYY9QjobuAdYCqwEztlO0PwW8B+Ao4GDgK8DHx5BnZKkCTdrICVZCBwLnFJVm6vqKuAS4Phpmj8KuKqqflhVW4ELgSeMsmBJ0mQa5gjpcGBrVa0Z2HY1MN0R0seAxyY5PMlewAnAF6fbaZITk6xKsmrDhg1zrVuSNGEWDNFmEbBxyraNwP7TtL0RuBL4PrAV+DHwrOl2WlXnAucCrFixooasV5I0oYY5QtoMLJ6ybTGwaZq2pwK/CjwC2Ac4Hbg8yX47UqQkafINE0hrgAVJDhvYdiSwepq2RwIfr6rrqureqroAOBC/R5IkzWLWQKqqLcDFwBlJFiZ5GvASph899y3gt5IsTbJHkuOBvYAfjLJoSdLkGeY7JICTgfOAm4FbgZOqanWSZcDfA0+oqmuBtwEPAf4PsJAuiI6tqp+MvHJJ0kQZKpCq6jbgmGm2X0s36GHb9buA3+8vkiQNzamDJElNMJAkSU0wkCRJTTCQJElNMJAkSU0wkCRJTTCQJElNMJAkSU0wkCRJTTCQJElNMJAkSU0wkCRJTTCQJElNMJAkSU0wkCRJTTCQJElNMJAkSU0wkCRJTTCQJElNMJAkSU0wkCRJTTCQJElNMJAkSU0wkCRJTTCQJElNMJAkSU0wkCRJTTCQJElNMJAkSU0YKpCSHJTk00m2JFmX5LgZ2j46yaVJNiW5JcnbR1euJGlSDXuEdDZwD7AUWAmck+SIqY2SPAj4MnA58FDg4cCFoylVkjTJZg2kJAuBY4FTqmpzVV0FXAIcP03zVwI3VNW7qmpLVd1VVd8dacWSpIk0zBHS4cDWqlozsO1q4H5HSMBTgLVJvtB3112R5J+PolBJ0mQbJpAWARunbNsI7D9N24cDLwPeAxwKXAZ8tu/Ku48kJyZZlWTVhg0b5la1JGniDBNIm4HFU7YtBjZN0/ZO4Kqq+kJV3QO8AzgYePzUhlV1blWtqKoVS5YsmWPZkqRJM0wgrQEWJDlsYNuRwOpp2n4XqFEUJknavcwaSFW1BbgYOCPJwiRPA14CfHia5hcCT0nynCR7Aq8FbgG+N8KaJUkTaNhh3ycD+wI3AxcBJ1XV6iTLkmxOsgygqr4PvBz4M+B2uuD6jb77TpKk7VowTKOqug04Zprt19INehjcdjHdEZUkSUNz6iBJUhMMJElSEwwkSVITDCRJUhOGGtTQiuV3fXRk+1o7sj1JkkbBIyRJUhMMJElSEwwkSVITDCRJUhMMJElSEwwkSVITDCRJUhMMJElSEwwkSVITDCRJUhMMJElSEwwkSVITDCRJUhMMJElSEwwkSVITdqn1kDQZXNdK0nQMpAnmG7+kXYlddpKkJhhIkqQm2GUnNc6uV+0uDCSp5xu/NF522UmSmmAgSZKaYJedpAfELk6NmkdIkqQmDHWElOQg4APA84BbgD+qqhk/HiW5HHgmsFdV3bujhbbMT4qSZuP7xOyG7bI7G7gHWAocBVyW5OqqWj1d4yQr57BvSRoZ3/h3XbN22SVZCBwLnFJVm6vqKuAS4PjttD8AOBV44ygLlSRNtmG+Qzoc2FpVawa2XQ0csZ32fwKcA6yfaadJTkyyKsmqDRs2DFWsJGlyDRNIi4CNU7ZtBPaf2jDJCuBpwHtn22lVnVtVK6pqxZIlS4apVZI0wYYJpM3A4inbFgObBjck2QN4P/CfJn0QgyRp9IYJpDXAgiSHDWw7Epg6oGExsAL4eJL1wLf67dclOXqHK5UkTbRZR8JV1ZYkFwNnJHk13Si7lwBPndJ0I3DowPVHAN8EngT4JZEkaUbDnhh7MrAvcDNwEXBSVa1OsizJ5iTLqrN+24VfhNBNVXXPPNQuSZogQ50rVFW3AcdMs/1aukEP091nLZAdKU6StPtw6iBJUhMMJElSEwwkSVITDCRJUhMMJElSEwwkSVITDCRJUhMMJElSEwwkSVITDCRJUhMMJElSEwwkSVITDCRJUhMMJElSE4ZafkKSNJmW3/XRke1r7Q7e3yMkSVITDCRJUhMMJElSEwwkSVITDCRJUhMMJElSEwwkSVITDCRJUhMMJElSEwwkSVITDCRJUhMMJElSEwwkSVITDCRJUhMMJElSE4YKpCQHJfl0ki1J1iU5bjvtTkjy7SR3JLkuyduTuOaSJGlWwx4hnQ3cAywFVgLnJDlimnb7Aa8FDgGeDDwbeMMI6pQkTbhZj16SLASOBZ5YVZuBq5JcAhwPvGmwbVWdM3D1+iQfAZ45wnolSRNqmCOkw4GtVbVmYNvVwHRHSFP9GrB6uhuSnJhkVZJVGzZsGGJXkqRJNkwgLQI2Ttm2Edh/pjsleRWwAnjHdLdX1blVtaKqVixZsmSYWiVJE2yYAQebgcVTti0GNm3vDkmOAd4KPKeqbnng5UmSdhfDHCGtARYkOWxg25FsvyvuBcD/BF5cVf93x0uUJO0OZg2kqtoCXAyckWRhkqcBLwE+PLVtkmcBHwGOrapvjrpYSdLkGnbY98nAvsDNwEXASVW1OsmyJJuTLOvbnQIcAHy+3745yRdGX7YkadIMddJqVd0GHDPN9mvpBj1su+4Qb0nSA+LUQZKkJhhIkqQmGEiSpCYYSJKkJhhIkqQmGEiSpCYYSJKkJhhIkqQmGEiSpCYYSJKkJhhIkqQmGEiSpCYYSJKkJhhIkqQmGEiSpCYYSJKkJhhIkqQmGEiSpCYYSJKkJhhIkqQmGEiSpCYYSJKkJhhIkqQmGEiSpCYYSJKkJhhIkqQmGEiSpCYYSJKkJhhIkqQmDBVISQ5K8ukkW5KsS3LcDG1fl2R9ko1Jzkuy9+jKlSRNqmGPkM4G7gGWAiuBc5IcMbVRkucDbwKeDSwHHg2cPpJKJUkTbdZASrIQOBY4pao2V9VVwCXA8dM0PwH4QFWtrqrbgTOBV46wXknShBrmCOlwYGtVrRnYdjVwvyOkftvVU9otTXLwAy9RkrQ7SFXN3CA5GvhkVT10YNvvAiur6hlT2l4D/H5VfbG/vhddV9+jqmrtlLYnAif2Vx8HfH+HfpNfOAS4ZUT7GiXrmhvrmhvrmhvrmptR1vXIqloy3Q0LhrjzZmDxlG2LgU1DtN328/3aVtW5wLlDPP6cJFlVVStGvd8dZV1zY11zY11zY11zs7PqGqbLbg2wIMlhA9uOBFZP03Z1f9tgu5uq6tYHXqIkaXcwayBV1RbgYuCMJAuTPA14CfDhaZp/CPidJE9IciDwZuCCEdYrSZpQww77PhnYF7gZuAg4qapWJ1mWZHOSZQD9d0dvB74GrOsvp46+7BmNvBtwRKxrbqxrbqxrbqxrbnZKXbMOapAkaWdw6iBJUhMMJElSEyYmkOYy397OlOQ1SVYluTvJBeOuByDJ3kk+0D9Pm5J8J8mvj7sugCQXJrkxyR1J1iR59bhrGpTksCR3Jblw3LUAJLmir2dzfxnV+Xw7LMnLknyv/z95TX9O4zjr2TzlsjXJe8dZ0zZJlif5fJLb+7lA35dkmNNy5ruuxye5vJ+b9AdJfnM+H29iAokh59sbgxuAs4Dzxl3IgAXAj4GnAwcApwCfSLJ8jDVt8xZgeVUtBn4DOCvJk8Zc06CzgW+Nu4gpXlNVi/rL48ZdDECS5wJvA14F7A/8GvDDcdY08BwtonufuBP45DhrGvB+ukFjvwQcRfd/8+RxFtQH4meBS4GD6CYyuDDJ4fP1mBMRSHOcb2+nqqqLq+ozQDPnYlXVlqo6rarWVtU/VdWlwI+Asb/x9/Mg3r3tan95zBhL+rkkLwN+Anx13LXsAk4Hzqiq/93/jV1fVdePu6gB/44uAK4cdyG9RwGfqKq7qmo98EWmn55tZ/pnwKHAu6tqa1VdDvwN8/i+OhGBxNzm29MUSZbSPYfTney80yV5f5KfAv8A3Ah8fswlkWQxcAbw+nHXMo23JLklyd8keca4i0myJ7ACWNJ381zXd0HtO+7aBpwAfKjaGWb8p8DLkuyX5GHAr9OF0jhlO9ueOF8POCmBtAjYOGXbRrquAs2gn2/wI8AHq+ofxl0PQFWdTPfaHU13UvbdM99jpziTbib7H4+7kCn+C90yLw+jO1fkc0nGfUS5FNiL7ijkaLouqF+hO1F+7PrzJp8OfHDctQz4K7oP0HcA1wGrgM+MtaLuA+HNwH9OsleS59E9b/vN1wNOSiDNZb499ZLsQTfjxj3Aa8Zczn30XQRXAQ8HThpnLUmOAp4DvHucdUynqr5RVZuq6u6q+iBdl8q/GXNZd/b/vreqbqyqW4B3Mf66tnkFcFVV/WjchcDP/x/+Jd2Hr4V0E5keSPcd3NhU1c+AY4AXAuvpegc+QReY82JSAmku8+0JSBLgA3SfZo/t//hatIDxf4f0DLoFJ69Nsh54A3Bskr8bZ1HbUUzf1bLzCujWQruur6VFr6Cto6ODgEcA7+s/WNwKnE8DAV5V362qp1fVwVX1fLqj8W/O1+NNRCDNcb69nSrJgiT7AHsCeybZp4XhnMA5wOOBF1fVnbM13hmSPKQfKrwoyZ79CsS/DVw+5tLOpQvFo/rLnwGXAc8fZ1FJHpzk+dv+ppKspBvN9pfjrKt3PvAH/Wt6IPBautFaY5XkqXTdm62MrqM/gvwRcFL/Oj6Y7juuq2e+5/xL8sv939d+Sd5ANwrwgvl6vIkIpN608+2NtySg6ze/k25p95f3P4+1Lz3JI4Hfo3tzXT9wXsbKcdZF94n6JLpP17cD7wBeW1WfHWtRVT+tqvXbLnRdxHdV1YZx1kX3Pc1ZwAa6tWr+ADimqlo4F+lMuuHxa4DvAd8B/ttYK+qcAFxcVa115/9b4AV0r+UPgHuB1421os7xdAOLbgaeDTx3YBTsyDmXnSSpCZN0hCRJ2oUZSJKkJhhIkqQmGEiSpCYYSJKkJhhIkqQmGEjSmCRZmeRLD/C+p7WyJpM0KgaSNEdJ1ia5sz+Z+KYk5ydZNNf9VNVHqup581GjtCsykKQH5sX9Qm//AvhV5jj7RiPTR0lNMZCkHdAvOvcF4IlJDuiXhr8xyfVJzurXBiLJK/v1it6d5DbgtH7bVdv2leSpSb7VLxf9rX7etW23PSrJX6Vbcv7LdDNCSxPFQJJ2QJJH0M3K/B26GaTvBR5Lt/7P84BXDzR/Mt0y3g9hyrxuSQ6im7D1PcDBdMs1XJbk4L7JR4Fv0wXRmXRzskkTxW4D6YH5TJJ76RaCvAz4C7qJRB/cz56+Jcm7gROBP+/vc0NVvbf/+d5uBZCfeyHwj1W1bYb6i5L8R+DFSS6n6xZ8Tj+x5V8n+dx8/nLSOBhI0gNzTFV9ZduVJP+SbvbtGweCZg9gcIXZmVabPRRYN2XbOrqlEg4Fbu+XWRm87REPrHSpTQaSNBo/pltq/ZCqunc7bWaaWv8G4JFTti0Dvkg3/f+BSRYOhNKyWfYn7XL8Dkkagaq6EfgS8M4ki5PskeQxSZ4+5C4+Dxye5Lh+kbZ/DzwBuLSq1gGrgNOTPCjJvwZePC+/iDRGBpI0Oq8AHgT8Pd0Cg/+LboXNWfXLVr8IeD1wK/BG4EX9aqIAx9ENirgNOBX40EgrlxrgAn1qRpLHAR+jG6W2EDi1qs6c5T5rgVcPfp8zcNvRwF9U1ePmodyJNNPzuatJchrw2Kp6+bhr0XD8Dmk3t/xNl83rJ5K1b31hZm/1c28ErqiqXxnFY1fVlcCuEUanHTC/nwxP2ziX10EaC7vs1JJHAqvHXYSk8TCQ1IT+XJtnAu/r54j7aJKz+tsOSXJpkp8kuS3JlUkG/3aPSvLdfoaDjyfZp7/fM5JcN/AYa5O8Ybq2/e1v7GdZuCHJq5NUksfupKegJfd7PpMc2L8GG5Lc3v/88G13SHJFPzPF3/av3+eSHJzkI0nu6GeeWD7QvpKcnOQf+9knzuwHgXy9b/+JJA8aaP+7SX7Qv/6XJDl04LYjkny5v+2mJH889RdKsleSi5J8anC/aouBpCZU1bOAK4HX9HPE3TNw8+uB64AlwFLgj7nvkOeXAi8AHgX8MvDKGR5q2rZJXgD8IfAcuu+whh0dN4mme472AM6nO4pdBtwJvG/K/V4GHE937tRjgK/39zkI+B7dYIxBLwCeBDyFrrv2XGAl3flVTwR+GyDJs4C39HX9Et05WB/rb9sf+Ard8PhD6V67rw4+SJJ9gc/QDct/aVUN/m2pIQaSdgU/o3sjemRV/ayqrqz7jsZ5T1XdUFW3AZ8DjpphX9tr+1Lg/KpaXVU/BU6fh99jV3G/56iqbq2qT1XVT6tqE93UR1ND+/yquqaqNtLN73dNVX2lPy/rk3TTKQ16W1XdUVWrgf8HfKmqfjhw/23tVwLnVdXf9TNV/BHwr/ojrhcB66vqnVV1V1VtqqpvDDzGYrqwugZ4VVVtHcUTpPlhIGlX8N+BHwBfSvLDJG+acvv6gZ9/Csy0FMT22h7K8LMqTLr7PUdJ9kvy50nWJbkD+Gvgweknj+3dNPDzndNcn/q6DNv+PrNYVNVmuqHxD6M7mrpmht/lKXRHeW+d8iFGDTKQ1Lz+U+/rq+rRdCeE/mGSZ4/4YW4EHj5w3Wl57uv1dCMWn1xVi4Ff67fvjNF795nFIslCuglor6f74PCYGe77Jbruvq8mWTqfRWrHGUhqXpIXJXlsukni7gC29pdR+gTwqiSPT7If8F9HvP9d3f50Ry0/6Wcmn/p90Hz6KN1rc1SSvYE/Ab5RVWuBS4GHJnltkr2T7J/kyYN3rqq39/v4ahKX7WiY5yHt5uZ4ntC4HEb3BfoSuhkQ3l9VV4zyAarqC0neA3wN+Ce6JR6Op/sifP61f57Q/6B7U7+F7ojlncAxO+OBq+qrSU4BPgUcCPwt3QAKqmpTkucCf0oXknf3tX5jyj7O7MPsK0me1X8/psY4U4M0jSSPp/uife8ZJkuVNEJ22Um9JL/ZT156IPA24HOGkbTzGEjSL/wesIFu1NZW4KTxliPtXuyykyQ1wSMkSVITDCRJUhMMJElSEwwkSVITDCRJUhMMJElSEwwkSVITDCRJUhMMJElSEwwkSVIT/j9Mu6xbRKh2hQAAAABJRU5ErkJggg==\n",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -822,7 +939,7 @@
     {
      "data": {
       "text/plain": [
-       "<matplotlib.axes._subplots.AxesSubplot at 0x126eae538d0>"
+       "<matplotlib.axes._subplots.AxesSubplot at 0x15e55947988>"
       ]
      },
      "execution_count": 9,
@@ -831,7 +948,7 @@
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 432x288 with 2 Axes>"
       ]
@@ -896,7 +1013,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -1167,7 +1284,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAaQAAAERCAYAAAA0S9PzAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8li6FKAAAZTUlEQVR4nO3de/xcdX3n8dcbghcCQS6RFiUGFaygha7p6mqp90vXG122VkEEW0sL1a1W67pdWRHYellv9YZlKxcvqLiioqhVQaxYV426QCM1ggJyCYSLIQk3jZ/945zoMP6SzI/ML/PN5PV8POaR35zznTOfnJnf7z3nO9/zPakqJEmatO0mXYAkSWAgSZIaYSBJkppgIEmSmmAgSZKaMG/SBQDssccetXjx4kmXIUmaY9/5zndurKqFM61rIpAWL17M0qVLJ12GJGmOJblyQ+vsspMkNcFAkiQ1wUCSJDXBQJIkNcFAkiQ1YaRASvLSJEuT3Jnk9E20fUWSFUlWJTk1yb3HUqkkaaqNeoR0LXAScOrGGiV5OvAa4MnAYuDBwOs3oz5J0jZipECqqrOr6lPATZtoeiTw/qpaVlW3ACcCR21eiZKkbcG4T4w9APj0wP2LgD2T7F5VdwuzJEcDRwMsWrRotK0fv8t4qgQ4ftUYt2Vds9uWdc1uW9Y1u21Z1+y21U5d4x7UsBMwWNH6n3ceblhVp1TVkqpasnDhjLNISJK2IeMOpDXAgoH7639ePebnkSRNmXEH0jLgwIH7BwLXD3fXSZI0bNRh3/OS3AfYHtg+yX2SzPT90weAP02yf5JdgdcCp4+tWknS1Br1COm1wO10Q7pf2P/82iSLkqxJsgigqr4AvBn4CnBlf3vd2KuWJE2dkUbZVdXxwPEbWL3TUNu3AW/brKokSdscpw6SJDXBQJIkNcFAkiQ1wUCSJDXBQJIkNcFAkiQ1wUCSJDXBQJIkNcFAkiQ1wUCSJDXBQJIkNcFAkiQ1wUCSJDXBQJIkNcFAkiQ1wUCSJDXBQJIkNcFAkiQ1wUCSJDXBQJIkNcFAkiQ1wUCSJDXBQJIkNcFAkiQ1wUCSJDXBQJIkNcFAkiQ1wUCSJDXBQJIkNcFAkiQ1YaRASrJbkk8mWZvkyiSHbaBdkpyU5Jokq5JckOSA8ZYsSZpGox4hvQe4C9gTOBw4eQNB80fAnwAHA7sB3wA+OIY6JUlTbpOBlGQ+cChwXFWtqaoLgXOAI2Zovg9wYVX9qKrWAR8C9h9nwZKk6TTKEdJ+wLqqWj6w7CJgpiOkjwIPTbJfkh2AI4EvzLTRJEcnWZpk6cqVK2dbtyRpyswboc1OwKqhZauAnWdoex3wNeAHwDrgJ8CTZtpoVZ0CnAKwZMmSGrFeSdKUGuUIaQ2wYGjZAmD1DG1fB/wusDdwH+D1wPlJdtycIiVJ02+UI6TlwLwk+1bVD/tlBwLLZmh7IPCxqrq6v396knfQfY+0dLOr1aw8cp9FY9vWJWPbkiTNbJNHSFW1FjgbOCHJ/CSPA57LzKPnvg38UZI9k2yX5AhgB+CycRYtSZo+oxwhARwLnArcANwEHFNVy5IsAr4P7F9VVwFvAu4P/D9gPl0QHVpVPx175ZKkqTJSIFXVzcAhMyy/im7Qw/r7dwB/2d+kGdmVKGkmTh0kSWqCgSRJaoKBJElqgoEkSWqCgSRJaoKBJElqgoEkSWqCgSRJaoKBJElqgoEkSWqCgSRJaoKBJElqwqizfTdh8R1njm1bV4xtS5KkcfAISZLUBANJktQEA0mS1AQDSZLUBANJktQEA0mS1AQDSZLUhK3qPCRpLj1yn0Vj29YlY9uStO3wCEmS1AQDSZLUBANJktQEA0mS1AQDSZLUBANJktQEA0mS1AQDSZLUhJECKcluST6ZZG2SK5MctpG2D07y2SSrk9yY5M3jK1eSNK1GnanhPcBdwJ7AQcC5SS6qqmWDjZLcC/hS3/6PgXXAfuMrV9r2OIOEthWbPEJKMh84FDiuqtZU1YXAOcARMzQ/Cri2qt5WVWur6o6qunisFUuSptIoXXb7AeuqavnAsouAA2Zo+xjgiiSf77vrLkjyyHEUKkmabqN02e0ErBpatgrYeYa2DwSeCDwHOA/4K+DTSX6rqu4abJjkaOBogEWLxtclMQmL7zhzbNu6YmxbkqStyyhHSGuABUPLFgCrZ2h7O3BhVX2+D6C3ALsDDx9uWFWnVNWSqlqycOHCWZYtSZo2owTScmBekn0Hlh0ILJuh7cVAjaMwSdK2ZZOBVFVrgbOBE5LMT/I44LnAB2do/iHgMUmekmR74OXAjcClY6xZkjSFRh32fSxwKnADcBNwTFUtS7II+D6wf1VdVVU/SPJC4H3A/YHvAs8Z/v5I0tbP4egat5ECqapuBg6ZYflVdIMeBpedTXdEJUlbnEG59fIS5lLjVl/6xkmXsFVxf229nMtOktQEA0mS1AS77CTdI3aNadw8QpIkNcFAkiQ1wS47bXF29UiaiYEk9QxKabLsspMkNcFAkiQ1wUCSJDXBQJIkNcFAkiQ1wUCSJDXBYd+StAUsvuPMsW3rirFtqS0eIUmSmmAgSZKaYCBJkppgIEmSmmAgSZKaYCBJkppgIEmSmmAgSZKaYCBJkppgIEmSmmAgSZKaYCBJkppgIEmSmmAgSZKaYCBJkpowUiAl2S3JJ5OsTXJlksNGeMz5SSqJ11ySJG3SqGHxHuAuYE/gIODcJBdV1bKZGic5fBbbliRNSEsXDtzkEVKS+cChwHFVtaaqLgTOAY7YQPtdgNcBr97M2iRJ25BRuuz2A9ZV1fKBZRcBB2yg/d8BJwMrNrbRJEcnWZpk6cqVK0cqVpI0vUYJpJ2AVUPLVgE7DzdMsgR4HPCuTW20qk6pqiVVtWThwoWj1CpJmmKjBNIaYMHQsgXA6sEFSbYD3gv8VVX9fDzlSZK2FaME0nJgXpJ9B5YdCAwPaFgALAE+lmQF8O1++dVJDt7sSiVJU22TI+Gqam2Ss4ETkryEbpTdc4HHDjVdBew1cH9v4FvAowC/JJIkbdSoJ8YeC9wXuAH4CHBMVS1LsijJmiSLqrNi/Y1fhdD1VXXXHNQuSZoiI50rVFU3A4fMsPwqukEPMz3mCiCbU5wkadvh1EGSpCYYSJKkJhhIkqQmON/cFFt96RsnXYIkjcwjJElSEwwkSVITDCRJUhMMJElSEwwkSVITDCRJUhMMJElSEwwkSVITDCRJUhMMJElSEwwkSVITDCRJUhMMJElSEwwkSVITDCRJUhMMJElSEwwkSVITDCRJUhMMJElSEwwkSVITDCRJUhMMJElSEwwkSVITDCRJUhMMJElSEwwkSVITRgqkJLsl+WSStUmuTHLYBtodmeQ7SW5NcnWSNyeZN96SJUnTaNQjpPcAdwF7AocDJyc5YIZ2OwIvB/YAHg08GXjVGOqUJE25TR69JJkPHAo8oqrWABcmOQc4AnjNYNuqOnng7jVJPgw8cYz1SpKm1ChHSPsB66pq+cCyi4CZjpCG/T6wbKYVSY5OsjTJ0pUrV46wKUnSNBslkHYCVg0tWwXsvLEHJXkxsAR4y0zrq+qUqlpSVUsWLlw4Sq2SpCk2yoCDNcCCoWULgNUbekCSQ4A3Ak+pqhvveXmSpG3FKEdIy4F5SfYdWHYgG+6Kewbwv4FnV9Ulm1+iJGlbsMlAqqq1wNnACUnmJ3kc8Fzgg8NtkzwJ+DBwaFV9a9zFSpKm16jDvo8F7gvcAHwEOKaqliVZlGRNkkV9u+OAXYDP9cvXJPn8+MuWJE2bkU5araqbgUNmWH4V3aCH9fcd4i1JukecOkiS1AQDSZLUBANJktQEA0mS1AQDSZLUBANJktQEA0mS1AQDSZLUBANJktQEA0mS1AQDSZLUBANJktQEA0mS1AQDSZLUBANJktQEA0mS1AQDSZLUBANJktQEA0mS1AQDSZLUBANJktQEA0mS1AQDSZLUBANJktQEA0mS1AQDSZLUBANJktQEA0mS1AQDSZLUhJECKcluST6ZZG2SK5MctpG2r0iyIsmqJKcmuff4ypUkTatRj5DeA9wF7AkcDpyc5IDhRkmeDrwGeDKwGHgw8PqxVCpJmmqbDKQk84FDgeOqak1VXQicAxwxQ/MjgfdX1bKqugU4EThqjPVKkqbUKEdI+wHrqmr5wLKLgF87QuqXXTTUbs8ku9/zEiVJ24JU1cYbJAcDH6+q3xhY9mfA4VX1hKG2lwN/WVVf6O/vQNfVt09VXTHU9mjg6P7uw4AfbNb/5Ff2AG4c07bGybpmx7pmx7pmx7pmZ5x1PaiqFs60Yt4ID14DLBhatgBYPULb9T//WtuqOgU4ZYTnn5UkS6tqybi3u7msa3asa3asa3asa3a2VF2jdNktB+Yl2Xdg2YHAshnaLuvXDba7vqpuuuclSpK2BZsMpKpaC5wNnJBkfpLHAc8FPjhD8w8Af5pk/yS7Aq8FTh9jvZKkKTXqsO9jgfsCNwAfAY6pqmVJFiVZk2QRQP/d0ZuBrwBX9rfXjb/sjRp7N+CYWNfsWNfsWNfsWNfsbJG6NjmoQZKkLcGpgyRJTTCQJElNmJpAms18e1tSkpcmWZrkziSnT7oegCT3TvL+fj+tTvK9JH8w6boAknwoyXVJbk2yPMlLJl3ToCT7JrkjyYcmXQtAkgv6etb0t3Gdz7fZkjw/yaX97+Tl/TmNk6xnzdBtXZJ3TbKm9ZIsTvK5JLf0c4G+O8kop+XMdV0PT3J+PzfpZUn+cC6fb2oCiRHn25uAa4GTgFMnXciAecBPgMcDuwDHAWclWTzBmtZ7A7C4qhYAzwFOSvKoCdc06D3AtyddxJCXVtVO/e1hky4GIMlTgTcBLwZ2Bn4f+NEkaxrYRzvR/Z24Hfj4JGsa8F66QWO/CRxE97t57CQL6gPx08Bngd3oJjL4UJL95uo5pyKQZjnf3hZVVWdX1aeAZs7Fqqq1VXV8VV1RVb+oqs8CPwYm/oe/nwfxzvV3+9tDJljSLyV5PvBT4LxJ17IVeD1wQlX93/49dk1VXTPpogb8Z7oA+NqkC+ntA5xVVXdU1QrgC8w8PduW9FvAXsDbq2pdVZ0PfJ05/Ls6FYHE7Obb05Ake9Ltw5lOdt7ikrw3yW3AvwHXAZ+bcEkkWQCcALxy0rXM4A1Jbkzy9SRPmHQxSbYHlgAL+26eq/suqPtOurYBRwIfqHaGGf898PwkOyZ5APAHdKE0SdnAskfM1RNOSyDtBKwaWraKrqtAG9HPN/hh4Iyq+rdJ1wNQVcfSvXYH052UfefGH7FFnEg3k/1PJl3IkP9Kd5mXB9CdK/KZJJM+otwT2IHuKORgui6o36E7UX7i+vMmHw+cMelaBnyV7gP0rcDVwFLgUxOtqPtAeAPwN0l2SPI0uv2241w94bQE0mzm21MvyXZ0M27cBbx0wuXcTd9FcCHwQOCYSdaS5CDgKcDbJ1nHTKrqm1W1uqrurKoz6LpU/uOEy7q9//ddVXVdVd0IvI3J17Xei4ALq+rHky4Efvl7+E90H77m001kuivdd3ATU1U/Aw4BngmsoOsdOIsuMOfEtATSbObbE5AkwPvpPs0e2r/5WjSPyX+H9AS6C05elWQF8Crg0CTfnWRRG1DM3NWy5QroroV2dV9Li15EW0dHuwF7A+/uP1jcBJxGAwFeVRdX1eOraveqejrd0fi35ur5piKQZjnf3haVZF6S+wDbA9snuU8LwzmBk4GHA8+uqts31XhLSHL/fqjwTkm2769A/ALg/AmXdgpdKB7U394HnAs8fZJFJblfkqevf08lOZxuNNs/TbKu3mnAy/rXdFfg5XSjtSYqyWPpujdbGV1HfwT5Y+CY/nW8H913XBdt/JFzL8lv9++vHZO8im4U4Olz9XxTEUi9Gefbm2xJQNdvfjvdpd1f2P880b70JA8C/pzuj+uKgfMyDp9kXXSfqI+h+3R9C/AW4OVV9emJFlV1W1WtWH+j6yK+o6pWTrIuuu9pTgJW0l2r5mXAIVXVwrlIJ9INj18OXAp8D/ifE62ocyRwdlW11p3/n4Bn0L2WlwE/B14x0Yo6R9ANLLoBeDLw1IFRsGPnXHaSpCZM0xGSJGkrZiBJkppgIEmSmmAgSZKaYCBJkppgIEmSmmAgSROS5PAkX7yHjz2+lWsySeNiIEmzlOSKJLf3JxNfn+S0JDvNdjtV9eGqetpc1ChtjQwk6Z55dn+ht38H/C6znH2jkemjpKYYSNJm6C8693ngEUl26S8Nf12Sa5Kc1F8biCRH9dcrenuSm4Hj+2UXrt9Wkscm+XZ/uehv9/OurV+3T5Kvprvk/JfoZoSWpoqBJG2GJHvTzcr8PboZpH8OPJTu+j9PA14y0PzRdJfxvj9D87ol2Y1uwtZ3ArvTXa7h3CS7903OBL5DF0Qn0s3JJk0Vuw2ke+ZTSX5OdyHIc4F/pJtI9H797Olrk7wdOBr4h/4x11bVu/qff95dAeSXngn8sKrWz1D/kST/BXh2kvPpugWf0k9s+c9JPjOX/zlpEgwk6Z45pKq+vP5Okn9PN/v2dQNBsx0weIXZjV1tdi/gyqFlV9JdKmEv4Jb+MiuD6/a+Z6VLbTKQpPH4Cd2l1veoqp9voM3Gpta/FnjQ0LJFwBfopv/fNcn8gVBatIntSVsdv0OSxqCqrgO+CLw1yYIk2yV5SJLHj7iJzwH7JTmsv0jbHwP7A5+tqiuBpcDrk9wrye8Bz56T/4g0QQaSND4vAu4FfJ/uAoP/h+4Km5vUX7b6WcArgZuAVwPP6q8mCnAY3aCIm4HXAR8Ya+VSA7xA35RJ8jDgo3QjveYDr6uqEzfxmCuAlwx+JzKw7mDgH6vqYXNQ7tQaeh3+e1W9c2j9+4BrNvTaJClg36q6bM6LnRIbex9vbZIcDzy0ql446Vq2JL9DGpPFrzl3TpP9ijc+M5tuBXSfrC+oqt8Zx/NW1deArSKMHnnGI+f0NbjkyEtGfQ1gE69DVf3FeKqasON3mdtPtMevms0+11bOLrvp8yBg2aSL0IZfh/Uny0q6OwNpivTnqzwReHc/z9qZSU7q1+2R5LNJfprk5iRfSzL4+h+U5OJ+loCPJblP/7gnJLl64DmuSPKqmdr261/dz1RwbZKXJKkkD91Cu6AJG3gdTk7yuSRrgScmOX39a9M/5m8G9tufDG3vmUm+l+TWJD/pu3PWrzs3ycuG2l+c5JC5/V8269fex0l27d/7K5Pc0v/8wPUPSHJBP6vGv/Sv12eS7J7kw/0+/3aSxQPtK8mxSX7Yz5xxYj+A5Rt9+7OS3Gug/Z8luaz/vTsnyV4D6w5I8qV+3fVJ/nb4P5RkhyQfSfKJwe1OIwNpilTVk4CvAS/t51m7a2D1K4GrgYXAnsDfcvdhw88DngHsA/w2cNRGnmrGtkmeAfw18BS6705GHWE2VTbwOhxGNzvDzsCFg+37/fYq4KnAvnT7b9BaugET96M7gfaYgcA5A/jl9wxJDqQ7d+lz4/1fbTVmem9uB5xGd9S6CLgdePfQ454PHEG37x4CfKN/zG7ApXQDSQY9A3gU8Bi67tlTgMPpzg17BPACgCRPAt7Q1/WbdOePfbRftzPwZbqh/XvR/c6cN/gkSe4LfIrulILnVdXg7/TUMZC2HT+j+4V4UFX9rKq+Vncf0fLOqrq2qm4GPgMctJFtbajt84DTqmpZVd0GvH4O/h9bq09X1der6hdVdcfQuvX77V/784yOH1xZVRdU1SX9Yy8GPsKvwv7TwL5J9u3vHwF8bNr/cG3Er703q+qmqvpEVd1WVavpPhgMf1g6raour6pVdHMTXl5VX+7PKfs43VRQg95UVbdW1TLgX4EvVtWPBh6/vv3hwKlV9d1+lo3/BvyH/ojrWcCKqnprVd1RVaur6psDz7GALqwuB15cVevGsYNaZiBtO/4XcBnwxSQ/SvKaofUrBn6+DdjY5RQ21HYvRp+ZYFuzqVkaBtffbcaGJI9O8pW+y2kV8Bf0k6v2f+TOAl7Yd8G+APgg265fe28m2THJPyS5MsmtwD8D9xv6Lu/6gZ9vn+H+8O/DqO3vNgNHVa2hG9b/ALqjqcs38n95DN1R3huHPjxOLQNpG9F/+nplVT2Y7qTKv07y5DE/zXXAAwfuO7XNr2zsD8p13H1fLRpafyZwDrB3Ve0CvA8YHH12Bt0n8ScDt1XVNza/3KnySrqRoo+uqgXA7/fLt8QIvrvNwJFkPt3kudfQfQh5yEYe+0W67r7zkuw5l0W2wkDaRiR5VpKHJglwK7Cuv43TWcCLkzw8yY7A/xjz9qfVWcBRSfbv99vw9xU7AzdX1R3p5sw7bHBlH0C/AN7Ktn10tCE70x21/DTdrOrD+3cunUn3O3FQknsDfwd8s6quAD4L/EaSlye5d5Kdkzx68MFV9eZ+G+clmfpLjnge0pjM4jyhSdmX7ovchXSzCLy3qi4Y5xNU1eeTvBP4Ct0fyBPpvtO4c5zPsyGzPE+oGf1+ewdwPt1+ey3dEc96x9JNSfRu4Kt0AXa/oc18gG5/b9nRdVvHeULvoPujfiPdEctb2UL7qarOS3Ic8AlgV+Bf6AZQUFWrkzwV+Hu6kLyzr/WbQ9s4sQ+zLyd5Uv/92FRypgbNmSQPp/vC994bmXBUY5DkRcDRVfV7k65FuqfsstNYJfnDdBOA7gq8CfiMYTS3+m6+Y+mGHktbLQNJ4/bnwEq60UPrgGMmW850S/J0uv19PV23lLTVsstOktQEj5AkSU0wkCRJTTCQJElNMJAkSU0wkCRJTTCQJElNMJAkSU0wkCRJTTCQJElNMJAkSU34/1wiVnhwjQEiAAAAAElFTkSuQmCC\n",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -1228,7 +1345,7 @@
     "crit_func = rp.get_crit_func(params, options, df)\n",
     "crit_func(params)\n",
     "\n",
-    "constr = rp.get_parameter_constraints(\"robinson\")"
+    "constr = rp.get_parameter_constraints(\"robinson_crusoe\")"
    ]
   },
   {
@@ -1287,7 +1404,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.7.3"
+   "version": "3.7.6"
   }
  },
  "nbformat": 4,
diff --git a/docs/index.rst b/docs/index.rst
index e9019178d..0ed3579c8 100644
--- a/docs/index.rst
+++ b/docs/index.rst
@@ -15,7 +15,7 @@ baseline model presented in:
     Evidence <https://doi.org/10.2307/2109768>`_. *The Review of Economics and
     Statistics*, 76(4): 648-672.
 
-.. image:: https://img.shields.io/github/license/mashape/apistatus.svg?maxAge=2592000
+.. image:: https://img.shields.io/badge/License-MIT-yellow.svg
 
 .. toctree::
     :maxdepth: 1
diff --git a/docs/software/reliability.rst b/docs/software/reliability.rst
index ab2c65bc4..f7ed0ef9d 100644
--- a/docs/software/reliability.rst
+++ b/docs/software/reliability.rst
@@ -53,8 +53,8 @@ implementation always remain. So, if you are struggling with a particularly poor
 performance in your application, please do not hesitate to let us know so we can help
 with the investigation.
 
-For more details, see the script `online <https://github.com/OpenSourceEconomics/
-respy/tree/master/development/documentation/reliability>`_. The results for all the
+For more details, see the script `online <https://github.com/OpenSourceEconomics/respy/
+tree/v1.2.1/development/documentation/reliability>`_. The results for all the
 parameterizations analyzed in Keane and Wolpin (1994) are available `here
-<https://github.com/OpenSourceEconomics/respy/blob/master/docs/results/reliability
-.respy.info>`_.
+<https://github.com/OpenSourceEconomics/respy/blob/v1.2.1/docs/results/
+reliability.respy.info>`_.
diff --git a/environment.yml b/environment.yml
index a7cf8eb41..224d54e94 100644
--- a/environment.yml
+++ b/environment.yml
@@ -6,7 +6,6 @@ dependencies:
   - python=3.7
   - pip
   - anaconda-client
-  - bump2version
   - chaospy
   - click
   - codecov
@@ -14,6 +13,7 @@ dependencies:
   - conda-verify
   - doc8
   - estimagic>=0.0.14
+  - joblib
   - jupyterlab
   - line_profiler
   - matplotlib
@@ -37,4 +37,5 @@ dependencies:
   - tox-conda
   - pip:
     - apprise
+    - bump2version
     - pytest-randomly
diff --git a/meta.yaml b/meta.yaml
index 025abbd3f..c17597d41 100644
--- a/meta.yaml
+++ b/meta.yaml
@@ -20,6 +20,7 @@ requirements:
     - chaospy
     - click
     - estimagic>=0.0.12
+    - joblib
     - mkl
     - numba>=0.42
     - numpy
diff --git a/respy/__init__.py b/respy/__init__.py
index 2e8165634..d7cbacf22 100755
--- a/respy/__init__.py
+++ b/respy/__init__.py
@@ -21,7 +21,7 @@
 from respy.method_of_simulated_moments import get_flat_moments  # noqa: F401
 from respy.method_of_simulated_moments import get_msm_func  # noqa: F401
 from respy.simulate import get_simulate_func  # noqa: F401
-from respy.solve import solve  # noqa: F401
+from respy.solve import get_solve_func  # noqa: F401
 from respy.tests.random_model import add_noise_to_params  # noqa: F401
 
 # We only maintain the code base for Python >= 3.6.
diff --git a/respy/config.py b/respy/config.py
index 0e0ccee00..b250e926d 100644
--- a/respy/config.py
+++ b/respy/config.py
@@ -34,19 +34,16 @@
 # Some assert functions take rtol instead of decimals
 TOL_REGRESSION_TESTS = 1e-10
 
-# Interpolation
+# Penalty for states which cannot be reached.
 INADMISSIBILITY_PENALTY = -400_000
 
 SEED_STARTUP_ITERATION_GAP = 100
 
-IS_DEBUG = False
-
 DEFAULT_OPTIONS = {
     "estimation_draws": 200,
     "estimation_seed": 1,
     "estimation_tau": 500,
     "interpolation_points": -1,
-    "n_periods": 40,
     "simulation_agents": 1000,
     "simulation_seed": 2,
     "solution_draws": 200,
diff --git a/respy/interpolate.py b/respy/interpolate.py
new file mode 100644
index 000000000..4b0cfd851
--- /dev/null
+++ b/respy/interpolate.py
@@ -0,0 +1,330 @@
+"""This module contains the code for approximate solutions to the DCDP."""
+import warnings
+
+import numba as nb
+import numpy as np
+
+from respy.config import MAX_LOG_FLOAT
+from respy.parallelization import parallelize_across_dense_dimensions
+from respy.shared import calculate_expected_value_functions
+from respy.shared import calculate_value_functions_and_flow_utilities
+
+
+@parallelize_across_dense_dimensions
+def interpolate(
+    wages,
+    nonpecs,
+    continuation_values,
+    is_inadmissible,
+    period_draws_emax_risk,
+    interpolation_points,
+    optim_paras,
+    options,
+):
+    """Interface to switch between different interpolation routines."""
+    period_expected_value_functions = _kw_94_interpolation(
+        wages,
+        nonpecs,
+        continuation_values,
+        is_inadmissible,
+        period_draws_emax_risk,
+        interpolation_points,
+        optim_paras,
+        options,
+    )
+
+    return period_expected_value_functions
+
+
+def _kw_94_interpolation(
+    wages,
+    nonpecs,
+    continuation_values,
+    is_inadmissible,
+    period_draws_emax_risk,
+    interpolation_points,
+    optim_paras,
+    options,
+):
+    r"""Calculate the approximate solution proposed by [1]_.
+
+    The authors propose an interpolation method to alleviate the computation burden of
+    the full solution. The full solution calculates the expected value function with
+    Monte-Carlo simulation for each state in the state space for a pre-defined number of
+    points. Both, the number of states and points, have a huge impact on runtime.
+
+    [1]_ propose an interpolation method to alleviate the computation burden. The
+    general idea is to calculate the expected value function with Monte-Carlo simulation
+    only for a much smaller number of states and predict the remaining expected value
+    functions with a linear model. The linear model is
+
+    .. math::
+
+        EVF = MaxeVF + \sum^{n-1}_{i=0} MaxeVF - eVF_i
+                     + \sum^{n-1}_{i=0} \sqrt{MaxeVF - eVF_i}
+
+    where :math:`EVF` are the expected value functions generated by the Monte-Carlo
+    simulation, :math:`eVF_i` are the value functions generated with the expected value
+    of the shocks, and :math:`MaxeVF` is their maximum over all :math:`i`.
+
+    The expected value of the shocks is zero for non-working alternatives. For working
+    alternatives, the shocks are log normally distributed and cannot be set to zero, but
+    :math:`E(X) = \exp\{\mu + \frac{\sigma^2}{2}\}` where :math:`\mu = 0`.
+
+    After experimenting with various functions for :math:`g()`, the authors include
+    simple differences and the square root of the simple differences in the equation.
+
+    The function consists of the following steps.
+
+    1. Create an indicator for whether the expected value function of the state is
+       calculated with Monte-Carlo simulation or interpolation.
+
+    2. Compute the expected value of the shocks.
+
+    3. Compute the right-hand side variables of the linear model.
+
+    4. Compute the left-hand side variables of the linear model by Monte-Carlo
+       simulation on subset of states.
+
+    5. Fit the linear model with ordinary least squares on the subset without
+       interpolation and predict the expected value functions for all other states.
+
+    References
+    ----------
+    .. [1] Keane, M. P. and  Wolpin, K. I. (1994). `The Solution and Estimation of
+           Discrete Choice Dynamic Programming Models by Simulation and Interpolation:
+           Monte Carlo Evidence <https://doi.org/10.2307/2109768>`_. *The Review of
+           Economics and Statistics*, 76(4): 648-672.
+
+    """
+    n_wages = len(optim_paras["choices_w_wage"])
+    n_core_states_in_period = wages.shape[0]
+
+    not_interpolated = _get_not_interpolated_indicator(
+        interpolation_points,
+        n_core_states_in_period,
+        next(options["solution_seed_iteration"]),
+    )
+
+    # Create an array with the expected value of the shocks.
+    expected_shocks = np.zeros(len(optim_paras["choices"]))
+    var = np.diag(optim_paras["shocks_cholesky"].dot(optim_paras["shocks_cholesky"].T))
+    expected_shocks[:n_wages] = np.exp(np.clip(var[:n_wages], 0, MAX_LOG_FLOAT) / 2)
+
+    exogenous, max_emax = _compute_rhs_variables(
+        wages,
+        nonpecs,
+        continuation_values,
+        expected_shocks,
+        optim_paras["delta"],
+        is_inadmissible,
+    )
+
+    endogenous = _compute_lhs_variable(
+        wages,
+        nonpecs,
+        continuation_values,
+        max_emax,
+        not_interpolated,
+        period_draws_emax_risk,
+        optim_paras["delta"],
+        is_inadmissible,
+    )
+
+    # Create prediction model based on the random subset of points where the EMAX is
+    # actually simulated and thus dependent and independent variables are available. For
+    # the interpolation points, the actual values are used.
+    period_expected_value_functions = _predict_with_linear_model(
+        endogenous, exogenous, max_emax, not_interpolated
+    )
+
+    return period_expected_value_functions
+
+
+def _get_not_interpolated_indicator(interpolation_points, n_states, seed):
+    """Get indicator for states which will be not interpolated.
+
+    Parameters
+    ----------
+    interpolation_points : int
+        Number of states which will be interpolated.
+    n_states : int
+        Total number of states in period.
+    seed : int
+        Seed to set randomness.
+
+    Returns
+    -------
+    not_interpolated : numpy.ndarray
+        Array of shape (n_states,) indicating states which will not be interpolated.
+
+    """
+    np.random.seed(seed)
+
+    indices = np.random.choice(n_states, size=interpolation_points, replace=False)
+    not_interpolated = np.zeros(n_states, dtype="bool")
+    not_interpolated[indices] = True
+
+    return not_interpolated
+
+
+def _compute_rhs_variables(wages, nonpec, emaxs, draws, delta, is_inadmissible):
+    """Compute right-hand side variables of the linear model.
+
+    Constructing the exogenous variable for all states, including the ones where
+    simulation will take place. All information will be used in either the construction
+    of the prediction model or the prediction step.
+
+    Parameters
+    ----------
+    wages : numpy.ndarray
+        Array with shape (n_states_in_period, n_choices).
+    nonpec : numpy.ndarray
+        Array with shape (n_states_in_period, n_choices).
+    emaxs : numpy.ndarray
+        Array with shape (n_states_in_period, n_choices).
+    draws : numpy.ndarray
+        Array with shape (n_choices,).
+    delta : float
+        Discount factor.
+    is_inadmissible : numpy.ndarray
+        Array with shape (n_states_in_period, n_choices) containing an indicator for
+        whether the state in the next period is not admissible.
+
+    Returns
+    -------
+    exogenous : numpy.ndarray
+        Array with shape (n_states_in_period, n_choices * 2 + 1) where the last column
+        contains the constant.
+    max_value_functions : numpy.ndarray
+        Array with shape (n_states_in_period,) containing maximum over all value
+        functions computed with the expected value of shocks.
+
+    """
+    value_functions, _ = calculate_value_functions_and_flow_utilities(
+        wages, nonpec, emaxs, draws, delta, is_inadmissible
+    )
+
+    max_value_functions = value_functions.max(axis=1)
+    exogenous = max_value_functions.reshape(-1, 1) - value_functions
+
+    exogenous = np.column_stack(
+        (exogenous, np.sqrt(exogenous), np.ones(exogenous.shape[0]))
+    )
+
+    return exogenous, max_value_functions
+
+
+def _compute_lhs_variable(
+    wages,
+    nonpec,
+    continuation_values,
+    max_value_functions,
+    not_interpolated,
+    draws,
+    delta,
+    is_inadmissible,
+):
+    """Calculate left-hand side variable for all states which are not interpolated.
+
+    The function computes the full solution for a subset of states. Then, the dependent
+    variable is the expected value function minus the maximum of value function with the
+    expected shocks.
+
+    Parameters
+    ----------
+    wages : numpy.ndarray
+        Array with shape (n_states_in_period, n_choices).
+    nonpec : numpy.ndarray
+        Array with shape (n_states_in_period, n_choices).
+    continuation_values : numpy.ndarray
+        Array with shape (n_states_in_period, n_choices).
+    max_value_functions : numpy.ndarray
+        Array with shape (n_states_in_period,) containing maximum over all value
+        functions computed with the expected value of shocks.
+    not_interpolated : numpy.ndarray
+        Array with shape (n_states_in_period,) containing indicators for simulated
+        continuation_values.
+    draws : numpy.ndarray
+        Array with shape (n_draws, n_choices) containing draws.
+    delta : float
+        Discount factor.
+    is_inadmissible : numpy.ndarray
+        Array with shape (n_states_in_period, n_choices) containing an indicator for
+        whether the state in the next period is not admissible.
+
+    """
+    expected_value_functions = calculate_expected_value_functions(
+        wages[not_interpolated],
+        nonpec[not_interpolated],
+        continuation_values[not_interpolated],
+        draws,
+        delta,
+        is_inadmissible[not_interpolated],
+    )
+    endogenous = expected_value_functions - max_value_functions[not_interpolated]
+
+    return endogenous
+
+
+def _predict_with_linear_model(
+    endogenous, exogenous, max_value_functions, not_interpolated
+):
+    """Predict the expected value function for interpolated states with a linear model.
+
+    The linear model is fitted with ordinary least squares. Then, predict the expected
+    value function for all interpolated states and use the compute expected value
+    functions for the remaining states.
+
+    Parameters
+    ----------
+    endogenous : numpy.ndarray
+        Array with shape (num_simulated_states_in_period,) containing the expected value
+        functions minus the maximufor states used to interpolate the rest.
+    exogenous : numpy.ndarray
+        Array with shape (n_states_in_period, n_choices * 2 + 1) containing exogenous
+        variables.
+    max_value_functions : numpy.ndarray
+        Array with shape (n_states_in_period,) containing maximum over all value
+        functions computed with the expected value of shocks.
+    not_interpolated : numpy.ndarray
+        Array with shape (n_states_in_period,) containing indicator for states which
+        are not interpolated and used to estimate the coefficients for the
+        interpolation.
+
+    """
+    beta = ols(endogenous, exogenous[not_interpolated])
+
+    endogenous_predicted = exogenous.dot(beta)
+    endogenous_predicted = np.clip(endogenous_predicted, 0, None)
+
+    predictions = endogenous_predicted + max_value_functions
+    predictions[not_interpolated] = endogenous + max_value_functions[not_interpolated]
+
+    if not np.all(np.isfinite(beta)):
+        warnings.warn("OLS coefficients in the interpolation are not finite.")
+
+    return predictions
+
+
+@nb.njit
+def ols(y, x):
+    """Calculate the coefficients of a linear model with OLS using a pseudo-inverse.
+
+    Parameters
+    ----------
+    x : numpy.ndarray
+        Array with shape (n_observations, n_independent_variables) containing the
+        independent variables.
+    y : numpy.ndarray
+        Array with shape (n_observations,) containing the dependent variable.
+
+    Returns
+    -------
+    beta : numpy.ndarray
+        Array with shape (n_independent_variables,) containing the coefficients of the
+        linear model.
+
+    """
+    beta = np.dot(np.linalg.pinv(x.T.dot(x)), x.T.dot(y))
+    return beta
diff --git a/respy/likelihood.py b/respy/likelihood.py
index 599227ad6..397a3ab15 100644
--- a/respy/likelihood.py
+++ b/respy/likelihood.py
@@ -8,20 +8,25 @@
 from scipy import special
 
 from respy.conditional_draws import create_draws_and_log_prob_wages
+from respy.config import INDEXER_INVALID_INDEX
 from respy.config import MAX_FLOAT
 from respy.config import MIN_FLOAT
+from respy.parallelization import distribute_and_combine_likelihood
+from respy.parallelization import parallelize_across_dense_dimensions
 from respy.pre_processing.data_checking import check_estimation_data
 from respy.pre_processing.model_processing import process_params_and_options
+from respy.pre_processing.process_covariates import identify_necessary_covariates
 from respy.shared import aggregate_keane_wolpin_utility
+from respy.shared import cast_bool_to_numeric
+from respy.shared import compute_covariates
 from respy.shared import convert_labeled_variables_to_codes
-from respy.shared import create_base_covariates
 from respy.shared import create_base_draws
 from respy.shared import create_core_state_space_columns
+from respy.shared import create_dense_state_space_columns
 from respy.shared import downcast_to_smallest_dtype
 from respy.shared import generate_column_dtype_dict_for_estimation
 from respy.shared import rename_labels_to_internal
-from respy.solve import solve_with_backward_induction
-from respy.state_space import StateSpace
+from respy.solve import get_solve_func
 
 
 def get_crit_func(
@@ -66,7 +71,8 @@ def get_crit_func(
 
     check_estimation_data(df, optim_paras)
 
-    state_space = StateSpace(optim_paras, options)
+    solve = get_solve_func(params, options)
+    state_space = solve.keywords["state_space"]
 
     df, type_covariates = _process_estimation_data(
         df, state_space, optim_paras, options
@@ -86,7 +92,7 @@ def get_crit_func(
         log_like,
         df=df,
         base_draws_est=base_draws_est,
-        state_space=state_space,
+        solve=solve,
         type_covariates=type_covariates,
         options=options,
         return_scalar=return_scalar,
@@ -100,7 +106,7 @@ def log_like(
     params,
     df,
     base_draws_est,
-    state_space,
+    solve,
     type_covariates,
     options,
     return_scalar,
@@ -119,25 +125,27 @@ def log_like(
         different types.
     base_draws_est : numpy.ndarray
         Set of draws to calculate the probability of observed wages.
-    state_space : :class:`~respy.state_space.StateSpace`
-        State space.
+    solve : :func:`~respy.solve.solve`
+        Function which solves the model with new parameters.
     options : dict
         Contains model options.
 
     """
     optim_paras, options = process_params_and_options(params, options)
 
-    state_space.update_systematic_rewards(optim_paras)
-
-    state_space = solve_with_backward_induction(state_space, optim_paras, options)
+    state_space = solve(params)
 
-    contribs, df = _internal_log_like_obs(
+    contribs, df, log_type_probabilities = _internal_log_like_obs(
         state_space, df, base_draws_est, type_covariates, optim_paras, options
     )
 
+    # Return mean log likelihood or log likelihood contributions.
     out = contribs.mean() if return_scalar else contribs
+
     if return_comparison_plot_data:
-        comparison_plot_data = _create_comparison_plot_data(df, optim_paras)
+        comparison_plot_data = _create_comparison_plot_data(
+            df, log_type_probabilities, optim_paras
+        )
         out = (out, comparison_plot_data)
 
     return out
@@ -184,15 +192,74 @@ def _internal_log_like_obs(
     """
     df = df.copy()
 
+    n_types = optim_paras["n_types"]
+
+    wages = state_space.get_attribute("wages")
+    nonpecs = state_space.get_attribute("nonpecs")
+    expected_value_functions = state_space.get_attribute("expected_value_functions")
+    is_inadmissible = state_space.get_attribute("is_inadmissible")
+
+    df = _compute_wage_and_choice_likelihood_contributions(
+        df,
+        base_draws_est,
+        wages,
+        nonpecs,
+        expected_value_functions,
+        is_inadmissible,
+        optim_paras=optim_paras,
+        options=options,
+    )
+
+    # Aggregate choice probabilities and wage densities to log likes per observation.
+    loglikes = (
+        df.groupby(["identifier", "period", "type"])[["loglike_choice", "loglike_wage"]]
+        .first()
+        .unstack("type")
+        if optim_paras["n_types"] >= 2
+        else df[["loglike_choice", "loglike_wage"]]
+    )
+    per_observation_loglikes = loglikes["loglike_choice"] + loglikes["loglike_wage"]
+    per_individual_loglikes = per_observation_loglikes.groupby("identifier").sum()
+
+    if n_types >= 2:
+        # To not alter the attribute in the functools.partial, create a copy.
+        type_covariates = type_covariates.copy()
+        # Weight each type-specific individual log likelihood with the type probability.
+        log_type_probabilities = _compute_log_type_probabilities(
+            type_covariates, optim_paras, options
+        )
+        weighted_loglikes = per_individual_loglikes + log_type_probabilities
+
+        contribs = special.logsumexp(weighted_loglikes, axis=1)
+    else:
+        contribs = per_individual_loglikes.to_numpy().flatten()
+        log_type_probabilities = None
+
+    contribs = np.clip(contribs, MIN_FLOAT, MAX_FLOAT)
+
+    return contribs, df, log_type_probabilities
+
+
+@distribute_and_combine_likelihood
+@parallelize_across_dense_dimensions
+def _compute_wage_and_choice_likelihood_contributions(
+    df,
+    base_draws_est,
+    wages,
+    nonpecs,
+    expected_value_functions,
+    is_inadmissible,
+    optim_paras,
+    options,
+):
     n_choices = len(optim_paras["choices"])
     n_obs = df.shape[0]
-    n_types = optim_paras["n_types"]
 
-    indices = df[[f"index_type_{i}" for i in range(optim_paras["n_types"])]].to_numpy()
+    indices = df["index"].to_numpy()
 
-    wages_systematic = state_space.wages[indices].reshape(n_obs * n_types, n_choices)
-    log_wages_observed = df["log_wage"].to_numpy().repeat(n_types)
-    choices = df["choice"].to_numpy().repeat(n_types)
+    wages_systematic = wages[indices]
+    log_wages_observed = df["log_wage"].to_numpy()
+    choices = df["choice"].to_numpy()
 
     draws, wage_loglikes = create_draws_and_log_prob_wages(
         log_wages_observed,
@@ -205,61 +272,64 @@ def _internal_log_like_obs(
         optim_paras["is_meas_error"],
     )
 
-    draws = draws.reshape(n_obs, n_types, -1, n_choices)
+    draws = draws.reshape(n_obs, -1, n_choices)
 
-    continuation_values = state_space.get_continuation_values(indices=indices)
+    # To get the continuation values, correctly index the expected value functions. This
+    # is the same operation done in `_SingleDimStateSpace.get_continuation_values()`.
+    child_indices = df[[f"child_index_{c}" for c in optim_paras["choices"]]]
+    mask = child_indices != INDEXER_INVALID_INDEX
+    valid_indices = np.where(mask, child_indices, 0)
+    continuation_values = np.where(mask, expected_value_functions[valid_indices], 0)
 
     choice_loglikes = _simulate_log_probability_of_individuals_observed_choice(
-        state_space.wages[indices],
-        state_space.nonpec[indices],
+        wages[indices],
+        nonpecs[indices],
         continuation_values,
         draws,
         optim_paras["delta"],
-        state_space.is_inadmissible[indices],
-        choices.reshape(-1, n_types),
+        is_inadmissible[indices],
+        choices,
         options["estimation_tau"],
     )
 
-    wage_loglikes = wage_loglikes.reshape(n_obs, n_types)
-
-    choice_loglikes = np.clip(choice_loglikes, MIN_FLOAT, MAX_FLOAT)
-    wage_loglikes = np.clip(wage_loglikes, MIN_FLOAT, MAX_FLOAT)
+    df["loglike_choice"] = np.clip(choice_loglikes, MIN_FLOAT, MAX_FLOAT)
+    df["loglike_wage"] = np.clip(wage_loglikes, MIN_FLOAT, MAX_FLOAT)
 
-    choice_cols = [f"loglike_choice_type_{i}" for i in range(n_types)]
-    wage_cols = [f"loglike_wage_type_{i}" for i in range(n_types)]
+    return df
 
-    df = df.reindex(columns=df.columns.tolist() + choice_cols + wage_cols)
-    df[choice_cols] = choice_loglikes
-    df[wage_cols] = wage_loglikes
 
-    data = df[choice_cols].to_numpy() + df[wage_cols].to_numpy()
-    per_individual_loglikes = (
-        pd.DataFrame(data=data, index=df.index).groupby("identifier").sum()
-    )
+def _compute_log_type_probabilities(df, optim_paras, options):
+    dense_columns = create_dense_state_space_columns(optim_paras)
+    dense_columns.remove("type")
 
-    if n_types >= 2:
-        z = ()
+    if dense_columns:
+        x_betas = df.groupby(dense_columns, as_index=False).apply(
+            _compute_x_beta_for_type_probability, optim_paras, options
+        )
+    else:
+        x_betas = _compute_x_beta_for_type_probability(df, optim_paras, options)
 
-        for level in optim_paras["type_prob"]:
-            labels = optim_paras["type_prob"][level].index
-            x_beta = np.dot(type_covariates[labels], optim_paras["type_prob"][level])
+    probabilities = special.softmax(x_betas, axis=1)
 
-            z += (x_beta,)
+    probabilities = np.clip(probabilities, 1 / MAX_FLOAT, None)
+    log_probabilities = np.log(probabilities)
 
-        type_probabilities = special.softmax(np.column_stack(z), axis=1)
+    return log_probabilities
 
-        type_probabilities = np.clip(type_probabilities, 1 / MAX_FLOAT, None)
-        log_type_probabilities = np.log(type_probabilities)
 
-        weighted_loglikes = per_individual_loglikes + log_type_probabilities
+def _compute_x_beta_for_type_probability(df, optim_paras, options):
+    for type_ in range(optim_paras["n_types"]):
+        first_observations = df.copy().assign(type=type_)
+        relevant_covariates = identify_necessary_covariates(
+            optim_paras["type_prob"][type_].index, options["covariates_all"]
+        )
+        first_observations = compute_covariates(first_observations, relevant_covariates)
+        first_observations = cast_bool_to_numeric(first_observations)
 
-        contribs = special.logsumexp(weighted_loglikes, axis=1)
-    else:
-        contribs = per_individual_loglikes.to_numpy().flatten()
+        labels = optim_paras["type_prob"][type_].index
+        df[type_] = np.dot(first_observations[labels], optim_paras["type_prob"][type_])
 
-    contribs = np.clip(contribs, MIN_FLOAT, MAX_FLOAT)
-
-    return contribs, df
+    return df[range(optim_paras["n_types"])]
 
 
 @nb.njit
@@ -402,8 +472,10 @@ def _process_estimation_data(df, state_space, optim_paras, options):
         The DataFrame which contains the data used for estimation. The DataFrame
         contains individual identifiers, periods, experiences, lagged choices, choices
         in current period, the wage and other observed data.
-    state_space : ~respy.state_space.StateSpace
+    indexer : numpy.ndarray
+        Indexer for the core state space.
     optim_paras : dict
+    options : dict
 
     Returns
     -------
@@ -433,25 +505,18 @@ def _process_estimation_data(df, state_space, optim_paras, options):
     df = convert_labeled_variables_to_codes(df, optim_paras)
 
     # Get indices of states in the state space corresponding to all observations for all
-    # types. The indexer has the shape (n_observations, n_types).
+    # types. The indexer has the shape (n_observations,).
     n_periods = int(df.index.get_level_values("period").max() + 1)
-    indices = ()
+    indices = []
+    core_columns = create_core_state_space_columns(optim_paras)
 
     for period in range(n_periods):
         period_df = df.query("period == @period")
-
-        core_columns = create_core_state_space_columns(optim_paras)
         period_core = tuple(period_df[col].to_numpy() for col in core_columns)
+        period_indices = state_space.indexer[period][period_core]
+        indices.append(period_indices)
 
-        period_observables = tuple(
-            period_df[observable].to_numpy()
-            for observable in optim_paras["observables"]
-        )
-
-        period_indices = state_space.indexer[period][period_core + period_observables]
-        indices += (period_indices,)
-
-    indices = np.concatenate(indices).reshape(-1, optim_paras["n_types"])
+    indices = np.concatenate(indices)
 
     # The indexer is now sorted in period-individual pairs whereas the estimation needs
     # individual-period pairs. Sort it!
@@ -461,28 +526,27 @@ def _process_estimation_data(df, state_space, optim_paras, options):
         .sort_values(["identifier", "period"])["__index__"]
         .to_numpy()
     )
-    indices = indices[indices_to_reorder]
+    df["index"] = indices[indices_to_reorder]
 
-    # Finally, add the indices to the DataFrame.
-    type_index_cols = [f"index_type_{i}" for i in range(optim_paras["n_types"])]
-    df = df.reindex(columns=df.columns.tolist() + type_index_cols)
-    df[type_index_cols] = indices
+    # Add indices of child states to the DataFrame.
+    children = pd.DataFrame(
+        data=state_space.indices_of_child_states[df["index"].to_numpy()],
+        index=df.index,
+        columns=[f"child_index_{c}" for c in optim_paras["choices"]],
+    )
+    df = pd.concat([df, children], axis="columns")
 
+    # For the estimation, log wages are needed with shape (n_observations, n_types).
     df["log_wage"] = np.log(np.clip(df.wage.to_numpy(), 1 / MAX_FLOAT, MAX_FLOAT))
     df = df.drop(columns="wage")
 
     # For the type covariates, we only need the first observation of each individual.
     if optim_paras["n_types"] >= 2:
-        initial_states = df.query("period == 0")
-        covariates = create_base_covariates(
-            initial_states, options["covariates"], raise_errors=False
-        )
-
-        all_data = pd.concat([covariates, initial_states], axis="columns")
-
-        type_covariates = all_data[optim_paras["type_covariates"]].apply(
-            downcast_to_smallest_dtype
+        initial_states = df.query("period == 0").copy()
+        type_covariates = compute_covariates(
+            initial_states, options["covariates_core"], raise_errors=False
         )
+        type_covariates = type_covariates.apply(downcast_to_smallest_dtype)
     else:
         type_covariates = None
 
@@ -521,7 +585,7 @@ def _adjust_optim_paras_for_estimation(optim_paras, df):
     return optim_paras
 
 
-def _create_comparison_plot_data(df, optim_paras):
+def _create_comparison_plot_data(df, log_type_probabilities, optim_paras):
     """Create DataFrame for estimagic's comparison plot."""
     # During the likelihood calculation, the log likelihood for missing wages is
     # substituted with 0. Remove these log likelihoods to get the correct picture.
@@ -540,4 +604,18 @@ def _create_comparison_plot_data(df, optim_paras):
     df["type"] = splitted_label[3]
     df = df.drop(columns="variable")
 
+    if log_type_probabilities is not None:
+        log_type_probabilities = log_type_probabilities.reset_index().melt(
+            id_vars=["identifier", "period"]
+        )
+        log_type_probabilities["kind"] = "log_type_probability"
+        log_type_probabilities["type"] = (
+            log_type_probabilities["variable"]
+            .str.split("_", expand=True)[3]
+            .astype(int)
+        )
+        log_type_probabilities = log_type_probabilities.drop(columns="variable")
+
+        df = df.append(log_type_probabilities, sort=False)
+
     return df
diff --git a/respy/parallelization.py b/respy/parallelization.py
new file mode 100644
index 000000000..31dbeefb3
--- /dev/null
+++ b/respy/parallelization.py
@@ -0,0 +1,219 @@
+"""This module contains the code to control parallel execution."""
+import functools
+
+import joblib
+import numpy as np
+import pandas as pd
+
+from respy.shared import create_dense_state_space_columns
+
+
+def parallelize_across_dense_dimensions(func=None, *, n_jobs=1):
+    """Parallelizes decorated function across dense state space dimensions.
+
+    Parallelization is only possible if the decorated function has no side-effects to
+    other dense dimensions. This might be true for different levels. E.g.
+    :meth:`respy.solve._create_choice_rewards` can be directly
+    parallelized. :func:`respy.solve.solve_with_backward_induction` cannot be
+    directly parallelized because the continuation values for one dense dimension will
+    become important for others if we implement exogenous processes. Thus, parallelize
+    across periods.
+
+    If applied to a function, the decorator recognizes if the model or state space
+    contains dense dimensions likes types or observables. Then, it splits the operation
+    across dense dimensions by patching the attribute access such that each sub state
+    space can only access its attributes.
+
+    The decorator can be applied to functions without trailing parentheses. At the same
+    time, the `*` prohibits to use the decorator with positional arguments.
+
+    """
+
+    def decorator_parallelize_across_dense_dimensions(func):
+        @functools.wraps(func)
+        def wrapper_parallelize_across_dense_dimensions(*args, **kwargs):
+            dense_indices = _infer_dense_indices_from_arguments(args, kwargs)
+            if dense_indices:
+                args_, kwargs_ = _broadcast_arguments(args, kwargs, dense_indices)
+
+                out = joblib.Parallel(n_jobs=n_jobs)(
+                    joblib.delayed(func)(*args_[idx], **kwargs_[idx])
+                    for idx in dense_indices
+                )
+
+                # Re-order multiple return values from list of tuples to tuple of lists
+                # to tuple of dictionaries to set as state space attributes.
+                if isinstance(out[0], tuple):
+                    n_returns = len(out[0])
+                    tuple_of_lists = tuple(
+                        [single_out[i] for single_out in out] for i in range(n_returns)
+                    )
+                    out = tuple(
+                        dict(zip(dense_indices, list_)) for list_ in tuple_of_lists
+                    )
+                else:
+                    out = dict(zip(dense_indices, out))
+            else:
+                out = func(*args, **kwargs)
+
+            return out
+
+        return wrapper_parallelize_across_dense_dimensions
+
+    # Ensures that the decorator can be used without parentheses.
+    if callable(func):
+        return decorator_parallelize_across_dense_dimensions(func)
+    else:
+        return decorator_parallelize_across_dense_dimensions
+
+
+def _infer_dense_indices_from_arguments(args, kwargs):
+    """Infer the dense indices from the arguments.
+
+    This function uses the intersection of all dense indices from the arguments. Since
+    the simulated data or data for the likelihood might not comprise all dense
+    dimensions, we might need to discard some indices.
+
+    """
+    list_of_dense_indices = []
+    for arg in args:
+        if _is_dictionary_with_tuple_keys(arg):
+            list_of_dense_indices.append(set(arg.keys()))
+    for kwarg in kwargs.values():
+        if _is_dictionary_with_tuple_keys(kwarg):
+            list_of_dense_indices.append(set(kwarg.keys()))
+
+    intersection_of_dense_indices = (
+        set.intersection(*list_of_dense_indices) if list_of_dense_indices else []
+    )
+
+    return intersection_of_dense_indices
+
+
+def _is_dictionary_with_tuple_keys(candidate):
+    """Infer whether the argument is a dictionary with tuple keys."""
+    return isinstance(candidate, dict) and all(
+        isinstance(key, tuple) for key in candidate
+    )
+
+
+def _broadcast_arguments(args, kwargs, dense_indices):
+    """Broadcast arguments to dense state space dimensions."""
+    args = list(args) if isinstance(args, tuple) else [args]
+
+    # Broadcast arguments which are not captured in a dictionary with dense state space
+    # dimension as keys.
+    for i, arg in enumerate(args):
+        if _is_dense_dictionary_argument(arg, dense_indices):
+            args[i] = {idx: arg[idx] for idx in dense_indices}
+        else:
+            args[i] = {idx: arg for idx in dense_indices}
+    for kwarg, value in kwargs.items():
+        if _is_dense_dictionary_argument(value, dense_indices):
+            kwargs[kwarg] = {idx: kwargs[kwarg][idx] for idx in dense_indices}
+        else:
+            kwargs[kwarg] = {idx: value for idx in dense_indices}
+
+    # Re-order arguments for zipping.
+    args = {idx: [arg[idx] for arg in args] for idx in dense_indices}
+    kwargs = {
+        idx: {kwarg: value[idx] for kwarg, value in kwargs.items()}
+        for idx in dense_indices
+    }
+
+    return args, kwargs
+
+
+def _is_dense_dictionary_argument(argument, dense_indices):
+    """Check whether all keys of the dictionary argument are also dense indices.
+
+    We cannot check whether all dense indices are in the argument because `splitted_df`
+    in :func:`distribute_and_combine_simulation` may not cover all dense combinations.
+
+    """
+    return isinstance(argument, dict) and all(idx in argument for idx in dense_indices)
+
+
+def distribute_and_combine_simulation(func):
+    """Distribute the simulation across sub state spaces and combine."""
+
+    @functools.wraps(func)
+    def wrapper_distribute_and_combine_simulation(df, *args, optim_paras, **kwargs):
+        dense_columns = create_dense_state_space_columns(optim_paras)
+        splitted_df = _split_dataframe(df, dense_columns) if dense_columns else df
+
+        out = func(splitted_df, *args, optim_paras, **kwargs)
+
+        df = pd.concat(out.values()).sort_index() if isinstance(out, dict) else out
+
+        return df
+
+    return wrapper_distribute_and_combine_simulation
+
+
+def distribute_and_combine_likelihood(func):
+    """Distribute the likelihood calculation across sub state spaces and combine."""
+
+    @functools.wraps(func)
+    def wrapper_distribute_and_combine_likelihood(
+        df, base_draws_est, *args, optim_paras, options
+    ):
+        dense_columns = create_dense_state_space_columns(optim_paras)
+        # Duplicate the DataFrame for each type.
+        if dense_columns:
+            n_obs = df.shape[0]
+            n_types = optim_paras["n_types"]
+            # Number each state to split the shocks later. This is necessary to keep the
+            # regression tests from failing.
+            df["__id"] = np.arange(n_obs)
+            # Each row of indices corresponds to a state whereas the columns refer to
+            # different types.
+            indices = np.arange(n_obs * n_types).reshape(n_obs, n_types)
+            splitted_df = {}
+            for i in range(optim_paras["n_types"]):
+                df_ = df.copy().assign(type=i)
+                type_specific_dense = _split_dataframe(df_, dense_columns)
+                splitted_df = {**splitted_df, **type_specific_dense}
+            splitted_shocks = _split_shocks(
+                base_draws_est, splitted_df, indices, optim_paras
+            )
+        else:
+            splitted_df = df
+            splitted_shocks = base_draws_est
+
+        out = func(splitted_df, splitted_shocks, *args, optim_paras, options)
+
+        out = pd.concat(out.values()).sort_index() if isinstance(out, dict) else out
+
+        return out
+
+    return wrapper_distribute_and_combine_likelihood
+
+
+def _split_dataframe(df, dense_columns):
+    """Split a DataFrame by creating groups of the same values for the dense dims."""
+    groups = {}
+    for name, group in df.groupby(dense_columns):
+        name = (int(name),) if len(dense_columns) == 1 else tuple(int(i) for i in name)
+        groups[name] = group
+
+    return groups
+
+
+def _split_shocks(base_draws_est, splitted_df, indices, optim_paras):
+    """Split the shocks.
+
+    Previously, shocks were assigned to observations which were ordered like observation
+    * n_types. Due to the changes to the dense dimensions, this might not be true
+    anymore. Thus, ensure the former ordering with the `__id` variable. This will be
+    removed with new regression tests.
+
+    """
+    splitted_shocks = {}
+    for dense_idx, sub_df in splitted_df.items():
+        type_ = dense_idx[-1] if optim_paras["n_types"] >= 2 else 0
+        sub_indices = sub_df.pop("__id").to_numpy()
+        shock_indices_for_group = indices[sub_indices][:, type_].reshape(-1)
+        splitted_shocks[dense_idx] = base_draws_est[shock_indices_for_group]
+
+    return splitted_shocks
diff --git a/respy/pre_processing/data_checking.py b/respy/pre_processing/data_checking.py
index 3502f3bf5..02d573109 100644
--- a/respy/pre_processing/data_checking.py
+++ b/respy/pre_processing/data_checking.py
@@ -66,7 +66,14 @@ def check_estimation_data(df, optim_paras):
     assert df.drop(columns="Wage").notna().all().all()
 
     # We check individual state variables against the recorded choices.
-    df.groupby("Identifier").apply(_check_state_variables, optim_paras=optim_paras)
+    for choice in optim_paras["choices_w_exp"]:
+        df["__exp"] = df[f"Experience_{choice.title()}"] + df["Choice"].eq(choice)
+        shifted_exp = (
+            df.groupby("Identifier")["__exp"].transform("shift").dropna().astype(int)
+        )
+        assert shifted_exp.eq(
+            df.loc[shifted_exp.index, f"Experience_{choice.title()}"]
+        ).all()
 
     # Check that there are no duplicated observations for any period by agent.
     assert ~df.duplicated(subset=["Identifier", "Period"]).any()
@@ -77,24 +84,6 @@ def check_estimation_data(df, optim_paras):
     assert (max_periods_per_ind == n_obs_per_ind).all()
 
 
-def _check_state_variables(agent, optim_paras):
-    """Check that state variables in the dataset.
-
-    Construct the experience and schooling levels implied by the reported
-    choices and compare them to the information provided in the dataset.
-
-    """
-    experiences = agent.iloc[0].filter(like="Experience_").to_numpy()
-
-    for _, row in agent.iterrows():
-
-        assert (experiences == row.filter(like="Experience_").to_numpy()).all()
-
-        if row.Choice in optim_paras["choices_w_exp"]:
-            index_of_choice = optim_paras["choices_w_exp"].index(row.Choice)
-            experiences[index_of_choice] += 1
-
-
 def check_simulated_data(optim_paras, df):
     """Check simulated data.
 
diff --git a/respy/pre_processing/model_checking.py b/respy/pre_processing/model_checking.py
index 2079136da..a32f21fe1 100644
--- a/respy/pre_processing/model_checking.py
+++ b/respy/pre_processing/model_checking.py
@@ -1,34 +1,33 @@
 """Everything related to validate the model."""
 import numpy as np
-import pandas as pd
 
 
 def validate_options(o):
     """Validate the options provided by the user."""
+    assert _is_positive_nonzero_integer(o["n_periods"])
+
     for option, value in o.items():
         if "draws" in option:
             assert _is_positive_nonzero_integer(value)
         elif option.endswith("_seed"):
             assert _is_nonnegative_integer(value)
-        else:
-            pass
 
     assert 0 < o["estimation_tau"]
-
     assert (
         _is_positive_nonzero_integer(o["interpolation_points"])
         or o["interpolation_points"] == -1
     )
-
-    # Number of periods.
-    assert _is_positive_nonzero_integer(o["n_periods"])
-
-    # Covariates.
-    if "covariates" in o:
-        assert all(
-            isinstance(key, str) and isinstance(val, str)
-            for key, val in o["covariates"].items()
-        )
+    assert _is_positive_nonzero_integer(o["simulation_agents"])
+    assert isinstance(o["core_state_space_filters"], list) and all(
+        isinstance(filter_, str) for filter_ in o["core_state_space_filters"]
+    )
+    assert isinstance(o["inadmissible_states"], dict) and all(
+        isinstance(key, str)
+        and isinstance(val, list)
+        and all(isinstance(condition, str) for condition in val)
+        for key, val in o["inadmissible_states"].items()
+    )
+    assert o["monte_carlo_sequence"] in ["random", "halton", "sobol"]
 
 
 def validate_params(params, optim_paras):
@@ -87,48 +86,65 @@ def check_model_solution(optim_paras, options, state_space):
         [max(choices[choice]["start"]) for choice in optim_paras["choices_w_exp"]]
     )
     n_periods = options["n_periods"]
-    n_choices_w_exp = len(optim_paras["choices_w_exp"])
 
     # Check period.
-    assert np.all(np.isin(state_space.states[:, 0], range(n_periods)))
+    assert np.all(np.isin(state_space.core.period, range(n_periods)))
 
     # The sum of years of experiences cannot be larger than constraint time.
     assert np.all(
-        state_space.states[:, 1 : n_choices_w_exp + 1].sum(axis=1)
-        <= (state_space.states[:, 0] + max_initial_experience.sum())
+        state_space.core[[f"exp_{c}" for c in optim_paras["choices_w_exp"]]].sum(axis=1)
+        <= (state_space.core.period + max_initial_experience.sum())
     )
 
     # Choice experience cannot exceed the time frame.
     for choice in optim_paras["choices_w_exp"]:
-        idx = list(choices).index(choice) + 1
-        assert np.all(state_space.states[:, idx] <= choices[choice]["max"])
+        assert state_space.core[f"exp_{choice}"].le(choices[choice]["max"]).all()
 
     # Lagged choices are always in ``range(n_choices)``.
     if optim_paras["n_lagged_choices"]:
-        assert np.isin(
-            state_space.states[
-                :,
-                n_choices_w_exp
-                + 1 : n_choices_w_exp
-                + optim_paras["n_lagged_choices"]
-                + 1,
-            ],
-            range(len(choices)),
-        ).all()
-
-    # States and covariates have finite and nonnegative values.
-    assert np.all(state_space.states >= 0)
-    assert np.all(np.isfinite(state_space.states))
+        assert np.all(
+            state_space.core.filter(regex=r"\blagged_choice_[0-9]*\b").isin(
+                range(len(choices))
+            )
+        )
+
+    assert np.all(np.isfinite(state_space.core))
 
     # Check for duplicate rows in each period. We only have possible duplicates if there
     # are multiple initial conditions.
-    assert not pd.DataFrame(state_space.states).duplicated().any()
+    assert not state_space.core.duplicated().any()
 
     # Check that we have as many indices as states.
     n_valid_indices = sum((indexer >= 0).sum() for indexer in state_space.indexer)
-    assert state_space.states.shape[0] == n_valid_indices
+    assert state_space.core.shape[0] == n_valid_indices
 
     # Check finiteness of rewards and emaxs.
-    assert np.all(np.isfinite(state_space.wages))
-    assert np.all(np.isfinite(state_space.nonpec))
-    assert np.all(np.isfinite(state_space.emax_value_functions))
+    assert np.all(
+        _apply_to_attribute_of_state_space(
+            state_space.get_attribute("wages"), np.isfinite
+        )
+    )
+    assert np.all(
+        _apply_to_attribute_of_state_space(
+            state_space.get_attribute("nonpecs"), np.isfinite
+        )
+    )
+    assert np.all(
+        _apply_to_attribute_of_state_space(
+            state_space.get_attribute("expected_value_functions"), np.isfinite
+        )
+    )
+
+
+def _apply_to_attribute_of_state_space(attribute, func):
+    """Apply a function to a state space attribute which might be dense or not.
+
+    Attribute might be `state_space.wages` which can be a dictionary or a Numpy array.
+
+    """
+    if isinstance(attribute, dict):
+        out = [func(val) for val in attribute.values()]
+    else:
+        out = func(attribute)
+
+    return out
diff --git a/respy/pre_processing/model_processing.py b/respy/pre_processing/model_processing.py
index 16f38c7aa..edc5d874c 100644
--- a/respy/pre_processing/model_processing.py
+++ b/respy/pre_processing/model_processing.py
@@ -19,6 +19,10 @@
 from respy.config import SEED_STARTUP_ITERATION_GAP
 from respy.pre_processing.model_checking import validate_options
 from respy.pre_processing.model_checking import validate_params
+from respy.pre_processing.process_covariates import remove_irrelevant_covariates
+from respy.pre_processing.process_covariates import (
+    separate_covariates_into_core_dense_mixed,
+)
 from respy.shared import normalize_probabilities
 
 warnings.simplefilter("error", category=pd.errors.PerformanceWarning)
@@ -35,7 +39,7 @@ def process_params_and_options(params, options):
 
     options = {**DEFAULT_OPTIONS, **options}
     options = _create_internal_seeds_from_user_seeds(options)
-    options = _identify_relevant_covariates(options, params)
+    options = remove_irrelevant_covariates(options, params)
     validate_options(options)
 
     optim_paras = _parse_parameters(params, options)
@@ -174,6 +178,12 @@ def _parse_observables(optim_paras, params):
         parsed_parameters = _parse_probabilities_or_logit_coefficients(
             params, regex_pattern
         )
+        if len(parsed_parameters) < 2:
+            warnings.warn(
+                f"Observable '{observable}' must have at least two possible values. "
+                "Constant effects should be implemented via constant covariates.",
+                category=DeprecationWarning,
+            )
         optim_paras["observables"][observable] = parsed_parameters
 
     return optim_paras
@@ -559,46 +569,6 @@ def _parse_probabilities_or_logit_coefficients(params, regex_for_levels):
     return container
 
 
-def _identify_relevant_covariates(options, params):
-    """Identify the relevant covariates.
-
-    We try to make every model as sparse as possible which means discarding covariates
-    which are irrelevant. The immediate benefit is that memory consumption and start-up
-    costs are reduced.
-
-    An advantage further downstream is that the number of lagged choices is inferred
-    from covariates. Eliminating irrelevant covariates might reduce the number of
-    implemented lags.
-
-    """
-    covariates = options["covariates"]
-
-    relevant_covariates = {}
-    for cov in covariates:
-        if cov in params.index.get_level_values("name"):
-            relevant_covariates[cov] = covariates[cov]
-
-    n_relevant_covariates_changed = True
-    while n_relevant_covariates_changed:
-        n_relevant_covariates = len(relevant_covariates)
-
-        for cov in covariates:
-            for relevant_cov in list(relevant_covariates):
-                if cov in relevant_covariates[relevant_cov]:
-                    # Append the covariate to the front such that nested covariates are
-                    # created in the beginning.
-                    relevant_covariates = {cov: covariates[cov], **relevant_covariates}
-
-        if n_relevant_covariates == len(relevant_covariates):
-            n_relevant_covariates_changed = False
-        else:
-            n_relevant_covariates_changed = True
-
-    options["covariates"] = relevant_covariates
-
-    return options
-
-
 def _sync_optim_paras_and_options(optim_paras, options):
     """Sync ``optim_paras`` and ``options`` after they have been parsed separately."""
     optim_paras["n_periods"] = options["n_periods"]
@@ -612,6 +582,7 @@ def _sync_optim_paras_and_options(optim_paras, options):
         options["covariates"] = {**options["covariates"], **type_covariates}
 
     options = _convert_labels_in_formulas_to_codes(options, optim_paras)
+    options = separate_covariates_into_core_dense_mixed(options, optim_paras)
 
     return optim_paras, options
 
diff --git a/respy/pre_processing/process_covariates.py b/respy/pre_processing/process_covariates.py
new file mode 100644
index 000000000..426ecbeed
--- /dev/null
+++ b/respy/pre_processing/process_covariates.py
@@ -0,0 +1,167 @@
+"""This module comprises all functions which process the definition of covariates."""
+import copy
+
+
+def remove_irrelevant_covariates(options, params):
+    """Identify the relevant covariates.
+
+    We try to make every model as sparse as possible which means discarding covariates
+    which are irrelevant. The immediate benefit is that memory consumption and start-up
+    costs are reduced.
+
+    An advantage further downstream is that the number of lagged choices is inferred
+    from covariates. Eliminating irrelevant covariates might reduce the number of
+    implemented lags.
+
+    The function catches all relevant "high-level" covariates by looking at the `"name"`
+    index in `params`. "Low-level" covariates which are relevant but not included in the
+    index are recursively found by checking whether covariates are used in the formula
+    of relevant covariates.
+
+    See also
+    --------
+    separate_covariates_into_core_dense_mixed
+
+    """
+    options = copy.deepcopy(options)
+    covariates = options["covariates"]
+
+    # Collect initial relevant covariates from params.
+    relevant_covs = {}
+    for cov in covariates:
+        if cov in params.index.get_level_values("name"):
+            relevant_covs[cov] = covariates[cov]
+
+    # Start by iterating over initial covariates and add variables which are used to
+    # compute them and repeat the process.
+    n_relevant_covariates_changed = True
+    while n_relevant_covariates_changed:
+        n_relevant_covariates = len(relevant_covs)
+
+        for cov in covariates:
+            for relevant_cov in relevant_covs:
+                if cov in relevant_covs[relevant_cov]:
+                    # Append the covariate to the front such that nested covariates are
+                    # created in the beginning.
+                    relevant_covs = {cov: covariates[cov], **relevant_covs}
+
+        n_relevant_covariates_changed = n_relevant_covariates != len(relevant_covs)
+
+    options["covariates"] = relevant_covs
+
+    return options
+
+
+def separate_covariates_into_core_dense_mixed(options, optim_paras):
+    """Separate covariates into distinct groups.
+
+    Covariates are separated into three groups.
+
+    1. Covariates which use only information from the core state space.
+    2. Covariates which use only information from the dense state space.
+    3. Covariates which use information from the core and the dense state space.
+
+    Parameters
+    ----------
+    options : dict
+        Contains among other information covariates and their formulas.
+    optim_paras : dict
+        Contains information to separate the core and dense state space.
+
+    Returns
+    -------
+    options : dict
+        Contains three new covariate categories.
+
+    """
+    options = copy.deepcopy(options)
+    covariates = options["covariates"]
+
+    # Define two sets with default covariates for the core and dense state space.
+    core_covs = set(
+        ["period"]
+        + [f"exp_{choice}" for choice in optim_paras["choices_w_exp"]]
+        + [f"lagged_choice_{i}" for i in range(1, optim_paras["n_lagged_choices"] + 1)]
+    )
+    dense_covs = set(optim_paras["observables"])
+    if optim_paras["n_types"] >= 2:
+        dense_covs |= set(
+            ["type"] + [f"type_{i}" for i in range(2, optim_paras["n_types"] + 1)]
+        )
+
+    detailed_covariates = {
+        cov: {"formula": covariates[cov], "depends_on": set()} for cov in covariates
+    }
+
+    # Loop over all covariates and add them two the sets if the formula contains
+    # covariates from the sets. If both lengths of the sets do not change anymore, stop.
+    n_core_covs_changed = True
+    n_dense_covs_changed = True
+    while n_core_covs_changed or n_dense_covs_changed:
+        n_core_covs = len(core_covs)
+        n_dense_covs = len(dense_covs)
+
+        for cov, formula in covariates.items():
+            matches_core = [i for i in core_covs if i in formula]
+            if matches_core:
+                core_covs.update([cov])
+
+            matches_dense = [i for i in dense_covs if i in formula]
+            if matches_dense:
+                dense_covs.update([cov])
+
+            detailed_covariates[cov]["depends_on"] |= set(matches_core + matches_dense)
+
+        n_core_covs_changed = n_core_covs != len(core_covs)
+        n_dense_covs_changed = n_dense_covs != len(dense_covs)
+
+    only_core_covs = core_covs - dense_covs
+    only_dense_covs = dense_covs - core_covs
+    independent_covs = set(covariates) - core_covs - dense_covs
+
+    options["covariates_core"] = {
+        cov: detailed_covariates[cov]
+        for cov in only_core_covs | independent_covs
+        if cov in detailed_covariates
+    }
+    options["covariates_dense"] = {
+        cov: detailed_covariates[cov]
+        for cov in only_dense_covs
+        if cov in detailed_covariates
+    }
+    options["covariates_mixed"] = {
+        cov: detailed_covariates[cov] for cov in core_covs & dense_covs
+    }
+    # We cannot overwrite `options["covariates"]`.
+    options["covariates_all"] = detailed_covariates
+
+    return options
+
+
+def identify_necessary_covariates(dependents, definitions):
+    """Identify covariates necessary to compute `dependents`.
+
+    This function can be used if only a specific subset of covariates is necessary and
+    not all covariates.
+
+    See also
+    --------
+    respy.likelihood._compute_x_beta_for_type_probability
+
+    """
+    dependents = {dependents} if isinstance(dependents, str) else set(dependents)
+    new_dependents = dependents.copy()
+
+    while new_dependents:
+        deps = list(new_dependents)
+        new_dependents = set()
+        for dependent in deps:
+            if dependent in definitions and definitions[dependent]["depends_on"]:
+                dependents |= definitions[dependent]["depends_on"]
+                new_dependents |= definitions[dependent]["depends_on"]
+            else:
+                dependents.remove(dependent)
+
+    covariates = {dep: definitions[dep] for dep in dependents}
+
+    return covariates
diff --git a/respy/shared.py b/respy/shared.py
index 989cdc644..d5d78549f 100644
--- a/respy/shared.py
+++ b/respy/shared.py
@@ -4,8 +4,6 @@
 import from respy itself. This is to prevent circular imports.
 
 """
-import copy
-
 import chaospy as cp
 import numba as nb
 import numpy as np
@@ -180,22 +178,6 @@ def generate_column_dtype_dict_for_estimation(optim_paras):
     return column_dtype_dict
 
 
-@nb.njit
-def clip(x, minimum=None, maximum=None):
-    """Clip input array at minimum and maximum."""
-    out = np.empty_like(x)
-
-    for index, value in np.ndenumerate(x):
-        if minimum is not None and value < minimum:
-            out[index] = minimum
-        elif maximum is not None and value > maximum:
-            out[index] = maximum
-        else:
-            out[index] = value
-
-    return out
-
-
 def downcast_to_smallest_dtype(series, downcast_options=None):
     """Downcast the dtype of a :class:`pandas.Series` to the lowest possible dtype.
 
@@ -248,19 +230,38 @@ def downcast_to_smallest_dtype(series, downcast_options=None):
     return out
 
 
-def create_base_covariates(states, covariates_spec, raise_errors=True):
-    """Create set of covariates for each state.
+def cast_bool_to_numeric(df):
+    """Cast columns with boolean data type to the smallest integer."""
+    bool_columns = df.columns[df.dtypes == np.bool]
+    for column in bool_columns:
+        df[column] = df[column].astype(np.uint8)
+    return df
+
+
+def compute_covariates(df, definitions, check_nans=False, raise_errors=True):
+    """Compute covariates.
+
+    The function iterates over the definitions of covariates and tries to compute them.
+    It keeps track on how many covariates still need to be computed and stops if the
+    number does not change anymore. This might be due to missing information.
 
     Parameters
     ----------
-    states : pandas.DataFrame
-        DataFrame with some, not all state space dimensions like period, experiences.
-    covariates_spec : dict
+    df : pandas.DataFrame
+        DataFrame with some, maybe not all state space dimensions like period,
+        experiences.
+    definitions : dict
         Keys represent covariates and values are strings passed to ``df.eval``.
+    check_nans : bool, default False
+        Perform a check whether the variables used to compute the selected covariate do
+        not contain any `np.nan`. This is necessary in
+        :func:`respy.simulate._sample_characteristic` where some characteristics may
+        contain missings.
     raise_errors : bool, default True
-        Whether to raise errors if a variable was not found. This option is necessary
-        for, e.g., :func:`~respy.simulate._sample_characteristic` where not all
-        necessary variables exist and it is not clear how to exclude them easily.
+        Whether to raise errors if variables cannot be computed. This option is
+        necessary for, e.g., :func:`~respy.simulate._sample_characteristic` where not
+        all necessary variables exist and it is not easy to exclude covariates which
+        depend on them.
 
     Returns
     -------
@@ -269,39 +270,51 @@ def create_base_covariates(states, covariates_spec, raise_errors=True):
 
     Raises
     ------
-    pd.core.computation.ops.UndefinedVariableError
-        If variable on the right-hand-side of the definition is not found in the data.
+    Exception
+        If variables cannot be computed and ``raise_errors`` is true.
 
     """
-    covariates = states.copy()
-
     has_covariates_left_changed = True
-    covariates_left = list(covariates_spec)
+    covariates_left = list(definitions)
 
     while has_covariates_left_changed:
         n_covariates_left = len(covariates_left)
 
         # Create a copy of `covariates_left` to remove elements without side-effects.
-        for covariate in copy.copy(covariates_left):
+        for covariate in covariates_left.copy():
             # Check if the covariate does not exist and needs to be computed.
-            is_covariate_missing = covariate not in covariates.columns
-
-            if is_covariate_missing:
-                try:
-                    covariates[covariate] = covariates.eval(covariates_spec[covariate])
-                except pd.core.computation.ops.UndefinedVariableError:
-                    pass
+            is_covariate_missing = covariate not in df.columns
+            if not is_covariate_missing:
+                covariates_left.remove(covariate)
+                continue
+
+            # Check that the dependencies are present.
+            index_or_columns = df.columns.union(df.index.names)
+            are_dependencies_present = all(
+                dep in index_or_columns for dep in definitions[covariate]["depends_on"]
+            )
+            if are_dependencies_present:
+                # If true, perform checks for NaNs.
+                if check_nans:
+                    have_dependencies_no_missings = all(
+                        df.eval(f"{dep}.notna().all()")
+                        for dep in definitions[covariate]["depends_on"]
+                    )
                 else:
-                    covariates_left.remove(covariate)
+                    have_dependencies_no_missings = True
+            else:
+                have_dependencies_no_missings = False
+
+            if have_dependencies_no_missings:
+                df[covariate] = df.eval(definitions[covariate]["formula"])
+                covariates_left.remove(covariate)
 
         has_covariates_left_changed = n_covariates_left != len(covariates_left)
 
     if covariates_left and raise_errors:
         raise Exception(f"Cannot compute all covariates: {covariates_left}.")
 
-    covariates = covariates.drop(columns=states.columns)
-
-    return covariates
+    return df
 
 
 def convert_labeled_variables_to_codes(df, optim_paras):
@@ -411,3 +424,93 @@ def create_state_space_columns(optim_paras):
     return create_core_state_space_columns(
         optim_paras
     ) + create_dense_state_space_columns(optim_paras)
+
+
+@nb.guvectorize(
+    ["f8[:], f8[:], f8[:], f8[:, :], f8, b1[:], f8[:]"],
+    "(n_choices), (n_choices), (n_choices), (n_draws, n_choices), (), (n_choices) "
+    "-> ()",
+    nopython=True,
+    target="parallel",
+)
+def calculate_expected_value_functions(
+    wages,
+    nonpecs,
+    continuation_values,
+    draws,
+    delta,
+    is_inadmissible,
+    expected_value_functions,
+):
+    r"""Calculate the expected maximum of value functions for a set of unobservables.
+
+    The function takes an agent and calculates the utility for each of the choices, the
+    ex-post rewards, with multiple draws from the distribution of unobservables and adds
+    the discounted expected maximum utility of subsequent periods resulting from
+    choices. Averaging over all maximum utilities yields the expected maximum utility of
+    this state.
+
+    The underlying process in this function is called `Monte Carlo integration`_. The
+    goal is to approximate an integral by evaluating the integrand at randomly chosen
+    points. In this setting, one wants to approximate the expected maximum utility of
+    the current state.
+
+    Note that `wages` have the same length as `nonpecs` despite that wages are only
+    available in some choices. Missing choices are filled with ones. In the case of a
+    choice with wage and without wage, flow utilities are
+
+    .. math::
+
+        \text{Flow Utility} = \text{Wage} * \epsilon + \text{Non-pecuniary}
+        \text{Flow Utility} = 1 * \epsilon + \text{Non-pecuniary}
+
+    Parameters
+    ----------
+    wages : numpy.ndarray
+        Array with shape (n_choices,) containing wages.
+    nonpecs : numpy.ndarray
+        Array with shape (n_choices,) containing non-pecuniary rewards.
+    continuation_values : numpy.ndarray
+        Array with shape (n_choices,) containing expected maximum utility for each
+        choice in the subsequent period.
+    draws : numpy.ndarray
+        Array with shape (n_draws, n_choices).
+    delta : float
+        The discount factor.
+    is_inadmissible: numpy.ndarray
+        Array with shape (n_choices,) containing indicator for whether the following
+        state is inadmissible.
+
+    Returns
+    -------
+    expected_value_functions : float
+        Expected maximum utility of an agent.
+
+    .. _Monte Carlo integration:
+        https://en.wikipedia.org/wiki/Monte_Carlo_integration
+
+    """
+    n_draws, n_choices = draws.shape
+
+    expected_value_functions[0] = 0
+
+    for i in range(n_draws):
+
+        max_value_functions = 0
+
+        for j in range(n_choices):
+            value_function, _ = aggregate_keane_wolpin_utility(
+                wages[j],
+                nonpecs[j],
+                continuation_values[j],
+                draws[i, j],
+                delta,
+                is_inadmissible[j],
+            )
+
+            if value_function > max_value_functions:
+                max_value_functions = value_function
+
+        expected_value_functions[0] += max_value_functions
+
+    expected_value_functions[0] /= n_draws
diff --git a/respy/simulate.py b/respy/simulate.py
index 9f7064e7e..e566ed6a3 100644
--- a/respy/simulate.py
+++ b/respy/simulate.py
@@ -6,16 +6,20 @@
 import pandas as pd
 from scipy.special import softmax
 
+from respy.config import INDEXER_INVALID_INDEX
+from respy.parallelization import distribute_and_combine_simulation
+from respy.parallelization import parallelize_across_dense_dimensions
 from respy.pre_processing.model_processing import process_params_and_options
 from respy.shared import calculate_value_functions_and_flow_utilities
-from respy.shared import create_base_covariates
+from respy.shared import compute_covariates
 from respy.shared import create_base_draws
+from respy.shared import create_core_state_space_columns
+from respy.shared import create_state_space_columns
 from respy.shared import downcast_to_smallest_dtype
 from respy.shared import rename_labels_from_internal
 from respy.shared import rename_labels_to_internal
 from respy.shared import transform_base_draws_with_cholesky_factor
-from respy.solve import solve_with_backward_induction
-from respy.state_space import StateSpace
+from respy.solve import get_solve_func
 
 
 def get_simulate_func(
@@ -63,7 +67,7 @@ def get_simulate_func(
         df, method, n_simulation_periods, options, optim_paras
     )
 
-    state_space = StateSpace(optim_paras, options)
+    solve = get_solve_func(params, options)
 
     shape = (df.shape[0], len(optim_paras["choices"]))
     base_draws_sim = create_base_draws(
@@ -78,14 +82,14 @@ def get_simulate_func(
         base_draws_sim=base_draws_sim,
         base_draws_wage=base_draws_wage,
         df=df,
-        state_space=state_space,
+        solve=solve,
         options=options,
     )
 
     return simulate_function
 
 
-def simulate(params, base_draws_sim, base_draws_wage, df, state_space, options):
+def simulate(params, base_draws_sim, base_draws_wage, df, solve, options):
     """Perform a simulation.
 
     This function performs one of three possible simulation exercises. The type of the
@@ -125,8 +129,8 @@ def simulate(params, base_draws_sim, base_draws_wage, df, state_space, options):
           a one-step-ahead simulation.
         - :class:`pandas.DataFrame` containing only first observations which triggers a
           n-step-ahead simulation taking the data as initial conditions.
-    state_space : :class:`~respy.state_space.StateSpace`
-        State space of the model.
+    solve : :func:`~respy.solve.solve`
+        Function which creates the solution of the model with new parameters.
     options : dict
         Contains model options.
 
@@ -141,9 +145,7 @@ def simulate(params, base_draws_sim, base_draws_wage, df, state_space, options):
 
     optim_paras, options = process_params_and_options(params, options)
 
-    # Solve the model.
-    state_space.update_systematic_rewards(optim_paras)
-    state_space = solve_with_backward_induction(state_space, optim_paras, options)
+    state_space = solve(params)
 
     # Prepare simulation.
     n_simulation_periods = int(df.index.get_level_values("period").max() + 1)
@@ -169,9 +171,21 @@ def simulate(params, base_draws_sim, base_draws_wage, df, state_space, options):
         # If it is a one-step-ahead simulation, we pick rows from the panel data. For
         # n-step-ahead simulation, `df` always contains only data of the current period.
         current_df = df.query("period == @period").copy()
+        wages = state_space.get_attribute_from_period("wages", period)
+        nonpecs = state_space.get_attribute_from_period("nonpecs", period)
+        continuation_values = state_space.get_continuation_values(period=period)
+        is_inadmissible = state_space.get_attribute_from_period(
+            "is_inadmissible", period
+        )
 
         current_df_extended = _simulate_single_period(
-            current_df, state_space, optim_paras
+            current_df,
+            state_space.indexer[period],
+            wages,
+            nonpecs,
+            continuation_values,
+            is_inadmissible,
+            optim_paras=optim_paras,
         )
 
         data.append(current_df_extended)
@@ -257,38 +271,34 @@ def _extend_data_with_sampled_characteristics(df, optim_paras, options):
     return df
 
 
-def _simulate_single_period(df, state_space, optim_paras):
+@distribute_and_combine_simulation
+@parallelize_across_dense_dimensions
+def _simulate_single_period(
+    df, indexer, wages, nonpecs, continuation_values, is_inadmissible, optim_paras
+):
     """Simulate individuals in a single period.
 
-    This function takes a set of states and simulates wages, choices and other
-    information. The information is stored in a NumPy array.
+    The function performs the following sets:
 
-    Parameter
-    ---------
-    df : pandas.DataFrame
-        DataFrame with shape (n_individuals_in_period, n_state_space_dims) which
-        contains the states of simulated individuals.
-    state_space : :class:`~respy.state_space.StateSpace`
-        State space of the model.
-    optim_paras : dict
+    - Map individuals in one period to the states in the model.
+    - Simulate choices and wages for those individuals.
+    - Store additional information in a :class:`pandas.DataFrame` and return it.
 
     """
-    period = df.index.get_level_values("period").max()
     n_wages = len(optim_paras["choices_w_wage"])
 
-    # Get indices which connect states in the state space and simulated agents.
-    columns = create_state_space_columns(optim_paras)
-    indices = state_space.indexer[period][tuple(df[col].astype(int) for col in columns)]
+    # Get indices which connect states in the state space and simulated agents. Subtract
+    # the minimum of indices (excluding invalid indices) because wages, etc. contain
+    # only wages in this period and normal indices select rows from all wages.
+    columns = create_core_state_space_columns(optim_paras)
+    indices = indexer[tuple(df[col].astype("int64") for col in columns)]
+    period_indices = indices - np.min(indexer[indexer != INDEXER_INVALID_INDEX])
 
     try:
-        wages = state_space.wages[indices]
-        nonpecs = state_space.nonpec[indices]
-        # Get continuation values. Indices work on the complete state space whereas
-        # continuation values are period-specific. Make them period-specific.
-        cont_indices = indices - state_space.slices_by_periods[period].start
-        continuation_values = state_space.get_continuation_values(period)[cont_indices]
-
-        is_inadmissible = state_space.is_inadmissible[indices]
+        wages = wages[period_indices]
+        nonpecs = nonpecs[period_indices]
+        continuation_values = continuation_values[period_indices]
+        is_inadmissible = is_inadmissible[period_indices]
     except IndexError as e:
         raise Exception(
             "Simulated individuals could not be mapped to their corresponding states in"
@@ -296,11 +306,9 @@ def _simulate_single_period(df, state_space, optim_paras):
             "option['core_state_space_filters'] and the initial conditions."
         ) from e
 
-    # Select relevant subset of random draws.
     draws_shock = df[[f"shock_reward_{c}" for c in optim_paras["choices"]]].to_numpy()
     draws_wage = df[[f"meas_error_wage_{c}" for c in optim_paras["choices"]]].to_numpy()
 
-    # Get total values and ex post rewards.
     value_functions, flow_utilities = calculate_value_functions_and_flow_utilities(
         wages,
         nonpecs,
@@ -311,9 +319,8 @@ def _simulate_single_period(df, state_space, optim_paras):
     )
 
     # We need to ensure that no individual chooses an inadmissible state. Thus, set
-    # value functions to NaN. This cannot be done in
-    # :func:`aggregate_keane_wolpin_utility` as the interpolation requires a mild
-    # penalty.
+    # value functions to NaN. This cannot be done in `aggregate_keane_wolpin_utility` as
+    # the interpolation requires a mild penalty.
     value_functions = np.where(is_inadmissible, np.nan, value_functions)
 
     choice = np.nanargmax(value_functions, axis=1)
@@ -353,8 +360,6 @@ def _sample_characteristic(states_df, options, level_dict, use_keys):
 
     Parameters
     ----------
-    lag : int
-        Number of lag.
     states_df : pandas.DataFrame
         Contains the state of each individual.
     options : dict
@@ -363,6 +368,9 @@ def _sample_characteristic(states_df, options, level_dict, use_keys):
         A dictionary where the keys are the values distributed according to the
         probability mass function. The values are a :class:`pandas.Series` with
         covariate names as the index and parameter values.
+    use_keys : bool
+        Identifier for whether the keys of the level dict should be used as variables
+        values or use numeric codes instead. For example, assign numbers to choices.
 
     Returns
     -------
@@ -371,10 +379,9 @@ def _sample_characteristic(states_df, options, level_dict, use_keys):
 
     """
     # Generate covariates.
-    covariates_df = create_base_covariates(
-        states_df, options["covariates"], raise_errors=False
+    all_data = compute_covariates(
+        states_df, options["covariates_all"], check_nans=True, raise_errors=False
     )
-    all_data = pd.concat([covariates_df, states_df], axis="columns", sort=False)
     for column in all_data:
         if all_data[column].dtype == np.bool:
             all_data[column] = all_data[column].astype(np.uint8)
@@ -574,29 +581,6 @@ def _apply_law_of_motion(df, optim_paras):
     return df
 
 
-def create_core_state_space_columns(optim_paras):
-    """Create internal column names for the core state space."""
-    return [f"exp_{choice}" for choice in optim_paras["choices_w_exp"]] + [
-        f"lagged_choice_{i}" for i in range(1, optim_paras["n_lagged_choices"] + 1)
-    ]
-
-
-def create_dense_state_space_columns(optim_paras):
-    """Create internal column names for the dense state space."""
-    columns = list(optim_paras["observables"])
-    if optim_paras["n_types"] >= 2:
-        columns += ["type"]
-
-    return columns
-
-
-def create_state_space_columns(optim_paras):
-    """Create names of state space dimensions excluding the period and identifier."""
-    return create_core_state_space_columns(
-        optim_paras
-    ) + create_dense_state_space_columns(optim_paras)
-
-
 def _harmonize_simulation_arguments(method, df, n_sim_p, options):
     """Harmonize the arguments of the simulation."""
     if method == "n_step_ahead_with_sampling":
@@ -615,15 +599,15 @@ def _harmonize_simulation_arguments(method, df, n_sim_p, options):
         options["n_periods"] = n_sim_p
         warnings.warn(
             f"The number of periods in the model, {options['n_periods']}, is lower than"
-            f" the requested number of simulated periods, {n_sim_p}. Set "
-            "model periods equal to simulated periods."
+            f" the requested number of simulated periods, {n_sim_p}. Set model periods "
+            "equal to simulated periods."
         )
 
     return n_sim_p, options
 
 
 def _process_input_df_for_simulation(df, method, n_sim_periods, options, optim_paras):
-    """Process the ``df`` provided by the user for the simulation."""
+    """Process a :class:`pandas.DataFrame` provided by the user for the simulation."""
     if method == "n_step_ahead_with_sampling":
         ids = np.arange(options["simulation_agents"])
         index = pd.MultiIndex.from_product(
diff --git a/respy/solve.py b/respy/solve.py
index 35f2eb07c..466a54a2f 100644
--- a/respy/solve.py
+++ b/respy/solve.py
@@ -1,24 +1,22 @@
 """Everything related to the solution of a structural model."""
-import warnings
+import functools
 
-import numba as nb
 import numpy as np
 
-from respy.config import MAX_LOG_FLOAT
+from respy.interpolate import interpolate
+from respy.parallelization import parallelize_across_dense_dimensions
 from respy.pre_processing.model_processing import process_params_and_options
-from respy.shared import aggregate_keane_wolpin_utility
-from respy.shared import calculate_value_functions_and_flow_utilities
-from respy.shared import clip
+from respy.shared import calculate_expected_value_functions
 from respy.shared import transform_base_draws_with_cholesky_factor
-from respy.state_space import StateSpace
+from respy.state_space import create_state_space_class
 
 
-def solve(params, options):
-    """Solve the model.
+def get_solve_func(params, options):
+    """Get the solve function.
 
     This function takes a model specification and returns the state space of the model
     along with components of the solution such as covariates, non-pecuniary rewards,
-    wages, continuation values and value functions as attributes of the class.
+    wages, continuation values and expected value functions as attributes of the class.
 
     Parameters
     ----------
@@ -29,19 +27,76 @@ def solve(params, options):
 
     Returns
     -------
-    state_space : :class:`~respy.state_space.StateSpace`
-        State space of the model which is already solved via backward-induction.
+    solve : :func:`~respy.solve.solve`
+        Function with partialed arguments.
 
     """
     optim_paras, options = process_params_and_options(params, options)
 
-    state_space = StateSpace(optim_paras, options)
-    state_space = solve_with_backward_induction(state_space, optim_paras, options)
+    state_space = create_state_space_class(optim_paras, options)
+    solve_function = functools.partial(solve, options=options, state_space=state_space)
+
+    return solve_function
+
+
+def solve(params, options, state_space):
+    """Solve the model."""
+    optim_paras, options = process_params_and_options(params, options)
+
+    states = state_space.states
+    wages = state_space.get_attribute("wages")
+    nonpecs = state_space.get_attribute("nonpecs")
+
+    wages, nonpecs = _create_choice_rewards(states, wages, nonpecs, optim_paras)
+    state_space.set_attribute("wages", wages)
+    state_space.set_attribute("nonpecs", nonpecs)
+
+    if optim_paras["delta"] == 0:
+        expected_value_functions = _solve_for_myopic_individuals(
+            state_space.get_attribute("expected_value_functions")
+        )
+        state_space.set_attribute("expected_value_functions", expected_value_functions)
+    else:
+        state_space = _solve_with_backward_induction(state_space, optim_paras, options)
 
     return state_space
 
 
-def solve_with_backward_induction(state_space, optim_paras, options):
+@parallelize_across_dense_dimensions
+def _create_choice_rewards(states, wages, nonpecs, optim_paras):
+    """Create wage and non-pecuniary reward for each state and choice.
+
+    Note that missing wages filled with ones and missing non-pecuniary rewards with
+    zeros. This is done in :meth:`_initialize_attributes`.
+
+    """
+    for i, choice in enumerate(optim_paras["choices"]):
+        if f"wage_{choice}" in optim_paras:
+            wage_columns = optim_paras[f"wage_{choice}"].index
+            log_wage = np.dot(
+                states[wage_columns].to_numpy(),
+                optim_paras[f"wage_{choice}"].to_numpy(),
+            )
+            wages[:, i] = np.exp(log_wage)
+
+        if f"nonpec_{choice}" in optim_paras:
+            nonpec_columns = optim_paras[f"nonpec_{choice}"].index
+            nonpecs[:, i] = np.dot(
+                states[nonpec_columns].to_numpy(),
+                optim_paras[f"nonpec_{choice}"].to_numpy(),
+            )
+
+    return wages, nonpecs
+
+
+@parallelize_across_dense_dimensions
+def _solve_for_myopic_individuals(expected_value_functions):
+    """Solve the dynamic programming problem for myopic individuals."""
+    expected_value_functions[:] = 0
+    return expected_value_functions
+
+
+def _solve_with_backward_induction(state_space, optim_paras, options):
     """Calculate utilities with backward induction.
 
     Parameters
@@ -58,427 +113,86 @@ def solve_with_backward_induction(state_space, optim_paras, options):
     state_space : :class:`~respy.state_space.StateSpace`
 
     """
-    n_choices = len(optim_paras["choices"])
     n_wages = len(optim_paras["choices_w_wage"])
     n_periods = optim_paras["n_periods"]
-    n_states = state_space.states.shape[0]
-
-    state_space.emax_value_functions = np.zeros(n_states)
-
-    # For myopic agents, utility of later periods does not play a role.
-    if optim_paras["delta"] == 0:
-        return state_space
-
-    # Unpack arguments.
-    delta = optim_paras["delta"]
     shocks_cholesky = optim_paras["shocks_cholesky"]
 
-    shocks_cov = shocks_cholesky.dot(shocks_cholesky.T)
-
     draws_emax_risk = transform_base_draws_with_cholesky_factor(
         state_space.base_draws_sol, shocks_cholesky, n_wages
     )
 
     for period in reversed(range(n_periods)):
-        # Unpack necessary attributes of the specific period.
         wages = state_space.get_attribute_from_period("wages", period)
-        nonpec = state_space.get_attribute_from_period("nonpec", period)
+        nonpecs = state_space.get_attribute_from_period("nonpecs", period)
         is_inadmissible = state_space.get_attribute_from_period(
             "is_inadmissible", period
         )
         continuation_values = state_space.get_continuation_values(period)
-
-        n_states_in_period = wages.shape[0]
+        period_draws_emax_risk = draws_emax_risk[period]
 
         # The number of interpolation points is the same for all periods. Thus, for some
         # periods the number of interpolation points is larger than the actual number of
-        # states. In that case no interpolation is needed.
+        # states. In this case, no interpolation is needed.
+        n_dense_combinations = len(getattr(state_space, "sub_state_spaces", [1]))
+        n_core_states = state_space.core.query("period == @period").shape[0]
+        n_states_in_period = n_core_states * n_dense_combinations
         any_interpolated = (
             options["interpolation_points"] <= n_states_in_period
             and options["interpolation_points"] != -1
         )
 
         if any_interpolated:
-            # These shifts are used to determine the expected values of the working
-            # alternatives. These are log normal distributed and thus the draws cannot
-            # simply set to zero, but :math:`E(X) = \exp\{\mu + \frac{\sigma^2}{2}\}`.
-            shifts = np.zeros(n_choices)
-            n_choices_w_wage = len(optim_paras["choices_w_wage"])
-            shifts[:n_choices_w_wage] = np.exp(
-                np.clip(np.diag(shocks_cov)[:n_choices_w_wage], 0, MAX_LOG_FLOAT) / 2
-            )
-
-            # Get indicator for interpolation and simulation of states. The seed value
-            # is the base seed plus the number of the period. Thus, not interpolated
-            # states are held constant for each periods and not across periods.
-            not_interpolated = get_not_interpolated_indicator(
-                options["interpolation_points"],
-                n_states_in_period,
-                next(options["solution_seed_iteration"]),
-            )
-
-            # Constructing the exogenous variable for all states, including the ones
-            # where simulation will take place. All information will be used in either
-            # the construction of the prediction model or the prediction step.
-            exogenous, max_emax = calculate_exogenous_variables(
-                wages, nonpec, continuation_values, shifts, delta, is_inadmissible
-            )
-
-            # Constructing the dependent variables for all states at the random subset
-            # of points where the EMAX is actually calculated.
-            endogenous = calculate_endogenous_variables(
+            interp_points = int(options["interpolation_points"] / n_dense_combinations)
+            period_expected_value_functions = interpolate(
                 wages,
-                nonpec,
+                nonpecs,
                 continuation_values,
-                max_emax,
-                not_interpolated,
-                draws_emax_risk[period],
-                delta,
                 is_inadmissible,
+                period_draws_emax_risk,
+                interp_points,
+                optim_paras,
+                options,
             )
 
-            # Create prediction model based on the random subset of points where the
-            # EMAX is actually simulated and thus dependent and independent variables
-            # are available. For the interpolation points, the actual values are used.
-            emax = get_predictions(endogenous, exogenous, max_emax, not_interpolated)
-
         else:
-            emax = calculate_emax_value_functions(
+            period_expected_value_functions = _full_solution(
                 wages,
-                nonpec,
+                nonpecs,
                 continuation_values,
-                draws_emax_risk[period],
-                delta,
                 is_inadmissible,
+                period_draws_emax_risk,
+                optim_paras,
             )
 
-        state_space.get_attribute_from_period("emax_value_functions", period)[:] = emax
+        state_space.set_attribute_from_period(
+            "expected_value_functions", period_expected_value_functions, period
+        )
 
     return state_space
 
 
-def get_not_interpolated_indicator(interpolation_points, n_states, seed):
-    """Get indicator for states which will be not interpolated.
-
-    Randomness in this function is held constant for each period but not across periods.
-    This is done by adding the period to the seed set for the solution.
-
-    Parameters
-    ----------
-    interpolation_points : int
-        Number of states which will be interpolated.
-    n_states : int
-        Total number of states in period.
-    seed : int
-        Seed to set randomness.
-
-    Returns
-    -------
-    not_interpolated : numpy.ndarray
-        Array of shape (n_states,) indicating states which will not be interpolated.
-
-    """
-    np.random.seed(seed)
-
-    indices = np.random.choice(n_states, size=interpolation_points, replace=False)
-
-    not_interpolated = np.full(n_states, False)
-    not_interpolated[indices] = True
-
-    return not_interpolated
-
-
-def calculate_exogenous_variables(wages, nonpec, emaxs, draws, delta, is_inadmissible):
-    """Calculate exogenous variables for interpolation scheme.
-
-    Parameters
-    ----------
-    wages : numpy.ndarray
-        Array with shape (n_states_in_period, n_wages).
-    nonpec : numpy.ndarray
-        Array with shape (n_states_in_period, n_choices).
-    emaxs : numpy.ndarray
-        Array with shape (n_states_in_period, n_choices).
-    draws : numpy.ndarray
-        Array with shape (n_draws, n_choices).
-    delta : float
-        Discount factor.
-    is_inadmissible : numpy.ndarray
-        Array with shape (n_states_in_period,) containing an indicator for whether the
-        state has reached maximum education.
-
-    Returns
-    -------
-    exogenous : numpy.ndarray
-        Array with shape (n_states_in_period, n_choices * 2 + 1).
-    max_emax : numpy.ndarray
-        Array with shape (n_states_in_period,) containing maximum over all value
-        functions.
-
-    """
-    value_functions, _ = calculate_value_functions_and_flow_utilities(
-        wages, nonpec, emaxs, draws, delta, is_inadmissible
-    )
-
-    max_value_functions = value_functions.max(axis=1)
-    exogenous = max_value_functions.reshape(-1, 1) - value_functions
-
-    exogenous = np.column_stack(
-        (exogenous, np.sqrt(exogenous), np.ones(exogenous.shape[0]))
-    )
-
-    return exogenous, max_value_functions
-
-
-def calculate_endogenous_variables(
+@parallelize_across_dense_dimensions
+def _full_solution(
     wages,
-    nonpec,
+    nonpecs,
     continuation_values,
-    max_value_functions,
-    not_interpolated,
-    draws,
-    delta,
     is_inadmissible,
+    period_draws_emax_risk,
+    optim_paras,
 ):
-    """Calculate endogenous variable for all states which are not interpolated.
+    """Calculate the full solution of the model.
 
-    Parameters
-    ----------
-    wages : numpy.ndarray
-        Array with shape (n_states_in_period, n_wages).
-    nonpec : numpy.ndarray
-        Array with shape (n_states_in_period, n_choices).
-    continuation_values : numpy.ndarray
-        Array with shape (n_states_in_period, n_choices).
-    max_value_functions : numpy.ndarray
-        Array with shape (n_states_in_period,) containing maximum over all value
-        functions.
-    not_interpolated : numpy.ndarray
-        Array with shape (n_states_in_period,) containing indicators for simulated
-        continuation_values.
-    draws : numpy.ndarray
-        Array with shape (n_draws, n_choices) containing draws.
-    delta : float
-        Discount factor.
-    is_inadmissible : numpy.ndarray
-        Array with shape (n_states_in_period,) containing an indicator for whether the
-        state has reached maximum education.
+    In contrast to approximate solution, the Monte Carlo integration is done for each
+    state and not only a subset.
 
     """
-    emax_value_functions = calculate_emax_value_functions(
-        wages[not_interpolated],
-        nonpec[not_interpolated],
-        continuation_values[not_interpolated],
-        draws,
-        delta,
-        is_inadmissible[not_interpolated],
+    period_expected_value_functions = calculate_expected_value_functions(
+        wages,
+        nonpecs,
+        continuation_values,
+        period_draws_emax_risk,
+        optim_paras["delta"],
+        is_inadmissible,
     )
-    endogenous = emax_value_functions - max_value_functions[not_interpolated]
-
-    return endogenous
-
-
-def get_predictions(endogenous, exogenous, max_value_functions, not_interpolated):
-    """Get predictions for the emax of interpolated states.
-
-    Fit an OLS regression of the exogenous variables on the endogenous variables and use
-    the results to predict the endogenous variables for all points in state space. Then,
-    replace emax values for not interpolated states with true value.
 
-    Parameters
-    ----------
-    endogenous : numpy.ndarray
-        Array with shape (num_simulated_states_in_period,) containing emax for states
-        used to interpolate the rest.
-    exogenous : numpy.ndarray
-        Array with shape (n_states_in_period, n_choices * 2 + 1) containing exogenous
-        variables.
-    max_value_functions : numpy.ndarray
-        Array with shape (n_states_in_period,) containing the maximum over all value
-        functions.
-    not_interpolated : numpy.ndarray
-        Array with shape (n_states_in_period,) containing indicator for states which
-        are not interpolated and used to estimate the coefficients for the
-        interpolation.
-
-    """
-    # Define ordinary least squares model and fit to the data.
-    beta = ols(endogenous, exogenous[not_interpolated])
-
-    # Use the model to predict EMAX for all states. As in Keane & Wolpin (1994),
-    # negative predictions are truncated to zero.
-    endogenous_predicted = exogenous.dot(beta)
-    endogenous_predicted = clip(endogenous_predicted, 0)
-
-    # Construct predicted EMAX for all states and the
-    predictions = endogenous_predicted + max_value_functions
-    predictions[not_interpolated] = endogenous + max_value_functions[not_interpolated]
-
-    if not np.all(np.isfinite(beta)):
-        warnings.warn("OLS coefficients in the interpolation are not finite.")
-
-    return predictions
-
-
-@nb.guvectorize(
-    ["f8[:], f8[:], f8[:], f8[:, :], f8, b1[:], f8[:]"],
-    "(n_choices), (n_choices), (n_choices), (n_draws, n_choices), (), (n_choices) "
-    "-> ()",
-    nopython=True,
-    target="parallel",
-)
-def calculate_emax_value_functions(
-    wages,
-    nonpec,
-    continuation_values,
-    draws,
-    delta,
-    is_inadmissible,
-    emax_value_functions,
-):
-    r"""Calculate the expected maximum of value functions for a set of unobservables.
-
-    The function takes an agent and calculates the utility for each of the choices, the
-    ex-post rewards, with multiple draws from the distribution of unobservables and adds
-    the discounted expected maximum utility of subsequent periods resulting from
-    choices. Averaging over all maximum utilities yields the expected maximum utility of
-    this state.
-
-    The underlying process in this function is called `Monte Carlo integration`_. The
-    goal is to approximate an integral by evaluating the integrand at randomly chosen
-    points. In this setting, one wants to approximate the expected maximum utility of
-    the current state.
-
-    Note that ``wages`` have the same length as ``nonpec`` despite that wages are only
-    available in some choices. Missing choices are filled with ones. In the case of a
-    choice with wage and without wage, flow utilities are
-
-    .. math::
-
-        \text{Flow Utility} = \text{Wage} * \epsilon + \text{Non-pecuniary}
-        \text{Flow Utility} = 1 * \epsilon + \text{Non-pecuniary}
-
-
-    Parameters
-    ----------
-    wages : numpy.ndarray
-        Array with shape (n_choices,) containing wages.
-    nonpec : numpy.ndarray
-        Array with shape (n_choices,) containing non-pecuniary rewards.
-    continuation_values : numpy.ndarray
-        Array with shape (n_choices,) containing expected maximum utility for each
-        choice in the subsequent period.
-    draws : numpy.ndarray
-        Array with shape (n_draws, n_choices).
-    delta : float
-        The discount factor.
-    is_inadmissible: numpy.ndarray
-        Array with shape (n_choices,) containing indicator for whether the following
-        state is inadmissible.
-
-    Returns
-    -------
-    emax_value_functions : float
-        Expected maximum utility of an agent.
-
-    .. _Monte Carlo integration:
-        https://en.wikipedia.org/wiki/Monte_Carlo_integration
-
-    """
-    n_draws, n_choices = draws.shape
-
-    emax_value_functions[0] = 0
-
-    for i in range(n_draws):
-
-        max_value_functions = 0
-
-        for j in range(n_choices):
-            value_function, _ = aggregate_keane_wolpin_utility(
-                wages[j],
-                nonpec[j],
-                continuation_values[j],
-                draws[i, j],
-                delta,
-                is_inadmissible[j],
-            )
-
-            if value_function > max_value_functions:
-                max_value_functions = value_function
-
-        emax_value_functions[0] += max_value_functions
-
-    emax_value_functions[0] /= n_draws
-
-
-@nb.njit
-def ols(y, x):
-    """Calculate OLS coefficients using a pseudo-inverse.
-
-    Parameters
-    ----------
-    x : numpy.ndarray
-        n x n matrix of independent variables.
-    y : numpy.ndarray
-        n x 1 matrix with dependent variable.
-
-    Returns
-    -------
-    beta : numpy.ndarray
-        n x 1 array of estimated parameter vector
-
-    """
-    beta = np.dot(np.linalg.pinv(x.T.dot(x)), x.T.dot(y))
-    return beta
-
-
-def mse(x1, x2, axis=0):
-    """Calculate mean squared error.
-
-    If ``x1`` and ``x2`` have different shapes, then they need to broadcast. This uses
-    :func:`numpy.asanyarray` to convert the input. Whether this is the desired result or
-    not depends on the array subclass, for example NumPy matrices will silently
-    produce an incorrect result.
-
-    Parameters
-    ----------
-    x1, x2 : array_like
-       The performance measure depends on the difference between these two arrays.
-    axis : int
-       Axis along which the summary statistic is calculated
-
-    Returns
-    -------
-    mse : numpy.ndarray or float
-       Mean squared error along given axis.
-
-    """
-    x1 = np.asanyarray(x1)
-    x2 = np.asanyarray(x2)
-    return np.mean((x1 - x2) ** 2, axis=axis)
-
-
-def rmse(x1, x2, axis=0):
-    """Calculate root mean squared error.
-
-    If ``x1`` and ``x2`` have different shapes, then they need to broadcast. This uses
-    :func:`numpy.asanyarray` to convert the input. Whether this is the desired result or
-    not depends on the array subclass, for example NumPy matrices will silently
-    produce an incorrect result.
-
-    Parameters
-    ----------
-    x1, x2 : array_like
-       The performance measure depends on the difference between these two arrays.
-    axis : int
-       Axis along which the summary statistic is calculated.
-
-    Returns
-    -------
-    rmse : numpy.ndarray or float
-       Root mean squared error along given axis.
-
-    """
-    x1 = np.asanyarray(x1)
-    x2 = np.asanyarray(x2)
-    return np.sqrt(mse(x1, x2, axis=axis))
+    return period_expected_value_functions
diff --git a/respy/state_space.py b/respy/state_space.py
index f1efbc90a..7d9a2c21e 100644
--- a/respy/state_space.py
+++ b/respy/state_space.py
@@ -8,18 +8,142 @@
 from respy._numba import array_to_tuple
 from respy.config import INDEXER_DTYPE
 from respy.config import INDEXER_INVALID_INDEX
-from respy.config import MAX_LOG_FLOAT
-from respy.config import MIN_LOG_FLOAT
-from respy.shared import create_base_covariates
+from respy.shared import cast_bool_to_numeric
+from respy.shared import compute_covariates
 from respy.shared import create_base_draws
+from respy.shared import create_core_state_space_columns
+from respy.shared import create_dense_state_space_columns
 from respy.shared import downcast_to_smallest_dtype
 
 
-class StateSpace:
+def create_state_space_class(optim_paras, options):
+    """Create the state space of the model."""
+    core, indexer = _create_core_and_indexer(optim_paras, options)
+    dense_grid = _create_dense_state_space_grid(optim_paras)
+
+    # Downcast after calculations or be aware of silent integer overflows.
+    core = compute_covariates(core, options["covariates_core"])
+    core = core.apply(downcast_to_smallest_dtype)
+    dense = _create_dense_state_space_covariates(dense_grid, optim_paras, options)
+
+    base_draws_sol = create_base_draws(
+        (options["n_periods"], options["solution_draws"], len(optim_paras["choices"])),
+        next(options["solution_seed_startup"]),
+        options["monte_carlo_sequence"],
+    )
+
+    if dense:
+        state_space = _MultiDimStateSpace(
+            core, indexer, base_draws_sol, optim_paras, options, dense
+        )
+    else:
+        state_space = _SingleDimStateSpace(
+            core, indexer, base_draws_sol, optim_paras, options
+        )
+
+    return state_space
+
+
+class _BaseStateSpace:
+    """The base class of a state space.
+
+    The base class includes some methods which should be available to both state spaces
+    and are shared between multiple sub state spaces.
+
+    """
+
+    def _create_slices_by_core_periods(self):
+        """Create slices to index all attributes in a given period.
+
+        It is important that the returned objects are not fancy indices. Fancy indexing
+        results in copies of array which decrease performance and raise memory usage.
+
+        """
+        period = self.core.period
+        indices = np.where(period - period.shift(1).fillna(-1) == 1)[0]
+        indices = np.append(indices, self.core.shape[0])
+
+        slices = [slice(indices[i], indices[i + 1]) for i in range(len(indices) - 1)]
+
+        return slices
+
+    def _create_is_inadmissible(self, optim_paras, options):
+        core = self.core.copy()
+        # Apply the maximum experience as a default constraint only if its not the last
+        # period. Otherwise, it is unconstrained.
+        for choice in optim_paras["choices_w_exp"]:
+            max_exp = optim_paras["choices"][choice]["max"]
+            formula = (
+                f"exp_{choice} == {max_exp}"
+                if max_exp != optim_paras["n_periods"] - 1
+                else "False"
+            )
+            core[choice] = core.eval(formula)
+
+        # Apply no constraint for choices without experience.
+        for choice in optim_paras["choices_wo_exp"]:
+            core[choice] = core.eval("False")
+
+        # Apply user-defined constraints
+        for choice in optim_paras["choices"]:
+            for formula in options["inadmissible_states"].get(choice, []):
+                core[choice] |= core.eval(formula)
+
+        is_inadmissible = core[optim_paras["choices"]].to_numpy(dtype=np.bool)
+
+        return is_inadmissible
+
+    def _create_indices_of_child_states(self, optim_paras):
+        """For each parent state get the indices of child states.
+
+        During the backward induction, the ``expected_value_functions`` in the future
+        period serve as the ``continuation_values`` of the current period. As the
+        indices for child states never change, these indices can be precomputed and
+        added to the state_space.
+
+        Actually, the indices of the child states do not have to cover the last period,
+        but it makes the code prettier and reduces the need to expand the indices in the
+        estimation.
+
+        """
+        n_choices = len(optim_paras["choices"])
+        n_choices_w_exp = len(optim_paras["choices_w_exp"])
+        n_periods = optim_paras["n_periods"]
+        n_states = self.core.shape[0]
+        core_columns = create_core_state_space_columns(optim_paras)
+
+        indices = np.full(
+            (n_states, n_choices), INDEXER_INVALID_INDEX, dtype=INDEXER_DTYPE
+        )
+
+        # Skip the last period which does not have child states.
+        for period in reversed(range(n_periods - 1)):
+            states_in_period = self.core.query("period == @period")[
+                core_columns
+            ].to_numpy(dtype=np.int8)
+
+            indices = _insert_indices_of_child_states(
+                indices,
+                states_in_period,
+                self.indexer[period],
+                self.indexer[period + 1],
+                self.is_inadmissible,
+                n_choices_w_exp,
+                optim_paras["n_lagged_choices"],
+            )
+
+        return indices
+
+
+class _SingleDimStateSpace(_BaseStateSpace):
     """The state space of a discrete choice dynamic programming model.
 
     Parameters
     ----------
+    core : pandas.DataFrame
+        DataFrame containing the core state space.
+    indexer : numpy.ndarray
+        Multidimensional array containing indices of states in valid positions.
     optim_paras : dict
         Dictionary containing model parameters.
     options : dict
@@ -44,110 +168,75 @@ class StateSpace:
         Array with shape (n_states, n_choices + 3) containing containing the emax of
         each choice of the subsequent period and the simulated or interpolated maximum
         of the current period.
-    emax_value_functions : numpy.ndarray
+    expected_value_functions : numpy.ndarray
         Array with shape (n_states, 1) containing the expected maximum of
         choice-specific value functions.
 
     """
 
-    def __init__(self, optim_paras, options):
-        """Initialize the state space class."""
-        self.base_draws_sol = create_base_draws(
-            (
-                options["n_periods"],
-                options["solution_draws"],
-                len(optim_paras["choices"]),
-            ),
-            next(options["solution_seed_startup"]),
-            options["monte_carlo_sequence"],
+    def __init__(
+        self,
+        core,
+        indexer,
+        base_draws_sol,
+        optim_paras,
+        options,
+        dense_dim=None,
+        dense_covariates=None,
+        is_inadmissible=None,
+        indices_of_child_states=None,
+        slices_by_periods=None,
+    ):
+        self.dense_dim = dense_dim
+        self.core = core
+        self.indexer = indexer
+        self.dense_covariates = dense_covariates if dense_covariates is not None else {}
+        self.mixed_covariates = options["covariates_mixed"]
+        self.base_draws_sol = base_draws_sol
+        self.slices_by_periods = (
+            super()._create_slices_by_core_periods()
+            if slices_by_periods is None
+            else slices_by_periods
         )
-
-        states_df, self.indexer = _create_state_space(optim_paras, options)
-
-        base_covariates_df = create_base_covariates(states_df, options["covariates"])
-
-        # Downcast after calculations or be aware of silent integer overflows.
-        states_df = states_df.apply(downcast_to_smallest_dtype)
-        base_covariates_df = base_covariates_df.apply(downcast_to_smallest_dtype)
-        self.states = states_df.to_numpy()
-
-        self.covariates = _create_choice_covariates(
-            base_covariates_df, states_df, optim_paras
+        self._initialize_attributes(optim_paras)
+        self.is_inadmissible = (
+            self._create_is_inadmissible(optim_paras, options)
+            if is_inadmissible is None
+            else is_inadmissible
         )
-
-        self.wages, self.nonpec = _create_reward_components(
-            self.states[:, -1], self.covariates, optim_paras
-        )
-
-        self.is_inadmissible = _create_is_inadmissible_indicator(
-            states_df, optim_paras, options
+        self.indices_of_child_states = (
+            super()._create_indices_of_child_states(optim_paras)
+            if indices_of_child_states is None
+            else indices_of_child_states
         )
 
-        self._create_slices_by_periods(options["n_periods"])
-
-        self.indices_of_child_states = _get_indices_of_child_states(self, optim_paras)
-
-    def update_systematic_rewards(self, optim_paras):
-        """Update wages and non-pecuniary rewards.
-
-        During the estimation, the rewards need to be updated according to the new
-        parameters whereas the covariates stay the same.
+    def get_attribute(self, attr):
+        """Get an attribute of the state space."""
+        return getattr(self, attr)
 
-        """
-        self.wages, self.nonpec = _create_reward_components(
-            self.states[:, -1], self.covariates, optim_paras
-        )
-
-    def get_attribute_from_period(self, attr, period):
+    def get_attribute_from_period(self, attribute, period):
         """Get an attribute of the state space sliced to a given period.
 
         Parameters
         ----------
-        attr : str
+        attribute : str
             Attribute name, e.g. ``"states"`` to retrieve ``self.states``.
         period : int
             Attribute is retrieved from this period.
 
         """
-        if attr == "covariates":
-            raise AttributeError("Attribute covariates cannot be retrieved by periods.")
-        else:
-            pass
+        attr = self.get_attribute(attribute)
+        slice_ = self.slices_by_periods[period]
+        out = attr[slice_]
 
-        try:
-            attribute = getattr(self, attr)
-        except AttributeError as e:
-            raise AttributeError(f"StateSpace has no attribute {attr}.").with_traceback(
-                e.__traceback__
-            )
-
-        try:
-            indices = self.slices_by_periods[period]
-        except IndexError as e:
-            raise IndexError(f"StateSpace has no period {period}.").with_traceback(
-                e.__traceback__
-            )
-
-        return attribute[indices]
-
-    def _create_slices_by_periods(self, n_periods):
-        """Create slices to index all attributes in a given period.
-
-        It is important that the returned objects are not fancy indices. Fancy indexing
-        results in copies of array which decrease performance and raise memory usage.
-
-        """
-        self.slices_by_periods = []
-        for i in range(n_periods):
-            idx_start, idx_end = np.where(self.states[:, 0] == i)[0][[0, -1]]
-            self.slices_by_periods.append(slice(idx_start, idx_end + 1))
+        return out
 
     def get_continuation_values(self, period=None, indices=None):
         """Return the continuation values for a given period or states.
 
         If the last period is selected, return a matrix of zeros. In any other period,
-        use the precomputed ``indices_of_child_states`` to select continuation values
-        from ``emax_value_functions``.
+        use the precomputed `indices_of_child_states` to select continuation values from
+        `expected_value_functions`.
 
         You can also indices to collect continuation values across periods.
 
@@ -170,12 +259,12 @@ def get_continuation_values(self, period=None, indices=None):
         if period == n_periods - 1:
             last_slice = self.slices_by_periods[-1]
             n_states_last_period = len(range(last_slice.start, last_slice.stop))
-            n_choices = self.is_inadmissible.shape[1]
+            n_choices = self.get_attribute("is_inadmissible").shape[1]
             continuation_values = np.zeros((n_states_last_period, n_choices))
 
         else:
             if indices is not None:
-                child_indices = self.indices_of_child_states[indices]
+                child_indices = self.get_attribute("indices_of_child_states")[indices]
             elif period is not None and 0 <= period <= n_periods - 2:
                 child_indices = self.get_attribute_from_period(
                     "indices_of_child_states", period
@@ -186,13 +275,111 @@ def get_continuation_values(self, period=None, indices=None):
             mask = child_indices != INDEXER_INVALID_INDEX
             valid_indices = np.where(mask, child_indices, 0)
             continuation_values = np.where(
-                mask, self.emax_value_functions[valid_indices], 0
+                mask, self.get_attribute("expected_value_functions")[valid_indices], 0
             )
 
         return continuation_values
 
+    def set_attribute(self, attribute, value):
+        self.get_attribute(attribute)[:] = value
+
+    def set_attribute_from_period(self, attribute, value, period):
+        self.get_attribute_from_period(attribute, period)[:] = value
+
+    @property
+    def states(self):
+        states = self.core.copy().assign(**self.dense_covariates)
+        states = compute_covariates(states, self.mixed_covariates)
+        states = cast_bool_to_numeric(states)
+        return states
+
+    def _initialize_attributes(self, optim_paras):
+        """Initialize attributes to use references later."""
+        n_states = self.core.shape[0]
+        n_choices = len(optim_paras["choices"])
+        n_choices_w_wage = len(optim_paras["choices_w_wage"])
+        n_choices_wo_wage = n_choices - n_choices_w_wage
+
+        for name, array in (
+            ("expected_value_functions", np.empty(n_states)),
+            (
+                "wages",
+                np.column_stack(
+                    (
+                        np.empty((n_states, n_choices_w_wage)),
+                        np.ones((n_states, n_choices_wo_wage)),
+                    )
+                ),
+            ),
+            ("nonpecs", np.zeros((n_states, n_choices))),
+        ):
+            setattr(self, name, array)
+
+
+class _MultiDimStateSpace(_BaseStateSpace):
+    """The state space of a discrete choice dynamic programming model.
+
+    This class wraps the whole state space of the model.
+
+    """
+
+    def __init__(self, core, indexer, base_draws_sol, optim_paras, options, dense):
+        self.base_draws_sol = base_draws_sol
+        self.core = core
+        self.indexer = indexer
+        self.is_inadmissible = super()._create_is_inadmissible(optim_paras, options)
+        self.indices_of_child_states = super()._create_indices_of_child_states(
+            optim_paras
+        )
+        self.slices_by_periods = super()._create_slices_by_core_periods()
+        self.sub_state_spaces = {
+            dense_dim: _SingleDimStateSpace(
+                self.core,
+                self.indexer,
+                self.base_draws_sol,
+                optim_paras,
+                options,
+                dense_dim,
+                dense_covariates,
+                self.is_inadmissible,
+                self.indices_of_child_states,
+                self.slices_by_periods,
+            )
+            for dense_dim, dense_covariates in dense.items()
+        }
+
+    def get_attribute(self, attribute):
+        return {
+            key: sss.get_attribute(attribute)
+            for key, sss in self.sub_state_spaces.items()
+        }
+
+    def get_attribute_from_period(self, attribute, period):
+        return {
+            key: sss.get_attribute_from_period(attribute, period)
+            for key, sss in self.sub_state_spaces.items()
+        }
+
+    def get_continuation_values(self, period=None, indices=None):
+        return {
+            key: sss.get_continuation_values(period, indices)
+            for key, sss in self.sub_state_spaces.items()
+        }
+
+    def set_attribute(self, attribute, value):
+        for key, sss in self.sub_state_spaces.items():
+            sss.set_attribute(attribute, value[key])
 
-def _create_state_space(optim_paras, options):
+    def set_attribute_from_period(self, attribute, value, period):
+        for key, sss in self.sub_state_spaces.items():
+            sss.set_attribute_from_period(attribute, value[key], period)
+
+    @property
+    def states(self):
+        return {key: sss.states for key, sss in self.sub_state_spaces.items()}
+
+
+def _create_core_and_indexer(optim_paras, options):
     """Create the state space.
 
     The state space of the model are all feasible combinations of the period,
@@ -254,26 +441,22 @@ def _create_state_space(optim_paras, options):
     _create_core_state_space_per_period
     _filter_core_state_space
     _add_initial_experiences_to_core_state_space
-    _create_state_space_indexer
+    _create_core_state_space_indexer
 
     """
-    df = _create_core_state_space(optim_paras)
+    core = _create_core_state_space(optim_paras)
 
-    df = _add_lagged_choice_to_core_state_space(df, optim_paras)
+    core = _add_lagged_choice_to_core_state_space(core, optim_paras)
 
-    df = _filter_core_state_space(df, options)
+    core = _filter_core_state_space(core, options)
 
-    df = _add_initial_experiences_to_core_state_space(df, optim_paras)
+    core = _add_initial_experiences_to_core_state_space(core, optim_paras)
 
-    df = _add_observables_to_state_space(df, optim_paras)
+    core = core.sort_values("period").reset_index(drop=True)
 
-    df = _add_types_to_state_space(df, optim_paras["n_types"])
+    indexer = _create_core_state_space_indexer(core, optim_paras)
 
-    df = df.sort_values("period").reset_index(drop=True)
-
-    indexer = _create_state_space_indexer(df, optim_paras)
-
-    return df, indexer
+    return core, indexer
 
 
 def _create_core_state_space(optim_paras):
@@ -442,37 +625,18 @@ def _add_initial_experiences_to_core_state_space(df, optim_paras):
     return df
 
 
-def _add_observables_to_state_space(df, optim_paras):
+def _create_dense_state_space_grid(optim_paras):
     levels_of_observables = [range(len(i)) for i in optim_paras["observables"].values()]
-    combinations = itertools.product(*levels_of_observables)
+    types = [range(optim_paras["n_types"])] if optim_paras["n_types"] >= 2 else []
 
-    container = []
-    for combination in combinations:
-        df_ = df.copy()
-        df_ = df_.assign(
-            **{col: val for col, val in zip(optim_paras["observables"], combination)}
-        )
-        container.append(df_)
+    dense_state_space_grid = list(itertools.product(*levels_of_observables, *types))
+    if dense_state_space_grid == [()]:
+        dense_state_space_grid = False
 
-    df = pd.concat(container, axis="rows", sort=False) if container else df
+    return dense_state_space_grid
 
-    return df
 
-
-def _add_types_to_state_space(df, n_types):
-    if n_types >= 2:
-        container = []
-        for i in range(n_types):
-            df_ = df.copy()
-            df_["type"] = i
-            container.append(df_)
-
-        df = pd.concat(container, axis="rows", sort=False)
-
-    return df
-
-
-def _create_state_space_indexer(df, optim_paras):
+def _create_core_state_space_indexer(df, optim_paras):
     """Create the indexer for the state space.
 
     The indexer consists of sub indexers for each period. This is much more
@@ -500,26 +664,18 @@ def _create_state_space_indexer(df, optim_paras):
         shape = (
             tuple(np.minimum(max_initial_experience + period, max_experience) + 1)
             + (n_choices,) * optim_paras["n_lagged_choices"]
-            + tuple(len(x) for x in optim_paras["observables"].values())
         )
-        if optim_paras["n_types"] >= 2:
-            shape += (optim_paras["n_types"],)
-
         sub_indexer = np.full(shape, INDEXER_INVALID_INDEX, dtype=INDEXER_DTYPE)
 
         sub_df = df.query("period == @period")
         n_states = sub_df.shape[0]
 
-        indices = (
-            tuple(sub_df[f"exp_{i}"] for i in optim_paras["choices_w_exp"])
-            + tuple(
-                sub_df[f"lagged_choice_{i}"]
-                for i in range(1, optim_paras["n_lagged_choices"] + 1)
-            )
-            + tuple(sub_df[observable] for observable in optim_paras["observables"])
+        indices = tuple(
+            sub_df[f"exp_{i}"] for i in optim_paras["choices_w_exp"]
+        ) + tuple(
+            sub_df[f"lagged_choice_{i}"]
+            for i in range(1, optim_paras["n_lagged_choices"] + 1)
         )
-        if optim_paras["n_types"] >= 2:
-            indices += (sub_df["type"],)
 
         sub_indexer[indices] = np.arange(count_states, count_states + n_states)
         indexer.append(sub_indexer)
@@ -529,152 +685,6 @@ def _create_state_space_indexer(df, optim_paras):
     return indexer
 
 
-def _create_reward_components(types, covariates, optim_paras):
-    """Calculate systematic rewards for each state.
-
-    Wages are only available for some choices, i.e. n_nonpec >= n_wages. We extend the
-    array of wages with ones for the difference in dimensions, n_nonpec - n_wages. Ones
-    are necessary as it facilitates the aggregation of reward components in
-    :func:`calculate_emax_value_functions` and related functions.
-
-    Parameters
-    ----------
-    types : numpy.ndarray
-        Array with shape (n_states,) containing type information.
-    covariates : dict
-        Dictionary with covariate arrays for wage and nonpec rewards.
-    optim_paras : dict
-        Contains parameters affected by the optimization.
-
-    """
-    wage_labels = [f"wage_{choice}" for choice in optim_paras["choices_w_wage"]]
-    log_wages = np.column_stack(
-        [np.dot(covariates[w], optim_paras[w]) for w in wage_labels]
-    )
-
-    n_states = types.shape[0]
-
-    nonpec_labels = [f"nonpec_{choice}" for choice in optim_paras["choices"]]
-    nonpec = np.column_stack(
-        [
-            np.zeros(n_states)
-            if n not in optim_paras
-            else np.dot(covariates[n], optim_paras[n])
-            for n in nonpec_labels
-        ]
-    )
-
-    wages = np.exp(np.clip(log_wages, MIN_LOG_FLOAT, MAX_LOG_FLOAT))
-
-    # Extend wages to dimension of non-pecuniary rewards.
-    additional_dim = nonpec.shape[1] - log_wages.shape[1]
-    wages = np.column_stack((wages, np.ones((wages.shape[0], additional_dim))))
-
-    return wages, nonpec
-
-
-def _create_choice_covariates(covariates_df, states_df, optim_paras):
-    """Create the covariates for each choice.
-
-    Parameters
-    ----------
-    covariates_df : pandas.DataFrame
-        DataFrame with the basic covariates.
-    states_df : pandas.DataFrame
-        DataFrame with the state information.
-    optim_paras : dict
-        Dictionary of parsed parameters.
-
-    Returns
-    -------
-    covariates : dict
-        Dictionary where values are the wage or non-pecuniary covariates for choices.
-
-    """
-    all_data = pd.concat([covariates_df, states_df], axis="columns", sort=False)
-
-    covariates = {}
-
-    for choice in optim_paras["choices"]:
-        if f"wage_{choice}" in optim_paras:
-            wage_columns = optim_paras[f"wage_{choice}"].index
-            covariates[f"wage_{choice}"] = all_data[wage_columns].to_numpy()
-
-        if f"nonpec_{choice}" in optim_paras:
-            nonpec_columns = optim_paras[f"nonpec_{choice}"].index
-            covariates[f"nonpec_{choice}"] = all_data[nonpec_columns].to_numpy()
-
-    for key, val in covariates.items():
-        covariates[key] = np.ascontiguousarray(val)
-
-    return covariates
-
-
-def _create_is_inadmissible_indicator(states, optim_paras, options):
-    df = states.copy()
-
-    # Apply the maximum experience as a default constraint only if its not the last
-    # period. Otherwise, it is unconstrained.
-    for choice in optim_paras["choices_w_exp"]:
-        max_exp = optim_paras["choices"][choice]["max"]
-        formula = (
-            f"exp_{choice} == {max_exp}"
-            if max_exp != optim_paras["n_periods"] - 1
-            else "False"
-        )
-        df[choice] = df.eval(formula)
-
-    # Apply no constraint for choices without experience.
-    for choice in optim_paras["choices_wo_exp"]:
-        df[choice] = df.eval("False")
-
-    # Apply user-defined constraints
-    for choice in optim_paras["choices"]:
-        for formula in options["inadmissible_states"].get(choice, []):
-            df[choice] |= df.eval(formula)
-
-    is_inadmissible = df[optim_paras["choices"]].to_numpy()
-
-    return is_inadmissible
-
-
-def _get_indices_of_child_states(state_space, optim_paras):
-    """For each parent state get the indices of child states.
-
-    During the backward induction, the ``emax_value_functions`` in the future period
-    serve as the ``continuation_values`` of the current period. As the indices for child
-    states never change, these indices can be precomputed and added to the state_space.
-
-    Actually, the indices of the child states do not have to cover the last period, but
-    it makes the code prettier and reduces the need to expand the indices in the
-    estimation.
-
-    """
-    n_choices = len(optim_paras["choices"])
-    n_choices_w_exp = len(optim_paras["choices_w_exp"])
-    n_periods = optim_paras["n_periods"]
-    n_states = state_space.states.shape[0]
-
-    indices = np.full((n_states, n_choices), INDEXER_INVALID_INDEX, dtype=INDEXER_DTYPE)
-
-    # Skip the last period which does not have child states.
-    for period in reversed(range(n_periods - 1)):
-
-        states_in_period = state_space.get_attribute_from_period("states", period)
-
-        indices = _insert_indices_of_child_states(
-            indices,
-            states_in_period,
-            state_space.indexer[period],
-            state_space.indexer[period + 1],
-            state_space.is_inadmissible,
-            n_choices_w_exp,
-            optim_paras["n_lagged_choices"],
-        )
-
-    return indices
-
-
 @nb.njit
 def _insert_indices_of_child_states(
     indices,
@@ -690,7 +700,7 @@ def _insert_indices_of_child_states(
 
     for i in range(states.shape[0]):
 
-        idx_current = indexer_current[array_to_tuple(indexer_current, states[i, 1:])]
+        idx_current = indexer_current[array_to_tuple(indexer_current, states[i])]
 
         for choice in range(n_choices):
             # Check if the state in the future is admissible.
@@ -698,7 +708,7 @@ def _insert_indices_of_child_states(
                 continue
             else:
                 # Cut off the period which is not necessary for the indexer.
-                child = states[i, 1:].copy()
+                child = states[i].copy()
 
                 # Increment experience if it is a choice with experience
                 # accumulation.
@@ -718,3 +728,26 @@ def _insert_indices_of_child_states(
                 indices[idx_current, choice] = idx_future
 
     return indices
+
+
+def _create_dense_state_space_covariates(dense_grid, optim_paras, options):
+    if dense_grid:
+        columns = create_dense_state_space_columns(optim_paras)
+
+        df = pd.DataFrame(data=dense_grid, columns=columns).set_index(
+            columns, drop=False
+        )
+
+        covariates = compute_covariates(df, options["covariates_dense"])
+        covariates = covariates.apply(downcast_to_smallest_dtype)
+        covariates = covariates.to_dict(orient="index")
+
+        # Convert scalar keys to tuples.
+        for key in covariates.copy():
+            if np.isscalar(key):
+                covariates[(key,)] = covariates.pop(key)
+
+    else:
+        covariates = False
+
+    return covariates
diff --git a/respy/tests/random_model.py b/respy/tests/random_model.py
index e15b4343c..c833392b9 100644
--- a/respy/tests/random_model.py
+++ b/respy/tests/random_model.py
@@ -138,8 +138,9 @@ def generate_random_model(
     observables = point_constr.pop("observables", None)
     if observables is None:
         n_observables = np.random.randint(0, 3)
+        # Do not sample observables with 1 level!
         observables = (
-            np.random.randint(1, 4, size=n_observables) if n_observables else False
+            np.random.randint(2, 4, size=n_observables) if n_observables else False
         )
 
     if observables is not False:
@@ -148,7 +149,7 @@ def generate_random_model(
             observable_prob_template(observables),
             observable_coeffs_template(observables, params),
         ]
-        params = pd.concat(to_concat, axis=0, sort=False)
+        params = pd.concat(to_concat, axis="rows", sort=False)
 
         indices = (
             params.index.get_level_values("category")
diff --git a/respy/tests/test_interpolate.py b/respy/tests/test_interpolate.py
new file mode 100644
index 000000000..4e32be89e
--- /dev/null
+++ b/respy/tests/test_interpolate.py
@@ -0,0 +1,11 @@
+from respy.solve import get_solve_func
+from respy.tests.random_model import generate_random_model
+
+
+def test_simple_run():
+    params, options = generate_random_model(
+        point_constr={"n_periods": 5, "interpolation_points": 10}
+    )
+
+    solve = get_solve_func(params, options)
+    solve(params)
diff --git a/respy/tests/test_model.py b/respy/tests/test_model.py
index 3b140563c..8be015f02 100644
--- a/respy/tests/test_model.py
+++ b/respy/tests/test_model.py
@@ -10,9 +10,9 @@
 from respy.likelihood import get_crit_func
 from respy.pre_processing.model_checking import validate_options
 from respy.pre_processing.model_processing import _convert_labels_in_formulas_to_codes
-from respy.pre_processing.model_processing import _identify_relevant_covariates
 from respy.pre_processing.model_processing import _parse_initial_and_max_experience
 from respy.pre_processing.model_processing import process_params_and_options
+from respy.pre_processing.process_covariates import remove_irrelevant_covariates
 from respy.tests.random_model import generate_random_model
 from respy.tests.random_model import simulate_truncated_data
 from respy.tests.utils import process_model_or_seed
@@ -159,7 +159,7 @@ def test_identify_relevant_covariates():
         }
     }
 
-    relevant_covariates = _identify_relevant_covariates(options, params)
+    relevant_covariates = remove_irrelevant_covariates(options, params)
 
     expected = {
         "covariates": {
diff --git a/respy/tests/test_randomness.py b/respy/tests/test_randomness.py
index 13ca83e8a..ff46657e3 100644
--- a/respy/tests/test_randomness.py
+++ b/respy/tests/test_randomness.py
@@ -2,7 +2,10 @@
 import numpy as np
 import pytest
 
-import respy as rp
+from respy.likelihood import get_crit_func
+from respy.simulate import get_simulate_func
+from respy.solve import get_solve_func
+from respy.tests.utils import apply_to_attributes_of_two_state_spaces
 from respy.tests.utils import process_model_or_seed
 
 
@@ -12,23 +15,37 @@ def test_invariance_of_model_solution_in_solve_and_criterion_functions(model):
 
     options["n_periods"] = 2 if model == "kw_2000" else 3
 
-    state_space = rp.solve(params, options)
+    solve = get_solve_func(params, options)
+    state_space = solve(params)
 
-    simulate = rp.get_simulate_func(params, options)
+    simulate = get_simulate_func(params, options)
     df = simulate(params)
-    state_space_sim = simulate.keywords["state_space"]
+    state_space_sim = simulate.keywords["solve"].keywords["state_space"]
 
-    criterion = rp.get_crit_func(params, options, df)
+    criterion = get_crit_func(params, options, df)
     _ = criterion(params)
-    state_space_crit = criterion.keywords["state_space"]
+    state_space_crit = criterion.keywords["solve"].keywords["state_space"]
 
     for state_space_ in [state_space_sim, state_space_crit]:
-        np.testing.assert_array_equal(state_space.states, state_space_.states)
-        np.testing.assert_array_equal(state_space.wages, state_space_.wages)
-        np.testing.assert_array_equal(state_space.nonpec, state_space_.nonpec)
-        np.testing.assert_array_equal(
-            state_space.emax_value_functions, state_space_.emax_value_functions
+        assert state_space.core.equals(state_space_.core)
+
+        apply_to_attributes_of_two_state_spaces(
+            state_space.get_attribute("wages"),
+            state_space_.get_attribute("wages"),
+            np.testing.assert_array_equal,
+        )
+        apply_to_attributes_of_two_state_spaces(
+            state_space.get_attribute("nonpecs"),
+            state_space_.get_attribute("nonpecs"),
+            np.testing.assert_array_equal,
+        )
+        apply_to_attributes_of_two_state_spaces(
+            state_space.get_attribute("expected_value_functions"),
+            state_space_.get_attribute("expected_value_functions"),
+            np.testing.assert_array_equal,
         )
-        np.testing.assert_array_equal(
-            state_space.base_draws_sol, state_space_.base_draws_sol
+        apply_to_attributes_of_two_state_spaces(
+            state_space.get_attribute("base_draws_sol"),
+            state_space_.get_attribute("base_draws_sol"),
+            np.testing.assert_array_equal,
         )
diff --git a/respy/tests/test_solve.py b/respy/tests/test_solve.py
index d87247f90..58fef4285 100644
--- a/respy/tests/test_solve.py
+++ b/respy/tests/test_solve.py
@@ -1,18 +1,21 @@
 import numpy as np
+import pandas as pd
 import pytest
 
-import respy as rp
 from respy.config import EXAMPLE_MODELS
 from respy.config import INDEXER_INVALID_INDEX
 from respy.config import KEANE_WOLPIN_1994_MODELS
 from respy.config import KEANE_WOLPIN_1997_MODELS
 from respy.pre_processing.model_checking import check_model_solution
 from respy.pre_processing.model_processing import process_params_and_options
-from respy.state_space import _create_state_space
+from respy.shared import create_core_state_space_columns
+from respy.solve import get_solve_func
+from respy.state_space import _create_core_and_indexer
 from respy.state_space import _insert_indices_of_child_states
 from respy.tests._former_code import _create_state_space_kw94
 from respy.tests._former_code import _create_state_space_kw97_base
 from respy.tests._former_code import _create_state_space_kw97_extended
+from respy.tests.utils import apply_to_attributes_of_two_state_spaces
 from respy.tests.utils import process_model_or_seed
 
 
@@ -20,7 +23,8 @@
 def test_check_solution(model_or_seed):
     params, options = process_model_or_seed(model_or_seed)
 
-    state_space = rp.solve(params, options)
+    solve = get_solve_func(params, options)
+    state_space = solve(params)
 
     optim_paras, options = process_params_and_options(params, options)
 
@@ -45,23 +49,26 @@ def test_state_space_restrictions_by_traversing_forward(model):
     params, options = process_model_or_seed(model)
     optim_paras, options = process_params_and_options(params, options)
 
-    state_space = rp.solve(params, options)
+    solve = get_solve_func(params, options)
+    state_space = solve(params)
 
     indices = np.full(
-        (state_space.states.shape[0], len(optim_paras["choices"])),
-        INDEXER_INVALID_INDEX,
+        (state_space.core.shape[0], len(optim_paras["choices"])), INDEXER_INVALID_INDEX
     )
+    core_columns = create_core_state_space_columns(optim_paras)
 
     for period in range(options["n_periods"] - 1):
 
         if period == 0:
-            states = state_space.get_attribute_from_period("states", period)
-        else:
-            indices_period = state_space.get_attribute_from_period(
-                "indices_of_child_states", period - 1
+            states = state_space.core.query("period == 0")[core_columns].to_numpy(
+                np.int
             )
+        else:
+            indices_period = state_space.indices_of_child_states[
+                state_space.slices_by_periods[period - 1]
+            ]
             indices_period = indices_period[indices_period >= 0]
-            states = state_space.states[indices_period]
+            states = state_space.core[core_columns].to_numpy(np.int)[indices_period]
 
         indices = _insert_indices_of_child_states(
             indices,
@@ -75,10 +82,10 @@ def test_state_space_restrictions_by_traversing_forward(model):
 
     # Take all valid indices and add the indices of the first period.
     set_valid_indices = set(indices[indices != INDEXER_INVALID_INDEX]) | set(
-        range(state_space.get_attribute_from_period("states", 0).shape[0])
+        range(state_space.core.query("period == 0").shape[0])
     )
 
-    assert set_valid_indices == set(range(state_space.states.shape[0]))
+    assert set_valid_indices == set(range(state_space.core.shape[0]))
 
 
 @pytest.mark.parametrize("model_or_seed", EXAMPLE_MODELS)
@@ -92,17 +99,32 @@ def test_invariance_of_solution(model_or_seed):
 
     optim_paras, options = process_params_and_options(params, options)
 
-    state_space = rp.solve(params, options)
-    state_space_ = rp.solve(params, options)
+    solve = get_solve_func(params, options)
+    state_space = solve(params)
+    state_space_ = solve(params)
 
-    np.testing.assert_array_equal(state_space.states, state_space_.states)
-    np.testing.assert_array_equal(state_space.wages, state_space_.wages)
-    np.testing.assert_array_equal(state_space.nonpec, state_space_.nonpec)
-    np.testing.assert_array_equal(
-        state_space.emax_value_functions, state_space_.emax_value_functions
+    apply_to_attributes_of_two_state_spaces(
+        state_space.core, state_space_.core, np.testing.assert_array_equal
+    )
+    apply_to_attributes_of_two_state_spaces(
+        state_space.get_attribute("wages"),
+        state_space_.get_attribute("wages"),
+        np.testing.assert_array_equal,
     )
-    np.testing.assert_array_equal(
-        state_space.base_draws_sol, state_space_.base_draws_sol
+    apply_to_attributes_of_two_state_spaces(
+        state_space.get_attribute("nonpecs"),
+        state_space_.get_attribute("nonpecs"),
+        np.testing.assert_array_equal,
+    )
+    apply_to_attributes_of_two_state_spaces(
+        state_space.get_attribute("expected_value_functions"),
+        state_space_.get_attribute("expected_value_functions"),
+        np.testing.assert_array_equal,
+    )
+    apply_to_attributes_of_two_state_spaces(
+        state_space.get_attribute("base_draws_sol"),
+        state_space_.get_attribute("base_draws_sol"),
+        np.testing.assert_array_equal,
     )
 
 
@@ -123,13 +145,13 @@ def test_create_state_space_vs_specialized_kw94(model):
     states_old, indexer_old = _create_state_space_kw94(
         n_periods, n_types, edu_starts, edu_max
     )
-    if n_types < 2:
+    if n_types == 1:
         states_old = states_old[:, :-1]
         for i, idx in enumerate(indexer_old):
             shape = idx.shape
             indexer_old[i] = idx.reshape(shape[:-2] + (-1,))
 
-    states_new, indexer_new = _create_state_space(optim_paras, options)
+    states_new, indexer_new = _create_core_and_indexer(optim_paras, options)
 
     # Compare the state spaces via sets as ordering changed in some cases.
     states_old_set = set(map(tuple, states_old))
@@ -167,13 +189,14 @@ def test_create_state_space_vs_specialized_kw97(model):
         states_old, indexer_old = _create_state_space_kw97_extended(
             n_periods, n_types, edu_starts, edu_max
         )
-    if n_types < 2:
+    if n_types == 1:
         states_old = states_old[:, :-1]
         for i, idx in enumerate(indexer_old):
             shape = idx.shape
             indexer_old[i] = idx.reshape(shape[:-2] + (-1,))
 
-    states_new, indexer_new = _create_state_space(optim_paras, options)
+    states_new, indexer_new = _create_core_and_indexer(optim_paras, options)
+    states_new = pd.concat([states_new.copy().assign(type=i) for i in range(4)])
 
     # Compare the state spaces via sets as ordering changed in some cases.
     states_old_set = set(map(tuple, states_old))
@@ -184,4 +207,5 @@ def test_create_state_space_vs_specialized_kw97(model):
     for period in range(n_periods):
         mask_old = indexer_old[period] != INDEXER_INVALID_INDEX
         mask_new = indexer_new[period] != INDEXER_INVALID_INDEX
-        assert np.array_equal(mask_old, mask_new)
+        adj_mask_new = np.repeat(mask_new, 4).reshape(mask_old.shape)
+        assert np.array_equal(mask_old, adj_mask_new)
diff --git a/respy/tests/utils.py b/respy/tests/utils.py
index a1195ec0d..56606b2f1 100644
--- a/respy/tests/utils.py
+++ b/respy/tests/utils.py
@@ -21,3 +21,17 @@ def process_model_or_seed(model_or_seed=None, **kwargs):
         options["n_periods"] = 3
 
     return params, options
+
+
+def apply_to_attributes_of_two_state_spaces(attr_1, attr_2, func):
+    """Apply a function to two state space attributes, dense or not.
+
+    Attributes might be `state_space.wages` which can be a dictionary or a Numpy array.
+
+    """
+    if isinstance(attr_1, dict):
+        out = {key: func(attr_1[key], attr_2[key]) for key in attr_1}
+    else:
+        out = func(attr_1, attr_2)
+
+    return out
diff --git a/setup.py b/setup.py
index eb6157042..47e32e7cf 100644
--- a/setup.py
+++ b/setup.py
@@ -9,6 +9,7 @@
     "respy is a Python package for the simulation and estimation of a prototypical "
     "finite-horizon dynamic discrete choice model."
 )
+EMAIL = "respy.9b46528f81292a712fa4855ff362f40f.show-sender@streams.zulipchat.com"
 README = Path("README.rst").read_text()
 PROJECT_URLS = {
     "Bug Tracker": "https://github.com/OpenSourceEconomics/respy/issues",
@@ -23,8 +24,8 @@
     description=DESCRIPTION,
     long_description=DESCRIPTION + "\n\n" + README,
     long_description_content_type="text/x-rst",
-    author="Philipp Eisenhauer",
-    author_email="eisenhauer@policy-lab.org",
+    author="The respy Development Team",
+    author_email=EMAIL,
     python_requires=">=3.6.0",
     url="https://respy.readthedocs.io/en/latest/",
     project_urls=PROJECT_URLS,
@@ -45,7 +46,7 @@
             "tests/resources/*.pickle",
             "tests/resources/*.yaml",
             "tox.ini",
-        ],
+        ]
     },
     include_package_data=True,
     zip_safe=False,
diff --git a/tox.ini b/tox.ini
index 0937ba432..3784bd96f 100644
--- a/tox.ini
+++ b/tox.ini
@@ -15,6 +15,7 @@ conda_deps =
     codecov
     conda-build
     estimagic >= 0.0.14
+    joblib
     mkl
     numba
     numpy
@@ -78,6 +79,7 @@ per-file-ignores =
     respy/tests/*:D
     development/*:D
     respy/pre_processing/specification_helpers.py:D
+    respy/parallelization.py:D202,E800
 
 [pytest]
 junit_family = xunit2
@@ -96,3 +98,4 @@ filterwarnings =
     ignore: the imp module is deprecated
     ignore: The probabilities for parameter group
     ignore: The distribution of initial lagged choices is insufficiently specified
+    ignore: Observable 'observable_