diff --git a/causalts/cli.py b/causalts/cli.py
index 7c7faac..8d58034 100644
--- a/causalts/cli.py
+++ b/causalts/cli.py
@@ -1224,6 +1224,154 @@ def plot(ctx, graph, plot_type, val_matrix, var_names, figsize, plot_format, sav
     _log(ctx, f"Saved {fname} to {outdir}")
 
 
+# ---------------------------------------------------------------------------
+# deconfound — LUCID latent-confounder corrections on a discovered graph
+# ---------------------------------------------------------------------------
+@main.command()
+@click.argument("graph_path", metavar="GRAPH", type=click.Path(exists=True))
+@click.option(
+    "--data",
+    "data_path",
+    required=True,
+    type=click.Path(exists=True),
+    help="Data file the graph was discovered from (CSV/parquet/feather).",
+)
+@click.option(
+    "--strategy",
+    type=click.Choice(["adaptive", "tetrad", "pds"]),
+    default="adaptive",
+    show_default=True,
+    help=(
+        "adaptive = LUCID (infers the regime, applies the matching correction); "
+        "tetrad/pds = fixed single-strategy comparators."
+    ),
+)
+@click.option(
+    "--threshold",
+    type=float,
+    default=None,
+    help="Tetrad factor-consistency threshold (--strategy tetrad only). Default 0.25.",
+)
+@click.option(
+    "--alpha",
+    type=float,
+    default=None,
+    help="Significance level for the PDS filter (--strategy pds only). Default 1e-10.",
+)
+@click.option(
+    "--var-names", type=str, default=None, help="Comma-separated variable names."
+)
+@click.option(
+    "--json",
+    "output_json",
+    is_flag=True,
+    default=False,
+    help="Echo the run summary as JSON to stdout.",
+)
+@click.pass_context
+def deconfound(
+    ctx, graph_path, data_path, strategy, threshold, alpha, var_names, output_json
+):
+    """Correct a discovered graph for latent confounders.
+
+    GRAPH is an .npy file produced by `discover` (e.g. estimated_graph.npy); --data
+    is the series it was discovered from. max_lag is read from the graph's shape.
+
+    The default `adaptive` strategy is LUCID: it infers from the residual spectrum
+    whether latent confounding is sparse or pervasive and applies the matching
+    correction. `tetrad` and `pds` always apply one fixed correction regardless of
+    the data, and exist mainly as comparators.
+    """
+    import json as _json
+
+    from .inspection import edges_from_graph
+    from .utils.io import read_dataframe
+
+    outdir = _make_output_dir(ctx.obj["output_dir"], f"deconfound_{strategy}")
+
+    graph = np.load(graph_path, allow_pickle=True)
+    df = read_dataframe(data_path)
+    var_name_list = _parse_comma_list(var_names)
+    if var_name_list:
+        df.columns = var_name_list
+
+    d = df.shape[1]
+    max_lag = int(graph.shape[2] - 1)
+    # discover saves the C-node rows/columns too when include_C was set; the
+    # deconfounding layer works on observed variables only.
+    graph_obs = np.asarray(graph)[:d, :d, : max_lag + 1]
+
+    for name, value, owner in (
+        ("--threshold", threshold, "tetrad"),
+        ("--alpha", alpha, "pds"),
+    ):
+        if value is not None and strategy != owner:
+            _log(ctx, f"Note: {name} only applies to --strategy {owner}; ignoring it.")
+
+    _log(ctx, f"Graph {graph.shape} -> observed slice {graph_obs.shape}, d={d}")
+    edges_before = int(graph_obs.sum())
+
+    summary = {
+        "command": "deconfound",
+        "strategy": strategy,
+        "graph": graph_path,
+        "data": data_path,
+        "n_vars": d,
+        "max_lag": max_lag,
+        "edges_before": edges_before,
+        "output_files": {},
+    }
+
+    if strategy == "adaptive":
+        from .confounders import run_lucid
+
+        res = run_lucid(df, max_lag, discovery=graph_obs)
+        out = np.asarray(res.cg_tig)
+        summary["regime"] = res.regime
+        summary["spectral_ratio"] = res.spectral_ratio
+        summary["tau"] = res.tau
+        summary["n_factors"] = res.n_factors
+        _log(
+            ctx,
+            f"Regime: {res.regime} (R={res.spectral_ratio:.3f} vs tau={res.tau:.3f})",
+        )
+    elif strategy == "tetrad":
+        from .confounders import tetrad_filter
+
+        kw = {} if threshold is None else {"threshold": threshold}
+        out = np.asarray(tetrad_filter(df, graph_obs, max_lag, **kw))
+        summary["threshold"] = threshold if threshold is not None else 0.25
+    else:  # pds
+        from .confounders import pds_filter
+
+        # pds_filter takes alpha positionally with no default; mirror the default
+        # CausalResult.pds_filter uses so the CLI and the method agree.
+        alpha_used = 1e-10 if alpha is None else alpha
+        out = np.asarray(pds_filter(df, graph_obs, max_lag, alpha_used))
+        summary["alpha"] = alpha_used
+
+    edges_after = int(out.sum())
+    summary["edges_after"] = edges_after
+    summary["edges_removed"] = edges_before - edges_after
+
+    np.save(os.path.join(outdir, "deconfounded_graph.npy"), out)
+    summary["output_files"]["graph"] = "deconfounded_graph.npy"
+
+    names = var_name_list or [str(c) for c in df.columns]
+    summary["edges"] = edges_from_graph(out, names)
+
+    _save_json(summary, os.path.join(outdir, "summary.json"))
+    _log(
+        ctx,
+        f"Edges: {edges_before} -> {edges_after} "
+        f"({edges_before - edges_after} removed)",
+    )
+    _log(ctx, f"Results saved to {outdir}")
+
+    if output_json:
+        click.echo(_json.dumps(summary, indent=2, default=str))
+
+
 # ---------------------------------------------------------------------------
 # dowhy — effect estimation, SCM fitting, root cause analysis
 # ---------------------------------------------------------------------------
diff --git a/causalts/confounders/result.py b/causalts/confounders/result.py
index 80de83a..64ec588 100644
--- a/causalts/confounders/result.py
+++ b/causalts/confounders/result.py
@@ -28,14 +28,19 @@ class LucidResult(CausalResult):
         The router statistic ``R`` -- the share of residual correlation mass carried by
         the top ``router_k`` eigenvalues. ``None`` for routers that do not compute it.
     tau : float or None
-        Routing threshold ``R`` was compared against. ``R > tau`` selects the pervasive
-        branch.
+        Routing threshold ``R`` was compared against. ``R <= tau`` selects ``"sparse"``;
+        ``R > tau`` selects a confounded branch -- ``"sf"`` or, above a second
+        threshold, ``"pervasive"``. So ``R > tau`` alone does **not** imply the
+        ``"pervasive"`` regime; read :attr:`regime` for the branch actually taken.
     router : str
         Which router ran (``"auto"``, ``"spectral"`` or ``"mp"``).
     n_factors : int or None
-        Number of pervasive latent factors implied by the Marchenko-Pastur edge
-        (:func:`~causalts.confounders.mp_factor_count`). ``0`` means no pervasive
-        factor was detected.
+        Number of latent factors implied by the Marchenko-Pastur edge
+        (:func:`~causalts.confounders.mp_factor_count`) -- eigenvalues too large to
+        come from the no-factor bulk. ``0`` means no such factor was detected.
+        This counts *broadly loading* factors and is independent of the
+        :attr:`regime` label: an ``"sf"`` result typically reports a nonzero
+        ``n_factors`` too.
     factor_loadings : np.ndarray or None, shape (n_factors, d)
         Leading right singular vectors of the VAR residuals, one row per detected
         factor, columns aligned with ``var_names``.
diff --git a/causalts/inspection.py b/causalts/inspection.py
index 5b265e6..3efbc8d 100644
--- a/causalts/inspection.py
+++ b/causalts/inspection.py
@@ -12,7 +12,10 @@
 Public API:
 
 - :func:`inspect_df` — full report ``{schema_version, data, facts, recommendation,
-  cost_class, warnings}`` for an in-memory DataFrame.
+  cost_class, warnings}`` for an in-memory DataFrame.  ``facts["latent_factor"]``
+  reports broad latent-factor structure when it is present; it is positive evidence
+  only, so ``detected`` False/None never means "no confounding" (see
+  :func:`_latent_factor_block`).
 - :func:`recommend_config` — the pure facts → config decision function.
 - :func:`discover_df` — run discovery on an in-memory DataFrame (the Python twin
   of ``causal-ts discover``).
@@ -198,6 +201,53 @@ def _warnings(df, data):
     return warns
 
 
