diff --git a/CONTEXT.md b/CONTEXT.md index 50d3e9f9..7c48c808 100644 --- a/CONTEXT.md +++ b/CONTEXT.md @@ -577,6 +577,14 @@ _Avoid_: shap_mode, use_shap, sample_plot. The strategy `ShapModel.fit` selects to turn a soft label `p` ∈ (0, 1) into a SHAP estimate when **fuzzy labeling** is active. `"interpolate"` (default, new in v1.1) fits the model twice (fuzzy sample at 0 → `S0`, at 1 → `S1`) and blends `p·S1 + (1−p)·S0` — the **unbiased** exact-`p` estimate. `"threshold"` (the `Breimann25` sweep) hard-labels the fuzzy sample `1` across a non-uniform `n_rounds × n_selection` grid and averages — a **biased** approximation whose effective positive-fraction is the grid's `frac1`, not `p`; kept as a first-class option. Each fuzzy protein is explained independently against the fixed balanced 0/1 **core**, with the other fuzzy proteins excluded from that run's training data. `n_rounds` (default `5`) is interpolate's speed/stability dial: `1` = fast exact two-fit estimate, `5` = light averaging, `≈15–20` = converged Monte-Carlo mean (run-to-run spread <5% on `DOM_GSEC`). _Avoid_: fuzzy mode, blend mode, soft-label aggregation. +**CPPStructurePlot**: +Public **pro** plotting class in `aaanalysis/feature_engineering_pro/` (abbr `csp`) that paints per-residue CPP / CPP-SHAP **feature impact** onto a 3D protein structure. Its single method `map_structure(df_feat, pdb=…|uniprot=…)` maps each feature to the residues it spans (`get_positions_`, shifted to absolute residue numbers by `start`) and aggregates `col_imp` per residue with the **same normalized-sum** `CPPPlot.profile` uses — never a re-implemented per-position loop. It **reuses** the shared CPP position backend and the `StructurePreprocessor` structure parser (no duplication; a thin chain-by-id Cα/pLDDT extractor is the only new structure code). Modes: `"impact"` (white→`COLOR_SHAP_POS`/`COLOR_SHAP_NEG` ramp with a `sign·sqrt` perceptual transform) and `"plddt"` (AlphaFold confidence palette); focus `"whole"`/`"fade"`/`"zoom"`. Returns a [[StructureView]]. The structure-side companion to `CPPPlot` for the **CPP-SHAP analysis** level. +_Avoid_: structure_plot, plot_structure (the verb-noun method is `map_structure`), CPPStructure (it is a plot class, suffix `Plot`). + +**StructureView**: +The thin return wrapper of [[CPPStructurePlot]]`.map_structure`, exposing a **uniform** `show()` / `write_html(path)` / `savefig(path)` / `_repr_html_` surface over its two render backends (interactive `py3Dmol` and static matplotlib `mplot3d`) whose native objects (`py3Dmol.view` vs `Figure`) are otherwise incompatible. A **pure delegator** — no rendering logic, no state beyond the backend object and the mapped `dict_impact` / `max_abs`. The package's first non-`Axes` plotting return type, a deliberate, documented exception to the "return fig/ax" rule (`savefig` is matplotlib-only; `write_html` is the py3Dmol shareable-interactive output). +_Avoid_: view wrapper, plot handle (it is specifically the structure-render delegator), figure (it is not a matplotlib Figure). + ### Scale-set vocabulary **explainable scale set** (`top_explain_n`): diff --git a/aaanalysis/__init__.py b/aaanalysis/__init__.py index 41e71a99..25d35953 100644 --- a/aaanalysis/__init__.py +++ b/aaanalysis/__init__.py @@ -80,7 +80,7 @@ # the ImportError's ``.name`` (reliable for ModuleNotFoundError on the Python 3.11+ floor), never on a # substring of the message. See .claude/rules/pro-core-boundary.md. _EXTRA_MODULES = { - "pro": {"shap", "Bio", "biopython", "upsetplot", "UpSetPlot", "requests", "afragmenter"}, + "pro": {"shap", "Bio", "biopython", "upsetplot", "UpSetPlot", "requests", "afragmenter", "py3Dmol"}, "embed": {"torch", "transformers", "sentencepiece", "huggingface_hub"}, "dev": {"IPython"}, } @@ -171,6 +171,15 @@ def missing_feature_stub(feature_name, error, mode="pro"): "AnnotationPreprocessor", e, mode="pro") +try: + from .feature_engineering_pro import CPPStructurePlot + __all__.append("CPPStructurePlot") +except ImportError as e: + CPPStructurePlot = None + globals()["CPPStructurePlot"] = missing_feature_stub( + "CPPStructurePlot", e, mode="pro") + + try: from .show_html import display_df __all__.append("display_df") diff --git a/aaanalysis/_constants.py b/aaanalysis/_constants.py index 0e109386..b5671a28 100644 --- a/aaanalysis/_constants.py +++ b/aaanalysis/_constants.py @@ -488,6 +488,24 @@ def _folder_path(super_folder, folder_name): "SAMPLES_REL_NEG": COLOR_REL_NEG } +# pLDDT confidence palette (AlphaFold-DB), ordered low -> high confidence. Read +# high -> low it is the familiar blue -> cyan -> yellow -> orange ramp used to +# paint per-residue AlphaFold model confidence onto a structure. +COLOR_PLDDT_VERY_LOW = '#FF7D45' # orange, pLDDT < 50 +COLOR_PLDDT_LOW = '#FFDB13' # yellow, 50 <= pLDDT < 70 +COLOR_PLDDT_CONFIDENT = '#65CBF3' # cyan, 70 <= pLDDT < 90 +COLOR_PLDDT_VERY_HIGH = '#0053D6' # blue, pLDDT >= 90 +COLOR_STRUCT_MISSING = '#BFBFBF' # gray for residues without a mapped value + +# Continuous low -> high ramp consumed by the pLDDT structure colouring. +LIST_COLOR_PLDDT = [COLOR_PLDDT_VERY_LOW, COLOR_PLDDT_LOW, + COLOR_PLDDT_CONFIDENT, COLOR_PLDDT_VERY_HIGH] + +DICT_COLOR_PLDDT = {"very_low": COLOR_PLDDT_VERY_LOW, + "low": COLOR_PLDDT_LOW, + "confident": COLOR_PLDDT_CONFIDENT, + "very_high": COLOR_PLDDT_VERY_HIGH} + DICT_COLOR_CAT = {"ASA/Volume": "tab:blue", "Composition": "tab:orange", "Conformation": "tab:green", diff --git a/aaanalysis/data_handling_pro/_backend/struct_preproc/encode_pdb.py b/aaanalysis/data_handling_pro/_backend/struct_preproc/encode_pdb.py index b0d6b3be..fe511511 100644 --- a/aaanalysis/data_handling_pro/_backend/struct_preproc/encode_pdb.py +++ b/aaanalysis/data_handling_pro/_backend/struct_preproc/encode_pdb.py @@ -135,6 +135,9 @@ def _align_atom_values_to_target(target_seq: str, # II Main Functions +# NOTE: load_structure / _collect_chain_residues / _resolve_best_chain are reused by +# feature_engineering_pro.CPPStructurePlot (no duplication) — they are load-bearing +# beyond StructurePreprocessor; keep their signatures and behaviour stable. def load_structure(pdb_path): """Parse a PDB or mmCIF file and return a Bio.PDB Structure (quiet mode). diff --git a/aaanalysis/feature_engineering_pro/__init__.py b/aaanalysis/feature_engineering_pro/__init__.py new file mode 100644 index 00000000..5dfcfbae --- /dev/null +++ b/aaanalysis/feature_engineering_pro/__init__.py @@ -0,0 +1,19 @@ +""" +Pro feature-engineering plots: CPP feature impact on 3D structure (``pro`` extra). + +Public objects: CPPStructurePlot. +Gated behind the ``pro`` extra (needs ``biopython``; ``py3Dmol`` for the +interactive backend, with a matplotlib fallback otherwise). Paints the per-residue +CPP / CPP-SHAP feature impact from a ``df_feat`` onto a protein structure, reusing +the shared CPP position backend (``feature_engineering``) and the structure parser +(``data_handling_pro``). Imported lazily from the top-level package and replaced by +an install-hint stub when ``biopython`` is absent. + +See ``.claude/rules/pro-core-boundary.md`` for the pro/core boundary, ``CONTEXT.md`` +for domain terms (CPPStructurePlot, StructureView). +""" +from ._cpp_structure_plot import CPPStructurePlot + +__all__ = [ + "CPPStructurePlot", +] diff --git a/aaanalysis/feature_engineering_pro/_backend/__init__.py b/aaanalysis/feature_engineering_pro/_backend/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/aaanalysis/feature_engineering_pro/_backend/cpp_struct/__init__.py b/aaanalysis/feature_engineering_pro/_backend/cpp_struct/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/aaanalysis/feature_engineering_pro/_backend/cpp_struct/colors.py b/aaanalysis/feature_engineering_pro/_backend/cpp_struct/colors.py new file mode 100644 index 00000000..ebb4905d --- /dev/null +++ b/aaanalysis/feature_engineering_pro/_backend/cpp_struct/colors.py @@ -0,0 +1,85 @@ +""" +This is a script for the backend colour ramps of the CPPStructurePlot class: +the signed white->SHAP-red / white->SHAP-blue impact ramp (with the +``sign * sqrt(|t|)`` perceptual transform that keeps faint impacts visible) and +the AlphaFold-style pLDDT confidence ramp. All colours come from the ``ut`` +constants barrel; no hex is hardcoded here. +""" +import numpy as np +import matplotlib.colors as mcolors + +import aaanalysis.utils as ut + +# White anchor of the signed impact ramp (a neutral, not a domain colour). +_WHITE = "#FFFFFF" + +# Reuse the package's SHAP ramps (``sns.light_palette`` via ``plot_get_cmap_``) so the +# 3D structure colours match CPPPlot.profile / feature_map exactly instead of a +# divergent linear interpolation. Both go white (index 0) -> saturated (index 100). +_N_RAMP = 101 +_RAMP_POS = [mcolors.to_hex(c) for c in + ut.plot_get_cmap_(cmap=ut.STR_CMAP_SHAP, n_colors=_N_RAMP, only_pos=True)] +_RAMP_NEG = [mcolors.to_hex(c) for c in + ut.plot_get_cmap_(cmap=ut.STR_CMAP_SHAP, n_colors=_N_RAMP, only_neg=True)][::-1] + + +# I Helper Functions +def _lerp_hex(color_lo, color_hi, frac): + """Linearly interpolate between two colours in RGB; return a hex string.""" + lo = np.asarray(mcolors.to_rgb(color_lo), dtype=np.float64) + hi = np.asarray(mcolors.to_rgb(color_hi), dtype=np.float64) + frac = float(np.clip(frac, 0.0, 1.0)) + return mcolors.to_hex(lo + (hi - lo) * frac) + + +# II Main Functions +def perceptual_transform(t): + """Signed square-root transform ``sign(t) * sqrt(|t|)`` on ``t`` in ``[-1, 1]``. + + Compresses large magnitudes and stretches small ones so faint but real + impacts stay visible; the sign is preserved and the output stays in + ``[-1, 1]``. + """ + t = np.asarray(t, dtype=np.float64) + return np.sign(t) * np.sqrt(np.abs(t)) + + +def impact_to_hex(impact, max_abs, color_pos=None, color_neg=None): + """Map a signed impact to a hex colour on the white->SHAP-pos / white->SHAP-neg ramp. + + ``impact`` is normalised by ``max_abs`` to ``[-1, 1]`` and passed through the + ``sign * sqrt`` transform to get a blend fraction in ``[0, 1]``. By default the + colour is read off the package SHAP ramp (so it matches the 2D CPP plots); a + custom ``color_pos`` / ``color_neg`` falls back to a white->colour interpolation. + Zero / non-finite impact and a non-positive ``max_abs`` map to white. + """ + if max_abs is None or max_abs <= 0 or not np.isfinite(impact) or impact == 0: + return _WHITE + t = float(np.clip(impact / max_abs, -1.0, 1.0)) + frac = float(np.sqrt(abs(t))) # |sign * sqrt(t)| -> blend fraction in [0, 1] + idx = int(round(frac * (_N_RAMP - 1))) + if t > 0: + return _RAMP_POS[idx] if color_pos is None else _lerp_hex(_WHITE, color_pos, frac) + return _RAMP_NEG[idx] if color_neg is None else _lerp_hex(_WHITE, color_neg, frac) + + +def plddt_cmap(): + """Continuous low->high pLDDT colormap built from the ``ut.LIST_COLOR_PLDDT`` ramp.""" + return mcolors.LinearSegmentedColormap.from_list("plddt", ut.LIST_COLOR_PLDDT) + + +def plddt_to_hex(plddt): + """Map a pLDDT value (0-100) to a hex colour; non-finite -> gray.""" + if plddt is None or not np.isfinite(plddt): + return ut.COLOR_STRUCT_MISSING + frac = float(np.clip(plddt / 100.0, 0.0, 1.0)) + return mcolors.to_hex(plddt_cmap()(frac)) + + +def color_for_residue(resi, dict_impact, max_abs, plddt, mode, + color_pos=None, color_neg=None): + """Resolve the colour of a single residue for ``mode`` ('impact' or 'plddt').""" + if mode == "plddt": + return plddt_to_hex(plddt) + return impact_to_hex(dict_impact.get(resi, 0.0), max_abs, + color_pos=color_pos, color_neg=color_neg) diff --git a/aaanalysis/feature_engineering_pro/_backend/cpp_struct/mapping.py b/aaanalysis/feature_engineering_pro/_backend/cpp_struct/mapping.py new file mode 100644 index 00000000..758b153c --- /dev/null +++ b/aaanalysis/feature_engineering_pro/_backend/cpp_struct/mapping.py @@ -0,0 +1,69 @@ +""" +This is a script for the backend feature->residue mapping of the CPPStructurePlot +class. It reuses the shared CPP feature backend (``get_positions_`` + +``get_df_pos_`` with the normalized-sum semantics) so the per-residue impact is +identical to what the CPP profile / feature map show, never a re-implemented +per-position loop. +""" +import numpy as np + +import aaanalysis.utils as ut +# Shared CPP feature backend (the deliberately shared ``_backend/cpp/`` package, +# registered as SHARED_BACKEND_SUBPKGS for feature_engineering). +from aaanalysis.feature_engineering._backend.cpp.utils_feature import ( + get_positions_, get_df_pos_) + + +# I Helper Functions +def _positions_union(feat_positions): + """Flatten the comma-separated position strings into a sorted list of ints.""" + positions = set() + for pos_str in feat_positions: + if not pos_str: + continue + for p in str(pos_str).split(","): + if p != "": + positions.add(int(p)) + return sorted(positions) + + +# II Main Functions +def compute_residue_impact(df_feat=None, col_imp=None, start=1, tmd_len=20, + jmd_n_len=10, jmd_c_len=10, col_cat=None): + """Map per-feature impact onto absolute residue numbers. + + The feature positions are derived with the shared ``get_positions_`` helper + (so ``start`` shifts them to absolute residue numbers) and aggregated with + ``get_df_pos_(value_type="sum")``, which divides each feature's value by the + number of positions it spans before summing per position — the same + normalized-sum the CPP profile uses. Summing across scale categories yields + one signed impact per residue. + + Returns + ------- + dict_impact : dict + ``{resi: impact}`` for every residue in ``[start, stop]``. + max_abs : float + Maximum absolute per-residue impact (0.0 if none finite); used to + normalise the colour ramp. + positions_union : list of int + Sorted residue numbers actually spanned by ``df_feat`` (the auto window). + """ + col_cat = ut.COL_CAT if col_cat is None else col_cat + df_feat = df_feat.copy() + features = df_feat[ut.COL_FEATURE].to_list() + feat_positions = get_positions_(features=features, start=start, tmd_len=tmd_len, + jmd_n_len=jmd_n_len, jmd_c_len=jmd_c_len) + df_feat[ut.COL_POSITION] = feat_positions + if col_cat not in df_feat.columns: + df_feat[col_cat] = "feature" + stop = start + jmd_n_len + tmd_len + jmd_c_len - 1 + df_pos = get_df_pos_(df_feat=df_feat, col_cat=col_cat, col_val=col_imp, + value_type="sum", start=start, stop=stop) + # Rows = scale categories, columns = positions; sum to one value per residue. + series = df_pos.sum(axis=0) + dict_impact = {int(p): float(v) for p, v in series.items()} + finite = [abs(v) for v in dict_impact.values() if np.isfinite(v)] + max_abs = max(finite) if finite else 0.0 + positions_union = _positions_union(feat_positions) + return dict_impact, max_abs, positions_union diff --git a/aaanalysis/feature_engineering_pro/_backend/cpp_struct/render.py b/aaanalysis/feature_engineering_pro/_backend/cpp_struct/render.py new file mode 100644 index 00000000..342f9be8 --- /dev/null +++ b/aaanalysis/feature_engineering_pro/_backend/cpp_struct/render.py @@ -0,0 +1,148 @@ +""" +This is a script for the backend renderers of the CPPStructurePlot class: the +interactive py3Dmol cartoon (per-residue ``setStyle`` colouring, optional impact- +scaled sticks, fade / zoom focus) and the static matplotlib ``mplot3d`` Cα-scatter +fallback. Both paint the same colour ramp and are wrapped by ``StructureView``. +``py3Dmol`` is imported lazily so the matplotlib fallback works when it is absent. +""" +import numpy as np +import matplotlib.pyplot as plt +import matplotlib.colors as mcolors + +import aaanalysis.utils as ut +from .colors import color_for_residue +from .view import StructureView + + +# I Helper Functions +def py3dmol_available(): + """Return ``True`` if the optional ``py3Dmol`` renderer is importable.""" + try: + import py3Dmol # noqa: F401 + return True + except ImportError: + return False + + +# Stick radii (Angstrom) for impact residues, matching the deployed app: a visible +# floor so every impact-carrying residue shows a stick, growing with |impact|. +_STICK_MIN = 0.18 +_STICK_SPAN = 0.55 +_STICK_FLAT = 0.22 + + +def _stick_radius(impact, max_abs, size_by_impact): + """Stick radius (A) for an impact residue; 0 for zero / undefined impact. + + With ``size_by_impact`` the radius floors at ``_STICK_MIN`` and grows with + ``|impact| / max_abs`` (so even faint impacts stay visible, like the app); + otherwise every impact residue gets a constant ``_STICK_FLAT`` stick. + """ + if max_abs is None or max_abs <= 0 or not np.isfinite(impact) or impact == 0: + return 0.0 + if not size_by_impact: + return _STICK_FLAT + return float(_STICK_MIN + _STICK_SPAN * min(1.0, abs(impact) / max_abs)) + + +def _read_structure_text(pdb_path): + """Read raw PDB / CIF text to feed py3Dmol's ``addModel``.""" + fmt = "cif" if str(pdb_path).lower().endswith(".cif") else "pdb" + with open(str(pdb_path), "r", encoding="utf-8") as f: + return f.read(), fmt + + +# II Main Functions +def render_py3dmol(pdb_path, records, dict_impact, max_abs, mode, + focus, window_resis, size_by_impact, chain_id=None, + color_pos=None, color_neg=None, width=600, height=450): + """Build a py3Dmol cartoon view coloured per residue and wrap it in a StructureView. + + ``addModel`` loads the whole (possibly multi-chain) structure, so every + per-residue ``setStyle`` / ``zoomTo`` selection is qualified by ``chain_id`` — + otherwise residue number 50 would be coloured on every chain that has one. + """ + import py3Dmol + pdb_text, fmt = _read_structure_text(pdb_path) + view = py3Dmol.view(width=width, height=height) + view.addModel(pdb_text, fmt) + view.setStyle({}, {"cartoon": {"color": ut.COLOR_STRUCT_MISSING}}) + present_resis = {res["resi"] for res in records} + for res in records: + resi = res["resi"] + color = color_for_residue(resi, dict_impact, max_abs, res["plddt"], mode, + color_pos=color_pos, color_neg=color_neg) + in_window = window_resis is None or resi in window_resis + cartoon = {"color": color} + if focus == "fade" and not in_window: + cartoon["opacity"] = 0.2 + style = {"cartoon": cartoon} + if mode == "impact": + radius = _stick_radius(dict_impact.get(resi, 0.0), max_abs, size_by_impact) + if radius > 0: + style["stick"] = {"radius": radius, "color": color} + sel = {"resi": str(resi)} + if chain_id is not None: + sel["chain"] = chain_id + view.setStyle(sel, style) + # Only zoom to window residues that actually exist in the structure, else the + # camera silently fails to focus on an empty selection. + zoom_resis = sorted((window_resis or set()) & present_resis) + if focus == "zoom" and zoom_resis: + sel = {"resi": [str(r) for r in zoom_resis]} + if chain_id is not None: + sel["chain"] = chain_id + view.zoomTo(sel) + else: + view.zoomTo() + view.setBackgroundColor("white") + return StructureView(backend="py3dmol", view=view, dict_impact=dict_impact, + max_abs=max_abs, mode=mode) + + +def render_mpl(records, dict_impact, max_abs, mode, focus, window_resis, + size_by_impact, color_pos=None, color_neg=None, figsize=(6, 6)): + """Build a matplotlib ``mplot3d`` Cα scatter coloured per residue; wrap as StructureView.""" + fig = plt.figure(figsize=figsize) + ax = fig.add_subplot(111, projection="3d") + xs, ys, zs, rgba, sizes = [], [], [], [], [] + win_coords = [] + for res in records: + coord = res["coord"] + if not np.all(np.isfinite(coord)): + continue + resi = res["resi"] + color = color_for_residue(resi, dict_impact, max_abs, res["plddt"], mode, + color_pos=color_pos, color_neg=color_neg) + in_window = window_resis is None or resi in window_resis + alpha = 1.0 if (focus != "fade" or in_window) else 0.15 + xs.append(coord[0]) + ys.append(coord[1]) + zs.append(coord[2]) + rgba.append(mcolors.to_rgba(color, alpha=alpha)) + size = 30.0 + if mode == "impact": + radius = _stick_radius(dict_impact.get(resi, 0.0), max_abs, size_by_impact) + if radius > 0: + size = 30.0 + 300.0 * radius # radius ~0.18..0.73 -> marker ~84..249 + sizes.append(size) + if in_window: + win_coords.append(coord) + if xs: + # Backbone trace plus the per-residue Cα scatter. + ax.plot(xs, ys, zs, color=ut.COLOR_STRUCT_MISSING, linewidth=0.8, alpha=0.6) + ax.scatter(xs, ys, zs, c=rgba, s=sizes, depthshade=False, edgecolors="none") + if focus == "zoom" and win_coords: + win = np.vstack(win_coords) + lo, hi = win.min(axis=0), win.max(axis=0) + pad = 0.1 * np.maximum(hi - lo, 1.0) + ax.set_xlim(lo[0] - pad[0], hi[0] + pad[0]) + ax.set_ylim(lo[1] - pad[1], hi[1] + pad[1]) + ax.set_zlim(lo[2] - pad[2], hi[2] + pad[2]) + ax.set_xlabel("x") + ax.set_ylabel("y") + ax.set_zlabel("z") + label = "pLDDT" if mode == "plddt" else "CPP feature impact" + ax.set_title(f"{label} on structure") + return StructureView(backend="mpl", fig=fig, ax=ax, dict_impact=dict_impact, + max_abs=max_abs, mode=mode) diff --git a/aaanalysis/feature_engineering_pro/_backend/cpp_struct/structure.py b/aaanalysis/feature_engineering_pro/_backend/cpp_struct/structure.py new file mode 100644 index 00000000..538f5ebd --- /dev/null +++ b/aaanalysis/feature_engineering_pro/_backend/cpp_struct/structure.py @@ -0,0 +1,135 @@ +""" +This is a script for the backend structure handling of the CPPStructurePlot class: +pick the chain (explicit id, best match to a target sequence, or the first +amino-acid chain) and extract per-residue Cα coordinates, **absolute** residue +numbers, and pLDDT (the AlphaFold B-factor column). + +Parsing and best-chain selection are reused verbatim from the StructurePreprocessor +backend (``load_structure`` / ``_collect_chain_residues`` / ``_resolve_best_chain``) +rather than re-implemented — the only new code here is the thin chain-by-id +Cα/pLDDT extractor, which the encoder backend does not expose because its encoders +return sequence-aligned arrays that drop the absolute residue numbering this +renderer needs. + +The top-level biopython import gates the whole CPPStructurePlot feature behind the +``pro`` extra, matching the other ``*_pro`` subpackages. +""" +import numpy as np +# Top-level biopython import: structure parsing has no fallback, so this is the +# dependency that gates CPPStructurePlot behind the ``pro`` extra. +from Bio.PDB.Polypeptide import protein_letters_3to1 + +import aaanalysis.utils as ut +# Reused (no duplication) from the StructurePreprocessor backend. These are +# load-bearing beyond StructurePreprocessor — CPPStructurePlot depends on their +# behaviour too; keep their contracts stable. +from aaanalysis.data_handling_pro._backend.struct_preproc.encode_pdb import ( + load_structure, _collect_chain_residues, _resolve_best_chain, _identity_fraction) + + +# I Helper Functions +def _residue_one_letter(residue): + """Return the 1-letter code for a residue, or 'X' if unknown.""" + return protein_letters_3to1.get(residue.get_resname(), "X") + + +def _ca_coord(residue): + """Return the residue's Cα coordinate as a ``(3,)`` array, NaN if absent.""" + for atom in residue.get_atoms(): + if atom.get_name() == "CA": + return np.asarray(atom.get_coord(), dtype=np.float64) + return np.array([np.nan, np.nan, np.nan]) + + +def _ca_plddt(residue): + """Return the residue's Cα B-factor (AlphaFold pLDDT); mean atom B-factor if no Cα.""" + for atom in residue.get_atoms(): + if atom.get_name() == "CA": + return float(atom.get_bfactor()) + b_values = [atom.get_bfactor() for atom in residue.get_atoms()] + return float(np.mean(b_values)) if b_values else float("nan") + + +def _records_from_residues(residues): + """Build ``{"resi", "coord", "plddt", "aa"}`` records from biopython residues. + + ``residues`` is the ``[(residue, key)]`` form returned by + ``_collect_chain_residues`` / ``_resolve_best_chain``; ``resi`` is the + structure's absolute residue number (``residue.id[1]``). + """ + records = [] + for residue, _key in residues: + records.append({"resi": int(residue.id[1]), + "coord": _ca_coord(residue), + "plddt": _ca_plddt(residue), + "aa": _residue_one_letter(residue)}) + return records + + +def _chain_identity(residues, sequence): + """Sequence-match fraction of a chain's residues against ``sequence`` (1.0 if no seq).""" + if sequence is None: + return 1.0 + atom_seq = "".join(_residue_one_letter(r) for r, _ in residues) + return _identity_fraction(sequence, atom_seq) + + +def _select_chain_residues(structure, chain=None, sequence=None): + """Select a chain's residues: explicit id, best match to ``sequence``, or first. + + Returns ``(residues, identity, chain_id)`` where ``residues`` is the + ``[(residue, key)]`` form, ``identity`` is the sequence-match fraction (1.0 when no + ``sequence`` is supplied), and ``chain_id`` is the selected chain's id (so the + renderer can qualify per-residue selections and not leak onto same-numbered + residues of other chains). + """ + chains = _collect_chain_residues(structure) + if not chains: + raise ValueError("'pdb' (structure) should contain at least one " + "amino-acid chain") + if chain is not None: + for ch, residues in chains: + if ch.id == chain: + # Still score identity so a wrong explicit chain + sequence warns. + return residues, _chain_identity(residues, sequence), ch.id + available = [ch.id for ch, _ in chains] + raise ValueError(f"'chain' ('{chain}') should be one of the available " + f"chains {available}") + if sequence is not None: + ch, residues, _atom_seq, identity = _resolve_best_chain(structure, sequence) + if residues is None: + raise ValueError("'pdb' (structure) should contain at least one " + "amino-acid chain") + return residues, identity, ch.id + # Default: first amino-acid chain. + ch, residues = chains[0] + return residues, 1.0, ch.id + + +# II Main Functions +def extract_chain_residues(structure, chain=None, sequence=None): + """Extract per-residue records for the selected chain. + + Returns + ------- + records : list of dict + One ``{"resi": int, "coord": (3,) ndarray, "plddt": float, "aa": str}`` + per amino-acid residue, in chain order; ``resi`` is the structure's + absolute residue number. + identity : float + Sequence-match fraction of the chosen chain (1.0 without ``sequence``). + chain_id : str + Id of the selected chain (qualifies per-residue rendering selections). + """ + residues, identity, chain_id = _select_chain_residues(structure, chain=chain, + sequence=sequence) + return _records_from_residues(residues), identity, chain_id + + +def residue_numbers(records): + """Return the set of absolute residue numbers present in ``records``.""" + return {r["resi"] for r in records} + + +# Re-export the reused parser so the frontend imports a single structure module. +__all__ = ["load_structure", "extract_chain_residues", "residue_numbers"] diff --git a/aaanalysis/feature_engineering_pro/_backend/cpp_struct/view.py b/aaanalysis/feature_engineering_pro/_backend/cpp_struct/view.py new file mode 100644 index 00000000..3c18240b --- /dev/null +++ b/aaanalysis/feature_engineering_pro/_backend/cpp_struct/view.py @@ -0,0 +1,100 @@ +""" +This is a script for the backend StructureView wrapper of the CPPStructurePlot +class: a thin, pure delegator that gives the interactive (py3Dmol) and static +(matplotlib) renderers one uniform surface — ``show`` / ``write_html`` / +``savefig`` / ``_repr_html_`` — so the return type of ``map_structure`` does not +vary with the backend that fired. +""" +import base64 +import io + + +# I Helper Functions +def _figure_to_png_b64(fig): + """Render a matplotlib Figure to a base64-encoded PNG string.""" + buffer = io.BytesIO() + fig.savefig(buffer, format="png", bbox_inches="tight") + buffer.seek(0) + return base64.b64encode(buffer.read()).decode("ascii") + + +# II Main Functions +class StructureView: + """Uniform handle over a py3Dmol view or a matplotlib Figure. + + Returned by :meth:`CPPStructurePlot.map_structure`. A pure delegator: it + forwards ``show`` / ``write_html`` / ``savefig`` / ``_repr_html_`` to whichever + backend produced it and otherwise carries the mapped impact for inspection. + + Attributes + ---------- + backend : str + ``'py3dmol'`` or ``'mpl'``. + dict_impact : dict + ``{resi: impact}`` painted onto the structure. + max_abs : float + Normalisation constant for the impact ramp. + mode : str + ``'impact'`` or ``'plddt'``. + """ + + def __init__(self, backend, view=None, fig=None, ax=None, + dict_impact=None, max_abs=None, mode=None): + """Store the backend object and the mapped-impact metadata.""" + self.backend = backend + self._view = view + self._fig = fig + self._ax = ax + self.dict_impact = dict_impact + self.max_abs = max_abs + self.mode = mode + + @property + def fig(self): + """The matplotlib :class:`~matplotlib.figure.Figure` (``mpl`` backend only).""" + return self._fig + + @property + def ax(self): + """The matplotlib :class:`~matplotlib.axes.Axes` (``mpl`` backend only).""" + return self._ax + + @property + def view(self): + """The underlying ``py3Dmol`` view object (``py3dmol`` backend only).""" + return self._view + + def show(self): + """Display the structure (py3Dmol viewer; the Figure for the mpl backend).""" + if self.backend == "py3dmol": + return self._view.show() + return self._fig + + def write_html(self, path): + """Write a self-contained HTML file (py3Dmol export, or an embedded PNG for mpl).""" + path = str(path) + if self.backend == "py3dmol": + self._view.write_html(path) + return path + png_b64 = _figure_to_png_b64(self._fig) + html = (f"" + f"" + f"") + with open(path, "w", encoding="utf-8") as f: + f.write(html) + return path + + def savefig(self, path, **kwargs): + """Save a static image (mpl backend only; py3Dmol exports via ``write_html``).""" + if self.backend == "mpl": + self._fig.savefig(str(path), **kwargs) + return str(path) + raise RuntimeError("'savefig' is only available for the matplotlib backend; " + "use 'write_html' for the py3Dmol backend") + + def _repr_html_(self): + """Notebook rich display: the py3Dmol widget or an embedded PNG.""" + if self.backend == "py3dmol": + return self._view._repr_html_() + png_b64 = _figure_to_png_b64(self._fig) + return f"" diff --git a/aaanalysis/feature_engineering_pro/_cpp_structure_plot.py b/aaanalysis/feature_engineering_pro/_cpp_structure_plot.py new file mode 100644 index 00000000..65a1f4aa --- /dev/null +++ b/aaanalysis/feature_engineering_pro/_cpp_structure_plot.py @@ -0,0 +1,316 @@ +""" +This is a script for the frontend of the CPPStructurePlot class, painting +per-residue CPP / CPP-SHAP feature impact onto a 3D protein structure. +""" +import os +import tempfile +import warnings +from typing import Optional, List, Tuple, Union, Literal + +import pandas as pd + +import aaanalysis.utils as ut + +from ._backend.cpp_struct.mapping import compute_residue_impact +from ._backend.cpp_struct.structure import (load_structure, extract_chain_residues, + residue_numbers) +from ._backend.cpp_struct.render import (render_py3dmol, render_mpl, + py3dmol_available) +from ._backend.cpp_struct.view import StructureView + +LIST_MODES = ["impact", "plddt"] +LIST_FOCUS = ["whole", "fade", "zoom"] +LIST_BACKENDS = ["py3dmol", "mpl"] + + +# I Helper Functions +def check_focus_region(focus_region=None): + """Validate ``focus_region``: ``None``, a ``(start, stop)`` tuple, or a list of them.""" + if focus_region is None: + return None + ranges = [focus_region] if isinstance(focus_region, tuple) else focus_region + if not isinstance(ranges, list): + raise ValueError(f"'focus_region' ({focus_region}) should be a (start, stop) " + f"tuple or a list of such tuples") + for rng in ranges: + ut.check_tuple(name="focus_region range", val=rng, n=2, check_number=True) + if int(rng[0]) > int(rng[1]): + raise ValueError(f"'focus_region' range ({rng}) should have start <= stop") + return ranges + + +def _resolve_window_resis(focus, focus_region, positions_union): + """Resolve the set of residues that define the focus window (None for 'whole').""" + if focus == "whole": + return None + if focus_region is None: + return set(positions_union) + ranges = [focus_region] if isinstance(focus_region, tuple) else focus_region + resis = set() + for start, stop in ranges: + resis.update(range(int(start), int(stop) + 1)) + return resis + + +def _resolve_backend(backend): + """Resolve the render backend; raise a friendly hint if py3Dmol is forced but absent.""" + if backend == "py3dmol" and not py3dmol_available(): + raise RuntimeError("backend='py3dmol' requires the optional 'py3Dmol' package; " + "install it via \"pip install 'aaanalysis[pro]'\" (or " + "\"pip install py3Dmol\"), or use backend='mpl'") + if backend is not None: + return backend + return "py3dmol" if py3dmol_available() else "mpl" + + +# II Main Functions +class CPPStructurePlot: + """ + Plotting class for painting :class:`CPP` feature impact onto a 3D protein structure + (**[pro]**, requires ``aaanalysis[pro]``) [Breimann25]_. + + The per-residue impact is the same normalized-sum that the :meth:`CPPPlot.profile` and + :meth:`CPPPlot.feature_map` show: each feature's signed impact is spread over the residue + positions it spans and summed per position, then painted residue-by-residue onto the protein + cartoon. A red-white-blue ramp shows where features raise (red) or lower (blue) the prediction; + an AlphaFold pLDDT mode shows per-residue model confidence instead. + + The single method :meth:`CPPStructurePlot.map_structure` returns a ``StructureView`` — a + thin wrapper exposing a uniform ``show`` / ``write_html`` / ``savefig`` surface over the + interactive `py3Dmol `_ backend and the static matplotlib + fallback (which is used automatically when py3Dmol is absent or ``backend="mpl"``). + + .. versionadded:: 1.1.0 + + Notes + ----- + * The ``jmd_n_len`` and ``jmd_c_len`` values supplied at construction are stored as + ``_jmd_n_len`` and ``_jmd_c_len`` and reused by :meth:`map_structure`, mirroring + :class:`CPPPlot` so juxta-membrane domain (JMD) lengths stay consistent. + * This is a ``pro`` feature (needs ``biopython``; ``py3Dmol`` for the interactive backend). + + """ + def __init__(self, + jmd_n_len: int = 10, + jmd_c_len: int = 10, + df_scales: Optional[pd.DataFrame] = None, + verbose: bool = True + ): + """ + Parameters + ---------- + jmd_n_len : int, default=10 + Length of JMD-N (>=0). Must match the value used when the features were generated. + jmd_c_len : int, default=10 + Length of JMD-C (>=0). Must match the value used when the features were generated. + df_scales : pd.DataFrame, shape (n_letters, n_scales), optional + DataFrame of scales with letters typically representing amino acids. Stored for + consistency with :class:`CPPPlot`; not required for structure mapping. + verbose : bool, default=True + If ``True``, verbose outputs are enabled. + + See Also + -------- + * :class:`CPPPlot` : the group- and sample-level CPP result plots. + * :class:`ShapModel` : produces the sample-level ``feat_impact`` column painted here. + * :class:`StructurePreprocessor` : parses PDB / CIF / AlphaFold files and fetches AlphaFold models. + + Examples + -------- + .. include:: examples/csp_map_structure.rst + """ + # Check input + verbose = ut.check_verbose(verbose) + jmd_n_len = ut.check_jmd_n_len(jmd_n_len=jmd_n_len) + jmd_c_len = ut.check_jmd_c_len(jmd_c_len=jmd_c_len) + if df_scales is not None: + ut.check_df(name="df_scales", df=df_scales) + # General settings + self._verbose = verbose + self._df_scales = df_scales + self._jmd_n_len = jmd_n_len + self._jmd_c_len = jmd_c_len + + def map_structure(self, + df_feat: pd.DataFrame, + pdb: Optional[str] = None, + uniprot: Optional[str] = None, + col_imp: str = ut.COL_FEAT_IMPACT, + tmd_len: int = 20, + start: int = 1, + chain: Optional[str] = None, + sequence: Optional[str] = None, + mode: Literal["impact", "plddt"] = "impact", + focus: Literal["whole", "fade", "zoom"] = "whole", + focus_region: Optional[Union[Tuple[int, int], List[Tuple[int, int]]]] = None, + size_by_impact: bool = True, + backend: Optional[Literal["py3dmol", "mpl"]] = None, + ) -> StructureView: + """ + Paint per-residue CPP feature impact onto a protein structure. + + Each feature in ``df_feat`` is mapped to the residue positions it spans (shifted to + absolute residue numbers by ``start``) and its ``col_imp`` value is aggregated per + position by the normalized-sum used in :meth:`CPPPlot.profile`. The per-residue signed + impact is then painted onto the structure cartoon. + + Parameters + ---------- + df_feat : pd.DataFrame, shape (n_features, n_feature_info) + Feature DataFrame with a ``feature`` column and the signed per-feature impact column + ``col_imp`` (e.g. from :meth:`ShapModel.add_feat_impact` or :meth:`CPP.run`). + pdb : str, optional + Path to a ``.pdb`` / ``.cif`` structure file. Exactly one of ``pdb`` or ``uniprot`` + must be given. + uniprot : str, optional + UniProt accession; the AlphaFold model is fetched from AlphaFold DB into a temporary + folder via :meth:`StructurePreprocessor.fetch_alphafold`. Exactly one of ``pdb`` or + ``uniprot`` must be given. + col_imp : str, default='feat_impact' + Column of ``df_feat`` holding the signed per-feature impact to paint. + tmd_len : int, default=20 + Length of the TMD (>=1). Must match the value used when the features were generated. + start : int, default=1 + Absolute residue number of the first JMD-N residue in the structure (>=0); shifts + window-relative feature positions onto the structure's residue numbering. + chain : str, optional + Chain id to render. Default selects the best-matching chain when ``sequence`` is + given, otherwise the first amino-acid chain. + sequence : str, optional + Full protein sequence; enables best-matching-chain selection (reusing the structure + backend's alignment) and a sanity check that ``start`` lines up with the structure. + mode : {'impact', 'plddt'}, default='impact' + ``'impact'`` paints the red-white-blue feature-impact ramp; ``'plddt'`` paints the + AlphaFold pLDDT confidence palette. + focus : {'whole', 'fade', 'zoom'}, default='whole' + ``'whole'`` styles every residue equally; ``'fade'`` ghosts residues outside the + window; ``'zoom'`` points the camera at the window. + focus_region : tuple or list of tuples, optional + ``(start, stop)`` residue range (or list of ranges) defining the focus window. + Default derives the window from the union of ``df_feat`` positions. + size_by_impact : bool, default=True + If ``True``, draw a stick whose radius (or marker size) is proportional to + ``|impact|`` (impact mode only). + backend : {'py3dmol', 'mpl'}, optional + ``'py3dmol'`` (interactive) or ``'mpl'`` (static). Default uses py3Dmol when + available, otherwise matplotlib. + + Returns + ------- + view : StructureView + A thin wrapper over the rendered view exposing ``show()``, ``write_html(path)``, + ``savefig(path)`` (matplotlib backend), and ``_repr_html_`` for inline display, plus + the mapped ``dict_impact`` / ``max_abs`` for inspection. + + Notes + ----- + ``tmd_len``, ``start``, ``jmd_n_len`` and ``jmd_c_len`` must match the geometry used when + the features were generated, otherwise the impact lands on the wrong residues. + + Raises + ------ + ValueError + On invalid arguments (e.g. an unknown ``mode`` / ``focus`` / ``backend``, neither or + both of ``pdb`` / ``uniprot``, a ``df_feat`` missing ``col_imp``, or an unknown ``chain``). + RuntimeError + If ``backend='py3dmol'`` is forced without py3Dmol installed, or an AlphaFold model + for ``uniprot`` cannot be fetched. + + Examples + -------- + .. include:: examples/csp_map_structure.rst + """ + # Validate + ut.check_df(name="df_feat", df=df_feat, cols_required=[ut.COL_FEATURE, col_imp]) + ut.check_str(name="col_imp", val=col_imp) + ut.check_number_range(name="tmd_len", val=tmd_len, min_val=1, just_int=True) + ut.check_number_range(name="start", val=start, min_val=0, just_int=True) + jmd_n_len = ut.check_jmd_n_len(jmd_n_len=self._jmd_n_len) + jmd_c_len = ut.check_jmd_c_len(jmd_c_len=self._jmd_c_len) + ut.check_str_options(name="mode", val=mode, list_str_options=LIST_MODES) + ut.check_str_options(name="focus", val=focus, list_str_options=LIST_FOCUS) + ut.check_str_options(name="backend", val=backend, list_str_options=LIST_BACKENDS, + accept_none=True) + ut.check_bool(name="size_by_impact", val=size_by_impact) + if chain is not None: + ut.check_str(name="chain", val=chain) + if sequence is not None: + ut.check_str(name="sequence", val=sequence) + focus_region = check_focus_region(focus_region=focus_region) + if (pdb is None) == (uniprot is None): + raise ValueError("Exactly one of 'pdb' or 'uniprot' should be given " + f"(got pdb={pdb}, uniprot={uniprot})") + + # Compute per-residue impact (shared CPP normalized-sum backend) + dict_impact, max_abs, positions_union = compute_residue_impact( + df_feat=df_feat, col_imp=col_imp, start=start, tmd_len=tmd_len, + jmd_n_len=jmd_n_len, jmd_c_len=jmd_c_len) + resolved_backend = _resolve_backend(backend) + window_resis = _resolve_window_resis(focus, focus_region, positions_union) + + # Resolve the structure file, parse it, and render inside one temp context + with tempfile.TemporaryDirectory() as tmp_dir: + pdb_path = pdb if uniprot is None else self._fetch_alphafold(uniprot, sequence, tmp_dir) + structure = load_structure(pdb_path) + records, identity, chain_id = extract_chain_residues( + structure, chain=chain, sequence=sequence) + self._check_start_alignment(records, positions_union, identity, sequence) + view = self._render(resolved_backend, pdb_path, records, dict_impact, max_abs, + mode, focus, window_resis, size_by_impact, chain_id) + + if self._verbose: + struct_resis = residue_numbers(records) + n_painted = sum(1 for r in struct_resis if abs(dict_impact.get(r, 0.0)) > 0) + ut.print_out(f"CPPStructurePlot: mapped {len(df_feat)} features onto " + f"{len(records)} residues ({n_painted} carry non-zero impact), " + f"mode='{mode}', backend='{resolved_backend}'.") + return view + + # Internal orchestration helpers + def _fetch_alphafold(self, uniprot, sequence, out_folder): + """Fetch the AlphaFold model for ``uniprot`` into ``out_folder``; return its path.""" + from aaanalysis.data_handling_pro import StructurePreprocessor + # The download is by accession; the sequence column only satisfies df_seq validation. + seq = sequence if sequence is not None else "M" + df_seq = pd.DataFrame({ut.COL_ENTRY: [uniprot], ut.COL_SEQ: [seq]}) + stp = StructurePreprocessor(verbose=self._verbose) + df_status = stp.fetch_alphafold(df_seq=df_seq, out_folder=out_folder, + file_format="pdb", on_failure="raise") + model_path = df_status["model_path"].iloc[0] + if not (isinstance(model_path, str) and os.path.isfile(model_path)): + raise RuntimeError(f"AlphaFold model for '{uniprot}' could not be fetched " + f"(model_path={model_path})") + return model_path + + @staticmethod + def _check_start_alignment(records, positions_union, identity, sequence): + """Warn if the mapped positions miss the structure (likely a wrong ``start``).""" + if not positions_union: + return + struct_resis = residue_numbers(records) + if struct_resis and not (set(positions_union) & struct_resis): + warnings.warn( + f"None of the mapped residue positions " + f"[{positions_union[0]}..{positions_union[-1]}] are present in the " + f"structure's residues; check that 'start' matches the structure numbering.", + UserWarning, stacklevel=2) + if sequence is not None and identity < 0.5: + warnings.warn( + f"The selected chain matches 'sequence' with low identity ({identity:.2f}); " + f"the painted residues may be misaligned.", + UserWarning, stacklevel=2) + + @staticmethod + def _render(resolved_backend, pdb_path, records, dict_impact, max_abs, mode, + focus, window_resis, size_by_impact, chain_id): + """Dispatch to the resolved render backend and return the StructureView.""" + if resolved_backend == "py3dmol": + return render_py3dmol(pdb_path=pdb_path, records=records, + dict_impact=dict_impact, max_abs=max_abs, mode=mode, + focus=focus, window_resis=window_resis, + size_by_impact=size_by_impact, chain_id=chain_id) + # The mpl backend only scatters the selected chain's records, so it never + # leaks onto other chains and needs no chain qualifier. + return render_mpl(records=records, dict_impact=dict_impact, max_abs=max_abs, + mode=mode, focus=focus, window_resis=window_resis, + size_by_impact=size_by_impact) diff --git a/docs/source/api.rst b/docs/source/api.rst index 6826975e..ca689a91 100755 --- a/docs/source/api.rst +++ b/docs/source/api.rst @@ -103,6 +103,7 @@ Feature Engineering CPP CPPGrid CPPPlot + CPPStructurePlot .. _pu_learning_api: diff --git a/docs/source/index/docstring_guide.rst b/docs/source/index/docstring_guide.rst index 00c663bb..1e2bbd7d 100644 --- a/docs/source/index/docstring_guide.rst +++ b/docs/source/index/docstring_guide.rst @@ -335,6 +335,9 @@ Rules: * - ``CPPGrid`` - ``cppg`` - + * - ``CPPStructurePlot`` + - ``csp`` + - ``pro`` * - ``dPULearn`` / ``dPULearnPlot`` - ``dpul`` / ``dpul_plot`` - diff --git a/docs/source/index/release_notes.rst b/docs/source/index/release_notes.rst index cd11c368..fe6163e1 100644 --- a/docs/source/index/release_notes.rst +++ b/docs/source/index/release_notes.rst @@ -94,6 +94,13 @@ Added exact two-fit estimate (~2x faster than the threshold default on the same cell), ``5`` adds light Monte-Carlo averaging, and the mean converges (run-to-run spread below ~5%) around ``n_rounds ≈ 15–20``; a fixed ``random_state`` keeps every run reproducible. +- **CPPStructurePlot** (``[pro]``): Paints per-residue CPP / CPP-SHAP feature impact onto a + 3D protein structure. ``map_structure(df_feat, pdb=...)`` (or ``uniprot=...`` to auto-fetch + the AlphaFold model) reuses the same normalized-sum mapping as ``CPPPlot.profile`` and + returns a ``StructureView`` with a uniform ``show`` / ``write_html`` / ``savefig`` surface + over an interactive `py3Dmol `_ backend (added to the + ``[pro]`` extra) and a static matplotlib fallback. Supports an ``'impact'`` red-white-blue + ramp and an ``'plddt'`` AlphaFold-confidence mode, with ``whole`` / ``fade`` / ``zoom`` focus. **Sequence Analysis** diff --git a/examples/feature_engineering_pro/csp_map_structure.ipynb b/examples/feature_engineering_pro/csp_map_structure.ipynb new file mode 100644 index 00000000..4f0ae3a4 --- /dev/null +++ b/examples/feature_engineering_pro/csp_map_structure.ipynb @@ -0,0 +1,490 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "c47449f2", + "metadata": {}, + "source": [ + "# `CPPStructurePlot.map_structure`\n", + "\n", + "Paint per-residue **CPP / CPP-SHAP feature impact** onto a 3D protein structure. Each feature in a `df_feat` is mapped to the residues it spans and its signed impact is aggregated per residue with the **same normalized-sum** as `CPPPlot.profile`, then painted onto the structure cartoon. The method returns a `StructureView` with a uniform `show()` / `write_html()` / `savefig()` surface over an interactive **py3Dmol** backend and a static **matplotlib** fallback (used here so the figures render in the docs).\n", + "\n", + "This is a `pro` feature (needs `biopython`; `py3Dmol` for the interactive backend)." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "efeb7c0c", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-26T03:04:29.894099Z", + "iopub.status.busy": "2026-06-26T03:04:29.893668Z", + "iopub.status.idle": "2026-06-26T03:04:31.211989Z", + "shell.execute_reply": "2026-06-26T03:04:31.211739Z" + } + }, + "outputs": [], + "source": [ + "%matplotlib inline\n", + "import numpy as np\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "import aaanalysis as aa\n", + "import aaanalysis.utils as ut\n", + "\n", + "aa.options[\"verbose\"] = False" + ] + }, + { + "cell_type": "markdown", + "id": "8456f226", + "metadata": {}, + "source": [ + "## A tiny structure and `df_feat`\n", + "\n", + "Normally you pass a real `.pdb` / `.cif` path (`pdb=...`) or a UniProt accession (`uniprot=...`, auto-fetched from AlphaFold DB). For a self-contained example we write a small synthetic structure (one Cα per residue; the B-factor column doubles as pLDDT) and a `df_feat` with two known features — a whole-TMD segment and a whole-JMD-N segment." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "67f14989", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-26T03:04:31.213255Z", + "iopub.status.busy": "2026-06-26T03:04:31.213116Z", + "iopub.status.idle": "2026-06-26T03:04:31.275463Z", + "shell.execute_reply": "2026-06-26T03:04:31.275245Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "DataFrame shape: (2, 3)\n" + ] + }, + { + "data": { + "text/html": [ + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
 featurecategoryfeat_impact
