diff --git a/.gitattributes b/.gitattributes
new file mode 100644
index 0000000000..f9c9d8f285
--- /dev/null
+++ b/.gitattributes
@@ -0,0 +1,2 @@
+
+*.ipynb	diff=jupyternotebook
diff --git a/.github/workflows/python.yml b/.github/workflows/python.yml
index 5bee5b8f9c..92c99f0a9d 100644
--- a/.github/workflows/python.yml
+++ b/.github/workflows/python.yml
@@ -47,10 +47,10 @@ jobs:
       - uses: actions/setup-python@v5
         with:
           python-version: "3.9"
-      - name: Install Python dependencies
-        run: pip install -r requirements.txt
       - name: Install PyTorch
         run: pip install torch==2.5.1
+      - name: Install Python dependencies
+        run: pip install -r requirements.txt
       - run: pip install -v .
       - run: pytest --junitxml=pytest.xml python/tests
       - name: Publish Test Results
diff --git a/include/neml2/models/LinearInterpolation.h b/include/neml2/models/LinearInterpolation.h
index 015973b18a..c522e48b11 100644
--- a/include/neml2/models/LinearInterpolation.h
+++ b/include/neml2/models/LinearInterpolation.h
@@ -95,17 +95,6 @@ class LinearInterpolation : public Interpolation<T>
    */
   template <typename T2>
   T2 mask(const T2 & in, const torch::Tensor & m) const;
-
-  /// Batch shape of the interpolant, excluding the last dimension which is the interpolation axis
-  const TensorShape _interp_batch_sizes;
-  /// Starting abscissa of each interval
-  const Scalar & _X0;
-  /// Ending abscissa of each interval
-  const Scalar & _X1;
-  /// Starting ordinate of each interval
-  const T & _Y0;
-  /// Slope of each interval
-  const T & _slope;
 };
 
 template <typename T>
diff --git a/include/neml2/models/solid_mechanics/KocksMeckingIntercept.h b/include/neml2/models/solid_mechanics/KocksMeckingIntercept.h
new file mode 100644
index 0000000000..63465b84c5
--- /dev/null
+++ b/include/neml2/models/solid_mechanics/KocksMeckingIntercept.h
@@ -0,0 +1,53 @@
+// Copyright 2024, UChicago Argonne, LLC
+// All Rights Reserved
+// Software Name: NEML2 -- the New Engineering material Model Library, version 2
+// By: Argonne National Laboratory
+// OPEN SOURCE LICENSE (MIT)
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+#pragma once
+
+#include "neml2/models/NonlinearParameter.h"
+
+namespace neml2
+{
+/**
+ * @brief A scalar-valued parameter defined by (C-B) / A
+ */
+class KocksMeckingIntercept : public NonlinearParameter<Scalar>
+{
+public:
+  static OptionSet expected_options();
+
+  KocksMeckingIntercept(const OptionSet & options);
+
+protected:
+  void set_value(bool out, bool dout_din, bool d2out_din2) override;
+
+  /// KM A
+  const Scalar & _A;
+
+  /// KM B
+  const Scalar & _B;
+
+  /// KM C
+  const Scalar & _C;
+};
+}
\ No newline at end of file
diff --git a/include/neml2/tensors/LabeledMatrix.h b/include/neml2/tensors/LabeledMatrix.h
index a20d28ff3d..dee30b588d 100644
--- a/include/neml2/tensors/LabeledMatrix.h
+++ b/include/neml2/tensors/LabeledMatrix.h
@@ -44,10 +44,6 @@ class LabeledMatrix : public LabeledTensor<LabeledMatrix, 2>
                                 const LabeledAxis & axis,
                                 const torch::TensorOptions & options = default_tensor_options());
 
-  /// Fill another matrix into this matrix.
-  /// The item set of the other matrix must be a subset of this matrix's item set.
-  void fill(const LabeledMatrix & other, bool recursive = true);
-
   /// Chain rule product of two derivatives
   LabeledMatrix chain(const LabeledMatrix & other) const;
 };
diff --git a/include/neml2/tensors/LabeledTensor.h b/include/neml2/tensors/LabeledTensor.h
index e717928775..8581ae9d53 100644
--- a/include/neml2/tensors/LabeledTensor.h
+++ b/include/neml2/tensors/LabeledTensor.h
@@ -160,6 +160,15 @@ class LabeledTensor
   /// Get a specific labeled axis
   const LabeledAxis & axis(Size i = 0) const { return *_axes[i]; }
 
+  /**
+   * @brief Fill with another LabeledTensor that matches this one on all but one axis
+   *
+   * @param Derived The LabeledTensor to fill from
+   * @param Size The common axis, default 0
+   * @param bool If true, fill recursively down subaxes
+   */
+  void fill(const Derived & other, Size odim = 0, bool recursive = true);
+
 protected:
   /// The tensor
   Tensor _tensor;
diff --git a/include/neml2/tensors/LabeledVector.h b/include/neml2/tensors/LabeledVector.h
index b79099fe30..df4b41663e 100644
--- a/include/neml2/tensors/LabeledVector.h
+++ b/include/neml2/tensors/LabeledVector.h
@@ -41,10 +41,6 @@ class LabeledVector : public LabeledTensor<LabeledVector, 1>
 
   /// Slice the logically 1D tensor by a single sub-axis
   LabeledVector slice(const std::string & name) const;
-
-  /// Fill (override) another vector into this vector.
-  /// The item set of the other vector must be a subset of this vector's item set.
-  void fill(const LabeledVector & other, bool recursive = true);
 };
 
 namespace utils
diff --git a/python/CMakeLists.txt b/python/CMakeLists.txt
index 69830feaee..8ee1adc05e 100644
--- a/python/CMakeLists.txt
+++ b/python/CMakeLists.txt
@@ -43,6 +43,11 @@ install(FILES
   DESTINATION .
 )
 
+# pyzag subpackage
+configure_file(neml2/pyzag/__init__.py ${NEML2_BINARY_DIR}/python/neml2/pyzag/__init__.py COPYONLY)
+configure_file(neml2/pyzag/interface.py ${NEML2_BINARY_DIR}/python/neml2/pyzag/interface.py COPYONLY)
+install(DIRECTORY neml2/pyzag DESTINATION .)
+
 # Tests
 if(NEML2_TESTS)
   add_subdirectory(tests)
diff --git a/python/examples/README.md b/python/examples/README.md
new file mode 100644
index 0000000000..b2101f9079
--- /dev/null
+++ b/python/examples/README.md
@@ -0,0 +1,21 @@
+# Jupyter notebook examples of the NEML2/pyzag interface
+
+## Setup
+
+To run these notebooks install the packages given in `python/examples/requirements.txt`
+
+```
+pip install -r python/examples/requirements.txt
+```
+
+after building the NEML2 python package and installing the main set of python requirements in `requirements.txt` in the root directory.
+
+## Version control for Jupyter notebook examples
+
+We track these notebooks with the `nbdime` python tool, installed as part of the package requirements.  The first time you install this for use in a new repository you need to run
+
+```
+git-nbdiffdriver config --enable
+```
+
+to enable the hooks.
\ No newline at end of file
diff --git a/python/examples/demo_model.i b/python/examples/demo_model.i
new file mode 100644
index 0000000000..9d486be135
--- /dev/null
+++ b/python/examples/demo_model.i
@@ -0,0 +1,210 @@
+[Tensors]
+  [T_controls]
+    type = Scalar
+    values = '300 347.36842105 394.73684211 442.10526316 489.47368421 536.84210526 584.21052632 631.57894737 678.94736842 726.31578947 773.68421053 821.05263158 868.42105263 915.78947368 963.15789474 1010.52631579 1057.89473684 1105.26315789 1152.63157895 1200'
+    batch_shape = '(20)'
+  []
+  [mu_values]
+    type = Scalar
+    values = '76670.48346056 75465.18012589 74314.80514263 73374.72880675 72651.54680595 71928.36480514 71120.75130575 70035.97830454 68951.20530333 67842.26597027 66399.97991161 65315.20691041 63884.85335476 62763.98151868 61373.80474086 59927.44073925 58481.07673765 56544.43551627 54599.93973483 52791.98473282'
+    batch_shape = '(20)'
+  []
+  [T_train]
+    type = Scalar
+    values = '300.0 600.0 900.0 1200.0'
+    batch_shape = '(4)'
+  []
+  [R_values]
+    type = Scalar
+    values = '300.0 200.0 100.0 50.0'
+    batch_shape = '(4)'
+  []
+  [d_values]
+    type = Scalar
+    values = '30.0 20.0 15.0 12.0'
+    batch_shape = '(4)'
+  []
+[]
+
+[Models]
+  [A]
+    type = ScalarConstantParameter
+    value = -8.679
+  []
+  [B]
+    type = ScalarConstantParameter
+    value = -0.744
+  []
+  [C]
+    type = ScalarConstantParameter
+    value = -5.41
+  []
+  [g0]
+    type = KocksMeckingIntercept
+    A = 'A'
+    B = 'B'
+    C = 'C'
+  []
+  [mandel_stress]
+    type = IsotropicMandelStress
+  []
+  [vonmises]
+    type = SR2Invariant
+    invariant_type = 'VONMISES'
+    tensor = 'state/internal/M'
+    invariant = 'state/internal/s'
+  []
+  [isoharden]
+    type = VoceIsotropicHardening
+    saturated_hardening = 'R'
+    saturation_rate = 'd'
+  []
+  [mu]
+    type = ScalarLinearInterpolation
+    argument = 'forces/T'
+    abscissa = 'T_controls'
+    ordinate = 'mu_values'
+  []
+  [R]
+    type = ScalarLinearInterpolation
+    argument = 'forces/T'
+    abscissa = 'T_train'
+    ordinate = 'R_values'
+  []
+  [d]
+    type = ScalarLinearInterpolation
+    argument = 'forces/T'
+    abscissa = 'T_train'
+    ordinate = 'd_values'
+  []
+  [ys]
+    type = KocksMeckingYieldStress
+    shear_modulus = 'mu'
+    C = 'C'
+  []
+  [yield]
+    type = YieldFunction
+    yield_stress = 'ys'
+    isotropic_hardening = 'state/internal/k'
+  []
+  [yield_zero]
+    type = YieldFunction
+    yield_stress = 0
+    isotropic_hardening = 'state/internal/k'
+    yield_function = 'state/internal/fp_alt'
+  []
+  [flow]
+    type = ComposedModel
+    models = 'vonmises yield'
+    automatic_nonlinear_parameter = false
+  []
+  [normality]
+    type = Normality
+    model = 'flow'
+    function = 'state/internal/fp'
+    from = 'state/internal/M state/internal/k'
+    to = 'state/internal/NM state/internal/Nk'
+  []
+  [ri_flowrate]
+    type = RateIndependentPlasticFlowConstraint
+    flow_rate = 'state/internal/gamma_rate_ri'
+  []
+  [km_sensitivity]
+    type = KocksMeckingRateSensitivity
+    A = 'A'
+    shear_modulus = 'mu'
+    k = 1.38064e-20
+    b = 2.474e-7
+  []
+  [km_viscosity]
+    type = KocksMeckingFlowViscosity
+    A = 'A'
+    B = 'B'
+    shear_modulus = 'mu'
+    k = 1.38064e-20
+    b = 2.474e-7
+    eps0 = 1e10
+  []
+  [rd_flowrate]
+    type = PerzynaPlasticFlowRate
+    reference_stress = 'km_viscosity'
+    exponent = 'km_sensitivity'
+    yield_function = 'state/internal/fp_alt'
+    flow_rate = 'state/internal/gamma_rate_rd'
+  []
+  [effective_strain_rate]
+    type = SR2Invariant
+    invariant_type = 'EFFECTIVE_STRAIN'
+    tensor = 'state/E_rate'
+    invariant = 'forces/effective_strain_rate'
+  []
+  [g]
+    type = KocksMeckingActivationEnergy
+    shear_modulus = 'mu'
+    k = 1.38064e-20
+    b = 2.474e-7
+    eps0 = 1e10
+  []
+  [flowrate]
+    type = KocksMeckingFlowSwitch
+    g0 = 'g0'
+    rate_independent_flow_rate = 'state/internal/gamma_rate_ri' 
+    rate_dependent_flow_rate = 'state/internal/gamma_rate_rd'
+    sharpness = 100.0
+  []
+  [Eprate]
+    type = AssociativePlasticFlow
+  []
+  [eprate]
+    type = AssociativeIsotropicPlasticHardening
+  []
+  [Erate]
+    type = SR2VariableRate
+    variable = 'state/E'
+    rate = 'state/E_rate'
+  []
+  [Eerate]
+    type = SR2LinearCombination
+    from_var = 'state/E_rate state/internal/Ep_rate'
+    to_var = 'state/internal/Ee_rate'
+    coefficients = '1 -1'
+  []
+  [elasticity]
+    type = LinearIsotropicElasticity
+    youngs_modulus = 1e5
+    poisson_ratio = 0.3
+    rate_form = true
+  []
+  [integrate_stress]
+    type = SR2BackwardEulerTimeIntegration
+    variable = 'state/S'
+  []
+  [integrate_ep]
+    type = ScalarBackwardEulerTimeIntegration
+    variable = 'state/internal/ep'
+  []
+  [mixed]
+    type = MixedControlSetup
+  []
+  [mixed_old]
+    type = MixedControlSetup
+    control = "old_forces/control"
+    mixed_state = "old_state/mixed_state"
+    fixed_values = "old_forces/fixed_values"
+    cauchy_stress = "old_state/S"
+    strain = "old_state/E"
+  []
+  [rename]
+    type = CopySR2
+    from = "residual/S"
+    to = "residual/mixed_state"
+  []
+  [implicit_rate]
+    type = ComposedModel
+    models = "isoharden elasticity g
+              mandel_stress vonmises
+              yield yield_zero normality eprate Eprate Erate Eerate
+              ri_flowrate rd_flowrate flowrate integrate_ep integrate_stress effective_strain_rate 
+              mixed mixed_old rename"
+  []
+[]
diff --git a/python/examples/deterministic.ipynb b/python/examples/deterministic.ipynb
new file mode 100644
index 0000000000..c98943a468
--- /dev/null
+++ b/python/examples/deterministic.ipynb
@@ -0,0 +1,580 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Deterministic material model learning\n",
+    "\n",
+    "This is a complete example of using the pyzag bindings to NEML2 to calibrated a material model against experimental data.  `demo_model.i` defines the constitutive model, which is a structural material model describing the evolution of strain and stress in the material under mechanical load.  The particular demonstration is a fairly complex model where the material responds differently as a function of both temperature and strain rate.  The model also reduces the full 3D form of the constitutive model to 1D, where the final model is driven by an axial strain and all the other stress components are zero.\n",
+    "\n",
+    "In this example we:\n",
+    "1. Load the model in from file and wrap it for use in pyzag\n",
+    "2. Setup a grid of \"experimental\" conditions spanning several strain rates and temperatures\n",
+    "3. Replace the original model parameters with samples from a narrow normal distrubtion, centered on the orignial model mean, and run the model over the experimental conditions.  This then becomes our synthetic input data.\n",
+    "4. Replace the original model parameters with random initial guesses (taken from a very wide normal distribution around the true values).\n",
+    "5. Setup the model for training with gradient-descent methods by scaling the model parameters and resulting gradient values.\n",
+    "6. Train the model against the synthetic experimental data.\n",
+    "7. Plot the results and print the trained parameter values, to see how close we can come to the true values.\n",
+    "\n",
+    "The accuracy of the final model and the trained parameter values is heavily dependent on the choice of the normal distributions for the synthetic data and the initial parameter guesses.  For narrow distributions for both the model can exactly recover the original parameter values.  For wider distributions the trained model will not be exact, but will still accurately capture the mean of the synthetic tests."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import torch\n",
+    "import torch.distributions as dist\n",
+    "import neml2\n",
+    "from pyzag import nonlinear, reparametrization, chunktime\n",
+    "import matplotlib.pyplot as plt\n",
+    "import tqdm"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Setup parameters related to *how* we train the model\n",
+    "\n",
+    "Choose which device to use.  The `nchunk` parameter controls the time integration in `pyzag`.  `pyzag` can vectorize the time integration itself, providing a larger bandwidth to the compute device.  This helps speed up the calculation, particularly when running on a GPU.  The optimal value will depend on your compute device."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "torch.manual_seed(0)\n",
+    "\n",
+    "torch.set_default_dtype(torch.double)\n",
+    "if torch.cuda.is_available():\n",
+    "    dev = \"cuda:0\"\n",
+    "else:\n",
+    "    dev = \"cpu\"\n",
+    "device = torch.device(dev)\n",
+    "\n",
+    "nchunk = 50"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Setup the synthetic experimental conditions\n",
+    "\n",
+    "Setup the loading conditions for the \"experiments\" we're going to run.  These will span several strain rates (`nrate`) and temperatures (`ntemperature`).  Overall, we'll run `nbatch` experiments.  Also setup the maximum strain to pull the material through `max_strain` and the number of time steps we're going to use for integration `ntime`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "nrate = 5\n",
+    "ntemperature = 5\n",
+    "nbatch = nrate * ntemperature\n",
+    "max_strain = 0.25\n",
+    "ntime = 100\n",
+    "rates = torch.logspace(-6,0,nrate, device = device)\n",
+    "temperatures = torch.linspace(310.0,1190.0,ntemperature, device = device)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Define the variability in the synthetic data and for our initial guess at the parameters\n",
+    "\n",
+    "These control the variability in the synthetic data (`actual_cov`) and the variability of the initial guess at the parameter values (`guess_cov`)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "actual_cov = 0.025\n",
+    "guess_cov = 0.2"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Setup the actual model\n",
+    "\n",
+    "This class is a thin wrapper around the underlying `pyzag` wrapper for NEML2.  All it does is take the input conditions (time, temperature, and strain), combine them into a single tensor, call the `pyzag` wrapper, and return the stress."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class SolveStrain(torch.nn.Module):\n",
+    "    \"\"\"Just integrate the model through some strain history\n",
+    "\n",
+    "    Args:\n",
+    "        discrete_equations: the pyzag wrapped model\n",
+    "        nchunk (int): number of vectorized time steps\n",
+    "        rtol (float): relative tolerance to use for Newton's method during time integration\n",
+    "        atol (float): absolute tolerance to use for Newton's method during time integration\n",
+    "    \"\"\"\n",
+    "    def __init__(self, discrete_equations, nchunk = 1, rtol = 1.0e-6, atol = 1.0e-4):\n",
+    "        super().__init__()\n",
+    "        self.discrete_equations = discrete_equations\n",
+    "        self.nchunk = nchunk\n",
+    "        self.cached_solution = None\n",
+    "        self.rtol = rtol\n",
+    "        self.atol = atol\n",
+    "\n",
+    "    def forward(self, time, temperature, loading, cache = False):\n",
+    "        \"\"\"Integrate through some time/temperature/strain history and return stress\n",
+    "        Args:\n",
+    "            time (torch.tensor): batched times\n",
+    "            temperature (torch.tensor): batched temperatures\n",
+    "            loading (torch.tensor): loading conditions, which are the input strain in the first base index and then the stress (zero) in the remainder\n",
+    "\n",
+    "        Keyword Args:\n",
+    "            cache (bool): if true, cache the solution and use it as a predictor for the next call.\n",
+    "                This heuristic can speed things up during inference where the model is called repeatedly with similar parameter values.\n",
+    "        \"\"\"\n",
+    "        if cache and self.cached_solution is not None:\n",
+    "            solver = nonlinear.RecursiveNonlinearEquationSolver(\n",
+    "                self.discrete_equations,\n",
+    "                step_generator=nonlinear.StepGenerator(self.nchunk),\n",
+    "                predictor=nonlinear.FullTrajectoryPredictor(self.cached_solution), nonlinear_solver = chunktime.ChunkNewtonRaphson(rtol = self.rtol, atol = self.atol)\n",
+    "            )\n",
+    "        else:\n",
+    "            solver = nonlinear.RecursiveNonlinearEquationSolver(\n",
+    "                self.discrete_equations, step_generator=nonlinear.StepGenerator(self.nchunk),\n",
+    "                predictor=nonlinear.PreviousStepsPredictor(), nonlinear_solver = chunktime.ChunkNewtonRaphson(rtol = self.rtol, atol = self.atol)\n",
+    "            )\n",
+    "\n",
+    "        # We could pass this in as input, but it's easy enough to do here\n",
+    "        control = torch.zeros_like(loading)\n",
+    "        control[...,1:] = 1.0\n",
+    "\n",
+    "        # Setup\n",
+    "        forces = self.discrete_equations.collect_forces({'t': time, 'T': temperature, 'fixed_values': loading, 'control': control})\n",
+    "        state0 = torch.zeros(forces.shape[1:-1] + (self.discrete_equations.nstate,), device = forces.device)\n",
+    "\n",
+    "        result =  nonlinear.solve_adjoint(\n",
+    "            solver, state0, len(forces), forces\n",
+    "        )\n",
+    "\n",
+    "        if cache:\n",
+    "            self.cached_solution = result.detach().clone()\n",
+    "\n",
+    "        return result[...,0:1]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Actually setup the model\n",
+    "\n",
+    "Load the NEML model from disk, wrap it in both the `pyzag` wrapper and our thin wrapper class above.  Exclude some of the model parameters we don't want to train."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "model = SolveStrain(neml2.pyzag.NEML2PyzagModel(neml2.load_model(\"demo_model.i\", \"implicit_rate\"), exclude_parameters = [\"elasticity.E\", \"elasticity.nu\",\"R.X\", \"d.X\", \"mu.X\", \"mu.Y\",\"yield_zero.sy\"]))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Create the input tensors\n",
+    "\n",
+    "Actually setup the full input tensors based on the parameters above"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "time = torch.zeros((ntime, nrate, ntemperature, 1), device = device)\n",
+    "loading = torch.zeros((ntime, nrate, ntemperature, 6), device = device)\n",
+    "temperature = torch.zeros((ntime, nrate, ntemperature, 1), device = device)\n",
+    "for i, rate in enumerate(rates):\n",
+    "    time[:, i] = torch.linspace(0, max_strain / rate, ntime, device = device)[:, None, None]\n",
+    "loading[...,0] = torch.linspace(0, max_strain, ntime, device = device)[:, None, None]\n",
+    "for i, T in enumerate(temperatures):\n",
+    "    temperature[:, :, i] = T\n",
+    "time = time.reshape((ntime, -1, 1))\n",
+    "temperature = temperature.reshape((ntime, -1, 1))\n",
+    "loading = loading.reshape((ntime, -1, 6))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Replace the model parameters with random values\n",
+    "\n",
+    "Sampled from a normal distribution controlled by the `actual_cov` parameter.\n",
+    "\n",
+    "This controls the randomness in the input synthetic test data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Replace with samples from normal\n",
+    "actual_parameter_values = {}\n",
+    "for n,p in model.named_parameters():\n",
+    "    actual_parameter_values[n] = p.data.detach().clone().cpu()\n",
+    "    ndist = dist.Normal(p.data, torch.abs(p.data) * actual_cov).expand((nbatch,)+p.shape)\n",
+    "    p.data = ndist.sample().to(device)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Run the model to generate the synthetic data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "with torch.no_grad():\n",
+    "    data = model(time, temperature, loading)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Plot the synthetic data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.plot(loading.cpu()[...,0], data[...,0].cpu())\n",
+    "plt.xlabel(\"Strain (mm/mm)\")\n",
+    "plt.ylabel(\"Stress (MPa)\")\n",
+    "plt.title(\"Input data -- all conditions\")\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Setup the model for training\n",
+    "\n",
+    "Replace the parameter values with random initial guesses, with variability controlled by the `guess_cov` parameter."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Now replace our original parameter with random values over a range\n",
+    "guess_parameter_values = {}\n",
+    "for n, p in model.named_parameters():\n",
+    "    p.data = torch.normal(actual_parameter_values[n], torch.abs(actual_parameter_values[n])*guess_cov).to(device)\n",
+    "    guess_parameter_values[n] = p.data.detach().clone()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Scale the model parameters\n",
+    "\n",
+    "Our material model parameters have units.  In general, the parameter values will have different magnitudes from each other, which affects the scale of the gradients.  Unbalanced gradients in turn affect the convergence of gradient descent optimization methods.\n",
+    "\n",
+    "Typically we'd scale the training data to fix this problem.  However, again our data has units and a physical meaning we want to preserve.\n",
+    "\n",
+    "As an alternative we can scale the parameter values themselves both to clip the values to a physical range and to scale the gradients and hopefully improve the convergence of the optimization step.  We do that here, in a way that should be mostly invisible to the training algorithms."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Scale to get better performance\n",
+    "A_scaler = reparametrization.RangeRescale(torch.tensor(-12.0, device = device), torch.tensor(-4.0, device = device))\n",
+    "B_scaler = reparametrization.RangeRescale(\n",
+    "    torch.tensor(-1.0, device = device), torch.tensor(-0.5, device = device)\n",
+    ")\n",
+    "C_scaler = reparametrization.RangeRescale(torch.tensor(-8.0, device = device), torch.tensor(-3.0, device = device))\n",
+    "R_scaler = reparametrization.RangeRescale(\n",
+    "    torch.tensor([0.0,0.0,0.0,0.0], device=device), torch.tensor([500.0,500.0,500.0,500.0], device=device)\n",
+    ")\n",
+    "d_scaler = reparametrization.RangeRescale(\n",
+    "    torch.tensor([0.01, 0.01, 0.01, 0.01], device=device),\n",
+    "    torch.tensor([50.0, 50.0, 50.0, 50.0], device=device),\n",
+    ")\n",
+    "\n",
+    "model_reparameterizer = reparametrization.Reparameterizer(\n",
+    "    {\"discrete_equations.A_value\": A_scaler,\n",
+    "     \"discrete_equations.B_value\": B_scaler,\n",
+    "     \"discrete_equations.C_value\": C_scaler,\n",
+    "     \"discrete_equations.R_Y\": R_scaler,\n",
+    "     \"discrete_equations.d_Y\": d_scaler}, error_not_provided=True)\n",
+    "model_reparameterizer(model)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Run the model with the initial parameter values\n",
+    "\n",
+    "Just to see how far away from the training data we starting from."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Generate the initial results so we know where we are starting from\n",
+    "with torch.no_grad():\n",
+    "    initial_results = model(time, temperature, loading)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjsAAAHHCAYAAABZbpmkAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy80BEi2AAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOydd3hT1f/H30madO+996RsaMsGmQVEZINMlaWoLAUVAQVFQAEVBNlVQKbILIKyyi6blrbQTUtb2qY7HRn390d/93yTNEnT0pK2nNfznOeee+7JveeGkvu5n8lhGIYBhUKhUCgUSguFq+sFUCgUCoVCoTQmVNihUCgUCoXSoqHCDoVCoVAolBYNFXYoFAqFQqG0aKiwQ6FQKBQKpUVDhR0KhUKhUCgtGirsUCgUCoVCadFQYYdCoVAoFEqLhgo7FAqFQqFQWjRU2KFQXnM4HA6WL1+u1VwPDw9MnTq1ztdITU0Fh8PB7t276/zZ14WLFy+Cw+Hg4sWLul4KhdLioMIOhdLM2b17NzgcDm7fvt0g57t27RqWL1+OwsLCBjkfhUKh6Bo9XS+AQqHolvLycujp/e+n4Nq1a/j6668xdepUWFhYKMxNSEgAl0vfkRqDnj17ory8HAKBQNdLoVBaHFTYoVBecwwMDLSeq6+v34greT2pqKiAQCAAl8ut078FhULRHvqKRqG0QKZOnQoTExNkZmZi+PDhMDExga2tLRYuXAipVKowV95nZ/ny5fj0008BAJ6enuBwOOBwOEhNTQVQ02dHKBRi4cKFaN26NUxMTGBmZobw8HA8ePCg3msvLCzEvHnz4OHhAX19fbi4uGDy5MnIy8sjc168eIH33nsP9vb2MDAwQNu2bREREaFwHtZP6IcffsCmTZvg5eUFIyMjDBgwAM+ePQPDMFixYgVcXFxgaGiIt956C0KhUOEcHh4eGDp0KM6ePYt27drBwMAAQUFB+OuvvxTmafs9sH45+/fvx5IlS+Ds7AwjIyMUFxer9Nl5+vQpRo4cCQcHBxgYGMDFxQXjxo1DUVERmSORSLBixQp4e3tDX18fHh4e+OKLL1BZWanyXq5cuYKQkBAYGBjAy8sLv//+e73+nSiU5gTV7FAoLRSpVIqBAwciNDQUP/zwA/7991/8+OOP8Pb2xuzZs1V+ZsSIEXjy5An+/PNPrF+/HjY2NgAAW1tblfOTk5Px999/Y/To0fD09EROTg5+++039OrVC48fP4aTk1Od1lxaWooePXogLi4O7777Ljp06IC8vDwcP34cGRkZsLGxQXl5OXr37o3ExETMmTMHnp6eOHToEKZOnYrCwkJ88sknCufcu3cvqqqq8NFHH0EoFGLNmjUYM2YM3njjDVy8eBGLFi1CYmIifvnlFyxcuBA7d+5U+PzTp08xduxYzJo1C1OmTMGuXbswevRonDlzBv3796/X97BixQoIBAIsXLgQlZWVKk1XVVVVGDhwICorK/HRRx/BwcEBmZmZOHnyJAoLC2Fubg4AeP/99xEREYFRo0ZhwYIFuHnzJlatWoW4uDgcPXpU4ZyJiYkYNWoU3nvvPUyZMgU7d+7E1KlT0bFjR7Rq1apO/1YUSrOCoVAozZpdu3YxAJjo6GgyNmXKFAYA88033yjMbd++PdOxY0eFMQDMsmXLyP7atWsZAExKSkqNa7m7uzNTpkwh+xUVFYxUKlWYk5KSwujr6ytcOyUlhQHA7Nq1S+O9LF26lAHA/PXXXzWOyWQyhmEYZsOGDQwAZs+ePeRYVVUV06VLF8bExIQpLi5WuKatrS1TWFhI5n7++ecMAKZt27aMWCwm4+PHj2cEAgFTUVGhcL8AmCNHjpCxoqIixtHRkWnfvn2dv4cLFy4wABgvLy9GJBIpzGePXbhwgWEYhrl37x4DgDl06JDa7+v+/fsMAOb9999XGF+4cCEDgDl//nyNe7l8+TIZe/HiBaOvr88sWLBA7TUolJYANWNRKC2YWbNmKez36NEDycnJDXZ+fX194rAslUqRn58PExMT+Pv74+7du3U+35EjR9C2bVu8/fbbNY5xOBwAwOnTp+Hg4IDx48eTY3w+Hx9//DFKS0tx6dIlhc+NHj2aaEEAIDQ0FAAwceJEBcfs0NBQVFVVITMzU+HzTk5OCusxMzPD5MmTce/ePWRnZ9fre5gyZQoMDQ01fhfsmv/55x+IRCKVc06fPg0AmD9/vsL4ggULAACnTp1SGA8KCkKPHj3Ivq2tLfz9/Rv0b4JCaYpQYYdCaaEYGBjUMD9ZWlqioKCgwa4hk8mwfv16+Pr6Ql9fHzY2NrC1tcXDhw8V/Eq0JSkpCcHBwRrnpKWlwdfXt0ZUWGBgIDkuj5ubm8I+K0S4urqqHFf+fnx8fIigxeLn5wcAxJeprt+Dp6enxntk58yfPx/bt2+HjY0NBg4ciE2bNimcLy0tDVwuFz4+PgqfdXBwgIWFRa3fBdDwfxMUSlOECjsUSguFx+M1+jW+++47zJ8/Hz179sSePXvwzz//4Ny5c2jVqhVkMlmjX18b1H0P6sYZhqnzNer6PdSm1WH58ccf8fDhQ3zxxRcoLy/Hxx9/jFatWiEjI0NhnrIwpo6GvGcKpTlBHZQpFIoC2j44AeDw4cPo06cPduzYoTBeWFhInJvrgre3N2JiYjTOcXd3x8OHDyGTyRS0O/Hx8eR4Q5KYmAiGYRS+lydPngCojnACGv57kKd169Zo3bo1lixZgmvXrqFbt27YsmULVq5cCXd3d8hkMjx9+pRotgAgJycHhYWFDf5dUCjNFarZoVAoChgbGwOAVhmUeTxeDa3AoUOHavi9aMvIkSPx4MGDGlFEwP+0D4MHD0Z2djYOHDhAjkkkEvzyyy8wMTFBr1696nVtdTx//lxhPcXFxfj999/Rrl07ODg4AGj474G9jkQiURhr3bo1uFwuCSsfPHgwAGDDhg0K89atWwcAGDJkSL2vT6G0JKhmh0KhKNCxY0cAwJdffolx48aBz+fjzTffJEKQPEOHDsU333yDadOmoWvXrnj06BH27t0LLy+vel37008/xeHDhzF69Gi8++676NixI4RCIY4fP44tW7agbdu2mDFjBn777TdMnToVd+7cgYeHBw4fPoyrV69iw4YNMDU1fan7V8bPzw/vvfceoqOjYW9vj507dyInJwe7du0icxr6ewCA8+fPY86cORg9ejT8/PwgkUjwxx9/gMfjYeTIkQCAtm3bYsqUKdi6dSsKCwvRq1cv3Lp1CxERERg+fDj69Onz0vdPobQEqLBDoVAU6Ny5M1asWIEtW7bgzJkzkMlkSElJUSnsfPHFFygrK8O+fftw4MABdOjQAadOncLixYvrdW0TExNERUVh2bJlOHr0KCIiImBnZ4e+ffvCxcUFQLW/y8WLF7F48WJERESguLgY/v7+2LVrV72KlNaGr68vfvnlF3z66adISEiAp6cnDhw4gIEDB5I5Df09ANWCzMCBA3HixAlkZmbCyMgIbdu2RWRkJMLCwsi87du3w8vLC7t378bRo0fh4OCAzz//HMuWLXup+6ZQWhIchnqmUSgUiko8PDwQHByMkydP6nopFArlJaA+OxQKhUKhUFo0VNihUCgUCoXSoqHCDoVCoVAolBYN9dmhUCgUCoXSoqGaHQqFQqFQKC0aKuxQKBQKhUJp0dA8O6gu4vf8+XOYmprWKVU+hUKhUCgU3cEwDEpKSuDk5FSjOLA8VNhBdTp45QrIFAqFQqFQmgfPnj0jiUdVQYUdgKSXf/bsGczMzHS8GgqFQqFQKNpQXFwMV1fXWsvEUGEH/6vybGZmRoUdCoVCoVCaGbW5oFAHZQqFQqFQKC0aKuxQKBQKhUJp0VBhh0KhUCgUSouGCjsUCoVCoVBaNFTYoVAoFAqF0qKhwg6FQqFQKJQWDRV2KBQKhUKhtGiosEOhUCgUCqVFQ4UdCoVCoVAoLRoq7FAoFAqFQmnRUGGHQqFQKBRKi4YKOxQKhUKhUFo0tBAohUKhUJoNYrGY9Pl8PukXFRVBJBJBLBaTORKJBACgp6cHb29vMjcmJgYSiQRisRhSqVThvHw+H2FhYWTujRs3UFBQQPZlMpnCeoYMGUL6Fy5cgFAoJNeVXwMAvPPOO6R/7tw5PHv2TOFc7FoAYOrUqeT+IiMjkZqaqvL6ADBx4kSYm5uTuQkJCTXmyM+1sbEhc+Pi4lRen53r6OhI1nv//v0ac1hGjx5NvuNz587h1q1bCsdnzpxJrqsLOAzDMDq7ehOhuLgY5ubmKCoqolXPKZTXHJFIhKysLDx//hwvXryAUChEfn4+ioqK0L17d/Jwi4qKwtdff42KigpUVFSQh6xYLIZEIkG/fv2wbds2AMCRI0fw/vvvQyaTgWGYGtvg4GDcvn0bAHDgwAHyUGR/nuV/ph0dHZGZmQkAOHXqFIYOHar2XoyNjVFaWgoAiI6ORkhIiNq5fD4fVVVVAKoFBwsLC7VzORyOwkO3torT8uunc7Wb++jRIwQHBwMAuFwuND2q9+/fj7FjxwIAeDyeSoGIZeXKlfjyyy8BVP+bywtjysyaNQubN28GAOjr65O/D1UMHz4cR48eBVD9dycSiRSOr1+/HnPnzlX7+fqi7fObanYoFEqTo6ioCA8fPkR8fDySk5ORlZWFsWPHIjw8HADw7bffYuPGjaiqqoJEIiGNFSDCw8Nx4sQJANVv3qdPn1Z7LScnJyI8hIaG1ngjlcfExAQlJSUAgO+++w7//fef2rl79uwhws6pU6dQWFiodu7Dhw9J/9GjR2rfngEgOzub9HNyctTOA6DwwNF0TkBRAyGvMVEFfUdufDQJIQ1FbQIXj8cjfS5Xs9dLXebqAirsUCiUBqGoqAhXrlxBQEAAUWcvWrQIe/bsgUgkQmVlJSQSCaRSKRiGAcMwGDlyJA4fPgwAcHd3R3p6utrzX758GcnJyQCAHTt2KDz0lZEXWDIyMjSum9V8AIChoaHGufIPB3t7e41zWbMCAPKGrurhwuFw4ObmRva7dOkCPp9P5nK5XHA4HLLfqlUrMjckJASWlpZkHo/HA4fDIQ8e9roA4OPjA29vb/B4PHC5XHJe9lqBgYFkLp/PR8+ePcHhcMDlcqGnp6fwOX9/f4V7mDRpElmD/DoEAgFcXFwU5i5btgyVlZXg8XjQ09Mj83k8Huzs7BTm7tixA5WVleT6AMjnlDVPZ8+eJZoHds1AtQmL7bPcu3dPwWzFzpPfZ3n+/HmNueqEwbKyMoXvUBN1ERg1aWqUqU2olUeTpkaZ8vJyreeyLwRNCWrGAjVjUSjyiMViXLx4Ef/++y/u37+PZ8+eYcWKFRg5ciQAoG3btgqaCGVCQkJw8+ZNAICNjQ3y8/PVzvX29kZiYiKA2oUdT09PIuwMHDgQZ8+eBfA/AYJ9MHO5XAwePJio1Ddt2oSVK1dCIBDA0NAQhoaGMDAwgLGxMUxNTTFq1ChiNkpPT0dUVBTs7e3h4OAAR0dHmJub13hYUiiUpoG2z28q7IAKO5TXg+joaBw4cADR0dFITU3FmjVriJ3fzc2thrOkPPUVYEJCQhAdHQ3gf8IIj8cDn8+Hvr4+Zs+ejZUrVwKodpY8evQo3N3d4ePjg1atWsHf37/WN2QKhfL6QoWdOkCFHUpzJyEhAVu2bMGECRPQuXNnAEBAQIDGqIy6CDA9e/bEpUuXAACzZ8/Gn3/+CVNTU9jY2MDJyQl+fn5o164d+vTpo2CSoVAolMaEOihTKC2Q5cuXY8uWLSgoKIBYLK5h979x4wauX78OABAKhRrPJe+fsnDhQuzduxc+Pj7o2rUrwsPDFfw95Nm8eTOJ0KBQKJTmANXsgGp2KE2HmJgYrFq1CleuXMGLFy9QWVmJcePGYd++fQAAW1tb5OXlqf28vAlpyZIl2L59O9zc3NCxY0eMGTMGffr0eSX3QaFQKK8CasaqA1TYoeiS8PBwnDlzRu1xW1tbvHjxQmEul8uFgYEB7Ozs0KZNG0yYMAEjRoyg/i0UCuW1gpqxKJQmQlJSEhYuXIhLly6hsLAQDMMoRBapMzdxOBwYGhoqJI2LjIx8JWumUCiUlkTTy/xDobQAvvnmG5JrxMfHB3///TcKCgqIj4187pfPP/8cZmZmCAkJwdatW1FVVUWS45WVlWHnzp26ug0KhUJpEVDNDoXyEiQlJWHmzJm4du0anJyciL+MupTtfD4fLi4umDFjBhkbPnw4ioqKXtmaKRQK5XWD+uyA+uxQtCc9PR2TJ0/GjRs3UFlZWeM4+99JLBbDxMQEzs7OmDp1Kj7//HPqT0OhUCgNDPXZoVAamKysLLi7u6s9Lp/qns/nqxSGKBQKhfLqoT47FIoS9+/fR3BwMPG5YXF0dCR9DocDKysrfPjhh8THpraijBQKhULRDVTYoVAA/P3333B0dASHw0H79u0RGxtLfG7kHYT379+PsrIyyGQy5OfnY+PGjdQ8RaFQKE0casaivPYYGhqioqKixjiXy0VAQAC6detGxthaUhQKhUJpPlDNDuW1IioqCs7Ozli3bh0Zs7KyIn19fX1MmDABVVVVkEqliI2Nhb+/vy6WSqFQKJQGgkZjgUZjtXREIhF69+6N27dvk2gpIyMjlJWVAaiuJ3X06FGsXr1al8ukUCgUSh2h0ViU155vvvkG3333ncqoKCMjI9IPCwtDWFjYq1wahUKhUF4h1IxFaZHcuHEDy5YtUxB0uFwuhg0bhqqqKuTm5upwdRQKhUJ5lVBhh9IiOHXqFFxcXMh+WFgYCRt3dXXFo0ePIJVKcezYMRo9RaFQKK8ZVNihNGu+/fZb6OnpYejQocjMzMTkyZPJMbYWVXp6OoKDg3W4SgqFQqHoEuqzQ2mWjBs3DgcPHoSyf316ejrpm5ubv+plUSgUCqUJQjU7lGbF5s2bweFwcODAAQVBp0OHDqiqqsLFixd1tzgKhUKhNEmosENpVrzxxhukz+FwMHbsWDAMgzt37lBfHAqFQqGohAo7lCbN9OnToaenB5FIBADw9/dHx44dsWDBAshkMuzfv1/HK6RQKBRKU4f67FCaJBs2bMD8+fOJqcrX1xeZmZkAgNu3b+tyaRQKhUJpZlBhh9KkiIqKQt++fSEWixXGx4wZo6MVUSgUCqW5Q4UdSpNALBbDy8sLGRkZCuP9+/fH2bNndbQqCoVCobQEqLBDaRKIxWIFQcfX1xexsbHU6ZhCoVAoLw11UKbojBs3biApKQlAda2qoUOHwsDAAPHx8Xjy5AkVdCgUCoXSIFDNDkUndOrUCXfu3IFAICD1q06cOKHjVVEoFAqlJaJTzY5UKsVXX30FT09PGBoawtvbGytWrFBIFscwDJYuXQpHR0cYGhqiX79+ePr0qcJ5hEIh3nnnHZiZmcHCwgLvvfceSktLX/XtULTg1KlT4HK5uHPnDgCgqqqKaHcoFAqFQmkMdCrsrF69Gps3b8bGjRsRFxeH1atXY82aNfjll1/InDVr1uDnn3/Gli1bcPPmTRgbG2PgwIGoqKggc9555x3Exsbi3LlzOHnyJC5fvowZM2bo4pYoGmjVqhWGDh1KhFkej4fr16/D29tbxyujUCgUSkuGwygXF3qFDB06FPb29tixYwcZGzlyJAwNDbFnzx4wDAMnJycsWLAACxcuBAAUFRXB3t4eu3fvxrhx4xAXF4egoCBER0ejU6dOAIAzZ85g8ODByMjIgJOTU63rKC4uhrm5OYqKimBmZtY4N/sac//+fXTs2BEymYyM9e3bF//++68OV0WhUCiU5o62z2+d+ux07doVW7duxZMnT+Dn54cHDx7gypUrWLduHQAgJSUF2dnZ6NevH/mMubk5QkNDcf36dYwbNw7Xr1+HhYUFEXQAoF+/fuByubh58ybefvvtV35fFEUiIiKIoMPj8RAbGwt/f38dr4pCobyupKenIycnB6WlpRCJRKioqCD9yspKzJgxA0ZGRgCAnTt34sGDBygvL4dEIiFNLBZDIpHgp59+gpubGwDg888/x9WrVyGVSiGRSCCVSiGTySCVSiGVSrF9+3aEhYUBqM4O/99//wGodulgGAYymYxsN27ciJEjRwIAJkyYgLNnz4JhGNIAkN/Vr7/+GnPnzgUAjB49GpGRkWSOslvI3LlzsWrVKjL3+PHjCsflmThxInbu3Amguvjy4cOH1X6n4eHhxO9y8uTJ2Lt3r8J5T5w4gSFDhmj3D9QYMDpEKpUyixYtYjgcDqOnp8dwOBzmu+++I8evXr3KAGCeP3+u8LnRo0czY8aMYRiGYb799lvGz8+vxrltbW2ZX3/9VeV1KyoqmKKiItKePXvGAGCKiooa8O4o8jg7OzMdO3bU9TIoFIocVVVVzPPnz5nr168z58+fVzj22WefMePHj2eGDh3K9O3bl+nWrRvToUMHplWrVkznzp0V5vr4+DCWlpaMmZkZY2JiwhgZGTEGBgaMvr4+Y2RkpDDX2NiY4XA4Cg0AA4DhcDgKc/X09MgxVU0e+fOoaomJiVrPPXr0KJnL5XI1zl2zZg2Zy+PxNM798MMPyVyBQKBx7siRI8lcQ0NDjXN79uxJ5pqZmWmc265dOzLX1tZW41xvb28y183NTeNcBwcHMjcgIKDG8fXr1zONQVFRkVbPb51qdg4ePIi9e/di3759aNWqFe7fv4+5c+fCyckJU6ZMabTrrlq1Cl9//XWjnf9159SpUxg6dKhCQkDlZIEUCgXIyspCTEwMJBIJwsPDyXi/fv1QWFiIsrIyom0Qi8UQi8WwtLREWloamcvn8yGVSgHUfDPncDgK5mMOh6NxPfKfX7Nmjdb3kZiYqPXcsrIyra4PABKJROO5xGIxSVGh/FllSkpKtFyh4hpr+854PB7p6+vrkzp+qrCwsCB9c3Nz5Obmqp3r6upK+k5OTioDOdi1BQUFkTF/f3+NJXXat2+v0P/333/V3mPXrl1Jv3v37jh06JDaNfTp04eMDRo0CKmpqQrz2rZtq3ZNrwKd+uy4urpi8eLF+PDDD8nYypUrsWfPHsTHxyM5ORne3t64d+8e2rVrR+b06tUL7dq1w08//YSdO3diwYIFKCgoIMclEgkMDAxw6NAhlWasyspKEu4MVNv8XF1dqc9OAzBu3DgcOHCA7Ofm5sLGxkaHK6JQXo6ioiLcunULjx49gqmpKaZPnw6gWlAJDQ2FSCRCVVUVxGIxMVvIZDKYmpqiqKgIACASiWBsbKzxOvI/xXURSprCXD6fD4lEUuMzHA4HPB4PVVVVZMzR0RFFRUXgcDjgcrmk8Xg86OnpITs7m8wdMGAA0tLSoKenBz09PfD5fPD5fAgEAvD5fERGRhJh5/vvv0dycjIMDQ1hYGBAtgYGBtDX18eUKVOIaSomJgbl5eUwMzODmZkZzM3NybkpzYtm4bMjEonA5SoGhPF4PPIm4unpCQcHB/z3339E2CkuLsbNmzcxe/ZsAECXLl1QWFiIO3fuoGPHjgCA8+fPQyaTITQ0VOV19fX1oa+v30h39fpiZ2en8KYyatQoKuhQdE5eXh6++uorJCcnIzs7G4WFhSgtLUVFRQXEYjGcnZ2RkpICADh37hwGDBig9lwcDocIO2KxGM+ePVM7t7i4mPTZh+zLwuFwavx2mZqaQiqVQk9PDzwejwgD+vr6cHZ2Vpg7a9YsyGQyWFlZwcrKCtbW1nB0dISjoyNcXFwU5tblPVi5lp0msrKytJ5bl1Ixixcv1npucHCw1nMpLQOdCjtvvvkmvv32W7i5uaFVq1a4d+8e1q1bh3fffRdA9X/suXPnYuXKlfD19YWnpye++uorODk5Yfjw4QCAwMBADBo0CNOnT8eWLVsgFosxZ84cjBs3TqtILMrLk5WVBRcXFwV1+cmTJ3XrjEZpMYjFYty4cQMSiYSoyi9cuIARI0YQgYV17GSRT1Z5/PhxbNmyRe355U1CXl5eWq+LdUoF/qcFYTUUPB6vhqDRo0cPGBsbw9bWlggYHh4eCAwMrHHdugga8kJVbWzevFnruRRKS0Knws4vv/yCr776Ch988AFevHgBJycnzJw5E0uXLiVzPvvsM5SVlWHGjBkoLCxE9+7dcebMGRgYGJA5e/fuxZw5c9C3b19wuVyMHDkSP//8sy5u6bXjxo0b6NKlC9k3NDREXl5eg73JUlom0dHR+Ouvv2Bvb0+iSPbv34+JEyfWEFxYeDwe8eFISUlBYWGh2vPLaxrkoznlYc0oDg4OZMzb2xvBwcGwtraGk5MTvLy8EBgYiE6dOsHLy6uGmaMuQsnly5e1nkuhUBoWnfrsNBVonp36I++LEBgYiMePH+t4RRRdIRaL8ddffwEAxo4dC6D6RWTy5MkKWj955AWYnTt34r333lN7fnln26ysLDg5ORFNCp/Ph5GREczNzWFvb4+ePXuS8FoKhdJyaRY+O5Tmj5GREW7duoWtW7di27Ztul4O5RUQGRmJcePGQSQSkfwg8vB4PCLsSCQStYIOoKgZGTZsGPh8PvT19WFmZgY7Ozt4eHigU6dOGDBggEKQgqOjY520KhQK5fWGanZANTt1xc3NDRkZGaisrKTRCy0EkUiELVu24Pjx40hISEBhYSEqKyuJQMHn80lETUREBKZOnar2XPIaGJFIBAsLCxgZGcHKygoeHh7o3Lkzhg4dirCwMPr3Q6FQXgptn99U2AEVduqCubk5cYj09PREcnKyjldE0ZaEhAT8+OOPuHLlCjIyMuDo6IiEhAQAtZuQgP9pYcRiMfT19cHlcmFoaAgrKyv4+vqiZ8+eeOedd2itMwqF8sqgZixKgyIWi2FiYkLe7nk8HmJiYnS8KoomVNUkk0c+ydqkSZMUhB02xNnCwgK+vr4YMWIEOcbn8zWapigUCqWpQYUdSq0UFRXBysqKPOAMDAxQXFxMTRA6JC8vDytXrsSpU6eISZFhGAUTkp+fn1qhhMPhwNTUlOzz+XwUFhbC3Nz8layfQqFQXiVU2KFoJC8vD3Z2dsSEYWlpCaFQqONVvT6wOWZ69OhB9gUCgdr58lZpIyMjmJqawtDQEK1atcKUKVMwYcIEtUIqFXQoFEpLhQo7FI1MmjSJPECpj07jUlRUhE8//RSnT59GTk6OQl0geUdhZTgcDgwNDeHm5lYjkWNdEs5RKBRKS4UKOxSNREZGwsfHB3w+H3FxcbpeTotBvoAhUJ15V1OsQFFREdG8DB8+HK1atcIXX3xBkzdSKBSKFnBrn0J53cjKylJIK5+YmEgFnZckIiICAQEBEAgE4HA4EAgECll+lQUdLpcLGxsbDB8+HI8ePVIwMR09ehQrV66kgg6FQqFoCdXsUBRgM9MCgFAoxJdffqnjFTVf/P398fTpU7Uam2+//RbLly8HAEybNg16enpYu3Yt9Z2hUCiUBoZqdigEkUikULzwyJEjOlxN8yErKwvh4eEwNjbGjRs3yHhycnINQYfD4cDa2hrjx4/HnDlzyPjOnTuxdetWKuhQKBRKI0CFHQqAah8SMzMz8nAOCAjA3bt3dbyqpklRURHefPNNGBsbg8PhwMnJCWfOnIFIJFIQYPr06QOBQIB27drh5MmTYBgGMpkMeXl52LdvH2xsbHR4FxQKhfL6QM1YFADVYcdSqRQA4ODgQH101BAYGIj4+Hi1x62srEj/7Nmzr2JJFAqFQqkFqtmhwMrKCuXl5QAAU1NTZGVl6XhFuufGjRsIDAwEj8dDQEAAGQ8NDVWYZ2ZmhgkTJqCsrAwMw1ABh0KhUJogVLPzmpOeno6CggIAgEAgeK3zsixcuBC//fYbSktLFcafPHlC+tu2bUNBQQF+//136l9DoVAozQQq7LzmuLm5Yf/+/XjvvfeI0PO6ERMTg9atW6s8xuVy0bFjR7LP5/Nx7NixV7U0CoVCoTQA1Iz1miJvqho7dixKS0tfi1pX6enp6NChg4JWJjg4WGGOmZkZFixYgKqqKkilUty6detVL5NCoVAoDQgVdl5DIiMj4eTkpOBM25JJT09H69atweVy4e7ujnv37qG4uBjnzp0jc6ZPn46zZ8+CYRgUFRXhhx9+eC2EPwqFQnkdoMLOa0ZWVhYGDx4MACgoKMB///2n4xU1HkOGDCECTkxMjELOGy6Xq+CLs3XrVvTv318Xy6RQKBRKI0N9dl4jxGIxXFxcyP7YsWPRt29fHa6oYRGLxRCJRMREdeXKFQUBh8fjoXv37jh27Bh1LqZQKJTXCKrZeY2ws7ODTCYDUJ00cP/+/TpeUcOwadMmGBsbQyAQwNfXl4yvX78eXC4X3bp1Q2FhISQSCS5evEgFHQqFQnnN4DCaSi2/JhQXF8Pc3BxFRUUwMzPT9XIahQEDBhAfFWNj4xrh1c2N9PR0vPHGG0hKSqpxjP5JUygUyuuBts9vasZ6Dfj777+JoMPhcJp1iLlIJIKFhYVCxXAWOzs77NmzRwerolAoFEpThpqxXgOGDBkCIyMjAMC1a9eaXZSRSCQifSMjIwVBh8/nY+7cuWAYBjk5OdTJmEKhUCg1oMLOawCfz0dZWRnS0tIQFham6+Vozc6dO2FoaAhjY2Ns3ryZjPfq1QsBAQHIzc1FVVUV1q9fr8NVUigUCqWpQ3120HJ9dvr164eVK1c2KwEHAN566y2cOHFCwfemJfgZUSgUCqVh0fb5TTU7LZRFixbhv//+Q5cuXbBt2zZdL6dWRCIRAgMDweFwcPz4cQVBx9XVFY8fP9bh6igUCoXSnKHCTgskPT0da9asIftvv/22DlejHUePHkV8fDzZ53A4GDZsGBiGQXp6Otzc3HS4OgqFQqE0Z6iw0wLx8fEh/TVr1sDGxkaHq1FNVFQU3N3dyf4777wDPp8PPp+PjRs3QiaT0YKbFAqFQmkQaOh5CyM0NJREK3l7e+PTTz/V8YoU+fvvvzF+/HhUVFQAqPbPYYWaqqoqXS6NQqFQKC0UKuy0IA4cOEAqdHM4HCQmJup4Rf/j77//xtixY2sINC9evNDRiigUCoXyukCFnRbE+PHjSf/mzZs6XMn/uH//Prp06UI0OSxubm54+PAhLd1AoVAolEaH+uy0INatWwegWujp3LmzjldTjaGhoYKg4+Pjg6qqKqSlpVFBh0KhUCivBJpnBy03z44uyMvLQ4cOHfDo0SMizHh5eQEAYmJiSCZnCoVCoVBeFppn5zVBLBZj4MCBul4GxGIxfH19YWtri2fPniEgIIAcS05ORnJyMhV0KBQKhaITqM9OM8fBwQFCoRB6enqQSCQ6WcPo0aNx+PBhnVybQqFQKLojLy8PGRkZqKioQElJCaqqqlBaWoqKigqIRCKEh4fDw8ND18ukwk5z5ttvv4VQKAQAnWhNtm3bhpkzZypkOxYIBDhz5gz69OnzytdDoVAojYFIJEJeXp5CctMjR44gPj4epaWlKCkpIQ/4srIyVFVVITIyElxutfFk5MiRiI2NRVVVFaRSKSQSCSQSCaRSKWQyGZ48eULyoQUFBSElJQUMw9RoQHUx55CQEADVL7tsRKsqj5SdO3di2rRpAABzc3MUFxervcfFixdj1apVAAATExOUlZWpnfv222/jr7/+AgB4eHhonNujRw9cvnxZ7fFXBRV2milisRhLliwh+9nZ2a98DTNmzCB9DoeD1atXN7m8PhQKpXmwfft2pKamIj8/H8XFxSguLkZJSQlEIhGMjY1x4cIFMtfb2xtCoRBSqZQIDDKZDAzDgMfjoby8nMzV19fXmMNLXkjgcDga1yg/d9SoURrnVlRUkJdQVjBQR3JyMhF24uPjVQouLI8fPybCTm5ursa5KSkppC8SiTSuITc3l/RrsxKwudy0QSqVaj23MaHCTjPF0dGR9BcsWPDKNDtisRh8Ph8AMGDAAJw9exaDBg1CZGTkK7k+hUJpWCQSCS5evIiUlBRkZmYiMzMTeXl5KCgoQElJCRwdHXHy5Eky39LSEpWVlZBKpWAYhggaQLVmVz76si7Cw/Tp07Vec3Jystpjyg/ihkxWKpVKwePxtJorEonI77JAINC4Dvlz2tvbE20N+/2xGiIOh0MCPgAgJCQEsbGx4HA44HK54PF44HK5pD9gwAAy991338WVK1egp6dHGpu1XiAQ4IMPPiBzN2/ejGvXrkFfXx8GBgYwMDCAQCCAoaEhjIyMMHToUDL34cOHyMzMhKmpKUxNTWFkZARzc/Mm56NJo7HQ/KKxNmzYgHnz5gEATE1NNaomG/Ka8+fPB5/PR2VlJRmXF34oFErjIRQKsWjRImRlZSE/Px9FRUUoKytDeXk5Kisr4eLigtjYWADAs2fP4O7urvatn8PhEAFFIpHU+n+4vtqPxpqrp6cHqVSq8BkulwsOhwM9PT0FzY6XlxcKCwvB4/HIA14gEIDP58PExATR0dFk7qeffooXL17A2NgYpqamsLS0hLm5OaysrGBlZYV+/frVuk7Kq0Xb5zcVdtD8hB35/2xlZWWNKkEXFRXBzc1NQaA6evQohg8f3mjXpFCaM8XFxTh8+DAeP36MtLQ0ZGVlQSgUEpOMv78/rl27BgA4c+YMBg8erFYo4XK5xAxw5coV9OjRQ+O12fOUlpbC1NRUq7mAZkFDfg1AtRaCYRiiTWCbnp4erK2tkZqaSuaGhYVBIpHAxMSECA+WlpawtraGl5cXJk6cqHGNFEptaPv8pmasZoibmxvS09MxadKkRhV03n33XezatUthbOzYsVTQobRIxGIxYmNjcfXqVcTExCAwMBAff/wxgOpyJ++88w7EYjEx38gLC0ZGRsRJc/PmzVi8eLHa68hnN9fT09PocyF/LDg4WO08DocDExMTss8KF3p6ehAIBDAyMoKhoSEsLCxgbm6ONm3aKHw+Pj4eXl5eWmlp6+KDcePGDa3nNiasuU3TVlNf1b66Jj+Pvba6pu44O67Ncfk5tfVVbTUdq+sc5bnK/d69eyv8nb5KqLDTDGHfFuX9dhqSpKQkBAUFKdiYLS0tkZGR0eTssBSKMunp6fjnn38QHR2NxMREZGVloaCgAGVlZejQoQMuXboEAFi6dClWrFih9jx6enpE2Hn8+LFGB095P5W2bdtqXJ/822enTp1gZmYGAwMDGBkZwcTEBNbW1nBwcICTkxO6du1K5pqbm6OqqgpVVVUQi8Uqt/fu3YNYLIZYLMbx48chkUggFotVbnfs2EH68hFC8k05ckh5q02TyWRq++w+26/rmLzPkLp9arxoOiQkJMDPz08n16bCTjNCXsBpLEEHqI6KkBd01q9fj7lz5zba9SgUTcTGxmLFihVITEzEixcvUFRUhIqKCkgkEjAMAzc3N2I6mThxIvbu3av2XKz5CAAMDAw0XlfetNO7d28FJ1B5jYmRkRFat26No0ePklwja9asAZfLRUVFRY1WWVmJMWPGoLKyEpWVlejQoQMqKytRVVWFyspKPH/+HKmpqaiqqkJERASmTZtGhByKbuBwOFo11m9IvtX2eXXH2XH54/XtK9+Hcl/5Wqq26sZq+7x8v7b/c40J9dlB8/DZmTNnDjZt2gQnJyekpqY2uFOwsqOxtbU1zM3NkZCQQB2QKQ3OpUuXsGDBAmRlZaG4uBiVlZVEeAEAKysr5OfnAwDGjRuHAwcOqD2Xnp4eicBZvXq1RhOSpaUlVq1ahdLSUqSlpeGPP/4gESeGhoYwNDQEj8dDVVUVysrKUFZWBpFIBJFIpLOknZpgo2nknW7ZJh9tI78vv+XxeKSvvM8KdeyW7cuPa2qsYKhqXz5ySD6CSNU4h8NRmKO8z46p25cXQpS3tY0pCwSUpgf12WlBiMVibNq0CQDw/PnzBj//O++8g3379qF///44e/YsAJAHDYWiLVevXsWCBQuQkZGBwsJChfBkoNoMU1hYCKDar+XOnTtqz1VcXIz8/Hzk5+fD3t5e5Rz2oWRqaoqOHTuiqKgI+fn54HA4ak0XBQUFmDVr1kvdJ5fLJT4wbCgu22eFJjZcV36MFar09fVr9AUCAenL7wsEApWNFWDog5hC0Q4q7DQDPD09SX/ZsmUNpmkpKiqCk5MT8UU4d+4cDSWnKPDs2TOsX78eN2/eRFpaGgoKClBZWUn8IWxsbEgysl9++UXB+VaZ0tJS3Lp1Cy9evIC+vn6N4+xbNMMwkEgkJMmaOhiGgVQqRUFBAQoKClTOMTExgZmZGckBYmZmRpx3TU1NSd/Y2BgmJiYwNjau0YyMjMjWyMgIAoGAChkUSjODCjtNnOjoaGRmZgIADA0NsXz58gY5r3yuHpYdO3ZQQec14v79+9i1axeuX7+OtLQ0Yk7y9PREUlISgOq8I5pMSAUFBYiNjUVmZqbKKAt5LYtUKkVoaKjac6lyJjUzM4OlpSWsrKwUthYWFmTLRhjJN1bAYZOxUSiU1xsq7DRxunfvTvqPHj1qkHP6+/vjyZMnZN/Ozg4ZGRlU0GlBsNE4f/75J+7fv4+2bdviyJEjAP7n/6WOtLQ0ANU5nNq2batS2GGFGKlUqjEkWrlump2dHezt7WFraws7OzvY2trCxsZGoVlbW8Pa2hqWlpb0b5JCoTQIVNhpwqxbt45EYHh6esLb2/ulz9m9e3cFQWfu3LlYv379S5+X8uopKyuDsbExgOqCfzNmzFCbA0U+0VvPnj3VCjtcLhf6+vqwtbVFXl6e2mvLCzGWlpZwdnaGk5MTHB0dSXNwcICDgwPs7e1hb28Pc3Nzav6hUCg6gQo7TZiVK1eSfkJCQoOc88KFC8TBMTExUaGKL6VpIRaLcfDgQURERCA2NhZ5eXkQi8VE0ODxeCRCyNjYWGOyNz6fj40bN+LJkyeIj4+HsbGxykrFMpmMRB8B1U7F7u7ucHNzg6urq0JjBRyae4lCoTR1qLDThBEKhQgPD4e9vf1LqfNbtWqFLVu2oEePHuDz+SgsLIS5uXkDrpTyMpw7dw4bN27EnTt3YG9vT6KU9uzZg3fffVft5+SFm+HDh4PP50NfX5845QJARkYGRCIRKioq8NFHH9U4h4GBAby8vBSap6cn3N3d4e7uDgsLi4a9WQqFojNUZVZWN/6yc5THgOpajtoWUm1oaJ4dNI88O/UhPT0dXl5epGBeZWUl9YHQMWlpaQgODoZIJCKFGJVh/0sqF2jkcDgwNDSEra0tPDw8EBAQgKqqKjx8+BCxsbEKWXzl0dPTg4+PD/z9/eHn5wdfX1/4+vrCx8cHTk5O1In3NYeNflPOsKzcVI3XlmFZPtOyNlmXVWVbVrXVNtOyckZlTRmYlUtIqBpvyPIS2pSfYP99tJ2jaj471hRojAzKNM9OM+aNN95A7969sXTp0nqfY9OmTZgzZw7Z19PTg0gkohqdRiYvLw8rVqzAqVOnkJmZicrKSujp6RHfK3t7e5SWlqr9vHxItp6eHqKjo5GVlYW7d+/i3r17uHv3LtLS0pCWlkbKHrAYGhoiMDAQQUFBpAUGBsLT05MKuTqGYRiIxWKUl5eTTMryffnsyvJ9VY3NtCy/lW9s6Qh1ZSWUW1NMlkihNDRUs4OmpdlJSkqCj48PgOqKwdevX6/zOcLDw3HmzBmyHxAQgLi4uAZbI0URiUQCgUCg8e1J/hifzweXy4WtrS06d+6M+fPno0ePHigtLUV0dDRu3ryJW7duITo6GhkZGSrP5+XlhbZt26JNmzakeXl5US3NSyAWi1FSUoKSkhKUlpbWaGxGZfnMyspZltlWXl6u0K+oqFCryWuqsFmT5TMuq2vK2ZaVMy3XlnFZOXOy/Lhy5mV12Zfrk2VZfp78vqqMypr2VWVdVlU6QptjdS030VAlJWrrs/uqtpqOyW/19PQaPEiBanaaKfPnzyf9bdu21fnzdnZ2JMkbAHz22WdYvXp1g6ztdeXGjRtYtmwZbt++jcLCQvLQYgUYdZWrWbOTchQdW9ogPT0dUVFR2L9/Pz755BM8fPiwhpMxh8NBYGAgOnXqhPbt26N9+/Zo164d1dDJwTAMysvLUVBQgMLCwhqtqKgIRUVFKC4uVttKSkpQWVn5ytYsn1VZPuOyfGZl+QzLqjIry4+py7KsvFXXlEtJsA98CqWlQIWdJoZ8WLim/CWqiIyMVBB0Ll++jB49ejTY2l439PT0NEY4FRUVEaHD398fXC4XY8aMwWeffVYjQolhGCQlJeHChQuIiorC5cuXST4beVxcXNClSxeEhISgc+fO6NChA0xNTRv2xpowEokEQqEQeXl5yM3NRV5eHvLy8kjpCKFQSLZCoRAFBQUQCoUNWiRTIBAoZFiWz66snGWZzaqsnGVZvoSEcqMZmCmUVw8VdpoY8sJKXQkPD0efPn1w/fp15Ofn05DgWti2bRs2bNiA5ORk4txbUVFB/GZUCTp8Ph/29vbo37+/gh9MfHx8jbmZmZk4f/48/vvvP5w/fx7Pnj1TOM7j8dChQwd069YNXbt2RZcuXeDi4tKQt9gkEIvFyMnJQVZWFrKzs5GTk0O2OTk5ePHiBWlCobDezpQ8Ho9kVFbOrCzfNzMzI40VauQb9W+iUFoeVNhpYrC5T7R981uyZAnOnj2LW7duAQDOnz/faGtrCbi6uqr1gwGAtWvXYsmSJQCAfv36QSgU4sMPP9QYAs5SUVGBqKgo/PPPPzhz5gxiY2MVjgsEAoSFhaFXr17o0aMHunTporLEQnOiqKgIz549w7Nnz5CRkYHMzEzSnj9/jufPnyMvL6/OAoyVlZXKrMrW1tawsrJSaJaWlrC0tISpqSnVmFAoFJVQYaeJwarjtXm7HDBgAM6dOwcAmDBhAvbt29eoa2suZGVl4eOPP8a///6LoqIinD59GoMGDQIAZGdn15jP4XBI5exx48aRcfa71cTz589x8uRJnDhxAv/99x/Ky8sVztuxY0f07dsXffv2Rbdu3ZqVto1hGOTk5CAlJQWpqakkCoxtz549Q0lJiVbn4vF4JKOyfFZltrGlI+zs7GBtbQ09PfrTRKFQGg76i9LEYJ1fa3sourm5KZhFunXr1qjrasocO3YMixYtQnJyMnH+leerr74iwk6/fv1w5coVdOzYEd9//z3CwsLqdC2GYRATE4OjR4/i+PHjJAEgi6OjIwYNGoSBAweiX79+sLa2rv+NvQLEYjHS0tKQmJhIWlJSEpKTk5GamkoyKWvCysoKrq6ucHFxgbOzM2lOTk6khISNjQ2NFKNQKDqDCjtNjODgYCQlJSE8PFztHBMTE4VU/7du3ULnzp1fxfJ0jlgsxueff46wsDCMGjUKADBt2jQUFBSonC8QCNCrVy+yHxkZWedrMgyDO3fu4MiRIzhy5AiePn1KjnE4HISEhGDYsGEYOnQoWrdu3SRNKfn5+Xj8+DHi4+ORkJCAhIQEPHnyBMnJyRrzrHA4HLi4uChkVfbw8ICbmxvc3Nzg4uJC6nNRKBRKU4UKO00MTZXN2aSA7MOJx+MhPz+/RYchi0QiTJ8+HSdPnkRxcTEZt7a2JsLOm2++id9//x0cDge2trYYMWIEfvzxx5c2GcXExGDfvn3Yv38/UlJSyLi+vj4GDBiA4cOHY8iQIbC3t3+p6zQkBQUFiImJwaNHjxATE4PHjx/j8ePHGh3f2fB4Hx8f+Pj4wNvbG97e3vD09ISbmxsEAsErvAMKhUJpeGhSQTStpIKakK9EbWxsrDETb3Nn2bJl+Oabb9QeNzAwUPCPaSjS09Oxd+9e7Nu3DzExMWTcyMgIQ4YMwciRIzF48GCdh4PLZDIkJibi/v37pD18+BCZmZlqP+Pu7o6AgAAEBATAz8+PlI9wdnamJiZKg8KWbdB1uQhN5SHUlZNQLhuhzbYplotoyD67r2mrzZyIiAi4uro2xJ8YodkkFczMzMSiRYsQGRkJkUgEHx8f7Nq1C506dQJQ/SUtW7YM27ZtQ2FhIbp164bNmzfD19eXnEMoFOKjjz7CiRMnwOVyMXLkSPz000/NLtIlKSkJY8aMQUBAAHbv3l3DSfnhw4fED0LTQ605IRaLsXDhQvzxxx8wNzcnGpTQ0NAacw0NDRESEoLffvsN/v7+DbYGkUiEo0ePYvfu3fjvv//If0yBQIDw8HBMmDABQ4cO1ZlzsUwmw5MnT3D79m3cvn0bd+7cwb1791RWLQeq/blat26N4OBgtGrVCkFBQfD39292/x9eVyQSidblImpr2pSLUK6Jpa5GVl1qY9F3aIoqEhMTG1zY0RadCjsFBQXo1q0b+vTpg8jISNja2uLp06ewtLQkc9asWYOff/4ZERER8PT0xFdffYWBAwfi8ePHMDAwAAC88847yMrKwrlz5yAWizFt2jTMmDGj2UUnbd26FXfv3sXdu3exd+9eAMCFCxcQGhoKIyMjODo6oqqqqtnnAYmIiMCSJUuQmZmp8KMo73czePBg2NraIiQkBNu3b4eDg0ODr+POnTv47bffsH//foWoot69e2PixIkYMWKEwt/iqyInJwc3b94k7datWyqjngwMDNCmTRu0a9cO7dq1Q5s2bRAcHNyizZq6gGEYVFVVkdIQbOkIVeUilMtEsFu2ZIRyX1VtLE2JLFsK6solAKrTbnA4nBoClKpCl+o0H5SmgS5/m3Rqxlq8eDGuXr2KqKgolccZhoGTkxMWLFiAhQsXAqjO62Fvb4/du3dj3LhxiIuLQ1BQEKKjo4k26MyZMxg8eDAyMjLg5ORU6zqaihnrjTfewIULFwBU33tERASmTp0KLpeLioqKZi/kKFfxVsbIyAilpaWN6uBbVlaG/fv3Y8uWLbh9+zYZ9/T0xJQpUzBlyhR4eHg02vWVYRgG8fHxuHLlCq5evYorV64gKSmpxjwjIyO0a9cOnTp1QseOHdGxY0f4+/vTEG0NVFRUkFIR2pSLkG/KdbF0VSyTy+WSshDypR3YxtaEkq+3pIyyuUbZXCSvnZHX3qiKbGxpcLlchfpe2tTxUlXXS1VNL3V1v9TV9lJV40tVnS9V++rmKNfhUh5T3qqrA6Zqjjb1vpTHwsLCGlxD3izMWMePH8fAgQMxevRoXLp0Cc7Ozvjggw8wffp0AEBKSgqys7PRr18/8hlzc3OEhobi+vXrGDduHK5fvw4LCwsi6ADV4cVcLhc3b97E22+/XeO6rDqYRd7xVZekpqaS/oYNGzBv3jwA1T9WmzZtwty5c3WzsHrw7bff4scff0RhYSGkUikpAicPn89HmzZtsHv37jqXxqgrSUlJ+OWXX7Br1y7y7y0QCDBy5EjMmDEDPXv2fCV+KzKZDLGxsbh48SIuXryIS5cuIT8/X2EOWw8rLCwMoaGhCAsLQ1BQ0Gsp2MhkMhQWFpJyEfJlI+TLRRQUFNSojcVmxW5IBAKBQrkI+RIRhoaGRBhhHyqs8MFqGZSFC9bcxP4myVdELy8vR1lZGenrGh6PV6M+l6bG1uSSr8ulrq+uVpe6ul3K4/Jj8vus8KKqWKk64ZDSMtHpr2dycjI2b96M+fPn44svvkB0dDQ+/vhjCAQCTJkyhSSAU452sbe3J8eys7NhZ2encFxPTw9WVlYqE8gBwKpVq/D11183wh29HEKhkPRZQQcAFixY0OQFnby8PIwYMQI3btyo8Ua4YMECrFu3DkC1Ni8gIABTpkxp9DUxDIOLFy/ip59+wvHjx4lK29vbGzNnzsTUqVNha2vb6OtITk7Gv//+i3PnzuHChQs1hBtDQ0OEhoaiW7du6N69O8LCwmBhYdHo69IFDMOgqKiIlIpQLheRm5tLamLl5uYiPz//pauFm5qaaiwXYWJiAgMDAyKgsJoQqVQKsVisIISUlJTU0AplZGSguLi4UYQrZQwNDRXqbqmqwcUWGWW38oVG5RurMVK1r6oAKY/Ha/T7o1AaC50KOzKZDJ06dcJ3330HAGjfvj1iYmKwZcuWRn0Yfv755wrVxYuLi3XmNCWPqre3lStX4ssvv9TBarRHudK6PIaGhggKCiL7q1atavT1SCQSHDx4EGvWrMGDBw/IeHh4OD755BP079+/UbU4paWlOH/+PE6fPo1z584hOTlZ4bixsTG6d++OXr16oXfv3ujYsWOzD+9mGAaFhYUqy0VkZWWRlpOTU6/q4qamprWWizA3N4dAIFAQVCoqKoj2R14blJaWpqANashCovr6+kSIkt8aGxuTrYmJSY2iosraInZraGgIY2NjGBgYUE0EhVJPdCrsODo6KjwIASAwMBBHjhwBAOKUmpOTA0dHRzInJycH7dq1I3NevHihcA62crI6p1b2baWpoawR2bhxIz788EMdrUY169atw4oVKzBq1Chs27YNQHVIPCvscDgcuLq64tdff8WQIUNe6drKy8uxa9curF27lpgEjYyMMHXqVHz00UcICAhotGs/ffoUJ0+exOnTp3H58mWFh6eenh66dOmCfv36oV+/fujcuXOz87+qrKzEs2fPapSLkG/aZFtmMTMzU1suwtbWFra2trC0tASPx4NYLEZBQQFyc3MVtD85OTmIjY0lWiChUPhSzr1sIVHlwqHyzczMrIZ2iNUQmZmZwcTEpNkLrs0Z1jdJXcSYpgiy+oTK1yd0vj5h9KpC5OvS5D9fWyi9tuH19Qm7v3nzJry8vHTyt6FTYadbt25ISEhQGHvy5Anc3d0BVDuNOjg44L///iPCTXFxMW7evInZs2cDALp06YLCwkLcuXMHHTt2BFBdDFMmk6kMX27KKPuKNxVBZ968efjtt98UNE8RERFE2Dlw4AA++eQT/PXXXzrxti8tLcWmTZvw448/EqHL1tYWn3zyCWbPng0rK6sGv6ZMJsOtW7dw7NgxHDt2DHFxcQrHPT09MWTIEAwcOBC9evXSeV6e2mDrYMmXi0hJSSHbrKwsrSJbLC0ta5SMcHR0JM3BwQFGRkYoLCwkmp/s7GxkZ2cjJSUF169fJxXR8/Ly6mXCMjY2ho2NDaysrGpogywtLRW0QWyzsLCAiYkJ1Zz8P1KpVCH8Xd6vSDn0vT5h8LWFwiuHxNcWFv86OVU3Z3Tl6A/oWNiZN28eunbtiu+++w5jxozBrVu3sHXrVmzduhVAtZZg7ty5WLlyJXx9fUnouZOTE4YPHw6gWhM0aNAgTJ8+HVu2bIFYLMacOXMwbtw4rSKxmhJBQUGIj4+HTCbTeXLDW7duoVevXmr9EGxsbEg/ODgY//3336taGqGsrAy//vor1qxZQ5Ituru749NPP8W0adMa3OtfKpUiKioKhw4dwl9//aXgE6anp4devXphyJAhGDx4MPz8/Jrkg1MoFOLJkycKJSPYmljq8vawGBoawsPDA+7u7qRcBFsTy9XVFY6OjigtLUVGRoZCFfTr168rmLbqmgzT2toa9vb2RPMjr/2Rr4pua2sLa2vrJqm1rS8Mw6CiooKEs7Ph7vIh7fJ9+SYf3q4qzF0+3F152xLD3+WdlVVFXylHYdUlKutlo7GUo7rqEo2lPKYcnSUfFaUqGktVZNbLRGOpSyvA4XCIIkMX6DyD8smTJ/H555/j6dOn8PT0xPz580k0FvC/pIJbt25FYWEhunfvjl9//RV+fn5kjlAoxJw5cxSSCv78889aJ1FrKqHnuubIkSMYOXIkAODFixc1HMOtra2xatUqhX8fXVBRUYFff/0Vq1evJiZMHx8ffPXVVxg/fnyDmohkMhmioqJw4MAB/PXXX8jJySHHTE1NMXjwYLz11lsIDw9vUk7FOTk5CuUi4uLiai0bweVy4e7uDi8vL1IuQr6Zmpri2bNnSE1NRWpqKtLT05Geno60tDSkp6cjIyND6zdrU1NTBa2Puorotra2zSYKrbKykoSuFxcXo7S0lISxqwpnZxubq0c+Z4987h5d54phw9/lo7BURWUpR2ipi8aSP6YuGktVVJZ8tFVt0VjykVs08qplo+3zW+fCTlPgdRZ2lixZgnXr1hETVXl5OUnWaGlpCX19fezYseOV+9+oQiqV4o8//sDSpUtJxXcvLy989dVXmDhxYoM+FB8+fIi9e/fizz//VKgub2lpieHDh2P06NF44403dK5FqKioQGxsLCkXwdbE0iTUuLi4wM/PT6H5+PjAzc0NQqGQmLHkTVmpqal4/vx5revhcDhwdHRUWQWdbY6Ojk0um3N5eTkKCwsVwteLiorIVj5Xj7qcPQ3p5KwKfX19hTB35a1yNJa66CzlCCxN0VgGBgbNRtikvJ40izw7lP8RExODyZMno6CgADt37kSfPn0a7VoRERH45JNPUFRUVOPYvHnzsHnzZgBQW0n8VcMwDCIjI7F48WJSKNXFxQXLly/H5MmTG0yTk5OTgz179mD37t0KdbHMzc0xYsQIjBkzBn379tWZc3FpaSnu3buHO3fu4M6dO7h//z7i4uJUmhw4HA68vb1JuYjAwEAEBQXBz88PJSUlePLkCWmXLl1CYmIikpOTa83nYmxsTExZrDmL3bq4uMDJyUln3w/DMBCJRMjLy0N+fj7y8vIgFAprzc1TUFBQrwgxdRgaGsLU1FShsdFX8n3laCz5ffloLLa97qHfqpIivqyjrybH35dx5K3NgVfb2lh1bUDNLNLKY/L79e2r2mo6xm4//fTTV5LuQxVUs4OmodmZPn06tm/fTvYvX76MHj16NPh1LCwsVAo5tra22Lp1K/GFairExMRg7ty5xCfIwsICX3zxBebMmQNDQ8OXPr9EIkFkZCR27tyJkydPEgc6gUCAIUOG4J133sGQIUOItutVIRaL8ejRI9y4cQM3b97E7du3ERcXp9KkYWVlhfbt26NNmzZo3bo1WrduDS8vL2RkZCA+Ph7x8fFISEggW02+OTweD+7u7vD29oaXlxcxYXl5ecHDwwPW1tavzBzAMAxKS0tr5OKRj8iSz8mTl5f3UkILh8OBhYWFQmOjsJTz9KjK18NGY70qTQjDMCQPkLwjsPI+6wysjXOwOofg2pyClSObVG21iXRSzuwsP05p/iQkJCi4oDQEVLPTzHj48KHCfkMIOiKRCOHh4ejQoQPWr18PoDqX0cWLFwFU+02sXr2aRLY1JYRCIZYtW4bNmzdDKpVCX18fH330ET7//PMGia7KyMjA1q1bsX37dmRlZZHxkJAQTJs2DWPHjn2ldbHy8vJw7do1XL16FdeuXcPt27dVOoc7OzuTchEdOnRAUFAQSktLERMTg9jYWBw/fhzff/89EhMT1T4geDwePD094efnB19fX/j6+sLHx4eYshpbMyORSPDixQuFaKysrCyFLZtwsD6ZgwUCAXFaZiOx2D4bjaUckWVhYQFTU9N65V+SSqXEv6agoKDWGlnKTsTaOA6rKwhKqYm6UgyanHY1lV1Q5bSrqhSDsmOuJoddTU689WkAah2v6xzlPruvao62W13UGmShmh00Dc2Oi4uLQiXzl/lnWbt2LZYuXUoellwul5g6ysvLsWTJEvz4448vt+BGQiqVYtu2bViyZAnJNDxy5Ej88MMPL12zSiaT4d9//8Wvv/6KEydOEGHA1tYWkyZNwrRp0xq9bAVLRkYGKRlx5cqVGikYgGotVkhICMLCwtCpUye4uroiKysLDx48wIMHD/Do0SMkJCSoDec0NzdHYGAgAgICyNbPzw9eXl6NlgumvLyc5N3JyMggEVmZmZnIyMjA8+fPkZOTU6e/b2NjY5KLRzkaSz4ii43GMjY2Vqt9YqObtK2PJe9YzBYBVXYqbkgT2MvA4/E0lm3QpkyDKgdheUdgdfuaIp1epu6UqsgmTVFM1Am54ZHJZETbx+FwSNJOLpdLIveKi4tRUFCgoBW0s7ODnp4eZDIZjIyM4Orq2igvUtRBuQ40BWHH1NSUhOSyKevrQlJSEvr374+UlJQax/T09JpF/on79+9jxowZiI6OBgC0atUKP//8M954442XOm9ZWRl+//13/PTTTwpCRa9evTB79my8/fbbjZ4ILicnB//99x/Onz+Pixcvqiz2GRgYSMpFuLi4QCgU4v79+7h79y7u37+v1unYzMwMrVu3RqtWrYiPTlBQEBwdHRv0x59hGOTn55NoLDYKi92mp6fXKIWhDh6PBwcHBzg6OsLJyYn02Wgs+agsY2Njhc9KJBIFvxtl/xvlGlnKjsaNmetD3sdGlfMwu6/sNKzJeVi5dINyGQdazqFhYBgGEomECLWVlZUoLy+HWCyGlZUVxGIxEdJZP68nT54gPz9fIWQ/ICCAPPDNzMzw/PlziMVixMXFIS8vT8Ec2KZNG7Lv7OyMpKQkSKVSJCcnkySZrH+Qj48PgOq/f29vb8TFxUEmkyE7OxvFxcUKfkBsJK1MJkNAQABiYmIglUpRWlpKXoLZe2Ezc8tkMgQHB+PBgwcKPknqCA4OVvBt1IS/vz/atm2Ln3/+uUaU78tChZ060BSEHT6fr+AvUpe3RXXVxJ2cnPD333+jc+fODbbOxqCsrAzLli3Dhg0bIJVKYWZmhhUrVuCDDz54Kf+HjIwMbNq0Cb/99htxtjYzM8OUKVMwa9asGtm7G5KKigpcunQJ586dw7lz52qYKblcLjp06IBevXohICAAXC4X8fHxiI6Oxt27d1UWp+VyueRHo23btmjTpg2Cg4Ph6uraYEJNRUUFicBSjspKTU3VKkeOsbExXF1d4erqCmdnZ4WoLCcnJzg7O8PW1hY8Ho/45Wiqj5WXl0ecjvPz81X6nNUVDodD/GxYnxtVTsXKDsXqSjywQszrrFlgfYjYyDY2BD8xMREFBQVESyaVSmFubo6KigpwuVwUFRWRh3BiYiIqKipQVVUFiUQCDodDBA2BQEByDkkkEiI4sA95DocDIyMjyGQy6OnpgWEYlJeXg2EYVFVV1XiBZP+tWJOSLhPevS6cP3++wYNvqM9OM0M+oqa2fC3p6eno06cPbt26BWtra+jp6UEgEKCqqgoCgQDz589/JTWoGoLTp09j9uzZSE9PBwCMHj0aGzZseKmEkPHx8Vi9ejX27NlDfsC8vLzwySefYNq0aY2WzTglJQWnT59GZGQkzp8/X8PfpF27dujevTscHR1RXl6O+/fvIyIigiRElEdfXx9t27ZFhw4d0L59e7Rv3x7BwcEN4pRdWVmJ5OTkGkkFExMTkZGRUauJydHRkURjyUdlsUkGLSwsIJVKkZOTo1Ab6/bt28Qf52X9coBqM52qjMgWFhakVpYqR2PWkfhVVLnXBlajoOyPI99X1VhzXFlZGcRiMUpKSiAWi5Gfn0+0E5mZmQpOy0D1y5RYLAaXy0VZWRlxFi4vL6/xNi8vvLHCQlN+P67LSyJ7Hy0xgWJTRVvNb2NAhZ0mgvwPiL+/v8o533//PZYtW0Z+tHr27InY2FgAQFRUFLy8vBQyGzdlCgsLMW/ePOzevRtAdebjTZs2vVQ+n+joaHz//fc4evQo+T579eqFefPmYejQoQ2u5mdLRhw/fhzHjh3D48ePFY47OTmhW7dusLW1RVlZGe7evYtNmzbVeFjo6emhTZs26Ny5Mzp37oxOnTohKCjope3beXl5iI+PR1xcHInKio+PR2pqqkYzqampKYnGYpMLstFYrANzZmamQl2sf/75h/jnZGRkICcnp06mWENDQ4UaWawvjnKWZHlH48aKemI1AZoS/cm38vJylJWV1UgmmJubS5yQKysriQaCNXdUVlYSQYNCaerU5pyszbinp+erXjaBCjtNhICAAMTHxwMApk6dSsbFYjG6detG/FjkkTcphISENPoaG4p//vkH77//PjIyMkhJkBUrVtTwzdCWGzduYNmyZTh79iwZe+utt/D55583eH00sViMCxcu4MiRIzh+/LhCyQgul4v27dvD1dUVFRUVePjwIQ4dOlTjHB4eHggLC0NYWBhCQ0PRrl27lwptFwqFePToEWJjYxEbG4vHjx8jNjZWY2JBExMT+Pv7w9fXlyQVZJulpSWeP3+uUBvr+vXrSEtLQ2pqKjIzM7V6QMv75cj75qjKlFzff3sW1mTB+uUUFhYqOB+zeXZYrUd+fj5JEMiGrLPCBzVnNE3qkkFZVUZldaUhmkK5CPlW25i6iDF1c2orBaHNnJZAnX124uLisH//fkRFRSEtLQ0ikQi2trZo3749Bg4ciJEjR+o8q2xdaQo+O6r4888/MWHChBrj3t7eiIqKUqgE3xwoKSnBggULSAFRb29v7N69G927d6/X+W7fvo1ly5bh9OnTAKofrhMmTMCiRYvQqlWrBlu3WCzGf//9h8OHD+Po0aMQCoXkmJGREQICAsDj8ZCcnFxDTaunp4eOHTuiW7du6NatG7p27QoHB4d6rUMikSAhIQH3798n0VgPHz7UmNnY3d2dRGIFBATA398f/v7+sLW1RVpaWg0zVmJiIlJSUmp1aOfz+XBxcSGmK1UZk+3s7OqsTauqqsLz58/x7Nkz5OXlITU1FTk5OUhPT0dSUhKKioqIhoXL5UIikRAfD5qLpe7o6elpzKCszhlaVbkIVVFg+vr6ChFgdY0Kky/78Dr7Q1HU0+AOynfv3sVnn32GK1euoFu3bggJCYGTkxMMDQ0hFAoRExODqKgoFBcX47PPPsPcuXObjdDTVIUdecdjHo+HWbNmYePGjTpeVf24ffs2xo8fj8TERADAxx9/jO+++65eb/QxMTH48ssvcfz4cQDV382kSZOwZMkSeHt7N8h6GYbBtWvXsHfvXhw8eFBBiDE1NYW9vT3JyCuPoaEhunbtip49e6JHjx4IDQ2tV0HS8vJyPHr0CHfu3CHRWI8ePVLrk+Du7o7g4GASkdWqVSsEBASAYRhiynr8+DFJLJiUlKQxTwufz4e7u7tCbSzWP8fDwwMODg4Kb3xSqRQlJSXIzMxEfHw8cTTOy8uDqakpKioqkJOTAzMzM9y5cwdFRUXIz89HQUFBrVEfrxM8Hg8mJiYKGZQNDQ1rZFVWju5S1eTLRrACjXzEl76+Po3gojR7GlzY8fT0xKeffooJEyZodKC9fv06fvrpJ7Rp0wZffPFFnReuC3Qt7Ny4cQNvvfUWjIyMEBERgZ49e5JjM2fOxKhRo9C/f/9Xvq6GQCaT4ccff8QXX3wBiUQCV1dX/P777+jdu3edz/Xs2TMsXboUERERYBgGXC4X77zzDr766iv4+vo2yHqfPHmCiIgI7Nu3D6mpqWScfWAol9AwMDBAt27d0KdPH/Tp0wedOnWqcxh7VVUVHj16hOjoaNIeP36s0lRkYmKiEI3VunVrBAcHQ19fH/Hx8YiJiSH1sWJiYpCWlqb2uvr6+sR05erqCicnJ9jb28PCwgKurq5ITExEYWEhYmNjER0dTaJpysvLYW9vT0LAu3btir///rtO96wN+vr6JLcH0DCOpGyekIaCjeiS36qL7GKju9jSEKrKRTR2CgQKpaXR4MKOWCyuk8NkXefrEl0LO6NGjcKRI0cUxhwcHBQy+zZHsrKyMGXKFJw7dw5A9X1u3bq1zlk0CwsL8f333+Onn34iOSJGjRqFlStXqnXmrgslJSU4dOgQdu7ciatXr5Jx9q1X/iHL4XDQuXNn9O/fH/369UNYWFid/G0YhkF6ejpu3LiB69ev48aNG7h//75KjY2trS3JlNy+fXu0a9cOXl5eKCoqItqeBw8ekBpZ6nxNTExMYGVlBW9vbxQXF4PD4SAvLw+ZmZmQSCQqH/6zZs3Cli1btL6v2mBNG6amppBIJCTRZXl5OSldUFdeVnARCAQkkouN2qotiku+ZERTiuiiUF5XGjz0vK6CS3MRdJoCrGOyPE0lK2t9OX/+PMaNG4fc3FwYGhri559/xnvvvVcnu7tUKsX27duxZMkSEp7ds2dPrFmz5qUdjxmGQXR0NLZs2YIDBw5AJBKpvD5QXaJh0KBBGDhwIN544w1YW1trfZ2qqircu3cPV69eJaUg5J2aWSwtLdGpUyeEhISgffv28PX1hUAgQHR0NCIjI/HPP/8gMzOzXkUr2ay/b731Fn755ReNc9ncN9oKOpaWlrC2toaJiQkMDAzA5XJRVVWF0tJSCIVC5OXlQSaTkXBpbfL0aAsr6HC5XFhZWZHILWtra9jY2CiUiZAvEcFGc73ueXEolNeJekdjlZWV4dKlS0hPT69h+//4449femGvEy9evKgxNn78eB2s5OVhGAZr1qzBF198AZlMhjZt2mD//v0IDAys03kuX76MTz75BPfv3wdQnV149erVGDp06Es9oMrKyvDnn39i06ZN5NzK8Hg8dO/eHeHh4Rg8eDCCg4O1vqZIJMKNGzdw6dIlXL58GTdv3qyRR4bD4cDMzIwIBxKJBC4uLkhPT0d0dDTatm2LS5cuaXW9kJAQ3Lp1q8b52dxLfn5+sLW1hUQiQXp6OoKDg1FQUIAXL16o1KbIa7HMzMzg6uoKKysrUnWbFVhYzRCbsbihsbCwUIjWsre3h62trcpyERYWFtT3hEKhaKReGZTv3buHwYMHk9wTVlZWyMvLg5GREezs7JCcnNwYa200dG3GMjIyqvFALC8vf+WVtl+WoqIiTJkyBceOHQNQHUL/66+/1ikRXmZmJhYsWIADBw4AqH7off3115g9e/ZLaQtTUlKwbt067Ny5U6UWx8zMDIMHD8awYcMwaNAgjaY2qVSK/Px8iEQixMXF4erVq/jnn38QHx+vVnPh4eGh4ANUFzgcDvh8PoyNjWFlZYXevXujffv2sLa2RmBgIPFrycjIQGpqKp48eUJC0DWFn/N4PHh4eMDV1RXm5uYQCASQSCSk0nh6ejoKCwvrtWZ192FnZ0cyKTs5OakNSW8uwQ0UCkW3NGoG5Xnz5uHNN9/Eli1bYG5ujhs3boDP52PixIn45JNP6r3o1xVVb/7NTdB59OgRRowYgcTERAgEAmzcuBHvv/++1hoRqVSKX3/9FV9++SVKSkrA4XAwY8YMrFixAra2tvVaE8Mw+O+//7BkyRLcvHmzxnF7e3uMGjUKw4cPR48ePVBeXo6SkhLcv38f2dnZuHHjBm7evIm8vDwUFhairKwMxsbGJILI2dlZoXirJoYPH46DBw/C0NAQIpEIQqFQpTnK0NAQnTt3RteuXdG1a1eEhIQo1JJha+zcv38ft2/fxq5du/Dw4UOVpjEWFxcX+Pj4wNbWFvr6+pBIJCgqKkJmZiYSExNV1umqKzweD05OTiQMXb5cBNscHByoeZtCoeiEeml2LCwscPPmTfj7+8PCwgLXr19HYGAgbt68iSlTpqj0QWnK6FqzoywQWFtbqywh0FQ5ceIEJkyYgNLSUri7u+Pw4cPo1KmT1p+/e/cuZs6cidu3bwMAwsLCsHnzZrRr165e66msrMQ333yDLVu21AgNNzY2ho2NDfh8PsrLy1FcXAxTU1MIhUJUVFTggw8+wK+//lqn67GOrnp6eiRc29XVFSEhIRCLxbh//z6uXLmC69ev1zAdOTs7o0ePHiQPT+vWrUlmYPkorbt37+LevXtqw885HA48PT3h6+sLa2tr8Pl8iEQivHjxAk+fPtWYi0fbe2TDzuXD0NlSEU5OTo2W0ZhCoVDU0aiaHT6fT6IQ7OzskJ6ejsDAQJibm+PZs2f1WzGFMG3aNF0vQSsYhsHatWuxePFiMAyDN954AwcPHtTagVckEuGrr77Chg0bIJPJYG5uju+//x4zZszQKspFIpEgOzsbt2/fRlRUFG7fvo179+6hpKREYZ6enh6JVGLT/8sjP9/Q0BD+/v4wMjJCQUEBsrOzSQQYi4mJCfr06UMclgMCAojAypZOiIyMxKZNm2oU9HRzc0Pv3r3Rq1cv9OrVC15eXiSqKDExEfv27cPNmzcRHR2NBw8eqMyFY2ZmhuDgYDg7O8PAwACVlZXIyspCQkIC/vnnn1q/N3XY2NjAx8eHlIlgS0Z4enrCycmJRh5RKJRmS72Enfbt2yM6Ohq+vr7o1asXli5diry8PPzxxx8IDg5u6DW2eFiplGX58uW6W4yWVFZWYubMmYiIiABQHar8888/a22muHr1KqZNm4anT58CAMaNG4f169eT7MISiQSxsbG4e/cuYmJikJSUBBsbGxQVFeHZs2fo1asXfvjhB62y5s6aNQt79+6Fk5MTjIyMIBQKYWtrC2dnZ7i7u6Nnz57w8PDAgwcP8M8//+DFixcKTrccDgchISEYOHAgBgwYgJCQEHKfUqkUV69exYkTJ3Dq1ClSq4zFysoKb7zxBvr27Yt+/frB29sbHA4HlZWViI6OxsGDB3Ht2jXcuHFDpTbP0tISbdq0IdmIi4qK8PTpU1y/fr1eYddmZmbw9/eHn58fab6+vvD29q61AC2FQqE0V+plxrp9+zZKSkrQp08fvHjxApMnT8a1a9fg6+uLnTt3om3bto2x1kZD12as5kZ+fj7eeustXL16FVwuFz/99BM+/PBDrfxzRCIRlixZgvXr1wOofphPmjQJ5ubmcHV1xb59+5Ceno60tDSNSeTCw8MRGRlZY5zD4cDFxQUzZ85Ez549iTOsKh+ozMxMHD16FMeOHcPFixcV8tRYWVlh0KBBGDx4MAYOHKhQYLWsrAz//PMPjh8/jlOnTikIKVwuF6GhoRg0aBDCw8PRoUMH8Hg8iEQiXL16FRcvXkRUVBRu3bpVwxwlEAiIxobH40EoFCIuLk6jk7E6nJ2dERQUhMDAQIVyEfb29jTcmkKhtBgaPKkgC6tur6qqgr+/f4uw01NhR3tSU1MxaNAgJCQkwNzcHAcPHsSAAQNqzKuqqiK1027evInU1FT8888/uHfvnlqNxEcffVQjDwyPx4ORkREsLCzQtm1bVFRUIDo6WkETBlQLJ0uXLsWsWbM0RvIkJyfjr7/+wpEjR3Djxg2FYwEBARg2bBiGDRuGsLAwhXDm4uJinDp1CocPH0ZkZKSCU7mFhQUGDx6MoUOHYsCAAbC2toZYLMaNGzdw/vx5nD9/XqW/jq2tLfz8/GBiYoKSkhIkJiaqTEOgCRsbG7Ru3ZpkUm7VqhWCgoKoloZCobwWNIrPTkpKCoYNG4bHjx8DqI7yOHLkSJ2cUSmKnDt3DkOGDIFAIMDdu3fh5+en6yWp5f79+wgPD0d2djZcXFywb98+FBUV4YMPPkBCQgLS09ORm5sLgUCAvLw8MAyDOXPmaKzn5ejoiLZt28Ld3R19+/ZFaGgocXh1cnICn8/HiRMnsGXLFpw8ebLG5+3t7fH1119j2rRpalPtp6Wl4eDBgzhw4ADu3LmjcKxr1654++23MWzYsBrffVlZGU6cOIE///wTZ86cUfCf8fDwIJ/r1q0b+Hw+kpOTcfDgQfzzzz84f/58Dd8he3t7uLu7g8fjISsrC6mpqVprbXg8HgICAtC2bVu0a9eOlIugmhoKpXnDMAxkMhlpte2rOqbpM8pzGIYhTX5fm766ps0chmEwcOBAmJqa6uR7rpOw8+mnn0IikWDPnj0wMDDADz/8gJkzZ9Z4gFC0Z8WKFRCLxRCLxfD3929S2iWJRII7d+7gypUrePz4Mfbs2YOqqirY2dmhoKBAoYaXKtj8OpaWlsQHxt/fH3PnzkXv3r3h5+en1uk1NzcXGzZswObNm1U6vdvZ2WHp0qV4//33VWpycnJycODAAezfvx/Xr18n4zweD7169cLIkSMxfPhwODk5KXxOLBbj7Nmz2LdvH44dO6bgzOzn54dRo0Zh5MiRaN++PSQSCa5cuYLFixfj5MmTePLkicK5zMzM4ObmBplMhrS0NOTk5CAnJ0fjdwZUm7PatGmDDh06kBYcHFynfEUUii5hGAZisZiUAmGbRCJR2Jcfk9+yTXlfXZNKpWr77L6qvqp9qVQKmUymdl9VX9WWbcr7ymOvEwkJCc1D2Lly5QoOHz6M7t27A6gOEXZxcSH5Ryh15+HDhwr7r1rQYRgG2dnZEAqFuHbtGp4+fYqbN2/i5s2bassSDBkyBLt27QKHw4GDgwNEIhHs7Ozg5uYGf39/9OnTBz169MCFCxcwa9YsFBUVwdTUFJs2bcLEiRM1aiLu3buHDRs2YP/+/USTwufziQnI1NQUn332GebOnQsTExOFz4pEIvz999/Ys2cPzp49S3x+OBwOevXqhbFjx2LkyJEq8/Y8ePAAERER2LNnj4K2xdPTE+PHj8e4ceMQHByM0tJSnD59GmvWrMGZM2cUzGlsrhkOh4PMzEwUFxcjJiZG4/fP4XDQqlUrdO7cGZ07d0ZISAhat25NC0JStIIVKioqKhRaeXk5KioqUFlZScbYfmVlZY2+fKuqqiJb5b6qxgo18v2GKNpKUQ+XyyWNw+GAw+HU2OfxeGRc3Ry2r2pM3b66ps08XeaPq5PPDpfLRVZWlkKSMxMTEzx69Aienp6NssBXgS59dng8HpHuG7P4Z0FBAf755x9cu3YNjx49QkpKCrhcLnJzc1FaWorZs2dj8+bNGs/h4+OD2bNno3v37jAzM4Onp6dKrUplZSXmzZtHzhcWFoa9e/fCy8tL5XllMhlOnz6NH3/8ERcvXiTj9vb2yM3NhUwmA5/Px+zZs7FkyRIFYYVhGERFRWHXrl04fPiwQgbj0NBQTJgwAaNGjaqhwWG/kz/++AO7du1SKB1hZ2eHcePGYfz48QgNDYVQKMTx48fx119/4ezZswrmLCMjIxgbGyM/P1+rtzQbGxt06dIFYWFhCAsLQ+fOnXX2pkNpXGQyGckyX1ZWhtLSUtJnG3tcJBIp9MvLy8kY2y8vL6/RKioqmo12gMfjgc/nKzQ9PT2V+3p6egpNfow9D9uX37J95X3lrTaNy+XWOi4vdCiPyc9VHmMFA+VzyI/JCxDyY9RsrUij+OxwOByUlpYqqNO5XC5KSkoU8ok0FTNMc0D+h2rWrFkvfa6srCwkJiYiLi4OZmZmiIiIQHx8PNLT09V+jv1POGjQIPj5+cHT0xNlZWXIyckhDsOzZs3Cpk2bas21kpqaitGjR5MEgV9++SWWL1+u0pG9oqICERERWLduHTEB8Xg8dOzYEU+ePCEmnzfffBM//vgjfH19yWczMjIQERGBXbt2KWQA9vLywsSJE/HOO++o9H9iGAbXrl3Db7/9hkOHDpEcOgKBAMOGDcOUKVMwcOBAiEQiHDt2DN988w3OnTunEKllZGSEyspKSKVS8kBSh7+/P7p164bu3bujW7du8PX1pT9WTRipVIqSkhIUFRWhuLiYbOUb+3tXUlKi0NiCq2xfOZ/Tq8DAwIA0fX19GBoaQl9fn+yz29qaQCAgW/m+vr4++Hw+2bLH2b78VrnRv3uKLqmTsMMwTI0HCMMwaN++PelzOByqwqwnkydP1moewzDIyclBdHQ0IiIi8PjxY2RmZqKkpEQh0mnixIk4e/Ys2edwODAxMYGjoyO8vb3Rq1cvvPXWW/Dy8qphNlmzZg0RdObPn48ffvih1h+rkydPYvLkySgoKICVlRX27NmD8PDwGvOKi4uxZcsWrF+/npQ5MDc3x/Dhw/HgwQNS2DIgIAAbNmzAwIEDAVT7EEVGRuK3335DZGQkERRNTEwwduxYTJs2DV27dlW5zpKSEvz+++/49ddfiYM9ALRp0wbTp0/H+PHjYWJiglOnTmHs2LE4ffq0ghlPPjGhJuGmdevWJGFgz549YWdnp/E7ozQ8FRUVEAqFpLHFSoVCIQoLC0krKCgg/aKiIhQWFtZwKm8ojI2NNTYjIyPSjI2NYWhoSPYNDQ1JY/cNDAwUxlkhhgoUFIpq6iTsXLhwobHWQUF1hI8yKSkpuH37NnJzcxETEwMXFxf8+OOPNcogyOPp6YnAwEB06dIFffv2ha+vL/z9/RVyxaiDYRh8/fXX+PrrrwEAX331Fb7++muNP6IymQzLli3DypUrAVRX4j506BDc3NwU5rFOx5s2bSK+Li4uLpgzZw4yMzPx66+/QiqVwtTUFN988w0+/PBD8Pl8ZGZmYtu2bdixYwcyMjLI+Xr16oV3330XI0eOVOszlpiYiE2bNmHnzp1E+2hkZIRx48ZhxowZ6Ny5M27fvo2lS5di//79ar9Xec2OPAEBAejbty/eeOMN9OrVS+vs0RTtqKqqQm5uLnJzc5GXl6fQz8/Pr7EVCoUahVFt0dfXh5mZGczNzWFqagpzc3OYmZmRZmpqqrKZmJjUaIaGhjT7NIWiY+ok7PTq1aux1kEBEBMTgwcPHmDHjh2IiYmBUCisYY/v3bs3JBIJuFwuvL29UVVVBWdnZ7Rt2xbdunWrkQCvrixfvhzffPMNAGDVqlVYvHixxvklJSWYNGkSqXQ+Z84c/PjjjwqaotzcXPzwww/YtGkTUe0HBARg0aJFMDc3xyeffEIirkaPHo0NGzbA0dERUVFR+OWXX3D06FGiLbSxscHUqVMxffp0tWH6DMPg8uXL+OGHH3Dq1Cmi7fLz88OcOXMwefJkSCQS/P7775g2bRri4uK0/n7s7e3Rv39/9O/fH/369VPpC0TRTEVFBbKzsxUaG6mWk5ODFy9ekFbfqutcLheWlpawsrKCpaVljWZhYUG2FhYWMDc3J1szM7NmV4iXQqFopvlnBGwhcDgctGnTRuUxfX199OvXD8HBwQgJCUFwcDDc3Nwa/Af522+/JYLO+vXrMXfuXI3zk5OTMWzYMMTGxkIgEGDbtm0KprgXL15g7dq1+PXXX8nbdocOHbBkyRL06NEDc+fOxd69ewFUa7U2bdqEPn36YM+ePdi4caNCpFrPnj0xa9YsjBgxQm3SQKlUiqNHj2Lt2rXEFAYAgwcPxkcffYT+/fsjKioK77//Pv7++2+12hp59PT00KNHDwwaNAgDBw5E69at6Vu6GqRSKbKzs5GZmYmMjAxkZmbi+fPnCi0rK0uhFIc28Hg82NjYwMbGBra2trC1tSX71tbWZMs2KysrmJmZ0X8nCoVCqJOwI59RVhPUZ0d7WK1Dp06d8PTpU7Rp0wZubm7Izc3FyJEjMWTIELi4uDT6OtauXYslS5aQfm2Czvnz5zF69GgIhUI4ODjg6NGjCAsLA1Ad5fTDDz9gw4YNRMjp1KkTli1bhiFDhuD48eMIDg5GTk4OuFwuFixYgNmzZ2PXrl2YPHky8vPzAVTn6Zk0aRI+/PBDtYIgUG3qiIiIwOrVq4mzsr6+PqZNm4Z58+bByckJv/32G9577z2tqn87ODhgyJAhGDx4MPr160cd7lH9dyoUCpGWlkbKeTx79kyhZWVlaf1/XyAQwNHREQ4ODnBwcIC9vT1pdnZ2sLe3h62tLezs7GBpaUkFFwqF8lLU2UHZ3d0dU6ZMIU7JlIbh3LlzsLCw0ImD4U8//YTPPvsMALBy5UosXLhQ4/ydO3dixowZkEql6Ny5M44ePQpnZ2eUlZXh559/xpo1a4j5oXPnzli+fDnCw8NRUFCAiRMnYt++fQCAwMBALF26FOfOnUNAQAAJ6fbw8MCcOXPw7rvvwtLSUu06KisrsXPnTqxatYqYwSwtLTFnzhzMmTMHWVlZ+OSTT/Dvv//WqsVp3bo1hg0bhrfeegsdO3Z8LR+uJSUlSE5ORnJyMlJSUkhLTU1FamqqVtFFbK4hZ2dn0ths2E5OTnBwcICjoyMsLS2pMy2lRSCTyVQmQdSUEFE+8aE2CRJVbWtLkKgqWaKqhIm1JU+sLaGifIJEdX22RUdHw9vbWyf/TnUSdm7duoUdO3bgp59+gqenJ95991288847Gh9IFM2wuRR27dqFSZMmvfLr//bbb0SLs2TJEnz55Zdq5zIMg2XLlmHFihUAgAkTJmD79u3Q09PD5s2b8fXXX5Nw8VatWuHbb7/FsGHDwOFwcOHCBUyaNAmZmZngcrl45513UFBQgPHjx5Pzh4WFYcGCBRg+fLjGmmsVFRXYtm0bVq9ejczMTADVZSc+++wzTJ48GTt27ECHDh3IMXV069YNI0aMwNtvv92s80TVBaFQiMTERDx9+pRsk5KSkJSUpFXpCjs7O7i7u8PNzQ1ubm5wdXUlWxcXF9jb22utAaZQWNjkiOqSGapKdqhNckP5PpuxWV2f3dc2yzO7bS55jpoC2rgONBb1qnpeUVGBw4cPY9euXbhx4wbefPNNvPfee+jfv39jrLHR0VVSwYyMDLi6ugIA2rVrhw4dOqCgoABLlixBhw4dGv36hw4dwtixY8EwDD799FOsXr1a7dt2VVUVpk+fjt9//x1Adf6cb775BidPnsSiRYsQHx8PoDoS7JtvvsH48ePB4/FQVVWFpUuXYs2aNWAYBs7OzrC3t8fdu3cBVAt7b7/9NhYuXIguXbpoXC/rVLx8+XKiyXFxccGiRYsQGBiIH374QaMWh8PhoHfv3hg1ahTefvttODo61ut7a+pIJBIkJSUhLi4OCQkJCo01EarDxsYGXl5e8PT0hIeHB9l6eHjAzc2NlqxooUilUpUJC9mtpr5yU87aLJ+tWVXWZlaIaWkoJ0eUT4Yov68qAaKmBInqkiQqJ0zUlEBR24SJmvrqEiaqOsbue3h4aCzUXB8aJakgi4GBASZOnIiJEyciJSUF7733HgYNGoTc3FxYWVnVe9GvG/IVvrt3745du3ahrKwMixYtavRrnz9/HhMnTgTDMJg1a5ZGQaeoqAijRo3Cv//+Cx6Ph82bN6NDhw7o27cvyXhsY2ODZcuWYcaMGSQSKyEhARMmTCCCja2tLTIzM5GZmQk+n49Jkybhs88+g7+/v8a1ymQyHDlyBF999RUSEhIAVAs5H3zwASorK/Htt9+SfD2q6N69O8aOHYtRo0bBwcGhrl9Vk0UsFuPp06eIjY1FTEwMHj9+jLi4ODx58qRGhXV5nJyc4OPjA19fX/j4+MDHxwfe3t7w8vKCubn5K7wDijZIJJIamZdry8TM7stnYlaVkZndavp70QU8Ho8kLGSTGconOVRuyokO65rwkD2mnNG5Ltme5ccawgzOFth8WXOUNnW8VM2RyWRE26ZNnS/lYqSq5s6dO7fBhR1tqXc0VkZGBnbv3o3du3dDJBLh008/pY6cdUS+NIKjoyPKysrg6emJkJCQRr3u3bt3MXz4cFRVVWHkyJHYuHGjWkHnxYsXGDhwIO7fvw9jY2Ns3boV//77L2bMmAGgWvCdO3cuFi9erPCg3Lt3L2bMmAGRSAQejwepVIrc3FwYGhpi5syZmD9/PtFqaSIqKgrz588nGZmtra0xePBgZGRk4IsvvlD7uTZt2mDixIkYN26cVtdpyjAMg6ysLDx8+BAPHz7EgwcP8OjRI8THx6t9SBkZGSEgIAD+/v4KzdfXt0ZNMUrDwTAMKioqFLItq2vy2ZZVNbbExKvWerCZluUTFrJbtinvK2dult9qm7VZPkuzOlOocoHR2sxUqpq8mYoVJDWZqTQVKtXkh6NuX9ttSzSPTZ48WWe5yOok7FRVVeHo0aPYsWMHoqKiEB4ejg0bNiA8PJza6etBamoq6V+7dg0AMG7cuEZ13ExKSkJ4eDhKSkrQu3dv7NmzR+2/XXp6Ovr3748nT57Azs4OEyZMwOzZs0lyvokTJ+Lbb79VSB5YUVGBTz75BFu3biVjUqkURkZG+PDDD7Fw4UKtsgonJSVh0aJFOHLkCIDqh3e7du0QHx+PP/74Q+VnHBwcMHnyZLzzzjsao7eaMjKZDE+fPsW9e/cUWl5ensr5JiYmaNWqFYKDgxEUFITAwEAEBQXB1dX1tXSyfhkYhkFpaWmNrMpsX76pKyVRXFzcaH4JPB4PxsbGMDExIZmW5bMvq8rGLN+UszLLZ2eWz8zM5XLBMAwkEkmtpip5c5T8fnl5OQoLC7UqMKpqTN7nRr7p0uejqcHWzNLGTFWbGUobc5S6Gl+q6nypqvvF5XJ1qhCpk8+OtbU1TE1NMWXKFEyaNEntQ6u5aXh05bNjYGBA3trYyt4PHz5E69atG+V6OTk56Nq1K5KTk9GuXTtcvHhRrdkiISEB/fv3x7Nnz2BrawsTExOkpKQAqA4j/+WXX0ioOUtycjIGDx5MTE0A6izkFBUVYcWKFfj5558hFovB5XLh4OCgNmScx+PhzTffxMyZM9G/f/9mJXQzDIPExETcvn0bt2/fxp07d3D37l2VJQu4XC78/f3Rpk0btGnTBq1bt0br1q3h5uZGhRo5WIFFuVyE8pYtFSFfMqKwsLBB02aYmJiozbhsYmJSY6uqsQKMiYkJeDweysvLa5ir1Jmp1BUPVfbLUeWDU15e3mw0C/JmKHUmKG3NUvJj6gqRqitWquxXo65YKVuNnH2pVX65ZffZRzNbhondZ/9dGIapU1SVNqYsdRFVmqKs1JmxVLUffvihwV0JtH1+17nqOfmgCu1Dc62NpSthR77iOVAdwRQTE9Mo1yovL0efPn1w8+ZNeHl54erVq2r/6O7du4eBAwciNzcXpqam5OFrZ2eH77//HlOmTKnxgN20aRPmzp1L3rz09PTw4Ycf4osvvtBKyGEYBnv37sXChQtJRJe+vr5aFb69vT0WLlyId999t9n4iQmFQty8eZO0W7duqSxPYWhoiDZt2qB9+/akBQcHv3bOwQzDoLi4mJSHUG75+fkKpSLYchEv63/C5/MVMivLZ1dmMywr9+VLSZiYmIBhGIhEIpXmKmXTlXxFdE2V0XXpxCsQCBTMUapMVrUVGlUuKFpbkVFWQ8A+V1gYhlF48CubqWozY2kbZaVsstJkwqqr+ep1JSEhQW3m+/rSKA7KtDZWw6L85jRu3LhGu87UqVNx8+ZNWFpaIjIyUq2gc/PmTQwYMADFxcWkoj2Xy8VHH32Er7/+uoYmKCsrC2+99Raio6PJ2NixY7FmzZoatbHUERMTgw8//BCXL19WGFf14x4cHIwffvgBAwYMaNJ5WhiGQUJCAq5du0aaqrIU+vr6aNeuHTp16kRaQECAxtD75kx5ebna0hAvXrxAbm4u2ebl5dVbcBEIBLCysoK1tbXGshHy5SNMTU3B4/GIz428yUq+5eXlITk5WWU19JKSkkavds7hcGBoaKhgsmL3VRUQVS4mquyHI2++YlNhAP8TKmQyGaqqqupkxmJbcXFxvcxYr7O5SlUUlabIqldlxlKOrNI0ps6M9TKljF76e63LZFobq2Gxt7cnWoyQkJBGE3aWLVuGgwcPgs/n4+jRo2ol65s3b6Jv377kx1omkyEkJARbtmypkUSyrKwMq1evxqpVq8gPk6enJ44dO6a1Ga6srAxLly7Fhg0balWZh4WFYfv27WjVqpVW537VSKVSPHjwAJcvX0ZUVBSioqJU5q3x9fVFWFgYQkNDERoaijZt2tSoON/cYJ3Ps7KyFJp83St2W5+q4sbGxgolIuTLQyiXimALwlZUVBBzlXwrLCxEYmKiyqrnDV3xnMfjKZiqjI2N1Zqs5Cugs/tGRkYQCAQKGg7Wl4Y1Q9VmxsrLy6vVjMVumzq1RVdpE3GlKpLqVZuxNIWQU5N046G1sFNWVqa2snRDzH8d0RQu3VD8/vvvpBr51q1b1Qqsly9fRv/+/UkWY3Nzc3z//feYPn26gh8MwzDYt28fFixYQAQ1AFi4cCHWrl2r9bpOnz6NKVOmqHW8ZWnTpg127dr1SvIO1QWZTIaHDx/i/PnzuHDhAi5fvkwct1kMDAwQEhKCrl27omvXrujSpYtO32zqCsMwKCoqInWu2FpXyjWvcnJy6qSa19fXJ2Uh2NIQdnZ2pDyEra0trK2tiRBYWlpaw2wlFAqRnp4OoVBIzFdCobBBHtoGBgbETKXKbKXcWAFGIBAQbaNUKoVYLFZrumJbfn6+RjOWLkwerOZI3iQlH32lHG0lb6pSZcZSNlVpMmmxZizlsHI9Pb0mrcltarAaufpmRa7NP6e2MXVt8ODBMDU11cl3orWw4+Pjg08++QRTpkxRm4yNYRj8+++/WLduHXr27InPP/+8wRZKqTts0UsAWLx4MaZOnapy3rZt2zBr1iyiXRk+fDg2b95cw9R1584dfPzxxyRyDABMTU1x4sQJrbV+qampGDVqFO7cuaNxnru7O9avX4/hw4c3mR+5lJQUnDt3DufOncP58+dr+NuYmZmhe/fu6NGjB3r27ImOHTvqLKeENpSUlCA9PR3p6ekKNa4yMjJI09Ykw+VyYWdnB0dHR4WaV46OjqTmFVu4ViQSEXMV2xITE3H9+nVivsrPz6+3gyyXy1VrtrKysiL+OGwzNDQkb9QymQxlZWU1Iq/YlpmZibi4OAXTFbttTIdePp9PIq7ko6/qEmmlyoylyqzF5/ObzP+5+qDKj0dbnx1tws+VGzteW+i5Jh8ebfvy+7Xl2WmKPHnypOkLOxcvXsQXX3yB5cuXo23btujUqROcnJxgYGCAgoICPH78GNevX4eenh4+//xzzJw5szHX3SJwcnJCTk4OXF1dERcX16AOqOnp6RgxYgTEYjFGjhyJb7/9tsac8vJyvPvuu9i/fz+A6h/U3bt3Y8KECQrzcnNz8eWXX2L79u2Q92dv3bo1Tpw4AXd391rXk5ubi1mzZuHo0aPQ5BNvYGCAJUuWYOHChToXFEpLS3HhwgVERkbi7NmzpMgoi4mJCXr06IE+ffqgT58+aN++fZOJBmMYBnl5eUhNTUVaWhqpb8UW8kxPTyf1y2rD0tISLi4uKutdmZubg8vlQiwWE1MWa766e/eugm9OffwwzMzMaq1wbmVlRQQWhmFQVVWl0oRVUFCAlJQUYrpizVgN6fjL4XBqRFzJm66UzVjyZitlM5Z8KHlTMnXKZDKVWZFV+eyoCj1X9tWpS+i5qvIQyk7Jr7MDcF2Q96t52dBzbX122BcendxvXctFpKen49ChQ4iKikJaWhrKy8thY2OD9u3bY+DAgc0y546uorHk354uXbqEnj17Nsh5y8vL0aNHD9y5cwft27fHlStXYGRkpDDn1q1bGDt2LMn1Y29vj9u3bytUWJfJZNi5cyc+++wzFBQUKHw+PDwcBw8erDVBXXZ2Nr799lts3rxZ5Y+QQCAgprOhQ4fi559/1mmdqoSEBJw8eRKRkZGIiooiawOqHQfDwsLQv39/9OvXD507dwafz9fZWkUiEVJSUpCUlFSjgKe2hTstLCxIbSv5ZmdnBz6fD5lMhry8PAWzFduysrJQWlpapzWbm5srmLDkTVesXw7rLCuRSFBUVKQy+krefJWfn6/w71QfOByOgrmqrmYsU1NTmJmZwcjI6JVqRWQyWQ3fHVWh5+rC0OV9drQtB9HUsi1rg6rMyHUNPVeVLVlTmQdVPjvy5SG0LfvQEA7KysdYgUQVmkxUdcmgrKoFBgbqrFxEvWpjtTSagrBz//59tG3b9qXPyTAM3n33XezevRvW1ta4c+eOgualqqoKK1euxHfffUeEj6CgINy6dUvBx+rRo0eYNWsWMVnZ2toSh9uZM2di48aNGiOGsrOzsWrVKmzevFnlj6O8c7abmxt++eUXDBs27KXvv65IJBJcvXoVJ06cwPHjx/H06VOF456enggPD8fAgQPRp0+fV66CLSoqIkU7k5KSkJiYSFptPl8cDgeOjo7w8PCAu7s7ac7OztDX1yeCTEZGBjFfsVttioKymJiYENOVvAnL3t4eDg4OMDU1JSkpCgsLa0RgsdFXrAmrvpE4fD6fmK80RV8pm7HYSKzGcg5lsyrXFnquzm+HDT1XVRaivLy8UdasLRwOp86h5+p8duRDz1WVgqivgzL7O6Wtyao2c9XLhJzXpYJ5bePalouoay6dxuTJkyfw9fVt0HM2am0sSsPTUELW5s2bsXv3bnC5XBw8eFBB0ImLi8PEiRNJrSqgOpQ7KiqKCDoikQjLly/HunXrIJVKYWJiAh8fH9y/fx8A8P333+Ozzz5T+1aQn5+PNWvW4Oeff1bpLNq+fXs8e/aMCDoffvghVq1a9UqFiPLycpw7dw5Hjx7F8ePHFXxv+Hw+evfujcGDByM8PBx+fn6N/qZeUVGBxMREPHnyBAkJCXjy5AmePHmCp0+f1ip0mJubw9vbG97e3vD09ISnpyccHR1JksrMzEykpaUhLS0NFy9eRHp6OrKysjSaEln09fVVmq6cnZ1ha2tLND/FxcXEdJWdnY1nz54hOjqaRGCJRKI6fyempqYqzVeqzFhseLmJiUmD/luxmqXaMiarKg3B7rPCzaswrbB+N6p8d5T9djT57CiXgtDkoMyaDZVNVhUVFSpNVeqqmrOh7UVFRWpNWNqWh1CVZ4eathoeeQ2RtmYsXUabUc0OmoZmJz8//6WT4129ehW9e/eGRCLB2rVrsXDhQgDVb5bbt2/HJ598gvLycnC5XMhkMvj5+SEqKook/btw4QLef/99JCcnAwDeeustFBQU4PLly+Dz+YiIiMD48eNVXru4uBjr1q3DunXrVIbw9u7dG0ZGRjh9+jSA6hDsHTt2oEePHi91z9pSVlaGU6dO4fDhwzh9+rSCicfa2hpDhgzBm2++iQEDBjTa34BQKERcXBzi4uIQHx9PtikpKRqFD3t7e4XCnV5eXiRxXW5uLjFhJScnIzU1FS9evKh1LQKBoIb5ysXFBS4uLkQTU1JSojL66vnz53jx4oVWAhOLkZER7O3tYWtrq9GMJW/KelmkUimKiorUZk1WDj1X3tZHSKsNIyMjrbIly/vsyPvuKPeNjIxgYGAADodDzE/KRT6VTVbaZFBWVyJC2TenuT8+lE1arKmpLqHmmsxYqkxUtVUvV9XUHVeXT0eVGUs5187L5NlpSiHyVLPTzHhZzcbz588xatQoSCQSjB07FgsWLAAAFBQUYMaMGTh8+DC5TklJCVxdXXHu3DnY2dmhqKgIn332Galn5erqirVr1+Lnn3/GtWvXYGRkhL///hv9+/evcd2qqips2bIFK1asUBlG3qFDB8yYMQOrVq1CWloauFwuFixYgK+//rrRMwKLRCJERkbi4MGDOHnypMLDy8XFBSNGjMCIESPQrVu3Bk3iJxQKFSqRP378GLGxsQqh+sqYmZmRYp1+fn7w8vKCsbExJBIJMjMziRnr2rVrSElJqdVvwszMDJ6enjVMWFZWVuBwOCgrK0NGRgbS09ORkZGBa9eukQgsbU0jPB4P9vb2cHR0hJOTEzFfKZux7O3tX6r4KBsCL58tWd5vRz70XL5EhLYO2LVhZGSkNluyvN+OqrIQbGO1IOXl5SoLfrKN3S8qKsLz589Vmq7YvrxA0xTQ09PTOnOyqgzKyiYrVRXMNZmv6loqorn5llJeDirsNBFextFVKpViwoQJyM7ORnBwMHbs2AEOh4MrV65gwoQJePbsGfT09ODh4YHExETY2tri33//hZubG06dOoWZM2ciMzMTADB79mzMmzcPo0aNwsOHD2FhYYHTp0+jS5cuCteUyWQ4dOgQvvjiC6IJksfMzAxbt27F/fv3MXv2bDAMA09PT/zxxx/o1q1bve+1NiQSCc6fP4+9e/fir7/+UnCg9fT0xJgxYzBq1Ch07NjxpU0eFRUViIuLI9XIHz16hJiYGGRlZan9jJubGwIDAxEQEICAgACiVXvx4gUxX/3xxx9ISUnR6LsiEAiI2crLywteXl7w8PCAtbU1GIaBUCgkEVgpKSm4ePEi0tLSUFRUpNW92djYqI3AcnJygqOjI2xsbOr1wJBKpRAKhSp9dl68eEEckuXD0F8mo66xsbFKvx1l/x35shBmZmYwMDAgAoom01VhYSHS09NVVjVn28s6UGuLQCBQG25em9nK0NCwhslK3oylKp8OuxUIBFR4oDRpqLDTAlixYgUuXboEExMTHDlyBIaGhli9ejW+/PJLSKVS+Pj4wM/PD6dPn4axsTHOnDkDBwcHvP/++9ixYweAarPS9u3b4eHhgb59+yIxMRH29vY4e/ZsjQriV69exbx580iJCPkidQAwYcIELFmyRME/aNq0adiwYUOjmYju3buH33//Hfv371dw3HV3d8eYMWMwZsyYlxJwsrOz8eDBA9y/f59snzx5otYXwN3dnVQj9/f3h5mZGcRiMVJTUxEfH4/r169j165dNRIRymNoaKhgvvLx8YGbmxv09fVRWlqKtLQ0Yr66cuUKUlJStMoCbGlpCTc3N5VmLFdXV5JSoi7IZDIIhUKF0HPl7Mlsy8vLq5cjpLGxsVqfHfkt65zMOmGLRCIFM5Z8S01NVTBdybfGiDrS19cnpiptQs5Vma/k8+wo++VQgYNCUU29fHbOnDkDExMTdO/eHUB1Echt27YhKCgImzZtgqWlZYMvtDHRtc+OiYlJvVPVnz9/Hv369SOFNAcNGoQpU6bg5MmTAICJEyfC2dkZq1evBo/Hw4kTJ2BkZISpU6ciNTUVHA4H8+bNw8qVK5Gbm4vevXsjJSUFHh4eOHfuHHx8fMi10tPTsWjRIpKXh/X9YTE3N8eRI0cgFArx3nvvoaSkBFZWVti2bRtGjBhR369JLbm5udi3bx927dqFBw8ekHFra2uMGTMGEydORJcuXeok4DAMg7S0NNy9exd3797FvXv3cPfuXbWRT1ZWVmjbti1at26NVq1awcrKCmKxGMnJycSMlZCQoDaXC5fLhZeXF/z8/IgZy8PDA3w+H0VFRUhKSlKIxnr27FmtgoKDgwM8PDxIkzdjubm51cmkxDAM8vPzia+Osv+OfGmIumpfrK2tVfrsyPvu2NjYwNDQkFQzVzZbKZuw5CubN0R9JQ6HAxMTkxrmK1VmK+V95crmxsbGOk1VQKG0RBo19Lx169ZYvXo1Bg8ejEePHqFz586YP38+Lly4gICAAOzateulFv+q0ZWw87K8ePECbdu2RXZ2Nt577z3MnDkTo0ePRlpaGvT19fHLL7+Aw+Fg+vTpAIBff/0ViYmJWL9+PRiGgYeHByIiItCzZ0+kpaWhT58+SElJgbe3Ny5cuABXV1cA1c69a9aswZo1a9Sm4w8NDcWff/6JH3/8EZs2bQIAdO/eHX/++adC7p6XRSaT4ezZs9i2bRtOnDhB3r4FAgHeeustTJo0CQMHDtQqCRvDMHj27Blu376NO3fu4Pbt27h9+7bKSuQcDgf+/v5o27Yt2rVrBw8PD3C5XDx//hyPHj3Cw4cPERsbq9Z/wtDQEIGBgaT5+/vDwsIClZWVSElJUYjESktL0+j4aWxsrBCBxZqxPD094e7urrUvFOvgzPrtKGdQZktE1CXpno2NTQ2fHbZvb28PGxsbCAQCSCQSFBQUEPOVfFOubP4yJiA+n69gttJkulKVX6cxQ9IpFMrL06gOyikpKQgKCgIAHDlyBEOHDsV3332Hu3fvYvDgwfVbMaVOyGQyTJo0CdnZ2QgKCkLbtm3RrVs3iMVieHt749ChQ3jx4gWGDBkCoDo3zpYtW/Dw4UMAwPTp0/Hjjz/C1NQUaWlp6N27N1JTU+Ht7Y2LFy/CxcUFDMPg77//xty5c5Geng6gpskKqA4fnzNnDkaNGkXMVosXL8aKFSsazPH3+fPn2LVrF7Zt24a0tDQy3qlTJ0ydOhXjx4+vNZqtoKAAt27dwq1btxAdHY1bt26pdBrm8/lo3bo12rdvj/bt28Pe3h4VFRWIj4/H/fv3sXHjRuLjpIy+vj6CgoIQHByMVq1aITAwEMbGxigoKCARWH/99RcSEhI0Jv0zMzODr6+vggnLx8cH3t7esLe310pbJRaL8ezZMxJ6npqaSrIns01bQcbW1lal346joyNsbW2hr68PqVSK/Px8BfNVZmYm7t27R7Io5+Xl1SuCx8DAQMF8pZxB2dLSkoSgy+fZedVJ/igUStOkXk8igUBAIlv+/fdfTJ48GUC1Sl+TDwLlf2RkZMDT0xMCgQDnz59HaGhonT6/du1anD17FgYGBmjVqhU+/vhjAMDbb7+NXbt2ISMjA6NHj4ZUKkVoaCh+//13lJeXw9bWFrt27SJCkDpBJzExER9//DEiIyMBVEfeSKVSMAwDIyMjiEQiGBgY4LfffoOjoyO6du2KgoICWFtb448//kB4ePhLf0cMw+DixYvYuHEjjh07RvxjLCwsMGXKFLz33ntqK6xLpVLExsbixo0buH79Om7cuIH4+Pga8/T09BAcHIxOnTqhQ4cOsLW1RUlJCR49eoS7d+/i0KFDav+mvby80KZNG7Rp0watWrWChYUFSktLSfTVnj17kJCQoNb3Q09PDz4+PggICCBmLD8/P/j5+cHW1rbWh7RMJkN2dnaN0HM2i3JmZmatJi8OhwMHBweVIehsPSuJRIK8vDxkZWUR81V0dDQxYeXm5tbZB8fa2lplyLnylvXRUc4ATqFQKHWhXmasYcOGoaqqCt26dcOKFSuQkpICZ2dnnD17FnPmzMGTJ08aY62Nhi7MWBMnTsTevXsBAJ07d8atW7e0/mx0dDS6dOkCqVQKb29vJCUlgcPhYNWqVfjss88gFAoREhKC5ORk2NjYkJDwAQMGICIighT4fP78OXr06IHk5GT4+PjgwoULsLGxwffff4/vv/8elZWVCpocBwcHlJWVoaSkBE5OTjh27BguXryIRYsWQSaTISQkBIcPHybmr/pSWlqKP/74Axs3bsTjx4/JePfu3TFjxgyMGjWqhqmmtLQUN27cwLVr13D16lXcuHFDpZDi7e2N0NBQdO7cGa6urhCJRHjw4AExZakqf6Cvr080PW3btoWXlxdkMhmSkpJIJFZsbKzavCxGRkYICgpCUFAQMWMFBATAy8urVh8OiUSC1NTUGhmUk5KSkJKSUmuVbwMDAwWfHbY5OTmBz+ejqqoKOTk5CsU/WRNWdna21kIMWwhUOeScbWx1c1awachQfwqF8vrSqGasjRs34oMPPsDhw4exefNmODs7AwAiIyMxaNCg+q34NeP27duk365dO60/JxKJMGnSJEilUhgYGCApKQkWFhb4888/MWjQIIjFYowZMwbJycng8XjIy8sDn8/HqlWrMG/ePOJ/kJ+fj/79+yM5ORleXl64cOECkpOT0a9fPyQkJAD4nwOyQCBAeHg4Tp8+DbFYjI4dO2L//v1YtmwZ9u3bBwB49913sWnTppdKBpeeno6ff/4Z27ZtI4KKsbExJk+ejA8++ADBwcFkbm5uLq5cuYKoqChERUXh3r17NSKjTExMEBoaii5duiA4OBhcLhdxcXG4desWvvvuO5XZiY2MjNCuXTt06tQJ7du3h4ODA9H0PHjwAGvWrCEmPWUMDAwQFBREorDYraurq0a/D4ZhkJmZqTKDcm0h6DweD25ubgoZlD08PIhmqLS0lJis0tLS8PDhQ6SnpyM7O1srcxKPx4ODg4NaExZbHsLW1pZGAlEolCYLzaAM3Wh2LCwsSM6TL7/8EitXrtTqcx999BE2btxI9lu1aoW///6bRE0pH/fx8cH+/fvRsWNHMlZcXIy+ffvi9u3bcHZ2xqlTp0hEHfA/kxUAvPHGG/Dz88OWLVsAACNHjsT333+PMWPG4N69e9DT08OGDRvwwQcf1Ns3Ijo6GuvWrcOhQ4fIdX19ffHhhx9iypQpsLCwQHZ2Ni5dukSavMaHxd3dHd26dUPXrl3h5OSEvLw83Lx5E9evX0dcXFyNhzufz0e7du3QuXNndOrUCQ4ODigoKMD9+/dJNJZyAVQWDw8PtG3blpixWrduDR8fH40P/MrKSiQmJtbIoFyb/46BgQG8vb0VfHecnZ0hEAhQUVGB9PR0YsJimzYJ9QQCQQ3TFdvY3Dp2dnZUiKFQKE2WRtXs3L17lzhxAsCxY8ewa9cuBAUFYfny5VpFwrzuyD/ctA3Vj4yMVBBkhg8fjt9//51kX/7pp58Ujo8ePRrbt29X+AMoLy/HsGHDcPv2bVhbW2PRokUYNGiQQmi1VCqFnZ0d1q5diwsXLhBB54svvsCoUaPQu3dvZGZmwtbWFocOHUKvXr3qfP8Mw+DMmTP4/vvvcfnyZTL+xhtvYP78+QgNDcXly5exZMkSnD9/HnFxcTXOERwcjB49eqBLly4wNTXF06dPceXKFSxfvlxlNmdvb2+EhYUhNDQUnp6eKC8vx7179xAdHY0///xTpWDD5/MRHByMdu3aETNWmzZtYGFhofbeqqqq8OTJE8TExCA2NpZkUX769KnavDw8Hg9eXl4KfjsODg7g8XgoLCwk1c1v3ryJffv2aUxcyGJjYwMPDw+4ubmRsHP5/Dq2trY00ohCaQKwRTlZ865MJkN+fr7a4qGmpqbEXYBhGFy/fl1tYVE7OzuEhYWRa+3btw+VlZUqC4i6uLhg1KhRZO7atWtRWlqqsvCoq6sr5s+fT+Z++umnyMvLU1mA1MXFBRs2bHg1X6Ya6qXZ6dy5MxYvXoyRI0ciOTkZrVq1wttvv43o6GgMGTJE5zdVV3Sh2ZHXgmzbtg3vv/++xvmZmZnw8fEhPhqLFi3Cd999Rx5Wu3fvxrRp0wBUPzjXr1+POXPmKFzn/9g77/Aoqu//v7PZze4mm9303gspQAgt9N4REFGRogKiKCL2/lGxg2JBUcACKiJFUZQivXepAQIEQiC9955s+f2R373fmdmZzQbSgPt6nvvMnZmzs7OT7M6Ze88577q6Otx3333YsmULNBoN+vTpg+3btwOoD5Yl0yWPPfYY3nvvPcyaNQtbt26FTCbDd999Bx8fHzz00EMoLy9HdHQ0tmzZgqCgoEZ9boPBgPXr12PBggVUXFShUODBBx+k8UO7du3C2bNneSMxNjY26NSpEwYMGICePXtCpVIhPj4eBw4cwNGjR81SvlUqFeLi4tC7d2906dIFSqUSiYmJOHbsGI4fPy6aTWVnZ4fY2Fh07doVXbt2RefOndG+fXsolUrRz2IymZCammpWQTkxMVFy6kmr1dKYnaioKAQFBUGpVKKyspKmoJMprIKCAovXUqfT0dRzMoXFlYjgqtgzGLcrBoOBinuSCs5A/ZR+amoqT/yTq2geHh6O4OBgAEB+fj62bNkiqnqu1+vRt29f9O/fHwCQlZWFBQsWSCqhjx07liblZGVlYfLkyZJK6JMnT8a8efMA1E+9R0VFiSqkA8D06dNp2Zby8nKLEkIPPvggfv/9dwD1jpGl0dfRo0djy5YtdN3e3l6yRMaAAQOwb98+uu7m5ib5OySMNQ0MDJSc4o+OjkZCQoLkOd4KzTqyc+XKFRpn8scff6B///5YvXo1Dh8+jEmTJt12zk5ro9PpLO7Pzs5GTEwMdXSWLl2Kp556iu7//vvv6bq9vT12797N8+SB+hvz448/ji1btlA9me3bt9MAZL1ej6CgIHz//feIjY3FmDFj8N9//0GtVmPdunVIT0/H2LFjYTQaMXjwYPz5558WRzeE6PV6rFq1Ch999BGSkpIA1Nee6datG4D6EgYk/ocQHR2NwYMHo2/fvlCr1Th9+jT27t2LpUuXmtVecXV1Rb9+/dC3b1+EhYWhrKwMx48fx86dO/HZZ5+ZOR8ymQwdOnRAXFwcunfvju7du6N9+/aSo5I1NTVISEjAmTNncPbsWZw9exbnzp2TzNTSarU0ZicqKgo+Pj6wsbFBXl4eEhMTcfnyZezdu1fyx4Hg7e2N8PBwWleH225VOJZxd0MeJsgDUVlZGXJzc0WVymtqatCtWzd4enoCABITE7Fr1y5R9fLa2lpMmzYNnTt3BgAcPXoUCxcuFFUyr62txfvvv4/x48cDAHbu3ImHHnqI58BwH3q++eYbzJkzBwDw33//YdCgQZKfb8GCBXjttdcA1JdLmT59uqTt22+/TZ2doqIifP3115K2AQEBtF9XV4f9+/dL2nJHYGUymcUHGO6oL3FeiHq4UECUWxhUJpMhPDxcVPzT1tYWERERvPcZPnw4amtrRW1JSRnCjBkzUFlZKSouKkxEee2111BWVmYmOGpra9smfqtuytkxmUw0S2PXrl0YM2YMgHoBSbHpA4ZlLHmjV65cQd++fWmhO66jYzAY8MYbb2DhwoUA6oN5L168yPsyEubNm4eVK1fCxsYGdXV1KCwshEKhQF1dHWxsbDB37lx89NFHKCgoQN++fXHlyhW4uLhg06ZN+Oeff/Dpp58CqH/6+O6776yeqiROzocffohr164BABX/Kysrw8GDB6mtj48Phg0bhiFDhsDd3R1nz57F7t278eOPP5plHfn4+GDAgAHo27cvfH19kZ6ejsOHD+Orr75CWlqa2Xl4e3ujV69edBqrS5cukpWEKyoqeHE7p0+fxsWLF0VHaxQKBaKiohATE4MOHTrQAoq5ubk0BX39+vWSsT9AvaNGpq4iIiJ49XXY6MzdASmwKFQgJ/2RI0fSh4uDBw9i9+7dZorkZDl//nx6g/v111/xySefmKmVk7Z7924MHjwYALBq1So8/fTTkuf4zz//YNy4cQDqHY1nnnlG0rZHjx7U2cnOzsaGDRskbbmJAiaTyeJ3hVvGQaVSwdnZmScIShTKFQoF3NzcqK2LiwtGjBhhJgZK+l26dKG2Hh4eePPNN3lK51x7bkKJm5sb1q1bJ6qCrlAo4OPjQ22dnJyQkJAgqpRua2vLyzBVqVQwGAxWTzM3JgP677//ttqW3FuswdL/Tlvgppydbt264cMPP8TQoUOxf/9+LF26FEC990w8f4ZllEolLegWGhoqanPs2DHcc8891NF55plnqKNTVFSEyZMn02kohUKBY8eOiTo6P/74Iz744AMA9T8mZDSnrq4OwcHB+OWXX9CvXz8kJSVh8ODBSEtLQ2BgIDZv3owvv/wSK1asAAB8+OGHePPNN60KRNbr9fj111/xzjvvID09nbePPNGp1WoMGjQIw4cPR4cOHZCcnIydO3fiueeeM/vB8/LywqBBg9C/f394eXnh2rVrOHjwIN5++22zise2traIjY2lwcq9evWCv7+/6HlXV1cjPj4eJ06cwMmTJ3HixAnRYGag/gezc+fOiI2NRbt27aBWq1FaWopLly7h/Pnz2LJli+QPtY2NDUJCQngioJGRkYiIiOD9KDNaF6PRSNXEibp4REQEfdI+deoULl26RG246uOVlZX46KOPaAzet99+i9WrV6OqqsqsVVdXIyEhAeHh4QDqbyrz58+XPK9Tp07RG/KhQ4fw3nvvSdo+//zz1NkpKiqyOH3ALSpJ9LZUKpWZQrlSqeQ9HISEhODBBx/kqZFz1cujoqKobefOnbFs2TKeojlXwZxr27t3b1y8eJG3X6h+TujZs6dotXMxQkNDsW3bNqts3dzc8NFHH1lla29vj4kTJ1plKzZyIoWNjQ0rhtnE3JSzs2jRIkydOhV///03/ve//9FMoPXr16N37943dSILFizAG2+8geeee45Og1VXV+Oll17C2rVrUVNTgxEjRmDJkiU8hyo1NRWzZ8/G3r17odFoMG3aNMyfP7/N1/FoqD7Kpk2b8NBDD9G51ejoaHzxxRcA6oeQx4wZQ6eDgPqnMm5qNmHjxo2YNWsWXSejOQAwa9YsfPbZZ3B0dERCQgKGDh2K7OxsREREYPPmzXj11VexYcMGyGQy/PjjjzQmyBI1NTX46KOPsHjxYtGMoKioKIwaNQqDBw+G0WjE7t27sWzZMrOCf1qtFgMHDsSgQYPg7++PGzduYP/+/Xj99dfNlLvt7e3Ru3dv9OvXD3369EGPHj1ER22MRiOuXLmC48eP4/jx4/jvv/8QHx8vOmLj4+ODLl26oEuXLnS4NiMjA+fOncOGDRtEld6B+iHl0NBQmnpO6usQ54hx65hMJlRXV/NUxcvLy9GrVy9qs337dly4cAEVFRW0lZeX0/6GDRto7McLL7yAX3/9lTouQvLy8qhDumLFCixZskTy3F5++WXq7KSmpuLIkSOSttz30mq10Ol0omrkpBG6du2Kp556irefq0DOfXgaP348OnToYKZWTho3OWLatGmYNm2a5Ply6dOnD/r06WOVbVBQEJ588kmrbDUaDc/5YTCaiiZNPa+urqbDd43hxIkTmDhxIrRaLQYNGkSdndmzZ2PLli34+eefodPp8Mwzz0Amk+Hw4cMA6qdxYmNj4eXlhYULFyIrKwuPPvoonnjiCXz88cdWv39b08b64Ycf8NRTT9GpQplMhhMnTqBLly7YvXs3HnjgARQXF9MRGq6DyOXPP//ExIkTeccxGo3w8vLC8uXLqbTHmTNnMGzYMBQUFKBjx47466+/MGvWLOzduxd2dnZYu3Yt7rvvPsnzLSkpwebNm/H999/j0KFDvEJ0crkcQ4YMwdixYxETE4P4+Hhs3boVe/fu5f3Y29raokePHhg2bBjat2+PvLw87Nu3D3v27DGb59Zqtejfvz8GDBiA/v37o3PnzqL/cyUlJfjvv/9w9OhRWkVZzAFzd3dH9+7d0bVrV/j6+sJgMOD69es4c+YMzpw5I/n06OPjg44dO6Jjx450GisyMpI5NSLU1NSgtLQUFRUVvKD23bt3Izk5GWVlZWatpqYGf/75J7WdPn06NmzYgPLyctFih7W1tfT/YOrUqWYxYFzy8/Ph6uoKAHjqqafw3XffmdmoVCo4ODjg7NmzdHry22+/xT///ENVxoniuFqthoODA5555hnqGJ0/fx5Xr17l2XAdGU9PTyYMegdAYh6lMqe4GUxi2VI307iZUcIsKWEm1M0uhX2xde42Et5iqf3++++3XHRWSLMKgQJAcXEx1q9fj2vXruGVV16Bi4sLTp8+DU9PT1pk0BrKy8vRpUsXLFmyBB9++CFiY2OxaNEilJSUwN3dHatXr6apcJcvX0ZUVBSOHj2Knj17YuvWrRgzZgwyMzPpaM+yZcvw2muvIS8vz+q4ktZwdiIiIpCRkYFBgwZh48aNdMhy/vz5ePPNNwHUB/BWVVXhtddew4IFC/DDDz/g6aefhl6vh4ODAyoqKtCrVy/s27fP7LMuWrQIL774Im/aCgDuvfdeLF++nP7QHzt2DCNHjkRJSQm6deuGNWvWYNKkSTh16hQ0Gg02btwoGgSYnZ2Nf/75Bxs2bMDu3bt5oyM2NjaIjY3Fyy+/DC8vL+zcuRObNm0yG0739fXFqFGj0L9/f9jY2ODQoUPYsWMHrl+/zrNzcHBA//79MXjwYAwcOBCdO3cWzT5IS0vDoUOHcOjQIRw+fBjnzp0zm45Sq9Xo2rUr4uLiaKbGjRs3cPr0aZw6dUo04FgulyM6OhqxsbHo1KkTbXfT9FNmZiby8/NRUlJCW2lpKUpKSmA0Gun/LFA/3Xr48GGUlpbSRgLK7e3teWUXRo8eTSVJxKirq6OjtJMnT8batWt5++3t7aHRaKhTQr6/S5cuxeHDh+k+0sj6xIkTqQRFamoqysrK4ODgQB0Ye3t7lpbfBBiNRl6wMVkK+2Lrwswpse2WllLbhPuEmVGWGteW9FmpOutJTExEu3btmvSYzersnDt3DkOGDIGTkxNu3LiBxMREhISE4K233kJqaipWrlxp9bGmTZsGFxcXfPnllxg4cCB1dvbs2YMhQ4agqKiIl/UTGBiI559/Hi+88ALeeecdbNy4kaYwA/VxQyEhITh9+jQNkBNCgvMIpaWl8Pf3b7XUc/KU+sYbb+CTTz4BUF9V+ezZswgPD8fp06cxb948Oo0VERGBxMREuLm54cyZMzxV8fLycjz11FNUioI4OiqVCl988QWeeuop+t7//fcfhg4dirKyMvTp0we//PILJkyYgHPnzsHNzQ1bt26l2VJA/TTOX3/9hfXr1+PgwYNmX3KZTIYJEybgnnvuwcGDB7Fp0yZe8KGtrS369OmDUaNGITg4GFevXsW2bdtw7NgxXiaCQqFAz549MXToUAwZMgRxcXFmT8AmkwlXr17FgQMHcODAAezfv180syk4OBi9evVCTEwM7O3tkZubi1OnTuHEiROiwfQqlQqdOnWiU1idO3em0wC3IyaTCZWVlSgqKkJVVRWNEQHqg1evXbuG4uJis6ZWq3H06FFq27t3b946FwcHB57MhiUHxsHBASUlJdRZ/eCDD3DixAk4OjpSlXGNRgNHR0c4Ojpi2rRp9G+fmpqK6upqaDQa6rSwgof18XHcAGThUti4GVZimVfCDCuxbCupfcRpIX2pulJ3CzKZjJdFxe1zm9R2sSwoS/vIutR2MRvuUtgXW7dmG8kiE9oMHjxYMjHkZmnW1PMXX3wRM2bMwKeffsqrBTB69GhMmTLF6uOsXbsWp0+fxokTJ8z2ZWdnw87Oziy92dPTkxbAy87ONguIJuvcInlC5s+fbzHAr6UxGo2YM2cOHUp/8sknaX/JkiV45JFHaAT9ww8/jFWrVgGor63DdXTOnz+PiRMn8uJfTCYT2rdvj7Vr1/Jiek6dOoXhw4ejrKwMAwcOxIoVKzBu3DhcuHABnp6e2LNnD6Kjo5GZmYk//vgDv//+u1n8AZkWA4C4uDg4OTnh33//xfr166mNk5MTjdGRy+XYt28fFi1aZKY2HhERgeHDh2P48OEYOHCg2RfCZDIhKSkJe/fuxd69e7Fv3z6zv7GtrS06d+6MPn36ICAgAHq9HpcuXcLRo0dFpzRIZkW3bt1oi4qKapNTCyaTCaWlpSgoKEBBQQEKCwvp9NrkyZOp3dNPP434+HgUFhaiqKgIRUVFdFTFz8+Pl6m2ZMkSHDt2TPT9hNffw8MDHh4e0Ol0oo2MIAL1abzPPvssjUMhjoxGozGLpXv77betvgZiwfdtCb1eT4OVSSAyty8VqCy1tNSIM1NdXX1bORQ2NjZmQceNbdwsKmHGlFQGlXCbMGtKbJ3rhAhfI5Z9Jea0sCDjtsNNOTsnTpwQneP29fW16GRwSUtLw3PPPYedO3fekp7SzfDGG2/wKj+SkZ3W4tFHH8Xq1athY2ODxYsX0xGcxx57DPPmzcORI0egVCrx1Vdf0ZvDs88+S5XLAeCnn37C008/bRb4/OSTT+LLL7/kxZHEx8dj2LBhKCkpQd++fbF8+XKMHTsWCQkJ8Pb2xp9//omDBw9izpw52L9/P28EJyIiArm5uSgqKoLRaISTkxPKysp4xaUCAgIwfvx4dO/eHTk5Odi6dSuefvppXtqoRqPBkCFDMGrUKIwcORKBgYFm1yU9PR27d+/G7t27sWfPHrNCgEqlEj169EDv3r3h5uaG4uJinDx5Ej///LNZEDNQL0HRo0cP9OjRA3FxcejUqVOrjdgUFxcjLy8P+fn5Zk2tVuPdd9+ltn369MHx48dFb2p+fn48Z+fs2bOiIzDkR5nL+PHjERsbC2dnZzg5OdGm0+nMqno3Jl2VGyjclqitraVBysIlt3EzscjSmialbt+S2Nra8gKQhQHJwsbNthL2yTo3i0q4zs2aEq4TO65j09YTRxh3Ljf1n6dUKkVjG65cuQJ3d3erjnHq1Cnk5uby6hsYDAYcOHAA33zzDbZv347a2loUFxfzRndycnKoareXl5eZWjgZMSA2UufflqYlVq9eDblcjlWrVuH8+fNITk6Gt7c3Dh48iKtXr8LJyQl///03Fa/s1KkTne6qqanBs88+i++//553TDs7O6xYsQJTp07lbb9w4QKGDh2KoqIi9OzZEz/99BPGjBmDS5cuwcnJCe3atUO/fv14N9ZevXph4MCB2Lt3r9lIAAn4jY6OxoQJExAZGYmLFy9i48aNZoW52rVrhzFjxuCee+5B3759zeKMysrKsHfvXuzYsQO7du2igqTcz9SrVy/06tULOp0OeXl5OHr0KD7//HOzG42DgwN69uyJnj17olevXujRo0ezx9gkJSUhKysLubm5tOXl5SEvLw86nY73N+rRo4dkbQxfX1+eswP8X8ExtVoNV1dXuLi4wNXV1Sw+bt68eaioqICLiwucnZ1p02g0Zk+ZpOBaW4RMv5GYH2Hwcnl5udk6t5FtxKEpLy9vUWeEG5BMgpnFgpSF62JZWEqlUnSbcF2pVDJngsGQ4Ka+GePGjcP7779Py1Xb2NggNTUVr732Gu6//36rjjFkyBCcP3+et23GjBmIjIzEa6+9Bn9/fygUCuzevZseMzExEampqfTJsVevXvjoo4+Qm5sLDw8PAPUVOLVardX1DNoKixcvRmxsLB555BEA9ZltWVlZ8Pf3x9atW7Ft2zbs2LEDarUaa9asgUqlQlpaGh544AEzh8/Z2RmHDh0yuwaJiYkYMmQI8vPz0a1bN6xcuZLW1bGxsUFxcTGtBtq5c2dMmjQJgwYNwrvvvosFCxaYxejExsZiwoQJCAwMxIkTJ/Dzzz/zaurY2tqif//+GDt2LO655x6zwDSj0YgzZ87Qz3bkyBFeoLNMJkO3bt3Qr18/ODs7Iy8vD4cPH8ann35qlo3j4+NDU8/79OmDmJiYJvnhv3TpEjIyMpCdnY2cnBxec3Z2xpo1a6jtmDFjzBw07vlxcXd3R2ZmJtzc3ODu7g43NzfavL29eba//fYbFAoFXFxcGsz0GjFixE1+0qajrq4OJSUlKC4u5gU0FxcX06BmbpCzWCsrKxPNuGoK7OzsRIOWSSP1ZrgBy8LgZWHjZmepVCo2fcFgtDFu6m7w+eef44EHHoCHhweqqqowYMAAZGdnU+fDGhwdHc3qwjg4OMDV1ZVunzlzJl588UW4uLhAq9Vi7ty5tAouUF/2Ojo6Go888gg+/fRTZGdn46233sKcOXPa1MiNNXTq1Alz5syh2SdFRUXo2LEjtm7dipycHLzxxhsA6rOsoqKisGfPHkyaNIlmnZG4DE9PT1y6dMlsGiI9PR3Dhg1Dbm4uIiMjqTwCedo1mUwIDg7G1KlTMXHiRKSkpGDhwoV4/fXXzaaxpkyZAn9/fxw9ehSLFy/mBSE7ODhg1KhRuPfeezF69GizMuFFRUXYuXMn/v33X2zduhW5ubm8/WFhYRgyZAh8fHxQUlKCw4cPY9GiRWZTOGFhYRgwYAD69euHfv36ITg42OobTFpaGjIyMpCZmYmsrCxkZWUhOzsb2dnZ0Ol0NLgbAO677z5JB0bolISGhsJoNMLd3R0eHh5wd3enTWi7b98+q52xxuqP3SomkwkVFRW8uB+xJhbYXFxcjMrKyiY7FxsbG17wslgjAcvc4GbiwDg6OvIcGo1G0yZjshgMRvNyU86OTqfDzp07cfjwYcTHx9P08aFDhzbpyX355ZeQyWS4//77eUUFCba2tti8eTNmz56NXr16wcHBAdOmTcP777/fpOfREvz333/YvXs3gPpAx4EDB+Lvv/+GUqnEsGHDUFdXhwkTJuDxxx/H4sWL8cILL8BgMND0dKB+ROf8+fNmjk5BQQGGDBmCtLQ0qFQqXL58mQYx29jYYNKkSZgzZw7s7OywcuVK9O/fn1ePRi6XY8KECRgxYgSOHz+Or7/+mlf7xtnZGffeey/uv/9+DB061CwGKzExEZs2bcLmzZtx6NAhnuNCYnfat28Po9GIU6dO4ZdffjGLPQoNDcWgQYMwcOBADBgwgBeYDdRP8+Tl5SEjI4O2zMxMZGZmQq1W89Tghw0bJunACKc/IyMjIZfL4enpadaEDgxXbK8hWmq6oaqqigY15+fn8wKchcHOpBUVFTXJlI9Go4FOp6NxQDqdjgYtkz5ZJ33i1JDAZgcHBzZKwmAwbplGp57X1dVBrVbj7NmzohV7b0daW/UcqC+UR+Kgxo0bh3Xr1kGlUuGVV17BZ599Bi8vL5qC/sMPPwDgS07I5XIcOXIE3bt3p8c0mUzYuXMnpk6dykuzJuno9vb2+P3333HhwgWsXLkSFy9eNDtPEjy8YcMG3iiMm5sbJkyYgAceeAADBw7kPS0bDAYcOXIEf//9NzZt2oSrV6/yjhkdHY2BAwfS0gW7d+82y87y9vbGkCFDMGTIEPTv3x8KhQJpaWlIT09HWloajEYjXnnlFWrfvn170fMH+Bl85DNdunQJPj4+8Pb2ps3Ly4vW/mmLmEwmFBcX8+KB8vPzaVwQCXDm9m9llIVMnXFjf0hzcnLi9bmBzcR5YfEjDAajuWm21HOFQoGAgIDbKt2xLWIymZCcnIzQ0FDIZDLq6EyaNAkrV66EQqHA4cOH8fnnnwOo186ZNGkSDhw4QHVTuLWCFi9eTB2dgoIC/PLLL/juu+94QbDBwcFwcHDAhQsXaD2ZcePGmVVYBkBVurl6Mi4uLpgwYQIeeughDBw4kHczq66uxq5du7Bhwwaz+joKhQIDBw5ETEwM6urqcOzYMSxdupQ3PUbOZ/LkyRg2bBiioqIwdepUvP3228jMzDSL33B3d+c5O15eXrh8+TK8vLzg4+MDX19fXuNirUZOS6DX65GXlycaE0ScGtLPy8sTlbZoCFtbW7i6usLNzQ2urq68RgKdXVxcaHN2doaLiwvs7e3ZqAqDwbgjuKmigsuXL8dff/2FX3/9tU1It98qrSUXcfToUZ6W2NixY/H3339DJpOhoqICsbGxSEpKwr333ov4+HjcuHGDF5+jUqlQXV2NRx55BD///DOOHDmC7777Dn/88QfPEbK1tcWSJUuwY8cOXvl9QkhICNLS0qgCOvdfwsHBAffddx+mTJmCoUOH8kZwKioqsG3bNqxfvx6bN2/mFZZzdnbGiBEj4Ovri9zcXOzYscNs9EapVNIKq0B9LReuzdChQ+nUnlwuh6+vL/z9/eHn5wd/f3988skn9GZcXFwsWseltSgvL0dWVhYvLogbG0Rafn5+oyuwarVaXjwQaWLBzm5ubtBqtcxpYTAYFK60gzVyEY2VkJDa3qtXL1q5vKlo1grKnTt3RlJSEurq6hAYGAgHBwfe/tOnTzf+jFuRlnZ2tm/fjoceegj29vbIysoCUF8DJjExkd6U5s6di2+++Qbu7u6orq5GWVkZ7O3t6bREQEAAUlNTER0djaeeego//PADL7vN09MTOTk5sLW1xUsvvYR169YhJSWF7vf29saYMWOwZ88eXLt2jXd+crkcI0eOxNSpUzFu3DjeP2dlZSW2bNmC33//HVu2bOHpW7m4uCAkJAS1tbVUXoCLRqOBWq3mjfoQPDw8EBgYiCNHjlCH5eTJkzAYDAgICICnp2ebKN+v1+uRlZXFiw0SxghlZmairKzM6mPKZDJ4eHiYxQSRbaSgHwl6vt2C7xmMloLcxBsjIdEYuQgp6YiGtLHEtLKs1caSshPTxGpIO4v0W0vi4sqVK7wq7k1Bs1ZQvvfee9mT4i0wa9YsmnpL4Mo47NmzhwbUFhQUwGg0Ui0spVKJ0aNHY8OGDTSO5dlnnwVQX9tj8uTJ8Pb2pllxKpUKn376KX2fmJgYzJo1Cxs3bsSPP/7I+6fv1q0bHn30UUyaNIlXL6mqqgq//fYbVq9ejcOHD9ORJaB+aoykyXOr+nJ5+umncd9996F///749ddfcePGDQQEBCAwMBCBgYEICAgQTanmSlW0BMSRSU1N5cUHkX56ejpycnKsTol2cHAQjQsiSy8vL3h6esLNzY3JHjDaFEajUVQ6oiG5CDHpCGuWUtpYwkZshE4Lt89oOqyVlLBWLqI1MyGbVPX8dqWlR3Y0Gg1PDBEA/v33X4waNQplZWXo0KEDT+eJZFy5ublh8uTJWLx4Me+1oaGhmDNnDh599FF89913eOutt0Q990GDBqG0tBSnTp2i2xQKBWbMmIFnnnkGHTt2pNu//fZbrF69GhcvXhRVCn/00UehUqlw5MgRXLhwgbfPx8cHPXr0wD333IMBAwYgJCSkTYzKVFRUICUlxawR5yYjI8OqWDS5XA4fHx/4+fnB19eXxgiRpbe3N3x8fHhSKgyGNRgMBp5chDXSEVKaWEJtLCmtLDG9rDstJpNIOQjlIoTbhPIRUpISwr6YpISYfITwNdZoY1naL6Wb1VTaWLcDzTqNFRISghMnTlDlbEJxcTG6dOmC5OTkxp9xK9LSzo5cLjf7MUlLS4Ofnx/mzJnDS68nGVdeXl5wcHDgTTndc889eOaZZ9CjRw/8/PPP+OKLL3hF/Xr27IkzZ86gpqYGCoXC7Kmnffv2CA0NRVJSEm7cuIGCggJcvXoVK1euxJIlS8wyeUi9k4qKCp4DJJPJMGTIEEyYMAHjxo0zK6DXUtTU1CAlJQXJycm4fv06rl+/jhs3btAmNn0mRC6X05ggbuPGC7m7u982PwSMW8dgMJhJR0jJSEhpY4ntE9PEupkA9JaASD5IyUUIm5RchFBe4lZ1ssS0scQ0sdhMxJ1Lszo7MpkM2dnZtGoxIScnB/7+/rxpjtuBlnZ2xL54RqMRe/fuxZAhQ6iNjY0NjEYj5HI570dQp9Nh37590Gg0WLx4MVasWMELDvby8sLYsWOxYsWKRj2hRUZG8kREVSoV4uLi4OHhgYsXL/JSu+3s7DB8+HDcf//9GDduXIsFqhcWFiIpKQnXrl3DtWvXkJycTJcZGRkNzkXrdDo6fUam0MiUGokNYlNKtyc1NTWikhHCZq02Fmmt9XtmZ2fHk4vgSkaIyUUIl5a0sch2rh6WmGYWcU6Ys8BoqzRLzM7GjRtpf/v27dDpdHTdYDBg9+7dCA4OvonTvbuxtbVFVlYWxowZA+D/6uCQG7der4eLiwsKCwtha2uLzz//HPPmzcOmTZuoDXGIiCNKavEA9ZlRRUVFdD0gIAARERFQKpVISUlBQkICjEYjLl++DIVCgaFDh8LHxwfnz5/HgQMH6OsUCgVGjBiBiRMnYty4cby/f1NSUFCAK1euICkpCVevXsXVq1eRlJSEpKQk0Sk1Lg4ODggODua1oKAg2rg6a4zWxWQyoaamRlIygisdwdXHKi0tFdXGau54DRsbG55EBFdCgisXwdXCEmpiCdeltLGUSiVzuhmMJqRRIztk6F6YngzU3wiDgoLw+eef05v27UJrj+yo1Wo4ODiYZS8BQJcuXTBp0iT873//Q11dHVxdXXnVi8PCwpCUlCT5PkqlEtXV1XBycsK3336Ljh07YvXq1fjll19oJhh5n5iYGKSlpWHfvn10RIhMUU2ePBn33XdfkzkL1dXVSEpKQmJiIm1XrlzBlStXRIOcufj4+CA0NBRhYWEICQlBSEgIQkNDERwcDHd3d/YU2kIYDAaUlpZKykYQbSyhRha3NYeDolareXIRRE6CyEUItbC46xqNRlIbi2le3b2YTCZedpS1WVbCTCprM7AayroSy7CytM2aVHJrUsotbeOms0u17du3N7n8TbOM7JAslODgYJw4caLZVaTvFsj8PZfw8HAsW7YM3t7eiIuLozeFgoICyOVyTJs2DWFhYbToIMHLy4tWCzaZTKiurkbPnj0xdepU/Pjjj9i7dy+1dXd3x6BBg6DX67Fr1y5eyYC4uDiqk2VJQb4hioqKcOnSJVy6dAkXL16kUhU3btywmNXk5+eH8PBwhIeHIywsjC5DQkKavE7D3YzJZEJ5eTmVj+BKRnD7Yo0UwmwKSDyYUC6CrFvSxuI2BweHNlNr6W7CZDKJZlVZyr6ypollW1mTVi5sUtsbk07OuHVaM8SFZWOh5Ud2ZDKZxdiS119/Hffffz9mz56NkydP8vZ5e3ujb9++OHDgAK8AX1xcHCZPnowXXniBZ9+zZ08kJydTqQeZTIaBAwfCy8sLx48f5wU8BwUF4ZFHHsHDDz9splDeEAUFBUhISKCxPaTPlWkQotPpEBERQVu7du0QERGBsLAw5tDcBEajESUlJTy5CKKHJVxynZtbHV2xt7fnyUVw5SOE2lhCjSzixLApG+vQ6/WNyr4SZllx08Wltkmlkltqd3PKN8lgksq0siYbSyqrqjFZVmIZVtw+SQcXy7yylFbeUJq5WKq5VOp5ly5dWq2oYKMegY4ePYqCggLeNNXKlSsxb948VFRUYPz48Vi8eDEretYARqMROTk5ZiMmNjY2+Pbbb3HhwgWexhUA9O7dG9HR0Vi9ejX++OMPAP8n73Dvvffi3XffpWrwwP9lfB07dgxA/dRPnz59kJ+fj3379tFRFY1Gg4kTJ2LatGno27dvg1lGVVVVSEhIwLlz53DhwgXauFNiQvz8/BAVFYXo6GhERkYiKioKERER8PT0ZNMCFjCZTCgqKuLJRRAJCTFtrIKCgpt+AlUqlVQ2gshFiOlikW1EG8vJyQl2dnZN/MnbPkajEdXV1bwsK2GmlbCRjCvhNmGT2n67pYTL5XKzLKvGZmCJZVlxtwlTyIU2YmnmwtRxqdRzS2nlXGeF/YbdHjRqZGfUqFEYOHAgXnvtNQDA+fPn0aVLF0yfPh1RUVFYuHAhnnzySbz77rvNdb7NQmvIRZw/fx4xMTF03cbGBhMmTMCOHTto9V0SG+Xv74+MjAzqoHTs2BEVFRVITk5GTEwMNm/ejJiYGNHg3f79+8PDwwOHDh3ijbL069cPjz32GB544AFoNBqz15lMJqSlpSE+Ph7x8fE4d+4czp07h6tXr0pOPwUGBqJ9+/Zo3749oqOjER0djaioKFZvhgNxYLiSETk5OZLaWDeTiuzo6GgmGdGQNtadNpJmNBppVhU348qa7CtuKrlUinl1dXVrf0TI5XKLGVeWGjfbSrhNmFYuTDUXppQL08rt7OxYujejxWiWkZ2zZ8/igw8+oOtr165Fjx49aOaPv78/5s2bd9s5Oy1Nnz59ePVwgPqMLKJbFRMTA3t7ezoqk5aWBgAYMWIEXn75Zfz1119YunQpXFxcMH/+fERFRfGKFDo5OWHAgAEoKirCwYMH6ZSZh4cHZsyYgccee4w3TaXX63H58mWcOXOGtvj4eF4GFxc3NzfExMSgQ4cO6NixIzp06ID27dvf1U6N0WhEfn4+lYsgulhCbaycnJxGz1vrdDqeZASRjRDTxnJzc7stR1aNRiPKy8t5GVjCLCxuBhY3tVwsxVxYtLM5sbOzs5iBRTKsLGVfcbOwuCnm3NRzYWo5m/prHYTBytbKQ7RGgLJUsLKlYGSpviUdLGvbxo0bERAQ0Cp/t0Y5O0VFRfD09KTr+/fvx6hRo+h69+7d6Y2ZIc2RI0fMtun1egQHB2PSpEnYsmULdXRkMhkefPBBvP7664iNjcXatWuxdOlSAPUp5Pfccw89houLCwYMGIBTp07hn3/+oduHDh2KJ598EuPGjQMAJCQk4Mcff8Tp06dx6tQpnDt3TvRJVS6XIyoqCrGxsYiJiUGnTp3QsWPHu276qba2FhkZGVQygvS5ulhZWVmNiltwdnamchFc6QihNpaHh0ebd15qampo1pVY5lVpaSmvTxp3nVsnqqmxNvNKmH1FliRbkpt2znVqmNPxf5hMJuj1eqvkIKwJVm5MgLJYwHJDAcrCgGRL+0nfWrkYhjmtOSLaKGfH09MT169fp4UDT58+jffee4/uLysra1Xti9uZBx54AOvXr8f8+fPptoiICGzevBlhYWEA6p2UGTNm0P1nz56l/cDAQGRlZWHDhg0A6h2f6dOnY8iQIcjJycHevXvx6aefIj4+XnRkQaPRIDY2Fp07d0bnzp0RGxuL6OjoNn+jvVUMBgOys7ORmppKZSPIkmhiCdXaLeHh4QEfHx+qiSWmjeXl5dWmrqvJZEJFRYVkBlZxcbHZktuEmYS3glwutyoDS6PR8NLKhetc5+VOq3ZtMplQW1t7U/IQYsHIYsHJjQlUJo7L3R6oDMDqQGOx4F1hwK/YOnkPUnSW27ilYciS2zeZTGYPqcLtwr4Q7jbS59aEk9pGWms+GDTK2Rk9ejRef/11fPLJJ/j7779hb2+Pfv360f3nzp1DaGhok5/k3cD69et56z4+Pvjvv/+g1WpRXl6OpUuX0lo7YhBF85CQELRr1w7l5eX47rvv8MUXX5jZOjk5oWvXrujSpQtdhoaG3nE3BaB+VCY9PZ0nG8HVxUpPT7cqLkapVMLPz4/qYfn6+pppY3l5ebV6sG5tbS0v60rYJ86MMNW8KW5SJMNKLPuKZF4RG24mFjfNXKlU3jajhqQoojUByiTOR0wmwloNLK4DczshDDIWk3OQyk4SOgEA6I1deDMXg3uj5d58SV0Y0qSmXRqaHiIjPWLTV3V1dbdVQHlL0JrXo1HOzgcffIAJEyZgwIAB0Gg0+OWXX3g/7itWrMDw4cOb/CTvFrjFGpcvXw69Xo/3338fX331FS20J1bQEfg/sdDk5GSeNplGo0HXrl3RrVs3dO/eHd26dUNISMhtc0NpCKPRiOzsbPq5r1+/ztPGskZCwtbWluphBQQEmOli+fv7w9XVtcWvGRlx4WZikcwr0kg2FkkzJ8HtN4NCoeBlY5GMK24j24Rp5m0xfdxkMqGqqkpUJuJWA5SJA9MWKndwJSCE2lTCTCOSSSQ1YkCe7LnOgVjBOLE4FLFpI+7IT3V1dZPWZroTaMxIUGNS0cW2C9PRG0o9t+R0Wpt6LrQTSky1JDdVZ6ekpAQajcbsx62wsBAajabVn24bS2tXUCaQ6sgTJkxAaGgoli5d2qhYBltbW3Ts2BE9evRAXFwcevTogcjIyDZ3E2osdXV1uHHjBtXE4mpjXb9+vcF5YJVKReUiuLpYRA/Lx8enxa6RyWRCYWGhaAZWbm4uXZJ2M1NEMpmMZlkJM7DIdm6aOenb29u3qhNsMBhEpSGkApQt6V8Rp6alnBFbW1teYDJXe0qYFk3SlYWjEwBERxa4TgQ3zoVMNXFHfW7HkQSZTCaZhm5pVKihdPSGFM4bSj0XUzlvSPVcmJZuSd2c/P0Zt0azCoHeabQFZ0elUqG6uhoqlYoOjwP1IzNSDo9Wq8XgwYPRs2dP9OrVC127doWDg0OznntzYTAYkJKSgqtXr1LZCKKJdePGDYs/4ra2tggICEBwcDBCQkLMtLE8PDya/Uelrq4OOTk5vMyrzMxMZGdnIysriy5zcnIaPWWkVqstZmBxM7Hc3Nzg5OTUolOSZARFKA1B+tYEKJeWlqKysrLZzlEoAcF1Ruzs7MxGPLifjTge3FELbmxLTU0Nb8SnrUwz2djYNJiWLkxBFwqAClXOpVTPhann3Fo6UrV1iCN4uz+MMVqXZkk9ZzQf5AdSOEohdHSI4OfkyZPx22+/3XZPBkVFRbh8+TISExPpMjExEdeuXbOYkq1WqxEWFkY1sUJDQxEaGoqQkBAEBAQ0W2C8yWRCcXGxWfZVRkYGTS3PyMhAbm5uo0YRuNlY3Owr4dLDw6NFHFhSfZkEKYvJQ0gFKBcXFzdpYKqdnR0v2JiMlpAbrUKh4A2XE4eEGyvBHe2orKykoz15eXlNdp7WfhZLwp+WUtHFUs8tqZwLHRtW64bB+D+Ys9NGaOhGqdVq0bFjRxw+fBhRUVH48ccf2+wPmclkQmZmJpWOuHz5MtXHIrIVYiiVSqqH1a5dO6qJFR4eDm9v72b5vGVlZZJZWKRZW7NFLpfDy8vLLAuLZGB5e3tTx6a5srGI1lVjA5SLi4tvecpHJpPR4GOiU0WcFPIUT0ZNSK0SMiVDgnArKyvp9FVGRsZNFVW0FuFoj1RfqHAubFxFc25aukqlYqMWDEYbgTk7rUB5eblo1WIHBwfRG6uHhwdmzZqFDz/8EEqlEmvWrGkTFW9NJhOysrJw4cIFJCQk4MKFC9TBsRSI6Ofnh4iICERGRiIyMpJqYvn7+zfp9IvJZEJubq5ZBlZKSgpNNRerOi2Gq6srzcLiNpJm7uvrCzc3tyafPjIYDCgoKLA6QDk/P/+WRlns7e1pMLKjoyO9eZOpHuJwklEUko1UUVGBsrIyFBcXIysrCzdu3GiiK1APN7VcLA1dLBWdqJ5z6+uQ5Z2Yks5gMKRhzk4rIDW6UVFRAblcjsGDB2Pnzp0wmUxwdnbG6tWrMXr0aADAwoUL0alTp5Y8XQD186IXLlzA+fPnce7cOZw/fx4XLlyQrLJsa2uL8PBwREVF0RYZGYmIiIgmq7RMpBe4GVg3btygyxs3blhVxMrZ2Vk0A8vf35+ml6vV6iY5Z6B+ylJKIoIboEycmJsZcVGpVDQQWavVQqPRQKVS0SkgGxsbGAwGGndCRlTINFZGRkaTfFaSWi4UABWmopM+V/mcLDUaDXNMGAzGLcGcnRbm33//xXPPPWe2XS6X44knnkDXrl0xa9YsmEwmqFQqnDx5EuPGjUNtbS3GjBmDZ555plnPz2Qy4fr161QTi7Tr16+L2stkMoSHh1PJCKKL1a5duybJyjMYDEhPT+dlYF27do2mmpeUlFh8vY2NDXx9fc0ysQICAhAYGAh/f3/RUbbGQmJ7xAKUuUHK2dnZVo8mcT+Di4sL3Nzc4OLiAq1WS6eHiBNARlm4Tkt+fj7Onz9/S9NTGo1GNP2cKwTKVTnn9ttiOjqDwbg7Yc5OC3P//feLjjbs2bMH2dnZmDRpEoxGI2xsbLB9+3Z8//33SEhIgLu7O1asWNGkcSt1dXW4ePEi1cM6e/Yszp49KzkF5evri44dOyImJoZqYkVGRkKlUt3SeRiNRqSnp9MMLNKSkpKQnJzcoJaUl5eXWQYWSTX39/e/ZaerpqbGLDiZBChzA5UbUwpdoVDAy8sLHh4ecHJyoiMvxDkwGAyorq5GeXk5ioqKkJeXh5SUFCQmJt7UZ9BqtdRZ4qaek3Whyjnps4roDAbjToA5Oy2M1I376tWrePzxx+lT+FtvvQW5XI6FCxcCAL7//nu4u7vf0vsmJCTg5MmTOHXqFE6fPo1z586Jpsna2dmhffv26NSpE20xMTFwdXW96fcHgOLiYpp9xW1JSUkWHQWFQoHg4GCagcXNxAoKCrqlbCWie2UpQLkxGTxOTk7w9vaGh4cHtFot7O3tqcNQV1eHqqoqlJaWoqCgADk5OTh9+nSjR17UanWD6edcpXMXFxfmtDAYjLsaVmcHLVtnR2xkRlgVOTY2Fnv27EFcXBySkpLwyCOPYOXKlVa/h8FgQGJiIv777z+cOHECJ0+eRHx8vKhjo9VqqR4W0cSKioq66ZsjCVq+ePEizcAi2VjZ2dmSr5PL5QgNDTXLxgoLC4O/v/9NT4eUlpYiJSWFBimnpqbyApSzsrKscjZUKhV8fX3h7e0NZ2dnODg48JyY8vJyFBcXIycnB5mZmY1S3ZbJZHBzcxNNQSd94ti0VCo6g8FgNAZhlW2uLAfZJlaM+FZhdXZuI7g3W7lcjp9//hnz5s1DUlISfH198fXXX1t8fVZWFo4dO4bjx4/jv//+w8mTJ0VlA4gmVrdu3dClSxd06dIFISEhNxX8SdLLExISaCOZWJbiaLy9vWmgMsnCateuHYKCgiCXN/7fsbKyEjdu3JAMUJYKoOaiVCrh7+8PHx8fuLi4UEeGTCUVFxcjNzcXGRkZuHbtmtXn5ujoCB8fH5p2TlLPSTo6cW7c3d1ZbAuD0QCkXIFQh0ooWyG2r7FNKIkhtU+sb81+oa1wm9S6pe1StjfTpBwXS+vWcOXKFYSHhzfzf4o4zNlpIyiVStTU1OCdd95BQUEBFi9eDKBeb8zJyYna1dbW4syZMzhy5AiOHj2K48ePIzU11ex49vb26NatG9XE6t69+01rYpWWluL8+fO8ZikTSyaTISwszCwTKzIystEjZyaTCXl5eZIBypZGiwguLi4IDAyEt7c3tFotr0p1SUkJcnNzkZqaiqSkJKvOiYzyCFPPvb296TZvb282AsNoVoxGI61TZKmRQovCde524TbuUmqbcJ+wCaUuGtrPXRdzaoxGY2tfcsYt0pp/Q+bstBFqamrQpUsXzJkzB126dAEAPPXUU+jSpQv++ecfHD58GEeOHMHJkyfNpqNkMhk6dOiAHj16UF2sqKioRo+UGI1GJCcn4+zZszh37hzi4+Nx7tw5yZopJBOLZGGRFh4e3qiiecSh4QYnkwDlpKSkBsUttVotgoOD4evrCycnJyiVSiqiWVRUhIyMDCQmJuLMmTMNnou9vT0v7ZwsuYrnLi4ubbagI+PWMJlMNLONNK4sBOlz5SKktlnTuNITpC+2FNt2O+pgNRc2NjZmOlRS+lQ3K7JpSXyzIUFOMSFOMaHMhsQ5pUQ2pYQ4ua+VsiE6bVI2wvMTbiP6bmKvEx67NXUzWcwOWj9mB6gPwj158iS++OIL/PLLL3B0dIS3tzeuXLliZuvq6orevXujV69e6NmzJ7p169bo2jW1tbW4ePEiTp8+TTOx4uPjJR0LX19fXhZWx44dG52JVVVVhStXrpgFKF+5csViEUIbGxv4+flRnStSd4VMMaWnp+P69esNOkU2Njbw9vbmpZ4TlfOAgAAEBATA2dmZOTKtBHE0qqqqUFVVherqarrkNu42Igkh1ch+7lLYF7bb+SfRWuFMYV+4FIphWiOyKWxSIptiQpoNiWxK9bnCqoy7Exazc5sRGRmJoUOH0swfou4MANHR0ejTpw/69OmD3r17IywsrFFf7pqaGpw/fx6nTp3CyZMncfr0aVy4cEE0M0ypVKJDhw6IjY1FTEwMbS4uLla/X0FBgVmA8uXLl5GSkiJ5I7GxsYG/vz/CwsLg7u5Op4AqKiqQl5eH5ORkHDp0qMFhUG9vb176OVmSmjrNJdNwJ1NbW0uFLi21qqoqyb61ra1NVchksgaFM7mimVICmkQAU7hOtnFFMoXimmIimmLrCoWC3fQ5cONlxGJ4uHpqDcXsNBSHIxazY2lp7bbGxOw0ZWtszI4lG+72I0eOIDg4uFX+H5iz08Lo9XrR6aXz58/Tvru7O6ZPn45+/fqhd+/ejUr5NhgMuHjxIk6cOEGDlc+dOycqIeDk5GSWiRUREWF1JlZ+fr5ogLIl/StnZ2dERETAz88Pjo6OkMlkqKysRF5eHq5du4Z9+/ZZvOGp1Wpe+jlROg8JCUFgYGCTVjq+nTAYDFSygYhelpeXo6Kiwmwp7Iu1yspKumxOfSpLNEYckwhhcteJjTWimVLtdg0cJ/E81sTnWBOzYyk2x9qYHUsxPGIxOtYupRwaRtujKQWDGwtzdlqYwsJC0e39+vXDwYMH4ebmhkuXLlnt4KSnp9NMrOPHj+PUqVOorKw0s3N1dUXXrl1p69KlC4KCgqx6EqyoqEBCQgINTCZBypacmsDAQLRr1w6enp5Qq9XQ6/VU2iE+Ph7Hjh2TfK2joyPCw8Np6jm3eXl53RFPr0Sws7S0lApfcpekkfXy8nLJZXl5Oaqqqpr9nGUyGdWVUqvVPHFMrhCmUBxTrG9JBZw4LG3l72wymayKz7E2Vocbp9NQrI5YzA63iW2rq6trcyNkbZHWitmxtBT2GxuzIxWf01Bcj6V4nKaM2QkICGi1vzdzdlqYxx9/3GybTqfD8ePHAQBfffWVpKNTXV2N06dP4+jRozhy5AiOHTuGzMxMMzuNRoNu3bohLi6OZmMFBgY2ePMwmUxITU01C1BOSkqSnH4KCgpCZGQkVfKura1Fbm4urly5gt27d0v+6CoUCoSFhdHUc9LCw8Ph6enZZm50YtTV1aGkpAQlJSUoLi7m9UtLS+l6aWkpXSd9bmuO2BBbW1uqJyUmgCnsW2pctW+Sjt+SfxeDwXBTMTvCuByxmB1rGnFgWvNptCmRyWS3FLNjab2hmB1yI26qmJ2bWRc6I4y7C+bstDAbN24022ZnZ4eSkhKMHDkSkydPpttzc3Nx+PBh2k6fPm0WZ2Nra4uOHTvSTKwePXogIiKiweF3vV6Py5cv8wKUz549K6nb5OHhgQ4dOlBRTOLUJCYmYvv27ZI3bmdnZ5p6HhUVRdXOg4ODb6quTlNgMpmofhS3FRcX8/pSrTEFAxtCJpOJil821IQq4MSBUSqVzeaQ6PV6q+J0uMuGGtd5ES5ba/qsIeRyeYMxO1IxOtz9YjE6jYnZsbYR54Td4Bl3MywbC20jG0utVmPr1q1ITk7GwYMHcejQIVy9etXMzsPDA7169aKta9euDdZzqaurw4ULF3Dq1CmeVISYRINcLkd0dDQiIiLg5OREBS6vXLmCy5cvS8pduLm58YRASfPw8Gi2m6/RaERJSQkKCgpQWFhIl6QJ10krLi5ukjl9BwcHKnoppezNXRcqexNBz6a6PiaTCVVVVZKxOlJxOiQ+h/S58TrcfmuOcNjZ2Vkds8ONuRFuszZWRywYmQQS365xPAzGnQjLxrrNUCgUGDhwoNn2Dh068DKxGioMaDAYcPnyZbMAZTGpCEdHR3Tq1AlBQUHQaDSorq5Geno6zp07h3Pnzoke39HRkaaed+jQgaqde3h43PRnB/5vtCUvLw95eXnIz8+XbAUFBcjPz0dhYeEtxSbY2dnxxC+5St5ChW+dTsdb12q1tzwyZTAYUFJSIhqrw43L4cbmCAOQha0lnl1sbGxozA43FkcYr2MpTocboyMWhMzdfjsHCjMYdwJGo5HG5gD/l6EplYnm4eEBe3t7AKDlQRqT/NIcMGenjVBaWgqFQoG4uDj069cPffv2Re/eveHs7GzxdRkZGTQ4mQQol5eXm9npdDp06dIFgYGBUKlUKC8vR3JyMk6fPo1Dhw6Z2dvY2CA8PJyKgJJmTewPoaKiAjk5OcjNzTVrxKnJy8tDbm4u8vPzG1Q3l8LBwYEqd3OXzs7OdJ2r5E2WNzuqYjQaUVZWRmNzuDE6wqWlJhZI3lSQOBuxmB1rY3S4Acfc9eacKmMwWgOx7DXS/Pz8qF1KSgoKCgoks8qGDx9OH4KOHj2Kq1evSmamzZ49m47Kb9q0CUeOHOFllnFfN3/+fCoE/dtvv+Gvv/6SzEj76aefEBISAqBeQHrJkiWSKfYbN25E586dAQCLFy/GW2+9JZqGDwC7d+/G4MGDAQDLly/H008/LXk9N27ciLFjx9L+tGnTkJGRAR8fn6b8szUK5uy0ARwcHLBp0yb07NnTYup0TU0NTp8+TaUijh07hoyMDNHjEd0rtVqN8vJyXL16FUePHsXevXvN7O3t7RETE4PY2FjaOnbsSD1zLpWVlcjOzua1nJwcuuS2m7mZ29vbUxVvrpI3UfDmrpPW2No5RqMRpaWlyMnJoXE6lmJ0SBAyWTZ1cLFCoaCxONyYHRKPIxanI4zVIUtHR0fY29uz+AxGi2EymXjOb25uLqqqqsyyzmpra6FQKNCjRw9q+++//9IHHWEWmr29PZ5//nlqu3DhQly9elU0+8ze3h7r1q2jtrNnz8bRo0dFU+ttbW2Rnp5ObceNG4dNmzZJfj7yGgB47bXXeO8jhDuVsnz5cixfvlzSdurUqdTZ2blzJ5UIEuP111+nzs6FCxfw119/Sdpyi6vm5uYiPj5e0pabxVlXV2exuCt3FF3s90Uq+FutVtNzb02Ys9MGeP311zFo0CCz7dYEKBOpiA4dOkCr1aK6uhrJyck4deoUDh48aHZMrVZLRUBJCw8PR0VFBTIzM5GZmYkrV65g//79yMrKQmZmJrKysqhj01CVYiEqlYqn4O3u7k7FL8k617ERc7CkqKmpMYvRKSoq4m0j6yTwuLCwECUlJU2SmmtnZycZq0NicoSxOsSh4To1jalCzbi7MZlMqKuro9llMpmMl715+PBhyewzLy8v3HvvvdT27bffRklJiZkkRk1NDdq1a4cvvviC2g4aNAjp6emiafbt27fnSbH07t1bUjA3LCyMF4v45ptvSt6Mvb29ec7O33//jSNHjojaCmM1rl27Jnlc4c1YaopUJpNBLpejrq6O2ri5ucHX19csG41kf3Hp0KEDRo4cycsM42ajcR/SBg4cKFkd2tbWljfCf++99yIgIEAyWy0wMJDaTp48GXFxcWaZaSSdPTIyktrOmDEDY8eOlcxe0+l01HbmzJmYMWMGPY6lkd4HH3wQDz74oOT+loIFKKPlApTPnTuHTp068bbZ29sjLy8ParUa165dw4EDB2iAspgwpbu7O7p37w5fX18A9YrnJ0+eFBXEdHBwQGxsLKKiouDn5wcnJycYDAbq1GRkZNB+Y0Zh1Go1vLy8aPP09OSpeJNGpB2smfKoqqqiMTl5eXk0LocsSZ/bbjUrSqVSicboCONziAMjXGdOyt0Nd0RDr9cjKSlJMgstODgY/fv3B1BfQuLtt9/mpdBz+/369cO7775LjxsQEMBLref+ZI8dO5aX4UnKP4gxaNAg7Nmzh667urpK1v3q3r07/vvvP7oeGBgoKjgM1Fd4T0hIoOsdO3ZEUlKSaDZaUFAQduzYQW2ffvppJCcni2akOTs7Y+HChdR2xYoVyMjIEM1OU6lUmDp1KrU9ceIEioqKRNPsFQoFoqOjqS1JWBCm1bPR0dsDFqDcBjl9+rTZtokTJ2LGjBk4cOCAmcNiY2OD9u3bIyYmBjqdDuXl5bh48SK2b99ulk1EdJ9cXFygUChQW1uLgoICHDlyBIcPH7bq/JycnKhiN7f5+PjAy8sL3t7e8PLygqOjY4MOTGVlJXJzc3Hp0iUaoyOM1eEGI9+s4yKTyWgcDjdWhxufww1C5jbmrNy5mEwmmkmmVCrpU2lZWRn27dvHyzLjLvv27Yvx48cDALKzszFlyhRJaYyZM2diyZIlAICioiJERUVJns8jjzxCnR2TyYTPPvtM0pb7BC2Xy5GbmyuZPShMz4+OjoZerxfNPouJieHZPvfcc6ipqRHNRPP09OTZrl27Fkaj0SzNnrwHF241+IYg188aHnvsMattu3fvbrWtk5OT1baM2xc2soPWSz2Xy+WwsbGhKb12dnbo3r07IiIiYGdnh/T0dJw4cQI5OTlmx5HJZFZPxdjZ2cHX19es+fj40KWPj4/FeCGTyYTS0lLRGJ3c3FxePzc396acF4VCQeNx3N3daZwOic0Rxuq4urpCp9OxJ7DbHL1ej/LycigUChrDUFRUhAMHDkhmoI0ZMwZjxowBAFy+fBkTJ040S60nvPnmm/joo48AAFeuXEFERITkucydOxdff/01gHpnx9vbW9J2+vTp+OmnnwDUB+P7+/tLZqANHjwYr7zyCoD679Irr7wiWTk6MDAQvXv3pu8THx8vKYfB/vcZdztsZKcNIhwyJk9l0dHR0Ol0yMzMxPHjx60aiSGOjp2dHfz9/XnNz8+PNl9fX7i7u0uOxOj1euTm5uLixYvIysriNRKnk5WVhZycHNG6PJZQKpU0Vocbn0P63EBkd3d3q0aMGG2LyspKpKSkSGacDR8+nAaknj17Fs8++6xZij0Jkvz000+pQ5CUlERHWMRwd3enzg5geTSBW3ZBp9Ohe/fuvOwybkZanz59qK2zszPWrFljJo1BnBnuCIyDg4PklJAQGxsbiyM7QoRT3wwGo/EwZ6cF4Qbbcbl48aLka3Q6HUJCQqhyd0BAAF36+/vD3d1d9OnOZDKhoKAAGRkZOHnyJI3PIUsSfJybm9uoYF2tVktjckicjoeHh1msTmPidRgtT01NDS/bLCgoiE5dXL58GStXrjSTxCAp9R9++CEefvhhAMChQ4cwYsQIyfext7enzk5NTY1o0DyBWzLB1dUVPXr0gKOjI80y42agkSkhAAgICMDOnTtFU+3VajXv++Hp6cmLRbGEUqnEpEmTrLJlMBhtG+bstCC//vqr6HZbW1t4eXkhIiICcXFx6NOnD0JDQxEQECBaHdloNCI7OxspKSk4fPgw0tPTeS0jIwMZGRmihQSl3t/T09MsVocbp0Ocm7tVVbwtUldXZ1Ylmpt1dv/999NRgV27duHZZ5+lzo1QOPTHH3/EzJkzAdTXEpk/f77k+3KnVUn8k1iFaFKAktCuXTusW7dOUhKDm50SEhJiUSyWi729PYYOHWqVLYPBuDthzk4r0r59e8ydOxczZ87kpS2WlpYiNTUV+/fvR0pKClJTU5Gamoq0tDSkpaUhIyPD6tL97u7uvBgdYZyOj48P3NzcWIXaNgLJrhNmnpHU+rfeeosW9vrzzz95WmpCAgMDqbNjMBhw6dIl3n4bGxtotVo4OTnx/v/CwsLw7LPPmslgkBYcHExtu3fvbvX0jbOzMyZOnGj1tWAwGIymgjk7rcQTTzyB77//HhcvXsTLL7+M69evIyUlBSkpKZJinFxkMhm8vLwk43T8/Pzg7e3d6IJ7jFunoqKCV0fj8uXL2LJlC02rF8pfLF++nNY/2b9/v0UHhpte6+LiAplMBicnJ9Eq0e3ataO23bt3x549e3iSGFqtVnQKNDQ0FF999VVTXQ4GgyECyQ0iU/0GgwE1NTUwmUwwGo20kXWNRkMz3yorK5Gfn29mQ/peXl40y6y0tBTJyclmtmQZHBxMA/GLi4tx+vRpMxuyjIiIQFhYGID6JIK9e/fyjkua0WhEx44daQZgcXEx7OzsGlVHralhzk4rQYo5PfHEE6KFslxcXBAQEECbv78/Xfr7+8PHx6fVVMPvNgwGA/Ly8qDVaumX9cyZM1i3bp2oDEZlZSX++usv3HfffQDqA3NffvllyePn5eXRvr+/P7p3786TveC2nj17UtshQ4agrq7OqowcFxcX0cKVDAZQf+PlSgro9XoYjUZeMbucnByUlZWZSQ+QPvd/89y5c8jMzBS1MxqNmDhxItVJ2rt3Ly5dumQmU0DaCy+8QKfz//nnHxw+fFhU0sBoNOLjjz+Gm5sbAGDNmjXYuHEjT7OJ21+6dCmCgoIAAD///DOWL1/O03gizWAwYNWqVejYsSOA+srI8+fPN7Mj7c8//0Tfvn0B1E8PP//886J2JpMJmzZtooH2q1atwvTp0yX/RmvXrsVDDz0EoL7ytKVCfcuXL6ep+ocPH8bo0aMlbb/++mvMnTsXQH3m35AhQyRtFyxYgNdeew1AfeHG+++/X9L27bffps5OZmYmdDodc3buRoKDg1FQUEDjEr788ku0a9cOgYGBCAwMhEajaeUzvLMxmUwoLCykmTVAfR2k1atX89Lqs7OzkZ+fD5PJxHNgrly5gk8++UTy+Pn5+bQfERGBqVOnUqkLoQwGt+Jpnz59rA6gZVOPLQNxBIRyBnV1dZDL5bTAJwCcOnWKKsQLm1arxciRI6ntzz//THWWuJIGdXV1cHV1pTcVAHjrrbdw48YNqpnE1W9ycXHBmjVrqO2jjz6Ks2fPmukr6fV6aLVa3nTmiBEjsHv3btE6PkqlkpeBOXPmTGzZskXyOhkMBup4f/TRR/j9998lbceNG0ednV9//ZWm8Isxc+ZM6uzs2rUL33zzjaTta6+9Rp2d+Ph4rF27VtKWK42QlpYmqhFI4AbPl5SUSFaIBvjZf3q93mIZDm7ll4YeWriJJGTkWCaTUYFOUulYJpPBzs6O2qrVavj4+MDGxobu576Gm1Wo0WjQvn17ng3pk9kEgqOjI/r06cM7Ftee6HMR29aeZWDOTisRHByMXbt2wWg0okOHDpKZWozGQZ6YiCOQkJCADRs28DLQSFp9XV0dz4FJSkrC559/LnpcGxsb3vQi+ZuJpdaTNHpC586dsWrVqub70LcxJpMJer2eyhTI5XL646vX63H69GmenAF3GRAQgAEDBlDbjz/+2EyLibTY2Fi8+OKL9H0HDx6M6upqup+r49S3b1+e8+Dk5CSpGdSnTx/eTXLMmDGi1cwBIDY2lufsfPjhh5I3zfDwcJ6zs2nTJpw7d07UViiumJSUJJmKL7zxkpELMYTbSVaclKQB19kJCQlB586dzWQKSONmaXbr1g2lpaWidra2tryihUOGDIFSqTSTPSBL7kjU2LFj4ePjY2ZDllyBzwceeADR0dE8G64UArdg5EMPPYSePXvybMnN3tbWlo4WAfVyDcOHD+fZcB0ObkHDSZMmYfz48bxjcl/HvWbjx4+3uhTIwIEDRTUUxejatSsuXLhglW1ERIRFB5GLv7+/VXbNCSsqiJYrKsj9Zy0uLsbzzz+Pn3/+GS+//DKvLDrDMunp6Th48CAv84wrfbFu3TrqwPz+++906FeM77//Hk888QQA4NKlS1i+fDkvrZ4s79QgbpPJhNraWlRXV0OhUNBh5oqKCsTHx1MZA6G0QefOnelQfW5uLt577z2qx8TVZqqursaECRPwwgsvAKgv1BcbG8vTbeL+BD3++OP44YcfANQ/QVuqbjtp0iTqlOj1ejpSIIZQVkGlUklmK1ojqyCTyaBQKNCzZ0/s27ePbu/bty/y8vKoLAG3hYeH088GAC+++CJyc3N5NkSuwN3dnefs/PLLLygoKKD7ic4SKcRI/t8B4Pjx4ygrK6M2XP0mOzs7tG/fntrm5eVRoUuuAyOl98RgtDVYUcE2jlarxbZt2wCA97R3t6LX65GRkcHLOuO2jz/+mF6no0ePYsqUKZLHyszMpP3o6GjMnDmTyl5wU+s9PT15Q6tRUVGNKvbWnBiNRp48AZE0qKysREhICH1SSk9Pxx9//GEmZUCWU6dOpcX5zp07hwceeMBMt4k4G++99x7eeecdAMD169d5BfaEvPLKK9TZqaystFj2n5t+LpfLRSuCE7i6TkqlEoGBgVSWgCtRYGdnx5M/kMvlePLJJ3lyBlxtJhJUSVi9ejV1Bri6THZ2dmYO1qVLl3i6SsTZEMPaJ10APKHNhpg2bZrVtlxV8YZoC2rUDEZLwJydViI+Ph7Z2dmwt7enN407mdLSUpptRtrEiRPRrVs3AMBff/1lcQSGK4oaFhaGAQMG0MwzofwFd165Q4cO+PHHH5vtc9XW1ppJGZDWuXNn6pQkJCTg119/NZM0IOv/+9//6NP5tm3bMGrUKMn3/Oqrr/Dss88CAG7cuMGbnhESGxtLnR2j0chTnBbCrb2j0WgQFhZG5Qm4cgZqtZoGawL1wc9vv/22qJyBWq3mORrOzs6Ij4/n2XAb14lQqVS4ceOG5PkKWbZsmdW2EyZMsNrWw8PDalsGg9E2Yc5OK0FGdQYPHtzqgVtNQVlZGa5fvw4PDw/qbBw6dAhz585FSkoKioqKzF7j7+9PnZ2AgADY2dnBz8+Pl3lG1jt37kxf17lzZ97UQWMwGo2oqKhAWVkZlTQIDw+nc/0XLlzAxo0bzSQNSPv4449pnZs1a9ZYHGH65Zdf8OijjwKoHymxFNDMnVMXFm4UyhVw44G8vb0xZcoUnowBV5upV69e1DY8PBwHDhwQ1W5SqVS8oMagoCCLjhEXrVaL999/3ypbW1tbM0FKBoPBaG6Ys9NKEGfH0hN8WyQrKwubN29GcnIykpOTcf36dSQnJ6OgoAAAP41RoVDg7Nmz9LUuLi402ywwMJB304uLi0NVVZXVwoZZWVlITEykUgbC9sILLyA6OhpA/ZTFa6+9htLSUpSVlUEYpvbPP/9g3LhxAOpH3P73v/9Jvi/XKeFWt1YqlTw5AwcHB16WQ3h4OE2hJY3YOTg48EZKevbsidzcXOqUWLomoaGh+O2336y6Zg4ODujXr59VtgwGgyEFt56OWK0fqXVXV9dWiwNjzk4rQcQ+21K8Tk1NDZKTk5GUlISkpCRcu3YNSUlJePTRR+kIxo0bNzBr1izR17u4uPAqO7dv3x6bN2/mpdNXVVVRSYOioiKUlpbS4nb79+/HX3/9haKiIp5uE1n/999/6c36zz//pE6VGOPGjaPOjsFgQHp6Om8/Sbl0dHTkORMRERF47LHHROUMHB0d0bVrV2o7YsQIFBUVwcHBwWJwLDmutTEaSqWSxVIwGBYwGo28tHpLS0t9sfWGGrdmT0P7xOr7cPvCuj5StmJ2wro9t7Ktse1m85quXLmC8PDwJv5vsA7m7LQSer0e4eHhvFoELUFdXR2uX78OtVpN40kuXLiAMWPGIDU1VfSfODo6mjo74eHhGDlyJAICAuDh4QEXFxc4ODjAzs4OVVVVKCwsRFZWFry9vaHRaJCXl4fXXnuNajcJM2AOHDhAHZjz58/j66+/ljx3buq3j48PoqKiJCUNuF+oUaNG4cSJE1SzSafTQaVSiYqUduvWDcuXL7fqWpI4EwajLWAymWidHpJOb20Tq/Uj1re0FDap7VKNWw+I2xdbZ9yeNEZ0uqlhzk4r0pyjOtXV1Th+/DgSExORmJiIK1euIDExEcnJyTAYDLx0dzc3N6SkpACoDwr19PSEi4sL7O3tYWdnh4SEBNy4cQNBQUFwc3NDnz598Pbbb0u+d//+/Wn58fLyciQkJPD2k3oYzs7OPOcqLi4Ob7zxBk/SgPR1Oh2vLsaECROsDjIlBfwYjJvBaDTSNHnShHV/pGoBCfsNNW69H7F9YoUNSV+qXs7dBql3I0yhl6rjI2VD6uhY04S2Yq/lbhPrc2v7NLRNrBYQ93jcmj5S24R1f6RqAYnZCNelXsetFST2cNmSMGenFblVZ8dgMCA5ORmXLl3CpUuXEBYWRst3FxQUYODAgaKvs7W1xapVq/Dkk08iLCwMnp6emDlzJpYvX47q6mqaLcUlLS2NFssiwbwKhYLKGHClDVxcXOjryHQSV7fJ0dFR9B8/Li4OcXFxt3RNGHcWRqORV+eHpMuTGj7WNLH6P2JLYZ+023kkQZgyL1bTx9I24jCI2ZB9XBvuUqzOj5gN9xjCdbHaP+Q4QgdFLpdbHfPHuPtgzk4roVQqJZ0RKaqqqvDuu+/ixIkTuHr1KrKysnhPc1qtFh07dkS7du3g4+MDDw8P5Obmmh3HYDAgOzsbGRkZCAsLg42NDeLi4rB582YqZSCUNOBWBZ0xYwYeffRRaDSaBr11ou3FuHMwGAy0lo+wDpBwu7DuD7fP3cZ1Yrjr3Lo7bQVuvR/SF1vn1gQS1v3h1vbhbiPrYvV/uH3ukjTuup2dHeRyeas/TTMYbQXm7LQQs2fP5q0PGDBAUhTt7NmzWLduHY4ePYry8nJs3rwZXl5esLOzwxdffCH5pFlaWorMzEy0a9cONjY2+Oyzz/Dpp5+aSRqQJbeS6qxZsyQDj4W0ppgbwzoMBgOvjg93ya31I9Unzgu3T9alKg83N3K53KzeD7e2j1qthlKp5NX64W4T7hPW+mlonTghzIFgMG4/WtXZmT9/Pv766y9cvnwZarUavXv3xieffIKIiAhqU11djZdeeglr165FTU0NRowYgSVLlsDT05PapKamYvbs2di7dy80Gg2mTZuG+fPnt6lS58L0YLEprJ07d2LOnDlm9U3OnTsHLy8v2NraYvTo0Th69Ch8fHwQHByMkJAQeHt7U1mDTp060dc98sgjeOSRR5rnAzGaFKPRiPLyclr7h9T14fa5rby83GzJ7XMLBDYnpAYQdyms+SOs/yOs82Nvb0+dFWHtH26/LX2fGQzG7UWr/nrs378fc+bMQffu3aHX6/Hmm29i+PDhuHjxIq1h8sILL2DLli34448/oNPp8Mwzz2DChAk0ddtgMOCee+6Bl5cXjhw5gqysLDz66KNQKBT4+OOPW/Pj8SgrK+Otc52df/75By+++CKSk5PpNqVSCT8/P3Ts2JE3hfTPP/80+7kyrMdkMqGqqgolJSVmNX9KS0vNltzG3cZVVW5KZDIZrecjtRT2uc3e3p7XJ+vECWExEgwG43agTQmB5uXlwcPDA/v370f//v1RUlICd3d3rF69Gg888AAA4PLly4iKisLRo0fRs2dPbN26FWPGjEFmZiYd7Vm2bBlee+015OXl8arCStESQqAKhYJOP/n7+yMlJYUOh0+ePBlr164FUB93M3/+fMyePZsNl7cQNTU1vNo/pK6PsN6PsBEHpykDWOVyORwdHaHVaiVr/QgbKWZIVKk1Gg1tUin2DAaDcSdwWwqBlpSUAADN5jl16hTq6uowdOhQahMZGYmAgADq7Bw9ehQdO3bkTWuNGDECs2fPRkJCAk9mgECyLAilpaXN9ZEo3BtiaGgo7wb0wQcfIDU1FcOGDcObb75plYPG4GMymVBWVobCwkIUFBTwlkVFRbTOD1kn24qKippkykcmk0nW/CG1fbh1fkjf0dGRFjfUarVQKpXMOWEwGIwmps04O0ajEc8//zz69OlDVZKzs7NFVYg9PT2RnZ1NbbiODtlP9okxf/58vPfee038CaxH+HnCwsLotByj3nEpKSlBfn6+aCsoKKBLbruVERYbGxtefR9SB4jU+tHpdGbr3L41mWkMBoPBaB3ajLMzZ84cXLhwAYcOHWr293rjjTd4StGlpaW0mnBLoFarYTKZ8PTTT6Nnz56YPHnyHT2aYzKZUFRUhNzcXNry8vJoy83NRX5+Pl3Pz8+/acdFpVLRWj+k9g+p7yO1dHZ2ppIVDAaDwbjzaBPOzjPPPIPNmzfjwIEDvCq5Xl5eqK2tRXFxMW80JCcnhypre3l54b///uMdLycnh+4To7XL/Lu6uuLEiRNYtmwZli1bhqKiIjz//POtdj43g8FgQH5+PnJycpCdnY2cnByzlpubi5ycHOTl5d2U86LRaHi1fkifrIs1lhbPYDAY5hBNK1tbWwD1D6HFxcWS+l5qtZpWwgfqS6JI6Xc5OTkhNjaW2m7duhW1tbU8La6xY8dCrVa39MemtKqzYzKZMHfuXGzYsAH79u1DcHAwb3/Xrl2hUCiwe/duWhk4MTERqamp6NWrFwCgV69e+Oijj5CbmwsPDw8A9SncWq2WCkG2NVxcXLBo0SK6PmnSpNY7GQFVVVXIysqiLTMzE1lZWcjOzua13NzcRuuc6HQ6uLu7w9PTk1fvh9u4Dk1rfjEYDMbtDVHdrquro1WXgfpyJjk5OTztLq7OV1BQEHx8fADUV6I/fPiwpNZX9+7d0aVLFwD1YRPLly+X1P4aPnw4xo4dCwDIysrCyy+/LCleet9999HabDk5ObjnnnskhUsnTZqE+fPnAwCKiooQHBwsKlIKAFOnTsWqVasAALW1tbxq90LGjx+PDRs20PWuXbtK/uYPGzYMO3bsoOsPPfSQWQZyeno6fH19rfzrNT2t6uzMmTMHq1evxj///ANHR0caY6PT6aBWq6HT6TBz5ky8+OKLcHFxgVarxdy5c9GrVy/07NkTADB8+HBER0fjkUcewaeffors7Gy89dZbmDNnTpsVaVSpVPjzzz8BAJ06dZIcgWpK6urqaNXkjIwMZGZm0iVpWVlZPLHNhrCxsYGbmxs8PT1pnR9uI4UMiXPTVv8eDAZDGiIwytX5cnFxod/nnJwcXL9+XVLna9CgQdR5iI+Px9atW3kaYFydr9mzZ9MRgv3792PhwoU8wVKuHtj8+fMxZswYAMC///6LadOmmQmcEr7//ns88cQTAOrFh0eMGCH5eb/88ks60n758mXce++9krYffvghz9l56623JG0dHR2ps1NeXo7Vq1dL2kZFRdG+Xq/HqVOnJG3z8vJoXyaT0UQfMbgV98kID/e1XC0v4e+1n58fDAaDqN6XsEp+XFwcKisrefpdxNlsLVrV2Vm6dCkAmMkm/PTTT5g+fTqA+n88mUyG+++/n1dUkGBra4vNmzdj9uzZ6NWrFxwcHDBt2jS8//77LfUxGs2VK1doGfzHHnvslo9XXV2N9PR00ZaRkYH09HTk5OSIKpqLQYYvuc3Ly4suSXN3d2eF3hiMZsBgMEhqfHXo0IHG+MXHx+PixYuiul7V1dV44YUXqAjuH3/8gfXr10sKmq5Zs4aOhn/55Zd45513qEMi5ODBg+jbty8AYN26dXjuueckP8vWrVups3Py5Em88cYbkrbDhw+nzk5WVha2bNkiaVtYWMi7Xvn5+ZK23Gl0Ozs7qFQqM50uorfl6OhIbXU6HXr06GGmBUbW27VrR23d3NzwxBNPSGp89e/fn9q6u7vjiy++ENX+ksvliIyMpLaurq7YvHmzmQ4YWZIZDaDeoUpMTIRMJhMVP1WpVNTW1tYWtbW1VLCzoQQLoV6iJXbt2mW1bUvR6tNYDaFSqfDtt9/i22+/lbQJDAzEv//+25Sn1qzs37+f9kn9IEsUFhbi2rVrSElJQWpqKl2mpqYiLS2N59lbQi6Xw8fHB76+vvD19YWPj49o02q1LLOIwfj/EDHSyspK6jgA9U/9GRkZohpfVVVVeOWVV+jT7A8//IC9e/eaaYCR5bFjx+iUwjPPPGPx9+7GjRsIDAwEAKxatQqfffaZpO2UKVPoOSckJOD333+XtOWW4DAYDJKFLmUyGW/UxNnZGcHBwTzNL67OFxEOBoCIiAjMmDGDZ8PV8+KOaMTFxWH58uWiIqZ2dna8MIUBAwbgwoULksKm3CnxgQMHWl1uokOHDjh27JhVtn5+fvj++++tsnVycsILL7xgla1KpcI999xjla1MJuM5YJawsbFp9dGWloQ9lrcC169fBwB0796dPvEQLl++jL///hvnz5/H1atXkZSUhKKiogaPqVar4e/vDz8/P17z9fWlS3d3d5ZxxLjjMBqNPH2vmpoanu7bzp07cf36dZ7eF1nq9Xr89NNP1Pa5557D9u3bzYRMCXq9ng7/v/vuu1i3bp3keT399NM0seK///7DmjVrJG0rKyupsyO8Adna2lLJDKVSyRulaNeuHQYPHiyp5cVN7Bg1ahSdfuKKlpI+dzThsccew/jx40VFT4XTH42Rpenbty8dEWqIkJAQhISEWGWr1Wp5f3MGQ0ibqqDcWrREBWXuSImtrS0MBgMWLVqEZ599FgkJCVi/fj3Wr1+PhIQE0dd7e3sjKCgIgYGBVEk8ICAA/v7+8Pf3h4uLCxuNYbR5iGNCnBKuFMrWrVuRlpZGdb64el92dnZYvnw5tX3ggQdw4MABUR0wjUbDC44cOXIktm/fbvGcyHdn4sSJ+OOPPyRty8rKoNFoAACvv/46tmzZwtP44mp7ffHFF/T3ZOfOnUhISOBpfnG1v7p160anGEpLS1FXV0edFzZVzGBIY+39mzk7aHln5+TJk8jPz0fXrl3x+eefY8GCBXSfXC7H0KFDMXDgQISHhyM8PBwhISFUK4zBaG0uXryIgoICUc0vBwcHXkzGpEmTEB8fTwVNy8vL6fS1n58f0tLSqG2vXr0kpwx0Oh0veH7EiBG87A+g/jvm4OAArVaL9PR0+p177733cPr0aTO9L6L19dxzz9HRivPnz6OoqIjuIw4M0QMTjmowGIzWhTk7jaClnZ2cnBx4eHjg6tWriIqKgsFgwJgxY/Dggw9i7NixvDluBqMpqK6u5ml9yWQy9OjRg+7/6KOPkJqayhM0JcuAgACeExIZGYnExETR9wkICOAFMvbo0cOsDhZQ/33w8/NDamoq3fbqq68iMTGRan0RnS8HBwfodDqaTQP8X5A/V8BUrVaz0U0G4y7jttTGulvQ6XQA6p84DQYDRo8ejU2bNrXyWTFuB3Jzc6nmF1f3q6ioCK6urnj22Wepbb9+/XD16lUUFxfztOAAICYmBvHx8XR95cqVuHLliuh7CmNIQkNDYTQaedpfpAnLKCxatAg1NTVmwqb29vZmjsmnn35q9XWwNgiTwWAwADayA6DlR3bat2+P3377DZ07d4bJZMLJkyfRtWvXZnlfRttnx44d1IkRtpCQEHz33XfU1sPDQzL7TujARERE8BwYIlbq7OyMyMhIXlrvokWL6PeA6H6RPsm2YTAYjLYGG9lpw2RnZ+Ojjz6CyWTC+PHjmaNzm2MwGFBZWcmrz7Fs2TJkZ2dTzS8iYpqXl4eYmBhs27aN2j788MOSDkzHjh15625ubtDr9XB2doarqytP40uYubJmzRrY2tpSYVONRiOZjXe7yZUwGAxGY2DOTiugVqtpxkdrqq8zpCHpye7u7nTbxx9/jKysLKr7RQRNCwoKMGDAAOzdu5favvPOO5IODLdWC1CfjltaWkr1v4iAqaurK08rDqivlWJtXAqp7MpgMBh3O8zZaQGSkpJ46yQtduLEiYiJiWmNU7or0ev1KC8v59Ue+fjjj5GRkUHFTIn2V0VFBQYOHMhzYL766ivk5uaKHlvo2EyZMgXV1dU8zS93d3e4urrC09OTZ/vXX39Z/RlYAC6DwWA0HubstADPPPMMb72kpAQymQzvvvtu65zQHYbJZOI5Ad999x3S09N5ml9ZWVnIy8szG4H5+uuvkZOTI3pcoU7YU089Bb1ezxMyJc3V1ZVnyxV6ZTAYDEbrwgKU0fwBykql0kxf5uGHH8avv/7a5O91p7Jv3z6kpaXxNL9Ii46O5mmxeHt7U1FZIdHR0bzCje+++y70ej28vb15gqZeXl7QaDRsJIXBYDDaMKzOTiNobmdHeMO0sbHBlStXEBYW1uTvdTtRW1uL9PR0qvHFbT4+PjydGS8vL8kRmPDwcF7W0UsvvYTq6mp4e3vDx8eHt3Rzc2OSGQzGXYbJZILBYIDBYIBer6d9sXWDwQCj0Wi2TawJ7Sytk77RaOT1xfaL2XOb2HZrt1lzPJPJZNFebL9wm9j64cOHrZYAsRaWjdWGCQ4OviscndLSUty4cQMpKSlISUmBQqHAk08+SfcHBQUhKytL9LXC69O/f38UFhZSnS+i+eXj42MWxPv55583/YdhMG5jyM2+rq6ONr1eb9a3tI27lNp2K404HsK+pXUxp0VsP3umbxtwdd1aGubstAJ3SpZMRUUF8vPzqQIzAMycORNnzpzBjRs3zARMQ0NDec6On58fioqKqL4XV+tLWNfFklozg9HSmEwm1NbWora2FjU1NaipqeGtN9Qnra6uzmybcB93KbZNzEasMcSxsbGBra2tWZPJZFZvF27jrpO+2DbhfqGt2Dbu+ZL9wm1knfta7jax9cbYCNfFXif2Gu69oqVhzk4rwE1nvh04evQoLl++jOTkZF7Lzc1FWFgYrl69Sm3Pnz+PM2fO0HUXFxcEBgYiMDAQ4eHhvOPu2rULjo6OLC6GYTVGoxHV1dWoqqpCdXW1Va2mpsasz10K+8LGdWhIu1OcB4VCAYVCAblczltyt3O3cde5S2FfLpfD1taWt024TrZZWudus7QU9q21ITdoxp0Pc3Zagbbk7Oj1eqSkpCApKYm2qqoqLFu2jNrMnTsXp06dEn19aWkpLxuKSGAQhXZuoT0hzVWtmtFymEwmVFdX07pEVVVVqKys5DWyraqqyqxvqXGdGrIUBvq3FWxtbaFUKqFUKmFnZ0cbWVcqlVAoFGb7yTaFQiG6TrYJl8J+Q/vEGnniZtx9cGNqhEuj0chLzigrK0NNTY3ka3x9fanDmJeXh9LSUrqPaxceHm4mPdOSMGenFeDWeWkJjEYjcnNzebpFzz//PLZu3Yrk5GSzeVQ7Ozt8++23VOG5X79+cHV1RUhICG3BwcEICQkx+yyjRo1q9s/DaBx1dXWoqKhAeXk5bRUVFXQb6QtbZWUlr0/Whc5MayGXy6FSqWhTq9VQKpV0XalU8rYJ95FlYxtxXkhTKBR3rRo6iQUSC/JVKpX0YcdgMOD69euSgb4uLi40Ts9gMGDPnj2Sgb4+Pj7o27cvPYcVK1ZI2gYGBuKBBx6gtgsWLEBVVZVoIHBQUBBPW+7VV19FUVGRaABvYGAg5s+fT21nzZqFrKws0YBgPz8/rFy5kto+/PDDuHLlimggr6enJy+z9IEHHsDp06dFg4F1Oh0uX75Mbe+9917s3bvX7JgmkwkKhQIVFRU8282bN0v+Xevq6iCX17sHTzzxBNatWydpyw0Mfv3117FixQpRu/T0dPj6+koep7lhzk4r4O3t3SzHLSsrQ2JiIi5fvkyXV65cwdWrV2EymVBRUUE98MzMTJrBpFKpEBoairCwMISHhyM0NBQGg4H+gH/55ZfNcr4Mc8hISVlZGcrKylBaWkr73FZeXm62FPZJa6nREOJc2Nvbw97eXrSvVqtpE66TRhwX4Tp3qVKp6I9xW8BoNNLYGOIAAfVxbVlZWWbBv6RFRETAx8cHQL2MzP79+yUDgQcMGEDj/W7cuIHvv/9eNNC3rq4O999/P8aMGQMAuHbtGl544QXJYN/p06dj9uzZAIDk5GSMGDFCMth39uzZ9CaflpaGgIAAyWsya9YsqutWUlJiNo3NZerUqVi1ahWA+hvt8OHDJW3Hjx/Pc3ZmzZoFg8Egajts2DCeszN//nyUlpaK2vbp04fnbDRmDwAAOv5JREFU7KxatUoygSI2Npbn7OzZswfXrl0TtRV+7vPnz+PcuXOitsI4x8zMTFy/fl3Utrq6mrdeUVFBC9Y2RENTd9yAbu7oH4nP4cbqcG3VajUNTRDatfYoYtv5tbiL8PDwuOnXmkwm5OTk4OLFi7hy5QqefPJJ+k/06KOP4u+//xZ9nUKhQHZ2Nv1hfeWVV/DUU08hPDycNwzJuHlqampQUlJi1kpLS+mS27jbiGNTWlrabBkLcrkcGo0GGo0GDg4OdGmp2dvb8/pkXa1W8/ar1eomHd3gBgDb29vTY+fn5yM5OVky+HfgwIFUjuPMmTPYu3evZADwM888g+joaAD1YqzffPONZNDvokWLMGTIEADA+vXrMWvWLJ7TYjQa6bmvWrUKU6dOpcedMGGC5Of87rvvMGvWLADAuXPnMGnSJEnbL774gjo7mZmZvJutkNDQUOrslJeXY9OmTZK2gwcPpn2j0WhW8Z0Ld3Sgob831wGRy+VwdHQUDfi1tbXlFeWUy+WIiYmRDBBu3749733Gjh0Lo9EoGvzboUMHnu3jjz+OmpoaXvAseU1QUBDP9tVXX0VlZaVo8K/wN/zjjz9GeXm5aGCvcCr/q6++Qnl5uWjwr1Kp5Nl+//33KC8vFw3+FTr7v/zyC6qqqng23EBhLr/++ivq6urMjil27N9++w2rV6+2yln55ptv8M033zRo1xowZ6cVEGojWeLMmTM4cOAAEhIScPHiRVy8eJHn/Y8bN446MFFRUTh69CgiIiIQGRmJiIgI2oKCgnj/wN27d2+6D3SHUFtbi6KiIhQVFaG4uJguhX3SSkpK6LKkpMTsSetW0Wg0cHR0FG3cfaTv4OBA18WanZ1dg+9pMplQV1dHA3q5dYmuXbuGtLQ0FBQUmAX+VldX47HHHqM/7H///Td27twpGQT866+/0lGBzz//HF9++aVZUDDh1KlT9Cb/ww8/4M0335Q8/wMHDqBfv34AgEOHDuGll16StB07dix1dtLT0y06BNzvnMFgMHsC58J1VlUqFRwdHc2Cf0mfG7fm5uaGgQMHSgb/RkREUFsfHx8899xz1EYY/EuuAQD4+/vjhx9+MAv8Ja/jjjz4+fnh8OHDooG9crkczs7O1NbT0xO5ubmSwb/cG6xWq5UcUREil8sRHx9vlS0AbNiwwWrbxpSlaIw47sSJE622HThwoNW2QmfNEo2ZImpMvOSd8iDMnJ1WQCxAuaioCMeOHcORI0fw+uuvw8HBAUD9U+IXX3zBs5XJZAgNDUVkZCSqqqro9g8++AAff/xx8558G8dkMqGsrAyFhYUoKChAYWGhWSsqKjJbFhUVNVn8iaOjI3Q6HW1arZYuhX2y7ujoCK1Wy3NouD8yVVVVKC8vlwz+HT9+PLXdsGEDDhw4IBkQ/Pfff9MnyFdeeQVr1qzhBQFzRyny8vKoc/75559j6dKlkp973Lhx1Nk5cuQIlixZImlbUlJC+xUVFcjIyJC05To+Op0Onp6eksG/5HsDAJGRkXj44YfNAn1JCw0NpbZ9+/bFDz/8IBoIrFAoeBp2I0eOxMWLFyWDgblP56NGjbL6Jt+lSxeelIklgoKCrJYkcXFxweOPP26VrUqlQu/eva2ytbW1bVPJFgyGJZiz0wpwR3ZWrVqF+fPn4+LFi3TbkCFDqPfft29fXL9+He3bt0f79u0RHR2Ndu3aQaVSmR33TguSNBqNKC4uRn5+vmgrKCgwa4WFhbc0DWRjYwOtVgtnZ2c4OzvDyckJzs7O0Ol0dN3JyQk6nc6sr9PpUFVVReNmuAHA5eXlMBqNeOyxx+h7ffHFF9izZw8v8JcsDQYDryr0xIkTLQYU1tbW0jiRP/74A2vWrJG0rayspDfkkpISi44G15n29fVFZGQkL/iXG/DLvckPHTpUMhhYpVLB39+f2s6cORNjxoyxGAxMePrpp/H0009Lni+XYcOGYdiwYVbZtmvXDu3atbPKljixDAbj9oHJRaBl5SJsbW3pzfizzz7DK6+8QveFh4ejd+/eePbZZ++YwoNcDAYDCgsLkZubi7y8PLMltxFnRirwsCFUKhVcXFzg6uoKFxcX2pydneHi4gKdTge1Wg07OzvI5XI6X03m/u+//356rPnz5+Py5cuiQcEODg64cOECte3Xrx8OHTokek4ODg4oLy+n66NHj8bWrVslP4Ner6cO7EMPPYTff/8dKpWKBvaSWBl7e3vs2rUL9vb2AOqzU06cOGEWBEz6EydOhFqtBlAfkFpUVMQLCiZ9Ozu7O2YIm8Fg3JkwbaxG0JLOjoODA8rKyvDOO+/gww8/BAC8/PLLePXVV2/LIeG6ujrk5uYiJycH2dnZyMnJMWu5ubnIzc1Ffn4+b4rEWrRaLVxdXeHu7g5XV1dotVo4ODjAyckJ4eHhcHV1haurK44dO4by8nLU1dWhqqqKFwzs6uqKP/74gx6zQ4cOPEFQLj4+PrzRjj59+uDIkSOithqNhpcBMXbsWBw8eJAX/MsNCP7999/p/8Mff/yBlJQUXqAvNyC4S5cu1NmoqamhtVEYDAaDUQ/TxmqjxMTEwGg0IjExEUB9FP8bb7zRymfFh8S9ZGVl8Vp2djZdkpafn9/o45MRFp1OB41GQ2uhkBiABx98EO7u7nB3d8fcuXNx7do1FBcX48qVKygpKaGpjtHR0byAw2eeeQaXLl0SfU9h8B6JLSG1QLjxMtx6RADw5JNP4t577+UFBJOgYI1Gw7O1FOQq5MEHH7TaVpilwWAwGAzrYc5OC+Pu7g5bW1usWrUKDz/8MMaNG9ei719dXY3MzExkZGQgIyMDmZmZoo2bYtoQtra2NMjW3t6eTg2RgmP+/v748MMP4enpCTc3NwQEBEjWpGjfvj2tzQEAly9f5sUzEUjmCZdx48YhLi6OFwRMli4uLjzbHTt20JiQhnj00UetuQwMBoPBaKMwZ6eFIVNVdnZ2Te7oVFRUIC0tDenp6XRJWkZGBtLT01FQUGD18ZRKJXVebG1taVpyVVUVQkNDsWrVKnh5ecHV1RW+vr5ISUkRPY5er0enTp3ourOzM/Lz83kBwKQfEhLCe+3XX38Ng8HACwLW6XRQqVRmdR8WLFhg9WezJGPBYDAYjDsL5uy0MNu3b8d3333HU/+2Br1ej8zMTKSmpiIlJQWpqalITU1FWloabZZqf3CRyWQ0+NRgMKC2thYmkwmRkZH47rvv4O3tDW9vb7Rr106ygqher0fHjh3per9+/VBYWCgaEEzqABFOnToFpVJpVZEqUsiNwWAwGIybhTk7LUx6erpkwazS0lJcunQJly5dQnJyMlJSUnDjxg3cuHED6enpVgX3Cst3BwQE4O2334afnx98fX0xbNgw5OTkiBbA02q16N+/P11/7LHHUFNTQwOA3dzcaF8YTP37779bewlE0+YZDAaDwWgumLPTzFy9etVsm5+fH4D6QOB169Zh+fLlSEhIkBxFEaLT6TB+/Hj4+/vD398fb775Jp2e4jo6rq6u6NChA6+g2Lx582A0GmkAsLu7O3VihIq0JFuMwWAwGIzbGebsNDNicTl+fn4oKCjAk08+iT///JO3z9vbG1FRUTh+/LhZkLBMJoOHhwe6d++On3/+mW5Xq9VUr8XT0xMeHh5wc3Mzc14AUME/BoPBYDDuFpiz08xwq+ASMjIyEBUVhby8PLrNzc0NV69ehZOTEwDgxx9/hI2NDY2f8fb2pplcQh555JFmO38Gg8FgMG53WFFBNG9RwYaCcNVqNZYuXYp7772XOjoMBoPBaPuYTCYYjUYYDAazpVTfaDSKvkbqOGQft4ltl7K9GTvyuRqzX7iNrHO3f/rpp/D09GzSvwErKngb0L59e6xfvx6RkZGtfSoMBoNhhtFohF6vR11dHW/JbWLbrGkGg0FyXWqf2JI07rqlfcImto/rpFjadzMV4e9m/ve//zW5s2MtzNlpJaZPn45vv/2W6hkxGIw7C5PJBL1ej5qaGtTW1oq2uro6yXWxfl1dHW3cdeE+axpxVISODHfJBv6bBltbW8hkMtja2kr2ZTKZWV+4zdbWFjY2NrzXEl0/7jayzj2GcJu1NsJzEW6zsbFp8HVknSuC3dIwZ6cFUalUqK6uxpQpU/DTTz+19ukwGHcUBoMB1dXVvFZTU9PgsjGttra2wSW33YnY2NjQCubcJtxma2vL20bWbW1teduEr5FaJ4VNyTmQGz/3xurm5kZty8rKUF1dTW+25HWkRUVF0WrvaWlpvIKrwhIegwcPhoODA2xtbXHu3DkkJyfzrgnXdsqUKXB2doatrS0OHz6M48ePS04HPf3001SeZteuXdi2bZvkdNDLL79Mi67u2LEDa9asEZ1CMplMeOutt2gdtO3bt2PJkiV0lE44vfTee++hd+/e9LgffPCBmQ1Zfvjhhxg5ciQAYPfu3Xj++ed5NqQZjUZ89NFHmDhxIgDgwIEDaNeunVkl+5aEOTstiEKhQHV1Nfr169fap8JgNBuk0nZlZSUqKytRVVVFl8K+sFVXV5v1uUthnzgt1dXV0Ov1rf3RLWJjYwM7OzteUygU9IZLHAOy3cHBgfarqqrMRgHIUq1WIygoiNpevnwZer2e3uC54rFOTk4YNmwYFAoFFAoF/vzzT5SVlZndrID6pIk333yTntu8efNw48YN0WkgFxcXXq2tGTNm4OzZs9Dr9aitreXZazQanD9/ntred9992L59u+j0kZ2dHWpqaqjtvffei40bN0pe47q6OiojM3nyZKxdu1bStri4GDqdDgDw+OOPY/ny5ZK2GRkZtDjqokWL8PXXX0vajh07ljow27dvx/z58yVt77//fmp77NgxntafkIcffpg6OxcvXuRl5Ap5/PHHqbOTkpJi8ZrNmTOH9vPy8nDo0CFJW65DWFpaigsXLkjalpSU0H5b+H4yZ6cFMRgMAGAmicBgtCQGgwEVFRUWW2VlpdlS2Bc24shUVla2eiyDra0tz6lQqVTQaDRQqVRQKBSoqKigIwDCoXxPT09ERETQKt979uyhx+U6BCaTCTExMZgyZQqtSP7EE0/QG7YwtmTIkCG8EV0HBwdUVVWJThUNGzYM27Zto+tOTk68mweXXr16YcWKFXTd19cXmZmZorYxMTH47LPP6PrMmTNFa4EBQGhoKL744gu6vnv3bpw9e1bUViiee/XqVUlboVRLRUUFSktLRW3JbyaB67gRuM6fwWCgzo6TkxPc3d1FHURhVmtgYCBiY2Mlp4i4OnxRUVEYOXIk73jcaRwHBwdq26VLF0yfPl1yiog70tGrVy+8/PLLvGNyX0fqswFAnz59sGDBArPpJ/KaiIgIatu/f3/88MMPvBEw7ohY165dqW2/fv2wfv163ntz7WNjY3nnsHPnTt40Ftc+LCyM2vbo0QNqtVr0b9xSsGwstHw21oEDB9joDsMqDAYDysvLUVZWxmtkW3l5Oa+JbauoqOAtxapnNxc2NjZQq9VwcHCAvb095HI5KisrzeILyPckMjISHTt2hFqtRkVFBdatW8fLHuEGrU6ZMgXPPfccVCoVMjMzLX6n5s6dS5/Gs7Oz4e3tLWk7Y8YM6jyUlZVZ/E2YOHEi1q1bB6A+mFesNARh9OjR2LJlC11Xq9WSf4vBgwdj9+7ddL1du3YoLS2loz/cKaLY2Fj8+uuv1HbSpEkoKCgwm2aytbVFUFAQT0Pugw8+QH5+Pp0u4i5dXV0xd+5cart27VoUFBSI2trb22P8+PHU9tixYyguLjazI+fdpUsXapuWlobq6mqzWBbSuHEeZJSH7LNGcoZxZ8Oysdowrq6urX0KjGamuroapaWlKCkp4S25jWwrKyuj20ifODWVlZXNep7cGyEpSung4IDq6mpcuHDBLGWVBK0+8sgjGDduHOzt7ZGYmIgXX3xR9Pgmkwnz5s3Dq6++CgA4ceIE4uLiJM9nypQpeP/99wEAly5dwqeffippq9FoEB0dTT8HgUwNKRQKqmzP/RFUq9Xo3bs3bxqJu+zZsye1ValUeOWVV+g+rp1CoUB4eDi1lclk2LBhA5324Ta5XA5nZ2fe+V+9epXe/Ll2crncbARDrF6XFJamboS8/fbbVttOmjTJalvuNWwIf39/q22VSqXVtgwGF+bstALcH0hG28NoNKKsrAzFxcUWW0lJCV2SPnFimiM4lYyC+Pn5wcvLC46OjigsLMTp06clX/PSSy9h9OjRcHBwwLFjx/D888/z9pNREgB4/fXXMWvWLADAzp07MXz4cMnjxsbG4oEHHgBQH9vh5uYGlUoFlUoFpVLJW3JvZl5eXpg1axaUSqVo69GjB7X19/fHP//8w9vPnZriPvH7+fmhuroaCoVCdKqDi06nw+HDhy3aEBQKhUWHSwh3dKMhuNMSDAajeWHTWGjZaSylUtmi0wh3KyaTCRUVFSgsLERRUREKCwtpKyoqottIn7utpKSkyVJutVottFot9Ho9srOzJe3mzp2LPn36wNHREQcPHuRNNQhZt24dzXJYv349HnzwQdjY2MDe3h5qtZou1Wo1PvjgA4wZMwYAcPbsWXz55ZdQq9VQqVTUhqwPGjQIHTp0AAAUFhbi7Nmz1IERNo1GAzs7uya5RgwGg3GzWHv/Zs4OWtbZ8fb2lgweZIhjMBhQWFiI/Px85Ofno6CggLfMzs5Gbm4u8vPzUVRUhOLiYpSXl6Ourq7Jz2Xo0KEICwuDTqfDhQsXeDEYQv7991+MGjUKALBy5Uq89NJLcHBwEG0vv/wyunfvDgBISEjA1q1bYW9vTxuJebG3t0d4eDgNbKyrq4PRaISdnR2LX2AwGHcdzNlpBC3p7MTFxeH48eNN+h63G9XV1cjLy0Nubi5d5ufn48qVK7hx4wZ1WkpLS285oJbEWAhFVbnMmzcP3bt3h7OzMzZt2oTFixfD0dERWq0Wjo6O0Gg00Gg0cHR0xFtvvYX27dsDAOLj43H48GG638HBgfY1Gg18fHxaPQOBwWAw7mSYs9MIWtLZmTJlCn777bcmfY/WRq/XIzU1FVevXsX169eh0+mQn5+P3NxcHD9+HMnJySgtLUVFRQVqamrM0kmtRavVUkX3goICXsqsXC6Hvb09dVK+/vpr9OzZEw4ODti7dy927dpFnRcyteTo6AhHR0dERUVBo9E01eVgMBhNDLdoHleqwWg00lo5QH0dmMrKSkltKfKgAtQHiBcUFEjqRQ0ePJhm1506dQqpqamS+lIPPfQQDZ4+ePAgEhISJAsJzpo1i95ndu7ciaNHj0rqTL300kvw8PAAUD9SvG3bNkkdqrfffhuBgYEAgE2bNmHt2rWihQFNJhM+/PBDGty/adMmLF26VNJ2wYIFNJZu8+bN+Oijj8wKCZL+woULMXToUADA1q1b8fLLL9P9+/fvbxapCJaN1UaJiYlp7VOwSHV1NZ0eyszMxLVr13Djxg3ExcXRKaMdO3YgMTERVVVVdBrlZomIiIC/vz/c3d2RkZGBK1euwNHREU5OTnB1dYWbmxu8vLzg4eGBadOm0S9+Tk4OSktLodVqodPpoFKpJN9j8ODBGDx48E2fI4PR3JAbArm5mkwm5ObmSmpPaTQaXh2TPXv2oLa2VlSDyt3dHSNGjKC23333HcrLy0V1p3x8fHhF5t58803k5+eL6k75+vpi0aJF1HbGjBlmRQeJrbe3N/79919qO27cOMTHx4vqTrm5ufEeZAYMGIADBw6IXjcHBweUl5fT9alTp2L79u2itjY2Nrzfqtdffx1//fWX5N+ksrKSjsx+9dVXvPR+IaNHj6bOzurVq7Fs2TJJ24kTJ9Kb8rZt23i1jIRwf/OOHTuGxYsXS9o+9dRT1Nm5ePEiVq9eLWnLTVRISUnB1q1bJW25hQRzc3Nx7NgxSdvi4mLaLy0txcWLF+l6c4QVNAbm7LQwDz30UIu9l8lkQmlpKfLy8njTRtnZ2UhJScHDDz+MvLw8ZGZm4tdff6UVT28FUvcjKCgIHh4eKCoqQkFBATw8PODt7Q1fX18EBgbCz88PLi4u8Pf3h0KhaPT7eHp6tpqgHKPtQSr1crWkHBwc4OTkBKD+xhUfHy+pSRUVFUWLqxUXF+O7776T1J7q168fpkyZQm2nTZsmqTs1ZswYmkpfUVGB8PBwUU0qo9HIq9ljMpnMCvVxEdbsGTNmDKqqqkRtBwwYwHN23nrrLeTn54vaduvWjefsrF69GikpKaK2UVFRvPXjx4/j0qVLoraFhYW89aysLKSmporacssIAOK1ygjCBy2SsScsIEj6JpOJHs/T0xPBwcFmRSXJOpd27dqhT58+kppS3HPu3Lkz7rvvPkndKa4eYq9evfDUU0+JakoJiw4OGDAARqNRtDihjY0NrfAM1D/gffnll2ZFAclruI7ykCFD8PPPP5vZiBUSHDJkCDZs2CBacFAmk6FTp07UdtCgQdizZw+1cXd3l/w7tgRsGgstN42l0WhQWlp6S4GkBoOBjrDk5OQgNzcXOTk5tP/FF18gNzcX6enpePfdd61OsbV0/mq1GpGRkQgMDISXlxf9wQgICEBQUBDCwsLQrl27Jr92jLaLXq+n8VRCvanq6mqEh4fTwn3p6enYvn27pN7U+PHjaUHAhIQE/O9//+PpTXH7L730Ep544gkA9VMLffv2RW1trejo4jvvvIP33nsPQP2TLncKQ8hLL71EKwunpKQgKChI0vbJJ5+kT+4FBQUWxQ0ffvhhOiJQXV1tMYbrvvvu4400yOVyWr1XqDs1ePBgrFq1itr27t0bNTU1otpUMTExWLhwIbWdPXs2ysvLRbWnAgMDeTWTvv76a5SWlvKKApLXuLq68mrvbNmyBeXl5WZFAckNvn///tT2/PnzVAKD22QyGezs7HhV5gsKCmAwGEQLDhJ7xt0Lm8Zqg4SEhEg6OlVVVcjKykJmZiYyMjKQlZWF7OxsZGVl4ccff4RCoUBtbS0eeugh/P3335Lv8csvv1h1LjKZDD4+PggICICPjw+0Wi1cXFwQGhqK0NBQ+Pj4wMfHB05OTizLpw1jMBh4elOVlZXw9/enMUjXr1/HiRMnJLWopk+fTtPN9+7di4ULF4rqUVVXV2PJkiWYMGECAOCff/6hdXbE+OGHH/D4448DqHdgSF8Mf39/6uwUFxfjn3/+kbTNycmhfVtbW8ngdYVCwSsfYG9vj5CQEFFtKoVCwXvS1Wq1mD59Om8/t3Xr1o3aajQafPfdd6J2CoUCvr6+1FapVOLMmTNmzguxFU7F1tXVWf3dO3LkiFV2ALB06VKrbZ999lmrbe+55x6rbYlukzW0RBFWbhyOMB7HYDDA0dGROlWkpIVYnI/RaISvry+NIyoqKsK1a9ck43ciIiLoQ0FeXh5OnDghKQQaGxtL/09zcnKwY8cOSSHQHj160BGZnJwcrFmzRlLcs0+fPtQRzcvLwzfffCNqazKZ0L9/f/p3LiwsxHvvvScpBDpgwAA6AlpWVga9Xm9WWLMlYc5OC0J+mGtqaniVQGfNmoUffvhB8nXnz59HdnY2srOzrar/otVq4efnR6eNgoKC4Ovry2tubm7MiWlmTCYTamtrqVQDV7ahoqICffr0odMsR48exY4dO0T1qCorK/Hll1/SeK8ffvgBr776KiorK0WLF27bto1OW+zevZuOhIjRs2dP6uzk5uZanLvn6hdxb8zcAoKkz9UH8vLywpgxYyQLCXK1ecLCwrBs2TKzQoKkHxwcTG2jo6ORkpJiVi1ZoVCY/W8HBQXh2rVrkp+Ni7OzM0/DyhJKpZIWYmwI4ZSANfaWIDcVvV7P+z0pKipCZWWlWUwOaVyphgsXLiA7O5tnw+0/+OCDdJp57969uHjxIi8Wh9t/+eWX6d99w4YNOHjwIM+O2z777DM6rbFy5Ur89ddfZkKgpL9ixQo60vP9999j2bJlkrZ//fUXvcZLlizBu+++a+bEkOX27dsxcOBAAMCyZct403dCNm3aROtVrV+/HtOnT5e0Xbt2LQ1X2L17Nx588EFJ2xUrVmDGjBkAgJMnT1p0GBcvXoxnnnkGAHD58mU8+uijkrYLFiyg1yEtLQ0vvPCCpO3bb79NnZ38/Hw67SqGwWCg51heXm5REFUmk1Fnh4zQMmfnDkUYpFZbW4tRo0Zh7969OHDgABITE3H48GFs3rzZ4nHOnDlD+0qlEgEBAQgMDIS/v79Z8/PzY9NJN4HJZEJNTY2o/lT//v3pPPuuXbuwZ88eM/0p0n7//Xf69PX+++/j3XfflXzPY8eO0SyHI0eOWLTNzc3lnSs3EJBACgVyp3T8/f0xYMAAXgFBblFBbjXvHj164KeffuIVHOQWEgwICKC2I0aMQHV1tVX1fTp16oRNmzZZtCF4enriySeftMrWzs6Od06Nobi4mE6PcWNyamtroVQqqQMI1GfMlJSUmMXl1NXVQavVYtq0adR20aJFyMjIEI3fcXJy4gWYzp07FwkJCTwbbgAyNxD0vvvuw/79+3lOCwn4VKlUvHidRx991OJvCpkSAuq1sbhq5ULGjBlDnZ1ff/3VohP45JNPUmdnz549+OabbyRt33nnHersJCQkWBzNKysro/2cnBze76EQ7nUgJS6k4GaFNlR1m/udksvlUCqVkkKg3BhEBwcHBAQESAqBcjPJnJyc0KVLF0khUK6em4uLC0aMGGFmQ9a532tXV1dMnjxZUgi0c+fO1NbZ2RmzZ88WjfORyWQYMGAAtdXpdHjjjTd4dtwl9yHGwcGh1acbWcwOmi9mx9PTk3eTioyMxOXLly2+RqfTITg4GEFBQQgMDKSODVm6u7uzERkORNqhpKQEvr6+NJvl+PHjOHfunJkeFdGd+vXXX+mP7euvv47PP/9cMjj78uXLVEX47bffxocffih5Pv/99x8tDrhw4UKqCUVGO7jt+++/p0/Ze/bswR9//MErIsgtJDhw4ED6Y1dYWIjc3Fw4ODjQiskqlarBH+yWwGQyQa/X0xiempoa2NnZ0WttNBpx4MABs1gc0gICAnhPt6+++iqqq6tpIDF5TW1tLWJiYvDBBx9Q2z59+qCoqIgXeExa9+7dsXfvXmrr7e0tWdE6NjaWd0MNCwuTHBUKDw/n6VZ16tQJ586dE7X18fFBRkYGXe/duzeOHj0qaqvVankq58OGDcOuXbtEbeVyOS/TZcKECdi0aRNPLJQbn5OcnExvPK+99hq2bt3Ks+EKd/79999UpXzJkiXYu3evWewO6S9YsICOVG7cuBFHjhwxi/UhN/InnniCPuUfP34cZ8+eFY31kclkGD58OD1uUlISkpKSePu5y/bt29Pzzc/PR05OjqjquUwmg7u7Ox2hJNO2QhviQDDR0bYLq7PTCJrL2RF+OTw9PWnMgVwuR9euXdGnTx/07NkTYWFhCA4Opl/qu4Xa2lqL+lPPP/88/WH+/PPPsWHDBqpFVVJSgrKyMjq1l5WVRTNY5s6da/HJkuvA/O9//8PHH39M95F6PaSg4Jo1axAZGQmgfopo27ZtcHBw4BUcJEUFe/XqxcsAIllBwgyT5obE8shkMjoqVV1djTNnztB4HfIDT/odOnTAoEGDANSPfLzxxhu8mB1uHM8999xDRSRLSkoQHBxMbYQ/KZMnT6ZpsHV1dRaf8MaOHYuNGzfSdaVSKakzJlQGd3V1Ncv6IQiLeQYEBCAtLY0Xu0OW7du3x7Zt26jtpEmTkJGRISoE6uPjgy+//JLafvbZZ8jOzhaN39FqtbwpxZ07d6KgoMBMBJS8R58+fahtSkoKqqurzYKPyTp3hIDBuJtgAcptEJLu+eCDD+KXX365Y6rrGgwGOqIC1M89JyYmSupQ7d69m97wZs6cycsqETJ9+nRaZ+LGjRuS2WUKhYJXbyM2NhZjx46FTqfjFRN0dHSETqfjpa2/+OKLmD17NnVeuJ9FyMiRIzFy5Eirrgs3xZRA4nhI3A5pXl5eNJg1Ly8PGzZsMIvbIe3ee++lwcFJSUm47777eAHKVVVV1EF45ZVXqJBlZmYmevfuLXm+s2fPps5OXV2dxVoh7dq1o307OzsUFRWJ2gmdPLlcjujoaBpjI2xkVIzwyiuvwGQyiQqBCtWySSYT14EhrxH+LZKTk61+Wm+MivjLL79ste2wYcOstiX1UxgMxs3BnJ0WhMwRv/DCC23W0amqqkJ+fj4KCwt5NRNWr16NY8eOoaCggDYirFlSUoKamho6V71o0SKLVaKLioqos0FGQbRaLZydneHk5ASdTkf73JvR9OnTMXDgQOh0OrOmVCp5tjNnzsTMmTOt+sxS2R56vZ4Xu1NeXo6AgAA6epSSkoI///zTLG6HBCLPmjUL999/P4D6+JwRI0agoqJCtIL0Rx99hDfffBNAfaq2pbgVf39/XibUhQsXJG252UoajQbBwcF02ksYw8MNXHV0dMS7774rKQTKvfmqVCpcunTJTPXczs7OzHG0sbFBQkKC5PkKsTRlKIQbT9AQLT3SxmAwWhf2jW9hlEolDUptbkwmE4qKimhRwcLCQowbN47uX7hwIXbt2kUFNvPz81FZWUn3k3gLoL5UuSUHprCwkDownTp1QnZ2NlxcXODs7GzWyJw6OYdFixZZHE0hdO3alRf0JgZxUMjNHKh3Hg4dOsSL2SHLsrIyPPXUU3REY8eOHXj44YdRVlYmmta8ZMkSzJ49G0D96MBLL70keS7cqs0KhYKXzUS2kdgcrvPr5uaG8ePH84RAuY37/+Pr64tdu3bxlM65fW7WlIeHB5KTky1eP4JKpcK8efOssrWxsaHTfAwGg9EWYc5OC9OlS5dbCiStq6vjFRIsKCjAww8/TPe/+eab+Pfff2m1ZGHQbXV1NU1TPXfuHHbs2GH2HgqFAm5ubigpKaGBpePGjUNAQABcXV15zcXFBS4uLrzCaq+88gpeeeUVqz4P92ZsNBpRWlrKi9kpKSmh/XvuuYdmOu3duxfz589HSUkJSktLaQwPcdZWr16NyZMnA6ifViN9MQYNGkSdHblcbpbBYWdnR2N0uPEmfn5+mDp1qqQQKNcxa9++Pa5cucILPJaqHO3v748NGzZYdf3UajWGDBlilS2DwWDcrTBnp4VQqVSorq7mpakSyAhMVlYWsrKykJ+fz6tM+vrrr2PTpk3UuRHy4IMPUgcmPT0d8fHxvP2Ojo7w8PCAu7s7KioqqO3MmTMxdOhQuLm5wd3dHW5ubnBzc4Ojo6NZLMPEiRMxceLEBj8nmaIhIzXXr1/HsWPHeLE7xcXFKCoqQnFxMT788EMaR/Lzzz9bnHry9PSkzk5RURF27twpactNV/X19cWgQYNo0LFQCLRv377UNi4uDufPn+cFKEsF1IaHh1uMN+KiUql46aAMBoPBaDmYs9NCkEwK4sQsWrQI27dvR3JyMlJSUlBTU8Ozv++++6hTkp2dzRNUs7W1hYeHB9WHqqyspLbPPvsspkyZAg8PD6oQLiWSSQpqiUF0tfLz81FQUICIiAia8XH48GGsXr2axuxwW3FxMbZv347hw4cDqB+BseTApKamUmeHxO8olUoas0OaTqfjab90794dK1eu5MXtEFFQ4QhM9+7dsWfPHslz4KLRaHg1VhgMBoNx+8OcnRakb9++1GGIj4/npbcC9QWdvL294eXlhfLycurAPPfcc3j44Yfh5eUFT09PuLq6Sk6FcUvZc6mpqaGxO3l5ecjPz8eQIUNonM0///yDL7/8ksbuFBQU8KbAuFV5ExMTsWTJEsnPyU3/DQ4OxqBBg0Rjd5ycnHjZQWPHjkVVVZVFBXOCv78/HnnkkQbtGAwGg8Fgzk4LwnVEHn30UfTt2xchISEICgqCt7e35E2eW+GSYDQaaXE5rhDo/fffT1OYV61ahXfffRd5eXlmwbEAsHXrVppGXVhYiP3795vZ2Nvbw9XVlZdB1LVrV7z11lu8mB3SXF1deSXBufEwDUHqjTAYDAaD0ZQwZ6cFWbx4MXx9ffH888+LOgFk6oiIgJL2wAMPwM/PD0B9XMubb76J3Nxc0RTmdu3aUWdHr9fzKr/K5XIan+Pu7s6rPTJw4ECsXbsWbm5ucHV1pUuxFPlOnTrx0tIZDAaDwWjLMGenBampqUFJSQnWrl2LQYMG0SmkVatW4Z133kF2djZP24UQERFBnR0bGxtkZWXRfS4uLjR+x8PDAy4uLnTfyJEjcfDgQRqcbEnBPDg4mCeyyGAwGAzGnQJzdloQDw8PKva4ZcsWjB49GkD9lNT169epnVarpbE7Xl5ePAdm9OjROHXqFDw9PeHu7m6x9D55PYPBYDAYdzN3jLPz7bffYuHChcjOzkanTp2wePFixMXFtfZp8SCioL179+bF54wYMQKHDh2iDo6YzACBTEExGAwGg8GwjjvC2Vm3bh1efPFFLFu2DD169MCiRYswYsQIJCYmUl2ltsLXX3+NuXPn8raRFHIGg8FgMBhNz82X8m1DfPHFF3jiiScwY8YMREdHY9myZbC3t8eKFSta+9Qocrkca9euNXN0GAwGg8FgNC+3/chObW0tTp06hTfeeINuk8lkGDp0KI4ePSr6mpqaGl4RP7G07KZm69atGDp0aLO/D4PBYDAYDD63/chOfn4+DAaD2TSQp6cnsrOzRV8zf/58XuVdf3//Jj+vuro63jpzdBgMBoPBaB1ue2fnZnjjjTeocGRJSQnS0tKa/D0UCgVMJhNu3LiB9PT0Jj8+g8FgMBgM67jtp7Hc3Nxga2uLnJwc3vacnBzJtGulUkmlGJqbwMDAFnkfBoPBYDAY4tz2Izt2dnbo2rUrdu/eTbcZjUbs3r0bvXr1asUzYzAYDAaD0Ra47Ud2AODFF1/EtGnT0K1bN8TFxWHRokWoqKjAjBkzWvvUGAwGg8FgtDJ3hLPz0EMPIS8vj0ouxMbGYtu2bax2DYPBYDAYDNiYTCZTa59Ea1NaWgqdToeSkhJotdrWPh0Gg8FgMBhWYO39+7aP2WEwGAwGg8GwBHN2GAwGg8Fg3NEwZ4fBYDAYDMYdDXN2GAwGg8Fg3NEwZ4fBYDAYDMYdDXN2GAwGg8Fg3NEwZ4fBYDAYDMYdDXN2GAwGg8Fg3NEwZ4fBYDAYDMYdzR0hF3GrkCLSpaWlrXwmDAaDwWAwrIXctxsSg2DODoCysjIAgL+/fyufCYPBYDAYjMZSVlYGnU4nuZ9pYwEwGo3IzMyEo6MjbGxsmuy4paWl8Pf3R1paGtPcakbYdW452LVuGdh1bhnYdW4ZmvM6m0wmlJWVwcfHBzKZdGQOG9kBIJPJ4Ofn12zH12q17IvUArDr3HKwa90ysOvcMrDr3DI013W2NKJDYAHKDAaDwWAw7miYs8NgMBgMBuOOhjk7zYhSqcS8efOgVCpb+1TuaNh1bjnYtW4Z2HVuGdh1bhnawnVmAcoMBoPBYDDuaNjIDoPBYDAYjDsa5uwwGAwGg8G4o2HODoPBYDAYjDsa5uwwGAwGg8G4o2HOTiP59ttvERQUBJVKhR49euC///6zaP/HH38gMjISKpUKHTt2xL///svbbzKZ8M4778Db2xtqtRpDhw7F1atXm/Mj3BY09XWePn06bGxseG3kyJHN+RFuCxpznRMSEnD//fcjKCgINjY2WLRo0S0f826hqa/zu+++a/b/HBkZ2Yyf4PagMdf5hx9+QL9+/eDs7AxnZ2cMHTrUzJ79PkvT1Ne62X+jTQyrWbt2rcnOzs60YsUKU0JCgumJJ54wOTk5mXJyckTtDx8+bLK1tTV9+umnposXL5reeustk0KhMJ0/f57aLFiwwKTT6Ux///23KT4+3jRu3DhTcHCwqaqqqqU+VpujOa7ztGnTTCNHjjRlZWXRVlhY2FIfqU3S2Ov833//mV5++WXTmjVrTF5eXqYvv/zylo95N9Ac13nevHmm9u3b8/6f8/LymvmTtG0ae52nTJli+vbbb01nzpwxXbp0yTR9+nSTTqczpaenUxv2+yxOc1zr5v6NZs5OI4iLizPNmTOHrhsMBpOPj49p/vz5ovYTJ0403XPPPbxtPXr0MD355JMmk8lkMhqNJi8vL9PChQvp/uLiYpNSqTStWbOmGT7B7UFTX2eTqf6LdO+99zbL+d6uNPY6cwkMDBS9Cd/KMe9UmuM6z5s3z9SpU6cmPMvbn1v939Pr9SZHR0fTL7/8YjKZ2O+zJZr6WptMzf8bzaaxrKS2thanTp3C0KFD6TaZTIahQ4fi6NGjoq85evQozx4ARowYQe2vX7+O7Oxsno1Op0OPHj0kj3mn0xzXmbBv3z54eHggIiICs2fPRkFBQdN/gNuEm7nOrXHM253mvCZXr16Fj48PQkJCMHXqVKSmpt7q6d62NMV1rqysRF1dHVxcXACw32cpmuNaE5rzN5o5O1aSn58Pg8EAT09P3nZPT09kZ2eLviY7O9uiPVk25ph3Os1xnQFg5MiRWLlyJXbv3o1PPvkE+/fvx6hRo2AwGJr+Q9wG3Mx1bo1j3u401zXp0aMHfv75Z2zbtg1Lly7F9evX0a9fP5SVld3qKd+WNMV1fu211+Dj40Nv4uz3WZzmuNZA8/9GM9Vzxl3BpEmTaL9jx46IiYlBaGgo9u3bhyFDhrTimTEYjWfUqFG0HxMTgx49eiAwMBC///47Zs6c2YpndnuyYMECrF27Fvv27YNKpWrt07mjkbrWzf0bzUZ2rMTNzQ22trb/r737j4m6/uMA/jyEA+Fih0h3rOBOtzQRrYhoYKRpii3UnDWWZTqbma21aWRR0FWsVPzRnM6tFLXNDaZYwKaw9AwEQgZ5ZmlDj10r5g8YmvgDZMDr+8d3fPLjXciP4/CO52Nz8nnf+/16vz6vsc+99vncKS5fvqwav3z5MoxGo8s1RqOx1/k9f/cnpq8bijq7Mn78eIwdOxZ2u33wSXuhgdR5OGJ6O0/VRK/XY8KECfx9HkCdN23ahPXr1+PHH3/E1KlTlXFen10bilq74u5rNJudPtJqtXjyySdhtVqVse7ublitViQmJrpck5iYqJoPAEeOHFHmjxs3DkajUTWntbUVNTU1/xnT1w1FnV1pbGxES0sLIiMj3ZO4lxlInYcjprfzVE1u3LiBhoYG/j73s845OTnIzs5GaWkp4uPjVa/x+uzaUNTaFbdfo4fso88+KD8/XwIDA2Xv3r1y9uxZeeutt0Sv18ulS5dERGTJkiXy0UcfKfOrqqrE399fNm3aJH/88YdYLBaXXz3X6/VSVFQkp0+flgULFoz4rza6u87Xr1+X9PR0qa6uFofDIUePHpW4uDh55JFHpL29fVjO8X7Q3zrfvn1bbDab2Gw2iYyMlPT0dLHZbHL+/Pk+xxyJhqLO77//vpSVlYnD4ZCqqip5/vnnZezYsdLU1OTx87tf9LfO69evF61WKwUFBaqvO1+/fl01h9dnZ+6utSeu0Wx2+mnbtm0SHR0tWq1WEhIS5MSJE8pr06dPl6VLl6rm79+/XyZMmCBarVYmT54shw4dUr3e3d0tWVlZYjAYJDAwUGbNmiX19fWeOJX7mjvrfOvWLZkzZ45ERERIQECAmEwmWbFixYh+A+7Rnzo7HA4B4PRn+vTpfY45Urm7zmlpaRIZGSlarVYeeughSUtLE7vd7sEzuj/1p84mk8llnS0WizKH1+f/5s5ae+IarRERcc89IiIiIqL7Dz+zQ0RERD6NzQ4RERH5NDY7RERE5NPY7BAREZFPY7NDREREPo3NDhEREfk0NjtERETk09jsEBERkU9js0NEHvXnn39Co9Hg1KlTg46Vm5uLOXPmDD4pL9PR0QGz2Yy6urrhToXIK7DZIRrhmpubsWrVKkRHRyMwMBBGoxEpKSmoqqpS5mg0GhQWFrplv6ioKFy8eBGxsbGDitPe3o6srCxYLBa35DVQn3/+OV5//XWP7qnVapGeno4PP/zQo/sSeSs2O0Qj3KJFi2Cz2fDdd9/h3LlzKC4uxowZM9DS0tKvOB0dHX2aN2rUKBiNRvj7+w8kXUVBQQFCQ0Mxbdq0QcUZrKKiIsyfP9/j+7722muorKzEmTNnPL43kbdhs0M0gv3zzz+oqKjAhg0b8Nxzz8FkMiEhIQEZGRnKG7jZbAYALFy4EBqNRjn+7LPP8Pjjj2PXrl0YN24cgoKCAAClpaV45plnoNfrER4ejtTUVDQ0NCh73v0Yq6ysDBqNBlarFfHx8QgODkZSUhLq6+t7zT0/Px/z5s1TjS1btgwvvfQSvvrqKxgMBuj1enzxxRfo7OzEBx98gDFjxuDhhx/Gnj17nPLZv38/kpOTMXr0aDz11FM4d+4camtrER8fD51OhxdeeAHNzc2q/f7++2+cOXMGc+fOBfD/O2DffPMNUlNTERwcjEmTJqG6uhp2ux0zZsxASEgIkpKSVPXoqePu3bsRHR0NnU6Hd955B11dXcjJyYHRaMSDDz6IL7/8UrV3WFgYpk2bhvz8/F7rRERsdohGNJ1OB51Oh8LCQty+fdvlnNraWgDAnj17cPHiReUYAOx2Ow4ePIjvv/9eaV5u3ryJNWvWoK6uDlarFX5+fli4cCG6u7t7zeWTTz7B5s2bUVdXB39/fyxfvrzX+ZWVlYiPj3caP3bsGC5cuIDjx49jy5YtsFgsSE1NRVhYGGpqavD2229j5cqVaGxsVK2zWCzIzMzEyZMn4e/vj8WLF2Pt2rXYunUrKioqYLfb8emnn6rW9NwFCw0NVcays7Pxxhtv4NSpU3j00UexePFirFy5EhkZGairq4OI4N1331XFaWhoQElJCUpLS5GXl4fc3Fy8+OKLaGxsRHl5OTZs2IDMzEzU1NSo1iUkJKCioqLXOhERALf9/+lE5JUKCgokLCxMgoKCJCkpSTIyMuTXX39VzQEgP/zwg2rMYrFIQECANDU19Rq/ublZAMhvv/0mIiIOh0MAiM1mExGRn376SQDI0aNHlTWHDh0SANLW1uYy5tWrVwWAHD9+XDW+dOlSMZlM0tXVpYxNnDhRkpOTlePOzk4JCQmRvLw8VT67du1S5uTl5QkAsVqtyti6detk4sSJqv1mz54t27dvV44BSGZmpnJcXV0tACQ3N1cVOygoSDm2WCwSHBwsra2tylhKSoqYzWan81i3bp1q/61bt4rZbHZZIyL6F+/sEI1wixYtwoULF1BcXIy5c+eirKwMcXFx2Lt37z3XmkwmREREqMbOnz+PV199FePHj0doaKjy2Ouvv/7qNdbUqVOVnyMjIwEATU1NLue2tbUBgPLo7E6TJ0+Gn9+/lzaDwYApU6Yox6NGjUJ4eLhT7Dv3NxgMAKBaZzAYVGtaW1tRXl7u9HmdvsRpb29Ha2urMmY2m/HAAw+o5sTExDidx905jx49Grdu3XKqARGpsdkhIgQFBWH27NnIysrCzz//jGXLlvXpW04hISFOY/PmzcOVK1ewc+dO1NTUKI9e7vUB5oCAAOVnjUYDAP/56Cs8PBwajQZXr17tNU5PLFdjd8d2tf/dY3euKSkpQUxMDKKiovod5+5zG2jOV65ccWo2icgZmx0ichITE4ObN28qxwEBAejq6rrnupaWFtTX1yMzMxOzZs3CpEmTXDYkg6XVahETE4OzZ8+6PXZfFRUVYcGCBcO2PwD8/vvveOKJJ4Y1ByJvwGaHaARraWnBzJkzsW/fPpw+fRoOhwMHDhxATk6O6o3cbDbDarXi0qVLvTYvYWFhCA8Px7fffgu73Y5jx45hzZo1Q5J7SkoKKisrhyT2vXR2dqKkpGRYvnJ+p4qKihH5jyoS9RebHaIRTKfT4emnn8bXX3+NZ599FrGxscjKysKKFSuwfft2Zd7mzZtx5MgRREVF9Xonwc/PD/n5+fjll18QGxuL1atXY+PGjUOS+5tvvonDhw/j2rVrQxK/N+Xl5dDpdIiLi/P43j2qq6tx7do1vPzyy8OWA5G30IiIDHcSREQD8corryAuLg4ZGRke3fe9995DZ2cnduzY4dF975SWlobHHnsMH3/88bDlQOQteGeHiLzWxo0bodPpPL5vbGwsVq1a5fF9e3R0dGDKlClYvXr1sOVA5E14Z4eIiIh8Gu/sEBERkU9js0NEREQ+jc0OERER+TQ2O0REROTT2OwQERGRT2OzQ0RERD6NzQ4RERH5NDY7RERE5NPY7BAREZFP+x+asAukR90PlQAAAABJRU5ErkJggg==",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.plot(loading.cpu()[..., 0], data.cpu()[...,0], 'k-')\n",
+    "plt.plot(loading.cpu()[..., 0], initial_results.cpu()[...,0], 'k--')\n",
+    "plt.xlabel(\"Strain (mm/mm)\")\n",
+    "plt.ylabel(\"Stress (MPa)\")\n",
+    "plt.title(\"Initial comparison\")\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Train the model against the synthetic data\n",
+    "\n",
+    "\n",
+    "Apply a fairly standard training algorithm to adjust the model parameters to better match the synthetic data.  Plot the loss versus iteration data from training."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Loss: 9.80e+02: : 100%|██████████|200/200\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "niter = 200\n",
+    "lr = 5.0e-3\n",
+    "optimizer = torch.optim.Adam(model.parameters(), lr=lr)\n",
+    "loss_fn = torch.nn.MSELoss()\n",
+    "\n",
+    "titer = tqdm.tqdm(\n",
+    "    range(niter),\n",
+    "    bar_format=\"{desc}: {percentage:3.0f}%|{bar}|{n_fmt}/{total_fmt}{postfix}\",\n",
+    ")\n",
+    "titer.set_description(\"Loss:\")\n",
+    "loss_history = []\n",
+    "for i in titer:\n",
+    "    optimizer.zero_grad()\n",
+    "    res = model(time, temperature, loading, cache = True)\n",
+    "    loss = loss_fn(res, data)\n",
+    "    loss.backward()\n",
+    "    loss_history.append(loss.detach().clone().cpu())\n",
+    "    titer.set_description(\"Loss: %3.2e\" % loss_history[-1])\n",
+    "    optimizer.step()\n",
+    "\n",
+    "plt.loglog(loss_history, label=\"Training\")\n",
+    "plt.xlabel(\"Iteration\")\n",
+    "plt.ylabel(\"MSE\")\n",
+    "plt.legend(loc=\"best\")\n",
+    "plt.title(\"Loss history\")\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Plot the train model predictions\n",
+    "\n",
+    "See how accurately the trained model recovers the synthetic data."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.plot(loading.cpu()[..., 0], data.cpu()[...,0], \"k-\")\n",
+    "plt.plot(loading.cpu()[..., 0], res.detach().cpu()[...,0], \"k--\")\n",
+    "plt.xlabel(\"Strain (mm/mm)\")\n",
+    "plt.ylabel(\"Stress (MPa)\")\n",
+    "plt.title(\"Final comparison\")\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Print the trained model coefficients\n",
+    "\n",
+    "These may vary sigifnicantly from the actual mean values, particularly if you used a large variance when sampling the parameters to generate the synthetic data."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "The results:\n",
+      "A_value\n",
+      "\tInitial: \ttensor(-10.7698)\n",
+      "\tOptimized: \ttensor(-8.6582)\n",
+      "\tTrue value: \ttensor(-8.6790)\n",
+      "B_value\n",
+      "\tInitial: \ttensor(-0.7348)\n",
+      "\tOptimized: \ttensor(-0.6079)\n",
+      "\tTrue value: \ttensor(-0.7440)\n",
+      "C_value\n",
+      "\tInitial: \ttensor(-4.8089)\n",
+      "\tOptimized: \ttensor(-5.3143)\n",
+      "\tTrue value: \ttensor(-5.4100)\n",
+      "R_Y\n",
+      "\tInitial: \ttensor([277.7843, 194.1953,  85.3228,  39.9726])\n",
+      "\tOptimized: \ttensor([220.7807, 216.7279,  77.9216,  38.7819])\n",
+      "\tTrue value: \ttensor([300., 200., 100.,  50.])\n",
+      "d_Y\n",
+      "\tInitial: \ttensor([37.3538, 20.1206, 11.8659, 12.1953])\n",
+      "\tOptimized: \ttensor([30.0554, 21.9522, 10.5630, 11.5646])\n",
+      "\tTrue value: \ttensor([30., 20., 15., 12.])\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(\"The results:\")\n",
+    "for n, p in model.discrete_equations.named_parameters():\n",
+    "    nice_name = n.split('.')[-2]\n",
+    "    ref_name = \"discrete_equations.\" + nice_name\n",
+    "    scaler = model_reparameterizer.map_dict[ref_name]\n",
+    "    print(nice_name)\n",
+    "    print(\"\\tInitial: \\t\" + str(guess_parameter_values[ref_name].cpu()))\n",
+    "    print(\"\\tOptimized: \\t\" + str(scaler(p.data).cpu()))\n",
+    "    print(\"\\tTrue value: \\t\" + str(actual_parameter_values[ref_name].cpu()))"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "neml2",
+   "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.10.0"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/python/examples/requirements.txt b/python/examples/requirements.txt
new file mode 100644
index 0000000000..607fef4d4e
--- /dev/null
+++ b/python/examples/requirements.txt
@@ -0,0 +1,6 @@
+nbdime
+pyro-ppl
+tqdm
+matplotlib
+ipykernel
+ipywidgets
\ No newline at end of file
diff --git a/python/examples/statistical.ipynb b/python/examples/statistical.ipynb
new file mode 100644
index 0000000000..65e44da4e9
--- /dev/null
+++ b/python/examples/statistical.ipynb
@@ -0,0 +1,706 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Statistic material model learning\n",
+    "\n",
+    "**This is a modification of the deterministic example to use Stochastic Variational Inference (SVI) to train a hierarchical statistical model rather than a simple deterministic model.  The modifications required to train a model with SVI only start half way through the example --- the rest is the same as the previous, deterministic example.**\n",
+    "\n",
+    "This is a complete example of using the pyzag bindings to NEML2 to calibrated a material model against experimental data.  `demo_model.i` defines the constitutive model, which is a structural material model describing the evolution of strain and stress in the material under mechanical load.  The particular demonstration is a fairly complex model where the material responds differently as a function of both temperature and strain rate.  The model also reduces the full 3D form of the constitutive model to 1D, where the final model is driven by an axial strain and all the other stress components are zero.\n",
+    "\n",
+    "In this example we:\n",
+    "1. Load the model in from file and wrap it for use in pyzag\n",
+    "2. Setup a grid of \"experimental\" conditions spanning several strain rates and temperatures\n",
+    "3. Replace the original model parameters with samples from a normal distrubtion, centered on the orignial model mean, and run the model over the experimental conditions.  This then becomes our synthetic input data.\n",
+    "4. Replace the original model parameters with random priors from wide normal distributions (with means sampled from the original distributions).\n",
+    "5. Setup the model for training with gradient-descent methods by scaling the model parameters and resulting gradient values.\n",
+    "6. Use SVI to train the model against the synthetic data.\n",
+    "7. Plot the results and print the trained parameter values, to see how close we can come to the true values.\n",
+    "\n",
+    "Because it's difficult to consider random variation across a wide range of test conditions, we also consider a set of repeated experiments at the same test condition.  Simulating the same test many times gives a clear idea of the amount of variability in the synthetic data and for the corresponding trained model."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import torch\n",
+    "import torch.distributions as dist\n",
+    "import neml2\n",
+    "from pyzag import nonlinear, reparametrization, chunktime, stochastic\n",
+    "import matplotlib.pyplot as plt\n",
+    "import tqdm\n",
+    "\n",
+    "import pyro\n",
+    "from pyro.infer import SVI, Trace_ELBO, Predictive"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Setup parameters related to *how* we train the model\n",
+    "\n",
+    "Choose which device to use.  The `nchunk` parameter controls the time integration in `pyzag`.  `pyzag` can vectorize the time integration itself, providing a larger bandwidth to the compute device.  This helps speed up the calculation, particularly when running on a GPU.  The optimal value will depend on your compute device."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "torch.manual_seed(42)\n",
+    "\n",
+    "torch.set_default_dtype(torch.double)\n",
+    "if torch.cuda.is_available():\n",
+    "    dev = \"cuda:0\"\n",
+    "else:\n",
+    "    dev = \"cpu\"\n",
+    "device = torch.device(dev)\n",
+    "\n",
+    "nchunk = 100"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Setup the synthetic experimental conditions\n",
+    "\n",
+    "Setup the loading conditions for the \"experiments\" we're going to run.  These will span several strain rates (`nrate`) and temperatures (`ntemperature`).  Overall, we'll run `nbatch` experiments.  Also setup the maximum strain to pull the material through `max_strain` and the number of time steps we're going to use for integration `ntime`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "nrate = 5\n",
+    "ntemperature = 10\n",
+    "nbatch = nrate * ntemperature\n",
+    "max_strain = 0.25\n",
+    "ntime = 100\n",
+    "rates = torch.logspace(-6,0,nrate, device = device)\n",
+    "temperatures = torch.linspace(310.0,1190.0,ntemperature, device = device)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Conditions for the repeated experiment\n",
+    "\n",
+    "Also choose a single condition to repeat multiple times to give a clearer idea of the variability captured in the synthetic data and model."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "nrepeat = 100\n",
+    "single_temperature = 600.0\n",
+    "single_rate = 1.0e-3"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Define the variability in the synthetic data and for our initial guess at the parameters\n",
+    "\n",
+    "These control the variability in the synthetic data (`actual_cov`) and the variability of the initial guess at the parameter values (`guess_cov`).  Also provide the actual values and a prior on the white noise included on top of the experimental measurements."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "actual_cov = 0.02\n",
+    "actual_noise_scale = 5.0\n",
+    "prior_cov = 0.05\n",
+    "prior_noise_scale = 10.0\n",
+    "\n",
+    "guess_cov = 0.1 # On the means of the priors"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Setup the actual model\n",
+    "\n",
+    "This class is a thin wrapper around the underlying `pyzag` wrapper for NEML2.  All it does is take the input conditions (time, temperature, and strain), combine them into a single tensor, call the `pyzag` wrapper, and return the stress."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class SolveStrain(torch.nn.Module):\n",
+    "    \"\"\"Just integrate the model through some strain history\n",
+    "\n",
+    "    Args:\n",
+    "        discrete_equations: the pyzag wrapped model\n",
+    "        nchunk (int): number of vectorized time steps\n",
+    "        rtol (float): relative tolerance to use for Newton's method during time integration\n",
+    "        atol (float): absolute tolerance to use for Newton's method during time integration\n",
+    "    \"\"\"\n",
+    "    def __init__(self, discrete_equations, nchunk = 1, rtol = 1.0e-6, atol = 1.0e-4):\n",
+    "        super().__init__()\n",
+    "        self.discrete_equations = discrete_equations\n",
+    "        self.nchunk = nchunk\n",
+    "        self.cached_solution = None\n",
+    "        self.rtol = rtol\n",
+    "        self.atol = atol\n",
+    "\n",
+    "    def forward(self, time, temperature, loading, cache = False):\n",
+    "        \"\"\"Integrate through some time/temperature/strain history and return stress\n",
+    "        Args:\n",
+    "            time (torch.tensor): batched times\n",
+    "            temperature (torch.tensor): batched temperatures\n",
+    "            loading (torch.tensor): loading conditions, which are the input strain in the first base index and then the stress (zero) in the remainder\n",
+    "\n",
+    "        Keyword Args:\n",
+    "            cache (bool): if true, cache the solution and use it as a predictor for the next call.\n",
+    "                This heuristic can speed things up during inference where the model is called repeatedly with similar parameter values.\n",
+    "        \"\"\"\n",
+    "        if cache and self.cached_solution is not None:\n",
+    "            solver = nonlinear.RecursiveNonlinearEquationSolver(\n",
+    "                self.discrete_equations,\n",
+    "                step_generator=nonlinear.StepGenerator(self.nchunk),\n",
+    "                predictor=nonlinear.FullTrajectoryPredictor(self.cached_solution), nonlinear_solver = chunktime.ChunkNewtonRaphson(rtol = self.rtol, atol = self.atol)\n",
+    "            )\n",
+    "        else:\n",
+    "            solver = nonlinear.RecursiveNonlinearEquationSolver(\n",
+    "                self.discrete_equations, step_generator=nonlinear.StepGenerator(self.nchunk),\n",
+    "                predictor=nonlinear.PreviousStepsPredictor(), nonlinear_solver = chunktime.ChunkNewtonRaphson(rtol = self.rtol, atol = self.atol)\n",
+    "            )\n",
+    "\n",
+    "        # We could pass this in as input, but it's easy enough to do here\n",
+    "        control = torch.zeros_like(loading)\n",
+    "        control[...,1:] = 1.0\n",
+    "\n",
+    "        # Setup\n",
+    "        forces = self.discrete_equations.collect_forces({'t': time, 'T': temperature, 'fixed_values': loading, 'control': control})\n",
+    "        state0 = torch.zeros(forces.shape[1:-1] + (self.discrete_equations.nstate,), device = forces.device)\n",
+    "\n",
+    "        result =  nonlinear.solve_adjoint(\n",
+    "            solver, state0, len(forces), forces\n",
+    "        )\n",
+    "\n",
+    "        if cache:\n",
+    "            self.cached_solution = result.detach().clone()\n",
+    "\n",
+    "        return result[...,0:1]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Actually setup the model\n",
+    "\n",
+    "Load the NEML model from disk, wrap it in both the `pyzag` wrapper and our thin wrapper class above.  Exclude some of the model parameters we don't want to train."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "model = SolveStrain(neml2.pyzag.NEML2PyzagModel(neml2.load_model(\"demo_model.i\", \"implicit_rate\"), exclude_parameters = [\"elasticity.E\", \"elasticity.nu\",\"R.X\", \"d.X\", \"mu.X\", \"mu.Y\",\"yield_zero.sy\"]))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Create the input tendors\n",
+    "\n",
+    "Actually setup the full input tensors based on the parameters above"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "time = torch.zeros((ntime, nrate, ntemperature, 1), device = device)\n",
+    "loading = torch.zeros((ntime, nrate, ntemperature, 6), device = device)\n",
+    "temperature = torch.zeros((ntime, nrate, ntemperature, 1), device = device)\n",
+    "for i, rate in enumerate(rates):\n",
+    "    time[:, i] = torch.linspace(0, max_strain / rate, ntime, device = device)[:, None, None]\n",
+    "loading[...,0] = torch.linspace(0, max_strain, ntime, device = device)[:, None, None]\n",
+    "for i, T in enumerate(temperatures):\n",
+    "    temperature[:, :, i] = T\n",
+    "time = time.reshape((ntime, -1, 1))\n",
+    "temperature = temperature.reshape((ntime, -1, 1))\n",
+    "loading = loading.reshape((ntime, -1, 6))\n",
+    "\n",
+    "\n",
+    "single_times = torch.linspace(0, max_strain / single_rate, ntime, device = device).unsqueeze(-1).expand((ntime,nrepeat)).unsqueeze(-1)\n",
+    "single_temperatures = torch.full_like(single_times, single_temperature)\n",
+    "single_loading = torch.zeros((ntime,nrepeat,6), device = device)\n",
+    "single_loading[...,0] = torch.linspace(0, max_strain, ntime, device = device).unsqueeze(-1)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Replace the model parameters with random values\n",
+    "\n",
+    "Sampled from a normal distribution controlled by the `actual_cov` parameter.\n",
+    "\n",
+    "This controls the randomness in the input synthetic test data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Replace with samples from normal\n",
+    "actual_parameter_values = {}\n",
+    "for n,p in model.named_parameters():\n",
+    "    actual_parameter_values[n] = p.data.detach().clone().cpu()\n",
+    "    ndist = dist.Normal(p.data, torch.abs(p.data) * actual_cov).expand((nbatch,)+p.shape)\n",
+    "    p.data = ndist.sample().to(device)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Run the model to generate the synthetic data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "with torch.no_grad():\n",
+    "    data = model(time, temperature, loading)\n",
+    "    data = torch.normal(data, actual_noise_scale)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Plot the synthetic data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.figure()\n",
+    "plt.plot(loading.cpu()[...,0], data[...,0].cpu())\n",
+    "plt.xlabel(\"Strain (mm/mm)\")\n",
+    "plt.ylabel(\"Stress (MPa)\")\n",
+    "plt.title(\"Input data -- all conditions\")\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Now sample at run at a fixed condition\n",
+    "\n",
+    "The idea being to clearly see the variability in repeated trials at a fix condition."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Replace with samples from normal\n",
+    "for n, p in model.named_parameters():\n",
+    "    ndist = dist.Normal(\n",
+    "        actual_parameter_values[n], torch.abs(actual_parameter_values[n]) * actual_cov\n",
+    "    ).expand((nrepeat,) + actual_parameter_values[n].shape)\n",
+    "    p.data = ndist.sample().to(device)\n",
+    "\n",
+    "with torch.no_grad():\n",
+    "    single_data = model(single_times, single_temperatures, single_loading)\n",
+    "    single_data = torch.normal(single_data, actual_noise_scale)\n",
+    "\n",
+    "plt.figure()\n",
+    "plt.plot(single_loading.cpu()[..., 0], single_data[...,0].cpu())\n",
+    "plt.xlabel(\"Strain (mm/mm)\")\n",
+    "plt.ylabel(\"Stress (MPa)\")\n",
+    "plt.title(\"Input data -- single condition\")\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Setup the model for training\n",
+    "\n",
+    "Replace the parameter values with random initial guesses, with variability controlled by the `guess_cov` parameter."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Now replace our original parameter with random values over a range\n",
+    "guess_parameter_values = {}\n",
+    "for n, p in model.named_parameters():\n",
+    "    p.data = torch.normal(actual_parameter_values[n], torch.abs(actual_parameter_values[n])*guess_cov).to(device)\n",
+    "    guess_parameter_values[n] = p.data.detach().clone()\n",
+    "model.discrete_equations._update_parameter_values()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Scale the model parameters\n",
+    "\n",
+    "Our material model parameters have units.  In general, the parameter values will have different magnitudes from each other, which affects the scale of the gradients.  Unbalanced gradients in turn affect the convergence of gradient descent optimization methods.\n",
+    "\n",
+    "Typically we'd scale the training data to fix this problem.  However, again our data has units and a physical meaning we want to preserve.\n",
+    "\n",
+    "As an alternative we can scale the parameter values themselves both to clip the values to a physical range and to scale the gradients and hopefully improve the convergence of the optimization step.  We do that here, in a way that should be mostly invisible to the training algorithms."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Scale to get better performance\n",
+    "A_scaler = reparametrization.RangeRescale(torch.tensor(-12.0, device = device), torch.tensor(-4.0, device = device))\n",
+    "B_scaler = reparametrization.RangeRescale(\n",
+    "    torch.tensor(-1.0, device = device), torch.tensor(-0.5, device = device)\n",
+    ")\n",
+    "C_scaler = reparametrization.RangeRescale(torch.tensor(-8.0, device = device), torch.tensor(-3.0, device = device))\n",
+    "R_scaler = reparametrization.RangeRescale(\n",
+    "    torch.tensor([0.0,0.0,0.0,0.0], device=device), torch.tensor([500.0,500.0,500.0,500.0], device=device)\n",
+    ")\n",
+    "d_scaler = reparametrization.RangeRescale(\n",
+    "    torch.tensor([0.01, 0.01, 0.01, 0.01], device=device),\n",
+    "    torch.tensor([50.0, 50.0, 50.0, 50.0], device=device),\n",
+    ")\n",
+    "\n",
+    "model_reparameterizer = reparametrization.Reparameterizer(\n",
+    "    {\"discrete_equations.A_value\": A_scaler,\n",
+    "     \"discrete_equations.B_value\": B_scaler,\n",
+    "     \"discrete_equations.C_value\": C_scaler,\n",
+    "     \"discrete_equations.R_Y\": R_scaler,\n",
+    "     \"discrete_equations.d_Y\": d_scaler}, error_not_provided=True)\n",
+    "model_reparameterizer(model)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Convert the model to a hierarchical statistical model\n",
+    "\n",
+    "We now convert the model from deterministic to a hierarchnical statistical model.  We use the `pyzag` mapper functionality to convert the model with two levels.  The top level statistics are common to the entire data set, i.e. all tests in the synthetic data, while the lower-level distributions provide statistics for each individual sample of material.  Each parameter is converted to a prior with the initial mean value selected based on the (random) deterministic values assigned above.  We also provide a prior on the level of white noise included in the experimental measurements."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "mapper = stochastic.MapNormal(prior_cov)\n",
+    "hsmodel = stochastic.HierarchicalStatisticalModel(model, mapper, torch.tensor(prior_noise_scale, device = device))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Sample the prior model to compare to the repeated test\n",
+    "\n",
+    "This is just for visualization, to see how far away our prior model starts from the true distribution"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "nreps = 5\n",
+    "predict = Predictive(hsmodel, num_samples=nreps)\n",
+    "with torch.no_grad():\n",
+    "    untrained_single = predict(\n",
+    "        single_times[:, :nbatch],\n",
+    "        single_temperatures[:, :nbatch],\n",
+    "        single_loading[:, :nbatch],\n",
+    "    )[\"obs\"]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "flat_untrained = untrained_single.transpose(0, 1).reshape(ntime, nreps * nbatch, 1)\n",
+    "plt.figure()\n",
+    "plt.plot(\n",
+    "    single_loading[:, 0, 0].cpu(),\n",
+    "    torch.mean(flat_untrained, dim=1)[:, 0].cpu(),\n",
+    "    ls=\"-\",\n",
+    "    color=\"k\",\n",
+    "    lw=4,\n",
+    "    label=\"Prior mean\",\n",
+    ")\n",
+    "\n",
+    "p = 0.05\n",
+    "n_lb = int(p * nreps * nbatch)\n",
+    "n_ub = int((1 - p) * nreps * nbatch)\n",
+    "plt.fill_between(\n",
+    "    single_loading[:, 0, 0].cpu(),\n",
+    "    torch.kthvalue(flat_untrained, n_lb, dim=1)[0][:, 0].cpu(),\n",
+    "    torch.kthvalue(flat_untrained, n_ub, dim=1)[0][:, 0].cpu(),\n",
+    "    color=\"tab:blue\",\n",
+    "    alpha=0.8,\n",
+    "    label=\"90% prediction\",\n",
+    ")\n",
+    "plt.plot(\n",
+    "    single_loading.cpu()[..., 0],\n",
+    "    single_data[..., 0].cpu(),\n",
+    "    color=\"k\",\n",
+    "    lw=0.3,\n",
+    "    label=\"Data\",\n",
+    ")\n",
+    "\n",
+    "handles, labels = plt.gca().get_legend_handles_labels()\n",
+    "\n",
+    "plt.xlabel(\"Strain\")\n",
+    "plt.ylabel(\"Stress\")\n",
+    "plt.legend(handles[:3], labels[:3], loc=\"best\")\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Setup a guide and training hyperparameters\n",
+    "\n",
+    "Use `AutoDelta` to get a MAP estimate of the parameters.\n",
+    "\n",
+    "Setup the SVI problem and the usual sorts of training hyperparameters"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "guide = pyro.infer.autoguide.guides.AutoDelta(hsmodel)\n",
+    "lr = 1.0e-3\n",
+    "niter = 500\n",
+    "num_samples = 1\n",
+    "\n",
+    "optimizer = pyro.optim.ClippedAdam({'lr': lr})\n",
+    "loss = Trace_ELBO(num_particles=num_samples)\n",
+    "svi = SVI(hsmodel, guide, optimizer, loss = loss)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Run the training loop"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Loss: 1.29e+04: : 100%|██████████|500/500\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "titer = tqdm.tqdm(\n",
+    "    range(niter),\n",
+    "    bar_format=\"{desc}: {percentage:3.0f}%|{bar}|{n_fmt}/{total_fmt}{postfix}\",\n",
+    ")\n",
+    "titer.set_description(\"Loss:\")\n",
+    "loss_history = []\n",
+    "for i in titer:\n",
+    "    closs = svi.step(time, temperature, loading, results=data)\n",
+    "    loss_history.append(closs)\n",
+    "    titer.set_description(\"Loss: %3.2e\" % closs)\n",
+    "\n",
+    "plt.figure()\n",
+    "plt.plot(loss_history, label=\"Training\")\n",
+    "plt.xlabel(\"Iteration\")\n",
+    "plt.ylabel(\"ELBO\")\n",
+    "plt.legend(loc=\"best\")\n",
+    "plt.title(\"Training loss\")\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Go back and sample our repeated case"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "nreps = 5\n",
+    "predict = Predictive(hsmodel, guide=guide, num_samples = nreps)\n",
+    "with torch.no_grad():\n",
+    "    trained_single = predict(single_times[:,:nbatch], single_temperatures[:,:nbatch], single_loading[:,:nbatch])['obs']"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "flat_trained = trained_single.transpose(0,1).reshape(ntime, nreps*nbatch,1)\n",
+    "plt.figure()\n",
+    "plt.plot(single_loading[:,0,0].cpu(), torch.mean(flat_trained, dim = 1)[:,0].cpu(), ls = '-', color = 'k', lw = 4, label = \"Trained mean\")\n",
+    "\n",
+    "p = 0.05\n",
+    "n_lb = int(p*nreps * nbatch)\n",
+    "n_ub = int((1-p) * nreps * nbatch)\n",
+    "plt.fill_between(\n",
+    "    single_loading[:, 0, 0].cpu(),\n",
+    "    torch.kthvalue(flat_trained, n_lb, dim=1)[0][:, 0].cpu(),\n",
+    "    torch.kthvalue(flat_trained, n_ub, dim=1)[0][:, 0].cpu(),\n",
+    "    color = 'tab:blue',\n",
+    "    alpha = 0.8,\n",
+    "    label = \"90% prediction\"\n",
+    ")\n",
+    "plt.plot(single_loading.cpu()[..., 0], single_data[..., 0].cpu(), color = 'k', lw = 0.3, label = \"Data\")\n",
+    "\n",
+    "handles, labels = plt.gca().get_legend_handles_labels()\n",
+    "\n",
+    "plt.xlabel(\"Strain\")\n",
+    "plt.ylabel(\"Stress\")\n",
+    "plt.legend(handles[:3], labels[:3], loc='best')\n",
+    "plt.show()"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "neml2",
+   "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.10.0"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/python/neml2/__init__.py b/python/neml2/__init__.py
index a2013ad40d..163740336f 100644
--- a/python/neml2/__init__.py
+++ b/python/neml2/__init__.py
@@ -27,3 +27,5 @@
 from .base import *
 from .tensors import *
 from .math import *
+
+from . import pyzag
diff --git a/python/neml2/pyzag/__init__.py b/python/neml2/pyzag/__init__.py
new file mode 100644
index 0000000000..4e7010cd25
--- /dev/null
+++ b/python/neml2/pyzag/__init__.py
@@ -0,0 +1,25 @@
+# Copyright 2024, UChicago Argonne, LLC
+# All Rights Reserved
+# Software Name: NEML2 -- the New Engineering material Model Library, version 2
+# By: Argonne National Laboratory
+# OPEN SOURCE LICENSE (MIT)
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+from .interface import *
diff --git a/python/neml2/pyzag/interface.py b/python/neml2/pyzag/interface.py
new file mode 100644
index 0000000000..38bf8455e5
--- /dev/null
+++ b/python/neml2/pyzag/interface.py
@@ -0,0 +1,333 @@
+# Copyright 2024, UChicago Argonne, LLC
+# All Rights Reserved
+# Software Name: NEML2 -- the New Engineering material Model Library, version 2
+# By: Argonne National Laboratory
+# OPEN SOURCE LICENSE (MIT)
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+from pyzag import nonlinear
+
+import neml2
+from neml2.tensors import Tensor
+
+import torch
+
+
+def assemble_vector(axis, tensors, warn_unused=True):
+    """Assemble a LabeledVector from a collection of tensors
+
+    Args:
+        axis (LabeledAxis): axis to use to setup LabeledVector
+        tensor (dict of torch.tensor): dictionary mapping names to tensors
+
+    Keyword Args:
+        warned_unused (bool, default True): throw a warning if there is a missing or extra variable in tensors
+    """
+    random_tensor = next(iter(tensors.values()))
+    batch_shape = random_tensor.shape[:-1]
+    device = random_tensor.device
+
+    vector = neml2.LabeledVector.zeros(batch_shape, [axis], device=device)
+
+    if warn_unused and set(tensors.keys()) != set(axis.variable_names()):
+        raise Warning(
+            "Tensor names in provided tensors dict do not match the variable names on the axis"
+        )
+
+    for name, value in tensors.items():
+        vector.base[name] = Tensor(value, len(batch_shape))
+
+    return vector
+
+
+class NEML2PyzagModel(nonlinear.NonlinearRecursiveFunction):
+    """Wraps a NEML2 model into a `nonlinear.NonlinearRecursiveFunction`
+
+    Args:
+        model (NEML2 model): the model to wrap
+
+    Keyword Args:
+        exclude_parameters (list of str): exclude these parameters from being wrapped as a pytorch parameter
+        state_axis (str): name of the state axis
+        forces_axis (str): name of the forces axis
+        residual_axis (str): name of the residual axis
+        old_prefix (str): prefix on the name of an axis to get the old values
+        neml2_sep_char (str): parameter seperator character used in NEML2
+        python_sep_char (str): seperator character to use in python used to name parameters
+    """
+
+    def __init__(
+        self,
+        model,
+        exclude_parameters=[],
+        state_axis="state",
+        forces_axis="forces",
+        residual_axis="residual",
+        old_prefix="old_",
+        neml2_sep_char=".",
+        python_sep_char="_",
+        *args,
+        **kwargs,
+    ):
+        super().__init__(*args, **kwargs)
+
+        self.model = model
+        self.lookback = (
+            1  # Hard coded because there aren't any other options in NEML2 right now
+        )
+
+        self.neml2_sep_char = neml2_sep_char
+        self.python_sep_char = python_sep_char
+        self._setup_parameters(exclude_parameters)
+
+        self.state_axis = state_axis
+        self.forces_axis = forces_axis
+        self.residual_axis = residual_axis
+        self.old_prefix = old_prefix
+
+        self._check_model()
+
+    def _setup_parameters(self, exclude_parameters):
+        """Mirror parameters of the neml model with torch.nn.Parameter
+
+        Args:
+            exclude_parameters (list of str): neml parameters to exclude
+        """
+        self.parameter_name_map = {}
+        for neml_name, neml_param in self.model.named_parameters().items():
+            if neml_name in exclude_parameters:
+                continue
+            neml_param.requires_grad_(True)
+            rename = neml_name.replace(self.neml2_sep_char, self.python_sep_char)
+            self.parameter_name_map[rename] = neml_name
+            self.register_parameter(rename, torch.nn.Parameter(neml_param.torch()))
+
+    def _update_parameter_values(self):
+        """Copy over new parameter values"""
+
+        # We may need to update the batch shapes, so this lambda sorts out the correct shape
+        def make_tensor(orig_name, neml_name):
+            new_value = getattr(self, orig_name)
+            current_value = self.model.get_parameter(neml_name)
+            batch_dim = new_value.dim() - current_value.tensor().base.dim()
+            return Tensor(new_value.clone(), batch_dim)
+
+        self.model.set_parameters(
+            {
+                neml_name: make_tensor(orig_name, neml_name)
+                for orig_name, neml_name in self.parameter_name_map.items()
+            }
+        )
+
+    def _check_model(self):
+        """Simple consistency checks, could be a debug check but we only call this once"""
+        should_axes = [
+            self.state_axis,
+            self.old_prefix + self.state_axis,
+            self.forces_axis,
+            self.old_prefix + self.forces_axis,
+        ]
+        if self.model.input_axis().nsubaxis() != len(should_axes):
+            raise ValueError(
+                "Wrapped NEML2 model should only have 4 subaxes on the input axis"
+            )
+        for axis in should_axes:
+            if not self.model.input_axis().has_subaxis(axis):
+                raise ValueError(
+                    "Wrapped NEML2 model missing input subaxis {}".format(axis)
+                )
+
+        # Output axis should just have the residual
+        if self.model.output_axis().nsubaxis() != 1:
+            raise ValueError(
+                "Wrapped NEML2 model should only have 1 subaxes on the output axis"
+            )
+
+        if not self.model.output_axis().has_subaxis(self.residual_axis):
+            raise ValueError(
+                "Wrapped NEML2 model is missing required output subaxis {}".format(
+                    self.residual_axis
+                )
+            )
+
+        # And all the variables on state should match the variables in the residual
+        for name in self.model.input_axis().subaxis(self.state_axis).variable_names():
+            if (
+                not self.model.output_axis()
+                .subaxis(self.residual_axis)
+                .has_variable(name)
+            ):
+                raise ValueError(
+                    "State variable {} is on the input state axis but not in the output residual axis".format(
+                        name
+                    )
+                )
+
+        # Everything in old_state should be in state (but not the other way around)
+        for name in (
+            self.model.input_axis()
+            .subaxis(self.old_prefix + self.state_axis)
+            .variable_names()
+        ):
+            if not self.model.input_axis().subaxis(self.state_axis).has_variable(name):
+                raise ValueError(
+                    "State variable {} is in old state but not in state".format(name)
+                )
+
+        # Everything in old_forces should be in forces (but not the other way around)
+        for name in (
+            self.model.input_axis()
+            .subaxis(self.old_prefix + self.forces_axis)
+            .variable_names()
+        ):
+            if not self.model.input_axis().subaxis(self.forces_axis).has_variable(name):
+                raise ValueError(
+                    "Force variable {} is in old forces but not in forces".format(name)
+                )
+
+    @property
+    def nstate(self):
+        return self.model.input_axis().subaxis("state").storage_size()
+
+    @property
+    def nforce(self):
+        return self.model.input_axis().subaxis("forces").storage_size()
+
+    def collect_forces(self, tensor_dict):
+        """Assemble the forces from a dictionary of tensors
+
+        Args:
+            tensor_dict (dict of tensors): dictionary of tensors containing the forces
+        """
+        return assemble_vector(
+            self.model.input_axis().subaxis(self.forces_axis), tensor_dict
+        ).torch()
+
+    def collect_state(self, tensor_dict):
+        """Assemble the state from a dictionary of tensors
+
+        Args:
+            tensor_dict (dict of tensors): dictionary of tensors containing the forces
+        """
+        return assemble_vector(
+            self.model.input_axis().subaxis(self.state_axis), tensor_dict
+        ).torch()
+
+    def _reduce_axis(self, reduce_axis, full_axis, full_tensor):
+        """Reduce a tensor spanning full_axis to only the vars on reduce_axis
+
+        Args:
+            reduce_axis (LabeledAxis): reduced set of variables
+            full_axis (LabeledAxis): full set of variables
+            full_tensor (torch.tensor): tensor representing the full set of variables
+        """
+
+        batch_shape = full_tensor.shape[:-1]
+        full = neml2.LabeledVector(full_tensor, [full_axis])
+        reduced = neml2.LabeledVector.zeros(
+            batch_shape, [reduce_axis], device=full_tensor.device
+        )
+        reduced.fill(full)
+
+        return reduced.tensor()
+
+    def _assemble_input(self, state, forces):
+        """Assemble the model input from the flat tensors
+
+        Args:
+            state (torch.tensor): tensor containing the model state
+            forces (torch.tensor): tensor containing the model forces
+        """
+        batch_shape = (state.shape[0] - self.lookback,) + state.shape[1:-1]
+        bdim = len(batch_shape)
+
+        self.model.reinit(batch_shape=batch_shape, deriv_order=1, device=forces.device)
+
+        input = neml2.LabeledVector.zeros(
+            batch_shape, [self.model.input_axis()], device=state.device
+        )
+
+        input.base[self.state_axis] = Tensor(state[self.lookback :], bdim)
+        # This deals with variables not in old_state
+        input.base[self.old_prefix + self.state_axis] = self._reduce_axis(
+            self.model.input_axis().subaxis(self.old_prefix + self.state_axis),
+            self.model.input_axis().subaxis(self.state_axis),
+            state[: -self.lookback],
+        )
+        input.base[self.forces_axis] = Tensor(forces[self.lookback :], bdim)
+        # This deals with variables not in old_forces
+        input.base[self.old_prefix + self.forces_axis] = self._reduce_axis(
+            self.model.input_axis().subaxis(self.old_prefix + self.forces_axis),
+            self.model.input_axis().subaxis(self.forces_axis),
+            forces[: -self.lookback],
+        )
+
+        return input
+
+    def _extract_jacobian(self, J):
+        """Extract the Jacobian components we need from the NEML output
+
+        Args:
+            J (LabeledMatrix): full jacobian from the NEML model
+        """
+        # This one is easy because state and residual always share all variables
+        J_new = J.base[self.residual_axis, self.state_axis].torch()
+
+        # Now we need to pad the variables not in old_state with zeros
+        J_old_reduced = neml2.LabeledMatrix(
+            J.base[self.residual_axis, self.old_prefix + self.state_axis],
+            [
+                self.model.output_axis().subaxis(self.residual_axis),
+                self.model.input_axis().subaxis(self.old_prefix + self.state_axis),
+            ],
+        )
+        J_old_full = neml2.LabeledMatrix.zeros(
+            J_new.shape[:-2],
+            [
+                self.model.output_axis().subaxis(self.residual_axis),
+                self.model.input_axis().subaxis(self.state_axis),
+            ],
+            device=J_new.device,
+        )
+
+        J_old_full.fill(J_old_reduced, odim=1)
+
+        return torch.stack([J_old_full.torch(), J_new])
+
+    def forward(self, state, forces):
+        """Actually call the NEML2 model and return the residual and Jacobian
+
+        Args:
+            state (torch.tensor): tensor with the flattened state
+            forces (torch.tensor): tensor with the flattened forces
+
+        The helper methods `collect_forces` and `collect_state` can be used to
+        assemble individual tensors into the flattened state and forces tensor
+        """
+        # Update the parameter values
+        self._update_parameter_values()
+
+        # Make a big LabeledVector with the input
+        x = self._assemble_input(state, forces)
+
+        # Call the model
+        y, J = self.model.value_and_dvalue(x)
+
+        return y.torch(), self._extract_jacobian(J)
diff --git a/python/neml2/tensors/LabeledAxis.cxx b/python/neml2/tensors/LabeledAxis.cxx
index eb0fd6a9c0..80d8ca470a 100644
--- a/python/neml2/tensors/LabeledAxis.cxx
+++ b/python/neml2/tensors/LabeledAxis.cxx
@@ -46,7 +46,7 @@ def_LabeledAxis(py::module_ & m)
                .def(
                    "subaxis",
                    [](const LabeledAxis & self, const LabeledAxisAccessor & name)
-                   { return self.subaxis(name); },
+                   { return &self.subaxis(name); },
                    py::return_value_policy::reference)
                .def(
                    "variable_names",
diff --git a/python/neml2/tensors/LabeledTensor.h b/python/neml2/tensors/LabeledTensor.h
index d16df35fd3..7b28df5580 100644
--- a/python/neml2/tensors/LabeledTensor.h
+++ b/python/neml2/tensors/LabeledTensor.h
@@ -203,7 +203,12 @@ def_LabeledTensor(py::class_<Derived> & c)
       .def_property_readonly("device", &Derived::device)
       .def("requires_grad_", &Derived::requires_grad_)
       .def_property_readonly("requires_grad", &Derived::requires_grad)
-      .def_property_readonly("grad", [](Derived * self) { return self->tensor().grad(); });
+      .def_property_readonly("grad", [](Derived * self) { return self->tensor().grad(); })
+      .def("fill",
+           &Derived::fill,
+           py::arg("other"),
+           py::arg("odim") = 0,
+           py::arg("recursive") = true);
 
   // Static methods
   c.def_static(
diff --git a/python/tests/pyzag/complex_model.i b/python/tests/pyzag/complex_model.i
new file mode 100644
index 0000000000..10497ccadf
--- /dev/null
+++ b/python/tests/pyzag/complex_model.i
@@ -0,0 +1,299 @@
+[Tensors]
+  [end_time]
+    type = LogspaceScalar
+    start = -1
+    end = 5
+    nstep = 20
+  []
+  [times]
+    type = LinspaceScalar
+    start = 0
+    end = end_time
+    nstep = 100
+  []
+  [exx]
+    type = FullScalar
+    batch_shape = '(20)'
+    value = 0.1
+  []
+  [syy]
+    type = FullScalar
+    batch_shape = '(20)'
+    value = -50.0
+  []
+  [ezz]
+    type = FullScalar
+    batch_shape = '(20)'
+    value = -0.025
+  []
+  [eyz]
+    type = FullScalar
+    batch_shape = '(20)'
+    value = 0.15
+  []
+  [sxz]
+    type = FullScalar
+    batch_shape = '(20)'
+    value = 75.0
+  []
+  [exy]
+    type = FullScalar
+    batch_shape = '(20)'
+    value = 0.05
+  []
+  [max_condition]
+    type = FillSR2
+    values = 'exx syy ezz eyz sxz exy'
+  []
+  [conditions]
+    type = LinspaceSR2
+    start = 0
+    end = max_condition
+    nstep = 100
+  []
+  [start_temperature]
+    type = LinspaceScalar
+    start = 300
+    end = 500
+    nstep = 20
+  []
+  [end_temperature]
+    type = LinspaceScalar
+    start = 600
+    end = 1200
+    nstep = 20
+  []
+  [temperatures]
+    type = LinspaceScalar
+    start = start_temperature
+    end = end_temperature
+    nstep = 100
+  []
+  [zero_control]
+    type = FullScalar
+    batch_shape = '(100,20)'
+    value = 0.0
+  []
+  [one_control]
+    type = FullScalar
+    batch_shape = '(100,20)'
+    value = 1.0
+  []
+  [control]
+    type = FillSR2
+    values = 'zero_control zero_control one_control zero_control one_control zero_control'
+  []
+  [T_controls]
+    type = Scalar
+    values = '300 347.36842105 394.73684211 442.10526316 489.47368421 536.84210526 584.21052632 631.57894737 678.94736842 726.31578947 773.68421053 821.05263158 868.42105263 915.78947368 963.15789474 1010.52631579 1057.89473684 1105.26315789 1152.63157895 1200'
+    batch_shape = '(20)'
+  []
+  [mu_values]
+    type = Scalar
+    values = '76670.48346056 75465.18012589 74314.80514263 73374.72880675 72651.54680595 71928.36480514 71120.75130575 70035.97830454 68951.20530333 67842.26597027 66399.97991161 65315.20691041 63884.85335476 62763.98151868 61373.80474086 59927.44073925 58481.07673765 56544.43551627 54599.93973483 52791.98473282'
+    batch_shape = '(20)'
+  []
+  [E_test]
+    type = Scalar
+    values = '1.0e5'
+  []
+[]
+
+[Drivers]
+  [driver]
+    type = SolidMechanicsDriver
+    model = 'model'
+    times = 'times'
+    prescribed_mixed_conditions = 'conditions'
+    prescribed_control = 'control'
+    save_as = 'result_complex_model.pt'
+    prescribed_temperatures = 'temperatures'
+    control = 'MIXED'
+  []
+[]
+
+[Solvers]
+  [newton]
+    type = Newton
+  []
+[]
+
+[Models]
+  [A]
+    type = ScalarConstantParameter
+    value = -8.679
+  []
+  [B]
+    type = ScalarConstantParameter
+    value = -0.744
+  []
+  [C]
+    type = ScalarConstantParameter
+    value = -5.41
+  []
+  [g0]
+    type = KocksMeckingIntercept
+    A = 'A'
+    B = 'B'
+    C = 'C'
+  []
+  [mandel_stress]
+    type = IsotropicMandelStress
+  []
+  [vonmises]
+    type = SR2Invariant
+    invariant_type = 'VONMISES'
+    tensor = 'state/internal/M'
+    invariant = 'state/internal/s'
+  []
+  [isoharden]
+    type = LinearIsotropicHardening
+    hardening_modulus = 1000
+  []
+  [mu]
+    type = ScalarLinearInterpolation
+    argument = 'forces/T'
+    abscissa = 'T_controls'
+    ordinate = 'mu_values'
+  []
+  [ys]
+    type = KocksMeckingYieldStress
+    shear_modulus = 'mu'
+    C = 'C'
+  []
+  [yield]
+    type = YieldFunction
+    yield_stress = 'ys'
+    isotropic_hardening = 'state/internal/k'
+  []
+  [yield_zero]
+    type = YieldFunction
+    yield_stress = 0
+    isotropic_hardening = 'state/internal/k'
+    yield_function = 'state/internal/fp_alt'
+  []
+  [flow]
+    type = ComposedModel
+    models = 'vonmises yield'
+    automatic_nonlinear_parameter = false
+  []
+  [normality]
+    type = Normality
+    model = 'flow'
+    function = 'state/internal/fp'
+    from = 'state/internal/M state/internal/k'
+    to = 'state/internal/NM state/internal/Nk'
+  []
+  [ri_flowrate]
+    type = RateIndependentPlasticFlowConstraint
+    flow_rate = 'state/internal/gamma_rate_ri'
+  []
+  [km_sensitivity]
+    type = KocksMeckingRateSensitivity
+    A = 'A'
+    shear_modulus = 'mu'
+    k = 1.38064e-20
+    b = 2.474e-7
+  []
+  [km_viscosity]
+    type = KocksMeckingFlowViscosity
+    A = 'A'
+    B = 'B'
+    shear_modulus = 'mu'
+    k = 1.38064e-20
+    b = 2.474e-7
+    eps0 = 1e10
+  []
+  [rd_flowrate]
+    type = PerzynaPlasticFlowRate
+    reference_stress = 'km_viscosity'
+    exponent = 'km_sensitivity'
+    yield_function = 'state/internal/fp_alt'
+    flow_rate = 'state/internal/gamma_rate_rd'
+  []
+  [effective_strain_rate]
+    type = SR2Invariant
+    invariant_type = 'EFFECTIVE_STRAIN'
+    tensor = 'state/E_rate'
+    invariant = 'forces/effective_strain_rate'
+  []
+  [g]
+    type = KocksMeckingActivationEnergy
+    shear_modulus = 'mu'
+    k = 1.38064e-20
+    b = 2.474e-7
+    eps0 = 1e10
+  []
+  [flowrate]
+    type = KocksMeckingFlowSwitch
+    g0 = 'g0'
+    rate_independent_flow_rate = 'state/internal/gamma_rate_ri' 
+    rate_dependent_flow_rate = 'state/internal/gamma_rate_rd'
+    sharpness = 100.0
+  []
+  [Eprate]
+    type = AssociativePlasticFlow
+  []
+  [eprate]
+    type = AssociativeIsotropicPlasticHardening
+  []
+  [Erate]
+    type = SR2VariableRate
+    variable = 'state/E'
+    rate = 'state/E_rate'
+  []
+  [Eerate]
+    type = SR2LinearCombination
+    from_var = 'state/E_rate state/internal/Ep_rate'
+    to_var = 'state/internal/Ee_rate'
+    coefficients = '1 -1'
+  []
+  [elasticity]
+    type = LinearIsotropicElasticity
+    youngs_modulus = 'E_test'
+    poisson_ratio = 0.3
+    rate_form = true
+  []
+  [integrate_stress]
+    type = SR2BackwardEulerTimeIntegration
+    variable = 'state/S'
+  []
+  [integrate_ep]
+    type = ScalarBackwardEulerTimeIntegration
+    variable = 'state/internal/ep'
+  []
+  [mixed]
+    type = MixedControlSetup
+  []
+  [mixed_old]
+    type = MixedControlSetup
+    control = "old_forces/control"
+    mixed_state = "old_state/mixed_state"
+    fixed_values = "old_forces/fixed_values"
+    cauchy_stress = "old_state/S"
+    strain = "old_state/E"
+  []
+  [rename]
+    type = CopySR2
+    from = "residual/S"
+    to = "residual/mixed_state"
+  []
+  [implicit_rate]
+    type = ComposedModel
+    models = "isoharden elasticity g
+              mandel_stress vonmises
+              yield yield_zero normality eprate Eprate Erate Eerate
+              ri_flowrate rd_flowrate flowrate integrate_ep integrate_stress effective_strain_rate 
+              mixed mixed_old rename"
+  []
+  [model_mixed]
+    type = ImplicitUpdate
+    implicit_model = 'implicit_rate'
+    solver = 'newton'
+  []
+  [model]
+    type = ComposedModel
+    models = 'model_mixed mixed'
+    additional_outputs = 'state/mixed_state'
+  []
+[]
diff --git a/python/tests/pyzag/correct_model.i b/python/tests/pyzag/correct_model.i
new file mode 100644
index 0000000000..b37ecd8d9a
--- /dev/null
+++ b/python/tests/pyzag/correct_model.i
@@ -0,0 +1,71 @@
+[Models]
+  [mandel_stress]
+    type = IsotropicMandelStress
+  []
+  [vonmises]
+    type = SR2Invariant
+    invariant_type = 'VONMISES'
+    tensor = 'state/internal/M'
+    invariant = 'state/internal/s'
+  []
+  [isoharden]
+    type = LinearIsotropicHardening
+    hardening_modulus = 1000
+  []
+  [yield]
+    type = YieldFunction
+    yield_stress = 5
+    isotropic_hardening = 'state/internal/k'
+  []
+  [flow]
+    type = ComposedModel
+    models = 'vonmises yield'
+  []
+  [normality]
+    type = Normality
+    model = 'flow'
+    function = 'state/internal/fp'
+    from = 'state/internal/M state/internal/k'
+    to = 'state/internal/NM state/internal/Nk'
+  []
+  [flow_rate]
+    type = PerzynaPlasticFlowRate
+    reference_stress = 100
+    exponent = 2
+  []
+  [Eprate]
+    type = AssociativePlasticFlow
+  []
+  [eprate]
+    type = AssociativeIsotropicPlasticHardening
+  []
+  [Erate]
+    type = SR2VariableRate
+    variable = 'forces/E'
+    rate = 'forces/E_rate'
+  []
+  [Eerate]
+    type = SR2LinearCombination
+    from_var = 'forces/E_rate state/internal/Ep_rate'
+    to_var = 'state/internal/Ee_rate'
+    coefficients = '1 -1'
+  []
+  [elasticity]
+    type = LinearIsotropicElasticity
+    youngs_modulus = 1e5
+    poisson_ratio = 0.3
+    rate_form = true
+  []
+  [integrate_stress]
+    type = SR2BackwardEulerTimeIntegration
+    variable = 'state/S'
+  []
+  [integrate_ep]
+    type = ScalarBackwardEulerTimeIntegration
+    variable = 'state/internal/ep'
+  []
+  [implicit_rate]
+    type = ComposedModel
+    models = 'mandel_stress vonmises isoharden yield normality flow_rate Eprate eprate Erate Eerate elasticity integrate_stress integrate_ep'
+  []
+[]
diff --git a/python/tests/pyzag/elastic_model.i b/python/tests/pyzag/elastic_model.i
new file mode 100644
index 0000000000..aae238796d
--- /dev/null
+++ b/python/tests/pyzag/elastic_model.i
@@ -0,0 +1,83 @@
+[Tensors]
+  [end_time]
+    type = LogspaceScalar
+    start = -1
+    end = 5
+    nstep = 20
+  []
+  [times]
+    type = LinspaceScalar
+    start = 0
+    end = end_time
+    nstep = 100
+  []
+  [exx]
+    type = FullScalar
+    batch_shape = '(20)'
+    value = 0.1
+  []
+  [eyy]
+    type = FullScalar
+    batch_shape = '(20)'
+    value = -0.05
+  []
+  [ezz]
+    type = FullScalar
+    batch_shape = '(20)'
+    value = -0.05
+  []
+  [max_strain]
+    type = FillSR2
+    values = 'exx eyy ezz'
+  []
+  [strains]
+    type = LinspaceSR2
+    start = 0
+    end = max_strain
+    nstep = 100
+  []
+[]
+
+[Drivers]
+  [driver]
+    type = SolidMechanicsDriver
+    model = 'model'
+    times = 'times'
+    prescribed_strains = 'strains'
+    save_as = 'result_elastic_model.pt'
+  []
+[]
+
+[Solvers]
+  [newton]
+    type = Newton
+  []
+[]
+
+[Models]
+  [Erate]
+    type = SR2VariableRate
+    variable = 'forces/E'
+    rate = 'forces/E_rate'
+  []
+  [elasticity]
+    type = LinearIsotropicElasticity
+    youngs_modulus = 1e5
+    poisson_ratio = 0.3
+    rate_form = true
+    strain = 'forces/E'
+  []
+  [integrate_stress]
+    type = SR2BackwardEulerTimeIntegration
+    variable = 'state/S'
+  []
+  [implicit_rate]
+    type = ComposedModel
+    models = 'Erate elasticity integrate_stress'
+  []
+  [model]
+    type = ImplicitUpdate
+    implicit_model = 'implicit_rate'
+    solver = 'newton'
+  []
+[]
diff --git a/python/tests/pyzag/result_complex_model.pt b/python/tests/pyzag/result_complex_model.pt
new file mode 100644
index 0000000000..77906fa068
Binary files /dev/null and b/python/tests/pyzag/result_complex_model.pt differ
diff --git a/python/tests/pyzag/result_elastic_model.pt b/python/tests/pyzag/result_elastic_model.pt
new file mode 100644
index 0000000000..82c36b97b1
Binary files /dev/null and b/python/tests/pyzag/result_elastic_model.pt differ
diff --git a/python/tests/pyzag/result_viscoplastic_model.pt b/python/tests/pyzag/result_viscoplastic_model.pt
new file mode 100644
index 0000000000..d1dbafab47
Binary files /dev/null and b/python/tests/pyzag/result_viscoplastic_model.pt differ
diff --git a/python/tests/pyzag/test_adjoint.py b/python/tests/pyzag/test_adjoint.py
new file mode 100644
index 0000000000..d802ebb10e
--- /dev/null
+++ b/python/tests/pyzag/test_adjoint.py
@@ -0,0 +1,229 @@
+# Copyright 2024, UChicago Argonne, LLC
+# All Rights Reserved
+# Software Name: NEML2 -- the New Engineering material Model Library, version 2
+# By: Argonne National Laboratory
+# OPEN SOURCE LICENSE (MIT)
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+"""Test adjoint correctness"""
+
+import unittest
+import os.path
+
+import torch
+
+torch.set_default_dtype(torch.double)
+
+import neml2
+from pyzag import nonlinear
+
+
+class DerivativeCheck:
+    def adjoint_grads(self):
+        solver = nonlinear.RecursiveNonlinearEquationSolver(
+            self.pmodel,
+            step_generator=nonlinear.StepGenerator(self.nchunk),
+            predictor=nonlinear.PreviousStepsPredictor(),
+        )
+        solver.zero_grad()
+        res = nonlinear.solve_adjoint(
+            solver, self.initial_state.detach().clone(), len(self.forces), self.forces
+        )
+        val = torch.norm(res)
+        val.backward()
+
+        return {n: p.grad.detach().clone() for n, p in solver.named_parameters()}
+
+    def fd_grads(self, eps=1.0e-6):
+        solver = nonlinear.RecursiveNonlinearEquationSolver(
+            self.pmodel,
+            step_generator=nonlinear.StepGenerator(self.nchunk),
+            predictor=nonlinear.PreviousStepsPredictor(),
+        )
+        res = {}
+        with torch.no_grad():
+            val0 = torch.norm(
+                nonlinear.solve(
+                    solver,
+                    self.initial_state.detach().clone(),
+                    len(self.forces),
+                    self.forces,
+                )
+            )
+            for n, p in solver.named_parameters():
+                p0 = p.clone()
+                dx = torch.abs(p0) * eps
+                p.data = p0 + dx
+                val1 = torch.norm(
+                    nonlinear.solve(
+                        solver,
+                        self.initial_state.detach().clone(),
+                        len(self.forces),
+                        self.forces,
+                    )
+                )
+                res[n] = (val1 - val0) / dx
+                p.data = p0
+
+        return res
+
+    def test_adjoint_vs_fd(self):
+        grads_adjoint = self.adjoint_grads()
+        grads_fd = self.fd_grads()
+        self.assertEqual(grads_adjoint.keys(), grads_fd.keys())
+
+        for n in grads_adjoint.keys():
+            self.assertTrue(
+                torch.allclose(grads_adjoint[n], grads_fd[n], rtol=self.rtol)
+            )
+
+
+class TestElasticModel(unittest.TestCase, DerivativeCheck):
+    def setUp(self):
+        self.nmodel = neml2.load_model(
+            os.path.join(os.path.dirname(__file__), "elastic_model.i"), "implicit_rate"
+        )
+        self.pmodel = neml2.pyzag.NEML2PyzagModel(self.nmodel)
+
+        self.nbatch = 20
+        self.ntime = 100
+
+        end_time = torch.logspace(-1, -5, self.nbatch)
+        time = torch.stack(
+            [torch.linspace(0, et, self.ntime) for et in end_time]
+        ).T.unsqueeze(-1)
+        strain = (
+            torch.stack(
+                [
+                    torch.linspace(0, 0.1, self.ntime),
+                    torch.linspace(0, -0.05, self.ntime),
+                    torch.linspace(0, -0.05, self.ntime),
+                    torch.zeros(self.ntime),
+                    torch.zeros(self.ntime),
+                    torch.zeros(self.ntime),
+                ]
+            )
+            .T[:, None]
+            .expand(-1, self.nbatch, -1)
+        )
+
+        self.initial_state = torch.zeros((self.nbatch, 6))
+        self.forces = self.pmodel.collect_forces({"t": time, "E": strain})
+
+        self.nchunk = 10
+        self.rtol = 1.0e-5
+
+
+class TestViscoplasticModel(unittest.TestCase, DerivativeCheck):
+    def setUp(self):
+        self.nmodel = neml2.load_model(
+            os.path.join(os.path.dirname(__file__), "viscoplastic_model.i"),
+            "implicit_rate",
+        )
+        self.pmodel = neml2.pyzag.NEML2PyzagModel(self.nmodel)
+
+        self.nbatch = 20
+        self.ntime = 100
+
+        end_time = torch.logspace(-1, -5, self.nbatch)
+        time = torch.stack(
+            [torch.linspace(0, et, self.ntime) for et in end_time]
+        ).T.unsqueeze(-1)
+        strain = (
+            torch.stack(
+                [
+                    torch.linspace(0, 0.1, self.ntime),
+                    torch.linspace(0, -0.05, self.ntime),
+                    torch.linspace(0, -0.05, self.ntime),
+                    torch.zeros(self.ntime),
+                    torch.zeros(self.ntime),
+                    torch.zeros(self.ntime),
+                ]
+            )
+            .T[:, None]
+            .expand(-1, self.nbatch, -1)
+        )
+
+        self.initial_state = torch.zeros((self.nbatch, 7))
+        self.forces = self.pmodel.collect_forces({"t": time, "E": strain})
+
+        self.nchunk = 10
+
+        self.rtol = 1.0e-5
+
+
+class TestComplexModel(unittest.TestCase, DerivativeCheck):
+    def setUp(self):
+        self.nmodel = neml2.load_model(
+            os.path.join(os.path.dirname(__file__), "complex_model.i"),
+            "implicit_rate",
+        )
+        self.pmodel = neml2.pyzag.NEML2PyzagModel(
+            self.nmodel, exclude_parameters=["yield_zero.sy", "mu.X", "mu.Y"]
+        )
+        self.nbatch = 20
+        self.ntime = 100
+
+        end_time = torch.logspace(-1, -5, self.nbatch)
+        time = torch.stack(
+            [torch.linspace(0, et, self.ntime) for et in end_time]
+        ).T.unsqueeze(-1)
+        conditions = (
+            torch.stack(
+                [
+                    torch.linspace(0, 0.1, self.ntime),
+                    torch.linspace(0, -50, self.ntime),
+                    torch.linspace(0, -0.025, self.ntime),
+                    torch.linspace(0, 0.15, self.ntime),
+                    torch.linspace(0, 75.0, self.ntime),
+                    torch.linspace(0, 0.05, self.ntime),
+                ]
+            )
+            .T[:, None]
+            .expand(-1, self.nbatch, -1)
+        )
+
+        control = torch.zeros((self.ntime, self.nbatch, 6))
+        control[..., 1] = 1.0
+        control[..., 4] = 1.0
+
+        temperatures = torch.stack(
+            [
+                torch.linspace(T1, T2, self.ntime)
+                for T1, T2 in zip(
+                    torch.linspace(300, 500, self.nbatch),
+                    torch.linspace(600, 1200, self.nbatch),
+                )
+            ]
+        ).T.unsqueeze(-1)
+
+        self.initial_state = torch.zeros((self.nbatch, 8))
+        self.forces = self.pmodel.collect_forces(
+            {
+                "t": time,
+                "control": control,
+                "fixed_values": conditions,
+                "T": temperatures,
+            }
+        )
+
+        self.nchunk = 10
+
+        self.rtol = 1.0e-4
diff --git a/python/tests/pyzag/test_correctness.py b/python/tests/pyzag/test_correctness.py
new file mode 100644
index 0000000000..59451d1c3c
--- /dev/null
+++ b/python/tests/pyzag/test_correctness.py
@@ -0,0 +1,93 @@
+# Copyright 2024, UChicago Argonne, LLC
+# All Rights Reserved
+# Software Name: NEML2 -- the New Engineering material Model Library, version 2
+# By: Argonne National Laboratory
+# OPEN SOURCE LICENSE (MIT)
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+"""Test we get the same answers in pyzag with parallel time as we do in NEML2 with sequential time"""
+
+import unittest
+import os.path
+
+import torch
+
+torch.set_default_dtype(torch.double)
+
+import neml2
+from pyzag import nonlinear, chunktime
+
+
+nchunk = 10
+
+models = ["elastic_model", "viscoplastic_model", "complex_model"]
+
+
+class TestCorrectness(unittest.TestCase):
+    def test_correctness(self):
+        for i, model in enumerate(models):
+            with self.subTest(i=i):
+                self.run_model(model)
+
+    def run_model(self, model_name):
+        nmodel = neml2.load_model(
+            os.path.join(os.path.dirname(__file__), model_name + ".i"),
+            "implicit_rate",
+        )
+        model = neml2.pyzag.NEML2PyzagModel(nmodel)
+
+        results = torch.jit.load(
+            os.path.join(os.path.dirname(__file__), "result_" + model_name + ".pt")
+        )
+
+        modules = dict(results.named_modules())
+        input = dict(modules["input"].named_buffers())
+        output = dict(modules["output"].named_buffers())
+
+        forces = torch.cat(
+            [
+                input["forces/" + n]
+                for n in model.model.input_axis().subaxis("forces").variable_names()
+            ],
+            dim=-1,
+        )
+        state = torch.cat(
+            [
+                output["state/" + n]
+                for n in model.model.input_axis().subaxis("state").variable_names()
+            ],
+            dim=-1,
+        )
+
+        solver = nonlinear.RecursiveNonlinearEquationSolver(
+            model,
+            step_generator=nonlinear.StepGenerator(nchunk),
+            predictor=nonlinear.PreviousStepsPredictor(),
+            nonlinear_solver=chunktime.ChunkNewtonRaphson(rtol=1.0e-8, atol=1.0e-10),
+        )
+        with torch.no_grad():
+            results = nonlinear.solve(
+                solver,
+                state[0],
+                len(forces),
+                forces,
+            )
+
+        self.assertTrue(torch.allclose(state, results))
diff --git a/python/tests/pyzag/test_definitions.py b/python/tests/pyzag/test_definitions.py
new file mode 100644
index 0000000000..3473a8ad0b
--- /dev/null
+++ b/python/tests/pyzag/test_definitions.py
@@ -0,0 +1,172 @@
+# Copyright 2024, UChicago Argonne, LLC
+# All Rights Reserved
+# Software Name: NEML2 -- the New Engineering material Model Library, version 2
+# By: Argonne National Laboratory
+# OPEN SOURCE LICENSE (MIT)
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+"""Test basic setup of NEML2 models"""
+
+import unittest
+import os.path
+
+import neml2
+
+import torch
+
+torch.set_default_dtype(torch.double)
+
+
+class TestChangeParameterShape(unittest.TestCase):
+    def setUp(self):
+        self.nmodel = neml2.load_model(
+            os.path.join(os.path.dirname(__file__), "correct_model.i"), "implicit_rate"
+        )
+        self.pmodel = neml2.pyzag.NEML2PyzagModel(
+            self.nmodel, exclude_parameters=["elasticity.nu"]
+        )
+
+    def test_update_parameter(self):
+        self.pmodel.elasticity_E.data = torch.tensor(1.2e5).expand(10)
+        self.pmodel._update_parameter_values()
+        self.assertTrue(
+            torch.allclose(
+                self.pmodel.model.named_parameters()["elasticity.E"].torch(),
+                self.pmodel.elasticity_E,
+            )
+        )
+        self.assertEqual(
+            self.pmodel.model.get_parameter("elasticity.E").tensor().batch.shape, (10,)
+        )
+
+        # Now go back
+        self.pmodel.elasticity_E.data = torch.tensor(1.3e5)
+        self.pmodel._update_parameter_values()
+        self.assertTrue(
+            torch.allclose(
+                self.pmodel.model.named_parameters()["elasticity.E"].torch(),
+                self.pmodel.elasticity_E,
+            )
+        )
+        self.assertEqual(
+            self.pmodel.model.get_parameter("elasticity.E").tensor().batch.shape,
+            tuple(),
+        )
+
+
+class TestCorrectlyDefinedModel(unittest.TestCase):
+    def setUp(self):
+        self.nmodel = neml2.load_model(
+            os.path.join(os.path.dirname(__file__), "correct_model.i"), "implicit_rate"
+        )
+        self.pmodel = neml2.pyzag.NEML2PyzagModel(
+            self.nmodel, exclude_parameters=["elasticity.nu"]
+        )
+
+    def test_parameter_names(self):
+        """Check that names and parameter values are the same"""
+        self.assertEqual(
+            set([n for n, _ in self.pmodel.named_parameters()]),
+            set(
+                [
+                    "elasticity_E",
+                    "flow_rate_eta",
+                    "flow_rate_n",
+                    "isoharden_K",
+                    "yield_sy",
+                ]
+            ),
+        )
+
+        for name, val in self.pmodel.named_parameters():
+            self.assertTrue(
+                torch.allclose(
+                    val,
+                    self.pmodel.model.named_parameters()[
+                        self.pmodel.parameter_name_map[name]
+                    ].torch(),
+                )
+            )
+
+    def test_update_parameter(self):
+        self.assertTrue(torch.allclose(self.pmodel.elasticity_E, torch.tensor(1e5)))
+        self.assertTrue(
+            torch.allclose(
+                self.pmodel.model.named_parameters()["elasticity.E"].torch(),
+                self.pmodel.elasticity_E,
+            )
+        )
+        self.pmodel.elasticity_E.data = torch.tensor(1.2e5)
+        self.pmodel._update_parameter_values()
+        self.assertTrue(torch.allclose(self.pmodel.elasticity_E, torch.tensor(1.2e5)))
+        self.assertTrue(
+            torch.allclose(
+                self.pmodel.model.named_parameters()["elasticity.E"].torch(),
+                self.pmodel.elasticity_E,
+            )
+        )
+
+    def test_nstate(self):
+        self.assertEqual(self.pmodel.nstate, 7)
+
+    def test_nforce(self):
+        self.assertEqual(self.pmodel.nforce, 7)
+
+
+class TestSetVectorParameter(unittest.TestCase):
+
+    def setUp(self):
+        self.nmodel = neml2.load_model(
+            os.path.join(os.path.dirname(__file__), "complex_model.i"), "implicit_rate"
+        )
+        self.pmodel = neml2.pyzag.NEML2PyzagModel(self.nmodel)
+
+    def test_set_vector(self):
+        self.assertTrue(
+            torch.allclose(
+                self.pmodel.mu_Y, self.nmodel.named_parameters()["mu.Y"].torch()
+            )
+        )
+        self.pmodel.mu_Y = torch.nn.Parameter(torch.ones_like(self.pmodel.mu_Y))
+        self.pmodel._update_parameter_values()
+        self.assertTrue(torch.allclose(self.pmodel.mu_Y, torch.tensor(1.0)))
+        self.assertTrue(
+            torch.allclose(
+                self.nmodel.named_parameters()["mu.Y"].torch(), torch.tensor(1.0)
+            )
+        )
+
+    def test_set_scalar(self):
+        self.assertTrue(torch.allclose(self.pmodel.elasticity_E, torch.tensor(1e5)))
+        self.assertTrue(
+            torch.allclose(
+                self.pmodel.model.named_parameters()["elasticity.E"].torch(),
+                self.pmodel.elasticity_E,
+            )
+        )
+        self.pmodel.elasticity_E.data = torch.tensor(1.2e5)
+        self.pmodel._update_parameter_values()
+        self.assertTrue(torch.allclose(self.pmodel.elasticity_E, torch.tensor(1.2e5)))
+        self.assertTrue(
+            torch.allclose(
+                self.pmodel.model.named_parameters()["elasticity.E"].torch(),
+                self.pmodel.elasticity_E,
+            )
+        )
diff --git a/python/tests/pyzag/viscoplastic_model.i b/python/tests/pyzag/viscoplastic_model.i
new file mode 100644
index 0000000000..58710debfa
--- /dev/null
+++ b/python/tests/pyzag/viscoplastic_model.i
@@ -0,0 +1,132 @@
+[Tensors]
+  [end_time]
+    type = LogspaceScalar
+    start = -1
+    end = 5
+    nstep = 20
+  []
+  [times]
+    type = LinspaceScalar
+    start = 0
+    end = end_time
+    nstep = 100
+  []
+  [exx]
+    type = FullScalar
+    batch_shape = '(20)'
+    value = 0.1
+  []
+  [eyy]
+    type = FullScalar
+    batch_shape = '(20)'
+    value = -0.05
+  []
+  [ezz]
+    type = FullScalar
+    batch_shape = '(20)'
+    value = -0.05
+  []
+  [max_strain]
+    type = FillSR2
+    values = 'exx eyy ezz'
+  []
+  [strains]
+    type = LinspaceSR2
+    start = 0
+    end = max_strain
+    nstep = 100
+  []
+[]
+
+[Drivers]
+  [driver]
+    type = SolidMechanicsDriver
+    model = 'model'
+    times = 'times'
+    prescribed_strains = 'strains'
+    save_as = 'result_viscoplastic_model.pt'
+  []
+[]
+
+[Solvers]
+  [newton]
+    type = Newton
+  []
+[]
+
+[Models]
+  [mandel_stress]
+    type = IsotropicMandelStress
+  []
+  [vonmises]
+    type = SR2Invariant
+    invariant_type = 'VONMISES'
+    tensor = 'state/internal/M'
+    invariant = 'state/internal/s'
+  []
+  [isoharden]
+    type = LinearIsotropicHardening
+    hardening_modulus = 1000
+  []
+  [yield]
+    type = YieldFunction
+    yield_stress = 5
+    isotropic_hardening = 'state/internal/k'
+  []
+  [flow]
+    type = ComposedModel
+    models = 'vonmises yield'
+  []
+  [normality]
+    type = Normality
+    model = 'flow'
+    function = 'state/internal/fp'
+    from = 'state/internal/M state/internal/k'
+    to = 'state/internal/NM state/internal/Nk'
+  []
+  [flow_rate]
+    type = PerzynaPlasticFlowRate
+    reference_stress = 100
+    exponent = 2
+  []
+  [Eprate]
+    type = AssociativePlasticFlow
+  []
+  [eprate]
+    type = AssociativeIsotropicPlasticHardening
+  []
+  [Erate]
+    type = SR2VariableRate
+    variable = 'forces/E'
+    rate = 'forces/E_rate'
+  []
+  [Eerate]
+    type = SR2LinearCombination
+    from_var = 'forces/E_rate state/internal/Ep_rate'
+    to_var = 'state/internal/Ee_rate'
+    coefficients = '1 -1'
+  []
+  [elasticity]
+    type = LinearIsotropicElasticity
+    youngs_modulus = 1e5
+    poisson_ratio = 0.3
+    rate_form = true
+  []
+  [integrate_stress]
+    type = SR2BackwardEulerTimeIntegration
+    variable = 'state/S'
+  []
+  [integrate_ep]
+    type = ScalarBackwardEulerTimeIntegration
+    variable = 'state/internal/ep'
+  []
+  [implicit_rate]
+    type = ComposedModel
+    models = 'mandel_stress vonmises isoharden yield normality flow_rate Eprate eprate Erate Eerate elasticity integrate_stress integrate_ep'
+  []
+  [model]
+    type = ImplicitUpdate
+    implicit_model = 'implicit_rate'
+    solver = 'newton'
+  []
+[]
diff --git a/python/tests/test_ParameterStore.py b/python/tests/test_ParameterStore.py
index 383a50e224..8bdfa363fd 100644
--- a/python/tests/test_ParameterStore.py
+++ b/python/tests/test_ParameterStore.py
@@ -104,6 +104,41 @@ def test_set_parameters():
     assert torch.allclose(nu.torch(), torch.tensor(0.2, dtype=torch.float64))
 
 
+def test_change_batch_dimensions():
+    pwd = Path(__file__).parent
+    model = neml2.reload_model(pwd / "test_ParameterStore.i", "model")
+
+    # Setup variable views with batch shape (5,2)
+    model.reinit([5, 2])
+
+    # This model has two parameters
+    E = model.get_parameter("E")
+    nu = model.get_parameter("nu")
+
+    # This model has two parameters
+    model.set_parameters(
+        {
+            "E": neml2.Scalar.full((5, 2), 200.0),
+            "nu": neml2.Scalar.full((5, 2), 0.2),
+        }
+    )
+
+    # Should have correct shape
+    assert E.tensor().batch.shape == (5, 2)
+    assert nu.tensor().batch.shape == (5, 2)
+
+    # Now go back
+    model.set_parameters(
+        {
+            "E": neml2.Scalar.full(200.0),
+            "nu": neml2.Scalar.full(0.2),
+        }
+    )
+
+    assert E.tensor().batch.shape == tuple()
+    assert nu.tensor().batch.shape == tuple()
+
+
 def test_parameter_derivative():
     pwd = Path(__file__).parent
     model = neml2.reload_model(pwd / "test_ParameterStore.i", "model")
diff --git a/python/tests/test_ParameterStoreVector.i b/python/tests/test_ParameterStoreVector.i
new file mode 100644
index 0000000000..9b3a078e46
--- /dev/null
+++ b/python/tests/test_ParameterStoreVector.i
@@ -0,0 +1,28 @@
+[Tensors]
+  [X_values]
+    type = Scalar
+    values = '0.0 1.0 2.0 3.0'
+    batch_shape = '(4)'
+  []
+  [Y_values]
+    type = Scalar
+    values = '2.0 -1.0 5.0 10.0'
+    batch_shape = '(4)'
+  []
+[]
+
+[Models]
+  [model]
+    type = ScalarLinearInterpolation
+    argument = 'forces/inp'
+    abscissa = 'X_values'
+    ordinate = 'Y_values'
+  []
+  [model2]
+    type = ScalarLinearCombination
+    from_var = 'forces/x1 forces/x2 forces/x3 forces/x4'
+    to_var = 'forces/y'
+    coefficients = '0.1 0.2 0.3 0.4'
+    coefficients_as_parameters = true
+  []
+[]
diff --git a/python/tests/test_ParameterStoreVector.py b/python/tests/test_ParameterStoreVector.py
new file mode 100644
index 0000000000..355806f926
--- /dev/null
+++ b/python/tests/test_ParameterStoreVector.py
@@ -0,0 +1,187 @@
+# Copyright 2024, UChicago Argonne, LLC
+# All Rights Reserved
+# Software Name: NEML2 -- the New Engineering material Model Library, version 2
+# By: Argonne National Laboratory
+# OPEN SOURCE LICENSE (MIT)
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+import unittest
+from pathlib import Path
+import torch
+import neml2
+
+
+class TestLinearCombination(unittest.TestCase):
+    def setUp(self):
+        pwd = Path(__file__).parent
+        self.model = neml2.reload_model(pwd / "test_ParameterStoreVector.i", "model2")
+
+    def test_parameter_derivative(self):
+        # Batch shape 5 (shape 5,4)
+        inp = torch.tensor(
+            [
+                [0.2, 2.5, 0.3, 0.1],
+                [-0.5, 0.4, 0.2, -1.4],
+                [2.5, 1.8, 0.6, 3.2],
+                [-10.0, 11.0, 12.0, 6.8],
+                [1.0, 2.0, 3.0, 7.2],
+            ]
+        )
+
+        # The input vector only contains input
+        x = neml2.LabeledVector(neml2.Tensor(inp, 1), [self.model.input_axis()])
+
+        # Setup variable views
+        self.model.reinit(x.batch.shape)
+
+        coefs = self.model.get_parameter("c")
+        coefs.requires_grad_(True)
+
+        # Forward
+        y = self.model.value(x)
+        v = torch.norm(y.torch())
+        v.backward()
+
+        self.assertIsNotNone(coefs.grad)
+
+
+class TestLinearInterpolation(unittest.TestCase):
+    def setUp(self):
+        pwd = Path(__file__).parent
+        self.model = neml2.reload_model(pwd / "test_ParameterStoreVector.i", "model")
+
+    def test_named_parameters(self):
+        # Setup variable views with batch shape (5,2)
+        self.model.reinit([5, 2])
+
+        # This model has two parameters
+        X = self.model.named_parameters()["X"]
+        Y = self.model.named_parameters()["Y"]
+
+        # Parameters should have the correct value
+        self.assertTrue(
+            torch.allclose(
+                X.torch(), torch.tensor([0.0, 1.0, 2.0, 3.0], dtype=torch.float64)
+            )
+        )
+        self.assertTrue(
+            torch.allclose(
+                Y.torch(), torch.tensor([2.0, -1.0, 5.0, 10.0], dtype=torch.float64)
+            )
+        )
+
+    def test_get_parameter(self):
+        # Setup variable views with batch shape (5,2)
+        self.model.reinit([5, 2])
+
+        # This model has two parameters
+        X = self.model.get_parameter("X")
+        Y = self.model.get_parameter("Y")
+
+        # Parameters should have the correct value
+        self.assertTrue(
+            torch.allclose(
+                X.torch(), torch.tensor([0.0, 1.0, 2.0, 3.0], dtype=torch.float64)
+            )
+        )
+        self.assertTrue(
+            torch.allclose(
+                Y.torch(), torch.tensor([2.0, -1.0, 5.0, 10.0], dtype=torch.float64)
+            )
+        )
+
+    def test_set_parameter(self):
+        # Setup variable views with batch shape (5,2)
+        self.model.reinit([5, 2])
+
+        # This model has two parameters
+        X = self.model.get_parameter("X")
+        Y = self.model.get_parameter("Y")
+
+        # This model has two parameters
+        self.model.set_parameter("X", neml2.Scalar.full(200.0))
+        self.model.set_parameter("Y", neml2.Scalar.full(0.2))
+
+        # Parameters should have the correct value
+        self.assertTrue(
+            torch.allclose(X.torch(), torch.tensor(200.0, dtype=torch.float64))
+        )
+        self.assertTrue(
+            torch.allclose(Y.torch(), torch.tensor(0.2, dtype=torch.float64))
+        )
+
+    def test_set_parameters(self):
+        # Setup variable views with batch shape (5,2)
+        self.model.reinit([5, 2])
+
+        # This model has two parameters
+        X = self.model.get_parameter("X")
+        Y = self.model.get_parameter("Y")
+
+        # This model has two parameters
+        self.model.set_parameters(
+            {
+                "X": neml2.Scalar.full(200.0),
+                "Y": neml2.Scalar.full(0.2),
+            }
+        )
+
+        # Parameters should have the correct value
+        self.assertTrue(
+            torch.allclose(X.torch(), torch.tensor(200.0, dtype=torch.float64))
+        )
+        self.assertTrue(
+            torch.allclose(Y.torch(), torch.tensor(0.2, dtype=torch.float64))
+        )
+
+    def test_parameter_derivative(self):
+        inp = torch.tensor(
+            [[0.2, 2.5, 0.3, 1.2, 0.5], [0.1, 2.5, 1.2, 1.3, 1.5]]
+        ).unsqueeze(-1)
+
+        # The input vector only contains input
+        x = neml2.LabeledVector(neml2.Tensor(inp, 2), [self.model.input_axis()])
+
+        # Setup variable views
+        self.model.reinit(x.batch.shape)
+
+        # This model has two parameters
+        X = self.model.named_parameters()["X"]
+        Y = self.model.named_parameters()["Y"]
+
+        # Model parameters do not require grad by default
+        self.assertFalse(X.requires_grad)
+        self.assertFalse(Y.requires_grad)
+
+        # Set parameters to requires_grad=True
+        X.requires_grad_(True)
+        Y.requires_grad_(True)
+        self.assertTrue(X.requires_grad)
+        self.assertTrue(Y.requires_grad)
+
+        # Forward
+        y = self.model.value(x)
+        self.assertTrue(y.torch().requires_grad)
+
+        # dy/dp * x
+        y.torch().backward(gradient=x.torch())
+
+        self.assertIsNotNone(X.grad)
+        self.assertIsNotNone(Y.grad)
diff --git a/requirements.txt b/requirements.txt
index c334eee623..17cf4928c9 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -2,6 +2,7 @@
 ##### pip requirements ######
 #
 numpy<2
+pyzag
 -r doc/requirements.txt
 -r scripts/requirements.txt
 -r python/tests/requirements.txt
diff --git a/src/neml2/models/LinearInterpolation.cxx b/src/neml2/models/LinearInterpolation.cxx
index de4a291921..aa4999b1c1 100644
--- a/src/neml2/models/LinearInterpolation.cxx
+++ b/src/neml2/models/LinearInterpolation.cxx
@@ -42,19 +42,7 @@ LinearInterpolation<T>::expected_options()
 
 template <typename T>
 LinearInterpolation<T>::LinearInterpolation(const OptionSet & options)
-  : Interpolation<T>(options),
-    _interp_batch_sizes(
-        utils::broadcast_sizes(this->_X.batch_sizes().slice(0, this->_X.batch_dim() - 1),
-                               this->_Y.batch_sizes().slice(0, this->_Y.batch_dim() - 1))),
-    _X0(this->template declare_buffer<Scalar>(
-        "X0", this->_X.batch_index({indexing::Ellipsis, indexing::Slice(indexing::None, -1)}))),
-    _X1(this->template declare_buffer<Scalar>(
-        "X1", this->_X.batch_index({indexing::Ellipsis, indexing::Slice(1, indexing::None)}))),
-    _Y0(this->template declare_buffer<T>(
-        "Y0", this->_Y.batch_index({indexing::Ellipsis, indexing::Slice(indexing::None, -1)}))),
-    _slope(this->template declare_buffer<T>("S",
-                                            math::diff(this->_Y, 1, this->_Y.batch_dim() - 1) /
-                                                math::diff(this->_X, 1, this->_X.batch_dim() - 1)))
+  : Interpolation<T>(options)
 {
 }
 
@@ -62,15 +50,21 @@ template <typename T>
 void
 LinearInterpolation<T>::set_value(bool out, bool dout_din, bool d2out_din2)
 {
+  const auto X0 = this->_X.batch_index({indexing::Ellipsis, indexing::Slice(indexing::None, -1)});
+  const auto X1 = this->_X.batch_index({indexing::Ellipsis, indexing::Slice(1, indexing::None)});
+  const auto Y0 = this->_Y.batch_index({indexing::Ellipsis, indexing::Slice(indexing::None, -1)});
+  const auto slope = math::diff(this->_Y, 1, this->_Y.batch_dim() - 1) /
+                     math::diff(this->_X, 1, this->_X.batch_dim() - 1);
+
   const auto x = Scalar(this->_x);
-  const auto loc = torch::logical_and(torch::gt(x.batch_unsqueeze(-1), _X0),
-                                      torch::le(x.batch_unsqueeze(-1), _X1));
-  const auto si = mask<T>(_slope, loc);
+  const auto loc = torch::logical_and(torch::gt(x.batch_unsqueeze(-1), X0),
+                                      torch::le(x.batch_unsqueeze(-1), X1));
+  const auto si = mask<T>(slope, loc);
 
   if (out)
   {
-    const auto X0i = mask<Scalar>(_X0, loc);
-    const auto Y0i = mask<T>(_Y0, loc);
+    const auto X0i = mask<Scalar>(X0, loc);
+    const auto Y0i = mask<T>(Y0, loc);
     this->_p = Y0i + si * (x - X0i);
   }
 
diff --git a/src/neml2/models/solid_mechanics/KocksMeckingIntercept.cxx b/src/neml2/models/solid_mechanics/KocksMeckingIntercept.cxx
new file mode 100644
index 0000000000..7b7a005eef
--- /dev/null
+++ b/src/neml2/models/solid_mechanics/KocksMeckingIntercept.cxx
@@ -0,0 +1,99 @@
+// Copyright 2024, UChicago Argonne, LLC
+// All Rights Reserved
+// Software Name: NEML2 -- the New Engineering material Model Library, version 2
+// By: Argonne National Laboratory
+// OPEN SOURCE LICENSE (MIT)
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+#include "neml2/models/solid_mechanics/KocksMeckingIntercept.h"
+
+#include "neml2/misc/math.h"
+
+namespace neml2
+{
+register_NEML2_object(KocksMeckingIntercept);
+
+OptionSet
+KocksMeckingIntercept::expected_options()
+{
+  OptionSet options = NonlinearParameter<Scalar>::expected_options();
+
+  options.doc() = "The critical value of the normalized activation energy given by \\f$ g_0 "
+                  "\\frac{C-B}{A} \\f$";
+
+  options.set_parameter<CrossRef<Scalar>>("A");
+  options.set("A").doc() = "The Kocks-Mecking slope";
+
+  options.set_parameter<CrossRef<Scalar>>("B");
+  options.set("B").doc() = "The Kocks-Mecking intercept";
+
+  options.set_parameter<CrossRef<Scalar>>("C");
+  options.set("C").doc() = "The Kocks-Mecking horizontal value";
+
+  return options;
+}
+
+KocksMeckingIntercept::KocksMeckingIntercept(const OptionSet & options)
+  : NonlinearParameter<Scalar>(options),
+    _A(declare_parameter<Scalar>("A", "A", true)),
+    _B(declare_parameter<Scalar>("B", "B", true)),
+    _C(declare_parameter<Scalar>("C", "C", true))
+{
+}
+
+void
+KocksMeckingIntercept::set_value(bool out, bool dout_din, bool d2out_din2)
+{
+  if (out)
+    _p = (_C - _B) / _A;
+
+  if (dout_din)
+  {
+    if (const auto * const A = nl_param("A"))
+      _p.d(*A) = -(_C - _B) / math::pow(_A, 2.0);
+
+    if (const auto * const B = nl_param("B"))
+      _p.d(*B) = -1.0 / _A;
+
+    if (const auto * const C = nl_param("C"))
+      _p.d(*C) = 1.0 / _A;
+  }
+
+  if (d2out_din2)
+  {
+    if (const auto * const A = nl_param("A"))
+    {
+      _p.d(*A, *A) = 2.0 * (_C - _B) / math::pow(_A, 3.0);
+      if (const auto * const B = nl_param("B"))
+        _p.d(*A, *B) = 1.0 / math::pow(_A, 2.0);
+      if (const auto * const C = nl_param("C"))
+        _p.d(*A, *C) = -1.0 / math::pow(_A, 2.0);
+    }
+
+    if (const auto * const B = nl_param("B"))
+      if (const auto * const A = nl_param("A"))
+        _p.d(*B, *A) = 1.0 / math::pow(_A, 2.0);
+
+    if (const auto * const C = nl_param("C"))
+      if (const auto * const A = nl_param("A"))
+        _p.d(*C, *A) = -1.0 / math::pow(_A, 2.0);
+  }
+}
+} // namespace neml2
diff --git a/src/neml2/models/solid_mechanics/PowerLawIsotropicHardeningStaticRecovery.cxx b/src/neml2/models/solid_mechanics/PowerLawIsotropicHardeningStaticRecovery.cxx
index ab98cfaed5..3c17850098 100644
--- a/src/neml2/models/solid_mechanics/PowerLawIsotropicHardeningStaticRecovery.cxx
+++ b/src/neml2/models/solid_mechanics/PowerLawIsotropicHardeningStaticRecovery.cxx
@@ -74,7 +74,7 @@ PowerLawIsotropicHardeningStaticRecovery::set_value(bool out, bool dout_din, boo
 
     if (const auto * const n = nl_param("n"))
       _h_dot.d(*n) = -_h * math::pow(_tau, -_n) * math::pow(math::abs(Scalar(_h)), _n - 1) *
-                     math::log(math::abs(Scalar(_h)) / _tau);
+                     math::log(math::abs(Scalar(_h) + machine_precision()) / _tau);
   }
 }
 } // namespace neml2
diff --git a/src/neml2/models/solid_mechanics/PowerLawKinematicHardeningStaticRecovery.cxx b/src/neml2/models/solid_mechanics/PowerLawKinematicHardeningStaticRecovery.cxx
index e587ec7d1e..90917f9ddd 100644
--- a/src/neml2/models/solid_mechanics/PowerLawKinematicHardeningStaticRecovery.cxx
+++ b/src/neml2/models/solid_mechanics/PowerLawKinematicHardeningStaticRecovery.cxx
@@ -83,7 +83,8 @@ PowerLawKinematicHardeningStaticRecovery::set_value(bool out, bool dout_din, boo
       _X_dot.d(*tau) = _n * math::pow(s / _tau, _n - 1) * _X / (_tau * _tau);
 
     if (const auto * const n = nl_param("n"))
-      _X_dot.d(*n) = -_X / s * math::pow(s / _tau, _n) * math::log(s / _tau);
+      _X_dot.d(*n) =
+          -_X / s * math::pow(s / _tau, _n) * math::log((s + machine_precision()) / _tau);
   }
 }
 
diff --git a/src/neml2/tensors/LabeledMatrix.cxx b/src/neml2/tensors/LabeledMatrix.cxx
index 16d1220e60..1dd090f117 100644
--- a/src/neml2/tensors/LabeledMatrix.cxx
+++ b/src/neml2/tensors/LabeledMatrix.cxx
@@ -36,15 +36,6 @@ LabeledMatrix::identity(TensorShapeRef batch_size,
   return LabeledMatrix(Tensor::identity(batch_size, axis.storage_size(), options), {&axis, &axis});
 }
 
-void
-LabeledMatrix::fill(const LabeledMatrix & other, bool recursive)
-{
-  neml_assert_dbg(axis(1) == other.axis(1), "Can only accumulate matrices with conformal y axes");
-  const auto indices = axis(0).common_indices(other.axis(0), recursive);
-  for (const auto & [idxi, idxi_other] : indices)
-    _tensor.base_index_put_({idxi}, other.tensor().base_index({idxi_other}));
-}
-
 LabeledMatrix
 LabeledMatrix::chain(const LabeledMatrix & other) const
 {
diff --git a/src/neml2/tensors/LabeledTensor.cxx b/src/neml2/tensors/LabeledTensor.cxx
index a8d811677a..b1281a739c 100644
--- a/src/neml2/tensors/LabeledTensor.cxx
+++ b/src/neml2/tensors/LabeledTensor.cxx
@@ -328,6 +328,25 @@ LabeledTensor<Derived, D>::labels_to_indices(indexing::TensorLabelsRef labels) c
   return indices;
 }
 
+template <class Derived, Size D>
+void
+LabeledTensor<Derived, D>::fill(const Derived & other, Size odim, bool recursive)
+{
+  neml_assert_dbg(odim < D, "Common axis for fill must be less than the tensor dimension");
+  for (Size i = 0; i < Size(axes().size()) && i != odim; i++)
+    neml_assert_dbg(axis(i) == other.axis(i),
+                    "Can only accumulate matrices with conformal common axes");
+  const auto cindices = axis(odim).common_indices(other.axis(odim), recursive);
+  for (const auto & [idx, idx_other] : cindices)
+  {
+    indexing::TensorIndices indices(base_dim(), indexing::Slice());
+    indexing::TensorIndices indices_other(base_dim(), indexing::Slice());
+    indices[odim] = idx;
+    indices_other[odim] = idx_other;
+    _tensor.base_index_put_(indices, other.tensor().base_index(indices_other));
+  }
+}
+
 template class LabeledTensor<LabeledVector, 1>;
 template class LabeledTensor<LabeledMatrix, 2>;
 template class LabeledTensor<LabeledTensor3D, 3>;
diff --git a/src/neml2/tensors/LabeledVector.cxx b/src/neml2/tensors/LabeledVector.cxx
index b7d163d893..45437a6092 100644
--- a/src/neml2/tensors/LabeledVector.cxx
+++ b/src/neml2/tensors/LabeledVector.cxx
@@ -33,14 +33,6 @@ LabeledVector::slice(const std::string & name) const
   return LabeledVector(_tensor.base_index({_axes[0]->indices(name)}), {&_axes[0]->subaxis(name)});
 }
 
-void
-LabeledVector::fill(const LabeledVector & other, bool recursive)
-{
-  const auto indices = axis(0).common_indices(other.axis(0), recursive);
-  for (const auto & [idx, idx_other] : indices)
-    _tensor.base_index_put_({idx}, other.tensor().base_index({idx_other}));
-}
-
 namespace utils
 {
 bool
diff --git a/tests/regression/solid_mechanics/viscoplasticity/misc/torch_script/model_scalar.i b/tests/regression/solid_mechanics/viscoplasticity/misc/torch_script/model_scalar.i
index a7e9ce9f03..bff2f209bc 100644
--- a/tests/regression/solid_mechanics/viscoplasticity/misc/torch_script/model_scalar.i
+++ b/tests/regression/solid_mechanics/viscoplasticity/misc/torch_script/model_scalar.i
@@ -166,7 +166,7 @@ nbatch = 20
     youngs_modulus = 1e5
     poisson_ratio = 0.3
     elastic_trial_stress = 'forces/s'
-    inelastic_strain = 'state/ep'
+    equivalent_plastic_strain = 'state/ep'
     updated_trial_stress = 'state/s'
   []
   [rom]
diff --git a/tests/src/ModelUnitTest.cxx b/tests/src/ModelUnitTest.cxx
index 0a992272ff..10fe24aa3c 100644
--- a/tests/src/ModelUnitTest.cxx
+++ b/tests/src/ModelUnitTest.cxx
@@ -118,7 +118,7 @@ ModelUnitTest::ModelUnitTest(const OptionSet & options)
 
   if (_check_2nd_deriv || _check_AD_2nd_deriv || _check_AD_derivs)
     _deriv_order = 2;
-  else if (_check_1st_deriv)
+  else if (_check_1st_deriv || _check_AD_1st_deriv)
     _deriv_order = 1;
   else
     _deriv_order = 0;
diff --git a/tests/unit/models/solid_mechanics/KocksMeckingIntercept.i b/tests/unit/models/solid_mechanics/KocksMeckingIntercept.i
new file mode 100644
index 0000000000..2532506f74
--- /dev/null
+++ b/tests/unit/models/solid_mechanics/KocksMeckingIntercept.i
@@ -0,0 +1,45 @@
+[Drivers]
+  [unit]
+    type = ModelUnitTest
+    model = 'p'
+    batch_shape = '(5)'
+    output_scalar_names = 'parameters/p'
+    output_scalar_values = 'p_correct'
+    check_second_derivatives = true
+  []
+[]
+
+[Models]
+  [p]
+    type = KocksMeckingIntercept
+    A = 'A'
+    B = 'B'
+    C = 'C'
+  []
+[]
+
+[Tensors]
+  [A]
+    type = LinspaceScalar
+    start = -2.0
+    end = -3.0
+    nstep = 5
+  []
+  [B]
+    type = LinspaceScalar
+    start = -4.0
+    end = -7.0
+    nstep = 5
+  []
+  [C]
+    type = LinspaceScalar
+    start = -5.0
+    end = -8.0
+    nstep = 5
+  []
+  [p_correct]
+    type = Scalar
+    values = "0.5 0.44444444 0.4 0.36363636 0.33333333"
+    batch_shape = '(5)'
+  []
+[]
diff --git a/tests/unit/models/solid_mechanics/KocksMeckingIntercept_nl_params.i b/tests/unit/models/solid_mechanics/KocksMeckingIntercept_nl_params.i
new file mode 100644
index 0000000000..641873d15d
--- /dev/null
+++ b/tests/unit/models/solid_mechanics/KocksMeckingIntercept_nl_params.i
@@ -0,0 +1,66 @@
+[Drivers]
+  [unit]
+    type = ModelUnitTest
+    model = 'model'
+    batch_shape = '(5)'
+    input_scalar_names = 'params/A_in params/B_in params/C_in'
+    input_scalar_values = 'A_in B_in C_in'
+    output_scalar_names = 'parameters/p'
+    output_scalar_values = 'p_correct'
+    check_second_derivatives = true
+    check_AD_first_derivatives = false
+    check_AD_second_derivatives = false
+    check_AD_derivatives = false
+  []
+[]
+
+[Models]
+  [A]
+    type = ScalarInputParameter
+    from = 'params/A_in'
+  []
+  [B]
+    type = ScalarInputParameter
+    from = 'params/B_in'
+  []
+  [C]
+    type = ScalarInputParameter
+    from = 'params/C_in'
+  []
+  [p]
+    type = KocksMeckingIntercept
+    A = 'A'
+    B = 'B'
+    C = 'C'
+  []
+  [model]
+    type = ComposedModel
+    models = 'p'
+  []
+[]
+
+[Tensors]
+  [A_in]
+    type = LinspaceScalar
+    start = -2.0
+    end = -3.0
+    nstep = 5
+  []
+  [B_in]
+    type = LinspaceScalar
+    start = -4.0
+    end = -7.0
+    nstep = 5
+  []
+  [C_in]
+    type = LinspaceScalar
+    start = -5.0
+    end = -8.0
+    nstep = 5
+  []
+  [p_correct]
+    type = Scalar
+    values = "0.5 0.44444444 0.4 0.36363636 0.33333333"
+    batch_shape = '(5)'
+  []
+[]