diff --git a/csiborgtools/flow/__init__.py b/csiborgtools/flow/__init__.py
index 49bb5bd..3c33d2d 100644
--- a/csiborgtools/flow/__init__.py
+++ b/csiborgtools/flow/__init__.py
@@ -12,8 +12,8 @@
 # You should have received a copy of the GNU General Public License along
 # with this program; if not, write to the Free Software Foundation, Inc.,
 # 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-from .flow_model import (DataLoader, radial_velocity_los, dist2redshift,        # noqa
-                         dist2distmodulus, predict_zobs, project_Vext,          # noqa
-                         PV_validation_model, get_model, distmodulus2dist,      # noqa
-                         Observed2CosmologicalRedshift,                         # noqa
-                         stack_pzosmo_over_realizations)                        # noqa
+from .flow_model import (DataLoader, PV_LogLikelihood, PV_validation_model,     # noqa
+                         dist2distmodulus, dist2redshift, distmodulus2dist,     # noqa
+                         get_model, Observed2CosmologicalRedshift,              # noqa
+                         predict_zobs, project_Vext,                            # noqa
+                         radial_velocity_los, stack_pzosmo_over_realizations)   # noqa
diff --git a/csiborgtools/flow/flow_model.py b/csiborgtools/flow/flow_model.py
index e7a5cde..9d9305b 100644
--- a/csiborgtools/flow/flow_model.py
+++ b/csiborgtools/flow/flow_model.py
@@ -24,15 +24,14 @@ References
 from abc import ABC, abstractmethod
 
 import numpy as np
-import numpyro
-from astropy.cosmology import FlatLambdaCDM, z_at_value
 from astropy import units as u
+from astropy.cosmology import FlatLambdaCDM, z_at_value
 from h5py import File
 from jax import jit
 from jax import numpy as jnp
 from jax import vmap
 from jax.scipy.special import logsumexp
-from numpyro import sample
+from numpyro import deterministic, factor, sample
 from numpyro.distributions import Normal, Uniform
 from quadax import simpson
 from scipy.interpolate import interp1d
@@ -558,15 +557,23 @@ def e2_distmod_SN(e2_mB, e2_x1, e2_c, alpha_cal, beta_cal, e_mu_intrinsic):
 
 
 def sample_SN(e_mu_min, e_mu_max, mag_cal_mean, mag_cal_std, alpha_cal_mean,
-              alpha_cal_std, beta_cal_mean, beta_cal_std):
+              alpha_cal_std, beta_cal_mean, beta_cal_std, alpha_min, alpha_max,
+              sample_alpha, name):
     """Sample SNIe Tripp parameters."""
-    e_mu = sample("e_mu", Uniform(e_mu_min, e_mu_max))
-    mag_cal = sample("mag_cal", Normal(mag_cal_mean, mag_cal_std))
-    alpha_cal = sample("alpha_cal", Normal(alpha_cal_mean, alpha_cal_std))
+    e_mu = sample(f"e_mu_{name}", Uniform(e_mu_min, e_mu_max))
+    mag_cal = sample(f"mag_cal_{name}", Normal(mag_cal_mean, mag_cal_std))
+    alpha_cal = sample(
+        f"alpha_cal_{name}", Normal(alpha_cal_mean, alpha_cal_std))
+    beta_cal = sample(f"beta_cal_{name}", Normal(beta_cal_mean, beta_cal_std))
+    alpha = sample(f"alpha_{name}",
+                   Uniform(alpha_min, alpha_max)) if sample_alpha else 1.0
 
-    beta_cal = sample("beta_cal", Normal(beta_cal_mean, beta_cal_std))
-
-    return e_mu, mag_cal, alpha_cal, beta_cal
+    return {"e_mu": e_mu,
+            "mag_cal": mag_cal,
+            "alpha_cal": alpha_cal,
+            "beta_cal": beta_cal,
+            "alpha": alpha
+            }
 
 
 ###############################################################################
@@ -583,34 +590,42 @@ def e2_distmod_TFR(e2_mag, e2_eta, b, e_mu_intrinsic):
     return e2_mag + b**2 * e2_eta + e_mu_intrinsic**2
 
 
-def sample_TFR(e_mu_min, e_mu_max, a_mean, a_std, b_mean, b_std):
+def sample_TFR(e_mu_min, e_mu_max, a_mean, a_std, b_mean, b_std, alpha_min,
+               alpha_max, sample_alpha, name):
     """Sample Tully-Fisher calibration parameters."""
-    e_mu = sample("e_mu", Uniform(e_mu_min, e_mu_max))
-    a = sample("a", Normal(a_mean, a_std))
-    b = sample("b", Normal(b_mean, b_std))
-
-    return e_mu, a, b
+    e_mu = sample(f"e_mu_{name}", Uniform(e_mu_min, e_mu_max))
+    a = sample(f"a_{name}", Normal(a_mean, a_std))
+    b = sample(f"b_{name}", Normal(b_mean, b_std))
+    alpha = sample(f"alpha_{name}",
+                   Uniform(alpha_min, alpha_max)) if sample_alpha else 1.0
 
+    return {"e_mu": e_mu,
+            "a": a,
+            "b": b,
+            "alpha": alpha
+            }
 
 ###############################################################################
 #                    Calibration parameters sampling                          #
 ###############################################################################
 
 
-def sample_calibration(Vext_min, Vext_max, Vmono_min, Vmono_max,
-                       alpha_min, alpha_max, beta_min, beta_max, sigma_v_min,
-                       sigma_v_max, sample_Vmono, sample_alpha, sample_beta,
-                       sample_sigma_v_ext):
+def sample_calibration(Vext_min, Vext_max, Vmono_min, Vmono_max, beta_min,
+                       beta_max, sigma_v_min, sigma_v_max, sample_Vmono,
+                       sample_beta, sample_sigma_v_ext):
     """Sample the flow calibration."""
     Vext = sample("Vext", Uniform(Vext_min, Vext_max).expand([3]))
     sigma_v = sample("sigma_v", Uniform(sigma_v_min, sigma_v_max))
 
-    alpha = sample("alpha", Uniform(alpha_min, alpha_max)) if sample_alpha else 1.0                            # noqa
     beta = sample("beta", Uniform(beta_min, beta_max)) if sample_beta else 1.0                                 # noqa
     Vmono = sample("Vmono", Uniform(Vmono_min, Vmono_max)) if sample_Vmono else 0.0                            # noqa
     sigma_v_ext = sample("sigma_v_ext", Uniform(sigma_v_min, sigma_v_max)) if sample_sigma_v_ext else sigma_v  # noqa
 
-    return Vext, Vmono, sigma_v, sigma_v_ext, alpha, beta
+    return {"Vext": Vext,
+            "Vmono": Vmono,
+            "sigma_v": sigma_v,
+            "sigma_v_ext": sigma_v_ext,
+            "beta": beta}
 
 
 ###############################################################################
@@ -635,9 +650,9 @@ def find_extrap_mask(rmax, rdist):
     return extrap_mask, extrap_weights
 
 
-class PV_validation_model(BaseFlowValidationModel):
+class PV_LogLikelihood(BaseFlowValidationModel):
     """
-    Peculiar velocity validation model.
+    Peculiar velocity validation model log-likelihood.
 
     Parameters
     ----------
@@ -663,7 +678,7 @@ class PV_validation_model(BaseFlowValidationModel):
     """
 
     def __init__(self, los_density, los_velocity, rmax, RA, dec, z_obs,
-                 e_zobs, calibration_params, r_xrange, Omega_m, kind):
+                 e_zobs, calibration_params, r_xrange, Omega_m, kind, name):
         if e_zobs is not None:
             e2_cz_obs = jnp.asarray((SPEED_OF_LIGHT * e_zobs)**2)
         else:
@@ -681,6 +696,7 @@ class PV_validation_model(BaseFlowValidationModel):
         self._set_radial_spacing(r_xrange, Omega_m)
 
         self.kind = kind
+        self.name = name
         self.Omega_m = Omega_m
         self.norm = - self.ndata * jnp.log(self.num_sims)
 
@@ -688,29 +704,37 @@ class PV_validation_model(BaseFlowValidationModel):
         self.extrap_mask = jnp.asarray(extrap_mask)
         self.extrap_weights = jnp.asarray(extrap_weights)
 
-    def __call__(self, calibration_hyperparams, distmod_hyperparams,
-                 store_ll_all=False):
-        """NumPyro PV validation model."""
-        Vext, Vmono, sigma_v, sigma_v_ext, alpha, beta = sample_calibration(**calibration_hyperparams)  # noqa
+    def __call__(self, field_calibration_params, distmod_params,
+                 sample_sigma_v_ext):
+        """PV validation model log-likelihood."""
         # Turn e2_cz to be of shape (nsims, ndata, nxrange) and apply
         # sigma_v_ext where applicable
+        sigma_v = field_calibration_params["sigma_v"]
+        sigma_v_ext = field_calibration_params["sigma_v_ext"]
         e2_cz = jnp.full_like(self.extrap_mask, sigma_v**2, dtype=jnp.float32)
-        if calibration_hyperparams["sample_sigma_v_ext"]:
+        if sample_sigma_v_ext:
             e2_cz = e2_cz.at[self.extrap_mask].set(sigma_v_ext**2)
 
         # Now add the observational errors
         e2_cz += self.e2_cz_obs[None, :, None]
 
+        Vext = field_calibration_params["Vext"]
+        Vmono = field_calibration_params["Vmono"]
         Vext_rad = project_Vext(Vext[0], Vext[1], Vext[2], self.RA, self.dec)
 
+        e_mu = distmod_params["e_mu"]
+        alpha = distmod_params["alpha"]
         if self.kind == "SN":
-            e_mu, mag_cal, alpha_cal, beta_cal = sample_SN(**distmod_hyperparams)  # noqa
+            mag_cal = distmod_params["mag_cal"]
+            alpha_cal = distmod_params["alpha_cal"]
+            beta_cal = distmod_params["beta_cal"]
             mu = distmod_SN(
                 self.mB, self.x1, self.c, mag_cal, alpha_cal, beta_cal)
             squared_e_mu = e2_distmod_SN(
                 self.e2_mB, self.e2_x1, self.e2_c, alpha_cal, beta_cal, e_mu)
         elif self.kind == "TFR":
-            e_mu, a, b = sample_TFR(**distmod_hyperparams)
+            a = distmod_params["a"]
+            b = distmod_params["b"]
             mu = distmod_TFR(self.mag, self.eta, a, b)
             squared_e_mu = e2_distmod_TFR(self.e2_mag, self.e2_eta, b, e_mu)
         else:
@@ -725,20 +749,51 @@ class PV_validation_model(BaseFlowValidationModel):
 
         # Calculate z_obs at each distance. Shape is (n_sims, ndata, nxrange)
         # The weights are related to the extrapolation of the velocity field.
-        vrad = beta * self.los_velocity
+        vrad = field_calibration_params["beta"] * self.los_velocity
         vrad += (Vext_rad[None, :, None] + Vmono) * self.extrap_weights
         zobs = (1 + self.z_xrange[None, None, :]) * (1 + vrad / SPEED_OF_LIGHT) - 1  # noqa
 
         ptilde *= calculate_likelihood_zobs(self.z_obs, zobs, e2_cz)
-        # ptilde *= calculate_likelihood_zobs(self.z_obs, zobs, sigma_v)
         ll = jnp.log(simpson(ptilde, dx=self.dr, axis=-1)) - jnp.log(pnorm)
 
-        if store_ll_all:
-            numpyro.deterministic("ll_all", ll)
+        return jnp.sum(logsumexp(ll, axis=0)) + self.norm
 
-        ll = jnp.sum(logsumexp(ll, axis=0)) + self.norm
-        numpyro.deterministic("ll_values", ll)
-        numpyro.factor("ll", ll)
+
+def PV_validation_model(models, distmod_hyperparams_per_model,
+                        field_calibration_hyperparams):
+    """
+    Peculiar velocity validation NumPyro model.
+
+    Parameters
+    ----------
+    models : list of `PV_LogLikelihood`
+        List of PV validation log-likelihoods for each catalogue.
+    distmod_hyperparams_per_model : list of dict
+        Distance modulus hyperparameters for each model/catalogue.
+    field_calibration_hyperparams : dict
+        Field calibration hyperparameters.
+    """
+    field_calibration_params = sample_calibration(
+        **field_calibration_hyperparams)
+    sample_sigma_v_ext = field_calibration_hyperparams["sample_sigma_v_ext"]
+
+    ll = 0.0
+    for n in range(len(models)):
+        model = models[n]
+        distmod_hyperparams = distmod_hyperparams_per_model[n]
+
+        if model.kind == "TFR":
+            distmod_params = sample_TFR(**distmod_hyperparams, name=model.name)
+        elif model.kind == "SN":
+            distmod_params = sample_SN(**distmod_hyperparams, name=model.name)
+        else:
+            raise ValueError(f"Unknown kind: `{model.kind}`.")
+
+        ll += model(
+            field_calibration_params, distmod_params, sample_sigma_v_ext)
+
+    deterministic("ll_values", ll)
+    factor("ll", ll)
 
 
 ###############################################################################
@@ -780,10 +835,10 @@ def get_model(loader, zcmb_max=None, verbose=True):
                               "e_mB": e_mB[mask], "e_x1": e_x1[mask],
                               "e_c": e_c[mask]}
 