+def _latent_factor_block(arr):
+    """Marchenko-Pastur check for broad latent-factor structure.
+
+    Delegates to LUCID's own router (``causalts.confounders.routed_deconf._route``)
+    rather than re-deriving the statistic, so this can never drift from the routing
+    decision :func:`~causalts.confounders.run_lucid` actually makes, and inherits its
+    validated no-factor null instead of a fresh ad-hoc cutoff.
+
+    This yields **positive evidence only**:
+
+    - ``detected=True``  — the residual spectrum carries factor structure above the
+      no-factor null, i.e. one or more latent factors load broadly enough to see.
+      This covers both regimes LUCID treats as confounded (``"sf"`` and
+      ``"pervasive"``), so do not describe it as specifically "pervasive".
+    - ``detected=False`` — no such structure. This is **not** "no confounding": a
+      latent cause touching only two or three variables produces no dominant
+      eigenvalue and is invisible to this test by construction.
+    - ``detected=None``  — the check could not run (see the guards below); this is
+      deliberately distinct from ``False`` so "did not check" is never read as
+      "checked and found nothing".
+
+    Returns
+    -------
+    dict
+        ``{detected, spectral_ratio, tau}``; the latter two are ``None`` whenever
+        the check did not run.
+    """
+    unavailable = {"detected": None, "spectral_ratio": None, "tau": None}
+    T, d = arr.shape
+    # The statistic is built on VAR(1) least-squares residuals, so skip the inputs
+    # that would make the fit raise (non-finite) or return a meaningless number
+    # (underdetermined: the design matrix is (T-1) x (d+1); d < 2 has no spectrum).
+    if d < 2 or T < d + 3 or not np.isfinite(arr).all():
+        return unavailable
+    try:
+        from .confounders.routed_deconf import _route
+
+        regime, info = _route(arr, router="auto")
+    except Exception:  # a diagnostic must never break the whole report
+        return unavailable
+    return {
+        "detected": regime != "sparse",
+        "spectral_ratio": float(info["R"]),
+        "tau": float(info["tau"]),
+    }
+
+
 def recommend_config(facts, data):
     """Map measured facts to a discovery configuration (pure, deterministic).
 
@@ -262,6 +312,18 @@ def recommend_config(facts, data):
     else:
         c_preset = "linear"
 
+    # --- latent confounding (advisory only) ---
+    # Deliberately does NOT influence algorithm/ci_test/include_C: LUCID is orthogonal
+    # post-discovery correction, not an alternative discovery algorithm. And the nudge
+    # fires only on a positive detection -- `detected` False/None cannot rule out
+    # sparse (few-variable) confounding, so silence is the honest default.
+    lf = facts.get("latent_factor") or {}
+    if lf.get("detected") is True:
+        reasons.append(
+            f"latent factor detected (R={lf['spectral_ratio']:.2f} vs "
+            f"tau={lf['tau']:.2f}) → consider res.deconfound() after discovery"
+        )
+
     return {
         "algorithm": algorithm,
         "ci_test": ci_test,
@@ -324,6 +386,7 @@ def inspect_df(df, max_lag=None):
             "form": form,
         },
         "suggested_max_lag": int(suggested),
+        "latent_factor": _latent_factor_block(arr),
     }
 
     recommendation = recommend_config(facts, data)
diff --git a/causalts/skills/causal-ts-discovery/SKILL.md b/causalts/skills/causal-ts-discovery/SKILL.md
index 70ca55e..b80db6f 100644
--- a/causalts/skills/causal-ts-discovery/SKILL.md
+++ b/causalts/skills/causal-ts-discovery/SKILL.md
@@ -46,7 +46,14 @@ warnings}`. Read it — do **not** re-derive these facts yourself.
   too-few rows). If a column is heavily missing or constant, recommend fixing it
   (impute/drop) before trusting results.
 - **`facts`** — linearity, per-column (non)stationarity + its `form`, suggested
-  max lag.
+  max lag, and `latent_factor`.
+  - **`latent_factor`** — `{detected, spectral_ratio, tau}`. `detected: true` means
+    one or more latent factors load broadly across the panel; plan on deconfounding
+    (§5). Read the negatives narrowly: `false` only rules out factor structure this
+    test can see — a latent cause touching just two or three variables produces no
+    dominant eigenvalue and stays invisible — and `null` means the check could not run
+    (missing values, `d < 2`, too few rows). **Never report either as "no
+    confounding".**
 - **`recommendation`** — `{algorithm, ci_test, include_C, c_preset, max_lag,
   rationale}`. This is a deterministic default; you may **override it** with
   context the tool can't see (e.g. the user says "these are already
@@ -116,6 +123,15 @@ read it rather than eyeballing, then apply:
   differencing, or verifying the C-node preset matches the trend `form`.
 - **High `max_in_degree` at `hub`** → inspect whether that variable is a common
   effect or an artifact of a confounder/persistence.
+- **Many `contemporaneous` edges, especially with step-2 `latent_factor.detected`**
+  → a broadly-loading latent factor induces exactly this signature (lag-0 edges
+  among variables with no direct causal link). Offer to correct it:
+  `causal-ts deconfound <graph.npy> --data <data-file>` (or `res.deconfound()` in
+  Python), which infers whether the confounding is sparse or pervasive and applies
+  the matching correction. Report edges-before/after and be explicit that the
+  removed edges were **judged confounded, not disproven**. Which edges are eligible
+  depends on the inferred regime: the pervasive branch rewrites the lag-0 slice only,
+  while the sparse branch also tests lagged edges against observed controls.
 - **`lagged` == 0 (all edges contemporaneous)** → check that `max_lag` is
   adequate and the sampling rate isn't washing out dynamics.
 - **Self-loops** are autoregressive terms (a variable's own past), expected for
diff --git a/examples/api_reference.ipynb b/examples/api_reference.ipynb
index 3104ad7..a9ca6e3 100644
--- a/examples/api_reference.ipynb
+++ b/examples/api_reference.ipynb
@@ -15,11 +15,12 @@
     "| 2 | [CDNOTS](#2-cdnots) | Constraint-based causal discovery for nonstationary time series |\n",
     "| 3 | [CEDAR](#3-cedar) | Scalable discovery via minimum-lag selection |\n",
     "| 4 | [GRACE](#4-grace) | Neural gated refinement with L0 regularization |\n",
-    "| 5 | [Plotting](#5-plotting) | Graph visualization, comparison, metrics, p-values |\n",
-    "| 6 | [Synthetic Data](#6-synthetic-data) | Random SCP graph generation for benchmarking |\n",
-    "| 7 | [Evaluation](#7-evaluation) | `evaluate_graph` metrics |\n",
-    "| 8 | [Effect Estimation (DoWhy)](#8-effect-estimation) | Effect estimation, counterfactuals, root cause analysis (optional) |\n",
-    "| 9 | [Tigramite Effects](#9-tigramite-effects) | TigramiteEffects, pathwise_effects |"
+    "| 5 | [LUCID](#5-lucid) | Latent-confounder correction: regime-adaptive deconfounding of a discovered graph |\n",
+    "| 6 | [Plotting](#6-plotting) | Graph visualization, comparison, metrics, p-values |\n",
+    "| 7 | [Synthetic Data](#7-synthetic-data) | Random SCP graph generation for benchmarking |\n",
+    "| 8 | [Evaluation](#8-evaluation) | `evaluate_graph` metrics |\n",
+    "| 9 | [Effect Estimation (DoWhy)](#9-effect-estimation) | Effect estimation, counterfactuals, root cause analysis (optional) |\n",
+    "| 10 | [Tigramite Effects](#10-tigramite-effects) | TigramiteEffects, pathwise_effects |"
    ]
   },
   {
@@ -804,7 +805,7 @@
     "parcorr_b = PartialCorr(data=df_b.values)\n",
     "result_b = run_cdnots(\n",
     "    df=df_b, indep_test=parcorr_b, num_lags=maxlag_b,\n",
-    "    include_C=False, alpha=0.05, stable=True,\n",
+    "    include_C=False, alpha=0.05, stable=True, return_pvals=True,\n",
     ")\n",
     "graph_b = result_b.cg_tig\n",
     "print(f\"Graph shape: {graph_b.shape}\")\n",
@@ -1265,10 +1266,11 @@
     "gen = SCPGraphGenerator(n_vars=25, max_lag=5)\n",
     "result = gen.sample(seed=42, T=2000)\n",
     "\n",
-    "G_hat, gate_vals, info = run_cdnots_gated(\n",
+    "res = run_cdnots_gated(\n",
     "    df=result[\"df\"], max_lag=result[\"max_lag\"],\n",
     "    verbose=True, device=\"cpu\", model_seed=42,\n",
-    ")"
+    ")\n",
+    "G_hat, gate_vals = res.cg_tig, res.gate_values"
    ]
   },
   {
@@ -1302,7 +1304,7 @@
    "source": [
     "fig, axes = plt.subplots(1, 2, figsize=(10, 8))\n",
     "_,_,pos = tp.compare_graphs(\n",
-    "    graph_true=result[\"ground_truth\"], graph_discovered=info[\"skeleton\"],\n",
+    "    graph_true=result[\"ground_truth\"], graph_discovered=res.skeleton,\n",
     "    var_names=result[\"var_names\"], node_layout=\"fdp\",\n",
     "    node_size=0.15, arrow_linewidth=3, link_label_fontsize=6,\n",
     "    title=\"Skeleton vs True Graph\",\n",
@@ -1326,7 +1328,7 @@
     "plt.tight_layout()\n",
     "plt.show()\n",
     "\n",
-    "skel_metrics = evaluate_graph(info[\"skeleton\"], result[\"ground_truth\"])\n",
+    "skel_metrics = evaluate_graph(res.skeleton, result[\"ground_truth\"])\n",
     "grace_metrics = evaluate_graph(G_hat, result[\"ground_truth\"])\n",
     "\n",
     "print(f\"{'Metric':<12} {'Skeleton':>10} {'GRACE':>10}\")\n",
@@ -1342,13 +1344,190 @@
     "---"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<a id=\"5-lucid\"></a>\n",
+    "# 5. LUCID\n",
+    "\n",
+    "Causal discovery assumes **causal sufficiency** \u2014 that every common cause is measured.\n",
+    "When it fails, an unobserved common cause of two variables shows up as an edge between\n",
+    "them. LUCID is not a discovery algorithm: it *corrects* an already-discovered graph.\n",
+    "\n",
+    "It first infers, from the spectrum of the VAR-residual correlation matrix, whether the\n",
+    "latent confounding is **sparse** (a cause touching a few variables) or **pervasive** (a\n",
+    "factor loading on everything), then applies the correction matched to that regime \u2014 the\n",
+    "two regimes need opposite treatments, and applying the wrong one is damaging.\n",
+    "\n",
+    "```python\n",
+    "from causalts.confounders import run_lucid, tetrad_filter, pds_filter\n",
+    "```\n",
+    "\n",
+    "<a id=\"run_lucid\"></a>\n",
+    "## `run_lucid`\n",
+    "\n",
+    "<div style=\"background: #FDF5E6; padding: 12px 16px; border-radius: 4px; margin: 8px 0; font-family: 'SFMono-Regular', Consolas, monospace; font-size: 0.85em; line-height: 1.8;\">\n",
+    "causalts.confounders.<strong>run_lucid</strong>(<em>df_obs, max_lag, ci=None, discovery=None, **kwargs</em>) &rarr; <em>LucidResult</em>\n",
+    "</div>\n",
+    "\n",
+    "<div style=\"border-left: 3px solid #ddd; padding-left: 16px; margin: 12px 0;\">\n",
+    "\n",
+    "**Parameters:**\n",
+    "\n",
+    "<dl style=\"margin-left: 8px;\">\n",
+    "<dt><strong>df_obs</strong> : <em>DataFrame</em></dt>\n",
+    "<dd style=\"margin-left: 24px; margin-bottom: 8px;\">Observed time series (T, d).</dd>\n",
+    "<dt><strong>max_lag</strong> : <em>int</em></dt>\n",
+    "<dd style=\"margin-left: 24px; margin-bottom: 8px;\">Maximum lag.</dd>\n",
+    "<dt><strong>ci</strong> : <em>CIT_Base, default=None</em></dt>\n",
+    "<dd style=\"margin-left: 24px; margin-bottom: 8px;\">CI test for the base skeleton search (default: <code>ParCorrGPU</code>).</dd>\n",
+    "<dt><strong>discovery</strong> : <em>CausalResult, ndarray or callable, default=None</em></dt>\n",
+    "<dd style=\"margin-left: 24px; margin-bottom: 8px;\">Reuse an existing discovery instead of re-running the skeleton search. Exact, because both regimes run the <em>same</em> base engine \u2014 routing changes only the correction applied afterwards.</dd>\n",
+    "</dl>\n",
+    "\n",
+    "**Returns:** `LucidResult` \u2014 `cg_tig` (corrected graph), `regime`, `spectral_ratio`, `tau`, `n_factors`, `factor_loadings`, plus inherited plotting / DoWhy methods.\n",
+    "\n",
+    "</div>\n",
+    "\n",
+    "> **On `factor_loadings`:** descriptive summaries of the estimated factor subspace. They\n",
+    "> are rotation-ambiguous and are **not** identified latent variables \u2014 do not read a\n",
+    "> loading as \"this factor is inflation\".\n",
+    "\n",
+    "Every result object also exposes the correction directly, so it composes with any engine:\n",
+    "\n",
+    "| Method | Strategy |\n",
+    "|---|---|\n",
+    "| `res.deconfound()` | Regime-adaptive (LUCID) \u2014 **the recommended path** |\n",
+    "| `res.tetrad_filter()` | Fixed comparator: always assumes pervasive factor structure |\n",
+    "| `res.pds_filter()` | Fixed comparator: post-double-selection against observed controls |\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "regime        : pervasive   (factors detected: 1)\n",
+      "router        : R = 0.538  vs  tau = 0.374\n",
+      "lag-0 edges   :  23 ->   0   (ground truth has 0)\n",
+      "lag-1 edges   :   4 ->   4   (ground truth has 3)\n",
+      "top loadings  : [('X6', -0.42), ('X1', -0.4), ('X3', -0.36)]\n"
+     ]
+    }
+   ],
+   "source": [
+    "# A panel where causal sufficiency FAILS: one latent factor loads on all 8 variables,\n",
+    "# on top of 3 genuine lag-1 edges. The factor is never put in the DataFrame.\n",
+    "rng_l = np.random.default_rng(0)\n",
+    "T_l, d_l, edge_l = 1500, 8, 0.7\n",
+    "latent = rng_l.standard_normal((T_l, 1)) @ (rng_l.uniform(0.6, 1.0, (1, d_l)))\n",
+    "X_l = np.zeros((T_l, d_l))\n",
+    "noise_l = rng_l.standard_normal((T_l, d_l))\n",
+    "true_edges_l = [(0, 1, 1), (2, 3, 1), (4, 5, 1)]\n",
+    "for t in range(1, T_l):\n",
+    "    X_l[t] = noise_l[t] + latent[t]              # <- the unobserved common cause\n",
+    "    for (i, j, lag) in true_edges_l:\n",
+    "        X_l[t, j] += edge_l * X_l[t - lag, i]\n",
+    "\n",
+    "df_l = pd.DataFrame(X_l, columns=[f\"X{i}\" for i in range(d_l)])\n",
+    "names_l = df_l.columns.tolist()\n",
+    "true_l = np.zeros((d_l, d_l, 2), dtype=np.int8)\n",
+    "for (i, j, lag) in true_edges_l:\n",
+    "    true_l[i, j, lag] = 1\n",
+    "\n",
+    "# 1) Plain discovery \u2014 the latent factor shows up as spurious contemporaneous edges.\n",
+    "cd_l = run_cdnots(df_l, ParCorrGPU(df_l.values.copy()), num_lags=1,\n",
+    "                  include_C=False, alpha=0.01, verbose=False)\n",
+    "g_plain = np.asarray(cd_l.cg_tig)[:d_l, :d_l, :2]\n",
+    "\n",
+    "# 2) Correct it. .deconfound() reuses the skeleton above \u2014 no re-discovery.\n",
+    "lucid_l = cd_l.deconfound()\n",
+    "g_lucid = np.asarray(lucid_l.cg_tig)\n",
+    "\n",
+    "print(f\"regime        : {lucid_l.regime}   (factors detected: {lucid_l.n_factors})\")\n",
+    "print(f\"router        : R = {lucid_l.spectral_ratio:.3f}  vs  tau = {lucid_l.tau:.3f}\")\n",
+    "print(f\"lag-0 edges   : {int(g_plain[:, :, 0].sum()):3d} -> {int(g_lucid[:, :, 0].sum()):3d}\"\n",
+    "      f\"   (ground truth has 0)\")\n",
+    "print(f\"lag-1 edges   : {int(g_plain[:, :, 1].sum()):3d} -> {int(g_lucid[:, :, 1].sum()):3d}\"\n",
+    "      f\"   (ground truth has {len(true_edges_l)})\")\n",
+    "print(f\"top loadings  : {[(v, round(w, 2)) for v, w in lucid_l.top_factor_variables(0, 3)]}\")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA6sAAAG4CAYAAACjP3GZAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzsnQV4FNfXxt+EJITggQQI7u7uLsWhpUL9X3d3F6i7u35taXH3QnF3d3eXBIh8zzs3k8zMerKe83ueIezs7Ozs7Ozcc+455z0RGRkZGRAEQRAEQRAEQRCEICIy0AcgCIIgCIIgCIIgCFbEWRUEQRAEQRAEQRCCDnFWBUEQBEEQBEEQhKBDnFVBEARBEARBEAQh6BBnVRAEQRAEQRAEQQg6xFkVBEEQBEEQBEEQgg5xVgVBEARBEARBEISgQ5xVQRAEQRAEQRAEIegQZ1UQBEEQBEEQBEEIOsRZFUKen3/+GREREdi9ezeCnd69e+Ouu+5CMDB16lQ0atQIsbGx2vk7ffo0gpHbbrsNlSpV8uo+uT/u13guChUqhGPHjnn1fQRBEPzJb7/9hlq1aiE6OhrFihULiZPP8efVV19FKLFs2TK0adMGBQsW1I5/9erVCEZ4Xnl8Vs6fP4/ExET83//9X9a6Z599Fi1btvRo/+np6ahXrx6GDRuGcCMn50PwDeKsBoAdO3bgnnvuQZUqVTRHoUiRImjbti0++eQTJCcnmwxq3mS4REZGagNP/fr1cffdd2PJkiV2961v/8EHHzh06pYvX27z3IIFCzBo0CCUKlUK+fPn196bx7h3796sbegM6vt3teiOI//efvvtqFq1qvZZS5cujQ4dOuCVV15BXoPnePr06XjmmWcCfSg4ceIErr32WhQoUABffPGFZuBw0M2r9OrVC9WqVcNbb70V6EMRBEGwy5dffqmNr44M6M2bN2uTcBxvv/vuO3z77be4ePGi5rDMmTNHzqqXuHLlCoYMGYKTJ0/io48+0sbPihUrhtT5pb1ZuHBhXH/99VnrHn30UaxZswbjx493ez9//vkn9u3bhwcffNAtW9NoS77//vt2n+d6RwGIMWPG4KqrrkLJkiURExODpKQkzZaZPXt21ja81vn6kSNH2hyTvtAe5Wt79uyJTz/9FOfOnbN5r5ycD8E3RPlov4IDJk2apN3k6BDecsst2ozU5cuXMX/+fDz11FPYsGGDNsDoMPL1xBNPaP/nj2nTpk34559/tIHosccew4cffmj3fd577z3cd999iIuLc/ldfPbZZ3jkkUc05/mhhx5CmTJltPf5/vvvMWLECEyePFmbQUxISNBuykboFO/fv1+7YRvhttu3b0fz5s01h+h///uf5gAfOnQIK1euxDvvvIPXXnstT10n/E66du2qOUXBMCvM6+mNN95At27dAn04QQEnZ5588kntuuQgLgiCEEwwCsZxdOnSpdr4ah1LaKQz0kVHRH/u+PHjWWNtp06dAnLc4Rhw2LNnj2aH3XnnnQhFZ5vXCG3IfPnyZa1nMGHAgAGas9i/f3+37Ro6vEWLFvXhEQMZGRmaHUmns3Hjxnj88ce146VNSQeWthUDArRVnfH666+jcuXK2jk4fPiw9puhU0pbmk5pgwYNcnU+BN8gzqof2bVrl/aj5gwcZ4HoFOo88MAD2uBDZ9ZI2bJlcdNNN5nW0dEbOnSo5iBWr15dc0qN0MFlSsrXX3+t/aCdwR83f6jt2rXTUiGNzi33y4jvNddcoznRxYsXtzmWv/76C6dOnbJZT3h8TDXhsVhnHY8ePYq8BD8vv1t+J8GAfv5DJU3MH1x99dXaZA0ngzgoCoIgBJP9sHDhQowePVqbWKPjas1Q8ud9/cKFC3k2GyfUx8+JEydqJS+MSFrhOgZUdu7cqQUwnLFq1Sot8mgvk8/b8D3oqOqOpTG1+YUXXtACKVFRrl0aRmWbNWuW9fi5557T7PG+fftqDikDNQyw5OR8CL5D0oD9yLvvvqs5bz/88IPJUdXhTCgjnK7gD4k/zPj4eK1OgDNORuhgdunSRXs/Y1qxPRhZ44/+l19+sYnCMpWI++DM1TfffIOczD6WK1fObnoMayVcsXbtWi2lSU+X5iwXnQimsLqbMlW3bl0tis10D04IWOsyOdPM6PbGjRvRuXNn7RxwgoCf28qlS5c044DfE/dZvnx5PP3009p6V9BRTU1NtRvF5DFxhpMz5twvzxmj7pwRNw6Od9xxh5amzXPRsGFD7TtzlFrD6Dy/P+6P0W1GUo2f+dZbb9X+z+f4GmP9Jp21pk2batcZU204EXHgwAGb82Zvlt5aX+ruMemMHTtW+z74GfmXM6b2YPTg448/1r5fbsvzQgOOEydG+Nt48803tXPK75bfMSde7MFrkrOq48aNs/u8IAhCoKBzygnjPn36aBPIxlpDwvuu7rwys0m/r/P/hNFVPQXSWB/K1GHuj/YE76U05K1pj3oK5dy5c3H//fdr90reUz2FYyXHOh4Ts1foHDAzyx4cczje66VJvNf/+OOPNtulpKRon6dGjRra8dO2Gjx4sGZ/GB1rZqhxzOa+atasqY1JVtuJn5HprPo4pL8vJ/J1eE47duyo/Z9ODF9jHAvp+LRv315z5OnMMjJHB8gdHQZ79aXuHJMOM/Q4tvI8cKx1ZLdxX3x/bmNFt1HcGQe5H6bisrTLl9COZYkOa7H1FGErN998M1q0aJGj/dNefumll7Ro+e+//57j8yH4DnFW/ciECRM0x8tVmoI7UAyGNaa8odPRsnfTO3LkCL766iuH+2Aty6xZs7QbK9Mi7HHddddpN0fOxHkKnVTWMhhrCTxhxowZ2mwWa16ZqsyoNCO5FCmyDjL2Pj+dUzqpnJFj1Iw37h49emjpH0bo4LBmkQ4gt+UNkXWlU6ZMMTlHHFh5o+zXr592PAMHDtSixzxHruCMeIkSJWwcd05e8Pxzfzw2pubce++9mgGhD+K8UXMw5ATFjTfeqKXdMOWGAx63t/LHH39o29B5o6NGh5GDt/65OQvJumc9JYb75ba6UcKZRKYGcXCgGBRn8hl5z40Ak6tjIqzn5ffEgYjvzfPL795e3Qv3w7R5vdab29F4Y/2JcZ8vv/yyNgjxu+X78/fH80zjxR500vldCYIgBBO8v/GeSefghhtuwLZt20wTfpy8o01AOO7zvk7HULcB+BzXceF+CCfuWrVqpTlTFJPh+Ecni/deexOFdFRpb/C+yu09hSmzPE7eg99++21NBIrOtxXaLjyumTNnao6antbMCVu+XictLU2LiNER572bx88J/zNnzmD9+vXaNrQVOHZzrOY4z6gcnVWOH/Yyz+jw8XPS3uCkNZ1hjkv6JDnHnueff177/8MPP6ydT46phMfLMYiTy7RBuH+OJxynciMA6eqYyLp167Tzqr83x0ROXtj7HnlMTZo0sftetC3oxDLrzhXcDx1ofo++hJ+f9cHMKDSmLXsTOru6HZLT8yH4kAzBL5w5c4beVcaAAQPcfk3FihUz+vTp4/D5jz76SNvnuHHjstbx8QMPPKD9v3PnzhmlS5fOuHjxovb4p59+0p5ftmyZ9nj16tXa40ceecTpcTRo0CAjPj7e7nM8Ph6nPdavX59RoEAB7T0aNWqkvc/YsWMzLly44Manz8g6biN//vmntr///vsva53+uXbt2qU9Pnr0aEZMTExGjx49MtLS0rK2+/zzz7Xtfvzxx6x1HTt21Nb9+uuvWesuXbqknberr746a91vv/2WERkZmTFv3jzT8Xz99dfa6xcsWOD0s7Rr1y6jadOmNutffvll7fWjR4+2eS49PV37+/HHH2vb/P7771nPXb58OaN169YZhQoVyjh79qy2jp+f25UoUSLj5MmTWdvy+uD6CRMm2Jwz/VrQ95mYmJhRr169jOTk5Kz1EydO1LblsRrPGxcrt956q+l68OSYeI2UKVMm4/Tp01nrpk+frm1n3Ce/A677v//7P9N7T5061bRevw54jernkjz//PPadjxWK8OHD9eeO3LkiM1zgiAIgWD58uXafWnGjBnaY97PypUrZzN2v/LKK9p2x44dy1rH/3Mdn7PStWvXjPr162ekpKRkreO+27Rpk1G9enWb8YLjWGpqao4+g25v3H///ab1Q4cOtTm+O+64QxsLjh8/btr2+uuvzyhatGiWbcCxnK/98MMPbd5Pv+fT5uA2b775pun5a665JiMiIiJj+/btWeu4HccM47o1a9Zo6z/77LOsdf/++6+27p9//jHtk2MYx9ATJ06YXk/b4ZZbbnE4Tlq/PyPuHtPAgQMzYmNjM/bs2ZO1buPGjRn58uUz7fPKlSva537iiScyHEHbqXbt2hmu4DVotJOc2RdGdLvgvffes/s81xttuk8++UR7PGbMmAx3sPf9uDomwmurcePGOT4fgu+QyKqfOHv2rPbXm8ItjK4SeypmhLNrLCB3VCepv87VMfF5/fg9gakqrFdlGilnFTk7yhlbpvVQmMAVxroBziQyLZazrYQiTY7g7CZFq1jbQBVlHUYJqbxsrQvmeTTW3HLmmukkjOoaU2Nr166tRV15HPrC9BHy77//Ov0snAFlCpeVUaNGaVE/fUbciJ7qQoErpkBzNl2HM5mc1WVklqlZRhjpNb4XI7fE+HnswQgmZ2U5g8s0Ih3OfPNzW8+bJ7g6Jqaa81pherJRqKF79+6oU6eOaV/8LrgNnzN+F5xZ53epfxf6dcA6VGPaEK8LR+jHaEzBFgRBCHRUleMmyxgI72e8pzLTiNHFnMBIFbOemElDW0C/j3KsYnSQkVtr+QfH0JxGtjiOEY5bRqz3Y/pnHBeZwcT/G+/xPC5GTfXxn9uxVIX3eGfjJ4/Z+r5MC+b+jRlUetqnMT2WpSG0G1yNn/oYxownplQbX8+xSv/8OcHVMfEamDZtmmZfVahQIWs72iw8Z9bvnZ/bnj2iw+fcGQMd2TWhYD/bg/aDPXva3fMh+A5xVv0EbyzOHMucQEfF2Q+YdQQc3BzVruqvc3VMfD6nNwnWkTBNhj901qAOHz5cK4JnGiqdCWfwpsqUHg7SdFxZ56KnK3PAcgTrDghTfYzQCWUaqP68DmtvrDUQvDkZ6x85cDNlisdgXPj53BWMspe6zLoaptE4g8dLIS2j460PRMbPq2McrPTPQqz1nPbex955I3RWre/jCa6OSd83P6cV6/Hwu+D3z7op6/fB34T+XTjaJ7dzNMDq35G9mhhBEAR/Q0eETinHcoosUYiRC9vXMF2WpTw5gfvg/Y5lEtb7qF77ah3XHJULuQPvxxzDrHWS1vs7hX9YckKNA+txMbXVeFwcP/l6Z8I6fF+WA1ltGHfHT3v2gKP3sfd59PeiDeSo/MQVro6J54w2njvjp46zUio+5+4Y6KokKzfox+AL+9ketB/s2bqenA/BN4gasJ/gj403TL2Owhvo+3LWCoWDDusdWa9pVa7j63iTpxPpTBBhy5YtJvW0nMCZTfaI5dK6dWtt4OVssbO2KZzxZU0Ea0uocMxZL9aOsu6Ef72Fo5li402Y78djd9QqiMINzmC9qqvBzp+fJ7fwxm1vf45m+b15TPwurM3MjeiCIjlB/444Wy8IghBoGP1k1I4OKxcrvA+yVtFT9DGU7bqs0Tcdq21hzHbyFfpxMdtJFwK0YmwvEqrjpz38MX4y6sv3d2aP8Dl3xsCc2jV65pYjAVDqqRi342S5XpfL6LEvoEYIJ8Ht2dPung/Bd4iz6kcoBMDZwkWLFmkOW25ngFg4TydJnyG0B1Xr6Kyy3Q1FEYxQSIFOIwdDzgraU+39+++/NYeVx+4tdMeXA7AjeHPgjDGFE4zHzaiaK/TPQSfbKDXOlFDOTOekryhngynRzl5eOZlh482WKUv29utqAoOfhxMKHMSN0VWKMOnPewPjedPTm3W4zvg+nNW1lxaV0+irvm973y/f23rOGJWnaIUz48m4T+N1wFloRwMsrw8OSrlxeAVBELwFnVFOzn3xxRc2z1H8jnYAS30c3QsdjVf6PZElJf7otc37MccwPRrq6P6uKwXTcXN1XBwLlixZoonqORL54ftyvLBmiPly/LTC9+K4orf64fhpT7Awp+Mnzxm/f3fGTwYoeN441jmCz7E8yR27xtl+nB0v1fntnSv9mPm87iBS4JHn7M8//9TErXwhssQMQGJv4sbd8yH4DkkD9iNsc8KbFRXxmL5jhTdxe+quVjgbReUypslShc6V86TXrtJRtvLiiy9qs3Oss7DOcvEHymOmFLyuFusJ8+bNs1HeJXrthqP0FKLfjKwzh0YlQEdwgGPK76effmp6PVsGcebMnvqgKxjlZf2OvVpbnjdX6T2cnKCDZHXwqOhHJ9ieYp9+7FQ/5vc3YsSIrOfYBocKwow26zL63phEoFFEw8fYjoc1PVSLNJ43DnYcgOn46fBz5FQxj9cYo+dsx2NM8aYitFXtmt8FDRm2XbLC86IbAbwOaMDwPBmvA2fX0IoVK3I9kSQIguANOLbQIeVkMdvLWBcq5dIJs7aaMaK3pLM6R7zX61lX9iaOjff2nMDxYe/evab+loTjshHr/ZhjP8dFTu7am8g1Hhe3Y3rt559/7nT85Hhh3YbqwLSd9OPKLcYxzHiu+RmoMMvjMI6fHOeMWW38Dhy1anMFzxmdLLaSMZ5zjtusZbXCMc6eyj7hcdEWdadrBffDz+dO+z7r8TIbgB0yjMdL+Jjr+bxuB/IaZocGfh7+tRdRZsuZpUuXIicwYEN7gmnu7LiQ0/Mh+A6JrPoR3qDYwoPCCIyGspcm6xUZ8WO6K4VjjP0uCR0kve8To6k03LkdnRcKBLjjRNKZ4WIV4tHrWtmOhRLrTK3h+/Omy4GGjhlnQulc5qSIntFcGv+UydfTdiiM8Ouvv2qpKM6Ebpg2zWNjvS0dXvY+5Q3fnVk8ztqx0TOjskwZpmw9Z+rYd5U9yIxiSu7CyQFGmdlWhgI+jOpxAOR54noOCM5SpenocUaTM7x62xjCFOeRI0dq/drYU44iQZyEoPFBp5GzedyeBgW/G55P9kfja+gYcqD3lugAHTt+Z6wL4vVCQSdOqnAChe/JNgg6PFamRHOAZDsB1hDxeCmqlRMxLsJ2NTxPnEXl/nke6Ghyn3p9NuGx8brn9hS04KDGY+esMn8bPF4acrwOmOLG7Wjs0VhgE3M63/ZSevgZaDyw5ZEgCEKg4ThAZ5RjmD0oOMj7HKOvjlqoMeJGkTpOdlJjgWMv7Q4ujNbyfssSF4onMdrKez6zv5gWyQnInEIbh/fqOXPmaI/pyHFM4ThMB4DGP7OnWDtrhW1tOM6yLpfHxePneED7gWMo/09oQ9GeoP1CR4XCfZw45jYUCmSPUwo1MYOME/sUeuSYSluCfTNpg9jrNZpT2B6Nzi+dOI6LnGzgGEZBQGNvW7agodNFYUUKPzHtlS2G+P04E490Bu0d9l7lOeBn1ye0OX5aS714XhhJ3Lp1a5buhg7PHZ1BbuMKbkMnj7alvVR09sW11w+WWiTUL+H1yxY6tHFoY/D7YVCFkwh83ghtJeqGsD0Rrw2O8RSepC1MJ53fvztt5zj+027j+eG1TkeVk+KMjPP3ZhSX9PR8CD7Eh0rDggO2bt2acdddd2VUqlRJkyQvXLhwRtu2bTUZcqOEPKXN+RVxodR4kSJFMurWrau9dsmSJXb3bWxdY0/K25F0N1vBsK1OyZIlM6KjozMqVKigvc/u3budfo/OWtewnQuPha1QKAmu7/e2227L2LFjh8vrY//+/RmDBg3KKFasmPb6IUOGZBw8eNBG5t7ausbYqqZWrVra+5YqVSrjvvvuyzh16pRpG7Zf4Tm1Yk9anq1d3nnnHW37/PnzZxQvXlxrR/Paa69prYlc0b9/f61VgBXK3D/44IMZZcuW1a4HysHz/Y2y/Wylcvvtt2vfD7dhuwF+bnfl4B2dM3vXwogRIzT5dn5Gtiy68cYbte/CClvpVKlSRTseSvZPmzbNYesad46JjBo1SpOI53vXqVNHa+njSOb/22+/1c4/2yPxN8Rz8vTTT2vXiA5bF/H7YRsEbtepUyetpRL3Z21d89VXX2XExcVltQISBEEIJP369dPakThr98bxlGMcxwt7rWvIwoULtXsl79XW+y7HYrZVYbs27ofjUN++fTNGjhzpUdsPK9ze2t6MLdEefvhhrZVZwYIFtc+3b98+u2MBxzzaD+XLl9eOi8fH8ZP3fSNsY/PCCy9kVK5cOWs7tqUx2hjnzp3LeOyxxzKSkpK0bdiWh2OSsaWZM/vJOl44al1DZs6cqdlzHG9os/EzsoWMFbZlo23E76RmzZraeOqodY07x0Tmzp2b9T1zbGZrPXv7ZHs+2hJvvPGGzX6vu+46rUWRu7C1IVsNGdGvF0cLv3OyadMm7f3Y7icqKkr7y/ZEXO8IXpdsJUPbhK/h2M59zJkzx63WNfrCc8RrpXv37lprHEfjvqfnQ/ANEfzHl86wIAjZadFMu+Ksnj3VPiGwNG7cWPt+mB4mCIIgCOEKI6I//fSTlpGkp9sySslUWAp5uRtJZISW2UhM37WKeIY6OTkfgm+QmlVB8BNMz2GqDFObheCCqUoctJk+LgiCIAjhDMt6WF5jVJhmWRFTwj1xzFjjydY69gTAQp2cnA/BN0hkVRAEQRAEQRAEQQg6JLIqCIIgCIIgCIIgBB3irAqCIAiCIAiCIAhBhzirgiAIgiAIgiAIQtAhzqogCIIgCIIgCIIQdIizKgiCIAiCIAiCIAQd4qwKgiAIgiAIgiAIQYc4q4IgCIIgCIIgCELQIc6qIAiCIAiCIAiCEHSIsyoIgiAIgiAIgiAEHeKsCoIgCIIgCIIgCEGHOKuCIAiCIAiCIAhC0CHOqiAIgiAIgiAIghB0iLMqCIIgCIIgCIIgBB3irAqCIAiCIAiCIAhBhzirgiAIgiAIgiAIQtAhzqogCIIgCIIgCIIQdIizKgiCIAiCIAiCIAQd4qwKgiAIgiAIgiAIQYc4q4IgCIIgCIIgCELQIc6qIAiCIAiCIAiCEHSIsyoIgiAIgiAIgiAEHeKsCoIgCIIgCIIgCEFHVKAPQBBCkdTUVFy6dAnp6emIiIhAvnz5kD9/fkRGyvyPIAiCIOR1xE4QBO8gzqoguEFGRgbOnTuHU6dOITk5WRuE7EGHtWDBgoiPj0dsbKycW0EQBEHIA4idIAi+ISKDvy5BEOzCn8fx48dx4sQJhw6qIwoUKIBSpUqhUKFCcnYFQRAEIQwRO0EQfIs4q4LgAEZQ9+/fr6X75oZixYqhTJkyWqqwIAiCIAjhgdgJguB7xFkVBDsw3ffAgQNeOzdRUVGoXLmyliYsCIIgCEJoI3aCIPgHcVYFwQJTfg8dOuT188LIKh1WqWUVBEEQhNBF7ARB8B8iXSoIBs6ePesTR5WkpaVh9+7dHte+CoIgCIIQHIidIAj+RZxVQciETqQ3U38dvcfBgwflnAuCIAhCiCF2giD4H3FWBSETOpGMfvpjVvbMmTNy3gVBEAQhhBA7QRD8jzirgpCp6Ecn0l8cPnxYk7sXBEEQBCH4ETtBEAKDOKuCkCmW4E+uXLmC8+fPy7kXBEEQhBBA7ARBCAzirAp5Hqb+OkvLTUlJQb9+/fDLL7+Y1j/yyCN45plnsGbNGtxzzz1o37492rZtq/1/x44dLs/ryZMn8/y5FwRBEIRgR+wEQQgc4qwKeZ6LFy86Tcllq5lhw4bhyy+/xM6dO7V148ePx/r16/H8889r6cMDBw7EpEmTMGfOHNSrVw/33nuvy/pXRlYlFVgQBEEQghuxEwQhcEifVSHPc/ToUW1xxccff4ylS5fivffew5AhQ/DOO+9o0VR7Tmjr1q0xefJklC9f3uk+q1evjvz58+f570AQBEEQghWxEwQhcEhkVcjzUDTBHR544AFt2xtuuAE9evSw66iS5cuXo3DhwihTpozX3lsQBEEQhMAgdoIgBI6oAL63IPitLxprSLdu3Yp9+/Zh//792qL/f8SIEYiJiXG5n+joaDRs2BCjRo3CgAED7G5z6NAhvP7663jqqacQFeX65+WPVjmCIAiCIDhG7ARBCF7EWRXCauZzy5Yt2LRpU9ayceNGbNu2TVPfdQSfc8dZXbJkCaZPn45rrrkGw4cPxx9//KE5sMZ2NHfeeacWeR00aJBbxyw1q4IgCILgH8ROEITQQ5xVIeSgg7d7924sWLBAU+LVnVKuy4nzd+nSJRQsWNDpNhcuXMDLL7+sRUz79u2LoUOH4vvvv8d9992X5ajecccd2nN33XWX2+8dERHh8fEKgiAIguAYsRMEIXwQZ1UIehj5pFM6f/58zUHlwnRbb3H8+HHEx8c73ebdd99F1apVsyKmb775Jm6++WZ06dIFxYsX1xzVnj17Zjmv7uJORFcQBEEQBMeInSAI4YuoAQtBB3ueLlq0KMsxZfotZeNzS2JiIqpUqYJy5cplLVTrZauZ9PR0h6+bN28enn32WYwZM0bbh85XX32FWbNmoWvXrlpbmwIFCphex+ebNm3q9Jhq1arlVm2rIAiCIAgKsRMEIe8gzqoQFOk6K1eu1HqXTpgwAatXr85VLWfFihVRu3Zt1KlTR/urL46ip3SE9f6p/oROKp1VQRAEQRAcI3aCIORdJKQjBATWic6ZMwfjxo3TnNQDBw54vI+SJUtq/UwbNGiQ5ZDWrFnTZf2pFUZE6ThSDdCfFC1a1K/vJwiCIAihgtgJYicIAhFnVfAbJ0+exOTJkzUHderUqTh//rxHr6cj2rZtW21p164dqlev7hWBIu6jRIkSOHLkCPxJ/KWVwL5LQEa6WpAZTY5g+2N+rggg6SogKs6vxyUIgiAIgUDsBDOu9DQEIS8gzqqQY9i7lDWlx44d09JZ+/TpY7PNiRMntBYv7E1KgSR3+4pSeKhZs2ZZzmmbNm2QkJDgs2+LIklHjx71WyuZQoUKIf+pOcCm9x1vVKIFUH6wX45HEARBELyN2Am5tBPy5/fityEIoYk4q0KOufvuu7WWMWzbwlYuurNKh3TmzJn48ccfMXbsWFy+fNmt/VFtd8CAAVr7F6b3xsbG+u3bYRpwqVKltM/iaxjJLVOmDFBhOHB8MXBsvv0NS3XOjLZKextBEAQh9BA7IZd2giAI4qwKOYfpvGywbVTI5Sxq586dsW/fPrduxq1atUL//v21hTWngew7ylRgKgzyM/mSUhenIv+pRkDprkDbv4ApjYFLx2w33PgOcGga0GCYSgeWnqyCIAhCCCF2Qs7g5LlEVQVBIZFVIVcpKlbHjqq6zhxVihl1795dc04ZiS1dunTQfAN0lNnKhg63u+nKnlI4bRdKbHsK2B4BNHoPqPUY0PYPYHaP7JpVI6dWA3P7AAltgYbDgcQOPjkuQRAEQfA2Yid4TuHChbXJc0EQFFRyEQSPOXv2rN31dERZY2qEs4PXX3+9lhJ8/Phxbab1jjvuCCpH1VgrW7lyZeTLl8/r+y6UcQjlN16DCDqlFFRa9QSw8CagZBug7vPOX3xsATCzI/BvL+XACoIgCEIQI3ZCzpx7TpoHMstMEIINiawKHrFkyRLs2bMH1157rcNtZsyYgWrVqmnpwXRKWc8aSop2rJWtUqUK9u7dq0nne0vAqcyG+xCZYanf3fMHcHYj0HYEcHSuql+t/zqw+3fg3FbbHTEt+NB0oMqtQIM3gbiyXjk+QRAEQfAGYifkwk4oUwaRkRJHEgQjERn+kj8VQhZeInRA3377bfz777+YN2+e1jrm448/xuLFizFixAgtGtmhQwc8/fTTqFOnDnbt2qWtC/XPTaVjqgTnRripbNmyWloPLp0CRpUEkG5nw8JAw2HA8UUqLTg9Fdj5E7DuVSD5oP2d54sDaj8F1HkKiPKst6wgCIIgeAuxE7xkJwiCYINEVgWHsG6TLWfopK5atcru87zJ3njjjdrj1NTUrNYvoe6oEqbhMDpcNC4SJ4/swcmUWLdb28RER6FEyQQUK1YsO6U4f3EgoY199d/Uc8CKh4GKNwFXzgHRhYFqdwGVbgS2fgZseBu4ctr8mrSLwPrXgB3fKhGmyrcAkd5PXxYEQRAEe4idkGknFC2q9Yjl4radEBOj1aaa7ARBEGyQyKpgQ0pKCn799Ve8++67mtiQlTfeeAMvvvhi3jhzrA+ddw1Q5Xak13kO586dw8WLFzVhqUspF5GenoGIiAxEIh0FYvOjQOESKFiwIOKWXYeIus8pYSQj64cBa12cu0LVgLZ/AiWaZa+7fEo5rFs/BdJS7L+uWEOgyQdKZVgQBEEQfITYCfZJT0832wmXLmnrOPnN9F6KTHLR7IS4OKlNFQQ3EGdVyIL9UL/88ku88847TvuNsvj/jz/+QMuWLREdHR2eZ5Azozt/BJY9AKRfUnWk9V8ybzO9jUrb1WnxDVDtbvX/sRWASyeAjuPNzuOJZcC0Fq7fPyJKqf/WfgKIMNSvXNwPrHtNHRtFmuyR1Bdo/B5QtJZnn1kQBEEQnCB2giAI/kaquAUtZWXkyJFareljjz3m0FGtXr06vvvuO2zbtk2rWQ1bR/XKeWDxbcCSO5WjqmHHMYwuYnldpkIy602TD6g03Tl9gAMTs7cp3gSILub6GDJSgdVPK/Xf5EPZ6+PKAS2/A3pvAMoPtv/agxOByfWAZQ8CKcddv5cgCIIgOBuSxE4QBCFAiLOax6FqX/v27TFkyBC7Kb+kadOm+Oeff7Bp0ybceeed4d2o+tQaYFozYNev5vUZHjirdFT17ens/jcI2DdaPWZNaeku7h/P4RnA5AbAgUnm9Yyath8F9FgExBvShbOONw3Y9gUwsQaw/TvHUVhBEARBcILYCYIgBBJxVvMoVOtl79NWrVphwYIFdrfp2rWrpgK8bNkyXHPNNeEvALDtG2BaS+DsFjtPZrjvrF7YY3lpKjD/WmD3X+px6W5A4epAi2+BCOs5tdNb7dJxYG5fYOl9wOUz5udKtgJ6LFYpyDF22gOx1nXp3cCMdsoRFwRBEAQ3EDtBEIRgQJzVPMbp06e19jK1atXSWs7Yo3Xr1li4cCFmzpyJbt265R0BgFKdgHL93f+pRDlwVs/vsh/pXHQjsPNXoNxAoPtCpfbb/CvrhqolTf5E231s/xqYVBvY+4+qqc06tHyqVrbf1syaWTvfF2trpzYFVjyu1IYFQRAEwQ5iJwiCEEyIs5pHuHLlCj777DNUq1YN7733niaSYKVKlSpaui8jrXRY8xxFagIJ7e0/Z89hj/bAWSUJHVTta2xpIJb9VqEc1jrPmLdjrWtkNFCmh+0+WL/KKC0jred3m5/LX0JFWHsucZwavOUjYGItYO9Is8MrCIIg5GnEThAEIRgRZzUPwDTeJk2a4OGHH8aJEydsnmePrw8++AAbN27U0n3zTCTVCiOO698wr4sp7vin4tBZ3Wl//7UeA6rcZuv4UvW3wrXmdax7pThSk4+AfAVs93VwMjCpDrDxPSD9ivm5Es2dpwYnHwTmDwHm9AbO2a9TFgRBEPIOYicIghCsiLMaxrDP11NPPaXVpa5fv97mear5Pvroo5qw0uOPPx7ewknusPlD4NIx87oO44CeS809T105q1zf6G0gvrn5eabv2oOtaVr9DJS0RLNPrQSOzgV6rwPK9LJ9XVqyUgye2gw4vtj8nDupwYemKtXgdW8AabrqsSAIgpBXEDtBEIRgR/qshilz587VlHu3b99u9/mrr74ab7/9tpYWLLDD+VFgfFUg9Xz26aCD2HmK49Oz529gwXXmNOK+m7Mfb/kcWPFQ9uOowsDVR4F8sfb3l3IMmN4aOG+JdtZ/Faj3snJ2VzwCpNhrLRQBVL9XRWlj7LTGYX/XZfcDJ5fbf29d8Il1u4IgCELYI3aCIAihgERWw4yzZ8/ivvvuQ6dOnew6qo0aNcK8efO0vqriqBpYP8zsqJKGbzo/2awRtar2GqlwtTmimXoOODTN8f5iE4BOkw2px5msexXYPxaoeK1yhqvfbydSmgFs+wqYWFu1qmGvV09Sg89tA2Z1BpY/BKRecP65BUEQhJBF7ARBEEIJcVbDiClTpqBevXr4+uuvbZ6LiYnBsGHDsHTpUrRr1y4gxxe0UBBpu0WVt/zVQHxT56+LtSj2XjppdhILlAESKapkicY6o0gNoN0/ti1tFt0MnF4HxBQFmn+h+qsWa2D7ekZd2apmUl1bESV3UoO3fq76uh79z/lxCoIgCCGH2AmCIIQa4qyGARRNuuWWW9C7d2/s27fP5vk2bdpgzZo1eP7557U6VcHC2pfNIkWsIW3wuuvTZNNeJgO4ZBGwqjDE/PjAeCA12fl+S3cFGn9gXsdo59wB2fsv2RLotRxo/J5qdWPl3FYlojStOXB4pmeqwRSImtkJWPEokHrR+bEKgiAIQY/YCYIghCrirIY4kyZNQp06dfDbb7/ZPBcXF4dPPvkE//33n9ZXVbDDqbXA7v8zr6t8C1C0juvTZU0DJpeO2kZoTanA552nAuvUfFgpBxu5sAuYf1129JbtbWo/CfTdCCT1tb+fkyuA2d2BWV2B40vtpwY3+diO4nAGsOUTYHJD4Oh818crCIIgBCViJwiCEMqIsxqiXLp0SVPy7du3L44etThIALp166YpALNdTb58lpRSIZs1zynHTIdOWwMXtao6kVG2DitFkowUKA0kdjSv2+siFZiwvU3zr4ASLc3rj8wCVj1lXlewItBpAtBlhv1Iqfa62cD0lsC8q4EzmwyfIR9Q6xHgqjVAQlvb153fDszsAKx8wnVEWBAEQQgaxE4QBCEcEGc1RNiyZUtW9HTz5s1aOxpGTa0ULVoUP/zwA6ZPn47KlSsH4EhDCNZlsl+pEUYq48q6vw9rKjBVha1QGMnTVGBC1eD2o1Xtq5EtHwM7f7bdvnQ31Wan3UilTGyPfaNVu5rF/wPOGJSLi1QHus5V6cc2asUZqq3PlEbAsUWuj1sQBEHwO2InCIIQjkjrmhDh1ltv1RR8n3vuObz11ltabzQr/fr108SVkpKSAnKMIQWFh6a3AU4Y+pPGlgb6bQOiC7m/n5kdzWJETT9RKbxGko8AY5OAjPTsdR3GAuUGuPcex5eo6Gb65ex1kTFAt/9U7ao9mCpMh5ZKwskHHO87qQ9Q63GgVGcVzdVVjSnmdHG/qnfd81f2e7Oet9YTQIM3gHx5vC+vIAhCECF2giAI4Yg4qyHAjh07ULNmTaSlpdl9PjY2Fh999BHuueceROgOh+Aca49U0vJ7oOodnp25eUOAfSOzH9d9EWj4hu12MzsDR+dkP+b78P3cZecvwGJLDSsjrj2XA3FOJicYwd32BbBhOHD5lOPtijVUfVZZx2q9hs7tAOb2Bc4aIrHFmwBt/1IRWUEQBCGgiJ0gCEK4EhXoAwhXMjIytHqR5ORkpKSk4PLly9o6OpNRUVEoUKCAttDRdOVgMpLqyFGtW7cu/vrrL61ljeAmV84DKx83r2MbmMoWZ9AdbNrX2EkDJuX6m53VAxNVpJWRSneocitwarVKAdZJPgTMGwx0m2MndTeTqAIqtbnqncCm94HNHwFpdhR+2RKnZAvtGp05YwbGjh2LkiVL4s4770T58lVVOvLk+kBG5nV4aiUwtQnQ/Eug8s0IZfjb4u9U/63qv7XIyEjkz59f+51SrIy/W0EQBG8hdoIghAZiJwQWiaz64II+deqUJhN/5YqhHYoDKH5UokQJFC9e3G5bmb1796Jq1apITTX078zk3nvvxQcffKAZ0oIHrHoG2PSueR3FiVjz6SlrXwXWv5b9uNxAoMMY2+3ObQcmWKKQVOJ1lMbrKLX3315KZMlI5VuBVj/ZRkTtkXxYqfxu+xq4ctrm83/zzTfaddW2bVvs2rVLc+BYI52YmAgsvBnY/bvtPivdrHq/RhdGKBmJ/Gz8nZ45c8at1xQqVAjx8fEoXLiwZDAIgpBjxE4QhOBH7ITgQQSWvHhRHz9+XDPsDx8+7Jajqg9aVPOlMAJfl55uqGsE8PHHH9t1VBnxeeCBB8RR9RQq4VIsyFq3mRNH1W5k1aIGrFO4GlCktnndgQmevRfVh9uNAApahLN2/QJs+dS9fVCduNFbwMB9QLPPgULVVP1rYmft6eHDh6Ns2bJauyMKdXHihQ6sRuP3bT8D2f0bMLUpcHIlQgFmOdAR37lzp9uOKjl//rw2ebRt2za7NeOCIAjOEDtBEEIDsROCC3FWvXRR0/Cls8nBKKfQ2d2+fbsW8SF0FL799lu72zLFmGJLuXm/PAfP1fKHgAyD8x+RD2j8Xs73GeuGGrBO2X62qsCewlY5HccBUQXN61c9ocSQ3IUiUjUeAPptATpO1lrY6M5Y9erVtRTYGjVqaJtu2LBBvebcVqUybM+xP7cNmN4K2PyxOs9BCH8rjKTm1tk0/t6tk0uCIAiu7htiJwhCcCJ2QnAiRVi5hI7l7t27HdaU5nRAq1Chgqbse+HCBS3lsE6dOmjZsiWaNGmCRo0aoX79+ihSpIhX3jPPQCEkawpttbuBonaihe6SP8EzZ9WYfkzF3Qt7VJ9UTyhWH2j9q+qZqsNa0gVDgatWOxdcssKa2TJdtf86uoazI/sRwP6x6r9RhYH0FCDdkEHA/698TDnNTEuOtZybAA9ANBLprHoLTi7x91+xYkXNuRcEQbCH2AmCEPyInRC8iLOaCxjdZDqht6Mr/MHs2bNHq1WdMWMGmjdvrvVPFXIpqrTiMfO66CJA/Vdzd1qtkdUrZ4C0y0C+GNttS7ZWkdFLBodp/wSg5oOev2/5wUC9V8z1skxBXjgU6DJTpQx7CK+xhIQELbrKa5B/iR5hxUX1WCP1nOMdHZwETGkItPk/1RInDAcgHU4m8bcqDqsgCPYQO0EQgh+xE4IbCQfkEDqoNFJ9mQZIhd+OHTuKo+oNNrxp22+07vO2zqan2Hu9o7rVyHyqPja3qcA69V+2TS0+OhdY/3qOd/nII49okf0bb7wRDz74oFYbfffdd6snj/zr/o6oVDyri2qZE+C0YNal+sJRNTqsrDsXBEEwInaCIIQGYicEN+Ks5hAap0zZ9fVAd/DgQalLzS1nNgObPjCvY+1lzUdzvWvEFFd1rzmtW2U7mytnc/beTOFt9TMQV8G8fv2bntWvGnj22Wfx3XffaTfupk2bYuHChahUqZJqs1OyFZDQzrMdrnkBmNwQOLEsIE4rhc74G/I1TAkW0SVBEIyInSAIwY/YCcGPtK7JYf0JG3D7i/Lly0t0NafQQfq3h63z1mUWULoLvMLo0kDKkezHnacBZXrY3/bKOWBUSSDdMNHR7h+gwjU5f/9ji4CZHczCUYz4sn61QBl4nfO7gN3/B+z6TYkuuUuBJOWsl+kFlOoExBSDr2Eq89mzOZwM8JCYmBhNnMpV32RBEMIfsRMEITQQOyH4kchqDqMo4fx+YSeqZHVUK93oPUeVxJYyP75oSTc2wl6kiZ3M6/bnIhWYJLQGGg63je4uvBFI947wl4lClYF6LwJ9NwM9lgA1HnLPKU4+CGz/Bpg3CBhZHJhQU/Vu3fIZcHwJkJbi1cNk5oO/HFX9/c6dc1LLKwhCnkHsBEEIfsROCA3EWfUQKqM6682YkpKCfv364ZdffrGpBXzmmWc0oZebbroJ7dq1Q+vWrXHNNddg1iyLQq2dGVq9nY2QW1GlokBjS0pwbrGq+V7Y7Xx7ayrwocm5dyprPwEk9TavY40pa3V9BSOIJVsAzT4FBh4ArloDNHobSOxomxptD0Zld/8OrHhYtb35pwgwtTmw7AFg5y+qJy7Tj+1x+RQw/zqzWJWFkydP5vh3yrSgxx9/HD179tSUt139Rt15T0EQ8gZiJwhCaCB2QmggasAe4sxRJbGxsRg2bBjuuusutG/fHlWqVMH48eOxfv16jB49GtHR0XjzzTe11jRsd7F69WpNwIbPlStXzuF+T58+jQIFCnh6uHkbe6JKjEAWsERCc0vBSp45q+X6ASseyn5Mh+v4IiDRw3pQm/rVX4Apjcyfed1rQGIH36vy0nEt3kAtdZ5RdbhMFV7zInDZTQeOrW9OLlfLti+zFZuLNQCK1AaK1FJthviXkeO9fwNH/wNafg+U7WOj7Mc+xTn9nZLGjRtrQlN0Xt2FvWppqEZFya1VEPIqYicIQvAjdkLoIJFVD3EnwtmgQQPccMMNePHFF3HgwAG8/fbbePXVV7W607i4OE2who4qfyisb2N/S1ciMCLe4gVRpfhmQLV74HU8dVYZiaUD5i1VYJ3YkkDbvyxRzQzVfzXZUFPrD+hkVr8PGLgXqHBdzvdDp/fYfGDHd8CqJ4A5vYHxVYAZbdTzKYeBuX2BJXcCl7Mnkugwuup97Ox3ykmlm2++WROZypfPjSixAcmCEIS8jdgJghD8iJ0QOoiz6iHuOo0PPPCANmDRGO7Ro4cWvTEyePBgNGnSREsJZgSH/3cG0xbp3ApuwPPEyKVRcIiRxxZfq/Yx3qaQxVk978JZtZcKfGCCd46F0dkGltRfOnSLbnacUutLogoCbf8EGr+vvgMrEVFAXHn+x7P9Wj/Ljh+ASXWAfWM9chhd/U5zgjirgpC3ETtBEIIfsRNCB3FWPYDOorvtahiZadiwoZaKOGDAAJvnmWq4dOlSfP7551r9qqvojSfvneexJ6pU/X4gvqlvTo01spq8X6W0euKsnt0MnN3mneOp87RS3DVyeAaw4S0EBKYIs6aWKsn5S5if44TCxf1AgzeALrOBRu8A5a/OdGA9hAJOFG+adw0unT/uld9pTuDEkiAIeROxEwQhNLh06ZJb24mdEHjEWfUATyKbS5YswfTp0zUBpeHDh2uCLfZ+AB07dtSc1okTJ3r1/fMsTBtd+bh5XWxp22ijt9VxrVE/OmDOKNHcVkXYW9FVRjBb/6paxRhZ97Kq8QwUpbsBPZcDxRtZnsgA1r6olJtrPQ60H6nShwcdBDpOABq9C1S5HSjZGoh20e6G33WhykhPTfHa7zQn/ZEFQcibiJ0gCKGBu2O12AmBR5xVH3DhwgW8/PLLeOqpp/D8889r677//nunefPs8yR4gZVP2DqKTT4EYor67vTSgWKNprUXqSuHsmxf3zirJDZBpd8aU2/pRC+4AUg5hoDBlOnuC1T7ICsUVfpvoFJxJmyHw3NU5ymg1Y9Aj4XANSeBQYfN5ztfAVUX22kyMHAf0Pg92wiuF36n7iJ9VgVB8Pb9R+wEQfA/YicEB+Ks+sAIfffdd1G1alUMGjQoS/33p59+wpYtW7Bs2TJNAZgRHC5jx47V1rGNjcsvK1K+LqccnAbs+N42mlfxevgUXheeiizZSwU+vhBIda8m2i2oAlz/NdtU2UW3BKZ+VScqDmj9G9DQTlrywUnAzA7AxYOOz3W+WNWTtdxAoM2fwOCjQLu/gKSrgEilwuuOKJKz3ylh2j3ThBgpoaHI/7sSbSLyOxWEvIvYCYIQGoidEDpEZEhuqUds377daU3avHnz8Oyzz2LMmDFITEzMWv/VV19pvRrvv/9+rU6V6qP8oVAZ+Pbbb0f37t1dGsC1a9eWqI0jLp8GJtUzt22huE/vdbZpur5g7gCzom+9l4AGr7tOWR4ZD2QYHKAuM5SD7S3Yv3VOL9sa3qafAjUN7XMCxZ4RynlOt9Rjs2a10ySgWH3b16Qmq+2dRMvZQmb37t05/p3++eef6Nu3r41K9xtvvIGBAwc6/UilSpVCQkKC020EQQhfxE4QhOBH7ITQQZxVD6GT6ax/o68oGHUJlaPXAuUGAPnj/f7+Qc/i/wE7fzKva/4VUP1e/7z/8keArZ9mP650M9DmV9evm9YKOLEk+3Gd54BGw717bGxbw/6rVAU2ps5etRooUgMB5+h84L8Btv1YmerbflSOnHdGQjdv3oxAwAmoQoUKBeS9BUHIw3ZCwYKoXNkPk7OCEAaInRA6SF6ph7BPaiCIOz0bWPI/YHQp4N9ewPbvgRT3FE/DngOTbR1VOji+6KnqCGv01p00YFKqi/nxkdnwOgVKAW1+M69LS86MaBra+wQKttvpsQgoVNU28vzvVcCOH21fwxY1E2upiPaqp9Tv4chc4MI+LZocFRWFmJgYBIICBQoE5H0FQcjjdkKA3lcQQhGxE0IHcVY9pGjRogGpSSu+7+PsVh+HpgFL7wLGlAZmdwe2fwukHEWe5PIpdS6MRBUGWn6v6hv9RU5qVklpi7N6chlw+Yz3jivrfboB1R8wr2NEd9O7CAoY4aXDSsVfI7zel9wBrHlJ9c81fp4Le1Tq9ab31TUwqxMwrgLwdxwwoSbio44F5P7gTh2MIAjhS8DshOLF/f6eghDKxMf7P1NR7ATPEWfV0xMWGen3AaEQjiHmih3BGdY6shZx6T3AmDLArK7Atq+AZEO6Z7iz4lElGmSkyQdAwYr+V7k1QkXiNDf64pZsA0QaIoAUPjo2Dz6h8TtAoWrmdeteBU6tQVBABeMus4Dy19g+t+FNYPEdwPElwNqXgZntlciSPVjPWmEIipVv4fca7xIlXKsQC4IQ3gTETihUKGDZJIIQqhQrVkzshBBAnNUcGqT+NIIT2aWjbH+zU2OFTg5TSJfdD4xJAmZ2UhGn0+vMEalwYv8EYJelLrR0D6Dqnf4/Fmtklb1DL+5zTxnXGk087INUYO29Cqr+q8Z2NulXgEU3A2nuNcf2OVEFgHYjgNpP2T636ydgeitg/RvAqdWO91HnGaDBG4iKjvbrrClT8CQFWBCEgNgJBqE4QRDcTwUWOyH4EWc1B3D2snTp0vAHJeLjEVehM9BxHDD4CNDqJ6BMLyBCteiwTwZwdK6q5ZvcABhbDlh8O7D7L+DSCYQFl04CS++2FeTxd/qvTgx7rRYN3rpVnYTWQO2nzes4ocEIa7DAlPYiNYFiDTx/ba0nVEuczGuAyrxsS+NraJSWK1dO1LoFQfC/nVCihNSrCkIOETsh+BE14BzCjj+7du3CxYte7ItpITriMqofeRGR7f60bdNBp3PfGGD/WJUKnO5uZCwCiG8GlOmplpItgUjfG/NeZ+FNwO7/M69r+QNQ9X+BOiJgciPgtCGllo5z1TvcU8NlWquRq48D+X2UUsoo6rQWwOm12esYbe02D0hoA7/D9jo8b4emAvvHm9WR3YHKxkVqA5VvAmo+ajNZwabe/K36kjJlykgKsCAI/rcToqNRvXp16e8sCLlA7ITgRpzVXMpecyC6dMn7KZT5ItJRZcsg5E/ZCRRrCHSeAhQoY3/jK+eBw9OB/eOAAxNtW4A4g9HIUl2BMj2U8+qPnqS5ZfcfwMIbzevKXKX6cgYiqqrz3yA1eaBT51mg0VuuX8fa1pHFgTSDQdNuJFDhavgM1qlOa67SgHVYz9p7tUoX9odzemQOcJTLf8CVHIhKFWsCtPoWKFwTiHbSKub8bpw6uhsHLpaEr6IajKD4uz5WEIQ8bifky4cqVaogf/78Xt+3IOQ12G6Kbad8gdgJuUPSgHOZ686eZt4eKKIiM1Bl82DlqBIa9tNbA2e32H8BDfXyg4HWv6hU4a5zgJqPAYWquH4ztgfZPwZYdh8wvgowoQaw/CHl9NIJDjbO7QCWWnqnMv225XeBdVRJ4ermx2c2uve6fDFAQjv/pQKT4g2B+pbU3/PbgVXP+MY5PbkS2PQhMLc/MKoEMLUpsOoJ4MAE9xxVtrWJNPzOmAbf/DMgvql2/R86dAjHjhnUfykyxt63E2oC4yuj+IX/ULZsWa9/NEZMzpw5I46qIAj+tROiosRRFQQvQlE0sROCE3FWvTBgVK1a1WsF2kWKFEG1hFTkTztifoJtOqa3AY4tcr6DyCigVEeg6YdAv+1A73VAgzeB+ObuHcC5bcDWz4G5/YBR8cCsLsCG4SoKlnoBAYURyAXXA6nnzOubfQ7Eed8R8Ziidc2Pz2xw/7XWFja+dlYJa1dLtDKv2/aFSisPtHPKiH/5q4EW3wED9gL9twM9FwP5E9TzlW/WUpZPnDiB7t27IykpSas7GTJkCJKTk4ECpYGzm4BzW1Xqe5XbtYGIRqM3alip9ska1Z07d6JOnToYPHgwFi1y8dsUBCFP4hM7oVo1iagKgpcROyE4kTRgL+e8H9i7HZfT8uVoMGPdG/svaRyYBMzta7thRDTQ9g+ggp32Hq64eED1aKUzwuWSh30oI/KplGTWNVLBlm1X2CLGXxFNCkZR4dhI5VtURDkYOLFcpdZmEQFce14p/rp87TJVR2pk4AEgLgk+5exWYEojIC05e11cOTXJQdEof6b1Fm8CJPVSKd2OaqmZXTC7G9Dub+0afPzxx/HRRx/h77//xpEjR/DQQw/h/fffxxNPPAHsHQnMH6L213ly9uGmp2vbnjx5Uqspy4mhSOeYv9k9e/agUqVsJeh27drhxRdfRI8ePSTaKgiCfTvhwAFcvuxGazNXdoIgCD5B7ITgQpxVb3JhHzLGVcDFYl1xouxDOJevCjLosDihYMGCWi574cKFzcYtjejRpYFLR+2/sOKNQNvfc36sbHVzej1weIZyXOlgGGsm3SW2tNl5jW8C5IuF1zk4FZhzlW3aba+VzusV/Qkjz39bjqXXCnVOXJGeCowqaXbyWv8OVLbU5vqCLZ8BKx52fxIg+RBwcoVa6KCzL2xOnFMKSJXuqRxUthwqUMq91zHLIKaE9r3XrFlTS/9lhDUlJUVTxOzSpQtmzZql0rAn1XVY/8tastOnT2tOqyvDkbVh8fnPonhSPcTEZtf00tml43r4sLm3cYsWLfDSSy+hT58+4rQKgmCC9w2WEPC+de7cOZeTZg7tBEEQfIrHdkJ8vBadNfY8Fjsh94iz6k2Y9shUx0wyoovjUu/dSL6chiuntiIjriIiIiO12VH2Y2QNC9MJHbLoNmCXk6ghBXwaDjP3zcyNQuzxxZlR1xnAyWXKofUU9oIt3jhzaaAiscXqA9GFc35srD+c0lC1NDG+T4/FQHxjBBXjqgAXDMqz7GvKlFV3mDsAODA++3GV/wGtfoDP4fc8u7tt6nG7UUCJ5sCplZnOaebfFLNj5jZRhYCEtkBCe6B0d1VvGul5FoIRRhg4OOhqv0zxrVGjBjZs2KAUsyfVAwbudal4zQGJzi6XtLO7gYLltd8mf6P8rWqpw/OvB9JTgLZ/qzrjTAYNGoSxYw3CWgZefvllvPbaa7n6jIIghC80ZCm+xPKFK1euaI/pkLptJwiC4BdMdkJamrbOxk5wgNgJucNZs07BU/aOMD2MKNsXsQWLIDbfUWBWb6DTFKCkJdXTGTTonTmrG99WNXl0iHKr4Jovv6p15dLwDeDyaZXWeWQWcGyhSvPMUD9Op6RfVq1HrO1HKPakOa4NlLgPl4KVXDvadKQW3Wx2VEmjd4PPUdXrVo3Oqid1q+y3anRW/VG3SvgdtPhWpQOnGkS15jPV3PM02SzylwQSOyjnNLG9+v5ZU+1FEhMTs9J5afBxMOE6jZRjqpWRG62ZaBgWKlQIhaKSgX+7Ad3nqUkWI+d3ACeXA/OuBtqPVL8ZAE2bNrXrrD7yyCN49dUg6l8rCELQQcc0NjZWWwRBCF6y7IRCnmfziZ2QO8RZ9RbndwEnlprX6XWlKx5T7WToeHrkrHZ1vc2+0VprDnQc712RIdYrlh+oFj3FlXWVxxcp5/XEIhW5cpfzO9VC5WFjpI3OK5eitVXrlMLVlBOrR642vWcr+JPUF6hpSVsNForVBQ5OzH58OhciSxd2q+vKm+2ELp8CzmwGzm0Bzm7OXqiynJFq2dhDR5X1y5pjmumgFqnp83pm1oZ++eWXmDFjBg4ePJi1ToMCS1Xv8myH615TKc1bPlF9co3w+iX8ftmmqMNoLeW9UaNGdnc1c+ZMbQaWM66CIAiCIORNxE7IHZIG7C02vgOsfjb7cVRh4OqjwOHZwNw+al1McWDQoayIjFtMqq+MbjqPzpzDAklAxwnu1Ud6A9bYUDmYzuvxheova2BzE4kzRvriKijlV6adwpCOzF6zV60FYn3TMzPX7PoNWHRL9uOClYEBmU6OKxhFHl0KuHQ8e13LH1R00JPvha+/uE8tdELPGpxTa4Q6p3CiganeTOWNb6YipwUrwG8cX6pN/LBWdMCAAVi6dGmWozpq1Cg18zlvCNDkfeVEuwNrXCc3UBkEbJMzcB8Qm6k+fPkMMNIiOJXUG2g/GvsOHkWFCvY/+3333ac504IgCIIg5E327dsndkIuEGfVW0xpApxalf244lCg+ZfA5PrKadBxIPbikDUvKQGj2FLAzA7O28fkiwPa/A6UH4SAQIOe0WXWOJ5ao1KHqd7qTvqwJxQoCxSqBMSWUc4rHXXtb+bC9RTvCYQQBes62abFiKYI7Gaa9vxrgb3/2Bc6oiN65bQm5KWc0f3ZTikXrk/eD6SlwLtEKmeUTqnmnDZR4lbeqJX2FJ6D9a+rdko9FmnHwhTgrVu3aoIGbE1jEuTiZEH3/5TCsSv+7Q0cmpL9uP7rQP2XHCg9Z5LUFxnt/kHpshXx6KOPaqrEq1evNm0yevRorV5FEARBEIS8B+2U0qVLi52QQ8RZ9QZM1Rxfxbyu/Whg/zjbmtPymfVunhjnutN1gOmHA1wLHzV6W/XQDAbVQDpOjFhpzuta5cDy/0yL9iWsU6RScZYDW1pFp9m/M6oIEFNU/T9rMTxmVC2n5y71YqYisCHC3HMZUKJZdpuX9EvqvFB9mWm5l06q88Fl/wTgwDjzBAQdQz7HyHpOFJs9gdFsnidGza3XVJ1nEFBSk4GldwO7M1WwY+KBxu8BlW7KThtnC55tXwNrXsw+Vzx/3eaq68ARByZnZ0DocBJkwG51Le3+A1joQJm5bH/sKv8BKlephs2bN2u1KVT61KEy4Jo1a1C+fPlcngBBEARBEEIRCkFyQl3sBM8RZ9UbbP4EWPlo9mNG0Zi+ueB6223Z1mXw0Zyr4275HFjxkOvtqtwGNP/GpFoaNNABTz6YHX1l+vD57cC57b53Yt2BzkmW05oPiIhSf6lcm68g0Ob/gKK1tE3ZdoARParBaez4GVh2jxKa0tGjqnRQvR1lzgn8LKwNLlJLLYVrZv6/JpA/XrXRmdpMfTc6+QoAfTZ4t37WExhFZp0oBY6s1HkBaPCa+n5STgCzOtoKWxWpDXSbA8Rmii8ZSbusMiAoVmal7V9AxeuAta8C6+2o+tZ+Eqh+v+m8/Pjjj7jjjjtMm3Xs2BGzZ88WVU9BEARByOOIneAZ4qx6g1ldgCP/Zj8uO0DVcV46Zn/73PbPpGDTlo9db0ehG7YfCdb6TnvYi2DRWWS9r6Pz6U/onDR+T6uVvO222zBt2jStt+dDDz2Et956CxGMek+qbRuZ9DsRKpLIek06oUbHlMrMriYxWBM6vZU5QlzmKqDTJP9H7CnoNW8wkHLEvJ5pyE0/BWo8YF6ffASY1UnV6Bqhum/Xf1WKuJFNHwCrnrT/3my1030+sOAGYO/fytFPv5L9fJMPgVqP2aT73HDDDRgxwqwOztpV1rAKgiAIgpB3ETvBM8RZzS1M4RydaI6YtR2h6kx3/gKsfdFwthmdy69Ufqnem1OYSjr/apVm7IpCVYGOE7MigUEN61untQCunDU7JJ2nq3N25ZxSZGUElpG2lENAsmHhY08UinNC/x2as3frrbfit99+w8iRIzF37lx8+umnWvsSiv1g0/vAqqd8exyMEMaVt10KZv6lo+pGyxanLHsA2GYRB2r3N1BhCPzG9u+B5febHURdwKztH0DZvvZfd/EgMLOjitgboSgUHVamgevs/gu4uBdY/4a5dU/hGsox7zAOuLAXKN4IWP00sPNn84QQU4wtnDlzBg0bNsSePXuy1lH0if1fHYkxCYIgCIKQNxA7wX3EWc0tu35XfUCNNYZXHwOi4mwVgtnOg4Yt1Vp1ldGcQqGlmZ2Bk8tso5DWFiSsx2SdbOluCFroiE5rqZSPjTR+H6j9hPv7YUpnymGzA6v9PaacYLYl0f4a/3/GvfRcpvNee16bEStatKhWg0jnY8uWLahVq5bmwP7888/AoWnAv73cP2Z+P6y/ZMSPf9mn1RiZpZPU4A0VXWbtLVsUMZ3cH4JZE2up86nD9++72ezs+QI6p8wg2PaF7XNsccTJHrY7cgYFpyhKxhZARkp1Vj2PrarcrDU2CpgxosrIqrVVFPusGidTBh22+3ueNWsWunUz/+Z69eqFyZMna70VBUEQBEHIu4id4B7SZzW3WKObbGdBR5VY0xCZhkkjNbeOqu440WCnQimjjDp0VKOLKdVYHTpjdJ6afQFUvwdBB1NnF91q66hWvB6o9bhn+2J6K1uoeNJGhTW0FObJcmIzF9ad0onVltQsB/H8+fNarSqFc4j+V+/zqTmXVrrMVI4oHSRG17kvLnRUI6OcT4DQ2U7q4//0WzqkTT8BFlyXvY6O65oXgOaf++59ObFAVeSjc2yfK9MTaPunctxdwShz19kqwmpU5GbKPq83RmZ1ReO0S7ZK2zGWdGFSugcQGZNdk8xrl8JnVW+32bRr165a7eoPP/yQtW7q1KlaRP6WWwztjQRBEARByHOIneAeAeg9EUbQwD001byuwjXZ/z9jcb5cRYI8pUBpoMNY2ygbjW7WJhqhw7XsXmDZgyr6GExsfBvYP8a8rlgDoOX3/nHQ+B6cYOD5LFJDKfeW7gIk9QLK9gHK9QfKD1YTEZnpnLGxsbhwQTk3+t+SJTNrg/OXtG3rwrTV+MZA0TpA4aoqOspIqtVRJSVamh+zVpNpqoGAKb+sVTXC1GDWtPqCU6vVBIw9R7X2U0DHSe45qjoUPuoyy1ZYae8IYKWhTtWesBfFpqxEFwJKdTGvs167Bt5//30kJSWZ1rHFzZEjlvpbQRAEQRDyHGInuEac1dxwZLa5xo01gpkOjRatsxdZ9Tbse0nlYSMZV5TxbXUyCNMqtUiTIRobSA5OUW1GjNAZ6TDG/d6kfoYpnJ06dcLGjRuxc+dOTJo0SVvPdWqDfKpW2Ajb9rgLlXqtDhn71wYCOvLNv1BqwFlkZCoeW9LNcwv7y05vC1zIrvPU4GQMRckav6sUfz2lSHXl5Fqvpy0fKXElYq/WmZFwe3Dywsih6Q77HxcrVgxfffWVad2pU6fw4IMPevIJBEEQBEEIQ8ROcI04q95MAU5ol92ShumSTL+1ts/wBZWGqr6qRqicy4gco1FWTiwGpjQBDs9GQKFQ0oKhZsVZRiTZLoSKtUHMu+++i4SEBFStWlVTAu7Ro4dWs5qFNRXYWlvsykEs0cK87vgSBAxGJ+u/YhsB3fKpd/bPVFpOWDD119pHNq4c0G1e7tSzCaPlVMZmTbcRqgBTgdoaWbWXnq2TZBF1Yt9coxq4hf79++P6681trCjMNXr0aA8/hCAIgiAI4YbYCc4RZzWnaLVq423r2YzGvBFGpjypo/SUhsOBMhZRn1MrgYsHgFa/2KYK05n9tzuw4W0VBfY3rAll30xjbS1p+BZQxnAeg5T69etrDZ7nzZuH9evXay1ssnqtEquz6WlkNLev9zasHS5az7xu7UtKJTe3Ik5zBwAbhtk+V7IN0HOZcjS9QVJP2ywEsvg2W2fT2t7GWgtLVWEjBy3lABaoFl2ihHmf999/P06eDIK+woIgCIIgBBSxExwjzmpOObFMCd9YxV8cORdM17XWMXoTpkdSeKZwdfP6PX+oCGuPRbbRSi2i9Rwwb5ByGvwFlV4ZRTuz3rY+0l4kOEiJjo5Gu3btULduXdfO5ul1QKolaugMa93qyRXeT7v1BKa4t/jGvI5R0OUP5XyfZ7eqXq4HJ9o+V/UuJY7EOmJvUuUWNSFivR43vOVeCrBO2X7mx9badQuMwnMgMsK61ccf91BATBAEQRCEsEPsBMeIs+qtFGAKuBRv6NhZtTovviCmGNBhPBBdxLx+9TNA8mGg13LbFEb9s0xtBpzyoK4ypzCKu+x+1d7FCKN2LX/0v+KtryjexDw5QYGrU6vcf731eqFjeGYDAgp7B1e727yO2QWHZni+L15z7Klrretmmm7zL5VjbG0t4y3qPAPUeNA2ldfdyKq9utXzO4CzhnZDdrjhhhvQt6/59/fLL79o0XlBEARBEPI2YifYR5zVnGKNBjEFWHdO6JAFwlklRWsBbf6PVr9hZQaw4HrVEqTjOKDBm5bnaWxvV1Eutk3xJew9u+N78zqq51LVmEqr4QI/S9G6OU/lZXujgpUtrw9g3apOo7dtlXVXPu5+1JdK1Oyf+t9A25puXgds8VP9Pt9OWnDfTT4GyhuUu63Ya1tjnYwokORRdJXCXF9//TWKFDFPJj3xxBNIT093fdyCIAiCIIQtYifYR5zVnMAoJdM6HaUAX9gNXDoeGGeVlO0LNLTUANIx+G8AcOUcUO8FoPM02+gRe42yvycjn2zL4212/6XSjo2wlpbRYLZzCTdyW3dasmVw1a0SqhQ3sFxbTOfe+aPr157fBcxoB2z52Pa5Yg1V5L9UR/gFps23+Q1I7GD/+dhSrh1eD1OBSdmyZTFsmPn8LVu2DH/99ZfrYxYEQRAEIawRO8EWcVZz2rLGilEUyOpUMGJUsBL8Sp1ngQrXmdcx5XLhjUB6GlCmO9BrJRDf3Pa1274CZnYALuzz3vEcnQcsNqjlakSoliQJrRGW5FbRN5gUgY1UuV31wbWKLVE0yxH7RgNTGttXRa54PdBjAVCwIvyKNlEy1jYCritmu6KsJRWYIk1pKS5fds8996BGjRqmdc899xxSUly/VhAEQRCE8EbsBDPirOaEw5YaPSqDGlMjKb5kdTr8XYvJ92v1g20LlYOTgHUvq/9Tnbj7PJV2aYUO91S2t5mZ+2M5u0WlfaZfNq9v/B5Q4WqELVaRpAu7VCp2Tl/PmlVGxgMNo5JNPjSvSzlqK1JEGKGnCNO8q23TfiPzA82/Atr8EbieuowUd56qeuMaOb5ITdo4o1RnIDLGnJnASRk3hLnY+sjI3r178cknn3h27IIgCIIghB1iJ5gRZ9VTWI9qdeCMKcAkUPWqVugAMHLEyK6RDcOBvSPV/yliQ0Gb1r+q9jpGmMo8uwewfphSDs4JdM7m9LbtY1n9ftUOJZxhxM56Tq0TGc7gJIipL2iGUgUOBkp3tU2D3fwRcH539uNzO4AZbYGtn9u+nqrVPRcD1e8NvKhWgbJK7djK8oed9k9FVAHbCQU3UoH1nmodO5pTnocPH45jxzyYzBAEQRAEISwROyEbcVY95dxW4OJ+x84qhWasDoW9VFt/wdTKdiMtTg+AJXcoZ0Kn8s1Aj8VAIWvtaAaw9kXg317AxYOevXdqMjC3P3B+p3l9Uh+g6SeBd1J8TWSUalmU07pTOkPWdNtgqFs1RsaN1xUVdVc/q/6/9x8VmbfnXFccCvRaYRv1DxRMX7aXvpuRCswfYnv9GinVKUfOKkUUPvjgA9O6s2fP4rXXXnPvmAVBEARBCFvETshGnFVPsUZVowoBJdtkPz6zUbUZMVIigM4qoWhNs09tDfQF15mFlIo3UCI31lo8PfV5SgNg31j33pORWIo1WWv/GC1s+5dy5PICuRVZsl47p/3QXshditRUEXIje0cA/w1WfXStNaysEW3xHdDmdyC6MIKG5AOOn7t0ApibKUxmj0SLs8rf/4W9br1t06ZNcdNNN5nWUS1482ZLOx9BEARBEPIcYicoxFnNbb0q69byxTh2Rth+hG1IAk21e4FKZsNYi3qtetpOr9YxQMO3zH1CdcN93iBg6T1A6gXXvVT3jTKvjysPdJwYXi1qPHVWTy5V58dd2H/WSKB7rVqp/7Kq+zSyf4ztdkVqAT2XAtXuDL6I+kWLs2pNCaba8cKb7KfCl2xtrlv1ILqqp/7GxsZmPU5LS8PTT1t+k4IgCIIg5EmGi50gzqpHMMXXWsNmrVe1Ph/oqKoOHQSK2TAaZmTrp8A+i3NBJ7Xus6rnJev5rGz/FpjaFDi50vY5OmKrnwa2f2NeH10E6DQZiLP0psxrziodfgotuUsxi1LtmU1KzTlYYPujepmCXY6odDPQcxlQrD6CkmRLenvhGrYKwQfGA2tftp+qXbKVed0hy4SWE8qXL4/HHzfXbk+YMAH//uukVlYQBEEQhDxBebETxFn1iJPLbVMbTfWqacDhabaR12CBEc22f6t0TCOL/6d6YFrhsfdeA5QfbF/hd3orYON75ojThmHApvdtI1XtRwHFLFHCvABbFlkFrjxpQWN1mlgXet5QaxxoGGFn5NEekbFAyx+B1r8EdzTdmgbMDIAO44CYePN6Xtt7RrhOBT72n0fR82eeeQaJiQY1cQAvvPACMjyJwAuCIAiCEJY8k8ftBEkDzk29aqEqQOFq5rRaRs6MJF2FoIJ1qRQ3MnLlNDCf9auW1jJ65IwCTS2/B/LFmZ9Lv6KiqLO7K9GpLZ+qfpvWKG2bP4HS3ZAnYUTbqhjrSd0qWyLlTwjOVOBji4DJjYAdP9h/vtpdQNXbgy/t14pVOKxAElC4KtDuH9uWNotvA06uci6yxDY+57a5/fZFihSxEVZatGgR5s+f7/Y+BEEQBEEIT/K6nSDOqie4allzaIr5cZHaSo032Kh6F1DxevO6k8uylVyt0Nmoegdw1Sogvpnt80dmAxNqAisesX2u5Q/h3Us1RyJLHkRW7UVXA+2sUpRr9XPAzHbA+e2Ot9v5I5B8CEGPTWQ1M/W9dBfbiR2qBlMh+LKhZ2yJVrZ1q8dc91s1cscdd6BChQqmdW+//bZH+xAEQRAEITy5Iw/bCeKsepLueHyhc2f1oMVZLdMLQQmdzxbfqF6XRrZ8BOwf7/h1RWoA3RcAdejUWqJlVgVk0vRToMptXjrocBJZWqHa+oSis3pqDTCtBbDxbVvBIab9Gq8L/maskfZQqFllZFWHasfV7jE/zzTsJXdmp/raq1s9+p/HDcCffPJJ07rJkydj7dogUn8WBEEQBCEgROdhO0GcVXdh6ibTXnWYHmisR005bpveGWwpwFbBo3Z/A5H5bdMcL+xx/DoqHzd6C+g6G4gr53i76vcBNR/y3vGGMnRkjMrK6ZdtJz48ElnaEBhxsQ3DgWnN7bfPYaoz65utkxM7flQObjBjVQM2iopxYoeTLtZU7n0jga1fOK5bPepZZFWfNS1Z0lzf/M4773i8H0EQBEEQwo878qidIM6quxxfZH5cvJFy+HQOT6cUbvZj1ncmdkBQw8/Q9CPzusungPnXmx1ze7BOj/1Sre1tdLZ9C2x4K7iUawMF2wEVb+pcNdqTyCrFreg8+ouzW4EZ7YE1L9heFxTPajgc6D5fRd4bvAlEFTRskAGsewVBC6/PlMP204CNEzTtRti26Fn1OHBimf26VSo+s47bA+Li4vDwww+b1v3111/YuXOnR/sRBEEQBCH8iMujdoI4q+5yzBIJK9nGeQpwqS5APkvUMhhh/9UKQ8zrTiwG1jzv+rUJbYH65oLvbNLUPma0A85s9MqhhjSsf7TW+eZYEfgycM5Jrai3YJrvls+AKY3UNWGFrWjYkqbuc0BklFrH1kS1nzJvt3+cSn0ORi4dBTLSHKcB67D2vPWv5nV03OdfqyZ47NWt5iC6+tJLL2nqfmPGjNFSftLT0/HBBx94vB9BEARBEMKPBx54AKVKlcLtt9+Ob775BlOnTsXly3YEUsMIcVbdgbVpVmO9ZGvD8+nAIUvLmqQgrVe1W7/6nVI2NsL2MwcmmVbNmDEDAwYMQNeuXfHdd99phjTqvZidAhlTwnb/PG9TGgPr3rCvNpxXSLS0MGLK+JVz7r2WisyxpfybCnxhr1J5XvEwkGapr2U0vc5zylEt3tD2tbUes237svaV0KhXZXo/FZjtUbavrSN+YTew+HbVDspat2rNxvCAgQMHZqX2/Pjjj0hJScnxvgRBEARBCA/i4+Oxbt06zTa4++670b17d9SqVQvhjDir7sA2FNaWNEZn9eRK4NKx0KlXtRJTNLN+1RIZWnRLlurpsmXL0LNnT5w4cQKlS5fWfiBffvml2q7OM0C5gcDAfUDdF2zFlxgJXPeyqnc8sRx5ksR2QERm9JEwmnfMA8nxopYetY56m3pjYmbnz8Dk+vajvxTl6jYfaDTcceYA0+OtTt3BSZ71lw1YvWoZx6ntpOEw26wKRo63fGxbt0o1cH5VZ85oEdMOHTrgf//7H7Zs2WLa7PDhw1i5cqX2f8rQv//++1kOKylYsCBiY2ORmpqKzz77TNvHDTfcoMnWC4IgCIKQt0hISNBsh7feegs33XSTZhPQPg9XxFl1B6sYDg1aY0uag5PNzxeuYRupDHbimwKNlZGcxeWTWemmX3/9tZaeyIjqb7/9ps3sfPHFF+b6VaqiNnwT6DYXKGToP6tDYZ7pLYFVz3imhhsOsI7TGnnLTSqwLyKryUeA/waqSOGVs7bP13hQtS9KMEzUOILb5jeLAGDtywg6qOxrJK688+1Zo8v6VUa7jax62hyRpXBZpaHaf+lcUl6+efPmmDVrFjp27IiLF7PVszds2IDrr78ea9asweDBg9GypRJz2rZN9WotXLiw9pfRVf7+OKPKGpW9e/c6PMzjx4/jiSeeCPvUIEEQBEHIi2zevBkTJkzQJq5pEyQnh69dLc6qO1jT+RhVZfqsHona81dotKxxx8EoP9i8LrqQyXAuX748IiMjUbZsWezYsUOlAjMF0hhlS2yvlGFrP2kbpWLK9KZ3gSkNc1TTF9KwjtnI4dnBoQjMa3jX78DkesABO62L6MB1mQE0+8winuQEXjeMuBuhCNnR+cGXNWHE2s7JHlTBbv2beV0G1ZLfzs5OKN5Ay1g4ePAgRo8ejX79+mm1p88++yyOHDmCUaNGZb2UEddz586hbdu2GD58ONq3b6+tf/TRR7W/+/fvx+nTp1GoUCFNov7ee+91enhpaWkYOnQo2rVrh5gYS7aEIAiCIAghT6dOnbBw4UJtAjzcEWc1t+JKp1YBZzeZn69wDUISOuAtfwAKVspel6n+qhu9mnOaaRBTACZCd9qtRMUBjd8DeixWQjz2nISZHYBlD7hfuxnqGFsd6dfOpZM5VATe6p0a4LPbVG3qopuBS8dtn698K9B7HVC6m+f7Zo9Sa61tsCkD58RZ1dP8WbdrJHk/EKUmdxCnGnfrCn3lypXLmuwh27dnC2Rx8qdSpUrIly8fbr755qz1/P8LL7yAZ555BuPHO+l/bIFR3CZNmmDQoEFuv0YQBEEQhNAnQ+8BH0aIs+oK1mxao1jGetVdlggL04OpkhvKbVY01dOIbAEZAA0aNMhKWWQK4+7du1G/fn3HzqpOieZAz+VKNZgplFa2fQlMqgscnIqwh2nAjEJnkQEc/S9nziojeVZHyxPSLinRK602dZbt80xp7TAWaP2zqmnOCZywsDp0TH0+Mgch76ySBq/btqdi6ryLSR7jevL666/j0KFDWl3q999/n7X+ueeew5tvvqktt9xyi8vDefXVV7F48WJNGZCvEQRBEAQhb3E5DMt/xFl1xQmKwhhmKehwxTdR/2evyz1/mrevdJNzgZZQgGm8tZ8w1eOyrxNr56655hq0atVKc1hffPFF9/bHPpX1XwZ6rQRKtLB9/uI+YM5VwKJb3Y80hiKaYmzbnNWtchLB2lIlp6nAR+aqNGyKXqVfsn2eqeC91wPlBiDXVLvb9rgZXQ2Gmb+0FKV6bK03dxe262nzJ5A/wfY59lllcLl6dc0x3bhRtW/S/3KihyxYsEBL/f3999+1uvCff/7ZtJsRI0bgzz8t9xgHzJ07F3379tXqWqOiDGJegiAIgiDkCfLnD4G2mR4SkRGO8WJvsu41YN2r2Y/ZT7FnZg0ro4F0soz02QQUDQMJ6R0/AkvuUA5W381axJi1c7/88otWX3fdddehcePGnu83PQ3Y8gmw9kXblih6RK/ZF6GbSu2KDcOBNVRMNkRM+7ip7Du7B3B4Rvbjei8DDRz1ubVDynFg9VNK7ddRLWbTz4DySoXWa2z9Alj+oHldl5lA6a4IKKc3qDpdI0POAtFK0Mht2OJpbl/zOk5Y9d+p/W6efPJJrV6VdSVU1a5Zs6b2l2m/rFNt1KhRlljZvn37slKFCeXor1y5otWH81bNDIeTJ09qtbBMLS5TpgyWLl2qbcuoKp/r3bt3Ts+IIAiCIAghwKpVq7SsK13XgrYF7Qz2XmUWF22McEGm3z2uVzWkAO/+3fxcfLPwcFS3fwssvTc7+jS3n5YSWq5cFa2GLldE5gNqPw6U6w8suQs4akkJTTkKzB8ClO0PNP0YKFQZYd1vldFRqvAWsNR22oOOrdFZPbvZAwGlX4BVT9q2YNIdqxqPKMfXU0fNHareCWx8G7i436wMTMEpV2nk/kwBji2ds89ftg9Q9S5gx3dmIbF1rwOtfsC7776riSgx8slJHtai6oPIY489pvVI0zE6qnRSDxw4gDvuuCNrnfH/hHXjOsx4EARBEAQh/ClVqpSNTVCxoupUwjY2iYkOesaHIBJZdWXkjyoBXD6lHscUB7rOBoo3UjVpyx9STgAdOtL0E6Dmwwjpz8so8vrXbZ+jyimjnYkdgeKNVS1qrt8vHdjxPbDqKfutUtj+g4qyXFj/GA7wuhkZD6Sez17Htj8Vr/M8QsmU6p4uepee2Qwsuxc4Otf+85xgafFNdmq7r9j2jToOI52mAEkBVM7e+B6w+unsxwntge5u1hBbuXJepVafV4JKWTR6W/WczUFpwPr16/HQQw9h4sSJWq9VQRAEQRAEV3z88cdZHQXCAXFWnXFhHzBOqXqi3ECg9S9AdBHbbeYNAk6tBgYdNPdaDCVYf7vsPuU8WqGia8oR87qu/6r+qt6AEbel9wEHJ9p/nsqqTT8Cyg0KbCTOW8zpY+7Ny7pOOoyeppvyWhts+V50OIHClGNGNDPFfkxEFQYaDlOKvYx2+xoqF0+smSXYpRFP8a0lgftOl9xtjoZW+Z8WCc0xxxYohWtOwljr2NtYhNg8hH3UfvjhB1SurDIN2L6mRAlLr1dBEARBEPJkz9VRo0ZpYo4sCZo8eTK2bNmCGjU80OEIYiQN2Bmn16i/hasBbf/U6jdXr16tNd+lcuett96qjMcO44EVD4Wuo5p6EZh/nX1nse4LQMWhwNQmZjGexbcBvdfaOu85gbWSHcerfrUrHrZtoXJxLzDvatU+pemnQNHaCGmY/mp0Vo/8697rjC2F9JRpfnfWqPPhmcr5P5/dHsVE+atVFkBcWfgNimzVe0nVQeucXAYcnASUtdR7hoISsD2oAl77aTVBYGTvP0phO4dOOWtPeK/Rex2T8+fP46233srd8QqCIAiCEPJUqVJFi6YeP55tP//0009hYyeEuGytjzm9Vv2t86zmqE6bNk3rX8i0PF4E9erVUwZkXJJy6kIRiu7M6mLHUY1QQkcN3wSK1QEaWS74C3uAlY977zhoyFe6Aei3FajxkP20STphkxsAK5+0nzYcqv1W6TTxfLqCbZGsGNVs+f8FQ1XfVHuOKiPUHScA7Uf611HVqXwzUKiqeR1rVwOl8eZtZ5WwRVMRy2QKJ3msquEewPpWqvwaodBZampqjvcpCIIgCEJ4EBMTY+rTHm52gjirzjiVGVlNUuqaw4YN0wRNGGIfP3681r7lww8/VNsUa4iQ4/wuYEbbzPY8llpROjQ17s9eV/MRVa9qZMcPKjXVm7AuuNmnQK9Vtj0s9f6imz8AJtRUPW5DUcya10pMvHndAQcp0EaiCwH5LamfTKu9cg5Y86JKs7XnFEVQ1OopoO/GwEUx9bZPVDA2cmqVWTTKX6ReAJIPeN9ZZQS57Qjb9csfUT2bc8j//vc/02P2ZZ0yZUqO9ycIgiAIQvjwvzC2E8RZdZUGzNYtBcpkCZ5QrbNQoUJaSwl9nTqTISYRfXIVML0NcG6reX10MaDLDNVr0wgjna1+AqIKmdcvudO+wmxuKd4A6DpH9bEsYCcKmHIYWHQLMKOd+iyhBK+VzAmQLPaPz1kq8O7/AybUADYMyxb6MlKiJdBrBdD4XSAqCER6Kg21dQo3ve//4zhnJ/LMdH9vULy+bb/Wy8eBFY/keJfM4mjRooVND1ZBEARBEIR6YWwniLPqCNYCMk2QUalMLl++jMhIdcr0v1wXcjCddmZH5fBZa0e7zwcS29t/HdvINPnIvI77WGaIwHoTLTX4etXnlanYjMxZOb4QmNpU1Wj6wmn2FWzdY+Tov+6lNts4q7/bfo+EtcTNvwS6LwCKB1HUPzIKqPWEeR0jq3oWQ6BSgDkh4k3FaYqBWaFy+MGcz3Kyn5qRSZMmae1tBEEQBEEQbglTO0GcVUew/yVVPZkueOmktqpatWpaWJ054Pv27dPWVa/uhdRBf7Lrd2BObyD1nHl90XpAj0VAsbrOX1/1DiCpj3nd3r+B3X/BZzD9lTWzvdcDZa6ys0EGsP1rFWHc9pVSNg52yvQ0O99U7D003fXrXAlaMQJe/T6g33b1Nxgj/pVvAfInBDa6anVWi3hZMa9EU/vrqbjNe0oOGDBggOkxm4DPnz8/R/sSBEEQBCG8GBCmdoI4q67ElchR1XvxwQcf1FQ4hw4dittvv11bd//9Pooqepv0NGD1s8Cim21bmbA2tPs8FVl1J9rZ8jvbmktNxVc59T6DDkWnSUp9uVAV2+cvn1RRXoow7RsT3PWsdDoTO7mfCsxzu+JRYOcvjrcp0wu4aq2KqMZanMFgIqoAUMPQL5ZQCZptoEJZXMlIvANnlUJaa1/J0S7LlSunCbwZYe28IAiCIAhCuTC1E8RZdYQxLXHTO9qfO+64Az///LM2U1GsWDFMnToVbdq0QdDD9NL/BgAb1eewaWPSeRoQU8z9/bGGlw6RkUvHlDPsa+gsl+sH9NkANHgDyFfAdpuzm4B5g1VN7pG5CFrKWlKB2cbFGhVmf9LNnwATqgFbPuGsg+1+itYBOk0BOk9xHRkPFtjflfXgRuGsrZ+Gj7PKdG171ybZ8hFwcqVXZk3HjRuHjGCelBEEQRAEwW8MCEM7ISIj1D+Br2BNZ2ZEVaPDBKBcAJVUcyMkM7e/cuCssEUMa1Bzmir630Bg/zjzum7zgMR28Bts17LyCWDfSOcRR6YRF2+EoIJRtnGWGtRuc1Wkmz/LAxOAVU/aOlZWhpxTqdKhBqPgTNvWiSoMDNwHxBT17fvy3I6MB66czl7XYZxtHXFumdIYOLXa/nPFGwM9l6oaXg9gn+fGjRub1q1bt04TVhAEQRAEIW+zOgztBImsOjJmTxnSgMm2L4CpzYGdPwOn16nnrem0wcbhWcC0FraOakQU0Pwr1SImNzWNTT+zVZhddq+KBvqLghWA9v8AXWY6dkYPTVWOw4IbgfM7ETSwb2qxBuZ1dFBPrgBmd1PRcFeOKkk+iJCkFvv0RmQ/Zh31ju98/74X95odVeILEaoiSjHcLmzZo0XKPaNhw4aoUKGCzaypIAiCIAhCwzC0E8RZtcfF/bbG7NE5wMnlwOLbVU0ka+zsqdMGi7O95XPg357A5VPm59ink61pqt+b+/cpWB6o/7qtMNXmzN6z/qR0V9Wipc0f9utZyZ4/gIm1gOUPAclHEJSpwIw0Tm0GHJltf/sKQ4Doora9VkMRtoopb1HN3fyx7yc7rNFOtmuKM9/YvULhmubH1omdtS+rXsceEBERgf79+4ddPYogCIIgCLknIgztBHFW7WHtPRoZY+5hychkjQcQlNDQX3oPsOIhICPNVvG35zKglEXYJzfUfNg2orn+tcBEMKmEW+kGoM8moNkXQGwp220YDd/6OTChqnIW3GkX40usqaeOlGLjm6kU63Z/2zrjoeqsklpPmh8nH1Dq0r7E2peX1y9roX0dWbX2KE67qFKhPazEsA5CS5cu1VTKBUEQBEEQ+oeZnSDOqqM6TyNsYWOk4vVAXFkEHSnHVPqovVTKcgOAHgtVr1Rvwpq75t+Y0znp2OfACPca+WKAGver9i0UYWItpBU6hevfAMZXATZ/BKRd8v9xntnkumULFZpb/wb0XJJdC8z0YWvta6iS0BooaREp2/Seb6+d05bIqq9qmYtanNWUI0DVO21T1Jml4QEdO3ZEkSLmFkYTJkzI8WEKgiAIghA+dAwzO0GcVXuc32F+TKVSI7UeQ9BxYjkwrTlwbJ7tc3VfANqPBqLtOG3eoGQL20jzoWm+j5C5gqJD9V4E+u8Eaj6mIuRWLp0AVj6uerSyLYw/erSe3QosvAmYVNfxOWJroIZvAX23AJVvUlFjo9KskfMhHFkltZ+ybRt1eKb/0oApduQL7CkMs8cs1bSNrHjEo7ZPMTExuOqqq8KqHkUQBEEQBO8QE2Z2gjir7kRWrcqy8eYeRkFRnzqjrW2Eja0z2v4FNHzT7Oz4ggZv2jHCHwUuW2p/A0FsSaDph0C/bUCV2+yfC4ruLL4NmFgT2P6tbyKtTI1mzfOk2sDu/+OX52DDCKDncqDus0BUnO3TVmc1lNOASdl+yrFjen3hGirNedMHvnkv1nBbfye+iqyyRtVaC3vxANDsc9u2T6ssDruHKT5z585FaqofJloEQRAEQQh6+oeRnSDOqj3OO3FW2QIlWLh8BlhwnapPTb9smz7afR5Q8Tr/HAvbjTS19MlMOQyseQFBA5WDW/0EXLVWpUU7cihZ86unBzuqIfUEOkdL7gIm1FRq0ta0chsy7EfIdQqFmbNKRWpOqlx9FOi3Bei/A2j1A3DxoG/7J2vvHeNctTe3WPd9djNQfjBQbqB5/c4fgeNL3N5tt27dTI8vXLiANWssn00QBEEQhDxJtzCyE8RZtRepdBRZrXhD8PTqZCojVWP3/mP7HGsAKaQU39S/x1T+aiCpt626rQdGuF8oVhfoMBbovgBIaO+4HQzTg9kHdf2wnEWIqSq99D5gQnVgx/e26eS66A7TtBmxN3LAiXJbgbK2tZCh3i6Z2QoxxXH27FnthqrVhMcl+T4FuGhdVePsL2f13Bb1l9FVay0104FdTmQoEhMTUb26Oc14wYIFuTtWQRAEQRDCgsQwshPEWbWSfAhIS7Y9U0xRbGBp0xII6JRs+waY1sp+BLj2k0C3OUCB0v4/NiqqUoWX6cdZZABL7w7OnrQJbYBuc4GOE5Xarj0uHQfWvgiMqwisfh5IOepeTerSe4HxVYHtX9v/7PnigNpPA/13qTTtCtfY1vym2rkOSWyC+TFVn6+cQShz6tQpDBgwAEWLFkWxYsVw55134vJlH7SwYX9TI76efCpS0zaySuiMs57ayIklmenh7tG2bduwGIQEQRAEQfA+bcPEThBn1d0U4Gp3qb6QgeTKOWDhjcCye4F0S01lTHGgw3ig8XuB7f/KFNX6r9oK5mz5BEEJHeyyfYCeS4HO04HEjva3Y4ubjW+pSOvyR1TU1MqxBcB/g1Qv1+3f2KZmk3yxQK3HlehT43dUPS1J6mNWVE49DxycbP9Y8me+xqoEHcIMGzZM6wP2yy+/4NVXX8UPP/yAn376yQ/iSr52Vq1pwFuyo+A1HwEKWtS5Vz8DXDnv1q7btctUhzYMQhmhHmEXBEEQBMErtAsTO0GcVSvnLErAhJHCei8hoJxep9J+9/xp+1yJFsBVq4By/RAUUC25WH3zurWvBHeLFTqtZbqrqHT3+UAZs4paFoy6b/1U1bSyDpXOx77RwPQ2wIx2wP6x9oWTWBtZ42HlpDb5AChg6QHLSHhiB/O6PX84Fu4xRa8zI8AhzNixY1GyZEncfPPNeOCBB7LWaXjrxkrRrDMb/aMErFO4quUYkrO/q3z5gcbv2mZ2bBieoxnTAwcOYO/evbk7XkEQBEEQwoK2YWIniLNqxZ6wTc1HbZVu/QUN9R0/ANNaAOe22j+2bvNse28GEkZ2td6rBtIuqpq8UCChLdB5MtBrJVD+GnPEU4epvaxDZRR13tXA8UWOz0X1+5VoULNPnF9HlYaaHx+Y5LhW1hpdpaJsCHPw4EEt/TciIkJLBdbXadiLUOcEOqrWuuFiDeBTCiTZXj8X95nrvK1105s/UEJfLqhZsyZKlChhWjd//vzcHa8gCIIgCGFBzTCxE8RZtWJNvYzMD9R5GgEh5Tgw/xpgyZ1AWor5ueiiqndq0498KxCTUxJaA9XuMa/bPw448i9ChvjGQPt/gD4bgMq3AhH53H9tdBHVP5SR1OZfKHVmV9AxNqZwM9V73xj72+ZPCKvIakJCAs6fV+mvFy9ezFqXJSDlixRgtsihirUv4fdpnaAwOquM6Df50Pw8nfOVT7rcNR37Nm3ahEU9iiAIgiAI3iUiTOwEcVaNHJhoaxgnXQXEFAvAsUwCJtdTKaZWqPJ7FaN+gxDUsM2PNQJIhd30NIQURWsDdZ8HKlznnsMaEw/Ufka9xh0nVSd/vG36saNUYJvIamg7q127dsXhw4exdOlSrXaVdOnSRT15cqV32tj4u15VJ668+fEFg7NKSjQDKt9iXrd/DHB4Vo7qUQRBEARBEMLFThBnVYf9NJepWjkTlW/z7zdCcRX2+Zzb135EqcaDquUKo0LBDkWfrArKdBh2/YqQgCnYmmjSQJXuS8eRyruuuHwSWPsCMKasal1zeoP772lNBT4yW9UxhnkaMEWVateujZYtW2Lo0KHazfWhhx5ST+76WfUhzS2nLc5qsQA5q8bIqk7DYbZ1yCseBdJTPapHWbduHc6cCW1laEEQBEEQvEPbMLATxFnVWfcqcHGva4EUX3JsITClEbD9W9vn8pcA2o8Cmn2mhFlChap3AUXrmNeted5txdOATVzs+BGY3ipTNGmcfdEkUqiq6pVqD9bpsnUNI+SzugL7xrqOKpftpwSUdNh3c88I1+1rQjyyWqFCBaxfvx7Lli3D2rVr8d9//6Fw4cIqurh/PLD9u9xF5HkerZFVpnkHi7PKCDxbGRk5s16pSjuhadOmiInJLgOgyt/ixYtzd7yCIAiCIIQFTcPAThBnldCI3fyR/TPkD2GltMuqh+fM9sB5O2rESb2B3uuB8oMRckRGAY0/MK9LOQxssqigBhPHl6jr4cRSx3WIrGHtvRbovx0YfARo8a2tArI1QrpvJJBsp+WNkag4oJwlvXv3H64jq6xvDnEiIyPRrFkz1K9fHxHI7CfMVkD8PyeS2Hs2p5zZpNoPBSINuKAbziqp81SmIJOBtS8Bl0443HVsbKx2zowwlVoQBEEQBCE2DOwEcVYZrWHarb30TrYbYf2hLzm9HpjeUvXwZPTHCCNsLb4BOk5UrU1ClaReQJme5nWb3ret3QsgFPfZsWMHUlNTgdJdgB4LgSK17YgmPQ303wW0/jnbOaWDyT68V60Bus5RCq/W2taaDwNtftdUm8+dO4edO3ciLS3NvVTgk8uAs9vCOg3YlggVlU49l73KRZTRKcfm20Y7Pakn9nVkVf+9N3zLvO7yKWDj205336RJE9PjTZs25ew4BUEQBEEIO5qEuJ0gzioNYEcRtNjSSq3TF9Ax3fSh6p1qTU8kJdso56fa3b47Bn/C6GpEpLnfJNOBA4UWaVOpyB999BHKlCmDatWqoWrVqvj333+B6MLZPTDpbFCxdeA+oPE7QFxZ+/vk91SqI9B+pHJo6zyn0re5NBimbfL666+jVKlS2vtQUnzJkiXqted3Zys+l+5m64xa++uGmRqw3XNpVZM+OBG46CIy7QjWHhtJMAsO+NdZPeA4pbnyTUC8eQYUWz93+rlZ6xvKg5AgCIIgCL6jdojbCXnbWaXC6JrnHD/vqxRgCu6wFnLVE6o9iTXFtOFwoNt//q2X9TXF6gJV7zav2/07cNyPqQh0Bnf9DsxoD2wYBkQXwtatW/Hkk09qarQsOmcu/1133aUirGX7Ap2mqPYztR5TkVVPUj8bDQcG7leR8ehCWLFiBV555RUMHjwYq1evxtmzZ3HPPfdo76lF+cbXBJbdryYvyl9r3p8m7pQRtmrADiPM1vpd9hzOCcetzqpZcMCvzip7vTpqx8MJHWsrG1636yxCZU4GoS1btiA93ZKlIQiCIAhCnqR2iNsJedtZXfmobR2bL51VGp1rXgKmNgaOL7J9vmhdoOdSoO5zQKQHPT1DhQav2Tp8qx43O2G+4MxmYMXjSp130c0qJTRT9GnatGnaD/baa69FvXr10L17dy0dmE5sVgoz625zSr5YoGQr7b9TpkzR/t5www1o2LAhOnTogDVr1uDQoUPqPQokANu+Aqa1AA5Z+v2e3QKcWuVYYOnKGVX7HE7wWqloSYne8b1LhVwbqKZ8fmfgIquxpYCIKPdSgUlie9Vz1wjVkM9mXpMuBqHk5GTs2bMn58crCIIgCELYUDvE7YS866yyj+nef8zrClc3P7aKneSGI3OAyQ2ADW8C6VcsT0YAtZ4Aei33n+hLIIhNBOq+YJueSeEhb8NJiJ2/ADM7A5NqA1s+Ui1ldPInan/Y25MUKaKc6KJFi5rWexN9n/p76O+Z9V48PzoXdtvuYOevjiOr5LJjIZ6QpbolFZjpsAeV05/jFGA6wUXrwW9w4smaOu7MWSVMN2fNvA5r6te+bHdTppUXK1YspFN8BEEQBEHwDaVC3E7Im87qlXPAcktPVdYVxlX0fmT10klg8R3ArM7AOYtIDilUDeg6G2jyvorChTsUGipY2bxu1dPZ9Zq5gfvYNwaYNwQYlQgsvg04Osf+tplps/wBE4oeEabmGtd7k8TERNN76H/19UhxIZK09VNg6f3AiWVAdHHb58MxFTi+KVDcLAzgsdCSVVypZGv/Zy5YxZySXUyGsI9yzUfN6/aOAE4aouuZREREoE6dOiE7CAmCIAiC4DsiQtxOyJvO6vKHgAuW8Hfj920jU7lxVpnauvtPFdVjCp8VpgXWfV61PynVCXkGOuSMGhlhFHHLpznbH4Vq2IuTEwKjSwPzBqtIrbUW2EipLkCpztp/mfbLH/Ho0aOxa9cuzJo1CxUrVkSNGjXgbXr2VIrII0eOxLZt2zBv3jzUrVsXSUlJ6nopdzVQsJKTPWQA2zPThKc2AvLFmZ925eyGS3T14GTggp2eyO5GVkv6sV5VJ6aErcqvK3h/sAppORAls6b4bNy40fNjFARBEAQhLKkdwnZC3nNW6UDu+sW8LrGj6pvJ2jYjsTl0VqnsOqcPsHAokHLU9vkSLYFeK4CGw4CoAshzsB7PKnCz/k3758oedOwYXVzxGDCuPDC7m5oQYN2mI5g2W/tJoO9WoOssoGTLrB/vm2++iYkTJ6JKlSpISUnBN998g+joaHibli1b4rnnnsPvv/+uOcNs0vz1119r/UU19dt6zwL9dwBd/1XXo9UZNXJmI5B20bzOEwculKh4AxBVyLCCE0G/u/daKj4ba31Joh/rVXXyW1pgGVPSHRFTVNV5Gzk0FTj6X9gp/QmCIAiC4Dtqh7CdEJGhSZHmEc7vAqY0MosqsX7tqtVAXAVgRIy512mvlUB8Y/f3z1pURghZW2Z1JAgNbvZRrH5feAooeQKdTUYIjVS7F2jxlePXUGSIkw1UxrWXUm0vep10FVDpRqDcQCBffoebnjp1CgcOHED16tWRP7/j7bzBiRMnNFEltq5x6hQzXX3x/9yv6WVv1zK9VJ/XcgNsHaRQZsndwI7vsh9TIKv3etdtnQ7PBmZ3NZ+jIWfMKsP+YOUTwGaDym/lW4DWlkkze1A0a2INcyYI21p1n2/67JMnT0afPn2yHrM25eTJk1rWgCAIgiAIeZvJIWwn5J3IKh3JBUNt1X+bfw0UqgxcOmZ2VD1JA6a/v38CMKkesOpJ+45q2f5An41AzQfFUSUlmgOVbjKfox3fKofU2pNS70c7sRaw/jXXjmpiB/W9Dj4MdBwPVLzOqaNKihcvrqkB+9pRJSVKlNDey2X0lr1em36iHCx3oAjPwUnAkv8Bo0sBs3sA2791P2IdzHDCwRpZPr3O83pV1r/621ElMfG2tezukC/GVpTs+EL1PTuZMT19+jSOHHHQHkcQBEEQhDxF7RC2E/KOs7ruNeDEYvM6plpWukH9314KaYwdERsrp9YCs7sD//UHztlpLUGHt/0ooMNY1XtTyIb9ZPMZ0qA5WcB+kuxDu+EtYFprYGx51Y/25ArnZ44qyo3eBQbsBbrNVXWOFM0KdeKSgLL9zOsKVlHXLpw4sezleXgGsPQeYEwZYGYnYMvnqrdwKMJ2LlaRIkbYPa1X9Wd/VadpwB4oN1e5zbaWmbWrhsk11lkXKFAgZFN8BEEQBEHwHRVD2E7IG84q28ZsGG6rwtvss+zHly3OamR+59G45CMqNZE9U4/Msr8N0337bALKD3adrpgXofNe8xFbB2RyPWWMa5MLGc4VU+u+CPTZAFy1CqjzVHhOCFSzCAxd2AlUvxco19+919OpOToXWPEQMLYsML2tilZbRcaCmYhIVbtqhCnh1mwIq/iWtZ9xoJzVmBzUrOpERgP1XjSvY1R5z4jsTSIjUa1aNdMmodRDTRAEQRAE3xEZwnZC+Durl04AC28yOz00/tr+qdIsdVLP2oqbOGqPsuFtYEJ1VUNnz1hmu43uC4DmXzreT17n8mnlbJy1E412BnuR1ngI6LEI6LcdaPiGql8MZ8r0sI2ssX2L8frVtuulalU50eIMppEyWj2uEjC1ObDxHZVWG+zl65WGmh9f3AscW+h4+zPrgFTVkijwkdUSOUsDNta4cnLGyPo3TPefcuXMkef9+/d7fpyCIAiCIIQl5ULUTohCOEPje8mdQPIB8/oGw4ASzczrrLWsUUVs97X3H2D1M6rViiNHigJKTNtjJEgwc36nqu09MF4pmjJV1R2iCqvoNJ0Vtp2JDO/L1gZeS9XuAtYYahcZVWMtrhHWXnOChMJMbO+ybxRwYJL9Gmqdk8vVsvpZIK48UKanWkp3A2LMDaQDTrGGQJHawFlD2sru/3Os7nvUUq9KZ88bvZO9FVnlPcXdjAtOsDGLgPXIOjwP/I4rDNEeli9fPiQHIUEQBEEQfE/5ELUTwtvqZ/Rp/1jzutLdgdpP2G5rdVapEqxzfCmw8jEVkXJkSNZ8VKXqGV+X12Ea5sllwP7xykE9s8GzfqxVblfCVOxDy8d5mSr/A9a+ku3gpyUDFw8DVe8ASramR5stxMSIKx1ZLqkXgUPTgL0jgQMTbCONRi7uA3Z8rxbuiy2WdOc1vlnghcHo2HHCYu1L2ev2/q1EqChEZOW4tV41AC1rHDmrFMPid+HJ/aLyzcCGYcD5HeboKtWfIyJDdsZUEARBEATfUy5E7YTwdVbpYK54xLbXJttF2It6WmtWaURe2AeseU5FbxyR1Bdo8iFQpLqXDjyEYUoiHdIj/wJHZgNH5gJXTudsX0y3rnonEN/E20cZmhQorVJ8GUkjCe2BNr+oaL4zouKA8oPUknZJiS5xH/vHAZdPOX4dnSlOznBZ94pytjjRozuvFH4KBKxbNTqrjFDyM5XNlmPXYNTS2o80UCnAxF4bIaYCe+KsMqOg3kvA4tvMtav8LssPCtlBSBAEQRAE31MuRO2EoHZW09PTkZKSoi38v14gHBsbqy38v12SDwPzBgPpl83rW/3sOA3QGllNPghMrKkiWPYoUgto8hGQ1At5FjoEbCOjOaZ0UP9VLYDchbWVTOulUBDbzcxoZ3ag1r2qWs8I2UJLdDQ56UJ16fzx2LZtG37//Xft93HTTTdpvVsdQsGwsn3VwlZO/L70VGFrqrwVOoV7R6iFFKuf7bjScXbRGshrFK6qIr4nlmSv2/2HrbN6Zr36DRtJ6ICAwVR2Rqs5CWASWbLUIrvTwofRVWP7pvWva32EK1WqhAEDBmjXQHx8vNYiidL0VP+LiYkJiV5qguA3O0EQBCGPUSlE7YSIjIzgUlVJS0vTTtypU6e0wccZHIjYH5ONbfPly0xRTLsMzO5q21+x5mNA0w8d72zVU8Cm910fYHRRoP5rQI37VfpvXoMKsod153S2ayfHSv4E5VgwvZeRuuhC2c9RsdlYl0l6LlU9WQUVuaawF9Oj672IlStXonXr1tpMGQ0yqrrNmzcPLVu29Oxs8RbAiDjThbkwIpl+yf3Xs/0QJxuYZsulRAsV0fUVWz41Z03kiwOuPmrun8rfMn/TOnEVgAG7A6vKPSoBuHQ8+3GXmUDprp7vZ9dvwKJbtP9eiq2Gk5VfwZnYpkhNMzjCFjgAFSpUSBuc+DdYByRB8IudIAiCkEe4dOkSTp48iTNnziA1NTUk7YSgcVY5I3r06FGcOHECnh4STyhnBxITExG54kFg21fmDUp1BjpPdyzMw/f7txdweLqTN8mn0lIbvAHEJiDPkHzIkNb7rxJJ8hSK4jB6SgeVUTFHtY8UBhpfWSk465S5Cug8OefHH25QuZdOfnwTXH/99RgxYgR2796tzYglJSVh4MCBGDNmTO7eg3WubHWjO69nN3v2+ogolb6tOa9tgZJtgQKl4DXYNmpsklmJu80f2T2TCXsfH56Z/bja3UCLbxBQxlZUCsY6HSfaRoTdIT0Vl2YPwKHEh3E+sqzHL4+Ojkbp0qVRtKgolQuhhdfsBIm2CoKQB5zUQ4cO4fz58yFvJwSFs3rhwgUtb/rKlSu52k90VCTK73wAcafnmCMqvZbbdzD50Sk6w3TTU6sc77jCtcpJLVIDYQ1rGk+tAU4szVyWAOc8bC2jn3NGjDhJwCXOnCPvlI3vKsVlI90XAgkUERKQclQ5g/njUadOHezduzfrRsToQcmSJbXUYK9H03XHlQ6gNWXeHdjXmKq9dFzpxBapmbso5+ye5skl1o53mqD+n3oBGBlvLgNoP0opSgeSCTXNv6d2I4EKV3u0C96uaagfOXLEY2PdSpEiRbQJjqiooK4GEQTv2gnR0ZoiZlycD7M/BEEQAkRGGNoJAXdWGZo+eNBSW5ZLkk58j/gDVAiNVf1OrSI9/MgHJykn9eQKxzti38qGw8JT5IdRKda9ZTmmS4FTq23rfN0htrSqPaVjWroLULByzh0ROhrjKptrXxlJ7OIk6p3XSE0GogpozZ0ZZTh7VjmPdFRpgNGB9RmsdT2+JNt5ZdsbYw9jT/qO6o4ro6/sTexJ3evOX8xCQ3TgBx0CYksCByYDc/uYsyKuPhH4nseTGyhBJJ02/2fbO9ZFVGnfvn04d86JorOHcABiDQtTJQUhWPGJnZCUpKW7CYIghAvpYWonRIXbAEQOlrhTU0mNT6xodjQ1J3VKppO6zPlO2Iqm6UcIGyg6ZYyYnlgGXLEoILsLlWG1qGmmg0qxKW/ltrPusM6zwCpDeyGqvR6dByS29857hDwq/ZXO6o4dO7S6LUYL+LdBgwa+fWvWaTNCyqXhG0DKcZUifmyBqhM/vdqcnusIpnqznREXbb/5gWINgOKNshc+NtY0G6G68dJ7smtr2dJn30ig+r3KiTZSslXgHVX9M1oVrz0YgFiTzOiSN2H9yq5du1ClShXkz+8nkSxBCAY7IXOf4rAKghAOpIexnRAwZ5Wpi74YgHQOFuyP6JIVUVh3UmnA0kk1qog6o3hDhCT8rKwzpWAOU5t1B5U9NHOjZJrYUUVN6ZzSibDX/sdb0OHY9B6Qcjh73dqXgW7/+u49QwkKCgF44IEHMG3aNE0FmDNfvFHdf//9/j0WRjIrXqsWve6YvzHdeT2+GEh1o16CTicnkEyTSBFA4epmB5YLI/ls+VK2n3JQddhiSnNWp9pmSAQD1l7BHohYse7E2wOQUayGA1H16tVFgEYIKnxuJxw8qE30FS6sWQqCIAghy6EwthMC4qzyQ/ujt8+BAwdQvcgB5Fv3InBiseMNmbbKlhJG8ROmFQa7U5pyRDmlxuX0hpz3NtVhPSGFkKjqyqV4Y8fiVL6ASrJ1nzMrvh6dowSe6CzndRjFzkhHv379MHLkSHz//feaIuZff/2Fa665JrDHFl0YKN1NLSQ9FTi9VjmuugNrbSnjELZG2qqWvX9nr2Zv2WKNspz2LLj/48ts66zZXicYsImsuuesMp2HUXNfwpnTw4cPo2xZzwWbBCHk7QSZqBEEIYQ5F+Z2QkBqVjk4+Pqk6hS/vAZlN99k/0lGaOq9pFR+pzZRzp4jddFAi+rojqjRMdX6NOYSnoOSBsc0vhkQUwwBhymS46uZW+OwPUq3uYE8quDhynkVqfPnJII34O2Ggk1G51X73XnpNlSwCnBhpzllffBRxwrU/mROH+CgQdm64VtA3WddGuwUzHImN+9NWJdCyXpBCDR+tROKF5eJGkEQQpK0PGAn+N3SpZKfvwYgciqmIRKjSyP6iiGltEBZVRdZ9Q5NqEaDkVWdyBgVIfInVFg9vxu4sEv9ZXRId0qNvRlzQ1Qh5YzqjimdVJ6LIOqllAUdsXovAMsMaa3s/3l8KVCyRSCPLDhgLefKZ4EiVYCSbdQ6pt9Sudrf164n8ForVEktlTMnkS6fUkJnFPjSl7Ob3Kt9tWJ0VLV9nwTGllPpxFyo6K3/nwrF+u/fHxQoo1KbdcfcjTRg9pL01wBEqB4ozqoQaPxuJ5w6pbW0YUqwIAhCKHE6D9gJfo+s8kMeO2ZQevUDCSlzUWrrg6qlCtNLq9xuqzw6oYaK5jV4HahwnfeNWNbyXdhtdkgvGBYa7N6EKZJF65idUwohBUOEyV2YJsm+q6zB1aEz1m5EII8qeKAzt28MsPbF7F6oDd8G6lpa/4Sq4vGZ9WYH9vQapRbtTdhWSXNeDU5swQpqEoeKxd6uzb54ENj6ObD5A6DW40CjtxxuylszZ0svX86BQncuoHCXqAMLgSQgdkJCAkqV8mI/aEEQBB+TkUfsBL86q3yrzZs3ayFre7DubsiQIVrd3a233pq1/pFHHtFOyjvvvJO1buHChbjnnns0cZlnnnFunOeLzECt6CWIqHILkC/G/kYzOqhejJn9WNlMNyYmRmsk7uJDAanngJRjKl330lHgwr5MJ9TglHojZdce+QoARWoDResCxeqqv1wKVvStCJK/2PA2sOa57Mf8TP22A4UqI6/C3xFvTFnXJ1OCZ3YETq0ECpQDBuxUqr1h2W5ph1IcpvN6chVwaoX63fkCnsMCSZlLWfU3zvKX6x0pFhvgPY8CWFmRm4NTgTUvA21/UzXidqBQAgUNHOHO/XLnzp145ZVXtPsuDfEnnngCnTs7r/umOirbeghCIAiYnZAvH2rVquV6zBcEQQgSLuQRO8GvacA0sB0NQIQnbtiwYbjrrrvQvn17TSZ5/PjxWL9+PUaPHp213cWLF/HWW2+hUaNGbr1vWnoELle4GfkdOaqEacGxCVixYgXuu+8+LFu2DBUrVsR7772nfdG4fBpYPxy4dEQZx5pjmumgeqDqmau0WEZGdWdUX+i0hYNT6ojq9wAb3syOqNFh2fwR0OxT5EVmzpyJhx9+GJs2bULt2rXx6aefolu3bkDzz4HpbYDk/cDekcFTb+1NeJ0XYSpvdaDCkOz101q5r/LtaU9Z1tdycaWWbXRe45KAYg2174CpOU8//TS+/vpr7f533XXXaf8vnNQL2DsCmFQPqPkwUO9lm/Y6rlT9XN0vmUr54IMPonfv3poI1+LFi/HUU09polwVKlRwuF9fqQkKQlDbCWlp2ntLCydBEEKFC3nETvCrl5OcnOxyG/aJvOGGG/Diiy9qAgtvv/02Xn31VRQtmm3IffbZZ9qJdXYibd778Apgy+fAhuHA6mdVLeTCm4C5/YH/BgNle2uD1c0336w11J06dSrKly+PW265RVO/0kSHzm0Gdv2qWmMwisV2MF51VCOUsZvQFqh0I9DgTaD9GKDvVmDIeeCqVUCb31Uqc7n+QOGq4e2okpjiSgDLyI4fgEs+ilQHMbw5DB06VPv/jBkztL833nijZpShZGul2kw2va8i/nmF8oPtr2eabe/16jfU6F2g6l1AYiflVHoTZlYwDZv9Znf/Bmx8J+u+8Ntvv+Gjjz7SZjF53/rjjz+0e5oGr2v2h938ITChOrD9OyA9zWv3S068sZaFkSUa4B07dkSzZs0wYcIEp/tkVgmjwIIQCAJqJ7jx3oIgCMFCch6xE/zq6TAc7Q7sH8kvgCe3R48e2myAztq1azXP/8477/TsvY9vAFY8BKx5QRmT275SfRkPTMjqA7lx40YtYtW3b1/07NkTt912m3bMEydOVDthf9HcQkOZgjgVhwJ1nwdafAt0ng702wZclwwM2g90n6+cUgoMlR+oIkmhVGvqbWo+CkQYPn/aRWD718hr/Pfff1odF6NzjKZee+21OHr0KObNm2e+PjmRwjY/eYWy/e2vT+qjUuP5G6rzFNDyW9Wrd9AB4FpO/qwG2v0DNByu6tg5SUR1bE0EKZcwsgrgn3/+0f5ypvLee+9FiRIl8Pfff9veT5ilsfRuYGpj4PBMjwxnR/fLrVu3anUlRtEYpjlyvSs4EAlCIAioneDmewuCIAQDyXnETvBrGrCz1B4jPGkNGzbEqFGjMGDAgKz1DFdzNuCFF17wWLUvLbKQC5VO1SBcz8U2/uVMhNouyXX9KHtAxpZR6bkFM1VPC+pLBZXOK3gGzyHTPvf8lb1uy6dArSdshbLCGP36pMPj8vpkdLV0F+QJWPNJJzPlsLlPMp1PR0QVBIo3VIsV9oblviiGxNZJ7At7MfOv8fGVM27fU9gag7Vw/M6yekdStZkK3ZmTZRqn1wGzuwPlr0Z6/Gu5ul8y4l64sFkZmo/dSd9x914tCGFlJ8h1LwhCCJHuZnQz1O2EoGzSuGTJEkyfPl0rCB4+fLiWOscT/eOPP6J+/fpaiNpj2I7GEZlKvLrxr6VVGnKydedAS9FlaiEd0vwJmX/pnGb+nwaw4BtqP2l2VlOOALt/V+2H8gj69alflzbXp1HE69AU4PR6oFg9hD0URKHTZ1XDzulEBnvXUiWYizNYR605tFan9kBWGrD+nXFGMy4uTvvOSpYsqV6fdtlW3Ti2FFD9fqDaPcjYeTxX90u+3/nz520ahxcs6Po+FYD224IQeDtBEAQhhMhwc6wOdTvBr2nA7qjs0Zh7+eWXtbS5559/XlvHol/CtB6ebIavubCulGl2DGu7fG9GMRI7AGX7qXrQ6vcBdZ4BGg5T7VCosVSnjmb4z507V0sHopgN6dChg9pJ+QFAkw/U66r+DyjbV/X8ZBRVHFXfEt8UKGVRJ9v0Qc56cYYoLVu21BSAZ8+erQmB8C8ft2iR2XeWvXmNsBYyL6A5jXst6866FkbKLfzNM0W/VEeg0lA1odL0I6Dd30qN23DvYI3xhg0btEhr1v3k3LbsnqusN271MzBgD1D/ZaBAKURGRubqflmjRg1s375dizTpbNmyBdWrV3e5X3feWxDCzk4QJWBBEEKIyDxiJ/g1suqOyt67776LqlWrYtCgQdrjN998UxM96tKlCz744ANTLyEq9bIx7UMPPeT6vUs1BerMdbzByZUoGN9Eew8WGnNWgeH1Rx99VCtOFoKAWk+aazHPbgIOTgHK9kFegDLhb7zxhnazKVCggGZYUe2yTJkyyjE7ttD8AkaeKdJFddpwhtdAup0eY/snADUfRCChsBKV9wYOHKh9XxR7ee21zPTe3X8AFa8Hajyo6tgthjLvl3qWR07ul02bNtUEFL777jutdo9GPFXOXbXw0N9bEAJBQO0Eue4FQQgh8ucRO8Gv0+c0sJ1BoRhGM1lvolOzZk3cfvvtWv0J86hLly6dtVCSmSHsrLQ6Z++d4UI9dt2rmhIn+xBRDXjSpElao10qeQpBAtt9FK1jXrfpPeQl2AZl9+7d2vXJv5wp06DCNaN0kfnNrVe2foawZ98o++spnhZgWKu6fPlyrd/jrFmztBlMDho4v0tFhNv+qWpr7UR0cnu/1BVRFy1ahDZt2mj91KgC6EodNSoqSlsEIRAEtZ0gCIIQRBTII3ZCRIYfk44ZqaTirv/JQJ11zRBZvIFKAa54XZYAShajywAlmgFNP1VpvUJwsuMnYMn/zOt6LgVKNEeeJPmQclTZUokCX5VuAnZ8l/18dDFg4F4l5hOOpKUAoxLMIkU6kdHA1ceB6CIIKg5NA5beAxRtAFS/GyhYObOUIM60GeXks8SY/EiRIkU8avchCHnGThAEQfAnu/9U9lsetxP8On3O/GaGm8+ccaKi6QOKpm1HZMZl4ORytax6AijVRQ1I5QYBMUWVSu+BiSqlMKEd0OQjID6zb6UQPLA2kErAZboBhaoqcSyme+ZFZ/X0RtXqRE+BZc9dCoAZndUrp1Vf2lqPIiw5NN2+o6pHlukYUkk6GNj6uVrOblGPY0oAc/tlP0+RtriKqt61YAUULlAZERGd/S52VKxYMb++nyCEjJ0gCILgT47NB7Z9ibxuJ/g914vqmP4ehOL3WlJFKcrDXoZcIu4ECtcEUjNzvjPSgKNzgfPbxVkNRqjw2mu5bd/Z1GQgynk6RNhB9V9jrSZ70RatpfqOHhhvFlqioFg4tvnZO9L8mJFkOug6nMgIFmf1yNxsR5UYeweTlKNqOblMe5iv/quILxmPEydO+O0QmdZjlbEXhDxhJxz4xLGdEHlvpjjjUCCpd3jeSwVBCL7MOQYhjORRO8Hvko+sHWENib+IjQbiUjY53oDO6dmNwKWj5vWX/TtQCu6TERGpKTa/8sor+Pnnn1VT5LzmqGqk2/85U5XWyMV9KroabrD1i9EpJ6W7mh8fmhw8itHWNjWZg41d+B3Wezmr9Y2/oBq6KKIKgSbo7AS2oto3Epg3GBidCCy4Edg7yvY3LQiCkBuSDwNbvwBmdgTGlFXZWI7IQ3aC351VfsCyZcv67f3KVqiKiKuPAZVu8eyFy+4H/hsE7Potqw+rEBywR1SnTp00ldX77rsPbdu2zZvN3K1OmD4DxzT2hPbm5zYMU/Wd4cSRWcAVy6RSrcfMjy+dUP1mA0XyEWDrl8DMTqr3rTswCt7oXU10iWp7iYmJ8Ad8L3dEaAQhLO2EgQeATlOByrfY9m02cuUssOcPYP41wKiSYicIguA9O2FMErD8QeDof9mt7eyRx+yEyECpV/njxCamr0OBjBNAZBTQ+iegzFXuvzjjCrB/LLDoFmBUIvBvL2D7t+qiEgIGJbqpVNa8eXOsXLkSr7/+OlatWoVx48blvW+FWQFG9LRSzng1eN38XPJBdf2GswpwiVZKWbdgJfP6I7P9eli4sE8NPLO6AGM58DygSgvcocptQLPPTerACQkJfpGIL1++vERVhaDBb3ZCYqJS1KSdkNQTaP0LMPgI0PYvlfob4aRaihOAYicIguA1O8GN2tMqec9OCFjnd55Y9j7zFYXS9iBh/S3A9NbAmY0q6tTmNyCunOc7y0jNVvAcUwaY0QHY/LHqbSn4lZ07d+L8+fOoX7++9oPhX7JmzZq89004iqySUp2AUp3Nz294K7s2O9RJT1VGopEKV6u/FEXxp7PK7+HEcmDtK8CUxsC4CmrgYU9gZynIbDNE8RYKJRD+v8X3NjUqWn/WyNXI58O7NaNY/ky7FISgsBMKFdLewwYqblINuON4YPBhoPnXttkqVsROEATB23ZCVGH37YQKFZAvn0ULI0zshIA109NP7N69ezXnw5sUwhFU2Hg1IpAKXNwPzGgHdBgPJLYD2vwBzOqUizq2DODYPLWsfAyIbwqUvxooPxgoUtOrn0OwRatPZVF55g9S7/OU1RT50kkgv3/z94PHWbXcpOq/DhwxGFgph4FtXwG1n0DIwxlIpvga4e9Qd1Z3/mjels4tIyfegoJeTEPePx44OFEJIXgKFcdr3KcGL06otfrZVjiMHJmL/EtvQOW4+thV7WekZXh3MEpKStL6wQpCsOFTO6FQIW3fLqME+UsA1e9Ry8WDwIFxwL7RmUamo/ITsRMEIc+TUzuBZQgUyqx4LVCmp+pW4spOyEzRrVy5Mnbt2uX10rhA2wlRgZaor1ixIg4fPuw1JasS8UVReuX1iMi4lL2SNaf/dleOavlBQP3XgLUvAc2+AE6tVoatw0EnwnlY/uQKtax5HihaByg3WL1H8camEL3gHfhDJAcPHtT+HjhwQPtbtWpVtcGJJUCSB+neYZUGbAm9cXKmdA/g8PTsdRvfAardA0T7LloREBXg4k2y+yNbI8qsMTu1KvftjSh8wPZWFHWiQmiamjhxSVRBNfCwBiVZXa9ZRjCp8QAQU9y+M31hLzB/iPZdx15Yjaqb+mFf7T+RnJH7Nhqc8OFMKfulCUKw4hM7oUQJlC5d2vN0trgkVSvGhZNlvB+wHIEttCjC5AixEwQhb5BbO6FCpoNqFQ2t4cROMMDIJ+3hffv2ZQV3wsFOiMjwd3MeBzAyxpN75cqVHL0+OiIF5QudRlzFbmoQmdMXOLHY1ping1r1LmDNc0Cjd5RDyXYSs7sr1VRH5E9Q/RzdvfBiSylHoUzmwt5IglcYMmQIxo4di+eeew7//POP5rju3r1bzfrMGwK0+in0nTF32DcWmDco+zFrNQfsMm9zfLFKhTfS6G2gzjMIWdLTgLFlgRRD/XjD4UDd57IfT6xlbhOTk8/MW+PptcCBCWpm1Jl6rxUOKqyRZ2oy/3LgoXCCcWa10xQgqZfzWdmZ7ZWhazysui/iRNlHcOTIkRz3VuPAw5lSPTNBEEKBXNsJ0dFazRXVhr3KlXOqRzsjrgcnOe79bEXsBEEIbbxtJ3jtsDK0yb1wsROCxlklPJSzZ89qJzgrrdMFcRGnUeLQlyhy9B9EFKkK9N6gQuSszVtwvbqArNR9UQnQGGdVF99hTh10RGInIDYBODxL9bl0F0ZaOVvCpWQbIF+M+68VTJw6dQpvvfUWZs2apUVan3/+eTRp0kSpvk5uALT4Bqh2V/ifNSpVUwBMp1gDoLed2t05fYCDk7Mfx8QrpzY6RCNqjFBS1t1I3y1AkRpmNW+mPOtw4qjLNNf7TrsEHJmj7htcLu51/7gKV1eCLJwdpdCTdQb070LmVhfdFwAJbezvi7flxbcBu341r0/qA3QYp93jUo8sxKnk/DiRUhCpqakuD49RJDbypsy9JigjCCFIjuyEuDgtmkrjy+fiIBRdYkSFjuv+cWInCEK44Us7wcukpqZqNjPvl6FsJwSVs2rk8uXL2kDEMDZrVdggnLOpXHf8+HH07NkTcWcWIWZBb/MLW/8GVL5J/Z91ajRad3xn+waUp2/xbXZz7xWPAVs+Nhv0jpxR5o/XfFQ5nYemAvvHeFazxnB/Yuds57VwNUkZzi2Mps/uptK6WUfcaznCHvbiosS5DlvWdJ9nux2L+qdZUmAbvAnUewEhyfKHzL3HitUHeq+1TRNm+qxOvjjgmlO2k0Ss+z21RokwsQaN9a3uRkWYqVGyLVCuvxp8nNWs8170V7R5Xe91QLF69rdnX9wld9oOcj2XAtFFgc0fAqufAdqNREa5Adp9Ul9470xPT9cGHc6IcsDhQoPdl+ILghCUdkJcHGJiAjQ5zN897yma4yp2giCEJP6yE3xIRkZGSNsJQeusGlm9ejUaN26c9Zgn99KlS4hmaJqqWqfXmA26PhuzZyv48da9Bqx/zXbHNO7bjwFiSwLr3gDWvZz9XFJfoNJQYO2LwPmd9g+Mqb0N3gAq36ZS9faPBvaNAc7v8OwDMn1Td1wpDhOT+3q0PMXZbcDMdkDK0ex1dFbptIYzG95W6ew6Sb2BTpPsbzt3gKqh0IkuBgzYHXrXWtplJfNuFFeq/ypQ/xXzdinHgdEWlc9u89RM5tnNmYMOlzmeRT6ozMfUXc6KsjZarzt1BevmR1qEvwbsBQqWt932zGZgalMg7aJZcKHnEqBAErD4f8rwJe1HKXE3QcjjOLQToi2TRIE0eI8vETtBEIId+g2BsBOE0HZWOUNqlZffs2ePpuSHvaNUc24jrX4BqhjSIwl7TC67z1ZBtVAVoONEdUGaolRtge7zlXHMyOz6183OkJGidYEmH6raVHJuuxJcYLsb7tfdGRhd0bVkK6B0pvNKh8uB8pdgmL0eX1kpP+uwLrllmPUVtbL6eWDjW9mPK1wHtPvL/rYnVwFTm5jX1XsFaPAqQgpOBs2zOGd9twJFqttuO7mhqiXRKVofuHRMqSJ7OpnEQadcPyChQ85S+Nnmapyl/+s1p20nC5heNL2VyhAw0m4kULCCKm0wTp61+weoYLn/CUIexKmdEIyInSAIwcP5XcpeP5zpoAbCThBC21nlITI0nZKSkrVuwYIFaNOmjXI+Wad4ZkP2CwpVA/puss0F3z8BWHiDuW6MMK2u+v1mw79IbaDvxuzHV84DG95U6XfpDsQdKgxR7Sjiymavo7N7fJFSZKXzahFLcWuGhs4ro8B0oEu0zBviQZ7C6Pm6V82p1oMOhm5dpjssexDY9oX7Dvq8q1U6mg7PTf9dodXqxxoh1ieVjLC9BFN12Ff2rOG+4DYR6nemp+1wMiq3dW6n16n7lJHrU20nolY8Dmz5yLyu6j2qHnfNs7b3nrZ/qX6QgpDHcWonBDtiJwiCf9HtBD16emF34O0EwSGBl3hyA6bzlCtXDtu3b89at3///ux8cAom0QnVOb8d2P07UOU2844440HDdm4/cxTuyhlg0zvmba0hfzqIVBRlyu+Kh5SAgpW9/yhFQKYG13hQOcucXSnVUS0NhwEpx4DDM7Ijr65mb1LPqe25aJ83H1C8kcqBT8hcjM5xXqXqHSr6rUfOOSGx+w+g+r0IW9iSxYgrx5wtmxiZ1Fsx8fWcfGn4JkKC5CNKadMIf49cz77H+qBjVAF2F05wle6i0vDZ+sbb6t2Xz5gfM63X6qgenGrrqHLS7PJxYNU3DnYsg6MguLQTgh2xEwTBt4SCnSCEtrNKnA5CjGiyJpU55jrr3wAq3QhEWupV6OhRpIQRGqPEtDU9mDVxDDpbZ0qK1gI6T1e91VY+ZnZ6CVN+uX7XL0Dzr1RU1AiVhFkLy0WTvF6nnFZGXqlymn7ZdW9NvWfb1k+z0w90x5URWG2Gx9JzM9yJK6fqjI1Rt+1UBb4nfGe7Uj10Vinmwx5ee0dkr9vyiRILY912sLPnD3NvWU7ccIJi6V05u15KGQYdptj6dWKhqO1AuvhW87rI/EC7EUD+kuo+tsdOine4XtuCkANC1lm1InaCIOQcdgOhjXxiaeayRJXiBLudIIS+s8reaEZ27jTUbTFCQZEV1nPpsK6LbR8YcbNSoAzQbQ6w6FZg30j7b5iRqhzP6ML2DUTWiZXpBWwYBmz+wDY9jzVn09uoFioN37Kfasn9FG+gljpPqR8YVcb0qOvZTXALpi9w2f1/2YZwydaG1OEWQJSX+8oFI3RMjc4qv4MTy4CSLRCWeBpZJRQi2vt3dnSV1/iG4UDTDxGU/VT5G+BAQ2EStuoxQsfVWW9ke7CXWbNPgUJV/evoOfuuOFFGR9VaE9/4faV0rLfDsEsem5QShJzaCaGK2AmC4BijnUDHlLbCmfXmiW13yZ+gHFM9eupvO0EIfWe1Rg1DD0UAmzZZHDlGVze+bRYmWf8mUOlm+4XOdN4YtVj7iqpFtQdVhunwOUJLDX4LqHyrg9TgDCXsxNTLxu+pdjnOLnweE5XDuJDkw8DxhcDR+cDxBcDJlcqJdgXTmtlShwuJiAKKN1S9XhlZ5sKenPYc8VCGglRxFcw9rxhdzTPOqhvfZ9HaKqqvT2yQbZ8DNe5XLZQCCbMU9MGGf08u90yczAgnbEp1UrXmR2aZVXkD8TmvnHbsrG7+WE1OGWENTI0H1P+PLQL2jzU/z98wszJkIBUE9+2EcEDsBCEv4ws7QY+eSt1p0BISAktk1KhRuOaabNXLMmXK4ODBg7Y1X3MyHT0d9lJldNMZu34Hltxhm4IbUxzoOAlIaO36AHkaHaUG6yR2AJp9CRSrixzByCt/nMcWAMfowC5SjmlOYf697rzqC1tjhLIBzAmKtS+Z+2sOPhSeQksTagLntmY/bve3mrRxR4VyUh1zNgDbn7ANij/gb4VRRM5+MvKtz4gmW37PnkBBrYT22ek6nJhhxgWzFP7taU4dvuak/6+Hta+a22cxZb3TBDUBRfVf43fBzI+r1qrUbJ6rWZ1UiYDxvkRhLCobMypL8SVBENyzE8IdsROEcMCfdoIQ9ISMs7px40bUrWt28k6fPo2iRQ21X/YMO0ba+m1zLSNNB3BG++z0SGPdWKsfVTTKHTTVYAepwXqUs87TQL2XgXz5kStoqFIFmY6r7sDmJC/fCOvjsqKvmX/ZxNiqrBzMCm/jKphTQFr/ClS+GWHH6DJmga5OU4Ekg2PmjJVPKHElI13nKCEwb8J+p7xGtWV99v+NfVJzQv5EoNwAoGRLpchHISJ7gw6FtkYWN/8Wu8xSaT7+ZOk9KsvCqNzMdOQpjSxCDxFAlxlA6a7q4YHJwNw+5n01ekfdQwRB8NxOyGuInSAEO76wE6jbwnZ1LINzZScIQU/IOKuXL19GwYIFkZqanQa7aNEitGplETA6thCY0da8jj1Qaz3m+k3GVXYsX03nknWx7kYdaYAufyhbxdcK0w1a/QyUaAavcvFAtuPKv6dX24pHeQoddtbOaQ5sQ+W8Fq4OxJUPzh/+nD7Awcnm9ODOmSnR4cSIgkDaxezH3Re6lwVALp8GJlQzDwbFmwC9luVMnIvptactAw0XR72JPSGmpFLEdae3qj2mNlepQjqsIa/7LPzK3P7AgQnm+wmhQJSROs8o1XHC3+2UxuZesbGlgf478kYNuiD4yk7I64idIAQCX9oJDExpTmkL5ZjGN1GRVCEsCJFwGRATE4Nq1aph8+bNpllUm0EooY1KsTs4MXvdutdVvWj+Es7fhIagI2eVRiXVhhlldecHQIeu8zTHqcH8gTL9r85zQL2XvNdAmG1sKl6rFnLlnEqdYC2vvrAY3ZPi8/RLytg3GvwkMgYoVEU5rkwppvOg/z+QjmzFoWZnlbXEVFstUAphQ3qq2VElnqS2xhQD6r2qaq11Tq1UIkZVLKq0OpzXYuop04iNAw2X5EPwCqwhKdFcDTbaoNNCRSWtvVXddVQJ92G8dvl78Dc25ycS2DjMvCq+mWp7pcPWS0ZHlfBeIY6qIOTOTsjriJ0g+IpA2QkFSntn30JQEjLOKqldu7ZpEHIonsB+plo/Rr2f5Glg3atAs89cp8A6gyqq/MG1H+1enZgr1WA6jBR3OjBORVk5E+RtKLrDlEI9rVBXFuXnMDqwp9aonq6ewBpfOvDGlkH2HFltqeY/R5bpofkKAGnJ2eeZPXBrPoiwwd535WkdZvV7gG1fmL+/1c8oeXbOdHLi5nym0jTTy/lXP6feIF8sULRe9kwo//J3ZYzsOuqt6gnc77Yvg8tZ3feP+V7AWtqWP2S32kq7ZK691ltUVb3TDwcrCKGL23aCkLftBCEXtaRHzHZBoO0EIewJOWd1zJgxrgchtoKxUTz9Cqh+v1JDddZTyUiJVsDJpeY0Wt68pzYDWv+sRGncQVcNrniDalFhVCwmVPWc1hKo+wJQ93nvRVmd/fjjm6pFh5/x/C7zwMQUYkdiUbkeoKoCBSsqMRkusZl/KfCk/S2tjjMn8HzTYTX2pWSPznByVq1KwO6oAfM7psL0BcPAQgfI+B1xEJrl5XpOft9FaqnUd31hz9eClV0bI9beqpyEcEdEyggHNyPJB1QaHKML/oDnnefVCO8jRmo9ru5bRhVra5ZHg9d9f28QhBDHbTtByNt2guC+naA7pBf5/z1OWqkFyE4Qwp6Qc1aNOB2E6r8G7BmR3eqFBu+qJ4FOliiNkYLlbY1/qgEvuM7sHHBmcd7VQO2ngIbD3RcfojHacymw4S1g/RvmNjT8P9VC9SgrW834E85SFa6qlgpXmwvf2cJHH5hoZJ/blnOp8KwBapPrPrJUPdUHpqxByrhkDlj20rIr3Wh2VqmczN67nMUNB5jebeXwLFUTcum4SsPh35Rj2Y+pomdVvPYmFA9j+rt1sKHBkROBLs7g7vzJvI4TRDEeiqXwmBh1Nv6GGV2NGwS/wPPvrOUUjTH2vzV+t1S1NkKDkde0IAjesxOEvG0n5BXnM8suMNoEYWInCHmCkBFYIitWrECzZtmCRBEREbhw4QIKFChg/wXLHjCn/xHWkZbpYX971ustuiX7MWd5+m5SuffzBqsIqJXEjkDbvzzPl+cNfdGttjVp+o+ZAiwUgdHTAoNRUpyD0fnt6u85/W8uB6icwEGINQx0SKIKZ/4tpPrMst5Wp2x/oMK16nnTkvkaCkn5um2PVmuanL2kGv5vWlIyn7+gRJCMAwsXqh5be3f6C6asMlXLOthwnTev15OrgKmW1HhNKbeb5/ua1c3cb7XOsyrbwR8wdY6qv47ghFjZ3o7b3PhKqVkQwhCP7QQh79oJjmyBqCLhYSfQCb18Ivcim8FsJwh5gpByVjngFCpUyLRu9erVaNiwoeM6sfFVzfnz/MFctdr+DM6ROcCszuab25Bz6sbE3mVL7wV2/2b7Os7atftHCb94QtplVbO6Ybh9wSOqs7b53XnqckgMUIZByt8DlCfwBhrBJZ+aQeaSPwGo+YiqPY5NVNE59u7kJMiFfZnpKZEqnbbi9SoirqWXRgKXjgKbPwb2j8kebJxF2IINCv5QBZqfTVsqAoUqAQXK+mcGdMePqv+xDmuY2F80JylBq58HNhqcU/ZZ62pwXn2Jvf7POkxpZn9cHf52eM8y/k7KDQQ6ZKc1CoLgRTtB8D/hZifo/4fh//HNldBlsQbKdiBMod34juqPzu1o9+kOp9EpDQU7gUEV6lvQLsiyEQJgJwh5gpByVkmlSpWwZ092L9Fff/0VN9/spIfmmheUM2ikOetX77Xd9twO1c7DyDUnVZoJ4ana/jWw4hHbHqr84TZ+H6j5sOezbidXAItuU3LeVvLFKWGoKrf7fjbP3wMU6wY5oZBySP3VFh+noHgCJyF6LFY3ZHv9dGd3Uc2qY+KBvpuB2AT7M6SjEgIXBXU02MZlDij6QBNdHFj9lHlih82zu80N7HXHgX11ZpsZ1nQ3tKTHusu+scA8Q9ovZ9aHnPaPSMOOn4Al/7Ndz1n6PpuAuKTsdUvuBnZ8Z76v9NngnqCbIAg5sxOE4CHU7AR7UKmWreTsOWtnNgGT6iDosWcn6M4o/zK9WmpJBT8RctMenB01DkLsoeZ0EGK6H+vejGqca19WYkfW2jerwBKhcIDurNJor36finjOv8YsKsCZsJWPqtrIlt8rkR93YT1ar+WqPc7Gt80pG2xPwugS+7U2/9rzer1ggueP7WO4JLZzPFCxvsI0OB00DFKGddbWLd6Gkw8FK2jKkk888QQWLFig1UO99dZb6NSpE9Die5XeWbKV5qju3r0bL7zwAtavX6/1+Zs0aZJmNGmRcV4XPiVSXb90mKlqnV//WzJ7XWypzEGmjH0njbXYa57LfnxsnooKuysklgsuXryonePff/8dsbGxuO+++/Dqq68ikn1HWXvMdPlqd+X8DawiS/ys7IXsj6wFXsf2YL270VE9vhTY8b15mxoPiKMqCL62E4TgIdTsBHsk9dYc1f/++w8ffvghtm3bhsKFC2Px4sVqzKEjaA14+AMGP4w2QU7sBEEIACHnrLZt2xbjx2f3XKQD4RTWGTR8W6nw6jCnn61kGr9r3jZffpWuYWxQzFRPpkIaYePhXiuBhUNVD08je0cAZ9YB7UYBRWu5/8H43my5w5Q/1rJaRQVosB9foupjS1oM73AbqPLHqwV1HW/HwYoOhzZYHVP/Z4quthj+f2SmudaY6Tvsp8vtU886ruXgDbvi9UhPT8f111+P/fv347PPPsN7772HgQMHaoZQUQpmleqcVX9x7tw5rSE9FxpHbFCf+aYuPnOkUrk1LbHqL3tqMnJrHVjYRsnYe7TyzUqhOjfUelRlDjBVSWfVU0BSH3V9+hCe16+//hpvv/02Dh48iDfeeAO1atXC0KFDgRoPAgcmqRndnEKnkGlJVAI2iiz5w1k9u9W+81zNkN2RngYsfyC73RaJZi/cl31/fIIQZnhsJwh5206gLWBvvf6cpzWftDM4xJw4gcqVK2PlypU4cOBALj9zDuyELKc0c5Ee3UKIEnJpwBx02rVrZxJPOHXqFIoWdRJx5I1memtzf0XKZFM8yaoOy7Y0TMvVYTST/SjtQQNz3SvK8bVCgZ9WP6laR09h3cLKx5XjYIVpgXRqaz8ps17uCllNaWxe1+0/ILG9GsiY9mocmBgh5/XCFM1i9bBu3To0aNAAd911F7799lt8/vnneOihh7QI4I033qjEcyjrTvGmzHTZBx54AF9++SW2bNmCGjVqqIgZU5airANN5qLVwHiYajvvGmDfqOzHdZ4DGlnS3XMCFbQXXG9e1/g9db35EDqmR48e1Qb3kydPomTJkujTpw8mTpyofo/8bjgxkBv+G6wixTrMkmhuEWDzBWPLW1o7RABXrQSKG0SXtn0DLLOUJjT5EKj1mO+PTxDCjBzZCYJgD2d2AmtO9b9Iz/4/HUOmAmfSokULbN26FadPZ5YD7fxN7YPjvtUe8KadIAhhQshFVps2bYqYmJisqBV9bUaxevXq5XxGquknymHVofOw6mmg/UjzthRxMTqrF/c53i/z9VlDx0bFi24GrpzJfo4CAfOHqP6Jjd72TP2MN6sWXynV0yV3musdeYNb/YxqU9L6V5UqIzimWEOgSG1zpHr3H8pZ5Y2fM41cHKg57927V/ubmKgEEhISEkzrNUElV22GfBEJN6a1E6bseAOqJW/5xJy2vO51lTbvw76k+/btQ1JSkmZUxsdzthxaNFsjroIa/HMLMyKMzqpx8spXnN5g24OQ4k5GR5VtH9Y8b96GMv7VGWkVBMEvdoIg2MMNO8FjqkhKuiB4QsglpLOezShL73aKD+sKK1luEIxMHf3P1lk14sxZ1SnXD+i1QjlGVjZ/CMzspBoqewr7mPVeDZRsY/vc4enAlIZKmVZwPtBY+1MyhZZKzG6gz8Sn/H975wEdVdl14Z0KCQESIBB67733Ir0rCNgRbNixK4qo2EB/Fftn7/J9iiLSmyK99y6910AgpJd/7ftmkrl3JsnMZPqcZ61Zk7l3yp2WOfs95+yTkqI7j46O9uyr7iqxyteLGT1zWDpFUzEXEhMTg+RkZe6Umpqau03DWSvKxr5VZsVdMdzcaPBmrdxad53ngbR4/Ta2KISEu/bYBMFPcThOEARBELwOnxOrxLy8x64fIWY4jYOhWW5r3o/giFglHJLddw1Qa4zlvgurlbBkRs9e2KdHR1Y6oRp7H1POAn/3A7Y865lmfV+hxi36yxQGNKyygSZNmuT2oJpW50n79u21VfuHH34YX36pTHG433Qyv+x0eJ80jnCFWDUt7Bg/x1zYOTkHruwxY0/PgQMHNFMK0qlTp7ySemdAIzPz7xCrFFgm7iourAVOzrJyHG0LNlWiC3MVM+diQRDcFycIgpMwjwmM8YEgCH4uVhnYmrNu3Tqkp6fbZrKiiT4zWPJ7+Mf8xao9GVGW77b/Gmj3meqJNYd9DqtvA1bfDqSZlQvbAu3PWW7cc4l1UbLnLWBpLyD5rH33GyiwL7lsB/22o9NtuikzqHSlXb16tVYC/Nlnn+HOO+9Eq1atNMffjz/+GAsXLtSuu2XLFgQHB+PTTz/N7cPs1q2b858Py8KzVPbRJWKVtHgbKFZWv23DQ2r4uAt45ZVXtFLrxo0bY8CAAVqv7+OP5/RrOmtWG/uQjYZKrioFZkBiGrljTkiJvJl71kyVKKZbvSO9SYLgqThBEJwEfS4YE2zcuBFXrlzR/qbrvSAIfm6wRC5cuJDbO2hiw4YNFmU/VmHZ35xGwLXDeds4L2rIfpV1pXilyVIuQcBNScp1zR44f3PlTfrHMUFb8E4/ArH6H1OboKPd2rHAqbmW++h22vU31Zsn6Nn3IbDpUb3T6o3nbO4lplkSbecpQJlVNX3maJywdOlS9OzZU3MD5jZjGTH7p5xKwm5grsEBcVSSWixxJoe+VZ81cxo+bemi7SRYBrx48WIUK1YMvXr1QmhoKJCZ6lwnYj4fPi8TLBHnd9HZnFoILLPSH8dWAZb2kwOfA+sN5m117lOLXYIgeC5OEAQnwGohxg7mVK1aFXXr1pXXVxD8XawSigbzfwLTpk3D+PE29tUdnwmsMMyObDwRaP4qkJ4I/FpSv2/gdsvxNbbAbOrGR4DD31s3feJjNnnR/swR3zKa4Gx9xrL8lxldOpzWvtv+4/VnOIJoVjX9tl5/FclhdtGiRdi+fTueesq1TrkW0Fzrr9564T3ykvMfh5+zpdcB5/7J2xYUovqzCzOVcuSxjH2pzHoa+0yLyv6PgY0P512ObgYM3Obcx2BbARe8Lm2x3Ff1RmXqlnoRmF1P36vKkQOD9+aMYxAEwaNxgiAIguAV+GQZsLV+lJUrV9p+Y84ypSOnOXumqoxVWJTKUJpzZa/jZYcdvwM6TQfCSlsGtDsnA4u7AomH7LtfBvU0aemz2rJsmS7HdBBe/4DNJkIBQYmqQIxhhM0JszmlDtC3b1/3C1Xiyn5V4+eMo5vMs8+05Wc20N65c4XBecUUeOvvB9bdC8xpqBZ7nE3pJpbf7awM5z7GsV+tC1VSsk4BpkosvRahKgheEScIgiAIXkGwv/Sj0JQlKyvL9iCco2yYJTLBDOX6+1QQXqqB/vpX9GUcdlPjZpW9oXGKkYtrgXktgMOcu2VnkrtsG5XlKt/Dch9ntDIrZnSNDWQ4C9Wck7Ptf829AVc5AVujdAOgkaH38uI64ICTS1X3faBK8Hm/muFQEFChF5xO6caWizuJB513//w/sm1i/vuj6qgWgQNf6LeX7wbUHO284xAEoWhxgiAIguAV+KxYNRrXnDt3zqJfsECimwANDVmx86tUEGkhVh3MrBpdfXv9DTR7TS+STaNB1owGVt8KpJnNVLWF4rFAz8VA/RwzGqML8YLWwPnVRTt2f4EjhsyhSDGfv+oruFOsksbPK5FlztYJzlsIYWWBsQe73sOuMRkqXi7P4MhEwi7n3T8XnRIP5L+/RE1gw4N6U6WgUKDNJ2KqJAjeFicIgiAIHsdnxWrt2rXRsKHe2XPWLCtjIgqiySTlFGsO+0CLV3S+WCXBIUCTF4A+q4Co2pb7j/4XmNfccvZrofcbCrR+F+j4IxBiMNmhoFjaA/hXTFsQ00qZaTmxFNg7xKrhOTkbmou1Uw7HuaQnAJusLJA42kdqLt5YPu/KLKMxu3rZSWKVWXrOVS6I+A1A/Eb9toZPAtGGYxIEwTviBEEQBMGj+KxYJUOH6ss6//zTTuERGql68sxhn9wZNYpEVwbszHJRuvUO2ALUMjitkqRjqnyXpYT2zk6teZsSwszimsP72ZDTCxjIfazM1FkrBfY1UtycWSVxvYEat+u3Hfufcr0tCjQ0O/i1fhu/F+wdd5dYdVZmlX23Bd1XcDFgt8FJmd9VmqwJguCdcYIgCILgUXxarF5//fW6y7t27cLBg3b2n1XsY5nFOb9Cfzkj0dLUpqiElQQ6fA10+UW5uZrDvtldrwOLOgKXttt3v2VaAv02Wu/3Yy8gx2mkucA51leobCgFvrAGSDkHnyLJ8Fk0VgK4Cs7/DI/Rb9vwAJCR5Ph9cnwL58bmEqRKgF2Jq8RqZjLQ/M08h+niFSwXx9IN373WH6iRWYIgeG+cIAiCIHgMnxarnHFZvnz5oq+atnwHKFbWsDHINaXARqqNVKNxyne33KfNfG0NbH9JzZu0py/vugVqJqaRs38DizoDiUcQkMT1BEIizTZkAyetzKz1ZjyRWSXs9WwxVb+Nc4R3vubY/XHm8d7/02+rNCjPMdddYvXqPvurGKxRZSjQ+Dk1Eqn3cqBcJ/1+4yIRs/y8jSAI3h8nCIIgCB7Bp8VqSEgIhgwZUvQfIYq7Vu8ZNma7R6yaxqr0XKqyMjRb0R1GhhpxQ9F6YZ19fawt31Jjc3TijM9lD7CoA3DR0DsXCLD/smI//baTPhS4pF8FMq55RqwSzu+N1TtsYs/bjvV9HvrWsv+WZk6uxsIROB24WoApkg1s3rwZr776Kr744gskJiYC5bsWXN7L72SbD4r0mIIguDFOEARBEDyCT4tVa/0oK1asQHy8YX6hLbAfL65P/vtdKVZN5kvMyvRdA5Sqb7mfpYosC970hH1llxyb02c5UDxOvz3lLLCku28aDBUVYzbr9CKV5fMFrh213OZqgyVzgoKBtp/pF1W4oLL+XiAr0/b7oUDcbcjSsnw2tiNcDmeZGr8PRSgF/uabb9C6dWtMnz4dTzzxBJo3b45r166pkvz8xu80fcmyt1wQBO+OEwRBEAS34/NitXfv3oiIyHPAzczMxLx58xwz32n3H0s3XRMJbhpxwtmpA7YCjSZYjrhhtnffe8C8pqqc11bKtAb6rQVKN9Jvz0wClt8A7PsQAUWlgfoyb74OZ/6CT3D1X/1lii5XmhFZg861xhJz9v7ufcf2+6Dz9bUj7s+qOrlvNTs7G5MmTUK1atWwfft2fPLJJzh06BC+++476+OSSNl2QIMnHHo8QRA8GCcIgiAIbsfnxWpkZCT69OnjHGt6jrFp+rL1fZe2ONcRuLBS1RZvAP3WAzEtrM+lXNoTWD8OSEuw7T6ZxaFTcIWehh3ZwKZH1RgSezJjvgx7L8t19M1SYGO5asm6njmOJhMtxy9tfxG4vKPw22oGYm9aCrj8spBeLFYvXryIEydOoFGjRggNDUWzZs207Vu3blVXMI7GoiNwh29Vmb4gCL4XJwiCIAhuxefFqrUSnwULFiA11Q5DInMaPA5EN7fcnhZvvQTTlZRppQRr89eB4HDrTqpzGwMn59h2f+HRQI/5QM07LfftmwasHFE0Z1dfLgXmCBt3LUY4M7PqajOi/KCzbYdv9BnqrDRgzejCxyMdn6n6ps1p/IKqbnAX0c4Rq8nJydp5WFiYdk7BSpKScr5HwcX1N2j+GlBaP/dREAQfixMEQRAEt+EXYnXw4MEIMgt0aXAyd66DDq/BYUD7L62U4OaUOrobHg/LIwdss3QXJckngX+GAKtuA1LOF35/IeFKZDR9xXLfiT+AJT2A5LMIuBE2HE10aTN8T6x6KLNKaCLU8En9tktbgZ2v5n8bLgjsekO/rXQToPJguBVjZvXKfodmEFesWBHFihXDyZMntcum89q1c7LOScfzrsxsfv3Hi3LUgiB4Q5wgCIIguA2/EKsVKlRAly5ddNu++uqrovWNNp5oud2enjxnU7qBGoeR31zGoz8DcxsBR/5beIaQP9hNJwEdvlNi2Jz4DcCSrsC1Y/BrSjW0LGP1BbOpxAPekVk10exVS+G3+03gwnrr1z+90HJRgIsxNG5yJ8ZjpkmUcSGgMDJTtUzqPffco7kBT5gwAS+++KK2bcyYMeo6F1arcxpScZGIRmqCIPh+nCAIgiC4Bb8Qq+Suu+6yKPExZTkcoskLlo6hnHt6ejE8BgPd+o8AA3dady5OvQCsvgVYfr1tc1RrjQZ6LADCSuu3M2hf3EVlm/wVCnbOuTTnjAffW1tgiXbSCe/JrJr6qzt+b3AHzgTWjgYyVImsjl2v6y9H1QGqjYLbYUm80UXZ3lLgnMWNt956SxOp/J9TtmxZLF68GDVr1lRjeY78pK5b72HrLt+CIPhunCAIgiC4HL8RqyNGjEBUVJ4rKrMbCxcudPwOmXFs+Kzl9rVjgbRL8ChRNYDrFgLtvwbCoi33s/9ybkNgxyvWBYM5cT2Bvqstx2iwfJEZ1kvb4bcY561eXK/mmHorNNYyQrHnadhbbZwpemUfsM3g7ntuOXB+pX5bo2c9l20sislSVgawaTxw/HfNvGXy5MnYsmWL5jDao0cPNQt39R15I5GaFlAaLQiCb8YJgiAIgsvxG7HKH6Cbb74ZJUuWxIwZM3D16lWLVVS7qTLYeo/ohofgFZnB2mOBwbuBKjdY7meQvONlVRp8/I+CS4M50qbPasvRNinn1CzWC+vgl8R2tswIGsWUN+ENY2vyo/EEoEwbS9Ous8vyLht7VSOrADVHw6Ol4OYkHrT9tmeWACmngRUjgFU3A2eWKoOpxMNqFNTcJsDZpXmOwOFe8j4JQgDjkjhBEARBcCl+NT+BPzp16tTBjTfeqF0+d+6cVuJTokQJ1KtXz/47ZE9jaCkg44p++9HpQJXrgeo3weNEVAS6/g4cnwFsfFgJTHM4y3LFMCCuL9Dmg/xLESMrAb3+AZb1V+XOJtIvAyuGA/03ARGGsmhfh0KvXHvg/Kq8bWf/AioNgFfiLWNr8qtEYDnw/JZAlpnD5toxwMDtqqSc/armcFYrDb88hXGsjHHua0Ec/iHnj2zg6P+Aq4fUd+vIj5bXLdO2aMcpCIL3xgmCIAiCS/GbzCrp0KED2rVrp/392GOPaYYKrVq1wtixYx3PXrLE0RobHgCSvKTXhcdZbSQwaA9Q9yHrZjVnFgHzmgJbnsm/1LV4OaDnUiBWb0KBjj9oQjU7OxurV6/GokWLkJKSU97o6xjnzp75C16Lt4ytyQ+OZGlhmJ/KcU+bn7DMqhaLBWrfA4+X05tjS5834ffnxEz9tvyEKsnvf4ggCL4fJwiCIAguxa/EKm3p+cNDbr/9duzatQsRERFFu9Myra1vZ9/quru9azZnsTJA24+A/pstBSfJSgf2vA3MqQ8c/sn6sYeXVv2wFfuryxwpEtdTK5fiD3znzp0xYMAAzUCGr6/fidVLW4DUePiGE7AXZVZN1B8PlO+u33bwK0txx3nGnNXqSUrUsBxflGnD3MXjvwOZ5r3gwWpbflgbOSUIgv/ECYIgCILL8Cuxapp7SNq0aYNGjRrp5qo5REFZEZY17v8QXkdMczXmptNPqkzYCF1K19wOLOmm5mIaoYjoNguoeiNQ/VZt06effoqNGzdi+vTpOHDggFY69fzzBgMdX6RcByC4mNmGbGUE5I1404zV/GBWnyNaQgvo0aT7dN0H4XGMpmJ8720Z2WTMoLKcPDPJ+nXZE53fgpcgCP4RJwiCIAguw+/EakxMDD777DPn3WFhgeaWp4CLG+B18Me3xq3A4H1Aw2cs56kSmgktaK0Mo4zZRPYSdv4vUK6jdnH5ciXg+vTpo2VVa9eujZUrvdiMyJ7RKzRaMod9qz4xtsbLyoBNRNUEWr2X/36OcWEG39NwfI3RTbuwvlWW/tNMyZx0Q0+7cbErVLI2guDXcYIgCILgMvxOrJJx48Y5786YvQotmf9+ltauHOX5cTb5EVYSaDkVGLjDclQLyc4C/v0EmFMP+PczICszb19waG72KT5eiVlTuRTPL126hKysLPhdKbA3ilVvHVuTH7XvBioOtNweWgJo+BS8BmPfamFi9cjPKgObH3x+5uQs9giC4MdxgiAIguAy/FKskvXr1+P7779Henq6VrLKv1m+6lBZozHgjGlhGeBy/qo39a8aoQFMj/lAtz+AEjUt96deBDbcrzKtp+bnPZec8qjKlStr5xcvXswVryylCg4O9j+xynmbyWfhVXjz2Bpr8HNT83brizsp5+E1GL8LhYnVo//Nf18QnY0N3wcRq4Lg/3GCIAiC4DL8QGlY588//8SECRMQGxuLpKQk7W/2XDpE+W76yzRhMZqmnJil5kp6MxQQHLkzaBfQ9BVVAmvk8jZg2UBg6XXAhbW5m0eNGqWdv/322/jyyy9x4sSJ3G1ea0hkK2XbWGbEzpnNB/UGvHlsjTWYsd/zluV2ziJdNUrNAfYGStjhCJx8Bri0Of/9jZ4FMgxO22KuJAiBEScIgiAILiEom/NIhIKh4c4Sg8Np/y3A371VRjL31QwF+qxQpj2+gDZW5Eng+G/5X6feo0Cb97Vy30mTJuHDDz/UftRHjBihmS5FR0cD6+4FKvQCatwMn+XvgcDp+XmX69wHtPOinqZ19wEHv8i7XOsuoMNX8FqOTAdWK3Muq9Bgqe3H8Dj7PgA2jddnQvuutn7dQ9+qCgprVBkGVBoIrL83b1tEZWCYoc9YEARBEARBsBm/zaySzMxMrbzHdGLp6rVr1+y/o7LtgGCW+JmR+K+aP2pOdgaw8ibfyTSyH7XrDKDnYqB0I+vX2f8BsHuKVu772muvaX2qycnJmiuwJlQ5l/TQN8pd+FgBotfbifPyeatX9/mGuRLJTAO2T9RvM35/2Cd97Fd4XWa1oDJglsdbI7Iq0P5L4GJeJYJGrIysEYSAiRMEQRAEl+DXYvXs2bOIiopCeHi4dipbtqwmuOyG5bIUrLo7XwZUGgA0mqDfnnQMWHOnKoP0FeJ6AwO2A+2/VoG3ka0TgNW3A5d3aKI1NDQUSEsAtr0ALBsAZGeq06qbgROz4Rd9q5xpeu04vAIWP1zapt9WujG8loNfWhpCtZgKhBhccdfeDVw9CO+atXraeolyVoYaVWWtp73Tz2rG8YU1+n3SryoIgRMnCIIgCC7Br8VqpUqVMHr0aN22Tz75BAkJCfbfWWxX6z2NzSZb9rSemgPseQc+RXAIUHssMGQ/0PL/gPAy+v1HfgLmNQNmlAH+rAfs/0hlkNmDqMssjwBOLYDPEd3ccozJ2b/hNeXa6QkFm3x5C+mJwM7J+m1l2wP1xwNtDGW/7O+kkzZ7wL3FDZhYm7XKMU/G94A0eRko30W5gSfs1u+TflVBCKw4QRAEQXA6fi1WydNPP60b+H3lyhXH5qsZBSkD05RzarxLp+lAsVj9/m0TgPOr4HMwi9zwSWDoIaDxC0BIpH4/g3KWQLPM8/hMILaLfj/F6/IbLGdR+oJYr9DDO0fYXNqqvxweYz0D7g3QZCzF4KTcYooy96o1Bqhxh34fDYu2PA2PEVbKcmHGWikwe7utVSQ0fl79bWZGphFcDIhp6cwjFQTB2+MEQRAEwen4vVitV68ebrzxRt229957DykpdrqRsv+MJX/mnPtHnUdWAjr9xJrAvH0si2X/KssKfZHw0kDz14ChB4C6DyjzKCOpZ1XGyTiHNisV+GcIcD4foxpfKQX2Fkdgo1hlVtUssPIaUi4Auw0OwJzta1oE4DG3/QQo1UB/nf0fAsd/h9f2rR74wtIFOKw00Pm/apGDnFli6TAdYujTFQTBv+MEQRAEwen4vVglzz77rO7ymTNntHlqdmdgWCpq7Fs1UbEP0MRgKpN8Elg+zHvGdDhCREUlMAbvAarn4/ZrHNdBMpOVYE3YC5+hfHfL8ltvmLd62SBWo720BHjXG5afheZv6i9zNmyXXyzHJq29C0g8DK8oBTY/DmZMNz5seZuWbwPFyuZdNvaz0h1bEITAihMEQRAEpxMQYrVNmzbo3bu3btuUKVOQlmbWb+lIKbAx89bkJcvs3MV1wPr7lUmOL0P32c7Tgf6bgLi+tt0mLR74ux+QdAo+AU2LjPNW4zfAKzOr3gb7PP819KRWvwUoY6UUNrop0PoD/Tb2g7ISgU7C3pJZ5VzVFTfq+7JNJb4178y7nHQCSNhlWSIsCELgxQmCIAiCUwkIsUqee+453eXDhw9rJgpFMlky9a2aYEkgSwM5Ekb3YN8Be9+FX1CmFdBzIdBzKVCmbeHXpzvy3/2Ve7C3w/evTGv9tgvr4FHYI8wMr7eL1R0v6UUdy8abvZr/9WvfA1S/1XJhYKs+u+EWjN9XCm+K5pUjgWQrCy2V+utLfE8v0u/nggdNpQRBCLw4QRAEQXAqASNWe/bsiU6d9HMPJ0+erM1Us5nyBrFq3rdqongs0O1Pywzd1mfyn9Poq3NJ+60Dusyw7EE0krADWNAKSDkPr8c4oujiengU48gazist7PV2N5d3AocN5XJ17gNK1s7/NuxfbfcfoGQ9S4OmE7Pg9lJ3c1LPA5ufUP3Y1qg4QH/ZWAJcvof0qwpCoMYJgiAIglMJGLFKp7933tGPk7l06RJef/112++keHmgdJP8+1ZNxDQDOv6g38a5q5xD6ks9nIVBwVHtRmDgTqDLrwW7n3Lu5szKwLYXlRGPt2LMiFGserKE21gCzFJlbzLu4Wuzabx+rjAdpJu8WPhtw0qq/lWW1ZqzZgyQaMWR11UYnbxZ1mssaTaH/ekmsjKBM4v1+6UEWBACN04QBEEQnErAiFXSoUMHjBo1Srftww8/xMGDB22/E5YA2uIYW3UY0NQwbzL9CrB8qCrt9CdYPltthOpn7TEPiO1s/XrZ6cCu14A/a6hRIN7Yy2rMrKZfBq4e8NTReH+/6vHfLEf8NHgCiIiz7fYxzYHW0yxf81U3uc+YjItQRnOwgoRtiZp5l+M3Wn6fRawKQmDHCYIgCILTCCixajJMCA/Py0ylp6db9KkUSMX+BfetmkN34Goj9duu/quMZLIy4Hcw01ppANB7BdBrGVC2g/XrZVxTPbx/1lTmU55ygbUG55cWr+A9pcDeLFYzklS5rDmRVYDGdnyfSJ1xQLVRlq/5hgfck9UuZhCrhS1mmI8NMpYA87PD7LcgCIEbJwiCIAhOI+DEas2aNfHoo4/qts2YMQOrV9s4EzS2iypzLKhv1QSD2g7fWpbHsmxwy9PwW/i8K3QH+q3JcX3NZyYoDXkOfAbMrgusutXzZkamY/eWvlWa/FzZ7b1iddebQNJx/baW/2fZr23La97+CyDK0ON66Fs1g9XVFCuT/79CYz+r8bNhFKvMqnrjDFxBENwXJwiCIAhOI+DEKnn++edRpgwD1DyefPJJZNuSxQkpZjmexlrfqonQSKDbLMtSQxrJHPwKfk/9R4CO3xV8nexM4Oh0YFEHYEE74PAPQGYqPIa3iFUK1ax0/TbjrF9PwR7kPW9bGgsZM6T2zDHuNtNS6DJze2YpXApf46AQy+1xfYDUS/l/NtIuq9FUxtsIghDYcYIgCILgNAJSrMbExOCll17SbVu7di1++eUXx/pWjQYrRkpUBbrOVE6u5rAE9tQC+D017wBaTLHtuhxfsmY0MKuaMmNKOgmPi9VLWzwz/9NYAsxeyfDS8Ao2PQ5kmS0oUOy1+aBoWUXOX+34veVCxspRShy7AhpDrR2r+qmN5cxNJgFZhr7ZsmbjmiiieXzmxPVyzXEKguBbcYIgCILgFAJSrJL7778fderU0W1jT0pqaqr9favsQ72yr+DbxHYC2v5Hvy07A1g5Ari4EX5Pw2eAeo9Y2ZGPuGEfMM2YZtVQPb7nVrrPlddckBCKssvb4Xa8tV+VI5hO/qnfVvchJTaLStXhSiSakxYP/HM9kJ4Ip7N9ksrqG6k5FriyR7+NZcrFyuZfAsyRQhS5giD4BUWKEwRBEASnELBileYJb731lm7bkSNHMHXq1MJvzPmRUfofMJwwBO/WqD0WaPCkpdnQP4OAq37uNMiMW6v3gCrDDDuygZL1gYjK1m9HQX/sF2DpdcDuN4HUi64XreExlvM/PVEK7I1ileXZHFVjdMht9orzHqPpS0CV6/XbEnYCa+/Uj8gpKizD35XPSApmWo3vuXnGnZ9Ba/2qgiD4DUWKEwRBEASnELBildxwww3o2rWrbttrr72GXbt22V8KfHK2bQ/a8i2g2k2WWcS/++XvKuxPI25Y5mnMwF3dB1S/BegyAyjf3crtwoGei4HGz6vMljsMbDzdt0ox5I1ide97qpLAHJZ4h0c77zGCgtWcYqOr7vHfgZ1Omnd4ehGwflz++/ldLEisspIi6Zh+f8UBzjk2QRD8I04QBEEQikxwoA8Af//99xESEqKzqL/77ruRmWnoRSusFPjCKpX1sykQ/w6ocJ1+e+JBYNlg15Q6ehNhUUC3P4Fi5fTb9/6fmm/ZexkwYBtQ+14gJELta/A4UKGHNpz9oYceQq1atdClSxfMmzdP7Wc/qbOzrTaKVZptuMRw49oRID3Bu8Qq+4dZmm18nWqNcf5jhZVUxmTMcpuzYxJwYlbR7vvSdmDFCMt+U3OST6tsbn6fCWNWlcZQcQbjNUEQAjtOEARBEIpMQItV0rJlSzz9tH6MzLp167QfpwKp0ENvmMTyxFM54skWR2EaLkU3szQXopmM0QHW34iqAXT9DQgK1W9fd48aXxPTDGj/OXDDCaDl20ADNcuTowQ+++wzjBs3Tgsghg4dikOHDgEh4cC254GdrwHXDNkuZ4nVK3uBtDzxGB8fj1tuuQXFihVDhQoVtLIwp4rWC2v0l8PLqBmwnoTjlli2nksQ0OYjtQDjClhu3/l/lve/+nbg8i7HBTfL7jOu6rfH9dVfvnZUX3JMAynzEVRGscrFq5Dijh2TIAj+GScIgiAIRSbgxSqh41/9+vV1L8zEiRNx4MCB/F85ZlLKd7O/b9UEXV17zAciq+m3n54PrL/PfWZCnoKvXduPLY2MVgzLcwDm/MuGT2ljf1JSUvDzzz+jY8eOePbZZ7WxAlzV/vHHH9V1S9QAtr+oDJmW9gYO/whkJDl+fDHNgeAwsw3ZQPym3Et8/P/+97/45JNPMHjwYM10Y8mSJXAa51fpL5fr5Nn5nWf/sTQiqn23pRmVs6nYR81uNScjEVh+PZAab999pZwH/uoNJJ3Qb682Eqhzn35b6ln9ZZYkh+Zk+jNTgHOGcVXGHltBEPwKh+IEQRAEociIWAVQvHhxfPXVV1q2zkRycjLuvfdeZGUVYOhi7FFjtsWe+aCRlYDrFliWOh76Vgkvf4cCgS6yxvLL5cOAjGTd5hMnTmjvRVxcnHbZdE6zi9zxQBrZwNmlwJo7gN/jVLbWESdhZsmMM00vbcv9k0KVgcs999yDp556Kneb0zi/Un85tjM8RlYGsMng5BwWDTR/wz2PX/8xoOZoy7L5VTerY7MFzkRlXzgz5MZFgA7fAcUrGK5/RX+5dCP9e8OSdfOsa6VBth2HIAiBFScIgiAIRULEag6dO3fGww8/rHtxli1bhi+++CL/V6/KUP1llhae+8e+d6B0Q6D7HMsSQrqU7v8Efk/r9yz7d1kOTZFpJjCjoqK087S0NN15yZIl1RV05alm7wcdX5d0BWbXs79M2LzskySf0s4SExORkJCAcuVU323ZsmqcyfHjx+EUWG58eYd+W2wXeIx/P7U8nmavAsVj3fP4DA7bfQaUaWs533jrs4Xfnp+NZYPUvFxz6PjMvlhmTIuX1+8zzl0t1TDv75Nz9Ptiu6oqAEEQ/BqH4gRBEAShSIhYNeONN95AjRo1dC8Q+1SY1bNKyTpA6SaOuQIbZ7B2/q9lb97Gh1U5qz/DUtsuvwJRtfTbj/4M7H0n9yL7QqtUqYJt27Zp5habNqmS3NatW6srhJYEwkrl/ziJB+wvEza60cZv1s4iIyO1kQZcVScsUSZlyuQIForsopRxX1irMsQm2Btdtg08AjPdxiw/3Zzr3u/e4+BiTreZQHGVUc9l77vAoe/zvx0rHZipv7Bav53l9z2XAMVzjL6MYtUIZ6gS9rEem6HfJyXAghAw2B0nCIIgCEUiKNslVqa+y+LFi9G3r95sZdCgQZg9e7au/CeX7ZOAna/qg+DrjzjWX/jvZ8AGgwiggO00Hag+Cn4NDXMWdVD9iObllb3/yS2BZX/qHXfcgapVq+Ls2bNo1KiRZnJB4ajB0uETf6gyambdzAWfNYLCgBLVVYaQZk/sRWTfLE/8O/0qkGboixwRr5VtX3fddVi7dq1WhrxgwQKMGTMGH374oVp1P/AlsP5edfzaKVSdM4MXWkr1K1NY8xSac26+7dRC4OQsvdlTv3VwO/zXsGK4ek3N6bUMqGBlxJA7OL8GWNoDyFKZ9bzRRkuB8obsM0uEV460PH4K3j4r1GKT+XP9X7H8zc0GblcinY+/uJN+39BDQFTNIj81QRD8NE4QBEEQHEbEqhXuuusufPPNN7pt33//vSaULGC2bUFOds8ER68wsGVfW2ikfe/I9peAnZMN71KIyj5WHQa/5sRsZZxjLjIjKgMDdwLF1BzP/fv3a+KwUqVKuP766xEWFgYkHgEOfQ0kHQeuHQeST6g5mexTLEyw2gvdb+s9hPXr16Nfv364du2alult166dVg4WEREBLO0FnP3LuY8bGgVEVFSn4jnn5ifTNvY/OytYOvarcqc2p8ZtQCcPZ/sPfgOsu8vSLbnvWqBU3bwM6Jo7gSM/Wl6PCyDRhooI8lsFINXKrGMuGI26prK7m54A9r2Xt4/fcwpZQRACCrviBEEQBMFhRKxagfM8mbU7c+ZM7jb2Rm7ZsgW1a9fWX5kZGZaWJh3T97ClnAWaTARq2vnDxfvbzIB4mmW5bNffgcqD4ddse9FylmdUXeUKXOMWNX/THM7cpCgxziR1FRGVgIE7tB5F9q7+/fffiImJ0XqZtBV1ji9if6SnYDk0M4Y8RfG8ds55HSVmbR0zw5nBcxsp0W+Cs3EH7ckrnfUkmx4D9pmNjeDzKlEb6LsaKFYW2PiQ6rU1Cv5ef+XvYDy7PnB1v/V9zMBXHAicmqMWRUw0eRFoZlhcEgTB77ErThAEQRAcRsRqPvzxxx8YNkyfyWzbti1WrlyZV3ZqyuCsvg04asUJlpmecu3tf1coWNmv+q/BYIklov02AKXqwS/g82RP5NV9yqU1YS9wZQ9wbrkqxbU2LqjKMNU/SPOkUwuAy3kOvW6DLsEdvgbKtMrblpWpsngbH7Gc4ekthEQAUbVzhGzOOU2GOO/XKEBXjwaO/KDfxnL0GjfDK+DrvfwGIDwaqP8oUKa1+i4m7FTVDuvu1l+fWVGOiuJ85PxY0BaI32h9H8Vw28+B9ffot/ffqB5bEISAw+Y4QRAEQXAYEat2lvlwxueUKVO0v7MT9iPor55Acs5cUCM5/Y0OwcB7/Tjg4Jd5QoPli66ea+kqmKmjiLi0Gbi8E7iSI1DdJeyYmWYJKE/MvPH15DFdO2LZl1oQLEtu+jJQsa/KYlLEZGcCmUmqj5J9krycnXNufpll4elXlNsvz3nKMFzma3LtsCtfiXyeVyUlWjlflmMY9r6t3195KNDtD8/OejXC/lLdLFwzdkwGdryk/mbPMF1/Kw8s+P4KKt9u/IJaQNljNvM1sgpw/THvek0EQfCuOCE7W/pYBUEQioCI1QJgmSfdZtknac6iRYu0MSWnTp3CxJsrAOvvs7xxsVjgRiv9b/YK1rVjgcPfA00mAc1ewblz5/Dkk09i/vz5Wt/mpEmTMGLECHgVLB2N36TEKc8pUK8ddc1jUXhGVrU8RcSpfSaByqxsfqIiYQ9w/Dd1urTVtscNiQQqDQSq3ghUHmRZnuwoK0ao4zBR4w5VappyWmWhOT5HO885mbanXYLLoBFV4+eB8t2sZ2E9CEcY8Tvwww8/aJmM+++/X3PmDA4OBuY1U8ZdbT7Q+owLZTnNpGZabo9pAfRZC8xtoBY3THBGcNuPnPuEBEHwvzhh4kSPHZ8gCIKvI2K1ENh/0qFDh9y5nqRYsWJITU3FgAEDMG/ePOsuvnSw7bPSOeWO7MlsPU0TCSNHjsSsWbPwwQcfYMaMGVrP5J49e1CvnodKgymUNGFqJk7zyzQ7g9KNgFbTgBI1VGaLDrvO5OoB4PjvajwJ573aArN7nINasT9QsZ8SdI5k21gWPbMSkJLXA4X2XwO1xxZ+W7oXU8gmHlLPgafEgznnB9R+Z8ExQ+U6AuU6qXOaDAWHwhO8/fbbeOaZZzBhwgRcvHgRn3/+OX7++WfccsstasYuqxPafgrUubfwO1szBjj8nX4bs7Is9WUWd6GhqoGVDhTwgiAENDbFCYIgCIJDiFi1gWnTpuHxxx+32F6xYkVt1VRj/yfK1MVEzdFAR0Pg6ygsJQ0ORVJSEqKiotC9e3dNpNIVlz+EL730El5++WW4HIqpq/8C51cA53ha7pySVZbklqqvelFzT/WVYc7K4cCZJfrrN30FaDoJLofZ4EPf5ZWT2gpHo1C08hTXx/ZMJIXmnwZjjsH7it6jzAy91hucI1yvHsw5/1dlla31B9sDs9Ycr5MrYDuorLYbaNasGQ4fPozLly8jISEBZcuWzQsOmSWf3xKoNgro8r/C72zjo8D+D/XbmFFu/jqw9Tlg91R92fQNx203rBIEwa+xKU4QBEEQ7MYz6RAfY/z48fjuu++wdau+RPT06dPavM8KFSoA9R5UgeuGB/KyT84iJ2vFoePsf4mNjdUuly9fXjs/dszMidiZMKubsEOJUopTilS6HDsKTW5oThTTEijdME+YMkOaX9Df6SdgfgsltkzseFllMuN6wqXQAZYluPs/UP2tuQQVPBKHmVFm6LQsXZAy4DFlXSnk8stCnltpWUpeMmcUS1HgaxtZWZ2M81G5EELRenEDsPkxx8qJM64BZ/9WJxNcbNDEa0fljs332QW9nfzsU6CGhIRorsw8z/0+RFRR52eXKsFemLCkgZk57Enm+89FGo7xMafaSBGqgiDYFycIgiAIdiNitRCSk5Px4IMPWvwAmZf/9O/fX12oe7+aicoeVjOxmpmZqc3iNBkthIaGaid7KVVKBdMsLTI/L126NJxCZpoqfTUJ0/MrlemPI7Cnk71+FGp0zeV5qYb2l4sWL69caGlkRcGhkQ2svlWNkCmuhLvLoMAq1Ui9HiYaPQdE1VS9pWcohDIKuINs5TDLE0fyUBBV6AVUyhGvFMQmLqyyLCV3tXkP3w8uHBz6xlKo1n1QieXL24FL24CEXbZnYTUDrX3AoW/zMpFxvdWJzz+yUtGOmwIyKEj7TphK7/g94yn3+2Ay7+JCA7Os5u7N1u4ytBTSw+KQFULjrBAElW6M8OBiCOJtmfU2p9pNRTt+QRACM07IB2fFCYIguA5+P/k9zaIRpRYiBml+GdroQsFlyH/CQihevDiGDx+OXbt2YcMGyx7G9evX63+E6tyLbITiSmgDXDl+XCvd5Qfb4oUPDUVkZKRW1hsdHa0MYQqBK7M1atTQfvhSUlKwZs0abXv79jnjcegkywyWPSQeBk4vBE7NV06oGYn23V57MlEqW2ouTEvWB4JD4BSYDWz2GrDt+bxtzPByUYCzZ139T6J0Y71YZXlwizdUHyTF/Jm/1Gt4eoHegMcavD5NfExGPsxAxvVTz/HsP5Zi1R1c3AjsfUe/rWwHoPUH+veQWViOhrmwBji/BriwWvXF2gL7aWkUxpPpNTWJ1/Ld7TOoYsY/9awmgNkn9uuvv2qlwKZSu9zvA8ueTZxeZFWsUuhyXuK1a9eQgkHIaqh3DA7avRvF+V2t9wWiT3yIiKTtQGQ1lSEXBEFwJE7ICXqvXLminZwZJwiC4Fx0cUJKSq5QNUGhyv8B/K7yexoR4WQvFUF6Vm2FPywLFy7E5MmTc0UiMTdP4MooTV544t+2wh8gljCyvLewlVQG5jSP4ReCX56OHTti2bJl6nYLWgP1xgO1Rud/BxnJwLl/lLDiidkvewmLVuKqfA81t7J0U+cJ0/xgVnXZYOD0fP32Dt8Atca49rH3fQRseiTvMkuZB27Nv6dXE64LVVksR9o4Sqefgeo3u1aMM5u+sA1weUfetuBwYMAWZWZli/PzhbVKuFLEspyYI3rsgSZGnEfM/l6KV/a/5jeShoKZhmMU+U0nacFhly5dkJGRoZ1YErxu3TpUrlwZWHcfcPALdTsK4t7Lcu+GwSGdtenkaQ8RQddQLuwkStUdJiupgiB4ZZwgCELRcThOiIhAuXLltMovybg6BzFYcuDHaMWKFXjrrbcwd+5c7ceDPzpccTl58qTV1VF7fowYZBdW1sve1cWLF6NKlSro1auXWm09Ml2VxpI2H+WN6tAE1H6VOaU4pVC11xnWE+LUGslngXlNgNQL+r7CgduBqBque1yKzqVm/bHBxYBR1wp/DTJTVSm1SbyynNZeaFRUrrPKsrJPl1nrkGJwGjteBXYYzKqaTgaavujY/dE1lyXDFK4UsCwpt9cdmu8pS6Sr3KBmo5pmFfO+V9+m+ke5bdBubUQRMxNz5szRSnEGDRqkVjXZR7tuHHD8VzX/loJ4RDyyQkpo/WP8zhaFkiVLaqOjwsLyEdWCIAQs3hAnCILgGMycSpzgXYhYLQI7d+7E//3f/2ljM4ry42OEP0L8MbKp5IcZxyM/Ausf0Gfxao5RY10oUgsrTbUmTjmSg8KUApWjWDwhTq1xfCawYrh+G7Nmvf5yneENs4e/Vyi6S2/SKeDMohzxughIi7f/WCiUy7bNE6903y1WBg5xeSewoJUSgSb4XnNUS36ZTXvhYsmVPXmC3d7FEvaA8/2lQRU/y+fMTJxKN1EGXDHN8r89+1UP/6hlWFObvIUjKbWd9l3l97NatWpaiZ4gCILXxgmCINgEvWCOHDkicYKXIWK1iKundPqLj3dAdBQCA2AGwvn+EFEEnPgD2PmqCub3TXP8wbxZnNo6D7Pl/wENn3TdY/4Wq8/odvsDqHK94/fHvkvOpKWAO79c9b1C3wdhMyzXpesu+4ZpasX3r7AeUArGhe305b8U+/3Wq+ytq2AZOvt/TeKVpk2OQuHO94FmVYWQmpKCQ4cPITPTwde4AKpXr65lWgVBELwqThAEwS6heujQIbvK821F4oSiIWK1CLCWnSdXwZXTqlWrWheqW57OM8Vhjx+FT3am7UF+hZ5AxT6+IU6NpCUA85oBScf0fZb9NwHRTVzzmIs6q7JWE62mAQ3GO+e+mXH9o7J+W3g5IM1MHNtLVB0lXM1PdOQ19b9uegzY977+Ng2fAVqazRJ1B0knVJaZwvXMYvtG53C0D2eoctGACy35ZIPZy3rgwAHt3BWwJ6VWrVpiqiAIgvfECYIg2IzECd6NiNUiNF5zBcbV8EdI15tCobr5SWDfe/bdEQP7yoOBykOViU2Yj5cunl2W00earTc+YmYwJNz5j7fqNuDoz3mX6z8GtLbzPcgPjndZOzbvclhpYPh51evJntfzq9S5loUsYL6rLZ8Bilbe//EZ+n1csOi3Ts3C9RRatnljXtb14jrbF2DYw1p1uBopU+E63Ygkzl1lX6srYb9snTp1JMMhCILn4wRBEOxC4gTvRizlHGy+psmRO6AZQ4kSJZT7nymjaq9QJRwl0/JtZdjjDzCT1uBxYO+7edsubwN2vKzGyjgbzlU1x94+4IKgMDMnrhcQEqZMo3iqebvazqyjNjImR7xeXG9f/2fqeZW9tCBIzVM98Lk656lEDftn4hYVZvfpCsxTbCfgn2FApo0ufHxtDn6lTlrGdYQmXBPCm7lcqGoPn5amZU/i4uJc/liCIHg/HosTBEGwi4SEBIkTvBzJrDoAXf3Yg+IuOI6jIoPgbROA3QWUadLxlL2nkVWAwz+xMVG/v2Q9oMc8oGRt+AUUagva6Pse2XfZe7nzZ5Qe+BJYf2/eZWYoOd7FGdnEmRWUEZCJdp8Bde6zbezMpc3A+dXApa3A5a1Awm7bs5EFwc9SVK088coTDaV4HlnVdWZWhJ/dtWOAbEPZblRt1Z96aiGQaDZDNR+yEYx9LbYgI8t9/Vz169cXh2BBEDwTJ1SsKK+8INjZU75v3z6XtQlZQ+IE+5FlOAc+2EUde2EvnKda4dx/EFyQUKVbaufpQHi0ulz9FmDlSCDDLDPFETaLOgDdZwPlOsDnYclqxx+ARe3zHG3pjrxmNDBgm3NLnY2jcRIPO+d+L23RC1US19e227Lcme+j+XtJAU/xTvFqfjL/HNgChSI/LzxZ63nmgocmYnMErOlk3hdrL6wcYB82qweMcBGm2yz1+eb1OAbo2Aw1miafWcFXY0e4Vaiavqvly5d362MKguBdeCxOqFBBWhEEwQ6uXr3qVqFKJE6wH8ms2gnnpB0+nL9QSUlJwciRIzFixAjceeedudvHjx+P4sWLY+rUqWjatKn2t2lYMPtNfvvttwIft1JsFMoEnwYSD+WcDuaJCYodZlOvP6rPeFGkLBsEJJ+yIvJ+BKrdCL9g15vAtuf12+o/DrQ2KxEuKlcPALPr6reNuJS3OOAoO18Htk/Mu0zxN8S6+HIYCniaGC0fqh9T4wr42aJg1U6V1Xmk+d8556GRlseo9WJbcbWuOgLo9IO+n/biBuViXbKOEucm4crMcg6Hmy7CtaCKDn1Pu3btismTJ+tuk5ycjKeeekp3fYunHxKCBg0ayCBwQQhgPBYnVKqEMmUcHGUmCAEIv6f8vlpD4gTvQTKrDqzCFAR/XF5//XXce++9WsBLl9A///xTm7X2+++/517vhx9+0IJaW0lMDUaZah2B2I6WOylWr+wHMlPVbFXzUlWa5lCwMhNlnn1j1pXjXtj36WgmzFugi+3JOXq33v3vAzVuBcq2cc5jsPSVvZ3mBkfsWw1v4dx+1Yr94HQoULc+ZylUO00HipfLyb5uUwsf/BylX3b8sfjZMi2oFASFpknEFisPXNoEXNlreb16DyvnZaNb9bkVwLbn1KJEkxeAZi+rE8Xqsd+QdXxmvkLVlu8pzUoGDx6ce/1du3bh1ltvRb9+Bb8/tLznD1xEhNn3UBCEgMJjcUJioohVQbCjrzw/oWrL91TiBPchw7nshNmVwmjWrBluueUWTJw4UTM+mDJlCl5++eUiufXRVTBfaJpEEWsuVE0w49pnhZXSUpo1PQlsfBjIcm8JhNOhkOnwjSpPNc/UscfUWc8tpJjKCJqTWESTpfQrwIU1rherzDrTfMqceo8ANW5WztANn1KZSy5sjIhXTsR9VgMdvgMaT1QOuzGtgFAnllVTEFNY0vDp6E/WhSrZ/ynwRyVgTkNgcRfgn+uVc/KxX5X43vMWMLu+clTme86Zs01fROp1q5z6PZ05cyY6duxok4GSLf8jBEHwX7wyThAEwWKuqjO/pxInuA4pA7azD2XPnj3aakxhpKenY9SoUVrfSs+ePbUPtwmW98TGxmp18vXq1cMjjzyC5s2bF3qfXGF12O2Pgf2GB4GDX1ruqzQI6Pxf3x9nYyypJXRAphhzBou7KhdeE63eAxo85vj9nZgFLL8h7zLnhLK0OLQEnMbpxcDfhoWK0k3UiB9rixsFwV7RlLPA1X+tnzI9LNIoqFu9C1Tojvj4eJw6ZSh/t/N7aoKZUu575ZVX0KdPn0Lvk2V4LMcTBCHw8Ok4QRACCIkTfAfJrNqJLT9AJCwsTPthYSP19ddfr9v31VdfYcGCBdqJpQXjxo2zyTWwSE3gFELtPgeaWxnrcmousKQrcO0ofJqGTyshZs72SYWXpNoKx7k4c3yNsQQ4totzhWrKBWCtob+S2efOP9svVAnLxSPigPJdgdp3AS3eBLrOAAZuA0YlAjccVxnZLjOA1u8DjZ4FatwOVOgJlKoPhJaES6Ez8tIewPLhyLh2rsjfUxOLFy/WrtejRw+b7pMBqCAIgYvPxgmCEEDY+l2ROMHziFi1c8XUVtatW4dFixZpBgpvvPGGLoBt164dwsPDERkZqZkr1KxZEytWrHDq4+crNhpPADr9DASH6/exb3FBa+DMX/BZ6I5LQa71lubAbN/6B1RW0NlitaiOwK7sV+XzXX8PkGwIblpMBaKbwunQ2Isl5yxHp3FX/UeBFlNUeXGvpcDgvcCoK8CN8UCtMdbvI7g4ULyiWlhxFM5YjW6K7KCwIn9PTbA3ZciQITaPpCny91QQBJ/F5+MEQQgQbP2uSJzgeUSs2oHJla8w2LA9adIkPP3003j+eeVS++WXX+b/JgTb9jbYer1CqXEL0HMJEB5jadT0dx9gzzvOEXeegGKp7oP6bWcWAUd+dv74mqJkVq8etMz4OlOsHvxClRnr7r+/EpGeIu0ysPoW1V9qhL2zw0+p002pwMgrwNDDQP9NwHWLlBlUm4+AppOB+uOVKDWHArz9V8ANx4BmryAovKRTvqfHjh3Dpk2bMHz4cJufptO+p4Ig+Bx+EycIgp9jy3dV4gTvQBob7PxgczQFHT8L4q233kLt2rUxbNgw7fJrr72GO+64Q+tJ4Q9JWlqa1oPCUqEZM2bgwIED6NSpU+FvljP7UFjK2XcN8M9Q/SxNmtRseQqI3wS0/9JyxIgv0OIN4MQfQPLJvG2bHwMq9VdmVM4sA6aod8RN2ZhVLV4BiG4Gp5CwB9hk6KWluKMJlaecnzkL1fhZM0HxSWfq4JzPN48xrKQ6wfCamzizFEi7CFQZpsyiOIfV7LnZkgUt6HvKod2mrCrL9OgCaCu2ZmAFQfA//CpOEAQ/RuIE30GW4OyksJEULNNZsmSJziiBge/YsWPxwgsv4Pz585gwYQI6d+6MXr16adf9z3/+gypVqhR4vywH4g+gU2EfIY12Kg+x3Hd0OrCoU9FLXT1BWCmVhTMn9YIS4UXBKFbp5uvomBejWI3ro5+R6yjpicCKGy3Njjp8rfpNPcGphcDC9pZCleW+XBBpzdE0dgZY7Jll5pU9sxW6W4jwon5PWY7HYJM29fZkVU1294IgBC5+FScIgp8icYLvIG7AdnLu3Dnt5G5ok82h4C6B2dSdrwI7LJ1QEV4G6DwdqGgcfeMDLB8OnJip39ZzKRDX07H7y0wD/kchYlYi3X8zUKal/c7MM8oAGYl52zr+ANS8HUWCWd5VNwPHftFvZ1l024+Ldt8OHU8WsPstYPsL6m9jprfr70D5Lq556Oxs7N692yP9W3Xq1BHBKggBjF/GCYLgZ0ic4DtIZtVOSpZ0saNpPpQqVcp1d86MXtOXgG6zVFbSnLR4YNkAYPdU3+tjbfOh5fNZPw7ITHHcwIkmQkXtW+VsVXOhSpyxGLDvfUuhGtNCldi6GzoRLxsMbJtgKVSjmwP9N7pMqJpK8TzxXWVmo1gxs3m/giAEHH4ZJwiCnyFxgu8gYtWBsoHCSgecDct63PIjVGWoKgsu1UC/nWJj63PAqptUmamvEFlZOdKak3gA2DvNs47Ap+brL8e0BIqXR5E4txLY8rR+W1g00PU3x8bUFIXzq4EFLYHThudJqt4I9F0FlKjm8sMoW7YI/ckOwhmrthqsCILgn/h1nCAIfoTECb6BiFUf+HDz8dwWAGt9rOuAKjdY7jv2K7CwjRpz4yvUGQeU66jftus1IOmUY/cXaSixSil87p0OZqeP/+5cF+DkM8CqUUC2YWYYx8ZE2W4MVGT43Pb8H7CkO5B0wrAzSDn5dvnFubNkC4AjH5jpdBf8jsbEGBy2BUEISPw6ThAEP0HiBN9AxKqDfSHuWjWlW1m5cuXc8lh5D1pKZeSavaafWWpydaVZzr6PfKMsmCXOrd/Xb8u4pspTHcGYAU05b9/tr+yxNBqio62jsP+VGW/jPNXGE4HKg+E2UuOB5der7K5RNPM167kYaPqic0ykbISBW6VKldz2eHFxcWJuIghCYMQJguAHSJzgG4hYdfDDTVc+d6xi8nE8MjeNoqLJC0D3OUBYaf2+rDRg0yPAimFqNqu3U7YtUOMO/bbD3wMX1jlBrNppomHMqrIHtmwbOMzWCcC55fptcX2BplbMslwFX8cFrYCTsy33le8BDNgKxPWCJ4iKitJKc92xOuuOxxEEwTcIiDhBEPwAiRO8H/nv5iA0UXF11iY2NhYlSrinZDJfKg9UZjgxrSz3nZgFzG9hKZa8dfZqiGGVe9N4S/OfwqCLrTmp9orV3yyzqo5mG4/NAPa+o98WWQ3o9BMQ7IbxBcys730fWNIVuHbUsDMIaPIi0HMJEFERniQuNhrFwoNd2ivmrqBUEATfIWDiBEHwcVgZ5UpzRIkTioaI1SLA/jR+wF0BszTlyxfRdMdZlKwD9F0N1H/cch97E5deB+x4BcgqeAi6R2EGs+Ez+m0X1wGHf3RfGXDiIct+36r2zfDMJWEvsHasfltwuJo7WtwN5WBpl4CVI4DNj6lSZHOKlQOuWwA0m+we0WwOP4MsVT/yM7DxUWBBOwT/Fo2aEUdd0r/KbEaNGjXc2hsrCILvEDBxgiD4MPwtr1mzpsQJXorMWXUCly5dwqlTp5w205E/Plwt9cpMzcl5wNo7gdQLlvvKd1NZPeN4F2+Bvaqz6wHJZuZKzPoN3geE2Thq4MJaYJGZYVNIcWBUEmu+Cr/tnneALU/ps7TDTtsv6OjIvLCd6n81p+1/gLrj4HJOL1ZCOfmk5b7YrmouL52Y3QWzurumqIWAy9uBzCT9/tKNgYHbkZGZhWPHjiEpybDfQShQq1evLqNqBEEolICKEwTBR8nIyJA4wZ/FamZmJtLTDRmWACItLQ1nzpxBSkpKkUwSKlasiOLFi8ObCUu/gJD1o4Gzf1vuDC8DdPhGjcHxRg59r8S2OY0mqDJhW7h6EJhdR79t5BXbxO6izsCF1XmXa98DtP8CdsGv66pbgGP/02+vead63V0ZuGQkAVufBfZ/ZH1/o+eAZq8CwaFwKyzl5kxXa6NySIdvgVrqPee/u/j4eO27WpR/fTQzYbAofWKCYDsSJwROnMDFPPn/KPgiEif4oVjlzfnP9/Lly847Kh8mKytL+0G252Xlyij/qfPkK6uk0aVLIe7itwja+RKQbaX8t+4DQIu3gLAoeBUUNnQzjt+oL58dtBsoWbvw26dfBX41zLIberDwETF0651p6F3qMQ+oNMCeowf2faB6bc2Jbgb0XQOERsJlXNwArLlDldhaW6Do+IPqb/YEWRnAlmeAfe9Z7ouoDAw9BISEWywuXbx4Uct28DtrK9HR0dqICHfPUBQEX0bihMCLE1xZVikI7kDiBD8Sq6dPn9aEKrMMdMT0hX+i7v4xshYMm35wfOnHh/D5sIzy3LlzWuBeMfSwyvQlHbO8comaKttXoTu8inMrgCXd9Ns4V7bbzMJvy6/LL5FAptnKOIViuQ4F3+7fT4END+rHAw0/B4TY0dB/fhWwpId+NAydmvtvsk1oOwL7UXe+rmbTWluUiOsDdPjac6XfLAFefZt6bazR6j2gwWP53pzfzStXrmifaZ6MGQ8GWvy/RnHKURShoW7OGguCHyBxQmDFCXwuLHlmFrhatWo+c9yCYA2JEzxPkSIv/pM1CVV3D8D2NczXBHz9H7cpq0TBWr5ee4QM3Aqsu9fS6fbaYWBpD6DeI0CLN4FQL3EsLN8VqDoCOD4jb9uJP4AzSwsfscL3jr2mScftG19jHFlTabB9QjXpJLBypOUMU2Y0XSVUmUVdfQcQv8FyH52VmTmv96BbZ6dauCHzc5d+OX8zrDr3FXgXDAC56MKT6Xtq+q7ye+rr31VB8DQSJwRmnMB+WgpW9gBStAqCryJxgucpUpRp6lFl5kEoGFPg6+s/QCZM77n2GQiPAbr8CrT91HI8DNn/ITCvucpoegstp6ryX3PYj2lLoYHRETi1EEdgzqI19vfa4wJMY6h/hqpSYnMaPw9UGQKXlErv+wiY39K6UC3TFhiwBaj/sGeEKkux192nxLtRqAaFKkMl0uApu0ujfTGLIQjejMQJgRknmMp/uVghCP6ExAnuxymRpj/8YxWK+J7zct37NddVxHaxvEHiQWBJd2DT48qox9Owx7S+ofczfpNldtgaxYzjawrJrJ6crS+hpaCv1N924cjs5qXN+u1xvYGmk+F0OIro7/7ApkeAzGT9vqAQoOnLQN9VQKn68AinFgJzmwAHv7Bedt5nJdD7HzUXmH3TgiB4BRInBBbyfguC4CxkzqoDHD16FPXq1UNqaip8kXvvvRdffGGnC609M1l7LVO9ghzroiMb2DcNmN8i/x5Dd9L4BVXSa872icqwpyCKx9onVo0lwBX7214Sve0F4IShlzaqDtD5v86dYZU7phgAACLkSURBVMr5pMymzmkEnFlsuZ/ilL25TV8Cgj1Q0pUaD6wZAyzrb70/uvotAMvRy7UHipVVotXbzL0EQQgYJE4QBEFwDi5xC+EswwsXrMzhdCIcHcHG/cKIisoLWJOTkzWDFFP/RNeuXTF//nxtBZB9mCz9K1GiBHr16oX3339f67mwxqRJk/DII4/4xHzFMWPGaP1406ZNy932wgsvoFOnThg9erRrngNFFE1tKg1U8zjNx7WQq/8Ci7sCDR4Hmr0GhHrIWTW8NNBsMrDhAX2f5uHvgdp3OacMmCWrpxc5VgJ86Ftg9xT9trBooMccJcicxeUdqqz24lrr++s9DLSY6lq34cLEPs2pUs5a7qPob/MxUHO0fmyPpz5TgiDYhMQJAR4nCIIgeEqs8geofv36RZojZgucMbZv375CBWtiYmLu3z169MANN9yAxx6zdAddvXo1WrRooZkGjRw5UrvOTz/9ZHE9jrv4/fff8d57VsZkOKG3x2hEYG1bUalRo4aWGZ4xYwZuu+02uIxS9YDey1U2lRnCLPNMdDaw913g5Byg7ceqrNUTcNYp54Ym7MrbtuNloMatVjLDDpQBn5qvf97sqaw8uPDjOrccWG8wB+Jtu85wXgluRrJy+d39lqVxk2nsC92cK/aBR0g+C2x8WG+EZU6FnmpObWFjgwRB8CokTnAcv4sTBEEQ3F0GzIyqq4Uq4WO4IntLZ2OK1e3bt1vdv3DhQjRs2BBlypTRzWJitrV27dooWbIkmjZtis2bVY/h1atXcd9992lDvHm6//77ce3aNW3fkSNHtKzuN998gzp16qBKlSpYtmyZtsL56aefakKcK5tkyZIlaNeunbavcePG+PPPP3W22h988AEaNGigPX7dunWxYMECbRsF9yeffKJlmHk7E8wem9+Hy2CWteGTwICtQNn2lvuv7gf+6gOsHKX6Jd1NcCjQ6l39Njr9ctSMM8qAjSXAdBsOV86z+XL1ALB8mBobY07bTwp3K7aVM38B85oBu96wLlRr3QUM2uEZoUqTq8M/AHMbWReqHPvT7nOg5xIRqoLgg0icIHGCIAiCrcjQQANnzpzBL7/8glatWll9wbZu3aqJQnOee+45LF++XBOIFJ379+/XMr9k/PjxmijduXOnZks/YsQIPP744/j8889zb0/RuHHjRs09b/369ZrA3bZtG/bu3avtp3CmgP7tt9+07DCzwIMGDdKuyyz2Rx99pJXv/Prrr9pxHz9+XBPE/fv310SzsbyHNGrUCD/++CPcRukGQJ9VwN53gO2TDFlWLrX/CpyaBzR5Eaj/OBDixkHiFfuqkmU+vgmKOGZdw0oWnlnNrwyYs1hPzbWvBDjtEvDPYCAtXr+9wRNAnXtRZOhMvOUpVWJsjZJ1gXafARWug8fmpq5/ADg93/p+jvxp96nn5roKghDwSJwgCILgPsRgKQf2r8bExGjZS2ZI8yvzvXTpEkqVKpV7mQL0s88+w7vvvqtlNJkppYCsXr26lvFkZvPNN9/U5tCyz/aNN97A999/rxsA/tJLL2mC0jQOhvumTJmiXeaJ98+ekp49e2p9tV26dMHgwYM1UU2YhX355ZfRunVr7fGZkWX2tyD4HPhc3AqzrI2eAQZsBsq2sz6iZetzwPxmwJkl7j22lm+zzjbvcuoFVaZsa2bV2sib04uBjLwydO3+K1+f/zEwk8oMM/tmjQKNM02LnK38CZjTwLpQZYlx44nKzdkTQjUtQb33s+tbF6rs0e30M9D9TxGqgiB4BIkTBEEQ3I9kVnNYsWKF1rNaGBS0XFU1cf78eSQlJWlC1Qj3sUSYvR8matWqpbkIm5cwG/tuWcpL8WqCmdm//vpLKxc2wUHbJtFM10Frj18QV65c0Z6LRyjdCOizGjj4ObB1ApCeYDi4fao0uNpIVaLrjiwaj6n6zcDR6Xnb9rwD1H0IKF5Of13OlTWHZbTMohpNfczvi3CkT0SF/MXkxkcsRXp0M6Dzz0Vz/r2yH9j0KHB6ofX9ZTuo3s/oJnA7FOgHvgB2vKQWCKzB96X1+5bGVoIgCG5E4gRBEAT3I5lVO6GgNZXnEjoGM/t54MABi+tyH0t7KTZN8G866zHLmvsmBOvfBuPlqlWrauXEly9fzj3ROIoZVcIsrrXHt3ZfJnbv3m2TOHcZFF+cgzl4H1DjduvXYWkwM4G7pwKZaa4/piaTgCCz1yvjKrD7Tes9k0bSrxguJwInZum3UXznx74PgAOf6bcVjwO6z7FeimzruJdNjwFzG1sXqqEllZMu56a6W6hSnJ+YrfpmNz5kXahGVAS6zQI6TxehKgiCzyBxgiAIgvMQsWonffv2xZ49e3JLaFl2y7mlTz75pCYYWRZMl2JmOykUb731Vs0CPj4+XnMSfv7553HHHXfkKyKtMW7cOC2r+vfffyMzM1PLzK5Zs0Y7DtP+V155Reun5ePTadG0r0KFCjh06JC23RxmallK7HGYaez0A9DrL6CUvhfY7aXB7KvlvE5z9n8MXDtuv1ilUM1MyrscFAJUv8n6456cC2x5Qr+NTsQUaiWqwqFsJcXv7DrAvvetGyhVuQEYvAeo96BeoLuD+M3AX72A5UOBK3kLP7qS5HqPAIN2A1WGuvfYBEEQiojECYIgCM5DxKqdMCM6bNgw3VibqVOnau66vXv31kpzaYZEcUo4r5VlwDQ0ohsvDZjY32oPLVu2xPTp0zFx4kQtW1u5cmW8+OKLmmgljz76KB544AGMGjVKKyHmcVCwknvuuQcnT57U3IubNWumbaOQZnaYx+k1sE9ywDag+evWR8aYSoPZ02kUj67MrtIIiuNdzAkuBgQbxgRkGMTqEcPYo7g+1rODnHG66mYgO6+HWaPDd0A5K329BcEFCY4CmtcU2DRemTUZiagEdP0d6DYTiKwMt8L3bc2dwII2wNm/rV+HInrQLqDNB4W7JguCIHghEicIgiA4j6BsY8rNzvExhw8fRs2aNXPdb71tfporYCkvV0537Njhk8OyOUqnbdu2WkbYme+900g8rPo3jU66JkIigaaTXOcavHo0cOSHvMsUpkMOACXMPmu/xepLV5kZNhkTpZwHZlYEsjPz9nf8AahpKHdOPgMsbA8kqYWFXJq9CjSZaN8xU/RufiL/7DOfQ/3H1P1aywy7kmvHlFnVgc+BzGTr1ynTBmj5f0CF7u49NkEQXIrECYEZJ7g0RhAEIaBwulg1CVZXzEA1rlx6QqgKbvoh0noa/1DGQPnNXy1VH2jzERDX27mPfeVfYG5Dvdis+yDQ9uO8y3/WBhIP5V3u9gdQ5fq80uGND+ftC4kAhp/V956mXwWW9AAuqXm8udS4TQnbIDNn4oJIPgvsmAQc/NIyO2vuJkyjqlL2mXAVmYTdwO63VJbZWikyiawKNH8TqHGL+8uRBUFwORInBCYiVgVB8Go3YIpIEZJCkaBYqzpMlc+yDHfve0BWmvXSYG20yxtAdFPnvOgUdTR9Ovxd3jaKwcbP55XOGrOT5j2rxhJgilhzoUqzqBU3WgrVcp2A9l/aJlTpPrx3mpoHSyMoq8+jAdDqPaBSf7iVC2uB3VMsDaaM5k58PeuPt3RRFgTB75E4QRAEQbAFSWUI3k1YFNBiCjB4L1AtH4OiU+zTbK76Ia8ddc7jNnlRmSKZoFBmljD3uEpZzgklzLZeWGOZLTXB7Oe6u4Ezi/XXKVFT9ZFa69c1ZpyP/gLMaQhsm2BdqIaVBlpNUzNT3SVUeVwXN6ls8aKO+QtVvqbMUg89ADR+ToSqIAiCIAiCkC8yZ1XwDaJqAl3+C5wfr3ozL641XCEbOPw9cPS/Sgw1fsFyPqo9lKwN1BwNHMqbbcu5sFkNn0VKUDSS4+5Hapm7kRUcgaDgEISEVUPxy5cRcWIuwhGEIB4PKVYWqNgv7z44V/bIj/rHKlYOuG5h4eNZLm4ANj8OnF9lfT/LaGvfBzSbDBSPhSuhs/XPP/+szeu98cYb0aBBAzX+JiVvBrEOlkLXvgdo+CRQorpLj00QBEEQPEVWVpZWBp2cnKwZYfIyJ0eEhIRobVMRERHaWENuEwTBQz2rgv/j0feeH9ljv6iRNtfyZthalJk2fBpo8LjKzjoCs6Sz6yM7OwNJpbsjvtozSAgqvE86JCgDZa4tR5mjUxFWfSjQTs3Dxd73gc2PGa4cCfT6u2DnX/bsWhO55pTvDrSeBsS4fnbumTNn0LRpU+0HmC7TBw8exJw5czBw4EDg8A/AmtF5Vw6PAeo9rEbRuFhAC4LgfUicEJgE2vvOUDopKUmbBJGQkFNpVQAUrvz95CkszDBdQBAEHZJZFXwPrkZyZil7Qfd9qHpajXNOWR5L46F/PwIavwjUuU85B7Nf9NivQE2z0tz8iKqF5Iav42RoZ6SgtM2Hl5kdivORPXG+YU/ElAxDXGYmQk78prKiuucRAnSdkb9QTT4N7JoCHPhMjdCxeoy1gRZvAlVH2G7K5ChZGUBwKD788EPNQG3JkiXo2LGjNsv35ZdfVmK18pC8ETkNngTq3Kvv1xUEQRAEP4IZVI4ItGcKRmZmJs6fP6+dYmJiEBcXpwlYQRAsEbEq+C7s72z0NFBrDLDjFeDAf/QOviTlHLDpEWDfe2okTHoCsPFRVeZbrkOBq6T8ETkXOrBIh3jpajqu/rsflU/ORElTabAJmilVGmB5I4602T1VPR8aKVmDYpAzYWvfZTnz1dlZbBomHfpKZUhjWmDr1q3aLs7tjYyMRO3atbF9+3Yt0xrM2ah0M642EgjxvXENgiAIgmALuXHCuXNFesEuXbqEq1evonLlyihZUhZ3BcGIiFXB92F5aduPgHoPAVueUYZL1kp6VzObyuxjNrDqFmDAFoDiygBFF8cvJSYmOuXwMjIycbTCC6gUVgllTryrNjZ/XYls4xiaPW8B/36a/zxSltU2ek4Jx9BIuAwKZpYdH/wauLJHbeNc25xVZBIaGpp7npaWpq0UBwcHW86TFQRBEAQ/wvlxQgaOHj2KSpUqaaXBgiDkIWJV8B9KNwR6zFYGRNueB84tt3KlnOwme13X3QN0+VVXPuvsHyBzTpUZq2Uby4RfARpNyNuRcl6J1P2fAJlJ1m/M3lb23zZ8yqrAdkoG9cpe5eJ78k+VTTVmgpOOA9GNUatWLfz9999a2VN0dLR2zjEU0ncjCIIg+DsujRNOndLORbAKgqvF6rVjQOoFuBQ6qJYo3OzGFfTv3x+PPvqo6tFzM1FRUVizZo1mcOMqfvrpJ8ybN08790liOwO9lqnxMNteAOI3Wr/e8d+A/R8D9R/O3XT27FmX/ACZOFX6VhSvUR2RFMgpF4A9bwP7P8pfpLLEt8445W4cEef8HtQLq4ETfyqRmnig4OvzupX647777sNXX32Fxx57DPXr19cMl15//XXnHpsgCP6NxAkuQ+IE1+LyOOHUKc2Uim02giC4QqzyB2h2fSDL9kZzhwguDgzZZ5Ng7dGjhybwzDM/b731Fh588EGMGTNGG8FBG3E2tzP4ZuDdp08fq/fFjBJ7FDwhVIkr/0GauOWWWzTDnC1btqBly5bwSSgGK/YF4voAJ/4ANo1XmUEjW54AyrYFyrXHtWvXtJEsrub4yVOom/ITgtlHm5Hf+xkE1LwDaPqyGtvjLNITgdMLVfb01Fwg1cbnG1UHCC+jzYlt164d/vzzT7z//vtYv3699l16/HGDeZQgCEJ+SJzgUiROcB1uixOOH0fdunVVa40gBDjO/xYwo+pqoUr4GHZkb6dOnar9AzedKFRN8G9u4z+gm266CcOGDcPly5et3s/HH3+MsWPHwt2kp6e77bH4z/G2227DJ598Ap+HopWCNT+joqx0YOVIZKdcwIkTJ9z2Xp5Ljc1fqFYZBgzcDnT8ruhCNe0ycGo+sG0isOQ64LeywMoRaiZtYUI1NAqocYfKUg/ZDzR4TM1yBTBkyBDNDXjDhg14+umnc/tXBUEQCkXiBJcgcYLrDZXcGicU0bhJEPwFWbIxgwH3uHHjtJUzzo609s9jwYIF6NmzZ+42zhHr3bs3SpcurfUYdO7cWZu1RWrUqKFlaVu1aoVSpUqhX79+uf0IR44c0QZCm4tillUy02u+/5tvvkGdOnVQpUoVbTu3mdxY+Y/znXfe0dxY+dgsTz506FDu/Zlfl0ybNk3LMptu++yzz2p26Ty2evXqabMyTfTq1QuzZ8+GXxC/CYjrBVS7SbnUcsxL1RuBaqOA6jcDsV1x5dgqt/7QX4zsgcxg8xKfIHVsA7YB3X4Hops41neaeBg4/COw/n5gblNgRhlg2UBg1+vAuWVAVlrB9xFRGaj7ANBjPnDjBaDT90CF7q4fiyMIguADSJzgp3GCDVy5csW9ccLFi5pxoSAEOpIOMYP/hD799FPNOpzlF0b+/fdfTYiyVNjECy+8oInJ+fPna5eZaTLPMn355ZfaPhrQPPDAA7j99tvx119/2fwGsdxy48aNWpmykR9++AHvvvuuJqB5vDwWZry2bdtWaKZr8eLFWvnz5s2bNfc5mgWYzwhr1KiR1pdx+vRpVKxYET4NxRZPBXCRIj/Net8oX5eRI0dixIgRuPPOO3O3jx8/XusrYdaebrgffPAB5s6dqy120IL+o48+0s6tkY0gXK76BMoefV0JZvakRje273nRmIlOvfGblanUhVVqNqu9xLQAKg8FqgwFYlqJMBUEQcgHiRP8NE6wgYLKf10SJ2RnawmNsmXLuuT5CIKvEDBidcKECVofpgk6mJYoUUL7mwL122+/1QRhgwYNtJVCZhutzcJiw7v54Gb2wfIfNTOhFIydOnXS3YYClfdJ2NvHTKY9ZSQvvfSS5rhqDYpVGj2ZzJbeeOMNfPHFF1ofofE4jPC4+c91165diI2N1cS0Oabnz+fs7z9C/AExZcOtwR8aZsjvvfdedO3aVXPD5SLCzp078fvvv2vXmThxIlJTU/G///1Pez2ZcS9sXtqlsqNQtsltQGn1+cg3W8pe24Q9Spgm7FbnPNnab2okKBSocF2OQB0ClKju2P0IgiD4ERIn6JE4wQvihEuXRKwKAU/AlAG/+eab2gqV6WQSqiZByW3sD1i+fDm6d7eehYuJidH+WZmXZbz99tvaqhhLgVn2S0FMW3MT1avnCYEKFSqgWLFimlC2FaOINIeil49pgvfNLKktYvi6667DK6+8ghdffBHlypXDjTfeqP3jNC93MT1nf6egHyATzZo104yn+GPD92/KlCnae83y7wMHDmDZsmWYPHkyypcvr5Vf84fK2oKHOSkZQcgqWU+ZHiXsBc4sAQ5+A+x4FVh9B7CgDfBrSWBWdWBZf2Dz48DBL4DzK+0TqsHFgNguQKNnge6zVXlvz0XKBVmEqiAIgobECXokTvCCOCElRRdTCkIgEjBi1Rkwc8rM6r59+3K38Z8OjYg4zJkZ2f/85z+YOXNm7n5uN0ExzFU1iltayxv/ATJDa6QgJzj2sTKja77yx55YU38rBXlB909jqbVr12olwBS6zNKa2L17tyau/T2rSpKTk2263kMPPaRdlz9Gffv21VZPCcu0uUjw4Ycfolu3bhg0aBC+/vprm+4zZdFAJUjnNgT+6gOsuwvYMQk48qPqtc245thYpyrXAy3fBvqsBkYmAH1WAC2mAJUHA+Gl7b9PQRAEoVAkTvBPPBonmJVeC0IgImLVDlgSQ5Mkjq8x8csvv2hij70FLNdlibB5v+hnn32miVv+86KhEf9JUUwym8ms6XfffaetmvE+OdvUHtj/yn4HCkuKYK7mUQhztAihsRNLhTMyMjSjJf5tgr21q1ev1gRuRESEJmzNj5t9tfxnGgjY+kPA97958+ZaWc7111+fuz0hIUEz5OJCBnuBOdKFM2ptMZ5IibDsjbYLZk2jmwG17wbafw0M3gcMPwd0+wNo+BQQ2xEIKVa0xxAEQRBsQuIE/8SjcYKIVSHAEbFqJ1w1Y3+riU2bNmn9ocyUduzYEXfffTeGDh2au/+uu+7SVtiYpWRZCP85meCqGt1+WSJCUXvzzTfbdSyjR4/GI488gsGDB2u9sDRW4j8+k+jkCh7ny1JEUyibN/2zzJeZVTbu87bMyPKfJ6F45nHyuQYCtpbYrFu3DosWLdIMFNgfbHIFNPUxP/zww1qGmoZbN9xwg1byU+hjh8fadpBhpYCy7YFaY4AWU4FufwJD/gVGXQMGbgPafwnUHguUqicGSYIgCB5E4gT/w6NxgpQBCwFOUDZTgg7C1R72OdasWVNrLvfWYd/OhtlVjpkZMGBAgddjPynHxfAfki9Bl2C61ZkLa5veex+Fq52FlfjQuW/48OG4//77tcWBW2+9VRthxH5nGlrdd999Wraaq6qmhQKWaHO0UEHEJS9BuX8fVxfCywCRVYDIqupzXaohULqhOo+oJCJUEASfQ+KEwIwT/ClG8HicEBenVeMJQqDifDdgBtkUkRz67UrYl+cBoUoWLlwIf4b/YHkKFArqCzZBJ2fOsx02bJh2+bXXXsMdd9yh/RC1bt1aK+mmqzR/lGhwNWvWLG1Bo9DHrjwAqD8IiKwMhJrPXRUEQfBTJE7weSROcGOcYEOMIgj+TKjLfog8JCQFwV646ssV0fxYsWIFlixZojPO4qzdsWPHarNtp0+frq2Q0uWvc+fOKFOmjNZPzJXVQh87uirrg+RNEwQhsJA4QfAhPBon+EFmWhC8qwxYCAj86b3n2CJ7Zt86Ew5Vl1VTQRD8FX/6rRAC932XOEEQPIfUFggBD40PPAF/wEWoCoIgCIJ3I3GCIHgOEatCwBMeHu6RH6KYmJiAf+0FQRAEwduROEEQPIeIVUEAtBE+7iQoKEgbKSQIgiAIgvcjcYIgeAYRq4IAoFSpUrl28u760ePMNUEQBEEQvB+JEwTBM4hYFYScTGeVKlXc8lpQFJcvX15ed0EQBEHwESROEAR/EqsZGXnnFy5Ynkxcvmy5LzVV7ePwZeO+K1fUvqwsIDERniQzMxPNmjXDzp07Hbo9B2l36tQJ7oTzvMaMGaP9ffXqVW0e2AXz9yPAKVGihFvKfKpWrSrGSoIgBDYSJxSKxAneh8QJguAPc1YpIhctAuLilPBcskS/n8ONb7hB/f3XX0qwmtOuHcAM17//Ajt26PdVrAh07KhE64YNwIMPAlFRhR5Sjx49sGbNGl2ZJ4c3P/jgg5p4++677zB79mzdvCv2E/7xxx/aba3x/fffo27dumjSpAkc4bbbbtNOnqJkyZIYPXo0Xn/9dbz33nseOw5vIy4uDqmpqUh00WJIpUqVPOYqKAiC4BVInGATEid4JxInCIKvi9WUFGDTJjblARER6twI9xOKR+N+zrs8exZIS7Pcl5mpbkuxmpCgHssGsUqmTp2qZRatwWza888/j4EDB9qc8fr444/x8ssvw5e588470aJFC02wioDKK/OpVq0ajh075nTBSqHKQeCCIAgBjcQJPoPECZZInCAI/tSzSgMZiknjyQQzTMZ9puxneLjlPopf7aide9g33XQTkpKS8OOPP9p0/VOnTmHLli3o3r177jYKV2Zmx40bh9KlS2uDsJctW6ZlZ+vUqaONKXnhhRdyr//tt99qQtHEu+++q4kkZjxr1KiBL7/8UtvOodq9e/fW7pNCp3PnztqxEoqphx9+WLsdeyCZKU2giM9h+fLlaNq0KaKiojB8+HCt9NccPg6F+j///FOEV8//4IJF9erVndZXGhoaqr3WIlQFQRAMSJwgcYIPInGCILgPMVjKMbx59dVXMWnSJK0EtDC2bt2KypUra8LSnEWLFqFfv36Ij4/HHXfcgdtvvx2zZs3Ctm3bsGrVKrzzzjvYvHmzxf3t378fEydO1G5PQblu3Tq0Yzk0oAlcil32lp49exZvv/22Jn7IXXfdpT3W9u3bNVGbnp6uiVdy6dIlDB06VLt8+fJljB071qoYb9SokfZ8BMuVU4pV9vUWL17c4ZeHixQsF+eCgSAIguCbSJwgcYIRiRMEwT0EjFidMGGC1odqOl27dk23/+abb9YyX59++mmh90UhSAtzI61bt9YymBxJwvs7efIknnvuOa0hn6KQhkzWxCqvn52djV27diE5ORkVKlTQrmv6gTx9+jSOHDmi/U1TJg6nPn/+PH777TetHJnPh48xefJk/O9//9PMn+bMmaOVnTLTS3E7ZMgQ9OzZ0+Kx+Tz4fATrREREaIKVmXJmt22B72dsbCzq16+vLWrIiBpBEATvR+IEiRMcQeIEQfA1scpS3Xr18sp5XUGJEsCQIdb7YfPhzTff1DKMphPFnXGFbMqUKVr/prFc1lq27IrJmdgMikwTph5Q4zZrfZAUQzR5+uijj7Tr9+3bNzfbyUwqBQ9LgVlKynLjrKwsTbzynCLKJMDbtm2rlaacOXNGK1VmKas5xsuEz4PPR8gffjb4eaGLLxcdatWqhYoVK2qLG3zteCpXrpw2+oZZ1AYNGmjvozvntgqCIPgMEidoSJzgP0icIAi+ZLBEEUiHXJOJkisIClJimOdOhCKxefPmmkAsCPaaMmtK4ems8s5Ro0ZpJ2ZWWY7MMuIdO3ZopaiffPKJdh1e7tOnj9aHyt5VClOKUmvmSMyqHj16VLeNpkHGPszdu3drrsiCbfA15+sthlSCIAgOInGCQ0ic4BtInCAI3p5ZTU8Hzp9Xzr2ugjNYV65UjsBOhtnVadOmIYVuhflAIUjB6ixjon379mHx4sWaUGWJLwWwqS/1l19+0UQmy4SZPWVJKffROv2GG27QelJNs1KZUZ05c6b296BBgzRB/cUXXyAjIwNz587FXxwVZAbFLG/brVs3pzwPQRAEQSgUiRPsRuIEQRACFeeLVQrIFSuUYGXJq+lkEn9ZWfrtppMJOt0a9/GHjfCcl1mme+5c3nYn0qZNGwwYMKBQo6WHHnoI33zzjVMeMy0tDS+++KJWOkp3XopKugWTTZs2aX2qFLAdO3bE3XffrRknEV7HVP7L3tOuXbtq1ycsUaW50/vvv69dh+7CxrmunBXLObPGkmhBEARBcBkSJ9iNxAmCIAQqQdlM2TkIs490oWXfZK5jKsXmRx9ZZj2rVgXats0bBm5k+HB1vmwZEB+v39emDVCtGnDwILBtm9rGftX77rN5zqqzoYlRy5YtMX36dDRu3Bi+Bvtyefxr1qzRzICc8t4LgiAIQmG/FRIn+H2cIDGCIAjeK1ZNP0Q5s0BzKVYM4KgXlgdbc58tV06dX74MZGTo9/F2vD2zs6YsLB9PxoF4DPkhEgRBEBz+rZA4wa+RGEEQBO81WCI0/LFi+pM7ANwkTK0RHZ3/Pv7QSRZPEARBEHwbiRMEQRAEGwiYOauCIAiCIAiCIAiC7yBiVRAEQRAEQRAEQfBPsVqEtlfBR5H3XBAEQZDfDEFiBEEQvFashoWFaedJRjMlwe8xveemz4AgCIIgGJE4ITDhqB3C2fCCIAgeM1jiPyHO8DzHmaeaX0IkgoKCinRAgvdnVClU+Z7zvZcfIkEQBCE/JE4IPLKysnD+/HktJgwNdY2PpyAIgUOR/4vExcVp5ybBKgQGFKqm914QBEEQ8kPihMAjODgY1apVkwSGIAienbNqTmZmJtLT051xV4IPlHVJRlUQBEGwB4kTAofw8HBNsAqCIHiNWBUEQRAEQRAEQRAEZyHLXoIgCIIgCIIgCILXIWJVEARBEARBEARB8DpErAqCIAiCIAiCIAheh4hVQRAEQRAEQRAEwesQsSoIgiAIgiAIgiB4HSJWBUEQBEEQBEEQBK9DxKogCIIgCIIgCILgdYhYFQRBEARBEARBELwOEauCIAiCIAiCIAiC1yFiVRAEQRAEQRAEQfA6RKwKgiAIgiAIgiAIXoeIVUEQBEEQBEEQBMHrELEqCIIgCIIgCIIgwNv4fzFZ5zRlAR83AAAAAElFTkSuQmCC",
+      "text/plain": [
+       "<Figure size 1100x450 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Metric           CDNOTS     +LUCID\n",
+      "Precision         0.111      0.750\n",
+      "TPR               1.000      1.000\n",
+      "F1                0.200      0.857\n",
+      "SHD              24.000      1.000\n"
+     ]
+    }
+   ],
+   "source": [
+    "fig, axes = plt.subplots(1, 2, figsize=(11, 4.5))\n",
+    "_, _, pos_l = tp.compare_graphs(\n",
+    "    graph_true=true_l, graph_discovered=g_plain, var_names=names_l,\n",
+    "    node_layout=\"circular\", node_size=0.18, arrow_linewidth=3,\n",
+    "    link_label_fontsize=7, title=\"CDNOTS alone (confounded)\",\n",
+    "    legend_loc=\"lower left\", tp_color=\"black\", fig_ax=(fig, axes[0]),\n",
+    "    return_pos=True, node_label_size=9,\n",
+    ")\n",
+    "tp.compare_graphs(\n",
+    "    graph_true=true_l, graph_discovered=g_lucid, var_names=names_l,\n",
+    "    node_size=0.18, arrow_linewidth=3, link_label_fontsize=7,\n",
+    "    title=\"After .deconfound() (LUCID)\", legend_loc=\"lower left\",\n",
+    "    tp_color=\"black\", fig_ax=(fig, axes[1]), node_pos=pos_l, node_label_size=9,\n",
+    ")\n",
+    "plt.tight_layout()\n",
+    "plt.show()\n",
+    "\n",
+    "m_plain = evaluate_graph(g_plain, true_l)\n",
+    "m_lucid = evaluate_graph(g_lucid, true_l)\n",
+    "print(f\"{'Metric':<12} {'CDNOTS':>10} {'+LUCID':>10}\")\n",
+    "for k in [\"Precision\", \"TPR\", \"F1\", \"SHD\"]:\n",
+    "    print(f\"{k:<12} {m_plain[k]:>10.3f} {m_lucid[k]:>10.3f}\")\n",
+    "\n",
+    "# Recall is unchanged: the correction removed false positives without dropping a\n",
+    "# true edge. It rewrites the lag-0 slice, so the surviving lag-1 false positive\n",
+    "# is out of its reach -- deconfounding is not a general-purpose graph cleaner.\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "---"
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "014237be",
    "metadata": {},
    "source": [
-    "<a id=\"5-plotting\"></a>\n",
-    "# 5. Plotting\n",
+    "<a id=\"6-plotting\"></a>\n",
+    "# 6. Plotting\n",
     "\n",
     "```python\n",
     "import causalts.plotting as tp\n",
@@ -1884,8 +2063,8 @@
   },
   {
    "cell_type": "code",
-   "metadata": {},
    "execution_count": 3,
+   "metadata": {},
    "outputs": [
     {
      "data": {
@@ -1944,8 +2123,8 @@
    "id": "7f46f483",
    "metadata": {},
    "source": [
-    "<a id=\"6-synthetic-data\"></a>\n",
-    "# 6. Synthetic Data\n",
+    "<a id=\"7-synthetic-data\"></a>\n",
+    "# 7. Synthetic Data\n",
     "\n",
     "```python\n",
     "from causalts.synthetic_data.synthetic_datasets import (\n",
@@ -2104,8 +2283,8 @@
    "id": "eac2e028",
    "metadata": {},
    "source": [
-    "<a id=\"7-evaluation\"></a>\n",
-    "# 7. Evaluation\n",
+    "<a id=\"8-evaluation\"></a>\n",
+    "# 8. Evaluation\n",
     "\n",
     "```python\n",
     "from causalts.utils import evaluate_graph\n",
@@ -2190,8 +2369,8 @@
    "metadata": {},
    "source": [
     "\n",
-    "<a id=\"8-effect-estimation\"></a>\n",
-    "# 8. Effect Estimation (DoWhy)\n",
+    "<a id=\"9-effect-estimation\"></a>\n",
+    "# 9. Effect Estimation (DoWhy)\n",
     "\n",
     "```python\n",
     "from causalts.effects import (\n",
@@ -2202,12 +2381,11 @@
     "\n",
     "Optional integration with [DoWhy](https://www.pywhy.org/dowhy/) for causal effect estimation, counterfactual analysis, and root cause attribution. Requires `pip install dowhy>=0.11` (or `pip install causalts[dowhy]`).\n",
     "\n",
-    "**Two usage modes:**\n",
-    "\n",
-    "| Algorithm | How to access |\n",
-    "|---|---|\n",
-    "| `run_cdnots` / `run_cdnots_plus` / `SYPI` | Methods bound automatically: `cg.estimate_effect(...)` |\n",
-    "| `run_cdnots_gated` / `run_stability_selection` | `cg = wrap_graph(G_hat, df)` then `cg.estimate_effect(...)` |\n",
+    "Every built-in algorithm (`run_cdnots`, `run_cdnots_plus`, `SYPI`, `run_cdnots_gated`,\n",
+    "`run_stability_selection`, `run_cedar`, `run_lucid`, ...) returns a `CausalResult`\n",
+    "subclass with these methods bound automatically: `res.estimate_effect(...)`.\n",
+    "`wrap_graph` is only needed for a **third-party algorithm that returns a plain\n",
+    "array** instead of a result object.\n",
     "\n",
     "---\n",
     "\n",
@@ -2385,8 +2563,8 @@
    "source": [
     "---\n",
     "\n",
-    "<a id=\"9-tigramite-effects\"></a>\n",
-    "# 9. Effect Estimation (Tigramite)\n",
+    "<a id=\"10-tigramite-effects\"></a>\n",
+    "# 10. Effect Estimation (Tigramite)\n",
     "\n",
     "```python\n",
     "from causalts.effects.tigramite_effects import TigramiteEffects, pathwise_effects\n",
@@ -2577,4 +2755,4 @@
  },
  "nbformat": 4,
  "nbformat_minor": 4
-}
\ No newline at end of file
+}
diff --git a/llms.txt b/llms.txt
index 72291da..5a25c8d 100644
--- a/llms.txt
+++ b/llms.txt
@@ -1,6 +1,6 @@
 # Causal-TS
 
-> A Python framework for causal discovery in nonstationary time series data. Implements CDNOTS, CEDAR, and GRACE algorithms with GPU acceleration via PyTorch. Install with `pip install causalts`.
+> A Python framework for causal discovery in nonstationary time series data. Implements CDNOTS, CEDAR, GRACE, and LUCID algorithms with GPU acceleration via PyTorch. Install with `pip install causalts`.
 
 ## Algorithms
 
@@ -8,6 +8,7 @@
 - **CEDAR** — Causal Edge Discovery for AutoRegressive processes. Uses lag selection (distance correlation) followed by pairwise CI testing. Most scalable algorithm (linear in d). Includes MCI pruning.
 - **GRACE** — Hybrid method: CDNOTS skeleton + neural gated refinement with L0 regularization (Hard Concrete gates). Best for high-dimensional data (d >= 20). Automatically prunes false positives.
 - **GRACE-SS** — GRACE with stability selection. Sweeps L0 penalties and keeps edges that appear consistently. Experimental — not suitable for large dimensions, use `run_cdnots_gated()` (GRACE) instead for high-d problems.
+- **LUCID** — Not a discovery algorithm but a *correction* applied to a discovered graph, for when the causal-sufficiency assumption fails (unobserved common causes). Infers from the VAR-residual spectrum whether latent confounding is **sparse** (few affected variables) or **pervasive** (a factor loading on everything), then applies the matching correction — the two need opposite treatments and the wrong one is damaging. Composes with any engine via `res.deconfound()`.
 
 ## CLI Usage
 
@@ -29,6 +30,11 @@ causal-ts ci-test-info
 causal-ts -s 42 discover data.csv -a grace --max-lag 3 --gate-threshold 0.5
 causal-ts -s 42 discover data.csv -a grace-ss --max-lag 3 --stability-threshold 0.6  # experimental
 
+# Correct a discovered graph for latent confounders (LUCID)
+# GRAPH is the estimated_graph.npy that `discover` saved; --data is the same series.
+causal-ts deconfound estimated_graph.npy --data data.csv
+causal-ts deconfound estimated_graph.npy --data data.csv --strategy tetrad  # fixed comparator
+
 # Evaluate discovered graph against ground truth
 causal-ts evaluate ground_truth.npy discovered_graph.npy
 
@@ -125,16 +131,19 @@ result = run_cedar(
 from causalts.grace import run_cdnots_gated, run_stability_selection
 
 # Single-shot gated refinement
-G_hat, gate_values, info = run_cdnots_gated(
+res = run_cdnots_gated(
     df=df,
     max_lag=3,
     gate_threshold=0.5,
     device="cpu",       # or "cuda", "mps"
     model_seed=42,
 )
+res.cg_tig        # binary numpy array shape (n_vars, n_vars, max_lag+1)
+res.gate_values   # learned Hard-Concrete gate values
+res.skeleton      # the CDNOTS skeleton before gating
 
 # With stability selection (more robust)
-G_hat, scores, selector = run_stability_selection(
+res_ss = run_stability_selection(
     df=df,
     max_lag=3,
     use_ci_skeleton=True,
@@ -142,9 +151,37 @@ G_hat, scores, selector = run_stability_selection(
     device="cpu",
     model_seed=42,
 )
-# G_hat: binary numpy array shape (n_vars, n_vars, max_lag+1)
+res_ss.cg_tig, res_ss.stability_scores
+# Both return a GraceResult (a CausalResult subclass) — NOT a tuple. Like every other
+# result object it carries .plot() and the DoWhy bridge methods directly.
+```
+
+### LUCID (latent confounders)
+
+```python
+from causalts.confounders import run_lucid
+
+res = run_lucid(df, max_lag=3)
+res.cg_tig        # corrected graph, shape (n_vars, n_vars, max_lag+1)
+res.regime        # "sparse" | "sf" | "pervasive" — which correction was applied
+res.spectral_ratio, res.tau   # router statistic vs the Marchenko-Pastur no-factor edge
+res.n_factors     # latent factors above the MP edge (0 on the sparse branch)
+res.top_factor_variables(0, 5)   # [(var_name, loading), ...] for factor 0
+
+# Reuse a graph you already discovered instead of re-running the skeleton search.
+# Available on EVERY result type (CdnotsResult, CedarResult, GraceResult, ...).
+res = run_cdnots(df, ci, num_lags=3)
+res.deconfound()        # -> LucidResult (regime-adaptive; the recommended path)
+res.tetrad_filter()     # fixed comparator: always assumes pervasive factors
+res.pds_filter()        # fixed comparator: post-double-selection on observed controls
 ```
 
+`causal-ts inspect` reports `facts.latent_factor.detected` — `true` means one or more
+latent factors load broadly across the panel, so plan on deconfounding. Read negatives
+narrowly: `false` only rules out factor structure this test can see (a confounder
+touching two or three variables leaves no dominant eigenvalue and stays invisible), and
+`null` means the check could not run. Neither means "no confounding".
+
 ## CI Tests — Choosing the Right Test
 
 All CI tests are in `causalts.ci_tests`. Run `causal-ts ci-test-info` for the full selection guide.
diff --git a/tests/test_inspect.py b/tests/test_inspect.py
index ef01c3c..0975291 100644
--- a/tests/test_inspect.py
+++ b/tests/test_inspect.py
@@ -73,5 +73,89 @@ def test_json_serialisable():
     json.dumps(report, default=str)  # must not raise
 
 
+# ── facts["latent_factor"] ───────────────────────────────────────────────────
+# Positive-evidence-only diagnostic: it can assert that a pervasive factor IS
+# present, but "not detected" never means "no confounding" (a confounder touching
+# two or three variables leaves no dominant eigenvalue). The tests below pin that
+# asymmetry, not just the happy path.
+def _pervasive(T=600, d=8, n_factors=2, seed=0):
+    """Low-rank innovations: a few latent factors drive every variable."""
+    rng = np.random.default_rng(seed)
+    factors = rng.standard_normal((T, n_factors))
+    loadings = rng.standard_normal((n_factors, d))
+    data = 2.0 * (factors @ loadings)
+    data[1:, 1] += 0.6 * data[:-1, 0]
+    data += 0.3 * rng.standard_normal((T, d))
+    return pd.DataFrame(data, columns=[f"X{i}" for i in range(d)])
+
+
+def test_latent_factor_detected_on_pervasive_data():
+    lf = inspect_df(_pervasive())["facts"]["latent_factor"]
+    assert lf["detected"] is True
+    assert lf["spectral_ratio"] > lf["tau"]
+
+
+def test_latent_factor_not_detected_on_full_rank_data():
+    lf = inspect_df(_linear_var(T=600, d=8))["facts"]["latent_factor"]
+    assert lf["detected"] is False
+    assert lf["spectral_ratio"] <= lf["tau"]
+
+
+@pytest.mark.parametrize(
+    "df",
+    [
+        pytest.param(
+            pd.DataFrame(
+                np.where(
+                    np.random.default_rng(1).random((300, 6)) < 0.15,
+                    np.nan,
+                    np.random.default_rng(0).standard_normal((300, 6)),
+                ),
+                columns=[f"X{i}" for i in range(6)],
+            ),
+            id="missing_values",
+        ),
+        pytest.param(
+            pd.DataFrame({"X0": np.random.default_rng(0).standard_normal(300)}),
+            id="single_column",
+        ),
+        pytest.param(
+            pd.DataFrame(
+                np.random.default_rng(0).standard_normal((6, 8)),
+                columns=[f"X{i}" for i in range(8)],
+            ),
+            id="underdetermined_T_lt_d",
+        ),
+    ],
+)
+def test_latent_factor_guards_report_none_not_false(df):
+    """The VAR(1) least-squares fit behind the statistic cannot run on these.
+
+    ``None`` (not ``False``) is required: "could not check" must never be
+    readable as "checked and found nothing".
+    """
+    import json
+
+    report = inspect_df(df)
+    lf = report["facts"]["latent_factor"]
+    assert lf == {"detected": None, "spectral_ratio": None, "tau": None}
+    json.dumps(report, default=str)  # stays serialisable
+
+
+def test_deconfound_nudge_only_fires_on_positive_detection():
+    assert "deconfound" in inspect_df(_pervasive())["recommendation"]["rationale"]
+    rec = inspect_df(_linear_var(T=600, d=8))["recommendation"]
+    assert "deconfound" not in rec["rationale"]
+
+
+def test_latent_factor_does_not_change_algorithm_choice():
+    """LUCID is orthogonal post-processing, not a discovery-algorithm alternative."""
+    pervasive, plain = _pervasive(d=8), _linear_var(T=600, d=8)
+    a = inspect_df(pervasive)["recommendation"]
+    b = inspect_df(plain)["recommendation"]
+    assert a["algorithm"] == b["algorithm"]
+    assert a["include_C"] == b["include_C"]
+
+
 if __name__ == "__main__":
     pytest.main([__file__, "-v"])