1TMD-Segment(1,1)-LDKEPolarity0.800000
2JMD_N-Segment(1,1)-CHAMEnergy-0.400000
\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import tempfile, os\n", + "tmp = tempfile.mkdtemp()\n", + "pdb = os.path.join(tmp, 'demo.pdb')\n", + "lines = []\n", + "for i in range(40):\n", + " x, y, z = i*1.5, np.sin(i*0.5)*5, np.cos(i*0.5)*5\n", + " b = 40 + (i % 60) # pLDDT-like 40..99 in the B-factor column\n", + " lines.append(f\"ATOM {i+1:5d} CA ALA A{i+1:4d} {x:8.3f}{y:8.3f}{z:8.3f} 1.00{b:6.2f} C\")\n", + "lines.append('END')\n", + "open(pdb, 'w').write('\\n'.join(lines) + '\\n')\n", + "\n", + "df_feat = pd.DataFrame({\n", + " ut.COL_FEATURE: ['TMD-Segment(1,1)-LDKE', 'JMD_N-Segment(1,1)-CHAM'],\n", + " 'category': ['Polarity', 'Energy'],\n", + " 'feat_impact': [0.8, -0.4],\n", + "})\n", + "aa.display_df(df_feat, n_rows=10, show_shape=True)" + ] + }, + { + "cell_type": "markdown", + "id": "c8ac952c", + "metadata": {}, + "source": [ + "## Construct the plotter\n", + "\n", + "`jmd_n_len` / `jmd_c_len` are the juxta-membrane lengths used when the features were generated (stored and reused by `map_structure`, mirroring `CPPPlot`). `df_scales` is accepted for parity with `CPPPlot` but is not needed for structure mapping." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "74b92ffe", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-26T03:04:31.276397Z", + "iopub.status.busy": "2026-06-26T03:04:31.276330Z", + "iopub.status.idle": "2026-06-26T03:04:31.277834Z", + "shell.execute_reply": "2026-06-26T03:04:31.277622Z" + } + }, + "outputs": [], + "source": [ + "csp = aa.CPPStructurePlot(jmd_n_len=10, jmd_c_len=10, df_scales=None, verbose=False)" + ] + }, + { + "cell_type": "markdown", + "id": "4ba25bae", + "metadata": {}, + "source": [ + "## Impact mode with fade-context\n", + "\n", + "`mode=\"impact\"` paints the white→red / white→blue ramp (red raises, blue lowers the prediction). `focus=\"fade\"` ghosts residues outside the feature window; `size_by_impact` scales the per-residue marker / stick by `|impact|`. `col_imp` selects the signed impact column, `tmd_len` the TMD length, and `start` the absolute residue number of the first JMD-N residue (here the features cover residues 1..20)." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "eeb12019", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-26T03:04:31.278676Z", + "iopub.status.busy": "2026-06-26T03:04:31.278625Z", + "iopub.status.idle": "2026-06-26T03:04:31.339027Z", + "shell.execute_reply": "2026-06-26T03:04:31.338809Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "view = csp.map_structure(df_feat=df_feat, pdb=pdb, col_imp='feat_impact',\n", + " tmd_len=10, start=1, mode='impact', focus='fade',\n", + " size_by_impact=True, backend='mpl')\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "9c9dff22", + "metadata": {}, + "source": [ + "The per-residue impact is the normalized sum: the TMD impact `0.8` spread over its 10 residues gives `0.08` each; the JMD-N impact `-0.4` gives `-0.04` each." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "7aea7399", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-26T03:04:31.339971Z", + "iopub.status.busy": "2026-06-26T03:04:31.339910Z", + "iopub.status.idle": "2026-06-26T03:04:31.342976Z", + "shell.execute_reply": "2026-06-26T03:04:31.342796Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "DataFrame shape: (30, 2)\n" + ] + }, + { + "data": { + "text/html": [ + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
 residueimpact