-        model = PV_validation_model(
+        model = PV_LogLikelihood(
             los_overdensity[:, mask], los_velocity[:, mask], rmax[:, mask],
             RA[mask], dec[mask], zCMB[mask], e_zCMB, calibration_params,
-            loader.rdist, loader._Omega_m, "SN")
+            loader.rdist, loader._Omega_m, "SN", name=kind)
     elif "Pantheon+" in kind:
         keys = ["RA", "DEC", "zCMB", "mB", "x1", "c", "biasCor_m_b", "mBERR",
                 "x1ERR", "cERR", "biasCorErr_m_b", "zCMB_SN", "zCMB_Group",
@@ -808,10 +863,10 @@ def get_model(loader, zcmb_max=None, verbose=True):
         calibration_params = {"mB": mB[mask], "x1": x1[mask], "c": c[mask],
                               "e_mB": e_mB[mask], "e_x1": e_x1[mask],
                               "e_c": e_c[mask]}
-        model = PV_validation_model(
+        model = PV_LogLikelihood(
             los_overdensity[:, mask], los_velocity[:, mask], rmax[:, mask],
             RA[mask], dec[mask], zCMB[mask], e_zCMB[mask], calibration_params,
-            loader.rdist, loader._Omega_m, "SN")
+            loader.rdist, loader._Omega_m, "SN", name=kind)
     elif kind in ["SFI_gals", "2MTF", "SFI_gals_masked"]:
         keys = ["RA", "DEC", "z_CMB", "mag", "eta", "e_mag", "e_eta"]
         RA, dec, zCMB, mag, eta, e_mag, e_eta = (loader.cat[k] for k in keys)
@@ -824,14 +879,14 @@ def get_model(loader, zcmb_max=None, verbose=True):
 
         calibration_params = {"mag": mag[mask], "eta": eta[mask],
                               "e_mag": e_mag[mask], "e_eta": e_eta[mask]}
-        model = PV_validation_model(
+        model = PV_LogLikelihood(
             los_overdensity[:, mask], los_velocity[:, mask], rmax[:, mask],
             RA[mask], dec[mask], zCMB[mask], None, calibration_params,
-            loader.rdist, loader._Omega_m, "TFR")
+            loader.rdist, loader._Omega_m, "TFR", name=kind)
     else:
         raise ValueError(f"Catalogue `{kind}` not recognized.")
 
-    fprint(f"selected {np.sum(mask)}/{len(mask)} galaxies.")
+    fprint(f"selected {np.sum(mask)}/{len(mask)} galaxies in catalogue `{kind}`")  # noqa
 
     return model
 
@@ -848,9 +903,12 @@ def _posterior_element(r, beta, Vext_radial, los_velocity, Omega_m, zobs,
     `Observed2CosmologicalRedshift`.
     """
     zobs_pred = predict_zobs(r, beta, Vext_radial, los_velocity, Omega_m)
+
     # Likelihood term
     dcz = SPEED_OF_LIGHT * (zobs - zobs_pred)
-    posterior = jnp.exp(-0.5 * dcz**2 / sigma_v**2) / jnp.sqrt(2 * jnp.pi * sigma_v**2)  # noqa
+    posterior = jnp.exp(-0.5 * dcz**2 / sigma_v**2)
+    posterior /= jnp.sqrt(2 * jnp.pi * sigma_v**2)
+
     # Prior term
     posterior *= dVdOmega * los_density**alpha
 
@@ -864,7 +922,8 @@ class BaseObserved2CosmologicalRedshift(ABC):
         for i, key in enumerate(calibration_samples.keys()):
             x = calibration_samples[key]
             if not isinstance(x, (np.ndarray, jnp.ndarray)):
-                raise ValueError(f"Calibration sample `{key}` must be an array.")  # noqa
+                raise ValueError(
+                    f"Calibration sample `{key}` must be an array.")
 
             if x.ndim != 1 and key != "Vext":
                 raise ValueError(f"Calibration samples `{key}` must be 1D.")
@@ -873,14 +932,19 @@ class BaseObserved2CosmologicalRedshift(ABC):
                 ncalibratrion = len(x)
 
             if len(x) != ncalibratrion:
-                raise ValueError("Calibration samples do not have the same length.")  # noqa
+                raise ValueError(
+                    "Calibration samples do not have the same length.")
 
             calibration_samples[key] = jnp.asarray(x)
 
         if "alpha" not in calibration_samples:
+            print("No `alpha` calibration sample found. Setting it to 1.",
+                  flush=True)
             calibration_samples["alpha"] = jnp.ones(ncalibratrion)
 
         if "beta" not in calibration_samples:
+            print("No `beta` calibration sample found. Setting it to 1.",
+                  flush=True)
             calibration_samples["beta"] = jnp.ones(ncalibratrion)
 
         # Get the stepsize, we need it to be constant for Simpson's rule.
@@ -898,7 +962,8 @@ class BaseObserved2CosmologicalRedshift(ABC):
     def get_calibration_samples(self, key):
         """Get calibration samples for a given key."""
         if key not in self._calibration_samples:
-            raise ValueError(f"Key `{key}` not found in calibration samples. Available keys are: `{self.calibration_keys}`.")  # noqa
+            raise ValueError(f"Key `{key}` not found in calibration samples. "
+                             f"Available keys are: `{self.calibration_keys}`.")
 
         return self._calibration_samples[key]
 
diff --git a/notebooks/flow/estimator_bulk_flow.ipynb b/notebooks/flow/estimator_bulk_flow.ipynb
index ea203fb..3f3258f 100644
--- a/notebooks/flow/estimator_bulk_flow.ipynb
+++ b/notebooks/flow/estimator_bulk_flow.ipynb
@@ -20,7 +20,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 69,
+   "execution_count": 2,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -49,6 +49,23 @@
     "    return distances, np.stack([bx, by, bz], axis=-1)\n"
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Keys are:  ['bf_volume_halo', 'bf_volume_halo_uniform', 'bf_volume_part', 'bf_vrad_weighted_halo', 'bf_vrad_weighted_halo_uniform', 'bf_vrad_weighted_part', 'distances', 'obs_0', 'obs_1', 'obs_10', 'obs_11', 'obs_12', 'obs_13', 'obs_14', 'obs_15', 'obs_16', 'obs_17', 'obs_18', 'obs_19', 'obs_2', 'obs_20', 'obs_21', 'obs_22', 'obs_23', 'obs_24', 'obs_25', 'obs_26', 'obs_3', 'obs_4', 'obs_5', 'obs_6', 'obs_7', 'obs_8', 'obs_9']\n"
+     ]
+    }
+   ],
+   "source": [
+    "distances, bf_volume_part = read_key(\"bf_volume_part\")"
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -58,20 +75,21 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 73,
+   "execution_count": 31,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
+      "Keys are:  ['bf_volume_halo', 'bf_volume_halo_uniform', 'bf_volume_part', 'bf_vrad_weighted_halo', 'bf_vrad_weighted_halo_uniform', 'bf_vrad_weighted_part', 'distances', 'obs_0', 'obs_1', 'obs_10', 'obs_11', 'obs_12', 'obs_13', 'obs_14', 'obs_15', 'obs_16', 'obs_17', 'obs_18', 'obs_19', 'obs_2', 'obs_20', 'obs_21', 'obs_22', 'obs_23', 'obs_24', 'obs_25', 'obs_26', 'obs_3', 'obs_4', 'obs_5', 'obs_6', 'obs_7', 'obs_8', 'obs_9']\n",
       "Keys are:  ['bf_volume_halo', 'bf_volume_halo_uniform', 'bf_volume_part', 'bf_vrad_weighted_halo', 'bf_vrad_weighted_halo_uniform', 'bf_vrad_weighted_part', 'distances', 'obs_0', 'obs_1', 'obs_10', 'obs_11', 'obs_12', 'obs_13', 'obs_14', 'obs_15', 'obs_16', 'obs_17', 'obs_18', 'obs_19', 'obs_2', 'obs_20', 'obs_21', 'obs_22', 'obs_23', 'obs_24', 'obs_25', 'obs_26', 'obs_3', 'obs_4', 'obs_5', 'obs_6', 'obs_7', 'obs_8', 'obs_9']\n",
       "Keys are:  ['bf_volume_halo', 'bf_volume_halo_uniform', 'bf_volume_part', 'bf_vrad_weighted_halo', 'bf_vrad_weighted_halo_uniform', 'bf_vrad_weighted_part', 'distances', 'obs_0', 'obs_1', 'obs_10', 'obs_11', 'obs_12', 'obs_13', 'obs_14', 'obs_15', 'obs_16', 'obs_17', 'obs_18', 'obs_19', 'obs_2', 'obs_20', 'obs_21', 'obs_22', 'obs_23', 'obs_24', 'obs_25', 'obs_26', 'obs_3', 'obs_4', 'obs_5', 'obs_6', 'obs_7', 'obs_8', 'obs_9']\n"
      ]
     },
     {
      "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAnYAAAHWCAYAAAD6oMSKAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/H5lhTAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdd5xU1f3/8de90/tsL7DAwtKLBSyoqNhQo4JfE6MxEUs0thijKZpEE/OLJTFVEzVdU9SYxAhiRI1gQ0Sk97osZXub2TL13vv747IDwy6wwC7bPs/HYx+6d+69c2ZmWd6c8jmKYRgGQgghhBCiz1N7ugFCCCGEEKJrSLATQgghhOgnJNgJIYQQQvQTEuyEEEIIIfoJCXZCCCGEEP2EBDshhBBCiH5Cgp0QQgghRD8hwU4IIYQQop+QYCeEEEII0U9IsBOij/jBD36AoihpxxRF4a677jqq+yWTSb71rW9RVFSEqqrMmjUrdc8f/OAHx9jage14vocd/VyIo/Pcc8+hKAo7duzo6aYIcdQk2AnRxdr+ctj/Kzc3l+nTp/PGG2/0dPNS/vSnP/HEE0/w2c9+lueff56vf/3rPd2kfuujjz7iBz/4AY2NjT3dFCFEP2ft6QYI0V/98Ic/pLi4GMMwqKqq4rnnnuPSSy/ltdde47LLLuvp5rFgwQIGDRrEL37xi55uSr8TiUSwWvf9ev3oo494+OGHueGGGwgGgz3XMHFIX/rSl7jmmmtwOBw93RQhjpoEOyG6ySWXXMKUKVNS3998883k5eXx4osv9opgV11dLSGjmzidzp5ugjgCLS0teDweLBYLFoulp5sjxDGRoVghjpNgMIjL5UrryXn33XdRFIV333037dwdO3agKArPPffcET/Pj370I1RV5amnnurw8bZ7L1y4kHXr1qWGiw9sw/5WrFjBJZdcgt/vx+v1cv755/Pxxx+nHm9sbMRisfDkk0+mjtXW1qKqKllZWRiGkTp+++23k5+ff8jX0DZvbPPmzXzxi18kEAiQk5PDgw8+iGEY7Nq1i5kzZ+L3+8nPz+dnP/tZ2vXxeJyHHnqIyZMnEwgE8Hg8TJs2jYULF7Z7rrq6Or70pS/h9/sJBoPMnj2bVatWtXv/b7jhBrxeL3v27GHWrFl4vV5ycnL4xje+gaZpaffcf47dD37wA775zW8CUFxcnHq/d+zYccjPuaN5eh9++CGnnHIKTqeTESNG8Nvf/vag7+Hf/vY3Jk+ejMvlIjMzk2uuuYZdu3Yd4l3fZ8+ePdx8880UFhbicDgoLi7m9ttvJx6Pp87Zvn07n/vc58jMzMTtdnP66afz+uuvp92n7ef75Zdf5uGHH2bQoEH4fD4++9nPEgqFiMVi3HPPPeTm5uL1ernxxhuJxWLt3oe77rqLv//974wePRqn08nkyZN5//33084rKyvjjjvuYPTo0bhcLrKysvjc5z7Xbr5c21SJ9957jzvuuIPc3FwGDx6c9tj+13z66afMmDGD7OxsXC4XxcXF3HTTTWn3bGlp4b777qOoqAiHw8Ho0aP56U9/mvZzv/9refXVV5kwYQIOh4Px48czf/78Tn0uQnSG9NgJ0U1CoRC1tbUYhkF1dTVPPfUUzc3NfPGLX+y25/ze977Ho48+ym9/+1tuueWWDs/Jycnhr3/9K4888gjNzc089thjAIwdO7bD89etW8e0adPw+/1861vfwmaz8dvf/pZzzz2X9957j9NOO41gMMiECRN4//33ufvuuwEzhCiKQn19PevXr2f8+PEAfPDBB0ybNq1Tr+fzn/88Y8eO5fHHH+f111/nRz/6EZmZmfz2t7/lvPPO48c//jF///vf+cY3vsEpp5zC2WefDUA4HOYPf/gD1157LbfccgtNTU388Y9/ZMaMGXzyySeceOKJAOi6zuWXX84nn3zC7bffzpgxY5gzZw6zZ8/usD2apjFjxgxOO+00fvrTn/K///2Pn/3sZ4wYMYLbb7+9w2v+7//+j82bN/Piiy/yi1/8guzs7NTnUFNT06n3AWDNmjVcdNFF5OTk8IMf/IBkMsn3v/998vLy2p37yCOP8OCDD3L11Vfz5S9/mZqaGp566inOPvtsVqxYccie2vLyck499VQaGxu59dZbGTNmDHv27OFf//oXra2t2O12qqqqOOOMM2htbeXuu+8mKyuL559/niuuuIJ//etfXHnllWn3fOyxx3C5XNx///1s3bqVp556CpvNhqqqNDQ08IMf/ICPP/6Y5557juLiYh566KG069977z3+8Y9/cPfdd+NwOHj66ae5+OKL+eSTT5gwYQIAS5cu5aOPPuKaa65h8ODB7Nixg2eeeYZzzz2X9evX43a70+55xx13kJOTw0MPPURLS0uH70V1dXXqPb///vsJBoPs2LGDV155JXWOYRhcccUVLFy4kJtvvpkTTzyRN998k29+85vs2bOn3VSHDz/8kFdeeYU77rgDn8/Hk08+yVVXXcXOnTvJyso66OciRKcZQogu9ec//9kA2n05HA7jueeeSzt34cKFBmAsXLgw7XhpaakBGH/+859Tx77//e8bB/6RBYw777zTMAzDuO+++wxVVds9x8Gcc845xvjx49sdB4zvf//7qe9nzZpl2O12Y9u2balj5eXlhs/nM84+++zUsTvvvNPIy8tLfX/vvfcaZ599tpGbm2s888wzhmEYRl1dnaEoivGrX/3qkG1re6233npr6lgymTQGDx5sKIpiPP7446njDQ0NhsvlMmbPnp12biwWS7tnQ0ODkZeXZ9x0002pY//+978NwPjlL3+ZOqZpmnHeeee1e/9nz55tAMYPf/jDtPuedNJJxuTJk9OOHfgePvHEEwZglJaWpp3X0ed8sHvMmjXLcDqdRllZWerY+vXrDYvFkvZzsWPHDsNisRiPPPJI2v3WrFljWK3WdscPdP311xuqqhpLly5t95iu64ZhGMY999xjAMYHH3yQeqypqckoLi42hg0bZmiaZhjGvp/vCRMmGPF4PHXutddeayiKYlxyySVp9586daoxdOjQdu8DYHz66aepY2VlZYbT6TSuvPLK1LHW1tZ27V28eLEBGH/5y19Sx9r+fJ511llGMplMO7/tsbbP6T//+Y8BdPhetHn11VcNwPjRj36Udvyzn/2soSiKsXXr1rTXYrfb046tWrXKAIynnnrqoM8hxJGQoVghuslvfvMb3n77bd5++23+9re/MX36dL785S+n/Wu/KxiGwV133cWvfvUr/va3vx20t+loaJrGW2+9xaxZsxg+fHjqeEFBAV/4whf48MMPCYfDAEybNo2qqio2bdoEmD1zZ599NtOmTeODDz4AzN4KwzA63WP35S9/OfX/FouFKVOmYBgGN998c+p4MBhk9OjRbN++Pe1cu90OmL1y9fX1JJNJpkyZwvLly1PnzZ8/H5vNlta7qaoqd95550HbdNttt6V9P23atLTn7g6apvHmm28ya9YshgwZkjo+duxYZsyYkXbuK6+8gq7rXH311dTW1qa+8vPzGTlyZIfD0W10XefVV1/l8ssvT5sf2qatrMp///tfTj31VM4666zUY16vl1tvvZUdO3awfv36tOuuv/56bDZb6vvTTjsNwzDaDWmedtpp7Nq1i2QymXZ86tSpTJ48OfX9kCFDmDlzJm+++WZqGNzlcqUeTyQS1NXVUVJSQjAYTPvM29xyyy2HnU/X1rM5b948EolEh+f897//xWKxpHqq29x3330YhtFuJfwFF1zAiBEjUt9PmjQJv9/f7T9DYuCQYCdENzn11FO54IILuOCCC7juuut4/fXXGTduHHfddVfaXKVj9Ze//IXf/OY3PPXUU1x77bVddl+AmpoaWltbGT16dLvHxo4di67rqXlbbWHtgw8+oKWlhRUrVjBt2jTOPvvsVLD74IMP8Pv9nHDCCZ16/v1DDEAgEMDpdKaGM/c/3tDQkHbs+eefZ9KkSTidTrKyssjJyeH1118nFAqlzikrK6OgoKDdMF1JSUmH7XE6neTk5KQdy8jIaPfcXa2mpoZIJMLIkSPbPXbgZ7NlyxYMw2DkyJHk5OSkfW3YsIHq6upDPk84HE4Nbx5MWVnZQX8m2h7fX0efI0BRUVG747qup31GQIeve9SoUbS2tqaGsyORCA899FBqnlt2djY5OTk0Nja2ux+Y8x0P55xzzuGqq67i4YcfJjs7m5kzZ/LnP/85bR5gWVkZhYWF+Hy+tGs7+17A8fkZEgOHzLET4jhRVZXp06fzq1/9ii1btjB+/PiDFpY9cDL+oZx55pmsXLmSX//611x99dVkZmZ2VZOPSGFhIcXFxbz//vsMGzYMwzCYOnUqOTk5fO1rX6OsrIwPPviAM844A1Xt3L8pO+pROVgvi7HfRPW//e1v3HDDDcyaNYtvfvOb5ObmYrFYeOyxx9i2bdvRvcBDPPfR6orP/0C6rqMoCm+88UaH7fV6vUd976N1sPetM59lZ331q1/lz3/+M/fccw9Tp04lEAigKArXXHMNuq63O3//Hr6DURSFf/3rX3z88ce89tprvPnmm9x000387Gc/4+OPPz6q97IrX7MQHZFgJ8Rx1DbE1NzcDJj/UgfaFa498F/5h1JSUsJPfvITzj33XC6++GLeeeeddr0HRysnJwe3250aXt3fxo0bUVU1rddl2rRpvP/++xQXF3PiiSfi8/k44YQTCAQCzJ8/n+XLl/Pwww93SdsO5V//+hfDhw/nlVdeSQtP3//+99POGzp0KAsXLqS1tTWt127r1q1d2p6DBbjOfv45OTm4XC62bNnS7h4HfjYjRozAMAyKi4sZNWrUEbUzJycHv9/P2rVrD3ne0KFDD/oz0fZ4V+rodW/evBm3253qQf3Xv/7F7Nmz01ZIR6PRLikKffrpp3P66afzyCOP8MILL3Ddddfx0ksv8eUvf5mhQ4fyv//9j6amprQ/d931XghxODIUK8RxkkgkeOutt7Db7alhmqFDh2KxWNqVbnj66aeP6N6TJk3iv//9Lxs2bODyyy8nEol0SZstFgsXXXQRc+bMSSsBUVVVxQsvvMBZZ52F3+9PHZ82bRo7duzgH//4R2poVlVVzjjjDH7+85+TSCQ6Pb/uWNsN6b0gS5YsYfHixWnnzZgxg0Qiwe9///vUMV3X+c1vftOl7fF4PED7AOf3+8nOzj7s52+xWJgxYwavvvoqO3fuTB3fsGEDb775Ztq5//d//4fFYuHhhx9u1wtkGAZ1dXUHbWfb1nKvvfYan376abvH2+536aWX8sknn6S9ny0tLfzud79j2LBhjBs37qDPcTQWL16cNk9u165dzJkzh4suuij1WVsslnav96mnnjqm3s+GhoZ292xbUd02HHvppZeiaRq//vWv0877xS9+gaIoXHLJJUf9/EIcDemxE6KbvPHGG6l/tVdXV/PCCy+wZcsW7r///lQYCgQCfO5zn+Opp55CURRGjBjBvHnzDjkP6mBOP/105syZw6WXXspnP/tZXn311bQJ60frRz/6EW+//TZnnXUWd9xxB1arld/+9rfEYjF+8pOfpJ3bFto2bdrEo48+mjp+9tln88Ybb+BwODjllFOOuU2Hc9lll/HKK69w5ZVX8pnPfIbS0lKeffZZxo0bl+otBZg1axannnoq9913H1u3bmXMmDHMnTuX+vp64OA9bUeqbeL/d7/7Xa655hpsNhuXX345Ho+HL3/5yzz++ON8+ctfZsqUKbz//vts3ry53T0efvhh5s+fz7Rp07jjjjtIJpM89dRTjB8/ntWrV6fOGzFiBD/60Y944IEH2LFjB7NmzcLn81FaWsp//vMfbr31Vr7xjW8ctK2PPvoob731Fueccw633norY8eOpaKign/+8598+OGHBINB7r//fl588UUuueQS7r77bjIzM3n++ecpLS3l3//+d6eH2jtrwoQJzJgxI63cSdt70uayyy7jr3/9K4FAgHHjxrF48WL+97//HVMJkeeff56nn36aK6+8khEjRtDU1MTvf/97/H4/l156KQCXX34506dP57vf/S47duzghBNO4K233mLOnDncc889aQslhDgujvs6XCH6uY7KnTidTuPEE080nnnmmVTJiDY1NTXGVVddZbjdbiMjI8P4yle+Yqxdu/aIy520mTNnjmG1Wo3Pf/7zqbITHelsuRPDMIzly5cbM2bMMLxer+F2u43p06cbH330UYf3zc3NNQCjqqoqdezDDz80AGPatGkHbc/+2l5rTU1N2vHZs2cbHo/nsK9F13Xj0UcfNYYOHWo4HA7jpJNOMubNm2fMnj27XTmNmpoa4wtf+ILh8/mMQCBg3HDDDcaiRYsMwHjppZcO+9wH+1wOfA//3//7f8agQYMMVVXTSmq0trYaN998sxEIBAyfz2dcffXVRnV1dYf3eO+994zJkycbdrvdGD58uPHss892+PyGYZZyOeusswyPx2N4PB5jzJgxxp133mls2rSp3bkHKisrM66//nojJyfHcDgcxvDhw40777wzrYTMtm3bjM9+9rNGMBg0nE6nceqppxrz5s1Lu09buZN//vOfacfb/owcWEako8+97Wf8b3/7mzFy5MjU53lgiaCGhgbjxhtvNLKzsw2v12vMmDHD2LhxozF06NC0UjgHe+79H2v7bJYvX25ce+21xpAhQwyHw2Hk5uYal112WVrpFcMwS718/etfNwoLCw2bzWaMHDnSeOKJJ9r9We/oz6thGO3aKMSxUAxDZmwKIcT+Xn31Va688ko+/PBDzjzzzJ5uzoCmKAp33nlnu6FOIUTHZI6dEGJAO3A+oqZpPPXUU/j9fk4++eQeapUQQhwdmWMnhBjQvvrVrxKJRJg6dSqxWIxXXnmFjz76iEcffbRTJTGEEKI3kWAnhBjQzjvvPH72s58xb948otEoJSUlPPXUU9x111093TQhhDhivWIo9v333+fyyy+nsLAQRVF49dVX0x43DIOHHnqIgoICXC4XF1xwQbu6RvX19Vx33XX4/X6CwSA333xz2uo3gNWrVzNt2jScTidFRUXtVvQJIQaeL3zhCyxbtoxQKEQsFmPdunUS6noRwzBkfp0QR6BXBLuWlhZOOOGEg9aO+slPfsKTTz7Js88+y5IlS/B4PMyYMYNoNJo657rrrmPdunW8/fbbzJs3j/fff59bb7019Xg4HOaiiy5i6NChLFu2jCeeeIIf/OAH/O53v+v21yeEEEIIcTz0ulWxiqLwn//8h1mzZgHmv9YKCwu57777UrWXQqEQeXl5PPfcc1xzzTVs2LCBcePGsXTp0tTG1fPnz+fSSy9l9+7dFBYW8swzz/Dd736XysrK1Obg999/P6+++mqq1pgQQgghRF/W6+fYlZaWUllZyQUXXJA6FggEOO2001i8eDHXXHMNixcvJhgMpkIdwAUXXICqqixZsoQrr7ySxYsXc/bZZ6dCHZhV53/84x/T0NCQ2trnQLFYLG3DZ13Xqa+vJysrq8uKlwohhBBCHIxhGDQ1NVFYWHjYAuC9PthVVlYCkJeXl3Y8Ly8v9VhlZSW5ublpj1utVjIzM9POKS4ubnePtscOFuwee+yx47K3pRBCCCHEoezatYvBgwcf8pxeH+x62gMPPMC9996b+j4UCjFkyBB2LfoXfq+n44uaKsGbC8Vn7Tu2+1Oo2waBfRumE2uCZCsMOwc8md30CoQQQgjRl4XDYYqKivD5fIc9t9cHu/z8fMDcdLygoCB1vKqqKrUZc35+fru9NZPJJPX19anr8/PzqaqqSjun7fu2czricDhwOBztjvu9Hvy+gwQ7ey4kY+C0gt0NrfWQrIXcwWDf7xqfBxrKIF4OeUOgi/dXFEIIIUT/0ZkpYL0+SRQXF5Ofn88777yTOhYOh1myZAlTp04FYOrUqTQ2NrJs2bLUOQsWLEDXdU477bTUOe+//z6JRCJ1zttvv83o0aMPOgx71GxuSLRAtNH8vr7UDHp2b/tzvXlQvwOayru2DUIIIYQYcHpFsGtubmblypWsXLkSMBdMrFy5kp07d6IoCvfccw8/+tGPmDt3LmvWrOH666+nsLAwtXJ27NixXHzxxdxyyy188sknLFq0iLvuuotrrrmGwsJCwKxVZbfbufnmm1m3bh3/+Mc/+NWvfpU2zNplVAsYhtlTF2mEhh3gOshQq81p9tRVbwQt0fE5QgghhBCd0CuGYj/99FOmT5+e+r4tbM2ePZvnnnuOb33rW7S0tHDrrbfS2NjIWWedxfz583E6nalr/v73v3PXXXdx/vnno6oqV111FU8++WTq8UAgwFtvvcWdd97J5MmTyc7O5qGHHkqrddelbG6zF05Pmr133tyDn+vNg9AuaNwJWSO6pz1CCCGE6Pd6XR273i4cDhMIBAiteuPgc+wA4q0QD4NiBYsNnIFD37ipEjzZMGL6oc8TQghx3GialjaFR4juYLPZsFgsB308lT1CIfx+/yHv1St67PolmwtaKgEFgsM6cb4boiFIRMxrhRBC9BjDMKisrKSxsbGnmyIGiGAwSH5+/jHXyJVg110UBZwZYLGb/384djeEyyEalmAnhBA9rC3U5ebm4na7pSC96DaGYdDa2pqq7rF/BZCjIcGuO7mOYLWtagVDN2vb+fIOf74QQohuoWlaKtRlZWX1dHPEAOBymR061dXV5ObmHnJY9nB6xapYsZdqhdbanm6FEEIMaG1z6txudw+3RAwkbT9vxzqnU4Jdb2L3QHMNaMmebokQQgx4Mvwqjqeu+nmTYNeb2FyQaIVYuKdbIoQQQog+SIJdb2J1ghYz59kJIYQQQhwhCXa9jaKau1UIIYQQR2nx4sUoisJnPvOZDh+vrKzkq1/9KsOHD8fhcFBUVMTll1+etn3nDTfcgKIoKIqCzWYjLy+PCy+8kD/96U/out7uvNtuu63d89x5550oisINN9zQ5a9RdEyCXW9jdUFzlbklmRBCCHEU/vjHPzJu3DjefPNNysvT9yLfsWMHkydPZsGCBTzxxBOsWbOG+fPnM336dO688860cy+++GIqKirYsWMHb7zxBtOnT+drX/sal112GcnkvvngRUVFvPTSS0QikdSxaDTKCy+8wJAhQ7r3xYo0Eux6G7vHHIqNt/R0S4QQQvRBzc3N/OMf/+CRRx5h/PjxPPfcc2mP33HHHSiKwieffMJVV13FqFGjGD9+PPfeey8ff/xx2rkOh4P8/HwGDRrEySefzHe+8x3mzJnDG2+8kXbfk08+maKiIl555ZXUsVdeeYUhQ4Zw0kkndefLFQeQYNfb2FyQjMgCCiGE6EUMw6ClpeW4fx3Nrp8vv/wyDoeDz3zmM1x//fX86U9/St2nvr6e+fPnc+edd+LxtN8WMxgMHvb+5513HieccEJaiAO46aab+POf/5z6/k9/+hM33njjEbdfHBspUNzbKKo5DCsLKIQQotdobW3F6/Ue9+dtbm7uMIAdyh//+EeuvfZabDYb1113Hd/+9rd57733OPfcc9m6dSuGYTBmzJhjateYMWNYvXp12rEvfvGLPPDAA5SVlQGwaNEiXnrpJd59991jei5xZKTHrjey2KG5uqdbIYQQoo/ZtGkTH330Eddffz0A+fn5XHTRRfzxj38EOKoewI4YhtGu7lpOTg6f+cxneO655/jzn//MZz7zGbKzs7vk+UTnSY9db2T3QKQekjGwOnq6NUIIMeC53W6am5t75HmPxB//+EfGjh3LKaeckjo2e/ZsbrzxRn79618zcuRIFEVh48aNx9SuDRs2UFxc3O74TTfdxF133QXAb37zm2N6DnF0JNj1Rja3uTI21iTBTgghegFFUY54SPR4SyaT/OUvf+Gee+5JOz5z5kzsdjsvvvgit912GzNmzOA3v/kNd999d7vX1NjYeNh5dgsWLGDNmjV8/etfb/fYxRdfTDweR1EUZsyYcawvSRwFGYrtjSw20JMQDfV0S4QQQvQR8+bNo6amhi9+8Ytpx51OJ1dffXVqOPY3v/kNmqZx6qmn8u9//5stW7awYcMGnnzySaZOnZp2bSwWo7Kykj179rB8+XIeffRRZs6cyWWXXZYa7t2fxWJhw4YNrF+//pg2shdHT3rseivFApGGnm6FEEKIPuKPf/wj5513HoMHD2732OzZs/n973/P6tWrmTRpEsuXL+eRRx7hvvvuo6KigpycHCZPnswzzzyTdt38+fMpKCjAarWSkZHBCSecwJNPPsns2bNR1Y77hvx+f7e8PtE5itFVMykHiHA4TCAQILTqDfy+buyWb6k1h2FHXQwH+cMjhBCi60WjUUpLSykuLsbpdPZ0c8QAcaifu1T2CIUOG5wlMfRWdg/EmyEuZU+EEEII0TkS7Horq9NcFRuVQsVCCCGE6BwJdr1VW30gWUAhhBBCiE6SYNeb2Vxm2RMhhBBCiE6QYNeb2dzmUGy8tadbIoQQQog+QIJdb2ZzQ6IFWmt7uiVCCCGE6AMk2PVmqgVUO1Stk147IYQQQhyWBLvezpcHLTVQvQGk5KAQQgghDkGCXW+nqODJhdrNEN7T060RQgghRC8mwa4vsHvMgFe5RoZkhRBCCHFQEuz6Cm8eNFdD9UYZkhVCCNHrPPXUU5SXlx/VtX/605/YuHFjF7doYJJg11eoFjPc1W6C8NH9wRFCCNH/nXPOOSiKkvrKzMxk1qxZ1NTUdNtzbt26lW9/+9tkZGQc1fVLlizht7/9bRe3amCSYNeXtA3JVq2BRKSnWyOEEKKXMQyDFStW8NOf/pSKigr27NnDiy++yDvvvMNjjz3Wbc87Z84cLrzwQlwu11FdP3PmTObOndvFrRqYJNj1Nd48aJIhWSGEEO1t2bKFpqYmzj33XPLz8yksLGTGjBmUlJTQ2tp9c7TnzJnDFVdckXYsNzeXP/zhD2nHli5ditPppLS0NO34+eefT1VVFWvXru22Ng4UEuz6GtUC3hyo2SirZIUQQqRZtmwZdrudiRMnAhCLxfj973/P1q1b+cpXvnLIax999FG8Xu8hv3bu3NnuutraWj7++GMuu+yytOMTJ05k/fr1ace+/e1v85WvfIXi4uK04w6Hg4suukh67bqAtacbII6C3QvRJnOVrCvDHKIVQgjRbQzDIJLQjvvzumwWFEXp9PnLly8nkUiQmZkJQGtrK7m5ubz11lucdNJJACxYsIAVK1Zw3333pV172223cfXVVx/y/oWFhe2OzZs3jylTppCXl5d2fMKECWnB7s033+TTTz/l5Zdf7rAdM2fO5JlnnuE73/kOAD//+c/52c9+RnZ2NpFIhF//+tdcdNFFnX4vBirFMGQ870iEw2ECgQChVW/g9/VgoDJ0aCiD3DEwaAqo0vkqhBBdIRqNUlpaSnFxMU6nE4DWeJJxD7153Nuy/oczcNs73wdz/vnnk5+fz8MPPwxATU0N999/P42NjaxYsQK1G/6uuPrqq5k0aRLf+9730o7/4Q9/4Ic//CE7d+7EMAwmT57MlVdeyYMPPtjhfWpqasjLy6O6uprs7GxuuukmLrzwQq699lpefvllfvazn7FkyZIub39v0dHPXZtU9giF8Pv9h7yPpIG+SlHNXSlqt0Cofde4EEKIgWf58uWcddZZlJSUUFJSwtSpU7n33ntZvXo1u3fvBuCKK65gzZo17a492qHYYcOGtZszB2aP3e7du2lubuall16ioqKCe++9N/X4ge0oLS0lGAwSDAYBWLt2LSNHjgRg+PDh2O32Y3pvBgoZiu3LbG6wOvcOyWaC89ApXgghxNFx2Sys/+GMHnneztq+fTuNjY2pIdc227Ztw2q1pgLTxo0bGTNmTLvrj3YodubMmVx11VXoup7WIzhhwgQAVq9ezYMPPshDDz2Ex7NvpOvAdsydO5dLL70Uq9WKYRhs2LCBUaNGoWkaf/rTnw7a0yfSSbDr6zw50LADqtZC0Wnm4gohhBBdSlGUIxoS7QnLli1DURRyc3OprKykpaWF999/nx/+8Ifcfvvt+P1+mpqacDqd2Gy2dtdnZmam5uYdialTp2IYBkuWLGHq1Kmp416vl6FDh3Lfffehqiq33HJL6rGO2jF37txUeCstLSUWi3H22WdTVlbGFVdcIfPrOkmGYvs6RQF/AdRtMwOeEEKIAWn58uUYhsGIESMoKCjglFNO4dlnn+WXv/wlv/zlLwFYt24d48eP79LnVVWVyy67jDlz5rR7bOLEiXz88cc88sgjWK37gvGB7SgtLWXTpk1cfPHFgDkMO2PGDFauXMnq1at55ZVX2LNHKkF0hgS7/sDqNFfKVq6B+u0Q2m3uTtFUaW5DFmno6RYKIYToZo899hiGYaS+6uvrWbJkCTfccENqiHTNmjWpUihd6WAFhufOnYthGHzuc59LO35gO+bOncu5556Lz+cDzGB34oknAlBUVMRll13G/Pnzu7zd/ZEEu/7CnWXuRrFjEWxbCFvfgS1vw5a3YPt70FLb0y0UQgjRw9asWZOa+9aVLrzwQsrKyti6detRtWPu3LlpBY73D3YAl19+OW+99VaXtbc/k3InR6jXlDvpLEOHxp1mWZTBp/R0a4QQotc7VNkJIbqLlDsRnaOo4M4259+11vd0a4QQQgjRjSTYDQQOL8QjZs+dEEIIIfotCXYDhTvTXFgRDfV0S4QQQgjRTSTYDRQOP8SaoUF67YQQQoj+SoLdQKEo4ApC/TYz4AkhhBCi35FgN5A4g+ZQbGhXT7dECCGEEN1Agt1AoijgDEDdVrPmnRBCCCH6FQl2A40rAyL15u4UQgghhOhXJNgNNIoKdh/UboFkrKdbI4QQQoguJMFuIHJlQmut9NoJIYTotxoaGnj44YepqKjo6aYcVxLsBiLVAjYP1GyUFbJCCCGOi127dnHuuecybtw4Jk2axD//+c9ufb6vfe1rfPLJJ9x+++1dcr/j3f6jJcFuoPJkQ2sdVK8H2S5YCCFEN7Narfzyl79k/fr1vPXWW9xzzz20tLR0y3O9/vrrNDU18frrrxMMBvn73/9+zPc8nu0/FhLsBipFBW8+1G6VrcaEEEJ0u4KCAk488UQA8vPzyc7Opr4+fQ/zp556ivLy8mN+rs985jP85z//AeC5557juuuuO+Z7Hqr9f/rTn9i4ceMxP0dXkGA3kNlcYLFB1VoZkhVCiH7inHPOQVGU1FdmZiazZs2ipqbmuDyn3W5n7NixvPDCCwc9f9myZWiaRlFRUerY1q1b+fa3v01GRka3tfNgbrzxRr73ve91+vwD279kyRJ++9vfdlfzjogEu4HOmwstMiQrhBD9gWEYrFixgp/+9KdUVFSwZ88eXnzxRd555x0ee+yx4/KcmzZt4uKLL+b666+ntLS03fn19fVcf/31/O53v0s7PmfOHC688EJcLle3tPNgNE1j3rx5XHHFFQc9J5lMpv6/o/bPnDmTuXPndms7O0uC3UCnqODLM4dkZUcKIYTo07Zs2UJTUxPnnnsu+fn5FBYWMmPGDEpKSmhtbe3W57z44ovJz8+nuLiYm2++GU3T2LRpU9q5sViMWbNmcf/993PGGWekPTZnzpx24So3N5c//OEPaceWLl2K0+nsMDRu27YNRVGYN28e559/Pm63m9GjR7NkyZKDtv+jjz7CZrNxyimnALBjxw4UReHll19m2rRpOByOVGg7WPvPP/98qqqqWLt2bSfese4lwU6AzW0OyVauhXjvmwgqhBCic5YtW4bdbmfixImAGUR+//vfs3XrVr7yla8c8tpHH30Ur9d7yK+dO9vPyV62bBkZGRmMGzcOgN27d/Pd734Xh8PBpEmTUucZhsENN9zAeeedx5e+9KW0e9TW1vLxxx9z2WWXpR2fOHEi69evTzv27W9/m6985SsUFxe3a8uqVatQFIWf//znPPjgg6xatYohQ4Zw//33H/R1z507l8svvxxFUVL3AHjiiSd46KGHWLduHeeff/4h2+9wOLjooot6Ra+dtacbIHoJby40lJlDsnkTze3HUhSzRIpq6bHmCSGEOLzly5eTSCTIzMwEoLW1ldzcXN566y1OOumkQ1572223cfXVVx/ynMLCwg6fMxQK4fP50DSNaDSKy+Xi2WefTTt/0aJF/OMf/2DSpEm8+uqrAPz1r39l4sSJzJs3jylTppCXl5d27wkTJqQFuzfffJNPP/2Ul19+ucP2rVq1imAwyD/+8Q9ycnIAuOKKKw45/23OnDn84he/SH2/cuVKPB4P//znPxk2bFjq+IcffnjQ9oM5HPvMM8/wne9856DPdTxIsBOmtiHZ6o0Q2tP+cYcfBk8Bp//4t00IIXqaYUCie4YyD8nmPuAf2oe2fPlyrr32Wh5++GEAampquP/++7nttttYsWIFqqqyYMECVqxYwX333Zd2bWZmZioQHonly5dz5513cvfdd9PY2Mg3vvENzjzzTG644Ya088466yx0Xe/wHv/973+59NJL2x2fOHFianWrYRg88MADfPOb3yQ7O7vD+6xatYqZM2emQh1AaWkpJSUlqe/3f/0bNmygvLyc888/P+0eV1xxRVqoO1z7AS699FJuvPFGamtrU+37+c9/zs9+9jOys7OJRCL8+te/5qKLLjroPbqCBDuxj80NvnzQEvuOtS2oCO+B3QYUnQYOb8+0TwghekqiFR5t31vV7b5TDnZPp09fvnw5jz76aCrIlJSUcO+99zJr1ix2797NkCFDOO+88zjvvPPaXfvoo4/y6KOPHvL+69evZ8iQIe2e85Zbbkk959NPP82kSZO45ZZb2oWjgxk2bFiHc+YmTJjA7t27aW5u5rXXXqOiooJ77723w3tomsaqVat44IEH0o6vXLmSs88+O/X9/q9/7ty5XHjhhTidzrTzDzV0ezClpaUEg0GCwWDq2Nq1a/npT3/Ktddey8svv8yDDz7Y7cFO5tiJdFYnOHz7vpx+8ytQBOFy2L0U4j3wr1YhhBCHtH37dhobG9sNuW7btg2r1ZoKHFdccQVr1qxpd/1tt93GypUrD/l14FBs23NOmDAhdWzcuHGMGDHikOVODjRz5kxef/31dj1ibfddvXo1Dz74IA899BAez76ge8UVV3DHHXdwyimn8Otf/5odO3a0e/0rV65M1Z878PXPmTOHmTNnph4Lh8Md3qMz5s6dy6WXXorVuq/PbO3atYwcORKA4cOHY7fbj/i+R0p67ETnqBYIDIbGXaBYoOhUsDkPf50QQvQHNrfZe9YTz9tJy5YtQ1EUcnNzqayspKWlhffff58f/vCH3H777fj95lSajRs3MmbMmHbXH81Q7LJly7DZbIwaNSrt+Pnnn89//vOfTs83mzp1KoZhsGTJEqZOnZo67vV6GTp0KPfddx+qqnLLLbekXbdmzRrOP/98nn76aT744AOsVmtqzhtAWVkZDQ0NacGu7fVXV1fz6aefpi14WLVqFRaLJe0enTV37lwefPDB1PeGYbBhwwZGjRqFpmn86U9/Snu8u0iwE52nWs1w11AKqgqDTwGro6dbJYQQ3U9RjmhItCcsX74cwzAYMWIEABkZGYwcOZJf/vKXXH/99QA0NTXhdDqx2Wxd9pwjR45s1xN1wQUX8Oyzz7J7924GDx582Puoqspll13GnDlz0oIdmPPsXnvtNV5++eW03rCmpiY0TeNrX/saYIay0aNHpw2rrlixgmAwmBoS3v/1v/baa5x66qlp8/U6ukdnlJaWpur37X8sFotx9tlnU1ZWxhVXXNHtw7DQh4ZiNU3jwQcfpLi4GJfLxYgRI/h//+//YexXVNcwDB566CEKCgpwuVxccMEFbNmyJe0+9fX1XHfddfj9foLBIDfffDPNzUe+68KhJlD2axabGe7qt8Oe5ZCI9HSLhBBCAI899hiGYaS+6uvrWbJkCTfccAOqav51v27dOsaPH9+lz7lu3bp2x//v//4PXdc7FeraHKzI79y5czEMg8997nNpx9etW5dWS+6uu+5qV0du1qxZNDQ0pF3T9vo7qpvX0T06Y+7cuZx77rn4fL7UsbVr1zJjxgxWrlzJ6tWreeWVV9izp4PFiV2szwS7H//4xzzzzDP8+te/ZsOGDfz4xz/mJz/5CU899VTqnJ/85Cc8+eSTPPvssyxZsgSPx8OMGTOIRqOpc6677jrWrVvH22+/zbx583j//fe59dZbj7g9G7ftTAuVA4rFDr5CqN0Mm9+ELW9D+Uqo2wZNVVILTwgheqk1a9Yc1TDj8XDhhRdSVlbG1q1bO3X+0byW/a8566yzuPbaa4+4nR2ZO3duu5C4du3a1BBwUVERl112GfPnz++S5zuUPjMU+9FHHzFz5kw+85nPAOYKmhdffJFPPvkEMHvrfvnLX/K9730vNRHyL3/5C3l5ebz66qtcc801bNiwgfnz57N06VKmTJkCmBsOX3rppfz0pz/tsD7PwdQ1htmwtYyxJUNTRQ0HFKsDgkPNEBcNm4EOQAEcARhyOnhzDnkLIYQQx9eaNWu44IILeroZHXK5XLS0dL5j4Ghey/7XfOtb3zqiaw/lnXfeaXds7dq1XHXVVanvL7/8cubMmcPNN9/cZc/bkT4T7M444wx+97vfsXnzZkaNGsWqVav48MMP+fnPfw6YY9mVlZVpH3IgEOC0005j8eLFXHPNNSxevJhgMJgKdWDOA1BVlSVLlnDllVe2e95YLEYsFkt9Hw6HAXO6RXVdAxaLyujhQ9pdNyColr117farbadrZmmUytUw7CyZgyeEEL3Ik08+2dNN6DJH81qO5+s/cFXwF77wBb7whS90+/P2mWB3//33Ew6HGTNmDBaLBU3TeOSRR7juuusAqKysBGhXtTovLy/1WGVlJbm5uWmPW61WMjMzU+cc6LHHHksVetzfyGFDKK+uoaK6DouqUjKs8/MI+jXVAv5CaNxpFjsumHRExTWFEEIIcfT6zBy7l19+mb///e+88MILLF++nOeff56f/vSnPP/88936vA888AChUCj1tWvXLgAqowr+7ByiCY3dlTWU7uqBZfC9lWoFTw7UbISmip5ujRBCCDFg9Jkeu29+85vcf//9XHPNNYC5/LmsrIzHHnuM2bNnk5+fD0BVVRUFBQWp66qqqlKTF/Pz86murk67bzKZpL6+PnX9gRwOBw5H++HESFwjoTiI2f1U19UQiu5GUS0MG5TXwV0GIIcPYmGoWAXOINg7X4tJCCGEEEenz/TYtba2ppZrt7FYLKmyI8XFxeTn56dNYAyHw2nFDqdOnUpjYyPLli1LnbNgwQJ0Xee00047ovYE3DZyfQ4G5eXg8AUprWlm0Zpt7KqsOdqX2P9486G5GqrXwUAtDyOEEEIcR32mx+7yyy/nkUceYciQIYwfP54VK1bw85//nJtuugkARVG45557+NGPfsTIkSMpLi7mwQcfpLCwkFmzZgEwduxYLr74Ym655RaeffZZEokEd911F9dcc80RrYhtoygKLruFCSOKcNktbN1ZzoertnKuRaUgJ6srX37fpFrMvWdrNptDsxnDerpFQgghRL/WZ4LdU089xYMPPsgdd9xBdXU1hYWFfOUrX+Ghhx5KnfOtb32LlpYWbr31VhobGznrrLOYP39+WgXpv//979x1112cf/75qKrKVVdd1SWrZEYUFaJpOmV7Kvlw5RbOnaySk5lxzPft82xuc//ZijXgygBnoKdbJIQQnTJga5WKHtFVP2+KIT+5RyQcDhMIBPj4zZfxetLnjRmGwfqtZZRX11KU6WH65LFkBv0HudMAYhjQsAOyS6DodHM7MiGE6KU0TWPz5s3k5uaSlSWjL+L4qKuro7q6mlGjRmGxWNIea8seoVAotefvwfSZHru+QFEUxpUMRdN19tQ18MHKTZxz8hiCft/hL+7PFAV8BVC/A4JDzC3JhBCil7JYLASDwdRiO7fbPTAL0YvjwjAMWltbqa6uJhgMtgt1R0qCXRdTFIUJI4exStPZWRfmgxWbOHfyOHzeAb4q1OY0e+qq14MnF6z2w18jhBA9pK1SwoGVFIToLsFg8KAVOo6EBLtuoKoqJ4wZzqfrtrCzroUPV27k7JPH4nG7erppPcubD41l0FAKOaN7ujVCCHFQiqJQUFBAbm4uiUSip5sj+jmbzXbMPXVtJNh1E1VVmTyuhKVrN7O9uglj+QamTxmPyzmAt9hSLebiieoN5tCsU+YfCiF6N4vF0mV/4QpxPMgs9m5ksViYMn4UDqeD7dVNvLtsPdH99p0dkFyZZuHi2i3mogohhBBCdBkJdt3MarUwZfxIHHY7WytDvLtsA/H4AO7WVxRzjl3dVrN4sRBCCCG6jAS748BmszFlwijsdjtbKhpZuGwDiUSyp5vVc+weMDSo2QDaAH4fhBBCiC4mwe44sdttTJkwErvNxubyet5dvoFkcgCHGm8+NO6C0M6ebokQQgjRb0iwO46cDgcnjx+J1Wpl8556Fq/egqZpPd2snmGxmbtSVG+EeGtPt0YIIYToFyTYHWdul5PJ40vQFYX1u2r4dP1WdF3v6Wb1DE82tNRAo/TaCSGEEF1Bgl0P8LjdTB5XQiSps66smtWbSwfmnoSKCg4/1G2RXjshhBCiC0iw6yEBn5cp40oIRzTWlFayetP2gdlz586E1noI7erplgghhBB9ngS7HpQR8HPCmOHUtSTYuLOaVRu3DrwFFW29drVbIBHp6dYIIYQQfZoEux6WmxVk4pjhVDfH2VHZyMr1WwdenTtXBkTqILS7p1sihBBC9GkS7HqB/MwgY0aOoKYlQU2omRXrtwysHSpUC9h9e3vtoj3dGiGEEKLPkmDXSxRm+RkydAiNUZ3mSJTlazfT3DKAFhS4Ms0VsuE9Pd0SIYQQos+SYNeL5Gf4yC4YRMKwEk8kWbl+K6Fwc0836/hQLWD3Qu1mSA6g3kohhBCiC0mw60VsFhW300EgrwCn20VS01i1cSt1DaGebtrx4c4ye+1krp0QQghxVCTY9TJ+l41IwiAzt4DMoA9dN1i7uZTKmrqeblr3Uy3mbhS1myEZ7+nWCCGEEH2OBLteRlUU/C4bVU1xBg8pIj8nE8Mw2LhtJ7vKq3q6ed3PvXc3irD02gkhhBBHSoJdL+SyWdAN2NUQoaR4CEUFuQBs21nO9p3lPdy6bqZawOqCqg0Q7uevVQghhOhiEux6qQy3jbqmOFWhCCOGDmLEkEIAdpZXsXFbWf/egsybC/EmKP0AKtbIsKwQQgjRSRLseimLquKyW9jZEKE5nqSoMI8xI4agKAqVNfWs21zaf7cgU1TwDzJXyZYvh50fmduOCSGEEOKQJNj1Yj6HlUhCo7SmmcpwFH8gwPiRw1BVhdqGEKs29PMtyJx+CBRB424ofR/qtkF/DbNCCCFEF5Bg14spikKWx05Da4L1FWFW7GqkOqaSVzgYzVAINbX0/y3ILDYIDgHDgJ2LYc+nsqesEEIIcRAS7Ho5q6qS5XGQ63XgtFqobYqxp0UHXzahmEZza4QV67cQifbjor6KAp5s8ORC9QbY8QG01PZ0q4QQQoheR4JdH6EoCk6bhSyvGfLcbhfurHxaNYhEY6xYNwC2ILO5IDgUmmtkaFYIIYTogAS7PkhRFPxOG163C1dmPgnFktqCrDHc1NPN616qxRyaRTGHZstXQCLa060SQgghegUJdn2Y32nDbrPhzMhHsTtIahqrN24bGLtUeLLBkwNVa6FsEUTDPd0iIYQQosdJsOvjgm47KCr2QA4OtwddN3ep2FK6q3/XugNz+7HgUAjvgV2fSLgTQggx4Emw6wcy3DbiGlh8WWTn5ACwp6qWleu39O8Vs2AOzQaGQFOFGe5i/XwoWgghhDgECXb9QFtZlNa4RtTiJie/EFSVUFMLy9Zuoqm5ny+qUC1mvbtwOexcIuFOCCHEgCXBrp9QFIUsr4NYUqcqqmAP5hPVVVqjcVas39z/5921LaoIl0vPnRBCiAFLgl0/oioKQbedbJ8dXbVgCebSkLBQ3xJn3dYytpTu6r/bkMG+cBfaO+cu1tzTLRJCCCGOKwl2/ZBFUclw28nzu8gpKCBq8bCnoZUdFdWs2tDPd6rYP9ztXiq7VAghhBhQJNj1YxZVJdvrZEzxIHzZBewJxaisD7Ns7SbCTS093bzuo1ogWAShXWadO60fB1khhBBiPxLsBgCbRWXEoCzyCouobtGoa4qwcsMWKqr78bZcqhV8hVC3BSpWg671dIuEEEKIbifBboCwKCqDs/0UDR1KY9Kcd7dp+y42b+/H8+6sDvDmQ80Gc4/Z/l7XTwghxIBn7ekGiONHVRTyAm7s1iIqqqqpaQqj6TW0RCKMH1mM3W7r6SZ2PZsbnBlQucbcazZrRE+3SAghhOg2EuwGoAyPA9ugfMprnZRWVVDbHKMm1MopE0rI8Ht7unldz+kHPQHly81evMDgnm6REEII0S1kKHaA8jpsjCjIomT4cOqjBuvLG/j3uyv5dPMuWuLJnm5e13NngQHs/hQayqC/Dj8LIYQY0CTYDWAWVSUn6OXMk8ZSlJtFJKHx/sotvLFkA+FIvKeb1/V8+eYK2R0fwM7F0Frf0y0SQgghupQEO4HFYmFMyTDGFg8iw21nV2UN//1oDeHWaE83rev58sGbB/XbYdtCqFgjte6EEEL0GxLsREpBfi6jS4rJ9Doprw/x2ocrqapr7OlmdT2rEzKGmfPtypfD9nehYYeURBFCCNHnSbATaQJ+HxPGjCQv6KMq1Mo7SzewcftONK0fhh5nAIJDza3HdnwIpe+bO1bI/DshhBB9lKyKFe04HQ4mjR3J9l3llO6uZM22PYTCzYwrGYbP6+7p5nUt1bJv7l1TJYQrzF0rskeaQ7aK0tMtFEIIITpNgp3okKqqlAwdjNvjYWvpLmwNzUTXbWbY4HyGFOah9LfAY7GZZVCSUXMrstBuyBgKmSPAk20GQCGEEKKXk6HYo7Rh8/aebsJxUZidwdjRJUSwE4rEKd1Vwcr1W4hEYz3dtO5hdUKgyCyPUr8dti0wF1nUbYN4a0+3TgghhDgk6bE7Sh9+/CnxRJwzTjmp//VeHSDb50K1DCLUGKKuqR5Nb+bT1RsZWTyY/Jysnm5e97C5zPl3yRhEGmDHHnNOXsYw8A8ye/H6+ecuhBCi75Eeu2Owcs0G5i/4gESyHxb03Y+iKGR5HORlZ+LJKaQxodASS7Bx207WbS4lkejHr9/qMOfgZQwDxWJuTbZ9obn3rKyiFUII0ctIsDtK06edhtViYfuOXbz6+v9oae3/w3Qeh5X8oJdgXiEJu49QNEF1fQNLV2+gvjHc083rXooKrqAZ8Gxu2LPM/Er0w1p/Qggh+iwJdkeppHgoV1x8Hi6ng+raOv792lvU1jf0dLO6nc2ikudzkpGVhSMjn1AMIvEEqzduY+uO3egDoVSIMwDefKjeaO5gEWns6RYJIYQQgAS7Y1KQn8tVl88gI+inqbmF/7z+Njt3l/d0s7qdoihkuO1kB3x4cgrA7kU3DHZX1rBszSaaW/p/7yU2p1kWJbwHyhaZZVKEEEKIHibB7hgF/D7+77KLGFSQRzye4PW332Ptxi093azjwmW3kOl1onqDBHMKsFqttESiLF+3mV3lVRiG0dNN7F6qFQJDINYEZR9C7RaZdyeEEKJHSbDrAk6Hg8tnTGfMyOHous57iz5h0SfL+3+wAZxWCz6njbBmIb9oKFkZfnTdYNvOclZt2EosFu/pJnYvRTFXyap22LUEdn4M0VBPt0oIIcQAJcGui1gsFs6bdjqnTT4BGDgrZgFcNgseh5U9oSgZuQWMGl6ERVVpDDezdPVGqmv7/9xD3JnmvLu6bbD9Pagvla3JhBBCHHcS7LqQoihMOXECF557ZtqK2dbWSE83rdu57VZcNivbapox7G4mTxqN3+smqWms37qDdZtLiccTPd3M7mV1mKtmtYQ57273UnMfWiGEEOI4kWB3lJT4wf/CHjViWNqK2X+99iZ1DY3Hr3E9xOOw4rRZ2FrTQkPUYNK4kQwbnI+iKNTUN/LJqg2UV9X27yFqRQFvLnhyoXYTlL4P4f6/oEYIIUTvIMHuKMU3v4ORPPi2Wm0rZoMBc8XsK/PeGhArZr0OG06ryuaqJrZUN5Obm8PkCaPweczeu82lu1ixbnP/XznbtnNFrMnsvavbBv050AohhOgVJNgdJXvDFkIbFhxyDl3A7+Oqywfeilmvw0aG205FKMraPWFadQsnTRjJyGGDsagq4eZWlq3dzPad5WhaP15FqqjgLzQXVuz8GCpWg9b/51wKIYToORLsjlLUFiBQt5KaDR8SSxw8nLStmB1dUjygVszaLCq5XgcJzWBDRYhtNS1kZ2dx6gljyckMYhgGO8urWLp6Y//ftcKdCa5MqFxpzrtL9P85l0IIIXqGBLujpNk86DYPOXVL2blxOa3xg/fEWCwWzj976oBbMasoCkG3DZ/Tzq76CGvLQ4TiBmNGDmPi6OE4HXaisTirN25j/ZYd/XtxhcMLvkKo2yK7VQghhOg2EuyOQcwWwGFTGVT/EZs2bSAcPXgw2X/FrMWiDqgVsw6rSo7PQSSusb48xKbKJqxON6dMGkNRQS6KolBd19D/F1dYnWZB43A57PgQGnfJvDshhBBdSoLdMWq2ZhGwxChu+JD1m7fR0HrogryjRgxj5sXnD7gVs+rebciCbjvV4Shr9jSyoz5CYWH+wFpcoVrMcJeImOGuYhUcYhGOEEIIcSQk2B0rRSFsyyFPDTGh8W12bVpObTh6yEs6WjG7vWzXcWpwz7JZVHJ8Tpw2K2X1raze3UgoASeMH0CLKxQFfPngCpoLKsoWQUtdT7dKCCFEP9Cngt2ePXv44he/SFZWFi6Xi4kTJ/Lpp5+mHjcMg4ceeoiCggJcLhcXXHABW7akr0Ktr6/nuuuuw+/3EwwGufnmm2luPrYisoai0mDLJ2CJMyH8Pk0b3qaq4dALAg5cMfvG/97nw4+XkUz2wyDTAZfNQq7XgW7ApqpmtlUPwMUVdi8EiyBcAaXvQe1W2WtWCCHEMekzwa6hoYEzzzwTm83GG2+8wfr16/nZz35GRkZG6pyf/OQnPPnkkzz77LMsWbIEj8fDjBkziEb39aBdd911rFu3jrfffpt58+bx/vvvc+uttx57AxWFJls2hs3LiMhqLBtepaZq9yEvaVsxe+LEsQCsWreR/7z+NqFw07G3pw9QFAW/00aGy86exlbWl4eJ6ArjRxUPnMUVqhWCQ8zSKDsXw+Y3YfdyaNgBrfUS9IQQQhwRxegjM9Xvv/9+Fi1axAcffNDh44ZhUFhYyH333cc3vvENAEKhEHl5eTz33HNcc801bNiwgXHjxrF06VKmTJkCwPz587n00kvZvXs3hYWFh21HOBwmEAiw4NFZeJ22Ds9R9QSeWDXNqp9Y0TQCQyaiqIfO0Dt27uGd9xcTjcWw221MP/M0SoYPPWx7+gvdMKhviWO1KBRne8j3OzF0nR27K9ldWYNhGFgtFoYPKaQgNwtFUXq6yV1Pi0M0DIlWMDSwOMDhM3eyyBoBrozD30MIIUS/05Y9QqEQfr//kOf2mR67uXPnMmXKFD73uc+Rm5vLSSedxO9///vU46WlpVRWVnLBBRekjgUCAU477TQWL14MwOLFiwkGg6lQB3DBBRegqipLlizp8HljsRjhcDjt63B01UaTsxCnEcVX9ha1mz4icZgh1mFDBnH1rEsoyMshHk/w5sIPee+jpQNmaFZVFLK9DlRFYXNlE9tqmokkDYqHFLZbXLFszSYaQv2wV9NiB0+22YOXUWzWv9PiUL0etr8HNZulwLEQQohD6jPBbvv27TzzzDOMHDmSN998k9tvv527776b559/HoDKykoA8vLy0q7Ly8tLPVZZWUlubm7a41arlczMzNQ5B3rssccIBAKpr6Kios41WFGIOHMwLHYyqxZRufY9wpFDr370eT3MuvQCJp8wHoC1Gzbz73lv0hjqp3PMOuB32gi4zLp3K3c1smpXiPoYDBs+jKFFhVgtFppbI6zasJU1G7fRGjn0QpU+zeoEdxYEh5nf7/pYFloIIYQ4pD4T7HRd5+STT+bRRx/lpJNO4tZbb+WWW27h2Wef7dbnfeCBBwiFQqmvXbuObPVq3B4Em4dBjZ9Qu3YB5Q0th6zTpqoqp085kctnTMflclJb18DLc+azaWvpMb6SvsNuVcn1OfDYrbTGNbbVNLNmd4iquJVgYRHZ2ZkoikJdY5ilqzeypXQXiUQ/7slSFDPg+QdDaBdsfxeqN0Dy0KV1hBBCDDx9JtgVFBQwbty4tGNjx45l586dAOTn5wNQVVWVdk5VVVXqsfz8fKqrq9MeTyaT1NfXp845kMPhwO/3p30dqZjNh2H3MaJ1JS0b32FTRSOarh/ymiGDC/n8rEsYVJBHIpHgf+99xMIPl/T73SraKIqC3aoSdNvI9TnJ8jpQUahuSqA5A4wbU0J2RgDDMNhTVcuSlevZVV6Ffpj3tU+z2CA41Byy3fUJ7PwIIg093SohhBC9SJ8JdmeeeSabNm1KO7Z582aGDjUXGBQXF5Ofn88777yTejwcDrNkyRKmTp0KwNSpU2lsbGTZsmWpcxYsWICu65x22mnd2v6Y1UvSHmRsYh3W0gV8urWChnAINdGKJd6EJR7CEg+n7UTgcbu54uLzOOWkiSiKwvpNW/n33Depbwh1a1t7I1VR8Dis5Pgc1LfE2RlKUDSkiBPHleB1u0hqGtt2lvPJqg3U1DX2dHO7lysIgSII7ZYdLIQQQqTpM6tily5dyhlnnMHDDz/M1VdfzSeffMItt9zC7373O6677joAfvzjH/P444/z/PPPU1xczIMPPsjq1atZv349TqcTgEsuuYSqqiqeffZZEokEN954I1OmTOGFF17oVDs6syr2UOx6BE+igQbdjVUBv8tKwGnBogCKSlP2STTlTjbLX+xnd3klb7/7Ea2RCFarlXPOOIUxI4cf8fP3B+YK2hhOm4WRuT4y3DaqauvZvrOc+N4h2YDPw4ghg/D7PD3c2m5kGNBcZZZEyRsPuWPBYu3pVgkhhOhiR7IqttPBbu7cuUfckAsvvBCXy3XE1x3MvHnzeOCBB9iyZQvFxcXce++93HLLLanHDcPg+9//Pr/73e9obGzkrLPO4umnn2bUqFGpc+rr67nrrrt47bXXUFWVq666iieffBKv19upNhxrsAOw6HFsepyEbhDXwG6zkOFx4LdqWJOtNGVPIpx/JobFnnZda2uEt9/7iN3l5kKP0SXFnHPGKdhsR9eOvswwDBpaE6gqlOT4yPM70DSNXRXV7CqvTg1152ZlMHxIAU6Ho4db3I2iYYjUQuYIKDjBLJEihBCi3+iWYKcepg5buxsrClu2bGH48P7Vq9QVwW5/hgHRhIZhgM9lJd+p4U020poxmobCc9Ft7gPON1i2ah2fLF+NYRhkBP1cNP0ssjMHZo2zcCRBQtcZmuUm3+/CYVWJxeKU7q6gsqYeAFVVGJyfy5DCXKzWftqjpcUhXG6WS8mbAP5BcIR/ZoUQQvRO3VbHrrKyEl3XO/XldrsPf0OBooDLbsFhUwlFkpSGoUbJwNWwkaydb2CNNRxwvsKUEycw69IL8HrcNDSG+ffcN1m3ceshV9v2V36XDafVwrbqFlbtamRPKIJitTJmxFCmTBxNRsCHrpvbky1ZuYHyqtr++T5Z7Gb9u2gTlL5vLqxoqe3pVgkhhDjOOh3sZs+efUTDql/84hePagXpQGVRFTx2C7oBu8M6ZYkMrKEdZJX9F3tLRbvzC/NzuXrWJQwtKiSpaby7aAlvv7uof267dRhtiyo03WBTZRNrdoeoDEVxOF2cMLaEiaOH43Y5SCSTbC7dxdLVG6jrjwtQFBX8BeZOFQ07YNsCKF8JsX5YzFkIIUSH+sziid6iq4diO5LUDKJJHZcFhtoasXuDNA6aTtRf3O5cwzBYsWYDS5atQtd1An4f5007ncL83A7u3P/phkE4kiSmaWS47AzKcJHpsWNRoLyqlh27K1MlYzICPooHF/TfBRaxJrPXzhWAnLGQWWyWTBFCCNGndMscO2E6HsEO9p97Z1BkC+GwO2gtOod49nhz/PYAFVU1vP3uIpqaWwCYMHYUU6eciN0+MP8i1wydcCRJQtPJcNspDLrI8tgxdI2yPVXsqapB180f/aygn2GDC/B5++H0AcOA1jqIhyEwBHLHgS/v8NcJIYToNbo92N10002cffbZ3HDDDQCUlZWxfv16zjjjDAKBwFE1uq84XsGuTVIziCU0AkYIh6pRnTmFeOGp5Phc2K3pI+mxWJzFS1ewbtNWALweN+eeeSpDiwZ1ezt7K03XCUf3Bby2HrxEPM6O3ZVU1Tak5txlZwQYNjgfr6cfBjwtAc2VoFggZzRkjwJ7P3ydQgjRD3V7sMvPz+fVV1/l9NNPp7GxkZKSEpqamsjOzmbBggWMHj36qBvf2x3vYNdGN8CWCOFItrDFNobtvimMGZTJ0Kz2w4i7yytZ+OESwk3NAIwqKeas007GtbeW30Ck6TqhSBJN1wm47GR77fhdNlQjye7yKqrrGlMBLyczyLDB+XjcXVeqp9eINUNLNXhyIG+c2Ysnq2eFEKJX67ZVsW1CoRCDBpm9QP/+97/Jz88nHA7z+c9/ngceeOBobikOQ1VAswdIOoNM1DcyvnkRW3aWUxmOtjt3cGE+1/zfZzhxwhgURWHz1lJefOV1tmzf0T9XhHaCRVXJ9NjJ8NhpjWtsrWlm5e5GNtdGcWfkUjJyOFkZQQBq6htZunoj67fsoKU10rMN72oOL2QMg0Qr7FgEOxdDa31Pt0oIIUQXOaqiXkVFRZSWllJUVMQ///lPbrjhBhwOB7fddhvTpk3r6jaK/cRVN2GbhZLEdrKbqqjeWEx0+Ak4s4rSdquwWa2cedpkRhQP5d0Pl1DX0MhbCxexZVsZZ59xSv8cbuwEq6oSdKuAjYSmE4lrbK9tRlUg4M5gaDCDcEMDDY2NVNc1UF3XQG5WBsMG5+N29ZMeT0UFbx4ko1C/HZoqzaHZ7BKw9cNeSiGEGECOaij20Ucf5eWXX+byyy/n8ccfZ8OGDZSUlLBx40YmT55MS0tLd7S1V+ipodh2DB2X1owab0KxOvDkFZPMGU/UNwzDkr7LgqZpLFu1juWr16FpOna7jTNOOZlxo0egdLAQYyBK6jpN0SRxTSfgshGwQ3NjPY2NYcCsH5ibFWTY4AJczn62i0U0ZC6w8OaaiysCRTI8K4QQvciRDMUeVY/dAw88gGEYvPXWWzz++OOUlJQA5n6uQ4YMOZpbiiOlqESsfgyLn0SsBWv1NrJbdmI4/CTtPpL2AJo9gGZ1o1ndTJ1QzIjiISz84GOqaup4d9EStpaWce6ZpxLwyxZUVlUlw21PlUsJRTS8jgzyBweJNDUSCoWpqm2guq6RvOwMhg7K7z8BzxkAuxdaamDHh5Ax1Ax47syebpkQQogjdEQ9dg899BAzZ85k8uTJHT7+xBNPEI1GefDBB7usgb1Nr+mx249uQGtcI8OpMtidwGIkUfQEiqEBZo9cwpVNY+E5RNyDWL1+E0uWrSaZTGK1Wjn15EmcMH70EW8b15/phkFzLEkkrpHjs5PlVKmrqaFuvx68/JxMhg7K61/70Caj0FwFNg/kT4CMYrD0023YhBCij+i2VbE33XQT8+bNw263c/nllzNz5kzOO+887Hb74S/uJ3pjsAPQdINIQifLYyfTY8duUdsyHRg6jtYqdIudUP5UWjInEGpq4d1Fn7C7vBKAvJwspk87PbWAQJg0XaeuJY7TZmFYlgeXkmTnnirqQ/sCXkFOFkMG5favgNdaB7GwGezyxkvvnRBC9KBuLXei6zqLFi3itddeY86cOVRUVHDhhRcyc+ZMLrvsMjIz+/dfAL012AEkNINYUsemKrjsFnxOGx6HBZtFBcPAGmtA1aI0Z00inD8VXbWzYfM2Fn2ynHg8gcWicvKk8Zw8aTxWq6WnX06vEo4miCU0CgIuhma7iUeilO6uoCFkbtelKAp52RkUFeT2nzIpWhyaKqT3Tgghethx3Xliw4YNqZC3bNkyTj31VK644gquvfbaVEmU/qQ3BzswNxpI6gYJTTdr31kUPHYrAZcNr8OKmmzBFq0j4h9OaNA5JB0ZNLe08v5HSynduRuArIwg5551Gvm52T38anqXeFKnIRIn4LJRnOUh02MnFG5mx57KVMADyAz4GTIol2B/mbvY1nvnzYfAYPBkgytDticTQojjpMe2FKupqWHu3LnMnTuXadOm8Y1vfKOrbt1r9PZgtz/DgISuk0gaqApkeOxkex1YSeJoqSDuzCISHEXcnU/MlcuWXbW8//GnRCJRFEVh4thRnHLyxP41xHiMdMOgoTWOqsDQTA+FGS4sikJTcyu7Kqqpqd9X6NjncTOkMI/szEDfX32sJSDSYNa/Uy3mggv/IDPkOXxmr5705gkhRLeQvWK7UV8KdvtrG6b12C3k+Bx47Cq2aD2WZARDVdGsHuKeAhqsubyzoZ71ZbUAuJwOTjl5EuNHl8jiiv20xJI0x5IUBp0MzfLgsplD15FojN0V1VTU1KX2onU5HRQV5JKfk9k/3kMtYfbgxZvBAGwOsDjN4seujL1Bzw2uoNTFE0KILnBcgl00GmX16tVUV1ej63raY1dcccXR3LJP6KvBDszVs9G4hqoqZHrsZHnsqKoCuoYl2YIl0Yyia+g2D2u0Yt7a3Ep9yNyWLCsjyBmnncyQQQU9/Cp6j4SmU98SJ+C2MTzbQ4Z73yKiRCLJnqoa9lTWkkgmAbNo9OCCHApzs7HZ+knvlqFDMrb3K2r+FwMUxSyh4skBXz44g2bQU2XuphBCHKluD3bz58/n+uuvp7a2tv0NFQVN0470ln1GXw52sHd4VtOJawZeh5VMjx2vw7JvqNAwsMYbscSbafUOZVG4gI/W7yEaiwEwrGgQZ5x6EhnBQA++it5DNwzqW+JYVYVhWW7yg+bQbBtN06isqWdXRTXRWBwwtzcryM1icEFO/x3m1jWzRy/WDHoCLHazJy9QBIFBZs9eXx+eFkKI46Tbg93IkSO56KKLeOihh8jLyzvqhvZFfT3YtWnrvUMBl81C0G3H77SaPXiAosWxt1aj29xU+yfx7m6FNRu3o+s6qqoyadwoJp84of8GkyPUHEvQEtfI9TooynQTcKX/bBiGQU1dIzvLq2jeu/9s224WRQW5/X+Lt2QMYk0QbwKr01yEERxqbm0mc/OEEOKQuj3Y+f1+VqxYwYgRI466kX1Vfwl2bTQdYkkNwwCHTSXothNw2rBalLTeu6h/GLusxSxcV0lpeR0g8+8OlNB0Glvj2CwqhUEXgzJcZj3BAzSEmthZXtVuJW1RYS4ZgX6ykvZQ4i0QqTeHcT05kDnC7MWT+XhCCNGhbg92N910E2eeeSY333zzUTeyr+pvwa6NbpjlPJK6gd2iEHDZCbhsOGyq2XsXqQFAs7rZ1OTm7c3N1ERUNKuLzGCQM0+fLPPv9mqNJwlHkwRdNooy3WR77agdDDs2t7Syszx9Ja3X7aKoIJecrGD/D8tawgx4iRZwZUJWCQSHgN3T0y0TQohepduDXWtrK5/73OfIyclh4sSJ2GzpAefuu+8+0lv2Gf012LUxDIhrOgnNwKoq+J02Am4bbpsF0LAkzEUWRjLB8j0x3tvaTKtmwbDYGDYon2knjyGYmUXCkUHcXTBg51HphkEokiCp6WR57WR5HfgcZsHoA0NeNBZjV3n6Slq7zUpBbhaFudk4HP18ZxdDN0upxMJmGZXMEeZ+tY4B0HsphBCd0O3B7o9//CO33XYbTqeTrKystBpdiqKwffv2I291H9Hfg12bthp48aSBRQGPwyxy7HZYsarmMK2qRYm1NvPRpmpW7Kg3598pCpOH+jljdC5KVjEtGeOJ+oaAOjDnUSU0naZokoRu7gjicVjJ8trxOW34HDZsln1/dhKJJOXVtZRX1RKLJwDzz1N2RoBB+dn9p+DxwRgGRBvNL7sPMovNWnnuLOjvvZdCCHEI3R7s8vPzufvuu7n//vv7/3DRAQZKsNtfUjOIazrG3p0svE5zFwuP3ZJabFHXFOXdteVsrwwB4LYanDvcyQlDAiS9hbRkTiASGI5hGbiLLRKaTiSuEU1qqHsXrWR67ObCFZctNR/PMAxq60PsqaqhMdycut7jcjIoP4e87Awsln5cNsQwIBoyA55qA1+uudDCVwD2fr7IRAghOtDtwS4zM5OlS5fK4okBEuzatJVKSWh7hwutKj6nlUy3HZvVDCWlVWEWrtlDXVMUgCyPjRmjXQzPcpBwZtOSOZ5IcCSazdtjr6M30Awz5EXiGjrgtlvIcNnJ8NjJcNtTPXktrRH2VNZSVVuPtrdepEVVyc/JZFB+Dm6XswdfxXGQjEJrA2hRcPghMASCReaOFwN0mF8IMfB0e7D7+te/Tk5ODt/5zneOupF91UAOdvvT9wt5DqtKttdBwGVFURR03WBlaS2LNlYSjZvFeYfleDhnuJMin0LS4ac1YyytwdEknVk9/Ep6nm4YRBIakZiGhkHAZaMw4CLLa0/14iWTSapqG9hTVUNrJJa6NiPgY1BeNlkZ/WDbskMxdLNcSlsvXmAQZA43y6VI0WMhRD/X7cHu7rvv5i9/+QsnnHACkyZNard44uc///mR3rLPkGCXzjAgltTRdLPgcY7Pgcu+d3uteJLFGytZsb0Wfe+P2fA8H2ePcFPkTqLZPEQCJbRkjCPuzpceGMyQF44kiWkafqeVwqCLbK8jbZi2MdzMnsoa6hrDqdW0ToedwtxsCnKz+s+uFgeTiEBrrbmdmT/fXGzhLwSL/HkUQvRP3R7spk+ffsjHFy5ceKS37DMk2HVM0yGa0LCoChluO5leu7nIAmhojrF4UyXrdzZgYP64leQHmFbiY5ArimFx0hocSXPWCSRcOT35MnoN3TBojiaJJDW8DiuDAk5y/M60unjRWIzyqjoqqutS25apqkJuVgaD8nLwefv5fDQtDi215n+9eZA33gx48g8EIUQ/c1z2ih2oJNgd3P7blTmsKhluGwGX3Sx2DNQ3R1m8sYoNu/YFvFGFQaaV+ChwRNCtbloyxtGcPQnNLluWwX4BL6HhdXYc8HRdp7qugT2VtTS1tKaO+71uCnKzyM3q54st9CQ0V5k/gNkjIWcMOAb2HE4hRP/S7cHuxRdf5Nprr+3wsW9+85s88cQTR3rLPkOC3eG1Dc8mdQO7VSXDZdbCs+0NI7XhKIs3VbJpdyMGBgoKowcFmDbCQ549iuYI0Jw5iZbMceg2KVYL6QHP57RSmOEiZ78h2jbhphb2VNVQU9+YqolnUVVyszPIz84k4O/HgSfeagY8d6bZexccKmVShBD9QrcHu2AwyIsvvsgll1ySdvzrX/86L730EhUVFUd6yz5Dgl3n7V/s2G5RCLrtBPcLeNWhCIs3VrK5vBEABYWxg4NMK3aS44iTdGTQkjmB1syxA34VbZsDA16e30nAZcPntKYVPo7HE1TW1FNZW5e22MLtclCQk0VediZ2ez/8+TV0c3g2GTEXV+SOBVdGT7dKCCGOSbcHu9dff53rrruOefPmcdZZZwHw1a9+lVdeeYV33nmHMWPGHF3L+wAJdkcuLeBZVbI8doIuW6oGXnVjK4s2VrK1wqyBpyoK44qCTBvmIMueIOkImgEvYwya/dA/0AOFbhg0x8yA17ZDSI7fQcBlw2O3oLAv5IXCzVTU1FFT15gqmaIoCllBPwW5WWQG/f1vRW0yCk2V5vZkOWPMkGfr56VhhBD91nGZY/fCCy9w11138fbbb/PHP/6ROXPmsHDhQkaNGnVUje4rJNgdvf2HaN12C1kecweGtkxR2WAGvLYix6qiMGFIBmcNc5Jli5FwBGjJGE8kYzRJh/TCtEloOs2xJPGkbs5t9NjJ9joIum1pQ7XJZJKa+kYqqusIN++bi+ew28jLzqQgNwuXs58VkI40mF++fLP3zj9YhmeFEH3OcVs88fTTT3PvvfeSk5PDwoULKSkpOdpb9RkS7I6dbpgraAG8DiuZHjtuuzUV8MrrW/hoQyWl1WHAnCM2cUgGZw5zkGGNodu8tAZG0poxRsqkHCCa1GiOJtEMA6/dSq7fQabHgc+Z3ovX0hqhorqOqtqG1IpagKDfS0FOFtmZgf6z4ELXoLka9ARkDDMDnjuzp1slhBCd1i3B7t577+3w+D//+U9OPvnktF0opI6d6AxNN4gmdFQF3HYrQbe5VVnbEO3uumY+2lBJWU0TYAa8E4ZlcvpQN1mWVnSLg6ivaMDvR9sR3TBoiSeJxM2h2qDbRn7ARZbHnjYXT9d16hrCVFTXUR8Kp45bLRZyszIoyM3qP2VTElFoqQKrC7JGmMOzThnaF0L0ft0S7A5Xuy51Q0VhwYIFnTq3L5Jg1/WSukE8ae5F67CpBF12/E5rapuynTVNLNpQye46c99UVVEYMziDU4u9DHZGMVCIeocSLjhD6uB1IJ7UaYomMDDI8TkZFHQRcLX/2Y3F4lTW1lNRXUc0Fk8d97icqbIp/WLBRTQErfXg8EFWCWQWS3kUIUSvJnXsupEEu+6jG2YISeoGNouC12HFY7fitluwqgpltc18vKmSXbXNqWuG5fo5ZXiAUd5WdHuAcN6ptGSMk22mOpDQdBpb41gtKgUBJ4VBFy5b+/epbXeLypq6tLIpiqKQ4feRl53R94dqDcMMeJF6cAUhe5RZHsXeT3onhRD9SrcEu9WrVzNhwgTUTk48XrduHaNHj8Zq7V/DYxLsul9boeOEZv5oWlUFl92C12HFbbfS0Bxl6dbqVB08gFy/i6lD7YzLtRPLHE0o/ww0hxQ57kgkrhGOJfDYLRQGXPhcNtx2S7uaeLBvj9qq2vq0BRcWVSU7M0BuVkbfXlVrGObiimijGfCCQ83dK9zZsshCCNFrdEuws1gsVFZWkpPTuaEuv9/PypUrGT58eKfO7ysk2B1fhgFJ3Qx5ugE2i0Kuz0nQZaOxNcayrTWsLqsjqZllPAIOldMGqYwfOZRo0ZlE/SMwZO5dO4Zh0LS3XIpFAbvVgstmMculOKy4HZZ2ZVMi0RhVtfVU1TYQie6rjWezWsnNCpKXnYnf10cLShu62YMXDZlzNT055hCtL98smSKEED2oW4KdqqrceuutuN2dG6p4+umnWb9+vQQ70WXayqXohkG210G214GiQCSeZOX2WlZsr6UllgDDwK1EOWmIjxNHDcGWM5y4u4C4O4+kPSiraA+gGTrxhEEsqZPQNHTAYTHLpuT4zNp4He1wUVVbT019I/HEvlW1LqcjFfLcrj5aNy4ZM3vxkhGw+8BfYAY8V6Y5L09+foQQx1m3BLtzzz33iIdbXnjhBQoKCo7omt5Ogl3PiyfNHrwMt51cvwPL3lW0SU1n/a4Glm6ppr45CrqGjQTj8x2cNjxAVjBA0pFJ1DeEuCuXhCsbzSZ/UXekrWyKbhh47FZyfA4yPfZ2O1wYhkFDqImq2npq60OpAsgAPo+bvOyMvrvowjAgFja/9CTYPODJMmvhuTPNHS3kZ0cIcRzI4oluJMGud0hqBtGkjt9pJd/vTK2gBTNsbKsMs3RLdWolLQaMyHFw+jA3xQEVVBXd6iLhyCDmLSLhyiHuzpetyw7QVjalNa5hUxV8h9jhQtM0autDVNc1UB9qou1Xi6IoBP1e8rIzyMkM9s1FF4YBiRaIhkGLg9UBgSJzuNaTK/PxhBDdSoJdN5Jg13toOkQSGm67hRyfA5fNkuq9a1Ne38LSLdVsKQ+lFlrkBd2cUpLNuFw7Vj2CqpmlPTSrh6iviJhvGDHPIDS777i/pt4sntRpie/b4SLgspHjcxJwW3Fa08NaIpGkuq79ogtVVcjOCJKTGSQz6OubIQ8g3gKtdaCo5lBt5gjwFYBF5nMKIbqeBLtuJMGudzEMaI1rKMq+1bNuuxWnzYLTqqaKHTc0x/h0azVrd9anFlr43XZOLM5mwtBMPHYLlkQz1ngzoKFZvcS8g4n6i4n4izEs/WyrrWMUTWq0RJMkDXN7uHy/kxyfA4+9fbCJRGOpkNca2bfowqKqZAb95GQGycrw982Ql4xCSy0Ymtlzlz3S7MmTgCeE6EIS7LqRBLveSTfMOXZJ3Vw9qypgs6gE3TaCbjvWvQGvNZZkZWkty7fVEImbk/4tqsqowgAnDs9mUKYHBWNvyGsCDBKuHJqzJhIJjEK39tEFAd1ENwxa40la4hpOq4Vcn51cv6vdFmZtmppbqa5roKa+Ma0IsqoqZAUDfTfkaQmzBy8ZhcBgyBlt9uDJHDwhRBeQYNeNJNj1DZq+r0yK06qS5XXgd+7briyR1Nm0p4EVpXVUNrSkrsvxuzhxeDZjB2fgsFlAT2KL1aNqMRKOLFqyJtIaHI1uk0K2B2qNJ2mOJbFZFHK8TnL3zsVTDxJumppbqalvpKa+Ma18iqoqZAb85GZl9L2QpyWgucr8/4xhZuFjT1aPNkkI0fdJsOtGEuz6FsOAaFJH180hQ3Nlpy2tI6WyoZWVpbVs2N2QGqa1Wy2MK8rgxOHZ5Phd5grbWAMWLULCnkFL5jgigRKSTtlM/kDRpEZTJGHuVOGxke93EXS3L5myv8OFvLaevD5T8DwRgZZqc5FFZgkEBpnlUmSIVghxFLo12D3//POHLXty/fXXH8kt+xQJdn2TbkA0oQHgsVsJum14Hft68MCsh7duZz2rSuvMcil7DcrycmJxNqMKA1hVsMYasCRa0G0eIr5iIhmjiHqKZBuzAyQ0naZokoSm49u7ejnLa8fdwTy8/TW3mCGvuq4fhLxYkzlEq1rAGTSHaT054M4Cq72nWyeE6COOJNgd8W/GPrt1kBjQVAXcdguabpbvaI4lcdosBNw2/E4rNouKy25lSkkuk0fksLO2mZXba9laEWJPXTN76ppZ6LAxcWgmJwzLIuDNxJJoxtOwAU/jRuKufFoyxxIJjEC3yjAtmHMcMz12dMOgOZpkS00zuxosZHpsZHk7LnwM4PW48XrcFBcVpkJeTX0jrZEYtQ0hahtCqKq5b21OVpCsYACbrZeGPIfP/NIS5q4WFavMlbQOPwSLzMLH7mzpyRNCdJkj7rGbPn36oW+oKCxYsOCYGtWbSY9d/6AbZvmOpG5gsygEXGYPnstuSZsT1hSJs3pHHat31NEcTQCgoFCc7+ek4myG5fqwGHFssUYUPU7SkUWzzMPrkGEYRBNmyRTNMPDYLWR57WR6HPidttQCl4NpaY2kFl7sv7pWURT8XjfZGQGyM4O4nL18BbOeNOvhxZvMkOfKMOfjefOk6LEQokMyx64bSbDrXwzDHDKMawaqAnaLitdpxWM3Q15bXTxdN9haGWLl9lrKappS16eXTFGxRRuwJFtJODNpzpxIa8YYdJvsNXqgttW0rXENVQGvw0auz0GGx47H0fGK2v21tEaoqW+ktj5Ec2sk7TGPy0l2prnTiM/r7t2jDFrC3L4s3gI2J3hzzXIp3jxwSLFsIYRJgl03kmDXf7WtpE1q5h8Jm0XF47Ditltw2SzYrSqKAvXNUVaV1rF2Zz3RvSVTVEVheL6fCUMyGZ7nwZkIYUm0knBk0pw1kZas8RgWKZXSEU3XaYlpRBIaDuuh96jtSDQWo64hTG1DiMZwM/v/SrPbrGRnBMnODBD0e1F78w4RiVaINJolUxw+8A8yF114csxFGEKIAavbg11DQwN+v1mGoLy8nGeffZZoNMrll1/OtGnTjrrhfYEEu4GhrS5eYm/IU1XF7M1zWHDZrbhsFgzDYOOeBlYeUDLF7bAxdnCQCUUZFLqiWBOtxDyFhHOnEPUXm8NvokOd3aP2YJLJZCrk1TeG0/aubSuInJ0R6N2LLwzDXHQRC4GugysIwSFm0HNnylCtEANQtwW7HTt2cMUVV7Bu3Tpyc3P561//yo033kh5eTkAqqry8ssvc+WVVx7bK+jFJNgNPIYBmm6Q1A00va03z9w31ec0e/Rqm6Ks39nAup31tMQSqWtzAy7GFwU4ISuJx2GlNTiSptxTSDqlttmhHLhHbcBtI9fnJMNtx2HtXDDWdZ3GcDO19SHqGkPE4vs+l7b9a7OCfrIzAzgdvbRHTNfMRRfR0N79aQdBcKi56MIiv3+EGCi6Ldh9/vOf55///Gfqe4fDQSwWSzvnjDPO4MMPPzzCJvcdEuxE27y8hGagKOC0WfDvXXxhUxR21DSxdmc9WytCqR4jVVEoyXFyYq7BsEF5RHJPoiVrvKyg7YR4Uqc5liSh67jtFrK9drI8DvwuG5ZO9l4ZhkFzS4TaBnNeXkskmva41+0iK8NPZsCP3+fpnfPyEq1m6RRdN4seZxSDvxCch/4lL4To+7ot2BUWFlJVVcVNN93Enj17mD9/Pm63m08//RRd1znllFOw2Ww0NjYe62votSTYif1pOsQ1HU03sKoKHocVv9OKx2ElntTYuLuRtTvr9w3VGuCxJJiYZ2PM8EH4hp1ANDiShDNHhtgOQzcMInGNlngSVQG/005uwEGGy3bY2ngHikRj1NY3UtcYJtTUkjYvz2a1khn0kRnwkxn0975SKnrSXHARazYXWASHmkO1nmz5GRKin+q2YGe32xk3bhwrV66ktbUVr9fLlClT+OSTTwA45ZRTWL58OZqmHdsr6MUk2ImOGAYkdYOEpmMYYLeq+J1WvA4bLruFuqYo63bWs35XvVk2xTBQtSh5Hhg/NJuSUeNQCiYQ9Q3FUOXn6nASmk5LLElM03FaLWR57GR57fg7ueAi7V6JJHWNIeobm6hvDJPc7/eXoij4PC6yMgJkBvz4vL2oh7VtLl60AVSbuTdtZrEM0wrRD3VbgeJkMonbbf5ia/vv/hOQe+1kZCG6maKY8+5sFguGYfbi1TTHqWuJ47JZCLjtnDm2gGnjCthR3cS6XfVsKQ9REdWp3NDIe+sWMCL3Y8YOL6Jw5EQ03yDi7nwplXIQNotK0G1P1carCEUoD0Vw2y3keJ0EPbZO1cYDsNms5OdkkZ+ThWEYhJtaqGsMU98Yprk1Qri5lXBzK6W7KrDbrKmQlxHw9uzvPEUxh2GdfnMLs/AeCO00V9HmjDHLpvTmVcBCiG5xRD12qqricDgoKCgAzMUU+39fXl5OIpGQHjsh9tJ0g3hSRzPAblHwu8zA4bRZiCaSbNrTyNqyeioaWsDQUbUYLovGqDwPo4bkUDBkBInAMOLuQhLOLBlqO4QDa+N5HFayvWbxY4/D2ulFF/uLxeLUh8LUNYRpCDWlrbJVFIWAz0NW0Byy9bhdXflyjo6ehJZa0GLmHLzcseZKWiFEn9ZtQ7GqqqIoCoe6RFEUCXZCHGD/QsgWBdx2KwG3Dd/e/WrrmqKs3VnP+p37hmoVPY7HojEmz82YoixyhowimjmaqG8IhqWXruLsJTRdpyWupfYHdtos+J02gh4bXrsVt92KzXJkIVnXdUJNLdQ1hKgPhdN2vwBwOuypkBf0e7FYenDv4GQUmqvA6oLsUZBdArZeEDyFEEel24Ldueee26nVYgsXLuzsLfuctjf3H//vOoo98Z5ujuiDkppBfO9cPIdV3btfrQ27VcUwDHbXtbBxdwOb9jQSiSfBAEVP4LcmGVPgYeSwQQSLTyQWHLG3F0+G2w5FNwyiCY1oQieh61hUBadVxW03VzO7bGZvnstuOaL5eZFojPpGszevsakJXd/3q7StN88csvXh9bh6ZqVtNGSupPXmmr13vkKw2o9/O4QQx0R2nuhGbW/uiK//ndlZG7jItYlOTOMRop20/WpVsy6e32X2JimKuY3ZzpomNuxpZEt5I7GElhquDdp1Rg/OZFTxYPyDRpH05BN35aDZ/DJcexhJXSeW0IlrOgltbzkaVTFDtstGptuB32UWoe4sTdNoDDdT1xCmPhQmGkv/R5/NaiUj4CMj4CUz4MfhOI7hStegpcbsxfNkQ1aJWSbFLvM3hegrujXY/eUvfznsOddff/2R3LJPaXtzi+55GdXhZpytktv9H5FvbTr8xUJ04MC6eG67lQy3WRdP3fuvBk3X2VHdxMbdjWypCJFIaChGAkVLkOlSGFvoZUxRNsGcfKLeocS95uILQ5UFTZ2h6TrRpE4krqEZhhnynDayvQ68TjPkWY7gX3BtvXkNoaZ2c/MA3C5HqjfvuA3b6prZexdvMRdcZA6HYBG4Mrr/uYUQx0SCXTdqe3Mf+N63+HdyKjHDhoME1/pWcIlrg/TeiWOi6QaxpDlM67RZCO4dprXuNx8skdTZXhVm057GfUWQDQNFT5LrURiXb2dMYRB/Vi4R/3Bi3sHE3QUYFhmC6wzDMD+DlniSpG5gt+zdTs5pw++04rRZcO7dP7gzBZLbVto2hM1yKk0tkbR5ysd92NbQ9+5m0WjOu/MV7t2TNhfsvaicixAipVuD3fTp0w99Q0VhwYIFR3LLPmX/xRMt1gyeCZ/BuoS5KnisrYrb/YsokN47cYx0A2JJs/Bx22pan8OKa+8wbZtYQmNbZZiNuxvYUb1fz5CuUeBTGJtjY1SBn0BmFtFACVHfUOKeQunJ6yTDMEhoBnFNS30eBmC3qNgtCr69q5xdNgtOm4rTZjnsnrbJZJKGUDMNoaaeH7aNN0Ok0VxN6/CZAc9XaJZMkbl4QvQa/X6O3eOPP84DDzzA1772NX75y18CEI1Gue+++3jppZeIxWLMmDGDp59+mry8vNR1O3fu5Pbbb2fhwoV4vV5mz57NY489dkS1qNre3Ce/Mo3TR+ejG/B2ZDR/a55M1LBhJ8m13hVc4t6ARelzb63oZdpq4iX3274ssHf7MvsB5Tsi8SRbK0Js2t1IWU0TetsfbUMny2kwJsfKyHw/ufkFRIKjiPmGEHfnyeKLI5QW9hI6ScNAwQx7LruFPL+TTI+903P0Djds63I6yPCbQ7ZBvxe7vRtW4xv63mLHjeb3jgC4s8CbYwY+h19684ToQf062C1dupSrr74av9/P9OnTU8Hu9ttv5/XXX+e5554jEAhw1113oaoqixYtAszJzSeeeCL5+fk88cQTVFRUcP3113PLLbfw6KOPdvr5295cgLPGFXDHpRMpKQxQrXl4NnwGa+KFAIy2VXOHfxGF1nDXvgFiwNq/Jp5t7/ZlXocVt8OC7YDVnC2xBFvLQ2ypCLGzpjmtJ89n1RidY2dkYYCCwUOI5p5IJDBCdrw4BvresBdNaEQSmlko2Wcnx+vE77Ki0Pk9bcNNLdSHzKB34LAtgMflTM3NC/q7oUiynjRDXqIVtMTe6tsecAXAm2/25rkywCK9vkIcL/022DU3N3PyySfz9NNP86Mf/YgTTzyRX/7yl4RCIXJycnjhhRf47Gc/C8DGjRsZO3Ysixcv5vTTT+eNN97gsssuo7y8PNWL9+yzz/Ltb3+bmpoa7PbODTu0vbmqYg6XKQpcMnkot148noIMD/+LjOSvzVOIGHZsJLnKs4ZL3Btwq4lue1/EwGJuX2YutjAMsFoU3Pa9Ia+tZMcBw7WlVWG2VoTYVhkmntxbZ1JP4lLilGS7GFY8hNxxZ6Fnj5aAd4wMw6B17562VlUhw20n2+cw5+bZVBxWtdNBL5lMEmpqoSHURGO4mebWSNrjiqLgdbsI+r1kBHwEfJ6uX4iha+bOFokW87+qFVxB8A82e/RcmTJsK0Q367fBbvbs2WRmZvKLX/yCc889NxXsFixYwPnnn09DQwPBYDB1/tChQ7nnnnv4+te/zkMPPcTcuXNZuXJl6vHS0lKGDx/O8uXLOemkkzrVhrY39/mvX8BfFmzknVW7AXOLo6vOGMGNF44l6crkt+GprIoPAsCjxLjYvZFL3Rvwq7FD3V6II7J/yNP39uS57GYxXq/T2m4lZ1LT2VXbzJaKEFvLQ7TEEmDoWJKtWBQYXFjAoLFTKBh7Km7voX95iMOLJ3XC0QS6YaACNqsFh03F57DicVjNoGez4LJ2btVtIpGkMWzOz2tsampXJFlRFPxedyro+b0e1K7eVkyLQzRszs9TLOYK28BgsyfPkw1WKZ4tRFfrtr1ie9JLL73E8uXLWbp0abvHKisrsdvtaaEOIC8vj8rKytQ5+8+3a3u87bGDicVixGL7fnmGw+bQalGOl8dmT2X9znp+8/oalm6p5qUPtjD3k1KuO3cU95zdyArnKP7dMok9WpB/t5zAvNZxXOjazOXudWRaIgd7SiE6zdyjVsVmaQt5Bs2xJE3RJHarit9pw7d3JaeigNWiUpznpzjPz4UnDKaioZUte4dsG5paKdtTQdnuuRgL/0d24RCGjhzL4NEnEAjKtlRHw25VyfaaQUc3zKH0eEKnIhpNzYG07V1163FY95ZWMedPOvZ+7b8Yw2azkpMVJCcrCJhbnjWGm2kImz160VicUFMLoaYWyvZUoaoKAZ85ZBv0efF53cce9Cx2M8B5ss2h2lgTVK41e4kdfrNGnjfP3MrM5pa6ikIcZ30i2O3atYuvfe1rvP322zidzuP63I899hgPP/zwQR8fNyST39x+Dp9sruLX89awcXcDv39zPf9atI2bLtjB41O3slIr5pWWSZQms5jXOp75rWOY6tzBha7NjLFVy+890SXMkKdgs1hSiy5qmmPUt8Rw2a34nWbxY7tVRVHM3p3CTA+FmR7OHl9AXVOMrRUhtpbXU1XbQH3ZBup2buTTd9/AnzuIwcNHM3j4OHILB/Xsdll9lKooe4dj9713+y/EaGhNUN0UwwAse0O4TVXwOmx4nBbcdqsZ0q37rnc47OTlZJKXYwbvaCyWGrZtCDURTyRTizLALMTs93oI+r0EfF78XvexfZYWmxng3JnmkG0sDDWboGajuZ2Z3W0O1bqCZkFkmxvsXhm6FaIb9Ymh2FdffZUrr7wy7ReQpmkoioKqqrz55ptccMEF3TIU21GPXVFRUYd7xeq6wTurd/PsG2vZVdMMQEGmm69cPIGLThrCmuQgXmmZxMbEvp7DwZZGLnBv5hznNryqbFEmul5y76IL3SC1nZbPacNtt6R68g7UFImzpdwMeXuq6jG0OKBgqHasngCDhhQzqHgkhcVjcPsCx/019Xe6YaR2xkhqBglNxwBcVgsBt40Mtx2f05xTeajyKq2RaCroNYabSSSTaY+3Dd229er5ve6uWYyha5CMQCIKyRjoe+cYW+xgc5o9e+4sc8Wt3WuGPll1K8RB9bs5dk1NTZSVlaUdu/HGGxkzZgzf/va3KSoqIicnhxdffJGrrroKgE2bNjFmzJh2iycqKirIzc0F4He/+x3f/OY3qa6uxuHo3LyQ/evYHRjs2iQ1nblLSvnDW+upDUcBKCkIcPulEzhrXAHbktn8LzKKDyPFxDDvYSPJVGcZ57m2MNZWJYWORZczDHNlbUIzV9ZaFLBbLamA4LJZUjtd7C8ST1Ja1URpRQM7KuuIRSLmzRQV3WInK6+QQSUTKBh5Ark52V0/p0sAZtiLJXRaE0mSmoHNYvbmZXntqRI4h5un1xqJpkJeqKmZWDx9UVfbYoyAb1+vns3WRQM7hmEGvETE3N4sGTWPqRazd88VBF8+OIPgDEjQE2I//S7YdWT/xRNgljv573//y3PPPYff7+erX/0qAB999BGwr9xJYWEhP/nJT6isrORLX/oSX/7yl4+q3Mmhgl2baDzJPz7YyvPvbKQ5av4CPaE4m7sum8gJxdm06jY+iA7n7cgoypL75jDlWZqY7tzKOa6tZFtaj+RtEaJTDGNfiY6kbqDunavn3Tup32W3YO0gJOi6QWVjK9srQ5RWNFJdH0LR44CKZvdhCRRSOGIcRUOHMWRwAc5O/oNJHLl4UieS0IgmNSyKgtdh3S/k2bBZDv+vw0g0RqipLei1EIm2X9zlcTlTIa9b6ujpSTPsxdtW3ap7y6sEzbl6ruDeOnoema8nBqwBGezaChS/+OKLaQWK8/PzU9eUlZVx++238+677+LxeJg9ezaPP/74URUo7kywaxNqifOXBRt5+YMtxJJmPbFp4wu4/RKzBp5hwNZkNgsiJSyKFhMxzPknCgaT7OWc79rCFMcubIp+qKcR4qjpe/erTWptE/pV/K62EirWg/592hJNUFoVprSijrI9NcSTSXSLi4QrG80RJLdwCEOGDGbo4EFkZQa7d6usASyhmfvcRpMaqgIum4UMj52Ay47HYcFtt3SqxEps7+KLxnBzh6tuwSyYHPB59n55cbu6eN6zrpk19OItZq+eopg9es6A2aPnCpq9eg5v1z6vEL3YgAh2PeVogl2b6sYIf3hrHa99sgNNN9Jq4BVmegCIGRY+jg5lYaQktVUZgF+JcK5rGxe4NsuWZaJbtS28SGhmT57TZsG/d6jPcUCNvP1pus6e2ibKdlewo7KemmYdXbWj2f0kbV5c/iwGDxvBkKLBDCrMk968bqLpe3vyEhqaAY69K24zPea8PI/DatY67IR4PLF3lW1zh3X0wNwCrW2eXsDn6ZqVt/sz9L1Br9WctwfmIgx3lrkCt21xhioLekT/JcGuGx1LsGtTVt3EM2+sZcHeGnhWi8KlU4bxpemjGZrrS51XlfSyIDqShZESGvR9803G2yq4wLWFU51l2KUXT3Sj/Xe7sO7d7cK/Nxwccj6XYdDU3MyOPTXsqKxnR00rCcOck6dbnBhWFznZ2QwePIhBgweTM3g4ivTAdDnDMIhpOtG4RkzTsSjgsFnwOWwEPTa8dvOz7GjYvSNtBZNDTS2Em80vXU//K0RRFHwe195Vt2bPXpcO3xq6GfJiYbOmnmoza+n5B5klWNyZYHN13fMJ0QtIsOtGXRHs2uxfAw/MEYdzJgziS9NHM3FYVuo8zVBYHhvM/yIjWREfhFnq1Cx8fJazlOmurQy31sn0E9Ft2mrkJTQdw2BvjTwrXocNl73jlbX7SyY19lTXU1pey47qMPVN0f0eVbHaneQOGUH+iInkF48hM0OGbbuDbhip3rykZmBRFVw2lUyPnYDbjtdh7fQetwC6rtPcEiHc3JLq2Ysnku3Oaxu+bQt6bpez6z7fZMyspRdvMb93eM0h27Zaeg6/zM0TfZ4Eu27UlcGuzarSWv66YBPvrytPHTtpeDZfOm8MZ47NT/sFWKN5WBgpYWGkhFp9Xw9HkbWB6c6tnOXcToYlihDd5cChWpfNgs9l9v44rAcfqt1fuDVOWU0TZVVNlNWEiLa2oGpxdNWGZg9gzxxEfvEYBg8eTFFhPm639MB0h6Sum/vbxjV0Y++wu9NKhteO127Or+zMIoz9RaIxwk37gl5LpP3vI6vFYoY8vxn2jrmeXhtdM3fEiIXNRRk2t9mLFygyh26dAQl5ok+SYNeNuiPYtdleGeZvCzcxf3lZahL7iHw/XzpvDBedVIR1v3kxugFr4wUsiJbwSXQoCfb9Uhxpq2GKYxdTHLsosjTK7zHRbQ4cqm3bzszjsGDr5DwuwzCoCUXYUd3Ezso6yqvrSGoGutVN0h5As7nJyMmncMhwigYPoiA/F1tXb3wvzHIqSXMRRkLXUzUP/S4bfpcNj32/vYiPQDKZJNzcSqjJXHnb1NyKprefQuJxOfH7zJDn93ZBr55hmHPzoiGzV8/uAnc2BIdIyBN9jgS7btSdwa5NVWMrL72/hf8s3k5rzBzWyAu6+MI5o5h5+nDcjvS/1Fp0G4uixbwbLWFLIiftsVxLE1McuzjHuY3htvpuaa8QbTXy4nuHaq0WBZfN3C3BaVNx2jq3FyqYdSD31DSya08VO6tDVIZjoFjM3jybD8PpJ3dwMYVDRjB4UD45WZlSO68bJHWdWEInmtRI6gYWwG4z6x169+6E4dy7963TZsHSyZBkGAbNLRFCTc2Em1sJN7cQjbUvzm5R1bSg5/d6jr6mnmGYpVSiIXOlrd1lLroIDDZDnitDFl+IXk2CXTc6HsEu9VytcV75aBsvfbCF+iaz7IDfZeOzZ5Vw9VklZPralxmo11wsiw3m01gRa+KFaT15JdYaLnJv5gxnKQ5F69a2i4HLMCChm6VTdANUZV9vnnvvZH2HtfNBrCUaZ3dlPWWVdeysDhNujWOoVjS7j6QjA9WTSV7hEAoL8hhcmEd2ZoYEvW6gGWbQS2gG8aSGjjnqbrOouOwWcrwOs4ae09rpkNcmHk/sXYxhBr2D9eq5nI60oOdxO4/8szYMc3VtNGyGPYsdXIF9iy9cmebuGEL0IhLsutHxDHZtYgmN/35axt8WbmJXrblVmcOqctmpxVx37igGZ3e8mjBqWFkdK2BRtJglsSFoe0OeW4lzjnMr011bGWptkF0uRLfSDbMXLqmbQc/WtrrWZcNj73i3i4MxDIOG5ig7y2vZVVnDrroWIpoFzeZFs/nQVTs2p4v8gkIKBw2mYNBgsqVHr9vohkFSM8x5ekkNi6rgc1jJPoaQB+bn3NIaSQW9cHNLhzX1VNXcKaMt6Pm8blzOIyyjk1p80WwOzdq95sILX57Zk+cImEWThehBEuy6UU8EuzaabvDemj38ZcFG1u9qAMzekPNOGMyXpo9hbFHGQa8N6U4WRkp4OzKKam1fSRWfEmW8vZIJ9krG2ysZZAnJtBPRbczVtTrxpIEC2G0qAacNj8OKzapiVZROLb5oo2s6dfV17KmsZVddC7vq/z97fx4uSXbXd8Kfc2LL/e5L7dXdaqm1tKTWArQ0A8wgW/KAGZaxDSMLITz4RUg2WJgRNgM8jEcWwh4Mthk0Yz/geV9bYDOPBEZmsUZIwkKtrVstoaX36q717kuusZ1z3j9ORGbeqltVt5Zb6/k8T1RERsbNjBt1M/Obv+X7i4kzDUJiivStX59m4fARFo/cy+KR+5hxQm/fyJSmXxgll/Y4M/Vw6IN4pfV54+R5TqfowG13bHTv/Nm3YH31mvUazUbVrus1oijc25MMmy86oNPCGHkSJo/Y+rzatEvZOm4KTtjtIzdT2JUYY3j0mVX+f594kkeeWBruf/398/zN/+YlfPOLFy4aBdEGvpIe5GODF/N4coiUnTUrk7LPQ+EZvqXyAg+G59y0C8e+oY0di1WONPOkwPckVd8jDCShJ6mFe6/NAzvybHW7y6nlbU6tbnNmrUOa2kiPET7ai/AbMywcOsLC0fs5ePReNxFjnzh/GkYl8KytSjWkEnhUiv/ja6HswC3TuN3+gN0+0qIwKMRebSj29lSvlw2syMv6IH1rhDx5FOpzNmXruSYex43BCbt95FYQduM8dWaLf/uJJ/nY46dQhVHokdkG3/Mt9/Jd33ScqcbF0xKZkTyTzfL1dJGvZos8mc6RjQm9mkh5XXSKb4le4FXRGWeG7NgX7Nxa0EajNMO/Y7B+eRPVgGYloLJHK5VxtDasbA84tdrh9MoGZ1a3R0JPBqiggd+cY+HwceaP3MeBxXlmp6euj/WGY4g2hn6aE2fWVkVKQeRLqoHtoi6bbKpX0XW743m0ptePbZ1er0+n26cfJ7uKvWolKkSeTeU26tVL/7/nibVRSbrgBbartnXQNl/Upu0sW4djn3DCbh+51YRdydmNHr/9qaf46Oefp1d00gae5L955SG+7+H7eOi+2ctGJVIjeTKd53PJMT6XHGVrbNpFTaT81drX+M7a16nKC9MfDsf1Ztwvr0zrTVStlYq8ygib1oblrT6n1jqcXlrn7OqWNdSVHsqrkEeTyOoEsweOsXjoMAcW5lmcnyEIbp3X+p2ATcfblHymbCOGJwRRIKmHHhPVkGpoO3Aj37tiL71xlFJDE+VOb0Cn12cQX1ivJ4SgVol2RPXqtcruYk9lVuSlXfuHGtZtFK95oJhlO2HFn8NxnXDCbh+5VYVdST/J+c9fOslHHnmObxR1eADH55t878P38t+97jgT9cvXm2gDT2bzfDY5xufiY6xr+210Qg74/vpXeFP1KZemddwQyqkXaa5tXZ5vIzuVwCPyJZHv2ZFYV/HZb4Vej9PLG5xb3eDMWpdBpjAyRAUN8nACEzaYmj/IgQMHOLAwx4GFOWeYvA8orYnzQvAp+94SSDH8/25GgRV6hb1KJZCIq/lPB7IstxG9IqrX6fVJ0uyC40qx16iP6vUuiOwZbadeJG0r+KRfNGDM2bq8yoRd/D3W+Tkcu+CE3T5yqwu7cb5xapOPPPIsf/LYSQaptTeJfMl/++ojfP/D9/Lg8Zk91RZpA48kx/md7kMsKfsHNSc7/EDjcd5YOYEn3J+Q48agja3dUtpgjNVynicIPUkjspMSqqG86po5Ywxr2z3OraxzbmWDMxt9tmKNliEqqKOCBtqv0ZqeZ+GANUs+sDDHRKvp6vSuM8aYoaDPlF00IIHQ96iF3rDzthp61IKrj+TCyHKl0+vTLSJ7u41HA6hVIxo1m8ZtFOlcvzTNVpmN5KU9O/1C+hDWbIdtbdbOtY2aVvy5RgzHHnHCbh+5nLATRhPpPlXdpaJ6ZDJiM1hAiZsnArtxxh8/epKPPPIsT5/dHu6/b7HF973hPv7Ka4/RqF7+/HIj+NPB/fxu71XDNO0Bb5s3157k2yvPUJcXfuN1OPYTXRgj59qgiiaMyPdoVnzqoVfMsb226QWdbteKvNUtzmz0We1kaOmjZYQOaii/SrXeYuHAQRYOHWXx4CFmpiZdnd4+oY0Ve3GmSZXCAKEnqQSSRhTQiDyiIoVbCSSBJ646spckKd3+YIfY2y2yB1CJwmFEr1mv0ahVCcPACr2sD2kfVJECDioQ1G2NXmPB+ue51K3jEjhht49cIOyMYTpbYipfoaK6VHQPyc5LqpFs+XOshwfZ9mcx4uZYLRhj+OoLG3zkkef42OOnSDIbxauEHn/p1Uf4/jfcx0uPTF32gzAxHn/Yfym/13uQvrHphZCc/7r6HG+uPsk9bsKF4yahtCFTZthpG3qSKJBFnZb9kLdredW2PoM4YXmtEHprHc5txihjQHgY4ZOHTURtmunFI8wdPMriwhyLc7MufbtPGGP/z+NckeUaZQwG22UdepKK7zFZC6zYj/xrSuGCjex1+4Oh0Ov2B7vW7IHtxm3UqjTqVRo1K/oqYYBQiRV7SReEtHV5U8egPu8sVRy74oTdPlJe3E+877s56q1xMHmOiu7vOEbhMfAaxLJOTbWp6e7wvlwEbPrzpLKCQaKFxCCs2DMgUUij8Iq1NIpUVuh7TQaySSKr12W+YWeQ8odffIEPf+Y5Tiy3h/tfcmiS7334Xt78mqPUL5NqHmifP4vv408GL+FUPvLQuz9Y5dsqz/LN0QtMehcOAHc4bgRK2yL9Mm0LNnUrpcArujIj3yP0R4Iv9K688zZXmqXNHmdWtzm7tsW51W3iNMdI3867jabIgwb1qTkWFxdZmJtlcWHWRfX2GaU1qSqie/moFKUe+kzXQ5u6jzwq/rX/H5Qee91e3677/V0NlcGOSrNCrxB8UUBdJsi8DzKwwq65aMVe1ISo5YSewwm7/aS8uCs/M8dcZF+4uQhYCY/Q9SYZeA1SURmJL2Oo6g6z6Tmms3OEZvcX+14pRWMia4jzBKBEoUTAQNaJvTqxbDCQ9UIM7h4lNMbw5RPrfOSRZ/n4l0+T5rZouRb5/KVXH+GvvPYYr7539pLTAYyBJ7J5/qT/AJ8dm3Ah0Lw8XOYN0fN8U+UFJuS1/e4Ox7VSzrRVxqCLSRgGW7dVWnA0Kz7V0KcaXF2tnjGGjU7MudV1llc3OLveY62Xo2SICluooIkK6oiowdzsDIsLcyzMzXJg3kX19hNt7CzjOFUkyjbiVHw793aqFlKPbETvWr31Sspu3G5/MIzw9QYDtL7wI1cIQbVixWbDy2iE0KiGhNXGqBGjOg1BzdbrBXXnoXeX4YTdPjK8uD/TpFqJWIqOsxIeQYs9vMiMoaU2aGVreCiE0Qg0EoMwVlBp4aHw0MIuBkGkB1RVh6ruIbnyTlSNIJZ1Ys8KvYHXYCAbxLK2Q/Bt9RL+0xde4COPPMvJ1VGUcWGyyl9+6Chvee1R7j84ecnn2lIV/iy+j8/Ex3k2nx3ul2heHi7x+ugUr41OMe/1rvj3cDj2i1LwZUqjivm2oSdpVPyhx1ogrzyaV5LEA1bX1jm3usm5zZjT2zl9HZCHLduU4dfRfoVWs8nC3AyL83MszM84T719RBtDkmviTJEpbf/PfY9G5DNZtdNQbPf1taVuxzHG0B/EFwi+3SZoYAyhNFbkhdCoBNRrEbV6ExHU7Hzb6rSN7NVmIHBfCu5knLDbR8qL+9VfeC1x6xha3MA3XaOp6D411SE08Q4BqItt36RUVG/YvFHRPbyLiEGNpO+16Hktet4EPa9FLOsY4LFnV/nDL77An37lNL149KZz32KLt7z2GG9+zVEWp2q7Pm7Jsmrw2fgYn4mP89yYyAM45m/wuugUr41Oc5+/5ubVOm4plLYzUPMiuuIXthu2Rsu7NqFnDCIfsL1t07Zntgac2dYs94UVen4N7VXQXogXVJmZmWJhdob5uRnmZ6eZnGi5Dtx9QBs78zYp7FYEthGnFtqJGWWN3vWK6I0zXrdnBd9FUrlGI42iFkA9lNQDQaNWoT45QzRzzM63rc1AtPv8cMftixN2+8jtZHcC2G99JqaqulR1d7iuqB4e6oLDFR7b/izr4QG2/Tni3PDnXz/HHz92kj//+jkyNRKJr753lre85ijf8aojl/XGO5c3+WJyhC8mR/hGNo9h9ObYFDEPhud4ZXiOB6OzLprnuKUoffRypSmzaL4niIroThnVuWqrDWOQakDe77C8sc2ZzZjTWxlnt3P6SqL8Ktqvob0I7VUIqk1m5xdYmCvF3gyN+qW/ZDmunPO7b8uxaJO1kKlaOOy+9fZJZCul6PXjMcHXp9ePUfq8L+paQz7A17GN6rUmacwdoT5/nPrcUbza5HWpy3bcXJyw20duO2F3MYwpon/b1FWbutqmpjo7xF6Oz0awyEZ4gI43RXuQ8adfOc2fPHqSx55bHRak+57gDQ8c4M2vPcp//bKDVMJLRzE7OuJLySG+mBzh8fQgA7NTFC54bV4ZnuOh8AyvCM+5SReOW4pxoTeetq1HPrXQKxoyxNVH1YxBmByRx2x3eiytt1na7HN2O2G5nZEZDy1DdFAfir7KxCxz8/MszM0wN2sje5Xo4uMEHVeOMpo4tfNvFYao6LIOfWuWXQ0loWenZNiobmGcfR0xxpCkaVGvFxfCr88gTu3YNKMhj0ceen6F6uS8FXkzB2jMHKTeaFCtVl3U9zbDCbt95I4RdrthNDXdYTpdYua8Ro9URLT9GTr+FB1vipMd+M+PneaPH3thhzdePfL59lce4i2vOcbr7p+/7AD33AieyWb5i/QgX0kP8HQ2hxqL5nkoXhqu8JrwNK+OznDY23ZfPh23FGX3ba4Kmw0h8IsP92oxHcN23l69xQoAxqBVysZmm+X1bZY2Opzbilnt5igZ2KaMMpXr15iYnLQRvZlp5udmmJ2ZIvBdwf31wBhDorQV95pC5Juh0VU5MaMW+kPj7DAYdV5fi7febmitbe1ef0CvXwi+Xp900LVmySqzky+CGkRNZHWCWmuS+sQM9YlZu12vU6lUnOC7RXHCbh+5o4XdOMbQVBvMpOeYypbx2Rk1S0VEx58ikVW2uzEvLLc5udohTjMM8PyW4VzfY2Fxkde+/B4eODy9pzeMgfb5erbI48lBvpQeYlnt/ANe8Nq8ofI8b4ye56i/6USe45bCGJvCKw2Ty3dXT1qxVw1sI8ZQ7F1DQ0ZJlsasr22wvL7Fuc0+Z9uKzdjYqJ5ftfV6MoQgYnJ2kZm5BeZmppmbnWZ2etLNwb3OjE/MSIuJGWD/m31P4Ekr7KqBZ4XfuJn2dRR7YEen9QZFR257k157i163g8oLk2XpW8HnheBHyKBOfWKKerNFrVkIv6k5olrDCb6bjBN2+8hdI+zGEEbRzDdpqk2a+QZ1tX2BCfOliHPD89uwqapQn6Uxd4jEb+3JqPlc3uSx9DBfSg7x9XSRjFGa95C3xRsrz/OGygkO+e1LPIrDcfMYWqzoUTNGOQptWKcXeFTCa6jTG3syoVPifpeVjc4wqnduK6GXaowsOnHDFnnQxARVpiYmmJ2dZn4o9qbsxATHdUUbM2zKyQp/xUxpDBAVqfxxf73Iv37duOMYY4iTlF6vT7/XpdfZptfr0u/30Xlm07nl83o+eCFepUF9aoHaxDT1yTnqUwu2YcOl+28YTtjtI3ejsDsfaRR1tUUz38QzGSAwCBB2LYwmVH1MvE1LJuxWcpcoWM3rmMYcmW+NlxNZJRPRRQt9Y+PzaHKYz8TH+VJyeIfIW/DavDo8y6vCs64uz3HLs1udXuBZ89xaZOeeBldhlnzx5zN0+wNW1zZYXd9iZXvA2Y6mnVuhZ2SIkT5GBhgvYGJymtm5eWaLer3Z6SmiyA2x3w/KtG6cahKlhv561WIWblm7uR81e+efxyBO6A9iW7/XG9Drtun3Opg8BZXaP1wpwatA1MBvzlGbmKU2OUt9co5avU6tVnMp3X3ACbt9xAm7K8QYTNzl+VOn6W+scCDs8fqDkunq7i96jSCVVWJZY8ufYzNYIJcXfivs64AvJEf48/gevpIevKAu7yXBKg+G57gvWOfeYJ0J6SZgOG5dzq/TC6QgCjzro1fYq1zXD8qiE7ff2WJ1o8NSO2V5O+ZcO6MTG4yQaC8iD1tov4by6zSnZ5mfnWF2ZprZmSlmp6eoVSvX75wcwMhfL8k0mVJoir8HXzJVD5moWuuVanBjrLZKwdfrx/QGA3rdLr32FoNuG5Mn9ou4H9n6veoURA1k1LCCr9miVqtRLwRftVpFypszUvN2xwm7fcQJu2sjyzWPPbvC08+dRHRXefms5r4pyT2TkiMT4oJvpAboepNsBgtsBguk8kITzoH2+Wp6gC+nB3k8PXhBXR7AjOxxb7DOvf46Lw2XeUmwgi/cn77j1uP8aJ4nIPDtzNPAk/iefZ3Yuj1bjH9dNF/RVTkYDFjZ7LC60WZ5s8PSdspWbDCF0FNBAxU00F5EvVYdirzZ6SlmZ6aYaDVdtOY6kylNkiviTKGMjei1Kj7TjZBmFFCL9s925WJora3g6/Xpd7bpdzbp99r0BzEaH/wKVIqRaEEFvAoirFGpN6k3GtRqtR2izxlxXxon7PYRJ+yuH1obvnZyg0/+xRk++dUznF3rcqglOD4p+ZbDHn/zVVUenNv55zmQdQaywcBrFPNz7Xi18U+2pbzJl9ODPJnN8Vw2w1k1YVPFY1RExoPhOV4VnuXV4RkW/C4Ox63GsBlD2TFo4+/W5dxb3xPUw6JOL7Czb6/rZ7zRxP0u6xubLK93WG4nLHUN64lPFk5YoefXMNJ23AZBwMz05JjYm2R6atJ15F4nyojeIFVkWhNIQa2Yf9uq+jQrwb6YKO8VYwxxr0O/s0mvvU2/16Ufp/TTnJzAirzajBV8UdM2bwBRFA3FXrlUq1WiKHJfFHDCbl9xwm5/MMbw3HKbT/7FGT71F2d44vQWAIdbgu99IOBtr67w2kV2nVCh8Oj6k2z7s2z7s8SyvkPoDbTPiXyG57IZnslm+Up6gI7ZmUJa8Nq8IlziFcESLw+XmPIG+/nrOhzXRPmuPd6UUVqtBL4VeuWEjNC/Dk0ZO55c4+V91KDD6laXlU7OuR6c63ssD3wSIrRfQXuVodgTQjA10WJ2ZoqZqclRKtfNxr1mMmVF3iAv6vMCW5s3WQtszWboE3i3gDBSGUm/Q7+zRb+zRS9O6SufvqiTenUr8oIqeDs/V6WUO4TeuPC7m6J8TtjtI07Y3RjObfT41FfP8sm/OMPjz62iDczWBA8tSt5wvMK33lvjZXOCuTC9YGRaIiq0/Rm2g1k63jS53Fn0rQ2cyKf5cnqIx5ODPJXN76jRAzjobfPycImHwjO8OjpDIK58Rq/DcSMxBpQxKDUu9MDzJLXAFuOHfumjdv2iekJnyHyAzGPIEzZ7KUtdzVLXsNQTnOsJOsrHyLCYnhFhpH3vrFWrzExP2mXKLlOTE/j+3fOBfT0px6INUkVuDJ4QVAJJqxowUQ2ohb612vHkZT1G9/9klfXYSzrkaUwvhYES9HVAnwp95THIBcavWDuWXf5goyi6QOzVarU7MsrnhN0+4oTdjWezm/BfvmZF3uefWibNRyIr8ATf++ppfuBVDb7loGLB6yLPE3o92aTjTw8NlrXYmRLq64CvZwt8LV3ka+kiz+fTO1K3TRHzhsrzfFv1WV7krznvPMdtwSU99aQgCqRN3XrS1ux5kkAKG927RiNloTOkipEqQaqUbpyx0k5Y6miWu5pzfclqGqG8ajE9o0L5pFJKJloNZqammJmeZHpqgpmpKVrN+h33Yb3fKG1HosVZKfTAL3z0osJAuxZ6w+kZlUDevDRuntipGdkAVAJGY4RPrCR95dEXVSv6UhgoSLUPF4nYSSmpVqtD0Te+HYa3Z3e3E3b7iBN2N5c4zXn0mVUeeWKJR55Y4tTaztq4YzNVfvhbpvnO+wNeOpnQMDvnzmoEHX+ajWCBLX/hgmgeQFeHfCNd4C/SRR5JjrOlR3M4D3jb/NeV53hleI57g3UXyXPcVgw99QpPNW2snBKAkAIpwJd2QkIp+sLCTPmaIzzFqDSZx8h8QJ4OWO1krPRhqS85F0es9CU95aG9Ktrb+doMgoDpqQlmpyYLwWfXbnTa3tHGkCnbmJMpQ641upiY4UlBWPy/Nyse9TAYGmnbySnXd1rGnlCZFXvloouRl35ELiL6ok6fqo3uaY9+ZhjEMfr8ebpjeJ63q+CrVqu3tFm3E3b7iBN2txanVruFyDvHF59ZJclGs249Kfi2B6b5H1/T4luPSI5EXSpmVDtnELT9aTaCRTb9edQuIk8ZwV+kB/iz+F4+Hx8lYfR/7qO4J1jnxcEqLwlWuddfZ9br4bluW8dthDG2+1wbgy4ie9pY0Qc2A+YVI7KqgUfF94iK6RnXHEEzxkb28j5eHmOMpptolvuCpYHP2aTKSg9We4pcBGh5oc9lvVZlZrqI7k1OMD01wdRE65b+kL4VUVqT5oZUadLc2qwIrND3izFotcCnGpZNOoLQK9L7/g0UfcYU0b0BpH3QWWG5UoWgiqlMEosqAyUZ5IJ+phlkMEgS4jjmUpInCIJdI33VahX/Jjf/OGG3jzhhd+uSZIovPbfKZ75ho3kvrHR23D/TrPC9r5nlBx+s8LqZPi12RvtSERHLOrFXJ5Z1BrJG32sNffQG2ufzyVE+lxzjyXSOtrmw8FuimZE95r3ucDnmb/LicNV56TluO6zIsx/6ZYSvrN3zPSv0qqGdkhBdLwNdrfCUrdmTKgE0WsNaLK3giyPODQJWujlbA43xIrQXcH7+uNVsFEJvkqnJlhV8kxOuO/cKKMej5cWUDFXY8JTxMF8KAikJfEEjCob+epUizX9dm3YuhVY707iqHJnmgRdZn71KCx22iLXPQGGje7mkn2QMBgOSJLnkU4yLvvOXG/Elwgm7fcQJu9uHM+s9Hnliic8+scQXnl5mkI6ieVLAm18+xY+8ts63H0qZDS4uunqyOWzG6HqTGOFhDCyrJk9lc8PlVD5JzsWLvue9DvcHq7y4WO7xN1x0z3HbcX7tnjYgsSPSKr5HPfKIisieL6+xXm/4pKqo10uQeYwwCjAkuWS5bwrBF7IykKx2cnqZsdM0vAAtR6JPCEGzUR82aUxPTTA9OcHkZMsJvivEGJvSz5QVfVmurSUPdkRaFEialYB6UcMX+DbVG3rejevS1XkR3Uvs5AyVjFrK/ch67UVNqM2g/CqD3GOghI30xTGDwYDBYECappd8Gt/3hyKvUqnsEH3Xa+yaE3b7iBN2tydprnj8uTU++8QSn3liieeWds6Wna9L/rtXTPGtL2ry6oMhR5uamulR1Ttr9BSSrj9F15tg4LXoeU1SUQUh0AY2dY1VVWdFNVlRDZZUk2ezWU6ryQvOqSliXhWd5TXhaV4VnaUlL/2N0eG4VdEGa6isDcqMBt5Hvh2TZoWevK5j0sqaPaHSoeizgg/6qWK1q1jtG1Z6hpXYZ7kv6eWyiPBFaDnqtBRC2AhfIfSmJgvBN9F0Kd0rpKzjS3JFmtsaPij/JorGDd+jEXlUQ5/Ql0S+jfLdsDo+Y6zIy5OxZg0DQlqxF1St1151CsI6yqswyAWDTA3FXrlcLtI33sgxLvwqlQqVSmXPkzicsNtHnLC7M1je7PP5p5f54tMrfPHpFVbbOyN2ldDjVffM8u0PzPBX7g956cSASbVBaC58Eef49L0mPW+CjfAAfdm8oA6opwOeyWZ5JpvjqWyWb2QLDMyopk9guM9f48HwHC8K1nhRsMa089Jz3KbY6Rl2RFpZq+cXdXpDy43r1ZRxkRMQOrPdudoKP6FzeolitZNZwdc3rMQBy33JQHmFFUtoI31i9GHbajaYnGgxPdlicmKCqckWU5MtqhU3Tu1KKI22M6VHqd1CfpQNO9XAo1Wx83ErgbQWPTeyS3c8pZvHNuIHRXRvfGxay4o/P0ILj0GSM0hz4lQxSJKh6LtcTR8wFHjni77zU7xO2O0jTtjdeRhjOLna5dFnVvjiMys8+swqm92dAq5e8Xno3lm+68Ep/tt7fI41cuqqQ1V3kJw/HaPGRnCAjeAAsVff9TlzI3gqm+dLySG+lB7ihXz6gmOmZH8o8u7x17nH32DSc3V6jtuP4Zg0XTRoYMshxpsyIt8bij3/Wi1XLoVWSJ0Mo3yojG6iWO9mLPdgra9Z6cPawHboGhmiZTBM65oitVutRExN2kaNyclWEeFr0Ww4W5YrJdea7LzGDa+Yj1stbFmqoR2pV/owlp26+17HNx7dyxO7XXbnCgnSLxbPrr0QwjqEdYxfIc40g7KBI4c4t527cRyjlLrkU5cdvJVKhTzPeeihh5yw2w+csLvzMcbw3FLbRvOeWeGxZ1fpDLIdx0zUQ1573xzfdP8c335/g/snFJNqnclsZYePXk+22A5m6HsT9LwWqajsarS5rmp2DFo6x7P5LCfzSQwXflOdkn2O+xvcE2xwn7/GA+GKS+E6bjt2NGUYLhR7XhGt8T2CYmya790YwSeUjfIJndGPU9a7GRu9jNWeZr2nWO0ptlOJ8ipov4r2ayi/OjRd9n2fqYkWU0V37tREi4mJJhOtpqvjuwKU1sS5FXy5ttE9gW3eGW/asF58/rBTd/gF4UZE+rQCo2xkT+U7t3UGpugtNtpO1PArVvTVZqAyQYpfNHN4xGk6jPLtluLt9Xp813d9lxN2+4ETdncfShuePrs1TNs+fmKNfpLvOGa6EfHKe2b5pvum+c4XSR5stZlUG4jzonmZCOl5LXpei0TWiWWNWNYusFqJjc+JbJpnslmezWY5kU9zTrUumHkLcMTb5GXhMi8Nl3lZsOzGoTluS0rbFduBa193JVLYubieEGO+auUi8KVN6e5b8Oa81G6WJmy1+6x1E9Z7Oas9wWris5aGZLKCCupob2eqtmzcmGg1bZRvoslEIfwa9ZqL8u2RsmkjV4asSPePd+oGUhD4ksizfnxlHV9YNHSE3nUesbdXxj35stiKQCGKmr4a1GahNgVhA6IG2qsQp9lQ7K2srPCa17zGCbv9wAk7R640Xz+1aVO3T6/wlRNrJPlOQ8wo8Hjj/VP8zYdqvP6A5FgjpW56F6Rth48pfGu1Iuv0vSZ9r0Xfa6LE6G9soH1O5lOcyKc5kU3zVDa/a1PGEW+T10SneW10mhcHq67z1nFbM+6rV3rtjWm+HaLPkzsXKQRSCvziPt8bHXfNEzYKhM6LkWoDTB6z1c9ZHUhWkoilvMlq4rM+EAzyiz+G7/tMTjSZbFnBN1kIv8lWiyi6PScl3AxKe5ZMWcGXjtXxecLW8fkSqqFPI7LWLOUEluh6z1Te0wnrUU1fNrDRvtKTr7BooTIJYZ32QDFx5CVO2O0HTtg5zifNFU+c2uTxE2t8+cQaXz6xTru/sz1eCHj54Rbf9YpJvvWeiJfNCqb8hIru79qQUZKICn2vRcefZtufIZb1HancbR3xRLrA17MFvpEuXDAOrS4SXh2e5aHoNC8JVlnwOm4kmuOOoUzpWuFnzZVNYbmx2yebEFixV/jwVYq0XeDZSKDvSTxxjZE/o5H5AC/v4eUJRti0bdtUWU1CVpOAjYFhrZez0cvZ6qUoPIz02E1p1qpVJidslK/VatpIX6tJq9lwqd0rQGlNpkdTNzKlbfofbITPlzSigEa0056ljArfMANmrUa1fOXaGNq9mIlv/dtO2O0HTtg5LofWhhdWO3z5uTW+/PwaX35ujdPrvQuOW5is8qp7ZnndvdO84d4G909L6qZLTXWoqQ6RuTClmogK2/4s7WCGtj+zI6IH0NEhX04O8Vh6iC8lh+ianemgpoi5P1jl/mCN+4M1jgfrtETixJ7jjqcUgaYQgbqo7SsnLIxH/saL8z05sui4Kl8+o/CyflG3lyLKwnsMCI8Mn63YsN43rMWS1YFkI5as9RXdlGG37vlPLISgUa8x0WoOl8mJJhNNK/p8/+Kemo4R2pRNG9aLLy9q+Up7Ft+zAq8R+TQqdvJGtYjw3cgRa+1T32Di2/4/TtjtB07YOa6GtXbMV06s8fiJNb5yYo0nz2ztqCEC23n74LEZHjw+wyuOzvDgkQYHKil1tU0rW6OpNnfpwK3T9Sbp+pN0vckdET1lBE9nszyWHOYv0gM8n0/vaqBcFwkH/W0OeW0O+tsc9Noc9rdY9Doujeu4KxhF/vRI8I396QusAXPZ1FGOVQs9ibxauxZjrPGyzhA6t558Ore1fEYBgjg3rA0E67FkJa2wmoZsxIKNvibWHkbsLt7G6/ns0mCy1WKi1aDVbOB5TvRdjtKepbTtKdO6EgrfPY+JakAt9IhCG/3dz3SuE3b7SCnsfuEHX8/Lj05zeLaBfyN9dhx3BIMk56snN4Zi76vPr9NLLizCOTLb4GVHp3nF0WkePDrB6xYNM2aDiXz9AvNkKD31WvS9BgOvSV82GXgNjPDIjOT5fJqns1meyuZ4JptjWTUveo4+ikP+Nof9LY54WxzxtzjmbzLnddkP6zGH41al7ODNtRV9MOrgDQpLjtAbNXX416OGzxiEUQiVnGfAbNAioKsCVvMaK1mDtSxgfSDZGBi2Oj2yLLvow0oph5G+VrMxtm4w0Ww4Q+bLoI0hzTVJPrJmOT+d26x4Q/FXuU6j9pyw20dKYfdD/+1LCH07Ouf4QpP7Fic4OF2/+m9vjrsapQ3Pntvm8efW+NqpDb72wjonV7sXHOd7gvsPTvLyo9N80z0tHj7ic28jpaG2qKs2Hhf6IhkgkTVSUSGTEamI7FpW6Io6J/QBTuoZzuYTnFUtzuQTnMknSNj9Db4iMo74mxzzNznqb3Gvv87xYINIXNqTyeG4UygbOspJG3osvGcbMwrRV9Rolem8qBCA11bDZxA6RaoYL48R2tbzGhmhghpxdZFtOcV6LNnoKzZ7ORu9lK1uzHane0nRB7amr1WIvFL4leKvWolc9+4u7JbOBduhGxWm3M2qTzXwqYVXJ/acsNtHSmH3gR9+mLMbfXrx6EVSDX3uWWzxogMTLExW3QvAcU20+ylfP7XB105u8LUX7Pp842SARiXgZUeneOWxab713hqvPuAxF8RUVYea7hCYS7+RA6Qisl25XmHBIqqsMMUJvcBT+QFeUNOcyicvOg9Xojnib/GiYI37/DVeFKxz2N8iEHqXZ3M47kyMoZifa3Z085aUnbn1wnct8iXB9TBkNqaYo9tHqgHC2NedET5G+hgZYGRIFjTYlNOsZRXWk4CNWLDd7dPudNlud4kvMx4rDAMr9prNQvxZwddqNmjUqy7FO0bZoZvmmlRpMmX/T/xC7DWigFbVH0b1Lif2nLDbR8Zr7OqRz9Jmn2fObXNiuU08NmS+UQ24d7HFfYsTzLYqTuQ5rhljDOc2+zuE3hOnN0myCyNli1M1Xn50mgcOT/Kao01euRgwFSlCkxDopFjHRLpPaC494NoAmYhIZJWu1+Isi3zdHOVxdS8n8hmezWfZ1tULfs5Dc6hI3x7zNznub3JvsE7TGSo77kJK0aeKCRwG8MqGjeLDPvK9YRdmGe276o+OcpauHtXuycKLD8wwwpfUFsmq8+ThJD1RZT32aHcHbHc6bLe7hejr0O31L/l0ZYq3FHrNRn247aJ9I7IispfkmlzbztxgbNxeI/KphT5hsLMrt3PqCSfs9otS2H38fbZ5wrbV2yLLpa0+J5a2eX65TTrmazZRD7lvcYL7Dkww1Yhu3sk77jhypXluqc1XX1jnayc3+PrJDZ5bbu9q9bA4VeMlhyZ54PAULzk8xQOHJ5ltVfFMRkX1qOg+Fd2jonuE2gq/wCQX9d7TSOu5J5usiSmeMkd4LL+PL6mjPJfN0jO7/60f8TZ5abjMS4MVXhouM+Nd+gPD4bgT2dGwoUGVdi0UzRpjgq8SlOO0Ci+265DOtXV7A2TeRxRvGLYDt0JWmSGrLZCHLVTQJA9bJKJKexjd69h1x647nR75ZcZj+b4/TO8ORV/Lbt/NtX0Xi+yd35XrbTzDq7/vp5yw2w9KYffRX/ir1CsBNoJufY/K1nljDMsbPZ5faXNytUuuRiJvulnhvgM2kteqOeNJx/WnF2c8cXqTr53c4MnTWzxxZpNTu9TrAcw0KzxweJKXHJ7iJYes2FucGnPBN4bApAQ6pqp71FSbmmpftJ4PrNnyQDbYFFO8wCJf10f5gnoxX8sPck5NXHD8nOxwwO8wI3vMeD1mZJ8Zr8ei12HR+e457kKG0b2ijq/8lBbCGu3K3QSfL/HltUT4dCH2YtuooXN7ItIbCb5oiqw6T1qdJ6vNo3zbhW+MoT8Y0G532e506XR7tDvd4dLrD7ic1KhWK7QadZqNBs1m3Yq/8najdtcJv/O7cpOlJ/lv3vYzTtjtB6Ww+9Kv/nUmamFhdmmLZVOlGaSKTpKT5to6YOeKcxs9nl/ucG6ju8PiYn6yyn2LE9y72KLurFMc+0g3znjqzBZPnt7kiWL9/HIbvcurv1ULrdg7NMUDR6Z44NAUh2bOawwyhkj3qas2Vd2lqrpUdJeK7l+0VCgVEW05wfMc5Mv6Xj6VvYxP5y9Gc3GT1YaIuT9Y48WF996LglXq8vI1gw7HnUhpxXIxwedJQRR4VIraPSv6rmHc2vmducUMXRBov0ZanSNpHCWtzZNVZtBedddZ2Hmu6PYKsVeKviLN2+n2LlvbBxcXfo1ifacLv97ZJ/jmv/73nbDbD0ph98wH/0ea1d0jbsZAmmsGmaKf5vRTRVaIvlOrbV5Y6bC8OUo/CQFzE1WOzjU5Nt9kuuFqERz7T5zmPH12myfPbPLEaSv2nl3aJlcXviXUI5/7Dkxw/8FJXnRwgvsPTHDvgYkLvByFUVR0n6rqUNVdaqpLVXWITLzrOSg81uU0L3CQJzjOl/SLOKEXWNc1zuUTZLs0aix47WHdnu3M3WTB6zgLFsddy26Cz1BYsuwi+EprFu9qmzYK02Uv71mhJzyUXyUPJ0nrB8iiafJoijyaQvuVyz5ckqRW5PV6dDo9G/HrjiJ/aXr5L3PVSlRE9+pW+NVH60ajRhSGt/XnqhN2+8hehN35aG2Ic01cCL1Bqmj3M04stzm11mZte+eHXqMacGyuydG5Jgema84nz3HDSHPFs+faRWRvkydPb/H02a0dNaPjHJyuD4VeKfoOzTTwzlNZ0uRUVTFVQ7epqQ5V1cHjwseNZY2ON0nbm+J5s8hX1HEezY/zdDZ/Ud89H0VdptRFSk2k1KVdT8qYWa/HrNdlVvaY83pMyIETgY47nlLclV26qjBdFhQRvsKOpTrWnRteZcOG0Bkyj23NnkoRhdee9itk1TmS+iGy6ixZZXaYvr0SkiQdib3zhF+n0yNJL90ABhAEQRHhq9Go12kW6zLqV69VkfLW/ax1wm4fuRphdz5KG3pJTifO6SU5W/2Us+tdzm30OLfR25GuDXzJ4ZkGR+caHJ1rUo3cbEDHjSVXmhdWOjxzbpunz27xzNltnjm3zcr2hSPPACqhx32LE7zowEQh+qzgu6Cm1BgqukddtWmoLRr5JlXd3TWAoPCs4JNNls0Mz5tFvqEP8eX8OI/lx0nY+2uxNF4+OubFd9TfZFr2XT2f446nbNpQZdPGeR58nhRUAjtJoSze96XAl1eQ0jXGij01wMsHCJWBlGivSlaZJq0tovw6Kqih/RrKr6H96kVTuZdjN+HX6fXodvt0ej0Gg90zBuNIKanXqjTqNZrNBs16jUajPlw3ajWi6ObVxTtht49cD2E3TppruklOe5ARZ4os15zZ6HF6rcuptS6DJCva4u2La26yyrF5G81zKVvHzWSrl/DsuW2eObvNU2e3eObcNs+d2ya5SHRvYbLKiw5Oct9ii3uL2tLj8y0q4Sjd6pmMRr5FQ21SUx0quk+kB4iLdOYCaAQDUaMn6rRFg22abDDBClM8qw/ylDnImmqwpups6Bqa3b+VN0XMvcF64cW3zn3BGtPe7uLV4bjTuFjDBozm6Mpijm6lGKc2quMTl/8s0gov7yNzG9UbfYMTGBmgZYAOaqSVOfLKNHnYIg8nUGHzqgVfSZbndLs9Or0+3W6Pbq9vxV+x9Pp9lLq852YYBjRqhdCr18aWOo16lUajTuDvT/DFCbt95HoLuxJjIMnV8NuTrZnQLG8NeOrcFt84vcXK9mBYLwHQrAYcdSlbxy2E0obTa10b2RuL8J3b3N3SRAg4NF0fCr17C9F3bL5JFFjBJ4wm0gMi3SuEXr+4bdcXs2MpSUVEx5+i602y7U1zkkVOqSlO5lO8kNn1WdXaVfBNyT4HvW2mvT7Tss9MsZ71eix6bdfI4bjjGTda1sZcMEe3nLRRjtAKx2r4fLmHGj6tECZDqsw2Z6ikMFg2heCL0H6FPJoii6ZQQcMuYRMVtNBedE2iz/6Otqu307XCr93t0R2L+HW7/T01eABUoohGo0azXqder9Gs1+y6Uadeq1GvVfH9KzdydsJuH9kvYXc50lxzdqPPX5za4MRyh6VNOye0/HMeT9kemmnQqN7ZHUKO24vOIOXZc22ePrvFs0vbPLfU5rmlNu3+7rUxUsCh2Qb3LrR2iL5j803C8TdFYwhNTKgHhDq2i7HrSMdUdPcC4afw6HmtYqZui57Xoi2anFLTPJPN8mw2wzP5LKfzCcxFonslE3LAAa/NAa/NQb9cb7PoddzUDccdz/ikjbKGb9i0UaRvA08MRZ4n7dr3xPD+i2qyYTo3KcyVRx25gBV9XoQKGmSVWbLKFCpoFksDFdRBXL9gR5ZldHt9ur2BFX29/mgpooGXG9dWUq1WbOSvEH2NerUQfXa7Ub/Q3sUJu33kZgm7klwbOoOM1U5SNF/Y2rw43TlAfqIWcnCmzsGZOoem61RCV5vnuLUwxrDRTQqRNxJ7J5a2aQ92f4OUAg7PNoZi756FFseL0oTd6k+lUdTVNo18k6bapJFv7eq/p/AYeI1C7DXpyxYbYpITapZV1WBD11hXNTa0TeeuqMau0zZKBJp5r8dBb5uD/jb3+evcH6yx4Hz5HHc4O5o2CtF3vq2SFFibsELkhZ43NF8O/aJj91IdTsN5uWlhw5LYJ8ZgRIDxArRXIQ8nyCozRXSvMVr82nUVffaUDGma0en16PX6dHp9u+726PUHdt3rX9bIuSQKwzHhV8Prr/Lj/+sHnbDbD262sCvR2tBLFduDjG6csbw94Ox6l+XNPmvtwQWTB2ZaFQ7N1Dk4XefAVJ3Ad2lbx62JMYb1TlyIPCv2nlu2wq9zEcEHdrLGsfkmx+ebHJu3gu/4QpOZ5thIP6MLG5YO9cJsuaY6u4o9g2Ag66SySiZCchnatQhJZcS6mOa0nuGcanE2b3FWTXAub3FWtRiY3d8bmiLm/sKT795gnQNem3mviyfc27Dj7qBs3jCmiPQNt3d27IaepBp6hMWkjbKxw5fi4jYt5Rg1lSIL4WejfPY+IwOMF6K9iDycJIsmUWED7ddRfg0V1NF+rUjvXv/PSGMMcZLQ6w3o9vr0+gN6/VHkr9fr0+33d7V3yTpr/Ov/52NO2O0Ht4qwG2IgyTWdJGN7kNkZdKliaavPuY0eS5s9tnupnZAhBAL7TWl+ssrB6TqHZurMT9Yu/e3I4bgFMMaw1o53RPheWO3w/HKbrd7F7Q7qFZ/j862dom+hyeGZhv2CYwwV3bciT3eGYi+4zAxdgIGs0/Mm6HqTdP0JBrKBQbKlq5xVLc7mE5zKJ3kmn+VENk2+iy+fh2a+mLJx0G9zn7/Gy8Ml17jhuOsYduxqjSq8+UpEEeUrzZhDX1qblkL4BZ6wAlBcpHO3SO2W6d3R3FwoEshFejfAyBAVNMjLOj6/ivKrRQdvHRVUMfLaa/suRppmFwi/tVNP8fc/8JtO2O0Ht5ywG0NrYztrdTGKRNlBw9v9lNNrXc5sdDmz3qcXp8U3I1v0GvgeB6ZqNm07U98Z4XA4bgO2ukkh8jq8sNLm+ZUOL6x0OLPe3XW6BtiowKGZ+lD0HZ1rcnS+wZHZJjONkJC0EHgJgU7xTUpg7DrSfSr6QuGlEcSyTuw1GMg6A6/BQDZIZJWUgOfzaZ7OZnkqm+NkPsVS3iS7yOSNA942Lw+XeEW4xEuDZabkwKVxHXclZXrXju20HbvnN3GMd+76hUdf4Nm6vjLat2M5XwBqVdTyZTbqpzOEzhFmLJovPLQMrAD0i1RvND2W6rVr7VWuu+hzNXb7yK0s7C6GMZBrTZYbUqVZbcecWN7m+dUuZ9a69NN8GMmTUlAJPFufN1VnYarGdCPaOU7K4bhNSHPFqbUuLyx3CrE3En39JL/oz9UjnyOFd+SR2caw+/zIXGPox+frlLrapq62aKht6vk2Phd/zFREJLJKImvFukoiKqwwyfN6gTNqmtNqgifSeU7kM5jzck1VkTLvdVnwOsXS5aC3zWF/i0kZO9HnuGsZde4WDRzF7fPVTTnbXUqbyfU9ORSBvhR4nsSX4MvSv2+sucMYMGoY6RuKwGHUr7Bt8UK0V0EFLbKohQ4aNtLnVa1Xn19Be9Ur7uZ1wm4fuR2F3cXQxhCnijMbPZ4+1+bESoezG13SXA+FnhAQBR4LkzUWJqssTNaYn6zu7Ex0OG4zjDGsbsc8v2JH/D2/3ObkWpeTqx2WNvsXfCCMM1kPOTLXHJqGl8LvyEydidBO2KjqLhXVG64vJfhKMhGQigqZrNAXVU7pOZ7SB3g8P8aX82OcNnPERLv+bEPEHPGtyDs6Nm6t5uxYHA5gFPUzQ/G3cz1Ome6VUhRdvV4xlaOMBO5i5WJ0keZNzxN9BnugwQjf1vlJu1ZBg7yI9OmgZtO9hQBUQXPHODYn7PaRO0nYnY8uJmKcWuvy3HKHF9bsh1ySjULRAhvunm5WODBVY3GqzoGpmrNXcdwxJJnizHqPU2sdTq507XrVir619qUd7OcnqhyZbXC4WA7N1DkyW+fYTIWZICMs/ffMgGjMomW35o3d6FNlXUxyzkxz0izwNXWUz6n7ecYcJuXC1+CC1+a4v8E9/gbHgw3u89eZ9C7vwu9w3K2Mp33VmG9fKc/K5g5fCiLfIwpGvn2Bd4lu3rKxQ5dLNrptSmuk8Vq/kDyaJKktkkfTbG1u8Jq3/5ITdvvBnSzszscY+yF3brPPC2tdTq91Ob3eY7uf2D9+Y4YOYbUoYHGqxsJUjYNTNeZaVTzP5YYcdxa9OOP0WncY3TtVCL5Ta122L9HAATbSd3jmfNFn13MNj8gkQx++QF+4famon0awISY5aRb5hj7KV9QxvqaPcsrMs02d8dDCjOxxb7DOff469wbrHPc3mHT1ew7HZSmbO0qjZjUW7fOKGr/Qk0SBR1B28XoCT0g87yK1fRc8iULo3DZ4qHg4e3e72+Poez97Zwm797///Xz4wx/miSeeoFqt8oY3vIEPfOADvOQlLxkeE8cxP/VTP8Xv/M7vkCQJb37zm/k//o//g4WFheExJ0+e5J3vfCef+MQnaDQavP3tb+f9738//h7HgNxNwu5itPspp9a7nFztcXq9y/LWgFwpcjX6Q/ekYH6iOrRYmZuoDicJOBx3Itu9dBjdO73W5cy6/SJ0eq3LZvfSrvW1yOfQTJ3DMw0OzTY4PFMfCsD5iaqt/zHZMNJXTt6oqB411bmk6BsQscwUJ/QBvqzv4Sl9mKfMYZ43i+RF44ZN5W5x1N/iiL/FYX+LOa/LtOzjOysWh+OSlDV9diSbjfaVET5g6EpR+vf5niCQRYTPE8OJUuVaSvDl2Jg2Y+ivneaev//xO0vYveUtb+EHfuAHeP3rX0+e5/zDf/gP+epXv8rXv/516vU6AO985zv5T//pP/Fv/s2/YWJigne/+91IKfnzP/9zAJRSvPrVr2ZxcZF/8k/+CefOneOHfuiH+NEf/VH+8T/+x3s6DyfsLiTNbVTvzHqvSGF16SW57dAt5u9JIZhuRMxNVJmdqDI/UWWmWXF+eo67gm6ccbZ4bZSi79RalzPrPZa3Ll3T50nBwmRtaDZ+sPiyVH5pmqqPOnirukNVdYfCL7yEZUuO5KRZ4IReYMVMscIUK2aSZTPFspnitJlliwaTMmbW6zEje8x5XTtpw++w6LWZln1cX5XDcXGGqV1jhvV8ZW3f7s0dY7YuclTXR2eZV/3sJ+4sYXc+q6urzM/P86lPfYpv/dZvZXt7m7m5OT70oQ/xP/wP/wMATzzxBC996Ut55JFH+JZv+Rb+6I/+iO/6ru/i7NmzwyjeBz/4Qd773veyurpKGF5eqDlhd3m0Nqx1Yk6v9Tix0ua55Q7rnRhlzPCP1pP2D3eqETHbskJvtlVluhm5mbeOu4o0V5xd73F6vceZtVLw2Wjf2fXe8MvRxaiGHgd3CL6GvT1d5/B0hckgK+xZ+sPGjqrq7qmur2ciTpu5Ypll2UyzTotN02DdtOhQw5OSiqeZ9gbMSDtLd9rrMSUH1GVKQyRURO5SvQ7HJRhv7hifz1uKQa+3zLf+b3++J2F3286Z2t7eBmB6ehqARx99lCzLeNOb3jQ85oEHHuDo0aNDYffII4/w4IMP7kjNvvnNb+ad73wnX/va13jooYdu7C9xhyKLNOz8RJXX3DcLQLuX8uxKh5NrXc5s9FjZGtBLMla2Y9baMU+e2UJgoxNTRWRvrhB7U43IGSg77lhC3+P4QovjCxe+WWttWG0POLthRd6Z9Z7dLm6vtgcMUsWzS22eXWrv+vhTjWgo9BanahyYnuPA1FHumwk43tQ0/IxQxwQmJdAxgUkIdUJoEuoi4SXiNC/h9CV/h56JOKNmOZ1bEXjGzPK4mecFs8jzZoGYiIZMaIiEg36b+4NVXhSs8SJ/jaq8fMeww3GnMxymMfwGtPMzT8V7D3jclsJOa81P/uRP8sY3vpFXvOIVACwtLRGGIZOTkzuOXVhYYGlpaXjMuKgr7y/v240kSUiSUX1Mu737m6fj0rTqIQ/dM8ND98yQK8MgU6y1Y55f7bK01WNle8Dadkyc5Zzb7LO02bc1CUXx6WyzytxEhdlWlZlWhcm6E3uOOx9ZpGEXJms8dO/cBfenueLcRp+zG+eLvi5n13u0Bxmb3YTNbsLXTm7s+hyT9ZDFqToHp4su9+lZDkzVOTRd4fikx1SQERa1fYEemTT7OsUzGQE5dZHwYnGGF3Nm1+dYNROcMIu8oBd4Nj/I09khPm1ezRkzy0G/zYv8NQ752xz02hz0t5n3ugTi0pFKh8OxO7elsHvXu97FV7/6VT796U/v+3O9//3v5xd/8Rf3/XnuJnxP0PR8mpUGx+caZEqTK0OmFBvd1H4wbdoPq9VtG5E4s97l7EZvKOY8KZhsREw3Ksy0Ksw0I2aaFSrhbfkn7XBcFaHvcWy+ybH55q73dwdZIfq6nNu0YwbPbfQ5t2nX3Thjq5ey1Ut54vTmro/RrAZFpM9aGx2YbrA4WRt2wU/XfCok1r7FDIh0PKzxi3SfwGTMiW3mxDbfJJ/c8dixCXjOHOQZdZBT+RwnzTyfMS/ijJkhkxEzXsyc12XO6zEnu8x6ts5vQsZO+DkcF+G2+xR897vfzUc/+lH+7M/+jMOHDw/3Ly4ukqYpW1tbO6J2y8vLLC4uDo/5/Oc/v+PxlpeXh/ftxj/4B/+A97znPcPb7XabI0eOXK9fZ4Qx1uDQ5AitxvxtbB2M9qsorwryzuosFQJCX2L1mMdELeSe+QYAuTbEac7y1oAXVruc2eyxujVgvZuQ5JrV7QHr7Zinz44er17xmWlWmG5WhuuJWugmZzjuShrVgBcfmuTFhyZ3vb8zSDm3YSPkpdhb2uxxtlhv9VI6g4zOYJunz27v+hihL4fG5YtTNRYnayxMNVicmmdhssahiYBJP6Wi+1R0j4ruUVV2XREZLxMv8DJe2PWxt02Nvq7QVxF9IvpU6JkKJ80k60zQpklP1khkBSUiJvyUGdkfNnu0ZOyaOxx3HbeNsDPG8Hf+zt/hIx/5CJ/85Ce55557dtz/2te+liAI+PjHP873f//3A/Dkk09y8uRJHn74YQAefvhh3ve+97GyssL8/DwAH/vYx2i1WrzsZS/b9XmjKCKKdnd73/vJa+tFo5Ji+PD5nWpF/4rwMMKzrtTCx/gVcr+G0Bo/3cJPthFotPDQftU6WCOKnLzECAFCYoS/b8OJbyS+FDQqAY3FgPsWW+TKzsLtpzlL2wOWNvustWM2ugntXkJnkNKLc3pxl5Or3eHjeJ6wkb1mhekisjfdrDj7FcddT7Ma0jwUXlT49ZPcir6N3ijit9ljeWvA8maf1faANNecKpo+LkarFo5E32SVhalpDkwd4r5pn+MtzUIlo1pG/YrFRzEh+kzQP7/caHcMrKSTnDTznDJzfN3Mc8YcZUtM0BUNAk8w6/WZkz1mvR6zno0ARmJv5tAOx+3CbdMV++M//uN86EMf4vd///d3eNdNTExQrVYBa3fyh3/4h/ybf/NvaLVa/J2/83cA+MxnPgOM7E4OHjzIL//yL7O0tMTb3vY2/qf/6X+67nYnQuf4ySaeijEIjAzRXkQWTZFV51BB3Qoz4Q/Hixjpo72oWCoYGViBZgxe3sOP1wnidcL+OcL+CrIcV2IMoliXUb9xrFCUhX60/92i3BIeRnrFeXjD80Hc2p2pxkCqNHGq6KdW7PXTnPV2zHonZquXsNVN2O4nKLX7n3izGjDViIYp3cl6xFQjchYsDsceyZWNnC9t9VkuamOXt3be7saXH2smBMw0KzbyN1FlfrLCvTMVjkwFLLZC5poB0zWP0DNInUPh3B/omKoe0KBLxKWfp21qPGcWOWEOcNIssGkatE2NVIRIIQg8iCS0vJyDga31a4nkTviO7LgDUNtLPPyL/+XOsjsRF3l1/dZv/RY//MM/DIwMin/7t397h0HxeJr1hRde4J3vfCef/OQnqdfrvP3tb+eXfumXrptBscz7BMkWGENWmaE/9QBZZZo8nEAFTYx3fSxS7EiSFKFVIeaUXXRu3arzAVIN8LI+XtoeixIW17EQjOWxoxSwGg411l6I8utov3pbCL1MaZJck+aKQaaIM02Wa7Z6CRvdhO1uzFYvZbOX0L/Eh02jGjBdCL6perFuRG4+rsNxFXTjjOUxobe01R9G/JY2+6xuDy5r6VIy3YyYn7BRv/lCBC5M2g78w5MBBxvQ9BJb26diPJ1Q0T0aprenoB9AZjxWsH5+a2aSnqgxkDVyGSGkT+QLWl7OlDdwaV7HDeOOFHa3CqWwe+5ffi+tileIKg1G42c9tBcRNw7Rn3opcfP4dRNy+8qOVHGMn3UIBmtE3ZMEySYyHzBMF+/69miKFHJgZ9zJAOOFNz0lbIwhyQ1prkhyTT9VJLlCaUOcKja7Cds9G9Xb7qW0ewlxdvG0TKMaDIXeUPg5wedwXBNaG7Z6CSvbA5a3+qxsDeyybQXgylaflW2b8t0LrVrIXKsytEyan6iyOBlx/7THsQnDgZpi0s/wTVHDbBTS5AQmo8qAvXyFTUzAOTPNClNs0qIrG8SihpIhnu9T9zSzft+leR3XDSfs9pFS2D3/z95MqxbZFKeQaOETN48xmLyftLZ4y0e49oQxeFmHYLBKOFgFo0F6mKKOzxSNHF4+wEu38ZNt/KyD0JkViiYv0tDBML2sveimij2lDWmuybUhV5pMGVKlSHNDpjT9JGerZwVfZ5DS6ads9RJ68cW9tuoVm9KdqIVM1iMm6iET9ZBGJbhopNnhcOwdYwzbvXQo/pYL4beyVYjBbSsGk0t8MRvHk4LZQvyV5uhzE1UWJyocnfI53JJM1wRGeCitCXRM3fSZMG2maeNdZsxabiTnzAxLTLPJBB3ZoCsaJLJKLit4UjLhJTRlTF2kVEXmon+OS+KE3T5SCrsv/MG/pt5oDevSEPKOaFi4ZnSOl/fx0g5+uo2fbBEOlovIX4zQKWAwMkD5VbRX3VFLOMLcWHFcpHLjXA8bNJLc2rAYIM+V7Q7sp2z1Yja7yWUFn+cJJmqF0BsXfbWISuiifA7H9cQYQzfOWNkesDpc4uH2yvaAtfaA9U58yRFu41RDb+idOVesF1oVjk/7zE7WmKqHNENDXSTUTZ9J02aGLYLLROoSE3DazHLGzLJkpllminXTYpsmXVEHL2DGSzgabHHU32TO6zrhd5fjhN0+Ugq7z/7Jf6BRr93s07ltEDqzEb1kEz/eIOovEcRrSDUY1vSNpiaX72AGI32U30AFNRA3UAyZwm4lU8SZopvkw0gf2G/8noRMGba7o3TuMK3bT1H64i+taugPI3uTdRvtm6hHNKuBG6nmcOwjudKsd+ILhV97wFopCNuDS35pO5/Il8xOVJltVZhtVXjRrLVtWpiqMVP3mQozZrwBM7SZYRtvDx58bVPlTDHO7ZyZpifqpCJEFU13QnoEUlCTOZN+zKQc0BCJE4B3KE7Y7SOlsPvP/89vsjA3g+e5yMvVIlRiI3lZf0zQiaGu8+NNKt2TBP0VvLwPaLRXRXth0WUc3rioXhHRG2S2MWOQKlKlUdrO8bMzcK3gk0XkthtntPsJW720qOWz60t9YAhRWFBUA1o1G+lr1kJatZBWNXQduw7HDWKQ5Ky1Y9Y6dirOWntgb5+37gwu3/Vb4knBXDPi5QciXr4Qcs+0z+GJgIWmx0zVMBnktLyUhoj3fp4mZM1MsMoE62aCbeq24UPUUDLC8zwqPsz5fWZk/7JpZMetiRN2+0gp7H79Az9PrValWq3QqNVo1Gs0GjUq1+p557gAL+sS9pcI+ktUuqfwsh5SZwhl07plqM+MWbcgpI327Zeps4Hc2Hq9chlkijRX6GKAc/nKEoCQAk+AFIJcGTqDhHZRv2cjfXY7u0yBeC3yrcgrhN5wuxYQBZ6r6XM4bjBxqljvWJFXmqavtWNW2zb1u9FJWGsP2Oqd7196cao+vHjW58GDFV4yF3J8ocmBiYCpCCaCnJaX0ZIDIrG3qKI2glUmWDLTtE2drqgxEBVSEZGJkFxEaC9ESJ+6lzMhYybkAN+JwFsGJ+z2kVLY/at/9r/h7ZIy832fRr1Gs16jXq9Rr1VdVO96YgxCJ3hZb7TkXWTWs00ced9avejUWr/kfQCUX0OFTVvPt6+nZ4rxaIZMa3KlSXPboJEpg9YGNSb6SoSwv1uSKdu0McjoDDLa/ZTuIKU9yEgvUxgeBR6t2ijaZ7ft7XolcLN1HY6bSK40G52E9Y712iw9N+32YLhvrRMTp3trAqkHsNAQHJsKuG+mwtGFBgenqiw0fRZqhvkoYcHrUhF7jypumgbnzAznzDRbNOiLGqmsgAzwpKTiQ8vLmPYGLvp3A3HCbh8Zr7GLwoBOt0+336fT7dHrDzj/E1sIQa1apVGvUq/XaNbrRNFtYIFyu6MVnhoQ9peIuqeptJ/Hz9oIrVB+xY5o86s3tG7PGMi1bcjItUENF1u7lynbqauNGXpJG6xYNECSKtpFp+72IKNbbHcGGf3EvnEPyxSLdRnB86SgXgloVUOatYBmNRiKvmY1pBb5buyaw3GL0E9GZutlw8d6J2ajk7DRie3Stdt7sYGZrQmOTXocmqlzcLrOkZkqixMhc3XJbEWzEMbMex0acm9RxcT4rDLJhmnRFg36okosamQyQssQT3pUfMOElxC6mb7XBSfs9pFS2H3mj/89fhhZQ9zSXFNreoOYfn9Ar9+n3++TZRkSQeBLQk/iSUEQBDTqVRr1Oo0iqielq53aT4RKrcjrnabSeQE/bSNVDEZjhIf2a2gZFqlczwq+m5TWNMaKuTKlW6Z1S4Gnx7bL/anSbPdStroJW/2EzW5hyty34s/WApodboRCiGFtoJSyEHlW6DWqO8VfLfJdmtfhuMUwxtCLcza6Y6Kv2F4/TwBudGIGl4kEtiI40pIcmZAcm61zaLbO8ZkKh1uSA7WchWDAlDfY07nlRrLMFCtmijUm2KJFV9QZiBp4AaEHdU8z7/dougkfl8UJu32kFHb/6f/5/zI12aQReUxWQ+qRj5DW6k2PfSj345iza22WN9psdXq0u30MhtDzqAQSTwiEEFSrFWrVCvValVq1Sq1acSnc/aL050s28ON1wv5SMaItLaZv5PY/cng8VvCVY99kMNa0YcZWxWi34jnKcW+IwstPhvtT73cpDCijafczNrr2zd6KvpSNXlx08GZos/NbdSn6RFEX6BVze+vVwM7vrQQ0qgH1yK4blcA1djgctziDJB8Kva1ewkYnYbNrxd9m125vDreTXTv7Qw8Wmx6H51ocnp/g0HSNw5MBhxuaI7WUQ9GAA36bYA+ROm0E6zRZNZNs0mJTtOiIZpH+raJkRCQN0/6AGdmjJrK7VgA6YbePDA2KP/f7HJieINyjNYXShkGm6CUZK1sdTq1ssbzRptvr42GoBN4FMx2qlYharUatWqFWrVKvVfHdlIN9oazHG03gKJcYmffx0zZ+2sbLe9aexWh2TOEQowSoQRS3xdCfT+gUuaPZQ6K9YOe0jh2C8cagtSHJNFv9ZPjmvjGM9iW0+xndQYa2v9XYrytGKd+ikTkKfZqVkdBrjInAejWgFrp0r8Nxu6C1oTPIzhN+I/G30U3YLATiZpEdKNWEFLBQFxydrXFsrs7R6YjDkz5HmnC4oThQyVgIB3tK0+ZGskmTNdNiyzTpUKMvqmyLJh3RZFCIwMCDpkxoioSGTGjIlLpI7pgGECfs9pFS2G1/+Y9oNetX/TjKGNpxxlYv4/R6m/XtHnEco7MUlafk2e7dTlEY2qherVpE9yoEwf42BDjG0DleMVt3p4jD3i4mkRghAIkREmFU0eTRw8u6dknbxaSOthWTxVBzjB4+XhkdLCOFRtxYM2ytDZk2JFnOVi+zHbxlJ28/Zbtv6/y6sW3suNgbiRRiGPkrU7y1KKBe8alHtrGjXvGpV5z4czhuV5Q2w07/zW7CVjdhs2eN3LcKUTgUgUXZSCsyHJoMObIwybG5OsemfI41DccaOUeqAxaD/p59+bZMnWUzRYcaHVOlTZ2OqdKnQp8qsaiQiAglAxQ+SJ+Kp2nKhIZIaciYhkxpiOSWnATihN0+cr2E3Tip0mwPMjZ6KVv9lDhTJGmGSjN0npKmMd3egP4gGRXdG40nJKEvqFciGvVRZK9ajahEkauJuh0wGpnHeHkPOezq7eNlXTu5I20j84EVfkYVsy3Hv+WOz+n1i1FvfiEw7fg3dojP63nuttxAaUM/VWz1E9q9lPYgtW/cxZv8Vs82eGitd4i/HY0eY6nfMr1biwIaFX+Y8h2Kv8h3Js4Ox22OMYZektu64HHBV4rBXkqvHyNUSmBSKr6hWa8yP1nl4ETIsZbmWD3jWC1mNkiu6hwGJmSdFpumwaZpskGTJTPNOTPNelEX2BENkB7TcsC012dW9pjx+kzLHtPegPoNMoV2wm4f2Q9hN06qNL0kpxPnrPdSeklOrjS+JzDGoNIYlWXoLGVtq8tmt0+a22iJLyVh0aQhpaRSiahWKtQqkd2uVojC0Am+24lhGjcuUsN2W6jU3s4H+FkHL2vjZT2EynYIQGE0MJ42LoWgb8VgKQQLUbhfAjBTumjqsMKv3be1feV2Z5DRjbNhTY8xYHaJAZYCsBr5ozRvxacW+dQiK/rs7YBK4Lnon8NxB6G0oVN+cSwE4HYvpT8YEKoBnkqgmFMekBMGkkboM9PwmasJ5mowGylmo4xI7r1bt2eiwgR6kjUzwZppsWomWafFhm7QNwGJCVAiwPM9ZoOMKW/ApLTNJlOyz4SMqYn0qkWgE3b7yH4Lu3G0MfQzRaY0gWcFW+AJxFi10yDNWN7qsrLR4WyR0u30B3gCKr6H7+38K/I8SSWqUK1a0VctxJ+zYLkDMHpYF2hTuza9K3SG1NlQCHpZGz/t4GWdQgjmw4jg6LEAYUapZbyh6fMoRexfV7sYreysz61BaiN/sfXx2+6PhOD2wJo4j3cJn08p/jwpRinfypjwK0VgxW47Y2eH486lrBUcjX1MafcT4kGMzmJEnuDphJCcisyZjAwLDcHhpuRIy7BQvTK7Fm0EZ8wsJ8wiz5qDnDCLnDAHeN4ssKSnQGWEOqZiYuoioSljJryU6SBlJsiZDlOaIqEmU2oioy5TaiJFtM85Ybdf3Ehhd6UYypRYyqm1DmuFyCPL0HlGmqUX+OyVeJ60Qq9a2SH4gsDZXNyxGF00hxRNIipG5sVap8OooFApUidDYSh1NqoJ5Lwmkt2eZigEw6JhJLrqyKAxhn6i2B6kbHdTtgfJKPI3SOn0rbFzL8kwRaq4pLR4kYIdf9OeFFSjMurnUw2LdWRrAMdvO5Nnh+PuIMkU272Ubn+AjnvobIDIY3ydEJqUmsypeopGaG1ipiPNVHhpO5lyAshZM8sZM8M5M8OqmWCTJhumyaZpDre3qbPjvbW/yQv/4m1O2O0Ht7KwG0cbQzexIm+1kzDIcrJcEycpcRyTJClZlqLSlDzP8C7yeeV5kiiKqIQhlSKlW4ns4jp070K0QqoBXj6wIk8Nim5fMWwYKef+SpUgsw5BsoWfbhWiMUXo0gRVoL1ouNiu4OsjnJTSVvz1MjaLeb1b3ZTtfkI3zuglOb0kJ0nzHc0dlyMKvKEALMVeLfSHwrAUgS4K6HDchRiNyWL0oI1MO0SqR80MmPBipoKMQO5dbqXGY7VI/66aSV6Ia/zoP/1DJ+z2g9tF2I2jtCHO7dD6LDdkSpNkml6aM0hz4iynM0hI4oQsScnzFJ1l5NmlXch936daiYiikGoUWQFYiahEoTNcduzEGKRK8LIOXtqxjSHJBuFgFS/rFIJvNPZIeyFGhhc0f9guZHnVNYFaWzPncr5vL83Y6tqIXy/O6ScZg1QRpzlJpoiznDhVDNIcvYun18WQQlCNPKqhFXvVaHzt7djnagEdjrsAY/BNSmhiQh0T6ZhQD/BNhm9SfJ3i6RTfZATiwshfOzFM/FJnT8LO36/fwXHr4ElBPfTZTYYqbRjkqvgQ03STnE6cEWeaJFekSYpWOSZPMUqRpilxkpCmGXme0+nmdLq9Cx43KiN8UTiM8oVhQBQ60XdXIgTar6D9Cll1brTfGBsBTDu2CSTt4KXbhPE6frpdNH8Y0BTmz6ZoKMmGljNlf60VgVZ8jVpFgGGnsG0a8YRPJQqgGjBLxNFp29yRKU2qDFluXwup0sOJHdbvzwq8QaqIk3yH6IvL/YUg1MVEgF58+SHtQkAl2F30ldE/u8+uXUeww3EbIgS5iMiJ6HsTlz7UaAKTEOiEwKQEJiHP14DOnp7KCbu7HE8KGqFPIxz9KShjzZQHqV02Byn9RBFnCgHUQp/QgyzNGCQJSZIyiBOSJCGOE3KlSNKUJE3Z3uU5wzAYCr3xdRQGzpPvbkMIO87Nr5GxsPM+nQ+7eoXRVtBhRZ3M45E9jBogsy5Sl0KPob+gMNpayWQ9PGVTwZ4ZIMbMoo3wCbwI44UYz8NEEkSANoJMC2sxZBiKPKXtrN9caTJlZ/2WY960sWngQVaIvEL4pflYFDC1kcB+Ym8bQyEYLy8CAQJfUinEXmVM8FUCz94u9lWKfU4IOhy3F0ZIUlElldXhPuUHwDN7+nkn7BwX4ImdYu8oNVKlaQ8yNvsp672UzYGy6aZag6lJb0d9UpZlRS1fYtdJTJJmDOKEPFf0ByndQWK7Gu3ELaKiXs/zJGEY2ohfFBKet3bRvrsI6Q+7Xi9IgkZX8Xg6H3YNe3m/iBK28eN1gngDLx+MLGKMRqCplBHDUjBKHx2EhW+gh8FD46O0IEegNOSFCFTakCszjAYqY9B6Z0OH1oY0z0lyTZIqksyKwX66ezRQaUOWa7Jc0xlku/+e5xH6kmroE4WlGPSoBOW6EIBj+0JfuvpAh+M2xgk7x54IPclsI2K2EXFszFB5s5+y0UvQBgJPUg08Qt+n4ftElSpRrqjm9kPNA7RWZGlGlmWkeUqeZvTjlE4/xmhF1TcoFTMYxLueRxAEREVKNwhH22EQEIaha+hwXBzpo6WPDurkzOy8z+idHb9DC5gcoVI7OSTr4qdb+MmW7RzOkmGquBSDtksYbGNIiAlDuxYVciS5hlxrcmXItY34pXlAqvQw5XuxUj5jbHQwzbUVgJkiSTVxNooMlqniJMsZJDYlbOsJU+jv7TJ5UlAJPaIx8XeBIAw9omB020UFHY5bByfsblW0gmwAWR90DkaBHo8eGJA++BUIKuBXdw6YN9o+Rjmm6vz7r4HQk8w1IuYa0dBQuRvnbAxSerGiHWeY4rhKIJmpV2hWAqqhhy/tQHkpikVCmmu2+hnntvqstfsMkgTfGITJydKMOE1Jk5RcKbLMisJub/dPqfGIX1iIwKAQf1EYOvsWx+4IiQ7q7MmxypjCKzAdTQQpfAOlTu3IuKRNEK8RpFt4WR+ptwmNYsfrF4HxJSYM0CIgFz4pAbnx0IhharcUfLm2Is1G/0K0LtK/XGg4U87vzZW2AnBsKWsD4yIqGBdp4zhTZLmtK9xrfWCJ54mhyLOCz0YCR9s7hWAUuMigw7FfOGF3PVAZpF3wIyu0rnSQu9GQp5APIO1bMSYEBDWotCBsgBeCH4IMrEAzBuJt6K/Zn+lvjA2mL/KbwgfPt/t6a/bnouLxrqPIC2shU7WQw1SJMyv0DNhC8MDDu8ybdzXwqE54zLci2nGD9W7CWjdlkCqqwJxvPxyEscIuSTLSLCMt6vjSNCdJU/I8t/VNg4tH/IQQVvBFIUEQFJE+v1gHBH7gxJ/j0giB9qtA9fKH6tx2/eaDkTegzobegKOZwR1CnRCpLsJk7JRqBiM98CQmsF3CCkFuhK39MwJtBJrR7UzDQAkyIQl8j1rFisTRCDe7LaU1c7aWLwKtNXGqSPJS/BXp4DHxt6NWMLVRQaUMPZXRi/eWHqZ4zmhM9J2/jIvE8f2B5wShw3EpnLC7Foy2gikfQDQBSRt6q1Z0SR+Cql2boptv/OfyFHQ6+gLvhTaqNnkUGnMQNQsRVrvMORgb1Ut7VlyCFX9eCF5gFwQMNqC9BJ2z0D5t94X14li/EIzXNlJKIKxIC65ONHpCMFUNmaqGHJnSdJOMTpyz2cvopzmJ0oBE+BGeH1GtQm1YLG+KiF5OkqXkWU6apmRZjlEKdI5ROcaYYWPHRX8PIQiCQuyVgm8o/HzC0O539X6Oy2GkTx5NQTR16QN1buv+8n7hD5jYJhGVIFSCl/cLMZgW00RyAp0SFk0lowaTUWpYGIXRqpgtbWv+jIYcQa4liRFkWpIhUMazqWLjIaSkGoVUizrGUgSKwu9PDPfZqGKurX1SkinSIiI4ahIpooSFKCz350Xq+UqaRko8KXYVgsPFH22HgRyKw9B3tjKOuwMn7K6WtAuby1CbgUMPQesw5LHdn3RhsAn9dZtGtW+FI9EkfajNQnXSCregZkVgUCuE2BUgCoEW1oH5ix8XNaxozAZWjHaXoLsKqogUqhxMbj8YhFcIy6Y915tA5EsiP2KmHnFsxk7U6CWKQZbbjDSjeaIGg0TiewJPltMF7NJLcrb6VhjGuSLPcozOSdOMJElJc5vuTbIMleegFFIWKaw0u+RMBX9M5JVCMAh8At8fRgNd9M+xJ6SPCluo8NL+VDswpmj2KGcDqyItrBEmG5pBlx6B5RQRP+8T5n2a+QCR90HZ14RRGUYPMFoVEUBt072FMMyNQGlhO4CFwBhrQKONQHuCXPqoioeigsLDCFl6VV8gDHOlSXNbI5jkVhDa2kEr/tJ8JBCTMUFYNqX0E9tVfKWEviwE36WFYLkv9D2iQDpR6LitcMLuakm7cPzVMHt/IaqwqdLK2BuzLr9BU4i6MXF3sz7sgypMHrGLMVbYqdSmk1VqxWlvDdpn7WK0Td1GTZtqvgkICh++0OeK2yGbEQbDIFX0UkU3tsXlQtpUkCdGQjDJNb0koxdb+5ZBkfLNspw8s759Nt2bI4xB5pp+kuKVH1hC7CoEfd8/T/idJwQLMeh5rvHDcQUIAcJ25l61y7zRQ/FnO4ZthFCqZNhIIk2Op1IilSJ0AlphVG6j4EaBUqAS+x6ic9AxqKyoERxfbKRQIVF4qMBD+R5K+OQmQlkzm11/TU8IEAYMOwTgRZd8tF2KRmBoTM0eO4rHCX1JOCb2hsLPHwnC0B/VD4ZjwtH3hPuC57hhOGF3tRz/Vjh476WPkRK4hdN1QhR1geeJpanjkCe2bq+3ZlO3/XX75i1DG/0L6zctmnelCAS10I5+mmtcWhgajO1UVNZSIs0NudFFEbomyctIQ1b4lKXFdkaeZqR5bqOAWUae5cUjpkjA9zwCT9gaoV2e2/e8QujZlK/ve7tuB4Hv0sCO64OQGK+C8ipcesrlZTCmEIjlvOFy/rBNH/s6ReTWZkZmfUTWt6PlVA4mQ+jYRg2LZhFjPanJjUdiJLHySLQkMx6e8KhGAdVo9+xGOR5uWEcobGQxyxSpGhd8elchWEYMk8y+1rPzRSFXLgqlEARltLAUfb5n9xXCsBSFgS93RArtIl3E0LFnbo9P5luRxuzNPoP9xY+gdcAuCy+zjRqDTegsQ391FM0D+05qxrv9xvdhm0mEVzSV6OKQcm1sw0nUsDWGV/qtVqsifSyvS0OIQBB6gtCTEO5+jMH6kZV1S8rY2iVljPXmo+hW1HaKwSBO2ewN2OwkdOOEfpyQZDkqyxDGYIzCE5ArRa4Ugzi57Hl6nhxG/nzfG24HgY/v+Tu2nQWMY98RAuNFKC9ChZd21QesEDT5WIQwHkYMy5SxzPtEWZda2kHmfYzK0HmKUakVf4zegoavuSJlnBtJqiXKSHI8UjwEPoHnEfg+rdqoccRG7EcR9/PfgpQ2pIX4SwuxVwrB4e2xVPL4seUUEm3MUDReLaXgC305FISlWBy/b3SMFYeBV6x9D8+Jw7sCJ+wcl0d6UJu2y8x9Npo32IJ4y6ZfpG+PKcWVkIXVik3XkCd20XlxjD9MIyEEdFcg2Ybu8qi+z6/amj+V2y7hIvWDOe+NsRSNpZWEGROWjInL8WSVECNRueP39EedzX5kG0p2EZoCW8vnIWBPmqkOTNnYXW6nesSZoptktAe5nfKRZKRlo4dRRSG8QitNluU2HZznZHmO1hqlNEolxMnlRWDZDOL7vo0KjkUAfd8bir/xY1zayLGvCIERAUoGEDQuf7jOi6aSwai5pHiNlI0iQiukTqlmPTttJO9DNigEYYZRA3TRTJIru6jxOkEo6gbtPlF0CgsBNeGjogBVtZ6Ee/0Caoovf6Xw2yEQ1YXCsEwbp/koapgrq15LY+oLBzjuHd+TFwjDcLi24q+8P/Qu3F9uO4F4a+OEnePK8SNoLtjleqC17SiOt2xXcXsJ4s1CMAa2xi+oFVG9aGcnr1d08+p8VCc43C5sY4ZvwmIk+M5fGw1xG+INyGJIOoUHoLFi1a+OBN+VNrgMn10Q+YLIl1ANgAoGQ5zp4Qi3TpzTTTLS3E4sKKcU+FIS+oLQ8xBGk6ucPLddwFme7di2IlCR5RlKaYwxpGlGmu4thSSEwCvTwoXQ8wsxWK7LmsBxYehw7BdG+qiwiaJ5hT+oi/TwAC8fIIvO4yDrE+oElK2Z1WOL/dKUkysrrpTK8XWKnw+IdBuJKnITAiU8tPAxwkcLDyU8jPAxyOF7jxCSaiSpRVdXWl1GDEeCb5QiTgrvwXGRODwu02RqpzjMVbF9+e+Dl8TzxFAYBt6F4jDw5PB26Hs7BGU4dn/guRTzfuCEnePmI6XtEK5O2vo+lVkLFxkUQu4GigZjbHQx6xc2Mv0iDb0O6cCKT1124xVFPGUaWgDIkdiU/s7tXX6PHRYxhbONNrbGr6zps9G9nG6c0UtzUqWtQ47w8SshobTCzxszfy5RSpEVIi/P1dDrL8vyQhxaEZikGVmek2UKbTTkCi/NhumqyyGEOE/0ySL6N9rn+95IDLrIoONGIORwFvGV9tD6xaKMtnYtcQc96GCStv0SmLbx0zZ+3sPPYzydEekYiSpG0hWziIutUYLANoEICQKJFh5aBlYgltNR8Ibzjj0pqEb+0H7matDa7CoMs132WRNsuy87b38pEJUy9FV+zQIRGApA37tQ9AX++LZXiEh77G4/55pULE7YOW49vAC8PdTp7AdC2EkeQQWYHu03ZjQJJOvbCN/QQ4xi0kduxV/Wh6wLeWb9BcuU9LiBNGLUXCPKb/c2lS2FR0X6VHwPQt8aTYsqysAgL6cHaLqJ7fAt35hzrcm1GX5+lG9vEmy6WnroMEQAUXXUX2yKY6QUSIqxb7m1hIlTm/7N8hytdCEMFSq3EY08V5jiGgiRDkVlWbfkSYHvCXZvF7ENI14REbR1g6NIoOftFIn2tt3vmkccNwpPSOpRCNEMTMzsfpBWkA8w6QBVlJ1obe2TMNZD075uMpTKyLPMRtTTmCDrUNE9fBUj8z6+yfGwpSWlXQzY15NFoIW04k9YW5ny/jKFDKCxHcdK2GarchTctTCcVaxGqeNs2Gim7ZdIpXeIwry4PX5/OeEERinm64EQjAnDUUTRHxeLnsQfRhovfl/5OJ68/cSiE3YOx14QwnoOXs4wehyVFzYQY3Yy5XaejLwDy7SxyQvjamVtZ0z5waDAWFOLBtAYno+BaogKauRejcxIMq1RyliBJUZGsqWcHFlQFDZoBlsv6Al8UXoB2jextBhePz7IXu/y/quUJsmsCEzTnCTPSNOcQZoWncN2n84VKi/mqRqNJ4WdIazUJQ2jd8PzJF4pCseEYCkUR2ni0W0nCh37hvQgbCDCxs4vVGNcrIBDmSI6nybkcQ+d9tBpbFPDWYJSKSq3dYJCpwQ6IdQxgUkITYqn06EJvjEMI4WSjMBkhOfFKjWeXaSHFoU4RGKEtP6EY9HCYZ1h8bOeFHihR2VvxcWXJC8E3kgIjkRfuS8fbo8E4vCY4bb9ufL9bNS9fOU+h7sxLhb9McEXeNJ+GR3bN36/L3f/Gd8T+N7+CkYn7ByO/cIrR7rVr+znhg0j2c5oXxkhLLfzBLrLeP11vP4SkdFFtLOoAxzWIpYdyVdGeI2D3dVwAL0mLd6UB5mNMvaTcjpBZjuElSoiGopc20jgcN/YfUrZ+ibfk/hefslo4MWQUhYicBQJLG+Pi8WRQBzt96R0wtBxXfGEpBZKaqEPjUu/V4x/MSu78nNlo1+ZUiili+56jVQJvh7gqwF+PiBQfTzVx8+s5Yyn+gQqxegcdGFsjUGUU0zGmsuGiYkdZ1NWGlKIQhs9tCKxiCQW5Sfjo+wofsqTPn7oUxXXLkOMMaMvoEVEcSj81LhA1DsE5fh95wvGMu28UyxeP3YIRmkjhaUYHBeApTD04u09P7YTdg7HrUYpCIPLzyJl7sW22SPetg0o3RW7LucX63zUBDLOsHmk6CqWZUq4vO3bfdIfpnGvCGPwxMVHzCmtybKULM3I8gRlfPADhPRH0UZsvaHSNgWkjX1z7Sc52/2YfpwTpylZbm1i7BQGA1oX6WGFUQZV2MgopQobGo3WmiyDqykSGheGuwpBTyI9uXO/HBOHbtap4yoRQuAJgcfFI4BXhLbm06ikmD5iJ5CochqJ1qhSTGrQRqOVxqjM/kyeofMEkfVBxXh5jKcTfJ3ZaShq9N5TFGwAII3GR1Eh3yEWTVFzaBCFOCzFYvFeZWVn8X5lI42iiHwFvvUKvFIP+4teGm3H5Y0LvdG2uahAzNXFRWMpwuHKBaNJuns+dyfsHI7bnbImsLlgJ6HA2CSRZLRtVGFDU1jR7EgRZ2NRwmKSQJaPji0Nw7yiSzls7BR7RttGk6Rjf3bc03DHdvEwxTf2iudD5BfTCrr2Ocvv99IrIpA+BGX0MQJZx4gJknzUYGIjgdrWHCpl33i1/UASWLNbUcw11UphjMYXII2dq6q0HkYGczW+PR41tNdgpzC8OsZTyZ4cicCdglDiSbuW0kYOpZT2uOJnHI5romjWINhZYjIek74SkWCM9fXMckWeJeg8Q4/NKlbGfkmzs5GtfY2XD/BVjJf3EHmMyAdDX0OhMuRwDrJBGBtRJC8jiyP7K/uuYbtSyq5kIyRCSHQhCm0jS3mf3bZiUhaxSntc2dEceB7B2Ovsenwf09rsEIDjIrEUkrkeF4r2+LS99/kyTtg5HHciXmEFE15hGhgKYZftTAeXncrdlcKS5owVc14EZY1PUIPGHLQO2dF6RhcG0mOCcijWwmIpUsY6G/kd5rFdpz27ZP2xmcb2fARQKRa8AAIPfA1VK8bKN85cG4zWaIQdWVWY18bK0I0VqYZUCwJPIKMAKSNsIbrEFG61Ugh0MRs108baYZTrIlo4njrWWqMK42ylNUZptLHeg1prBIJMKUQx62F8yuClInnn3yOEGIpC6Y0E37hAHEYKpdxxzPjPufSy43ohhMAXAj+UEF57TNGoHKNT+xpWZUNKEUnME3SWoLMYnSeYLEFlCaZ8H1EpUmd4JkeaDGkUnlHAeMrZ4KEJhrLO3jee4Bhtjr8CR/HHsqJRF4sZF5KFV2sZcTTCQ0iP0LPG0leC2t67qnTCzuFw7ESWqdfKhffN3l+kfrfsJJLuCoRNO4mlOm29Bq+KijWm3o3xmcZ52YCS2O08tuIvT6zA8yN8L8QvbWagEJWZ7VLWI6/DPE9JkpQkTYmznF6ckQ/TtQZjNEbbCSllzVFhZ2s/GHyBCGDYsSgkyJAcnxyPHA8lAxT+cAaq0oX4U3pYD6WKmsJM2WiiylVxnLaGusqmvzJtfy7X6oKPGPsxImxn83B2sR1lJRHDpuuykeZ8Su/CXQWgP6otLG+X23IYURyPJLpUs+P6IDwf4dnX8ZXGp42xUfus+IKnDeTamlqXdYXS5EitkMamjj2TI8oMhbYisJxuZLT9goaxpR5Ga4zRCJXhaTs9xSsjjTqFIjNgyulIRg9NtaXROwTjji93jCSkLrqaFT6Z3nuDmRN2DofjyggqECxCcxHmX7r/zzc+0/g61c/AyKesXrzZ72hOKaeYmOLNG1u7N2pi0aP6xTJdnac2uph0IE/QKkXnKVoNMNpQzqsyMsQU5tpGFKkw4Vu5WIzKOl8WlY5o5eg6KwStKbWdXZwTZzlx2ZSSpdavUCmb0slzG8HMc5uOLqaXaKOHUQfJSBSeLw4p7heFhc3lkGNC8HyhOIoSjkThzv1ybL8Ti46rQwgxnM19wzGmEHAKoW29os4zsiwhTxPyLLWp6qzYVgqlyxo8DVrjmZS67lLVPSp6MCqH2QNO2Dkcjrub0k/wIlyVnFB2DqocpoWKddqHtANJt4gc9iEtbG9gbCSed2HzipDgFw0ukQQRgqwyHM03hsE2neiytqlYdCEOh52VupxSkFtrmkwRZxlxkhVNKXrYbamKlHOSq2Gdoa15siK4bE6xF0wN57B60hb8Xyvni8WdItBDSrEjsiiLGkUxvr8QjFJIl4Z27B9CgPAx+BjPfhsVkR0/fpER5EPK16w2xZc5A0plpKe/AnxhT0/vhJ3D4XBcb8rO5ovVOBpTNK4kY76G5/kclrWGKrZp5GGUsEwRjUUOxynqePzzJ58ERT3jHinFXznEXhcfNmUnX6IU/dQuStnUUin4lLbpYzu1wC6qiEpobSOj5bpMa5X36eK48jGEAE8IpDBIT12xvc3lKGsVxXmi0aanLxSN4wJzJBrHjvEK4egijY6rQAqB9M77mwk8TK2158dwws7hcDhuNEKAH9plL5Tp4vFmlHK9Y0ZyOmo8yfojwZj1R40wYKN+XmjT22KsE3A4Gk8gRWHmXEYP/eLD5rx0uMEMjat3WFcUNU25MmR6p9G13V/Y3hSNKOXUBMnIXBsDcZoNTWpLkWjGBKQ0w7NAaIOyIUl0UQtFUQtlin1ajyxv7Hkaa5ejFNfQ6HxRzheO4nyRKMRIDJZRxPP2SSF2iEchxXn3OQHpGOGEncPhcNzqlOli7wo7DbUeNYzkiR2LVzacDLas12FZU6hLF9qyzlCPCcrSsHZ8PjJQNGN4OyRdOS5PEIzVKo5+F2Ez335ZTbiLx+JYW6I2glwra8ZbeIspLcmRZMYn0ZJEC1Jlo4um+LVN8ftrIW0jS+GRNpQ/xXNIDJ6w67K2Uo9HEAshqJQViGUkcbzTWRtjG2K0HkYfy1F7+y0ch5f1ooJwFwEpR/uHkUlRCsaRiBwet8vPOG5dnLBzOByOOxUprfefH+3edazHmkZKEYYZdQUOOwTHJ6AUx8DYJBQzZmtT2OMYPaoPLCN/w/bc82Ykj0cMYWxEgUEaTbijaUUVIrWY25zFoDOMVpTyU5enBLb2T2Uoldg0r7FRvSyHWMEgFyTadjHnWlBOdBYCfE+AJxCF7GP0myOKma3DKQtj013KtLQphaGxArCs5vQESGF92QymEIpmpzDUZkxcjvaVJsG6TGeX/5Vao8GOIdxnhChFn1cIQYGQFwpJIeWwU3soFsf3j4lGMRSPY9uijGyOxps5Lo8Tdg6Hw3G3Ij2u3EjiFqOoVxQ6H2vSGBMARhW1i2Oj+sr6xrSPSbukcc92K+a5nbRQmOmW0wfsTGWJV2hPT4iiaaSIiBprbUHR2QylJ+FIBiqt6aeKQWatbcqGlmHUUoAMbL2e8KwgFtJHSA8hfCuGCvsP648mR5NUjBlGEUdRRoPW6rz7zNj9alg7OR5l3IuINMaglBmadt8odgjGXQTleNp7h4gcu78UjOXEip33lY8vdhGct0+TjRN2DofD4bh9KesVL9lveHGjbgFExhCp9PKWEjuca8fqHs+f6zyMfjKKcBYRSoNNG8fKkGSKPMvseL0sI0kT0mRAnsSYsrFGZaAT0DlaK4wujXYLd0Rh3QkNBmlM4V0IQvpo6SGkNfA2nmcba4SHKUYICmzX8EV/3eIfG1cEXXZEG8ZEpBV+Rptilq0uPN6wtY12Yygay20wO4XmeXWQZrgeS8vfwKjkblxMWJYekjvF4YXishSSo/ukFfTnicjRcSOBmV/B7+yEncPhcDjubkqvxBvxVNj+k8s9m9LlCDxDnqeoPLMiME9RmfVEU3lKmuVFDaRtGjFGYVSOyAeYLMZkA8hTtMoxKi6Ephp1VcPOmkkxPgpwbKvMko85LZqxA4RnihmvxZiuwmpXW2VoKxhNMdbLgGIkdMtUvBim6wVCena/ESMfR6OHZt/GGIQpz8EMbw+FYRnJHBOJVhiXYtSKT12MHiyNybUZ/9mdQv9mCst47eSej3XCzuFwOByOWwxPCjzp2U/p6Bo/qouoolZFLaJWxbiu3E5G0MaOuBuvY4ThFJphSlgWzSfDzmx7rChS0UblGJVhVGrXhXgsbXNMKaCUQqmsWOd2okoxks8KLIUx9tysUGN433BB29NlzPNNM4xigsEIkL6dDCMFwwiYkH5hvG3FoLDjZTDYaOcoRmhTzhqB1gYpRrWbBlFYAQmUKcSqEUOvSDXWLa6NNRY3RqCKYK6mWA9T4KOopTGXFpiXwwk7h8PhcDjuZAqBJgM7JvCWqqo0Y53TZXp7vFlm2LDDsP5PqbI+UKGVKeoiy7rFUQe10pDlilgZMgWpMqTKoJGFYbe1yBmmzo1GGIUwGokabgudjQSnsucnMEhyhCoGCBqNj8YrmmLEsHt8FL+Uxf2eMHiU/TYSU3SXm/LndvFq3Jx1kyccDofD4XDc6pSz6y4x/aWk7Cq+QtOfHeih6LNRMSjTxGas1aU8NTG8rYwhV8ZOY9E2kpcVYjLNNUkxwWWQZ6jc1lmW82StnZAqbHNydF7WS+aIIjVuI4eFsCxOatwIqFvv7vl3dMLO4XA4HA7HXYGUgnAP846vN8YYssKkO1eGtDDrVmMiUxuKNCyYMVknEHQ77T0/lxN2DofD4XA4HPuIEILQF4T+1dmmtGvm8gcV3D7GLA6Hw+FwOByOS+KEncPhcDgcDscdghN2DofD4XA4HHcITtg5HA6Hw+Fw3CE4YedwOBwOh8Nxh+CEncPhcDgcDscdghN2DofD4XA4HHcITtg5HA6Hw+Fw3CE4YedwOBwOh8Nxh+CEncPhcDgcDscdghN2DofD4XA4HHcITtg5HA6Hw+Fw3CE4YedwOBwOh8Nxh3BXCrtf//Vf5/jx41QqFb75m7+Zz3/+8zf7lBwOh8PhcDiumbtO2P37f//vec973sMv/MIv8Nhjj/GqV72KN7/5zaysrNzsU3M4HA6Hw+G4Ju46Yfcrv/Ir/OiP/ijveMc7eNnLXsYHP/hBarUav/mbv3mzT83hcDgcDofjmrirhF2apjz66KO86U1vGu6TUvKmN72JRx555CaemcPhcDgcDse149/sE7iRrK2toZRiYWFhx/6FhQWeeOKJXX8mSRKSJBne3t7eBqDdbu/fiTocDofD4XAUlJrDGHPZY+8qYXc1vP/97+cXf/EXL9h/5MiRm3A2DofD4XA47lY6nQ4TExOXPOauEnazs7N4nsfy8vKO/cvLyywuLu76M//gH/wD3vOe9wxva63Z2NhgZmYGIcS+nu/NpN1uc+TIEU6dOkWr1brZp3PL4q7T3nHXau+4a7U33HXaO+5a7Z1b8VoZY+h0Ohw8ePCyx95Vwi4MQ1772tfy8Y9/nO/5nu8BrFD7+Mc/zrvf/e5dfyaKIqIo2rFvcnJyn8/01qHVat0yf9i3Mu467R13rfaOu1Z7w12nveOu1d651a7V5SJ1JXeVsAN4z3vew9vf/nZe97rX8U3f9E386q/+Kr1ej3e84x03+9QcDofD4XA4rom7Ttj9jb/xN1hdXeXnf/7nWVpa4tWvfjV//Md/fEFDhcPhcDgcDsftxl0n7ADe/e53XzT16rBEUcQv/MIvXJCGduzEXae9467V3nHXam+467R33LXaO7f7tRJmL72zDofD4XA4HI5bnrvKoNjhcDgcDofjTsYJO4fD4XA4HI47BCfsHA6Hw+FwOO4QnLC7i3n/+9/P61//eprNJvPz83zP93wPTz755I5j4jjmXe96FzMzMzQaDb7/+7//AoPnu41f+qVfQgjBT/7kTw73ues04syZM/zNv/k3mZmZoVqt8uCDD/LFL35xeL8xhp//+Z/nwIEDVKtV3vSmN/H000/fxDO+OSil+Lmf+znuueceqtUq9913H//oH/2jHSOD7tZr9Wd/9mf81b/6Vzl48CBCCH7v935vx/17uS4bGxu89a1vpdVqMTk5yd/6W3+Lbrd7A3+L/edS1ynLMt773vfy4IMPUq/XOXjwID/0Qz/E2bNndzzG3XCd4PJ/U+P82I/9GEIIfvVXf3XH/tvlWjlhdxfzqU99ine961189rOf5WMf+xhZlvGX//JfptfrDY/5e3/v7/EHf/AH/O7v/i6f+tSnOHv2LN/3fd93E8/65vKFL3yB//P//D955StfuWO/u06Wzc1N3vjGNxIEAX/0R3/E17/+df73//1/Z2pqanjML//yL/PP//k/54Mf/CCf+9znqNfrvPnNbyaO45t45jeeD3zgA/zGb/wG//Jf/ku+8Y1v8IEPfIBf/uVf5l/8i38xPOZuvVa9Xo9XvepV/Pqv//qu9+/lurz1rW/la1/7Gh/72Mf46Ec/yp/92Z/xt//2375Rv8IN4VLXqd/v89hjj/FzP/dzPPbYY3z4wx/mySef5Lu/+7t3HHc3XCe4/N9UyUc+8hE++9nP7jrh4ba5VsbhKFhZWTGA+dSnPmWMMWZra8sEQWB+93d/d3jMN77xDQOYRx555Gad5k2j0+mY+++/33zsYx8z3/Zt32Z+4id+whjjrtM4733ve81/9V/9Vxe9X2ttFhcXzT/5J/9kuG9ra8tEUWR++7d/+0ac4i3Dd37nd5of+ZEf2bHv+77v+8xb3/pWY4y7ViWA+chHPjK8vZfr8vWvf90A5gtf+MLwmD/6oz8yQghz5syZG3buN5Lzr9NufP7znzeAeeGFF4wxd+d1Mubi1+r06dPm0KFD5qtf/ao5duyY+Wf/7J8N77udrpWL2DmGbG9vAzA9PQ3Ao48+SpZlvOlNbxoe88ADD3D06FEeeeSRm3KON5N3vetdfOd3fueO6wHuOo3zH//jf+R1r3sdf+2v/TXm5+d56KGH+Ff/6l8N7z9x4gRLS0s7rtXExATf/M3ffNddqze84Q18/OMf56mnngLgy1/+Mp/+9Kf5K3/lrwDuWl2MvVyXRx55hMnJSV73utcNj3nTm96ElJLPfe5zN/ycbxW2t7cRQgzHYrrrNEJrzdve9jZ++qd/mpe//OUX3H87Xau70qDYcSFaa37yJ3+SN77xjbziFa8AYGlpiTAML5iNu7CwwNLS0k04y5vH7/zO7/DYY4/xhS984YL73HUa8dxzz/Ebv/EbvOc97+Ef/sN/yBe+8AX+7t/9u4RhyNvf/vbh9Th/0svdeK1+5md+hna7zQMPPIDneSileN/73sdb3/pWAHetLsJersvS0hLz8/M77vd9n+np6bv22sVxzHvf+15+8Ad/cDj/1F2nER/4wAfwfZ+/+3f/7q73307Xygk7B2CjUV/96lf59Kc/fbNP5Zbj1KlT/MRP/AQf+9jHqFQqN/t0bmm01rzuda/jH//jfwzAQw89xFe/+lU++MEP8va3v/0mn92txX/4D/+Bf/fv/h0f+tCHePnLX87jjz/OT/7kT3Lw4EF3rRzXlSzL+Ot//a9jjOE3fuM3bvbp3HI8+uij/Nqv/RqPPfYYQoibfTrXjEvFOnj3u9/NRz/6UT7xiU9w+PDh4f7FxUXSNGVra2vH8cvLyywuLt7gs7x5PProo6ysrPCa17wG3/fxfZ9PfepT/PN//s/xfZ+FhQV3nQoOHDjAy172sh37XvrSl3Ly5EmA4fU4v2P4brxWP/3TP83P/MzP8AM/8AM8+OCDvO1tb+Pv/b2/x/vf/37AXauLsZfrsri4yMrKyo778zxnY2Pjrrt2pah74YUX+NjHPjaM1oG7TiX/5b/8F1ZWVjh69OjwPf6FF17gp37qpzh+/Dhwe10rJ+zuYowxvPvd7+YjH/kIf/qnf8o999yz4/7Xvva1BEHAxz/+8eG+J598kpMnT/Lwww/f6NO9aXzHd3wHf/EXf8Hjjz8+XF73utfx1re+dlzT1QAACO9JREFUdbjtrpPljW984wWWOU899RTHjh0D4J577mFxcXHHtWq323zuc5+7665Vv99Hyp1vwZ7nobUG3LW6GHu5Lg8//DBbW1s8+uijw2P+9E//FK013/zN33zDz/lmUYq6p59+mv/3//1/mZmZ2XG/u06Wt73tbXzlK1/Z8R5/8OBBfvqnf5o/+ZM/AW6za3WzuzccN493vvOdZmJiwnzyk580586dGy79fn94zI/92I+Zo0ePmj/90z81X/ziF83DDz9sHn744Zt41rcG412xxrjrVPL5z3/e+L5v3ve+95mnn37a/Lt/9+9MrVYz//bf/tvhMb/0S79kJicnze///u+br3zlK+a//+//e3PPPfeYwWBwE8/8xvP2t7/dHDp0yHz0ox81J06cMB/+8IfN7Oys+Z//5/95eMzdeq06nY750pe+ZL70pS8ZwPzKr/yK+dKXvjTs5tzLdXnLW95iHnroIfO5z33OfPrTnzb333+/+cEf/MGb9SvtC5e6Tmmamu/+7u82hw8fNo8//viO9/gkSYaPcTdcJ2Mu/zd1Pud3xRpz+1wrJ+zuYoBdl9/6rd8aHjMYDMyP//iPm6mpKVOr1cz3fu/3mnPnzt28k75FOF/Yues04g/+4A/MK17xChNFkXnggQfM//V//V877tdam5/7uZ8zCwsLJooi8x3f8R3mySefvElne/Not9vmJ37iJ8zRo0dNpVIx9957r/nZn/3ZHR+6d+u1+sQnPrHre9Pb3/52Y8zersv6+rr5wR/8QdNoNEyr1TLveMc7TKfTuQm/zf5xqet04sSJi77Hf+ITnxg+xt1wnYy5/N/U+ewm7G6XayWMGbM5dzgcDofD4XDctrgaO4fD4XA4HI47BCfsHA6Hw+FwOO4QnLBzOBwOh8PhuENwws7hcDgcDofjDsEJO4fD4XA4HI47BCfsHA6Hw+FwOO4QnLBzOBwOh8PhuENwws7hcDgcDofjDsEJO4fD4XA4HI47BCfsHA6Hw+FwOO4QnLBzOByOy/Dt3/7tCCEQQvD444/f7NPZwd//+3+f7/me77no/T/8wz88PPff+73fu2Hn5XA4bg5O2DkcjruKb/u2bxsKnTAMeelLX8qHPvShy/7cj/7oj3Lu3Dle8YpXACPB9GM/9mMXHPuud70LIQQ//MM/fL1Pn3e84x38L//L/zK8/fjjj/PKV77yosf/2q/9GufOnbvu5+FwOG5NnLBzOBx3DcYYvvSlL/FP/+k/5dy5czz55JO85S1v4Yd+6Ic4ceLEJX+2VquxuLiI7/vDfUeOHOF3fud3GAwGw31xHPOhD32Io0ePXvfzV0rx0Y9+lO/+7u8e7vvyl7/Mq171qov+zMTEBIuLi9f9XBwOx62JE3YOh+Ou4emnn6bT6fCWt7yFxcVF7rnnHv7W3/pbKKV48sknr/jxXvOa13DkyBE+/OEPD/d9+MMf5ujRozz00EM7jv32b/923v3ud/Pud7+biYkJZmdn+bmf+zmMMcNjtNb88i//Mi960YuIooijR4/yvve9b3j/Zz7zGYIg4PWvfz0Ap0+fZm1tDYC/9Jf+ErVajZe85CV87nOfu+LfxeFw3Bk4YedwOO4aHn30UaampnjZy14GWGH0sz/7s0RRdMl05qX4kR/5EX7rt35rePs3f/M3ecc73rHrsf/3//1/4/s+n//85/m1X/s1fuVXfoV//a//9f+/vbsLZe8N4AD+XQdZRhJpYilGKbULrWEXakSN7VqJUrRSVtK8FNdcaOSluVDjArlZm2vlRu2C4yxluTAmdrEbw4W35H93+u/n90Pzy//v7Pu5O8/ree6+neec58j1Y2NjmJqawsTEBI6Pj7G+vo7i4mK5PhAIoKOjAyqVCgDk9/0WFxcxPj6OUCgEnU6H0dHRlNZCRD9fxsdNiIiUQRRF3NzcIDc3Fy8vL3h4eIBarYbH40FJSUlKY3Z1dWFsbAzRaBQAsLe3h83NTezu7r5pW1ZWBrfbDZVKherqahwdHcHtdqOvrw93d3eYm5vDwsICenp6AAAVFRUwm81yf7/fD7fbLV9LkoSCggJsbW2hsLAQAGCz2bC8vJzSWojo52OwI6K0IYoiBgYGMDg4iEQigeHhYTQ2Nn7pI4eioiJYrVZ4vV68vr7CarXKIetXJpNJftoGAPX19ZiZmcHLywvC4TAeHx9hsVh+2zccDiMWiyXVS5IEu92eNN/Z2RkqKytTXg8R/WzciiWitCGKIhoaGlBZWYm6ujosLS1henoa5+fnXxq3t7cXXq8Xq6ur6O3tTWkMtVr9bn0gEEBLSwuys7PlMkmSYDKZktpJkgSDwZDSPRDRz8dgR0RpIRKJIJFIyMeVAEBNTQ0qKio+ddzJe9ra2vD09ITn52e0trb+sd2vHzUEg0Ho9XoIggC9Xg+1Wo2dnZ3f9vX7/bDb7fL13d0dIpHIm480GOyI0huDHRGlhYODA2RmZqKqqiqp3GKxwOfzfWlsQRAQDodxfHwMQRD+2O7i4gJDQ0M4OTnBxsYG5ufn4XQ6AQDZ2dkYGRmBy+XC2toaTk9PEQwGsbKygng8jv39fbS3t8tjhUIhCIKA2tpauSwajeL6+prBjiiN8R07IkoLoihCr9cjKysrqby5uRkejweXl5coLS1Nefy8vLwP23R3d+P+/h5GoxGCIMDpdKK/v1+un5iYQEZGBiYnJxGLxaDVauFwOLC9vQ2j0Zj0Lp0kSaiurk7amj08PER+fj7Ky8tTXgcR/Wyq138fokRERG80NTXBYDBgdnb2PxnDZrPBbDbD5XKlPL9KpYLP53v392NE9PNxK5aI6BOWlpag0WhwdHT07XObzWZ0dnam1NfhcECj0fzlOyKi/ys+sSMi+sDV1ZX82zCdTvdmO/cz/sZTv1TE43Hc3t4CALRaLXJycr51fiL6Xgx2RERERArBrVgiIiIihWCwIyIiIlIIBjsiIiIihWCwIyIiIlIIBjsiIiIihWCwIyIiIlIIBjsiIiIihWCwIyIiIlIIBjsiIiIihWCwIyIiIlIIBjsiIiIihfgHJdOj2rk3Bw8AAAAASUVORK5CYII=",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -83,6 +101,7 @@
    "source": [
     "distances, bf_volume_part = read_key(\"bf_volume_part\")\n",
     "distances, bf_vrad_weighted_part = read_key(\"bf_vrad_weighted_part\")\n",
+    "distances, bf_vrad_weighted_halo = read_key(\"bf_vrad_weighted_halo\")\n",
     "\n",
     "plt.figure()\n",
     "plt.title(\"Bulk flow magnitude comparison\")\n",
@@ -98,18 +117,28 @@
     "plt.plot(Rs[m], mode[m], color=\"black\", label=r\"$\\Lambda\\mathrm{CDM}$\")\n",
     "\n",
     "# Volume averaging\n",
-    "y = np.linalg.norm(bf_volume_part, axis=-1)\n",
-    "ylowlow, ylow, ymed, yhigh, yhighhigh = np.percentile(y, [5, 16, 50, 84, 95], axis=0)\n",
-    "plt.fill_between(distances, ylowlow, yhighhigh, alpha=0.25, color=cols[0])\n",
-    "plt.fill_between(distances, ylow, yhigh, alpha=0.5, color=cols[0])\n",
-    "plt.plot(distances, ymed, label=r\"$B_i = \\langle v_i \\rangle_R$\", color=cols[0])\n",
+    "# y = np.linalg.norm(bf_volume_part, axis=-1)\n",
+    "# ylowlow, ylow, ymed, yhigh, yhighhigh = np.percentile(y, [5, 16, 50, 84, 95], axis=0)\n",
+    "# plt.fill_between(distances, ylowlow, yhighhigh, alpha=0.25, color=cols[0])\n",
+    "# plt.fill_between(distances, ylow, yhigh, alpha=0.5, color=cols[0])\n",
+    "# plt.plot(distances, ymed, label=r\"$B_i = \\langle v_i \\rangle_R$\", color=cols[0])\n",
+    "\n",
+    "# # 1 / r^2\n",
+    "# y = np.linalg.norm(bf_vrad_weighted_part, axis=-1)\n",
+    "# ylowlow, ylow, ymed, yhigh, yhighhigh = np.percentile(y, [5, 16, 50, 84, 95], axis=0)\n",
+    "# plt.fill_between(distances, ylowlow, yhighhigh, alpha=0.25, color=cols[1])\n",
+    "# plt.fill_between(distances, ylow, yhigh, alpha=0.5, color=cols[1])\n",
+    "# plt.plot(distances, ymed, label=r\"$B_i = R^2 \\langle v_r \\hat{n}_i / r^2 \\rangle_R$\", color=cols[1])\n",
+    "\n",
     "\n",
     "# 1 / r^2\n",
-    "y = np.linalg.norm(bf_vrad_weighted_part, axis=-1)\n",
+    "y = np.linalg.norm(bf_vrad_weighted_halo, axis=-1)\n",
     "ylowlow, ylow, ymed, yhigh, yhighhigh = np.percentile(y, [5, 16, 50, 84, 95], axis=0)\n",
-    "plt.fill_between(distances, ylowlow, yhighhigh, alpha=0.25, color=cols[1])\n",
-    "plt.fill_between(distances, ylow, yhigh, alpha=0.5, color=cols[1])\n",
-    "plt.plot(distances, ymed, label=r\"$B_i = R^2 \\langle v_r \\hat{n}_i / r^2 \\rangle_R$\", color=cols[1])\n",
+    "plt.fill_between(distances, ylowlow, yhighhigh, alpha=0.25, color=cols[2])\n",
+    "plt.fill_between(distances, ylow, yhigh, alpha=0.5, color=cols[2])\n",
+    "plt.plot(distances, ymed, label=\"Halo radial velocities\", color=cols[2])\n",
+    "\n",
+    "\n",
     "\n",
     "plt.legend()\n",
     "plt.xlim(distances[2], distances.max())\n",
@@ -122,6 +151,89 @@
     "plt.show()"
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(1377, 100, 3)"
+      ]
+     },
+     "execution_count": 23,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "bf_volume_part.shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "150.0\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "from scipy.stats import norm\n",
+    "\n",
+    "k = -1\n",
+    "\n",
+    "print(distances[k])\n",
+    "\n",
+    "plt.figure()\n",
+    "\n",
+    "plt.hist(np.linalg.norm(bf_volume_part[:, k, :], axis=-1), bins=\"auto\", density=1, histtype=\"step\")\n",
+    "\n",
+    "\n",
+    "plt.hist(np.linalg.norm(bf_vrad_weighted_part[:, k, :], axis=-1), bins=\"auto\", density=1, histtype=\"step\")\n",
+    "\n",
+    "plt.hist(np.linalg.norm(bf_vrad_weighted_halo[:, k, :], axis=-1), bins=\"auto\", density=1, histtype=\"step\")\n",
+    "\n",
+    "\n",
+    "d = norm(387, 28)\n",
+    "t = np.linspace(0, 500, 1000)\n",
+    "plt.plot(t, d.pdf(t) / 3)\n",
+    "\n",
+    "plt.xlim(0, 500)\n",
+    "\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
diff --git a/scripts/flow_validation.py b/scripts/flow_validation.py
index 6d3a319..d5d262c 100644
--- a/scripts/flow_validation.py
+++ b/scripts/flow_validation.py
@@ -33,7 +33,7 @@ def parse_args():
     parser.add_argument("--simname", type=str, required=True,
                         help="Simulation name.")
     parser.add_argument("--catalogue", type=str, required=True,
-                        help="PV catalogue.")
+                        help="PV catalogues.")
     parser.add_argument("--ksmooth", type=int, default=1,
                         help="Smoothing index.")
     parser.add_argument("--ksim", type=none_or_int, default=None,
@@ -42,7 +42,12 @@ def parse_args():
                         help="Number of devices to request.")
     parser.add_argument("--device", type=str, default="cpu",
                         help="Device to use.")
-    return parser.parse_args()
+    args = parser.parse_args()
+
+    # Convert the catalogue to a list of catalogues
+    args.catalogue = args.catalogue.split(",")
+
+    return args
 
 
 ARGS = parse_args()
@@ -58,8 +63,7 @@ from os.path import join
 import csiborgtools                                                             # noqa
 import jax                                                                      # noqa
 from h5py import File                                                           # noqa
-from mpi4py import MPI                                                          # noqa
-from numpyro.infer import MCMC, NUTS, Predictive, init_to_median                # noqa
+from numpyro.infer import MCMC, NUTS, init_to_median                            # noqa
 
 
 def print_variables(names, variables):
@@ -68,8 +72,8 @@ def print_variables(names, variables):
     print(flush=True)
 
 
-def get_model(paths, get_model_kwargs, verbose=True):
-    """Load the data and create the NumPyro model."""
+def get_models(get_model_kwargs, verbose=True):
+    """Load the data and create the NumPyro models."""
     paths = csiborgtools.read.Paths(**csiborgtools.paths_glamdring)
     folder = "/mnt/extraspace/rstiskalek/catalogs/"
 
@@ -86,55 +90,45 @@ def get_model(paths, get_model_kwargs, verbose=True):
         print(f"{'Num. realisations:':<20} {len(nsims)}")
         print(flush=True)
 
-    if ARGS.catalogue == "A2":
-        fpath = join(folder, "A2.h5")
-    elif ARGS.catalogue in ["LOSS", "Foundation", "Pantheon+", "SFI_gals",
-                            "2MTF", "SFI_groups", "SFI_gals_masked",
-                            "Pantheon+_groups", "Pantheon+_groups_zSN",
-                            "Pantheon+_zSN"]:
-        fpath = join(folder, "PV_compilation.hdf5")
-    else:
-        raise ValueError(f"Unsupported catalogue: `{ARGS.catalogue}`.")
+    # Get models
+    models = [None] * len(ARGS.catalogue)
+    for i, cat in enumerate(ARGS.catalogue):
+        if cat == "A2":
+            fpath = join(folder, "A2.h5")
+        elif cat in ["LOSS", "Foundation", "Pantheon+", "SFI_gals",
+                     "2MTF", "SFI_groups", "SFI_gals_masked",
+                     "Pantheon+_groups", "Pantheon+_groups_zSN",
+                     "Pantheon+_zSN"]:
+            fpath = join(folder, "PV_compilation.hdf5")
+        else:
+            raise ValueError(f"Unsupported catalogue: `{ARGS.catalogue}`.")
 
-    loader = csiborgtools.flow.DataLoader(ARGS.simname, nsim_iterator,
-                                          ARGS.catalogue, fpath, paths,
-                                          ksmooth=ARGS.ksmooth)
+        loader = csiborgtools.flow.DataLoader(ARGS.simname, nsim_iterator,
+                                              cat, fpath, paths,
+                                              ksmooth=ARGS.ksmooth)
+        models[i] = csiborgtools.flow.get_model(loader, **get_model_kwargs)
 
     print(f"\n{'Num. radial steps':<20} {len(loader.rdist)}\n", flush=True)
-
-    return csiborgtools.flow.get_model(loader, **get_model_kwargs)
+    return models
 
 
 def get_harmonic_evidence(samples, log_posterior, nchains_harmonic, epoch_num):
     """Compute evidence using the `harmonic` package."""
     data, names = csiborgtools.dict_samples_to_array(samples)
     data = data.reshape(nchains_harmonic, -1, len(names))
-    log_posterior = log_posterior.reshape(10, -1)
+    log_posterior = log_posterior.reshape(nchains_harmonic, -1)
 
     return csiborgtools.harmonic_evidence(
         data, log_posterior, return_flow_samples=False, epochs_num=epoch_num)
 
 
-def get_simulation_weights(samples, model, model_kwargs):
-    """Get the weights per posterior samples for each simulation."""
-    predictive = Predictive(model, samples)
-    ll_all = predictive(
-        jax.random.PRNGKey(1), store_ll_all=True, **model_kwargs)["ll_all"]
-
-    # Multiply the likelihood of galaxies
-    ll_per_simulation = jax.numpy.sum(ll_all, axis=-1)
-    # Normalization by summing the likelihood over simulations
-    norm = jax.scipy.special.logsumexp(ll_per_simulation, axis=-1)
-    return ll_per_simulation - norm[:, None]
-
-
 def run_model(model, nsteps, nburn,  model_kwargs, out_folder, sample_beta,
               calculate_evidence, nchains_harmonic, epoch_num, kwargs_print):
     """Run the NumPyro model and save output to a file."""
     try:
-        ndata = model.ndata
+        ndata = sum(model.ndata for model in model_kwargs["models"])
     except AttributeError as e:
-        raise AttributeError("The model must have an attribute `ndata` "
+        raise AttributeError("The models must have an attribute `ndata` "
                              "indicating the number of data points.") from e
 
     nuts_kernel = NUTS(model, init_strategy=init_to_median(num_samples=1000))
@@ -143,7 +137,6 @@ def run_model(model, nsteps, nburn,  model_kwargs, out_folder, sample_beta,
 
     mcmc.run(rng_key, extra_fields=("potential_energy",), **model_kwargs)
     samples = mcmc.get_samples()
-    simulation_weights = get_simulation_weights(samples, model, model_kwargs)
 
     log_posterior = -mcmc.get_extra_fields()["potential_energy"]
     log_likelihood = samples.pop("ll_values")
@@ -165,7 +158,7 @@ def run_model(model, nsteps, nburn,  model_kwargs, out_folder, sample_beta,
         neg_ln_evidence = jax.numpy.nan
         neg_ln_evidence_err = (jax.numpy.nan, jax.numpy.nan)
 
-    fname = f"samples_{ARGS.simname}_{ARGS.catalogue}_ksmooth{ARGS.ksmooth}.hdf5"  # noqa
+    fname = f"samples_{ARGS.simname}_{'+'.join(ARGS.catalogue)}_ksmooth{ARGS.ksmooth}.hdf5"  # noqa
     if ARGS.ksim is not None:
         fname = fname.replace(".hdf5", f"_nsim{ARGS.ksim}.hdf5")
 
@@ -183,7 +176,6 @@ def run_model(model, nsteps, nburn,  model_kwargs, out_folder, sample_beta,
         # Write log likelihood and posterior
         f.create_dataset("log_likelihood", data=log_likelihood)
         f.create_dataset("log_posterior", data=log_posterior)
-        f.create_dataset("simulation_weights", data=simulation_weights)
 
         # Write goodness of fit
         grp = f.create_group("gof")
@@ -215,6 +207,29 @@ def run_model(model, nsteps, nburn,  model_kwargs, out_folder, sample_beta,
 #                        Command line interface                               #
 ###############################################################################
 
+def get_distmod_hyperparams(catalogue):
+    alpha_min = -1.0
+    alpha_max = 3.0
+    sample_alpha = True
+
+    if catalogue in ["LOSS", "Foundation", "Pantheon+", "Pantheon+_groups", "Pantheon+_zSN"]:  # noqa
+        return {"e_mu_min": 0.001, "e_mu_max": 1.0,
+                "mag_cal_mean": -18.25, "mag_cal_std": 2.0,
+                "alpha_cal_mean": 0.148, "alpha_cal_std": 1.0,
+                "beta_cal_mean": 3.112, "beta_cal_std": 2.0,
+                "alpha_min": alpha_min, "alpha_max": alpha_max,
+                "sample_alpha": sample_alpha
+                }
+    elif catalogue in ["SFI_gals", "2MTF"]:
+        return {"e_mu_min": 0.001, "e_mu_max": 1.0,
+                "a_mean": -21., "a_std": 5.0,
+                "b_mean": -5.95, "b_std": 3.0,
+                "alpha_min": alpha_min, "alpha_max": alpha_max,
+                "sample_alpha": sample_alpha
+                }
+    else:
+        raise ValueError(f"Unsupported catalogue: `{ARGS.catalogue}`.")
+
 
 if __name__ == "__main__":
     paths = csiborgtools.read.Paths(**csiborgtools.paths_glamdring)
@@ -227,14 +242,15 @@ if __name__ == "__main__":
     ###########################################################################
 
     nsteps = 5000
-    nburn = 1000
-    zcmb_max = 0.06
+    nburn = 1500
+    zcmb_max = 0.05
     calculate_evidence = False
     nchains_harmonic = 10
     num_epochs = 30
 
     if nsteps % nchains_harmonic != 0:
-        raise ValueError("The number of steps must be divisible by the number of chains.")  # noqa
+        raise ValueError(
+            "The number of steps must be divisible by the number of chains.")
 
     main_params = {"nsteps": nsteps, "nburn": nburn, "zcmb_max": zcmb_max,
                    "calculate_evidence": calculate_evidence,
@@ -244,42 +260,36 @@ if __name__ == "__main__":
 
     calibration_hyperparams = {"Vext_min": -1000, "Vext_max": 1000,
                                "Vmono_min": -1000, "Vmono_max": 1000,
-                               "alpha_min": -1.0, "alpha_max": 3.0,
                                "beta_min": -1.0, "beta_max": 3.0,
                                "sigma_v_min": 1.0, "sigma_v_max": 750.,
                                "sample_Vmono": False,
-                               "sample_alpha": True,
                                "sample_beta": True,
                                "sample_sigma_v_ext": False,
                                }
     print_variables(
         calibration_hyperparams.keys(), calibration_hyperparams.values())
 
-    if ARGS.catalogue in ["LOSS", "Foundation", "Pantheon+", "Pantheon+_groups", "Pantheon+_zSN"]:  # noqa
-        distmod_hyperparams = {"e_mu_min": 0.001, "e_mu_max": 1.0,
-                               "mag_cal_mean": -18.25, "mag_cal_std": 2.0,
-                               "alpha_cal_mean": 0.148, "alpha_cal_std": 1.0,
-                               "beta_cal_mean": 3.112, "beta_cal_std": 2.0,
-                               }
-    elif ARGS.catalogue in ["SFI_gals", "2MTF"]:
-        distmod_hyperparams = {"e_mu_min": 0.001, "e_mu_max": 1.0,
-                               "a_mean": -21., "a_std": 5.0,
-                               "b_mean": -5.95, "b_std": 3.0,
-                               }
-    else:
-        raise ValueError(f"Unsupported catalogue: `{ARGS.catalogue}`.")
+    distmod_hyperparams_per_catalogue = []
+    for cat in ARGS.catalogue:
+        x = get_distmod_hyperparams(cat)
+        print(f"\n{cat} hyperparameters:")
+        print_variables(x.keys(), x.values())
+        distmod_hyperparams_per_catalogue.append(x)
 
-    print_variables(
-        distmod_hyperparams.keys(), distmod_hyperparams.values())
-
-    kwargs_print = (main_params, calibration_hyperparams, distmod_hyperparams)
+    kwargs_print = (main_params, calibration_hyperparams,
+                    *distmod_hyperparams_per_catalogue)
     ###########################################################################
 
-    model_kwargs = {"calibration_hyperparams": calibration_hyperparams,
-                    "distmod_hyperparams": distmod_hyperparams}
     get_model_kwargs = {"zcmb_max": zcmb_max}
+    models = get_models(get_model_kwargs, )
+    model_kwargs = {
+        "models": models,
+        "field_calibration_hyperparams": calibration_hyperparams,
+        "distmod_hyperparams_per_model": distmod_hyperparams_per_catalogue,
+        }
+
+    model = csiborgtools.flow.PV_validation_model
 
-    model = get_model(paths, get_model_kwargs, )
     run_model(model, nsteps, nburn, model_kwargs, out_folder,
               calibration_hyperparams["sample_beta"], calculate_evidence,
               nchains_harmonic, num_epochs, kwargs_print)
diff --git a/scripts/flow_validation.sh b/scripts/flow_validation.sh
index 5b2a150..1b71307 100755
--- a/scripts/flow_validation.sh
+++ b/scripts/flow_validation.sh
@@ -1,44 +1,66 @@
 #!/bin/bash
-memory=8
+memory=7
 on_login=${1}
+queue=${2}
 ndevice=1
-
-device="gpu"
-queue="gpulong"
-gputype="rtx2080with12gb"
-env="/mnt/users/rstiskalek/csiborgtools/venv_gpu_csiborgtools/bin/python"
 file="flow_validation.py"
 ksmooth=0
 
 
-if [ "$on_login" != "1" ] && [ "$on_login" != "0" ]; then
-  echo "Invalid input: 'on_login' (1). Please provide 1 or 0."
+if [ "$on_login" != "1" ] && [ "$on_login" != "0" ]
+then
+    echo "'on_login' (1) must be either 0 or 1."
+    exit 1
+fi
+
+
+if [ "$queue" != "redwood" ] && [ "$queue" != "berg" ] && [ "$queue" != "cmb" ] && [ "$queue" != "gpulong" ] && [ "$queue" != "cmbgpu" ]; then
+  echo "Invalid queue: $queue (2). Please provide one of 'redwood', 'berg', 'cmb', 'gpulong', 'cmbgpu'."
   exit 1
 fi
 
 
-# Submit a job for each combination of simname, catalogue, ksim
+if [ "$queue" == "gpulong" ]
+then
+    device="gpu"
+    gputype="rtx2080with12gb"
+    # gputype="rtx3070with8gb"
+    env="/mnt/users/rstiskalek/csiborgtools/venv_gpu_csiborgtools/bin/python"
+elif [ "$queue" == "cmbgpu" ]
+then
+    device="gpu"
+    gputype="rtx3090with24gb"
+    env="/mnt/users/rstiskalek/csiborgtools/venv_gpu_csiborgtools/bin/python"
+else
+    device="cpu"
+    env="/mnt/users/rstiskalek/csiborgtools/venv_csiborg/bin/python"
+fi
+
+
 # for simname in "Lilow2024" "CF4" "CF4gp" "csiborg1" "csiborg2_main" "csiborg2X"; do
 for simname in "Carrick2015"; do
-# for simname in "csiborg1" "csiborg2_main" "csiborg2X"; do
-    for catalogue in "Foundation"; do
-    # for catalogue in "2MTF"; do
-        # for ksim in 0 1 2; do
+    for catalogue in "LOSS,2MTF,SFI_gals"; do
         # for ksim in 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20; do
         for ksim in "none"; do
             pythoncm="$env $file --catalogue $catalogue --simname $simname --ksim $ksim --ksmooth $ksmooth --ndevice $ndevice --device $device"
 
-            if [ $on_login -eq 1 ]; then
+            if [ "$on_login" == "1" ]; then
                 echo $pythoncm
-                $pythoncm
+                eval $pythoncm
             else
-                cm="addqueue -q $queue -s -m $memory --gpus 1 --gputype $gputype $pythoncm"
+                if [ "$device" == "gpu" ]; then
+                    cm="addqueue -q $queue -s -m $memory --gpus 1 --gputype $gputype $pythoncm"
+                else
+                    cm="addqueue -s -q $queue -n 1 -m $memory $pythoncm"
+                fi
                 echo "Submitting:"
                 echo $cm
                 eval $cm
             fi
+
             echo
             sleep 0.001
+
         done
     done
 done