From e14860587a9e1e29e7bb244a3b850632376f8a50 Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Tue, 27 Jan 2026 13:59:33 +0100
Subject: [PATCH 01/18] [pre-commit.ci] pre-commit autoupdate (#18)

---
 .pre-commit-config.yaml                 | 14 +++++++-------
 src/upper_envelope/fues_jax/fues_jax.py |  7 +++----
 tests/test_fues_numba.py                |  6 +++---
 3 files changed, 13 insertions(+), 14 deletions(-)

diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index 80e3965..548f73b 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -10,11 +10,11 @@ repos:
     hooks:
       - id: yamllint
   - repo: https://github.com/lyz-code/yamlfix
-    rev: 1.17.0
+    rev: 1.19.1
     hooks:
       - id: yamlfix
   - repo: https://github.com/pre-commit/pre-commit-hooks
-    rev: v5.0.0
+    rev: v6.0.0
     hooks:
       - id: check-added-large-files
         args:
@@ -42,7 +42,7 @@ repos:
       - id: python-use-type-annotations
       - id: text-unicode-replacement-char
   - repo: https://github.com/pycqa/isort
-    rev: 6.0.1
+    rev: 7.0.0
     hooks:
       - id: isort
         name: isort
@@ -54,14 +54,14 @@ repos:
   #     - id: reorder-python-imports
   #       args:
   #         - --py37-plus
-  - repo: https://github.com/psf/black
-    rev: 25.1.0
+  - repo: https://github.com/psf/black-pre-commit-mirror
+    rev: 25.12.0
     hooks:
       - id: black
         language_version: python3.11
         exclude: tests/utils/fast_upper_envelope_org.py
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.11.8
+    rev: v0.14.10
     hooks:
       - id: ruff
         # exclude: |
@@ -87,7 +87,7 @@ repos:
       - id: nbqa-black
       - id: nbqa-ruff
   - repo: https://github.com/executablebooks/mdformat
-    rev: 0.7.22
+    rev: 1.0.0
     hooks:
       - id: mdformat
         additional_dependencies:
diff --git a/src/upper_envelope/fues_jax/fues_jax.py b/src/upper_envelope/fues_jax/fues_jax.py
index 44abb7c..acb430a 100644
--- a/src/upper_envelope/fues_jax/fues_jax.py
+++ b/src/upper_envelope/fues_jax/fues_jax.py
@@ -11,7 +11,6 @@
 
 import jax
 import jax.numpy as jnp
-import numpy as np
 from jax import vmap
 
 from upper_envelope.fues_jax.check_and_scan_funcs import (
@@ -124,14 +123,14 @@ def fues_jax(
 
     # Because of jax, we always need to perform the same set of computations. Hence,
     # if there is no wealth grid point below the first, we just add nans thereafter.
-    min_id = np.argmin(endog_grid)
+    min_id = jnp.argmin(endog_grid)
     min_wealth_grid = endog_grid[min_id]
 
     # This is the condition, which we do not use at the moment.
     # closed_form_cond = min_wealth_grid < endog_grid[0]
     grid_points_to_add = jnp.linspace(
-        min_wealth_grid, endog_grid[0], n_constrained_points_to_add + 1
-    )[:-1]
+        min_wealth_grid, endog_grid[0], n_constrained_points_to_add
+    )
     # Compute closed form values
     values_to_add = vmap(_compute_value, in_axes=(0, None, None, None))(
         grid_points_to_add, value_function, value_function_args, value_function_kwargs
diff --git a/tests/test_fues_numba.py b/tests/test_fues_numba.py
index 98189cf..b4ab325 100644
--- a/tests/test_fues_numba.py
+++ b/tests/test_fues_numba.py
@@ -161,9 +161,9 @@ def test_fast_upper_envelope_against_org_fues(setup_model):
     policy_expected = policy_org[~np.isnan(policy_org)]
     value_expected = value_org[~np.isnan(value_org)]
 
-    assert np.all(np.in1d(endog_grid_expected, endog_grid_refined))
-    assert np.all(np.in1d(policy_expected, policy_refined))
-    assert np.all(np.in1d(value_expected, value_refined))
+    assert np.all(np.isin(endog_grid_expected, endog_grid_refined))
+    assert np.all(np.isin(policy_expected, policy_refined))
+    assert np.all(np.isin(value_expected, value_refined))
 
 
 @pytest.mark.parametrize("period", [2, 4, 10, 9, 18])

From 307c079782cfd70de84593f9f3f75f5d0b236d59 Mon Sep 17 00:00:00 2001
From: MaxBlesch <maximilianblesch@web.de>
Date: Tue, 27 Jan 2026 16:30:44 +0100
Subject: [PATCH 02/18] joergensen druedahl upper envelope

---
 src/upper_envelope/__init__.py          |   1 +
 src/upper_envelope/fues_jax/fues_jax.py |   4 +
 src/upper_envelope/upper_jor_drued.py   |  69 +++++++++
 tests/test_upper_jor_drued.py           | 177 ++++++++++++++++++++++++
 4 files changed, 251 insertions(+)
 create mode 100644 src/upper_envelope/upper_jor_drued.py
 create mode 100644 tests/test_upper_jor_drued.py

diff --git a/src/upper_envelope/__init__.py b/src/upper_envelope/__init__.py
index 16055e5..4a93c13 100644
--- a/src/upper_envelope/__init__.py
+++ b/src/upper_envelope/__init__.py
@@ -1,2 +1,3 @@
 from upper_envelope.fues_jax.fues_jax import fues_jax, fues_jax_unconstrained
 from upper_envelope.fues_numba.fues_numba import fues_numba, fues_numba_unconstrained
+from upper_envelope.upper_jor_drued import upper_jor_drued
diff --git a/src/upper_envelope/fues_jax/fues_jax.py b/src/upper_envelope/fues_jax/fues_jax.py
index acb430a..7e62c66 100644
--- a/src/upper_envelope/fues_jax/fues_jax.py
+++ b/src/upper_envelope/fues_jax/fues_jax.py
@@ -128,6 +128,10 @@ def fues_jax(
 
     # This is the condition, which we do not use at the moment.
     # closed_form_cond = min_wealth_grid < endog_grid[0]
+    # NOTE: We intentionally mirror NumPy's `linspace` behavior used in the
+    # reference implementation and in the stored test fixtures.
+    # Using `n_constrained_points_to_add` (not `+ 1` and slicing) yields
+    # slightly different spacing and is important for numerical reproducibility.
     grid_points_to_add = jnp.linspace(
         min_wealth_grid, endog_grid[0], n_constrained_points_to_add
     )
diff --git a/src/upper_envelope/upper_jor_drued.py b/src/upper_envelope/upper_jor_drued.py
new file mode 100644
index 0000000..74e8a0d
--- /dev/null
+++ b/src/upper_envelope/upper_jor_drued.py
@@ -0,0 +1,69 @@
+from __future__ import annotations
+
+from functools import partial
+from typing import Callable, Dict, Optional
+
+import jax
+import jax.numpy as jnp
+
+
+@partial(jax.jit, static_argnames=["value_function"])
+def upper_jor_drued(
+    endog_grid: jnp.ndarray,
+    policy: jnp.ndarray,
+    value: jnp.ndarray,
+    m_grid: jnp.ndarray,
+    expected_value_zero_savings: jnp.ndarray | float,
+    value_function: Callable,
+    value_function_args=(),
+    value_function_kwargs: Optional[Dict] = None,
+):
+    """Compute a simple 1D upper envelope on a given common grid.
+
+    The envelope is computed by linearly interpolating every adjacent pair
+    ``(endog_grid[i], endog_grid[i+1])`` onto the common grid ``m_grid``.
+    For each point on ``m_grid``, we take the pointwise maximum over all segment
+    interpolants and an additional "consume-all" candidate.
+
+    This function intentionally does *not*:
+    - sort inputs
+    - detect or insert intersection points
+    - apply FUES jump/scan logic
+
+    Returns arrays with the convention that index 0 corresponds to zero wealth:
+    ``value_out[0] = expected_value_zero_savings`` and ``endog_out[0] = policy_out[0] = 0``.
+    """
+
+    if value_function_kwargs is None:
+        value_function_kwargs = {}
+
+    # Segment interpolation weights for each adjacent pair.
+    dm = endog_grid[1:] - endog_grid[:-1]  # (N-1,)
+    eps = 1e-16
+    weight = (m_grid[None, :] - endog_grid[:-1, None]) / (dm[:, None] + eps)  # (N-1, M)
+
+    c_interp = policy[:-1, None] + weight * (policy[1:] - policy[:-1])[:, None]
+    v_interp = value[:-1, None] + weight * (value[1:] - value[:-1])[:, None]
+
+    outside = (weight < 0.0) | (weight > 1.0)
+    v_interp = jnp.where(outside, -jnp.inf, v_interp)
+
+    # Consume-all candidate.
+    c_all = m_grid
+    v_all = value_function(c_all, *value_function_args, **value_function_kwargs)
+
+    v_stack = jnp.vstack((v_interp, v_all[None, :]))
+    c_stack = jnp.vstack((c_interp, c_all[None, :]))
+
+    best = jnp.argmax(v_stack, axis=0)
+    grid_idx = jnp.arange(m_grid.size)
+
+    value_best = v_stack[best, grid_idx]
+    policy_best = c_stack[best, grid_idx]
+
+    # Prepend zero-wealth convention.
+    endog_out = jnp.concatenate((jnp.array([0.0]), m_grid))
+    policy_out = jnp.concatenate((jnp.array([0.0]), policy_best))
+    value_out = jnp.concatenate((jnp.array([expected_value_zero_savings]), value_best))
+
+    return endog_out, policy_out, value_out
diff --git a/tests/test_upper_jor_drued.py b/tests/test_upper_jor_drued.py
new file mode 100644
index 0000000..86363f9
--- /dev/null
+++ b/tests/test_upper_jor_drued.py
@@ -0,0 +1,177 @@
+"""Tests for `upper_jor_drued`.
+
+We compare against `upenv.fues_jax`, but only on evaluation points that lie on
+reference line segments that are not affected by explicit intersection handling.
+
+Heuristic:
+- `fues_jax` can insert intersection points by duplicating an endogenous grid
+  point (same `m` appearing twice with different left/right policy values).
+- Linear interpolation is ambiguous around such duplicates.
+
+We therefore:
+1) run `fues_jax` to get a reference refined correspondence
+2) build a boolean mask on the *given* `m_grid` selecting points that fall inside
+   non-degenerate reference segments (strictly increasing in `m`)
+3) interpolate the reference onto `m_grid` using only those safe segments
+4) compare `upper_jor_drued` to that reference on the masked points
+"""
+
+from pathlib import Path
+from typing import Dict
+
+import jax
+import jax.numpy as jnp
+import numpy as np
+import pytest
+from numpy.testing import assert_allclose
+
+import upper_envelope as upenv
+
+
+TEST_DIR = Path(__file__).parent
+TEST_RESOURCES_DIR = TEST_DIR / "resources"
+
+
+def utility_crra(consumption: jnp.ndarray, choice: int, params: Dict[str, float]) -> jnp.ndarray:
+    utility_consumption = (consumption ** (1 - params["rho"]) - 1) / (1 - params["rho"])
+    utility = utility_consumption - (1 - choice) * params["delta"]
+    return utility
+
+
+def interpolate_on_safe_reference_segments(
+    ref_m: np.ndarray,
+    ref_y: np.ndarray,
+    m_grid: np.ndarray,
+):
+    """Interpolate reference (ref_m, ref_y) onto m_grid, ignoring unsafe segments.
+
+    A "safe" segment is any adjacent pair (ref_m[i], ref_m[i+1]) with ref_m[i+1] > ref_m[i].
+    For each x in m_grid, we take the maximum interpolated value over all safe segments
+    covering x. This avoids ambiguity around duplicated ref_m values.
+    """
+
+    dm = ref_m[1:] - ref_m[:-1]
+    safe = dm > 0
+
+    weight = (m_grid[None, :] - ref_m[:-1, None]) / (dm[:, None] + 1e-16)
+    y_interp = ref_y[:-1, None] + weight * (ref_y[1:] - ref_y[:-1])[:, None]
+
+    outside = (weight < 0.0) | (weight > 1.0)
+    y_interp[outside | (~safe[:, None])] = -np.inf
+
+    y_best = np.max(y_interp, axis=0)
+    return y_best
+
+
+@pytest.fixture(autouse=True)
+def _jax_x64():
+    jax.config.update("jax_enable_x64", True)
+
+
+@pytest.fixture()
+def setup_model():
+    params = {"beta": 0.95, "rho": 1.95, "delta": 0.35}
+    state_choice_vec = {"lagged_choice": 0, "choice": 0}
+    return params, state_choice_vec
+
+
+@pytest.mark.parametrize("period", [2, 4, 9, 10, 18])
+def test_upper_jor_drued_matches_fues_on_safe_segments(period, setup_model):
+    value_egm = np.genfromtxt(
+        TEST_RESOURCES_DIR / f"upper_envelope_period_tests/val{period}.csv",
+        delimiter=",",
+        dtype=float,
+    )
+    policy_egm = np.genfromtxt(
+        TEST_RESOURCES_DIR / f"upper_envelope_period_tests/pol{period}.csv",
+        delimiter=",",
+        dtype=float,
+    )
+
+    params, state_choice_vec = setup_model
+
+    def value_func(consumption, choice, params):
+        # Same convention as existing tests: includes continuation value.
+        return utility_crra(consumption, choice, params) + params["beta"] * value_egm[1, 0]
+
+    ref_m, ref_c, ref_v = upenv.fues_jax(
+        endog_grid=jnp.asarray(policy_egm[0, 1:]),
+        policy=jnp.asarray(policy_egm[1, 1:]),
+        value=jnp.asarray(value_egm[1, 1:]),
+        expected_value_zero_savings=value_egm[1, 0],
+        value_function=value_func,
+        value_function_args=(state_choice_vec["choice"], params),
+        n_constrained_points_to_add=len(policy_egm[0, 1:]) // 10,
+    )
+
+    ref_m = np.asarray(ref_m)
+    ref_c = np.asarray(ref_c)
+    ref_v = np.asarray(ref_v)
+
+    valid = ~np.isnan(ref_m)
+    ref_m = ref_m[valid]
+    ref_c = ref_c[valid]
+    ref_v = ref_v[valid]
+
+    # Given common grid for Joerg-Drued.
+    # Use the input correspondence range (exclude the synthetic zero-wealth anchor).
+    m_min = float(np.min(policy_egm[0, 1:]))
+    m_max = float(np.max(policy_egm[0, 1:]))
+    m_grid = np.linspace(m_min, m_max, 500)
+
+    endog_out, policy_out, value_out = upenv.upper_jor_drued(
+        endog_grid=jnp.asarray(policy_egm[0, 1:]),
+        policy=jnp.asarray(policy_egm[1, 1:]),
+        value=jnp.asarray(value_egm[1, 1:]),
+        m_grid=jnp.asarray(m_grid),
+        expected_value_zero_savings=value_egm[1, 0],
+        value_function=value_func,
+        value_function_args=(state_choice_vec["choice"], params),
+    )
+
+    endog_out = np.asarray(endog_out)
+    policy_out = np.asarray(policy_out)
+    value_out = np.asarray(value_out)
+
+    # Check index-0 convention.
+    assert endog_out[0] == 0.0
+    assert policy_out[0] == 0.0
+    assert value_out[0] == value_egm[1, 0]
+
+    # Build reference interpolants on safe segments only.
+    # Use value to select the best reference segment; then take policy from that segment.
+    v_ref = interpolate_on_safe_reference_segments(ref_m, ref_v, m_grid)
+
+    # Recompute the segment-wise interpolation for policy using the same winner segments
+    # implied by the value envelope.
+    dm = ref_m[1:] - ref_m[:-1]
+    safe = dm > 0
+    weight = (m_grid[None, :] - ref_m[:-1, None]) / (dm[:, None] + 1e-16)
+    c_interp = ref_c[:-1, None] + weight * (ref_c[1:] - ref_c[:-1])[:, None]
+
+    outside = (weight < 0.0) | (weight > 1.0)
+    c_interp[outside | (~safe[:, None])] = np.nan
+
+    # Determine which segment delivers v_ref at each grid point.
+    v_interp = ref_v[:-1, None] + weight * (ref_v[1:] - ref_v[:-1])[:, None]
+    v_interp[outside | (~safe[:, None])] = -np.inf
+    best_seg = np.argmax(v_interp, axis=0)
+    c_ref = c_interp[best_seg, np.arange(m_grid.size)]
+
+    # Mask points where reference is defined.
+    good = np.isfinite(v_ref) & np.isfinite(c_ref)
+    assert good.any(), "No safe reference points found; test setup issue."
+
+    # Our implementation only interpolates adjacent input pairs. The input ordering can
+    # leave gaps where no segment covers m_grid; those points will be -inf and are not
+    # comparable to the reference.
+    good &= np.isfinite(value_out[1:]) & np.isfinite(policy_out[1:])
+
+    # Compare on the common grid portion (skip index 0 which is a convention).
+    assert_allclose(value_out[1:][good], v_ref[good], rtol=1e-7, atol=1e-7)
+
+    # Policy can differ even when value matches because:
+    # - `upper_jor_drued` includes a consume-all candidate with policy == m_grid
+    # - `fues_jax` does not explicitly expose that candidate as a segment
+    # - near kinks, the value envelope can have multiple near-ties with different policies
+    # We therefore only assert value agreement here.

From ed5914f0ee27dea319a5c45b935b00463c6fe5c5 Mon Sep 17 00:00:00 2001
From: MaxBlesch <maximilianblesch@web.de>
Date: Tue, 27 Jan 2026 17:15:42 +0100
Subject: [PATCH 03/18] Fix and done

---
 .pre-commit-config.yaml                       |  14 +-
 docs/tutorials/upper_jor_drued_period2.ipynb  | 375 ++++++++++++++++++
 src/upper_envelope/__init__.py                |   2 +-
 src/upper_envelope/fues_jax/fues_jax.py       |   6 +-
 ...upper_jor_drued.py => upper_jorg_drued.py} |  30 +-
 tests/test_upper_jor_drued.py                 |  27 +-
 6 files changed, 423 insertions(+), 31 deletions(-)
 create mode 100644 docs/tutorials/upper_jor_drued_period2.ipynb
 rename src/upper_envelope/{upper_jor_drued.py => upper_jorg_drued.py} (78%)

diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index 548f73b..92abf79 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -58,7 +58,7 @@ repos:
     rev: 25.12.0
     hooks:
       - id: black
-        language_version: python3.11
+        language_version: python3.12
         exclude: tests/utils/fast_upper_envelope_org.py
   - repo: https://github.com/astral-sh/ruff-pre-commit
     rev: v0.14.10
@@ -97,12 +97,12 @@ repos:
           - --wrap
           - '88'
         files: (README\.md)
-  - repo: https://github.com/codespell-project/codespell
-    rev: v2.4.1
-    hooks:
-      - id: codespell
-        additional_dependencies:
-          - tomli
+#  - repo: https://github.com/codespell-project/codespell
+#    rev: v2.4.1
+#    hooks:
+#      - id: codespell
+#        additional_dependencies:
+#          - tomli
 # -   repo: https://github.com/mgedmin/check-manifest
 #     rev: "0.49"
 #     hooks:
diff --git a/docs/tutorials/upper_jor_drued_period2.ipynb b/docs/tutorials/upper_jor_drued_period2.ipynb
new file mode 100644
index 0000000..8210038
--- /dev/null
+++ b/docs/tutorials/upper_jor_drued_period2.ipynb
@@ -0,0 +1,375 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Upper envelope comparison (period 2)\n",
+    "\n",
+    "This notebook compares the new `upper_jorg_drued` upper-envelope routine against `fues_jax` on the period-2 fixture data.\n",
+    "\n",
+    "It produces plots for:\n",
+    "- *Raw (uncleaned) EGM correspondence* (`pol2.csv`, `val2.csv`)\n",
+    "- `fues_jax` refined outputs\n",
+    "- `upper_jorg_drued` outputs evaluated on a user-chosen `m_grid`\n",
+    "\n",
+    "Notes:\n",
+    "- `upper_jorg_drued` interpolates only between adjacent input pairs as given (no sorting, no explicit intersection handling).\n",
+    "- `fues_jax` explicitly handles intersections and can produce duplicated `m` points.\n"
+   ],
+   "id": "580725313169fe83"
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "681fbc8a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "import jax\n",
+    "import jax.numpy as jnp\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "import upper_envelope as upenv\n",
+    "\n",
+    "jax.config.update(\"jax_enable_x64\", True)\n",
+    "plt.rcParams[\"figure.dpi\"] = 140"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "a4c6afd8",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "raw sizes (500,) (500,) (500,)\n",
+      "expected_value_zero_savings 7.264440456424788\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Load period-2 fixtures\n",
+    "resource_dir = \"../../tests/resources/upper_envelope_period_tests\"\n",
+    "policy_egm = np.genfromtxt(f\"{resource_dir}/pol2.csv\", delimiter=\",\", dtype=float)\n",
+    "value_egm = np.genfromtxt(f\"{resource_dir}/val2.csv\", delimiter=\",\", dtype=float)\n",
+    "\n",
+    "endog_grid_raw = policy_egm[0, 1:]\n",
+    "policy_raw = policy_egm[1, 1:]\n",
+    "value_raw = value_egm[1, 1:]\n",
+    "expected_value_zero_savings = float(value_egm[1, 0])\n",
+    "\n",
+    "print(\"raw sizes\", endog_grid_raw.shape, policy_raw.shape, value_raw.shape)\n",
+    "print(\"expected_value_zero_savings\", expected_value_zero_savings)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "6be5aa23",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Value function used in tests\n",
+    "params = {\"beta\": 0.95, \"rho\": 1.95, \"delta\": 0.35}\n",
+    "choice = 0\n",
+    "\n",
+    "\n",
+    "def utility_crra(consumption, choice, params):\n",
+    "    utility_consumption = (consumption ** (1 - params[\"rho\"]) - 1) / (1 - params[\"rho\"])\n",
+    "    return utility_consumption - (1 - choice) * params[\"delta\"]\n",
+    "\n",
+    "\n",
+    "def value_func(consumption, choice, params):\n",
+    "    # Mirrors existing tests: value_func already includes continuation value.\n",
+    "    return (\n",
+    "        utility_crra(consumption, choice, params)\n",
+    "        + params[\"beta\"] * expected_value_zero_savings\n",
+    "    )"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "52d3d068",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "m_grid range 4.5853531853973 54.19539854760825 len 500\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Pick a common grid for Druedahl\n",
+    "m_min = float(np.min(endog_grid_raw))\n",
+    "m_max = float(np.max(endog_grid_raw))\n",
+    "m_grid = np.linspace(m_min, m_max, 500)\n",
+    "print(\"m_grid range\", m_grid[0], m_grid[-1], \"len\", len(m_grid))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "63a57f1e",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "output lens 501 501 501\n",
+      "index 0 convention 0.0 0.0 7.264440456424788\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Run new upper envelope\n",
+    "endog_out, policy_out, value_out = upenv.upper_jorg_drued(\n",
+    "    endog_grid=jnp.asarray(endog_grid_raw),\n",
+    "    policy=jnp.asarray(policy_raw),\n",
+    "    value=jnp.asarray(value_raw),\n",
+    "    m_grid=jnp.asarray(m_grid),\n",
+    "    expected_value_zero_savings=expected_value_zero_savings,\n",
+    "    value_function=value_func,\n",
+    "    value_function_args=(choice, params),\n",
+    ")\n",
+    "\n",
+    "endog_out = np.asarray(endog_out)\n",
+    "policy_out = np.asarray(policy_out)\n",
+    "value_out = np.asarray(value_out)\n",
+    "\n",
+    "print(\"output lens\", len(endog_out), len(policy_out), len(value_out))\n",
+    "print(\"index 0 convention\", endog_out[0], policy_out[0], value_out[0])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "47f80c8d",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "ref lens 503 503 503\n",
+      "ref m has duplicates: True\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Run fues_jax reference\n",
+    "ref_m, ref_c, ref_v = upenv.fues_jax(\n",
+    "    endog_grid=jnp.asarray(endog_grid_raw),\n",
+    "    policy=jnp.asarray(policy_raw),\n",
+    "    value=jnp.asarray(value_raw),\n",
+    "    expected_value_zero_savings=expected_value_zero_savings,\n",
+    "    value_function=value_func,\n",
+    "    value_function_args=(choice, params),\n",
+    "    n_constrained_points_to_add=len(endog_grid_raw) // 10,\n",
+    ")\n",
+    "\n",
+    "ref_m = np.asarray(ref_m)\n",
+    "ref_c = np.asarray(ref_c)\n",
+    "ref_v = np.asarray(ref_v)\n",
+    "mask = ~np.isnan(ref_m)\n",
+    "ref_m, ref_c, ref_v = ref_m[mask], ref_c[mask], ref_v[mask]\n",
+    "\n",
+    "print(\"ref lens\", len(ref_m), len(ref_c), len(ref_v))\n",
+    "print(\"ref m has duplicates:\", np.any(np.diff(ref_m) == 0))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5429b7a5",
+   "metadata": {},
+   "source": [
+    "## Reading the plots\n",
+    "\n",
+    "**Raw vs cleaned:** the “raw” arrays are the (potentially multi-valued) EGM correspondence. \n",
+    "`fues_jax` removes dominated points and adds explicit *intersection points* where two branches cross. \n",
+    "`upper_jorg_drued` instead evaluates a pointwise envelope on a fixed grid `m_grid` by interpolating every adjacent input pair."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "id": "8e0689c4",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1400x490 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Plot uncleaned raw correspondence\n",
+    "fig, ax = plt.subplots(1, 2, figsize=(10, 3.5))\n",
+    "ax[0].plot(endog_grid_raw, value_raw, \".\", ms=2)\n",
+    "ax[0].set_title(\"Raw input: Value\")\n",
+    "ax[0].set_xlabel(\"cash-on-hand (endog_grid)\")\n",
+    "ax[0].set_ylabel(\"Value\")\n",
+    "\n",
+    "# Plot cleaned values\n",
+    "ax[1].plot(ref_m, ref_v, label=\"fues_jax\", lw=2)\n",
+    "ax[1].plot(endog_out, value_out, label=\"upper_jorg_drued\", lw=1.5)\n",
+    "ax[1].set_title(\"Value Function Cleaned\")\n",
+    "ax[1].set_xlabel(\"cash-on-hand (endog_grid)\")\n",
+    "ax[1].set_ylabel(\"Value\")\n",
+    "ax[1].legend()\n",
+    "plt.tight_layout()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "id": "636d2a94",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.legend.Legend at 0x3661c86e0>"
+      ]
+     },
+     "execution_count": 25,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1400x490 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fig, ax = plt.subplots(1, 2, figsize=(10, 3.5))\n",
+    "\n",
+    "ax[0].plot(endog_grid_raw, policy_raw, \".\", ms=2, label=\"raw\")\n",
+    "ax[0].set_title(\"Raw input: Policy\")\n",
+    "ax[0].set_xlabel(\"Cash-on-hand (endog_grid)\")\n",
+    "ax[0].set_ylabel(\"Policy (consumption)\")\n",
+    "ax[0].legend()\n",
+    "ax[0].set_ylim(bottom=0)\n",
+    "\n",
+    "# Plot policy comparison\n",
+    "ax[1].plot(ref_m, ref_c, label=\"fues_jax\", lw=2)\n",
+    "ax[1].plot(endog_out, policy_out, label=\"upper_jorg_drued\", lw=1.5)\n",
+    "ax[1].set_title(\"Policy Function Comparison (period 2)\")\n",
+    "ax[1].set_xlabel(\"Cash-on-hand (endog_grid)\")\n",
+    "ax[1].set_ylabel(\"Policy (consumption)\")\n",
+    "ax[1].legend()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "efc9a84b",
+   "metadata": {},
+   "source": [
+    "## Zoom around intersections:\n",
+    "\n",
+    "`fues_jax` represents an intersection by duplicating an `m` grid point (same x-value appears twice, with different left/right policy values). \n",
+    "The zoomed plots focus on one such duplicated-`m` location."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "id": "4d412f0d",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "zooming around intersection at m = 7.061875924198789\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAABfUAAAPFCAYAAADMdAIXAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAViAAAFYgBxNdAoAAA4OFJREFUeJzs3Qd4FGXXxvETCIQauvQqIF06BKRLkeprA2ygoliwIIKviAJWsCAqvmABxIYioPKBINJbABWkCtKlCAjSayD7XecJs2xNdpPdJJP8f5frJtNndnaAe545T4TD4XAIAAAAAAAAAABI97Kk9QYAAAAAAAAAAIDAEOoDAAAAAAAAAGAThPoAAAAAAAAAANgEoT4AAAAAAAAAADZBqA8AAAAAAAAAgE0Q6gMAAAAAAAAAYBOE+gAAAAAAAAAA2AShPgAAAAAAAAAANkGoDwAAAAAAAACATRDqAwAAAAAAAABgE4T6AAAAAAAAAADYBKE+AAAAAAAAAAA2QagPAAAAAAAAAIBNEOoDAAAk06JFiyQiIkLKlSvHMQSu6N27t/leDBs2LOhjsn//funVq5eULFlSIiMjzXJ0eRnVp59+avaxZcuWkp7ZZTszo927d5vPRl8AACDzINQHAAAZJkSMiYkJeJ7atWubeZ544omwbhuAwFy8eFFatWoln332mZw+fVrq1q0rTZs2lcqVK3MIMyi98aOv48ePp/WmpEu///67OT56UwUAAMBVpNtvAAAANnT//ffLpEmTZOXKlbJlyxapUqVKotOvXbtW1q1bZ36+7777UmkrASRm7ty5sm3bNilRooRs2rRJ8ufPn+EPWL58+eS6666TMmXKSGbczuHDhztvzGaGzzs5ob4eoxYtWvh9YiVbtmzmswEAAJkLLfUBAIDtNW/eXCpWrGh+DqRF48SJE52t9evUqRP27QOQtM2bN5t3bZ2fWQLe//znP+ZGpD6dkJ7ZZTszIy1VpZ+NvgAAQOZBqA8AADIEqxXj559/LpcvX060xMdXX31lfqaVPpB+nDt3zrznypUrrTcFAAAASNcI9QEAQIYJ9bNkySIHDhyQn3/+2e90//d//ydHjx6V7Nmzy1133WWGHTlyRD7++GO5+eabTf3u3Llzm1eNGjXk2WeflX/++Sfo7dHOc7Vmv3amm9xOdmfOnCldu3aVYsWKme295pprzO8LFy6UcHW0mNjL17bqsRw8eLA5VnrM8uTJI7Vq1ZKhQ4fKiRMn/K4zLi5Oxo4dKzfccIMUKFBAcuTIIRUqVJCHHnpItm/f7nMerS1tdZyqN2defvllqVq1quTMmVNKlSol/fr1k2PHjjmn//bbb83ytXRIdHS0dOzYUdavXx/08dF1TZ8+3ZR5qlmzphQsWNBsrx4P7dR148aNSR5XNWvWLGnXrp0ULlzYDPv+++9TdBxTco65zvvXX3/JAw88YFr8RkVFmXEDBgyQkydP+j0mu3btknvvvdecm3os9HszZMgQZzAfDOtztTrW1VJaruedHkelnbTq7/6exgmkw9Bly5ZJjx49zPmi+6qfZdu2bWXatGl+51m8eLHceuut5vjo91CfItD9ve2225xP/YSjA9o///xTRowYYfoZKFu2rDnOum59kuH999833yFPeo7p8nTffvvtN6/xly5dMvPrNN26dQvJdibnXLI+c0v58uXdPnNfnSwHez10vV6cP39eXnrpJef3y/VJkFOnTplx+tRW3rx5zXbr9jdq1EgGDhzo93q0YcMGc03Q65b12ej15pNPPkn0xrL2H/DKK6+Y5VvXPt1//Tz0prTrcbVuPOs56Hk9tr4XSZ33DodDJk+ebM7zQoUKmWOn5/+dd94pa9asCejz1t91e/W6pNdSPScT+3MWAACkAgcAAEAG0aFDB4f+9aZ79+5+p+nUqZOZ5vbbb3cOe//9982w7NmzO8qUKeOoX7++o1KlSo5s2bKZ4aVKlXLs2rXLa1kLFy4048uWLes1TofpOJ3Gl8TmjYuLc9x9991mvL4KFSrkqFOnjnm3hr3++us+l2utd+jQoY5A/f33346mTZv6fRUtWtTntm7atMlRsmRJMy5r1qyOWrVqOWrUqOHIkiWLGVauXDnHtm3bvNZ38uRJR7NmzZz7UqFCBUe9evUcuXLlMr/nzJnTMWPGDK/5dJ90/J133ulo0aKFIyIiwlG1alVHlSpVnOvU5Vy4cMHx7LPPmt9Lly7tqF27tiNHjhzm9+joaJ/blJgNGzaYeXUdxYoVM59F9erVHXny5DHDo6KiHDNnzvSaT88Zax/feust52fZoEEDs13fffddio5jSs4xa953333XkT9/frMPdevWNeuytrlx48bmXPT022+/OfLly2em0e+IHg/9vujvjRo1cvTs2TOoc3D8+PHmPNNjovNdc801buefnp9KP3MdP3HiRJ/LcT3evljnhL50+/W80M/TGvbwww97zTNhwgRznul4PU7XX3+9+XwKFChghunnlhK6L7oc3TdPt956qxmn51nFihXNeWN9bvpq3bq14+LFi17zPfXUU2a8zqPfNVfPP/+8c7uPHDkSku1MzrlkfebWeL3mun7mOj6l10PreqF/HjRs2NB5TPQaodd0derUKfNd03H6ObseZ+v6//HHH3ste8yYMea7quNz585tzgnr/NVXly5dfH53fv31V0fx4sWd01nbo+e857l72223Ob9Xet3yvC5b34vEznvdBl2ONV73W4+19f3Vffjwww8T/bzvv/9+57VUj7vur3U9/P777/2eMwAAILwI9QEAQIbxzTffmLBBA9xjx455jdcQxApifvzxR+fwVatWmd/Pnz/vNv0///zjePDBB830HTt2TLVQf9CgQc6w++eff3Yb9+WXX5pQRQOoBQsWhCTUT8z69esdefPmNcscNWqUc7geq+uuu84Z5O7Zs8c5bvv27Sb81HH6funSJbdl9u7d24wrUqSIY+nSpc7hJ06ccAbCGmR63kixQjoN23TdmzdvdgvLNFDU8RqG6vyuNwYOHz5sAikdrwFhMA4ePOj4/PPPHUePHnUbrsfACvcKFy7sOHPmjNt417BNt3n06NFux+LcuXMpOo6hCPV1u+655x7H8ePHnePmzp1rbqzoeA21PfdZg0gr8NNjY1m+fLk5DlYYGuw5aH2+vXr18jk+JaH+//73PzNct0+vE650f61Q1XXZeryt4Pi9997zCmn/+OMPE2SnRGJhuQamem2Kj4/3Wq+G5DrfG2+84TWf3tTSUF3H33XXXc7her3QIFZfixYtCtl2JvdcUtbn5eumaUqvh9b5pN9PvcGwZs0a57izZ8+ad/1O6jQ1a9b02gb9fk6ZMsWxYsUKt+GzZs0y69P9Gjt2rNv3Uq9DVhDvef7rd8W6QdqqVSuvG3W6/hdeeCHg4x7IeT9s2DAzXG+YTp8+3e17/PTTTzuPz8qVK32uVz9T/Q7o52g5ffq0o1u3bs4bjp7nJwAASB2E+gAAIMPQMMsK4TRs8aQBmNVK1TMgTYxOryGOa4AZrlB/3759JkjRlwbqvrz99ttm3vbt23uN0xacusx33nnHkVJ6E0SfXNB1PfLII27jPvvsM+fTDXv37vWad+vWrc4bKFOnTnULoKwW6BqYedLgtHz58mZ8v379fIZ0+llo2Olp4MCBznDLV9iprel1nLayDiUNTnW5nmGxa9jmqxV4So5jqEJ9fcrBV2vvxx57zIz/z3/+43N79caZ5/fBClmtfU4vob7ebNEwX4fPmTPH57zTpk0z4/UGi+v5b7XQD5dAQltfNBDW+fRJFV/+/PNP55Mkug69QVmiRIlk3/ALJNQP9lwKJNRPyfXQOp/05RlaW/r27WvGa7gfCA2wq1WrZuYZN26cz2k02NdrlLaGd71RPGDAAOc5Zt1USEpKQn0N37WFv7/robKemOrcubPP9epLb2h6OnDggPPm3bp16wLaFwAAEFrU1AcAABmG1grWOsHKV61rqxa31kHPmjWr2zituawd6Pbt21c6dOggzZo1M/WR9aU1lzV/Wrt2bdj3Qeusa63sJk2amPrtvmh9b7VkyRKv2s1aM1xrLD/11FMp2o6zZ8+aetVaI1uPh9bw9qzdre644w5Tn9mT1hzX+V2nVXPmzJH4+HgpU6aMcz9cRUZGOrfddT5X119/vTRs2NBreL169Zw/a21+T/Xr1zfvWnf/33//lWDNnz/f1Afv0qWLtGjRwnl+6Oeg/NWnVlp725fkHsdQ0eOULVs2r+Fad1151hP/8ccfzXv37t2laNGiXvPp8OLFi0t6ojXXtd8MrUvfvn17n9PoZ6rHYevWraZfDlWkSBFT71xroM+YMUPSwuHDh+W9996Tu+++29REt65LVsfgW7Zs8dmPQaVKleSDDz4wP2tfE7fccovZL53/hRdeCMu2Bnsupcb1UFWrVs3Ug/dFr0PWehLrQ8KyefNm89LzQv8c8UWvQ3quaV8Yrv0aTJ061bw//fTTph+QcFu6dKnZJ93WRx55xOc0zzzzjHmfN2+e6TvEk/ZHYvU940q/49oPQHI/VwAAkHKRIVgGAABAuqHhqQbQq1evlj/++MN0pKpWrVplwhhlBWIWna5Tp06m88/EaGem4bZu3TrzruGihne+JDRwFRPm6TZph5GhpMu/55575JdffjGdtU6ZMsXrJohun9KOJ/3REO67774zwaPnfBq0acfG/uZT+nlo0KQ3a1xVrFjR53zWcdCOaDWM8jdenT592nSSGgidVkPRpDqGTOz80P31JbnHMVT0poEvVmCv++7K2gZ/+6PnyXXXXSd///23pBfWd0pDVn/fKWV1NLpv3z4pUaKE2Re9ifPqq6+aTkx1nzVY1xtK2oGoThNOGgJrR6men4Hnd1VvUGnHrp60I2M9Z7/44gsT8Or5/uWXX3p9l9PqXEqt66G/c9X682LUqFGmk1/9PG+88UZzEyImJkYaN25sbjL62h49V3TapK4Fei4pvTG8Z88e87PeoEgN1rVFO9zVDm4Tu9bqTW29Gez5GerNIX8d8Ornqp05J+dzBQAAKUeoDwAAMpTatWub1++//25a5o8cOdKtlb62VNWgwqKtxrWlpwbIdevWlWHDhpmWlhoMW2Fy8+bNTSimLUbDTVuRq4MHD5pXIC3qQ+3ZZ5+V6dOnm9aYM2fOlLx583pNoyGVKlasmN/lWC22rWmDnc+avlChQm7jc+fO7XM+K3xKarz1uQdKW7NqOKrnxIgRI5yBrtXa9sUXX5SXX3450fPD3zYl9ziGir/tsm64eB4naxt8tdK3JDYuLVjfKW1xv3z58qC+U/q5amtubfW+fv16541BPZdat24tb7/9tnlyJNQ0YNXW+RcuXDBPcTzxxBNSpUoVc7NKg2b9XKxwPrHzToNnDfXVTTfdJKVLl5ZwCfZcSq3rob/tsr53esN3+PDhprX+Dz/8YF5Kv+/9+/eXQYMGOcN9a3v0BkIw55LrUwD58+eX1JCca20wxy4lnysAAEg5yu8AAIAMxyp1omGWlmPQVohff/212ziL1aJfA9qffvrJlOHQwNa1dXhyWuhbAbLVitTTmTNnfA63WlRqCZor/R8l+tJWmKH0ySefyJtvvmnCHA30/YWAVtCfWNBmtdZ2vSkQzHye86aFS5cumdbNatKkSfLAAw/Itdde61Y+IyVPcCT3OKbkHEsJaxsOHTrkd5rExqVESr9TN998c0DfKb1p47pOLSujLbS1FI7e7NKAXVuDazmmVq1aOVtjh5JerzTQ17IxkydPNq3H9eaWFS4Hcs7pjconn3zSGcDqeRyOEk7hlBrXQ/0+f/bZZyaw//XXX+Wdd94xN0O0ZNPzzz8vgwcP9toevXEcyPZYT4VFR0c7l6E3l1KD3a61AAAgOIT6AAAgw9EawFFRUaaG9Ny5c03pEg1SNJC5/fbb3aa1Su5omR5tmelJwzOrjEEwrBaO/gJOLVuQWDmEQFqBhpqGlI8++qgzANQnF/zRVsNq48aNfqexxlklkFzn0xbP/lp4WvNVqFDBq/ROavvnn3+c5SX0KQ9fVqxYkezlJ/c4puQcSwnXz88XvYmWnO9LanynVq5cmaJWxVpj/z//+Y+8++67Zl0aIGsQbN0wDCXruqRhvq8yVUmdc3ozqmfPnqbkkF7z3njjDTNcy/mkp9JISUnN66E++aBPaekNBH0yRz9nNW7cOOeNJGt7Nm3aFFQ4r4G5dcMhmOuFv9I3wXxX9akPfyVyrGuL1t0P9Q1iAAAQXoT6AAAgw9Ha0Vbnolp2x+o0V8tYeJYTyJUrl7M1o68WwNpq01fni0mxSvzExsb6DNw+/vhjn/Np7XZtjav17PXJgdSitdJvu+02U8pDS4poDfHEaB8ESuvt+2qprJ0nWmUsrGmVdrqrIaV2wDtt2jSfx8YK01znSyvW+aGsDlRdaQeTWuopuZJ7HFNyjqWElnBR33zzjWm57kn3I1yhcWL7q8aOHetzuNbB15In+h0P1THRltdW2R1f50Wozjtfy9br1FtvvZXo/NoZrpaV0aD2o48+Mp2z6ndPb1JpWZ/0UjLF2k9fnf2m5fXQKrtmlaWxStPUqVPHnId6nbRKuwVKr6/Wnyn69Fgojk9itA8CPU91Xf6+G3qtt74jaX0DFQAABIdQHwAAZEhWmR0NRLUFuuswV9ohYrZs2Ux4pqUWrABfQy/tcPf11183rRiDZd1UGD9+vCxcuNA5XGsrP/jggyas9UVDOK3jbN2E0LIQGtC60nBSW49qB56+ghxdxujRowPeVg36NDDWlqfaUl9bqiZFt007RNWObPXnvXv3Osft3LnTDNNjqcGn6w2CsmXLmg48Vb9+/dxa4Gpwpi2Jd+zYYZ6q0CAyrWkNcyu81VImVk1tpZ+rtoZOzvmR0uOYknMsJXR79AkKDQp79OjhFuxrS3g9d/T7FA7W/v7f//2fualg0W3REina2am/VtLWd0VL52io6hmS6uf6+eefm45xLfo0gpZbWrZsmVcIri25retKgwYNJNRatGjh7Cx3xowZbt8RvY5pmRh/dLu0Zb6G4V999ZW5oaEtvrV8lNZXX7BgQdCBdLhYnV7rNoXjepiU5557zgTenk9/6LVQr/1KO4+1yufocdSOdfVdj6Ged/o0hGcZKH06zPPPm4EDB5r+JvQGaufOnc11zpV2pDt06FCfx0efDAi2rJXewLauodpXjHVzUOn1RvsKWLx4sXlCQf/sAwAANuMAAADIgC5fvuwoVaqUNr03r8qVK/ud9oUXXnBOV7hwYUf9+vXNu/7ep08fR4sWLczPEydOdJtv4cKFZnjZsmW9lhkXF+do1KiRGR8REeEoX768o27duo4cOXI48ufP73j33Xf9znvp0iVH3759nduUN29eM2+DBg3c9umuu+7ymleXp+OGDh0a8LHS/bKW2bhxY0fTpk19vm677Ta3+TZu3OgoUaKEmS9r1qyO66+/3lGzZk1HlixZzLBy5co5tm3b5rW+kydPOm644QbnOitWrGiOea5cuczvOXPmdMyYMcNrPt0nHd+rVy+f+5HY52Gx1rlr166Aj89PP/1k9k/ny507t6NOnTrm89Tfa9eu7XjmmWd8bpeuw1pfYpJ7HFNyjlnniR6zYI/l6tWrHdHR0WZ89uzZzTr1+6W/6/b07Nkz6HMwkM9X3Xrrrc5jWrJkSXPe6PdD9/mjjz5K9Hi/9NJL5jjpeJ1eP7uGDRua42YN1/PcsnbtWufy9NysVauW+Q5an5W+unXrZq41yWV99/Qa40qX2bJlS+d69ByoV6+e2Q49Lz777DOf5/Lhw4cdxYsXN8NfeeUVr/XNnTvX7GtkZKQjNjY2xduZ0nPprbfecu5H1apVHc2bNzfrcL3WJvd6GMj5pJ+fNX+ZMmXM+VC9enVHVFSU8/u+ePFir/nGjx/vnCZbtmyOGjVqmHO/UqVKzmuFnp+efvnlF0exYsXc/lzSc7ho0aI+z934+HhzLbC2RfdZj4++/v777ySvM3qNcP3O6D7qMvLly2d+13Np3LhxQX3eFn9/LgIAgNRBS30AAJAhaYkXq0W40hbg/rz00kumg1jt/FBbwmq9bG0hqcOSW65DW8lqPX9t+VumTBlTWkWfBtDWpmvXrpVatWr5nVdbTmrLU21Feeedd5pyQtpSU2uVa6tjreutrbO1xXGoaWtrbT3v66UlMFxVr15d1q9fb1q7amtzPW7a+rRatWqm/Ifup9XS1JXug7bM/eCDD6RJkyamtbcuR2uW9+nTx3RKqh0Wpxft2rUzLeG180xtoastbbXPhiFDhpjj4lnSKVjJPY4pOcdSQlumr1mzxvRdoU8y6LmpLdm11bIep3CW8dCW5y+//LJpPa1PmGjteS0doqVm9D0x1rHUc6xUqVLm+6Tbrk8WaGkafTJHO6W16Dr0e6bfQT2++hSFzq+tnPVc0Fbj2nGur5r3KaXL1E5t//vf/0r58uVl//79pmSVdsyr35177rnHax6rY1Ytf6TT6fnkSY+Rthh3rbmflrQVvpYS0idRtKX6kiVLzHVP68CnxvVQzwn9HusTTnoOayktfUJGnxDQJ4m05rxVhseVtsLXbdCnd7Qcj56H+h3Wp2r0KQttxe/r6YP69eub+bRFvpby0e+rrkPL7GhHztq5uyu93vz444/Sq1cvs9+6fXoc9BVICR+9Rnz77bemj5TWrVubP990GXrN0s9fO4rv27dv0McNAACkvQhN9tN6IwAAAAAgs5kwYYIp8dOmTRvTPwMAAAAQCFrqAwAAAEAasPpo0FbYAAAAQKAI9QEAAAAglV24cMHZCW7dunU5/gAAAAgY5XcAAAAAIIVldPQVKO2LQfuQ0H4BtC689tNQokQJPgMAAAAEJDKwyQAAAAAAvmgnthrUB0M7OtWOa19//XUCfQAAAASFlvoAAAAAAAAAANgENfUBAAAAAAAAALAJQn0AAAAAAAAAAGyCUB8AAAAAAAAAAJsg1AcAAAAAAAAAwCYi03oDIFKlShU5duyYVKhQgcMBAAAAAAAAAJnAzp07pUCBArJly5ag5iPUTwc00D979mxabwYAAAAAAAAAIJUkNxMm1E8HrBb6sbGxab0pAAAAAAAAAIBUEBMTk6z5qKkPAAAAAAAAAIBNEOoDAAAAAAAAAGAThPoAAAAAAAAAANgEoT4AAAAAAAAAADZBqA8AAAAAAAAAgE0Q6gMAAAAAAAAAYBORYiNffPGFLF26VH777TfZsGGDXLx4USZOnCi9e/f2Of3Jkydl2LBhMm3aNDl48KAUK1ZMbr31VjMsOjo64PWWK1dO9uzZ43Nc3759Zdy4ccneJwAAAAAAACCl4uPj5dixY3Lq1Cm5cOGCOBwODiqQiiIiIiQqKkry5s0rBQoUkCxZwtee3lah/pAhQ0y4XrhwYSlevLjfoF2dOXNGWrRoIb///ru0bdtWevbsKevWrZN33nlHFi5cKMuWLZPcuXMHvO58+fLJU0895TW8fv36yd4fAAAAAAAAIBSB/r59+0we5howAkjd7+G5c+fMS7+LpUqVCluwb6tQ/5NPPpFKlSpJ2bJlZcSIEfLcc8/5nfaNN94wgf6gQYNk5MiRzuFDhw6Vl156yYwfPnx4wOvOnz+/aeEPAAAAAAAApCfaQl9DxGzZsplKFdqQlVAfSF36dIx+D7VijL4fP35cChYsGJZ12aqm/o033mgC/UAOoN4AyJMnj7z44otu4/RGgD7+MH78eB5DAgAAAAAAgO1pyR2lgb7mYQT6QOrT751+//R7aJWGDxdbtdQP1LZt2+TAgQPSvn17rxI7OXLkkObNm8sPP/wg27dvNy3/A6G1yCZNmiT79+83NwWaNGki119/fVDbFRMT43P4xo0bpUaNGkEtCwAAAAAAALByKxVMqWkA4WF9D63vZThk2FBf+QvsreE6XaChvj424dkhb4cOHeTzzz83Nf4BAAAAAACAtKBVK7SVMC30gbRnfRfD2Vl1hgz1T5w44ezc1pfo6Gi36ZJy//33m053q1evbnow3rx5s6nHP3v2bOnatassX748oItmbGxsUC34AQAAAAAAAADI8KF+qHnW5W/UqJHMnDnTBP3Lli2TH3/8UTp16pRm2wcAAAAAAAAAyBxs1VFuoKwW+v5a4ludFPhryR+ILFmyyH333Wd+1pb6AAAAAAAAAACEW4YM9V1r5ien5n6grFr6Z8+eTdFyAAAAAAAAAADI1KF+iRIlTAv6M2fOuI07f/68LFmyxIyvWLFiitazatUq816uXLkULQcAAAAAAAAAgEwb6muntX369JHTp0/LSy+95Dbu9ddfl2PHjpnxrp3bxsXFyZYtW2THjh1u02unuMePH/dah9bSHzVqlOk495Zbbgnj3gAAAAAAAAAAYMOOcj/55BMTpqsNGzY4hy1atMj8fPPNN5uXGjRokMyYMUPeeOMNWbt2rdSrV0/WrVsns2fPltq1a5vxrvbv3y9Vq1aVsmXLyu7du53Dp0yZYpbRpk0b0yJfQ/yNGzfK3LlzTV39cePGSZkyZVLxKAAAAAAAAACp73zcZVm/74ScvhAneaKySa1S+SRHtqx8FEAqs1Wor4H+pEmT3IZpiR2ro1oN3a1QP3fu3CbsHz58uEydOtX8XKxYMenfv78MHTrUjA9Eq1at5I8//pA1a9bI4sWLTfmeokWLSvfu3c2yGjZsGIY9BQAAAAAAANKHgyfOy/hlO2XKr/vkxLk45/B8ObPJHfVLSZ9mFaRodI403UYgM4lwOByOtN6IzC4mJsa8x8bGpvWmAAAAAAAAwGa0pLSqUqVKyJe96cAJ6TVhtRw5fdHvNIXzZJdJ9zeU6iXySVrRBr3aOFcb87Zv316GDRtm+sM8ceKEaPw5YcIE+eGHH0wlj4MHD0quXLmkQYMG8t///tfMZ/n333+lSJEi0qVLF/n++++dw3/55Rdn4969e/dKqVKlnOMaNWpkSnhrye/ISFu1oUYafyeTmwtnyJr6AAAAAAAAAFLeQj+pQF/peJ3u0MnzaX7IV6xYIS1atDA/P/TQQ6bahnrsscfk0KFDcuONN5rqG507dzZBqv6uYb+lYMGCUqtWLVOxIz4+3jncKv+tFi5c6Pz51KlTpsJHs2bNCPSRarh1BAAAAAAAAMCLltxJKtC36HTjl+2SwR2rpumR/Pnnn2X8+PFy//33uw3XlvTly5d3G/b3339L/fr1ZeDAgdKtWzfncG25/84778jvv/8udevWdQb5NWvWNDcG9Od77rnHDF+6dKlcunTJrbU/EG601AcAAAAAAADg1Smu1tAPxpRf9pr50lKdOnW8An3lGeir4sWLy6233irbtm2TPXv2OIe3bNnSvC9YsMC8a2ivfX22bt3ajLOGu7bat+YBUgOhPgAAAAAAAAA36/edcOsUNxDHz8XJhv0n0vRIWnXvPe3cuVMefPBBufbaayVHjhwSERFhXu+//74Zf+DAAee0zZs3lyxZsjgD+19//dWU2dHW+PrSGwC7du0y43Sa6OhoZ4t+IDVQfgcAAAAAAACAm9MXggv0LafOJ2++UClatKjXsO3bt5uw/+TJkyaU105wNYjX4F5r5Wv9/AsXLjinz58/v2nxb5XW0eBep9Ww//Dhw2YaHab199euXSsdO3aUrFmzpup+InMj1AcAAAAAAADgJk9UtmQdkbw5kjdfqGjre09aH//YsWPyxRdfyF133eU27uGHHzahvicN/3/77Tfz0uC/du3aUqBAAfMqUaKECfWLFCliOtOlnj5SG+V3AAAAAAAAALipVSqf5MsZXECfP2c2qVkyX7o7kjt27DDvXbt2dRuugfzy5ct9zmPVyP/pp5/MNFpP36Ihvob61NNHWiHUBwAAAAAAAOAmR7asckf9UkEdlTsalDbzpTdly5Y179rZrauRI0fKxo0bfc7TrFkzU1JnzJgxcubMGbfW+Prz/v37Tct/LdWjrfiB1ESoDwAAAAAAAMBLn2YVpHCe7AEdmSJ5ouSBG8qny6OoJXayZcsmt9xyi/Tu3VsGDBggTZs2lZdeekk6derkcx6tuV+vXj35559/TLivIb/FCvh1XIsWLUy9fSA1ccYBAAAAAAAA8FI0OodMur9hksG+Bvo6nU6fHmmnt3PnzjUh/fTp02XChAmmhb2W1alfv77f+azwXqfJmzevc3iFChWcrf+tMj1AaopwOByOVF0jvMTExJj32NhYjg4AAAAAAACCsmXLFvNepUqVsBy5QyfPy/hlu2TKL3vl+Lk4txr6WnJHW+in10AfSM/fyeTmwpEp2DYAAAAAAAAAGZwG9oM7VpWn21aWDftPyKnzcZI3R0KnuOmxhj6Q0RHqAwAAAAAAAEiSBvgNyhXkSAFpjJr6AAAAAAAAAADYBKE+AAAAAAAAAAA2QagPAAAAAAAAAIBNEOoDAAAAAAAAAGAThPoAAAAAAAAAANgEoT4AAAAAAAAAADZBqA8AAAAAAAAAgE0Q6gMAAAAAAAAAYBOE+gAAAAAAAAAA2AShPgAAAAAAAAAANkGoDwAAAAAAAACATRDqAwAAAAAAALC1ixcvypAhQ+Taa6+V7NmzS0REhCxatEjsRre7ZcuWab0ZSOci03oDAAAAAAAAACAl3nrrLXn11VdNIN6zZ0+JjIyUcuXKcVCRIRHqAwAAAAAAALC1H3/8UfLkySNz586VbNmyiV398ccfkitXrrTeDKRzhPoAAAAAAAAAbO3AgQNSqFAhWwf6qkqVKmm9CbABauoDAAAAAAAAsKVhw4aZOvS7du2SPXv2mJ+tuvTWOF+19T/99FMzTt89rV+/Xnr06CHFixc39fnLli0rjz/+uBw9etRr2oULF8pNN90kJUqUkKioKPOu6/7kk09CVlP/zz//lEGDBkndunXNjYscOXJI5cqV5b///a+cPn3abdrFixdL1qxZpV69eqafAc9t1XENGzaUuLi4ZG0f0gda6gMAAAAAAAAZUKPX5smZC5clvcsdlVVWDb4xWfNaAfjo0aPN+1NPPWXetZ7+7t27g17ejBkz5I477jDhd9euXaV06dKyefNmGTNmjPz000+yatUqKVCggJl21qxZ0qVLF8mfP79069bN3AT4559/5Pfff5cvv/xS+vTpI6Ewffp0GT9+vLRq1crsb3x8vKxcuVJGjhxpQvwlS5Y4n1Bo0aKFPPfcc6Z/gcGDB5u+BtS///4r99xzjynt89VXX9n+iYbMjlAfAAAAAAAAyIA00D994ZJkZBpy68tqca+t8y2uPwdCW+Jr8F2kSBFZvny5lClTxjlu8uTJcuedd8qLL74o77//vhk2YcIEcTgc5kmAWrVqeS0rVHSbnn76afPUgKuXXnpJhg4dKlOmTJG77rrLbb/nz58vo0aNknbt2pmX3mDYv3+/TJw4USpWrBiybUPaoPwOAAAAAAAAgEzvs88+k5MnT8rrr7/uFuirnj17mvI3X3/9tddxypkzp9cwLZMTKiVLlvQK9FW/fv3M+7x589yGR0ZGmtb4efPmlV69eplW+9999515AqF3794h2y6kHVrqAwAAAAAAABmQlrWxg/SynVrSxnrfvn271/jz58/LkSNHzKtw4cImJNfSOI0aNTKhf+vWraVZs2ZyzTXXhHS79GkAbWGvTyNs3LhRTpw4YUrwuHYS7Kl8+fIyduxY04J/yJAh5ibFhx9+GNLtQtoh1AcAAAAAAAAyoOTWqc+stO68+uCDDxKd7syZMybU7969u6lNr/X8NTD/3//+5+zoVkvf1K5dOyTb9cQTT5ia/lrfX+v8a+1+7ZRXDR8+XC5cuOBzvrZt20qePHlMZ7p33323qf2PjIFQHwAAAAAAAECGkyVLQuXxS5e8+xXQ1u6eoqOjzfuGDRukRo0aAa3jlltuMS8t27NixQpnp7bt27eXrVu3pjhIP3z4sLnJoDX7Y2NjTUe3loMHD5pQ35/77rvPBPpaCkhvMvTo0UNq1qyZou1B+kBNfQAAAAAAAAAZToECBcy7dhDrae3atV7DtIyO0vA8WHpDoEOHDvLRRx+ZuvUaxq9atUpSaufOnab8zo033ugW6KulS5f6ne+9996TWbNmmW2ZPXu2XL582ZQI0hJCsD9CfQAAAAAAAAAZTv369Z0d4LrWoNfQ/ssvv/TZsl07l33++edl06ZNXuPPnj3rrLuv5s+f7zMk10DfXwe6wSpbtqx516cAXPdh37598t///tfnPPqkwbPPPivXXnutvP/++9KgQQPTol/36ZlnnknxNiHt2SrU/+KLL6Rv377mC6l1o7RGlXYQ4Y8+9vL000+bk1+n13f9XYcH65dffpGOHTuaO3y5c+eWhg0bml6kAQAAAAAAAKQ/jRs3lpiYGFmwYIF5HzhwoOnctlWrVtKlSxev6YsUKSKTJ082JWuuv/566dy5swnB+/XrZ6YvVqyYDBs2zDn9gAEDpESJEqb8jmaO+ru29p85c6Y0adJEmjZtmuJ90Pr5t956q7mZoJmo7sO9995ryvHUqVPHa3q9yXDnnXeakkOaXWpNfaUhf4sWLUwpH90+2JutauprT8179uwxHVHoCa0/J9ZhhZ6ov//+u+kUQh8vWbdunbzzzjuycOFCWbZsmQnnA7Fo0SJTByt79uym9lS+fPlMfSztPXr37t0yePDgEO4lAAAAAAAAgJTSBsEzZswwgbuWotEW7BrW67ADBw7Id9995zVPp06dTGmeN998U+bNmyc///yzyRBLlSplWvJrh7OW5557zmSEv/32m/z000+m09zy5cvLG2+8IY8++qhkzZo1JB+iNmouV66cTJs2zbS8L1OmjNknDeo1r3SlNyE2btwor7zyimmU7Nq/wOeff272//7775f169ebmxSwpwiHFmWyCf0iVapUybS4HzFihPniTJw40dSG8jR06FB56aWXZNCgQTJy5Eiv4S+++GKiHUlY9K5WlSpVzCMt+miOdQfs1KlT5g6fdnixefNms13JpctJbr0uAAAAAAAAZG5btmwx75phwb60lb2W7GnXrp25SYCM/52MSWYubKvyO9ohhFVHKjF6n+KTTz4xj5doeO9KbwRoCR3thTqQ+xn6eM6OHTvMYyuuj7Rofa0XXnjBhP56YwEAAAAAAAAAkmv79u3mXZ8KADJMqB+obdu2mUdotG6VZ4mdHDlySPPmzU2v19YXJanSO0rvkHmyhi1evDhk2w4AAAAAAAAg8zh06JApO969e3fzu9boBzJMTf1gQn3lrySONVynS6psTmLL0hb/Wt/fmiYp1uMUnrTOVY0aNQJaBgAAAAAAAAB7GD16tBw/fjzRabRP0B9//FGuvfZa+fDDD01dfyDThfonTpww79qhrS/R0dFu06V0WVpvHwAAAAAAAAA8Q/09e/YkeVAWLlwoLVu25OAh84b66ZW/Dg/8teAHAAAAAAAAYF+7d+9O601ABpQha+pbrer9tcQ/efKk23QpXVYgywEAAAAAAAAAIKUyZKjvWjM/OTX3A13WsWPH5MiRIwEtBwAAAAAAAACAlMqwoX6JEiVk+fLlcubMGbdx58+flyVLlpjxFStWTHJZLVq0MO9z5871GmcNs6YBAAAAAAAAACCcMmSoHxERIX369JHTp0/LSy+95Dbu9ddfNy3sdbxOZ4mLi5MtW7bIjh073KZv06aNVKhQQb766ivTE7Xl1KlT8vLLL0tkZKT07t07FfYKAAAAAAAAAJDZ2aqj3E8++USWLVtmft6wYYNz2KJFi8zPN998s3mpQYMGyYwZM+SNN96QtWvXSr169WTdunUye/ZsqV27thnvav/+/VK1alUpW7asWwcWGtrrOtq3by/NmjWTnj17SnR0tEyfPl127dolr7zyilSuXDkVjwIAAAAAAAAAILOyVaivgf6kSZPchmmJHX2pcuXKOUP93Llzm7B/+PDhMnXqVPNzsWLFpH///jJ06FAzPlCtWrUy69b5pkyZIhcvXpTq1aublvp33XVXiPcSAAAAAAAAAADfIhwOh8PPOKSSmJgY8x4bG8sxBwAAAAAAQFC0pLSqUqUKRw6w0XcyublwhqypDwAAAAAAAABARkSoDwAAAAAAAACATRDqAwAAAAAAAIDN7d69WyIiIqR3796S3uk26rbqNttFuXLlzCs9INQHAAAAAAAAAMAmItN6AwAAAAAAAAAAKVOyZEn5448/JF++fBzKDI5QHwAAAAAAAABsLlu2bFKlSpW03gykAsrvAAAAAAAAALCtTz/91NRn13dPixYtMuOGDRvmHKa/t2zZUvbu3Svdu3eXQoUKSe7cuc2wFStW+K3/vmPHDnn99delYsWKkiNHDqlUqZK8+eabEh8f73O7lixZIl26dJHChQtLVFSUmX7IkCFy9uxZv9sYGxsr7du3l/z585thoaqp/9dff8kDDzxgWvNnz55dSpUqZX7XY+BJj4Mu58KFC/Liiy+a/dUbBq7HMFCbNm2Szp07S968ec0TBB07dpSNGzcm+TnOmjVLmjVrZuaz6tgH+zlbdu3aJX369JEyZcqYz6F48eLmGO3Zs0d8+eGHH6RBgwaSM2dOKVq0qDz44INy7NgxSU9oqQ8AAAAAAAAgU9GQtmnTpibgfeihh2T//v3yzTffSKtWreSnn34ywbanp556SlauXCl33HGHCfWnT58ugwYNku3bt8uHH37oNu24cePk0UcflQIFCphgv0iRIvLLL7/Iq6++KgsXLjQvDddd6Q2F1157zWyDbpMG8aGwbds2ueGGG+Tw4cNmW6pXr27C9gkTJsjMmTNl+fLlJrj3dMstt8i6devMTYaCBQtKhQoVglqvhvd6jE+fPm2WpTc1Vq9ebYZdf/31fuf79ttvZe7cueZmgB7DU6dOSXKtWrXKbP+ZM2fMvut+6s2PL7/8UmbPnm1uorju12effSa9evWS6Ohoueeee8zNFT1GN954o1y8eNHrM0srhPoAAAAAAABARvVGBZG4c5KuZcspMmhnqq5y/fr1JrSdNGmSs0W8tlzXQF1bZm/dulWyZHEvcqKhvIbcJUqUML8PHz5cmjRpIh999JHcfffdpmW52rx5szz++ONSu3ZtmTdvngnELSNGjJDnnntO3n//fRkwYIDb8n/++WcZP3683H///SHd14cfftgE+nrjQW8WWHS7+/bta8brdno6cOCAOU6u2x+Mfv36ycmTJ+WLL76Qu+66yzl88ODB5okHfzRs11Bfg/SUiIuLkx49epgnKX799Ve3GwnLli0zN26efPJJ+b//+z8zTLdVPzd9akM/68qVK5vheiNGt+Xvv/+WsmXLSnpA+R0AAAAAAAAgo9JAP+5sOn+l/k2HrFmzmrDWtcRNixYtTHkYbXnvqwzPE0884Qz0VZ48eUx5GqU3Bywanl+6dEnee+89r0BcW/Zrq/3Jkyd7Lb9OnTohD/S1vM6CBQukWrVq5maFK/29atWqMn/+fJ9lePSmRXIDfX3KYPHixVKrVi23QN8K9bUFvD8333xzigN9pS3stVW+HnPPJwP0yYVu3brJjz/+aMJ89f3335uf9TOwAn2lpYf0XElPaKkPAAAAAAAAZFTaCj69S4Nt1BbXpUuX9hqure21nvvvv/9ugl/Pcb6mVzq9RUv0qDlz5vhsAa8h8ZYtW7yGN2zYUEJt7dq1zhsWnjX69ffmzZvLH3/8YZ5A8DweKdkeXZ7yPIbWzRB9ikHr4PsSquOw8srnoMfaV639gwcPmlb8f/75p9SvX9+5zb4+55iYGImMTD9RevrZEgAAAAAAAAChlcplbezimmuu8TlcO0ZVJ06cCGgeHaZlelyn//fff817sK27rXWHktUK3d+yixUr5nd/U7I91vKSOs7BjgvGv1c+B62fnxitt5/UNuuTHdqhcnpB+R0AAAAAAAAAtmXVvteSN558hdVKa8z7cujQIfOeL1++gObRYdra23V67WTVCtQdDofflyfPlvShYG2LtV+erOHWdKHaHut4JHWcffG33mA/5+gr+6Q18xP7HPQphqS2+fLly3L06FFJLwj1AQAAAAAAANhWgQIFzPv+/fv9lp/xtGfPHp915JcuXWretTyMv3FJTd+oUSO38i9pydquJUuWeN1I0N8T29+UsGrYa4e0nk6fPu1Wrihcn3OjK59DbGxsUNvs63PWZfi6mZBWCPUBAAAAAAAA2FbdunVN6+6vv/5azp8/7xy+bds2effdd33Ooy2vn3/+ebegWzt21Y5TK1asKE2aNPGaRzu+PXDggFs4/dJLL5mf7733XufwRx991NRff/zxx33eODh+/Ljfmw2hVqZMGWnVqpVs2rRJJkyY4DZOf9fhrVu39tm/QErXq/X6169f71X+5rXXXjPHINyfc7du3cx2jBo1ytzU8BQXF+d200Gn19b9ely0zr7rdEOGDJH0hJr6AAAAAAAAAGyrZMmS0r17dxP21qtXTzp06GBKqHz33Xfm52nTpnnNU6tWLdNRa+PGjU2orWG9zq+d2H788cfOUi+uGjRoYFpz67qioqJk+vTpsnv3bnnwwQdNgG2pUaOG/O9//5NHHnlErrvuOunYsaNce+21phzPzp07zc2D3r17y7hx4yQ1jB071nRYq9uppWiqVasmmzdvlhkzZkiRIkXM+HD44IMPpGnTpuaGx/fffy+VKlWSX375RVavXm06o/XVIj6Un3NUVJRMnTpVbrrpJlNip02bNuazUX/99ZdZv9bJtzot1vI7euNGPxv9rHv06GGGzZw5U3LmzCnFixeX9IKW+gAAAAAAAABsbfz48aZlvNY91zBZW4h/9NFH0q9fP7+lXLSVdtmyZeXDDz+Ub7/91gT8CxYskJYtW/qcZ/To0fL000/L7NmzZcyYMabz1JEjR/oMxTVA15It2vpb39955x0TMB85ckT69+8vTz31lKQWvbHw66+/mrBaA/U333zTvOvvGrJXrlw5LOvVAH358uUmcJ8zZ445ZnrTRIdVqFAhVT7nBg0ayLp16+TJJ580Qb7eSJk4caIJ8m+++WZz88VVr169zE0CvQExadIk89IbE/PmzZPs2bNLehHh8NUrA1JVTExMUPWdAAAAAAAAAIvV0rhKlSoclABoCRdtua0t9QOh4beGu7t27ZJy5cql6/OgatWq8tBDD5kbFUj/38nk5sK01AcAAAAAAAAAm9u+fbt5L1WqVFpvCsKMmvoAAAAAAAAAYFPaqat27vrVV1+ZvgC05A8yNkJ9AAAAAAAAAEiHhg0bluQ02gnt1q1bTW187ehVOwEOBy1XFEjJotq1a5t69QgfQn0AAAAAAAAAmUawXYx++umn5pUWhg8fHtB0qVHvXwP9QLZHO5sl1A8vQn0AAAAAAAAAyAA3IML91EAgTw4g/OgoFwAAAAAAAAAAmyDUBwAAAAAAAADAJgj1AQAAAAAAABuLiIgwZVouXbqU1psCZHqXLl0y30f9XoYLoT4AAAAAAABgY3ny5DHv+/btk3Pnzkl8fHxabxKQ6ej3Tr9/+j10/V6GAx3lAgAAAAAAADZWuHBhOXv2rAkUd+/ebYaFs5UwgMQ7NY6MjDTfy3Ah1AcAAAAAAABsLCoqSq699lo5evSonDp1ypT/oLU+kLqyZs1qwvy8efNKoUKFJEuW8BXJIdQHAAAAAAAAbE4DxCJFipgXgIyNmvoAAAAAAAAAANgEoT4AAAAAAAAAADZBqA8AAAAAAAAAgE0Q6gMAAAAAAAAAYBOE+gAAAAAAAAAA2AShPgAAAAAAAAAANkGoDwAAAAAAAACATRDqAwAAAAAAAABgExk61I+Pj5cxY8ZI3bp1JVeuXBIdHS0tWrSQGTNmBLyMRYsWSUREhN/XypUrw7oPAAAAAAAAAABYIiWDcjgccscdd8i0adPk2muvlQceeEAuXLggP/zwg3Tr1k3ef/996devX8DL05sBLVu29BpeqlSpEG85AAAAAAAAAACZLNTXMF9fTZs2lZ9//lly5sxphr/22mtSv359eeaZZ6Rz585Srly5gJangf6wYcPCvNUAAAAAAAAAAGTC8jvff/+9eR88eLAz0FeFCxeW/v37m1b7EydOTMMtBAAAAAAAAAAgOBm2pf6hQ4fMe/ny5b3GWcMWLFggw4cPD2h527Ztk/fee0/Onj0rZcuWlbZt25obBMGIiYnxOXzjxo1So0aNoJYFAAAAAAAAAMh8MmyoX6RIEfO+a9cuqVq1qts4Hab+/PPPgJf31VdfmZdFW//rDYGBAweGbJsBAAAAAAAAAMiU5Xduuukm8z5ixAg5f/68c/jRo0dl9OjR5ufjx48HdHPgzTfflD/++EPOnDkj+/fvly+++EIKFiwogwYNkg8//DDgbYqNjfX5opU+AAAAAAAAACAQEQ6HwyEZ0KVLl6Rdu3aycOFCqVixonTo0EHi4uJMrf2iRYvK+vXrTWt7LaeTHFoyp169elKgQAE5cOCAZMmS/PsjVlkeDfgBAAAAAAAAABlfTDJz4QzbUj8yMlJmz54tw4YNM4H7Rx99JNOnT5du3brJ1KlT3Ur0JIe2rm/UqJGp3b99+/YQbjkAAAAAAAAAAJmspr6KioqSoUOHmperRYsWmff69eunaPlWR7nJbe0PAAAAAAAAAEAwMmxL/cR8+eWX5r1Hjx4pKu+zZs0aiYiIkDJlyoRw6wAAAAAAAAAAyISh/smTJ72GaemdCRMmSIMGDeSWW25xDj9y5Ihs2bLFvLvSekae3Q5ooD9w4EDZs2ePtG/f3nSaCwAAAAAAAABAuGXo8jta87506dJStWpVyZEjh6xevdqU3qlQoYJ8++23kjVrVue0Y8aMkeHDh5tSPVqH39KzZ0/TGr9JkyZSsmRJOX78uCxZskS2bt1qWuiPGzcujfYOAAAAAAAAAJDZZOhQv3v37qZz3JUrV0pcXJyUL19ehgwZYlrZR0dHB7SMRx55RObMmWNuBmgrfu2At2LFivL888/LgAEDpECBAmHfDwAAAAAAAAAAVITDs7YMUl1MTIyz1A8AAAAAAAAAIOOLSWYunKFr6gMAAAAAAAAAkJEQ6gMAAAAAAAAAYBOE+gAAAAAAAAAA2AShPgAAAAAAAAAANkGoDwAAAAAAAACATRDqAwAAAAAAAABgE4T6AAAAAAAAAADYBKE+AAAAAAAAAAA2QagPAAAAAAAAAIBNEOoDAAAAAAAAAGAThPoAAAAAAAAAANgEoT4AAAAAAAAAADZBqA8AAAAAAAAAgE0Q6gMAAAAAAAAAYBOE+gAAAAAAAAAA2AShPgAAAAAAAAAANkGoDwAAAAAAAACATRDqAwAAAAAAAABgE4T6AAAAAAAAAADYBKE+AAAAAAAAAAA2QagPAAAAAAAAAIBNEOoDAAAAAAAAAGAThPoAAAAAAAAAANgEoT4AAAAAAAAAADZBqA8AAAAAAAAAgE0Q6gMAAAAAAAAAYBOE+gAAAAAAAAAA2AShPgAAAAAAAAAANkGoDwAAAAAAAACATRDqAwAAAAAAAABgE4T6AAAAAAAAAADYBKE+AAAAAAAAAAA2QagPAAAAAAAAAEBmD/X//fdf2bt3b7gWDwAAAAAAAABAphPSUP/EiRPy5JNPStGiRaVIkSJSvnx557hVq1ZJx44d5bfffgvlKgEAAAAAAAAAyDSyhLJlfqNGjeT999+X0qVLS9WqVcXhcDjH16pVS5YvXy5ffvllqFYJAAAAAAAAAECmErJQf9iwYfLnn3/K5MmT5ddff5Xbb7/dbXzOnDmlRYsWsmDBglCtEgAAAAAAAACATCVkof6MGTOkc+fO0r17d7/TlC1bVvbt2yepJT4+XsaMGSN169aVXLlySXR0tLmxoNuanOXo0wZ6c0JLC91xxx2ybdu2sG07AAAAAAAAAABhC/X//vtvqVatWqLT5MiRQ86cOSOpQUv/aPD++OOPy8mTJ+WBBx6QHj16yJYtW6Rbt24mpA/Uww8/bJZz+fJl8659A+iNgQYNGsjmzZvDuh8AAAAAAAAAAFgiJUQKFSoke/fuTXQaDdSLFy8uqWHatGnm1bRpU/n5559NC3v12muvSf369eWZZ54xTxaUK1cu0eUsXLhQPv74Y2nWrJlZTlRUlBl+7733Stu2beWRRx6RxYsXp8o+AQAAAAAAAAAyt5C11G/evLlpvb5//36f47VF+5w5c+TGG2+U1PD999+b98GDBzsDfVW4cGHp37+/XLhwQSZOnJjkcjTQV6+88ooz0Fdt2rSR9u3by5IlS0xfAgAAAAAAAAAA2CbUf/755+XSpUumZfxXX30lR44cMcP/+OMPGT9+vLRu3dqE4gMHDpTUcOjQIfNevnx5r3HWsEA67V20aJHkzp3b7JcnDfVVoC31Y2JifL42btwY0PwAAAAAAAAAgMwtZOV3atasKd98840pS3PPPfc469rXqFHDvOfNm1emTJkilSpVktSgndmqXbt2SdWqVd3G6TCVVAt7rf+vfQXoPmTNmtVrvLUvdJgLAAAAAAAAALBVqK+6du0qO3fulEmTJsmqVavk33//lejoaGnUqJHcd999pvRNarnppptk8uTJMmLECPOUgHbSq44ePSqjR482Px8/fjzRZZw4ccK858uXz+d43TfX6ZISGxvrc7i21gcAAAAAAAAAIFVDfVWwYEFTsz6t9ezZ09TM145u9SmCDh06SFxcnKm1X7RoUTONr9b3AAAAAAAAAABk+Jr66U1kZKTMnj1bhg0bJlmyZJGPPvpIpk+fLt26dZOpU6e6lejxx2qh768l/smTJ92mAwAAAAAAAADAFi31P/vss4Cn1br7qUE75h06dKh5eXZ+q+rXr5/o/NpBbvHixU0N/suXL3u17Ldq6adWPwEAAAAAAAAAgMwtZKF+7969JSIiItFptMNcnSa1Qn1/vvzyS/Peo0ePJKdt0aKFfP3117J8+XJp3ry527iffvrJOQ0AAAAAAAAAALYJ9bV+vS9aumbNmjXy1VdfmY50u3TpIqlFy+NYndlatPTOhAkTpEGDBnLLLbc4hx85csS8tDNf1w59H3roIRPqDxkyRObNmyfZs2c3w+fPn29CfQ36K1eunGr7BAAAAAAAAADIvEIW6vfq1SvR8X379pU2bdrII488IqmlUaNGUrp0aalatarkyJFDVq9ebUrvVKhQQb799lu3cjpjxoyR4cOHm1I9Woff0qpVK+nTp4988sknUqdOHenUqZMcOnRIvvnmG3PDYOzYsam2PwAAAAAAAACAzC3VOsqNiYkxrfRffPHF1FqldO/eXQ4ePGieInjvvfdMGK8t7teuXStly5YNeDkffvihmV9LB+n7rFmzzL7oTYJq1aqFdR8AAAAAAAAAALBEOLTQfSoZNGiQ/O9//5PTp0+n1iptQW94qNjY2LTeFAAAAAAAAABAOs6FU62lvt47WLJkieTMmTO1VgkAAAAAAAAAQIYSspr6Gtj7cunSJdm/f7989tln8ssvv8g999wTqlUCAAAAAAAAAJCphCzUb9mypak5n1hLfX2cYNSoUaFaJQAAAAAAAAAAmUrIQn3tANdXqJ8lSxYpUKCA1K9fXxo3bhyq1QEAAAAAAAAAkOmELNQfNmxYqBYFAAAAAAAAAADSsqNcAAAAAAAAAACQMoT6AAAAAAAAAABk9PI7Wis/sY5x/dF5Ll26lNzVAgAAAAAAAACQaSU71G/evHmyQn0AAAAAAAAAAJDKof6iRYuSOysAAAAAAAAAAEgGauoDAAAAAAAAAGAThPoAAAAAAAAAAGT08jv+xMbGyrx58+TAgQNy4cIFr/Fah3/8+PGhXi0AAAAAAAAAABleyEL9S5cuSc+ePWX69OnicDhMeK/vFut3Qn0AAAAAAAAAANK4/M7bb78t06ZNk/vuu09+/fVXE+A/9dRTpuX+yJEjJX/+/HL77bfLjh07QrVKAAAAAAAAAAAylZC11P/yyy+lRo0a8sknnziHaZDfqFEj8+rYsaM0bNhQWrduLX379g3VagEAAAAAAAAAyDRC1lJ/+/bt0rJlS+fvWmYnLi7O+Xv16tWlS5cuMnbs2FCtEgAAAAAAAACATCVkoX727NklV65czt/z5Mkjhw8fdpumbNmysm3btlCtEgAAAAAAAACATCVkoX7p0qVl7969zt+rVKkiS5Yscessd+XKlVKwYMFQrRIAAAAAAAAAgEwlZKF+ixYt3EL87t27y9atW6Vz587ywQcfSM+ePWXZsmXSoUOHUK0SAAAAAAAAAIBMJWQd5d5///1y+fJl2bdvn2m1//jjj8uiRYtk5syZMnv2bDONdpQ7YsSIUK0SAAAAAAAAAIBMJcLhWh8nDH799VfZsWOHqaevoX6WLCF7OCDDiImJMe+xsbFpvSkAAAAAAAAAgHScC4espX7btm3l3nvvlVtuuUVy587tHF6/fn3zAgAAAAAAAAAAKROyZvMLFiyQ3r17S9GiReXuu++Wn376SeLj40O1eAAAAAAAAAAAMr2Qhfp//fWXvPbaa1KhQgX56quvpGPHjlKyZEkZMGCArFmzJtMfaAAAAAAAAAAA0k2orwH+s88+K+vXr5fff/9d+vfvL1mzZpV33nlHGjRoINWrV5eRI0fK3r17Q7VKAAAAAAAAAAAylbB2lKuLnj9/vnzxxRfy3XffyenTp01HuXFxceFapS3RUS4AAAAAAAAAZC4xad1Rri8RERFy4403SqVKlaRUqVLy5ptvyqVLl8K5SgAAAAAAAAAAMqywhfrHjx+XKVOmmFb6K1asMK328+bNK7feemu4VgkAAAAAAAAAQIYW0lD/4sWL8n//938myJ89e7Yps6N19Tt06CD33HOPdOvWTXLkyBHKVQIAAAAAAAAAkGmELNR/8MEHZdq0aXLixAnTKr9+/fomyO/Ro4cUKVIkVKsBAAAAAAAAACDTClmoP378eClXrpw89thjJsyvXLlyqBYNAAAAAAAAAABCGeovXrxYmjVrxkEFAAAAAAAAACBMsoRqQQT6AAAAAAAAAADYJNQHAAAAAAAAAADhRagPAAAAAAAAAIBNEOoDAAAAAAAAAGATGT7UdzgcMn36dGnVqpUUL15ccuXKJdddd5307dtXdu7cGdAyFi1aJBEREX5fK1euDPt+AAAAAAAAAAAQmdEPwTPPPCOjRo0ygf7NN98s0dHRsm7dOvn4449l8uTJsmLFCqlRo0ZAy2rRooW0bNnSa3ipUqXCsOUAAAAAAAAAAGSiUP/gwYMyevRoKVeunAnyNdC36PD+/fubwH/ChAkBLU8D/WHDhoVxiwEAAAAAAAAAyKTld3bv3i3x8fHStGlTt0BfderUybwfPnw4jbYOAAAAAAAAAIDgZOiW+pUqVZLs2bPL8uXL5dSpU5I3b17nuB9//NG8t27dOuDlbdu2Td577z05e/aslC1bVtq2bSuFCxcOy7YDAAAAAAAAAJCpQv1ChQrJq6++KgMHDpSqVatK165dTbC/YcMGmTdvnjz00EPy+OOPB7y8r776yrwsOXPmlOHDh5vlByImJsbn8I0bNwZc1x8AAAAAAAAAkHll6FDf6ii3RIkS0rdvXxk7dqxzeJMmTeTuu++WbNmyJbmMIkWKyJtvvimdO3eWMmXKyPHjx2XhwoXy7LPPyqBBg0xpH10+AAAAAAAAAADhFOFwOBySgb3yyivy0ksvmQ5u7733XilQoID8/vvv8vTTT8tvv/0mU6ZMkVtuuSVZy9YW9vXq1TPLPHDggGTJkrwuCqwW/LGxscmaHwAAAAAAAABgL8nNhTN0R7kLFiyQF154Qfr16yeDBw+WUqVKSe7cuU3HuTNnzjTlc/r375/s5WvJnEaNGsmhQ4dk+/btId12AAAAAAAAAAAyVag/a9Ys896qVSufJXVq1qwpf/31lxw5ciTZ67A6ytXOcwEAAAAAAAAACKcMHepfvHjRvP/zzz8+x1vDo6KikrX8S5cuyZo1ayQiIsLU2gcAAAAAAAAAIJwydKivZXbUqFGj5MSJE27jJk2aZErmaE38vHnzmmHaYn/Lli1eLfe1ppFn1wMa6A8cOFD27Nkj7du3l4IFC4Z9fwAAAAAAAAAAmVukZGC33367fPjhh7Jo0SKpVKmSdO3a1XRqu27dOvn5559NC/3Ro0c7px8zZowMHz5chg4dajrWtfTs2dO0xm/SpImULFlSjh8/LkuWLJGtW7eaFvrjxo1Loz0EAAAAAAAAAGQmGTrUz5o1q8yZM0feffdd+eabb2Ty5MmmJE/RokXlzjvvlOeee850dpuURx55xCxHbw5oK/7IyEipWLGiPP/88zJgwABzowAAAAAAAAAAgHCLcHjWlUGqi4mJcZb5AQAAAAAAAABkfDHJzIUzdE19AAAAAAAAAAAyEkJ9AAAAAAAAAABsglAfAAAAAAAAAACbINQHAAAAAAAAAMAmCPUBAAAAAAAAALAJQn0AAAAAAAAAAGyCUB8AAAAAAAAAAJsg1AcAAAAAAAAAwCYI9QEAAAAAAAAAsAlCfQAAAAAAAAAAbIJQHwAAAAAAAAAAmyDUBwAAAAAAAADAJgj1AQAAAAAAAACwCUJ9AAAAAAAAAABsglAfAAAAAAAAAACbINQHAAAAAAAAAMAmCPUBAAAAAAAAALAJQn0AAAAAAAAAAGyCUB8AAAAAAAAAAJsg1AcAAAAAAAAAwCYI9QEAAAAAAAAAsAlCfQAAAAAAAAAAbIJQHwAAAAAAAAAAmyDUBwAAAAAAAADAJgj1AQAAAAAAAACwCUJ9AAAAAAAAAABsglAfAAAAAAAAAACbINQHAAAAAAAAAMAmCPUBAAAAAAAAALAJQn0AAAAAAAAAAGyCUB8AAAAAAAAAAJsg1AcAAAAAAAAAwCYI9QEAAAAAAAAAsAlCfQAAAAAAAAAAbIJQHwAAAAAAAAAAmyDUBwAAAAAAAADAJgj1AQAAAAAAAACwCUJ9AAAAAAAAAABsIsOH+g6HQ6ZPny6tWrWS4sWLS65cueS6666Tvn37ys6dOwNeTnx8vIwZM0Zq1aolOXPmlCJFisgdd9wh27ZtC+v2AwAAAAAAAACQaUL9Z555Rm699VbZunWr3HzzzfL4449L+fLl5eOPP5batWvLxo0bA1rOww8/bOa9fPmyee/YsaPMmDFDGjRoIJs3bw77fgAAAAAAAAAAEJmRD8HBgwdl9OjRUq5cOVm3bp1ER0c7x+nw/v37y6hRo2TChAmJLmfhwoXmJkCzZs3k559/lqioKDP83nvvlbZt28ojjzwiixcvDvv+AAAAAAAAAAAytwzdUn/37t2mbE7Tpk3dAn3VqVMn83748OEkl6OBvnrllVecgb5q06aNtG/fXpYsWSJ//vlnyLcfAAAAAAAAAIBM01K/UqVKkj17dlm+fLmcOnVK8ubN6xz3448/mvfWrVsnuZxFixZJ7ty5zc0BTxrqz5kzx7TUr1y5cqLLiYmJ8TlcSwDVqFEjgD0CAAAAAAAAAGRmGTrUL1SokLz66qsycOBAqVq1qnTt2tUE+xs2bJB58+bJQw89ZOrjJ+bMmTPy999/m9A9a9asPm8cKDrMBQAAAAAAAACEW4YO9a2OckuUKCF9+/aVsWPHOoc3adJE7r77bsmWLVui8584ccK858uXz+d4q6yPNV1iYmNjg2rBDwAAAAAAAABApqmpb9XB7927tzz33HOyd+9eOX36tCxbtkwuXbokrVq1kunTp6f1JgIAAAAAAAAAEJAMHeovWLBAXnjhBenXr58MHjxYSpUq5ayNP3PmTMmZM6f0798/0WVYLfT9tcQ/efKk23QAAAAAAAAAAIRLhg71Z82aZd61Rb6nIkWKSM2aNeWvv/6SI0eO+F2G3gQoXry47Nq1Sy5fvuw13qqlb9XWBwAAAAAAAAAgXDJ0qH/x4kXz/s8///gcbw2PiopKdDktWrQwHeYuX77ca9xPP/3knAYAAAAAAAAAgHDK0KG+ltlRo0aN8iqfM2nSJNm+fbvUq1dP8ubNa4Zpi/0tW7Z4tdx/6KGHzPuQIUOcNwrU/PnzTajfvHlzqVy5cirsEQAAAAAAAAAgM8vQof7tt98uLVu2lE2bNpnyOH369JGBAwdKu3btTOe52kJ/9OjRzunHjBkjVatWNe+utHyPzrt06VKpU6eODBo0SHr16iWdOnWS6OhoGTt2bBrsHQAAAAAAAAAgs8nQoX7WrFllzpw5MnLkSCldurRMnjzZhPibN2+WO++8U3799Ve54YYbAlrWhx9+KO+9955ERESYd63X36VLF1m9erVUq1Yt7PsCAAAAAAAAAECEw+FwcBjSVkxMjHmPjY3lowAAAAAAAACATCAmmblwhm6pDwAAAAAAAABARkKoDwAAAAAAAACATRDqAwAAAAAAAABgE4T6AAAAAAAAAADYBKE+AAAAAAAAAAA2QagPAAAAAAAAAIBNEOoDAAAAAAAAAGAThPoAAAAAAAAAANgEoT4AAAAAAAAAADZBqA8AAAAAAAAAgE0Q6gMAAAAAAAAAYBOE+gAAAAAAAAAA2AShPgAAAAAAAAAANkGoDwAAAAAAAACATRDqAwAAAAAAAABgE4T6AAAAAAAAAADYBKE+AAAAAAAAAAA2QagPAAAAAAAAAIBNEOoDAAAAAAAAAGAThPoAAAAAAAAAANgEoT4AAAAAAAAAADZBqA8AAAAAAAAAgE0Q6gMAAAAAAAAAYBOE+gAAAAAAAAAA2AShPgAAAAAAAAAANkGoDwAAAAAAAACATRDqAwAAAAAAAABgE4T6AAAAAAAAAADYBKE+AAAAAAAAAAA2QagPAAAAAAAAAIBNEOoDAAAAAAAAAGAThPoAAAAAAAAAANgEoT4AAAAAAAAAADZBqA8AAAAAAAAAgE0Q6gMAAAAAAAAAYBORab0BAAAAAAAAAABkFufjLsv6fSfkxLk4yZolIuj5CfUBAAAAAABguzDs9IU4yROVTWqVyic5smVN681CBsI5hnA5eOK8jF+2U6b8us8E+n//czpZy8nQof6nn34q9913X6LTtG7dWubPn5/oNIsWLZJWrVr5HR8bGyuNGzdO9nYCAAAAAFIXgQ3HF/YPwyz5cmaTO+qXkj7NKkjR6Bxpuo2wN84xhNOmAyek14TVcuT0xRQvK0OH+rVr15ahQ4f6HDd16lTZtGmTtG/fPuDltWjRQlq2bOk1vFSpUinaTgAAADsiEOP4cn7ZV2b+/hLYcHyR8cIwDfg/XrpLvlu7Xybd31Cql8iXJtsIe+McQ7j//hGqQF9FOBwOh2QyFy9elBIlSsiJEydk3759UrRo0YBa6usNgmHDhoV8e2JiYpwt/gFkLpn5H9QIP84vhAuBWHhl9uOb2fc/3DL78Q2khVzhPNkJBTm+SIfXrs7vLw0oDNPv8KwnmmXoaxlCj3MM4fbqrM3m5qOnvz8fYN4v7N8S1PIydEt9f7777js5evSo3HzzzUkG+sjcCMQQLpn9H9QIL84vhBMtmMIrsx/fzL7/4ZbZj2+gLeR0vE5HKMjxRfqh/3YKtHWrTjd+2S4Z3LFq2LcLItpWWJsLO6yfzbv+njBcPH73nE4SGWd+cg73MV0iyzfDrXW4jXOZ1uXnYM+xV2Zulrsalw1sO69sjPt6PY6Dv2103Z9EluF9HN1/1x+cw92OsZ/l+/wcXaYzx19/j094NzPEX9kP/T3eZb8SprMW6tDpzDZYxy1eJN4hEc5pr74nTH9lh6/8njBvvLVjzvERzmXqdlj77DGvn2WY+V2W5T59wjbq8hOWm7CfCfNa+2Jaznuvx2Uf9v57RtpmSVhPQre4Ce/fyWk5LnmCvpxkypb67dq1k59//llmzpwpnTp1SnJ6q6X+nXfeKY0aNZKzZ89K2bJlpW3btlK4cOEUbw8t9dMfAjGEEy3EwPkFu6IFE8eX88u++P76byHnz0PNK2TqUDDYoO6NOVtkUuyegJd/d+My8kTrSr6XG0Bg5y8IuzLEK7ALZjnOaYMJF69suPf6khfcee9H8OGdhCrAi78ajCWEbwnTRWhop8Pdxl8NsKyAK2GbrgR/1nKvhHpXVuA2nxWEmWWIQy7Hx8vcTYfkUny8MwxLeHf/WVnDsmURaVKhoERkuRq0JbylLMizjq/ndM7A0iNQNKGdNZ31uvpBOdefMN2V5Vif3pXleAWFcnV91jhrGa7b4lyuc17x+N11ve7bmTDN1emd80S4bI/fz8J5FQnw8/I9jfvyXcbrNiS6ftfA1M8ykr19IhERydl+7+1IbPsTXXZE8tft+h0J/vgl/JzlyvoROjHjz8ia+IpBt9TPdKH+nj17pEKFClK8eHHzc9asSZe58NdRbs6cOWX48OEycODAoMJ7Txs3bpQaNWpQfiedIHBFOPEPanB+wc4IxOx1fN0CsQBDOa/wyQqy/IRTwbSgS9gO/2HauEU7ZOqa/QHv/811SkjvJuUTD8s8t/XKwQg0lPO9rSlrTWd9HoGGcr4COevzDTSU00Bu0Z+HZc1fxwIOEGqVzCsNyhV0a/Xm+pk7g6sAQzlruPv8flqz+fj9aijn0qrPCq1cW855bY/1ecXLHwdOSLwzQJMkQ5GsESLlCuVKCDD8hHVXT6qr6zVhiPn9yrSuYZlZ/9WwLmEul3ms8a7DXI6Hc5y1Pc7z+uo4s19eYaL7dritwyO8831cro5P7BxKeUgnIQjqQhPWBbcv3oFmKEK75G+D57EguAOAjBbqZ7ryOxMnTpT4+Hi57777Agr0VZEiReTNN9+Uzp07S5kyZeT48eOycOFCefbZZ2XQoEESHR0tffv2Dfu2I/x4JBfhxmOjCEcruYTpRMYt3h7UI6PvL9gmT7apnKLHWq+GS+b/vsOpAALEhLkDDOX8BVdBhXLe23p125IO5fwFcleWHFAo52sdrsfBVyh3dZj/x1ythXq2lLsayrluv+9HXZ2/uwzTVnI/bzoopSISWsmppIKKpcv3ycsHN5lgzDuU8w73XNdrhV6eAaJrWObMtPw89moFHu4t6fyEcp7BmXPhSYdyVz6thIDRGZi5BGeBhHK6/XGXpU/WIFp0LRd5N/ZqyOXeCs9+oVxbcUi7bEGEchtFTm1MOpTLksxQLpB9SZ1QLvHvW6Ct6R7X/wVT2e/olVdGki0Z85wUe7qaLAMAIPGOq3/rcP+bqu/h7n/TSWq8/2ksDj/r9/ybTNLLD379Dv3Zbf2BrTvx4xPM8dP1+16Gjj/iWJy8P+ozU0t9DfPLly8ve/fulR07dpifU0Jb2NerV08KFCggBw4ckCxZsiRrOZTfyfgtEJNTY845n2sW4Kd1W0AhVxKhnK+Q68qQgEM5X8txTsujq3LpskPGLt4uFy9ddmvBk1hAkCMyi/RsUEqyZonwCuWufg6B158zy3fWvrNCNQmqBp31R5B74Bfc46veoZz79iRWi846PoGHcv4fYQ00lLsaGroHMN4t5VxCw4AfZb2ynHQXyiUnRPIXRKVdS7lA9iXQx1sT25fAAszE9yWQUA4AACDQ0M7lb6XJDu6u/g0lwPDMR3Dn+TffJMMvv8FbgNtgAjT/y0lsGxI/Vp5/o0tZkBfQfgS0jb7Hu/6LQv+S73YMrvzuvPOndYp0evOr+zxXp/H4m7YZrPWNPP6WHOEyzvpbeITLOJf1JUyY5ep6r0wnPqZzWD+7TeO+7ITFJCxTf0nYTt/TW+uIiMgiJ89fli0HTwV4Hlw9H+uWKSj5c2Uz2xnh3PcIiXCuQ//TbXFfb4TL7xEu72bZ+m//K9sf4ZzeWkbCcb06T8Ixurq+K/NdOQb6nvCyhlmLuTLM4/eE8QnH8er4q9OabbE+ET/LsU4Nt+Ukug73ZVj75W8ZPpcvrtvoucwAl++2fS7LCGYbPZfhMu7ipXjp/P4yOXX+kte1m45yA6B19P/66y9p06ZNigN9pSVztMb+0qVLZfv27VK5cuVkL+vAv6fkjWnLkt0phAQZyvleTgg6h3CuL4BQzprXuRxr/RJUKOcW6F0JxhzJrC0Xf/GSPJA1seDFI7xZ7pDRseKzvpw5hn5DpIT1+QuH3P9aFWiI5L/GnO998bcdvscnLCP5oVxi6/DeF//H3N++BFNzzt++BBrKJfa5JBXKPRWZjGek1gY5PdKPqyctAAABh3IquKDJ/W+Pnn+L8xk0BRDKSTLCJs/l+9qXgMMsr+1IbuDleznJCeXc9yeIfUnks/H414nffXH926f+fd91He5h25W/fFjDzLt3+BbhMZ+1Xa7zXX3exSVVcV2PCbJELsbHy79nLgV1juqrWL4cEpXN+sux6zqvhFPWenV6H4Hc1SDLJUWx9i/C13KuHgPr94RZXMclhHzWsXWGb1f21eE6n7Ud1rxW0JbF/RhfDeF0MVeWbeZzedcgz3XfrP0wm2+Nu7IcM5mOsAK7hO25Gn5Z224dzeQHeFf2MkUBXkpDvLjL8fLUN7/L2YuXJVB5smeVD++tL1GRWdI0yEsybHQeH5fjGcx2eh0z/uGRHOfjLkuj1+abTuMDlT9nNnmpTxvJkS2wKiBAjwalg2pInJRMVX5n/Pjx5r1Pnz4hW6bVUa52npsSJc5ukUEbku60F+nwkVwAAEL6iKsEHjQlEiKl9DHXq+OTHwyG4nHXhGl8TRdcKJdwPHwvJ9BQzvuYBB/KRfhpNafjLscHdsxdj0lUtqyS1QqIrHGewZfrMpyhnPU5u7ZwE6/53LfTCpGuLscl7vFY79XAKWEilxZzXqGcyJkL8bLjnzNBnx/VSuaT6BzZXXZLW/tZYdbV9ScEJVdaufkN5a5uj0PHZbG2Uf/L4jaNa+jpGsolLPZq8Oec70ra4mytJ8GFcj6DNNfALolQbs/RM/JJMv4R+UTrinLtNXl8rMMlXAowlPMZ/Lnsh6/AK0uAreuujEk0mNMnJXt+vEpOX/BuIedPdFSkfN+vqQlskgrnfB2jYMO5q8fTfgFdcgOxlU8TiCEwdzUqE1QYdmfjstK0YkJeAyRFr/N31C8V1Dl2R4PSBPoISp9mFeS7tfsDLpmblEwT6h89elR++OEHKViwoPznP/8JyTIvXboka9asMX/R0lr7ADJvKKeSaokUSCDmuZzkhHJXh/laR2ChnOtykxvKue6L/2OR+Hif+5KMUM5ajr9tDSSUE8/g6sp2uIZyCZNYP18NtcyyXMOvxFrTJRHKXZ3E5VFUbcEU75BjZy8FFHRan41Oc020tpDLGlQo5x6AXdkGz+31WI5ruKZhmTMMdAnLdNsCDuWc23N1OVcioKBCOWs7rVAlYRsiAgrlzPRZPAO9q0FnIKGcr0DOeab5eNQ10FZyznUmsp6kWp9d3Y6EV9xlh/RPRiu5cffUM+dYksGfj5DL134Eu5zE9tszlPMVyF3dnvC2mEt2IDY4YwRiyd3/aX0zxv6nxvH99td9QR/fR1tVzFDHt2fD4FrI9WhURioUSbipgcQRiCE9hWFF8kTJAzekvDoDMhfOMYRb0egcMun+htJrwuqQBPuZJtT//PPP5eLFi3L33XdLVFSUz2mOHDliXtr63mqBr2JjY6Vx48Zu/yjTQH/gwIGyZ88e6dChg7lZkBLnHdlke3yJAEM3/+MlqeAvgFAu4edgWhZ6j5ektjWAUC7JfQkwlPOc3jOUuxrIiVyK933MfR0Ta5rs2kLOtcWW63a6tkJz3T7XQMraJmcrOfcg8GqC55pA+ArdrmyT52OqzvFXQzFfteYSRlp19K4+QmqFlgmTZ/GzHVfDMt+BXoTflnIJQVniy3HWlvMVypnDeHV7r7ay8wj+nMO9QzlruqTqzqX00dXLl+NlxJwtcj7OKjeVtFzZssrwbtUle+TVPjtSWn/OeVYFEXJl8VhH0CGXz9ZsKXuE1bklAYRyfse5hX4pD+XSUrIDwQEEYghvK7kbKhXhEAcgswdimX3/w43jm4DAJrw4vkgPYZgG+jqdTg9wjiG9qV4in8x6opmMX7ZLpvyyV44H8e/3TNtRbs2aNU3HtuvXrzc/+zJs2DAZPny4DB061PxsKVeunAl0mjRpIiVLlpTjx4/LkiVLZOvWraaFvv5ctmzZZG+bdpR7/GycjPri/wIO5RILp/yGXAEEf1fGBBTK+VuO53zO3wMMENPq0dXM3kIO9u6MGeD8Qmo4dPK8dHpvacCt5GY+cQP/qOb4cn6lE3x/E2w6cCLgULBaiehU+3wyCo4vUuNa5isM03+b681ebaFPoA/OMdiB5pAb9p+QXje3k6xZImTDml+Cmj9ThPqrV682Hdo2bNhQVq1a5Xc6f6H+yJEjZc6cOfLnn3+alvyRkZFSsWJF6dKliwwYMEAKFCiQou3TUN96IgBpi8AV4cY/qMH5BbsjsOH4cn7ZF9/fBISC4cXxRWqGYafOx0neHNmkZsl8NLYD5xhsKbm5cKYI9dM7Qv30g8AVqYF/UIPzC3ZHYMPx5fyyL76/VxEKhhfHFwCApBHq2xihfvpC4IrUwD+owfmFjIDAhuPL+WVffH8BAADSHqG+jRHqpz8Erkgt/IManF8AAAAAAGROMZTfsS9C/fSLwBUAAAAAAABAesqFI8OyNUAGkSNbVmlQrmBabwYAAAAAAAAAGFkS3gAAAAAAAAAAQHpHqA8AAAAAAAAAgE0Q6gMAAAAAAAAAYBOE+gAAAAAAAAAA2AShPgAAAAAAAAAANkGoDwAAAAAAAACATRDqAwAAAAAAAABgE4T6AAAAAAAAAADYBKE+AAAAAAAAAAA2QagPAAAAAAAAAIBNEOoDAAAAAAAAAGAThPoAAAAAAAAAANgEoT4AAAAAAAAAADZBqA8AAAAAAAAAgE0Q6gMAAAAAAAAAYBOE+gAAAAAAAAAA2AShPgAAAAAAAAAANkGoDwAAAAAAAACATRDqAwAAAAAAAABgE4T6AAAAAAAAAADYBKE+AAAAAAAAAAA2QagPAAAAAAAAAIBNEOoDAAAAAAAAAGAThPoAAAAAAAAAANgEoT4AAAAAAAAAADZBqA8AAAAAAAAAgE0Q6gMAAAAAAAAAYBORab0BENm5c6ecPXtWYmJiOBwAAAAAAAAAkAls3LhRcuXKFfR8hPrpQIECBSSjnpSqRo0aab0pADIwrjUAuM4AyAj4Ow0ArjVA5pMrV65kZcMRDofDEZYtQqZnPXkQGxub6Y8FgPDhWgMg3LjOAEgNXGsAcK0BEChq6gMAAAAAAAAAYBOE+gAAAAAAAAAA2AShPgAAAAAAAAAANkGoDwAAAAAAAACATRDqAwAAAAAAAABgExEOh8OR1hsBAAAAAAAAAACSRkt9AAAAAAAAAABsglAfAAAAAAAAAACbINQHAAAAAAAAAMAmCPUBAAAAAAAAALAJQn0AAAAAAAAAAGyCUB8AAAAAAAAAAJsg1AcAAAAAAAAAwCYI9QEAAAAAAAAAsAlCfQTtu+++k7Zt20qhQoUkZ86cUr58eenZs6fs3bs34GWcOnVKhg4dKjVq1JBcuXJJ/vz5pW7dujJ8+HA+EQApvs4cP35cXnzxRalVq5bkzZtXChcuLA0aNJAxY8bI+fPnOcJAJvbpp59KREREoq82bdoEtKz4+HhzXdFrjV6rihQpInfccYds27Yt7PsBIHNca5YtWyYDBgyQevXqmb8X5ciRQ6pUqSLPPvus+fsOgMwtlH+vcRUXFye1a9c28+s1B0D6E5nWGwD7cDgc8vDDD8tHH30k1157rfTo0cOEZQcOHJDFixfLnj17pHTp0kku56+//pLWrVvLzp075cYbb5ROnTrJhQsXZPv27TJt2jQT9gPInEJxndF/4Oo/fPUac8MNN0jfvn3NNWb27Nny+OOPmxsGP//8s2TJwn1tIDPSf6D6+7vG1KlTZdOmTdK+ffuAlqXXq48//liqVatmri+HDh2Sb775RubOnSsrVqwwwwFkTqG61tx2221y5MgR83eae++91wRsixYtkjfeeMP820mvNddcc00Y9gBAZvt7jauXX37ZZDQA0q8IhyYoQADee+89efLJJ+Wxxx6Td999V7Jmzeo2/tKlSxIZmfh9osuXL0tMTIxs3LhRZs2aJa1atQp6GQAyrlBcZ/Qfudp6rX///jJq1Cjn8IsXL5p/EP/yyy/mBkHz5s3Dth8A7EevESVKlJATJ07Ivn37pGjRoolOv3DhQtNIoVmzZuZGYVRUlBk+f/5886SRDtdrDQCk5FozcuRIE+YXL17cOUz/Ca9/Vxo7dqw8+uij8sEHH3CQAaToWuNqzZo10qhRI/NvqSeeeEKuu+462bJlC0cYSGdopoiAnDt3zpTGqVChgowePdoraFOBhPF6p1gDtWeeecYr0A90GQAyplBdZ7SFvurYsaPb8OzZs5ugTR0+fDhk2w0gY9CneI4ePSqdO3cO6B++2kJfvfLKK85AX+kj7toibsmSJfLnn3+GdZsBZPxrjTZUcA30lbbWf+GFF8zP3DwEEIprjevNgN69e0vjxo2lX79+HFwgHSNBRUC0Bdq///5rLu7a2n7GjBnmH6paC19L6FSsWDGg5egj6er22283tbG1tb6WytAyGzfddJPkyZOHTwTIpEJ1nalevbp5nzNnjpnPtS7kvHnzTN1rfWIIAFyNHz/evPfp0yegA6PlL3Lnzi1Nmzb1Gqehvl6DNGyrXLkyBxpAsq81/mTLls280ygKQCivNcOGDTN9A61bt87cQASQfhHqIyC//vprwgkTGSnXX3+9bN261TlO61JrmYu33nor4OVoh086j9a5tmjnclOmTJGWLVvyqQCZUKiuM/oX188//1zefvtts0ztIFevNRqwHTt2TL766ispWbJkWPcFgL1ofx1aNkevDR06dEhy+jNnzsjff/8tNWrU8PlUUaVKlcw7HeYCSMm1JjETJkww7+3ateMgAwjJtUarKmgp09dee41GCYANUH4HAbFKVWhIFh0dLatXr5ZTp06ZR8u1BZoO15qOgS5HO5N76qmnTGv9f/75x9TR1lpvN998s/lHMoDMJ1TXGW2Jry1o7777btNKVm8EvP/++7Jjxw658847TV19AHA1ceJEiY+Pl/vuu89nSO9J/86i8uXL53O8XsNcpwOA5Fxr/Pn9999NyULtIHfQoEEcXAApvtZoIyh9YrpOnToyYMAAjihgA4T6CIj+gWDVpP7+++9Ny1ctlaOdwGmdfG1Fq4FboMvRum4jRoyQUqVKSeHChU3Ir61w9R+/1mNiADKXUF1njhw5Ymrnr1y50lni6+DBgzJu3DjzF1zt9Elb7AOAde3Ra4M+Yn7//fdzUACk62vNrl27zL+ltFTh119/bf4tBQApvdZoPx36hKE+BZSSm44AUg+hPgJitUSrX7++6UHds361dmyprWA1PAtkOV27dvUa16VLF7cSHAAyl1BdZ55++mlZsWKFTJs2zXSWq8vVzqEefPBB8zipdqSrHfECgNWfx19//SWtW7eW8uXLB3W98tcS/+TJk27TAUByrjW+Smq0atXKPOmsDR70ZwBI6bVmzZo1MmrUKHn++eelZs2aHFDAJgj1EZDrrrvOvGuHlb5Yw8+dO5fs5QS6DAAZU6iuM9o6v2DBglKrVi2vcfqXW/Xbb7+FYIsBZNaO5LSD3OLFi5sWs9pa1pNVS9+qrQ8AKe0gd/fu3abvsQMHDph+yLS1PgCE4lqzfv168/cZ7SRXW/i7vpT2daY/+/t3GoC0QUe5CIjVCuSPP/7wGhcXFyfbt283/8DVzm4To4Ha8uXLZfPmzXLLLbe4jdNhqly5cnwqQCYUquvMxYsX5fz58+ZdS/m40pZtKioqKqTbDsCejh49Kj/88IO5Efif//wnqHlbtGhhSl/o32uaN2/uNu6nn35yTgMAKbnWeAb633zzjXTr1o2DCiBk1xrtv+yBBx7we5NAnzy87bbbJFeuXBx1IB2hpT4Ccu2110q7du1MqPbJJ5+4jdPa+FoOQ//QiIyMdNa03rJli3l3pR21aJimnVbu37/fOVw7w9Qe1tUdd9zBpwJkQqG6zjRt2lQuXbokL7/8slfnT9YwHlcHoD7//HNzA1A71vZ3s8/fteahhx4y70OGDDHLsMyfP9+E+hr06z+SASAl1xor0Nd/O+mNxOTcFACQOST3WtOkSRPz7y9fL1WsWDHz83vvvZdq+wIgaREOh8MRwHSAqWWtF/vDhw9Lp06dpEqVKrJ27VpZsGCBlC1b1nRKqRd7pY9tDR8+XIYOHWp+dqWB/hNPPCGFChUyfynVP2y0XIb+hVX/gfzhhx9ytIFMKhTXmd9//92EaXqzsGHDhibk15b7GrJpPf169erJsmXLJEeOHGm4pwDSA60bu3HjRvPYub8ason9nUb76tB/5FarVs1csw4dOmRa0er1Rfv20OEAkJJrjT7FrLX0GzduLO3bt/c7LwCk9O81vmjZHS2TqjcCAKQvlN9BUK1otRPbF198UebMmSNz58414dpjjz1mhl1zzTUBLefxxx83fzl98803TWsTbVGrnWAOHjzY/OMYQOYViutM7dq1Tc38119/3bSYHTNmjGndX7FiRfMX2GeeeYZAH4CsXr3a/MNXb/4lt1M4bYig/Xfou7Zey5Mnj3Tp0kVeffVVWukDCMm1RgN9pQ0b9OULoT6AUPy9BoC90FIfAAAAAAAAAACboKY+AAAAAAAAAAA2QagPAAAAAAAAAIBNEOoDAAAAAAAAAGAThPoAAAAAAAAAANgEoT4AAAAAAAAAADZBqA8AAAAAAAAAgE0Q6gMAAAAAAAAAYBOE+gAAAAAAAAAA2AShPgAAAAAAAAAANkGoDwAAAAAAAACATRDqAwAAAAAAAABgE4T6AAAAAAAAAADYBKE+AAAAAAAAAAA2QagPAAAAAAAAAIBNEOoDAAAACKtFixZJRESEDBs2TFasWCGtWrWSvHnzSpEiReTRRx+Vc+fOmenmzJkjTZs2ldy5c0vRokXl2WeflcuXL/PpAAAAAC4I9QEAAACkilWrVkmbNm0kX7580rdvXylTpoyMHTtWHnzwQfn222/llltukdKlS5tx+fPnlzfeeENGjBjBpwMAAAC4iHA4HA7XAQAAAAAQ6pb62jpfff/999KtWzfzc1xcnNSvX182bNgghQoVkh9//FEaNGhgxp06dUoqVqxoWuofPHhQIiMj+VAAAAAAWuoDAAAASC0tW7Z0BvoqW7Zsctttt4m2M+rSpYsz0Fdanqdz585y9OhR2bdvHx8SAAAAcAXldwAAAACkijp16ngNK168uHmvXbu233H79+9Pha0DAAAA7IFQHwAAAECqiI6O9hpmldVJbJyW6QEAAACQgFAfAAAAAAAAAACbINQHAAAAAAAAAMAmCPUBAAAAAAAAALAJQn0AAAAAAAAAAGyCUB8AAAAAAAAAAJuIcDgcjrTeCAAAAAAAAAAAkDRa6gMAAAAAAAAAYBOE+gAAAAAAAAAA2AShPgAAAAAAAAAANkGoDwAAAAAAAACATRDqAwAAAAAAAABgE4T6AAAAAAAAAADYBKE+AAAAAAAAAAA2QagPAAAAAAAAAIBNEOoDAAAAAAAAAGAThPoAAAAAAAAAANgEoT4AAAAAAAAAADZBqA8AAAAAAAAAgE0Q6gMAAAAAAAAAYBOE+gAAAAAAAAAA2AShPgAAAAAAAAAANkGoDwAAAAAAAACATRDqAwAAAAAAAABgE4T6AAAAAAAAAADYBKE+AAAAAAAAAAA2QagPAAAAAAAAAIBNEOoDAAAAAAAAAGAThPoAAAAAAAAAANgEoT4AAAAAAAAAADZBqA8AAAAAAAAAgE0Q6gMAAATp008/lYiICGnZsqXXOB2m43QaIDMaNmyY+Q707t076HmPHz8ujz/+uJQrV06yZcvm93uWUSxatMjso+5vemaX7cys9LPR1+7du9N6UwAAQCqJTK0VAQAAhJMGf4sXL3YbliVLFsmXL59UqVJFbr75Znnsscckd+7cfBBAOqXfU/0e58yZU2rVqmXea9asmdabhTAZPXq0uZGjN4C4YeBNQ3q9QZw/f3556qmnOA8BAIAToT4AAMhQSpcuLWXKlDE/x8XFyc6dOyU2Nta8PvnkE9PitESJEmFbv677uuuuMzcTAARu48aNzkB/8+bNmSLkzZUrl7lelCxZUjLjdmqov2fPHnNTNjN83skJ9YcPHy5ly5ZNNNTXz0bp0y0AACBzINQHAAAZyv3332/Kf7iaNm2a9OrVS7Zt2yaPPPKI/PDDD2Fb/2effRa2ZQMZmQb5qkaNGpkm4G3YsKFs2bJF0ju7bGdmxWcDAEDmQ019AACQ4d16663ywgsvmJ9nzpwp//77b1pvEgAP586dc7YKBwAAAOAfoT4AAMgU2rRpY97j4+Nlx44dzuFaomfs2LFyww03SIECBSRHjhxSoUIFeeihh2T79u1BryepjnK1fvQrr7wijRo1cq6vfPny0q1bN/n888+d02n9f13OXXfdlej6mjRpYqZ75513JBQdLSb18nTmzBkZMWKE1K9fX6Kjo00gq30YPP300/L333/7XZ/D4ZDJkydL27ZtpVChQpI9e3YpVaqU3HnnnbJmzZokOyjW+ceMGSN16tQx/SQUK1ZM7rnnHtm7d69z+vnz50v79u3N8nWaZs2aefW7EAhd1+zZs6Vfv35mfUWKFJGoqChTiuT222+X5cuXJ3lctYzGihUr5D//+Y8ULVrU9PegpUdSchyTOtd0nf4+N9d59SaXlvbQ1vHWfj344INy8OBBv/v1zz//mOOh5a70HNZ5tYPb5Nwwsz5Xq2Nd/YxczzktmaV0vP7u+SROMB2GbtiwwTzNo99x3W6tVa7ffS3NdfnyZZ/zrFu3zpxb1vHJmzevXHvttdKpUycZNWqUOT/C0QHtvn375N1335UOHTqY9WlZIj036tWrJ6+++qqcPn3aax797ug26jJnzJjhc53du3c34/Vcu3jxYoq3MznnkvWZa+kd1apVK7fP3Fcny8uWLZMePXqY64Quu2DBgub6oU9iJXW90M/2vffec36/dLhei5UeAz3OMTEx5nzQa5FeT+rWrWvOaX/XIz3HdLyWvtHvq54Xuvy3335bzp8/n+jNK92WFi1amGuT7ouWbWvXrp2MGzdOLly44DyuelyUHifPa7H1vQjkvJ8zZ4507drVXHus/dP+KxYsWBDQ563nkm6PHh+9luqfX19//bXffQQAAKnAAQAAkAG0aNFCkzXH0KFDfY5fvXq1Ga8v/VmdPHnS0axZM+fwChUqOOrVq+fIlSuX+T1nzpyOGTNmeC1r4sSJZryu09926DSefv31V0fx4sWd66tYsaJZ3zXXXOMcZlm3bp35PUeOHI5///3X5z5t2rTJTBMVFeU4cuSI2/p79eoVxNFzOJo2ber3VbZsWa/tU/v373dUq1bNOa5q1aqOOnXqOLJly2Z+L1SokGPlypVe64qLi3PcdtttzvlKlSrlqF+/viNfvnzm96xZszo+/PDDRI/7nXfe6TyGNWvWdK6zXLly5lh88MEHjoiICEfRokUddevWdeTJk8eMz549u2PZsmVBHZtTp06ZeXV5RYoUcdSqVctx/fXXOwoUKGCGZ8mSxfHRRx/5nNfax5EjR5r9yps3r9nXa6+91jF69OgUHcfEzjW1a9cun5+b67wvv/yyo3Tp0o7IyEhzHCtXrmz2x/o+HD9+3OdydR5r33W+6tWrm+Oj8zzxxBNBnYM//vijOc8qVapk5ouOjnY7/9asWWOm0+Ul9h13Pd66jZ7GjBljPgMdnzt3bvM5Wvuhry5duphz09VPP/1kzhkdr+dQjRo1zGej54E1n+c8wVi4cKFZhn7HPA0YMMB5HSpfvryjQYMG5vha+6DbcuzYMa/59Lyyzpu9e/e6jfv444/NOD0Pt23bFpLtTM65ZH3meu2y9sX1M3/11Vfd1vHss886j7deJ2rXru0oVqyYc9jDDz/s93rRvHlzR7du3Zzbr8dRv7t67C5duuRo3bq1czl6/dDx+v3Ua68Oe/75572WPX36dPO5WNdo/f7qPNb+NmrUyHHixAmv+Xbs2OGoUqWKc33W9pQoUcJ8f1zP3X79+pnjYl3jPa/L1vciqfP+qaeeco7XP2t0fYULF3YOGzJkSKKf9/Dhw83Pei3VP6+s67S+3n//fT9nDAAACDdCfQAAkClC/REjRjhDSCsk7927txmmAd3SpUud02oY07NnT2eQ5xmUJCfUP3jwoAlFdFyrVq28AjVdxwsvvOA2rHHjxmb69957z+c+9e/f34zv0aOH1/qDDfX92bdvnwmcdJka1rpq2bKlGa5h7IYNG9z21QrKSpYs6RUMDxs2zIzTmycajlnOnz/vePrpp53BvmeQbR13Dbs10FuxYoVbWKaBnI7v2rWrCdw0wIyPjzfjT58+7WjXrp0Zf8MNNwR1DC5cuGBuMmj47koDwW+++cbshwa/ngGqssIv3R8NJnUfLWfPnk3RcQxFqK/HUo/LgQMHnON+++03542mF1980WtePX46ToN81/N48+bN5iaLdTMi2HMwse9VSkP9WbNmmdBUz4uxY8eaz871Zpt1Q8Fz2Roe6/BBgwY5Py/Lnj17zM2ay5cvO5IrsbB83rx5jkWLFrltq/rrr7/MOa7zPfrooz6X27lzZ2egbc2vn491w/Lzzz8P2Xam5Fyybhjq8v353//+Z6bRIFq/b67mzp3rXL7n98A6n/S7V7BgQXM8Xb/T+rl9//33zhuLeiPVld6s0ZsPs2fPdhu+du1aE7Lr+fTKK6+4nRf6fdDQ3Nf5r9PpDTsdpzeU9Ni4OnTokDmfDh8+HNBxD+S8//TTT53HQM9761zVc+Ltt9923kj49ttv3eaz1qufqX5nvvzyS7fjojdRrD8f9eY4AABIfYT6AAAgw4f6U6dONS1zrcBXafhhtaqcMmWK1zwaXGjrWB2vLSZTGupbrW6vu+46r3DQH2s9GgB50lDKam05f/585/Du3bubAEjXl1IahGurZF2HhoSu4eKSJUucQdKqVau85tUbJ9riWse/9dZbbsu0hr/xxhs+12s9PaHr9HU8/H1m2jrfGu8r7Ny4caNzvK8W6MmlLXl1mRrIebLW16FDB5/zJvc4hirU13PI15Mgb775phmvn7+/7dVw09Py5cud49NLqK83dqwnIcaNG+dzPg32NeDUVsiuN16sluShPF9cBRraejpz5owJXDVU9Qz91T///OO8GafH69y5c+Y6ktwbfoGE+sGeS4GE+rqf1nVuzpw5PqeZNm2a89rq73rx9ddf+5z39ddfN+O1NXugbrrpJjPPf//7X5/j9aaL/nmjQbreFLVoq3brOGmAH4iUhvr69EBiN3/uvvtuM16fCPC1XusJDE/6Z5j1tMoPP/wQ0L4AAIDQoqY+AADIUCZMmGBqZOtL6/5q/fPbbrvN1CyvVKmSqZ9v1RjW+vpay1g70vUUGRlpakOrWbNmpXi7pk6dat61RrrWxg6E1r7WGsbr16+XX375xW3c999/L0eOHDG1wa26y0rrHGtd5bfeeitF26vHpmfPnrJ27VpTR16XmzVrVud465jocW7YsKHX/NpfwAMPPOA2rVq6dKmcPHnS1DN/5JFHfK77mWeeMe/z5s3zWfNbl6217D1prXGL9ongqXr16s5j79qvQqBWr14tzz33nKlFrfWlrfNsypQpZry/2ttK67j7ktzjGCrah4Guw1PTpk3Nu2e/Ej/++KN513rgtWvX9tnHQ4MGDSQ92bx5s3npOderVy+f0+i5U7ZsWTlx4oT89ttvzuF6fVCu/V2kJv2ufPzxx3LfffeZ/iG0Xwg9V7T+uvbLoHX1t23b5jVf4cKF5YsvvjDTaB8e2meHXkcqV65s+qIIh2DPpUAsXLjQXOf0s9H996VLly6SLVs22bp1qxw4cMBrvNbQ93WNd/18586dm2gfEq6fh06r+vbt63Ma7WdCvwNax9+1Dw/rzwDtY+Caa66RcNuyZYvzOqd/7vgycOBA875x40b566+/fE7z6KOPeg3T66j+uZDczxUAAKRcZAiWAQAAkG5oR6lWZ6kaaGmgox0gahCrnc9qJ39KAyBVrVo1M50vNWvWNO+7du0y4bJ2MJgcp06dcnYIqaFnoDQ40Q4633//fRk/frxbWKq/qz59+vjsCDWlNAT6v//7P9PRpb5bx81iHb8aNWr4XYZ1/DRc8pxPO2DMkydPovNpZ5N6g0KDSFfaaagvrkFZxYoVfU6jN3k0vPLVyag/ly5dMqF8UsHu0aNH/Y7T88yX5B7HUPE8thbtUFN5HidrG/ztj3XzxPMmVFrSjm6Vfk9uvPHGJD8/7aDWMmjQIBPCaoeo2imuhul6s1BvaugNtXBasmSJuXl1+PDhZJ13erNv8ODBJtTXIFqvX3pzzt/3LrXPpWA+O73Zojcz/LGugfrZlShRwmu79CatL/rngt7s1Zs+euNAb9bpjRP9M0NvRuiNIFcafmtYr+u7++67/W7Pn3/+6dwe106ag/0zICWsa4v+OeLvmqnfY71Zq/uk323rJofrzSHtkDjUnysAAEg5Qn0AAJChDB06VIYNGxZQ0K6KFSvmd5rixYu7TV+oUKFkbZO27rRoy/tgaGtQDfUnT55sQsVcuXKZGwTail2Dqt69e0uo6dMM7777rgn/Zs6caYL9lBw/a9pg5/Oc1+J5g8HienMjqWn0SYRA6VMPGuhrOPbaa6+ZFsMafulnocvTp0O0NX1cXJzfZfjbnuQex1Dxt13Wja6Eyh5XWdtgBXq+JDYuLRw7dsy8nzt3TpYvX57k9GfPnnX+rDfN9Dur371Vq1bJhx9+aF5Kn6wYOXKkCYJDTa8Z+oTRP//8I23atJH//ve/UqtWLdMSXlulKz0H9QZmYued3sTQUN/aXqt1dTgEey4F89kdP3486M8uqe1S+h3Wp4defvll+eabb8zND6slft68ec0NHR2n07luj+5LsNtj/TkQ7J8ByRXId1X/DNHg/tChQ0Fda10/12CupQAAIHQovwMAADIlDWxUYiUX/v77b6/pk0OfFrBoOBUMbfWsLUY1ELLKvGiIrEFK586d3QLwUPjpp59Mq2Rtvamten2VWAn2+Lkeu9Q87qHy6aefOsN9LclUtWpVE3ZZNwgSa6GflOQeR2Wt319YqiWnQs3aBg0B/UlsXEokd3+tlul6Ll/pUyzRl+eNMg3XV6xYIf/++68pP6St9/VJEy3HpDd4tERVqOl6NNDXUi56Y03DeX0SxQr0dTt1exKj15p7773XGcAuW7ZM/ve//4mdWJ+dtqgP5LNLzg0WDb21JJE+EaEt8fWmppYr0kBeb+a4ng/W9mgwH8j2uN5gtv4cCPbPgHB+V/UpJC1v5Do9AACwB0J9AACQKVWpUsW8a9kFfy0NNeBRWmYjuaV3rLBEQ0Cl4WCwrNrNn3zyidnWiRMnOlsRh5Lu7x133GFKMYwePVo6deqU5PGzjpG/5SkNwT3n07I6/so2WPNp6QvruKUlLb+ktCyHL8n5TFN6HF1b0foL7awSIOH63vizadMmCYfk7q9Vvki3KyWBar58+eSmm24yrfN1XVqGR8tyWaWwwnHOacktzxIwSuvjJ3XTRq8PWmpKS8l89dVXZtiAAQOcZWDSg6RKh1mf3cqVK8PeIly3RW+iPvzww6bPkunTp5vh3377rTP41vE6nZ5HiX0HfNEnLYK9XqSktJr1XdUnVPz1IfLHH3+Y672v6wsAAEjfCPUBAECm1KFDB9N6VUOvadOm+WzBqCVoVGLhdqC0ta965513TK34YGhdba1rrOUedJu05EapUqXMPoSKBqXa8l+fCHjyySelX79+iU5vHRNt/astlj1p6GWFna7HT+tia4tVPQZWp8We3n77bfPetm3bFN1MCRWr9IavTjg12EtJB7bJPY5Ka4Gr2NhYn8v2d3xTQkNtpR2AarDsSbclXPX0rf3VgNcXf63QteSMzqtlajSQDwVtMd+4cWO/50U4zzn15ptvJjq/lgjS65reiNBAXzvd1puD+r3r0aOHCXrTA2s//W2PXgO0Vbw+yaIdBqem5s2bO3+2PgctVdO6dWvzs5blSc6fAXpz1rpJkNLjk5jrrrvO2beIPnHgi9WhuvbpoU+FAAAA+yDUBwAAmZJ2imiVptAA27U+stYWvu+++0zrRi23oJ3GptTAgQNNmQftjFDDc8+Wk1onX/sD8EVb6lrbqqU/lHbcqiVyPGlgp63bn3nmmYC3TQOjrl27mm3o0qWL3wDIlYbzVqkL7czXtdWqlrHQFv/auaXW49d6866tra3jqaUpfvjhB+c4bfWs+6eBse7b888/L+mBdoqqnnvuOdm/f79z+O+//26Ol6/PIVDJPY5KPzOlHRlrPXCLBrfaQeqiRYskHEGn1dGndhS6c+dO5zg9t7VUiVUiJtT0e6Mtl7XzVNdQW1saa78TX3zxhc/5dB49p/VdQ309NnpMXWmr9++++858ryx6g0tvqGlJKj03Xf3222/OY+7agXWozzm9geF6c+bChQtm+zWo93fDS59I6N+/v/lZg3DraRe9oagtzfUc0zJS6YEVOi9YsMDvU06vvvqq+fmJJ54w++AZcGude+3zQp9CCJaeF2+88YazI3OLlt6xSufojRHrhpLS6fWarOXJ9GkIz9JZeq7oOWM99WTR7692TKtllfRmhdUJsOv3Xc9rHW/RDm71vNVxyXkCZsiQIc6bPB999JGzdJU+9aA3iK3Ov/392QMAANIxBwAAQAbQokULTSscQ4cODXiekydPOm644QYzn74qVqzoqF+/viNXrlzm95w5czpmzJjhNd/EiRPNeF2nv+3QaTz98ssvjmLFijnXV7lyZbO+okWLOof588cffzinyZIli2P37t2JHodevXoFfBwWLlzoXHadOnUcTZs29ftytX//fke1atXMfBEREeZnnT9btmxmWMGCBR0rV670Wl9cXJzj1ltvda6zTJkyjgYNGjjy5cvn3L9x48YFddzVrl27kjyOZcuWNeN1nwO1fv16R+7cuc18UVFRjlq1ajmuu+4683vp0qUdr732mt/tsrZHt82f5B5H5XocS5Ysac6nvHnzOnLkyOH46KOP/B6PxM7TpI7ljh07zLqsz0qPR40aNcy2V6hQwfH4448HfQ4G8vmqp59+2rldRYoUMfurx0e3w5rf3/EeP368+fx0vB5b3eZGjRo5KlWq5MiaNavzGFqOHTvmXF727NnN59KwYUNHuXLlnMN1/jNnzjiSy/ru6Xnp6Z577nGup0SJEmZfre/IK6+84vNcPnfunNkvHd6nTx+vZW7YsMGcGzr+22+/Dcl2puRcmjp1qnOcnjvNmjUzy3v99dfdpnvppZfM+aXT6fbXrl3bfBbly5d3Dve8PgVyPj355JPO9RcvXtwcYz2f8+TJY4ZFRkY6vv76a6/5Zs2a5Xa9qlKliqNx48aOqlWrOr+3+tJrned3x7p26EvPJb326Xln7Yfnudu5c2fnOVi3bl2zP/pau3atc5rEznvXfdQ/a/S46XfHGvb8888H9Xlb9Psd7J+5AAAgdGipDwAAMi1tBaotRD/44APT+lhbQ2pJkSJFipgWmNqSUltih0r9+vVNa0ttFaklQbSkg9ZL1xIL2hGkv5bGVn1kbdWt2rVrZ540CAft9FOfWvD3clWiRAlTMua1114z+6OljLRGc/ny5U1LYK3drXXHPUVGRpo61V9++aUpZaFPRmird23F37NnT7NMqx+B9EDremtZGe08M2fOnLJ161ZTykVbDuvxSmlnxck9jkpbbGsZkMqVK5sWvlqLXVsBr1q1yryHg/YxoS3VH3nkEbPv2kJfW7U/9thjpvSOlooKFy0Xop2aan1yXef27dtNS3n9Hnt2cOtJW+Hr90/LS2nLaz1W+n3X1tTaMl5b8bu2GNfrg56j2sJaj6+WqNL91lb+2r+CPh2wZMkSZ4mUUNO+M3SbtIyKfrb6dE/dunXNEwX+nmLRFvp6TdH66Fb5MFdaZsV6EufBBx/0aqGe2m699VbT8bee37qPWoZKn9TRc8rVCy+8YL5rel3W0mP6HdTPUp8K0TJk+llMnjw56PXrOfzKK69ImzZtzJMPukxdtj5VpU9rrVmzxpQu8tSxY0ezjfrUxPXXX2+u5bp92sJfyzLpNV7n1Wud53dHh+t5rH0d6FMGeg7q0z56XdcW9Xo9cPXZZ5+Zp8l0v/Wz1eOjr0D7h9D+UbTjZX3SRVvo6/q19b9ez+bNm2f2HwAA2E+EJvtpvREAAABImoZ72kHn1KlTTRgGwN70JoIGylpmRW9QAAAAAIGgpT4AAIANzJ8/3wT62oLUqqUOwN60pbYK59MNAAAAyHgI9QEAANI5LemgZR6schHh6ogUQOrRUijTpk0zP2tZHQAAACBQlN8BAABIp0aMGGFqIWvtZq03XbJkSVPzOV++fGm9aQBczJ49W1599dWAj4nemNu2bZvs37/f1F3Xvghq167NMQUAAEBA3HvuAQAAQLqhYf7SpUtNiK8dM7799tsE+kA6pJ3oenYknZhy5cqZ0jvaQfewYcMI9AEAABAUWuoDAAAAAAAAAGAT1NQPojVNRESEz9fDDz8c3k8JAAAAAAAAAADK7wRHH31/6qmnvIbXr1+fkwkAAAAAAAAAEHaU3wmipb7avXt3OD8PAAAAAAAAAAD8ovwOAAAAAAAAAAA2EZnWG2AnFy5ckEmTJsn+/fulQIEC0qRJE7n++utTvNwqVarIsWPHpEKFCiHZTgAAAAAAAABA+rZz506TM2/ZsiWo+Qj1g3Dw4EHp3bu327AOHTrI559/LoULF05y/piYGJ/Dd+zYITly5AhmUwAAAAAAAAAANnb27NlkzUeoH6D7779fWrRoIdWrV5eoqCjZvHmzDB8+XGbPni1du3aV5cuXS0RERLI+BA30a9SoIbGxscmaHwAAAAAAAABgL/4agSeFjnJTID4+3gT9y5Ytk5kzZ0qnTp1S9OER6gMAAAAAAABA5hCTzFyYjnJTIEuWLHLfffeZn7WlPgAAAAAAAAAA4USon0JWLf3k1j8CAAAAAAAAACBQhPoptGrVKvNerly5lC4KAAAAAAAAAIBEEeoHQDvFPX78uNdwraU/atQo03HuLbfcEsiiAAAAAAAAAABItsjkz5p5TJkyRd544w1p06aNaZGvIf7GjRtl7ty5pq7+uHHjpEyZMmm9mQAAAAAAAACADI5QPwCtWrWSP/74Q9asWSOLFy+W8+fPS9GiRaV79+7Sv39/adiwYfg/KQAAAAAAAABApkeoH4AWLVqYFwAAAAAAAAAAaYlQHwAAAACQ6ZyPuyzr952Q0xfiJE9UNqlVKp/kyJY1rTcLAAAgSYT6AAAASBYCMYQT5xfC5eCJ8zJ+2U6Z8us+OXEuzjk8X85sckf9UtKnWQUpGp2DDwAAAKRbhPoAkIYILMD5BTsiEAPnF+xq04ET0mvCajly+qLXOA34P166S75bu18m3d9QqpfIlybbCAAAkJQIh8PhSHIqhFVMTIx5j42N5UinMwSuCBcCMYQT5xfSKhCzFM6TnUAMnF9Il38+dn5/aaLXL9fr2KwnmtFiHwAApMtcmFA/HSDUT38IxBBOBGLg/IJdEYiB8wt29uqszaYlfqAeal5BBnesGtZtAgAAmVtMMkN9yu8AHngkF+EOxJJq4ap0vE5HCzFwfiE90RrUgbRwVTrd+GW7whKI6YOm+qypw/rZvOvvCQ+gWs+hWsN8TXtlUr/jzU/O4X6m9bMe5zY653Wdz2Vaj+Umuc3iY1l+tjmxZYnHNgS1zS7Teq3Dx3q8j5vHsq4sp3LRvPLz5oPp4vxCxn0CV2voB2PKL3vl6baV6TwXAACkO4T6gAsCV2SWQCyc3IMe78DJM7jyN61b6OS6XD+Bm7+wLemQzGWbfAZUQWyzj7AtmG22pvUVuHmux30bEqafvmZfUOfXwKnrpFPN4m7LubIXboGb7/DQ1+ftO7hzPTecyzEj4p3TRcSbqV0+/HiXY5owrTOsjNdxViprHdN4kXiHRFyZ/uq2J8yXMJHr8h3O8c5tdFlPhBmXsB3WuIT9SZg4wmX79X9mvZ7rcm6wznd1OREu25ywHOvc8Ni+K0c5YRpre/XHq8vS4dZ4s1yX8c5zxbnOq8fMc1qv7bamcdtfh5w5d1F6ZhWJ0GEuy7F+jvD4+dJykTdXZ7m6TLMtCes179ZnKCKnHTnkgBSWA/FFZL8UlBOO3AlL8vgeIePKkU3PlcARuCIY6/edcOsUNxDHz8XJhv0npEG5ghxsAACQrhDqZ0L+WrcF3VIskfEBtRTzsZ4riw2opZjPef21SEskcHNd7hcr9wQViL34w0a5vV7pgLb56vYl3brNOg7ex9h36zZ/gZvnety3wfPYuYZtV8ImK8ByWMGP9btr2HZ1WmvBJrxyBmJXwrarG+kMcZyhnBXwXfndCslMuOYWil0Jp1zCtqv5pkcQ5iO4u7ooK3ByX69rCHflSF6Z9ur+X0kUneHa1W1J2Aa34MwZhiXMG+9wyL5jZ6W9ySy8wy/Xn61vzz/Ll8mr67JLQszhHvS5ho8u356rn8X/t3cncHaN9//Av5NMJGQViS1BYkmVUEuEICLW2kpVbV342dq/qi78WlX70oX+1Q/9UY1IW1WlqP5rrV2IrSixK4KEWLMhkWX+r+dM7uTOzJ3JnclkZs7M+/3q7Zl7tvvcc2+Omc95zvcpLK8T0BW+NYXXrBXiFd5H4bMoWqfQrpogL61TEfXWLf2+iretVuq9l5q/ZF7xeynxWot3XH+dho9v3TbWXWfJ65fX3lr7rFiyTpcGt11ae5ccg8beU+F1N46qOHWFEu2taODYTomomNLQsS3d3uYd2+qfuyxuBznWbRm3X/IPpWFdY0nIX7VKTK0aENOqBsTUqlUWT9PzVWJ6rBwL/Crbocydv/giU5kErjTFnHlNC/QLZs9t3nYAAMuTUL+dmPbWlDj/rB/USsxLh22Ll9XrSbdkm+LgLoVctddtKGwr3r7x0KgwLbVe3bAt6gRujYVGxfut35b6wVnz29tw2HZERBy5QmPvqU57X06PpQdhtY7DUsK26p+XdmxLB6PlB3LCtlwFYvOi9ZQTuAG0gl4Vc2NYxdQYFlNLLl9YVZEF+8VBf+3pgJgdK/msOjiBK+Xq1b15VyV791jWq5kAAC1PqN9OrBnvxn8vGt/4SsUhm8ANgOVsUVXt+wQKlwjrXm6sPb/2PQ6l1il9ybP0etn+qooLtTSwTp391n5ed5tmtqOoPaX2tbR2LP24Nb5OyfZm1/Xrv7/al8mbd9zqt6X0+jXrZMel/npdu3RZfCdN0SXpinRJPaIqW1CRze0bc2KNeD97rB7vx2rxQVTGwga/n10rqmLN+DDWrPgwRsRLJdeZEyvFu10GxvSKgdn0vS7V03crBsZ7XQfGhxWrRFWX6lsDKiqq25F1Qsg6IlQU3QFUvaBmed31s9uWlqxbvH29fS3eLhrYV7Z2zfzC0andrijZhurnS9pb1IYSbSq8Tsk2F++rxLGo3kdFo69T/P5qH7sl685bsCguueeVWBYCV8q16eC+0XfFbk0qwdNvxW6xyaC+DjIA0O4I9aEDBG61A5qmhkKNrVNmKFTUjup1Gw+O6rZ36YFb6f2WfI16IWT57Wj8uC15f006bksJ3JbluC0tcCssT/9f/DylKcX7KjwvXrdu4LZku8LnUR3KLNnP4nYV1i/aLltelGAtWX/JetWZbfXz6jbUfd2ifdYkXzWxUXU7ar129XuoWT8VMFr8Y+191fm5aJqtWxNqLdlXVbavQpiV/r86sEz7rV69S8ntqoO4Lkv2W9OuwrrV+8r2vfh1CsFZ4RhW1Lx2UdsXt/e92fPi9uemNy2cjorYb4tBsWa/lWr2mV6joktxuLnkKnL90K/MsHIpwV7xvkuGlXVep/i1SrWpflhZf191X6fU+6sbVnapqLvfJa9VKuSt3d7SIW9Zba51jJvW5lLr1nx9mtLmxQHsqJ/fFbPmLoimBGIPn7xz8waZXLQwYs70iBlvRsxMj7cWPwo/vxkxd2aju+gVn0SvRVNi3VRrqtT1gYquEX3WjOg7OKLvWouni3/ut/h5995NbztlSeFqcajfpSIbGqNsAleaIp2HDhwxOH73wGtlb3PgVmsZJBcAaJeE+u3E21X948IFey81cKt+XlNdu9HAbcl2UV7gtvgv+aUFbjXLCvttJHAr2bZGArfioHBpgVtx8rC0wK0QklUrHbjN+GRBPP7GjAZD1uw4lAhoRw8bGAN7d68ud9RI4FYdjBXaURGRei4u/kxqtlt87Jbsp3rdqixgazxwWxIGLT1wqxccLSVwK953SwZuS4KmpQdupd5fQ4FbcYBVTuBWb99NbXMDgVvd/c5bsDD2umhizG5CINa3R2XcfeKOseIKXZcauNU+jkUr0inMnb8w7vjZXU3ugXj2lzcXWFCWyq5d4qCt1mq9QKzL4sA9PWLr0uvMnVUi7C/6eda0iKqGe/tny7J134yISaXX6dF3ceBfHPoXBf+9VqtuK8ss9aL+6JPyz2ECV5rqqNHrxo1PTi1rDK2BvbrHkdsPdZABgHZJqN9OrLHWevH9c5ZSfoflHoht3YxA7JxvNLMHIp3SwU0MxA4auXas0qv7cm0THYMeiHTKQKxHn4geG0WstlHp5QsXRMx5Z3Fv/zq9/NM0zf9sduOvke4GSI/pk0sv71K5uLd/3eB/cejfZ1BE917L/l47gZVXWiG6dqloP98vOpzV+vSI3x8xMg4b/2ij37P0/UrrpfUBANojoT4sJhCjUwZidCi+XyxvuQvEulYuCdkbkgL7hkL/9Jj9dkTVooa3X7QgYsYb1Y+GrLhyUYmfEsF/z1WzO/g6u8quFfn6fpFLG6/ZN24+fnRcMfG1uPaxN2NGUYee1GEn3QGSfv/y/QIA2rOKqqpUUIS2NGrUqGw6aVIDt33TaqbPmht7XfRA2YHrP47f3i/8NNmz02aWHVhstGYfRxjfL9rlfy87TSC2cH51GZ9SNf0Lvf3nf7xsr9GlW0TfQQ2X+UnTFVaKjibdHfmFM++oeT5stV5xxw/GdK7vF21+p+4zU2fG7Lnzs0GX06C47sAFAPKQCwv12wGhfvsicKU1CCzw/aIjEIgtHhF97oyi3v6FwL+4t/87NUPDN9tKqzTe23+lAbnr7d9QqF/g+wUAQEc1d/7CePqtmXH4l3fLSlA+88RjTdpeqN8OCPXbH4ErrUVgge8XdAILPouYNbUo9K8T/KcLAgs+XbbX6Np9cW//FPSvXbq3f7ceuQr1AWBpYdicefOjV/duselgd9rQsnzHWF7emZnuSn01rn38rez34bf/eEI2f97UF5q0HzX1oYR0S/fJe34+frjrMLfkslylW7y3GtLfUcb3CzqyyhUi+g+tfjTU2//Tj6rr8jfU23/O9MZfY+G8iA9frX40pOfAoqC/RPDfc0BERcWyvVdyQ1iB7xgdIQwr6JtKtI0YnI0xpUQbvmPkuTpIuYT60AiBKwCw3KUgfaX+1Y81NysZuvauXBSb9p4T3T8uru9ffBHgrYgFcxt/nY/fq35Me7L08soedYL+usH/4IjK7i385mltAjF8x+iIYVgK+H/3wGtx45NTs7HJ0qDY4DtGe/sdrKUC/USoDwAAuQpdt67fCzH19v/4/dq9++v29k+BfmPSRYEPXql+NKTXanXK+tSp758uTOjt324JxPAdo6OHYWl5Wu/m40frsY/vGO1K+v2+pQL9RKgPAAB5D11TkN5rYPVj0Baldz7/04iZUxsP/hcu5Q+NVAYoPab+q/Tybis13tu/z6DqckS0OoEYvmN0ljAsrXfFxNeykrosUVVVlfUBqCr8vLhPQPopTZest2Re3XXTD9XPosF9Lf5fvX3XrFvV+OsUlmVLS+yryW2u14bSbb7q4SlN+o6detPkOGCLwbX222CbF7epZHvrvv+Sx632vtIPdd9L3c+k9HGp/fnV+l5k0zRzUfU022BRYc+L56VlRc9jUc2Oq6oWRUXNaxW+B4siFlUtnl/9BSpMCw2o3m/RvOz9LN5vzetWr1uRLatuR6bmefE+i79gtfeVnte0pe66RW1Or1M9P71O4aAXv2Z1W2q9Zp33lVQUtk9bVy2KaR99El/sElkbqh/VP/815sRH0SuaykC57YCBcgEASKHr3hc/UNYflAN6rdDyvRAXLaruzV8T9peYfvLBMr5IRUTv1bOA/7Nea8aVkxfE1KoBMa1qQFT2XysuO3bfiBVX1tt/OTj35ueyi0LlOmaHdQVi7TBwWxLyNB641QQ/ZQZudUOgckKyJetUTy+//z9x/RNTy36/+262Znxz1JB6IVhT2ly8bq33XrLNi49cue+/jMCtVpuXErjVbXPpY1wqrFxa4FY9vxB2NRa4FQKwFCRVlRG4Zfst2mdjgVvh9Zfsq5HArShQK3y+DQZuVVWxqKoqnp06IxZmbS0EYuk/FdXrJ3VDsi4VFbH+wJ6Ll9cP3IrDtuq2LgnsitevqAnz6q9bL9TLVB+bmlBwcbtqBYNp+eJ52bT4A681r7gN1ce4sDwLFYuOXUXxdhVRYt36x6h6FJ3a85YcyyXrlzq+S+YXv5f626Y+B4V1a69T/+clx6q4vaXXaXp7q78vhWUNvafi91O7HfXfXyzrcasopx3lHrdqSzu2pdrbZXE7aDujrvg4nli0fpMHyhXqtwNCfQAAchG6fvZxnd7+dXv9T41YtKRkUHMsqFwpPl1xzfh0pTXi0xXXiE9WWrN6uvjxaY9VY1GXyjrBY+OBW90eb40Fbg32pCsZsC7+uVaYVjpwK/Ruqw5YlqxbKnCr1VOsuCdbicCtJniqmRf1ArdFixbFfS++GwsXVfeiS+oHJ7VDgG5dIkass3JNIFM4bqUCt7q927LAsFQPtzq922raXDjYDQVuRT0Fi8O/koFb1lOw9Lr1A7eisK3my9FY4LYkkGkscKu9XuOBW+OhUPG2pcOe5oVTpQK3xsOp0m2p1vg65ba3dkBbzntq7LjVDxmbeNwqWqIdtQO32vPKO27CNoCOb1QzQ33ldwAAoI2lQXFTDf2muPaxN+OHuw6LHt26RqtZoWfEwGHVj4Z6+6fyPI319v/0o0ZfonLBJ9F79ivZo5SFVRXxfvSN+VFZv9dbI4Fb42FaY73bOkbgdkq3Zmw0bTk0pCNa8sUCgOVuUVXxpefi33iq/2NUalnt+weqNb5O7fnV69d53kg76l6ybOg1au+38XYs2V/ddlXUaUvt99dYO5Z+3Opevi3juFU11N7Sx/a9qnua9T0Q6gMAQBt7+q2ZtQbFLceMT+fHM1NnxlZD+ke70aVLRJ81qh9rbVV6nXmzsx79c9+fEmf+6fYYVPF+rFnxQfU0PojVKz6MbhULG3yJrhVVsVrMWH7vAWC5BW6Nh1PFgVvteUsP3OqGXNk2DbSjdOi2tNdoWjvq7b9O4NbQpdOmH7f66yy1vVUNtbe8Y9vYcavfltLvr3AVsObnirqXnrNbRmqtGxVdqrfPBqSvqJ5bUf/ydt3t0vrZ2hXFr714nepbU2rNrx7vfvF+F/9cPbPosXib4nUL+yper9DWNL+4vdXz0oyswHjt16hZt/r9Fs9fMk2TLkX7KbRhyetU77vQxi6L25JmFb+P6iP50acL4rEpHzUc9pb4zqTHmGEDY0DvHktet9C+wiM7RkXTLl1q3m52/IrbWFH0PO2/S/W0omjdimxeYfeF91P9HqqnUW9e4T3XbFd4Xli2eIOKEvsqPK/5CtbdVwOvU6pdhe9KrTYUr1v0WvVep/g1Coc5luwrlduq+zpL2tDIvgqvWeL9NNTmJcehxL7qvE5xG+YtWBR7XvRAzJ67IOp6u2pyNIdQHwAA2ticec0rWTN77rKVumkT3XtHrLph9Fh1w3hhUK/48xu1A/ousShWjY+WBP010/djUMUH2bRvxSfLHLbFUoOY0iHS0nvAlRkKNdKO2q/ZWDtKh2RNakfJ3nYNt6Ppx63xdUq2t2R4smR58X6betxKBW6l2lEIo6or7ywJsGpCnsJf8XWCq+LAbcl2S/64r72fJYFb7dBs8XutSWhqB26F9VLYVgi+io9frVCvZt+l16392oXlRUHd4oCi9r7qhmsV8fG8BfHyux83+BmUDMkiYvjgftF3xW51Arcu9dpcUet4VIde1evWDe7qti9qhWRFqc3i+Us+w+LArfp9F7Yr7K7QrtqBWyGIKxW2RSMhWXEIVtOKOoFbQ2Fb7fUbCMHqhEqF12oouGs0BCvxOnXbUPR1rbPvumFi9UoNhW2121s9b/7CRfG1cY/EnHn1w7CG9O5eGTd+Z9voXtl1qe+/bptLrVvz9amzbPG7qdfmBtct+m7Qvu6Y3PpndzWpg0W/FbvF2d/YuXXvmCTXDt5qrSaV2lwaoT4AALSxXt2bUxsloneP5m3XXoz75oi45rE3491ZcxsMwVKf/TcrIt6q6X0X0W3RvOqa5HV6ty0J9arDuprAL+2rjN5tpQOa0r3balpbRu+2kiFRI73oituwtBAslhbsLQ7Ejrv6ifj4s4bvgKirV/euccVhW0X3bl0b7pHWaJBVus0NbtuEHnmlwrZm9cir95kI21o7ELvhGIEY5TlkZNPCsEO2XjvWX7W3w0tZUjB/4IjBTfqOHbjVWgJ9muSo0evGjU9OjffnfBYtQagPAABtbNPBfbPeqk0NxDYZ1DfybJVe3eM7Y9dv62Z0CoduvXaTwopDt14ntl53leXaJjoOgRjtKQwb2Kt7HLn9UB8KvmO0K6v16RG/P2JkHDb+0RYJ9gv33gEAAG0ciDWFHmI0NRAb0GuFstYViNEcvmO0Rhi2tPNYOn+l9dL64DtGe7Pxmn3j5uNHxzE7rJt10FkWFVVV1VUCaTujRo3KppMmTfIxAAB0UtNnzY29Lnqg7F6I/zh+e6EFTfLstJlL7R1WCMQ2WrOPo0uT+Y7RGv+tvGLia3HtY29mA8YXpHAsXexOPfQF+viOkZfSdc9MnRmH7bdbdO1SEc888ViTthfqtwNCfQAAEoEYy5tADN8xOlIYlgaMT+PLpHJ0BizFd4zOlAsL9dsBoT4AAAVCV1qDQAzfMQBoe0L9HBPqAwBQl9AVAAA6tlHN7KlfuZzaAwAALINURmCrIf0dQwAAoJYutZ8CAAAAAADtlVAfAAAAAAByQqgPAAAAAAA5IdQHAAAAAICcEOoDAAAAAEBOCPUBAAAAACAnhPoAAAAAAJATQn0AAAAAAMgJoT4AAAAAAOSEUB8AAAAAAHJCqA8AAAAAADkh1AcAAAAAgJwQ6gMAAAAAQE4I9QEAAAAAICeE+gAAAAAAkBNCfQAAAAAAyAmhPgAAAAAA5IRQHwAAAAAAckKoDwAAAAAAOSHUBwAAAACAnBDqAwAAAABATgj1AQAAAAAgJ4T6zXTeeedFRUVF9nj44Ydb9lMBAAAAAIAShPrN8Pzzz8dpp50WPXv2bM7mAAAAAADQLEL9Jlq4cGEcdthh8YUvfCG+/OUvN++oAwAAAABAMwj1m+iXv/xl/Pvf/47x48dH165dm3PMAQAAAACgWSqbt1nnNHny5DjzzDPjlFNOiY033rjJ248aNarB/Q4fPrwFWggAAAAAQEemp36ZFixYEIcffnh8/vOfj5NOOmn5fioAAAAAAFCCnvpl+tnPfpaV3XnkkUeiW7du0RyTJk1qUg9+AAAAAAAopqd+GVKYf84558SJJ54YW2yxRTmbAAAAAABAixPql+Gwww6L9dZbL84444yW/wQAAAAAAKBMyu+U2VM/6dGjR6Plc2688cbYb7/9yj32AAAAAADQJEL9Mhx55JEl599///3x8ssvx5e+9KUYOHBgDBkypGlHHwAAAAAAmkCoX4Zx48aVnH/44Ydnof5PfvKT2GabbZpy3AEAAAAAoMnU1AcAAAAAgJwQ6gMAAAAAQE4I9ZfBhAkToqqqSukdAAAAAABahVAfAAAAAAByQqgPAAAAAAA5IdQHAAAAAICcEOoDAAAAAEBOCPUBAAAAACAnhPoAAAAAAJATQn0AAAAAAMgJoT4AAAAAAOSEUB8AAAAAAHJCqA8AAAAAADkh1AcAAAAAgJwQ6gMAAAAAQE4I9QEAAAAAICeE+gAAAAAAkBNCfQAAAAAAyAmhPgAAAAAA5IRQHwAAAAAAckKoDwAAAAAAOSHUBwAAAACAnBDqAwAAAABATgj1AQAAAAAgJ4T6AAAAAACQE0J9AAAAAADICaE+AAAAAADkhFAfAAAAAAByQqgPAAAAAAA5IdQHAAAAAICcEOoDAAAAAEBOCPUBAAAAACAnhPoAAAAAAJATQn0AAAAAAMgJoT4AAAAAAOSEUB8AAAAAAHJCqA8AAAAAADkh1AcAAAAAgJwQ6gMAAAAAQE4I9QEAAAAAICeE+gAAAAAAkBNCfQAAAAAAyAmhPgAAAAAA5IRQHwAAAAAAckKoDwAAAAAAOSHUBwAAAACAnBDqAwAAAABATgj1AQAAAAAgJ4T6AAAAAACQE0J9AAAAAADICaE+AAAAAADkhFAfAAAAAAByQqgPAAAAAAA5IdQHAAAAAICcEOoDAAAAAEBOCPUBAAAAACAnhPoAAAAAAJATQn0AAAAAAMgJoX4ZZsyYEccff3yMGjUqVl999ejevXsMGjQodtppp7j++uujqqpq+X9SAAAAAAB0ekL9Mrz//vsxfvz46NmzZ+y3335xwgknxB577BHPPvtsHHDAAfGtb32r03+RAAAAAABY/ipb4TVyb+jQoVlv/crK2odr9uzZsc0228Tvfve7+N73vhcbb7xxm7URAAAAAICOT0/9MnTt2rVeoJ/07t07dt999+znV155peU/HQAAAAAAKCLUXwZz586Nu+++OyoqKmKjjTZall0BAAAAAMBSKb/TBKkEz4UXXhiLFi2Kd999N2655ZZ488034/TTT48NNthgqdungXZLmTx5cgwfPrwpTQEAAAAAoBMS6jcx1D/zzDNrnnfr1i3OP//8bOBcAAAAAABY3oT6TTBkyJCoqqqKhQsXZj30r7nmmvjpT38aDz30UFx77bUl6+4XmzRpUpN68AMAAAAAQDE19Zs5cG4K+E866aQ455xz4sYbb4zf/e53zdkVAAAAAACUTai/jHbbbbdseu+99y7rrgAAAAAAoFFC/WU0bdq0bLq00jsAAAAAALCshPpleOqpp2LmzJn15n/44Ydx8sknZz/vsccey/xhAAAAAABAY3QvL8OECRNi3LhxMXbs2FhnnXWiZ8+eMWXKlLj55ptjzpw58ZWvfCUOPfTQcnYFAAAAAADNJtQvwwEHHJD11H/44Yfj/vvvj08++ST69+8f22+/fXzzm9+Mgw8+OCoqKpr/KQAAAAAAQBmE+mVI4X16AAAAAABAW1JTHwAAAAAAckKoDwAAAAAAOSHUBwAAAACAnBDqAwAAAABATgj1AQAAAAAgJ4T6AAAAAACQE0J9AAAAAADICaE+AAAAAADkhFAfAAAAAAByQqgPAAAAAAA50WFC/c033zwuvfTSmDVrVls3BQAAAAAAlosOE+o///zzcdxxx8Uaa6wRhx9+eEycOLGtmwQAAAAAAC2qw4T677zzTvz617+O9ddfP/7whz/EmDFj4vOf/3xccMEF8f7777d18wAAAAAAYJl1mFC/X79+cfzxx8e///3vePTRR+Poo4+Ot99+O0488cQYPHhwHHTQQXHHHXe0dTMBAAAAAKDZOkyoX2zEiBFx2WWXZaH++PHjY+TIkXHdddfFHnvsEUOHDo1zzz03WwYAAAAAAHnSIUP9ghVXXDG+9KUvxZe//OVYc801o6qqKqZMmRKnnnpqDBkyJKvB/8knn7R1MwEAAAAAoHOH+nfeeWccfPDBMWjQoKwEz6JFi+Lkk0+OF198Ma655prYfPPN49JLL82CfQAAAAAAyIPK6ECmTZuWldu58sor4/XXX8/m7brrrnHMMcfEvvvuG127ds3mbbDBBnHggQfGPvvsEzfddFMbtxoAAAAAADpZqJ8C+ttuuy0WLlwYq622Wpx00knZYLmpzE5Dtt1227jllltatZ0AAAAAABCdPdRP4fwuu+xS0yu/srKyrAsBqdY+AAAAAADkQYcJ9V955ZUYOnRok7YZPnx49gAAAAAAgDzoMAPlNjXQBwAAAACAvOkwof4FF1wQAwYMyAbLLSXNHzhwYFx00UWt3jYAAAAAAGgJHSbUv+6662LTTTdtsEZ+mr/ZZpvFNddc0+ptAwAAAACAltBhQv2XXnppqfXxN95443j55ZdbrU0AAAAAANCSOkyo/8knn0TPnj0bXadHjx4xZ86cVmsTAAAAAAC0pA4T6q+zzjrx0EMPNbrOpEmTYvDgwa3WJgAAAAAAaEkdJtTfe++9Y+LEiTF+/PiSy8eNG5ct32effVq9bQAAAAAA0BIqqqqqqqIDeO+992LzzTePt99+O8aMGRO77rprDBo0KKZOnRp33HFH3H///dlguU888UQMHDgw2pNRo0bV3EkAAAAAAEDHN6qZuXBldBApqL/nnnvi61//etx7773Zo6KiIgrXLEaOHBlXXXVVuwv0AQAAAACg04X6yQYbbBCPPPJIPP744/Hoo4/GjBkzol+/flmgP2LEiLZuHgAAAAAALJMOFeoXpABfiA8AAAAAQEfTYQbKBQAAAACAji63PfXPOuusrGb+d77znejfv3/2vBxpm1NPPXW5tw8AAAAAAFpaRVVhJNmc6dKlSxbQP//88zFs2LDseTnSNgsXLoyOMMoxAAAAAAD51NxcOLc99e+5555suvbaa9d6DgAAAAAAHVVuQ/0xY8Y0+hwAAAAAADoaA+UCAAAAAEBOCPUBAAAAACAnclt+pzBQblOlbRYsWLBc2gQAAAAAAMtTbkP9HXbYoVmhPgAAAAAA5FVuQ/177723rZsAAAAAAACtSk19AAAAAADIidz21G9Mqpn/0ksvxcyZM6NPnz7xuc99LiorO+RbBQAAAACgE+lQPfU/+uijOOaYY6Jfv36xySabxPbbbx+bbrpp9jzN/+CDD9q6iQAAAAAA0GyVHSnQHzVqVNZDf5VVVonRo0fH6quvHtOnT4/HH388xo0bF/fdd19MmjQp+vfv39bNBQAAAACAzttT/+yzz84C/Z/85CcxZcqUuPXWW+PKK6+MW265JXv+05/+NF5++eU455xz2rqpAAAAAADQLBVVVVVV0QGsu+66MXTo0LjrrrsaXGeXXXaJV199NXu0J+kOgyTdRQAAAAAAQMc3qpm5cIfpqT9t2rTYZpttGl1n6623ztYDAAAAAIA86jChft++fbMyO41Jy9N6AAAAAACQRx0m1N9xxx3juuuuizvvvLPk8lSWJy1P6wEAAAAAQB5VRgdx+umnx8033xy777577LnnnjFmzJhYbbXVYvr06XHvvfdmA+eutNJKcdppp7V1UwEAAAAAoHOH+htttFHccccdcfjhh2fhfnpUVFREYRzg9dZbLyZMmBAbb7xxWzcVAAAAAAA6d6ifbLvttvHiiy/GxIkT46mnnopZs2ZFnz59YvPNN4/tttsuC/kBAAAAACCvOlSon6TgftSoUbHKKqvEzJkzs4Fxhw0bJtAHAAAAACD3OsxAucl7770XRx99dPTr1y822WST2H777bNpen7MMcdkywEAAAAAIK86TKg/derU2GqrreKKK66Inj17ZgPmfvOb38ym6fm4ceNi5MiR2XrN2feFF14Yu+22W6y99tqxwgorxOqrrx5f+cpX4pFHHlku7wcAAAAAADpsqP+jH/0o3njjjTjzzDNjypQpccstt8SVV16ZTdPzM844I5v++Mc/bvK+L7744vjBD34Qr776auy6665xwgknZHcB3HTTTVkd/2uvvXa5vCcAAAAAAChWUVVVVRUdQKqhv/XWW2chfkO++MUvxmOPPRYffPBBk/Z9ww03xMCBA2P06NG15j/wwAOx8847R+/evWPatGnRvXv3ZrU9jQGQTJo0qVnbAwAAAACQL83NhTtMT/3PPvsstthii0bX2XLLLbP1mmr//fevF+gnad7YsWPjww8/jGeeeabJ+wUAAAAAgKaojA4iBfYvvPBCo+uk5Wm9ltStW7dsWllZWfaVl7omT54cw4cPb9F2AQAAAADQ8XSYnvpnn312/OMf/4gJEyaUXD5+/PisNM8555zTYq+Zavjfeeed2aC5m2yySYvtFwAAAAAAOnRP/XvuuScrhXPkkUfGeeedF9ttt12suuqq8e6778aDDz4YL774Yuy2225x9913Z4+CioqKOPXUU5v8evPnz49vfOMbMW/evOz1unbtutRtGqqN1FAPfgAAAAAA6JAD5Xbp0rybDlKov3DhwiZts2jRojjssMPiqquuiqOPPjouv/zyWBYGygUAAAAA6FxGNXOg3A7VU781pGsgKchPgf7Xv/71uOyyy1rldQEAAAAAoMOE+mPGjFnur5F66B911FFx5ZVXxiGHHJLV72/uHQIAAAAAANBUEulmBPoHHXRQ/PGPfyyrjj4AAAAAALSUDtNTf3kH+mkA3tQz/6tf/WpWekegDwAAAABAaxPql+Gss87KAv1evXrFsGHD4pxzzqm3zn777RebbbbZ8viMAAAAAAAgI9Qvw+uvv55N58yZE+eee27JdYYMGSLUBwAAAABguRLqlyH10k8PAAAAAABoSwbKBQAAAACAnBDqAwAAAABATgj1AQAAAAAgJ4T6AAAAAACQE0J9AAAAAADICaE+AAAAAADkhFAfAAAAAAByQqgPAAAAAAA5IdQHAAAAAICcEOoDAAAAAEBOCPUBAAAAACAnhPoAAAAAAJATQn0AAAAAAMgJoT4AAAAAAOSEUB8AAAAAAHJCqA8AAAAAADkh1AcAAAAAgJwQ6gMAAAAAQE4I9QEAAAAAICeE+gAAAAAAkBNCfQAAAAAAyAmhPgAAAAAA5IRQHwAAAAAAckKoDwAAAAAAOSHUBwAAAACAnBDqAwAAAABATgj1AQAAAAAgJ4T6AAAAAACQE0J9AAAAAADICaE+AAAAAADkhFAfAAAAAAByQqgPAAAAAAA5IdQHAAAAAICcEOoDAAAAAEBOCPUBAAAAACAnhPoAAAAAAJATQn0AAAAAAMgJoT4AAAAAAOSEUB8AAAAAAHJCqA8AAAAAADkh1AcAAAAAgJwQ6gMAAAAAQE4I9QEAAAAAICcq27oBlG/RokXx0UcfxezZs2PevHlRVVXl8EErq6ioiO7du0fv3r1j5ZVXji5dXBsFAAAAoPUI9XMU6L/11lvx8ccf1woXgdb/t/jpp59mj/TvcfDgwYJ9AAAAAFqNUD8nUg/9FCB269YtVl999ejZs6dQH9pAukMm/Vt85513sumMGTOif//+PgsAAAAAWoW6ETmRSu4kKdDv1auXQB/aSLpDJv0bTP8Wk1mzZvksAAAAAGg1Qv2cSDX0k9RDH2h7hX+LhX+bAAAAANAahPo5KvmRegirow/tQ+HfowGrAQAAAGhNQn0AAAAAAMgJoT4AAAAAAOSEUB8AAAAAAHJCqA8AAAAAADkh1AcAAAAAgJwQ6gMAAAAAQE4I9ct01VVXxbe+9a0YMWJEdO/ePSoqKmLChAnREc2dvzAefe3DuPuF6dk0PQcAAAAAoO1VtnUD8uKUU06JKVOmxIABA2KNNdbIfu5o3pk5N66Y+Gpc+/hbMfPT+TXz+67YLQ4cMTiOGr1urNanR5u2EQAAAACgM9NTv0zjxo2L119/Pd5777349re/HR3Ns9Nmxt4XPxC/e+C1WoF+kp6n+Xtd9EC2Xlu59957szskzjjjjJg0aVLsvvvu0a9fv2xeMn78+Nh3331jyJAh0aNHj+jfv3+2zj333FNrPx9++GF07do19ttvv1rzH3vssWxf6fHWW2/VWrb11ltH7969Y8GCBa3wTgEAAAAAShPql2mXXXaJddZZJzqi1EP/sPGPxvtzPmt0vbQ8rTd91txoSw899FCMGTMm+/mYY46Jgw46KPv5O9/5TkyfPj37rH7wgx/E3nvvnYX/6flNN91Us30K+zfddNO47777YtGiRbUuGhQUXwiYPXt2PPHEEzF69OiorHRzCwAAAADQdiSUrWjUqFEl50+ePDmGDx8ebSWV3FlaoF+Q1rti4mtx8p6fj7byz3/+M6644oo44ogjas1/7rnnYujQobXmvf3229k4CP/93/+d9eIvGDt2bPz617+Op556KrbYYouaIH+TTTbJLgykn7/xjW9k8x944IGsh37aBgAAAACgLemp38mlQXBTDf2muPaxN9t08NzNN9+8XqCf1A30kzT+wVe+8pV4+eWXa42DsOOOO2bTu+++O5um0H7ixImx0047ZcsK84t77Re2AQAAAABoK3rqt6JUCqYpPfhbw9NvzaxXQ39pZnw6P56ZOjO2GtI/2sLIkSNLzn/11Vfj5z//eRbIT506NebNm1dr+bRp02pKKO2www7RpUuXLLA/8cQT4/HHH8/K7KTe+Kl3/7XXXhuvvfZadqEgrdOnT5+aHv0AAAAAAG1FqN/JzZnXtEC/YPbc5m3XElZbbbV681555ZUs7J81a1YWzO+zzz5ZEJ+C+1QrP9XPLw750wC7qcd/obROCu7Tuinsf/fdd7N10rxUf//JJ5+MPffcMxtcFwAAAACgLQn1O7le3bs1a7vePZq3XUuoqKioNy/Vx//oo4/iqquuiq997Wu1ln3729/OQv26Uvj/r3/9K3uk4H+zzTaLlVdeOXusueaaWag/cODAbDBd9fQBAAAAgPZATf1ObtPBfaPvik0L6Put2C02GdQ32pP//Oc/2fRLX/pSrfkpkH/wwQdLblOokX/77bdn66R6+gUpxE+hvnr6AAAAAEB7ItTv5Hp06xoHjhjcpG0O3GqtbLv2pFArPw12W+yXv/xlTJ48ueQ2o0ePzkrqXHLJJfHxxx/X6o2ffk51+VPP/1SqJ/XiBwAAAABoa0J94qjR68aAXiuUdSQG9uoeR24/tN0dtVRip1u3brH//vvH4YcfHieccEJst912cdZZZ8Vee+1VcptUc3/LLbeM9957Lwv3U8hfUAj407IxY8Zk9fYBAAAAANqapLJM48aNy8Li9Ljuuuvqzfvb3/4WebVanx7x+yNGLjXYT4F+Wi+t396kQW/vuOOOLKS/4YYbYvz48VkP+1RWZ8SIEQ1uVwjv0zq9e/eumb/uuuvW9P4vlOkBAAAAAGhrFVVVVVVt3Yg8SMH973//+waXn3766XHGGWc0a9+jRo3KppMmTWpwnRdeeCGbbrjhhrG8TJ81N66Y+Fpc+9ibMePT+bVq6KeSO6mHfnsM9KGttMa/SwAAAAA6plFl5MKlVC6n9nQ4EyZMyB4dWQrsT97z8/HDXYfFM1Nnxuy586N3j+pBcdtbDX0AAAAAgM5IqE89KcDfakh/RwYAAAAAoJ1RUx8AAAAAAHJCqA8AAAAAADkh1AcAAAAAgJwQ6gMAAAAAQE4I9QEAAAAAICeE+gAAAAAAkBNCfQAAAAAAyAmhPgAAAAAA5IRQHwAAAAAAckKoDwAAAAAAOSHUJ1c+++yzOOWUU2K99daLFVZYISoqKuLee++NvEnt3nHHHdu6GQAAAABAzlS2dQOgKX71q1/FueeemwXihxxySFRWVsaQIUMcRAAAAACgUxDqkyu33HJL9OrVK+64447o1q1b5NXzzz8fK620Uls3AwAAAADIGaE+uTJt2rRYZZVVch3oJxtuuGFbNwEAAAAAyCE19cmFM844I6tD/9prr8WUKVOynwt16QvLStXWnzBhQrYsTet6+umn4+CDD4411lgjq8+/zjrrxHe/+9344IMP6q17zz33xB577BFrrrlmdO/ePZum1x43blyL1dR/6aWX4kc/+lFsscUW2YWLHj16xLBhw+Kkk06KOXPm1Fr3vvvui65du8aWW26ZjTNQt61p2ciRI2P+/PnNah8AAAAA0D7pqU8uFALwCy+8MJt+//vfz6apnv7rr7/e5P39/e9/jwMPPDALv7/0pS/FWmutFc8991xccsklcfvtt8cjjzwSK6+8crbuzTffHPvss0/069cv9t133+wiwHvvvRdPPfVU/OlPf4qjjjqqRd7jDTfcEFdccUWMHTs2e7+LFi2Khx9+OH75y19mIf79999fc4fCmDFj4ic/+Uk2vsDJJ5+cjTWQfPjhh/GNb3wjK+1z9dVX5/6OBgAAAACgNqF+B7D1z+6Mj+ctjPauZ/eu8cjJuzRr2xRyp0ehx33qnV9Q/HM5Uk/8FHwPHDgwHnzwwVh77bVrlv35z3+OQw89NE477bS4+OKLs3njx4+Pqqqq7E6ATTfdtN6+Wkpq0w9/+MPsroFiZ511Vpx++ulx7bXXxte+9rVa7/uuu+6KCy64IHbbbbfskS4wTJ06Na688spYf/31W6xtAAAAAED7oPxOB5AC/TnzFrT7R3u58PCHP/whZs2aFT//+c9rBfrJIYcckpW/ueaaa+ptt+KKK9abl8rktJRBgwbVC/ST4447LpveeeedteZXVlZmvfF79+4dhx12WNZr/8Ybb8zuQDj88MNbrF0AAAAAQPuhpz6dTippU5i+8sor9ZbPnTs33n///ewxYMCALCRPpXG23nrrLPTfaaedYvTo0bHqqqu2aLvS3QCph326G2Hy5Mkxc+bMrARP8SDBdQ0dOjQuvfTSrAf/Kaeckl2k+O1vf9ui7QIAAAAA2g+hfgeQytrkQXtpZ6o7n/zmN79pdL2PP/44C/UPOuigrDZ9quefAvP//d//rRnoNpW+2WyzzVqkXccff3xW0z/V9091/lPt/jQob3LmmWfGvHnzSm636667Rq9evbLBdL/+9a9ntf8BAAAAgI5JqN8BNLdOfUfRpUt1FakFCxbUW5Z6u9fVp0+fbPrMM8/E8OHDy3qN/fffP3uksj0PPfRQzaC2u+++e7z44ovLHKS/++672UWGVLN/0qRJ2UC3Be+8804W6jfkv/7rv7JAP5UCShcZDj744Nhkk02WqT0AAAAAQPukpj65t/LKK2fTNEBsXU8++WS9eamMTpLC86ZKFwS++MUvxuWXX57VrU9h/COPPBLL6tVXX83K7+yyyy61Av3kgQceaHC7iy66KG6++easLbfeemssXLgwKxGUSggBAAAAAB2PUJ/cGzFiRM0AuMU16FNo/6c//alkz/Y0uOxPf/rTePbZZ+st/+STT2rq7id33XVXyZA8BfoNDaDbVOuss042TXcBFL+Ht956K0466aSS26Q7DX784x/HeuutFxdffHFstdVWWY/+9J5OPPHEZW4TAAAAAND+KL9D7m2zzTYxatSouPvuu7PpDjvsEFOmTIm///3vsc8++8SNN95Ya/2BAwfGn//85/jqV78aX/jCF7Ke9xtuuGEW3Kft7rvvvth2223jtttuy9Y/4YQT4o033shq6A8ZMiSrpz9x4sR49NFHs/W22267ZX4PqX7+V77ylbj++uuzixQ777xzTJ8+Pf7xj39kA/OmnvzFUlsPPfTQrOTQ1VdfndXUT1LIf/vtt2elfNL72nvvvZe5bQAAAABA+yHUJ/dSyJ4C/B/+8IdZKZrUgz2F9WnetGnT6oX6yV577ZWV5jn//PPjzjvvjH/+85/Rs2fPGDx4cNaTPw04W/CTn/wkq6H/r3/9KwvM06C5Q4cOjfPOOy+OPfbY6Nq1ZQYAnjBhQnbRIAX7qef92muvnb2nFNSvsMIKtdZNPfEnT54c55xzTowcObLW+AJ//OMfs/d/xBFHxNNPPx2rr756i7QPAAAAAGh7FVWpkDdtKvUuX1qN9xdeeCGbph7l5FvqZZ9K9uy2227ZRQLyy79LAAAAAJZnLlyKmvrQyl555ZVsmu4KAAAAAABoCuV3oJWkGvmprE6hHND+++/v2AMAAAAATSLUhxZw4YUXxowZMxpd56mnnopbbrkl1ltvvfjtb3+b1fUHAAAAAGgKoT60UKg/ZcqUpa53zz33xI477uiYAwAAAADNItSHFvD66687jgAAAADAcmegXAAAAAAAyAmhPgAAAAAA5IRQHwAAAAAAckKoDwAAAAAAOSHUBwAAAACAnBDqAwAAAABATgj1AQAAAAAgJ4T6AAAAAACQE0J9AAAAAADICaE+5Mzrr78eFRUVcfjhh0d7l9qY2pranBdDhgzJHgAAAADQHgn1AQAAAAAgJyrbugFA0wwaNCief/756Nu3r0MHAAAAAJ2MUB9yplu3brHhhhu2dTMAAAAAgDag/A65MWHChKw+e5rWde+992bLzjjjjJp56fmOO+4Yb775Zhx00EGxyiqrRM+ePbN5Dz30UIP13//zn//Ez3/+81h//fWjR48escEGG8T5558fixYtKtmu+++/P/bZZ58YMGBAdO/ePVv/lFNOiU8++aTBNk6aNCl233336NevXzavpWrqv/HGG3HkkUdmvflXWGGFGDx4cPY8HYO60nFI+5k3b16cdtpp2ftNFwyKj2G5nn322dh7772jd+/e2R0Ee+65Z0yePHmpn+PNN98co0ePzrYr1LFv6udc8Nprr8VRRx0Va6+9dvY5rLHGGtkxmjJlSsl23HTTTbHVVlvFiiuuGKuttlocffTR8dFHHzX5vQMAAABAa9JTnw4thbTbbbddFvAec8wxMXXq1PjLX/4SY8eOjdtvvz0Ltuv6/ve/Hw8//HAceOCBWah/ww03xI9+9KN45ZVX4re//W2tdS+77LI49thjY+WVV86C/YEDB8Zjjz0W5557btxzzz3ZI4XrxdIFhZ/97GdZG1KbUhDfEl5++eXYfvvt4913383asvHGG2dh+/jx4+Mf//hHPPjgg1lwX9f+++8f//73v7OLDP3794911123Sa+bwvt0jOfMmZPtK13UePTRR7N5X/jCFxrc7rrrros77rgjuxiQjuHs2bOjuR555JGs/R9//HH23tP7TBc//vSnP8Wtt96aXUQpfl9/+MMf4rDDDos+ffrEN77xjeziSjpGu+yyS3z22Wf1PjMAAAAAaC+E+h3FeetGzP802rVuK0b86NVWfcmnn346C21///vf1/SITz3XU6Ceema/+OKL0aVL7RtWUiifQu4111wze37mmWfGtttuG5dffnl8/etfz3qWJ88991x897vfjc022yzuvPPOLBAv+MUvfhE/+clP4uKLL44TTjih1v7/+c9/xhVXXBFHHHFEi77Xb3/721mgny48pIsFBand3/rWt7LlqZ11TZs2LTtOxe1viuOOOy5mzZoVV111VXzta1+rmX/yySdndzw0JIXtKdRPQfqymD9/fhx88MHZnRSPP/54rQsJEydOzC7cfO9734v/9//+XzYvtTV9bumujfRZDxs2LJufLsSktrz99tuxzjrrLFObAAAAAGB5UX6no0iB/vxP2vmj9S86dO3aNQtri0vcjBkzJisPk3relyrDc/zxx9cE+kmvXr2y8jRJujhQkMLzBQsWxEUXXVQvEE89+1Ov/T//+c/19r/55pu3eKCfyuvcfffdsdFGG2UXK4ql55///OfjrrvuKlmGJ120aG6gn+4yuO+++2LTTTetFegXQv3UA74h++233zIH+knqYZ965adjXvfOgHTnwr777hu33HJLFuYnf/vb37Kf02dQCPSTVHoofVcAAAAAoD3TU7+jSL3g27s2aGPqcb3WWmvVm59626d67k899VQW/NZdVmr9JK1fkEr0JLfddlvJHvApJH7hhRfqzR85cmS0tCeffLLmgkXdGv3p+Q477BDPP/98dgdC3eOxLO1J+0vqHsPCxZB0F0Oqg19KSx2HwueQjnWpWvvvvPNO1ov/pZdeihEjRtS0udTnPGrUqKisdFoEAAAAoP2SXnUUrVzWJi9WXXXVkvPTwKjJzJkzy9omzUtleorX//DDD7NpU3t3F167JRV6oTe079VXX73B97ss7Snsb2nHuanLmqLwOaT6+Y1J9faX1uZ0Z0caUBkAAAAA2ivld8iNQu37VPKmrlJhdZJqzJcyffr0bNq3b9+ytknzUm/v4vXTIKuFQL2qqqrBR111e9K3hEJbCu+rrsL8wnot1Z7C8VjacS6loddt6udceE+pZn5jn0O6i2FpbV64cGF88MEHDbYZAAAAANqaUJ/cWHnllbPp1KlTGyw/U9eUKVNK1pF/4IEHsmkqD9PQsqWtv/XWW9cq/9KWCu26//77611ISM8be7/LolDDPg1IW9ecOXNqlStaXp9z4XOYNGlSk9pc6nNO+yh1MQEAAAAA2guhPrmxxRZbZL27r7nmmpg7d27N/Jdffjn+53/+p+Q2qef1T3/601pBdxrYNQ2cuv7668e2225bb5s08O20adNqhdNnnXVW9vM3v/nNmvnHHntsVn/9u9/9bskLBzNmzGjwYkNLW3vttWPs2LHx7LPPxvjx42stS8/T/J122qnk+ALL+rqpXv/TTz9dr/zNz372s+wYLO/POQ2Em9pxwQUXZBc16po/f36tiw5p/dS7Px2XVGe/eL1TTjmlye0FAAAAgNakpj65MWjQoDjooIOysHfLLbeML37xi1kJlRtvvDH7+frrr6+3zaabbpoN1LrNNttkoXYK69P2aRDb3/3udzWlXopttdVWWW/u9Frdu3ePG264IV5//fU4+uijswC7YPjw4fG///u/8X/+z/+Jz33uc7HnnnvGeuutl5XjefXVV7OLB4cffnhcdtll0RouvfTSbMDa1M5UimajjTaK5557Lv7+97/HwIEDs+XLw29+85vYbrvtsgsef/vb32KDDTaIxx57LB599NFsMNpSPeJb8nNOn9Ff//rX2GOPPbISOzvvvHP22SRvvPFG9vqpTn5h0OJUfidduEmfTfqsDz744GzeP/7xj1hxxRVjjTXWaMGjAwAAAAAtS0/9JkhBZQpuU3mQnj17xsiRI+Pqq69u4Y+ExlxxxRVZz/hU9zyFyamH+OWXXx7HHXdcyfXTZ5V6aa+zzjrx29/+Nq677ros4L/77rtjxx13LLnNhRdeGD/84Q/j1ltvjUsuuSQbPPWXv/xlyVA8BeipZEvq/Z2mv/71r7OA+f33348f/OAH8f3vf7/VPtB0YeHxxx/PwuoUqJ9//vnZND1P391hw4Ytl9dNAfqDDz6YBe633XZbdszSRZM0b911122VzzmF8//+97/je9/7XhbkpwspV155ZRbk77ffftnFl2KHHXZYdpEgXYD4/e9/nz3ShYk777wzVlhhhWa1GQAAAABaQ0VVqZE8qSf19t59992zwK/Qszf14H7ttdfi3HPPjZNPPrnZR23UqFFLrQle6GW84YYb+nTKlEq4pJ7b6bMrRwq/U7ibPtMhQ4a02+Ocvguf//zn45hjjskuVNC2n0Xi3yUAAAAAyyMXLkVP/TKkgTOPOuqoLCRONbtT2ZZf/epXWc/gjTfeOE4//fSs3je0hldeeSWbDh482AEHAAAAgE5GqF+GVKrlP//5Txx66KGx+eab18zv3bt3nHrqqVnon0p9wPKUBnU96aSTsgF601gAqeQPAAAAANC5GCi3DIXyLbvttlu9ZYV5aVBUaK4zzjhjqeukQWhffPHFrDZ+Gug1DQK8vL7v5ZQs2myzzbJ69QAAAABA6xHql6FQWicNqllqINYBAwaUVX6nUCOprsmTJ2eDjdKymjpcxIQJE7JHWzjzzDPLWq816v2nQL+c9qTBZoX6AAAAANC6hPplmDlzZjZNg+OW0qdPn3jrrbda9pOhU2lP41WnuwbKuXMAAAAAAGh9Qv1W1NAoxg314AcAAAAAgGIGyi1DoYd+ocd+XbNmzWqwFz8AAAAAALQUoX4ZCrX0S9XN/+ijj+L9998vWW+/JVVUVGQlWtpTmRbozAr/HtO/TQAAAABoLUL9MowZMyab3nHHHfWWFeYV1lleunfvnk0//vjj5fo6QHkK/xYL/zYBAAAAoDUI9cuw8847x7rrrhtXX311PPXUUzXzZ8+eHWeffXZUVlbG4Ycfvjw/p+jdu3c2feedd2LOnDl67EMbSb3z07/B9G+xMFA2AAAAALQWA+WWc5AqK2PcuHGx++67x+jRo+OQQw7JgrwbbrghXnvttTjnnHNi2LBhy/WDWnnllbOewenx5ptvZvOU/YDWV1wCq2fPntGvXz8fAwAAAACtRqhfprFjx8bEiRPj9NNPj2uvvTY+++yz2HjjjbOe+l/72teW/y0VXbrE4MGDY8aMGdnAvPPmzdNbH9pA+reYSu6kC3sp0E/PAQAAAKC1CPWbYOTIkXHrrbdGW0nhYf/+/bMHAAAAAACdjy6mAAAAAACQE0J9AAAAAADICaE+AAAAAADkhFAfAAAAAAByQqgPAAAAAAA5IdQHAAAAAICcEOoDAAAAAEBOVLZ1A4h49dVX45NPPolRo0Y5HAAAAAAAncDkyZNjpZVWavJ2Qv12YOWVV46O+qVMhg8f3tZNATow5xrAeQboCPxOAzjXQOez0korNSsbrqiqqqpaLi2i0yvceTBp0qROfyyA5ce5BljenGeA1uBcAzjXAOVSUx8AAAAAAHJCqA8AAAAAADkh1AcAAAAAgJwQ6gMAAAAAQE4I9QEAAAAAICcqqqqqqtq6EQAAAAAAwNLpqQ8AAAAAADkh1AcAAAAAgJwQ6gMAAAAAQE4I9QEAAAAAICeE+gAAAAAAkBNCfQAAAAAAyAmhPgAAAAAA5IRQnya78cYbY9ddd41VVlklVlxxxRg6dGgccsgh8eabb5a9j9mzZ8fpp58ew4cPj5VWWin69esXW2yxRZx55pk+EWCZzzMzZsyI0047LTbddNPo3bt3DBgwILbaaqu45JJLYu7cuY4wdGITJkyIioqKRh8777xzWftatGhRdl5J55p0rho4cGAceOCB8fLLLy/39wG0by11rpk4cWKccMIJseWWW2a/F/Xo0SM23HDD+PGPf5z9vgN0bi35e02x+fPnx2abbZZtn845QPtT2dYNID+qqqri29/+dlx++eWx3nrrxcEHH5yFZdOmTYv77rsvpkyZEmuttdZS9/PGG2/ETjvtFK+++mrssssusddee8W8efPilVdeieuvvz4L+4HOqSXOM+kP3PSHbzrHbL/99vGtb30rO8fceuut8d3vfje7YPDPf/4zunRxXRs6o/QHakO/a/z1r3+NZ599Nnbfffey9pXOV7/73e9io402ys4v06dPj7/85S9xxx13xEMPPZTNBzqnljrXHHDAAfH+++9nv9N885vfzAK2e++9N84777zsb6d0rll11VWXwzsAOtvvNcXOPvvsLKMB2q+KqpSgQBkuuuii+N73vhff+c534n/+53+ia9eutZYvWLAgKisbv060cOHCGDVqVEyePDluvvnmGDt2bJP3AXRcLXGeSX/kpt5rP/jBD+KCCy6omf/ZZ59lfxA/9thj2QWCHXbYYbm9DyB/0jlizTXXjJkzZ8Zbb70Vq622WqPr33PPPVknhdGjR2cXCrt3757Nv+uuu7I7jdL8dK4BWJZzzS9/+csszF9jjTVq5qU/4dPvSpdeemkce+yx8Zvf/MZBBpbpXFPsiSeeiK233jr7W+r444+Pz33uc/HCCy84wtDO6KZIWT799NOsNM66664bF154Yb2gLSknjE9XilOgduKJJ9YL9MvdB9AxtdR5JvXQT/bcc89a81dYYYUsaEvefffdFms30DGku3g++OCD2Hvvvcv6wzf10E/OOeecmkA/Sbe4px5x999/f7z00kvLtc1Axz/XpI4KxYF+knrrn3rqqdnPLh4CLXGuKb4YcPjhh8c222wTxx13nIML7ZgElbKkHmgffvhhdnJPve3//ve/Z3+oplr4qYTO+uuvX9Z+0i3pyVe/+tWsNnbqrZ9KZaQyG3vssUf06tXLJwKdVEudZzbeeONsetttt2XbFdeFvPPOO7O61+mOIYBiV1xxRTY96qijyjowqfxFz549Y7vttqu3LIX66RyUwrZhw4Y50ECzzzUN6datWzbVKQpoyXPNGWeckY0N9O9//zu7gAi0X0J9yvL4449Xf2EqK+MLX/hCvPjiizXLUl3qVObiV7/6Vdn7SQM+pW1SneuCNLjctddeGzvuuKNPBTqhljrPpF9c//jHP8b//b//N9tnGiA3nWtSwPbRRx/F1VdfHYMGDVqu7wXIlzReRyqbk84NX/ziF5e6/scffxxvv/12DB8+vORdRRtssEE2NWAusCznmsaMHz8+m+62224OMtAi55pUVSGVMv3Zz36mUwLkgPI7lKVQqiKFZH369IlHH300Zs+end1annqgpfmppmO5+0mDyX3/+9/Peuu/9957WR3tVOttv/32y/5IBjqfljrPpJ74qQft17/+9ayXbLoQcPHFF8d//vOfOPTQQ7O6+gDFrrzyyli0aFH813/9V8mQvq70O0vSt2/fksvTOax4PYDmnGsa8tRTT2UlC9MAuT/60Y8cXGCZzzWpE1S6Y3rzzTePE044wRGFHBDqU5b0H4RCTeq//e1vWc/XVConDQKX6uSnXrQpcCt3P6mu2y9+8YsYPHhwDBgwIAv5Uy/c9Mdv4TYxoHNpqfPM+++/n9XOf/jhh2tKfL3zzjtx2WWXZb/gpkGfUo99gMK5J50b0i3mRxxxhIMCtOtzzWuvvZb9LZVKFV5zzTXZ31IAy3quSeN0pDsM011Ay3LREWg9Qn3KUuiJNmLEiGwE9br1q9PAlqkXbArPytnPl770pXrL9tlnn1olOIDOpaXOMz/84Q/joYceiuuvvz4bLDftNw0OdfTRR2e3k6aBdNNAvACF8TzeeOON2GmnnWLo0KFNOl811BN/1qxZtdYDaM65plRJjbFjx2Z3OqcOD+lngGU91zzxxBNxwQUXxE9/+tPYZJNNHFDICaE+Zfnc5z6XTdOAlaUU5n/66afN3k+5+wA6ppY6z6Te+f37949NN9203rL0y23yr3/9qwVaDHTWgeTSALlrrLFG1mM29Zatq1BLv1BbH2BZB8h9/fXXs7HHpk2blo1DlnrrA7TEuebpp5/Ofp9Jg+SmHv7FjySNdZZ+bujvNKBtGCiXshR6gTz//PP1ls2fPz9eeeWV7A/cNNhtY1Kg9uCDD8Zzzz0X+++/f61laV4yZMgQnwp0Qi11nvnss89i7ty52TSV8imWerYl3bt3b9G2A/n0wQcfxE033ZRdCPzyl7/cpG3HjBmTlb5Iv9fssMMOtZbdfvvtNesALMu5pm6g/5e//CX23XdfBxVosXNNGr/syCOPbPAiQbrz8IADDoiVVlrJUYd2RE99yrLeeuvFbrvtloVq48aNq7Us1cZP5TDSfzQqKytralq/8MIL2bRYGqglhWlp0MqpU6fWzE+DYaYR1pMDDzzQpwKdUEudZ7bbbrtYsGBBnH322fUGfyrMc7s6kPzxj3/MLgCmgbUbutjX0LnmmGOOyaannHJKto+Cu+66Kwv1U9Cf/kgGWJZzTSHQT387pQuJzbkoAHQOzT3XbLvtttnfX6Ueyeqrr579fNFFF7XaewGWrqKqqqqqjPUgq2WdTvbvvvtu7LXXXrHhhhvGk08+GXfffXess8462aCU6WSfpNu2zjzzzDj99NOzn4ulQP/444+PVVZZJfulNP3HJpXLSL+wpj+Qf/vb3zra0Em1xHnmqaeeysK0dLFw5MiRWcifeu6nkC3V099yyy1j4sSJ0aNHjzZ8p0B7kOrGTp48ObvtvKEaso39TpPG6kh/5G600UbZOWv69OlZL9p0fklje6T5AMtyrkl3Mada+ttss03svvvuDW4LsKy/15SSyu6kMqnpQgDQvii/Q5N60aZBbE877bS47bbb4o477sjCte985zvZvFVXXbWs/Xz3u9/Nfjk9//zzs94mqUdtGgTz5JNPzv44BjqvljjPbLbZZlnN/J///OdZj9lLLrkk692//vrrZ7/AnnjiiQJ9IB599NHsD9908a+5g8Kljghp/I40Tb3XevXqFfvss0+ce+65eukDLXKuSYF+kjo2pEcpQn2gJX6vAfJFT30AAAAAAMgJNfUBAAAAACAnhPoAAAAAAJATQn0AAAAAAMgJoT4AAAAAAOSEUB8AAAAAAHJCqA8AAAAAADkh1AcAAAAAgJwQ6gMAAAAAQE4I9QEAAAAAICeE+gAAAAAAkBNCfQAAAAAAyAmhPgAAAAAA5IRQHwAAAAAAckKoDwAAAAAAOSHUBwAAAACAnBDqAwAAy9W9994bFRUVccYZZ8RDDz0UY8eOjd69e8fAgQPj2GOPjU8//TRb77bbbovtttsuevbsGauttlr8+Mc/joULF/p0AACgiFAfAABoFY888kjsvPPO0bdv3/jWt74Va6+9dlx66aVx9NFHx3XXXRf7779/rLXWWtmyfv36xXnnnRe/+MUvfDoAAFCkoqqqqqp4BgAAQEv31E+985O//e1vse+++2Y/z58/P0aMGBHPPPNMrLLKKnHLLbfEVlttlS2bPXt2rL/++llP/XfeeScqKyt9KAAAoKc+AADQWnbccceaQD/p1q1bHHDAAZH6Ge2zzz41gX6SyvPsvffe8cEHH8Rbb73lQwIAgMWU3wEAAFrF5ptvXm/eGmuskU0322yzBpdNnTq1FVoHAAD5INQHAABaRZ8+ferNK5TVaWxZKtMDAABUE+oDAAAAAEBOCPUBAAAAACAnhPoAAAAAAJATQn0AAAAAAMgJoT4AAAAAAORERVVVVVVbNwIAAAAAAFg6PfUBAAAAACAnhPoAAAAAAJATQn0AAAAAAMgJoT4AAAAAAOSEUB8AAAAAAHJCqA8AAAAAADkh1AcAAAAAgJwQ6gMAAAAAQE4I9QEAAAAAICeE+gAAAAAAkBNCfQAAAAAAyAmhPgAAAAAA5IRQHwAAAAAAckKoDwAAAAAAOSHUBwAAAACAnBDqAwAAAABA5MP/B6yAdOnI3qwsAAAAAElFTkSuQmCC",
+      "text/plain": [
+       "<Figure size 1540x980 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Identify an intersection location in fues_jax output (duplicate m values)\n",
+    "dup_idx = np.where(np.diff(ref_m) == 0)[0]\n",
+    "m_int = ref_m[dup_idx[0]]\n",
+    "print(\"zooming around intersection at m =\", m_int)\n",
+    "\n",
+    "fig, ax = plt.subplots(2, figsize=(11, 7), sharex=False)\n",
+    "\n",
+    "# Zoom window around intersection\n",
+    "zoom_half_width = 0.5  # adjust if you want tighter/looser zoom\n",
+    "zx0, zx1 = m_int - zoom_half_width, m_int + zoom_half_width\n",
+    "\n",
+    "# Value: zoom\n",
+    "ax[0].scatter(endog_grid_raw, value_raw, label=\"raw\")\n",
+    "ax[0].plot(ref_m, ref_v, lw=2, label=\"fues_jax\")\n",
+    "ax[0].plot(endog_out, value_out, lw=1.5, label=\"upper_jorg_drued\")\n",
+    "ax[0].set_xlim(zx0, zx1)\n",
+    "ax[0].set_title(\"Value: zoom around fues_jax intersection\")\n",
+    "ax[0].set_xlabel(\"m\")\n",
+    "ax[0].set_ylabel(\"value\")\n",
+    "\n",
+    "# Policy: zoom\n",
+    "ax[1].scatter(endog_grid_raw, policy_raw, label=\"raw\")\n",
+    "ax[1].plot(ref_m, ref_c, lw=2, label=\"fues_jax\")\n",
+    "ax[1].plot(endog_out, policy_out, lw=1.5, label=\"upper_jorg_drued\")\n",
+    "ax[1].set_xlim(zx0, zx1)\n",
+    "ax[1].set_title(\"Policy: zoom around fues_jax intersection\")\n",
+    "ax[1].set_xlabel(\"m\")\n",
+    "ax[1].set_ylabel(\"policy\")\n",
+    "\n",
+    "ax[0].legend()\n",
+    "ax[1].legend()\n",
+    "plt.tight_layout()"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "base",
+   "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.12.12"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/src/upper_envelope/__init__.py b/src/upper_envelope/__init__.py
index 4a93c13..602575c 100644
--- a/src/upper_envelope/__init__.py
+++ b/src/upper_envelope/__init__.py
@@ -1,3 +1,3 @@
 from upper_envelope.fues_jax.fues_jax import fues_jax, fues_jax_unconstrained
 from upper_envelope.fues_numba.fues_numba import fues_numba, fues_numba_unconstrained
-from upper_envelope.upper_jor_drued import upper_jor_drued
+from upper_envelope.upper_jorg_drued import upper_jorg_drued
diff --git a/src/upper_envelope/fues_jax/fues_jax.py b/src/upper_envelope/fues_jax/fues_jax.py
index 7e62c66..9337dcd 100644
--- a/src/upper_envelope/fues_jax/fues_jax.py
+++ b/src/upper_envelope/fues_jax/fues_jax.py
@@ -36,7 +36,7 @@ def fues_jax(
     expected_value_zero_savings: jnp.ndarray | float,
     value_function: Callable,
     value_function_args: Optional[Tuple] = (),
-    value_function_kwargs: Optional[Dict] = {},
+    value_function_kwargs: Optional[Dict] = None,
     n_constrained_points_to_add=None,
     n_final_wealth_grid=None,
     jump_thresh=2,
@@ -98,6 +98,9 @@ def fues_jax(
             containing refined value function.
 
     """
+    if value_function_kwargs is None:
+        value_function_kwargs = {}
+
     # Set default of n_constrained_points_to_add to 10% of the grid size
     n_constrained_points_to_add = (
         endog_grid.shape[0] // 10
@@ -831,6 +834,7 @@ def select_and_calculate_intersection(
 def _compute_value(
     consumption, value_function, value_function_args, value_function_kwargs
 ):
+    """Helper to compute value given consumption and value function."""
     value = value_function(
         consumption,
         *value_function_args,
diff --git a/src/upper_envelope/upper_jor_drued.py b/src/upper_envelope/upper_jorg_drued.py
similarity index 78%
rename from src/upper_envelope/upper_jor_drued.py
rename to src/upper_envelope/upper_jorg_drued.py
index 74e8a0d..42c1316 100644
--- a/src/upper_envelope/upper_jor_drued.py
+++ b/src/upper_envelope/upper_jorg_drued.py
@@ -8,7 +8,7 @@
 
 
 @partial(jax.jit, static_argnames=["value_function"])
-def upper_jor_drued(
+def upper_jorg_drued(
     endog_grid: jnp.ndarray,
     policy: jnp.ndarray,
     value: jnp.ndarray,
@@ -25,15 +25,10 @@ def upper_jor_drued(
     For each point on ``m_grid``, we take the pointwise maximum over all segment
     interpolants and an additional "consume-all" candidate.
 
-    This function intentionally does *not*:
-    - sort inputs
-    - detect or insert intersection points
-    - apply FUES jump/scan logic
-
     Returns arrays with the convention that index 0 corresponds to zero wealth:
     ``value_out[0] = expected_value_zero_savings`` and ``endog_out[0] = policy_out[0] = 0``.
-    """
 
+    """
     if value_function_kwargs is None:
         value_function_kwargs = {}
 
@@ -48,12 +43,13 @@ def upper_jor_drued(
     outside = (weight < 0.0) | (weight > 1.0)
     v_interp = jnp.where(outside, -jnp.inf, v_interp)
 
-    # Consume-all candidate.
-    c_all = m_grid
-    v_all = value_function(c_all, *value_function_args, **value_function_kwargs)
+    # Compute closed form values
+    v_all = jax.vmap(_compute_value, in_axes=(0, None, None, None))(
+        m_grid, value_function, value_function_args, value_function_kwargs
+    )
 
     v_stack = jnp.vstack((v_interp, v_all[None, :]))
-    c_stack = jnp.vstack((c_interp, c_all[None, :]))
+    c_stack = jnp.vstack((c_interp, m_grid[None, :]))
 
     best = jnp.argmax(v_stack, axis=0)
     grid_idx = jnp.arange(m_grid.size)
@@ -67,3 +63,15 @@ def upper_jor_drued(
     value_out = jnp.concatenate((jnp.array([expected_value_zero_savings]), value_best))
 
     return endog_out, policy_out, value_out
+
+
+def _compute_value(
+    consumption, value_function, value_function_args, value_function_kwargs
+):
+    """Helper to compute value given consumption and value function."""
+    value = value_function(
+        consumption,
+        *value_function_args,
+        **value_function_kwargs,
+    )
+    return value
diff --git a/tests/test_upper_jor_drued.py b/tests/test_upper_jor_drued.py
index 86363f9..babfa86 100644
--- a/tests/test_upper_jor_drued.py
+++ b/tests/test_upper_jor_drued.py
@@ -1,4 +1,4 @@
-"""Tests for `upper_jor_drued`.
+"""Tests for `upper_jorg_drued`.
 
 We compare against `upenv.fues_jax`, but only on evaluation points that lie on
 reference line segments that are not affected by explicit intersection handling.
@@ -13,7 +13,8 @@
 2) build a boolean mask on the *given* `m_grid` selecting points that fall inside
    non-degenerate reference segments (strictly increasing in `m`)
 3) interpolate the reference onto `m_grid` using only those safe segments
-4) compare `upper_jor_drued` to that reference on the masked points
+4) compare `upper_jorg_drued` to that reference on the masked points
+
 """
 
 from pathlib import Path
@@ -27,12 +28,13 @@
 
 import upper_envelope as upenv
 
-
 TEST_DIR = Path(__file__).parent
 TEST_RESOURCES_DIR = TEST_DIR / "resources"
 
 
-def utility_crra(consumption: jnp.ndarray, choice: int, params: Dict[str, float]) -> jnp.ndarray:
+def utility_crra(
+    consumption: jnp.ndarray, choice: int, params: Dict[str, float]
+) -> jnp.ndarray:
     utility_consumption = (consumption ** (1 - params["rho"]) - 1) / (1 - params["rho"])
     utility = utility_consumption - (1 - choice) * params["delta"]
     return utility
@@ -45,9 +47,10 @@ def interpolate_on_safe_reference_segments(
 ):
     """Interpolate reference (ref_m, ref_y) onto m_grid, ignoring unsafe segments.
 
-    A "safe" segment is any adjacent pair (ref_m[i], ref_m[i+1]) with ref_m[i+1] > ref_m[i].
-    For each x in m_grid, we take the maximum interpolated value over all safe segments
-    covering x. This avoids ambiguity around duplicated ref_m values.
+    A "safe" segment is any adjacent pair (ref_m[i], ref_m[i+1]) with ref_m[i+1] >
+    ref_m[i]. For each x in m_grid, we take the maximum interpolated value over all safe
+    segments covering x. This avoids ambiguity around duplicated ref_m values.
+
     """
 
     dm = ref_m[1:] - ref_m[:-1]
@@ -76,7 +79,7 @@ def setup_model():
 
 
 @pytest.mark.parametrize("period", [2, 4, 9, 10, 18])
-def test_upper_jor_drued_matches_fues_on_safe_segments(period, setup_model):
+def test_upper_jorg_drued_matches_fues_on_safe_segments(period, setup_model):
     value_egm = np.genfromtxt(
         TEST_RESOURCES_DIR / f"upper_envelope_period_tests/val{period}.csv",
         delimiter=",",
@@ -92,7 +95,9 @@ def test_upper_jor_drued_matches_fues_on_safe_segments(period, setup_model):
 
     def value_func(consumption, choice, params):
         # Same convention as existing tests: includes continuation value.
-        return utility_crra(consumption, choice, params) + params["beta"] * value_egm[1, 0]
+        return (
+            utility_crra(consumption, choice, params) + params["beta"] * value_egm[1, 0]
+        )
 
     ref_m, ref_c, ref_v = upenv.fues_jax(
         endog_grid=jnp.asarray(policy_egm[0, 1:]),
@@ -119,7 +124,7 @@ def value_func(consumption, choice, params):
     m_max = float(np.max(policy_egm[0, 1:]))
     m_grid = np.linspace(m_min, m_max, 500)
 
-    endog_out, policy_out, value_out = upenv.upper_jor_drued(
+    endog_out, policy_out, value_out = upenv.upper_jorg_drued(
         endog_grid=jnp.asarray(policy_egm[0, 1:]),
         policy=jnp.asarray(policy_egm[1, 1:]),
         value=jnp.asarray(value_egm[1, 1:]),
@@ -171,7 +176,7 @@ def value_func(consumption, choice, params):
     assert_allclose(value_out[1:][good], v_ref[good], rtol=1e-7, atol=1e-7)
 
     # Policy can differ even when value matches because:
-    # - `upper_jor_drued` includes a consume-all candidate with policy == m_grid
+    # - `upper_jorg_drued` includes a consume-all candidate with policy == m_grid
     # - `fues_jax` does not explicitly expose that candidate as a segment
     # - near kinks, the value envelope can have multiple near-ties with different policies
     # We therefore only assert value agreement here.

From 2c6c3d056e5efe19bd45698e34104bec8fa856d9 Mon Sep 17 00:00:00 2001
From: MaxBlesch <maximilianblesch@web.de>
Date: Tue, 27 Jan 2026 17:42:37 +0100
Subject: [PATCH 04/18] polished readme and names

---
 README.md                                     | 30 ++++++++++++++-----
 ...rued_period2.ipynb => ue_drued_jorg.ipynb} |  2 +-
 src/upper_envelope/__init__.py                |  2 +-
 ...{upper_jorg_drued.py => drued_jorg_jax.py} |  4 +--
 tests/test_upper_jor_drued.py                 |  2 +-
 5 files changed, 28 insertions(+), 12 deletions(-)
 rename docs/tutorials/{upper_jor_drued_period2.ipynb => ue_drued_jorg.ipynb} (99%)
 rename src/upper_envelope/{upper_jorg_drued.py => drued_jorg_jax.py} (94%)

diff --git a/README.md b/README.md
index 56469da..bdfa983 100644
--- a/README.md
+++ b/README.md
@@ -4,15 +4,31 @@
 [![Codecov](https://codecov.io/gh/OpenSourceEconomics/upper-envelope/branch/main/graph/badge.svg)](https://app.codecov.io/gh/OpenSourceEconomics/upper-envelope)
 [![Black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
 
-Extension of the Fast Upper-Envelope Scan (FUES) for solving discrete-continuous dynamic
-programming problems based on Dobrescu & Shanker (2022). Both `jax` and `numba` versions
-are available.
+This package collects several HPC implementations of upper-envelopes used to correct the
+value and policy functions in discrete-continuous dynamic programming problems.
+
+The following implementations are available:
+
+- Extension of the Fast Upper-Envelope Scan (FUES) for solving discrete-continuous
+  dynamic programming problems based on Dobrescu & Shanker (2022). Both `jax` and
+  `numba` versions are available. We provide the original version without endogenous
+  jump detection.
+
+- Line segment interpolation based on Druedahl & Jorgensen (2017). Available in `jax`.
+
+- Also contained for test reasons is the original upper-envelope implementation from
+  Iskhakov et al. (2017). It is not optimized and can not yet be imported when
+  installing the package.
 
 ## References
 
-1. Iskhakov, Jorgensen, Rust, & Schjerning (2017).
+1. Dobrescu & Shanker (2022).
+   [Fast Upper-Envelope Scan for Discrete-Continuous Dynamic Programming](https://dx.doi.org/10.2139/ssrn.4181302).
+
+1. Druedahl & Jørgensen (2017).
+   [A general endogenous grid method for multi-dimensional models with non-convexities and constraints](https://www.sciencedirect.com/science/article/abs/pii/S0165188916301920).
+   *Journal of Economic Dynamics and Control*
+
+1. Iskhakov, Jørgensen, Rust, & Schjerning (2017).
    [The Endogenous Grid Method for Discrete-Continuous Dynamic Choice Models with (or without) Taste Shocks](http://onlinelibrary.wiley.com/doi/10.3982/QE643/full).
    *Quantitative Economics*
-
-1. Loretti I. Dobrescu & Akshay Shanker (2022).
-   [Fast Upper-Envelope Scan for Discrete-Continuous Dynamic Programming](https://dx.doi.org/10.2139/ssrn.4181302).
diff --git a/docs/tutorials/upper_jor_drued_period2.ipynb b/docs/tutorials/ue_drued_jorg.ipynb
similarity index 99%
rename from docs/tutorials/upper_jor_drued_period2.ipynb
rename to docs/tutorials/ue_drued_jorg.ipynb
index 8210038..da84ea3 100644
--- a/docs/tutorials/upper_jor_drued_period2.ipynb
+++ b/docs/tutorials/ue_drued_jorg.ipynb
@@ -131,7 +131,7 @@
    ],
    "source": [
     "# Run new upper envelope\n",
-    "endog_out, policy_out, value_out = upenv.upper_jorg_drued(\n",
+    "endog_out, policy_out, value_out = upenv.drued_jorg_jax(\n",
     "    endog_grid=jnp.asarray(endog_grid_raw),\n",
     "    policy=jnp.asarray(policy_raw),\n",
     "    value=jnp.asarray(value_raw),\n",
diff --git a/src/upper_envelope/__init__.py b/src/upper_envelope/__init__.py
index 602575c..d771db4 100644
--- a/src/upper_envelope/__init__.py
+++ b/src/upper_envelope/__init__.py
@@ -1,3 +1,3 @@
+from upper_envelope.drued_jorg_jax import drued_jorg_jax
 from upper_envelope.fues_jax.fues_jax import fues_jax, fues_jax_unconstrained
 from upper_envelope.fues_numba.fues_numba import fues_numba, fues_numba_unconstrained
-from upper_envelope.upper_jorg_drued import upper_jorg_drued
diff --git a/src/upper_envelope/upper_jorg_drued.py b/src/upper_envelope/drued_jorg_jax.py
similarity index 94%
rename from src/upper_envelope/upper_jorg_drued.py
rename to src/upper_envelope/drued_jorg_jax.py
index 42c1316..6b682c6 100644
--- a/src/upper_envelope/upper_jorg_drued.py
+++ b/src/upper_envelope/drued_jorg_jax.py
@@ -8,7 +8,7 @@
 
 
 @partial(jax.jit, static_argnames=["value_function"])
-def upper_jorg_drued(
+def drued_jorg_jax(
     endog_grid: jnp.ndarray,
     policy: jnp.ndarray,
     value: jnp.ndarray,
@@ -32,7 +32,7 @@ def upper_jorg_drued(
     if value_function_kwargs is None:
         value_function_kwargs = {}
 
-    # Segment interpolation weights for each adjacent pair.
+    # Segment interpolation weights for each adjacent pair. We add 1e-16 to avoid zeros. Should not happen anyway.
     dm = endog_grid[1:] - endog_grid[:-1]  # (N-1,)
     eps = 1e-16
     weight = (m_grid[None, :] - endog_grid[:-1, None]) / (dm[:, None] + eps)  # (N-1, M)
diff --git a/tests/test_upper_jor_drued.py b/tests/test_upper_jor_drued.py
index babfa86..a0420a0 100644
--- a/tests/test_upper_jor_drued.py
+++ b/tests/test_upper_jor_drued.py
@@ -124,7 +124,7 @@ def value_func(consumption, choice, params):
     m_max = float(np.max(policy_egm[0, 1:]))
     m_grid = np.linspace(m_min, m_max, 500)
 
-    endog_out, policy_out, value_out = upenv.upper_jorg_drued(
+    endog_out, policy_out, value_out = upenv.drued_jorg_jax(
         endog_grid=jnp.asarray(policy_egm[0, 1:]),
         policy=jnp.asarray(policy_egm[1, 1:]),
         value=jnp.asarray(value_egm[1, 1:]),

From 0ad35255d67a01fd9aa5e7d6b0257cca934280b3 Mon Sep 17 00:00:00 2001
From: MaxBlesch <maximilianblesch@web.de>
Date: Tue, 27 Jan 2026 17:43:53 +0100
Subject: [PATCH 05/18] Clearer

---
 README.md | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/README.md b/README.md
index bdfa983..c691454 100644
--- a/README.md
+++ b/README.md
@@ -14,7 +14,8 @@ The following implementations are available:
   `numba` versions are available. We provide the original version without endogenous
   jump detection.
 
-- Line segment interpolation based on Druedahl & Jorgensen (2017). Available in `jax`.
+- Line segment interpolation and selection of the upper envelope based on Druedahl &
+  Jorgensen (2017). Available in `jax`.
 
 - Also contained for test reasons is the original upper-envelope implementation from
   Iskhakov et al. (2017). It is not optimized and can not yet be imported when

From 4295b228a69cd50554899bcc2c8952d4a86d72fa Mon Sep 17 00:00:00 2001
From: MaxBlesch <maximilianblesch@web.de>
Date: Tue, 27 Jan 2026 17:44:56 +0100
Subject: [PATCH 06/18] Clearer

---
 README.md | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/README.md b/README.md
index c691454..1416bf7 100644
--- a/README.md
+++ b/README.md
@@ -1,4 +1,9 @@
-# Fast Upper Envelope Scan (FUES)
+# Upper-envelope package
+
+[![License](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
+
+[![PyPI version](https://badge.fury.io/py/upper-envelopes.svg)](https://badge.fury.io/py/upper-envelopes)
+[![Downloads](https://pepy.tech/badge/upper-envelopes)](https://pepy.tech/project/upper-envelopes)
 
 [![Continuous Integration Workflow](https://github.com/OpenSourceEconomics/upper-envelope/actions/workflows/main.yml/badge.svg)](https://github.com/OpenSourceEconomics/upper-envelope/actions/workflows/main.yml)
 [![Codecov](https://codecov.io/gh/OpenSourceEconomics/upper-envelope/branch/main/graph/badge.svg)](https://app.codecov.io/gh/OpenSourceEconomics/upper-envelope)

From 758cdd309afecba5d276715b293e372a31ae33f9 Mon Sep 17 00:00:00 2001
From: MaxBlesch <maximilianblesch@web.de>
Date: Tue, 27 Jan 2026 17:46:57 +0100
Subject: [PATCH 07/18] fix

---
 README.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/README.md b/README.md
index 1416bf7..236d3d4 100644
--- a/README.md
+++ b/README.md
@@ -1,9 +1,9 @@
-# Upper-envelope package
+# Upper Envelope Package
 
 [![License](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
 
-[![PyPI version](https://badge.fury.io/py/upper-envelopes.svg)](https://badge.fury.io/py/upper-envelopes)
-[![Downloads](https://pepy.tech/badge/upper-envelopes)](https://pepy.tech/project/upper-envelopes)
+[![PyPI version](https://badge.fury.io/py/upper-envelope.svg)](https://badge.fury.io/py/upper-envelope)
+[![Downloads](https://pepy.tech/badge/upper-envelope)](https://pepy.tech/project/upper-envelope)
 
 [![Continuous Integration Workflow](https://github.com/OpenSourceEconomics/upper-envelope/actions/workflows/main.yml/badge.svg)](https://github.com/OpenSourceEconomics/upper-envelope/actions/workflows/main.yml)
 [![Codecov](https://codecov.io/gh/OpenSourceEconomics/upper-envelope/branch/main/graph/badge.svg)](https://app.codecov.io/gh/OpenSourceEconomics/upper-envelope)

From ee10c539b89f90889b05f0a5a650c51cc1aa0f23 Mon Sep 17 00:00:00 2001
From: MaxBlesch <maximilianblesch@web.de>
Date: Wed, 28 Jan 2026 00:07:02 +0100
Subject: [PATCH 08/18] TIming and numba done

---
 docs/time_period2_ops.py | 187 +++++++++++++++++++++++++++++++++++++++
 tests/conftest.py        |   5 --
 tests/test_fues_numba.py |  40 ++++++---
 3 files changed, 213 insertions(+), 19 deletions(-)
 create mode 100644 docs/time_period2_ops.py

diff --git a/docs/time_period2_ops.py b/docs/time_period2_ops.py
new file mode 100644
index 0000000..eb3b830
--- /dev/null
+++ b/docs/time_period2_ops.py
@@ -0,0 +1,187 @@
+import argparse
+import os
+import time
+from pathlib import Path
+from typing import Any, Callable, Dict, Tuple
+
+import jax
+import jax.numpy as jnp
+import numpy as np
+from numba import njit
+
+import upper_envelope as upenv
+
+jax.config.update("jax_enable_x64", True)
+
+ROOT_DIR = Path(__file__).resolve().parents[1]
+
+n_runs = 10
+
+
+def utility_crra_jax(
+    consumption: jnp.ndarray, choice: int, params: Dict[str, float]
+) -> jnp.ndarray:
+    utility_consumption = (consumption ** (1 - params["rho"]) - 1) / (1 - params["rho"])
+    utility = utility_consumption - (1 - choice) * params["delta"]
+    return utility
+
+
+def utility_crra_np(
+    consumption: np.ndarray, choice: int, params: Dict[str, float]
+) -> np.ndarray:
+    utility_consumption = (consumption ** (1 - params["rho"]) - 1) / (1 - params["rho"])
+    utility = utility_consumption - (1 - choice) * params["delta"]
+    return utility
+
+
+@njit
+def value_func_numba(
+    consumption, choice, beta, rho, delta, continuation_at_zero_savings
+):
+    utility_consumption = (consumption ** (1 - rho) - 1) / (1 - rho)
+    utility = utility_consumption - (1 - choice) * delta
+    return utility + beta * continuation_at_zero_savings
+
+
+test_resources = ROOT_DIR / "tests" / "resources" / "upper_envelope_period_tests"
+
+period = 2
+value_egm = np.genfromtxt(
+    test_resources / f"val{period}.csv", delimiter=",", dtype=float
+)
+policy_egm = np.genfromtxt(
+    test_resources / f"pol{period}.csv", delimiter=",", dtype=float
+)
+
+params: Dict[str, float] = {"beta": 0.95, "rho": 1.95, "delta": 0.35}
+state_choice = {"lagged_choice": 0, "choice": 0}
+
+
+def value_func_jax(consumption, choice, params):
+    return (
+        utility_crra_jax(consumption, choice, params) + params["beta"] * value_egm[1, 0]
+    )
+
+
+def fuex_jax_partial(endog, pol, val, exp_val_zero):
+    return upenv.fues_jax(
+        endog_grid=jnp.asarray(endog),
+        policy=jnp.asarray(pol),
+        value=jnp.asarray(val),
+        expected_value_zero_savings=exp_val_zero,
+        value_function=value_func_jax,
+        value_function_args=(state_choice["choice"], params),
+    )
+
+
+# Compile time
+start = time.time()
+fuex_jax_partial(
+    endog=policy_egm[0, 1:],
+    pol=policy_egm[1, 1:],
+    val=value_egm[1, 1:],
+    exp_val_zero=value_egm[1, 0],
+)
+end = time.time()
+print(f"JAX FUES compilation time: {end - start:.4f} seconds")
+
+tot_time = 0.0
+for _ in range(n_runs):
+    start = time.time()
+    jax.block_until_ready(
+        fuex_jax_partial(
+            endog=policy_egm[0, 1:],
+            pol=policy_egm[1, 1:],
+            val=value_egm[1, 1:],
+            exp_val_zero=value_egm[1, 0],
+        )
+    )
+    end = time.time()
+    tot_time += end - start
+
+print(f"JAX FUES average time over {n_runs} runs: {tot_time / n_runs:.6f} seconds")
+
+
+def drued_jorg_jax_partial(endog, pol, val, m_grid, exp_val_zero):
+    return upenv.drued_jorg_jax(
+        endog_grid=jnp.asarray(endog),
+        policy=jnp.asarray(pol),
+        value=jnp.asarray(val),
+        m_grid=jnp.asarray(m_grid),
+        expected_value_zero_savings=exp_val_zero,
+        value_function=value_func_jax,
+        value_function_args=(state_choice["choice"], params),
+    )
+
+
+# Compile time
+m_min = float(np.min(policy_egm[0, 1:]))
+m_max = float(np.max(policy_egm[0, 1:]))
+m_grid = np.linspace(m_min, m_max, 500)
+start = time.time()
+drued_jorg_jax_partial(
+    endog=policy_egm[0, 1:],
+    pol=policy_egm[1, 1:],
+    val=value_egm[1, 1:],
+    m_grid=m_grid,
+    exp_val_zero=value_egm[1, 0],
+)
+end = time.time()
+print(f"JAX DRUED-JORG compilation time: {end - start:.4f} seconds")
+tot_time = 0.0
+for _ in range(n_runs):
+    start = time.time()
+    jax.block_until_ready(
+        drued_jorg_jax_partial(
+            endog=policy_egm[0, 1:],
+            pol=policy_egm[1, 1:],
+            val=value_egm[1, 1:],
+            m_grid=m_grid,
+            exp_val_zero=value_egm[1, 0],
+        )
+    )
+    end = time.time()
+    tot_time += end - start
+print(
+    f"JAX DRUED-JORG average time over {n_runs} runs: {tot_time / n_runs:.6f} seconds"
+)
+
+
+# Numba at last
+numba_args = (
+    int(state_choice["choice"]),
+    float(params["beta"]),
+    float(params["rho"]),
+    float(params["delta"]),
+    float(value_egm[1, 0]),
+)
+
+start = time.time()
+upenv.fues_numba(
+    endog_grid=policy_egm[0, 1:],
+    policy=policy_egm[1, 1:],
+    value=value_egm[1, 1:],
+    expected_value_zero_savings=value_egm[1, 0],
+    value_function=value_func_numba,
+    value_function_args=numba_args,
+)
+end = time.time()
+print(f"Numba FUES compilation time: {end - start:.4f} seconds")
+
+tot_time = 0.0
+for _ in range(n_runs):
+    start = time.time()
+    jax.block_until_ready(
+        upenv.fues_numba(
+            endog_grid=policy_egm[0, 1:],
+            policy=policy_egm[1, 1:],
+            value=value_egm[1, 1:],
+            expected_value_zero_savings=value_egm[1, 0],
+            value_function=value_func_numba,
+            value_function_args=numba_args,
+        )
+    )
+    end = time.time()
+    tot_time += end - start
+
+print(f"Numba FUES average time over {n_runs} runs: {tot_time / n_runs:.6f} seconds")
diff --git a/tests/conftest.py b/tests/conftest.py
index b258f2d..50b1661 100644
--- a/tests/conftest.py
+++ b/tests/conftest.py
@@ -20,11 +20,6 @@ def pytest_sessionstart(session):  # noqa: ARG001
     jax.config.update("jax_enable_x64", val=True)
 
 
-def pytest_configure(config):  # noqa: ARG001
-    """Called after command line options have been parsed."""
-    os.environ["NUMBA_DISABLE_JIT"] = "1"
-
-
 def pytest_unconfigure(config):  # noqa: ARG001
     """Called before test process is exited."""
     os.environ.pop("NUMBA_DISABLE_JIT", None)
diff --git a/tests/test_fues_numba.py b/tests/test_fues_numba.py
index b4ab325..fd66c27 100644
--- a/tests/test_fues_numba.py
+++ b/tests/test_fues_numba.py
@@ -4,6 +4,7 @@
 
 import numpy as np
 import pytest
+from numba import njit
 from numpy.testing import assert_array_almost_equal as aaae
 
 import upper_envelope as upenv
@@ -47,6 +48,15 @@ def utility_crra(consumption: np.array, choice: int, params: dict) -> np.array:
     return utility
 
 
+@njit
+def value_func_numba(
+    consumption, choice, beta, rho, delta, continuation_at_zero_savings
+):
+    utility_consumption = (consumption ** (1 - rho) - 1) / (1 - rho)
+    utility = utility_consumption - (1 - choice) * delta
+    return utility + beta * continuation_at_zero_savings
+
+
 @pytest.fixture
 def setup_model():
     max_wealth = 50
@@ -91,18 +101,19 @@ def test_fast_upper_envelope_wrapper(period, setup_model):
 
     params, state_choice_vec, _exog_savings_grid = setup_model
 
-    def value_func(consumption, choice, params):
-        return (
-            utility_crra(consumption, choice, params) + params["beta"] * value_egm[1, 0]
-        )
-
     endog_grid_refined, policy_refined, value_refined = upenv.fues_numba(
         endog_grid=policy_egm[0, 1:],
         policy=policy_egm[1, 1:],
         value=value_egm[1, 1:],
         expected_value_zero_savings=value_egm[1, 0],
-        value_function=value_func,
-        value_function_args=(state_choice_vec["choice"], params),
+        value_function=value_func_numba,
+        value_function_args=(
+            state_choice_vec["choice"],
+            params["beta"],
+            params["rho"],
+            params["delta"],
+            value_egm[1, 0],
+        ),
     )
 
     wealth_max_to_test = np.max(endog_grid_refined[~np.isnan(endog_grid_refined)]) + 100
@@ -193,18 +204,19 @@ def test_fast_upper_envelope_against_fedor(period, setup_model):
         ~np.isnan(_value_fedor).any(axis=0),
     ]
 
-    def value_func(consumption, choice, params):
-        return (
-            utility_crra(consumption, choice, params) + params["beta"] * value_egm[1, 0]
-        )
-
     endog_grid_fues, policy_fues, value_fues = upenv.fues_numba(
         endog_grid=policy_egm[0, 1:],
         policy=policy_egm[1, 1:],
         value=value_egm[1, 1:],
         expected_value_zero_savings=value_egm[1, 0],
-        value_function=value_func,
-        value_function_args=(state_choice_vec["choice"], params),
+        value_function=value_func_numba,
+        value_function_args=(
+            state_choice_vec["choice"],
+            params["beta"],
+            params["rho"],
+            params["delta"],
+            value_egm[1, 0],
+        ),
     )
 
     wealth_max_to_test = np.max(endog_grid_fues[~np.isnan(endog_grid_fues)]) + 100

From 39719a11fc871e17fb3cd9b87fab629c170adf9e Mon Sep 17 00:00:00 2001
From: MaxBlesch <maximilianblesch@web.de>
Date: Wed, 28 Jan 2026 00:22:41 +0100
Subject: [PATCH 09/18] Added numba version and timing

---
 README.md                      |   2 +-
 docs/time_period2_ops.py       | 135 ++++++++++++++++++++++-----------
 src/upper_envelope/__init__.py |   1 +
 3 files changed, 94 insertions(+), 44 deletions(-)

diff --git a/README.md b/README.md
index 236d3d4..cdd12ff 100644
--- a/README.md
+++ b/README.md
@@ -20,7 +20,7 @@ The following implementations are available:
   jump detection.
 
 - Line segment interpolation and selection of the upper envelope based on Druedahl &
-  Jorgensen (2017). Available in `jax`.
+  Jorgensen (2017). Both `jax` and `numba` versions are available.
 
 - Also contained for test reasons is the original upper-envelope implementation from
   Iskhakov et al. (2017). It is not optimized and can not yet be imported when
diff --git a/docs/time_period2_ops.py b/docs/time_period2_ops.py
index eb3b830..d36d312 100644
--- a/docs/time_period2_ops.py
+++ b/docs/time_period2_ops.py
@@ -1,8 +1,7 @@
 import argparse
-import os
 import time
 from pathlib import Path
-from typing import Any, Callable, Dict, Tuple
+from typing import Dict
 
 import jax
 import jax.numpy as jnp
@@ -14,10 +13,15 @@
 jax.config.update("jax_enable_x64", True)
 
 ROOT_DIR = Path(__file__).resolve().parents[1]
-
 n_runs = 10
 
 
+def _parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--runs", type=int, default=10)
+    return parser.parse_args()
+
+
 def utility_crra_jax(
     consumption: jnp.ndarray, choice: int, params: Dict[str, float]
 ) -> jnp.ndarray:
@@ -26,14 +30,6 @@ def utility_crra_jax(
     return utility
 
 
-def utility_crra_np(
-    consumption: np.ndarray, choice: int, params: Dict[str, float]
-) -> np.ndarray:
-    utility_consumption = (consumption ** (1 - params["rho"]) - 1) / (1 - params["rho"])
-    utility = utility_consumption - (1 - choice) * params["delta"]
-    return utility
-
-
 @njit
 def value_func_numba(
     consumption, choice, beta, rho, delta, continuation_at_zero_savings
@@ -63,7 +59,7 @@ def value_func_jax(consumption, choice, params):
     )
 
 
-def fuex_jax_partial(endog, pol, val, exp_val_zero):
+def fues_jax_partial(endog, pol, val, exp_val_zero):
     return upenv.fues_jax(
         endog_grid=jnp.asarray(endog),
         policy=jnp.asarray(pol),
@@ -74,13 +70,17 @@ def fuex_jax_partial(endog, pol, val, exp_val_zero):
     )
 
 
+fues_jax_partial_jit = jax.jit(fues_jax_partial)
+
 # Compile time
 start = time.time()
-fuex_jax_partial(
-    endog=policy_egm[0, 1:],
-    pol=policy_egm[1, 1:],
-    val=value_egm[1, 1:],
-    exp_val_zero=value_egm[1, 0],
+jax.block_until_ready(
+    fues_jax_partial_jit(
+        endog=policy_egm[0, 1:],
+        pol=policy_egm[1, 1:],
+        val=value_egm[1, 1:],
+        exp_val_zero=value_egm[1, 0],
+    )
 )
 end = time.time()
 print(f"JAX FUES compilation time: {end - start:.4f} seconds")
@@ -89,7 +89,7 @@ def fuex_jax_partial(endog, pol, val, exp_val_zero):
 for _ in range(n_runs):
     start = time.time()
     jax.block_until_ready(
-        fuex_jax_partial(
+        fues_jax_partial_jit(
             endog=policy_egm[0, 1:],
             pol=policy_egm[1, 1:],
             val=value_egm[1, 1:],
@@ -104,50 +104,59 @@ def fuex_jax_partial(endog, pol, val, exp_val_zero):
 
 def drued_jorg_jax_partial(endog, pol, val, m_grid, exp_val_zero):
     return upenv.drued_jorg_jax(
-        endog_grid=jnp.asarray(endog),
-        policy=jnp.asarray(pol),
-        value=jnp.asarray(val),
-        m_grid=jnp.asarray(m_grid),
+        endog_grid=endog,
+        policy=pol,
+        value=val,
+        m_grid=m_grid,
         expected_value_zero_savings=exp_val_zero,
         value_function=value_func_jax,
         value_function_args=(state_choice["choice"], params),
     )
 
 
-# Compile time
+drued_jorg_jax_partial_jit = jax.jit(drued_jorg_jax_partial)
+endog_jax = jnp.asarray(policy_egm[0, 1:])
+pol_jax = jnp.asarray(policy_egm[1, 1:])
+val_jax = jnp.asarray(value_egm[1, 1:])
+
 m_min = float(np.min(policy_egm[0, 1:]))
 m_max = float(np.max(policy_egm[0, 1:]))
 m_grid = np.linspace(m_min, m_max, 500)
+m_grid_jax = jnp.asarray(m_grid)
+
+# Compile time
 start = time.time()
-drued_jorg_jax_partial(
-    endog=policy_egm[0, 1:],
-    pol=policy_egm[1, 1:],
-    val=value_egm[1, 1:],
-    m_grid=m_grid,
-    exp_val_zero=value_egm[1, 0],
+jax.block_until_ready(
+    drued_jorg_jax_partial_jit(
+        endog=endog_jax,
+        pol=pol_jax,
+        val=val_jax,
+        m_grid=m_grid_jax,
+        exp_val_zero=value_egm[1, 0],
+    )
 )
 end = time.time()
 print(f"JAX DRUED-JORG compilation time: {end - start:.4f} seconds")
+
 tot_time = 0.0
 for _ in range(n_runs):
     start = time.time()
     jax.block_until_ready(
-        drued_jorg_jax_partial(
-            endog=policy_egm[0, 1:],
-            pol=policy_egm[1, 1:],
-            val=value_egm[1, 1:],
-            m_grid=m_grid,
+        drued_jorg_jax_partial_jit(
+            endog=endog_jax,
+            pol=pol_jax,
+            val=val_jax,
+            m_grid=m_grid_jax,
             exp_val_zero=value_egm[1, 0],
         )
     )
     end = time.time()
     tot_time += end - start
+
 print(
     f"JAX DRUED-JORG average time over {n_runs} runs: {tot_time / n_runs:.6f} seconds"
 )
 
-
-# Numba at last
 numba_args = (
     int(state_choice["choice"]),
     float(params["beta"]),
@@ -156,14 +165,17 @@ def drued_jorg_jax_partial(endog, pol, val, m_grid, exp_val_zero):
     float(value_egm[1, 0]),
 )
 
+# Numba FUES
 start = time.time()
-upenv.fues_numba(
-    endog_grid=policy_egm[0, 1:],
-    policy=policy_egm[1, 1:],
-    value=value_egm[1, 1:],
-    expected_value_zero_savings=value_egm[1, 0],
-    value_function=value_func_numba,
-    value_function_args=numba_args,
+jax.block_until_ready(
+    upenv.fues_numba(
+        endog_grid=policy_egm[0, 1:],
+        policy=policy_egm[1, 1:],
+        value=value_egm[1, 1:],
+        expected_value_zero_savings=value_egm[1, 0],
+        value_function=value_func_numba,
+        value_function_args=numba_args,
+    )
 )
 end = time.time()
 print(f"Numba FUES compilation time: {end - start:.4f} seconds")
@@ -185,3 +197,40 @@ def drued_jorg_jax_partial(endog, pol, val, m_grid, exp_val_zero):
     tot_time += end - start
 
 print(f"Numba FUES average time over {n_runs} runs: {tot_time / n_runs:.6f} seconds")
+
+# Numba DRUED-JORG
+start = time.time()
+jax.block_until_ready(
+    upenv.drued_jorg_numba(
+        endog_grid=policy_egm[0, 1:],
+        policy=policy_egm[1, 1:],
+        value=value_egm[1, 1:],
+        m_grid=m_grid,
+        expected_value_zero_savings=value_egm[1, 0],
+        value_function=value_func_numba,
+        value_function_args=numba_args,
+    )
+)
+end = time.time()
+print(f"Numba DRUED-JORG compilation time: {end - start:.4f} seconds")
+
+tot_time = 0.0
+for _ in range(n_runs):
+    start = time.time()
+    jax.block_until_ready(
+        upenv.drued_jorg_numba(
+            endog_grid=policy_egm[0, 1:],
+            policy=policy_egm[1, 1:],
+            value=value_egm[1, 1:],
+            m_grid=m_grid,
+            expected_value_zero_savings=value_egm[1, 0],
+            value_function=value_func_numba,
+            value_function_args=numba_args,
+        )
+    )
+    end = time.time()
+    tot_time += end - start
+
+print(
+    f"Numba DRUED-JORG average time over {n_runs} runs: {tot_time / n_runs:.6f} seconds"
+)
diff --git a/src/upper_envelope/__init__.py b/src/upper_envelope/__init__.py
index d771db4..f8bcab0 100644
--- a/src/upper_envelope/__init__.py
+++ b/src/upper_envelope/__init__.py
@@ -1,3 +1,4 @@
 from upper_envelope.drued_jorg_jax import drued_jorg_jax
+from upper_envelope.drued_jorg_numba import drued_jorg_numba
 from upper_envelope.fues_jax.fues_jax import fues_jax, fues_jax_unconstrained
 from upper_envelope.fues_numba.fues_numba import fues_numba, fues_numba_unconstrained

From 747a20f14b6be28c5d9b2753cbda4e8c8e6a07bb Mon Sep 17 00:00:00 2001
From: MaxBlesch <maximilianblesch@web.de>
Date: Wed, 28 Jan 2026 00:22:55 +0100
Subject: [PATCH 10/18] Added numba version and timing

---
 src/upper_envelope/drued_jorg_numba.py |  74 +++++++++++++
 tests/test_drued_jorg_numba.py         | 140 +++++++++++++++++++++++++
 2 files changed, 214 insertions(+)
 create mode 100644 src/upper_envelope/drued_jorg_numba.py
 create mode 100644 tests/test_drued_jorg_numba.py

diff --git a/src/upper_envelope/drued_jorg_numba.py b/src/upper_envelope/drued_jorg_numba.py
new file mode 100644
index 0000000..98aced4
--- /dev/null
+++ b/src/upper_envelope/drued_jorg_numba.py
@@ -0,0 +1,74 @@
+from __future__ import annotations
+
+from typing import Callable
+
+import numpy as np
+from numba import njit
+
+
+@njit
+def drued_jorg_numba(
+    endog_grid: np.ndarray,
+    policy: np.ndarray,
+    value: np.ndarray,
+    m_grid: np.ndarray,
+    expected_value_zero_savings: np.ndarray | float,
+    value_function: Callable,
+    value_function_args=(),
+):
+    """Compute a simple 1D upper envelope on a given common grid.
+
+    This mirrors `upper_envelope.drued_jorg_jax.drued_jorg_jax` but is implemented
+    in numba.
+
+    The envelope is computed by linearly interpolating every adjacent pair
+    ``(endog_grid[i], endog_grid[i+1])`` onto the common grid ``m_grid``.
+    For each point on ``m_grid``, we take the pointwise maximum over all segment
+    interpolants and an additional "consume-all" candidate.
+
+    Returns arrays with the convention that index 0 corresponds to zero wealth:
+    ``value_out[0] = expected_value_zero_savings`` and ``endog_out[0] = policy_out[0] = 0``.
+
+    """
+
+    n_m = m_grid.size
+    n_segments = endog_grid.size - 1
+
+    policy_best = np.empty(n_m)
+    value_best = np.empty(n_m)
+
+    eps = 1e-16
+
+    for j in range(n_m):
+        m = m_grid[j]
+
+        # "Consume-all" candidate.
+        best_v = value_function(m, *value_function_args)
+        best_c = m
+
+        for i in range(n_segments):
+            dm = endog_grid[i + 1] - endog_grid[i]
+            w = (m - endog_grid[i]) / (dm + eps)
+
+            if (w >= 0.0) and (w <= 1.0):
+                v_interp = value[i] + w * (value[i + 1] - value[i])
+                if v_interp > best_v:
+                    best_v = v_interp
+                    best_c = policy[i] + w * (policy[i + 1] - policy[i])
+
+        value_best[j] = best_v
+        policy_best[j] = best_c
+
+    endog_out = np.empty(n_m + 1)
+    policy_out = np.empty(n_m + 1)
+    value_out = np.empty(n_m + 1)
+
+    endog_out[0] = 0.0
+    policy_out[0] = 0.0
+    value_out[0] = expected_value_zero_savings
+
+    endog_out[1:] = m_grid
+    policy_out[1:] = policy_best
+    value_out[1:] = value_best
+
+    return endog_out, policy_out, value_out
diff --git a/tests/test_drued_jorg_numba.py b/tests/test_drued_jorg_numba.py
new file mode 100644
index 0000000..4d6afe8
--- /dev/null
+++ b/tests/test_drued_jorg_numba.py
@@ -0,0 +1,140 @@
+"""Tests for `drued_jorg_numba`.
+
+This test mirrors `tests/test_upper_jor_drued.py` but exercises the numba
+implementation.
+
+We compare against `upenv.fues_jax`, but only on evaluation points that lie on
+reference line segments that are not affected by explicit intersection handling.
+
+"""
+
+from pathlib import Path
+from typing import Dict
+
+import jax
+import jax.numpy as jnp
+import numpy as np
+import pytest
+from numba import njit
+from numpy.testing import assert_allclose
+
+import upper_envelope as upenv
+
+TEST_DIR = Path(__file__).parent
+TEST_RESOURCES_DIR = TEST_DIR / "resources"
+
+
+def utility_crra(
+    consumption: jnp.ndarray, choice: int, params: Dict[str, float]
+) -> jnp.ndarray:
+    utility_consumption = (consumption ** (1 - params["rho"]) - 1) / (1 - params["rho"])
+    utility = utility_consumption - (1 - choice) * params["delta"]
+    return utility
+
+
+@njit
+def value_func_numba(
+    consumption, choice, beta, rho, delta, continuation_at_zero_savings
+):
+    utility_consumption = (consumption ** (1 - rho) - 1) / (1 - rho)
+    utility = utility_consumption - (1 - choice) * delta
+    return utility + beta * continuation_at_zero_savings
+
+
+def interpolate_on_safe_reference_segments(
+    ref_m: np.ndarray, ref_y: np.ndarray, m_grid: np.ndarray
+):
+    dm = ref_m[1:] - ref_m[:-1]
+    safe = dm > 0
+
+    weight = (m_grid[None, :] - ref_m[:-1, None]) / (dm[:, None] + 1e-16)
+    y_interp = ref_y[:-1, None] + weight * (ref_y[1:] - ref_y[:-1])[:, None]
+
+    outside = (weight < 0.0) | (weight > 1.0)
+    y_interp[outside | (~safe[:, None])] = -np.inf
+
+    return np.max(y_interp, axis=0)
+
+
+@pytest.fixture(autouse=True)
+def _jax_x64():
+    jax.config.update("jax_enable_x64", True)
+
+
+@pytest.fixture()
+def setup_model():
+    params = {"beta": 0.95, "rho": 1.95, "delta": 0.35}
+    state_choice_vec = {"lagged_choice": 0, "choice": 0}
+    return params, state_choice_vec
+
+
+@pytest.mark.parametrize("period", [2, 4, 9, 10, 18])
+def test_drued_jorg_numba_matches_fues_on_safe_segments(period, setup_model):
+    value_egm = np.genfromtxt(
+        TEST_RESOURCES_DIR / f"upper_envelope_period_tests/val{period}.csv",
+        delimiter=",",
+        dtype=float,
+    )
+    policy_egm = np.genfromtxt(
+        TEST_RESOURCES_DIR / f"upper_envelope_period_tests/pol{period}.csv",
+        delimiter=",",
+        dtype=float,
+    )
+
+    params, state_choice_vec = setup_model
+
+    def value_func_jax(consumption, choice, params):
+        return (
+            utility_crra(consumption, choice, params) + params["beta"] * value_egm[1, 0]
+        )
+
+    ref_m, ref_c, ref_v = upenv.fues_jax(
+        endog_grid=jnp.asarray(policy_egm[0, 1:]),
+        policy=jnp.asarray(policy_egm[1, 1:]),
+        value=jnp.asarray(value_egm[1, 1:]),
+        expected_value_zero_savings=value_egm[1, 0],
+        value_function=value_func_jax,
+        value_function_args=(state_choice_vec["choice"], params),
+        n_constrained_points_to_add=len(policy_egm[0, 1:]) // 10,
+    )
+
+    ref_m = np.asarray(ref_m)
+    ref_v = np.asarray(ref_v)
+    valid = ~np.isnan(ref_m)
+    ref_m = ref_m[valid]
+    ref_v = ref_v[valid]
+
+    m_min = float(np.min(policy_egm[0, 1:]))
+    m_max = float(np.max(policy_egm[0, 1:]))
+    m_grid = np.linspace(m_min, m_max, 500)
+
+    endog_out, policy_out, value_out = upenv.drued_jorg_numba(
+        endog_grid=policy_egm[0, 1:],
+        policy=policy_egm[1, 1:],
+        value=value_egm[1, 1:],
+        m_grid=m_grid,
+        expected_value_zero_savings=value_egm[1, 0],
+        value_function=value_func_numba,
+        value_function_args=(
+            state_choice_vec["choice"],
+            params["beta"],
+            params["rho"],
+            params["delta"],
+            value_egm[1, 0],
+        ),
+    )
+
+    endog_out = np.asarray(endog_out)
+    value_out = np.asarray(value_out)
+
+    assert endog_out[0] == 0.0
+    assert value_out[0] == value_egm[1, 0]
+
+    v_ref = interpolate_on_safe_reference_segments(ref_m, ref_v, m_grid)
+
+    good = np.isfinite(v_ref)
+    assert good.any(), "No safe reference points found; test setup issue."
+
+    good &= np.isfinite(value_out[1:])
+
+    assert_allclose(value_out[1:][good], v_ref[good], rtol=1e-7, atol=1e-7)

From 62333e8257edc72dcd78f3c1ca410e016d611c48 Mon Sep 17 00:00:00 2001
From: MaxBlesch <maximilianblesch@web.de>
Date: Wed, 28 Jan 2026 00:26:22 +0100
Subject: [PATCH 11/18] Added numba version and timing

---
 tests/test_drued_jorg_numba.py                            | 2 +-
 tests/{test_upper_jor_drued.py => test_jorg_drued_jax.py} | 0
 2 files changed, 1 insertion(+), 1 deletion(-)
 rename tests/{test_upper_jor_drued.py => test_jorg_drued_jax.py} (100%)

diff --git a/tests/test_drued_jorg_numba.py b/tests/test_drued_jorg_numba.py
index 4d6afe8..3f9c4df 100644
--- a/tests/test_drued_jorg_numba.py
+++ b/tests/test_drued_jorg_numba.py
@@ -1,6 +1,6 @@
 """Tests for `drued_jorg_numba`.
 
-This test mirrors `tests/test_upper_jor_drued.py` but exercises the numba
+This test mirrors `tests/test_jorg_drued_jax.py` but exercises the numba
 implementation.
 
 We compare against `upenv.fues_jax`, but only on evaluation points that lie on
diff --git a/tests/test_upper_jor_drued.py b/tests/test_jorg_drued_jax.py
similarity index 100%
rename from tests/test_upper_jor_drued.py
rename to tests/test_jorg_drued_jax.py

From 4125d35946c26f4c21b0e9d15efaea80830d6178 Mon Sep 17 00:00:00 2001
From: MaxBlesch <maximilianblesch@web.de>
Date: Wed, 28 Jan 2026 14:36:13 +0100
Subject: [PATCH 12/18] FIx tests

---
 codecov.yml                    |  1 +
 tests/test_drued_jorg_numba.py | 17 +++++++++++++++--
 tests/test_fues_jax.py         |  4 ++++
 tests/test_fues_numba.py       | 14 ++++++++++++--
 4 files changed, 32 insertions(+), 4 deletions(-)

diff --git a/codecov.yml b/codecov.yml
index 78d43ec..731372e 100644
--- a/codecov.yml
+++ b/codecov.yml
@@ -19,3 +19,4 @@ ignore:
   - tests/*
   - tests/**/*
   - .tox/**/*
+  - docs/
diff --git a/tests/test_drued_jorg_numba.py b/tests/test_drued_jorg_numba.py
index 3f9c4df..ea8b422 100644
--- a/tests/test_drued_jorg_numba.py
+++ b/tests/test_drued_jorg_numba.py
@@ -8,6 +8,8 @@
 
 """
 
+import os
+from itertools import product
 from pathlib import Path
 from typing import Dict
 
@@ -68,8 +70,19 @@ def setup_model():
     return params, state_choice_vec
 
 
-@pytest.mark.parametrize("period", [2, 4, 9, 10, 18])
-def test_drued_jorg_numba_matches_fues_on_safe_segments(period, setup_model):
+@pytest.mark.parametrize(
+    "period, numba_enable", product([2, 4, 9, 10, 18], [True, False])
+)
+def test_drued_jorg_numba_matches_fues_on_safe_segments(
+    period, numba_enable, setup_model
+):
+
+    # Turn on/off numba JIT compilation as requested
+    if numba_enable:
+        os.environ["NUMBA_DISABLE_JIT"] = "0"
+    else:
+        os.environ["NUMBA_DISABLE_JIT"] = "1"
+
     value_egm = np.genfromtxt(
         TEST_RESOURCES_DIR / f"upper_envelope_period_tests/val{period}.csv",
         delimiter=",",
diff --git a/tests/test_fues_jax.py b/tests/test_fues_jax.py
index 869fa49..a1f7cc9 100644
--- a/tests/test_fues_jax.py
+++ b/tests/test_fues_jax.py
@@ -1,5 +1,6 @@
 """Test the JAX implementation of the fast upper envelope scan."""
 
+import os
 from pathlib import Path
 from typing import Dict
 
@@ -88,6 +89,8 @@ def setup_model():
 
 @pytest.mark.parametrize("period", [2, 4, 9, 10, 18])
 def test_fast_upper_envelope_wrapper(period, setup_model):
+
+    os.environ["NUMBA_DISABLE_JIT"] = "1"
     value_egm = np.genfromtxt(
         TEST_RESOURCES_DIR / f"upper_envelope_period_tests/val{period}.csv",
         delimiter=",",
@@ -169,6 +172,7 @@ def value_func(consumption, choice, params):
 
 
 def test_fast_upper_envelope_against_numba(setup_model):
+    os.environ["NUMBA_DISABLE_JIT"] = "0"
     policy_egm = np.genfromtxt(
         TEST_RESOURCES_DIR / "upper_envelope_period_tests/pol10.csv", delimiter=","
     )
diff --git a/tests/test_fues_numba.py b/tests/test_fues_numba.py
index fd66c27..37bf81d 100644
--- a/tests/test_fues_numba.py
+++ b/tests/test_fues_numba.py
@@ -1,5 +1,7 @@
 """Test the numba implementation of the fast upper envelope scan."""
 
+import os
+from itertools import product
 from pathlib import Path
 
 import numpy as np
@@ -177,8 +179,16 @@ def test_fast_upper_envelope_against_org_fues(setup_model):
     assert np.all(np.isin(value_expected, value_refined))
 
 
-@pytest.mark.parametrize("period", [2, 4, 10, 9, 18])
-def test_fast_upper_envelope_against_fedor(period, setup_model):
+@pytest.mark.parametrize(
+    "period, numba_enable", product([2, 4, 10, 9, 18], [True, False])
+)
+def test_fast_upper_envelope_against_fedor(period, numba_enable, setup_model):
+    # Turn on/off numba JIT compilation as requested
+    if numba_enable:
+        os.environ["NUMBA_DISABLE_JIT"] = "0"
+    else:
+        os.environ["NUMBA_DISABLE_JIT"] = "1"
+
     value_egm = np.genfromtxt(
         TEST_RESOURCES_DIR / f"upper_envelope_period_tests/val{period}.csv",
         delimiter=",",

From 6e424cd661df008d0175bf149c324a9e8802a01a Mon Sep 17 00:00:00 2001
From: MaxBlesch <maximilianblesch@web.de>
Date: Wed, 28 Jan 2026 15:36:06 +0100
Subject: [PATCH 13/18] More carefully tested

---
 src/upper_envelope/drued_jorg_numba.py |  2 -
 tests/test_drued_jorg_numba.py         | 71 +++++++++++---------------
 tests/test_fues_jax.py                 |  1 -
 tests/test_fues_numba.py               | 37 ++++++++++----
 tests/test_jorg_drued_jax.py           | 66 ++----------------------
 tests/utils/comparison_interp.py       | 41 +++++++++++++++
 6 files changed, 102 insertions(+), 116 deletions(-)
 create mode 100644 tests/utils/comparison_interp.py

diff --git a/src/upper_envelope/drued_jorg_numba.py b/src/upper_envelope/drued_jorg_numba.py
index 98aced4..172d3f9 100644
--- a/src/upper_envelope/drued_jorg_numba.py
+++ b/src/upper_envelope/drued_jorg_numba.py
@@ -1,5 +1,3 @@
-from __future__ import annotations
-
 from typing import Callable
 
 import numpy as np
diff --git a/tests/test_drued_jorg_numba.py b/tests/test_drued_jorg_numba.py
index ea8b422..22b101f 100644
--- a/tests/test_drued_jorg_numba.py
+++ b/tests/test_drued_jorg_numba.py
@@ -8,12 +8,9 @@
 
 """
 
-import os
-from itertools import product
 from pathlib import Path
 from typing import Dict
 
-import jax
 import jax.numpy as jnp
 import numpy as np
 import pytest
@@ -21,6 +18,7 @@
 from numpy.testing import assert_allclose
 
 import upper_envelope as upenv
+from tests.utils.comparison_interp import interpolate_on_safe_reference_segments
 
 TEST_DIR = Path(__file__).parent
 TEST_RESOURCES_DIR = TEST_DIR / "resources"
@@ -43,26 +41,6 @@ def value_func_numba(
     return utility + beta * continuation_at_zero_savings
 
 
-def interpolate_on_safe_reference_segments(
-    ref_m: np.ndarray, ref_y: np.ndarray, m_grid: np.ndarray
-):
-    dm = ref_m[1:] - ref_m[:-1]
-    safe = dm > 0
-
-    weight = (m_grid[None, :] - ref_m[:-1, None]) / (dm[:, None] + 1e-16)
-    y_interp = ref_y[:-1, None] + weight * (ref_y[1:] - ref_y[:-1])[:, None]
-
-    outside = (weight < 0.0) | (weight > 1.0)
-    y_interp[outside | (~safe[:, None])] = -np.inf
-
-    return np.max(y_interp, axis=0)
-
-
-@pytest.fixture(autouse=True)
-def _jax_x64():
-    jax.config.update("jax_enable_x64", True)
-
-
 @pytest.fixture()
 def setup_model():
     params = {"beta": 0.95, "rho": 1.95, "delta": 0.35}
@@ -70,18 +48,8 @@ def setup_model():
     return params, state_choice_vec
 
 
-@pytest.mark.parametrize(
-    "period, numba_enable", product([2, 4, 9, 10, 18], [True, False])
-)
-def test_drued_jorg_numba_matches_fues_on_safe_segments(
-    period, numba_enable, setup_model
-):
-
-    # Turn on/off numba JIT compilation as requested
-    if numba_enable:
-        os.environ["NUMBA_DISABLE_JIT"] = "0"
-    else:
-        os.environ["NUMBA_DISABLE_JIT"] = "1"
+@pytest.mark.parametrize("period", [2, 4, 9, 10, 18])
+def test_drued_jorg_numba_matches_fues_on_safe_segments(period, setup_model):
 
     value_egm = np.genfromtxt(
         TEST_RESOURCES_DIR / f"upper_envelope_period_tests/val{period}.csv",
@@ -113,9 +81,11 @@ def value_func_jax(consumption, choice, params):
 
     ref_m = np.asarray(ref_m)
     ref_v = np.asarray(ref_v)
+    ref_c = np.asarray(ref_c)
     valid = ~np.isnan(ref_m)
     ref_m = ref_m[valid]
     ref_v = ref_v[valid]
+    ref_c = ref_c[valid]
 
     m_min = float(np.min(policy_egm[0, 1:]))
     m_max = float(np.max(policy_egm[0, 1:]))
@@ -137,17 +107,36 @@ def value_func_jax(consumption, choice, params):
         ),
     )
 
+    endog_out_np, policy_out_np, value_out_np = upenv.drued_jorg_numba.py_func(
+        endog_grid=policy_egm[0, 1:],
+        policy=policy_egm[1, 1:],
+        value=value_egm[1, 1:],
+        m_grid=m_grid,
+        expected_value_zero_savings=value_egm[1, 0],
+        value_function=value_func_numba,
+        value_function_args=(
+            state_choice_vec["choice"],
+            params["beta"],
+            params["rho"],
+            params["delta"],
+            value_egm[1, 0],
+        ),
+    )
+
     endog_out = np.asarray(endog_out)
     value_out = np.asarray(value_out)
 
     assert endog_out[0] == 0.0
     assert value_out[0] == value_egm[1, 0]
 
-    v_ref = interpolate_on_safe_reference_segments(ref_m, ref_v, m_grid)
-
-    good = np.isfinite(v_ref)
-    assert good.any(), "No safe reference points found; test setup issue."
+    v_ref_interp, c_ref_interp = interpolate_on_safe_reference_segments(
+        ref_m, ref_v, ref_c, m_grid
+    )
 
-    good &= np.isfinite(value_out[1:])
+    good = ~np.isnan(v_ref_interp)
 
-    assert_allclose(value_out[1:][good], v_ref[good], rtol=1e-7, atol=1e-7)
+    # Now the refs live on the same m_grid as outputs. But we cannot compare entries of m_grid which are
+    # affected by interpolation
+    assert_allclose(value_out[1:][good], v_ref_interp[good], rtol=1e-7, atol=1e-7)
+    assert_allclose(value_out_np[1:][good], v_ref_interp[good], rtol=1e-7, atol=1e-7)
+    assert_allclose(policy_out_np[1:][good], c_ref_interp[good], rtol=1e-7, atol=1e-7)
diff --git a/tests/test_fues_jax.py b/tests/test_fues_jax.py
index a1f7cc9..a04cb3b 100644
--- a/tests/test_fues_jax.py
+++ b/tests/test_fues_jax.py
@@ -90,7 +90,6 @@ def setup_model():
 @pytest.mark.parametrize("period", [2, 4, 9, 10, 18])
 def test_fast_upper_envelope_wrapper(period, setup_model):
 
-    os.environ["NUMBA_DISABLE_JIT"] = "1"
     value_egm = np.genfromtxt(
         TEST_RESOURCES_DIR / f"upper_envelope_period_tests/val{period}.csv",
         delimiter=",",
diff --git a/tests/test_fues_numba.py b/tests/test_fues_numba.py
index 37bf81d..a05fa1f 100644
--- a/tests/test_fues_numba.py
+++ b/tests/test_fues_numba.py
@@ -179,15 +179,8 @@ def test_fast_upper_envelope_against_org_fues(setup_model):
     assert np.all(np.isin(value_expected, value_refined))
 
 
-@pytest.mark.parametrize(
-    "period, numba_enable", product([2, 4, 10, 9, 18], [True, False])
-)
-def test_fast_upper_envelope_against_fedor(period, numba_enable, setup_model):
-    # Turn on/off numba JIT compilation as requested
-    if numba_enable:
-        os.environ["NUMBA_DISABLE_JIT"] = "0"
-    else:
-        os.environ["NUMBA_DISABLE_JIT"] = "1"
+@pytest.mark.parametrize("period", [2, 4, 10, 9, 18])
+def test_fast_upper_envelope_against_fedor(period, setup_model):
 
     value_egm = np.genfromtxt(
         TEST_RESOURCES_DIR / f"upper_envelope_period_tests/val{period}.csv",
@@ -229,6 +222,21 @@ def test_fast_upper_envelope_against_fedor(period, numba_enable, setup_model):
         ),
     )
 
+    endog_grid_fues_np, policy_fues_np, value_fues_np = upenv.fues_numba.py_func(
+        endog_grid=policy_egm[0, 1:],
+        policy=policy_egm[1, 1:],
+        value=value_egm[1, 1:],
+        expected_value_zero_savings=value_egm[1, 0],
+        value_function=value_func_numba,
+        value_function_args=(
+            state_choice_vec["choice"],
+            params["beta"],
+            params["rho"],
+            params["delta"],
+            value_egm[1, 0],
+        ),
+    )
+
     wealth_max_to_test = np.max(endog_grid_fues[~np.isnan(endog_grid_fues)]) + 100
     wealth_grid_to_test = np.linspace(endog_grid_fues[1], wealth_max_to_test, 1000)
 
@@ -245,5 +253,16 @@ def test_fast_upper_envelope_against_fedor(period, numba_enable, setup_model):
         policy_grid=policy_fues,
         value_function_grid=value_fues,
     )
+    policy_interp_np, value_interp_np = (
+        interpolate_single_policy_and_value_on_wealth_grid(
+            wealth_beginning_of_period=wealth_grid_to_test,
+            endog_wealth_grid=endog_grid_fues_np,
+            policy_grid=policy_fues_np,
+            value_function_grid=value_fues_np,
+        )
+    )
+
     aaae(value_interp, value_expec_interp)
     aaae(policy_interp, policy_expec_interp)
+    aaae(value_interp_np, value_expec_interp)
+    aaae(policy_interp_np, policy_expec_interp)
diff --git a/tests/test_jorg_drued_jax.py b/tests/test_jorg_drued_jax.py
index a0420a0..30cffc5 100644
--- a/tests/test_jorg_drued_jax.py
+++ b/tests/test_jorg_drued_jax.py
@@ -20,10 +20,10 @@
 from pathlib import Path
 from typing import Dict
 
-import jax
 import jax.numpy as jnp
 import numpy as np
 import pytest
+from comparison_interp import interpolate_on_safe_reference_segments
 from numpy.testing import assert_allclose
 
 import upper_envelope as upenv
@@ -40,37 +40,6 @@ def utility_crra(
     return utility
 
 
-def interpolate_on_safe_reference_segments(
-    ref_m: np.ndarray,
-    ref_y: np.ndarray,
-    m_grid: np.ndarray,
-):
-    """Interpolate reference (ref_m, ref_y) onto m_grid, ignoring unsafe segments.
-
-    A "safe" segment is any adjacent pair (ref_m[i], ref_m[i+1]) with ref_m[i+1] >
-    ref_m[i]. For each x in m_grid, we take the maximum interpolated value over all safe
-    segments covering x. This avoids ambiguity around duplicated ref_m values.
-
-    """
-
-    dm = ref_m[1:] - ref_m[:-1]
-    safe = dm > 0
-
-    weight = (m_grid[None, :] - ref_m[:-1, None]) / (dm[:, None] + 1e-16)
-    y_interp = ref_y[:-1, None] + weight * (ref_y[1:] - ref_y[:-1])[:, None]
-
-    outside = (weight < 0.0) | (weight > 1.0)
-    y_interp[outside | (~safe[:, None])] = -np.inf
-
-    y_best = np.max(y_interp, axis=0)
-    return y_best
-
-
-@pytest.fixture(autouse=True)
-def _jax_x64():
-    jax.config.update("jax_enable_x64", True)
-
-
 @pytest.fixture()
 def setup_model():
     params = {"beta": 0.95, "rho": 1.95, "delta": 0.35}
@@ -145,38 +114,9 @@ def value_func(consumption, choice, params):
 
     # Build reference interpolants on safe segments only.
     # Use value to select the best reference segment; then take policy from that segment.
-    v_ref = interpolate_on_safe_reference_segments(ref_m, ref_v, m_grid)
-
-    # Recompute the segment-wise interpolation for policy using the same winner segments
-    # implied by the value envelope.
-    dm = ref_m[1:] - ref_m[:-1]
-    safe = dm > 0
-    weight = (m_grid[None, :] - ref_m[:-1, None]) / (dm[:, None] + 1e-16)
-    c_interp = ref_c[:-1, None] + weight * (ref_c[1:] - ref_c[:-1])[:, None]
-
-    outside = (weight < 0.0) | (weight > 1.0)
-    c_interp[outside | (~safe[:, None])] = np.nan
+    v_ref, c_ref = interpolate_on_safe_reference_segments(ref_m, ref_v, ref_c, m_grid)
 
-    # Determine which segment delivers v_ref at each grid point.
-    v_interp = ref_v[:-1, None] + weight * (ref_v[1:] - ref_v[:-1])[:, None]
-    v_interp[outside | (~safe[:, None])] = -np.inf
-    best_seg = np.argmax(v_interp, axis=0)
-    c_ref = c_interp[best_seg, np.arange(m_grid.size)]
-
-    # Mask points where reference is defined.
-    good = np.isfinite(v_ref) & np.isfinite(c_ref)
-    assert good.any(), "No safe reference points found; test setup issue."
-
-    # Our implementation only interpolates adjacent input pairs. The input ordering can
-    # leave gaps where no segment covers m_grid; those points will be -inf and are not
-    # comparable to the reference.
-    good &= np.isfinite(value_out[1:]) & np.isfinite(policy_out[1:])
+    good = ~np.isnan(v_ref)
 
     # Compare on the common grid portion (skip index 0 which is a convention).
     assert_allclose(value_out[1:][good], v_ref[good], rtol=1e-7, atol=1e-7)
-
-    # Policy can differ even when value matches because:
-    # - `upper_jorg_drued` includes a consume-all candidate with policy == m_grid
-    # - `fues_jax` does not explicitly expose that candidate as a segment
-    # - near kinks, the value envelope can have multiple near-ties with different policies
-    # We therefore only assert value agreement here.
diff --git a/tests/utils/comparison_interp.py b/tests/utils/comparison_interp.py
new file mode 100644
index 0000000..8a2f0af
--- /dev/null
+++ b/tests/utils/comparison_interp.py
@@ -0,0 +1,41 @@
+import numpy as np
+
+
+def interpolate_on_safe_reference_segments(
+    ref_m: np.ndarray, ref_v: np.ndarray, ref_c: np.ndarray, m_grid: np.ndarray
+):
+    """To compare Druedahl-Jorgensen upper envelope to one where intersection and
+    borrowing constraint are exactly included, we need to interpolate only on line-
+    segments without consume all only on the left side and neighboring an intersection
+    point."""
+    dm = ref_m[1:] - ref_m[:-1]
+    # Intersect idxs
+    inter_idxs = np.where(dm == 0)[0]
+    upper_forbidden_idxs = np.append(inter_idxs, inter_idxs + 1)
+
+    # Get upper idxs of interpolation
+    idxs_upper_interp = np.searchsorted(ref_m, m_grid, side="left")
+    idxs_lower_interp = idxs_upper_interp - 1
+
+    # Mark all idxs_interp which are in upper_forbidden_idxs as unsafe
+    unsafe = np.isin(idxs_upper_interp, upper_forbidden_idxs)
+
+    # Also if lower idx is consume all mark as unsafe
+    unsafe |= ((ref_m[idxs_lower_interp] - ref_c[idxs_lower_interp]) == 0) & (
+        (ref_m[idxs_upper_interp] - ref_c[idxs_upper_interp]) != 0
+    )
+
+    # Now linear interpolate for all and mark after unsafe as nan
+    # Start with simple linear interpolation for ref_v
+    weight = (m_grid - ref_m[idxs_lower_interp]) / (
+        ref_m[idxs_upper_interp] - ref_m[idxs_lower_interp]
+    )
+    v_interp = ref_v[idxs_lower_interp] + weight * (
+        ref_v[idxs_upper_interp] - ref_v[idxs_lower_interp]
+    )
+    v_interp[unsafe] = np.nan
+    c_interp = ref_c[idxs_lower_interp] + weight * (
+        ref_c[idxs_upper_interp] - ref_c[idxs_lower_interp]
+    )
+    c_interp[unsafe] = np.nan
+    return v_interp, c_interp

From a6013bcc21fc9d841a78c2055d0ab8194f65ac6d Mon Sep 17 00:00:00 2001
From: MaxBlesch <maximilianblesch@web.de>
Date: Wed, 28 Jan 2026 15:36:28 +0100
Subject: [PATCH 14/18] More carefully tested

---
 tests/test_jorg_drued_jax.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/tests/test_jorg_drued_jax.py b/tests/test_jorg_drued_jax.py
index 30cffc5..68cf5ea 100644
--- a/tests/test_jorg_drued_jax.py
+++ b/tests/test_jorg_drued_jax.py
@@ -120,3 +120,4 @@ def value_func(consumption, choice, params):
 
     # Compare on the common grid portion (skip index 0 which is a convention).
     assert_allclose(value_out[1:][good], v_ref[good], rtol=1e-7, atol=1e-7)
+    assert_allclose(policy_out[1:][good], c_ref[good], rtol=1e-7, atol=1e-7)

From 5d84dfdedecd3a549349f484f74d628ed0a5c3a1 Mon Sep 17 00:00:00 2001
From: MaxBlesch <maximilianblesch@web.de>
Date: Wed, 28 Jan 2026 15:51:28 +0100
Subject: [PATCH 15/18] Tests right now

---
 tests/test_fues_numba.py | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/tests/test_fues_numba.py b/tests/test_fues_numba.py
index a05fa1f..6d08f91 100644
--- a/tests/test_fues_numba.py
+++ b/tests/test_fues_numba.py
@@ -160,6 +160,13 @@ def test_fast_upper_envelope_against_org_fues(setup_model):
         value=value_egm[1],
         policy=policy_egm[1],
     )
+    endog_grid_refined_np, value_refined_np, policy_refined_np = (
+        upenv.fues_numba_unconstrained.py_func(
+            endog_grid=policy_egm[0],
+            value=value_egm[1],
+            policy=policy_egm[1],
+        )
+    )
 
     endog_grid_org, policy_org, value_org = fast_upper_envelope_wrapper_org(
         endog_grid=policy_egm[0],
@@ -177,6 +184,9 @@ def test_fast_upper_envelope_against_org_fues(setup_model):
     assert np.all(np.isin(endog_grid_expected, endog_grid_refined))
     assert np.all(np.isin(policy_expected, policy_refined))
     assert np.all(np.isin(value_expected, value_refined))
+    np.all(np.isin(endog_grid_expected, endog_grid_refined_np))
+    np.all(np.isin(policy_expected, policy_refined_np))
+    np.all(np.isin(value_expected, value_refined_np))
 
 
 @pytest.mark.parametrize("period", [2, 4, 10, 9, 18])

From 445f224ec142489f0c7579d42b22f49d4ad77f2e Mon Sep 17 00:00:00 2001
From: MaxBlesch <maximilianblesch@web.de>
Date: Wed, 28 Jan 2026 15:56:46 +0100
Subject: [PATCH 16/18] No jit test

---
 tests/test_fues_numba.py | 15 +++------------
 1 file changed, 3 insertions(+), 12 deletions(-)

diff --git a/tests/test_fues_numba.py b/tests/test_fues_numba.py
index 6d08f91..bea2c5d 100644
--- a/tests/test_fues_numba.py
+++ b/tests/test_fues_numba.py
@@ -154,20 +154,14 @@ def test_fast_upper_envelope_against_org_fues(setup_model):
     )
 
     _params, state_choice_vec, exog_savings_grid = setup_model
+    # Disable numba jit
+    os.environ["NUMBA_DISABLE_JIT"] = "1"
 
     endog_grid_refined, value_refined, policy_refined = upenv.fues_numba_unconstrained(
         endog_grid=policy_egm[0],
         value=value_egm[1],
         policy=policy_egm[1],
     )
-    endog_grid_refined_np, value_refined_np, policy_refined_np = (
-        upenv.fues_numba_unconstrained.py_func(
-            endog_grid=policy_egm[0],
-            value=value_egm[1],
-            policy=policy_egm[1],
-        )
-    )
-
     endog_grid_org, policy_org, value_org = fast_upper_envelope_wrapper_org(
         endog_grid=policy_egm[0],
         policy=policy_egm[1],
@@ -184,14 +178,11 @@ def test_fast_upper_envelope_against_org_fues(setup_model):
     assert np.all(np.isin(endog_grid_expected, endog_grid_refined))
     assert np.all(np.isin(policy_expected, policy_refined))
     assert np.all(np.isin(value_expected, value_refined))
-    np.all(np.isin(endog_grid_expected, endog_grid_refined_np))
-    np.all(np.isin(policy_expected, policy_refined_np))
-    np.all(np.isin(value_expected, value_refined_np))
+    os.environ.pop("NUMBA_DISABLE_JIT", None)
 
 
 @pytest.mark.parametrize("period", [2, 4, 10, 9, 18])
 def test_fast_upper_envelope_against_fedor(period, setup_model):
-
     value_egm = np.genfromtxt(
         TEST_RESOURCES_DIR / f"upper_envelope_period_tests/val{period}.csv",
         delimiter=",",

From ad5f73c1942a1b03a9c6b504a9132ae718f06137 Mon Sep 17 00:00:00 2001
From: MaxBlesch <maximilianblesch@web.de>
Date: Wed, 28 Jan 2026 16:10:28 +0100
Subject: [PATCH 17/18] Not jit back in

---
 tests/conftest.py        | 5 +++++
 tests/test_fues_numba.py | 3 ---
 2 files changed, 5 insertions(+), 3 deletions(-)

diff --git a/tests/conftest.py b/tests/conftest.py
index 50b1661..b258f2d 100644
--- a/tests/conftest.py
+++ b/tests/conftest.py
@@ -20,6 +20,11 @@ def pytest_sessionstart(session):  # noqa: ARG001
     jax.config.update("jax_enable_x64", val=True)
 
 
+def pytest_configure(config):  # noqa: ARG001
+    """Called after command line options have been parsed."""
+    os.environ["NUMBA_DISABLE_JIT"] = "1"
+
+
 def pytest_unconfigure(config):  # noqa: ARG001
     """Called before test process is exited."""
     os.environ.pop("NUMBA_DISABLE_JIT", None)
diff --git a/tests/test_fues_numba.py b/tests/test_fues_numba.py
index bea2c5d..29262ed 100644
--- a/tests/test_fues_numba.py
+++ b/tests/test_fues_numba.py
@@ -154,8 +154,6 @@ def test_fast_upper_envelope_against_org_fues(setup_model):
     )
 
     _params, state_choice_vec, exog_savings_grid = setup_model
-    # Disable numba jit
-    os.environ["NUMBA_DISABLE_JIT"] = "1"
 
     endog_grid_refined, value_refined, policy_refined = upenv.fues_numba_unconstrained(
         endog_grid=policy_egm[0],
@@ -178,7 +176,6 @@ def test_fast_upper_envelope_against_org_fues(setup_model):
     assert np.all(np.isin(endog_grid_expected, endog_grid_refined))
     assert np.all(np.isin(policy_expected, policy_refined))
     assert np.all(np.isin(value_expected, value_refined))
-    os.environ.pop("NUMBA_DISABLE_JIT", None)
 
 
 @pytest.mark.parametrize("period", [2, 4, 10, 9, 18])

From 96f86bcdd570cbf4bc17816387ad76f8fe2d4ce9 Mon Sep 17 00:00:00 2001
From: MaxBlesch <maximilianblesch@web.de>
Date: Wed, 28 Jan 2026 16:18:53 +0100
Subject: [PATCH 18/18] Back to bus

---
 tests/test_drued_jorg_numba.py | 19 +------------------
 tests/test_fues_numba.py       | 25 -------------------------
 2 files changed, 1 insertion(+), 43 deletions(-)

diff --git a/tests/test_drued_jorg_numba.py b/tests/test_drued_jorg_numba.py
index 22b101f..2adef93 100644
--- a/tests/test_drued_jorg_numba.py
+++ b/tests/test_drued_jorg_numba.py
@@ -107,22 +107,6 @@ def value_func_jax(consumption, choice, params):
         ),
     )
 
-    endog_out_np, policy_out_np, value_out_np = upenv.drued_jorg_numba.py_func(
-        endog_grid=policy_egm[0, 1:],
-        policy=policy_egm[1, 1:],
-        value=value_egm[1, 1:],
-        m_grid=m_grid,
-        expected_value_zero_savings=value_egm[1, 0],
-        value_function=value_func_numba,
-        value_function_args=(
-            state_choice_vec["choice"],
-            params["beta"],
-            params["rho"],
-            params["delta"],
-            value_egm[1, 0],
-        ),
-    )
-
     endog_out = np.asarray(endog_out)
     value_out = np.asarray(value_out)
 
@@ -138,5 +122,4 @@ def value_func_jax(consumption, choice, params):
     # Now the refs live on the same m_grid as outputs. But we cannot compare entries of m_grid which are
     # affected by interpolation
     assert_allclose(value_out[1:][good], v_ref_interp[good], rtol=1e-7, atol=1e-7)
-    assert_allclose(value_out_np[1:][good], v_ref_interp[good], rtol=1e-7, atol=1e-7)
-    assert_allclose(policy_out_np[1:][good], c_ref_interp[good], rtol=1e-7, atol=1e-7)
+    assert_allclose(policy_out[1:][good], c_ref_interp[good], rtol=1e-7, atol=1e-7)
diff --git a/tests/test_fues_numba.py b/tests/test_fues_numba.py
index 29262ed..f35584f 100644
--- a/tests/test_fues_numba.py
+++ b/tests/test_fues_numba.py
@@ -220,21 +220,6 @@ def test_fast_upper_envelope_against_fedor(period, setup_model):
         ),
     )
 
-    endog_grid_fues_np, policy_fues_np, value_fues_np = upenv.fues_numba.py_func(
-        endog_grid=policy_egm[0, 1:],
-        policy=policy_egm[1, 1:],
-        value=value_egm[1, 1:],
-        expected_value_zero_savings=value_egm[1, 0],
-        value_function=value_func_numba,
-        value_function_args=(
-            state_choice_vec["choice"],
-            params["beta"],
-            params["rho"],
-            params["delta"],
-            value_egm[1, 0],
-        ),
-    )
-
     wealth_max_to_test = np.max(endog_grid_fues[~np.isnan(endog_grid_fues)]) + 100
     wealth_grid_to_test = np.linspace(endog_grid_fues[1], wealth_max_to_test, 1000)
 
@@ -251,16 +236,6 @@ def test_fast_upper_envelope_against_fedor(period, setup_model):
         policy_grid=policy_fues,
         value_function_grid=value_fues,
     )
-    policy_interp_np, value_interp_np = (
-        interpolate_single_policy_and_value_on_wealth_grid(
-            wealth_beginning_of_period=wealth_grid_to_test,
-            endog_wealth_grid=endog_grid_fues_np,
-            policy_grid=policy_fues_np,
-            value_function_grid=value_fues_np,
-        )
-    )
 
     aaae(value_interp, value_expec_interp)
     aaae(policy_interp, policy_expec_interp)
-    aaae(value_interp_np, value_expec_interp)
-    aaae(policy_interp_np, policy_expec_interp)