11-0.040000
22-0.040000
33-0.040000
44-0.040000
55-0.040000
66-0.040000
77-0.040000
88-0.040000
99-0.040000
1010-0.040000
\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "df_imp = pd.DataFrame({'residue': list(view.dict_impact),\n", + " 'impact': [round(v, 3) for v in view.dict_impact.values()]})\n", + "aa.display_df(df_imp, n_rows=10, show_shape=True)" + ] + }, + { + "cell_type": "markdown", + "id": "ed4c2279", + "metadata": {}, + "source": [ + "## Zoom-to-window, an explicit `focus_region`, and chain / sequence selection\n", + "\n", + "`focus=\"zoom\"` points the camera at the window; `focus_region=(start, stop)` (or a list of ranges) overrides the auto window. `chain` picks a chain by id; `sequence` enables best-matching-chain selection and a sanity check that `start` lines up with the structure." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "d56b1e7b", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-26T03:04:31.343833Z", + "iopub.status.busy": "2026-06-26T03:04:31.343764Z", + "iopub.status.idle": "2026-06-26T03:04:31.390656Z", + "shell.execute_reply": "2026-06-26T03:04:31.390453Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "view_zoom = csp.map_structure(df_feat=df_feat, pdb=pdb, tmd_len=10, start=1,\n", + " mode='impact', focus='zoom', focus_region=(11, 20),\n", + " chain='A', sequence='A'*40, backend='mpl')\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "dba5ba58", + "metadata": {}, + "source": [ + "## pLDDT confidence mode\n", + "\n", + "`mode=\"plddt\"` ignores the impact and paints the AlphaFold confidence palette (blue = high, orange = low) read from the structure's B-factor column." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "bc2f93d2", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-26T03:04:31.391537Z", + "iopub.status.busy": "2026-06-26T03:04:31.391477Z", + "iopub.status.idle": "2026-06-26T03:04:31.442515Z", + "shell.execute_reply": "2026-06-26T03:04:31.442307Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAj0AAAJOCAYAAABcJ7ZuAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjExLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlcelbwAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzsvQeYHNWV/n0maZQDCgQhBIiMyBlssDEYR5wDjtiss/13Wi+2l/XuOqzjOu7nsF4H1gavsbGNs8k552gyQiAJ5TQKM9PT3/Mr6QxXperuCreqbnXf93n6GWlCd1XdcN77ntRVr9fr4uHh4eHh4eHR5ugu+wI8PDw8PDw8PIqAJz0eHh4eHh4eHQFPejw8PDw8PDw6Ap70eHh4eHh4eHQEPOnx8PDw8PDw6Ah40uPh4eHh4eHREfCkx8PDw8PDw6Mj4EmPh4eHh4eHR0fAkx4PDw8PDw+PjkBv2Rfg4dGOWL9+vfzxj3+UAw44QA4++OCmv6Po7e2VyZMny9y5c2XvvfeW7u7uzH/zpz/9SdatW9fyevfYYw855phjxGUsX75cLr30UjnxxBNll1126fjr8PDwSA5Pejw8csCSJUvkjDPOkLPPPrsh6dHf2X///YPfoSPM6tWr5Z577pHBwUF5+9vfLp/5zGdkypQpqf/mkksuCf5G8cADD8jdd98tp5xyikyfPn30+yeddJLzpOfvf/97cO9/+MMfSiU9rlyHh4dHcnjS4+FRMk4//XT50pe+tM33UHPOOuuswLBed911MnPmzFR/881vfnOb3+FvID2f+9zn5Nhjj83xrjw8PDzcg4/p8fCIiWeeeUb+7//+L/iKwgKxuOiii+TJJ5+0/gxf9rKXyYUXXigPP/xwoBbl9TdxsXHjRrnyyivlt7/9rdxyyy1Sq9UaPhtw0003ye9+9zt5/PHHY38Gz/T222+X3//+93LDDTcErjzFggUL5LLLLgv+fc011wSfxevBBx+M/Pybb75ZfvWrX8maNWuCa+BnYTcf98T3eV5hjIyMBNfCPfBeqGhxriPJZzW7ZgX/xqXHc4esenh4ZINXejw8YgIXEm4NDNV3v/vdIJ5m7dq1cscdd8gnPvEJ+eIXv2j1WT7nOc+RI488Un7xi1/I9773Penv78/lb1qB+33/+98v06ZNk3333VduvfXW4N+//OUv5dBDD93m2UC6fvjDH8rmzZsD0nLbbbfJF77wBfnkJz/Z9DMee+wxeelLXxo8zyOOOCIw9k888UTgqkO9WrhwYUAyAIQI8gEmTpwYXJN+Ptf0gx/8ICAt/A5uQK73He94R+Da22+//UY/c8WKFcHffOc73wnioRRXXXVV8Jlcw+GHHx5c06pVq+RHP/pRQMyaXQd/G/ezml0zcVqoccwp3gc3GkTywAMPDIjRrFmzMo+rh0dHou7h4RELl1xySZ0lc9hhh9Xvuuuu0e//4Ac/CL7/05/+dPR7Dz/8cPC9s88+u+H7xfmd973vfcHv3H777an/xsQXv/jF4Gc33HBDrHu+6aab6j09PfV3vvOd9VqtFnxv1apV9aOOOqq+00471VevXr3Nszn66KPr99xzz+jff/jDH6739fXVFyxY0PRzXvva19b333//+qZNm0a/x3v/6le/Gv3/NddcE3zGH/7wh6Zjc+eddwbfW7duXf2ZZ56p/+QnPwl+9sADD2zzNwsXLgy+/53vfGf0e/zO+PHj6694xSuCv1c88cQT9SuuuKLldST5rGbX/OUvfzn42S9+8YvR31+2bFn9wAMPrJ9yyilNn6WHh0djePeWh0dCvOAFL9gmOPnd7363HHLIIfKtb33L+rPcYYcdgq8oDXn+TSOgTIwZM0a+9rWvjWaGTZ06Vb7yla8EAdLnnXfeNr9/6qmnyvz580f//773vU+Ghobk8ssvb/o5ixYtCtQSPktBMPZrX/vaRNf7vOc9LxgLwPslVUS4T1x3//3f/x38vYLsON47D4SvmfFD4XnFK14hb3zjG0d/b8aMGfLP//zPgbsLJcnDwyM5vHvLwyMhcB9Ffe8nP/lJ4KKISjVPC2JBwIQJE3L9m0a48847ZZ999gncWSY004ufmzjssMO2+f+cOXOCr7inmoGss/e85z0BYXrNa14TZJPhqkvqnosamyQgrob7LdJ9FL5mssPIyGP8fv3rXwcuNcBXjR+79957AzeYh4dHMnjS4+GREOPGjYv8HoQHlcAm6eFE39XVJXvttVeuf9MIBPCqcmQCRaanp2c0wFdhptfr7wFifJoBtQz1jFgkss+IA5o0aZJ89atflXe9612xrzec5QZ0PJQ8KKKuie+FCV4SJPmsRtespJWgZ0hPGG94wxtkxx13TH2NHh6dDE96PDwS4pFHHon83uzZs6Wvr8/a8ySrB7fQc5/73G1q6tj+m1ZFCwnUDitYBB5D8Pi5LZBCr2n0S5cuDdSf9773vUF6PkYeItcKUb+z0047jRY3bDWOqDzXX3+9DA8PB4HqcT8jzWc1er8999wzeNaoXZA+Dw8Pe/AxPR4eCUEci3lyR1mhCKAZf5EVZA6R2YNBjGv40vxNK6AqQEDOP//8bb7/9a9/PTDMr3/96618Tji1HffSi170ooBsaWwSMS3ATOmOA1xmEBjGSIESQzZWGGRtrVy5Ur797W9v97PFixe3vI4kn9UIkNVXv/rVgbv06aef3u7nuLh4Lh4eHsnhlR4Pj4QguPa0004LvpLOTAAzxo706jAgRKR8h0F6M+4b83cwjrzfXXfdJRdccEHgVvrrX/8qRx99dMP3TfI3aXDmmWfK3/72N3nnO98Z1K0hfZo6NaRNf+Mb37AWV0Ka99ixY4MWE7vuumtAgniur3rVq0ZTv+fNmxe47P7zP/8zIJ3jx48PYoh4ls1AujfuMwozouDstttugQuNQGHuw8QrX/lK+dSnPiUf//jHg/gegox5vtTr+Yd/+IfgOTS7jiSf1QwEUlN3CZcf7j3ee9myZUH6PePA+Nt0o3p4dAo86fHwSIijjjoqMGI//vGPAzfGOeecExhEM9YHQoNKAjCYYbzkJS8JiJP5OygE/B2ZQr/5zW8CF1XY9RF+3zh/Y4JeYPy9qhWtwHtBrv7yl78EZOraa68N3C8YXq3Ro24d3lfdOwoMM99v1IpDQeFDyNQVV1wRuOdQeqhfQ7sMBfd68cUXB8+d3yMrTOvjNPp8BcoNAcNXX321DAwMyGc/+9nANcdn4dIy8R//8R8BoaXmELV4IGFUtlYi2ew6knxWs2smroh6QH/+85+Dv+NzcJ+i5BH3RDyVh4dHcnSRt57i7zw8Og6kCpOSjevCNMYeHh4eHtWA10c9PDw8PDw8OgKe9Hh4eHh4eHh0BDzp8fCIiVZxIx4eHh4ebsPH9Hh4eHh4eHh0BLzS4+Hh4eHh4dER8KTHw8PDw8PDoyPgSY+Hh4eHh4dHR8CTHg8PDw8PD4+OgCc9Hh4eHh4eHh0BT3o8PDw8PDw8OgKe9Hh4eHh4eHh0BDzp8fDw8PDw8OgIeNLj4eHh4eHh0RHwpMfDw8PDw8OjI+BJj4eHh4eHh0dHwJMeDw8PDw8Pj46AJz0eHh4eHh4eHQFPejw8PDw8PDw6Ap70eHh4eHh4eHQEPOnx8PDw8PDw6Ah40uPh4eHh4eHREfCkx8PDw8PDw6Mj4EmPh4eHh4eHR0fAkx4PDw8PDw+PjoAnPR4eHh4eHh4dAU96PDw8PDw8PDoCnvR4eHh4eHh4dAQ86fHw8PDw8PDoCHjS4+Hh4eHh4dER8KTHw8PDw8PDoyPgSY+Hh4eHh4dHR8CTHg8PDw8PD4+OgCc9Hh4eHh4eHh0BT3o8PDw8PDw8OgKe9Hh4eHh4eHh0BDzp8fDw8PDw8OgIeNLj4eHh4eHh0RHwpMfDw8PDw8OjI+BJj4eHh4eHh0dHwJMeDw8PDw8Pj46AJz0eHh4eHh4eHQFPejw8PDw8PDw6Ap70eHh4eHh4eHQEPOnx8PDw8PDw6Ah40uPh4eHh4eHREfCkx8PDw8PDw6Mj4EmPh4eHh4eHR0fAkx4PDw8PDw+PjkBv2Rfg4eGxLer1+ui/u7q6/OPx8PDwsARPejw8HCM8Q0NDsmHDBunp6ZHe3t7gxb8hQJ4EeXh4eKRHV908Vnp4eJQCluHIyEhAePi6efPm0e8r2YH49PX1BV95dXd777SHh4dHEnjS4+FRMiA2w8PDwUsxODg4Smr4uZIiT4I8PDw80sOTHg+PEmGqOwCiw79N0hNGmATp35muMK8EeXh4eGwPT3o8PBxwZ0FaNF6nFemJeq8oJciTIA8PD49t4UmPh0dJwcq1Wm3LIgwFKCclPVHvrwTo7rvvlj322EMmT568DQniqw+K9vDw6DT47C0PjwKh6g6Ex1R3wshCSDToGWzatGn0+3wuZCqsBJnZYR4eHh7tDE96PDwKAKoLRAfiwb+bER79fWCLiCgJ0vdW8qUkiOsJZ4d5EuTh4dFu8KTHw6Ngd1YrwmMTUZ9jKkHNSFA4JsiTIA8Pj6rDkx4Pjxyh6k44WLlItCrFZZIg/V2NK6JekCdBHh4e7QJPejw8Cqi9Uxbh4TOT1B/Va/QkyMPDox3hSY+HR861d8psH5H1c6NIkL5QgVCDgHeHeXh4VAGe9Hh4FFB7JwlsEySbnWZMAgcRCpMg0x2mQdHEBZWldHl4eHiY8KTHw6PiwcrNkPc1NCNBmi5vkiANjHbl+Xh4eHQWPOnx8Cio9k4S2CQERfYUjkuCwh3kPQny8PAoAp70eHhkrL1DsHKZ2VnNUPb1NCJBPC8lQTy3cEyQi8/Sw8Oj+vCkx8OjjdxZZSs9WUjQqlWr5LHHHpODDjrIkyAPD49c4EmPh0cFa+/EhcvXFpXZtm7duuD/PGNejQKjy8yI8/DwqC486fHwSFF7J04rCVfgktITB+ruAqoEqRtRyU44JsiTIA8PjzjwpMfDIwbU/YIxHjt2bGUITxWusRmUzIRJEAQIta0RCUrbod7Dw6O94UmPh0fM2jt///vfZebMmTJ37txKPbOqKT22SJDZPNWTIA8PD+BJj4dHglYSVSMQVVd6spKgRtWiPQny8OhMeNLj4dGi9o4a1aR9rFxBFa/ZNgkyO8jz8iTIw6Mz4UmPh0fM2jtVJD3trvSkIUFKaFUJCpMgzQ7z8PBoP3jS4+ERs/ZOke4tmwSrakQtT2i8j8IkQVFKkJkd5uHhUX140uPhsdWdhdFrVnvHKz2dSYKYD+HAaE+CPDyqCU96PDoa6s7CyLWqvVNF0gOqeM2uk6BwTJAnQR4e1YAnPR4di6StJPgZBrBKqCpRc5EE6XNUVZBq0U8//XRQxmDSpEmeBHl4VACe9Hh0HMzTO/+OW823igTCKxD2n6VJghYtWhQQnv7+/m1aZnglyMPDTXjS49HRtXeStC+oIukBVbzmqpEgSI6pBEGAUIOAJ0EeHu7Akx6PjoGqO+qiSlqgjt9XV1hV4JWe4gilSYLMDvK8IEGNmqdWpaWJh0c7wJMej45yZ2XpjO6VHo9G86LR900iZJKgTZs2jf6OkiCzb5gnQR4e+cCTHo+2RtJg5XYjPd545osk8yEuCYpqnurH0cPDDjzp8eiIVhI2DEcVs7dA1Yha1ZCFREeRIOaYJ0EeHvnAkx6Pjq69kwRFVWTesGGDPPjgg4HLY4cddpBp06YFp/408ApBvrA5H5qRIOKBIELMwXBgtFeCPDziw5Mej7aCTXdWGe6tJUuWyL333hvUfuGzHn30Udm4cWOQFg354TVlypRtCui1gld68kVexDKcWagkiLnNq1GKvCdBHh6N4UmPR9tA1Z0swcplkR6u+e9//3tQ9+XAAw+U6dOnj94HJ/xVq1YFrwceeCBIhYb4QIBQgiBEjTLRvNKTL7TOU5kd5LVBrv48HBOUpCyDh0e7w5Mej7arvZPXSTevmJ6BgQG56667gn8ff/zxMm7cuNEO4GDs2LGy8847By/uFeVHSdBTTz0VXNPUqVNHlaCJEydupxB4tB8akSDWAfPHkyAPj+3hSY9HW9XeyfNUm4fSs3jxYrnvvvtk9uzZsu+++7aMG+Iaxo8fH7z4G353/fr1oyTo8ccfD35HCRAqgCc97aH02CJB/J/5o7WCktar8vCoMjzp8ejo2jtlBTJDRnBnQXoOOugg2XHHHVO9D/eMe4vXbrvtFjyLdevWBQRo2bJlwdeVK1cG6pAGRaMcebQ/GpGg2267Tfbee+9AHYyqFu1JkEc7w5Mej8ohz2DlIpQe3Fl33nlncN24szh12wLvSbwPr9133z2IAYIIQXRojgnR4t+qBPEaM2aMtc/vNLik9LSCqYIq0dG11KxlhidBHu0ET3o8Orr2TtGkh0Bl3Flz5syRffbZJ9Kg2HTR8T6QnHnz5gX/x7WxevXqQAFasGBBcC0TJkwYDYrm9J82Pb4TUUXXoVnGIawE6frSmDJ+7kmQRzvB724elYBWreVFR+sy0nKzBDJD0lBdnnnmGTnkkENk1qxZUgZRw4DNmDEjeAFO+EqCHn744eD5ZkmP70RURelppU5p5pf5e61IEF+rdv8enQ1Pejych0rw1LBBnTj22GNL2WjTKj0EGuPOwkBodlZRaPWccG1BwJSEZUmP70RUUemByMRZP81IEPNCVSJ+R4OiNUXew8NVeNLjUanaO2XGUKQJZCaO5v777w+CjAkeLYMwJLnmrOnxnYiq3X/aNRSXBIXdYVV7Ph7tDU96PJyvvaMxCLzK7H2VROmBrEF2li5dKoceemhQYbkMZDE4SdPjefG7nWLkdC5U7X5tHRxMEqTPgvUJAWpULdqTII+y4UmPh3Ng44TshLOziup9lZX0mO6sE044IVWKuE1DauuZtUqPf+SRRwI3h0mCfHq8e8hDLTV7hulnAE+CPFyDJz0ezsCUy3VjNjfnsrucxyE9uICIhZk7d67stddeqd1ZNolKXkQxnB4PSV2zZk1AgjohPb7TlZ60JAgVqFmKfNWep0e14EmPh5OtJKLStl1QehqRLq4bdxaKR5nurCgU9cwwWAQ782qWHq9FEqueHl/FIGa95qJjy0wSZHaQ5xUmQRoUzdzwzVM9bKO6O45HW9beMeuGhOFqTA8uHtxZqBhp3Vl5ocxTc9L0+KpmhVVJmXBFnTIPNWESxLzQ31ES5DvIe9iCJz0epcHsEB2nlUTZ7q2w0sS/cePgzsK9QwFAFw23K4pEnPR4QIB0FdLjXXmuVSQ9SUkQc4OWLXvuuacnQR6Z4EmPR2VaSbjg3tLPh6jhrlmxYoUcdthho2qGa3DNuDVLj8c1iIuQNh1VSo938ZqqRnpakSCID9XM99hjj22UIHWDeSXIIy486fEoHJrRkbRRqCvuLdxZd9xxR2C0KTbokjurqoqEtsvAiM2fPz8yPZ7xN0lQ2enxVXiuVSU9jYKvwzFBGhgNEdKyFp4EeTSDJz0ehbuzNDsraZCiko4yCxRy/TfeeGPgziI7y3Xj4fr1tUN6fJWesR4aqnTNQA9IinCig+4LrE9ejeoE+cBoD096PCrTGd1sjFj0po0766GHHgo++/DDD5fp06fn+nku1ukpEy6mx1fxuVZV6QmTnjCimqdGkSB1h5l9w6r2LDyywZMej9xhqjtZNhn9u1YboG2sXbt2NDsL5E14bKJdN/Q46fHEACkByjM9vkrPuKqkR5XhuGhEgpgn7EX683BMkCdB7Q9PejxKrb2TBOYGVgT4nIULF8qDDz4YZI3ssssuctVVV5XqXusURcJWevzKlStz6x5fRQJRtbmbtEmqDRJkNk91OXvQIx086fHItfaOxhDY2Dz0PYoIZuba77333sBwHnHEEYGigERedEVbV96namiVHs/4Tp48ueO6xydVTFyBbXU3LgkKV4uu4rPz2Bae9Hjk1koiaXZWEvdWniBWBHcW2UFkZ/X392/z+VVSTvJsQ1ElNOoejxKUNj3eKz3tQ9YakSDtIN+oZYYnQdWDJz0eTgUrx9mY8jLivO+TTz4ZBCzjzuIV7v2lv1clVO1680ac7vFmejxK0Lhx47aby1V8rp3q3rJNgrwSVF140uNhvZVEnmmhedXqMd1ZRx55ZGDsylKazE02K6po4FxKj1+6dGnT9PiqPd8qk54yVZUoEqR7Hi/9HVMJ0uwwD7fgSY9Hoa0ksiIPpQeic9dddwUuDXpnNUp1LjqQ2haqdr1VSY+HJPFsOflXpXt8VUmPa7FIGvSsMEmQKkFcb1R2mEe58KTHw1l3Vt5KD9dPejPZPRQaxMC16v2lf1cV+E02v/R4VCBw7bXXFpYeXzU3UadcdzMSRPmEmTNnBqUuwtlhLt9Tu8LNlelRmdo7Rag7eTQd5TSGO4saPI3cWVGfXTXSU8XrrUp6PHE+VIc+7rjjck+P73Slp2z3VhYSRLwY8yUcExQVGF3FsakaPOnxyFR7p+iy7jaajmKgyM7CMJGdlcQ1UbVsKL+J5o8qpcdXlfS45t5KStiU1ADdP7QHYaOWGZ4E5QNPejxS194po3ppFvcWm80TTzwRBKbGcWflqTQViSqRtCqhEYHIIz0+72t2Ha67t1qp4qbSZ3aPjyJBzVLkq/oMXIInPR4tof5pqhNzUuVkW9biS0s62EjuueeeICvnqKOOCoxOWUpTkfCbZHXS41lbkKCo9PhOV0yq5t5K2jcsTIL0hQpkkiCNB4II+eap6eBJj0fsYGVIA/ELWqyvDKQhHRgXsrNwMZCdxcaRFkW5t3zDUfeRRjVplh7/zDPPBDFBeXaPr6rSw3W7EheVN2EzFXTu2SRBuE71d5QE+Q7yyeBJj0fs2ju6AMtEEqWHa+Uk/eijj8ree+8tc+fOTb3hb970gAys+6vM2flh2TTwkIwf9yrp7dtJXEcVDVxVYGMtFN09vqqkp8rurawqlSdBduFJj0fs2jt5FQbMQ+lBEr777rtlYGBAjj766MCopMX6tX+UNSt+EPx7wjiRoU0LZenTV8iMnT4rY8buJ66jbKLazrBtiPPuHl9V8lBV9xbXbVulikuCwjWCvDtsCzzp8Yhde8cV0tPqGggYxZ2FQSA7K4s7q1ZbI2tW/ni779frG2X1ih/IrNnfkDzgG466jyLIZFT3eI0HSpMeX2Wlp6qkBxTRNyxMgvhsJUF8fjgwurvgzFtX4EmPR+zaOy6QnmbuLRb6Y489Frz22WefIGYi66LetOEWkfqWMvNhDA0+IsNDz0hv347iMrzSkx+KNhq4tnbcccfgFU6Pv//++wNliNg1DYoOp8dXlfRU9bqLID1xSRD7e61WC+ZMJ5MgT3o8tqm9o9kdUZPfZfcWWQ64s0gPzurOUgQtBjZvbPE7W+oV5QEbG1AnbGKdTCaj0uNROiFBZFuG0+O9e6v9SU/c5qm1rSRI6wSpO8zsG9aO+4cnPR0OFiVkJ04rCVdIT/gaVqxYERAeNvXDDjssUwsA3hvDQSwQr+6u3aRXcBdseT4m6rKTLFo8LJMmrQxO1FncaGGQyYPh4sSepaJv1YopVg0uGQUzPX7XXXeNTI/ne6wPgqTzTo+3iaq6t/JuwGyTBA0PDwdKv/48qm+YS/eRFp70dCjM3jAqHbea0K65t7huMrPYzPfdd1+ZM2dOqkXJ+23YsCEgOXxlgU+YMCE4Pff37y7rVr9W1q3+ZeivemX6ju+VkfqMIOWYUzUGBNcCRift5sC1PPjgg4FRgvBoRV+Ij1nRN8n7e9KTD1x/rlHp8cQBFZUebxNVdm+5Tta6mpAgsgeZPzvttNN2fcNcv69G8KSnAxFuJRGXwbvk3kKSJVgZ//QxxxwTkI2kJzCT6LCYITq77LLLdsUXJ097i/SNmScD6/4i69YulP6x82TGjm+UMf17BT/n73iWkJ/ly5cH31Njk0T9QWGiPQbP+Nhjjx2VmE2XxZNPPhn8rhKgVqf1KhqKqqBqhpi1A6kh+2v+/PkN0+N1XuEWc6V7fBXIQ7tcd5dBgjRQnv9HKUFVJEGe9HRw7R2T3ceBC6SHa4aoXHfddUHX4sMPPzy2O4tFq0QHIsGGDmHRKtPNMG7CccHr4cdvCOqpjOnfeZufcw1qKHhvGpkmUX9oXImLjgDV/fffP/hdbUxouizCxeweeuihoFikSYLC9+K6IlFlVIn0hCsyN0uPp10LrjFXusdXkTxU+brDLTQ08DnKHQbMoGi+BxlyVTX0pKfDa+8kAX+jsT9l3QNkAqN/wAEHBCSg1T2wACE6bOCoQxAEiA4pwGlicFrVCTJJShz1h/eiFxhGhnuiVQFoRC6jitlF1XFRAuQJT36o4rNtpk7ZTo+3fd1VJA/hvlvtcP1dDdxh2kH+S1/6UnAgO/fcc8VFeNLT4bV3kqBMpYcNFyUEAoN/mfidRuBeNRAZoqOSPipK1pNqksDgVuoPP9eMM9xZGJSkYENC8eJlGircYcQGaWYGpCoqhdmjs5SeJNlbcdLjNdYs77nls87K7RDfDGESxL7LwdJVeNLT5tDOvWnVHRNM/jJID0oJ5IATKBtr+BqC1PLBwVFFB9JjupVsV0NNesKPUn/otr106dLgOkmxtyUFm4aK61y8eHFQt4jP1HggbW7JqyrZOy6i3ZSepOnxrDclQVHp8Ta7x1fVTVTV686iVEF6Zs2aJa7Ck542d2dpdpaNtMmilR4+C9cPbhviXHD98H/UCyU6kBwWGWSC0wWbLl/z2mjSdnlXsIEQPMo97bHHHoFhWLRokZXMr6hrxZ2HonTQQQcFzwzygwpEDBHPElebusLixDZ5bP+MOzH4mvdgnfFqlB7PGjQzw7IQ7Kq6tzqV9ExKoVoXBU962hC23Fm2DX4SIKWTncV9qOtH0+whO6gW/BuSgGuHDbWIzSVL3RuIGZ3qIT1HHXVUYAj0++HYH1vysDnu/BtixctsbgkJ4qSOy0IDu8sOXK0COk3pSdM9nrmlAfcQ6rTp8VV1b7VDTE93wn0VBZB92VX4Ha3NYKo7totJsXg1Wj8r6vVB6Jh0dfU2zGRCIt1vv/0CUsD3OEFAhtgAZ86cWYprJm7D0zAwAHfccUdwzfQDMxWVqNgfTsuoMBCU8H1u3vygDAxcJrXaSunrmysTJ75Qensbt8JodL3h7B3GVuOBNHBVWxpofaAqn1rzQNUMcVGKiRlwj6KZNT2+qopJVa87S7NUzfpzFZ70dHjtnaLdW0ObH5R1q34qg5vuDEhP//jjZNK0f5Devp1Gi6eh4uy1116B6sAGCfi3xqmQrVTWSSKN0kP8DkUGUVe4r2Y1dTT2x8ycgYSwifDatOkyWbPmf0f/ZnDwAdmw4QqZPv1s6e/fN/I94wKSBdFUf7xZH4h7YHz0lI6xsumKqyKqVqenzGvOkh6v2UFVJA9VJj21rZ4C797ycLb2Tt59XrKSnqHBJ2TlkrOlXt/S+ZfWDps3XCtDm/8u46d+Te659/Hg/efOnTta8IpMLeJSXOn0noT0sGlAdpD3Dz300ECdigs2fE7JbP4oLhiFRYselp6e87f73Xp9c0CEZs36glU3DAoTcVS8NGYDEkTbDyphc41mPBDj5OE2XCFqSdLjWQPAhevOI/up3UjPhg0bfPaWR/6tJGxkZ7VCVsIxsObXBuF5FiO15fL4oz+VMWNODQgPm124KrJ5DWXGUsQlPSx83FlcL+4sCETaz+Nvea1bd5+sXRvd4HRo6AkZHl4qvb3bZk3YDIrWmA3GiA0RNxwkSJUs1DglQJ0QD+QKgUgCVxWTZunxzC1w7733BvF7VSq9kCYmpsp9w+r1ehCG4N1bHpUJVs5V6dl8X8OfTZ+6Qnaee7jz/b/iBHOj7BCwjEJCTzBbm153d6vxjb6uPEgipz91RcybN280Hsg8qRMPpCSIf1d1828EH8icH8z0eFSga6+9NnC74hLLOz3eJrhOm42Iq6BSDXjS45HHZFTCU2QH36yEo7t7stRkceTPxk/YMdZ9FJlB1ujzGxk7rossFTZlUsRxzdnE2LEHQzciO7739u4ivb3bf15RcyMqHkhJEARQjZS6w1CFXDRSSVG1e6iqOgU4RFCUNO/0eJuoekxPd4pr96THw6lWEmWSnnETT5WhlQ82/FncayjzhN3o880U++OOOy4XebenB1n/VbJu3a9DPyH+563WU+yzQF1yNHBVyRtXGC+NBzL7hbnap6fdlJ4qpn7rnqPXnXd6vE1UOWW9luLa+Rv2Ql+R2aOS7izbpKd/wmkyuPR6GdN7+zbfnzDlTdI/7pBCriErokgEgb0QHoIyjzzyyFw3ucmTXyV9fbvJwMDlUqutkHp9J+nqOmmrCuQmeGaafaZGKpy+DEFio+RnkPqqxANVjUBUUelpdcCLkx7P/DIzw4oqwll1pacnRbo68MUJPTJPvqKClfMiHAT2Qgzq9ZfJ/ANeJ131u6Srq0/Gjj9Resc07qPlinIR9fl8pcUDL+oJxWmAagPjxh0RvAAEgYrOxD1EbeRlP68omK6IPffcM7gH7RrPXL/mmmuCTVNVIIyZi4bDtefarqQn6TU3S4/HFabulyK6x3ca6RkYGAi++kBmj0y1d1SuxZ9d5oaVtsv6kiVLgswLXB0E9m5ZSIelvoaylR6tCk2sCicbemdhmMsAmzUKCZlUmv5bNePMPZDOT8o7holq1VqfCELHGjDjgVwKWnXlOtqZ9GQlDmV2j+800rNhw4ZgHbscvF0NDbkDYaaisyiZgGVvVkkJB7+LtIzhmj9/vpXAXhcCmRmP66+/PshIIh297AXOJs0zZr6Er6XsOWOjsSWnRyVBZtCqkqC05QA6kUBU9ZptEociu8dXOaZnJEX2FodA14uWetJTgdo7ZXU3DyPJdcD477yTqssSEANbFZTLDGTWhp30yNpnn32CCst5Lu64781JlueL2kMdk6opPXHjgVA6mX/c5zMrn5H7Vt8nA2sHpKerR6Z3T5c9J+8p03eYXjoJdRlVJD15B1836x5PdXi+p+nxEO0kmYedpvSsX7/e6SBm4ElPBYKVbfa8KkLpUXeW7To1Sa7BNjj93XfffYHawMZHwGTeULISZ4PlZLp48eLgqxmfUDUDF2f8+yb0ySNrH5FN47YUuqwFhRAWB0Zq7H1jZfKkLf3CbLsq2oFAuFqc0BXiYLt7fKeRnoGt8VIurwtPeipQe4eJhwRbNlq5lrj2Bx980Ko7K+k15AE2Paor46umGjE1aFwD6gabLyqIBnBmVXrWDa6RutRlUt8Upzaxv6/+u2yqbb8eNvVvkvlHzJf+jf0BOTVdFRrYanNDrqKCVkWiViZxyJoeX/U2FD0pYnpc7rAOPOmpQO2dsoN3w+6tqI0Tho87S9su5DXxi3ZvQeBQeCA7NAtdsGBBsLBdBMYdlc1UN9IYuOUbn5F7Vt4i64bWBP8f3ztR5u9whOw0flcpEtpokjlnvhYNLGr4N8sHl8sROx0REG51VWjTVBpbmqd0SFDWeKCqEYgqkh6X1Kmk6fHs665ce1LUarXEqf2ud1gHnvRUoPYOBixN1pRt6OINb5y4VXBnIQfbdmeVpfTwGfT8gUQccsgho5WGyw6kbgY2KE6ZqD1suIokJHH90Fq5aekVUqs/O982DK+XW5ZeI8/Z+YUyrX/7mKFmiCItjV4QFFxzGA/9noI5pa+m99MV7arQeKDwKR31TlUgnlmSeKAqKj1VLU7o6jW3So/n2s2eYVXqSVdL6d7yMT0emWvvuKL0KJnRaza7iJvEoIhryPPEagZhU13ZVK3KrgjdCpxAGQ8yy9iwkj6jx9c+tA3hUdRlRB5ZfZ8cNOXo2CRGVUHAdZjExXxxnZANfp85hYEwf87fmvcxZ/kceWzdY5HXP3v87NindAwUp3RIECoQxklTlzFiceKBXDXG7aT0VCkuxkyP51lfccUVwWEQBSScHq896Vx1f9VSure80uMRWXuHl8q2rTYh15QeNiEWMcUGs3YRz3INeWwWS5cuDerv4B7Zf//9t9tsiyr2l9YwoVzwQtHgVAmSXO+6odUNf7Zq4wpZMbwikrhAWhqRmiQFNbnWVi0D9p+6vzyz8RkZGN5SCE2xQ9cOMn54fCIDBcHSjDfqt6grDDLPoURTlzFQGCvzPlwmv+1EelxybyWBHlRJjYf4hNPjcZvbTI+3jZrP3vLICi2xn7SVhGtKD+4sXAME9u29996FLlJ9XrYNDs/3kUceCWJ2DjzwwKCQYqPPL8rYpTVObKLLli0LTpFJ32NsT2PSMHncVJm9Y2MlpSiM7R0rJ+9ysjy+7vGA/PR298qcCXNkRs+MoJwA45OmWCTuQciuxgMRsK4kiNRlYNYHqiqBqNo1u+zeagZzn0+aHu9CY96RFAdL797y2K72jm46Scuqu6D0KPFCpi3KndVM6bGFzZs3B6oVX1s1C3U5psfcWFFeUHtQfeIau+DUOTxDnpLHI3+++6S9xRWM6Rkj+07dN3iZ4FSNWqdd3dMaDP4OtyYvTumqbprxQKxL1CL+j4Eqqp9Tp6kmVXJvmdB9otG1N0uPZ57R3qbM7vG1FF3WIT2NDoyuoBoRVW3izgJJCU+W9g82wWLUOJfDDjsssgheFUkPmwuEhw3l8MMPbxlk6GIvqyigdKB6NGpNYcKsejxl3A5y0ISj5P5Vd0itvmXOdku37Dvt4MKzt7JU21Xiw4nZhpFg3qGc8aIoJeuRTB3WBeogrgrt58RnQrhcjNWootJTRaIGkvZKTJoezzzTQ00eqNVqiYOufUxPh8OsvaOBnGlQdkVmsmmoecJCxCddZsVb3UCyPg82UoJXcWmRcRa3r5nrgcym2sOGpen1jYwdZJxNlXgWiCzKxgyZIbtO3F2WblwU/N3McTtLf0/zOBuXwPxU4qPEz7ahZ03yrJgPxH5pPyeeJbWqUA3D8UAuGO4qkp6qureyKlRld4+vpVR6fPZWByJO7Z0qKD1cP2SH+JBDDz00aApJ3Zqy3TtZiQdElGBlUrtpbqkBv3FQFaWH69TYniiYNWzYOIkxMJWJvu4xMnvC7lJVQPiU+PBi7tomHeY8MPs5aTyQkqCFCxcGv2PGapTVn6iqpMcFwlgEaUiTHq896Wx3j6+lDGT22Vsdhri1d1xXepBVcWexmZ9wwgmjGTUuuNqyxNVAdKiuzGmErLOkJ6OqkB4AmWHu8DKvmfFbsWLFNuqOK7BpkLlvSAjET4mPbZdT1PWa8UC0YtGebZAgrgV1ETXKDIrO001RddJTdfdWXojbPV7nWJL0+JGt5SbSpKzzmS7Dx/RYBBOFiWdD3YlSNoo48fA5SKek7BK7MG/evG0+04VMsjRKD7//1FNPBZLwnnvuGbzSjE+VSI/GCLA56txppu60I7hnAu4hG8RFQIJs3XPcecA4aDwQlb3VTaEqEGoqJFyNU54F7KpIeqrayqHo6w53j0dtVCUIhT5JevzI1j0+TfaWS4eoKHjSY9GdpdlZNgmPOfHyJj3qziIOgmDlqCDYsuOL0hAvxoZAU+6LYOUsQdhVyN4yoRsQSgPPgVgT19SdvMGYofKgblFhG6Ngi1SkWedhNwX7hrrC9IQOQdLfsRUPpG09qkh6yowjrKpbjoONHm6SpsfXtqr5SUiPJkR4pafNkYc7KwydeGmi6ZO6s5DZcfs0KhDngtFPcg0sQtxZbJrN7qsdlR4F14uygK+9E9SdRuMG2WPDh/ig/mQN+rQ1D5ibXI+WgDDjgVAnmetmxk7aeCCzOnaVUDZ5cCWmJwuSpseP25oan3Su+EDmNoep7qSZIEVnLLVy++DOoqmm6y0x4rq3MG7aE2yfffaxsgFVJXtL5ycbmt43xrITCY+Cec2GzjPA1QXJyBpLk8ea1xM69U5M44RS9eijjwYHHz2dJ0lbrirpqaI65TpZ62qRHs8hieeO8p9knvmYnjaFjdo7ScB751GgkOvH7cNmGtftUwX3Fj8jbZjYpIMOOmjUx20DVVF6OHGxgaFm4C7Bl89GVlbWkGtZbcwhgptx4aZtoVKEMQ4bJ/YAgvEZW4294/Ru1gdqpAbrvHXVEFeRPLRLLFJ3KD2e+YVtgOjoPGPvMAslhl2OCAC4z4tIWSdG6S1veUuwLi666KJEf+tjelLW3mlVbdM2bCssbJy4s9jwyc6Ke1p0QelpRjxwDXBfXCPVlW0vQNdJj6o7EB2MoLrzeA6cwng+nRTP0wgaJ0OAM8SnKs8EI6pGB7AXabAqWWGML/FAZkNLs0kvqBrp9dlb5Tzzvr6+IJElKj0eBV3T41Ei8RLo/Mo7poe9HcKDIoUSlRSe9KRoJWE7OysObCk93AcZIyghMHomdZL7cIH0NLoGApWproyyQ8G4PE5ZRZAe3p9AQ8YIY6wBra26fmtmFgQW10hYlcMAovYUWcreZWjgJvOG55u0vogLxhjDRJA2LwDZ1X5h1KLSdhyarQOqNvZVLU7oUkxP1ho9vU3S4z//+c/LZZddFoRGgFtvvVWe+9znZo6fbAQ+j73shS98oXzzm99M/Pee9DgSrFwE2eAekCyZqGmzmFwgPeFAZsaHWAdOIJAd7WhcxGfbhplpNn/+/OCEZXb91mwLXmq0+Rt+h1N+ONDVnKcYdUgPhjGtS6fdwLPSlHbGlc20ysDQQHg1HkjdnMwPglUBc0ljgvIyTDZRZfdWFa87TmFCMz3+wgsvDFpknHfeeYHa+Pa3vz2Yb3gQTj75ZHnBC14gRx55pJVD6LXXXis//OEPg+SU//mf/0n1Hp70JGglUQbZsaX0YOxQQTB2ZDGlDeB0gfSYwcScOLgvDP6xxx6bu7Sap9KDUoNrjvvDNadFBbXrtyo5mm3B6QsSxGkfY63qTjNVwlR7PLYAw8/mjVzO3EZRi7POyw6wXbypLtesGpFFm+sypbdLjpnaJQdMfNbIcm0QXV7EA0GAbrrppmDsw20MNB7IxdTwqpKHKsX0ZL12EkVOP/10+d///d8gMQYSdPnllwcv1Bj+n6TyfRTY99785jcHZCdOT8FG8KSnoFYSWZGWbKirhEmXpShf1uuwCb0GThMQHowUJKGIDTuv7C2UhrvvvjtIKd9vv/2CMYJsR6Wc0ieMnxHMR8YF8VkYMdyWYVdYeKwhhfw+ak8VTvlFgZMr5BLiw7qP06i0zNiuRwZG5CdPj8jw1ktYvLkufx+oyynTRU6d0birNy/dB1RF5IVSysGB+aEkSAO+y4YLbsQ0YB65SCLzakGh6erMMfYwXu9///utHQ7OOussedWrXiWnnXZapvfxpCcCDBIbASdiNsKyCU9apQfDSMAZAWhHHHHEaDG0LHCB9ADcP8j0nDCoclvU+KjSY2sh8z6oNrwOOOCAoG2Bfr8RzKrK/D6Kj9nwMuwKA2bgPYaNue1Jz7bAQLHeyeoioxH3b6sxLmtf+MPSZwmPictXjASKz+Te7a8rPGeZN2Y8EJk36grDxQopMovXoRiVcb9VjempqkKVpdlo1ByxMXasx9/97neBm+w5z3lO8D0UJeYr///MZz4TxPjEgSc9DWrvQBRQSHAZuICkPa8warhKYN74Vm113+U6TAWiaLARa3VhmoVqFktRsLn58hxRd8h+OOaYY1rGk7CJssg5kYcrqIYbXpquMHDbbbcFRlxP8Kg9GLmiej5VsVGpZnY12vzLUnpWDtZlyWD0z6C2D6yvB8QnjFZEnbmA0qgVfDFiSqSJl9PidUqCinKRVpU8VPW6syg9eWVBsmddc80123yPGKILLrhAvvSlL8m+++4b+7086WlQe4dTX9mNNdPUx+E+FixYEJSzJzOLDC2bhrrMhqOQHQLYuEdiFIomPECfZValR++FTQLXXCtSCtHhtMPvYZSaVeYOu8Lwq++9997BpqS9njiRcQ28V6ussE6DNirVDu0EOo9IXRZvfEaGRoZl1tjpMrFvSymEMhSIVh+5aeMG2TS2NyAx5vUlmbNmPBBziL0HogwJWrx4cZBZiFKoBCiqbkunu7eqHNNTc6zDOvudKjxmUDNzLvz9lu9l+draovZOXsUA8yYb3ANpqmxOyIB5kIKy3FvErGCsqQeBilHWZmJWx067EWM0cDvGqYCtsUtR6k5caAAzrhuIMPME9yAGXV1hEB9VgtJ8RruBZ6Yd2u9f9KA8VHtChkaeVTj3nLibjK8XG6+B8WcebF67VmZ2T5ZlI9sT5R6py+49m2X58tXB70NMeKHKZCHqPA9cXbw4SGndFuam1m0xO3rbJNJVdW9VPWV9TELvQBVaUEink55mtXdcqDxsotX1sAHhzmLjITvLljur7DYMLD4MMwGmhx56aBB/wAZb1tiEC70lgVkp+pBDDhnttWRD3UmSccbpiPdDCRgeHpDevqdk/foVsmrlSGDAtACeBkV3qgssUMymTZQHnrpZRgLH0bN4bP2TslPvdJnblf8mz7zBoHCYYRwhsK+Z1C8/froug6Fp+KKZPTJ3h+mjZTaYQ5q2rr37+B5EKAuRCNdtwVUajimD+CgJYl9K+3lVdRNV9brTqlQcRvNSeqJAgUJS4pOiY0lPq9o7DLi6ulxWeriPJ554IqiPgGqAepDnqahI95amcHM/EDmNISiz6anp3koCjAL3wpxrVSma5wvZwf2E4chiMJqhu+c22TDwG/L+RbpEps0YL3vOO0OGh/YfbXapbQ6UAHHSr6pknwYLBp7ajvAoVvSskbmyJfA8DzAPmAO8tDyB1mAi+usju9flutUjsmjTlpT1o6d2ybzxW4wsvwNZ5sUcYr2gWvF9JUCmCsT7Z5ljEGOURLO8gpIg9ife2+wXliQeqMrurSped9bsraJAPbY0Ndk6kvTEqb2j7q2ya3GEr8cEGTu4s9gUCerNWgfBJfcWyg73RnYSQWrm5lFm0880pIfNH8LDZk8WXTPFBmOBcVI1xkbmYFRtoY2b7pXV6/4vIDuKkfoGWbH6J7LzrH+WadPmjbrCtNkldV3ME7xWMXZhfeSFDcMbG/5suGs4l3vnGaPqYEQgJaib4fgcMH1Ml5w+K55hYh5BgJgHJGdwoEPxoXQBKjH7ixIgvmYx1uGO3uFmlpTP4H7MeKBGyrSq8VWcY1WP6elOOAfyjOmxiY4iPUlq76hhcmXicq2QHIXWqEHqJjurqHoQeZMe3psgbDLnqEiM4Y+6hrLirZKQHrNGEoHEzVLruW+IBRsHsTVsHjpPbSB8vWvXX97gN0dk3forpX+HM4P/Ma9ww/GKOsG3uyts6pgpDX/WP9IvXRGp4WnAs0UN1BpKEAZUE5tuaiUPvBhXLWrJ9/lsSBAECNLFOGq3d34vDulYPywyVBeZ2rttsHW4mSVrV/s4kXRBejzzXUmQqSZWtUlqO8T09KRwb6Wp8l80Oob0JG0loZM1zeDnAVN5Iu6CYmKtDGle15EX6WGzh8ipC6jRqcEF91arz9d2EhCZVkHlprrDyZivNpWsqPkxPLys4e8P15bFPsFTGgESZHb8bidX2NyJu8r9qx+SjbVN2/1sxuAUkYycRIkkZAeSiysTw5HHc2ukWrPXKcEBpgrE+PJzUwUKX9uyQZHfPCPy0IBIXbpk1pi6vGSmyMENiqPz99yjGkgOc1ofCDWR/6uayFe9xqrBu7fcRG8n1d5JUllZF7YrGVxcN5sR9VaQvY8++ujRDaHo68iDcEAOIDwERrZyAZXp3orz+Rgx0tGZQ5C3RkUAw+pOXrE7IHy9fX07y9Dwosjf7evdXl2LgtZt4UWFX3WFYcDaxRXW190rz9/5eLll+V2ybNOK4Hv93WPkoB32lw1PrM0UnMu44/YBKC4QxjyNe1xXPWuPuchLFShIEMSMrD/UJyVJtZ4x8t0nu2TN8LPvu3SwS859ui7vmSOyz4T41bA1HojPUhKEUmr2C9N4oCrMI1e8BEXG9EzKuQ2QDfR2Su0dDYZLUqfCpbR17Z6Mf5+g3rLKm9smPWZFYsqWoyDEqYJbZmZds/5bKDaQN41FCtpJjAxKb9e2LgI2dn4XA6PqTp7XG8bkiS+UDRtvZwRCP+mVSROTZ0REucLUeKkrjLmjhqtKrrBJfRPl5J1PkIHhDbJyzSrpHxkjsybNlLvrd6curgnh4Xlpkb8ijHia+ER+XwOeAfuhqkCUPLhjaKKsGd6+0juKz2Ur6rFIT/jzCNbmxbrgc66//vrAmLJecH1Dksyg6LwyVbPCKz1uom1JDxOODSZLZ3QXSI+SAnzfbDykbVexB1gUNBAbA5BEuSpb6YkiPWan9wMPPDAIFn1k1d3y6Kp7ZOPweunvGSe7TzlA9p52qKxetTowfGzYnPCLMngmxvbvJTN3eLesXP1LqY2sDr7X2zNDdpj6FhnTl70Kedh4aXE7CFAjV5jrmNA7XrrHdwUKhCLu2DHXuX9UQEgOxBBjXeRatpGUwZ6oRQt5vyufros0qA69cHuPYOp5q1mpGg+kKpAW2jSbprqgrmgAdhXdcllS1r3SU3LtHV3kWQpylUl6kJVpU8DJividJUuWlC7r2iI9xArgAtK6QkmUDteUHm0ngbyrnd4fWH6rPLjyttHf2VzbGPx/+ZpnZN64w1qqO1nmbdR7RWHC+KNl/LgjZNnyu6Wrq0dmTJ8vXV35bNJmcbuwK4zaRcx1jJemabvqCoOoqKu8FfHm5ygV2vKDeyIwvyyV1nYmKu81dUzj95ti4Ugd3sOj4oG0aarOIw5PSoJYi2UQD7PXXVVtaE+Kisx5taGwid52biWR1XDgeiiL9GAMcJOweFF3ON3QVbtsZCU9jBGtENig0rbJcEHp0Weg7SRQLbTTO+6sR1dFuz5W1p6Ww2ecWLjha/S8IDu9PVuC4fMiPHFdYcxvNs7bb7/dWVcYhoB9AeMKouau9q2C7DBPIDvEqpWtQORR7+aYKSJXrazLiFn7YCuOtSDetVJLzJ5zwIwHYp/hns1+YVrnKG/o/lD2mKdBbavNS3LtOue90lNS7R0mtY3FXYZ7y3STEBNC3xu9n7JdbVlJD2SUjCY2pSxd38vu9K6kCyPN/UDcIHC6ma7dvFKG69FNWetSl9Wbl8qEMcUF/LmomES5wiBAqJkof61cYWUaEwwtCkOYSGo9Gl7azd4lxSqPmmOz+kXeuLPIBUvqMlx/9r0PmzAsz53WUzhRw3VIPB0v/hYSzTwiHogCrhpHpSQoLzJdZaWnZoSEJHVv+TYUjtXecZ30mO6scNdtV9piKOFIuoGy+VCgD4OBUcuy2ZRNegCBuWym2hrDxJie6GytuD/PA2UqY3m4wvhZWVlhzF3cVroG2HsgacxxLbrnYoZRXoVWj5wisv9EkXvW1WVwRGSX+nqZMLhOumQnKG2m985SmJC/0yw0Snuwl2uJBW28q2Ra6wOlbfUShh6+XZsDcZBWOPBKj4O1d1wmPZqyja/6sMMO227xuRBUHe49FfdZqyJCZ3Rik7KefsqM6cHYaVAq7qwoH/akMVNlh7E7yspNz2z3s/F9k2TGuOyBwklQxY3X5aww3l/7YHG6ZX5DcnCxuOKGi0KelY0n9DzrzqrXJ8jTT6+2cvK3GQzMHqpzxKw2zousMNY2B00lQfw77WdXOYi5liJdnT2R5+krMucIJhUP2ra6UzTRYONEdmXzbpay7YK6odcRd1HzO9RrwSjEabCZ5BrKUC60nQTjw1g1C9rbd9LRcuumS2RINm2j8By186mJyiZ0otKTJSuM+cbP8nKFadygFgplLpKpZ0shyBNFtdQJApynTg3iELPG0ORJHkwyDSDTqijSd47PVkUREgSBi3svnVajZ/369cFXT3pydGdpdlZehKcI0sPJAncWcr1m/TS7ljRupTxJTzOwgUAQuF7cWTaj+otWesx2Evvss0/w72ZjwHhuWL1ZTpr9allVWyLrBlfJ+L7JsuukedLb3Vc4Uam60lOUK+yhgZpcv2pIlg3VZUZfl5wwrU/2QcLYOhZaTNCce8zrKhAeUOTeAUFQl1+W4NYim41qwUVIrI639p0jzpJxNusDNVP1Oq0FxcDAQPDVx/RUzJ1VJOmhsimEh6yOww8/vOXGaZKNMk8QZnuORiBokHujwiqKiO3rLVLp4T7vvffewIhqOwkUhUafz+8TjMvvTZwwSSZK+RVKmxVTbDfEdYWp4dKiezetHpKLlj4bfL5qqC4Pb9gsL5/RK/t3bwjIDvNYKyfzfqzhKqFI0qNqD88pS6XpspqNmvFAuOW15YoZXK+KolYlN/fwKru3RlLYGEgPz6MK99xbtVYSWWvvlE16mFC4syg2uP/++wdZBknbYpRJevTZRyktjA2+ce5NC/TlgaJcfdpOgs3MDL5uRCL4Hl2kMaRltAjxiO8Kw+WKEsTPJk+bLn/tovXG9uvwb8sHZc7kzcHhhHHVtWrOhaqgaJUY1YS9CsKYdj24Qh7MlisAW6RNU1GBINcQJCVBuEBduO4iO6xPSOD+KxO9nVZ7JwlYsGZnc1sNNXnPVu6stG6lIhBFOnAjcG9xXHVVUC4osY9ape0kzE2g0ecjg7NhoHC5tPhbPa9OUYIaucLuXTkgm7ujx2tQumXjpBkybty2Bw2yEHlmVXpuRZMePgsCgPKbtkhg2e78ZooiWZuaualtgrT5LvYK+4ErHCJUFUKQpcN6FVxbzpMeJrwGK4OimbNNpUddPiySVg01o+BSrZ5w+rwG+LLBxXHVuaz0mIHljdSqKJKg/ZQgSS6e8KpknIt2he0xsSby1JZig1FYtWKFbOqZvE3jWC0u6cIhxMX4GAXPDIKIa0hVkioqPXHuk71C44Gos4bqu3LlKrn8wRXyxNBUmTSuX56za7ccMmdqwybEVQ5knlARYuc06dEHWFa9Axukh0WLywfGf8ABBwRGMS1cyuDSoGrIAfeHGoLvu4hxyus5RLWTiELYvYe6RXwHKctltRhohipsRGVit3HdMrlHZG3EUh8vNZGlT8oNj64L3DUaEI0B16SKqqAs1QRlDQLAekp6IKoK6THBM4bojRk7QX67bh+5fc3WvWKDyJUrRI5+aKGcOn3FNv3CXNo3aikDmb3SYwllGvqspAc/Ly4fpE5qumRN53OpVg8KHPEuxEjQLLTIhpF5uGO4D+6HMdJ2EnE+3wxcdrnvjFd6GqOrXpeTxmyQP28cJzUjrqe3S+S1O4+X/fY5cpsYDrL4ILrMEVRO4lUw6K6Ty7JID/FPEEbUHu2Z5bI6ZQPYrBvWTJPbl29vu27eOFteMGO6dI0sD+KBcA0RIK8kiPlU5j3XMig9VYDTSk/ZyEIy1J3F6Z+AZRvBx664t9iIqGaqzUI51VSZCDdqJ9Hs8zWeI8/A5bwbjnpsmcus1T3HiHxwZr/cunZElg+NyPS+bjlmaq/MHNMdGcOBocKlq+RfA11VCXLRfVEmgeBQtHjx4sC4J1E1ysreygr26TvWNXbn3bZmgnzoiC1teCDQGg/EPsQh2awPVHTF8ZGUHdarUKOnEqSnzAmfhvSY7izbGUwutKKgaBcKFt2iDz744NLSSZV0ZC18RjE7NuOodhKtPp+NysXA5Sh4pSf6mRCwzldieyAEL43JVVD1WI8Qf+YO8j7zgblEVpjpCrPZ3iALyix3AdFBCUDtIROuHd1b6u6ECENkNtUaX/fA4LZKGPspL63yrSSI2CCTUPOVuZUnarVaYncb89+TnjZAUtJj253lktLD56LucCpm88JIlGXo07TCCINsC07q3FejdhKNwGeyqfH5rgYum3CdkJWp8JiEJw34O9Y7Sh8v1ELTFabtDfiZkqCyXGFlZ0LxDFBVIQVx1WFX3VuaVcy9mC9IGoSBfWXP8ZvkzrXRNuCgmdH3xPiwv/Ki2bQ2sTUJNSqiSYJsxwPVfExP5yIJ6eHEeM8991h1Z7mi9MDiIQh8Pu4s3HZldznPcgpkA9E+Z6hxScdKi95R+yXPAETfhiJfwsPaZr2mNaq8DwoOxi6c2WW6wswCiVrNuwxXWNmkh2cF4YMQxm1J44J7S4viKrHRf/N9xhoCx6FJA5KZTxCVF+68QR7cMFE2bqm2MorZE7vk+XPjKX+8l0moIVo8P1WBKJzKMzXjgbLanlrKOj1e6ekQ9xaLEvaN22f+/PmBRJkXylB6CNJlYWHgacHANZSdRaZzIqnLht+ncKJmm3GSSjq/eP68MFQuBy6bKNtouATmAJl2jGEWhUeBkUP1awbcESiCvKJO7kW5wsomPYCYHtQe1K84ZK9ol1yY4OgLBBlZY8YEKowqLI2eJ/Nr14l1+Y+Txsr59w/K7UtGZEyPyHPn9MhbDhwj4/vSjQNzA/egugiZe9p2hSrRXLuqilxjGlWxlrJOD27+KqB8R7PDUNLTaLNgoFEMWJgoIHlHrxep9CiZo9AWZM6c0GUHVKcp1MgJiSBBs51EUmjgMp/vUoppHLQqTlh2rFhRz4ACkhgGFJ6sxtRUeuIi6uSuRitvV5gLriJt5YFawRi0urdW11wbqcvfnqjJFU8Oy8CQyIEzuuWVe/fK7Imt75M5HyY4/H805XzMmOD585VxTjIOqkLvMa1bPnNCfkoe8UDszbw0HkjnE+VETFVR44G6WtxHWvdWVQ6BnvQ0gQ581GkD44c7i0BlVIMiTiNFkY1wvEuYzJXV5VyhizauoWZBkmEDUTHbSSSFBi4Xla1mq+Jv2ad7lwgPhs0G4QkrPWnbw2BMm7nCgBKgrK4wF5QeAJFA7eJeWxnKVu6tr94yKDctfnYfWEzT2Kdr8h/P7Ze5U7q3eZ+wegPBYcyU4EA2+cr3sj6nMgKwzXggbbuiqiL2ilIL/f3925CgqL0sLenJswp/R5Gest1b4UnQTAEp4nryPpEj/aNeIf1TTDFq8rvg3opbq0fbSZjuuTRg8+CFi4KaPlXLhqra9dqEZtrZJjyqQijxsXHSzdMV5grpUbULtaeV8tCMPNy9rLYN4VFsGBb52X2b5UMHPktwUNR4VmYMji2Ck/S6i0JYVcSOrd4aYI+bH+WbOBwlQMwn9W74NhQdCp20LBgWiNbmACgGRct5eRYnZEOkUBbBcQRiQxIaoWz3VhziZbaTyBprFa64XFSvKq/02HmGbPKolzYJj763ukIwrLb3A9uuMFdID8DYcnholerczL1125LG6/+OZXXZvHlQ+vvHBO+vBKcolN0YOgpcz/Tp00cLRDJndT5RuoP/M59QwFDh+Hfc+eJT1tsEDLgSDQ3oxZ213377lcLi81JYmOyoIZC6Y445JvC5l3EdSdCMeJj3k7X5KWOPNMwpSI1aETEwbDq45PiKQWOj4msa11qnNBQNg3tmU1fCk0eAMM8WlwFzLW9kdYW5kAml4DowqtTtadazqdk19zbZgnu7u2TWrHh1t/KAC0pPK4wZMyZYF7w0I5X1ghqEKwxirZ3lmU+NVDn+Nu82FFr/Dhc1in2SWk9hePdWCzBxUQx42EW7s8KAgLXKFEkKJjjqFRtQq/YL5nW4qvRoOwmITtz7aRW4zOZgttnIm/RgxBgTjBsnfMZo4cKFo1Ww1aiVXa7eZTB2PDfNKsmD8CiRZH7wWUUrKUldYS4pPQAjyXol3bnRwaQZeThul275zcPR7338LuWqLFUgPSaYFxzqmDPMHVoLofgwnyjvAOFgnqsrLHwAazaGWXHhhRfKpz/96eAa+VzCL971rnfJN77xjVTz2XnSUyZgr0jKDGgZ7qw8FRY2QE6HMPq99tpLdt9999gTiOtgQbj2LIizghjsueeewSvrBt+o4nJe7j1zTFATccnxnFF5aI+BgsU1QcBRHbl/NiBVgRpVau00pYd7RUFg/eal8CjUvaXF6srK6ovjCtP4I8iGC73C+HzIGNfINUWRhEbkgfU3aXC5nLzTGLl8ybaK1sxxXfLmA/o6tvp1FtS27musGfYTVH9sA99nTTFWegC7/fbbg5CIF7zgBbm6tzhQ/PnPfw72QMDnYo8PO+wwefvb3574/TzpaQBOSwR6Mfh777136YTHpsLChojRZFNMk77tmnsrbTuJZoDoauByeNPNg0RoxWtih3RMGCcTGFczPZVrhABpZka4C3gVN10bYHPm2eTd9V7ngBIfbULqAqJcYSigXKPGJZqn9rxbGzQCn8u1stai+tdFxfRA/lEfeOYfOHqKPGdZXa5cWJOBoXqQsn7q3F6ZOKZcQpemwJ8LqG21L+G9g//r3gK01QYZzKgwjN973vMeefnLXy6nnHKKHHXUUdYOG2edddY2/z/88MPloIMOkptuusmTHluDjgElhocH+9hjjzlzSrZBNpicbHr4+9Omb7tAevQaNL2efydtJ9EILGY2VTLYooyYbdLDPWCQAPegsRjNTuL8jNM6L05i5sleu4BzikYFYk6XPV7tRngUOkYazOwqIBc8j7lz5wbxELiVmCvsc2HCXGSvMFV7WG8oBWFjG47pwV3JwQCChArBzw7bUeSwHd0i+FVzbynYK3imra6d+f7iF784eKkL+XWve53ccsst8s1vfjPYj573vOfJt7/97WDO2YQGXr/lLW9J9ffOKz1FSrBslvgLGXAIARsBqX1lx6/YUnrU/YORxKWV9tm6QHq4dgwcAcucZhul12cJXG4UmGeT9EBUIDzcAy0x0m6U5slegxJRgbRxoWbKqGELEwJXiH0WcI+8iiI85jPj8MBnuwyN6dEg4ihXGPGLzB0Ihc4VJRd5AZKvzy+sOqvSoy5LDm2QNheU93YkPSMpO6yD9773vfKJT3wieA8OopdeemmqIrCtru+d73xnMAf42pakp6iYBEqj486iNYFZz8WFoN2ssST8DSXKMeY23D9lkx4tFY8/mdiXNO0kGr0vdX3Cgcth2ApkJn6HoMG0LTGaXR9GgRfviwQNCYAYkcLPPFejpumrVQcGE6MI4SmqeGRY6WFOuhYsbKLRtTXLCiN+A5i9wvJwhbHeUJ1QLk2VSdcZ6o7WWSpyfNM+5yrH9PQkvG7EAt1z1D7gguJl+7lCrK6//nq58sorUwdOV4L05AmTEBxyyCHbNcJzifSkKU6otYWYlKpeZUWZpEfjkdgACWzbbbfdrL03mzzvTxxPM8OVtSI1zw7FDYJ1xBFHjPrJw7BJghh3ZGYUPlxfqgLRM455hWuBZwoJSluxuixw+ofwsHaLNIjmHNA2BTxDV59fXEJmZoXxNzxf5ou6wlBmzNgxG64wLRjIOJpEnLWiae24UKpAJHRvrKLSU8vQYT1Pss88/MAHPiC//e1v5fLLLw+U/bToaNIDQ4UQsGgbEYIqKz1ajdh2baGySI+2k2CDRKmwKXEzF1ALogKXbSqP4RikIgJIw5sRRpk5wYv7IACce0ftRHniuaoKZKNrc55g3LRrdxlkQ5+t1utxmfSkqdPD77PWeJldviHMKK02XWHMNeYi74EyyVph7vE8GV9XFbR2Iz3dKTqs5016PvjBD8qvfvUrueyyy4JY2yzoWPeWxregFJCd1Wigq6j0aCEn3Cd5dH4vg/SE20ncdttt1q7BDFyOoxSknY8YC0gbZIL4nThkwmazyUbvz4bFfUOMcdEQ38HJXrs2m64NCJErxofNFuNbFuEJKyeaweVqDyIbrrdwl28taGfDFabp9KyTwd5x8szqtTI4XEtUGdgFVJ309KSI6cmzMOGnPvUp+d73vidf/vKXg4MZL4Crk7T1tiQ9NsFJhc0cIxonvoUJEE4ddlnp4XREMDbGCiUhj9oJRZIeNmoIHAHlJoGzdQ1xApdtkB7cSMw7CDZupiI38SSfheGBRPDSSqsYNGIqONlrgTKImy3XRhrodXGdWZpw2kRRlZnTIo94I0gNL1UNww0uk7rChsdNkZ89MSRP1iBLE2XspOkyvE7k5HxKwJSaAdVOMT0TclR6sGkvfOELA5WHl0Jr9SRFR5EeFiSEgI39hBNOiLVZskhtV0HOS+nhdM79YZCIFcnLIBVFepq1k7Ch/sUNXM4SyGzWECKwr6zA4TTPivuENPNCEdWGhcwz07WhxRGLKngH4eEaOLCUSXiilB4OG65m7uQdZG26wrSMQjNXGPPFfE4bh2ryX4+LrBl5Vh3a1N0vv1suMmmsyFF2E4Fyg6vjn3dMT16g8rJNdATpYbHjzuKkrcGccSelC801w6628ObF/2kUysZiOxOoLNJD8CKxL43aSdi4hriBy2kDmbUQHJ9hq4ZQGtiaC+GGhWaWD0ocz0UNGr+TR1AxBFgJT1kF9RThOcDz0UNS2dcWhaIzy8KuME7sjbLCINY3LK/JmpHooP5Ll3nS06mkxzYqQXqyLFQMjla6RQpL2qjMpZgeJWrm5sXJEjUEiZF+KVFVTfO4jjyfibqCmrWTyJo2niRwOeqzW5EeSBvxO2zquOXKDgbOo+RDuPcTzxNCouOHIVMVyEafMC1Mxxp2hVREBYmjULpyfSbKTqdHlTMD6NUVRlYYRPHRsXuINCivtHizyEhdpLsCoT1VVnpGUqTaV6nDemVIT9bqw2xE+P/SSOGcVlwhPToZNcJe1RAmHPdXVAn8vJQe3hNjySbYiqBmSRtPGriclPRokHzSnmZ5Ic7nZyVFjAcuQl5mnzBe1AVizuqpHiKUlBSgKinhcaEwXaPnxXxC0XARUS0dyoJWFFdlgXmzYkW3PLgu+vcn99aluyLBzGnUkipnbw14pceNxc1pk1iKrNWHXVR6UK+0kzIGhlTSIg1rmnpBcVsxMHZx6gmlVXrSBC5HfXaU0eN6GBOyC9KoinmhFUnLY+5E9QmDABFDRWA6BxBVgVq1PWBuQFL5fRcIT7Nnt7l7WB7c8JQsXL5Kdh4/XXYeN7100uuK0hNeK5BY9jLmCAe2540TuervIoMRU3XXdQvknnvW5Vog0RaqrPTUarXEmZCsba/0WEaShcoi4mSJzG4jcNRF0oMaQoBgWYGxqrLY2kQ1ADtJO4k0Sk/awOU4hAtlA9WNr2XG77gIs08YMXWN+oRBQnmu5ryC8DBmGDqX4gbMZqOKe1Y9JnetemTLf9YulwfWLghIz/N2Okx6uso1gjbXa1bgkofEQnQhPLqvTeoVOWuuyLkLRTYYW+6RU+ry8t12kDWrJHVWWJGoOunpSZGyXkRYhS24M1MsgJgCbaZJdpaN2h0ukR4YtRqCtO46G9AFnbXUOpswbRHo90ONGGrwxN2U07jYMLRsuEkDl1spJ8y722+/PVj4EFGXNuCi2rgkQbjtAZumpjlDiK677rrROCDGC8XM9ZPk8k1rniU8BhZvXCEPrH5C5k/bU1wjaWVA3ZSMJ0Q3fD37TxL57H4id64cksUr10jXkkfk9IOOxcEl06akyworGp1IembPni1VgVu7c4YFTTYArgVcPbh8bGasuEB6cGfRfoHFhBpSZqquDdKj7STYvI466qjEygvjm2RcIIzEQLE4s/rbTZVJx6VZ0LVHc2ifMAwXih/zG8OIm1CDlzUWqGyD1ohEPLZ+S8G0KDy6flHHkx4NXGa9M47NVLsx3SKHTq7LjLVrZWF9c6KsMMIa+Ky8e4W1c0xPT4o6PVVStitBepoZEjWenOLzcPeUTXq0zgsGgN5gBMiW3eHcJD1Z2n/gZkKxShNMnMS9hcspS+ByI/cWJBuybaOJaycpPc2gFaIJjqQQJeOFMcMFSoC4GjSNByqL/Ief52BtqOHvNvtZJyg9fDbjBzmhim4cBV7XWJzrbZQVFuUK43CVd8JHlZUen71VEXcWTB7jmUcpeg3aLcMfjmzL/WlwL2waQ1s26dHnkOY62Ijo+k0toWbtP2y5tyCsZIPhKrEVE8J7QqSINSF+x6VYk0aoCukBPFfGS4tRQn54mc0vNZBf+4SpQSv6hK1rYda4afLEwJLI39lxXHTtmU4gPRxKOXDwuYxh3PFRop6mnEScAolKnPNQDjvRvTXRcfdz5ZSeMFgM9JWCxeftVjDTxIuM1WCjoP4OgX7Eu+h1lK08AS2xnoT0mO0kaBjHfWW9hlafbwYus8nZAEYXZRFAeFyL36my0oOB4nmq0WrV/FL7hGHQUEP5P8RHVaA8+4SFn+eeE3eWv69ZIGuHtm1DQQDzgVP3kE4kPVoagkMp45Hks9OSniSuMJRD9hANhtY50+mkpztFyronPZZhLhY2No0FodUCEzVPFE16WOgE9hLgS2xDOECsrA7nYSS5DlQRYjXYcGz1A4vj3rIVuKxAMUKl4sTKv6tAeBStnlXZpEgJDHMqbiZIuE+YVmvWNhn8XAkQRi0Pt4bOq97uXjl156PkzlWPyOPrFsmI1IPMrUOmzZPp/dsTuHYnPVqiABKapj2J/r5t8tDIFaalFPAWaF+5tHOmk2J66lv783nSkxO0GB/uBLKz8ihzHwaLLmnQbJaTEeoOEmy415TCBaUnCenRysQYMpvKSKvPZyHaClxWlQp1kbgqTq6QnqqglcEpO/gawoPbk+ealtBrLBAvs08YBu2xxx7bJsNH3RpZ7juKJI7r7ZdjZxwgszdOCohxUcVCXSI9fA7klfWXpVWIKj1F9goz5wxtfSh9wjxR9ym/F4eEZc1qrWIbionevWUXmtqM4SmrGF/eRIONAkLH6YLCdo3IQZWUHm1HkMeYNXPZaLyNjcBlbfPBwoaIsrg5xZatjCRFo+ut1dbLhsGbZLC2XjYPHS39fbuUQnggKzZP9WafMGLH1K2BCkTwOfNHjRmvtPGA4TmtvfFcUwGVQOS5b3LvZNrxVQsOZkWRbqJwbzmdM+zNKLzsd2ZWWCNXGL/nEuFNMkdGfBsKN4ACggE98sgjrcVmuEJ6zFo1++yzT3BKbbYxVUHp4ftkmWHM8iqg2OjzbQYuQ26ov8P7mE1PqxIjo2g0n9YO3CDLVp0vddmSXbTwmb/KpPHHyqxpb5OuAorpEcMDOcV44AbB1ZAXTLeG9gnTuA7tE6YqUJw+YY3GX+OSylbPwshbNYG8MpasEbPgYFoUofQkdYWxH0CaiVNSV5hZIFH3h6oqPbWtdiWNe6sKyRwKt44jDYBEijurrAWQF9HQ+CTcMHFr1biu9IQzzvKqkREVyKyBy2w+WcmxZplRQTjcxqRqpCcyxXpoiSxd9TO26G2+v27DjdLft6tMnXRKrtcDOVCXFmNV5No2+4SRBIEyyGkegxbuE9YquDV83Up6XEOeBEJjqXAFQRhtK7quVRVv5QpDIYoKTXAdI1v30ySkh7FnblXpft1bnTk0mHSR9Gi6PRtqklo1Lik94evQdhK4lfbff/9cTztR88FG4LIZSN4oy0xJT9kn0biIusa1A9dvR3gUawauzZX0KOHhJF004YkCa4/6Mbz05Gqe6LXOCyqQ9glrpfS4hrg1b5KAZ8A+xqGtVcHBtO/vahZU2BWGN0KzwngmWojRLJBY9jxvhVqtltgFCukBPqanzWCbaGisS5rq0VFko2ylJ9xOgho8RX6+rcBlDBbxO2xYjQLJgY5XVUgPCBvp2siahr9bq63N7TqYu6hxSiRce35cDxs4L+0ThvGCBEGAOMWjZkSl1AN+38V4DttzlbXHM0El42CQV1KJq6QnDFxdWk+KOcLc5tpbucJcTFfvSjBPcPmx35bZISAp3DuStDHp4T2IdWHTT9uFm2tBzSgbWrSRTR43EITj6KOPLqTx3FBtszyz+UEZmPy43Lt0SHYat7esWz6YKXAZ0kT8DouX+J1m76MbcVVcXFGbWH/fXFknN0X+fv+Y3ax87vBIXZ7aNCzdXV2y69geqY+MBAoPz9ZFwhOnzov2CcOYAe0Tpi/Wg4sdwG2SHrPgIIQnT0W3CnMk6lmjerEfQZxtZYW5mrk1fvx4J66/7UhPmXEUTAQWehYwOXBn8V7EJ6Vlxi4pPcTv3HDDDcG9pG0nkRQbhtbIDU9dKJuG14uMFVmwZrUsWHO37D7+SJkwIV0ROEgoCg8KFcHkcVO8i5iPtjb98LVOmnCcrFp/sdRqq8OfKNMmvSjz5925ZrNcvHyjbKht+dzJPV1y/JjNMm/slto5VTRmZp8wjNWNN94oBx54YGDMKGfAgQYDBvEnXdsVY2aT9KBikKGVpuBgUlRJSW1W4K+ZKywqK6wsV1itA9LVK0V6XFA10oJsIgKW6SKOUc2yEWa9FltA1ubUwkkmSzuJpLh/2TVbCE8ICzbcJnsOHSTj+iYl2lSp4cJr/vz5gTQdB0WSHhv1VaL+tqd7nMye+TF5ZsX5snno78H3+np3kulTXinjx+6X4YpFHt8wJL97ZtvKxGtrdbl4Y5+8d+bkShqyKDDntYgdbmoOAbh5MWoYs7IbX9omELh9iZvjnooKXK3iXGlVkdl0hWlWmKqHZbrCailJT5Uyt4AnPTm6t5j8tMoghgejmrX1ggtKD/fEwiRYj/vZd999C/vs2siQLB14PPJndanL4vUPy57TDo/1XuqW4z6OOeaYhjEaZZOePFXSMb2zZHzvW2V8H4X7xktfr53q5jet2r4zNhiRLrllzaC8dGz1t52o54krDAOgMW1a7ZdDD/sApEcrRBfdJyxJUPB9y0fk6YER2XlCl8yfvuVvtOAgLpui4jeqqvQkSVk3s8KiXGEclrWoZt6usFoG91aVxqkyu0+ZDzWNewsZGHcWE8lmU8oylR6znQTyfdEMf6ROcf/GRKNWjzdGxGUQv4M7rlX8ju2Gqy4Bo4I6gSHu67WnQiwfqqX6WdUQ3pOItTNr9IQbX6pLg0aprCWIj2aF5W044hCIFRvr8sWbB+Xxtc+usbmTRN6151qZ2lcLlIkiM9Nczt7Kq/dWma6wkRT1hVCpvHurDcFEYJOKC3zexIhADOifZfNEV5bSE24nUUa3976efpnav6Os3vxM5M9njd89diNXsrzSuhrbRenBSDOGtk/uO/T1yPLB6LmxQ1/1jFgUop5ns/58fD/cJ0yNGe5VXBhKgPJwacQhPd+6Y1vCAxasE/nRoxPkKyeNK4WAVJH0pGnamcYVRrasJgXYcIXVOqDDeqWUnjIRV11hUtLoEFmSOjXE8JR1LTZB2X66WFOkj1Nrmi7rtrDvjOPl5qcvknqoxswuE/eRKWNnNR0bxoXxIfiUKqtpobUsqkJ6GgGVB8JjW2E4Zmq/PDSwfYYhZuCoqenaPbiItIUJzT5huMIwNhwqSAHX7B6bfcLikJ6n1o3IfSui5/Pj63sC8rNH/omZ26CK60tbOeRB1vJ2hdVSkDVImI/p6dCYHpQgFASYb9IYEVeVHj6HekJR7STKUpxmjJ8jB009TR5fc4esG1omk8ZPlTmTD5Ddpx7S8G8wRmwIbBC20uqLID22yEija8VN2azacFrMm9Anp0zukqvXjsigbLmHCT1d8tJZ42Wn/vY4Z0WRCJSzNKoZ+4saKrPnEy8OHEAJUNo+Ya2KE67Y1HwuL99YL4X0VClWBOg6KyJey7YrrOYDmd2CyzE9GFPid9T1k2e0fVFKDyoA7iyee1Q7CUhPGfWCgpPUhjEyf4dT5Oabb5bnnnZa07kBCeU+OIEzNmkbS5ZBejB+CxYsCAg0m1eWjTR8rcwh3j+PvmhsnnOH1skHZk+XpdIXKDxzx/dKb8UMWFI0c29l6RNGQDQqULhPmAZExzmdtyIQcyZ1S08XcXHb/ywYv8nljF3VSI/uzWW45Vq5wlq5UGveveXRSulhYlGfg8wM0/WTJ4poQ8EGC4mjLD8xSVELuCz3FgtZ3QOtgu/0PtgEqBRtcyOK6v1lE2TLQNZQYsj+0cBXPdklUWii5iSEh00vj8BUDgEY7ikTxkvB4kBhCJMI/q+BzDbBnOUwxYs+YXyGnuapC8RhDAOmKlCj03wr0rPD2C45cXa3XPHU9nP6hNndMmt8d1u0zsgbujeXHYsUxxU2ySiQyPzid5IeCtmP8zg45Yn20JpzRhTRUJcJxqnI7u95kg0z7qVVTFIZpIfrY+Ga6b5RpIffQyEhtT6v2Ko8e8FxosegUf9IyxygvEHiCJLn1AapUAIUJ/05fK0az2MbSOyksWaJmaoCopQzvpd3dhNENdwnLFzjRQkQe5JeTxxX0ZvnDcrQpiG5eeU4IQ59TLfISbv2yDvml2MmqhjTo0StbNKTxBV239Ymu/wOqnKSNHR+F1JVJVSG9JTt3jJJD3IzCgIbDK4fWy6TNNdiC0nbSZRBenBVce/I+7ohbtdTqlYLFjEEIW7nelfcW7wfWXGQHtqUsEFp1qAGvu62227b9IMy058bqUDhtWOmqtu+fg4BbJwuNt20DfO5MiaszSKNndknjHnB3Of5Y8g4uDDGrGMIkDaTbASuf/2aVfLeQ2fIu3v7g/T16eO6ZEJfeftuFWN68gpiztsVNjAwEBzi2WNvueWWUVeYvhqFbChByhNXXXVV4NblIHXaaadltrftvzNZJhqLFi0KjCquLFxaRS9KVRhsLi4kSlwpSdpJlBHIDCFjEzdVFpN4aRwSP8+bjNomPbgtqIHEPdDsFILT6P3NflCa/hylAulpH5jvlVeqOteB8cwriN8lhMfGhe7q7FNmnzDmEgSIucFXrhkFUQ2ZrnO+z9xhzmnsXplkp8pKj8109aLJc39//6iKyF7LnEExD/cK0z0475R19qg3vvGNcvXVV8sLX/jCIIbznHPOkSuvvHI06D8NPOmJ85B6e4NNjcEnvuLQQw8NavCUAdOtY2NxcT8oPNpOIi6JK1rpIQYFSZYFGVUgkAWqcUi4tPLeeGySHm12yokJwpMkEN5MfzZP+xg6Ys1QgTBkPCc2KP7Ns7Sdqs77a4uCqm36tpSesklPGIw19ah4EXuICwzDRkYY5EcNmZLfolz0ceGVnnIC8XtC2YTqCmN9YwOxF7/73e/kec97XtC3MK+U9fPPP19+//vfBwoUAgOHcxTwf/3Xf5XvfOc7qd/XrVXaBGXKnBgOJgQtC6IymYqEGpSsmSLaToIN8OCDDx4lE67WC+LkgYJgxq4o8eI0goEnWFlbAOQNW4HMnLAha3GbnSY57asKRD8oSNBNN90UGD2MHQYuTbZGs/FhPuYtdbsCF5WeVmDs6RHGiz1NY4F48X/miBkQXTaqSnqKbC9ShErVH3KFUWATsnPppZcG5PnjH/94oMaceuqp8oIXvGBUacyKCy64QE455ZSA8AAUpbe+9a3y//1//19nkJ6yoB24ATEiZW9sOimzGFyYO64UNjqUhTTyZJFKD+4Y1BCUjDAgOxjcIoPJbQQym8HWZMhxGrcNVYEwZIz5IYccEhi6xYsXByd/XGEaC4ShS9sKgfEhzo2g66oZKZtKT5GxfVkzoXBtYbwwdKwr5jOkh5pc2ifMrPRbhiGvYpuXqsT0RCHOIYg5xOEMtYU97KCDDpL3ve99wdz54he/KG9605uCmm7/9V//FdSrywII1Stf+cptvsfBFpusBD0NPOlpoYRgHHCXILG54GNm0mUJZtaaQhg7JmdaEpd3ynb4miFm5rXiolElg/o7RTVBtOHe4rmxoDlh5xlsbYJrZd4oCWKz0lYIbCAEvmIINRg6iaFD9uZ9k/YwqzLCKoTrSk+UasK4cc0oqJrirH3CNCBaXaTEcSg5ZqyLILcu7LedENOjSKP8sg+fdNJJwR6s4RIoQDYOcRykwnujHmz5WduTniJPkJyKIQYsdgaTEzCkh0mRZ+HBPFUWNhC6vYfbSaRFUe4tNmAmuLmItIYN149KUjThyUJ6mFtcO8+uKLJmjjOblNZyCbdCCMcCqaFr1hCTYFnuqd1T1MMwx55/V430QHh54bIIjyv3QcwiL83002Bos09Yq8yeTqzT0+5KTxgo8KanALX3LW95i9gAew57vwlCTPRnaeHuKi0JLGxcPyzmI444YnQjY/GV0XYhCkmVHn5XlYVwO4m0KMq9xSTHSKvrAOWNNG0kVjbgspCG9HAvBCxzekFpKcploNeqBiwq8yEcC6SGjhfPOUoF0hT1OHWC2hFqkHUtuvwMTNIDQWNcmQetiBp/g4HhZfYJY58kVkwDolUFUtXI1jVXDVWN6alvzQhOcu38PqQnr0Bm9ngUaBP8n8MYrtmOID15lv43C/Ptu+++wQI3Fy+bgyukJwnhCLeTsKUsFEF6eH+IAkHW6hLCnwsZZYMlJqasjTGpe0+z5KiqyyuuYbA55zF2caquRhk6dXfg8kUtguhg7DjlV63hoA2YY6Iqj8uqBNercWgQHg4SacbNzOxBMUblUxXI7BOm7Q6yxDn5mJ7iMLJ1L0tCelAKAftAHnjFK14hn/zkJ4PDOqoj6+wXv/hF8P0sqBTpyQsEYmKQMLCNCvMV0f4hLuJeC5lBqFZIjrbTuIsgPUibehKlRoO6hDSzpKxWGEnICL9DwDCn4jRZcjavFQKMEUo6D8L1X9js2IgwdqSRUkwxTSxQ1WEqJy67tkylhzXF9doqucF80j5hfAZ7KASIemYoshBnJUDsq0nmRhWVnqrG9NRStM9A5QF51en5h3/4BznvvPOCmKHXve51QYYYgfaf+9znMr2v2yu1ACDVEr/DwDUrzOcS6Wll7NkscEnwyrMNQ56Eg3tgbFASbrzxxmDTPPDAA7fZNIto+pkle0urXGMIyJLL60QUFxrPkxUYMtaLGjStDm2qQK1igdpR6anC9TJWEO88DDPjrH3C9thjj+AwqXFiVNTl/9r1m7nRquu3V3rcJz29vb25ZS1ii6+44oqgXg/zh0wu4oWyhme4vVJDsGnkzMDeOC4Hl0hPs2thAybFvplqZdPo51VLgwXFPZBeTdFEiieGP8dlpQdVhfgdSBvqVJmZTXqtEBIbaf1mf61wTx+tDq1BrxoLFO4F1W5KjwsJDs3AOmHPIBaiqNR6ngmfx8vsE4YCrdmCZtdvc27o3lI1VDWmp7Y1iDnJXo7Km3cmH3PkzDPPtPqe7bMDJQCbFPEhLL64gb0ukZ5GLSCYhBhaTlBx20lkuYa8Fjn3pvV3mo2Pq6RHs8uKqg6dJGU9K+lo1V8rHAukKhAuvnZSgcJKjwvF/JoBlUU7tpeBqD5hOje0TxhzyqwZVUVUNXurljJzq4rxfB1HeiAGuLM4hSQJ7HWJ9ESli6dtJ+Ea6TFTuqlh08xfXKZ7q1EgM+ohUizB8FHFFMu6Vl42Wk+w0cXtrxVHBTJP+lVDVWJ6IBTsXS6RzPDc0D5h2u9JlWQtieBy4UcTWSvlVzFdvcuRORUXlRqdrA8XVwn1djBGEIMkjNxVpQfDiyqCsS0yUNZGZegwUHYgPCwk6gi1CpBzSenhOgjcJIDTVlkA28iqRnCPnM7T9tdqpQIx3ny/CNk8K8yGty4bOq6NZ8z+5bLbxewTxjPlmjnEYVivu+66YG6oCmQ2vHQNVVV6RlIcXovosJ4H3FyplqEGiSyTtMTARaXHbCdB3EiRUqPZA8wGGBtcjgRA8t5xTv5FVoWO+mw1fLgOUA8ZDy1m6RL0GWUtV2Czv1aUCgRhhPDceuutgRJrZoS5Rio0lg2Vh68uGjpNT1eVxGUSaYJnqUH/xAPNnz9/tDYQDS/Zc8IB0a6g6jE9WQoTVgVu7SQ5AHkUg8QGgDsr7YbtEulhU2DCXX/99cHiz9JOIut1ZCUdpkJCB11dfHEWYNb+V1mgn61xVBBOMrRcM84AUqx1WtIi7/5arEsMHG5aiGM43sPsEeaKCqSkx9UaPcxNxp6qyzxXF6+xEcwECQgw846XrjnmBjW7yBiEzJvB8mWSjqoqPbUUqfY+pqcAJF201BIhk0kDSrMsBldIj5kFQdxIVFZTUcjaioIN2Wz3weZGgbO4ndLLVnrYfCloqe5SV40KhCUrOSR4mVNdEVloUfEeZnVoF1QgfZ6uxvNoujj1eLR6tqvzs1kLirAbWXuENeoThtoKQVYVqGiCXOU6PT0J7SP7n1d6HIFZEM5WB2smBAuqTGg7CU7BLGgWfZnIovRoSwb886pUkU3HJhU3/bcspUdPm9wD7STy7juVxWDxtxjALORQg0nLilPCfUGtKV4aC4SRUxXI7BFWpJEzlR6XwJizljBI6vrJqvSVpZi0SlaI6hOmTXQ5kPBzJUB59gkLX3fVUPPZW9UFqgFxLkx+mwXhylZ6iHlAFWFBoSwQ+Fk20iotGlBu1kfi2eI+SUIgyghk5jqJK4D04DZwvdEm8yTLJuxafy1TBUJdM1UgjFxRKpCp9JTR8LYZiH/h+sy4uKopPUrSkmRomu1TIMgaeK8ZYaxbsg6VBGEbbBOUTorp2bBhg09ZLxtszhADFjvxITY3vDJJj7aTwMjut99+QdNNLQFeJpK6t9i8kKBxYR1yyCHbNI1DNSHgMklqatGkBwJBdhkgvsD1gnQAUoBLKq0ipl2OXZWxwyoQBt+MBcpTBXJR6WGOspbCsVft4t5KAvYH7QMGUCtVBSLbFWArVAWyQV47TemZaamdSZFwZ7XGQKNFy6KAyRPU1qh6bxVJj9lOwnTTZY2lsYUkpEMVODblcKYZ74GxSto5t8g6PVwf7jhth8Fcq0LFWJ532honSiLY2KpgMM1mmI1UINPVkYWsaMVgl0iPpnqjyoVjr6pIepIqPa3AOuDgyIv3hNDzvFCezT5hvNIqm1WO6elPuE+gdpNtWzW4sVozQPsbsTkfeeSRuRU5K5r0aBNUFuYxxxyzTTG4sl1tSUkP9wBhQE6G8ISNBIuH7yVNPW1Umdo21B1HV2niqPQE6gLxbLU2mEds5mkMB64BTr+uuW+yqkAcInB1ZFWB1CC7QnpQMbiWKJe+KidVQRr3VhLwvuypvMJ9wmhNxP/NjMG4hR2rqvSMpLhuDhW+InPBwJjibiii7UKRREPvi4UW1bepzKJ8Sa9DK0WzscybN2+7jYMNTQvepTE6eTc9RdHBnXjooYduI+WWWQ06yaYEYUmzCZv9tdoBjVQgiEIaFUiVE97XBSPHWHFPjFfUOqqi0rO8e6I8MTBBJtZ65Zieuszo7yqsT5hWD1dXqcaK6RxqND86KaZnvc/eyh/motVy/42MaVVJj6oKKAooC1H3VQWlxyQMzQpCslnzu2liRvLM3tLGrSxsAuLD11cl0pP0WvldyECj/lrtAFMF0oDXsAqkJKhRqX1XVB7mKuPFtTYyXFUiPSP1uvxq5US5f8wMEUIXB0T+ukLkFTvX5ZRZ+d8DzwkFg5fZJ0zbp0QFROuz7bSYnkmWEoWKRPkrNsXgQHaeeeaZIFh5xowZhXxu3kTDrBodDvINw3WlB2kYwsCiiCIM5kaMywEZOc2GnJfSwykPdxw+bq4/SkEswr2lbrQ00K7qPNukpRYYN+4tTn+tdoAZ8KoqkAa8EitoZozpKV9JRNmkR6sua9ZSs9+rCum5arnI/Zu2dalC2X+3WGSviXXZfXxXqRmDrCtVCUnK4LlqYcSqlQbISnpcqz7fdqSHyXbjjTcGg4M7q8jy43mSHowSWWeQhTjtJFxWeswKxVpwsNl4cs9pTwt5KD1sZLgWNVOu0QZWZjXouHOKa+T5a0XmIvprtQPCfaBUBcINpiqQrsGyXRlkaqH0tMqiqRLpuXFl85/tXrKdRT015wdjwL7BgRWwlytJcrlPmImkc1ldgF7pyRmcvJloSI5FTyTd5GxvHmyoGFlOCkcccUSsk6OrSg/qG/E7cSsUc++oCWnH0vZzwBWH2gbZaVUV2nX3FmoFxjvpXEV5gyhV8QSXB8Jpz6oC4V6HbKA6a9ozX4ssYwCZZbxwHbdaQ1VSINYPN/7ZQJOflQGeKWoqL1yl1157bbD/ERQd7hOmAdEuouZ7b7kJJlhZVYi1lLst0sP7II1iZJOm2buk9CgR1ArYVCimRkicDRsDkqXOgy3iAXEiY4N4KoinGrgiPjvOtaWB1qhJcq1599dqJxVI42hQBLUdicZ66Cm/USyQtUDf5cuDMY6TalwlpWfPCSJ3rIn+2R7F9VRODN2TWT+aFs/cYJ6YfcI0FgiiVLZ7NGuXdVfrdzWDG088Aco6YeuEYLPLmiWmVX3ZtOIa2SiFo+yNjOvgeaBUYSyTVMBG5eF3syx6G0qP9v9S12Lck1gR89CsBaOdvON09NZUddP9G+dai+yvVXXo2iOmECNH0oHGekTFAtlWgVg/zIO4cVdl7xVJcOoskbvX1KUm217vtD6RY5NtlaXVFgr3CeNQy7pUVykEiPmiZROwAXmSZNtKT61W8ynr7Q6dEFmNLH5QSILGJaWpgWJeS5kxBUx81BEWblRqfSOw+DkBIQdnQVbSo/WDMBxJO9XnHcjMe+v7a/yQqe7xPX1FqTyc/vVncTbSsvtrVQ06Nub6C8d6aMaPbRWIPYRTNmpC3PeoEunZbXyXvHb8Yrlqw2RZIhOEWXzwFJFX7SIyvsfde2i1H7O/QJI1+YZxZH7wQiU3yyrwKurwUd+6tyRxf2pHAB/T08bQEzYGOy2063urINlW0L8rM5ASuZYaPAQsUxQyyYZKHAKKStZFnYV4cP2MBSewRqUBmiGvQGZVd5TgsFHqffJ9JUOqAIGwCsQJMhzk3+xaNUXdlf5aVYCSiEbzxowFaqQCpWmEybxgrJL2FataccJdujfKK7pXyI677ibTpkyWvm73rz1punq4T5gWzyS2kMbSEAqdH1liH+NcN0iy9pX0ePdWASgzgDRtLA3XS4ErTny0MMha8M2W6pS1NQYnFjbrJJspz49sB4hfVqQhHvw+48B4xI0/KmoeKtnR9zWNqm545tjr7+q/G2VVtBofxoP3r+IGVhZ43knmfVgFUgPHCR8DF0cF0vR0VLyklXCrpPQAJfZTxo+tBOHJ2oKCv4PIakcB7RPGi+QQbSCrRNlmlfTa1r0jKenh0FqF/oOVj+kpE2lIj9aswZ0TbieRFmoMiw5mNlt+cC8oV9xXUpcSi8XGok2q9PC8KPxI7MrRRx89GujrAulRwhOOC2gE07WlBkL97Hp9xCuZ8V/NSGhV+muVjfXDm+ShtYtkYfdy6evvkt0GB2TqmAmpDZypAmk38EYqEGuNMW1UdbmdSI/ubVWKL7NZmLBRnzDUdZo2o+Tq/Miq0Na2Puuk7i3bDXyLgic9OZIebSfB5CB+xyYrLrrpqBbsYxPSlh9s0km7rEOYbBWUTKL0aId0FinxR2mbcOZBepISnjBMFUhLwzPXlOwwdkrAw8HQEMAq99cqEs9sWi2XLr5bhuo1CQJNukUueuoWOXHWAbLHxGTNcpOqQFr4DsKTxrBWkfQwn6t0zXnFWDbqE8b+a/YJU6Ict09YlmfNPlPFvluVJD1lLoIkpGfRokVB8GKzdhJFXUtWaCwSG+6+++47uukmDSRmofA3tmpVxP18rYUE2cK9aOM0ZiuQWWN00hKeRqnqSrCJXcJwajdkc86wWWpArEdr3LDswS2Ex0Bd6nLD8gdlzvjp0tud3eA1UoFUVSVxIE0sUNVID+uhSipPkR3Wo/qEaQVxwg7MPnJxsgZHMqSrV2lOVZb0lIk4RCNJO4ksKKJAIQuK0yY1eA444IDgJJr2GrSxKAbZ1kKJQzyUfCathZR3IHM4YNkG4cH9iPsD6VvrQOnYaeySxv9oPyE9rUWpQB7PYtXgelk9tEUxC2NwZFie3rhS5k5IX3OqmQrEIYEChMSg4YrUYGhVgaJ6QJnQeVqlcXWh2nVSlNF3y+wTRkFVs0+YmTXYbI7UUpC1qragAJ70WCQ92k4C44MLKM9JkbfSwz0Q/8ICahT/koT0cBrhd22mODYjHnwf3zeGP9wh3QayuLfMLCx9LxtkTFPVeS9kb1QeUvGRvsOxQCgIgM0wHAxt/l6VDGWeqLUY65F6PgcQxgk3OWocaz4c7KoZYWT8MFZmjzA94ZuB8VUAew/XXLUgWReajZq1oXT+qAqkfcKmba0gzhxhv+ikasyVJD2uurfwsUJ4mEjz58/P/ZSi1ZDzgNYSIiW2WfxLEtJDnIJNlafZ57Np3nXXXS0bnpZBesz4HduqCqQHlwDzkM0OshrVn47PZr6y8alhSZIS34nYYcwEGd8zRjbUBrf7WXdXt+w8bgsRyaPqciMXBesSlzMvjQXSYGgz5VlJUlVIjzbIraLS49o1oxSac2Td1oBoPBG0UGFvZB7p2o+7vjWQuYqoHOkpE1Gkh8nCKQtVYZ999gn6rhSxueQVyMyCwGjGqSUUl/RggNnIkOjzJh4sRgKuMfatGp7a/uy8A5ZbvTcbGv3P2OggPI3quKDeQY5MJTIqJd58dboKBLE5Yod5cs2yB7b72SFT58rYHrvxJ5qezjjFIe1mLNC8efO2U4EAbnfi2kyy6yK49qrFIBUZ05MWXNuUKVOC15577hm4tLWPHAema665JlCFVQVq5qkok/RwYOOFrU1T0d+TniQPq7d3m81f20mwsVCgT09URcC20sMmwwmR8uj7779/rGrJSQKJ8SvbPgWFP18JG7FHENA8N6Ckgcx5Eh5AoCvprGxWZrB5GMT8EBfSKu25UUq82Rqj01SgeZN2kq6hEblv7UJZV9ssY6VHDttx70yZW82MCsY/SdXlRioQ73PdddcF34MAccJXFahZLFDZpKdq88kF91YS9PX1BQdR9gRsG2RZg+axA8wXJUDhYphluLcuvfRS+Zd/+ZeAvEPOuNZzzjlHPvGJT7Q36Sm715QSjbALqOiUX5tKj0nejjrqqG1iQLKSHhYUzwpWnpfawjXgr0Zti0vYbH12KyhJsJmhFQZkh42ADQx1rtm1cLLDyCXJjIlbGLETVKCJw71y4rT9AkWNccyD8EAoOcmiytg8KGDUGBdTBdI4Dw10LVsFYj6xZ4CqzaGqkR4F6xc7BonhRcIH39O0eJIhUOtRdv70pz/Ji170okBVLlrpQcH/1re+FajY4K9//au87GUvC5JUXvnKV7Yv6SkTbEBIgo1SuIuELaUHWRPyxvsRfJ2kfk0c0kOcAQspj27C+tyJXyBot0i1LU72Vjhg2TbhqY0MyiNPXCxr1z8ks3adITvOmBurv1bWoO5GKpDpDtPf0yDtKhqDKDLC5q8NgvM4gPEsiePBoETFY6V9T/N6w7FAmhGm7Q/M6tBFq0DMT/aKqrXNqGqafaNYJP5v9glj70D9ufXWW+X73/9+sN4hG+eff76ceuqp1hNFovBP//RP2/wf8kX87BVXXOFJT15gImDEOVnbaCdRttIDi8cdhEKAQpLUMLUiPRgJTgR5KS/qYmFMUNtsGQkbSk+4pYRto795cLU8tPDr0tWzSsZNFqnJ4/L0qlul3v0G2WHSCZHXoz2bbKoHjVQgMzC6XdxgSPoouhjlvFrhQEB4ZnHV1qx9whgLPouXGQvEXAmrQEU0weTzIWVVVE1cj+lphFqM7C321oMPPjhQeiD+KCv8zde+9jV561vfGmSJnnbaaXLGGWcEtrEIYFsoqfK2t70t0d95pScmUHio+YKrBgNbdnfZLCnrZvA1SlVa11Mr0sMGzmLJY6Nkwt92223Bv1lwRRKeVqQn7/gd5P8HHv2J9I5bFf5kWbTiApk07gDp691W8YIYch15z9tmKlCV3WDcB8UBTSXR9rhi8BknairZfC5JgoKbqUBFxAJhUFGGfUxPcajVaolcmhB/gqFReD760Y8Grt6LL75Y/va3vwVtiuKSHmI9IS3NwIG5UQX/D3zgA0Gw9ZlnniltTXrKkDy1nQREA+m3bMKTpTghExwJGxddVndQMxebbpi2M7YAiwz3ItWuaRxahuFsRHrMIN88CA+G9847b5Mpsxc0+I0RWTNwu8yY8oLR73A9GFPGosj100oFCgdDl9FANwkh4fqUXNvOLtL0dIyJ7UNC2muNUoHCNV9sqkBcJ4RelZ4qureqQuJNsCaTxqRquxvAvoLawysJbrrpJjn77LOb/s6nPvUpecMb3rDd9z/5yU/KRRddJJdccsmou7ltSU/R0Iq+lPHHz96KmRYFDInWs4gL7T8FiN/JGnxtnujDix2iyOnBZoC32eGd6rQsNkhPGcYynL1lBizrKdX2po2xgeztOmdH2dzVWOWrjWwpPKggIBFjXXZ/rbAKFE6J1wBWyJBrKpD2GtIxte3eYoxwm9loSByGLYJmNsE0VSAIULg6NP9O+pnaIFdjelwa/3atIg3SFifMevjHHcYrKcjY+u53vxsoSxrUnASe9LRoJwHp0Yq+qCNFdzZvhKQnYzZVCA/3QVsCG4vTPMGbG5S2nGDzs2X4ee5Ip7yv2a3edrfzuDA/N++AZWBmp+F6eHTRbrJxcEv9lTAmjN17G6KLSzbcQqRshAkQBpT7035CLqXEc308Q23lobA1xrw3r7Tp6a2QR82bZioQdV/SqEDMVa0o7t1bbpOeDRs2lNKG4jOf+Yx8+9vfDjK3CDNJg8qRniIkTxYfFX3ZeHmwOrhFNvlshSTXgsGkLYHt4omm0QKbhtfJ5uH1MrK5b7QnjA1ohhn3rB3ezWsoQ+kJKxZ5BSxrOw0aTRK7pO7IWdNeJgue+X7gzjIxYex+MnHcPqN/iyHCZZJH9pwtYCghtBRMI13WDAJ3IRaIUy2qpTnvbBFt9hjuH2KQ1xgVUegvrAKh9OKuUxXIjAVqpAJBnFSNrKLSU8VrTkN6mE82lJ6k+OIXvyhf+MIX5Dvf+U5gk0nCARBvQh3iwt2dsAnyPN1rOwkWJwFZ5mRwifTEMfb8nOBDYmCOOOKIxL7PONcANg8NyH3L/yxLBx4Ngmm7pEd2Gn+A7Cq7Spdk22xVoUIBQKEKbypZG3+mhW7aapzzUHcwiJABSB8yrnmymjh2P5nU+wbZXL9BhmpPSU/PeJk64Vh5Sk6Syxcsk421uuzc2yX71GuyUw4uE1tAFUBRZa2pkmKqOuHCiOGeZUWoQI0KsaUZ7xsX1+Six2vyxNq6TB8rcty0jXLqLuNyrXlSdHVjs/JvMxVIlSDIJNfI72mPv6rG9FTRvTWSsst60XV66AVJWMN///d/By8FAdVf/epX25v05IE47SRcIj2trgW1CvLGhM4rnVvTYO9d/idZO7hk9Pt1qcniDfdI/4qxsu+Mk1K/PxskpK2ZQpW0MrJtEONFbJHtDUDjrzAIFIwMZ1ew6XTX58hes48dNfgXLlol96xdP/o7ywdFHuzqkRmDNdl5bLdz642iZ/QAMhWstIURzXpANgkQWZvEmkC6w9efFJcvrMn3793itgNLN4pctHGcrOnqkvfnWOakbAIRpQIpAdKMMB1/5rnGx1VNNalyynp3ii7rRVdkPu+886y8jyc9WwcdFslppFlGkxINF/rCNMucIu4FgxmlVtlG17iN2xAeEwvX3CXzdjhOeruTZXXwfDn9YxAPO+ywhimLZbm3VMYm3R8Jn8BqSCXXScwUcmuWzY9MKwgr7xXV/0wbhjJP9WcLNw7KPWs3bvdeg3WRy5atlbfM2dJ12QVw/aw34nggdEkIY9GFEQlgRmGLeo8ke0BtpC6/fPhZwmPiqqfr8up5ddlpQj57igv7VaP+TxBKbX3AsyaGUhVpjeuqCjrFvTU8PByocr7LekXdW2Y7iVYVic3TZtkyZqPihHp6olom8RF5b3Zd/Zul3qRi8KahtTKxvzFpiTpZE0+FS4cO6a0MYpFKj55AlWzOmTMnUKDYBCDMECDcUVwPGzekBSKUJJUXVyTZghrfEjV+kAXG33w2D63fNmPLxCMDm2W4XpdeBwwf46sKJC67LGnOeRdG1NgFDg9RP0uythYP1GVVg2RL1s99K0dkpwn57CkuqyaMPwoQCg/jyHVCgMDNN98cKxbIFXQK6Vm/foua7ELpljToaKWH1gWkAJPZEqedhE4MF1ITw0oPC45gZQ14jdqoc7mOWn8olPZZdHX1SH9vfAlUO6RzsobwxCmYVVRMT7MKyxBm3B+aeYR8z8ZtpvJqSfdGBd34O1xljz/+eFBaPexOUXANUTV3ms1cfuaCqdADBmQN33weDWhtFkaEePOMo1L9k865cb3NR2BcjjuxS0pPM3cu64NnjWpKqAFueVRrDhQchIDZI8y1lg8uHIaTor51jSS5bvZp4JWeCkHjCTAySdpJ6CbpQlyPqfQgNXJ6DmebFXIdQ1Olp3uybB5Zu93Pdp64r/T1xKsNg0rCPaCeEMMTd5MuQulJ0jCUn0FyeGkQJ/fGi/kGQVICxMat44g6h8yPe7VZrZZGNXcOmDxOrlrxbDyPif0mjZWeko2euuwgaxww8jbCpgpkKnSNCiNGqUDh2jxhJLmH6eO65MAduuS+lduTpQm9IkfM6u5Y0sNYMDZKYpRQMsc1FojvaV0gMxbIFRXIrM9VJYxs3TuTkB4OL4xN1Qhexyo9+JBRdxg41IQkEh2LypVgZlV6MCacnokjIUOr6NTknu4e2WPiC+SJTVfJwODK0e/PGL+H7D/rlJZ/z0axYMGCoJldmn5meSs9WVtK4C5FSeSlsTgQIALmIUSMG4oC7427p1kBQX4fQxxVc2fH/j45YYeJct3KbYnPpN5uOWXm5NIVVWJ4IIG47IpGOLYnqjCiQhUgxt1sLhpGmjn37vm98u83DclKw83V1y3ywUN6pb+nq2NJD/MawhMugWFeM/8OxwJpRhj7OfdYpgpkxpK1O+lZ3+Iw4DoqSXrSPmxOChAEZDkUkST9RhSukB6ugxMSfu+99torqFNQxiRkkY/pmiQn7PYOeeSpu6R7zLDMmjpXJvXPjLXgiF+BBBDQmqbJYp6BzKZhtJGSznvopoyaxYYNGQCMJXNTVSA293DBRzZ5TrSN5u2psybLTl01uWvtRqmP6Zfdxo2RI6eOlwm95Z3IcFOgqkJo82hJYssNZtZb0ka5HCBUScwayAx2ntAtnzloQG5a1iPLR8YH6s/zZvfIDmPzXbeukx7IpUn248TGQGooccDLVIFIflAVyKwOnTcZqSrpGTZa5iQlPVVFJUlPGrAYiK/glMAr7SbgAulhgRH7wWLXatFlQUkHz7O/voPMnDxTxvWPi3W6w8hrSn3aFgl51GwKByznUYMHxYegZxrqQVq1SB0EUOMX2LCVBBEAzKsVcZg1Migvmz7eapduG0UVy76eJMHQjAXqG4azUSxQmjkXqEqbBuQl82ZJf3/yA1dVU9ZbQRVPRVI3UTMViDVmqkB8bZas0mmkZ2RrHFKS+aHp6i7PqY4mPWaArw2CUDbpYUETG6F9t4oKWG5FevSEHEc941RGwDIp1wTtZvEN21Z6wgHL6hqxTcCZk8S2QHoAz808ueK21Dgg1DBOqxgG3LKNpGWeA8Y6SxNZmyUgOBGGiyq6DnM+aZxIVEq82WstrqHDWKAeFe16cVnp4dlC5k0ikpWkhVUgrQ6tKhAG24wFskFUtNaNq8/ZZo2eDSW1oOho0hN3YmmBPgbWVoBvmaRHyQInmoMPPliuvPLK0gtiaWwRGxdoRWCWLFkSnL6I76CJqw2XkS3SkzV+J8774+ohEJP6Q43iRfhc7WuECkQmGJs2JILOxGzqmg4PwdFnznzn32nctrZJOcBl6VqGTRL5XuPjwinxqHSQUowqRD9OSrwa3zICbl0mPRzeNF09j9RvM7EgTxWoU9LVwx3Wq4hKkp44YGKz+WIYbBboK4v0oFRxelb3nCoRZVYjNkkHpIfNq9HmambMHXLIIQ1TspPCVvZW3oRH1Q8MH+pHXJ84f8fJigBgSDv/15pAnFrZxNUNxtzkd8oycCgZuCxxC2VV8MoC4899hJuLAq0hg/JGHSx+p1lKvP5bjTu/U0YshOukJ0w08syCilKBzFigtCpQJ5GegRJaUNhE25EeMxsI9wEp0DYXfNGkR2MjqPlikgV1u5QdX6Qp181cW9pDCqUqacZcEdlbtgOWGymOPKukBfmoU4JRMJveovLw4r45dUGAqGSrp2b+BhJUpKrAZ3KPZN9BCFw1sllcUKxB9hWzjlKjwojhlHjmfllxEC6nUkdV9i0qBslUgVCdG6lAqgQ1U4GqWKMHeNJTETRaEGw0nMKYuGmzgVwiPSxCgloxmpCF8OZQVofxZkpPGMSY4JLjZ7gYbbs7sig9RQQsc5JE/WDjjGqY2gw8U/6+URo/1wqB5MXvcFolIBwSRNYUn2XWBMqrnIFWkYbscMioMlS6N+cBc+TRRx8N3JKNgrLDGWHmC8MOmSIInT2q6C7xrio9XBd7XJhMlKWaNFKBOFDQFgd1o5EKVHaYQZGkZ8OGDd695QJUWse4tmonYSNVPG+w4CALGDTIQpTBKjuoOkx6wpKndkhnE4nqIVWm0mM2rFTVzLZhwBXCiZFTZJqSApB3xj8OUYRcYqxRICBA3BvqCwQIg811EP+j/cFsxLdpk17enwrLZWYR2gBzGIJiul61cKT25YsTyxAmQOxNPG/tJh6nMGInkB6eNfcd3ttcUKbCKhBzAwLEPFAViPWkJKiq7q2RFAqVj+lxqJ0EmTDUP8lz8jXqeWUTGuyLoSSQtdGG5ZrSY25euAI0Q4n+VHl/ftr4nTwMjkkG0tangcSg8Gl2V5zTl+k25J5UmmdN8HOtDI2LJmuDVG0Ki8pDUUyC66sObS5qtpthX2EcUI7TllWA9PCcOYjFKYyYx3x0lfTwTMLX5mKKfTi7MqwC6cGEg164xlY7dljfoUESRhVQyZgeXRBmcCx+dsqV54081RXuB4OEwSQ7q5WxdEXp4Ro0pocNi02AzaCIHmBJ6/TkHbCsJRJQedKSAS1ECBmJcwrjfnATNFNv+Bnk02yQqkoU12zWBGqlLPF5/B1EihglCFTVofFROl81C405gsKTNiOOZ8R7KGFq1B9MXa15qEAuk56oueO6ahKlAnHA4UBBskJYBcrL61Cme2uCD2SuVjuJLGCCaI0cm2DhcD+w6Kj4HZeVHk1X51q0hlBRPcCSPIO8CY+OIXMzCxnA+HKtzXpwmWANQFTibl5xG6SiToTjW7TPG5+F+lFmerxNoKwBxkzj0Lj3LFloWim4UUB5oy7xpuvVhgrkonLCPYaLEpo/c5n0hMEagASw7nHzqgpExq3GAmkwtGsqUC1l9lZVO6xXVulhk7/hhhtG412K3HjzUFcwcmyyLI4k9+OS0sNGRQ0ZDAWkrageYHEy2IoIWGZOQgYwmpCBtPev/bnYIONeY5ZiYXEbpKp7hsB6DBVuO5c276zQOAVdizYao2IEIcJxa5o06xJvFkbU+RtXBXJR6dGDUtRe57rSEwXzIBVWgTQjDBWI3zN7hJWtAtVqtcT206eslwCkYmJdCNgsejHbJhoaj4TbIWmqrxKOMsE1EPNA0GwZ6cqtApnNvkogj4BlTdfGvZqkQ3yj92ITiktiuC+ev60qzFENUlGBCOZVdwSn1UauiSpCayHxzBlHYuls9LLTNPU0BryRCmT2CgNxCyO6RnoaxfO4qky1QiOixlqGQPMyY4FUBWLOKQEqQwWq1WqJY9W0DUVVUUmlh40gqtN0UZ9tg2hoGiw9tJBEo4qhxbmWMt1b3ANGkUVA8TyIaNFo5t4Kt5TIY0Nh88IlBNnJmq7NqRBDCXlKUnWc+8pD7dQGqSgWpGtTFJM5B1GndhTKpKpAbNhVM1QK1B3ukfW4//77NywRkATMO9aFrX2qmQrUqjCii6SHedtI5aiq0tPKTdRMBaLkA+NoVodOGzifBDVfnLA6yKPRZFGkh2BF1B1Yf5Z4pDKVHj6XhQrpwfiVla7cqE5PES0lHnvssSDonKKRGP+s0GeZRPIm/gTFJQ+jxj3i4oKY07dO7xEVRFN4cYNp2wk2a+YBX6sS68M9Ut8IImdrHAFrG6OVFxlNUhiR7xflbk4Sz9No33ORpOWRBRVWgSDfRatAtYSkh+v0MT0dhqykhwlDzAAbYtZifWUpPZzSqL8DiAMhbbksIxfl3iqipQSEj/5LxO/YkHp5phCYJMoA94lbJo8MOTMLjXsMG6hGDVIhSMQusElrf7BGDVLLhqbdQzYhPLZchOrGKKoZcLPCiBAgCIbWFyu6MGIUuA6urd2Unix7oFloVA8VUSqQKkG2VKCRFM/ax/R0GLKQHo3fwQ1C7EvWhV1GIDPGDdLGwiOYlZpCbPJlkp6oztd5ER4MCMG84JhjjrFSYVpT1CEKSU7kbIxpfPJxlUjuNU4WWrhBKuRNg6FxGWHc1A0GsXDBoDE/cEviTsTI2OxMDxEFZcQ8maSGuUEJDO4Rd0oZhRGjwLxi3TTr0+fCHEkC220oGqlA7Le4lm2pQDVfkbk6qJJ7S10hvGzWEyravaVNTzFsZqAn91eWfK7zIBywnAfhYeNB4cK401LC1ibHyYlxjJuibhpXDKtNA6F9wth009an4Zog9rzMBqmQDIgap1VVgcrIXlFSRxwPSpVtRaZZmnpRUKWOZw9xxUjmlRJvo8lo+NpdcsfFQZ5tKKJUINRJUwUy6wIlOQTVEpIe1gwvn7LeQUhKerTZJgoJykBSw9bqWjT1M0+YRROJ7TDjd5RwlLXBq9KTd8AyRptxJMuOgF5b96sZUmkUkHAVZlukjmtJ2iesERo1SDW7WisBKoIosGFzjxhVgpZxQ9kkXrx/uJVF0TCLR5qVpMsojBiFRvV52jF7Kw9wEDHrbDVSgThctKq2XktIejigAZ+91UFgs9QNo9XCZNPBFYSUSz8w2802i1B69FTMwooqmqgbZllgDLQeCptBHpslRfvYTCACtqt+owqw6SStcKpVmG25UFAEcNvZJnWNTqza1VrdYEU0SNX1iDsA1yzuZq7F5r1qmnpZHbdZryh17FHNikcWVRgxDN6XtdpK6amie6uMa26mAqGstlKBaglJD3YA+IrMJaBMZUEnS7NNmY0cI0L6K0XO8lgQeQcyq5Fgg4LwRJE206VUNNigMfps9Ndcc82o20QL6WUF9wXZ4QRFS4lmp9M04LpRAPHbJ53PxM0wHjaIAS1DUF1spWvHBdfP5zVrkKoqUNbq3pARbX5LeQGePa48m1mH7AkYhSKfoQlIpB6yDjvssETGLK/CiFEqD0Ss2bX5mJ58VaAdjOrQSWORtJ5V1UipiWo5Th2AGplGpEfTfOkJhjKQZz2hPJUeFgonxlakrSzSo5/LieOEE04IFiOZRhhwYhk4+SgBCrdSSOKWhFxoTIRtcCKDtKUJRNZ4Hltp97gti8o2ikKjBqmMKZs196oEKGmDVOYyBxAULE7DAGPAe9pUZHhPyLZtRTcOtHUG8564wSxGyWZhxKTxPFV1b+UZ05OXCjQ8PByMJ4onB684+xBz3NVszLjwpCch9JQTRTbUl86JFUOZd+fpvJQejCCpvPvtt1/LgnthKTxvNApYhtjwMt0mGEwIKKcfM3uolaHDgED4MF559Zdi809bvI5nwDVmmV88P9QdNkACll0LTLTVIFWLR5quyXBzURvQPls2s8Dignl02223Bc8Ctc62QUpaGLGZ8UddaxXX6N1bxahAq1evDtRP9koOP6YK1OhgUXa6Ovvel7/85WC/+vjHP57qPTzpSQg2lKhgZk6mGiBJ/Z0islJsKz1qCKm7gzuHBdAM5uZXBOJWWDbdJvy+2UqB044aTEhQ2GDiboLwsDHk5ZbUFHU2/zSESqswp1UUIBEoH9oYtYjKr1kQbpAKudA4IG2QqiqQqnr83oIFC0YLK5oEh+enrlHbDUuLNgjMV/adXXfdNaiZlfcJPGlhRFMF4neYc632xqq6t6p0zYyLzv/DDz98NMsyKhYIO6C/C+mBHJWl9Py///f/5MILLwzWfMeRnjLltTDpUVcQJ0nUkaImv02lh82Ie4AUQNriGAR9BkpE8hyTtPV3eEaqCOgJHwJEWwVIkBpMXvyMBY/xQGHI634gyDxnJOW0f5+2CrMWlsTwZGmMWha4ZxQuXmaDVMYUgqMNUpnPnGQh72FlgYytNC7PZoCI2Q6KbgWMFGuW50AbmDLQrDBiWAViTFiPreZcFd1btuv0FOmS6+rq2u5gAbnBrnEAxr38rW99K7BvrLuyeu5dcMEFcuutt8p73/teOf/881O/T7V2PEegpEdPk6RzIytz2ioStpQejADxABgHWH9cQ4jh1t/Nk/TYqrBs+riJ78BgYix5ETzL56hakNf9aL+ytEX6slRhZpwhPNxjkeQ8T4QbpLJR45qF3DF+jKuSXjZrbS5qM9iYdWA7KLoViMPA1Vd08HlSN5gSIJ237Bc8r2axQFVTTVyN6WmFWoPMLTNcADKNekes5F/+8he56KKLgnE8/fTT5cUvfnHw0ji5PMGB5sMf/rBcdtllAfnJAk96MtTHYdNhk+XEbDuzpyilR6tEa8PQJIZe08Tz3KjMk6PtgoMYTAyGdjYnHgi1Rwt+xY0bSaoI6KaSBmmrMGudIVsdxF0EcwSXF2PJmuRZcd+cViFCuJ44qdruicWY8t5FnfSpccT90Ki4zHpASd1gGE9VCZrFAnn3VjGoxUxXh6i++c1vDl7f+c535OKLLw6SR375y18G7ibsxvvf/3750Ic+lMt1so7POOMMOeecc4LYvKyoLOkpc9Pms9l0MJq4gsqKicjShsKsEp22yzubmJIB23E9Wv9H7y+PCsvI7cS2cO2k5GusgfZOQgHSuBHtJcUrrU+be4FgYajS3os2GE1CMDGSZLTlUWfIFaDaaXkFXFps1Pwbcmk2SCWwWeOBzJpAaUkQcweinNZVmRRmA9hWMXcuYFOtLtcvG5GH19VlZON4ecGcCbLXmN5t4vPCiQlllcDIuldV0b3Vk/Ca2X/YQ84+++zgBeG/9NJLE7nJCSs477zzmv4OChLECvzzP/9zsEY/8IEPiA1UlvSUBfzoGESUHU6TZUqaaTcIJjvtJHCzZKkSjSHJg/SEA5Y1Y84m8Fnj6tEUX3Px81k8E17ES+C6gACZvaSUACVJn4bwQJCz+MSRluMGy/L8uF6KK1K3pQpGMksT32aVpCE1/JyxPPjgg0dJrTZIZRyVBCVJyYXw8N55Jy4wlpTBgMBGxSm5iFWDdfnq/cOybLN+Z6Lc/pDIq+fU5cW79EQGQzOWEFiefys3mCswCVu7xyENDAxso1IzD1/96lcneg8+s5VQoNeFJ+JrX/uanHXWWYHSA66++upgL+X/KEAUGk0CT3oSbDqcDgnqYtBRRsqe5GmUHjZ9DATXnjXLjE1JA0JtkZ68G4aa1YeJwYrj0mOBmr2kUAzC6dOaPdRIMUBVwtBmib/gszEIcWJHtKEmxNZWJ3gXodlLxPS0GkutMcK60QapNP5N2yBVM8lQAfMO4tfyAoxlVarh/vrJmkF4nsVvF47IETt0y6yxW56ZurZYH6wpxpJnaiq95u/pv12BqUa3exzS+vXrM+8l1OFSAtMKHBA/+9nPbvM9VCXWG/tyGnWtsqSnSPcWkwMDgqGjpgnkp+ju5lFgwibpfaV1GdjQYcdZFimfqYHMtiRpWwHLzUDWltYgSlMjh0UWTp/WekDEAmFIlQCZxgmihaqUJTYI4wypaiUlMy6QOtyPpKSX0dSzCCjxhOyQbdcMmrkX5YaKapDKezOePEMztst8lhwgtEBmXuD9UaK4drOPluuo1ety+8ro9jR895YVI/LS2T3bkVfGkdg6XftJUuLLQlWVnloK9xZKT5FxZOyZYYLEHCAsIy5xahvSUxQ0xRfQP4tNB4nZBdKjE7ZVSwxA9D2bOCdbgpazEgpVYzDCNrLI8gxYNpum8hxsuXrM9GkMryoGGEw+S6sIIwHbyO7REvDNwDUwX/nspK0IqgSNU8I1GSeehmfHs2hFAKMapDKe2iCVTVgJEGPK//MydlpPia8ctsqo9JwWI3WR4SYt+QaNMxJqJKn3ZFSGU+9tFkbMC3ke0lwjPRsSuNddhSc9TaCLkQ2OWAGdIFkCiG3C3AwagU0Cl5zGdXAvNmCqPFmUniIClrVSNqeUPN0DpmKAocIdgU+aWAwNeE0bOBunCrP2l8qzsGLZ0DYvvJKQ1zS1ecIlDsINUiFQEFrWAtdhs+aR1s1ir9HA7Cqhr7tL9pnUJQ+ti2Y+B07p2qZFCC6PViU/zIww3W9cUIGqmGKfRekpu3r7ySefnMmOVWslGcibVUMSOEmyGMOF6jRlvWyYzU+bnRRh58Tv2DT2Zrp62tT5IgKWOY1jPDAauHryaCkRBT4PBQIihHSPwdVy77grtJkmrziBzVp3ptFpX109elqu2qkzDpgnrEmIZJLWGdpcNCvhNyt9Y6whmawDVD0Iqa0GqRp3x3oNB9lXCa+a0y1ff6AmQyHec8jULtlncvdoraE0WYXh2J5WhRHzVIGqWKMnC+kpW+k58cQTg1fHkZ68oK0YtLN21EmSicLGVDb0JBNFejSjBYNKOrZtY28WJkyj9BQRv4NRgvCgrFDEreiNSTuHqxHEKOJeDDfT5GdKgBoFxWJUG6XKQ9AxvBiPNKUHqgDNOEQtg7y2IoqrNm+QO1YulKc3rpGeepfM7p0gu3bbmWOq2vGsuY6oBqmMlbrBkmT46bpl3yljztrEXpO65f27rZdLlnbLU8P9MqFX5PgZ3XLKTt3B/oq73VatoUZuMFWS81SBqqr0jIyMJFYQw9lbVUSlSY/22LEFMmNwDzAZiN9ptLG64t5qpLJoWwwCdXFz5EEozHT1pKSnCMLDKRIjSVBkWcX4tOhheB6ZzTS1fgzGkrnHdapaAFnTTQmjGm5maaYxU0m7jAKZRYBnxHzmfnFPtoptWbF5QC5aeLcMjjy7RtfWNsuap++Xl+06X7ozzgU2fsbFDCoON0hlTLUgpJnhx9dG16/uSVQPyHHV1True/LgannPXpD+vu2KKx5yyCHW3O1x+oNpZqhtFaiKLSgAzyFJkoNW1S5b6elo0mMTmtnEpkRmU7NJ7BLpMZUeM60+77YYbOw6+ZOQniIClmkNghuJcSyqaBxYu+F+eWbNZbJh8Cnp7Z4kPbX9ZPedXtL0HiFFKAa8eCa4wiBAkBkMJid+XmY1W8CYc1LGUFYpjTltIgEEg/o6cYzLbSue3IbwKBZtXCMLBlbKHhPTd1fXjL1mfbbUtcnLbJDKvGTMohqkavwgBB2i3g5ADWO8zHnL/sTcLrK4YrNg6HBhRHWxJyFBVVV6aincW4xp2TE9WeFJz9Y0ZlxacTObXFR6tC6LxjuEVQHbMGN64pCeIgKWuQZiPiANuCabBf3axqqBO2XBsp9tTcgVGaqtlCG5Xp5Zt0nmjn1LrPfgmTBuvHCZoChobzDcW3zVgoiQOoCrp0pZPUk3WD2IJOkV9uTAqoY/WziwKhPpQQ2GgMaV+MMNUiFxGgxNYUTWEIQV0sP+0yr1vipgrUPgmcu6zrlfAtCLXptJusTrPpbEDVblmJ7uhNftQkxPR5OerO4tNZKUpsc9ELeJo0ukh0nLRnrLLbcE1xS3Q3oW8Dlmmnwr0hMuNZ9HwDIkjB5ifKXKdJH1TLi/Jav+Mkp4TKwauF1mTTlZxo1JXpSQzYUXEjQvDC6xEBgPnjlKAgol87aK8noc5RUSQHB2kvnS290tw7Xo+djTlc04odpAeNIaOeYlCiwv1hDFEFGAID/EZeEW08KIVanJ08g4MmbMX60MzuEySQB6EUiaEq//7kSlp77VveVjeioKDAhyMqc2iEKSbAuXSA+AuGH4CAoswvhBLPgc/axmpMfcRPJKIWUhYiAZQzbVotN7h2qrZfPwsoY/X7fx4VSkx6zCjCHkeXN6JiUeo4hagCuTn+MqUJdJlY2lGY+F8sG9JsW8iTPlvjWLI3+216T0tZLYK5hraYpaRoHYFogABy7GD6LAmEJstUGqjmneVZ9tgjUPaVU1hzlK01fX3bCtVKBGwdBVjunpSXDdqnK6RFo7TulJC63+iZsgTQ0MV0gPG4lWmSUosKhN0XRtNSM9RQQs4xYgLZ/gT1xCZRiG7i7cS3xutOrY0z02cxVm7hMiYFYfhuiqGwxjiWIJAeYkptlgzWJPXAQkACNJqnbarJ4jZ+wmT65bIetGBrf5/iHTZsuO49Jv2NT6sdGhXZv9knVnunoYt3CDVFyaHM6AjQapRYA5q5WqCRugwjWEJ28FOm8VqFFKPGNVpTWWlvSwzwCv9JSINBNNKxPjXzfLnVeJ9KhcjJtDK8QWuehg+61ITxGEh7FkUyVDLc+g7Vbo7ZkgE8fuK+s3/T2SEE0Zf3AmA8JmAxmIIgI8V9NYagE9jCVuEwi9uktQE1w9kSoRINCVooNZYtJqGzfLsb0zZePkflm0aa2M6e6RvSfPlNnjp2a6PkhP1mwj3gcVR2PvGhmQcIC7tjsJN0hlXBuVMihT5WFf0kB77rPq6mOUG4yvEB5IHWPA2nOpPUYepKerqytTDSoX0DFKDxOUzQZDSeZAlpYATBSVOouGVhdmY6H+DpkQRRGwkZFhWTbwoKxYv0gmjKH31MxtJF4zYDnvDC3tHs5Yxo3FygtBzaLB46Wna5HU6mtHv98lPTJn+huktyfdCZfnhwsEZTJu8KdZQI+/RyHCWKIAsSmbzVFd6cmlsXWQtazNUTVdfKeZs7YU95P0DV7DGz5zOYtawX2aGXdx34vPjWqQyrhqg1Qd02YNUosA8YXMM1Ro/h2nxEDVYD5fDl0ABVb3QVfaY7TCSEK3nAYxu0Kw06IjSI+WdOcrRCGrX5mJooa9yMmsfZX4fOoIsZnYavbZCus2LZa7F/1SBmvrt3xjk8jSzbfIIbucMXoN4YDlvFpKmIajbKmVOUUMxuSJu8iuUz4pqzfcLhs2L5S+nimyw8SjpL9veiZyy5hzUk4zZ3n+kBxeqGG4QjGWZh8pdYMlbdFgC3qfxMqQiZZFEWD+cX+cRG3HjqDyZHEVcp+4YZkvjGcWwpm2QWoRgGQzBlwX9+myGy4LuD9sCnsdMVkaIlF0YcQis7fWr1/vSU/ZiLMBacEvamOYkzMLzEC3oiYvm4n2VaLyrhl0l7fSM1IfkXsWX/As4dmK9ZuXyINL/yR93QePZnRpNl0ez0WDz3lvF1K1NZtKU5KZjzMmHS8yyQ5JB7isbBhws48Ubl2uXdUCXCY8S1ULcIMVMa9RyLQgIwQ2q4FkU+Y9szZ2DYNnxSttjJEWVwQodjaJQNwGqUXEd6kbFlSxX1hcQGJ0PLEpplpSdGHEtBjZSs7SKD1VR3vOyq0gsBP/NymvSdNem0EnCpO/iIWtdYSi+oAVofSsHHhUNg+vi/zZ8oGHZafufWV4sCvX+B1O2mw0yPcm6SsLKDDEZXA9EGpbYGNRkm77vU2gAJCFxIuNWN1g1HpStUBJUB7kUlVLW/2lNLYCYmI7bkmblaZ5X8gSbSWSFFdMi1YNUlkzZnyXzb2L589ey/0Rk+Vq7FhWsDaYtzxLXOut7jPvwohpUdtKvpKSHpfix9KiLUmP2VmcrCYbvV1M6ATNXWEx4pAa1REqQukJKzzboi59/V3y5OOLA1WNDZXnbfNUqc00tVpt2YsOVwzXxHjYdK8RpwWxIx6He2Xci8h4YQ6pO4QigKgFEDrWDyRIKwjzsuHTh0RgOHg/Pi/r+6lbi7Gw/bxYWzwPxiTNPIHwEItTBlEPx3cxv5i32iAV4qPjniU4VYkdClbexK5swsN9QhaxK0nvM4/CiEWTnokV77vVlqSH0w1F6ljUxO/kNUhpO4snOTkRA8B9NKsjxKLIu+P75LGNN/ze7n6ZveM8mT1r79EU29tuu20b2T2Lu0TL1rvSTBMDqAXkbEq9BH4Sk6G1aSCQqANFG0pTLTArCDOuZFehEKlakCZoFjWGeU3lc1sElmfFJp5HFXIIGvecVO3i7zCQzNmySimYYJy0pQnxXVrmINwgVZvexh1X5gfrnb9HNSzb5Zy3KzYt4bFRGNHmXlDbGs+TZF5qTE/VUWnSEx4wPUFCdCAKebqe8szgYnKxYTLBWt1HEUrPxP4dZfr4vWTFhke2+9kuk4+Svt7+YCyolcPLzBrCLceGoRsqX+PENPAeWtTMlWaaGFfuCyXLlqJg9gqjuKTGo6ASuFDXJFxBWINmcWXEbaQZJnYYXVsF/jjkMCaQC9sEUdPUk/aI0mrSNomdbWi1b67RbJDKgTHuuDJHITw8H94r79Y3ZYH9i/2Y5wDhyeMgkrYwYlqMpCio2A7VmCtPekwQUKouENIH895o8iIbGBROwpz245wQi8reOnDnV8sjyy+VJWvvkZH6kPR0jZPpY+bL3GnP2e4aw1lDGA6tG4PRY3NUFSjKsLPJMJacIglYdsH4Y8hIHacQpK2aI1qzBTKgKenrhoZl/dCQDGzcWHoqfqug2XAjTa7fdINFKXYmscsKroF5xefmUQcGlRUkcf0ocUhbTboMRDVINdcrz1fdYJrlpwcz/oZ5yh7UjplakGozJqso5TVuYcS0KlAtRbNRH8jsCFik+KhZoEzKorpq2yY9euLnXugOHjeGoKhCiT3dY2SfmS+WPaadLJuH1ouMjJGlzyzbpgdXFNggiQnhhbtEG2eqrK6l9nnxO2ZXbQhP2RkgjAtKAps8KpYt+Z7npm5Y7rPW1ycXLFwijwxsCH6O+Thm9Tp57oxnGza6hKhGmjqu1I5h/NRQog6RTWRbsYOIgrxUwFbd1KMOXpAEXLHMlSrCHFcOj2aDVNRI5j8/4/+ofwRMk2hR1fttRXjUdQdZLyt5olFhxCwqUC1lh3Wv9DgSWAYDxQ1U5IDYJBtatEyLsyXZxIsiPaMd0uvdMm7M1GBhjRu3PjAMSeR/VBsy0HhpqX2CZhlHDQ7n/dhkXCA8XB/EhE3d1klWU+8ZO8ab+/zxE0/LM5ufbZtAlNa1K1ZLT1eXnDDDfbcBJEdrx7AuITqMq9YygfxgQMMtTNKC90J543CQBynE4PEZcVUpgr45sOD+yFq12SWE3ZsQHO6Tucs9o+JqU9F2JDyaXVh2tqjtlPhayg7rcQqkuo5Ku7eCSri9vQHhKVpatUU2MIAoG0xY7iOpTF+Ee8uUVs3gN8gZZQFYCGkC+8xS+9pSArWHE8XVV1+dOA7IJjQjiPGB8NgiYNyb9n1D0eN5Pj6wYRvCY+LmVWvk2OlTA/JTFfCscHlgICG5KAaQY7OFgqp7abKGmIeMDe+TV+CsGvNW85p5wn2h0roSe5YXIJmoeNr2hWfEfTO21157bWUbpIbBmofwoPLpGnUVjYKhGxWK7dqqAqVReojpSZPF6BoqTXrYMDlZlbWxZyU9bBYoHMS4pK1VkqfSoxVF9f3D0f5ktUDS2AyTBnuan4Fsru5JjRcJxwFhTAggbhQHZBNsFHw2igWEx1YKrmYuoYbgEtJnuXRTNOEBG2sjsn64JlP6eit1StbK4Vp0kLGD/JjuTRQD1rAaSsY4jqHE3ch753HqXD9Yl56ukYCctsoW1NIYuLWoPlz17tNxYpUoMaCGTxU8nhNrRd1gWnDSrAlUlXgfzUZjbkF4qkTcWqlAZkr80NBQKqXHZ2+VjDInpLLlrIHXWRqf5qn0mCcG/ZwoYKgIxE2j9vD+1IEhNgPjqEYjaRyQzXnAs+R+AJu5LcKDIsa9YjTCmUuTmxCaPtyIPe6eNKNOgxg9xjLKLWC6NzVrSIP3gRpKlKIodY25oHVzbI777Utr8n8PDcoT6yA9dTlo8hR574590t9knphzt+pNGJuB9YBCBwlQIqhNULXZMaTGzN7kIAQBQhlin1N1T2sCuUgmlPBoXSUXr9GGClSr1YJ5y/rigBK3MKKv09PhSKuwMPHIYkHBsFE4MQ+lJ0nDUJQeFB82wCQpqyw2DB2fQSBvsx5BzeKAbNUDAjxHNnjeg3GxIWvzLJ944ong1SjeY++JE2Rib0+g6IQxf8pEGeOwvB7V8iVubZpw1hAbsWkow1l+jA8/5/s2lYN7ltfkK7dvlpGtYSm1epfcuWaM/NtNm+Wrzxkr/T1dTfuiVb2DeDOo21lVWAXEk7UXpbqybhgjXuEGqex9LjVINQnPrbfeGuwh+++/f+UJTxj6jLu7u4MxgMBQUZr/xy2M6EmPI2BwygiiS0M2ONmyWWIcjjnmGCtyuG2lxyyQFbd4lao9qC5xlBE2TAJc+X1Oj0nUFDMOyEY9IHNsuAf+hr+3semZ3cObuT96u7vk9bvuJBc+9YysMWo/7T1xvJwyy6209UaAiOL+QLWk9kvS58fvm4ZSq16b6h7Pj6+2ExZ+8+jQKOExsWRDXa5bVJOT5/Ru13eJsW3nhpqAmCyePcbRLJ/AHoGSw1jFGedwg1StCeRCg1QAKUPh4TpsVAh3FVoiY+XKlduQ9biFEVmT3r3VweCUSsBbUtmfTZKAZVsBmLazyOIqPCZYPNxPHLVHjWM4riUNorqIowAljQOCLOFu1DRrG5semzn3yRyJ0z18p7H98r55c+TxgY3y5NJlstf0aTJnSj59t2xDXXeckG0FOuICgTzxYnz4DCVB1Pyx2UPq4dWNDw0PrX6W9GjNFuZ6O/eXAlowMyo4mxM/aySNAeSZsSZ5aeweBKiMBqlKeFB4+Dz2kHYmPBDYZcuWbadOmrFAeoCOKozI3loGKbWN6kRHOoYkZANmDeHB381Jwqacq0oPkzPtgm0VsBwHbIwsimYl7ElxZeHZNI6N2ieopM41NYsDwpCh8GBkMaA2Nj2kctQACG4SNaC7q0vmTRwv49b2yeSKxPFgHHFH5ZmqrRI8RolxUjcYgdA8a9MNlsbVNKW/S5ZtrDf8GWA+QXgaxSq1CzSxgLVKwcxww1tVeWxkZ5mxe2aDVE1ggMyqAsTBxjbJ1IrSEDAXWoXkTXjY54488simB0DTDQb0EHzuuecG48IzqzoqT3rKcm/FDWRm88DFwYZNTIptmJH6aTaFcMCyBrQlhan2hE+Guug4rXNyLKJcvSmpaxwQi9aMA+I62WjZdONmDsVNSdfYgDTGsajaSzaKghLzodWk8/ocDCHjqW4t7SGFoUJ1YFxR6pDu+R1VCuIGuT9/dq9c8Mj2/eu6u0ROmt07Wn3YVoNU18eUdYpxjHIjQv6Ym3nURGvWIFVjvHRss2ZwMm8gPLjJcae285gSw6OEZ3zCgHueyy9/+Uv59Kc/LRdffLGcfPLJUnVUnvSUhVYp6xrPwQaCUUib0t0KalTT1F1IE7/TCPytqj0YG70ujWPihICbp4wsl6g4IIwk9VUgRFw3ikHWekDqusvac8l10qPFNDnx5z2mEA5chI16dWkPKdrPMJaqFEBSmINmkHuj9fHKeb3y2NoRuXXps8+c2OV3HThGJgyvk1vvuCOoS5PVHesy2AvM+LMo15UGmxdRgydOg1SzJlCSwwXvhUsLclVEy6KywHihwnIwSUN46vW6/OpXv5KPfvSj8utf/7otCA/wpCclmhkmzUxis27WId220lMW4THVHkgDfno2Im0pwQkO4+hC0Cf3qqoBKhD3HY4DYjNN2lRUs1xsuO7ybGabFVwXcxuCQap2nj5+PgPXMOMRh9CH06YhtxhKFCDWIgZUDaXpBiOQ/J+O6Jd7lmyQW57eIDtNnyLH79wrtfUr5bbb7grIDkS2XWGm3zdzf2hF7TLqEZkNUnVeaKkD9jLTDdYsXhISjcIDiW5nEgtwUxIr1YjEtsJFF10kH/zgB+X//u//5EUvepG0CypPesqatI1Ij0rhGNVjjz0291YK6o5KogykDViOcy2QBgwNGxEbkroEXImBYHy4PrMppsYBaf8oSBCSepx6QBoDQXBtOMsly9xKEiRfFLR6OEaFjTTPua1uLcYgzaHBDHI33WCQUxQN1qeOrQbM7j6hJjN2GZKdd+4b7QhvFuNrR7AHUIOHddGKxKLsmSpuWYDcxmmQqmtc1y33iMLDYYcYonYnPIRWpCU8f/zjH+Vd73qX/PznP5eXvexl0k6oPOkpC1GkR08exO4U6Sc2o+7zDlhuBU6JkAdcR5p948rmggLFCREVJ8qQmv2jouKA2Ej5W60HxDNH3eE9MRi24hzijmeRgDRAeLRSbd6GD0OGqmSjgTDzj7HhhdsxKmBW40SYF5yOUYcIWM5aR8tlaNNbyCzGsZlCwu/wituLzKUGqaxbDD+uHvYjCE87g72XQxhhFWn2pL/97W/yzne+U3784x/Lq171Kmk3eNJjgfRoAToCxtgoi+44HCcGxGxIp+qQbTKiz4HTNPEzkD9XCA+nVOR7jGicDJ9W9YAgPsQpcX8QHpsF6lyL6eHZQXhQPIog85ASnjfPPg9yFQ6Y1bGF7DC2kC3mbjs0V2zlpmSeYRxbuZ6ZAxhQ19P0ww1SGVv2I0gs85b7oP5Q2MXZLtBCqGnbolx++eXy1re+Vb7//e/L61//emlHVJ70lO3e4oWkiipA3EoZG2WrAoVm/E6rUuNpoaoHz4EaJkjJvMIpr0VDgy9ReTCiaWJQwvWAuEfGXJ8p7oEsDTQbza0sZQhs91wqKq5F3VrMmyKMko4tJJaAe4wk8R7MGU7LXIe6SjD6ZY+HDUDstDca2ZSt3JSQUAg+RKJK4P4gc6xXVCDGEHJLcom6OJNm+rkM5isqDyQ2DeG55ppr5IwzzpBvf/vb8uY3v7nyz6NtSU9Z0GDTm2++Ofh/mg7pRSgDeQQsR22inBp5HlqIj40Ut08RBcYUA5uflqVrb5TNwytlbN9MmTnpGNm0fkywYUN4bBSEhMgR9KmxShgEs4Gmjb5gjKcqc2WerDU42+y5lDcgG9x7kd3K+Tzuk7Gl3YKWVMCdo24wjAnzR8fWlfYJSaEFFiH/3Guc+aUqT97xibbBdXOvuLOUsJsuTq0Mze+YDVIb9X1zGcTv4L6DxKY5aN5www3yute9Tr761a/KO97xjrYlPKCrXkaRG4vAoJeR6cJGSBYArqy0HdJt4frrrw9O4uH4hyIID7EeFOLD2B900EGjz4HPxl2gxcfyxor1d8pjy36N5mR8t0em9Zwmc3c+xkrmmKoebJqkSIefpxkHxO9GxQHFBbEmzC1blbuz9AvLq9xCGJAMTuHcd1GVX1kbKDzMY8aJsY1ay6wjSLySIG2foNlgZYxTUhDvokkWcQsscp+4g1C/XMi+TEKeUbPYF1vVRzMbpGoBPq0JpPFArhMeQitQ2NMcFm655RZ5xSteIZ/97GflQx/6UFsTHlAtOhuBMgaIEzDuDUCKctl+7rDSU0TAMsAIQAKiYj00kwt3Qd5qz8jIkCxY8YcQ4QE1WS/XSW/v8Zk/g42fuAC6LzeK2WoVB6RGklcrA1JWXI/259FiZkWlJ/O8eFbMmaIIj8a18BXVA8LaiAiYjW1R+HCXaksMlL9GGUOuQPtLaQfxuAQcMoDLtkqEh3XHQQyXFkkJrRDVIFUPLqi3BLgrAXJN4WNf4hqj2oXEwR133CGvfOUr5ZxzzukIwtMWpKeMiqVsdJyAOTW5kGVjxvSYHdJBHgHLABVHK0038vWzWT614nq5Y+FFMlxfJ+P7dpRdpp4gO4zf127MzsAjUhvZGPnzodoaWb95oUwaOzdTgS9OU0mqSTfqC6ZGUusBNYoDKoP0aHwSBh03Zdaqt0kNFc+sqJg43Bts+LgxiIFAZeLfcdaK2T5BSx2oSkDGkHYR16rfZRtJVCz2Kox2korSzD/mQtGJGVkPYhAeyhSkjUFi3qMO8YIQq8LH2uCZuKLwcfimUGNaheeee+6R008/XT7xiU/Ixz/+8Y4gPMCTnoSnQjYQ6u8gEcdtRZE3zMBXs6VEHputljXnhMFia+b6WLDqb7Jq5KbR/6/b/KQ8+MyTMm/GK2TWpMNiZ5vx7M2v4X8PytJWVy1ZKg8jlUMC0src4b5gWg+oWRxQ0aRH47L4TLLRitzMOVlDClEMi9h41c2jLlnWCes6rZoRzhjSWBGMCnPINJJFKyZajC9N9WHKBnBvVWkyqYSHQ0ajCt5JAREON0hl3XII4vCige68ioxf1GBsaoOlaetz//33y8tf/vJA3fnUpz7VMYQHeNITA/h4NfiPgGXduFxJLVbylXf8Du9vKgHNSMDm4dWyZO2WIO8wnlx1uUztP0BqtS2kJkxk9CubDPfCc2bz0a8YZPN70rWL3L3wSqnVty/o19czSSb0t5a4m5EA7tXmxt+sHpC2TuC0WZRCoJWzua6iu4czXyEIbNxFEAJVPSDruHl0nTAONoJXw13EtXAe8VFaOE8Jbt6xInw294pikbQtCuPC39uok1QEWEOs1zyLSYYVPg1058X45t0g1SQ8uMzTxts99NBDAeE566yz5F//9V87ivC0BenJe8BYTJweWEicIExD5BLpYQFq/608ngnvz3PgsyABrZSANRufaKiwDNXWyYKn75OxvTNHiQsviIX+W78fz/D3yq47vFgWrLgo9JldMmeHl0h3V09i5QESAPHImwQ0igNCumY81UjmJaWbJCBtg9Ss64tnUETskJIAVICw6gHRtt0uJlw4j3mlbjDUUuaXjq1tN5jGtZiZS0mfFfOtCiqPJhgwf4t0xfFsmEu8zLYnkAr2S4i8jq8tVzGxdqg0EJ401d8fffTRoMLym970JvnCF77QcYSnLbK3uHz883mA+AuCOllMUf5h6hrwMyZ1GdCAZeJrYP4aS8Ap01bXcICyo53D4wZBrhi4Xx5aekHDnx86+//JuDF2s4LWbnw0SFnfNLwiSFnfcfLxiWN5CNzEWHDCheSWtSlgdNhEIT7EAuGmaBUHlBS47bjXspppoqBCADAaeacIKwnQzLswcNdiRIqKY9JYEXVzav8oTZnO2vgW1SNtXAsGXAv4ldEgOAl4drgR2ZeKKqsQB2aDVNZZlgapJuFBaSfoPk1lbNSoF7/4xYHKQy2esmPNyoInPU0K7THJOOk38pk2ShUvAuGAZT1pYCBZaEAJULMO03E3lUZp2o1QGxmU2xZ+XWojm7b72cT+2XLQLu8S16D3qmmuZZ6CIARaKA+YcUAYSzZRxjZtPSC9V7JV4mS42AZkDrLO3LTVvqPVvTaK9WAtUSKgrLRsPh+yrRlDGExNmU5KcPVes6geEG4OOkXFWKWF3it1pFx2w5kNUrUvobrB4sZ5sa9zr2kJD2vthS98YfD63ve+17GEpy1ID7DZnBHViBMhE5VsnWYnv5tuuikwGEU3JGwVsKxViFkovDRdGiMZd5HxHihdyKFpN5WVAw/IQ0t/LXV51gXY2z1eDtj57TJhjFubFIGJBBW7soEypyHdUTVGUAn0FMlXjQPiFYfgam+psu6VuWUS8zwNqxZYpC5No3tlffBMXOkTpynTvCC+qhLwQiVodI1LliwJ4oaa3WucsUHlgXTlTUazgH0N1aNq/dGU4GosEApuq3IHzAPcdwTdp7lXYoDokv7c5z5XfvjDH5ZeYqVstAXpgajYuA1ON/j8OTkzwVpJ7nTsZRK2Kn5lE0kLDvL7mi7NS0+RqhJEVZHmvckMYLGRHZAljXjT0CpZuu522VxbExCdmRMPk76e8c6VIcA4cq9FVgJuBgwxxqeVusZYKcFlvMx6QOE4IO6VysKoGmmzPmyA+cjJF2Ulzw2Y+4S0t4p/0FibMhSvVoDgmgUvQVTlYCWyKAFZ3O2MDUQLt5gLBDAKHAYgd+zRrjVATQqz3AFrQqt+a00gxgJXZVoiy76AS4uyDOeee27HEx7gSY+xkLTabtz4BuJcMJL8TdEKT9r6O2zwSoA4cUDw1A3GKQOjyXOASGIYi6zVUjS0bxpyPm5MlyqvQmYw2hDquMRACS4bqMYBQVhV4UO542fca1FFB8GG4SFZsGGtoEfuOnaiLF+8xFpcUrPaSlpWoRVp57DDYcClmJBmlYOVAOECVWWP/7cqIRHnuUH+mRtl98xrBNQsAnnbgfA0q/rNiz2YMedwQEB60jZHvMdLX/rSwNV5/vnnV661Rl7oeNLDQqegGC8WUpKND3KAoYQk5Q2N37GZkq59ozCQLDYCoTWLhQ20SlVY09w7JyjGH3LnYhuBrK0oNA5Ix5c5wwaKO7aoBou3rFgkN61cLCNbldge6ZIjxu8gx+6az0GB8VSVEvd0HBeNBoyXlZCQFpAe1B2UIJC17xvvh6FE5XEx5kNTtbOqWVWAZg0zlri6tf9Z3AapzGmytHDZXnDBBU7ub2Who0mP1p1hgqRp1IZKAHsmQDIvFFVhWTM+ID48Ty27j0rgWun1rGBzR6XTHkSu+rhtZBSh3LF5Mn8wZnqSTBoHlAaPrl8lf1r0aOTPXj9nP9lp3MTcKkq3isczASnEKLji2kyqZuG6QAVQhUDH13SDtRpf3g9SAXEqqip2EqBAQWbTpmpXCVpk0aw5pA1SIfPaLsWsCWSqOBAkMrRwh/3mN7+pRNmBItEWehckICnp0aqsTB4KDqaZGHnX6SmiwjJgs0MyJsWVuAazXgzETk/BEKAqdiCOStNGQeF+XY1bsDG/dI6j3GkzWK0ponFAGJJmcUBZcM/qLcHKUbh3zTKrpIfnBGnHOCStKI266ZJrsxXYD6gFo/3RVM1iTvPS8WX9hmvGhOP4hkbqsmFYpHd4UzAPinR7xoXGK6HIFtX8tixoaQUO0maCDPPZHF91c0J8b775ZvnP//xPOfnkk4PsrE9/+tPBc7rwwgs94WlXpYfFmqQHlnbgZYMngyUtmSAAFsOCQbENsw1DXhWW1bVHrAf3ECUZm1VlMZLEBLGgNBC6SrKpZnxQKK7I4PMs1wsZT3PyJp7H7LfUaI6bcUC8UEk0Dihr3M3PnrhXVg1uX7IAzBk/SV61677W1j/rmTWCYUzqlsWNiFu7CidixgsXD6d9FJ5W48Pvaz0kXuommTpjltwwvJPcsrpXNo+ITO4ZkefPGJLT57lFelCyIG6dQHjULlFGIkl9JfaJH/3oR/LXv/41aDkCqaXaMo1Eydiq0h5dBDqO9HBqQNVgYmVNUYUwQAhYkGVmaGUJ4mUTJH4nbnoqAZ9KgLh3WwYyb2gmT5VSXDFsjH3SzV5PixA7AiCTzJ+oekDq5kwaJ/LnRY/II+tXR/7s0Kk7yomzsmdLoWJA7nBlqZqVd8B4WdBecKw7dWklhbpJfvTkGHm8tj3Bed3cHnnR7B6nykg0q5XWLmAfZh7H7QwfBofR1772tcH6/fCHPyyXXXaZ/OlPfwoONKeddpp89KMfleOPPz6Xa68aquunMBBnI1ZJmIXEIrIRCJeHeyuPgOUoQ4ErABxzzDGJTgK4AXiRSs37aKq0Ns5UAlRk871W4440jisAQ+FivEKz+QWhT6Nmpa3Ga/YF03Rp3tPsCxYnDgh1YZfBLiGiJ3yq6uvqloOnzrTWE49YnLiVwsPg+Wp/N5fBfkDiBMYNl1ZaVYq1PjR5R3m8Nhz58z8s2Cz7jayUnWfNLFX50hphxGZVKdYqS3sUEmLSEB6IzhlnnBF8Re1hj3vjG98YzBkOP3/84x+daJfkCtpC6dEGlY2gadhskiwiW/57pFcC7OhFZaulhN5HXgHLMH9NtcdQ2NrsecZmwTxcDEqAbPcVigueJVVMUacgui4rUTZSqfVknIeaZcaJQIJQDDRQ1owD0rRbTadeKsNy7fKnZM3QlgKi08eMk+fN2k1mj59kpaYWzyZLbBbPl1N20QVG08QracHUrFmVVy6pyc8ea7xfvr7nAelZtyw4uCjJRQku6hCD8oaKzr1W6ZCSlvDgkkrbI42D51ve8pbgUHfJJZe0vSJmA22h9MRpqIj8feyxx1pNw7al9BQVsAwZgQSkcXu0As/VDLTTTAM+j/vSzTPP7sNRlbW5R0hpFdPv484vzeSB9OR1MmZOQmJ4QTI0DojPxF2McdIsP8il9tOC2uw5caqsHNwk3V1dMm1McpdMo9gHjETS7uFRByaXA/O5Pu4VoFTauNbJfY2fFz857rCDZaw8e4ihZxPrR0ku45zXGuazKKDJvbpaK8gWlLgzh9MQHkjwmWeeGYRs4M7yhCce3F3tCdBo02PRckJiA86jeaQN0mOmpOflzgIYJ9x7qDt5dyI23SBadh11QDNJdPPklQcZgehiKNg0CVR33XWRZX5pnzjUFbKWimgdwBxFBeAFeUbVYX4RSwQZwi3Chm62TZjeP85qR21bPcMwHK6SHq4No8gaIVXb1jw+eFqXTOkTWRPhOT1kWpdMHsMeNCZQv3gxBzWbk7mm2X66jm0Fymq18E4gPKwTFB7ITlQD3Dhk+B/+4R+Cw84VV1zR9mn8NtEW7i0WJZMg3EAQqR8jH9Vk0AZQM4ifOOmkk5wNWNaYFiqZlt1mgWuBkGhFaBa+ptLijkkTmBmGlm1nzAkKdCGuKC02Dw3JfU8+KXN33VWmR8RXMHcgAPjycd/ZeH5JAeFhHagSAFTl42WzHpCWVoDI2qqezLrA3e1aqrYZoE0xPpvqL+vwlidXyM8WT5QNI8++767ju+RjB/TKlID0SOxsP63q3qh3VBxoFimEx7WxyIvwEHOXprAt6/69731vMD8gPK5XEncNbUd6IBBsjBjVvIPgUDCYvNRHcDFgmWeCe4ngRwiPazEt2liRscJlgUoB+dGWGEmfiTZcRNVLE8TrEu5cvVquodXAVqVn57Fj5cU77SQzt5Ifdd8xd1ABinbfMW9RlyCx2ik9PF5x44CSxCvZrsZrowCkbUBi2VdUqbTt7uZgEIzbrJ3kztVdsnKQEgJdctC0rsAFmZScaRwfZFd7R6kbrNW1a9kMLbLocpNTG+C507NRD2VpbN2HPvQhue666+TKK6/M7UDfzmgL0sPmiuTKAsQQMDEgPHmffDnl3HjjjXLqqac6F7AMoeBZsAlhKFyPacEgsnFiHNk8GTtVgJp1ljaVPW0lUvWePH9ft04uWrRou++P7+mRd+2xh9QHB4NTXlkVpcPqThz3UKN6QKZC0Ojv1O2BmmXzEKPzBsPhyvrg2UJ4IGL0TLK9NzAGjF2W9iaNoEHsSoI4dDUreqmxaMSkdALhYWwhPDz7NCo0do7Uc+J3UHjSxAF5tBHpYSFr+mqaeh1pJ/HVV18d1EGImzZvBiznRXhQoCA8EAZUj6q1kOAZaao0myfPSAkQqoJ5P4w97jt+F6PYDrEA/7tggSzeFF3U74TJk6X20ENBifk84tSyqjtZ6wGZcUBaZgIFj0OMbbcHByUMbtZ6XbbAc4XwMLZ5VAvnmfMsef+8lS3GDmKrY6zNb5UAMd4QHrJfScGvUkXsLIQHVxTxaGkIz9lnny1/+MMfAoWHWDqPDiY9GEYUFyaC7aykVurE5ZdfHig9cXrb5B2/A0hdxMWDr5gsLRc28ywwWyaweWKotCUGBJfASlQtCI9LLoos+PpDD8lQg2U5c2BAnj9tWhD8WOTY8oy1FEFcdScutB6QGQfEZ/CZvOJUHs5yTzYCorMCgmDGedgeW9YNMVGsmTIOBhAuzQaD5DLG7IlUC4cIVO1glnSeQXjYs9KQWfbAf/mXfwkah0J4IE0eHU56WNAYxaI770JiqI1ATE8zqbiogGVN92wHF0+z0yNjDbnj9ITxhehWpY1AHPzP44/LisHByJ/N7+mRl+RgFOOoO8Ro5F10Uj8PMou7Osj8mj49MBg2+4KlqYOUdzVeiCzpy3k8UwgP64NnWeZBiDVMvzfWL/OJAw3XZ7rBXHE12iQ83FsaZZbn9bnPfU5++tOfBi4tXJ4e2eBmrmZCYPiKJjxATyfN0oqLCFjW4G1NW27X7AeeHadUniObuLpCIEEEufIzLYhYZbn8sKlT5dKlS7f7PlrivL6+wCXAfafNlEmj7pC6XIQxYi1B3Inpolq4Bsqa9YBaxQFVKV1dO2rn1Q8Oo8nzQ4l2gfDgimZOMbYos2ZvPw5tqNSoUUqAqryONSCd+0hLeL785S8HfbXwKHjCYwdtofRwC7iaygBKD13aw0F4RQUsc9+kaEN8yNBqF7WjmZHgfnFJmG4ANY68cJXgDlEClLRnVNlg3ly2bJncvmrVaAuHsV1d8rJddpE9xo8P4iNQBwAGwna13KLVHXMuo3ig5kTVpYkTB5QEkGU+q6wyDlpzCIOYVxaOVscmeLbMelWq8Gij1EauaCXaOsb8njnGVXGDKeFh/aQJSOd5feMb3wheBC7b7u/YyfCkJyNg4OGeTmbBwTwJjxbhwyiVkcVTNLROC3EAzYwEMSJmSwyeixKgOGm0LoC5c9v998vCDRtknz33lP122EF6jevWmkfqHmD+MQ+y3pup7qAMFOVq4HMhPHHTtKPigJLWAzIVs6KBe4caXzZrDkW57yAORal0rTrDcy0ELcfNqjXHmDkJUE14FTk3k4IDGC4tbfWThvD813/9l3zpS1+Siy++OFDvPeyhLUiPTrQycNVVVwUxNNoJ24zfYbLnZWBV8SDwsepF+FrBTFsm/T5J9VFVLbRWDP9X48jm6SJRZLNHAUD5IEC7mXrHs4EwQH5w10AaeKXpNl6GugNQriA8mm2YJtBT6wHxYi+IEwfEfCojFkzJO/uG7R5pZWRqNQPzk3tlfNJ2htf3Qd3UMUa90sKmmg3mAlizEB4l72kIzw9/+EP5t3/7N/nLX/4SeBE87KJtSA+TrYxbufbaa4ONWlsuFJGhRSEvfOOtFI92AM8SWZyTHgQgS7ySuXFCgDAMGkBps5x+1nmMekesCS6euDEn3Bv3w/1h9HlObLzm3w8MD8nf166WTbVh2WXcBNl9whZio+qOxsYVeYLmerlf3JU2Mi/Nqt/N6gGxTqkATLp6kcofa5c0fMY2r9YBZWdqmWNBjA4xOxAem+QS0qNqLsUWs7o6ba1dXFpaPysN4Tn33HPlk5/8ZNAZ/cQTT8ztWjsZnvRkxA033BBkXHCiKiJDi4BdZHkUD1WX2hWqeGDEbbdZUOOoBAjjiJFQN1gZp2M2chQPNu0slXh5XpAJ3o8NmPd7dON6uXjJQqkZB4Odx46Xk8ZPlcGtp+Yi1R2A6wK1Mq8gXjNVmjE244AYa55PkQXetIAm8Rl5NYfUTC3WSpn9mLgOCA/ryjbhiSJ5zCUlQcxhrfzNMygiWF0JD6QawpN07bIfnXfeefLxj39cfv/738vzn//83K610+FJT0bcdNNNgdqCTJ4n4YFQ0VICQ82mWeWshrjGCgWAzRKCl/fGpUGyGEdOjpAFLYhoO1A4CpyGuV/mka3CdGzEkJ/l69fJxYPrZEuE2bbYu2+cnDZnj8LjIzSmpYgGuFExInxlTinRzdoXLI57FmUJ8m7G/9n+HJ4r4BBWlsubfZCxZa+C8BSpoPLZphsMFZOxVTdYHocZSBeEh/fGZZmG8PzqV7+SD37wg3LhhRcGxW7LxIoVK+QLX/hCsC4/8YlPSLuhbUgPE08Dh4sCj47JzqJGmud0lcdGg0EmrVVdHq4G8NkCp0MIgJbiLzrwmLmk6gBfIV5KgDCStsdYFQ/mUJqOy61w07LFcv3K7VPgwZjubnn/XsmleBsunjLrSUFsiTOBGJpxQLZdnewRjzzySKDO5lFV2rVMLfZgDmdcR9GEJwoQL1WAGG8OizrGNrI62StQZ/Vwlmav+u1vfyvvfve75Ze//KW87GUvk7Jx+umnB8V+CYDH7rQbPOlJCY3fwWBxiuN0oXVieNkKrEMBYOKVRQCKBs8TlxZuB9yGZQdoaz8hjREBZkuMrMZFg1rzVDyuWbZIbl255dqj8KG9D9omMyxPsFaox5KniycONKuPa4hyddqoB6R1aXhfCE+e6qwLmVoQHtYuhzTut2zC0+gwo0qfVv5WN1jStYxyCOHheXMYTbM3E7vzjne8Q37+85/Lq171Kikb3/rWt4JrYj8iSceTHodRpNITFbCsdWI0diBrx3DAeyETY/yLbjtQBuiDRNBykS6PpOOuLTF4MefMLKGkxgbjT4xHnkGt4NH1a+T3Tz8R+bNZ/ePkzbvvI3lD49EgeWX1SBup1+WvT9bk0qdqsmLjiMyZUJdXzuuXI2dtXw+oWa2YOOuQvYE0bRSlZnVpbAAXDm6tMjO1uF/USpQzCI/ranRUxp/pBmsVP6iER9X3NIefv/71r/LWt75VfvKTn8jrX/96KRt33HGHvPSlLw2yz77yla8ELS886XEYRZEes2loo/o7YfcIC0gJUBxJ1ewaTkArm1k7g/vlXol5YAOpQoC2dg1XAqSp3hoI3WzTNBtpFkEA+Lz/e/IRWbJpw3Y/O3327jJvYj4xJmECAIHIW/Fohv+5f0gue3r76unvO7BPTtylJ1atGA2Sbab0aUwL84P7tRmAH7XX4DrjWsqqxM5+COHhWTGfXSc8YajSp0QX1V5j+niFA/y5TwgCB14UyzSEh/pub3zjG+X73/++vPnNby79QLt+/fqAnP/Hf/yHvOY1r5GPfOQjnvS4DiZis3YQWaEVlpO2lDA7hrOgOBkoAYqKD9EUbX6XBZVX0KMr0BYanIjZMMOVrasCTttKgNTVqW4w08hrVgu/g0Esqr7IplpNrl22KEhZH6qPBArPsdN3lHmT8p1fzH8Nas2bADTDMxtG5KPXDY5WuDYxfazIt5/TL90t1nOjekBmHBD3qxmHebt4uB4ID3OorIOCSXi437LbetgAapXpBtNSDqr0Mb7s22kJz9VXXy2ve93r5Nvf/raceeaZpRMe8La3vS0gq7S8AJ70dDjpsVVhWQvAqXEESoDYtHTD1KJ0ZRmIosAplfvla6sifFWCBseqq1OVPsaYmBbGmfstI+YBF0+tPiJ93T2FrEkMIveLgSgzxuPyp4blhw8MN/z5144bI7Mnxo/JiIoDgugy9hhCKg/nqXi4kKnFuOL+YF9jPrcD4QmDe+NApkQX1yf3SZkF1nTSPev666+XV7/61YH76D3veY8ThOehhx4Kas2dddZZo4dO4nlIOECFev/73x9klLYL2m+W5ujOAlkCiTVwjhdByRofgvSP4Qec2jgxtQsBaKaMIBETg4CBaKcNE+NOGQNe6h7BlUUMD5sc8UoYyTJaYqBmdHf1FFpk0QUFYGxvV6afh8E4YiB4EXOHewACwDpG5bn55ptHXZ15FMuDTDO3CFwui/AwvqBdCQ9gfaLmocpDciGy7N/EphGkjutLlb5WpS1uueUWee1rXxukg7tCeAD3R48vE4wt+xixpGVW9M4DbZO9xSJkE8hD4eG986ywrJ2WcYNwD5wmNG6g6Aq5RUBr0mjbgXbPSGOzJOiRjRPCo/FezCsd56KKqBUB5i/3y3xOU7ckl2uq1eX9V2+WjRFbxH5Tu+Rfj+rP3ChV05bZN6LigNJmCUWtH9SHsjK1bMS0VAnYAPbnsAsPcsv48mK8lRBp/zdz3vO8SEc/55xz5GMf+5gzhKcRvHurA0lPUS0l8Mmj9GD86aNlltHnxQmSBaRuMNfSQNN2lqYmDWnpri9+W20WUH3MHmmMM8ZL3SNaRE3VgaqOsxI8LbHg0vjesrQm3757SIaNY96Uvrr8y1H9MntC+urXWok3iuDFiQNKk6lFEcsy3N+atQTR6RTCEycrDVthusFwY11zzTXyohe9KMhGJXbnH//xH4MWEy6tiUbwpKfDSI/G7+TdUuLRRx+VhQsXNm2iSZEvJUAYSaRyfPhltUqw0TMsz87SLoHNj0JtcdosmPEhOs5KgFxpptgKXDcGMUzwXMKyjXW5atGwrNgkMntsTfbuWip7zZ2dynhDQCA82k27laKVtR5Q2ZlafL7ZF64TCI/WHSKzKa6qpj3H/vd//1f+/Oc/B3F8HGiJjaHwX5rO60XjKiOmp93QNu4tJqjGxWTN0NKA6LQBy63A+2sjPk5LcTOWOCUqAeJUwcZn1gJyFVqVljo8bJZlFqUrCqrgpSF4Os5aJ4axVQJUdH+suOA6ORFrTamqANUEI560TpIqWrgzaPybZky0tpeOswa8R8UBsWcQR1JWppZWHkaZ4pDWCYSHAwvENgnhMcEB78UvfnGQqcUz+8Mf/iCXXnppsB+8/OUvl3/6p39q+4bRLsKTnhwCllttdPiHeX8IQFo3BpuQnhjxJ6P6KAFyyTCaKdoEPLpMzmyA+UPAMi8bNYfMKrJ8ZfNVw4jC4EK8jBbRxEVbtU0ctwUEleuOa9hwOaPwEJ+19957W1lr4XpAQBUg5pDGBjH2Ra9t7S0FKUvbaqFKsNE7DBUf1xa1eL761a+OPjOUe2r0QID+/d//vSMUb9fgSU+BAcvI2RAelcNtnZZ0w+TUahpG3GB5ZI4k2Sw1pRVFq90z0rTtAOOQR58lnqMaRl58nhpGGwGyWRQt4lmYc1UEa4ZnG+f61YU3Z86cIC4tj7WlTTNV7WNfQg1mPRcd16dB2mmbaVYNrCkID3s1WaVpnjUHHhQeXFm0dWj3Z1Y1tA3p4TZYoK4GLLN5sZjy7ikV7hWlp0NeRaZIa0o6cjybZbvL4VqET6vw5h1vxbxVw8gLBVEzR3gVkdVD1XBOtBDaKlTRbnZowPUKqWgWHExAMnO6SBeedgxnHUN4IV3a4y9LX7A4YD/VIO358+e3vfHWWByeMQpPmkMacTB0Sef13e9+t+2fWRXR0aSniIBlQHsFYlpQd4qUMzVzRA0jhlmrBOepDLBRo/BgRHB5uOJqy1vRYg6WUYQvKuMPgqtjbTvLR4Pw2eBxWbZD1XBi5AhYZX1GzVcIBzFLuLNQeYpAVKZWVByQjrNNVVez0lCYOoXwUBme/RKFJw3hIeYKl9Zzn/tc+eEPf9j2B72qoiNJT1EBy5AOql2ycRHfgVurLISVAZ6VWQvIVo0Yje+YN29eoGq1OzCUnP413sGFjQ5jqfFebOI2mt+a80jbpHAabpcYLdYqJI7DQPieNAuPgGVq4xQBzdTieholOjSLA8pyqFHCg6IUJyut6mBOa284CE+aQwJ7PC4t/v7cc891Yh/waHPSo4s1acByXoSHTYuNEqPIadil9PKoZpnaLTxLjRjS7+mk3QlNUgHPEMKDa4eaNC4aB+0jpAHvWZQBDfAk3qEIF17RwK3Bi6BmfS5U0sblgdqR15zeMFyXq5fU5IHVdRnXI3LMTJGZm55JlKkVjgNKWw+I/QrCw9xgHbe7SqsknrWRlvCwvl7ykpcEz+u8885rmyKj7YqOIj1Fxe9oPAsLiHgW1ysqm64RDBqKlNYCirMJ8FwhO5xMce+UqWgVBRQUXFrU30DVqoJxMJvfajaQEqBwBdmovzWLtFW1eGKreUxsDwoHL/5NYDprmOeUB1YP1uU/7hqSZzZuuw0fP3WzvPugdFmYZj0gXhoHFNUAN0x4br311sA1WoVaMrYSD3hGEJ40JB516KUvfWkQ1H7BBRc4v9d7tBnpYUNudDtFER6MIcYB0kCTNhdP/83AxqcEiHvRoEleUUXyNIBXT/9VKaRnw4VXZHxHnvFebPook43cnVqUTtsOtPNJlpRidRURh5d3kPZPHhqSK5dsaWQcxr8c2id7Tc6+fzSKA9KyB+yFWmhRVctOIDyEHjD/0xIelDXq7RBzdeGFF7Z9dmq7oCNIT1EBy0jhBMPFqcBbtW7hKARaJI8XcQYawAvK7qJdFIj7YLPE3VHVFO0wWDOQViVAqATaEgPSi3tHU5bbPVZBA1qZ78Ro5a1avv/6zTLQoJD8C2f3yJvn2SWYxAFpdqeSO5QdArkhQZ2i8KBMs19DeNIc1Fgvr3jFKwI34EUXXVRKSxCPdGhr0lNUwDKf8dhjjwVZWhjDvKTwMqFF8nSzhOCwgVKLpt1P/+Ex5n7buaq0tj7BKLC5I9kTlO565W9bWWm4tSg8iMsiz3nN+nnfjcMyOBK9J71g52552975uUs4BBKASxAv+yL/V7KL2teOyoVWh8cVD+FJM585FLz61a8O1sUf//jHjlC32wltRXowzCxcs+Cg/j/PlhKa6ogxLKMnTtHQrvCcbpDOOf2rAuRKlWCbYA4R7AjZw4UXt21IlQHZoSgdBB61BwUI9YMNXgPe+X67qALq7oDokZUG8WMeY/xt71EYTd6fQ9qvV06Xe9ZHK6Qfm98rh+yQn7LGdeDSwhWPq5ZrShoHVDVoqYW0hIdnRFsJ9n36anXCXtBuaEvSY8bvsCnnZYTZtIjf6ZSKw4CTIe4OjWfh3pHG+b5ZJVhrAVWdADGPyMJjs4PwdIKMzXhCainAx0uJDcqE2RJDyS7jXWThy7xSliF1EB6IHXsJig8p6lnctry3SXT4N3MIg8vnPLO5Sz5/59B2Lq6Dp3XLR+f3SndOpFIJD4pWVHPYOHFAVYMqtRCeNGSFeMc3vOENQdbm3/72t4AUelQPbUd6MFJFBCwz8TEMTHxSFTsh1oENg5NSo3gWfscshsh4mASoai4wDeBlDkFqOyEzQ2vSEIRPZlojsL4whhrzxf+LKHyZV284rcJrklpIEEQvaaq61gyD5EAueA8IDi9io8LPhsytPy8cDlLWx/aKHD+rW07ZpUd6u/PbuyA8pObHyTwMZ/2BstufJAWdzqkgnpbwQALpOM58v/jii9vavd3uaCvSQwZCEQHLbAB33313oHRUJV3ZVk8pjH+cCrxmcCwvxsasBeQ6gdCyA1qCvwobe1ZQURZXbdLO8Fr4UgkQJ2Ida9xDrga4aydtVfHCSi3G/omFT8nCnlny9KY+mdovcsKOPTK1vyvyGWAYlejw3hAc5g9fXVHBlPBAaNP0DtODjY4190wckJIgF9VubQAMqU0TfsDh521ve1tAmi677LJgbntUF21DetiwybagKiZR9SeffHIuCxB/MASAtM6iqrO64t7JUmSRzZaNEuKkbRI0Dsi1jRKyBuFhE6cKb7uTWrOwJGsoaxyLjrVZ90nJrisFDbXuEAaNeR1FzFZurssXbtskSzc/S1j6ukU+eGCvHD6jJyAAEDzWBi+IDmoORAfFyBWio2AsIDx6WMuKZvWAtC9Y2WsHooJbC8KTxh2FSvfOd74ziOm74oor2jJJpdPQNqSHDeeaa66RX//61/K73/0uWOBUyYQAnXLKKZk3Ww10hFzRUqIT5E0kerM+iy11BhVFFSAUApQjJUBlG0VcNhjDvBvDupiVhvG3naINKVACRKwQrgV1g/HvMp4vhkx7pXHPjdyu37hnSG5fvn0NnbHddfnX/dbLyOYNwf9NouPqfFHCo/M6D7gWB6TueFS8NP3hIMbvec97grly+eWXF9o30SM/tA3pCROgG2+8cZQAsQjpevvKV74y+Jo0ap9N0lQ7OiFFkRMchEfL0ed1atWNEqPIRmn2iSo6M0KDtGmSSrxDu8N0W3ISzvt5h8seoPApASrKKHINZKVBdCDyjdyW64fq8oHrBmWkwe74pl03yfN2HeM00VGgwHDPGpheBDQOSElQ0XFAKJekpmchPB/60Ifk+uuvDxSesvYDbI/GnOFdsJ1N2IloS9ITJkCccCBAv/3tb4OMDJQfCBCusFaSpzaURP5G+nc9FsVm9g5+/6jMjjwNklkMEdVHCRC++DyvQ907ebYccG1daKkFCE/RChtGRYvkmUZRW2LkYRRRLtkLuFfWcjMiv2xjXT52Y+MGxm/eq0deNMf9wHyUVAgP8TtlNQA244B4safmGQekBUQhPGmUS9bGRz7ykUDdufLKK0srNPujH/1IPv/5zwc2iv2PcfzYxz4WfM8jPdqe9IQnMwHIlAz/zW9+E0ifL3jBCwIXGP1TwqdNyA6LlewNYjtc89HnAW2wiNrRLHunCKOoqgAbJWTTrAVkiwBpQTo2yk7pG8azZR1gfKICeItGVNafGQht46ChjTQ127LVWh6p1+XjNw7K8k3RP//ckX2y+yS39wOeKXsY8TuuVIjPOw5I+6WhyKcJQcBGnH322UHRQRQeyGJZ+MEPfiCnn356UFYAEL7xvOc9L/Be0P7CIx06ivRE1eZAAYIAceplQkGAXvaylwWFpz7+8Y8HE4/qm65L2DaeBxkOpHbaCGa1CTYiTZllo9RGmZDRLPVheF/mAIoDxr9dCrA1Q7h1iGvKJfOQQGglQBhIDXqP2wA3DO0rlbSR5rVLavKDB7bvEXHEjG75yEFuPbdGhAel1uX+cDbjgKiyTMBx2n5p7AfnnHNOYBMgPNQicw3EY731rW+Vz372s2VfSmXRsaQnqjQ5kx0ViM0CvPGNb5TPfe5zgXFtZ9LDYud0hJHhhORy0S2zUSYvVIs09WE0e4dNl3vuhKKD3CsSOfcKsa1CGn446D1plWAtwsfvo14mXcc3La3J7xfU5Mn1dZnUJ/L8XXrklbv3SF9ONXRsuafZw1rVWnINUXFA2gS31domwYQDDEkmaVLKsQEQiXPPPTdwaaHsuwYOpRAxrvFNb3pT2ZdTWXjSE/L5v/e975W//OUvQeXNW265RW6++WY55phjAgWIFwFt7USANEgb45IlJb0MsFEhj2MQCcbFqJudwhupGJqVxibKJuma2pEHVO3IOzC9qAa4qgqoyzOqJYZmLGH4s9bTqo3UpcdhohNuEVP1YPwkcUDa6DkL4fnSl74k3//+9wOFh7pcLs59YlHZ77BJrta+qgI86TE2i9e85jXBpPr9738fbBgsBmI9cH/xIpIfNwhB0BAgAgOrTIAgCRh/jH7Vg7Q1VgDyo24RbZ7ISzcJjD9qB4GBbG5VNP5JgbuIe06rdrhK1k1VAAKrChBuLO0dRrZSXinaroHngXqJStFONcRY29oENxwHxPolAQGXVhqXPO/9jW98I3hReJD3cXGuv/71rw/26quvvtppd2UV4EnPVvzjP/5jEND685//PFI2Z3FwoiADDAJ01VVXBZk+SoCKzHKyZQhZRBrn0G7GXzdJXmySxAewUeL3p95Guxj/VsAlxDizUaapwFsFaP83VYEwEnyPAFDGuWrtT7IQHtKaNfC1XcFhjSQHDqSsbQ403HPSOCD29P/6r/+SL3/5y0EvraOOOkpcA3P5jDPOCLwOuN2KKjnQzvCkx1hIKB1xjD+LhU3moosuCuKASG1kc1UXGBuPy8ZFC/CR0dGuhtAE0jj+cDZJxg7yowpQOwcvqyGEkLuSvZM3ID5kpqHyoerxUsUPo9iObgEIAPfM4aVTCujpOHPPqHxJ44DYB/77v/9b/v3f/z0IZzjuuOPExRgnCA/uLE947MGTHku+Z1xiBEFfcsklARsn1fBVr3qVcy4U7a/UKW00zDR8Le5l1gKC9JjFENuFAOLmu/feewOj0O4nfwVjSnyaec+aHq2Kn1b/hgC1Q5FRbRBLnFbSxqhVJnmQefZW856bxQGx7jVZgd/76U9/Kp/61KeC1PQTTzxRXATtL/A8fP3rX99G4eEAQziCRzp40mMZbKwsJAjQX//612DzVQJEoHBZBIiFrp2GWTCd0jSP+8VtGZWGj3RsVghGBVAChHGsKgHS4mydUmjRJPPcM+PXSM3VuBDUTiW8PKO8i1/mSfLCxr+doeplHFULwqvjjRuL7K5TTz01ILvf/va35Q9/+IM8//nPF1fx7ne/O3DHh0FXAapFe6SDJz05x80gnRID9Kc//Sk4dVBUCgKE/7iolGGtR8OGAfFK02m4aoDkEeDIpsE9typFr+myuklCTpUAZakFVEatJV4EZHZCfziT5CXJ3tGWGIw1X7X4pcaFuD7equQ1I3nthixxS1RcJxThZz/7WVCeA5WbkiSEIxx//PEdEfflsQWe9BQEYgsIloMAccLgtIECRCA0/uS8Fh1qBr7vTqpHA8nDnUUQL9l2Sd0YGhirgdCQibxbJNgieSge3HMnEFuzi3YWkqfFL9UtouNdVJ+opNAU7U5S8jQVP0tmGkkoNBClzg37LTGZ7MWMNwVpCWjuFMWsk+FJTwnA10x6JASIhcemigIEAXruc59rLXVc+4ZR0wL3TiecZiB5nAY5yUPysrZYYEOEPGktIN7XrAXkwjM1K0vTR6sdYlWSuGvTNpVsNd68tPaTkqCyyzpoET7XqqYXUWwxS+0hQg7e8Y53BDEyKO2mwktzasjPv/3bv3XEobDT4UlPycCIkv6uHeH5PwQI2ZW2GGmNNnVK2CjYGDulb5hZdwhXh21Coi0StBaQZgZxOuQ5l5EZxKZNXAcp+hj/Tti0tYI6rss8VS2t/aQEiLFHTVLVr+hnrW0W0hbhqyIITKbeUpbq0sRWvu1tb5Mf//jHQb0bj86GJz2OqRTXXnvtKAFik33JS14SKEA0Ro1bLRmpHpcWEf+8qhagmQYYfTbHIisOmwYRkpm1R1Sa+YLkj9KDqlW2ClEEICLaMgVVq8iSA5BczQTDGJPtZ5Y+yHOdZe0rVUVoh/gs/cMoJ0LsDj0Uad3QCXuhR3N40uMoVHZVAgSRIWofAvTCF76w4WZPl2E2x05KVdYCfPj66U1TxsamBhEVSHtEqUHMw91EWXoMAuoSJ3/X4k7yIjzEsuDugPCU2TKF56+Zf6xNbZSZR+afBmp3IuHJ0iGe6sWve93rgkytM8880xMejwCe9FQAnORvvfXWgAARjMepj9RLXGAvfvGLAwPL73zsYx8LDMEnPvGJjtkctTAbmyNtQVzqHK09omwrAsRq0VOqk1ppML/JVkL9dM2NZ2b+MR8ZXzPwPcv4KOFByeuUbDzKfjC/KZyadk3TMujVr361fO1rX5N3vetdnvB4jMKTngpu/gTqUgeIQGgyV04++eRA4SHIEWJ05JFHSicA8kdQJ+4sVyvRamq0GsRWTTLjuNQ4ARPT4Xrlb5ukQjMQITwuV1VmfeL60tIHWQLfSbMmdgnCQxp9J0CbxKprPg2oYIwi/vnPf14+8IEPdMQa8YgPT3oqLvfjAsNXTRorMR4QIBQgUjAxjO244LlvsnbI3qlSoUWMt0mAMIBmk8xWY6VuPBtdw6sCnhlxS3ytWtwS8xQjrgTIbIIb7hQexpNPPhkU1bSZmVYVwoO6k7ZJLAcCEkH+5V/+RT760Y92xBrxSAZPeioMDP9LX/rS4ET0i1/8YlTpQQFCDSL9HQLEJkCGUTtsABgS5H5IHkYQtaSKQBHA9aWB0EAVoCiXiPZLyyL5Vw2oJBAe5i3xLC6UB8gCs1O4GfcFATJj9CguCaHvJMKD2xIXvvYDTAPUQPZD3Ptnn312W+x3HvbhSU9FQXwDcT3IuN/5zne2MQhawwQXGDFAdOg99thjRxuiEvBbxQ1B4zo4EWIQygxktQntGaQECMXOdIkQL0Jaeif1S9NAba0x1W6B2hr3xYvxJdid8YboQegJ1K4qoU8KFDAIjyqYaUCAO/GNH/zgB+Uzn/lMJfc3j2LgSU9FwUaJqkN/lmYLHINKbADqDwTouuuuC2J+lAChGlRhg8AYoHSom8PluI4sYLwI5FQCRFYY39MTcJXcO1kIAW4O1A+qDrd7oLb2gOOgguLB3EaZRQGqSguUrISHooNpXbaUMIDwnHXWWUEcTxX2M4/y4ElPBwHjiQsM8gMJIqWTU7QSIOphuLhhaGVpgoDb8dTfCLg5CFTHAKJuYRDjxoRUFZA8CA+Bu5RdaGeDb4L4HQ4nEHoIvmb/oW5q3JeLLTGyuvsgPJTWSLv3EOgN4TnjjDPkK1/5SsfMF4/08KSngwkQp0tqAOEGo4gXlZshP7jM+LcLBEizlTD2uHc6YVPTisNk5OHGUzeHxoTwQg0i3kPjgNrB1cf9QXi0irgL86+IsYbwMNa4tChvYP6M2B8lQJB/iI+6PausdkJuITzcC9WW04w1h4IXvehFwZ71rW99qyP2Bo/s8KTHI9hcKfj2+9//PiBAl1xySZA9wWZCn5qiKhyHQZwLgaydlK3EWJCGj/sSwtOoCCUGUI0hY0fNHrMWUNWAigXh4dRfVoHJMttp4HJuNW48Ix1zlD/UMFX9qkR6lfBw3fTTSjPWqGIQHgq2fve73/WExyM2POnx2A6cLmnQhwuMvjUYIiVAZNEUQYDY3AnexQCmLUHfKQX4THcIZAkDqAQIMuQ6gUC1Qs1jnIlbcv16bRGehx9+eDRoOSlRDZNeFCJ1g/FvV58h1w3hQbFKq+bhoofsnHjiifLDH/6wrVx+HvmjI0gPasEnP/nJwKBQxI76DW9+85vLvqxKAAP85z//OSBAfMXNdPrppwcusKOOOiqXDQepn+BEFCbiWToB2h2er1kCtfl7iA/tMHBfEviMIeQ52m6PYEvNI14LZTFtMbqqll1gjFB4srYpCRfAJNZLCRBqkCtjroRHXdVprotnRgwPe89Pf/pTT3g8EqPtSQ/SMcaTQLePfOQjcs0118h73/te+eUvfxmUKfdIFnNx8cUXBy4wlCBOpxAgVKDjjjsucx0VTbWn/hD9pDqllQZGC8OPgmazHg2ZbloLCFUAI6MKkAtZQZAziF4nqXnaMJXxQOGx3ZctPObAbIlRlipCRh6ERwPU0xAeCB0NmNnPzzvvvMrXbfIoB21Pev75n/9Zzj333MAHrAvt7W9/e6D6EEPgkf7UdumllwYK0EUXXRQoClSBxgX2nOc8J3FqNdOQRqls1CgduGU65Tni2sH4kZ6dl1Ey2yPwwjiWmRWk7ktcHJ1Se0jnOMYbhSfvOJxw/SfItRkIXVT5Ay1BQEA+hCUN4YHIUXgQ9+cFF1xQaukG1g4uNg4OVYyf63S0PemhKjELBeKj4JTw1re+NQgG9JM2O9hMr7zyytGO8GwKECBcYM973vNaumr4fUgomVoQnioFZVYxM02zgtQYUggwbX+oNMBFwXjTLLVT3JcaoI7xLqNDPJ+Pq1rHnLmH0dZA6LwauDK3UHi0OW4awgNxo6o8sYUcssrMWuPz3/e+9wV7Hs/wbW97m3zve9/zqlOF0Pakh6yf17zmNUENBwUKBdWMyZxIWwHUo3FMybXXXiu/+tWvAgLExsAJDRfYKaecst3myomfgE4MbdV6K2UBhBvCU3a2UpQxVDUAY2jbwOBuRu1A1eL9OwE8YyoGE3CMwuNCh3gyqHTMtSWGKn+2DoIQHi0yCeFJQ+oJcufwRDwainKZzw63JPP2G9/4RtDIlH0LVZtwiX//938v7bo8kqHtSQ8qzxve8Ab54he/OPo9VInnP//5QTAhBscjH6Dg3HDDDaPtMDjlkmbKJgbpJHNFY4I+97nPdUxQIsaP4HoCd9M2VswLkB41hmZaNK+sBgcXM4aCuKVOiddie73vvvsCYoHC4wLhiSInmgnGGuUadcwhQ2kIOUoIhAdFK21Vbcg4cZcQ7z/96U+lK8D/9E//FKjZFAxV0NiUDDLcXa4EjHt0OOk55phjgkX3P//zP6PfQ4V4/etfHxgfNnWP/EFMCT3AIEBIxGRoMfUYG/5flU7ptmJZKMhG/SHX442UAOFi0AaZvJIG4GoTTdS8TllzzHkID+QRwlOFCtqa/ad9wTiIqAIUN/hdCY9WUE9DeEiaeO1rXxvsERAes2hjWeCgjDJ7/vnnj37vb3/7W3CQI/mCVjEe7qPtw98hPWQcmbjqqqsCo9Mpm68LYONjLHjh7sJHz4ZIUCdjgesL1YefuZhabQOcBnFzVCWWBaPFRs7LVANwC+OyUALUrC4MRouTMSpPJzXR1JpLKGe4tKpSPRk3M3OTF/fAwZBxh7yh3GrsF4eUqNgvCI/ZKDYN4YFsk23LnKNOmAuEB7BXsXZN8Dz0Z570VANtX7cbfyub7je/+c3gFEPDTYKaP/ShD5V9aR0J3FwQm6997WtB7A/BnShAGES6xePuQdJmjDhxtosQ+eSTTwb3imunCoQnDIw2TSFRak466aTANYf74eabbw7WFG4rXDjmeGk9mqeeeiow/J1EeFDzIDzM66oQnjAgLFpEkIQQCmbiYqJtBgdHyiyg2EJOAPsr3+N+KTmRhvCQ6fWWt7wlUBapC+bSnOF+IHUm9N47xTXfDmh79xagvQIkh5M2p9cPf/jDQQyJR7GA5CAFkz1HHE8YaiTVBUYNFzZbYoBQhjhhVk0BMpUOCAMqVjuB0z/kVOvCsPlrEDQxW5qtZLsejeuEh0BhSEJVCU8rQOhU+SPYGHICYWF/5b7TkAAIBNlQrBWSTVxzeZORirpFgoZ5iOOQhtLj2vV6dDDpUWiKetlF2ToVGATUDmp1xCULGgSNGnT88ccHZAk3GLVdXCdAWogOw4AhcEWmzwvqDiElnQMG/0fVIg4Cg9Du6477hahj/CF6nZKJSPwNLi2UHl7q+oT4xm2Dwt+9853vDNYLzY9dzOxDnf785z8fzG+Nz3rXu94lN954Y0B0PaqBjiI9HtUEU5TTH+oPr+uvvz4oQw8B4oUv3TUCpEGsmrVTduZJGa6dvfbaKyBBWhjPLIbYbtV0UbzuvvvuQK2A4HYK4eG+cWkBlEzGH9UDFchsg8LYE0MZRXwhPO95z3sCwgjhoVWQi2Atc2A79thj5ROf+ERQf4gq/7/4xS+CoGuPasCTHo/KESBUBNQfVCDaihA/oATIhW7sagA58WMIqpC1Y+u+MVxq+NW1w5ihsmomGK4fsxZQ1QmC3rf2Tav6/SS5b0ovQHS47zCR5ftmJhjzgPHm74jdQwXi3x/84AeD0haUEnG9OjcZiOecc05w39wL1+4JT7XgSY9HZcEmymaKjx0CdMUVVwSVjSE/xAHtu+++hRMgFA02REDQcqcYQAw+982YtLpvsxgi/9bKwLyqRhBbGf52hUn0ILit7tusAv6Zz3wmSPVGMeHvCYa++uqrffaTRyHwpMcRsBmQzkwzPjb/KJAFg5sHt4GLPu8ywaaKK4WqrRAgAiEpTAkBoh8YzzXvmBKUHWIbtD5Jp2R0aMNU7hfCk+S+w5WBCfRWAuS6S1BdO8y9TiI8GrvEuMchPFF/j2uIhBJi/Hh+J554YnBQ4dUpzWc9ykF7RxZWAMR9vOlNbwo2TYpf4dOO2lzPPPPMoJ4NKfhsCjRS9XgWKDpU+X3HO94RdIAn2PDTn/50EBhJ/y+eLydMSAmbrm1gvAm2RrLH3dYphEd7K+HKSkp4AMRm7ty5QYwWmXoEPeMSIQ2eAFGC2VGDXAMKBXMJpDH8VQVrR2OXshA93NOMM/sfKfCQHRRbDiqUN6CYpYdHHvBKT8lgoZP9gCJBdg9BcW984xu3+R16vZBiT00UVB4CeamVQmVpNguP5iCehJofBEHzlYJiZIDx7DC2WRUgjDIVaMlUKsOlVnaHeOZt2t5KjYCKoCnRGEfIkSpAcTOC8oLWo+F+0xC9dkjHT5udhqpDn6qf/exngTuaGkAmGGsqMLMHtmu6v0e58KTHEbCRsolEkR5cJTS2++53vzv6vdNOOy1wo+DO8YgPCCbxBLjAUIQwoNQAggAdd9xxiQ0YRdQwgKgVBGd2CuHB8EH0iMfBdZjnfaN0kgmktYA0I4gXGUFFPnN15aFwdJKiZ1aYTltwEcLzpS99SX7wgx8Eina4urGHRxHoDE22wkBGJtYH/7cJNp6f//znpV1XVUGRPGJ8eKFUXHLJJYECRNl7NnIKkPGzE044oeVJFkOM1E/T2k6KQ8DwQXggHUUoWxALszWCFkMkroTP1lR43Jt5xm1piwXmSSfFbGnT1KyE5+tf/3pwcPOEx6NMeNLjOP7/9s48NspyC+NvMCQKbtEQRYygxARkCZssRWQHF4xGUFQWKYWyKMi+REDEICCgoCCIUlAsm3+ooCxGUBREwAUSVBQEjEgExQUxRNHcm9+5eXunpS3t15nOfPM9v2TCLe3F9pvpvM93znOeQ9opd7oFt1LTosG4K4JDpYwqDw8ONMrtbFHGF8ThyroMBBCtxIJv9LQYqXZQ5cCHEqVWIQc/o8W0Wsu7soWoQeTw4Dmi0uaHAPg9ic0Ciqco8Us0mS4LumIhzIKH5z3oDjH+DVbM0Kanysr1E85NnjzZqs144mLhhovJttmzZ+syJYBo/OaGGP8mwwFbsE2jnnf8oKrTqVMnt2jRIhuhXb16tVWFBg8ebG2r7Oxs8xpQHZo5c6Z5gjhcoyR4mK7iDZowSKpbyW7lITy4GYjdDYUoYZUJmS9Ugsh0KrgvKUi11W8Nj5rgQUz6gM2ggod2Fm0tfn/w0In/8eCDD9oNhA93BKbZuKHicyIxqNKT4rDTBt8CB3EsfIyPRMQf/BpM0vHgDpU3ITxAI0eOtKkwKgzDhw+3IMSoQFWRPBqma1LxdYcAY9ydBxUoWjE8V0wBUalAHHkfUGkOby94EMD16tWLlODhAKaShuAJkp/Ev7FkyRKraCB48MyJ/8PNVPv27V1OTo69z8DixYutokb7VCSGaPwGh5yOHTva0lQPd668ifD3IrHQIqGKgB+B5FUmlfD/4ANi03iPHj1sio7yf7qCd4m7Uao7qSh4ChNAPE+IUg5adrYheo4ePWoheFSr2HpP1e5cuUt8Lbukoih4/LJYKlxB/g08h+PHj7dhC36HxNn069fPLV++3F5rDLNwzdhBJhKHpreSDG8smGHxI3To0MFNnDjRtWvXzjwT5PIAd6rNmjWzPJ9bb73VvfLKK5Zhwp035k6RWHgz4s1py5YtZnymkkC1h+uPBwgB9N1339nzR/TAbbfdZhWHZLd/4gF+GcaU08W7hNDxo/BUr5je8xUgxI2HQ4gKD59n31KUBA/ZVlwjKg5BAiL5N2gPDxkyxH43aBuLoiuJ1apVc/PmzbNqGjdUtGSp7ovEINGTZMjeGTNmzFl/j2dkxIgReR8zLjpnzhy7Q2ViZtSoUaG4604HCDlcu3atmTAL2w3EmzzPjxdAeEpojTEGjxmaKkMYBRBvvng6qHIUlRIe9gMnNgvIbwdHsO7bt88OHgRPGJ+7IPA65rXL9QgqeIDfAUJUV61aZa9/UTy8z/N7huihQpmbm6tLlkAkeoQ4BxyIPvG5pHfKeIB486eK5yP2mRJjuigMhygrTzgA8RYwKRiFah5tPIQef9LWvPrqq/NEUBies7LA63b//v3uxx9/NMGDhykI3BzQnuHgVnBqyaCVyI0Fr7ENGzaYz0ckDokeIRJ4kLBGgQoQsfu0S/CYcBhQyaNdlIqHKa06vm/ShgkfjAqxgYuIUx+GSGvLt8D4XLq1unidHjhwwARfWQTP+vXrbeoI8/I999wT9+8znWFMnevPSo5UfE9IJyR6hCing4XWJNUfHtu3b3dNmzbNW4dBuGEqvNkhdhA9jH9T4YiS4MG0TFWLEXj/XODdwvvjl6LyPMaGIaZDQCGCh2lQBE+sr6k0bNq0yfwoRD7wZyq8lsNE7dq1zbOJp1MkFokeIcoZDk4miaj+0AbbunWr5b8gfjBCMxZe3oeGv9vn+0LwYOCNCmReUeFBzBSXMM01IrMG8cM4PFOUiCQEEH+GcekolQVamUxp4ScJAhNxVHYYu6bSI8FTOpjY6t+/v91spKN3LtWQ6BGBIL+DreJMnXFgFzbZwyGBUZsKB5NoSmJ1hV4jDlEWzyKACNXjrs8LoPJY8+B9SHwfHH5B7/bDLHg4bHiNlvRac81YNIv44bpRKaLywzQlAigMwaFU9fjdpMITVPBs27bNde3a1c2aNcsObgmeksN7J+ZlsthIq1YgYfkg0SNKzdixY82oyBgzUKmgLEsmh4dDgNYN484cpAT88TH9/nTzRMQLDlIiDMg1QQDRMiBrBvGDCOJ6x/va+dRdWjg8T0EndsK8Q+zKK68sc8I0/5ZvgZHZhPcHIUX1KEjOTaI5dOiQVRZ4zoNW9bih4bU5depU99BDD0nwBDTQh7FCGGYkekSpIUGUvr0/IAlO5M2Pyg93jTBlyhS3cOFCC7Xj7pcJBdom9Px79eqlq17CahrTMHiAGJdnmsgLoHisQ/Cbs6lY8Nyk4uGcKBApeHgSsUMMwY8BmioQ7TDu5L0ROqhJOJ4gdhA9ZRE8rE9gGpGbHdLJVeERYUGiR5QZDk/K+QganyZKW4aN5bFL8zisCYdjLFOUDqoHpHAjgJiSoYVC5YyFqAjN0gogSuuM0/N8BN2rFFYQeVR4CIWjkpbIA5uQQ58FRBWPNlJsGGJ5iwXaWfh4eM4RY0HgdUMAJ/liVH1TVfCQwxSl17UoGRHKWKoAABQVSURBVOoziDKzefNmO0TJmvBv9GR+1K1bN9/X8XnaXaL0cEd+3333WdItFQTEJHkyvu01evRo81fwPJwLvoY0aYy4QTdnh1k8UuGhalYeW+LxbPDfopLWunVrCxTle9ixY4e1fPk9oRpEmzHRfP/99yZ4+F6CCh5aoVR4hg0blpKCB2E5YcIEu878zlBlpu1e1qWzIn1QM1GUCe5gWdHA9IbfoHzy5El7Ey+Y8YLRkzd4UTZokdx99932oFLDagw8QN27d7dDlkOJChDZHwX9AhwKmJbZKs/hFyU/AWKDCg9b4pmQK2+45hj+eSA8Ea38/tAq4nnwo/D83sRbTDChxXRew4YNA0cR8LqhepudnW1trVQTPEA1lLY7PkNiIBC4pELjnZk5c2ayvz2RAqi9JQLDAcqeMO4aaVl5vwLtA+6yli1b5nr27Jn39fh8GGul3C8SU85/7733LAwRMzTCk0OKahBVBp4v2hLsCJs2bVpaZMyUFIQ44oIKANutU609zHPjjdDgW2DcKJTVu0UGD4IFkRt0pxOCib1/ZMnMmDEjVMMIVHq4KSBhXIjo3OaJuMK0D4cnHoV169blM2h63wKGyVj4OBl32FGBNlXnzp3tsWDBAstPYQP8oEGDzLjL4cpmeA6BKAkeqosIHsQOP3+qgYDAo8WDuAIM7IgfzP9UKGKzgEr7vJG7hOChwhNU8Bw+fNjEM6PpYRM83scUhVUqomSo0iMCCx7KyJhqC5sAyczMdHv27LGJLt6oOXQRPIy2Tpo0SVe9HOHQatWqlQlTcmmoetxyyy1WAerYsWNKTBQlWvBgWKatFSao1PFc+QoQrcxYAUS7rDhYa4BwYp1ISfbGFeUDQkTzenn++eeTIngQgcXBdSgqW4rcK3ZZUXWmSiWERI8oNc2aNbM306eeeipfqBlvrt68TFUHjw9f26lTJ7dy5UprayGCorTeINnQlkCg+kMLMNFS7icRGlM0zw8CiK8JGlKXinBYEpmAYRl/R5hBAMVmAdFCRsj4LCC8XLGwOBTTMdEGl19+eaD/JqIJwUNrlMnMZFQH+ZmZsisOXt+0dAvCTVfbtm0tImPu3LkJ/C5FmJDoEaWG5NDCpoQwM5MjE1ta582S8jIj7AMGDAhcYhfBzKvs9yJTicTcgsZT2l2IAg4MRuG5q+euGAGE9wevViqaVUtajeRnI3Qw7IKnMKjYeQFENYgbCe8D4uMvvvjC1a9fP3BbBzGMh4cbl6VLl4auHcqUKH7Dbt26mdgP6+tYxB+JHiHSFEQN6y2Y5DrXmz6VBIIK8QAhgBil5tBAxOLnSMREUaLAFMxIPmslGBdPd2h7xWYBARNieJiCrBTh32Liiaote6HCNuGH4KPCw3Qj3rawvG5F+SDRI4Q4SwDt27fPWmAIIMTQzTffbAKIcXjaKal6kJw4ccLaGlQWz9UWSTcQPQQHIvQQQlwLfHe+AoT37lzPm5/woyW4atWqc/qGUg1et7TjaHnNmzcv7+flT7XVhb0W/lMeqVhCiFDC2wOBdrTA8ABhCs7IyDABRCI0FYVUEUBe8NSqVcvWS0QJqjMIHgJA/aZuJr98FhB/ImD4HIF9CICCzxseKEQt1w7BG8bQyunTp9ujIKxYweckhESPEKLEAgiDOtUfHh9//LF5hhBAPPDOJEsAcahz6DPyjRCLEv5nr1OnjgmawsCD57OAEEg8T3jtqP7g3SFFneeQNiYt0SjtYRPRQqJHRAre/MktwZiJ56Gou1m+hskRfA1hvOMtDwGEUR3xQ1WAFRhM72GC5vDk2paXAOIQx7jKOg42pkcJX90qzc+O14uqzrPPPusWL15soZZMf1HhYcQ76Hi7EGFAokdEhmeeecai6JloYSUBombOnDn58jtIr6XET0WDFgBfl5uba2PdomgBxLQPFQIE0JYtW+wQ9gIIQ3GiBBCVCzxHxVU50hVv2C5LdYvXN1lNiCeED9cTTw8mYD/BJ0Q6Ea5oTSHKAB4H8oVoBRw6dMiWdPbu3dvaA54+ffpYVg1VjIMHD9qY/b333ps3FSPOBkFDlWHgwIHunXfesXyXIUOGuJ07d7rmzZtbVtPUqVNtqoYqQ7wFD9W4qAkeRvIRPPiXggqe06dPux49etjrnd8LvFtU7BBRPF8Y1mlhCpFOqNIjIgtBiXhSfKWAnBpSe9966y0b2QUyTzB/MgnCYlVRugoQichr1qyxNtjGjRvt+mKAZoyeHJmgCb9UlhBRGHc5nKMErSkM5WWZUMPDQ4WTCg9CtbD8LHZV8XzJ3yPSCYkeESkQNrSumOQgUZrWC1kkwOFMO4ZKRaw/glTbm266yc2fPz+J33n4QUCyBRsBxPoSxKQXQI0bNy6xAPJpw1EVPD50MWgGER4eKpz8LmzatEkeHhEpwpU6JUQZYQv5Cy+8YG/4eBiysrLyPudbWAVj+/lY7a2ygz+EdGge+Kk2bNhgHiCED/4p/sQHRDusqARgv0+qLGnDYYWqmV+rEVTwnDlzxiqWtHf5XZBpWUQNeXpEpOAOF98C47qPPPKIGZQJNAMfxEawW0Hvgya44gtJwWztXr58uVVuaB9iqsU/Rdtm+PDhZojGh+Xha2bPnm2Vt6gJHqpkfnFq0LUaXEt8V1TJ3n333chdQyFAokdEFja+I2Y4AKB69ep5E1yx8HHYNnSHCVKDqfK8/PLLJoBycnIsWgCBSlWD54nHY4895tq0aRN4gWZYQQx++umn7rrrrgv8OuR6Yi7n3+H1HjXjtxAeiR4RCVjQWDB8HDHD3/tDlOWKtFnw9nhoJ9AKY6xXJB5EKNveX3rpJWtlrVixwqaKEETsgFq7dq35gTDiRknwkHvkRXlpYWKOytnWrVtN8EQtrVqIWOTpEZGASR/e+NkQzwFCe8u3SjDSAh6fKVOmuHHjxrlKlSrZ3fDEiRMtr4TdU6J8QeTQeiR8j9A8RCseoGHDhpkYQBzhAWLPEs9XunHq1CkTPFR3atSoEVjwjBkzxsQOHh5VLEXU0fSWiAzk8yxatMhGcfEzsJiQXB7ETiwsWqTCQBWIrxkxYoS1YET5MnfuXGtpUdlp0aJFvoOc/BgEEPvASGTGm4UA6ty5s+XOpIvgwbCMjycIXKdHH33UrhOikVahEFFHokcIkXLQvmInFMsjyVIq7mDH4MtCVEbhjxw5YpUfogd8onCqLEQtKUy2ffLJJ5bBg+AJ8v1TFXv88cfdsmXLrMJDiKEQQqJHCJGicHCX5sBHALGDywugAwcOuPbt25tJukuXLrZMM9UFENVFBA8py1RmggqeadOmWVUTwUPwphDif6jSI4RIOzj4yfNBANECw9OFL4sWGLvVaG+mmgDygodgTMIHgwoevGosEyV4EM+aEOL/SPQIIdIahABVHy+AmMjLyMgwAUQVCJGRbAFEFhSCh5TqoAta+TkROyzVZbVEkyZNEvK9ChFmJHqEEJEBYcAaEsy9tMB27NhhCdB4gHhgHC5vAYTgwbRM9YlgxqCCh6Rxpg9JumbRqxDibJTTI0SIYGqJ1ocfsy84nUbKMR4Oxrlpb4j8ICgY/x45cqTl1hw+fNh1797ddoKxrb1t27Zuzpw5tqahYK5TIiD9G8FDVlRZBM+SJUvMuMyyXAkeIYpGokeIEO1e6tmzp23EJjAxFqoXeFaoFixdutTaNwgfVm6IwkFgUNkZOnSojXRzTTMzM93mzZtdgwYNbMksS2mJOEiEAGJCDcHD/iumq4IKHia0xo8f79588037noUQRaP2lhAhwe+l+vXXX63igwfEQ2DfunXr3Ndff513eDLyDeTciNIJiRMnTpiIoA1GxQyfjd8IX7t27TK3wLzgIQH8hhtuCCx4yJRCtNGqI6tICFE8qvQIEQLwa1DNIayvMKhUcOjFHp7k1HzwwQc2yi1KDteQillWVpa1vdgHNmrUKLd3717XqlUr16hRIzd58mRLig5ybf/++28TPGQIBRU8gCmbfVoIHwkeIUqGRI8QKQ7j1qzDyM3NtdUMhUFrhimkWPiYMWgqQyIYCBLyfVhfQuXn2LFjJjwPHjxo+9jq169vqce7du0qkQDygueiiy4y71VQwcMOsgEDBthr4vbbb3epzgMPPGA/66xZs5L9rYiII9EjQgstCLwXCxcuzHf4037g7jcdYLIHoy1hc8WtEeDArVix4lnLO/2GbREfqM5wgDP+jgDC80MliOwfRMzYsWPdRx99VOg1//nnn93OnTtd5cqVyyR4aFf27dvXvFuM3ac6OTk5tusO8ShEspHoEaGFiRcOGRaJUg3h4MfoyzZq/C/pAB4dfjYveni8+uqr1mrhfzNyDbRjEIEFD9nzzjvPjM8i/iBeunXrZnvaEEBk5GA2994rdrbRXvznn39sPxjrMfBdMSVWoUKwt178RVSdXnzxRftvpzosjJ0wYYK9ZoP+zELEE21ZF6Hm/vvvt4OEP7nr/fLLL20VQbLD5uIFno/9+/fn+ztGk3fv3m2eDvYzwY033ui2b9+e7+sYyab94is+InGwkNZn/dDCYqs5JuhevXqZ4ZjKD5NiTFkFPfwRUFSZ5s+fb6/3VH+NY9amSkk1LOiWeCHijaS3CD0cAmylfuKJJ9zixYvP8raEGQSLr/D4BxM/bIbnf/vt7/g7aKswxQO0UV577TU3aNCgJP8E0YPnDBM5r0UqHaQs4+E5fvy4idiBAwdagCCioKQQPUAF6emnn3a9e/dOecEDVLr4eam+CpEqSPSItPC9IHogqlWN1q1bm/jD60Hbj48ffvhh179//2R/a5Hljz/+sDH3a665xrJ+jh49atUfRCtj5tdee61NiGFK5jVcFLQwaWU9+eSTrl+/fkkTPLTn+G8X9yBsEQhJ5LFgwYKkfK9CFIVyekTo4a6aKaWWLVuaaZL2Fh6XdAWvDocL7ZKCnDlzxoy1/Py+CiTKH16PhENSkVuzZs1ZzwXtLrKWEEG0KXlOO3fubO0x/rzwwgvt6z777DMzSU+aNMmymMJQ4YFx48a5GTNmFPq5K664wl6jQiQDiR4Rap577jk7EMhMueqqqyxHhXYC48VCJAtEDessaC9WqlSp2K/FgM8Yu1+IeuTIERuHJw+IfwMBMWbMmNAInqJAiPOzkHkkRLKQ6BGhhakmNklT3cHYCd9++61r2LCh5YFkZ2cn+1sUolQggNihhgBiGqxdu3YmhMIueECiR6QCEj0itBC6h28Cz0QsjAczJly1atWkfW9ClBWMzoRREjuQDkj0iFRAokcIIYQQkUA5PUKIhMFUXexiVA8tSKaYYqFqR84Syb0s+BRCiHijSo8QImEQoojAycjIyLcmAwN6vXr18j5etmyZmX5J0/7hhx8sVJGpJ6VJCyHiiUSPECLhogefVVExAiROE2K3aNEil5mZaascWrRo4Zo2bWr7pYQQIl4onFAIUS47xGhzIWgKQpWHmIE+ffrYx7S9hgwZYktjybsRQoh4IdEjhEg4rCKgilOlShVrY7GfyvP5559bJk3sWHbjxo0tgJE1DkIIES9kZBZCJAw8OWwGJ2/Gt7vatGljrS52pfnogZo1a+b7//lWGJ8TQoh4oUqPECJhsF3bCx5o0KCBhUbSuvKwL63g7inf1orqLjUhRGKQ6BFClCu0uFi+6fETW7H4j/mcEELEC4keIUTCIHunIBs3bsw3rs6eqZ07d+ZbQvnGG29YVk/BtG0hhCgLGlkXQiSMESNGuJMnT7oOHTpYq2r58uVu3bp1bv369a5169b2NawMYUQdI/Po0aPdV1995aZMmWL7p+666y49O0KIuCHRI4RI6ALNlStXurffftv9+eefrlatWm7w4MFnVXAQRjNnznS7du2yROasrCwTSkIIEU8keoQQQggRCeTpEUIIIUQkkOgRQgghRCSQ6BFCCCFEJJDoEUIIIUQk0BoKIYQ4B+wK27Ztm/vll19cRkaGq1q16llfw6j9nj17bHlqq1atXMWKFXVdhUgxVOkRQohiYDs8QYlDhw617KD27dvnW6MBY8eOdU2bNnW5ubmuf//+tjD1p59+0nUVIsXQyLoQQhQBC0/JFurataubP3++BSiy/X3Hjh154Yrvv/++a9u2rdu6datr2bKl7Q1r1qyZa9KkiVuyZImurRAphCo9QghRBIiWU6dOuRkzZpjggfPPPz9P8AAp01R2EDxQqVIl169fP7d69WpLmxZCpA4SPUIIUQQffviha968uSVLv/7667ZC4/jx4/m+Zu/eva5OnTr5/q5u3bpW8Tl06JCurRAphIzMQghRBPhyMDHTqkLI0O7C47Nw4ULXs2dP+5rff//dXXrppfn+f5dddlne54QQqYNEjxBCFAGtrO3bt9tOsEaNGtnfTZ8+3WVnZ7s77rjDXXLJJe6CCy6wvWKFbZfnc0KI1EHtLSGEKILrr7/eVatWLU/wAGLn9OnTbt++ffZxzZo13eHDh/P9//i4QoUKrkaNGrq2QqQQEj1CCFEEd955pzt27Fi+8XM8PJiaq1evbh936dLFvD9Hjx7N+5oVK1bYRFflypV1bYVIITSyLoQQxdCtWzf3zTffuKysLPfbb7+5uXPnWhYPE13w77//msA5ceKE69u3r3l+1q5da0KoYcOGurZCpBASPUIIUQxMblG5IZH54osvdh06dLBHLH/99ZfLyclxu3fvdlWqVHGZmZnW9hJCpBYSPUIIIYSIBPL0CCGEECISSPQIIYQQIhJI9AghhBAiEkj0CCGEECISSPQIIYQQIhJI9AghhBAiEkj0CCGEECISSPQIIYQQIhJI9AghhBAiEkj0CCGEECISSPQIIYQQIhJI9AghhBAiEkj0CCGEECISSPQIIYQQwkWB/wJjTsiwpZujigAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "view_plddt = csp.map_structure(df_feat=df_feat, pdb=pdb, tmd_len=10, start=1,\n", + " mode='plddt', focus='whole', backend='mpl')\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "76b75a95", + "metadata": {}, + "source": [ + "## Interactive backend, HTML export, and AlphaFold auto-fetch\n", + "\n", + "With `backend=None` (the default) py3Dmol is used when available, otherwise matplotlib. The interactive view exports a self-contained page with `write_html(path)`; the static backend writes a PNG with `savefig(path)`. To fetch the structure straight from AlphaFold DB, pass `uniprot=` instead of `pdb=`:\n", + "\n", + "```python\n", + "view = csp.map_structure(df_feat=df_feat, uniprot='Q9NQ76', tmd_len=10, start=312)\n", + "view.write_html('adamts7.html') # interactive, shareable\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "7ca52ac0", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-26T03:04:31.443489Z", + "iopub.status.busy": "2026-06-26T03:04:31.443425Z", + "iopub.status.idle": "2026-06-26T03:04:31.457494Z", + "shell.execute_reply": "2026-06-26T03:04:31.457319Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "backend: py3dmol | wrote view.html ( 9954 bytes )\n" + ] + } + ], + "source": [ + "html_path = os.path.join(tmp, 'view.html')\n", + "view_auto = csp.map_structure(df_feat=df_feat, pdb=pdb, tmd_len=10, backend=None)\n", + "view_auto.write_html(html_path)\n", + "print('backend:', view_auto.backend, '| wrote', os.path.basename(html_path),\n", + " '(', os.path.getsize(html_path), 'bytes )')" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.13.11" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/pyproject.toml b/pyproject.toml index 4747fe3c..432ccba6 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -80,6 +80,10 @@ pro = [ # StructurePreprocessor.get_domains(tool='afragmenter'); ~10 MB of new # transitive deps (python-igraph + rich), no DL framework. "afragmenter>=0.0.6", + # py3Dmol (Python binding to 3Dmol.js): interactive in-notebook 3D viewer and + # self-contained HTML export for CPPStructurePlot.map_structure. Pure-Python, + # no DL framework; lazy-imported so the matplotlib fallback works without it. + "py3Dmol>=2.0", ] embed = [ # Protein-language-model embedding compute path for diff --git a/tests/unit/api_tests/test_backend_import_hygiene.py b/tests/unit/api_tests/test_backend_import_hygiene.py index e792bcea..b67f6432 100644 --- a/tests/unit/api_tests/test_backend_import_hygiene.py +++ b/tests/unit/api_tests/test_backend_import_hygiene.py @@ -33,6 +33,9 @@ "protein_design_pro": { "seqopt": {"_seqopt"}, }, + "feature_engineering_pro": { + "cpp_struct": {"_cpp_structure_plot"}, + }, } diff --git a/tests/unit/api_tests/test_class_abbreviation_registry.py b/tests/unit/api_tests/test_class_abbreviation_registry.py index ff8e4b50..1ac0f087 100644 --- a/tests/unit/api_tests/test_class_abbreviation_registry.py +++ b/tests/unit/api_tests/test_class_abbreviation_registry.py @@ -39,6 +39,7 @@ "CPP": "cpp", "CPPGrid": "cppg", "CPPPlot": "cpp_plot", + "CPPStructurePlot": "csp", "dPULearn": "dpul", "dPULearnPlot": "dpul_plot", "AAMut": "aamut", diff --git a/tests/unit/cpp_structure_plot_tests/test_cpp_structure_plot_map_structure.py b/tests/unit/cpp_structure_plot_tests/test_cpp_structure_plot_map_structure.py new file mode 100644 index 00000000..c8f0b8c0 --- /dev/null +++ b/tests/unit/cpp_structure_plot_tests/test_cpp_structure_plot_map_structure.py @@ -0,0 +1,429 @@ +"""This is a script to test CPPStructurePlot.map_structure().""" +import matplotlib +matplotlib.use("Agg") +import os +import tempfile +import numpy as np +import pandas as pd +import pytest +from hypothesis import given, settings +import hypothesis.strategies as some + +# Pro-gated: structure parsing needs biopython. Skip the whole module cleanly +# when the pro extra is not installed. +pytest.importorskip("Bio") + +import aaanalysis as aa +import aaanalysis.utils as ut + +settings.register_profile("ci", deadline=None) +settings.load_profile("ci") + +HAS_PY3DMOL = True +try: + import py3Dmol # noqa: F401 +except ImportError: + HAS_PY3DMOL = False + + +# --- fixtures / helpers ------------------------------------------------------ +def _make_pdb(path, n=40, start_resi=1, chain="A"): + """Write a tiny synthetic PDB: one CA per residue, B-factor used as pLDDT.""" + lines = [] + serial = 1 + for i in range(n): + resi = start_resi + i + x, y, z = i * 1.5, np.sin(i * 0.5) * 5, np.cos(i * 0.5) * 5 + b = 40 + (i % 60) # pLDDT-ish 40..99 + lines.append( + f"ATOM {serial:5d} CA ALA {chain}{resi:4d} " + f"{x:8.3f}{y:8.3f}{z:8.3f} 1.00{b:6.2f} C") + serial += 1 + lines.append("END") + path.write_text("\n".join(lines) + "\n", encoding="utf-8") + return str(path) + + +@pytest.fixture(scope="module") +def pdb_path(tmp_path_factory): + p = tmp_path_factory.mktemp("struct") / "synthetic.pdb" + return _make_pdb(p) + + +def _df_feat(tmd_impact=0.8, jmd_impact=-0.4, col_imp="feat_impact"): + """Two known features: a whole-TMD segment and a whole-JMD-N segment.""" + return pd.DataFrame({ + ut.COL_FEATURE: ["TMD-Segment(1,1)-ABC", "JMD_N-Segment(1,1)-XYZ"], + ut.COL_CAT: ["Polarity", "Energy"], + col_imp: [tmd_impact, jmd_impact], + }) + + +# --- normal cases, one parameter per test ------------------------------------ +class TestMapStructure: + """Normal cases — one parameter per test.""" + + def test_returns_structure_view(self, pdb_path): + csp = aa.CPPStructurePlot(verbose=False) + view = csp.map_structure(df_feat=_df_feat(), pdb=pdb_path, tmd_len=10, backend="mpl") + assert view.backend == "mpl" + assert hasattr(view, "show") and hasattr(view, "write_html") + + def test_df_feat_positive(self, pdb_path): + csp = aa.CPPStructurePlot(verbose=False) + view = csp.map_structure(df_feat=_df_feat(), pdb=pdb_path, tmd_len=10, backend="mpl") + assert isinstance(view.dict_impact, dict) and len(view.dict_impact) > 0 + + @pytest.mark.parametrize("mode", ["impact", "plddt"]) + def test_mode_positive(self, pdb_path, mode): + csp = aa.CPPStructurePlot(verbose=False) + view = csp.map_structure(df_feat=_df_feat(), pdb=pdb_path, tmd_len=10, + mode=mode, backend="mpl") + assert view.mode == mode + + @pytest.mark.parametrize("focus", ["whole", "fade", "zoom"]) + def test_focus_positive(self, pdb_path, focus): + csp = aa.CPPStructurePlot(verbose=False) + view = csp.map_structure(df_feat=_df_feat(), pdb=pdb_path, tmd_len=10, + focus=focus, backend="mpl") + assert view.backend == "mpl" + + def test_backend_mpl_positive(self, pdb_path): + csp = aa.CPPStructurePlot(verbose=False) + view = csp.map_structure(df_feat=_df_feat(), pdb=pdb_path, tmd_len=10, backend="mpl") + assert view.backend == "mpl" + + @pytest.mark.skipif(not HAS_PY3DMOL, reason="py3Dmol not installed") + def test_backend_py3dmol_positive(self, pdb_path): + csp = aa.CPPStructurePlot(verbose=False) + view = csp.map_structure(df_feat=_df_feat(), pdb=pdb_path, tmd_len=10, backend="py3dmol") + assert view.backend == "py3dmol" + + def test_backend_none_autoselects(self, pdb_path): + csp = aa.CPPStructurePlot(verbose=False) + view = csp.map_structure(df_feat=_df_feat(), pdb=pdb_path, tmd_len=10, backend=None) + assert view.backend in ("py3dmol", "mpl") + + def test_col_imp_positive(self, pdb_path): + csp = aa.CPPStructurePlot(verbose=False) + df = _df_feat(col_imp="feat_impact_P05067") + view = csp.map_structure(df_feat=df, pdb=pdb_path, tmd_len=10, + col_imp="feat_impact_P05067", backend="mpl") + assert view.max_abs > 0 + + @settings(max_examples=5, deadline=None) + @given(tmd_len=some.integers(min_value=1, max_value=20)) + def test_tmd_len_positive(self, pdb_path, tmd_len): + csp = aa.CPPStructurePlot(verbose=False) + view = csp.map_structure(df_feat=_df_feat(), pdb=pdb_path, tmd_len=tmd_len, backend="mpl") + assert view.backend == "mpl" + + @settings(max_examples=5, deadline=None) + @given(start=some.integers(min_value=1, max_value=15)) + def test_start_positive(self, pdb_path, start): + csp = aa.CPPStructurePlot(verbose=False) + view = csp.map_structure(df_feat=_df_feat(), pdb=pdb_path, tmd_len=10, + start=start, backend="mpl") + # The smallest mapped residue equals start (first JMD-N residue). + assert min(view.dict_impact) == start + + @pytest.mark.parametrize("size_by_impact", [True, False]) + def test_size_by_impact_positive(self, pdb_path, size_by_impact): + csp = aa.CPPStructurePlot(verbose=False) + view = csp.map_structure(df_feat=_df_feat(), pdb=pdb_path, tmd_len=10, + size_by_impact=size_by_impact, backend="mpl") + assert view.backend == "mpl" + + def test_chain_positive(self, pdb_path): + csp = aa.CPPStructurePlot(verbose=False) + view = csp.map_structure(df_feat=_df_feat(), pdb=pdb_path, tmd_len=10, + chain="A", backend="mpl") + assert view.backend == "mpl" + + def test_sequence_positive(self, pdb_path): + csp = aa.CPPStructurePlot(verbose=False) + view = csp.map_structure(df_feat=_df_feat(), pdb=pdb_path, tmd_len=10, + sequence="A" * 40, backend="mpl") + assert view.backend == "mpl" + + def test_focus_region_tuple_positive(self, pdb_path): + csp = aa.CPPStructurePlot(verbose=False) + view = csp.map_structure(df_feat=_df_feat(), pdb=pdb_path, tmd_len=10, + focus="zoom", focus_region=(11, 20), backend="mpl") + assert view.backend == "mpl" + + def test_focus_region_list_positive(self, pdb_path): + csp = aa.CPPStructurePlot(verbose=False) + view = csp.map_structure(df_feat=_df_feat(), pdb=pdb_path, tmd_len=10, + focus="fade", focus_region=[(1, 10), (11, 20)], backend="mpl") + assert view.backend == "mpl" + + # --- negatives ----------------------------------------------------------- + @pytest.mark.parametrize("mode", ["Impact", "shap", "", "color"]) + def test_mode_negative(self, pdb_path, mode): + csp = aa.CPPStructurePlot(verbose=False) + with pytest.raises(ValueError): + csp.map_structure(df_feat=_df_feat(), pdb=pdb_path, tmd_len=10, mode=mode) + + @pytest.mark.parametrize("focus", ["all", "Fade", "near", ""]) + def test_focus_negative(self, pdb_path, focus): + csp = aa.CPPStructurePlot(verbose=False) + with pytest.raises(ValueError): + csp.map_structure(df_feat=_df_feat(), pdb=pdb_path, tmd_len=10, focus=focus) + + @pytest.mark.parametrize("backend", ["py3DMOL", "matplotlib", "ngl", ""]) + def test_backend_negative(self, pdb_path, backend): + csp = aa.CPPStructurePlot(verbose=False) + with pytest.raises(ValueError): + csp.map_structure(df_feat=_df_feat(), pdb=pdb_path, tmd_len=10, backend=backend) + + @pytest.mark.parametrize("tmd_len", [0, -1, -5]) + def test_tmd_len_negative(self, pdb_path, tmd_len): + csp = aa.CPPStructurePlot(verbose=False) + with pytest.raises(ValueError): + csp.map_structure(df_feat=_df_feat(), pdb=pdb_path, tmd_len=tmd_len) + + @pytest.mark.parametrize("start", [-1, -10]) + def test_start_negative(self, pdb_path, start): + csp = aa.CPPStructurePlot(verbose=False) + with pytest.raises(ValueError): + csp.map_structure(df_feat=_df_feat(), pdb=pdb_path, tmd_len=10, start=start) + + def test_df_feat_missing_col_imp_negative(self, pdb_path): + csp = aa.CPPStructurePlot(verbose=False) + df = _df_feat().drop(columns=["feat_impact"]) + with pytest.raises(ValueError): + csp.map_structure(df_feat=df, pdb=pdb_path, tmd_len=10) + + def test_pdb_and_uniprot_both_negative(self, pdb_path): + csp = aa.CPPStructurePlot(verbose=False) + with pytest.raises(ValueError): + csp.map_structure(df_feat=_df_feat(), pdb=pdb_path, uniprot="P05067", tmd_len=10) + + def test_pdb_and_uniprot_neither_negative(self): + csp = aa.CPPStructurePlot(verbose=False) + with pytest.raises(ValueError): + csp.map_structure(df_feat=_df_feat(), tmd_len=10) + + @pytest.mark.parametrize("focus_region", [(20, 11), (5, 1)]) + def test_focus_region_negative(self, pdb_path, focus_region): + csp = aa.CPPStructurePlot(verbose=False) + with pytest.raises(ValueError): + csp.map_structure(df_feat=_df_feat(), pdb=pdb_path, tmd_len=10, + focus="zoom", focus_region=focus_region) + + def test_chain_unknown_negative(self, pdb_path): + csp = aa.CPPStructurePlot(verbose=False) + with pytest.raises(ValueError): + csp.map_structure(df_feat=_df_feat(), pdb=pdb_path, tmd_len=10, chain="Z") + + +# --- combinations & edge interactions ---------------------------------------- +class TestMapStructureComplex: + """Combinations and edge interactions.""" + + def test_plddt_zoom_focus_region(self, pdb_path): + csp = aa.CPPStructurePlot(verbose=False) + view = csp.map_structure(df_feat=_df_feat(), pdb=pdb_path, tmd_len=10, + mode="plddt", focus="zoom", focus_region=(11, 20), + backend="mpl") + assert view.mode == "plddt" + + def test_impact_fade_size_by_impact(self, pdb_path): + csp = aa.CPPStructurePlot(verbose=False) + view = csp.map_structure(df_feat=_df_feat(), pdb=pdb_path, tmd_len=10, + mode="impact", focus="fade", size_by_impact=True, + backend="mpl") + assert view.backend == "mpl" + + def test_jmd_lengths_shift_window(self, pdb_path): + csp = aa.CPPStructurePlot(jmd_n_len=5, jmd_c_len=5, verbose=False) + view = csp.map_structure(df_feat=_df_feat(), pdb=pdb_path, tmd_len=10, + start=1, backend="mpl") + # JMD_N now spans residues 1..5; TMD spans 6..15. + assert view.dict_impact.get(6, 0) != 0 # first TMD residue carries impact + + @settings(max_examples=5, deadline=None) + @given(start=some.integers(min_value=100, max_value=300)) + def test_start_offsets_into_structure(self, pdb_path, start): + csp = aa.CPPStructurePlot(verbose=False) + # start far outside the 1..40 structure -> warns, still returns a view. + with pytest.warns(UserWarning): + view = csp.map_structure(df_feat=_df_feat(), pdb=pdb_path, tmd_len=10, + start=start, backend="mpl") + assert view.backend == "mpl" + + def test_savefig_writes_png(self, pdb_path, tmp_path): + csp = aa.CPPStructurePlot(verbose=False) + view = csp.map_structure(df_feat=_df_feat(), pdb=pdb_path, tmd_len=10, backend="mpl") + out = tmp_path / "v.png" + view.savefig(str(out)) + assert out.exists() and out.stat().st_size > 0 + + def test_write_html_mpl_embeds_png(self, pdb_path, tmp_path): + csp = aa.CPPStructurePlot(verbose=False) + view = csp.map_structure(df_feat=_df_feat(), pdb=pdb_path, tmd_len=10, backend="mpl") + out = tmp_path / "v.html" + view.write_html(str(out)) + assert "base64" in out.read_text(encoding="utf-8") + + def test_savefig_on_py3dmol_raises(self, pdb_path, tmp_path): + if not HAS_PY3DMOL: + pytest.skip("py3Dmol not installed") + csp = aa.CPPStructurePlot(verbose=False) + view = csp.map_structure(df_feat=_df_feat(), pdb=pdb_path, tmd_len=10, backend="py3dmol") + with pytest.raises(RuntimeError): + view.savefig(str(tmp_path / "x.png")) + + def test_single_feature_df(self, pdb_path): + csp = aa.CPPStructurePlot(verbose=False) + df = pd.DataFrame({ut.COL_FEATURE: ["TMD-Segment(1,1)-ABC"], + ut.COL_CAT: ["Polarity"], "feat_impact": [1.0]}) + view = csp.map_structure(df_feat=df, pdb=pdb_path, tmd_len=10, backend="mpl") + assert view.max_abs > 0 + + +# --- golden values (hand-computed normalized perpos) ------------------------- +class TestMapStructureGoldenValues: + """Hand-computed per-residue impact == normalized-sum mapping.""" + + def test_whole_tmd_segment_normalized(self, pdb_path): + # TMD Segment(1,1) spans the whole 10-residue TMD (residues 11..20 with + # start=1, jmd_n_len=10). Impact 0.8 spread over 10 positions -> 0.08 each. + csp = aa.CPPStructurePlot(jmd_n_len=10, jmd_c_len=10, verbose=False) + view = csp.map_structure(df_feat=_df_feat(tmd_impact=0.8, jmd_impact=0.0), + pdb=pdb_path, tmd_len=10, start=1, backend="mpl") + for resi in range(11, 21): + assert view.dict_impact[resi] == pytest.approx(0.08) + + def test_whole_jmd_segment_normalized(self, pdb_path): + # JMD_N Segment(1,1) spans residues 1..10; impact -0.4 / 10 -> -0.04 each. + csp = aa.CPPStructurePlot(jmd_n_len=10, jmd_c_len=10, verbose=False) + view = csp.map_structure(df_feat=_df_feat(tmd_impact=0.0, jmd_impact=-0.4), + pdb=pdb_path, tmd_len=10, start=1, backend="mpl") + for resi in range(1, 11): + assert view.dict_impact[resi] == pytest.approx(-0.04) + + def test_max_abs_is_max_per_residue(self, pdb_path): + csp = aa.CPPStructurePlot(jmd_n_len=10, jmd_c_len=10, verbose=False) + view = csp.map_structure(df_feat=_df_feat(tmd_impact=0.8, jmd_impact=-0.4), + pdb=pdb_path, tmd_len=10, start=1, backend="mpl") + assert view.max_abs == pytest.approx(0.08) + + def test_start_shifts_absolute_residues(self, pdb_path): + # start=312 -> JMD_N spans 312..321, TMD spans 322..331. + csp = aa.CPPStructurePlot(jmd_n_len=10, jmd_c_len=10, verbose=False) + with pytest.warns(UserWarning): # window outside the 1..40 synthetic structure + view = csp.map_structure(df_feat=_df_feat(tmd_impact=0.8, jmd_impact=0.0), + pdb=pdb_path, tmd_len=10, start=312, backend="mpl") + assert view.dict_impact[322] == pytest.approx(0.08) + assert min(view.dict_impact) == 312 + + +# --- constructor ------------------------------------------------------------- +class TestCPPStructurePlotInit: + """Constructor parameter checks.""" + + @settings(max_examples=5, deadline=None) + @given(jmd_n_len=some.integers(min_value=0, max_value=20)) + def test_jmd_n_len_positive(self, jmd_n_len): + csp = aa.CPPStructurePlot(jmd_n_len=jmd_n_len, verbose=False) + assert csp._jmd_n_len == jmd_n_len + + @settings(max_examples=5, deadline=None) + @given(jmd_c_len=some.integers(min_value=0, max_value=20)) + def test_jmd_c_len_positive(self, jmd_c_len): + csp = aa.CPPStructurePlot(jmd_c_len=jmd_c_len, verbose=False) + assert csp._jmd_c_len == jmd_c_len + + def test_df_scales_positive(self): + df_scales = aa.load_scales() + csp = aa.CPPStructurePlot(df_scales=df_scales, verbose=False) + assert csp._df_scales is not None + + @pytest.mark.parametrize("verbose", [True, False]) + def test_verbose_positive(self, verbose): + csp = aa.CPPStructurePlot(verbose=verbose) + assert csp._verbose == verbose + + @pytest.mark.parametrize("jmd_n_len", [-1, -5]) + def test_jmd_n_len_negative(self, jmd_n_len): + with pytest.raises(ValueError): + aa.CPPStructurePlot(jmd_n_len=jmd_n_len) + + @pytest.mark.parametrize("jmd_c_len", [-1, -5]) + def test_jmd_c_len_negative(self, jmd_c_len): + with pytest.raises(ValueError): + aa.CPPStructurePlot(jmd_c_len=jmd_c_len) + + +def _make_multichain_pdb(path, chains=("A", "B"), n=12): + """Two chains sharing residue numbers 1..n (different coords) to test chain leak.""" + lines = [] + serial = 1 + for ci, ch in enumerate(chains): + for i in range(n): + resi = i + 1 + x, y, z = i * 1.5 + ci * 100, ci * 50.0, 0.0 + b = 50 + i + lines.append( + f"ATOM {serial:5d} CA ALA {ch}{resi:4d} " + f"{x:8.3f}{y:8.3f}{z:8.3f} 1.00{b:6.2f} C") + serial += 1 + lines.append("END") + path.write_text("\n".join(lines) + "\n", encoding="utf-8") + return str(path) + + +class TestMapStructureChainHandling: + """Multi-chain selection, identity warning, and zoom robustness (review fixes).""" + + def test_extract_returns_selected_chain_id(self, tmp_path): + from aaanalysis.feature_engineering_pro._backend.cpp_struct.structure import ( + load_structure, extract_chain_residues) + pdb = _make_multichain_pdb(tmp_path / "multi.pdb") + structure = load_structure(pdb) + records, identity, chain_id = extract_chain_residues(structure, chain="B") + assert chain_id == "B" + # All records belong to chain B (its x-coords are offset by +100). + assert all(r["coord"][0] >= 100 for r in records) + + def test_multichain_render_uses_chain_qualifier(self, tmp_path): + # Regression: residue selections must be chain-qualified so chain B's + # residues are not painted onto chain A's same-numbered residues. + csp = aa.CPPStructurePlot(verbose=False) + pdb = _make_multichain_pdb(tmp_path / "multi.pdb") + if not HAS_PY3DMOL: + pytest.skip("py3Dmol not installed") + view = csp.map_structure(df_feat=_df_feat(), pdb=pdb, tmd_len=2, start=1, + chain="B", backend="py3dmol") + assert view.backend == "py3dmol" + + def test_explicit_chain_sequence_mismatch_warns(self, pdb_path): + # Explicit chain + a non-matching sequence should still warn (identity < 0.5). + csp = aa.CPPStructurePlot(verbose=False) + with pytest.warns(UserWarning): + csp.map_structure(df_feat=_df_feat(), pdb=pdb_path, tmd_len=10, + chain="A", sequence="W" * 40, backend="mpl") + + def test_zoom_region_outside_structure_no_error(self, pdb_path): + # zoomTo on residues absent from the structure must not raise. + csp = aa.CPPStructurePlot(verbose=False) + view = csp.map_structure(df_feat=_df_feat(), pdb=pdb_path, tmd_len=10, + focus="zoom", focus_region=(900, 950), backend="mpl") + assert view.backend == "mpl" + + +def test_impact_color_matches_package_shap_ramp(): + # The impact ramp reuses the package SHAP palette (white -> SHAP_POS / NEG). + from aaanalysis.feature_engineering_pro._backend.cpp_struct.colors import impact_to_hex + import matplotlib.colors as mcolors + pos = mcolors.to_hex(impact_to_hex(1.0, 1.0)) + neg = mcolors.to_hex(impact_to_hex(-1.0, 1.0)) + assert pos.lower() == ut.COLOR_SHAP_POS.lower() + assert neg.lower() == ut.COLOR_SHAP_NEG.lower() + assert impact_to_hex(0.0, 1.0) == "#FFFFFF" + + +def test_cpp_structure_plot_in_public_api(): + assert "CPPStructurePlot" in aa.__all__