diff --git a/QPIXL/qiskit/README(new).md b/QPIXL/qiskit/README(new).md
new file mode 100644
index 0000000..7318ee4
--- /dev/null
+++ b/QPIXL/qiskit/README(new).md
@@ -0,0 +1,40 @@
+### `qpixl_module.py`
+- Wraps an image or data source into a reusable quantum circuit using the QPIXL (cFRQI) encoding scheme.
+- Supports compression, optional gate injection, and validation.
+### `quantum_composer.py`
+
+A flexible system to combine multiple quantum circuits using integration rules.
+
+#### Key Features:
+
+* Combines modules using rules like:
+    * `sequential`: stack circuits in time
+    * `merge`: align circuits side-by-side with optional entanglement
+    * `hardware_aware_sequential`: transpile for specific coupling maps
+* Built-in circuit safety (no duplicate bits)
+* Modular `CircuitModule` interface for Qiskit circuits or QPIXL modules
+
+#### Example:
+
+```python
+composer = QuantumComposer([qpixl_mod, algo_mod])
+combined = composer.combine(rule="merge", connection_map={0: 5}, entangle_type="cx")
+``````
+### `QPIXL_demo_composer_extension.ipynb`
+
+A complete test notebook demonstrating how to use the new modules.```
+
+#### Covers:
+
+* Basic image encoding + algorithm circuit
+* Audio signal → QPIXL circuit integration
+* Injecting gates during encoding
+* Hardware-aware transpilation with `transpile()`
+* Entanglement across subsystems
+* Compression vs uncompressed QPIXL comparison
+* `process_audio` helper 
+    * You can define this in the notebook to convert `.mp3` audio signals into QPIXL-compatible angle arrays and circuits.
+    * **Steps:**
+        * Downsample audio → normalize → map to `[0, π]` rotation angles
+        * Use `cFRQI()` to create circuit
+        * Supports direct integration into `QPIXLModule`
diff --git a/QPIXL/qiskit/qpixl_module.py b/QPIXL/qiskit/qpixl_module.py
new file mode 100644
index 0000000..db814cf
--- /dev/null
+++ b/QPIXL/qiskit/qpixl_module.py
@@ -0,0 +1,126 @@
+import numpy as np
+from qiskit import QuantumCircuit, transpile
+from enum import Enum
+from QPIXL.qiskit.qpixl import cFRQI
+
+
+class InjectionPoint(Enum):
+    BEFORE_ENCODING = "before"
+    DURING_ENCODING = "during"
+    AFTER_ENCODING = "after"
+
+
+class QPIXLModule:
+    def __init__(self, image_array, compression=0, name="QPIXLModule", algorithm_qubits=0):
+        if not isinstance(image_array, np.ndarray):
+            raise TypeError("Expected NumPy array")
+        if image_array.ndim != 1:
+            raise ValueError("Expected a 1D flattened array")
+        if not (0 <= compression <= 100):
+            raise ValueError("Compression must be in [0, 100]")
+
+        self.image_array = image_array
+        self.compression = compression
+        self._name = name
+        self._algo_qubits = algorithm_qubits
+        self._injections = []
+
+    @property
+    def name(self):
+        return self._name
+
+    def add_injection(self, when, gate_type, qubits, params=None, condition=None):
+        """Injects a standard gate like ry, cx, crx, unitary, etc."""
+        self._injections.append({
+            "when": InjectionPoint(when),
+            "gate": gate_type.lower(),
+            "qubits": qubits,
+            "params": params or {},
+            "cond": condition
+        })
+        return self
+
+    def add_custom_injection(self, func, when):
+        """Injects a custom callable. Signature: func(circuit, idx, angle)"""
+        self._injections.append({
+            "when": InjectionPoint(when),
+            "custom": func
+        })
+        return self
+
+    def get_circuit(self, optimize=False, verbose=False):
+        # Total qubits = log2(image) + encoding qubit + optional algorithm qubits
+        total_qubits = int(np.log2(len(self.image_array))) + 2 + self._algo_qubits
+        circuit = QuantumCircuit(total_qubits, name=self._name)
+
+        # Inject before encoding
+        self._apply_injections(circuit, InjectionPoint.BEFORE_ENCODING, total_qubits)
+
+        # Encode angles with QPIXL (gets a new circuit)
+        base = cFRQI(self.image_array, self.compression)
+
+        # Strip ghost registers and names
+        base.name = None
+        base.qregs = []
+        base.cregs = []
+
+        # Inject during encoding (per angle)
+        for i, angle in enumerate(self.image_array):
+            for inj in self._injections:
+                if inj.get("when") != InjectionPoint.DURING_ENCODING:
+                    continue
+                if "custom" in inj:
+                    inj["custom"](circuit, i, angle)
+                else:
+                    q = self._resolve_qubits(inj["qubits"], total_qubits)
+                    if not inj.get("cond") or inj["cond"](i, angle):
+                        self._apply_gate(circuit, inj["gate"], q, inj["params"])
+
+        # Compose base into the correct qubit range (avoid mismatch)
+        base_qubit_count = base.num_qubits
+        circuit.compose(base, qubits=range(base_qubit_count), inplace=True)
+
+        # Inject after encoding
+        self._apply_injections(circuit, InjectionPoint.AFTER_ENCODING, total_qubits)
+
+        if optimize:
+            circuit = transpile(circuit, optimization_level=3)
+
+        if verbose:
+            print(f"[QPIXL] qubits={circuit.num_qubits}, depth={circuit.depth()}, compression={self.compression}")
+
+        return circuit.copy()
+
+    def _apply_injections(self, circuit, when, total_qubits):
+        for inj in self._injections:
+            if inj.get("when") != when:
+                continue
+            if "custom" in inj:
+                inj["custom"](circuit, None, None)
+            else:
+                q = self._resolve_qubits(inj["qubits"], total_qubits)
+                if not inj.get("cond") or inj["cond"](None, None):
+                    self._apply_gate(circuit, inj["gate"], q, inj["params"])
+
+    def _resolve_qubits(self, qubit_ids, total):
+        return [q if q >= 0 else total + q for q in qubit_ids]
+
+    def _apply_gate(self, circuit, gate, qubits, params):
+        theta = params.get("angle", 0)
+        if gate == "ry":
+            circuit.ry(theta, qubits[0])
+        elif gate == "cry":
+            circuit.cry(theta, *qubits)
+        elif gate == "crx":
+            circuit.crx(theta, *qubits)
+        elif gate == "cz":
+            circuit.cz(*qubits)
+        elif gate == "cx":
+            circuit.cx(*qubits)
+        elif gate == "swap":
+            circuit.swap(*qubits)
+        elif gate == "unitary":
+            circuit.unitary(params["matrix"], qubits, label="U")
+        else:
+            raise ValueError(f"Unsupported gate: {gate}")
+
diff --git a/QPIXL/qiskit/quantum_composer.py b/QPIXL/qiskit/quantum_composer.py
new file mode 100644
index 0000000..7edb78f
--- /dev/null
+++ b/QPIXL/qiskit/quantum_composer.py
@@ -0,0 +1,336 @@
+# quantum_composer.py
+
+import qiskit
+from qiskit import QuantumCircuit
+from qiskit.circuit import ControlFlowOp
+from typing import List, Dict, Optional, Union, Sequence, Any, Callable
+import warnings
+import time
+from abc import ABC, abstractmethod
+from itertools import zip_longest
+import numpy as np  # For create_sliced_circuit
+
+# ----- Base Module -----
+class CircuitModule(ABC):
+    @abstractmethod
+    def get_circuit(self) -> QuantumCircuit:
+        pass
+
+    @property
+    @abstractmethod
+    def name(self) -> str:
+        pass
+
+    def get_qubit_roles(self) -> Dict[str, List[qiskit.circuit.Qubit]]:
+        return {}
+
+    def get_parameters(self) -> Dict[str, Any]:
+        return {}
+
+class QiskitCircuitModule(CircuitModule):
+    def __init__(self, circuit: QuantumCircuit, name: Optional[str] = None):
+        if not isinstance(circuit, QuantumCircuit):
+            raise TypeError("Expected a Qiskit QuantumCircuit")
+        self._circuit = circuit.copy()
+        self._name = name or circuit.name or "UnnamedCircuit"
+
+    def get_circuit(self) -> QuantumCircuit:
+        return self._circuit
+
+    @property
+    def name(self) -> str:
+        return self._name
+
+    def get_qubit_roles(self) -> Dict[str, List[qiskit.circuit.Qubit]]:
+        roles = {}
+        for q in self._circuit.qubits:
+            regs = self._circuit.find_bit(q).registers
+            name = regs[0][0].name if regs else "ungrouped_qubits"
+            roles.setdefault(name, []).append(q)
+        for c in self._circuit.clbits:
+            regs = self._circuit.find_bit(c).registers
+            name = regs[0][0].name + "_classical" if regs else "ungrouped_clbits"
+            roles.setdefault(name, []).append(c)
+        return roles
+
+# ----- Main Composer -----
+CombinationRule = Callable[[Dict[str, Any]], Union[QuantumCircuit, Any]]
+
+class QuantumComposer:
+    def __init__(self, modules: Sequence[CircuitModule]):
+        if not modules:
+            raise ValueError("No modules provided")
+        self.modules = list(modules)
+        self._rules: Dict[str, CombinationRule] = {}
+        self._register_rules()
+
+    def _register_rules(self):
+        self.register_rule("sequential", self._combine_sequential)
+        self.register_rule("merge", self._combine_merge)
+        self.register_rule("hardware_aware_sequential", self._combine_hw_aware)
+        self.register_rule("slice", self._combine_slice)
+
+    def register_rule(self, name: str, func: CombinationRule):
+        if not name or not callable(func):
+            raise ValueError("Invalid rule")
+        if name in self._rules:
+            warnings.warn(f"Overwriting rule: {name}")
+        self._rules[name] = func
+
+    def list_rules(self) -> List[str]:
+        return list(self._rules.keys())
+
+    def combine(self, rule: str = "sequential", **kwargs) -> Union[QuantumCircuit, Any]:
+        if rule not in self._rules:
+            raise ValueError(f"Unknown rule '{rule}'. Available: {self.list_rules()}")
+        print(f"▶ Combining using rule: {rule}")
+        start = time.time()
+        out = self._rules[rule](kwargs)
+        print(f"✓ Done in {time.time() - start:.2f}s")
+        return out
+
+    # --- RULE: sequential ---
+    def _combine_sequential(self, _: Dict[str, Any]) -> QuantumCircuit:
+        if not self.modules:
+            return QuantumCircuit()
+        qubits, clbits = [], []
+        qset, cset = set(), set()
+        for m in self.modules:
+            qc = m.get_circuit()
+            print(f"  ↪ {m.name}")
+            for q in qc.qubits:
+                if q not in qset:
+                    qubits.append(q)
+                    qset.add(q)
+            for c in qc.clbits:
+                if c not in cset:
+                    clbits.append(c)
+                    cset.add(c)
+        combined = QuantumCircuit(qubits, clbits,
+                                  name="_then_".join(m.name for m in self.modules))
+        for m in self.modules:
+            qc = m.get_circuit()
+            qmap = {q: q for q in qc.qubits}
+            cmap = {c: c for c in qc.clbits}
+            for inst in qc.data:
+                combined.append(inst.operation,
+                                [qmap[q] for q in inst.qubits],
+                                [cmap[c] for c in inst.clbits])
+        return combined
+
+    # --- RULE: merge ---
+    def _combine_merge(self, kwargs: Dict[str, Any]) -> QuantumCircuit:
+        if len(self.modules) < 2:
+            raise ValueError("Merge needs ≥2 modules")
+        connection_map = kwargs.get("connection_map", {})
+        etype = kwargs.get("entangle_type", "cx")
+        combined = self._combine_sequential({})
+        for src, tgt in connection_map.items():
+            q_src = combined.qubits[src]
+            q_tgt = combined.qubits[tgt]
+            if q_src is q_tgt: continue
+            if etype == "cx":
+                combined.cx(q_src, q_tgt)
+            elif etype == "cz":
+                combined.cz(q_src, q_tgt)
+            elif etype == "swap":
+                combined.swap(q_src, q_tgt)
+            else:
+                raise ValueError(f"Unsupported entangle_type: {etype}")
+        return combined
+
+    # --- RULE: hardware_aware_sequential ---
+    def _combine_hw_aware(self, kwargs: Dict[str, Any]) -> QuantumCircuit:
+        backend = kwargs.get("backend")
+        cmap = kwargs.get("coupling_map")
+        gates = kwargs.get("basis_gates")
+        opt = kwargs.get("optimization_level", 1)
+        raw = self._combine_sequential({})
+        if raw.num_qubits == 0:
+            return raw
+        return qiskit.transpile(raw,
+                                backend=backend,
+                                coupling_map=cmap,
+                                basis_gates=gates,
+                                optimization_level=opt)
+
+    # --- RULE: slice (patched) ---
+    def _combine_slice(self, kwargs: Dict[str, Any]) -> QuantumCircuit:
+        slice_size = kwargs.get("slice_size", 3)
+        connection_rule = kwargs.get("connection_rule", "cx")
+        connection_map = kwargs.get("connection_map", [(0, 0)])
+
+        if len(self.modules) != 2:
+            raise ValueError("Slice rule currently only supports exactly 2 modules")
+
+        data_mod, algo_mod = self.modules
+        data_qc = data_mod.get_circuit()
+        algo_qc = algo_mod.get_circuit()
+
+        total_qubits = data_qc.num_qubits + algo_qc.num_qubits
+        combined = QuantumCircuit(total_qubits, name=f"Sliced_{data_mod.name}__{algo_mod.name}")
+
+        def chunk_circuit(qc: QuantumCircuit):
+            chunks = []
+            for i in range(0, len(qc.data), slice_size):
+                sub = QuantumCircuit(qc.num_qubits, qc.num_clbits)
+                for inst in qc.data[i:i + slice_size]:
+                    sub.append(inst.operation, inst.qubits, inst.clbits)
+                chunks.append(sub)
+            return chunks
+
+        data_chunks = chunk_circuit(data_qc)
+        algo_chunks = chunk_circuit(algo_qc)
+
+        data_offset = 0
+        algo_offset = data_qc.num_qubits
+
+        for d_chunk, a_chunk in zip_longest(data_chunks, algo_chunks, fillvalue=None):
+            if d_chunk:
+                combined.compose(d_chunk, qubits=range(data_offset, data_offset + d_chunk.num_qubits), inplace=True)
+            if a_chunk:
+                combined.compose(a_chunk, qubits=range(algo_offset, algo_offset + a_chunk.num_qubits), inplace=True)
+
+            # 🔥 FIX: Only entangle if both chunks are present
+            if d_chunk and a_chunk:
+                for dq, aq in connection_map:
+                    global_dq = data_offset + dq
+                    global_aq = algo_offset + aq
+                    if connection_rule == "cx":
+                        combined.cx(global_dq, global_aq)
+                    elif connection_rule == "cz":
+                        combined.cz(global_dq, global_aq)
+                    elif connection_rule == "swap":
+                        combined.swap(global_dq, global_aq)
+                    else:
+                        raise ValueError(f"Unknown connection_rule: {connection_rule}")
+
+        return combined
+
+# === Helper ===
+from QPIXL.qiskit.qpixl import cFRQI
+from QPIXL.helper import (
+    preprocess_image,
+    convertToAngles,
+    grayPermutation,
+    grayCode,
+    sfwht,
+    ilog2,
+    countr_zero,
+)
+import random
+
+def create_sliced_circuit(
+    image_array: np.ndarray,
+    compression: float,
+    algorithm_circuit: QuantumCircuit,
+    slice_size: int = 3,
+    insertion_rule: Union[str, Callable[[int, float], bool]] = "interval",
+    connection_rule: Union[str, Callable[[int], str]] = "cx",
+    connection_map: dict = None,
+    name: str = "QPIXL_SlicedComposer",
+    interval: int = 4,
+    angle_threshold: float = 0.5,
+    verbose: bool = True,
+) -> QuantumCircuit:
+    """Creates an interleaved QPIXL + algorithm circuit with optional CZ/CX gates."""
+    a = convertToAngles(image_array)
+    a = preprocess_image(a)
+    n = len(a)
+    k = ilog2(n)
+    a = 2 * a
+    a = sfwht(a)
+    a = grayPermutation(a)
+
+    if compression > 0:
+        cutoff = int((compression / 100.0) * n)
+        a[np.argsort(np.abs(a))[:cutoff]] = 0
+
+    storage_qubits = k
+    encoding_qubit = 1
+    algo_qubits = algorithm_circuit.num_qubits
+    total_qubits = storage_qubits + encoding_qubit + algo_qubits
+    circuit = QuantumCircuit(total_qubits, name=name)
+
+    algo_slices = []
+    data = algorithm_circuit.data
+    for i in range(0, len(data), slice_size):
+        sub = QuantumCircuit(algo_qubits)
+        for inst in data[i:i + slice_size]:
+            sub.append(inst[0], inst[1], inst[2])
+        algo_slices.append(sub)
+
+    slice_idx = 0
+    inserted_log = []
+
+    circuit.h(range(storage_qubits))
+    ctrl, pc, i = 0, 0, 0
+
+    def should_insert(idx, angle):
+        if callable(insertion_rule):
+            return insertion_rule(idx, angle)
+        if insertion_rule == "interval":
+            return idx % interval == 0
+        if insertion_rule == "angle_threshold":
+            return abs(angle) > angle_threshold
+        return False
+
+    def pick_connection_type(idx):
+        if callable(connection_rule):
+            return connection_rule(idx)
+        if connection_rule == "random":
+            return random.choice(["cx", "cz", "swap"])
+        return connection_rule
+
+    while i < 2**k:
+        pc = 0
+        if a[i] != 0:
+            circuit.ry(a[i], storage_qubits)
+            if slice_idx < len(algo_slices) and should_insert(i, a[i]):
+                slice_circuit = algo_slices[slice_idx]
+                circuit.compose(
+                    slice_circuit,
+                    qubits=range(storage_qubits + 1, total_qubits),
+                    inplace=True
+                )
+                if connection_map:
+                    for dq, aq in connection_map.items():
+                        q1 = dq
+                        q2 = storage_qubits + 1 + aq
+                        gate = pick_connection_type(slice_idx)
+                        if gate == "cx":
+                            circuit.cx(q1, q2)
+                        elif gate == "cz":
+                            circuit.cz(q1, q2)
+                        elif gate == "swap":
+                            circuit.swap(q1, q2)
+                inserted_log.append((i, slice_idx))
+                slice_idx += 1
+
+        if i == 2**k - 1:
+            ctrl = 0
+        else:
+            ctrl = grayCode(i) ^ grayCode(i + 1)
+            ctrl = k - countr_zero(ctrl, n_bits=k + 1) - 1
+        pc ^= 2**ctrl
+        i += 1
+        while i < 2**k and a[i] == 0:
+            if i == 2**k - 1:
+                ctrl = 0
+            else:
+                ctrl = grayCode(i) ^ grayCode(i + 1)
+                ctrl = k - countr_zero(ctrl, n_bits=k + 1) - 1
+            pc ^= 2**ctrl
+            i += 1
+        for j in range(k):
+            if (pc >> j) & 1:
+                circuit.cx(j, storage_qubits)
+
+    circuit.reverse_bits()
+
+    if verbose:
+        print(f"[QPIXL] Interleaved {slice_idx} slices:")
+        for i, s in inserted_log:
+            print(f"  ↪ At index {i}: inserted slice {s}")
+
+    return circuit
diff --git a/QPIXL_demo_composer_extension_v4.ipynb b/QPIXL_demo_composer_extension_v4.ipynb
new file mode 100644
index 0000000..3c9d817
--- /dev/null
+++ b/QPIXL_demo_composer_extension_v4.ipynb
@@ -0,0 +1,1586 @@
+{
+  "nbformat": 4,
+  "nbformat_minor": 0,
+  "metadata": {
+    "colab": {
+      "provenance": []
+    },
+    "kernelspec": {
+      "name": "python3",
+      "display_name": "Python 3"
+    },
+    "language_info": {
+      "name": "python"
+    }
+  },
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "source": [
+        "### QPIXL Extension Demo Notebook\n",
+        "\n",
+        "This notebook demonstrates the integration of the following components added to the QPIXL/qiskit module:\n",
+        "- `qpixl_module.py`: A modular interface to create QPIXL-encoded circuits\n",
+        "- `quantum_composer.py`: A flexible system to combine QPIXL data and quantum circuits using composition rules\n",
+        "\n",
+        "The tests below cover various integration modes, including image/audio encoding, gate injection, algorithm composition, and hardware-aware transpilation.\n"
+      ],
+      "metadata": {
+        "id": "A6jHkBo5C7uV"
+      }
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 1,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "2FZTwE6pMFu0",
+        "outputId": "774bb96d-03a5-4b52-8104-8cf06cd3777c"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "fatal: destination path 'QuantumArtHack' already exists and is not an empty directory.\n"
+          ]
+        }
+      ],
+      "source": [
+        "!git clone https://github.com/moth-quantum/QuantumArtHack"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "%cd QuantumArtHack"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "wONUJ-UrMJKK",
+        "outputId": "7ced9f1d-7435-4fe3-ebe9-8ed6f2a74536"
+      },
+      "execution_count": 2,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "/content/QuantumArtHack\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "!pip install qiskit==2.0.0 matplotlib==3.10.1 pillow==11.1.0 ipywidgets==8.1.5 qiskit-aer==0.17.0 soundfile==0.13.1 pylatexenc==2.10 playsound3==3.2.2"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "QakLtN0yMJF-",
+        "outputId": "621ac231-6835-4efb-a380-4d88e921580e"
+      },
+      "execution_count": 3,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Requirement already satisfied: qiskit==2.0.0 in /usr/local/lib/python3.11/dist-packages (2.0.0)\n",
+            "Requirement already satisfied: matplotlib==3.10.1 in /usr/local/lib/python3.11/dist-packages (3.10.1)\n",
+            "Requirement already satisfied: pillow==11.1.0 in /usr/local/lib/python3.11/dist-packages (11.1.0)\n",
+            "Requirement already satisfied: ipywidgets==8.1.5 in /usr/local/lib/python3.11/dist-packages (8.1.5)\n",
+            "Requirement already satisfied: qiskit-aer==0.17.0 in /usr/local/lib/python3.11/dist-packages (0.17.0)\n",
+            "Requirement already satisfied: soundfile==0.13.1 in /usr/local/lib/python3.11/dist-packages (0.13.1)\n",
+            "Requirement already satisfied: pylatexenc==2.10 in /usr/local/lib/python3.11/dist-packages (2.10)\n",
+            "Requirement already satisfied: playsound3==3.2.2 in /usr/local/lib/python3.11/dist-packages (3.2.2)\n",
+            "Requirement already satisfied: rustworkx>=0.15.0 in /usr/local/lib/python3.11/dist-packages (from qiskit==2.0.0) (0.16.0)\n",
+            "Requirement already satisfied: numpy<3,>=1.17 in /usr/local/lib/python3.11/dist-packages (from qiskit==2.0.0) (2.0.2)\n",
+            "Requirement already satisfied: scipy>=1.5 in /usr/local/lib/python3.11/dist-packages (from qiskit==2.0.0) (1.15.3)\n",
+            "Requirement already satisfied: sympy>=1.3 in /usr/local/lib/python3.11/dist-packages (from qiskit==2.0.0) (1.13.1)\n",
+            "Requirement already satisfied: dill>=0.3 in /usr/local/lib/python3.11/dist-packages (from qiskit==2.0.0) (0.3.7)\n",
+            "Requirement already satisfied: python-dateutil>=2.8.0 in /usr/local/lib/python3.11/dist-packages (from qiskit==2.0.0) (2.9.0.post0)\n",
+            "Requirement already satisfied: stevedore>=3.0.0 in /usr/local/lib/python3.11/dist-packages (from qiskit==2.0.0) (5.4.1)\n",
+            "Requirement already satisfied: typing-extensions in /usr/local/lib/python3.11/dist-packages (from qiskit==2.0.0) (4.14.0)\n",
+            "Requirement already satisfied: symengine<0.14,>=0.11 in /usr/local/lib/python3.11/dist-packages (from qiskit==2.0.0) (0.13.0)\n",
+            "Requirement already satisfied: contourpy>=1.0.1 in /usr/local/lib/python3.11/dist-packages (from matplotlib==3.10.1) (1.3.2)\n",
+            "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.11/dist-packages (from matplotlib==3.10.1) (0.12.1)\n",
+            "Requirement already satisfied: fonttools>=4.22.0 in /usr/local/lib/python3.11/dist-packages (from matplotlib==3.10.1) (4.58.1)\n",
+            "Requirement already satisfied: kiwisolver>=1.3.1 in /usr/local/lib/python3.11/dist-packages (from matplotlib==3.10.1) (1.4.8)\n",
+            "Requirement already satisfied: packaging>=20.0 in /usr/local/lib/python3.11/dist-packages (from matplotlib==3.10.1) (24.2)\n",
+            "Requirement already satisfied: pyparsing>=2.3.1 in /usr/local/lib/python3.11/dist-packages (from matplotlib==3.10.1) (3.2.3)\n",
+            "Requirement already satisfied: comm>=0.1.3 in /usr/local/lib/python3.11/dist-packages (from ipywidgets==8.1.5) (0.2.2)\n",
+            "Requirement already satisfied: ipython>=6.1.0 in /usr/local/lib/python3.11/dist-packages (from ipywidgets==8.1.5) (7.34.0)\n",
+            "Requirement already satisfied: traitlets>=4.3.1 in /usr/local/lib/python3.11/dist-packages (from ipywidgets==8.1.5) (5.7.1)\n",
+            "Requirement already satisfied: widgetsnbextension~=4.0.12 in /usr/local/lib/python3.11/dist-packages (from ipywidgets==8.1.5) (4.0.14)\n",
+            "Requirement already satisfied: jupyterlab-widgets~=3.0.12 in /usr/local/lib/python3.11/dist-packages (from ipywidgets==8.1.5) (3.0.15)\n",
+            "Requirement already satisfied: psutil>=5 in /usr/local/lib/python3.11/dist-packages (from qiskit-aer==0.17.0) (5.9.5)\n",
+            "Requirement already satisfied: cffi>=1.0 in /usr/local/lib/python3.11/dist-packages (from soundfile==0.13.1) (1.17.1)\n",
+            "Requirement already satisfied: pycparser in /usr/local/lib/python3.11/dist-packages (from cffi>=1.0->soundfile==0.13.1) (2.22)\n",
+            "Requirement already satisfied: setuptools>=18.5 in /usr/local/lib/python3.11/dist-packages (from ipython>=6.1.0->ipywidgets==8.1.5) (75.2.0)\n",
+            "Requirement already satisfied: jedi>=0.16 in /usr/local/lib/python3.11/dist-packages (from ipython>=6.1.0->ipywidgets==8.1.5) (0.19.2)\n",
+            "Requirement already satisfied: decorator in /usr/local/lib/python3.11/dist-packages (from ipython>=6.1.0->ipywidgets==8.1.5) (4.4.2)\n",
+            "Requirement already satisfied: pickleshare in /usr/local/lib/python3.11/dist-packages (from ipython>=6.1.0->ipywidgets==8.1.5) (0.7.5)\n",
+            "Requirement already satisfied: prompt-toolkit!=3.0.0,!=3.0.1,<3.1.0,>=2.0.0 in /usr/local/lib/python3.11/dist-packages (from ipython>=6.1.0->ipywidgets==8.1.5) (3.0.51)\n",
+            "Requirement already satisfied: pygments in /usr/local/lib/python3.11/dist-packages (from ipython>=6.1.0->ipywidgets==8.1.5) (2.19.1)\n",
+            "Requirement already satisfied: backcall in /usr/local/lib/python3.11/dist-packages (from ipython>=6.1.0->ipywidgets==8.1.5) (0.2.0)\n",
+            "Requirement already satisfied: matplotlib-inline in /usr/local/lib/python3.11/dist-packages (from ipython>=6.1.0->ipywidgets==8.1.5) (0.1.7)\n",
+            "Requirement already satisfied: pexpect>4.3 in /usr/local/lib/python3.11/dist-packages (from ipython>=6.1.0->ipywidgets==8.1.5) (4.9.0)\n",
+            "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.11/dist-packages (from python-dateutil>=2.8.0->qiskit==2.0.0) (1.17.0)\n",
+            "Requirement already satisfied: pbr>=2.0.0 in /usr/local/lib/python3.11/dist-packages (from stevedore>=3.0.0->qiskit==2.0.0) (6.1.1)\n",
+            "Requirement already satisfied: mpmath<1.4,>=1.1.0 in /usr/local/lib/python3.11/dist-packages (from sympy>=1.3->qiskit==2.0.0) (1.3.0)\n",
+            "Requirement already satisfied: parso<0.9.0,>=0.8.4 in /usr/local/lib/python3.11/dist-packages (from jedi>=0.16->ipython>=6.1.0->ipywidgets==8.1.5) (0.8.4)\n",
+            "Requirement already satisfied: ptyprocess>=0.5 in /usr/local/lib/python3.11/dist-packages (from pexpect>4.3->ipython>=6.1.0->ipywidgets==8.1.5) (0.7.0)\n",
+            "Requirement already satisfied: wcwidth in /usr/local/lib/python3.11/dist-packages (from prompt-toolkit!=3.0.0,!=3.0.1,<3.1.0,>=2.0.0->ipython>=6.1.0->ipywidgets==8.1.5) (0.2.13)\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import os\n",
+        "import sys\n",
+        "\n",
+        "# Add the current directory (QuantumArtHack) to Python's path\n",
+        "sys.path.append(os.getcwd())"
+      ],
+      "metadata": {
+        "id": "mX_qs1eSMI9C"
+      },
+      "execution_count": 4,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import QPIXL.helper as hlp\n",
+        "from QPIXL.qiskit.qpixl import cFRQI\n",
+        "from QPIXL.qiskit.qpixl_angs import cFRQIangs, decodeAngQPIXL\n",
+        "import qiskit\n",
+        "from qiskit import QuantumCircuit\n",
+        "from qiskit_aer import StatevectorSimulator, AerSimulator\n",
+        "import matplotlib.pyplot as plt\n",
+        "from matplotlib import animation\n",
+        "import numpy as np\n",
+        "from PIL import Image\n",
+        "from ipywidgets import interact\n",
+        "import ipywidgets as widgets\n",
+        "from IPython.display import display, clear_output\n",
+        "import os\n",
+        "from itertools import chain\n",
+        "import io\n",
+        "import math\n",
+        "# Removed: from scipy.fft import fwht, ifwht # No longer directly import these\n",
+        "from qiskit.circuit.library import QFT\n",
+        "import traceback\n",
+        "\n",
+        "import warnings\n",
+        "import soundfile\n",
+        "\n",
+        "warnings.filterwarnings(\"ignore\")\n",
+        "\n",
+        "backend = StatevectorSimulator(method=\"statevector\")"
+      ],
+      "metadata": {
+        "id": "GhGDUPeyNBhA"
+      },
+      "execution_count": 5,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "# Test 1: Sequential Combination — QPIXL and Simple Algorithm\n",
+        "This cell demonstrates the use of the QuantumComposer with the sequential combination rule. **bold text**\n",
+        "\n",
+        "-A QPIXL module is created from an 8-pixel grayscale image encoded as rotation angles\n",
+        "\n",
+        "-A simple quantum algorithm circuit is defined with a Hadamard and a CNOT\n",
+        "\n",
+        "-The two circuits are combined sequentially without entanglement\n",
+        "\n",
+        "-The resulting circuit is drawn to verify structure and correctness\n",
+        "\n"
+      ],
+      "metadata": {
+        "id": "fOJ114Xj19PH"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "from QPIXL.qiskit.qpixl_module import QPIXLModule\n",
+        "from QPIXL.qiskit.quantum_composer import QiskitCircuitModule, QuantumComposer\n",
+        "from qiskit import QuantumCircuit\n",
+        "import numpy as np\n",
+        "\n",
+        "# Setup QPIXL and a small algorithm\n",
+        "image = np.linspace(0, np.pi / 2, 8)\n",
+        "qpixl = QPIXLModule(image)\n",
+        "algo = QuantumCircuit(3); algo.h(0); algo.cx(0, 1)\n",
+        "algo_mod = QiskitCircuitModule(algo, name=\"MyAlgo\")\n",
+        "\n",
+        "# Combine sequentially\n",
+        "composer = QuantumComposer([qpixl, algo_mod])\n",
+        "combined = composer.combine(rule=\"sequential\")\n",
+        "\n",
+        "# Show\n",
+        "combined.draw(\"mpl\")\n"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 561
+        },
+        "id": "Mt4mBicyNBdC",
+        "outputId": "6146201c-2287-4227-8b73-42a7eeb0d820"
+      },
+      "execution_count": 6,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "▶ Combining using rule: sequential\n",
+            "  ↪ QPIXLModule\n",
+            "  ↪ MyAlgo\n",
+            "✓ Done in 0.00s\n"
+          ]
+        },
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "<Figure size 938.155x702.333 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {},
+          "execution_count": 6
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "# Test 2: Merged Combination with Entanglement\n",
+        "This test uses the merge rule in QuantumComposer to combine a QPIXL module and an algorithm circuit.\n",
+        "\n",
+        "*   The QPIXL and algorithm circuits are merged side by side\n",
+        "*   An entangling CZ gate is applied between qubit 0 of the QPIXL circuit and qubit 0 of the algorithm circuit using connection_map={0: 3}\n",
+        "\n",
+        "*  The output circuit includes both sub-circuits along with the entanglement gate\n"
+      ],
+      "metadata": {
+        "id": "tYd5JevD3JoO"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "composer = QuantumComposer([qpixl, algo_mod])\n",
+        "merged = composer.combine(\n",
+        "    rule=\"merge\",\n",
+        "    connection_map={0: 3},\n",
+        "    entangle_type=\"cz\"\n",
+        ")\n",
+        "merged.draw(\"mpl\")\n"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 663
+        },
+        "id": "ZZAo31MkNBXP",
+        "outputId": "f2837249-395d-4da2-b5f4-649dce6d9da6"
+      },
+      "execution_count": 24,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "▶ Combining using rule: merge\n",
+            "  ↪ QPIXLImg\n",
+            "  ↪ MyAlgo\n",
+            "✓ Done in 0.00s\n"
+          ]
+        },
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "<Figure size 1039.59x953.167 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {},
+          "execution_count": 24
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "# Test 3: Image-Based QPIXL with Compression + Algorithm\n",
+        "In this test, an 8×8 grayscale image is converted into angle-encoded pixel data and encoded using QPIXL with compression enabled.\n",
+        "\n",
+        "*   The image is flattened and scaled to angles between 0 and π\n",
+        "\n",
+        "*    QPIXL encoding is applied with a compression setting of 30\n",
+        "\n",
+        "\n",
+        "*   A simple quantum algorithm (Hadamard + two CNOTs) is defined on 6 qubits\n",
+        "\n",
+        "\n",
+        "*   Both circuits are combined sequentially to form a full quantum circuit\n",
+        "\n"
+      ],
+      "metadata": {
+        "id": "-0SmBu_x38o6"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "from PIL import Image\n",
+        "import numpy as np\n",
+        "from qiskit import QuantumCircuit\n",
+        "from QPIXL.qiskit.qpixl_module import QPIXLModule\n",
+        "from QPIXL.qiskit.quantum_composer import QiskitCircuitModule, QuantumComposer\n",
+        "\n",
+        "# Load and preprocess the image (8x8)\n",
+        "img = Image.open(\"/content/QuantumArtHack/figures/cat.webp\").convert(\"L\").resize((8, 8))\n",
+        "angles = (np.array(img) / 255.0 * np.pi).flatten()\n",
+        "\n",
+        "# QPIXL module (with compression)\n",
+        "qpixl_mod = QPIXLModule(angles, compression=30)\n",
+        "\n",
+        "# Add an algorithm module (e.g. simple QFT)\n",
+        "algo = QuantumCircuit(6)\n",
+        "algo.h(0); algo.cx(0, 1); algo.cx(1, 2)\n",
+        "algo_mod = QiskitCircuitModule(algo, name=\"MyAlgo\")\n",
+        "\n",
+        "# Compose the system\n",
+        "composer = QuantumComposer([qpixl_mod, algo_mod])\n",
+        "combined = composer.combine(rule=\"sequential\")\n",
+        "\n",
+        "# Visualize\n",
+        "combined.draw(\"mpl\")\n"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 1000
+        },
+        "id": "NPDeHncCPgmg",
+        "outputId": "ba8c1e52-d704-4dc4-e82b-711a945145be"
+      },
+      "execution_count": 23,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "▶ Combining using rule: sequential\n",
+            "  ↪ QPIXLModule\n",
+            "  ↪ MyAlgo\n",
+            "✓ Done in 0.01s\n"
+          ]
+        },
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "<Figure size 2210.55x6220.67 with 1 Axes>"
+            ],
+            "image/png": "iVBORw0KGgoAAAANSUhEUgAABroAABLJCAYAAACMTG86AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjEsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvc2/+5QAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzs3Xd4FOXax/HfJpueUAOE0HtRFAGlixQFBAsW7IINEMuxK75YsXePBRUbelRAUIoozYI0QRCRXkIRQkIIEEjdZMv7B4KUhOxudnd2dr+f6+I6HmaemXuZe2aemXvmGYvL5XIJAAAAAAAAAAAAMJkIowMAAAAAAAAAAAAAvEGhCwAAAAAAAAAAAKZEoQsAAAAAAAAAAACmRKELAAAAAAAAAAAApkShCwAAAAAAAAAAAKZEoQsAAAAAAAAAAACmRKELAAAAAAAAAAAApkShCwAAAAAAAAAAAKZEoQsAAAAAAAAAAACmRKELAAAAAAAAAAAApkShCwAAAAAAAAAAAKZEoQsAAAAAAAAAAACmRKELAAAAAAAAAAAApkShCwAAAAAAAAAAAKZEoQsAAAAAAAAAAACmRKELAAAAAAAAAAAApkShCwAAAAAAAAAAAKZEoQsAAAAAAAAAAACmRKELAAAAAAAAAAAApkShCwAAAAAAAAAAAKZEoQsAAAAAAAAAAACmRKELAAAAAAAAAAAApkShCwAAAAAAAAAAAKZEoQsAAAAAAAAAAACmRKELAAAAAAAAAAAApkShCwAAAAAAAAAAAKZEoQsAAAAAAAAAAACmRKELAAAAAAAAAAAApkShCwAAAAAAAAAAAKZEoQsAAAAAAAAAAACmRKELAAAAAAAAAAAApkShCwAAAAAAAAAAAKZEoQsAAAAAAAAAAACmRKELAAAAAAAAAAAApkShCwAAAAAAAAAAAKZEoQsAAAAAAAAAAACmRKELAAAAAAAAAAAApmQ1OgCUzuVyyV5oMzoMt1njYmSxWIwOw5TMtq09QV54z4x5wfb2HTNu/yPIg4oz8/aXyAFvmH2bnwr54B5yAKUxY16wvb1nxu3tLvLCO2bMCbY1fM1s+wH7ACrCbPnurkDtFxS6gpS90KYvmlxvdBhuuy7tf4qKjzU6DFMy27b2BHnhPTPmBdvbd8y4/Y8gDyrOzNtfIge8YfZtfirkg3vIAZTGjHnB9vaeGbe3u8gL75gxJ9jW8DWz7QfsA6gIs+W7uwK1XzB0IQAAAAAAAAAAAEyJQhcAAAAAAAAAAABMiUIXAAAAAAAAAAAATIlCFwAAAAAAAAAAAEzJanQAgL/l5hdr5fp92rj9oAqK7IqIsKhSQrTaNKuq05tVVXRUpNEhws/27CvUinXZ2rE7T7Zih6KiIpRcJVbtWlVXk3qVFBFhMTpE+JHL5dLWXbn6Y/0+Ze0vVEmJUzHRkaqXkqD2rZNVu0a80SHCz0pKnFq39YBWbdyvg3nFcjpdiou1qnmDymrXqroqJUYbHSL8LK+gRH9u2KcN2w4qv7BEFotFSQlRatOsqto0q6aYaPoCoW7v/kKtWLdP29JzZSt2yGqNUPXKMTqrVXU1b1CZvkCIc7lc2p6epz/WZytzX6GKS5yKiYpQ3VqH+wKpNeNlsZADocxud2r91hyt2rRfBw7Z5HAc7gs0q19J7VpVV5VKMUaHCD8rKLRr1aZ9WpeWo7yCw32BxPgond60qs5oXlWxMdweC3X7coq0Yl22tu7KVZHtcF+gWqUYtW1ZTS0aVlZkZGi/C1Bc4tCazQe0evMBHcwrlsvlUnysVS0bVdFZraorMT7K6BDhZ2XdHz2jeVWd1jT07486HE5t2HZQf27cpwOHimW3OxUbE6km9SqpfetkVatMX8DsOJMjJGXsLdC4KRv11Q9p2rj9oFyu0ueLjopQ+9bJuvnS5rqmf2MlcGIPGas37de7E9drxvy/lZ5VUOZ8lRKjdG67FI0Y3FL9utYN+c5tuHA6XZr3W7re+3qDfl6WoZzc4jLnrV0jXgO619XIq1rprFbJAYwS/lRYZNek2dv00bcbtWxNtmzFjjLnbd6gsq7q10jDLm+puikJAYwS/pS1r1AffbtJX8zconVbc8rsC0RZI3RWy+oaekkzXT+wiZISKHyGivVbczR20npN/WmHdmbmlzlfYnyUurerpeFXttSA7vVktdIXCAUul0s/L8vQ2Enr9dOyDO0/aCtz3lrV49Sv6+G+wNmnJ1P0ChG2Yocmz92mD7/ZpKWrs1RYVHZfoEm9JF15QSMNv6KlGtZJCmCU8Kd9OUX6ZOpmff7dFq3ZckBOZ+mdAavVojOaVdOQi5vpxouaUvgMIZt3HNR7X2/QN/O2a/vuvDLnS4izqkvbmhp2eUtd0rOBoqJCoy+QX1CiL79P08dTN+mP9ftUXOIsdT6LRWrZqIqu6d9Yt13eQinJPAwaKnZn5evDbza5dX+0w2lH7o82UXxcaJQMikscmvrTDo2bslGL/8xSQZG9zHkb1UnSZb0b6ParWqlJvUoBjBK+YnG5ykpxGKmkoEhfNLne6DDcdl3a/xQVH2t0GErfk68HX1umr+duk93uWWpXTorWyMGt9NjwtoqLDdwB3Wzb2hNG5MXSv7L0wKvLtHDlHo/bNqqTpNHD2uqmS5sZfoPDjHkRDMcBl8ulL79P05NjV2rL34c8bt/pjBp66d5z1L19ih+ic58Zt/8RRueBrdihFz5apf9+ue6UNzVLExlp0aU9G+jVB85Rg1TjbnKZeftLxufAnn2Feui1Zfrqh60qsZd+MV+WpIQoDbu8hZ4c2S6gT7WafZufihH5sHJ9tu5/ZZl+/j3D47b1UhI06pYzNfzKlgF9y4sc8K3Jc7bpsXdWaMO2gx63bd86WS/ec7Z6d0r1Q2SeMWNeGH0OkA6/yf3K+NV6/fM12nugyKO2Fot0UY/6evWBjmpaP7A3ucy4vd0V6LzYl1OkUW8u12cztpzyYafSxMdadctlzTXmjvaqnGTswy9mzIlgOAZI0totB3T/K0s1e3G6x21r14jXQ0Pb6K5rW5v2QdiCQrvGfLBS705cr0N5JR61tVotGnxBY71839lKrWn8Q4Bm2w+CZR/YlXn4/ujkeZ7fH62SFK2RV7XS6GGBvT/qSw6HU2/8b61eGb9amdmFHrfv362uXn2go1o1ruL74E7BbPnurkDtF+bMVpQqpfNp6vfNU8f9XUl+oQ5tzVDa5F+1/qPv5XJ4dsPHLFwul8ZP36x7Xlqqg6d4c+NUDuYW6/mPVmnKvO36ZEx3dWlby8dR+l8450CRza4n3v1Dr4xfU+aTeuXZlp6rW55YoEmzt2rck91ULyXRx1H6XzjnQMbeAo0Ys0jTf/nb62X89tde9bh5pu6+9jQ9d3cHUz7FFM45sHztXt302AKt2XLAq/YOh0tT5m3X7MXpeuX+czTsihaGF709Fc7b3+VyacIPW3Xn80s8LnIekZtfolc/W6Nvftyhj5/urvPOru3jKP0vnHOguMShZz9Ypec++tPjC/ojdmbma+SzizVpzjZ9/FR3Naprvjc7wjkH9u4v1B3PLdHXc7Z5vYwV67LVZ9gPGnFlS71039mmfMsznHPgr037NXT0r1q5YZ9X7V0uafovf2vub+l6/u4Ouuva00w3tGk4b39J+vbH7RoxZpGy9ntW5DyioMiut75cp29/3KEPn+ymvl3r+jhC/wvnHLDbnXr509V6cuwfZb69VJ6MvQW69+Wl+nru4b5Ai0ZVfBukny1auUc3Pf6rNu/w/MFPSbLbDz88+v2CnXrz4U664aKmXBOZiMvl0qfTNuvel72/P5qTW6znPjx8f/TTMeeq05k1fRylf63fmqObHvtVS1fv9XoZPyzcpZ+WZejpke10/5DTTVf0Dtd9wHx38FCurd8s0K6f/pAsFsXVqKKmV/bQOU8NVeVmdbTkwfeNDs/nSkqcuvmJX/W/79J8srxNOw6q25Dv9ObDnXTXtaf5ZJmBFm45sGdfofrfPtvrC9oTzV6crjaXf6vpb/bRuR3Md5NTCr8cWPpXlgbcOUf7cry7uX0sl0t684u1mvtbuua81091ahn/FJs3wi0HPpyyUSOeWSSHo+IvqucVlGjEmEWauyRdX7xwnim/3xRu29/hcOr2ZxZr3JSNPlnetvRc9bzle71wTwc9fPOZPllmoIVbDuw/aNOFI2dX6IL2WL/8nqE2l3+jb9/oo/M71/HJMgMt3HJg1cZ96jtitvbs8/yp3dK89/UGzVu6W3Pe62fKgqcUfjnw5cw0DX3sV4/f5i1NYZFD97y0VHOWpOvrV3qb8uGncNv+TqdL9728VG9+sdYny9u1J1/9bp+tx4a31VMj25nuRr8UfjlwMLdYl/xnruYvz/TJ8hb/maW2g6dq4ks9dXHPBj5Zpr+9+b81uvflpWUOT+eJnNxiDRn9q35culsfPdXdlEM7h9s+UFLi1NDHftWX3/vm/ujG7QfVdch3+u8jnXTH1a19skx/+/bH7brm4V88fpu3NLZihx5+43fNXrxLU9/sY8qHn8JtHzDfUQrl2rd6m7ZOWaCtk3/V2rHTNXPAo8pPz1bza3srpnpojTFqtzt19UM/+6zIdYTLJd39wm96dfxqny43UMIpB7L2FarHTTN9VuQ64mBusfrePlu/eDHsUTAIpxxYsmqP+gyb5ZMi17HWpeWo+9CZSt9T9nddglk45cC7E9bptqcW+qTIdawp87Zr0D3zVFxS8U5yoIXT9nc6XRoy+lefFbmO9cgby/XU2D98vtxACKcc2H/Qpp63fO+zItcR+YV2Dbhjjn5YsNOnyw2UcMqBleuzdd7N3/usyHXElr8PqfvQ77RtV65Plxso4ZQD46dt1vWP/uKTItexvl+wSwPunKPCU3zTI1iF0/Z3uVwaMWaRz4pcxxrz/p96+PXfZcavfoRTDhzKK9b5w3/wWZHriCKbQ5fd96O+mbfdp8v1h5c+/kv3vOSbItexPpuxRdc8/LPsPj6+BkI47QN2u1ODH/zJZ0WuI5xOl+58bole+yz4749+PWebrrj/J58UuY7107IMXTB8lvIKPBsGNBiE0z4gUegKC/ZCm/b+sVmWiAhVamC+4fhO5e4XluibH7f7bfkPvLpMX8707UnCCKGaA7Zih/qPnK2N2z3//oI7imwOXXTXXK3fmuOX5QdSqObA1l2HdOHIOX7rcGxLz1XfEbNUUGi+mxsnCtUcmPrTdt3x3BK/Lf+Hhbt025ML/bb8QAnV7S9JD7/+u77w47n6ybEr9aEfimiBFqo5YLc7dfHdc/XXpv1+WX6J3anL7/9RK9dn+2X5gRSqOZC+J199R8xWjpfD85S7/KwCnT/8B6+H/wkmoZoDcxbv0s1PLPD5zd0jfvk9Qzc8Ot+UhY5jher2l6Snxq70ywMvR7z86Wr91w9FtEAL1RxwOl26/L4f9fsa/5yrHQ6Xrnn4Zy1Z5fl3wAPli5lb9PAbv/tt+ZPnbtc9L/3mt+UHSqjuA5J05/NLNPWnHX5b/v2vLNPEWVv9tvyKWrAiU9c98ovXnzIpz29/7dWV9//kt+UHSijvAxKFruPMmTNH/fr1U/Xq1RUfH682bdro+eefV3Gx+S9qkhoeTl5bTp7BkfjOrIW7NHbSBo/a/P7Vxdo592r9/tXFbrcZ+dxi077RcaxQzIEx76/UH+s9e5PL0xzIKyjR0NG/mvLppROFWg44nS7d/PgCj25seXMMWJuWo/97a7k3IQadUMuBvfsLNeypRR618SYHPpuxxRRPcZYn1La/JP26PEOvePj2tTc5cM9Lv5n2jY5jhWIOvDJ+tRat9OzGk6c5UFjk0JDRv5ry7c4ThVoOuFwu3fbUQu094P63eLw5BqTtzNWDry3zJsSgE2o5kHPIppsfX+DRjSdvcmDKvO3633dbvAkxqITa9pek39fs1ZgP/vSsjRc58PAby0PiAchQzIF3JqzTvN92e9TG0xwoLnFqyOhfg/Ltzl3/fF/UE97sA+9MWK85i3d5Gl7QCcV94PsFO/X+1/6/P3r7M4uUsbfA0/D8Lr+gxOOhi735/bMW7dIHkz37dw5GobgPHEGh6x+vvvqq+vbtq9mzZyspKUktWrTQhg0b9Oijj6pnz54qLPTtMBj+ZI2LVky1JMVUr6QqLeur43O3qnqbxtr7x2Yd2mrOYdhOdDC3WLc95fkT9inJ8apbK0EpyfEerWv4mEWmeoIvHHJg+dq9euHjvzxu500OLFuzV6+a4DXtY4VDDrw7cb3HQ1N4s/2lw9/sWrDCt8Ng+Fs45MCdzy/x6Oam5H0O3P7MImV7uC4jhcP2zy8o0c1PLPC4nTc5kF9o1y1PeHYj1WjhkANrtxzQE+96PrSkNzmwevMBPePhjVSjhUMOfDpts35Y6NlNN2/PA+OmbDTdDb5wyIH7Xlmq9CzPbrp5mwN3v/CbdmeZ5wHIcNj+tmKHbnrsV4/Pz97kwJF1ORzmeQAyHHIgbechPfKG5w8lepMDm3cc0ui3V3i8Ln868sDHoTzPRjjx9jh465MLdSjPPC8DhMM+kHPIFrD7owcOFWv408F3f3TUf5drq4cPJXq7Dzz42u/anm6eByDDYR84lvm+qOoHy5Yt04MPPiiLxaJPPvlEQ4YMkSSlpaWpX79+Wrx4sUaNGqU33njD2EDddNZDV+ush64+7u+2z/xNS0d9aFBEvvfmF2u1K4BvWc38dafmL8/UeWfXDtg6KyIccmDUm8t9/j2eU3n6vT814spWqpxkjo9PhnoOFBTa9VgALzJcLunhN37X4s8vCtg6KyrUc+D3NXs1afa2gK0va3+RXv70L7147zkBW2dFhPr2l6T3J29Q2s7AXWT8/HuGvl+wUwN71A/YOisiHHJg9NsrVFwSuBuOL378l+68urVqVo8L2DorItRzoLjEoUf/G9g3rh987Xed37mOLBZLQNfrrVDPgXVpB/TJ1M0BW19ObrGe+3CV3n60S8DWWRGhvv2lw8XutWk5AVvf0tV7NXnudl3Vr3HA1lkR4ZADT7z7hwoC+JbVG/9bq3uuP031UhIDts5T+WlphmYtCtxDGDsz8/XWl+v0f8PaBmydFREO+8Ab/1ur3R4+8FERM+b/rQUrMnVuh+C4P7ptV67e/mpdwNaXV1CiJ8eu1KfPnBuwdVZEOOwDx+KNLkljxoyRy+XSTTfddLTIJUlNmjTRRx99JEkaO3assrKyjArRIxs/n6PZg5/S3Oue1fIxn6tof64SaleXw/bvUxc9xt6rHu/fd1y76CqJGvznODW+rHugQ/aI3e405FXRsZPWB3yd3gr1HNi4LcfjoQkqqqDIrs9NNFxJqOfAhFlb/fYtjrIsWZWlPzd4NlSmkUI9B96dGPhj8sdTN6vIFnzDlZQm1Le/0+nyePhiX6AvEDx2ZuZp+i9/B3SdxSVOfTx1U0DXWRGhngNTf9qhzOzAjrrx16b9WvynOa4JpdDPASPOA5/N2GKaj9GH+vZ3uVyG9AfpCwSPrH2F+npO4B58kw73QT+YHDzfbjUiH9+fvME0bzaG+j5QUuLUBwZ8S9iI829Z3p+8wW/f6CzLxNlbtS/HHKO9hPo+cKKwL3Tl5uZqzpw5kqTbbrvtpOnnnnuumjdvruLiYk2fPj3Q4Xnl0NZMZSxYrfSfVmrNu9P045AXlNy2iTq/OPzoPEtGjVPNs1uo0aVdj/5dp+duVdayDdr6jefDAAXSjPl/ezw8hS988+P2oByLtjShngPveTj2sK+8O3F90L2iXZZQzwEjLmqNXK83QjkH9h+0aYIBH8LNPlAU8Itpb4Xy9pekeb+la8vfhwK+3h8W7tLWXYFfrzdCPQc+mLzRkKEk3/vaPDd3Qj0HjDonvzMhcE8NV1Qo50BeQYnGTw/c21xH5OaXmOZbXaG8/SVp8Z9Z+mvT/oCvd/7yTK3dciDg6/VGqOfAx1M3BfTN7iPGTdkYFN/tTN+Tr6k/7wj4endm5uu7X3cGfL3eCPV9YNrPOwy5Tzll3nZlZht/f9RW7NBH3wb+IbQimyOgb5RXRKjvAycK+0LXypUrVVxcrJiYGHXo0KHUebp16yZJ+u233wIZms/sXb5RaZN/VaNLu6pGhxaSpOKcPC2+f6w6Pnur4mpVVYMBnZTS5TQtefh9g6Mt30yDTqh2u0tzl6Qbsu6KCrkcWGBMDqzfmqPt6eb8WGMo5cCefYVasS7bkHV/b1Du+UIo5cBPS3eryGbMxeX3C8z1fZYjQmn7S8b1BVwuaZaH3wMKFuSAb+zYnad1ARwmy5dCKQdy84v1q0Hfzvxh4S7TPPh0olDKgYV/7FFuvjFvVtEXCA5GnQck814TkAO+sWdfof5YZ/xIH3OWpAf0cw7HYh8IDkbdGyuxOwM+ylJplq3ea9h3tNkHglPYF7o2bTpc+W3QoIGs1tI/WdakSZPj5jWjVa9PltPu0FkPXnX079J//lPbZyzWuW/frU4v3KbF94+V7UDw38Rfsd6YG9ySDLu57guhkgMHc4u1eYdxT9OTA8YzchukZxVoz77ADpPkSyGTA0aeBwxcd0WFyvaXpBXrjbu5YOS6KypUcsBW7NAaA5+m5zhgvJXr9wV8mJojcnKLPf7geTAJlRwwsj/IMSA40B/0TqjkgMPh1EoDh5UPhhww9DgYBIU+b4XKPiAZnQPhvQ/8sWGfaR98CqV94ERhX+g6cODwRXLVqlXLnOfItCPzmlHu9kxtm7ZIqeeeoZodWx39++VPfaakRilK/2mldv34h4ERuqfIZjf4xoZ5T+ahkgN/bjR2GwRDh9ZboZIDfxi8DYKhQ+et0MkB444Dm3cc0sEAfx/OV0Jl+zscTq00stDFMcBwqzfvV4nduOEDzXxzJ1RywOg+OccB4xnZJ9+dVWCaIe1PFCrb3+VyGdof5DxgvM1/H1J+oXHfzg2G84CRMfy1ab9sxcYP3+iNUNkHCovsWrc1x7D1B8U+YGBf4GBusdJ2mvPBp1DZB0oT9oWuoqLDrzhGR0eXOU9MTIwkqbDQvE/xS9Jfb06R03F8xdZeaFPejiwdWB/Yj3l7a8++QtntxlXMd2aar5p9rFDIgZ2Z+WG9/ooiB8y//ooiByouPcu8ORAK2//AoWIVFBl3Y2PXHvNufyk0csDoYwA5YDyj++TkgPE4DngvFLa/rdhh2HBVkvH5V1GhkANGbwOj1290DCV2p/buN24frKhQ2AcyswsNG7pSYh+Q6Av4ksvlUn5+vvLz8yv0ppzFZdb37Hzk5Zdf1kMPPaSOHTuW+Q2usWPHauTIkTr99NO1evVqj9fRoUMHZWZ6NoZ8lCtCTzjP8Xhd3ug35SntnLtCa9+b7vUynopYphKL/5+sLYmorqwqd5c5/fevLlZKcnyZ01OS42SNjJDd4VRmdtmFy8zsAp19zcn/HhHOPNXOedmzoMsRyG1dFl/kQGn8kRf50e2Uk3hJqdPK2/5SxXMgtnitqudN8ixoLwQ6L8x0HDiQcKkKYs4qdZqvjgFS2TlQOf8HJdr8+81GI44LvjoOBCIPMiv/R47IaqVOC0QO1Dg4VtEO/30bxszbX/J/DjgsScqs+kCZ0/3dF7C4bEo98JxnQZeDvoBnCqJP14HEK0udFoi+QEzxZiXn/c+zoMtBDngmJ36A8mNL//cKxHmgUsE8JRX5/+Pc9AfLtqfS7bJbU0qdFogcSD70kWLsvr0RZPRxwF/HAMn3eeG0xCij6qNlTvd3X0CSUvc/IYv7IXuFY0DZCqOaa3/SdaVOC0RfILpku2rkfuJZ0D6WUeUhOSMSSp0WiH2gVs6bsjr3exa0F7g/WrqSiGRlVbmrzOn+vz+aq9o5r3gWtI9lVbpVJdZ6pU4LRF+geu7nii3Z4lnQ5QjVvkB5+4XT6VRGRoYkqW3btlq5cqVX6yn9o1RhxJ1hCd0Z3vBUMjMzlZ6e7lGbaEukVMur1Rlid8ZuFbsC8NpylE2qUvbklOR41a1V+on+WNbICLfmO5HTXuzxtiyP2ba1J/ySF1XqS4mlT3J3+0ve50BRQZ7Pc6A0ZsyLgB0H6uRKMaVP8vcxQJIO5uzTwf3+zQEzbv8jApIH8TYpsvRJgciBvXsyJJv/Pr5r5u0vBSAHIhOlU3TJ/J0DLoedvoAH/JIPlWoZ2hewFfm+L0AOeKj2QSm29EmBOA8cOrhfh7LpD5YmYP3BOFuZdzMCkQPZWZlSIccBd/k8LyzRhvYF5LRrN9eEpQrYMSCxipRU+qRA9AWKbQUBuS9wSkklZY7TFYjj4J7MdKnE/4Uus+0HAdsHootD7v6ox6ILKnxNUJF9YN/ePVI+fQF3eLJf7Nmzx+v1hH2hq3nz5pKkHTt2yG63y2o9+Z8kLS3tuHk9lZJS+pNmpxLlipCM+/SAx1JrpwbkiQWnopVxiumZ2aceK92TJxZKExVRpJp16rgTqtvMtq094Y+8KIqKVlkjope3/aWK50BCrFNVfJwDpTFjXgTqOHAwTiprwCJfHQNOtaxqlayKi/NvDphx+x8RiDzYG2lTWV/JCkQOpNRIVKTLfzlg5u0v+T8HXIrUbpddspTejfV3X8BqKVAt+gJu80c+2KwxKmtE/kD0BeKjnapKDrjNHzmQG2vRoTKmBeI8UDXJqvgY+oOlCVR/MDuyWLYypgUiB2olx8vq5DjgLl/nhUtShssml6X0p9/83ReIUL5qc01YqkAdA4ojY7W3jGmB6AvERTlULQA5cCpZlkKVlFHp8Pc+IJdTtWtWUoTi3A3Xa2bbDwJ3fzQm5O6PempftF1lDaAZiL5AzepxiqpCX8Ad5e0Xx77RVauW95W+sB+6MDc3V8nJySouLtaSJUvUqVOnk+Zp0aKFNm3apA8++EC33XZbQOIqKSjSF02uD8i6fOG6tP8pKr6Mxyp9rOXFk7Vx+0Gv2u6ce7Xq1krQrj35qnf+BI/b33Z5C33wRDev1l0Ws21rT/gjL7L2FapWzy+9bl/RHPjs2XN1w0XNvF6/u8yYF4E6DkyZu01X3P+TV20ruv0ladsPg9WwThmPD/qIGbf/EYHIg3te/E1vfrHWq7YVzYG6tRK0c+7VXq3bXWbe/lJgcqD9VVO9/gh9RXPgmv6N9eWLPb1ad1nMvs1PxR/5kJtfrMpdPpe3VzEVzYF3/6+Lbr+qVfkzeoAc8MzsRbvU7/bZXrX1RV9g9ZRBOr1Z6UPo+pIZ8yJQ/cHRby3Xs+NWedW2ojlQtVK09i24XhaLbweuM+P2dpc/8uLcod9pwR/ePfVd0Ry4+Lz6mvbf871atyfMmBOBOgYUlziU1OkzFZd4d0e4ojnw8n3n6IGhbbxat6/c8sQCffztJq/aVvT3t25SRWu/vdyrdXvKbPtBIO+PNhv4tbb8XdajP6dW0RwYfmVLvfdYV6/W7SvPf7hKj/53uVdtK/r742IjdWjxjbJay3it0ktmy3d3lbdf5OfnKzHx8Ot5eXl5Skjw7i07324NE0pKStL55x/uoIwbN+6k6b/++qs2bdqk6OhoXXJJ6d8FQmC1b50cluvGYTWrx3n9WrEvkAPGM3IbVKscowapZbwbj4Bp37p6WK4b/6IvEN6SEqLVomFlw9ZPDhjPyG0QFxuplo2qGLZ+HGb0ecDXRS54zugcgLGioyLVJgAPHJQlGK4J2rcy8JqoFftAMDD0utjA/Dsag4G//8zm1Xxe5ELFsUUkjR49WhaLRZ988onGjx9/9O/T0tJ0yy23SJKGDx+umjVrGhUijtHrnNqGrbvn2catG/8yKgdq14g39MYaDmuQmqhGfn6jqiw9z67NjY0g0KNDbRm1GTgPBAf6Auh1Tqoh661aKVpntjDuxhoOS64aqzbNvPt+ckWd2y6FGxtBoNtZtRRl0HbgPBAcjDoPSORAsDCqP5gQZ9XZp9cwZN3H6mnkPmBgXxz/MvI4eF4QHAc7tqmpuNgyPt7tZz3PNu7fHmWjhy6pU6dOeuGFF+RyuTR06FA1bNhQZ511llq2bKktW7aoY8eOeuGFF4wOE/+4ul9jVUqMCvh6e51TW80pcgSFEYNbGrLeYZe3UGQkh02jWSwWjbjSmBy4fbBvh6qCd+rXTtSA7vUCvt642EjdeLH/hy5F+Qb1bqgaVQMzJMixzjm9htrxFHdQMOo8cPOlzRUTbcwFNY5nWF/Ax8NWwjs1qsXp8j4NA77eKGuEbh7k3be74Vv9u9VVvZTAj/RxWpMq6tbO+++HwHeGXWHMeeCGgU2VGB/4e1InatW4inp0SAn4eqskReuqvo0Dvl6c7Jr+jZWUEPhc7NMpVc0aGH9/tHJStK7t3yTg67VYpGFXtAj4elE+7tj+46GHHtKsWbN0/vnn6+DBg9qwYYOaN2+uZ599VvPnz1d8fLzRIeIfCfFRGmrAjcaRXNQGjU5n1NRZLQP7inJkpEW3Xc6JLFjcPCjwNxpbNKysXh2Nf2oJh91xdeuAr/O6C5uoaqXSP3qOwIqJjjTkmHzH1fQFgkWb5tXU3YAbjRQ5gsf1BtxorF87QQPPDfyDFiidEddnl/dpqJRk7g0EA6s1wpCC98irWjHCQ5BoWr+S+nWtG/D1BtO9ISNiuenSZoqPswZ8vThZUkK0hoT5/VEjYhl4bn2/f7cd3qHQdYy+fftqzpw5OnDggAoLC7V27Vo9+uijionhplawuX9Im4A+tdC2ZTVdfF6DgK0Pp2axWPTk7WcFdJ3DLm+hOgZ+GwzHS64aq7uvDWyh44kRZ3FRG0Qu6FJHnc8M3JDCsTGReuimMwK2PpTv7utOU9VK0QFbX8tGlXVVP55eDSZP3t4uoOu78aKmalKvUkDXibJVSozWA0NOD+g6Hxt2Fm/3B5Fu7Wqpd8fADR0UZY3Qo7eeGbD1oXwjBrdSrepxAVtfw9RE3u4PMo+PaBvQIc0v79NQbZoHzxDGg3o1DOiQykkJUbr3hsCee3FqDww5XQkBLDy2a1VdF/WoH7D1ladd62Rd0jNw8UREWPTY8LYBWx88Qwk+BJwz5mbV79tBifVqanqfB7R/7faTZ7JYdPYTN6pOz7Zy2p2yHcjV4gfeU+72TFnjY9XzowdU/YzGioiM1JcthwT8N3iqfu1EvXL/ORr+9CK/r8tqtejTMecqKoqL2mBycc8Gum5AE30xM83v62qYmqiX7jvH7+spT1KjFHV/8y7FVEtSSW6BFv7nbeVs2nXSfM2u6aU2dw6SIizKXLRGSx4ZJ5fdoRrtm6vzC7dJkixRVmUtW6+loz+Ws9h+ymnH6vv1E6repnFQHCeeGtlO03/5Wxu3H/T7ugb1bqCr+3ODO5hERFj0ydPd1XbwVBXZHH5f33N3dwiK4Rnwr1rV4/TWqM66ftR8v68rIuJwX4Ah64JLr46pGn5lS73/9Qa/r6t2jXi98XAnv68Hnhl165n69qcdWrVxv9/XdUGXOrrlMuOHrKtof/BYpfXrEuokq9Nzt6pS49pyOZ3aMH6ONnz8g1LPO1Md/u/6o/PFJldW4d4czbjgIf/92HJYLBZ9+GQ3tbn8W+UVlPh9fY+PaBtUN7ghVasco/ce66JB9/wYkPV9MubcoBiyzp/XhZJUpWV9dXr2FsXWONz3/eOFr/T390vV9Kqean3rhUeXH59aXXt+W6+fb3k5AL+6dJ3PrKV7bzhdr322xu/rql4lRu/8Xxe/r8cTUVER+nTMuTr72mmy211+X99rD3RUvZREv6+nPBXdB1I6n6Y+XzyqQ2m7j84786L/k6Oo+JT3TyXp9DsuVdPBPeQststhK9HS0R8r+88tAfvtJ2qQmqSX7ztHI59d7Pd1RVkP51uwfat07Oiu+nVFpg4cKvb7uh4c2iYovtGH0lHoCgE7Zi7Rmnen6sJpz5Q5T/2+HVTz7Jaa1vsBuewOnXHP5Wo36lrNH/6anHa7Vr89VcU5eeo35akARl4xt13eQt/M267Zi9PdbpOZXXDc/7rjiRFn6cwWgR0mz13untxPNV9kTJR6vHevKjerK0dRsYqyD2rJI+OOnsTr9DpL7R65RhaLRRZrpNa8O01pX89XTNVE9Z30xNF1RMbFKKlBLU1oc4uKc/IC8vv/+0hn/fx7hnZnub89Pc2BiAiLPn66e1Bc0HR5abg2/W+utkz6RQ0GdFK3N+/Ud/0fOW6exHo1ddZDV2vGBQ+pcG+Oen36sFpcf742fDpL+9dt14z+jxy+yWGxqOdHD6jl0H5a98F3p5x2ROvhA5W7Y4+qtwmOgk9crFWfjOmuc2+a6Xan3ptjQHLVWI0d3dUUb3O5c0zwdp+XpCuWvSuHreTwBYCkv976Vtun+79DXZYWjaroubs76L6Xl7rdxpsc6N6uVsDfIPSWL3LAnWU0vaqnur1xh3666UX9Pev3gP2+E117YRNNmbdd3/64w+023uTAQze1UcczAvcGoSd80ReQpIhoq85+YojqnNdWDlux9q/boQV3/rfcfHHrgSs/evm+szVncbq2pee63cabHPjg8a5BOXSpv7d/edNOdc4IhOioSH065lx1vG66ikucbrXxZvtXTorWuCe6BUVfoKL9wSPK6tf1/PhBrX5rqnZ8t0TS4YKWJO3+ZZWm/7Lq6Hy9PxulzEX+v7FcnoZ1kvTqA549AOlNDnQ4LVkP3xScb3OF+zXhpb0a6vqBTfS/79x/ANKbHLjr2tY67+zgGMbcn9eFkXHR6v3pw1pw91vKWrZBlogIRVc9XNjYMvFnbZn489F1XPLza9r6za8B/e2leebO9vp+wU5t2Ob+A5De5MC7/9cloG8Quqtty+p6bNhZeuLdP9xu483v79e1blA88CH55lx4KG23pp//4EnLPtX902qnNVTLoX01tce9shcUqfHl3dXxuVs088JRAfndZRl+ZUt98+N2zfttd/kz/8ObHHhqZLugfOCjdo14vT2qi64b9Yvbbbz5/ac1qRLw0aXcZfQ1gdHXhEdQ6AoBe35bX+48LpcUGW1VZEyU7HaHohLjVJCxT5LkLLYrc9EaJdY1V0XaYrFo4su91POW77Vywz632px9zXSP1nHTpc306K1tvYguMNw5ubsz38bP5yr9p5WSpJY39VPXV2/XrMsPX7Cc+/bdmnX5kzqwfocS69bQoAVvasf3S2U7kHdcp+C0ERcrpXPrgF3QSIef4Jv1bl/1uHmm209ueJoDHzzeVT3PCdyQKGWJrV5J1c9sojlXj5Ek7Zj5mzo9d4uSGqYcvQCVpAYDO2nnnOUq3JsjSdr42Ryd8Z/LtOHTWXIU/vtvFBltlTU2+vDBQTrlNEmq0ryu6vc7R4vueUcNB3b250/1SOcza+mzZ3roulG/HBtumTzd/kkJUZo1tm9QXtCUxt1jgjf7vD2/SJI0f8TrhnVaSnPP9acpbechvTOh/HOh5HkOtG5SRd++0cc0Q1X5IgfKW0Zi3Rpqfl0fZS3fGJgfdQoWi0WfP9tD52fP0pJVWW618TQHrurXSM/c2d6b8ALCV32B9v93veRy6Zuud0mS4mpUOTrtVPnizgNX/pSUEK1ZY/uq+9DvlLW/yK02nubAmw930sAgGqLlWIHY/qeaVt45IxDatqyuiS/31BX3/ySHo/zOgKfbPy42UjPfvkD1axv/BLsv+oNS2f262t3byGmzHy1ySVJR9sk3juNqVVXtbqdr0b3v+ONneuy2y1sobechvfTJarfm9zQHmtavpBlvnR+0I3yE+zWhJI17opvS9xTo598z3Jrf0xy4qEd9vXp/R29C8zl/Xxc2HtRde1dsUtayw29Lu5xO2fYdOimO5LOaKTa5sv6evdxfP9VtcbFW/fBuX3Ub8p3S3XwI1tMceO7uDhrcNzge+CzN6GFttXVXrsZP3+zW/J7+/vatkzXx5Z5B8cCHr86FZTnV/VOXy6UIa6Ss8TGyFxQpulKCCjL8/1Z5eSIiLPr6lV7qeev3+nODe/F4mgO3DGquR24J3qH8rx3QRGm7Dunxd9wr+Hr6++ulJOj7d/sqNiY4SylGXxMYfU14RHD21OBzO+csV+aStbrqrw911apxqt29jVa+NNHosCqsclK05o3rr45tfF+kG3ZFC417opsiIow/kZfmyMk9bcrhJ6h2zPxNCanVldQwxaP5HLaSoxc0krT3j81KrPfvv6fLJUVXPvzB5aikeBUdyD1pODtJanZtL23+KjBDRhyrTfNq+vmjC1WzWqxPlxsRYdFHT3XXLZe18OlyvZVQJ1mFew7I5fj3aeW89Gwl1Ek+br7EOsnK27X333l27T1unsS6NXTxvFd09dqPVXyoQBs+nV3uNIs1Ul1euV1LHnr/uPUHi2subKIvnj9PVqtv99VqlWP047j+at86ufyZg4C7xwRf7fPBwmKx6L+PdNZ/rjvN58tu27Kafv7wQlWv4tvji7/4IgfKXYbFoi6v3q6loz8KmrxIiD9ckD63fUr5M3vo+oFN9Pmz5wVtodNXfQFrXIyaXdNLf7zw1dE2R24KlHfM2PPbesMv8Js3rKz5nwxQnZrxPl/2W6M6624/HF98IRDb/1TTpOA5Z1zaq6Emv9pL0T4uRFRKjNKc9/qp61m1fLpcb/miP3iqfl2V5vVUtO+Qeoy9VxfNeVk9P35QifVPfpu16VU9teunlSoq5ea3ESwWi16452y/fD+rdZMq+uWjC5WS7Pvjiy9wTXhYbIxVM946Xxd0qePzZV/ep6G+frVX0BQ6/X1dWKV5XTmKS9T7s1G6eO7L6vbfuxRT/eTvUza7tpfSJs8/aUhUozSsk6T5nwxQozpJPl/2C/d00Kgg/z7f4fsX3XTLIN+/cdX5zJqa+0E/VUoM3LdxT8VX+0BSwxRdNOclDfzhBbUY0vfo35/q/umBdTu09oPvdMWyd3XlivfVethALf2/j/z1Uz1SpVKM5n3QX+f4YVi9EVe21PuPB/8oN6OHtdWzd/n+AcUm9ZL06ycDguKhp9IEwzVBMFwTShS6wkbymU1UpUV9fX3WME1sO0wZC1ar80vDjA7LJ6pVjtFPH16oe284zScfIU1KiNIHj3fVe491DdobW5L7J3d35zui9a0X6u/Z/w5DNX/Ea+r50YO64vex6j9tjBb+5205S46/qKnRoYViKido59wVvvhpHjuzRXWtmHCp+ner65PlNa6bpJ8/7K+b/dBJNFrerr2a3ucBTTzjNkXGRKnBhR3Lndb2/iu14/ulOrjZ/WFCA+2aC5towScD1bKRb76h1Ouc2lox4RJTjb3s6b5+hKf7fLf/3qVLfnpVXV69vdSLXiNERFj0+kMd9dmz56pKkm8uwEZe1UoLPh2omiZ5m0/yTQ6Ut4zThl+krN83aN9fW/3wC7xXKTFac97vp1G3nOmTB1TiY616a1RnjX+mR9Dc2CqNr/oCSQ1TVJyTpzPuvkwDZ72o/lPHqHa3NqWu88RjRrBo2aiKlk+4RJf2auCT5dWvnaC5H/TTndcE77Clgdj+5eWGO/3EQLm0V0Mt+fwitWlW1SfL63pWLS3/6hJ1a+f7IrqRTtWvs1gjVLvb6Vr1+teaccGD2v3LKp33wf0nzdfs6p7a/GXgixmnYrFY9OzdHTTx5Z5KruqbB1RuHtRciz+7SHVqJfhkef7ANeG/EuKj9N1bF+ipke188gBcTHSkXr7vHE18uWdIfqOzrGs/S2SkUrufoSUPva/p5z+ogsx9R7/ndYQ1LkaNLumqzV/9ZEToZWpSr5KWfXmxru7nmzevateI14y3ztfDNwd3keuIyMgIjXuym95/vKtPPr1gsUj333i6fhzXPyiHb66Ifau3alK74ZpxwUP66eaX1OLGC9TwosNvOJ/q/mlivZpqcGFHTel8p75uP1zrPvhOPd6/18ifcpzqVWL180cX6p7rfXN/tFJilD58spveHd0lqO+PHmGxWPTobW017c0+Skn2zXX8dQOaaNmXl6ihH4rovhIM1wTBIjjft4PPNbmyhzIWrVHxocOvcadN+kXnT3jM4Kh8Jz7Oqtce7KTLejfUiDGLtDYtx6vlDDi3nt79vy5BUaW/cMazqtS49DHASxtH2Bfa3H2ZkhqmaPHgw99qs0RG6Mx7rtDPt7ysPb+tV/Uzm6j3+Ec0rdd9su3/91sYza7ppS1fzzf0bZ+6KQma+c4F+nTaZj38+u/ae8DzIXOioyI04sqWeu7uDkoIgm9yHSs/PVtxtarKEhlx9N85sU6y8tOzj5svLz1blY55aiOxbo2T5pEke0GRtk1dpMaXdde2aYtOOS2l82lKqJOsVjf3kyUyUlFJcbpi2bua0f+RUoexMEqnM2vqj4mX6smxf+jNL9bJVuz504XVKsfomTvba/iVLYPubU5/HBM83ed/GPS48tOzZbFGqt3D16j7m3dq3vXPef2bfMliseiGi5qpd8dU3fn8Eo++2XSs5g0qa+zoLurV0fghS08UiBw4lSot6qnBgI76YdDjXq3L32KiI/XcfzpoUO8GGvb0QreH7TjR+Z1TNXZ0VzWpZ3whN1B9AYs1Qon1aipn8y6teO4LVTu9kS6Y+Jim9rj3uGHLPMkXI6Qkx+ub13vrq++36v5Xlyozu9DjZVitFt06qIVevPdsw59cDobtf6pptgO5bvUTA6ld62Qtn3CJxrz/p179bLUKizzvC1ROitYTI87S3de2DrqbOr7oD56qX5e/K1v71mw7+q2GtK/nq9Pzt8pijTz61kZK59MUGROt3cd8ryuYDO7bWOd1qK27X1yiSbO3uTW09Yka103S26M6q3/3er4P0ENcE3omKipCj484S5f0rK9hTy3SsjV7y29UinPbp+j9x7uqZaMqvg3QB/x9XZifnq2MxWtVkHm4H7V18q86/6vj7x01vKizcjbu1MFSvv9itOSqsfrqpZ668oJG+s+Lv2nXnnyPlxERYdGNFzXVaw92NF2Bx2KxaNgVLdW3Sx3d/sxi/bDQu210etOqev/xrurSNjjeaD6WL/aBkrx/+4gFGfu1bepC1erYSttnLDnl/dMGAzrpwIa/VbjngCRpy4Sf1em5WxURZTXsQZ8TxcdZ9fpD/9wffWaR1nl5f3TgufX07uguqpdi/P1RT13cs4G6tUvRvS/9pv/NTJPT6XlnoH7tBP33kc66pKdvHqKriGC/JihtmGujUOgKE7l/71HdXu20dux0OUvsqnt+B+Vs3Gl0WD7XrV2KVn9zmX75PUPvTlyvqT/vkN1+6gNa5aRoDbmoqUYMbqVWjasEJlA3fH/R/51yutNW4tbJ3d1OwGkjLlaDCztqzuCnjo7ZXe30RoqrVfXod+D2rUpTQcY+VTu9kTJ+/UuSZI2PVaOLu+i7/g9X/EdXkMVi0U2XNte1FzbRlLnb9c7EdVr8Z/nfbGmQmqgRV7bUzZc2D9q3N4r2HdL+1dvU5PJzj46lm5+x/7gxqKXDrx5fOO0Z/fnKJBXuzVGLGy/QtqmHC1lJDVOUt2uvXHaHIqKsqt//HO1fv6PcaT9c+u+FzZEhLiafMzJAv9wzcbFWvXjvOXropjP06bTNGjtpvdJ2ln+z7ZzTa2jkVa00uG8jxcUG56nRV8eEI7zZ548sy2V3aN2473TZord89fN8JrVmgr55vY827zio977eoE+mbir3G36RkRZd1KO+Rl7VSr07pgZdkfOIQOTAqc4ZqeeeocR6NXX54sPbPa5GFXV+eYTialbVxs/m+OpnVtjZp9fQHxMv1aKVe/TuxPWaPHe7SuynvumWGB+lGwY20e2DWwXVB5YD1RfIT8+W0+HQ1ikLJEn712xT3t9ZqtqqvjIWHP7mTWn5EowsFouuHdBEV1zQUFN/2qGxkzboFze+2VK3VoKGXdFCt17WQrVrBMcQZcGw/fev3V7mtOJDBeX2E40QHRWpMXe21/03nq7x0zdr7KQN2ri9/Avws1pW1x1Xt9LV/RoH3QNPR/iiP3iqfl36TyvV4bEbFJ9STQWZ+1WndzvlbE4/bmiyZtf20pZJP8vlDL7hrI+oWT1OE17qpefvztX7kzfoo283Kbuch+AsFunC7vU08qpW6tulTtAUObkm9M6ZLarrty8u0rLVe/XuxPWaOHtbuQ/Bxcdade2FjXX74FZqF8RDl/v7unD7jMVqdm0vRSXGqSSvUHV6t9P+dduPW3aza3sH3dtcJ7qsT0NdfF59zZj/t8ZOWq+5S3aX26Z2jXjddlkL3XZ5C9VNCd43Od3RIDVJ37/bV+vSDui9rzdo/PTNOpRXcso2VqtFg3o11MirWqlHh5SgHabOF/tAXM0qKtx7UHK5ZE2IVd0+7Y/m9Knun+b+vUdNr+4pa3ys7AVFqnt+ex3ckh40Ra5jdW+fojXfXKaflx2+PzrtF/fujw69uJlGDG4ZlIV+T1SrHKPxz/bQmDvba9yUjRo3ZaP27Dv1Q3AWi3R+5zoaeVUrDeheT1ZrePUFvL0mOHK9GAyC824ePNL5pWGq27u94mpW0flfjVZJXqG+6XKXurwyQjvnLNfOOcu14ZNZqtKsri7+8RU5Sxwq3JujJQ+9f3QZF//4qmKrV1JUUpyuXPG+Mhev0YK7gu8GpjssFot6npOqnuekqqDQrr827dfyddnasC1Hn0zdpIIihxLirHrn0S5q37q6WjaqEjQHL0+4e3J3Z77Wwweq0aCumjP46aNPrUiHD3LxtaqqcrM6Org5XUkNU5TUoJYOpf3bSWx0SRftX7ddB7eU33EMlJjoSF07oImuHdBE+3KK9Mf6fVqxLls7dufpsxmbVVDkUGK8VZ+OOVftWyerQWpi0HbijrX4offV7Y071Obuy1SSV6iF9xz+APix+3re31la+cok9Z9++AOQmYvXauPncyVJtbudrla3XCiXwymLNVIZC1brr9cnlzvNjKpXidX9Q9rovhtP187MfK1Yl60/1u/Ta5+tUUGRXQlxVj1665lq3zpZ7Vsn+2yIGyO5e0yQvNvnrXExioiKPDp/o0HdtG/NtoD9Pk81a1BZrz7QUS/de7Y2bj+oFeuytWrjfo2dtP7oeeC5uzuow2nJOrN5taC9qekJX+TAqZaxcXvmcQWtflOe0rpx3+nvWcE3jJ3FYlG3dinq1i5FHz9t11+bDmjFumyt25qjj7/deDQH3hrVWe1bJ6tVoypBPURhWXzVF7Dtz1XGwjVKPe9Mpf+0Uon1aiqxfs2jQ5uVlS/BLDoqUoP7Ntbgvo2Vc8h2tC+wdVfucX2Bj58+V+1bV1ejOkmm6AscKxDb/1TTnHZHuf1EI1WpFKP/XH+67r7uNO3OKtDyddlasS5br44/3BeIj7Vq1K1nqH2rw32BYH3Y6UQV7Q+eir3QpiUPf6A+n4+SLBYV5xZo/ojXj06PSopX/Qs7alrP+/zz43ysUd0kvXDP2Xru7g7atONwX+DPDfv17sR1R88Dz9zZXu1bJ6tty2pKSgiO7894gmvCslksFnU8o6Y6nlFTHzzRTas379eKdfu0Nu2APvrm377AGw91UvvW1XVa06qKjjLHEIX+vC7MT8/WX//9RhfOeFYup0sFmfu1+MH3jq67UpNUVTut4UmjggQjqzVCg3o31KDeDXUwt1grNxzuC6TtPKTx0//tC3z4ZHe1b52sxnWTgvaBN2+1blJV/32ks157oKPWb83RivXZ+mvTfr3/9Yaj+8CL956t9q2SdWaLakH70OeJKroPNBjQSS2G9JXL7pDFGqkdM5Zoy4TDha5T3T/9+/ulSm7bRBfNflEOW4nsBTb9esebBvwLuMdisahXx1T16nj4/uiqTfu0Yt2+kLs/eir1aydqzJ3t9dTIdkrbeUgr1mVr5YZ9evurf/sCT9/RTu1bJ+usltUNH9HBG0ZfEwQTi8vlzcv88LeSgiJ90eR6o8Nw23Vp/1NUfPDfKK7b5yulZxWoTs147Zp3jdHhSKrYtq7UJFXd3rhDMVWTjp7cczb8Len4E/yp5ouvXU2D//hAh7Znyv7P69uOYrtmDhglSWp0aVedcfdlcjldskRY9Ndb32rbtwuPxnDh9Ge16Yt52jLx55PiC8a8CMYcKI3ZjgFScG7vE4X69nfnmLBv9Vav9vnE+jXV88MHZYmMkMUi5e7I0rLHPj7uA79S8OeBGXLA3+eF8nLgVMs4VlmFLnLAc0b3BSQpsX5NdX1tpGKrJcnldGnV619rx8yl5fYTjn3gynYg9+gDV0cEYz6EUg74e/uXN628fqIUfDkQjNu/LPQH/SNYc8DI44A/rwml4MuLYM2BE3EM8B+z5IC/mOn3m20/YB8wh2D9/Wa9JqjoNWF+fr4SEw8Pk5mXl6eEBO/eqqXQFaQ4kPtHMB7IzLatPRGMeRGMOVAaM+ZFMG7vE7H9/S/Y88AMOWDm7S+RA94w+zY/lWDMB3IgsIItB4Jx+5fFjHkRbNu7NMGaA2bc3u4KtrwI1hw4kRlzIti2dVnMkgP+Yqbfb7b9gH3AHIL195st390VqEJXaL2PCAAAAAAAAAAAgLBBoQsAAAAAAAAAAACmRKELAAAAAAAAAAAApkShCwAAAAAAAAAAAKZkNToAlM4aF6Pr0v5ndBhus8bFGB2CaZltW3uCvPCeGfOC7e07Ztz+R5AHFWfm7S+RA94w+zY/FfLBPeQASmPGvGB7e8+M29td5IV3zJgTbGv4mtn2A/YBVITZ8t1dgdovKHQFKYvFoqj4WKPDQACwrVEa8iK8sf3DG9s//LDNQQ6gNORFeGF740TkBMB+gPBCvlcMQxcCAAAAAAAAAADAlCh0AQAAAAAAAAAAwJQodAEAAAAAAAAAAMCUKHQBAAAAAAAAAADAlCh0AQAAAAAAAAAAwJQodAEAAAAAAAAAAMCUKHQBAAAAAAAAAADAlCh0AQAAAAAAAAAAwJQodAEAAAAAAAAAAMCUKHQBAAAAAAAAAADAlCh0AQAAAAAAAAAAwJQodAEAAAAAAAAAAMCUKHQBAAAAAAAAAADAlCh0AQAAAAAAAAAAwJQodAEAAAAAAAAAAMCUKHQBAAAAAAAAAADAlCh0AQAAAAAAAAAAwJSsRgeA0rlcLslmMzoM98XEyGKxGB0FAAAAAAAAAAAIIxS6gpXNJvvgIUZH4TbrpPFSbKzRYQAAAAAAAAAAgDDC0IUAAAAAAAAAAAAwJQpdAAAAAAAAAAAAMCUKXQAAAAAAAAAAADAlCl0AAAAAAAAAAAAwJQpdAAAAAAAAAAAAMCUKXQAAAAAAAAAAADAlCl0AAAAAAAAAAAAwJQpdAAAAAAAAAAAAMCUKXQAAAAAAAAAAADAlCl0AAAAAAAAAAAAwJQpdAAAAAAAAAAAAMCUKXf/Yvn27PvroI40YMULt27dXdHS0LBaLhg4danRoAAAAAAAAAAAAKIXV6ACCxRtvvKE333zT6DAAAAAAAAAAAADgJt7o+kdycrIuvPBCPfHEE5oxY4ZGjhxpdEjwIYfDqUUr96iwyC5JKrE7DY4IQKBl7C1Qkc0hSSqyOZSbX2xwRAACyel0acmqY/oCJU65XC6DowIQSFn7Co/rC+QcshkcEYBAcrlcWrZ679G+QDF9AYSh1Zv2q9B2eB+wFTvkcHB/DOElbeeh4/YBW7HD4IjgKxS6/jF69GjNnDlTTz75pAYOHKiqVasaHZJPzM/OUvSMSXotbUOZ80TPmKRLly4IYFSBk3PIphc/XqWmA75WtyHfaf+hwze2s/YXqdN10/XZ9M2c1IEQt2jlHg1+4CfVv2CC9h08fENr30GbUnt/pZHPLNLGbTnGBgjAr3Lzi/Xq+NVqftHX6nLDMX2BA0XqcPU0ffTNRpWU0BcAQtmy1Xt13SO/qO75x/cF6vSZoGFPLdTaLQcMjhCAPxUU2vXfL9aq9aVT1PG66Uf7AnsPFKntlVP13qT13OhESHM4nBo/bbM6XjtdZ1zxrfYfPLwPZOfY1GzgZL348SodzOVBUIQul8ul6T/v0AXDf1DTAV8ftw/Uv2CCHn1zuTL2FhgcJSqKQhdC1o7duep8www98sZybd+dd9L0pav3asjoX3X5fT8efaILQGh5/fM16jbkO309Z5vsjuOf1swrsGvspA1qd9U0/bBgp0ERAvCnjL0F6j50ph54dZnSduaeNP2P9ft065MLdfHdc5VXUGJAhAD87f2vN6jzDTP05fdpJ43qUFBk17gpG9X+6qn6Zt52YwIE4Fd79xfqvFtm6j8v/qYN2w6eNP2vTft1+zOL1XfELG70IyQVFtl12b0/auhjv2rZmr0nTd+WnqtH3liuLjfO0M7Mk++dAWbndLp01/NLdMl/5mnukt0nTc/aX6TnP1qldldN1Z8b9hkQIXyFQhdC0v6DNvUdMbvUjuyJpv38t254dL6cToYsAELJuMkbdN/LS8udr6DIrkH3ztOilXsCEBWAQDmUV6x+t8/Wqo37y5131qJduurBn2RnaGMgpHw5M00jxiwqt59vK3bqqgd/0rzf0gMUGYBAKCi0a8Cdc/T7muxy552/PFOD7pmn4hLe7ELocDpdum7UL5r+y9/lzrsuLUcXDJ+lAwzrixDz8Ou/650J68udLzO7UBcMn6Wtuw4FICr4A4UuhKRXx6/Wxu3lF7mOmDJvu+Yu4cIWCBW5+cW675Xyi1xH2Iqduuv5JYzRD4SQdyas11+byi9yHfH9gl1u3QQAYA6FRXbd9cISt+e3O1y68zn6AkAo+fCbjW4VuY74+fcMTfhhqx8jAgJr1qJd+vbHHW7Pv2HbQb3++Ro/RgQE1oZtOXpl/Gq35997oEij31rhx4jgTxS6wkSBw6Fsm63UP6GmuMShD7/Z6HG7dyeWX90HYA7/+y5NeQWeDUm6csM+LVt98lAOAMzH4XDqva89P6/TFwBCx9dztmn/Qc+udTZuP6ifl2X4KSIAgeRyubw6r9MXQCjxJp/HTeH7tQgd703a4HGbyXO3a8++Qj9EA3+j0BUmnt64VqlzppX6J9TMXpSurP1FHrf77ted2pfjeTsAwWf89M1etftsxhYfRwLACPOXZ+rvjHyP2/24dDffJgBChLfndG/7EACCy7LVez0a5eWIpav3auO2HN8HBATY3v2F+t6Lb1FnZhdqLkP5IgS4XC59NsPzfl2J3akJP6T5ISL4m9XoAMJBhw4dlJmZ6VGbuIgIrWvb2Wcx3Fq/sS5PrVfqtP6/za/w8ps3b65CZ3A88ZEXc7aUMNDjdk6nS63P7KIoR5YfokKwyKhynxRRWRmZGapbt67R4cBPjmxnT338+beaNnawHyJCsOAYEB4Kos+UEi/zqm37jr0V7eDiPpRxHAgPeyrfKUXW8LjdxG/m6Mfx1/khIgQLjgHhoTCqlZR0tVdtu/W8SDH2bT6OCMEkHI4DJZG15Ko80qu21w29Swm25T6OCMEkHPYBp6J0oNpor9qOfuo1vfzIHB9HhLI4j6kpdOvWTStXrvRqORS6AiAzM1Pp6Z7dMImPjJTa+i6GpomJ6l2jlu8WeILdu3erwBEkH22t1lRK8K5p1p5MycZwJSEtySFFSE6Hw+P9EiaS6JCiPW9WVFhIXoQ6jgHhoUo9KdG7pnv37pUKyY2QxnEgPMTbpUjPm9lsReRFqOMYEB4q1ZKSvGuanb1Xyic3Qlo4HAdiJHn+7KckKefAfuUcCNF/FxwWDvuAJUqq5l3TvLxc5WWG6L9LkNuzZ4/XbSl0BUBKSorHbeIizDWqZGpqatC80VUUZdE+bxq6nKpdI14Rrjq+DglBJCMyUk5JEZGRql2HbR2q9lpyVexFjyYhxqYq5EVI4xgQHmzWCLn/6fl/uFySpJTqMYqkLxDSOA6Eh+zIfHnzNeL4qCJVJS9CGseA8FAcGaG90uHzu8XiXqN/5q1VLVrWKuRGKAuH44DDEqdMl1OyeH5/sXpli2LjQ/PfBYeFwz4gSRnOfDkjPH8bonK8Q4kh/O8SbJxOpzIyDr94UquW9y/qUOgKgOXLPX/d11VUJPvgIX6Ixj82bdokS2ys0WFIkkpKnGrYf6J2ZxV41O6KCxrr61f5Pk+oq9vnK6VnFah2Sm3tWrPL6HDgJx99s1G3PrnQ43a/Tn1e7VqP80NECBYcA8KD0+lS84u+VtrOXPcbWSzq362uvn+Xj9CHOo4D4WHCD2m65uFfPG43+6vH1K3dO74PCEGDY0B4cLlcOvOKb7V68wH3G1ks6t6uln799C//BYagEC7Hgcvunadvf9zhUZu6tRK07Y+fZbWa6wF8eCZc9oGHXlumlz9d7VGbmOhIpf36papXCY773OEgPz9fiYmHh2RZuNDze3lHcNRCyImKitCwy1t43G7kVa38EA0AI1zTv4kqJ3k2dmGnM2qoXetkP0UEIJAiIiy6fbDn53X6AkDouKxPQ9Ws5tkNijbNqqrrWf4b7h1A4FgsFq/O6/QFEEq8yefhV7agyIWQMfzKlm6/1HvE1f0aU+QyKY5cCEn33nC6zmju/rBlQy5upvPOru3HiAAEUnycVWP/r4vb8yfEWfXOo+7PDyD43T64lTq2qeH2/Fde0EgXdq/nx4gABFJ0VKQ+eKKb2zc3YqIj9N5jXWXx9G4IgKB106XN1aOD+5+SGHBuPV1xfiM/RgQEVu+OqbphYFO352/bspr+c91pfowICKwm9SrpydvbuT1/nZrxeubO9n6MCP5EoesfixYtUnJy8tE/r732miRpwoQJx/39okWLDI4U7qiUGK3Z7/VVu1bVy533hoFN9cETXNQCoeaaC5vowye7KTLy1Pt2laRoff/OBbzNBYSY+Dirvnv7AnU+s2a5815xfkN99uy5ioigLwCEkkt6NtD/njtPUeU8mZ4Yb9X0/56vLm15mwsIJTHRkZr6Rh+3HmodcG49TXypJ2+yIKRYLBZ9+FQ3XTegSbnztm+drFlj+ykpwbORUYBg99jwtnr01jPLna9haqLmjeuvuimef9MLwYFvdP2jpKRE+/btO+nvbTabbDbbcfOZSY/kmiq+aPAp5ylvulmlJMdrwacD9dmMzXp34vqTxua+oEsdjbyqlS4+rz5FLiBE3XJZC519eg299eVaffF9mgqLHEen1agaq1sva6Hbr2qpeimJBkYJwF+Sq8bqpw/764uZaXpnwnqt3HB8X6/XObV1++BWuqxPQ4pcQIi6dkATtW1ZTW9/tU6ff7dFeQX2o9OqVY7RzZc21x1Xt1LDOkkGRgnAX6pUitHs9/pqwg9b9c6E9Vq2Zu9x07u3q6WRV7XSFec3osiFkBQdFanPn+uhK85vqLGTNmjO4vTjprdpVlV3XN1aNwxsqvg4bhMj9FgsFj17dwdd0KWO3v5qnb79aYccDtfR6Q1TE3X74Fa69fIWqlY5xsBIUVEWl8vlKn82BJqrqEj2wUOMDsNt1knjZYkN3vFLXS6X1mw+oMx9hbJGWtS4bpIapHIxG46OfHCzTs147Zp3jdHhIIByDtm0ZssB5RfaVTkxWme1qq6Y6Eijw0KAcQwIXy6XS+u35mj33gJFRljUIDVRjetWMjosGIDjQPg6lFes1ZsPKK+gRJUSo9S2RXXFxXJTL9xwDAhvG7blKH1PgSwWqX7tRDWtT18gHIXzcWB7eq62pefK7nAppXqcTm9WlYe/w1A47wOZ2QXatP2gioodql4lVm1bVFNkJA86GCk/P1+JiYcfQM/Ly1NCgndv1dGrR1iwWCxq07ya2hgdCADDVKkUo27t3B+jH0BosVgsat2kqlo3qWp0KAAMUikxWl3PYnhCIJy1bFRFLRtVMToMwDAN6yTxFjPCWkpyvFKS440OA35AuRIAAAAAAAAAAACmRKELAAAAAAAAAAAApkShCwAAAAAAAAAAAKZEoQsAAAAAAAAAAACmRKELAAAAAAAAAAAApkShCwAAAAAAAAAAAKZEoQsAAAAAAAAAAACmRKELAAAAAAAAAAAApkShCwAAAAAAAAAAAKZEoQsAAAAAAAAAAACmRKELAAAAAAAAAAAApkShCwAAAAAAAAAAAKZEoQsAAAAAAAAAAACmZDU6AJQhJkbWSeONjsJ9MTFGRwAAAAAAAAAAAMIMha4gZbFYpNhYo8MAAAAAAAAAAAAIWgxdCAAAAAAAAAAAAFOi0AUAAAAAAAAAAABTotAFAAAAAAAAAAAAU6LQBQAAAAAAAAAAAFOi0AUAAAAAAAAAAABTotAFAAAAAAAAAAAAU6LQBQAAAAAAAAAAAFOi0AUAAAAAAAAAAABTotAFAAAAAAAAAAAAU6LQBQAAAAAAAAAAAFOi0AUAAAAAAAAAAABTotAFAAAAAAAAAAAAU6LQBQAAAAAAAAAAAFOi0AUAAAAAAAAAAABTotAFAAAAAAAAAAAAU6LQBQAAAAAAAAAAAFOi0AUAAAAAAAAAAABTshodAErncrkkm83oMNwXEyOLxWJ0FAAAAAAAAAAAIIxQ6ApWNpvsg4cYHYXbrJPGS7GxRocBAAAAAAAAAADCCEMXAgAAAAAAAAAAwJQodAEAAAAAAAAAAMCUKHQBAAAAAAAAAADAlCh0AQAAAAAAAAAAwJQodAEAAAAAAAAAAMCUKHQBAAAAAAAAAADAlCh0AQAAAAAAAAAAwJQodAEAAAAAAAAAAMCUKHQBAAAAAAAAAADAlCh0AQAAAAAAAAAAwJQodAEAAAAAAAAAAMCUKHQBAAAAAAAAAADAlCh0SXK5XFq0aJEefvhhdenSRdWqVVNUVJRq1aqlgQMHavr06UaHCAAAAAAAAAAAgBNYjQ4gGPz000/q06ePJMlisahJkyZq3LixtmzZopkzZ2rmzJm6+eab9eGHH8pisRgcLQAAAAAAAAAAACTe6JJ0+I2uxo0b66233lJWVpY2b96s5cuXa9++fXr99ddlsVj08ccfa+zYsUaH6rH52VmKnjFJr6VtKHOe6BmTdOnSBQGMCgisPzfs07CnFqpOn6+0e2+BJCk7p0gzfvlbDofT4OgAAIC/rd1yQHc8u1j1zp/wb1/gQJG+mbdddjt9AQAAQt3GbTm658Xf1KDvv32BvQeKNHHWVhWXOAyODgBQUbzRJemcc87Rhg0bFBUVddzfR0ZG6p577tGGDRv0/vvv64MPPtDIkSMNihKAp3Lzi3X9qPma/svfJ02zFTt18d1z1bR+JU19o49Oa1rVgAgBAIA/FRTaddPjv2rS7G0nTbOVOHX5fT+qQWqivnmtt9q1TjYgQgAA4E+2YoeGPbVQn83YctK04hKnrn7oZ6XWjNeUV3ur05k1DYgQAOALvNElqVKlSicVuY7Vt29fSdLGjRsDFRKACiootOv8YbNKLXIda8vfh9RtyHdau+VAgCIDAACBYCt2aMCdc0otch1rx+489bh5pv5Ylx2gyAAAQCCUlDg16J55pRa5jrU7q0C9bv1ei//cE6DIAAC+RqHLDUVFRZKk+Ph4gyMB4K4HX1umpav3ujVvTm6xLr1nHsMYAgAQQh5/Z4V++T3DrXnzCuy65D/zGLoIAIAQ8vxHq/TDwl1uzVtoc+jS/8xTQaHdz1EBAPyBQpcbJk6cKEnq3r27wZF4r8DhULbNVuofINTkHLLp02mbPWqz5e9DmrXIvQ4wAAAIbgWFdn0w2bPRGHbtyde3P+7wU0QAACCQikscenfieo/a7D1QpAmztvopIgCAP/GNrnJ8//33mjZtmiTpoYceMjga7z29ca2e3rjW6DCAgPhsxhYVFHn+FNa7E9drwLn1/RARAAAIpAmztiont9jjdu9OXK+r+jX2Q0QAACCQvv1xh/bsK/S43bsT1+vmQc39EBEAwJ8odJ1CWlqabrjhBknS3XffrS5duni1nA4dOigzM9OjNnEREVrXtrNX6yvNrfUb6/LUeqVO6//b/Aovv3nz5ip0MuwbgsP+hEFSTFuP282av151697i+4AABI2MKvdJEZWVkZmhunXrGh0OAD/JiR8gxZ7jcbsFy3dwbABCHH0BIDwcjDtfiuvmcbsVa7NUp249WeTyQ1RAcOBciGDiPKam0K1bN61cudKr5VDoKkNmZqb69eun/fv364ILLtArr7xSoWWlp6d71CY+MlJq6/UqT9I0MVG9a9Ty3QJPsHv3bhU4+KYBgkS9EinG82ZOl9XjfRWAySQ5pAjJ6XCwvwOhrE6xFOt5M5eiODYAoY6+ABAeatukOC/aWSK0e/ceyVXi85CAoMG5EEFqz549Xrel0FWKI8WtLVu2qGvXrvr2228VFRXl9fJSUlI8bhMXYa7Pp6WmpvJGF4LGgViLCrxoFymbUurU8Xk8AIJHRmSknJIiIiNVm/0dCFk58RHK96KdxVWkVI4NQEijLwCEh0NxVuV609BlV2pqTVl8HRAQRDgXIpg4nU5lZGRIkmrV8v5FHQpdJzh06JD69eun1atXq127dpo5c6bi4+MrtMzly5d73MZVVCT74CEVWm8gbdq0SZZYLx6bBfxg2s87dOl/5nncbtg1nfTu6F1+iAhAsKjb5yulZxWodkpt7VrD/g6Eqh9/260+w37wuN31F5+hz57j2ACEMvoCQHj4bVWWOt8ww+N2l/Vpqimvc2xAaONciGCSn5+vxMRESdLChQu9Xo65Xhvys4KCAg0cOFC///67WrVqpdmzZ6ty5cpGhwXAQwO611O9lASP290+uJUfogEAAIHWq2NttWjoeT9+5FX0BQAACAUdz6ihs1pW97gdfQEAMCcKXf8oLi7WoEGDtGDBAjVp0kTz5s1TcnKy0WEB8ILVGqHRw9p61ObSXg3Upnk1/wQEAAACymKx6LHhbT1qc37nVHU8o4Z/AgIAAAFlsVj0+Ii2HrXpelYt9epY2z8BAQD8ikKXJIfDoWuvvVZz5sxR3bp1NW/ePKWmphodFoAKGHZFSz188xluzdulbU19/lwPP0cEAAAC6boBTfX0He3cmrddq+qa9HIvWSx8kQMAgFBxaa+GevWBc9ya9/SmVTX1jT70BQDApPhGl6RJkyZpypQpkqTo6Ghdf/31Zc47efJkpaSkBCq0CuuRXFPFFw0+5TzlTQfM6oV7zlbjukl6dtyf+jvj5E/SJ8RZddOlzfXSvWcrLpbDIQAAoeax4WepQe1EPfXeSm3ddfIn6eNiI3XjRc30yv3nKDE+yoAIAQCAP913YxvVqZmgx9/5Q5t2HDxpekx0pK7p31ivP9hRVSrFGBAhAMAXuLMryWazHf3vrVu3auvWrWXOW1RUFIiQAPjIsCta6pZBzfX9gl2auWCncnJtSoiLUvtW1XX9wKaqlBhtdIgAAMCPbry4ma4f2FRzFqdr+i87dOBQseJiI3Vm82q68eJmqspNLQAAQtpV/RprcN9G+mlphr75cbv2H7QpNiZSpzetqqGXNFP1KrFGhwgAqCAKXZKGDh2qoUOHGh0GAD+JjIzQRefV10Xn1Tc6FAAAYICICIv6daurft3qGh0KAAAwgMViUe9OqerdiU+VAEAo4htdAAAAAAAAAAAAMCUKXQAAAAAAAAAAADAlCl0AAAAAAAAAAAAwJQpdAAAAAAAAAAAAMCUKXQAAAAAAAAAAADAlCl0AAAAAAAAAAAAwJQpdAAAAAAAAAAAAMCUKXQAAAAAAAAAAADAlCl0AAAAAAAAAAAAwJQpdAAAAAAAAAAAAMCUKXQAAAAAAAAAAADAlCl0AAAAAAAAAAAAwJQpdAAAAAAAAAAAAMCWr0QGgDDExsk4ab3QU7ouJMToCAAAAAAAAAAAQZih0BSmLxSLFxhodBgAAAAAAAAAAQNBi6EIAAAAAAAAAAACYEoUuAAAAAAAAAAAAmBKFLgAAAAAAAAAAAJgShS4AAAAAAAAAAACYEoUuAAAAAAAAAAAAmBKFLgAAAAAAAAAAAJgShS4AAAAAAAAAAACYEoUuAAAAAAAAAAAAmBKFLgAAAAAAAAAAAJgShS4AAAAAAAAAAACYEoUuAAAAAAAAAAAAmBKFLgAAAAAAAAAAAJgShS4AAAAAAAAAAACYEoUuAAAAAAAAAAAAmBKFLgAAAAAAAAAAAJgShS4AAAAAAAAAAACYEoUuAAAAAAAAAAAAmBKFLgAAAAAAAAAAAJiS1egAUDqXyyXZbEaH4b6YGFksFqOjAAAAAAAAAAAAYYRCV7Cy2WQfPMToKNxmnTReio01OgwAAAAAAAAAABBGGLoQAAAAAAAAAAAApkShCwAAAAAAAAAAAKZEoQsAAAAAAAAAAACmRKELAAAAAAAAAAAApkShCwAAAAAAAAAAAKZEoQsAAAAAAAAAAACmRKELAAAAAAAAAAAApkShCwAAAAAAAAAAAKZEoQsAAAAAAAAAAACmRKELAAAAAAAAAAAApkShCwAAAAAAAAAAAKZEoUvS9OnTdfvtt+ucc85RnTp1FBMTo6SkJLVt21aPPvqosrOzjQ4RAAAAAAAAAAAAJ7AaHUAweO211zR//nxFR0crNTVVZ5xxhrKysvTXX39p1apV+vDDDzVnzhy1bdvW6FABAAAAAAAAAADwD97oknTzzTfrxx9/VG5urrZt26bff/9dO3bs0KpVq3T66adr7969uvbaa40OEwAAeOlQXrE+mLxBB3OLJUm5+SXavOOgwVEBAAAAABAYW3cd0vMfrlLOP9fFeQUlyjlkMzgqwDcodEm68cYb1atXL0VHRx/3923atNFHH30kSVq/fr3Wr19vRHgVMj87S9EzJum1tA1lzhM9Y5IuXboggFEBABAYBw7ZNPKZRarT5ysNf3qR8grtkqRD+SVqftFk9R0xS8tW7zU4SgAAAAAA/GPl+mxdOHK2mg74Wo/+d7ny/7kuPphXojp9JmjYUwuVfaDI4CiBiqHQVY5WrVod/e+CggIDIwEAAJ7IzC5QtyHfaeykDcorsJc6z5zF6epx80x9v2BngKMDAAAAAMC/5v2Wrm5DZuqHhbvkcp08vaDIrnFTNqrLjTO0MzMv8AECPkKhqxyLFi2SJCUkJKhFixYGRwMAANxRUuLUwDvnal1aTrnzFtkcuuK+H7Vq4z7/BwYAAAAAQACsSzugQffMU0FR6Q9+HmvzjkMacMccFdnKnxcIRhS6SuF0OpWRkaHPPvtMQ4cOlSQ999xzSkxMNDYwAADglqk/79CKddluz19oc+j5j1b5MSIAAAAAAALnpU9Wlzm6SWlWbz6gSbO3+TEiwH8odB3jvffek8ViUWRkpFJTUzVkyBDVrVtXM2bM0N133210eBVS4HAo22Yr9Q8AAKHmnQnrPG4zZe52ZexlmGIAAAAAgLllHyjShFlbPW737sT1fogG8D+r0QEEk9q1a6tr166y2+3auXOnMjIy9Ndff+nLL79U9+7dVblyZaND9NrTG9fq6Y1rjQ4DAAC/23/QpvnLMz1uZ3e49N38v3XbFS39EBUAAAAAAIExa9Eu2YodHrdbunqvdmflK7Vmgh+iAvzH4nKV9hk6SNLq1at1xx13aMGCBeratasWLlzo1XI6dOigzEzPbrjFRURoXdvOXq3vWPOzs3T+kl90a/3Gujy1Xqnz9P9tvi6sWVtTO3b3ej2t/1yiQqfT6/YAAPiKPaKa9lT5j1dtKxXMVVKRd+d7AAAQ/DKq3CdnRGVFOA+qds5rRocDAIBf5MV00sGE/l61rXnwHUU5snwcEVC6I5+RkqS2bdtq5cqVXi2HN7pOoU2bNpo5c6YaN26sRYsWad68eerTp4/Hy8nMzFR6erpHbeIjI6W2Hq+qTE0TE9W7Ri3fLfAEu3fvVoHD86cEAADwOWuBVMW7podysnVon2fnbAAAYCJJDilCcjocHl+nAwBgGtX2Sl6+lJWVmS4VU+hC4O3Zs8frthS6ypGUlKQePXpoypQpWrVqlVeFrpSUFI/bxEWY6/NpqampvNEFAAgKLkUo05kvZ4QHvXqXS7JYVD3RptjYOv4LDgAAGCojMlJOSRGRkapdh3M+ACA02azFypaOXuu6y+IsVO0acbKIcyQC49g3umrV8v5FHQpdbrDb7ZIkh5dvLC1fvtzjNq6iItkHD/FqfUbYtGmTLLGxRocBAIAkadSbv+uFj/5yv4HFouYNKmv9tF8VEeH+RQAAADCXun2+UnpWgWqn1NauNbuMDgcAAL9wuVw684pvtXrzAY/a/efGDnr9oe3+CQooRX5+vhITEyXJ609HSZK5XhsywP79+zV//nxJh8eIBAAAwW/4FS1ljfSsYHXH1a0ocgEAAAAATM9iseiua1p71CYiwqIRV7b0U0SAf4V9oWv58uV6/PHHtWXLlpOmrVy5Uv3791dOTo7atGmj3r17GxAhAADwVMM6SRr3ZDe357+kZ33dcXUrP0YEAAAAAEDg3HJZC13Vr5Hb8789qrNaNKriv4AAPwr7oQvz8vI0ZswYjRkzRjVr1lS9evUUGRmpXbt2affu3ZKk5s2ba+rUqYqMjDQ4WgAA4K6hlzRXZIRFtz21SLbisocfvn5gE334ZHdFRob98z8AAAAAgBAREWHR58+ep6T4KH34zaYy54uyRuidRzvrtit4mwvmZXG5XC6jgzDSgQMH9Pnnn+vnn3/WmjVrtGfPHhUVFalatWpq06aNBg0apJtvvlmxAf7+lNm+0WWdNJ5vdAEAgtLe/YX6eOomfTB5o7buypUkJSVE6ep+jXX74JY6q1WywRECAIBAOfKNrjo147Vr3jVGhwMAQECs3rRfYyet15c/bNXB3GJJUoPURN12WQvdcllzpSTHGxwhwtWx3+jKy8tTQkKCV8sJ+0JXsKLQBQCA79ntTtkdTsXGhP1L7QAAhCUKXQCAcFdks8saGSGrlVFNYDxfFbq4ywMAAMKG1UpnHgAAAAAQvnjwE6GIOz0AAAAAAAAAAAAwJQpdAAAAAAAAAAAAMCUKXQAAAAAAAAAAADAlCl0AAAAAAAAAAAAwJQpdAAAAAAAAAAAAMCUKXQAAAAAAAAAAADAlCl0AAAAAAAAAAAAwJQpdAAAAAAAAAAAAMCUKXQAAAAAAAAAAADAlCl0AAAAAAAAAAAAwJQpdAAAAAAAAAAAAMCUKXQAAAAAAAAAAADAlCl0AAAAAAAAAAAAwJavRAaAMMTGyThpvdBTui4kxOgIAAAAAAAAAABBmKHQFKYvFIsXGGh0GAAAAAAAAAABA0GLoQgAAAAAAAAAAAJgShS4AAAAAAAAAAACYEoUuAAAAAAAAAAAAmBKFLgAAAAAAAAAAAJgShS4AAAAAAAAAAACYEoUuAAAAAAAAAAAAmBKFLgAAAAAAAAAAAJgShS4AAAAAAAAAAACYEoUuAAAAAAAAAAAAmBKFLgAAAAAAAAAAAJgShS4AAAAAAAAAAACYEoUuAAAAAAAAAAAAmBKFLgAAAAAAAAAAAJgShS4AAAAAAAAAAACYEoUuAAAAAAAAAAAAmBKFLgAAAAAAAAAAAJgShS4AAAAAAAAAAACYktXoAFA6l8sl2WxGh+G+mBhZLBajowAAAAAAAAAAAGGEQlewstlkHzzE6CjcZp00XoqNNToMAAAAAAAAAAAQRhi6EAAAAAAAAAAAAKZEoQsAAAAAAAAAAACmRKELAAAAAAAAAAAApkShCwAAAAAAAAAAAKZEoQsAAAAAAAAAAACmRKELAAAAAAAAAAAApkShCwAAAAAAAAAAAKZEoQsAAAAAAAAAAACmRKELAAAAAAAAAAAApkShCwAAAAAAAAAAAKZEoQsAAAAAAAAAAACmRKELAAAAAAAAAAAApkShqwzjxo2TxWKRxWLReeedZ3Q4AAAAAAAAAAAAOAGFrlJkZmbqoYceMjoMAAAAAADgI7n5xSqxOyVJDofT4GgAAADgKxS6SnHXXXfp0KFDGjhwoNGhVNj87CxFz5ik19I2lDlP9IxJunTpggBGBQAAAABAYPy5YZ+GPbVQKT2/Utb+IklS5r4idblhhv733RbZih0GRwgAAICKoNB1gunTp2vy5Mm644471L59e6PDAQAAAAAAXnC5XHpu3J86a/BUjZuyUQVF9uOmL1mVpRsena+uN36nzOwCg6IEAABARVHoOkZubq7uuOMOpaam6plnnjE6HAAAAAAA4KWXP1mt/3trRbnzrViXrQuGz9LB3OIARAUAAABfo9B1jFGjRmnXrl164403VKlSJaPDAQAAAAAAXtjy9yE9/Mbvbs+/evMBjXl/pR8jAgAAgL9Q6PrHkiVLNHbsWPXv319XXnml0eH4XIHDoWybrdQ/AAAAAACEkvcmrfe4zcdTN6nwhOENAQAAEPysRgcQDEpKSnTbbbcpJiZGb7/9ttHh+MXTG9fq6Y1rjQ4DAAAAAAC/cjic+mTaZo/bHThUrG9/3KFrBzTxQ1QAAADwFwpdkl544QWtXbtWzz77rBo3buzz5Xfo0EGZmZketYmLiNC6tp19FsOt9Rvr8tR6pU7r/9v8Ci+/efPmKnQ6K7wcAAAAAAAqwmGJ0/6qj3jVdsR/HtdDwyt+jQwAAIDyOY+pKXTr1k0rV3o3lHTYF7o2btyoZ599Vq1atdKDDz7ol3VkZmYqPT3dozbxkZFSW9/F0DQxUb1r1PLdAk+we/duFTgcfls+AAAAAABusVaSqnrXNDc3T7lZnl2/AwAAoOL27NnjdduwL3Tdfvvtstlseu+99xQVFeWXdaSkpHjcJi7CXJ9PS01N5Y0uAAAAAIDhXIrUbpddsnh+y6NyYoQSo+r4ISoAAACcyOl0KiMjQ5JUq5b3L+qEfaHrjz/+UEREhAYPHnzStLy8PEnS4sWLjxarNm3apEqVKnm0juXLl3scl6uoSPbBQzxuZ5RNmzbJEhtrdBgAAAAAAOj6Ub/oi5lpHrWJjorQ5t+/VI1qcX6KCgAAAMfKz89XYmKiJGnhwoVeLyfsC13S4arhqV6LKykpOTrdyVtLAAAAAAAEtZFXtfK40HXlBY0ocgEAAJiQucbH84OcnBy5XK5S/zzxxBOSpB49ehz9uypVqhgbMAAAAAAAOKXOZ9bU1f0auz1/tcoxemLEWX6MCAAAAP4S9oUuAAAAAAAQWiwWiz4Z010Xn1e/3HmrV4nR9+9coGYNKgcgMgAAAPgaQxeGuB7JNVV80cnfHztWedMBAAAAADCb2Birvnm9t8ZN2ai3v1qntWk5x01PjLfqxoua6YEhbdSobpIxQQIAAKDCKHQBAAAAAICQFBkZoRGDW2n4lS21+M8sbdiWI1uxQzWqxalf1zpKSog2OkQAAABUkMXlcrmMDgIncxUVyT54iNFhuM06abwssbFGhwEAAAAAAAAAAEwgPz9fiYmJkqS8vDwlJCR4tRy+0QUAAAAAAAAAAABTotAFAAAAAAAAAAAAU6LQBQAAAAAAAAAAAFOi0AUAAAAAAAAAAABTotAFAAAAAAAAAAAAU6LQBQAAAAAAAAAAAFOi0AUAAAAAAAAAAABTotAFAAAAAAAAAAAAU6LQBQAAAAAAAAAAAFOi0AUAAAAAAAAAAABTotAFAAAAAAAAAAAAU6LQBQAAAAAAAAAAAFOi0AUAAAAAAAAAAABTsrhcLpfRQeBkLpdLstmMDsN9MTGyWCxGRwEAAAAAAAAAAEwgPz9fiYmJkqS8vDwlJCR4tRyrL4OC71gsFik21ugwAAAAAAAAAAAAghZDFwIAAAAAAAAAAMCUKHQBAAAAAAAAAADAlCh0AQAAAAAAAAAAwJQodAEAAAAAAAAAAMCUKHQBAAAAAAAAAADAlCh0AQAAAAAAAAAAwJQodAEAAAAAAAAAAMCUKHQBAAAAAAAAAADAlCh0AQAAAAAAAAAAwJQodAEAAAAAAAAAAMCUKHQBAAAAAAAAAADAlCh0AQAAAAAAAAAAwJQodAEAAAAAAAAAAMCUKHQBAAAAAAAAAADAlCh0AQAAAAAAAAAAwJQodAEAAAAAAAAAAMCUKHQBAAAAAAAAAADAlCh0AQAAAAAAAAAAwJSsRgeA0rlcLslmMzoM98XEyGKxGB0FAAAAAAAAAAAIIxS6gpXNJvvgIUZH4TbrpPFSbKzRYQAAAAAAAAAAgDDC0IUAAAAAAAAAAAAwJQpdAAAAAAAAAAAAMCUKXQAAAAAAAAAAADAlCl0AAAAAAAAAAAAwJQpdAAAAAAAAAAAAMCUKXQAAAAAAAAAAADAlCl0AAAAAAAAAAAAwJQpdAAAAAAAAAAAAMCUKXQAAAAAAAAAAADAlCl0AAAAAAAAAAAAwJQpdAAAAAAAAAAAAMCUKXZKGDh0qi8Vyyj8bNmwwOkwAAAAAAAAAAAAcw2p0AMGkWbNmqlmzZqnT4uPjAxwNAAAAAAAAAAAAToVC1zEeffRRDR061OgwfGp+dpbOX/KLXmh9hu5r0rLUeaJnTNKFNWtrasfuAY4OAAAAAAAAAADAewxdCAAAAAAAAAAAAFOi0AUAAAAAAAAAAABTYujCY0yePFlTp07VoUOHlJycrE6dOumGG25QjRo1jA4NAAAAAAAAAAAAJ6DQdYyZM2ce9/+//vprPf7443rvvfd0/fXXGxSVbxQ4HMq22YwOAwAAAAAAAAAAwGcodElq3ry5Xn/9dfXs2VMNGzZUVFSUVqxYoWeeeUZz5szRjTfeqKpVq2rAgAFGh+q1pzeu1dMb1xodBgAAAAAAAAAAgM9YXC6Xy+gggpXL5dKgQYM0bdo0NW3aVJs2bZLFYvF4OR06dFBmZqZHbeIiIrSubWeP13Wi+dlZOn/JL7q1fmNdnlqv1Hn6/zZfF9asrakdu3u9ntZ/LlGh0+l1ewAAAAAAAAAAED6cTqcyMjIkSW3bttXKlSu9Wg5vdJ2CxWLRiy++qGnTpmnLli1avXq1zjjjDI+Xk5mZqfT0dI/axEdGSm09XlWZmiYmqneNWr5b4Al2796tAofDb8sHAAAAAAAAAAChac+ePV63pdBVjhYtWqhatWrav3+/Nm/e7FWhKyUlxeM2cRERHrcxUmpqKm90AQAAAAAAAAAAtxz7RletWt6/qEOhyw1RUVGSJLvd7lX75cuXe9zGVVQk++AhXq3PCJs2bZIlNtboMAAAAAAAAAAAgAnk5+crMTFRkrRw4UKvl2Ou14YMsHfvXmVlZUmS6tata3A0AAAAAAAAAAAAOIJCVzleffVVuVwuVa5cWWeffbbR4QAAAAAAAAAAAOAfYV/omjt3rh555BGlpaUd9/cFBQV6+umn9dJLL0mSRo0apejoaCNCBAAAAAAAAAAAQCksLpfLZXQQRpo6daoGDRokSapdu7bq1Kkjp9Op9evXq7CwUJI0bNgwvffee7JYLAGLy2zf6LJOGs83ugAAAAAAAAAAgFuO/UZXXl6eEhISvFqO1ZdBmVH79u01evRoLVmyRFu2bNG6devkcDhUq1Ytde7cWbfddpt69+5tdJgAAAAAAAAAAAA4QdgXuurVq6cxY8YYHQYAAAAAAAAAAAA8FPbf6AIAAAAAAAAAAIA5UegCAAAAAAAAAACAKVHoAgAAAAAAAAAAgClR6AIAAAAAAAAAAIApUegCAAAAAAAAAACAKVHoAgAAAAAAAAAAgClR6AIAAAAAAAAAAIApUegCAAAAAAAAAACAKVHoAgAAAAAAAAAAgClR6AIAAAAAAAAAAIApUegCAAAAAAAAAACAKVHoAgAAAAAAAAAAgClR6AIAAAAAAAAAAIApWVwul8voIHAyl8sl2WxGh+G+mBhZLBajowAAAAAAAAAAACaQn5+vxMRESVJeXp4SEhK8Wo7Vl0HBdywWixQba3QYAAAAAAAAAAAAQYuhCwEAAAAAAAAAAGBKFLoAAAAAAAAAAABgShS6AAAAAAAAAAAAYEoUugAAAAAAAAAAAGBKFLoAAAAAAAAAAABgShS6AAAAAAAAAAAAYEoUugAAAAAAAAAAAGBKFLoAAAAAAAAAAABgShS6AAAAAAAAAAAAYEoUugAAAAAAAAAAAGBKFLoAAAAAAAAAAABgShS6AAAAAAAAAAAAYEoUugAAAAAAAAAAAGBKFLoAAAAAAAAAAABgShS6AAAAAAAAAAAAYEoUugAAAAAAAAAAAGBKFLoAAAAAAAAAAABgShS6AAAAAAAAAAAAYEpWowNA6Vwul2SzGR2G+2JiZLFYjI4CAAAAAAAAAACEEQpdwcpmk33wEKOjcJt10ngpNtboMAAAAAAAAAAAQBhh6EIAAAAAAAAAAACYEoUuAAAAAAAAAAAAmBKFLgAAAAAAAAAAAJgShS4AAAAAAAAAAACYEoUuAAAAAAAAAAAAmBKFLgAAAAAAAAAAAJgShS4AAAAAAAAAAACYEoUuAAAAAAAAAAAAmBKFLgAAAAAAAAAAAJgShS4AAAAAAAAAAACYEoUuAAAAAAAAAAAAmBKFrhNMnTpVF110kWrXrq2YmBjVrl1bPXv21Msvv2x0aAAAAAAAAAAAADiG1egAgkVxcbGuu+46TZ48WZLUuHFj1atXT3v27NGCBQu0evVqPfjggwZHCQAAAAAAAAAAgCModP3j1ltv1eTJk9WvXz+9/fbbatKkydFpOTk5+vXXXw2MDgAAAAAAAAAAACdi6EJJc+bM0eeff66OHTtqxowZxxW5JKlKlSq6+OKLDYquYuZnZyl6xiS9lrahzHmiZ0zSpUsXBDAqAAAAAAAAAACAiqPQJen111+XJI0ePVpWKy+5AQAAAAAAAAAAmEHYV3UKCws1b948RUREqGfPnlq6dKk++eQTbdmyRYmJierUqZNuvfVWJScnGx0qAAAAAAAAAAAAjhH2ha5Vq1bJbrerRo0aevvttzVq1Ci5XK6j06dNm6YXX3xR33zzjXr27GlgpAAAAAAAAAAAADhW2A9dmJGRIUk6cOCAHnnkEV144YVau3atbDab/vrrL/Xq1Us5OTm67LLLtGvXLoOj9V6Bw6Fsm63UPwAAAAAAAAAAAGYU9m905efnS5LsdruaNGmib7/9VlFRUZKkNm3aaMaMGWrSpIkyMzP1xhtv6JVXXjEyXK89vXGtnt641ugwAAAAAAAAAAAAfCbsC12xsbFH//vOO+88WuQ6Ij4+XrfffrueeOIJzZo1y6tCV4cOHZSZmelRm7iICK1r29njdZXl1vqNdXlqvVKn9f9tfoWX37x5cxU6nRVeDgAAAAAAAAAACH3OY2oK3bp108qVK71aTtgXuqpWrXr0v1u1alXqPEf+ftu2bV6tIzMzU+np6R61iY+MlNp6tbpSNU1MVO8atXy3wBPs3r1bBQ6H35YPAAAAAAAAAABC0549e7xuG/aFrpYtWx797+jo6FLnOfLWl8PLQk5KSorHbeIizPX5tNTUVN7oAgAAAAAAAAAAbnE6ncrIyJAk1arl/Ys6YV/oqlOnjurXr6+///5bW7duVc+ePU+aJy0tTZJUt25dr9axfPlyj9u4iopkHzzEq/UZYdOmTbIcMwwkAAAAAAAAAABAWfLz85WYmChJWrhwodfLMddrQ34yePBgSdL48eNPmuZyufTpp59Kknr16hXIsAAAAAAAAAAAAHAKFLokPfjgg6pUqZIWLFigMWPGHB2i0G636+GHH9aqVasUExOje++91+BIAQAAAAAAAAAAcASFLkk1a9bUhAkTFBMTo8cff1y1a9dWx44dlZKSopdffllWq1UffvihWrVqZXSoAAAAAAAAAAAA+IfF5XK5jA4iWKxfv17PPfecfvzxR2VnZ6tatWrq0aOHHn74YbVr1y6gsZjtG13WSeP5RhcAAAAAAAAAAHDLsd/oysvLU0JCglfLsfoyKLNr1aqVPv/8c6PDAAAAAAAAAAAAgBsYuhAAAAAAAAAAAACmRKELAAAAAAAAAAAApkShCwAAAAAAAAAAAKZEoQsAAAAAAAAAAACmRKELAAAAAAAAAAAApkShCwAAAAAAAAAAAKZEoQsAAAAAAAAAAACmRKELAAAAAAAAAAAApkShCwAAAAAAAAAAAKZEoQsAAAAAAAAAAACmRKELAAAAAAAAAAAApkShCwAAAAAAAAAAAKZEoQsAAAAAAAAAAACmRKELAAAAAAAAAAAApmRxuVwuo4PAyVwul2SzGR2G+2JiZLFYjI4CAAAAAAAAAACYQH5+vhITEyVJeXl5SkhI8Go5Vl8GBd+xWCxSbKzRYQAAAAAAAAAAAAQthi4EAAAAAAAAAACAKVHoAgAAAAAAAAAAgClR6AIAAAAAAAAAAIApUegCAAD/z959h9lR1m0Afja76QmEJJAAgYQWEnoJPfRepClF/QREkSJ2wYYiVURB+FQ6IlhQitJLKAoERAhEeigBAoQkkAKkt93vj3zEALvJ7ubsOTub+74uL8lOed/d+Z05M/PMvAMAAAAAhSToAgAAAAAAoJAEXQAAAAAAABSSoAsAAAAAAIBCEnQBAAAAAABQSIIuAAAAAAAACknQBQAAAAAAQCEJugAAAAAAACgkQRcAAAAAAACFJOgCAAAAAACgkARdAAAAAAAAFJKgCwAAAAAAgEISdAEAAAAAAFBIgi4AAAAAAAAKSdAFAAAAAABAIQm6AAAAAAAAKCRBFwAAAAAAAIUk6AIAAAAAAKCQBF0AAAAAAAAUkqALAAAAAACAQhJ0AQAAAAAAUEiCLgAAAAAAAApJ0AUAAAAAAEAhCboAAAAAAAAoJEEXAAAAAAAAhSToAgAAAAAAoJAEXQAAAAAAABSSoAsAAAAAAIBCWuaDrtdffz1VVVWN+t9pp51W6e4CAAAAAADw/2oq3YFK69SpU7bbbrsGp0+dOjVPP/10kmTbbbctV7cAAAAAAABYgmU+6Orbt2+GDx/e4PRzzz03Tz/9dPr165ddd921jD0DAAAAAABgcZb5oQuX5JprrkmSfOELX0i7dv5cAAAAAAAArYXkZjGeeOKJPPfcc0mSI488ssK9AQAAAAAAYFGCrsW4+uqrkyRbbbVV1l133Qr3BgAAAAAAgEUJuhowd+7cXHvttUmSo446qrKdAQAAAAAA4BMEXQ24/fbbM3HixHTs2DGHHXZYpbsDAAAAAADAx9RUugOt1TXXXJMk2X///bPCCiss1bqGDBmS8ePHl6JbAAAAAAAAhVdbW7vwv4cOHZqRI0c2az2CrnpMmjQpt99+e5LSDFs4fvz4jB07dqnXAwAAAAAA0NZMmDCh2csKuupx7bXXZs6cOenbt2/23HPPpV5f3759S9ArAAAAAACAtqG2tjbjxo1LkvTp06fZ6xF01ePqq69Oknz+859PdXX1Uq9vxIgRS70OAAAAAACAtmL69Onp1q1bkmT48OHNXk+7UnWorXj++ecXBlOlGLYQAAAAAACAliHo+phrrrkmSbLZZptlgw02qHBvAAAAAAAAaIigaxG1tbX54x//mCQ58sgjK9wbAAAAAAAAFkfQtYh77703Y8eOTfv27fO5z32u0t0BAAAAAABgMQRdi7j66quTJPvuu2969+5d4d4AAAAAAACwOFV1dXV1le4EAAAAAAAAy47p06enW7duSZJp06ala9euzVqPJ7oAAAAAAAAoJEEXAAAAAAAAhSToAgAAAAAAoJAEXQAAAAAAABSSoAsAAAAAAIBCEnQBAAAAAABQSIIuAAAAAAAACknQBQAAAAAAQCEJugAAAAAAACgkQRcAAAAAAACFJOgCAAAAAACgkARdAAAAAAAAFJKgCwAAAAAAgEISdAEAAAAAAFBIgi4AAAAAAAAKSdAFAAAAAABAIQm6AAAAAAAAKCRBFwAAAAAAAIUk6AIAAAAAAKCQBF0AAAAAAAAUkqALAAAAAACAQhJ0AQAAAAAAUEiCLgAAAAAAAApJ0AUAAAAAAEAhCboAAAAAAAAoJEEXAAAAAAAAhSToAgAAAAAAoJAEXQAAAAAAABSSoAsAAAAAAIBCEnQBAAAAAABQSIIuAAAAAAAACknQBQAAAAAAQCEJugAAAAAAACikmkp3gPrV1dUls2dXuhuN17FjqqqqKt0LAAAAAABgGSLoaq1mz868Q4+sdC8area6q5NOnSrdDQAAAAAAYBli6EIAAAAAAAAKSdAFAAAAAABAIQm6AAAAAAAAKCRBFwAAAAAAAIUk6AIAAAAAAKCQBF0AAAAAAAAUkqALAAAAAACAQhJ0AQAAAAAAUEiCLgAAAAAAAApJ0AUAAAAAAEAhCboAAAAAAAAoJEHX/5s4cWK+973vZcMNN0zXrl3TsWPH9O/fP1/4whfy5JNPVrp7AAAAAAAAfIygK8mLL76YDTfcMOeee26ef/75rLzyyhk8eHAmT56cP/7xj9lyyy3zpz/9qdLdBAAAAAAAYBE1le5Aa3D88cdn/PjxWXfddXPTTTdl0KBBSZLp06fn29/+di677LIcd9xx2XvvvdOzZ88K95amqqury7+ffjfX3jk64yfNTHW7qqy9+nL54gEDs0a/7pXuHgAAAAAA0ExVdXV1dZXuRCVNnTo1yy+/fOrq6nLLLbfkU5/61Eemz5s3LyuvvHImTpyYv//97znwwAPL0q+6WbMy79Ajl3o9D0x8J7v/6585Z72N8u21BtU7T4dbr8s+K62cm7bavtnt1Fx3dao6dWr28i3l/n+/ne+e91hGjpr0iWlVVck+26+WX39/G4EXAAAAAACU0fTp09OtW7ckybRp09K1a9dmrWeZH7pw9uzZ+TDrW3PNNT8xvaamJv3790+SzJ07t6x9Y+lcP+y17HncXfWGXElSV5fc/uCb2fp/bsnzo6eUuXcAAAAAAMDSWuaDrt69e2fVVVdNkjzyyCOfmD558uSMGjUq7dq1y2abbVbu7tFMTzw/Mf/zg39m3vwlP7D4zuRZ2fuEu/PBtDll6BkAAAAAAFAqy3zQlSRnn312qqqqctJJJ+Wqq67KhAkTMn369Dz88MPZb7/9Fr6ra6211qp0V2mkc696OnPm1jZ6/jfGTc8fbnulBXsEAAAAAACUWk2lO9AaHHHEEVl++eVz5pln5uijj/7ItP79++eaa67JF77whQr1rjRmzJ+fibNnV7obZTF+4oz87d7Xm7zcxX99ISccNjhVVVWl7xQAAAAAAFBygq4kdXV1GT16dN599920a9cuq6++epZbbrm88sorGTNmTC699NIMGTIkgwcPrnRXm+30F5/L6S8+V+lulMU9/xrbqCELP+650e/ljXHT0n+V7i3QKwAAAAAAoNQEXUmOP/74XHrppdliiy0ybNiwDBw4MEkyc+bMnHrqqfnFL36RbbbZJs8880xWW221Jq9/yJAhGT9+fJOW6dyuXZ7fZJsmt9WQL6++Zj69Sv193/vRB5Z6/QMHDszM2sYPFdiSpnXcKum6T7OW3XKbndJ+/oQS9wgAAAAAAFhU7SKZwtChQzNy5MhmrWeZD7qeeuqpXHbZZWnfvn2uv/769O/ff+G0zp0759xzz82TTz6Z++67L2effXYuvvjiJrcxfvz4jB07tknLdKmuTjZpclMNWrtbt+y6Yp/SrfBj3n777cyYP7/F1t8kK7yTdG3eou+MfyuZ805p+wMAAAAAADRowoTmP4CyzAddDz/8cOrq6rLOOut8JORa1B577JH77rsvjz/+eLPa6Nu3b5OX6dyuXbPaqpRVVlml1TzRNbd6Rt5Jkrq6pAnv22pXOz19V+yUqqzaYn0DAAAAAAAWPNE1bty4JEmfPs1/UGeZD7qmTp3a6HlnzZrVrDZGjBjR5GXqZs3KvEOPbFZ7lfDSSy+lqlOnSndjoe2OuDWP/KdpT2adfMw2+dk3xrRQjwAAAAAAgA9Nnz493bp1S5IMHz682esp1mNDLeDD93G9/PLLGTOm/pBj2LBhSZJ11123bP1i6Xzj8+s3af4O7dvl2M8MaqHeAAAAAAAALWGZD7r22GOPrLTSSpk7d24OOeSQvPTSSwunzZw5MyeffHLuu+++JMkRRxxRqW7SRIfssUa+/rn1GjVvVVVyzVk7ZsCq3Vu4VwAAAAAAQCkt80MXdu3aNX/6059y4IEH5vHHH8/gwYPTv3//dO/ePa+88kpmzJiRJPnqV7+aAw44oMK9pbGqqqpywfe2To/uHXP2Ff/JvPl19c7Xo3uHXHXG9jlwlwHl7SAAAAAAALDUqurq6upPAJYxr776an71q1/l3nvvzZgxYzJv3rz07t07W265ZY455pjsu+++Ze1P0d7RVXPd1a3qHV2LGj9xRq7424v50+2j8+Lr76euLmlf0y4Xn7JtPrv3WunSeZnPewEAAAAAoKwWfUfXtGnT0rVr12atR9DVSgm6Wka/3a7N2HdmZNWVuuStez9b6e4AAAAAAMAyqVRB1zL/ji4AAAAAAACKSdAFAAAAAABAIQm6AAAAAAAAKCRBFwAAAAAAAIUk6AIAAAAAAKCQBF0AAAAAAAAUkqALAAAAAACAQhJ0AQAAAAAAUEiCLgAAAAAAAApJ0AUAAAAAAEAhCboAAAAAAAAoJEEXAAAAAAAAhSToAgAAAAAAoJAEXQAAAAAAABRSTaU7QAM6dkzNdVdXuheN17FjpXsAAAAAAAAsYwRdrVRVVVXSqVOluwEAAAAAANBqGboQAAAAAACAQhJ0AQAAAAAAUEiCLgAAAAAAAApJ0AUAAAAAAEAhCboAAAAAAAAoJEEXAAAAAAAAhSToAgAAAAAAoJAEXQAAAAAAABSSoAsAAAAAAIBCEnQBAAAAAABQSIIuAAAAAAAACknQBQAAAAAAQCEJugAAAAAAACgkQRcAAAAAAACFJOgCAAAAAACgkARdAAAAAAAAFJKgCwAAAAAAgEISdAEAAAAAAFBIgi4AAAAAAAAKSdAFAAAAAABAIQm6AAAAAAAAKCRBFwAAAAAAAIUk6AIAAAAAAKCQBF0sU+rq6irdBQAAAAAAoESq6lz5p42aMGlmbrzntYx4fmKeeH5SXnz9/cyeMz9JUlWVbLPxStl8vd7ZZqOVcsDO/dOlc02FewwAAAAAAMuG6dOnp1u3bkmSadOmpWvXrs1aj6CLNueR/0zIr//8fG689/XMnVfbqGVWWK5DvnjgwHz18MFZs99yLdxDAAAAAABYtgm64GPe+2B2vv3Lf+eqm15u9jo6dqjOGV/dLN8+YoNUVxvZEwAAAAAAWoKgCxbxwIhx+fz3/5mx78woyfq23mjF/PUXu2T1lbuVZH0AAAAAAMB/lSro8sgKhXfbA29kz+PuLlnIlSSPPv1uhh55W14e837J1gkAAAAAAJSWoItCu//fb+fT374vs+fML/m63xw/Pbt95c68OX5aydcNAAAAAAAsPUHX/3v33Xdz8sknZ/DgwencuXNWWGGF7LDDDvnzn/9c6a7RgHcnz8zhJ/8jc+bWtlgbb4ybni/88IHU1hrhEwAAAAAAWpuaSnegNXjhhRey22675e2330779u2zwQYbZNasWRk+fHgeeuih3Hfffbnyyisr3U0+5sSf/SvvTpnVpGUev3b/9O3dJeMnzsgWn72lUcs8MGJ8Lr7uhXz18PWa000AAAAAAKCFLPNPdM2fPz+f/vSn8/bbb2fo0KF544038uSTT+b555/PU089ldVXXz2/+93vcvnll1e6qyzijofezHV3v9bk5fr27pJ+fbqmb+8uTVru5PMfz/iJpXsHWCW8/c703P/vt3PHQ2/m30+/k3nzWu5JOAAAAAAAKIdlPui644478sILL6Rjx475wx/+kL59+y6ctuGGG+a3v/1tkuSnP/1p5s8v/XugaJ4L/vhsWdubMWtervjbi2Vts1T+8djbOfhb92b1Pf+aXY+5M/t+dVi2/p9bs+Y+1+Wsy/6TiU18Kg4AAAAAAFqLZT7oGj58eJJkyJAhGTBgwCem77fffunatWvefvvtPPTQQ2XuHfV56fX3c8+/3i57u5de/2KhnoKqq6vLDy58PLt8+c78/b4xmT//o+8Ze3P89Jzymyey2WE35blXplSolwAAAAAA0HzLfNA1efLkJMmqq67a4DwfTnvkkUfK0icW74+3v1KRdt+aMD3/eHxcRdpujjMu/U/OufLpJc735vjp2f3Yu/LGuGll6BUAAAAAAJTOMh909ejRI0kyduzYBuf5cNqLLxZz6Lq25t/PvFuxth+rYNtN8dpbU/PTi59s9Pzj3p2RH/16RAv2CAAAAAAASm+ZD7q22GKLJMmIESMyZsyYT0y/4447Mn369CTJlCmGd6u0urq6jHhuYsXaH/F85dpuikuufyF1dUueb1HX3f1a3pk0s2U6BAAAAAAALWCZD7oOOOCA9OvXL7Nnz87hhx+eN998c+G0xx9/PMcdd9zCf8+YMaMSXWQREybNzOT3Z1es/WcL8i6r39/8cpOXmTO3NtfeOboFegMAAAAAAC2jqq6uqc99tD3/+te/svfee+f9999PdXV11llnncyaNSuvv/56evXqlR133DF/+9vfcuCBB+bvf/97k9c/ZMiQjB8/vgV6vuyZ165nJvT4RoPTH792//Tt3aXB6X17d05NdbvMm1+b8RMbfnpp/MQZ2eKzt3zi5+1qP8jK753XtE6XWV2q83bPnzRr2W4zH87yM4eVuEcAAAAAAPBRtbW1GTduXJJkk002yciRI5u1nppSdqqottlmm4wcOTLnnHNO7r777rz66qtZYYUVctRRR+X000/P2WefnSTp27dvs9Y/fvz4xb4DjCboMDfp0fDkvr27pF+frktcTU11u0bN93G182tb/7asqkl6Nm/RadOmZ9r4Vv77AQAAAADQpkyYMKHZywq6/t8aa6yRSy+9tN5pzz33XJIFT2Y1R3MDMj5pflW3LO7ZuPETFz+8ZFOe6KpPdbv56bvqqo3pakWNq52e2nZND/KW71KbbgX4/QAAAAAAKLZFn+jq06dPs9dj6MIlmDhxYlZeeeUkyRtvvLHwv6mMurq69Nr+j5nywZxmLf/mPYenX5+ueWvC9Ky2+1+avPwBO6+emy7cvVltl9N3f/nvnHfNs01apn1Nu7wx7LDFDv0IAAAAAAClMH369HTr1i1JMm3atHTt2vSHN5KkXSk71RadcsopmTdvXg477DAhVytQVVWVzdfrXbH2K9l2Uxx36OAmL/Pp3QYIuQAAAAAAKBRBV5I77rgjDz/88Ed+9t577+Wb3/xmLr300qy44oo577zzKtQ7Pm7LDVZcJttuirVXXy4//PLGjZ5/pZ6dctbXN2/BHgEAAAAAQOkJupIMGzYsQ4cOzfLLL5+NN944G2+8cfr06ZMLL7wwq666au67776lGh+S0vqf/dauSLsrr9glu2y5SkXabo4zv7Z5vvWF9Zc438ordsmwS/fKmv2WK0OvAAAAAACgdARdSQ488MAcfvjh6d27d15++eW89tprWW+99XL66afnhRdeyIYbbljpLrKIwWv2yM5blH8Yya98et20b1+cj0xVVVXOP2nr3HnRntl3h9VSVfXR6X17d86Pj90kT/71gGy8bq/KdBIAAAAAAJZCTaU70BrstNNO2WmnnSrdDZrgG/+zfv7x+LiytdepY3WO+fS6ZWuvlPYa2i97De2X18dOzZDDb86k92end4+OGXP3YenQvrrS3QMAAAAAgGYrzuMpsIj9d1o9B+7Sv2ztnf31IVm1T9eytdcSBqzaPZ06Lgi2OnaoFnIBAAAAAFB4gi4KqaqqKhefsm16Lt+xScuNnzgjb02YnvETZzR6me027ZOvf269pnYRAAAAAABoYYYupLD69u6SP/1sp3zq68Myb15do5bZ4rO3NKmNVVbqkj+evWOqq2XCAAAAAADQ2rh6T6HtNbRf/nruLmlfU/pSXnnFLrn3sr0zYNXuJV83AAAAAACw9ARdFN7Buw3I7b/dI316dS7ZOjcb3CvDr943g9fsUbJ1AgAAAAAApSXook3YfZtV89zfD87n9llrqdbTvqZdzjhxszz6x/2zZr/lStQ7AAAAAACgJQi6aDN69eiUP52zU+6/Yu8cvOuAVFdXNXrZ7l3b56uHD84zNx6UU76yadq399EAAAAAAIDWrqbSHYBS23nLVbLzlqvkrfHTc/09r2XEcxPzxPMT8+Lr7y+cp31Nu2w0sGc2X69Xtt5opXxm9wHp3rVDBXsNAAAAAAA0laCLNqtf36751hc2WPjv2tq6zJo9P+3aJR07VKeqqvFPfAEAAAAAAK2PoItlRrt2VenSWckDAAAAAEBb4UVEAAAAAAAAFJKgCwAAAAAAgEISdAEAAAAAAFBIgi4AAAAAAAAKSdAFAAAAAABAIQm6AAAAAAAAKCRBFwAAAAAAAIUk6AIAAAAAAKCQBF0AAAAAAAAUkqALAAAAAACAQhJ0AQAAAAAAUEiCLgAAAAAAAApJ0AUAAAAAAEAhCboAAAAAAAAoJEEXAAAAAAAAhSToAgAAAAAAoJAEXQAAAAAAABSSoAsAAAAAAIBCEnQBAAAAAABQSIIuAAAAAAAACknQBQAAAAAAQCEJugAAAAAAACgkQRcAAAAAAACFJOgCAAAAAACgkARdAAAAAAAAFJKgCwAAAAAAgEISdAEAAAAAAFBIgi4AAAAAAAAKSdAFAAAAAABAIQm6AAAAAAAAKKSaSncAaDnz59fmpTEf5InnJ2bkqEmZ8sHsJMmUD2bn5797KkPWWzGbrdcrKyzXscI9BQAAAACApquqq6urq3QngNJ6fezUXHbDi7niby/m3Smzljj/zlusnBMOG5wDdu6f9u096AkAAAAAQMuaPn16unXrliSZNm1aunbt2qz1CLqgDZn03qx84+eP5s93jE5zPtmrrNQlF5y8dQ7ZY43Sdw4AAAAAAP6foAv4iJvufz3HnfFIJkyaudTrOnTPNfKbH2yTFXt2LkHPAAAAAADgo0oVdBmjDAqurq4uZ142Mgd9876ShFxJct3dr2Wrz9+a0W9+UJL1AQAAAABASxB0QcGdcel/8uPfPFny9b42dmp2/OLteX3s1JKvGwAAAAAASkHQBQX259tH59SLSh9yfWjsOzOy9wl3Z+aseS3WBgAAAAAANFebCrpef/31XHnllTnuuOOy+eabp0OHDqmqqspRRx3VqOWHDRuWvfbaK7169UqXLl2y4YYb5mc/+1nmzJnTsh2HZhj37oyc+LNHmrTM49funzfvOTyPX7t/o5cZ9dr7+fFvnmhq9wAAAAAAoMXVVLoDpXTBBRfkwgsvbNay5513Xr773e8mSfr375/VV189zz77bH74wx/mtttuy7333pvOnTuXsruwVI4/8+FM+aBpIWzf3l3Sr0/TX+h3/h+ezad3H5BtNu7T5GUBAAAAAKCltKknunr37p199tknp556am699daccMIJjVrusccey0knnZSqqqr8/ve/z+uvv56RI0dm1KhRWXvttfPII4/kBz/4QQv3Hhpv5AsTc/M/3ihbe3V1C94FBgAAAAAArUmbeqLrlFNO+ci/H3300UYtd8YZZ6Suri5HH310jjzyyIU/X2uttXLllVdmxx13zMUXX5wf/vCHWWmllUraZ2iOi/76QtnbvOvhtzL6zQ+y1mrLlb1tAAAAAACoT5t6oqs5pk6dmmHDhiVJjjnmmE9M32GHHTJw4MDMmTMnt9xyS7m7B5/wwbQ5+dMdo8vebl1dctkNo8reLgAAAAAANGSZD7pGjhyZOXPmpGPHjhkyZEi98wwdOjRJ458Qg5b072fezcxZ8yvS9j8eH1eRdgEAAAAAoD7LfND10ksvJUn69++fmpr6R3Jca621PjIvVNITz0+sWNtPvzQlc+fWVqx9AAAAAABY1DIfdE2ZMiVJssIKKzQ4z4fTPpwXKunJFyZVrO3Zc+bnudE+BwAAAAAAtA71P8K0DJk1a1aSpEOHDg3O07FjxyTJzJkzm9XGkCFDMn78+GYtCx/3bvejkvZr1Dvt8Wv3T9/eXRpctm/vzgv//817Dl9sO+MnzsgWn/3ke+l22+ugdJr3auM7DAAAAAAAH1Nb+9/Rw4YOHZqRI0c2az3LfNDVqVOnJMmcOXManGf27NlJks6dOzerjfHjx2fs2LHNWhY+Yc35Sfv6J/Xt3SX9+nRd4ipqqts1ar76TJr8XjJVPQMAAAAAUBoTJkxo9rLLfNDVmGEJGzO84eL07du3WctBfd7t0C4NxbLjJ85Y7LJ9e3dOTXW7zJtfm/ETF/+EYkPr6tVz+XRabtXGdBUAAAAAAOpVW1ubcePGJUn69OnT7PUs80HXwIEDkyRjxozJvHnzUlPzyT/J6NGjPzJvU40YMaL5HYSPOfJHD+SaW1+pd1p9Qw0u6s17Dk+/Pl0zfuLMrLb7X5rV/iP/vC0DByzfrGUBAAAAACBJpk+fnm7duiVJhg8f3uz1tCtVh4pq0003TYcOHTJ79uwGA6kP/8BbbbVVObsG9Rqyfu+Ktb1ct/ZZe/XlKtY+AAAAAAAsapkPurp3757dd989SXL55Zd/YvqDDz6Yl156KR06dMgBBxxQ7u7BJ2y+XuWCrs0G9067dlUVax8AAAAAABa1zAddSXLKKaekqqoqV111Va6++uqFPx89enS+9KUvJUmOPfbYrLTSSpXqIiw0ZP3eWalnp4q0vc/QfhVpFwAAAAAA6tOmgq6HH344vXv3Xvi/888/P0nyl7/85SM/f/jhhz+y3NZbb51zzjkndXV1OeqoozJgwIBsuummGTRoUF555ZVstdVWOeeccyrxK8EndGhfnS8fvG7Z2+3YoTpHH9S899QBAAAAAEBLaFNB19y5czNp0qSF/5s5c2aSZPbs2R/5+dy5cz+x7Mknn5y77roru+++e95///2MGjUqAwcOzFlnnZUHHnggXbp0KfevAw069pBBZR9C8PC91kyvHpV5kgwAAAAAAOpTVVdXV1fpTgBN9+1fPJpf/eG5Ji3z5j2Hp1+frnlrwvSstvtfGr1cty7t88yNB2XAqt2b2k0AAAAAAPiE6dOnp1u3bkmSadOmpWvXrs1aT5t6oguWJWeeOCTr9F+uLG394ttbCLkAAAAAAGh1BF1QUF061+TqM3dIh/aN/xiPnzgjb02YnvETZzR6mb2H9stXPjOoOV0EAAAAAIAWZehCKLi/3/d6Dj3p/sybV/qP8jYbr5Rhl+6Vbl3al3zdAAAAAAAsuwxdCCRJDtp1QP7+q93SuVN1Sde761ar5O5L9hRyAQAAAADQagm6oA3Yb8fV89T1B2W7Tfss9bo6dqjOL769Ze6+ZM9079qhBL0DAAAAAICWYehCaEPmz6/Nb//yQs696umMfafx7+FKkqqqZJ/tV8svv7NlBq3Ro2U6CAAAAAAAKd3QhYIuaIPmzavNrQ+8kctvfDHDR07I1OlzG5x3nf7L5eBdB+TYzwzKGv26l7GXAAAAAAAsqwRdQKPU1tbllTc+yMhRkzLlg9mZO682nTvWZK3Vumezwb2zfHfDEwIAAAAAUF6CLgAAAAAAAAqpVEFXu1J2CgAAAAAAAMpF0AUAAAAAAEAhCboAAAAAAAAoJEEXAAAAAAAAhSToAgAAAAAAoJAEXQAAAAAAABSSoAsAAAAAAIBCEnQBAAAAAABQSIIuAAAAAAAACknQBQAAAAAAQCEJugAAAAAAACgkQRcAAAAAAACFJOgCAAAAAACgkARdAAAAAAAAFJKgCwAAAAAAgEISdAEAAAAAAFBIgi4AAAAAAAAKSdAFAAAAAABAIQm6AAAAAAAAKCRBFwAAAAAAAIUk6AIAAAAAAKCQBF0AAAAAAAAUkqALAAAAAACAQhJ0AQAAAAAAUEiCLgAAAAAAAApJ0AUAAAAAAEAhCboAAAAAAAAoJEEXAAAAAAAAhSToAgAAAAAAoJAEXQAAAAAAABSSoAsAAAAAAIBCEnQBAAAAAABQSIIuAAAAAAAACknQBQAAAAAAQCEJugAAAAAAACgkQRcAAAAAAACFJOgCAAAAAACgkNpU0PX666/nyiuvzHHHHZfNN988HTp0SFVVVY466qgWWQ4AAAAAAIDKqal0B0rpggsuyIUXXli25QAAAAAAAKicNhV09e7dO/vss0+22GKLDBkyJHfeeWcuuuiiFlsOAAAAAACAymlTQdcpp5zykX8/+uijLbocAAAAAAAAldOm3tEFAAAAAADAskPQBQAAAAAAQCEJugAAAAAAACgkQRcAAAAAAACFJOgCAAAAAACgkGoq3YFlwZAhQzJ+/PhKdwMAAAAAAKBVqK2tXfjfQ4cOzciRI5u1HkFXGYwfPz5jx46tdDcAAAAAAABanQkTJjR7WUFXGfTt27fSXQAAAAAAAGg1amtrM27cuCRJnz59mr0eQVcZjBgxotJdAAAAAAAAaDWmT5+ebt26JUmGDx/e7PW0K1WHAAAAAAAAoJwEXQAAAAAAABRSVV1dXV2lO1EqDz/8cA444ICF/54xY0ZmzpyZjh07Lnz8LUluvvnmbLfddku9HAAAAAAAAE236NCF06ZNS9euXZu1njb1jq65c+dm0qRJn/j57NmzM3v27I/MV4rlAAAAAAAAqJw29UQXAAAAAAAArV+pnujyji4AAAAAAAAKSdAFAAAAAABAIQm6AAAAAAAAKCRBFwAAAAAAAIUk6AIAAAAAAKCQBF0AAAAAAAAUkqALAAAAAACAQhJ0AQAAAAAAUEiCLgAAAAAAAApJ0AUAAAAAAEAhCboAAAAAAAAoJEEXAAAAAAAAhSToAgAAAAAAoJAEXQAAAAAAABSSoAsAAAAAAIBCEnQBAAAAAABQSIIuAAAAAAAACknQBQAAAAAAQCEJugAAAAAAACgkQRcAAAAAAACFJOgCAAAAAACgkARdAAAAAAAAFJKgCwAAAAAAgEISdAEAAAAAAFBIgi4AAAAAAAAKSdAFAAAAAABAIQm6AAAAAAAAKCRBFwAAAAAAAIUk6AIAAAAAAKCQBF0AAAAAAAAUkqALAAAAAACAQhJ0AQAAAAAAUEiCLgAAAAAAAApJ0AUAAAAAAEAhCboAAAAAAAAoJEEXAAAAAAAAhSToAgAAAAAAoJAEXQAAAAAAABSSoAsAAAAAAIBCEnQBAAAAAABQSIIuAAAAAAAACknQBQAAAAAAQCEJugAAAAAAACgkQRcAAAAAAACFJOgCAAAAAACgkARdAAAAAAAAFJKgCwAAAAAAgEJqU0HX66+/niuvvDLHHXdcNt9883To0CFVVVU56qijGlymrq4uDz/8cL73ve9l2223Tc+ePdO+ffv06dMn++23X2655Zby/QIAAAAAAAA0Wk2lO1BKF1xwQS688MImLXP//fdnt912S5JUVVVlrbXWypprrplXXnklt99+e26//fYcffTRueKKK1JVVdUS3QYAAAAAAKAZ2tQTXb17984+++yTU089NbfeemtOOOGEJS5TV1eXNddcM7/+9a/zzjvv5OWXX86IESMyadKk/OpXv0pVVVV+97vf5eKLLy7DbwAAAAAAAEBjtaknuk455ZSP/PvRRx9d4jJbbrllRo0alfbt23/k59XV1fnmN7+ZUaNG5dJLL81ll13WqOAMAAAAAACA8mhTT3Q1x3LLLfeJkGtRe+65Z5LkxRdfLFeXAAAAAAAAaIRlPuhaklmzZiVJunTpUuGeAAAAAAAAsChB1xL89a9/TZJsv/32Fe4JAAAAAAAAixJ0LcYdd9yRm2++OUly8sknV7g3AAAAAAAALKqm0h1orUaPHp0vfOELSZKvf/3r2XbbbZu9riFDhmT8+PGl6hoAAAAAAECh1dbWLvzvoUOHZuTIkc1aj6CrHuPHj89ee+2VyZMnZ4899sgvf/nLpV7f2LFjS9Q7AAAAAACAtmPChAnNXlbQ9TEfhluvvPJKtttuu/z9739P+/btl2qdffv2LVHvAAAAAAAAiq+2tjbjxo1LkvTp06fZ6xF0LeKDDz7IXnvtlWeeeSabbbZZbr/99nTp0mWp1ztixIgS9A4AAAAAAKBtmD59erp165YkGT58eLPX065UHSq6GTNmZL/99svjjz+ewYMH5+67787yyy9f6W4BAAAAAADQAEFXkjlz5uSggw7KQw89lLXWWiv33ntvevfuXeluAQAAAAAAsBjLfNA1f/78fO5zn8uwYcPSr1+/3HvvvVlllVUq3S0AAAAAAACWoKqurq6u0p0olYcffjgHHHDAwn/PmDEjM2fOTMeOHReO85gkN998c7bbbrskybXXXpvPfe5zSZI111wzK6+8coPrv+GGG9K3b98W6j0AAAAAAMCyYdF3dE2bNi1du3Zt1npqStmpSps7d24mTZr0iZ/Pnj07s2fP/sh8i0770KuvvppXX321wfXPmjWrRD0FAAAAAABgabWpJ7oAAAAAAABo/Ur1RNcy/44uAAAAAAAAiknQBQAAAAAAQCEJugAAAAAAACgkQRcAAAAAAACFJOgCAAAAAACgkARdAAAAAAAAFJKgCwAAAAAAgEISdAEAAAAAAFBIgi4AAAAAAAAKSdAFAAAAAABAIQm6AAAAAAAAKCRBFwAAAAAAAIUk6AIAAAAAAKCQBF0AAAAAAAAUkqALAAAAAACAQhJ0AQAAAAAAUEiCLgAAAAAAAApJ0AUAAAAAAEAhCboAAAAAAAAoJEEXAAAAAAAAhSToAgAAAAAAoJAEXQAAAAAAABSSoAsAAAAAAIBCEnQBAAAAAABQSIIuAAAAAAAACknQBQAAAAAAQCEJugAAAAAAACgkQRcAAAAAAACFJOgCAAAAAACgkARdAAAAAAAAFJKgCwAAAAAAgEISdAEAAAAAAFBIgi4AAAAAAAAKSdAFAAAAAABAIQm6AAAAAAAAKCRBFwAAAAAAAIUk6AIAAAAAAKCQBF0AAAAAAAAUkqALAAAAAACAQhJ0AQAAAAAAUEiCLgAAAAAAAApJ0AUAAAAAAEAhCboAAAAAAAAoJEEXAAAAAAAAhSToAgAAAAAAoJAEXQAAAAAAABRSmwq6Xn/99Vx55ZU57rjjsvnmm6dDhw6pqqrKUUcdtdjlbrnllhx//PHZcssts+qqq6Zjx47p3r17Ntlkk/zwhz/MxIkTy/MLAAAAAAAA0Gg1le5AKV1wwQW58MILm7zc+eefnwceeCAdOnTIKqusko022ijvvPNOnn766Tz11FO54oorMmzYsGyyySal7zQAAAAAAADN0qae6Ordu3f22WefnHrqqbn11ltzwgknNGq5o48+Ovfdd1+mTp2a1157LY8//njGjBmTp556KhtssEHefffdfO5zn2vh3gMAAAAAANAUbeqJrlNOOeUj/3700UcbtdwRRxxR78833HDDXHnlldlqq63ywgsv5IUXXsjgwYOXup8AAAAAAAAsvTb1RFdLWDTYmjFjRgV7AgAAAAAAwKIEXUvw8MMPJ0m6du2addddt8K9AQAAAAAA4ENtaujCUqmtrc2ECRNyzz335OSTT06SnH322enWrVuFewYAAAAAAMCHBF2LuOSSS3L88cd/5Gebb755rrjiiuy3334V6hUAAAAAAAD1MXThIlZeeeVst9122WqrrbLKKqukqqoqTz/9dP785z/n/fffr3T3AAAAAAAAWIQnuhZxwAEH5IADDlj472eeeSZf/epXc+211+aNN97I8OHDm7XeIUOGZPz48aXqJgAAAAAAQKHV1tYu/O+hQ4dm5MiRzVqPoGsxNtxww9x+++1Zc8018/DDD+fee+/Nbrvt1uT1jB8/PmPHjm2BHgIAAAAAABTbhAkTmr2soGsJunfvnh133DE33nhjnnrqqWYFXX379m2BngEAAAAAABRTXV1d6urqkix4tVRzCboaYd68eUmS+fPnN2v5ESNGlLI7AAAAAAAAJGlX6Q60dpMnT84DDzyQJNlkk00q2xkAAAAAAAAWWuaDrhEjRuQnP/lJXnnllU9MGzlyZPbee++899572XDDDbPrrrtWoIcAAAAAAADUp6ruwwEQ24CHH344BxxwwMJ/z5gxIzNnzkzHjh3TrVu3hT+/+eabs9122yVJ/vnPf2bnnXdOkqy00kpZbbXVUl1dnbfeeitvv/12kmTgwIG58847s+aaa5bxtwEAAAAAAGBx2tQ7uubOnZtJkyZ94uezZ8/O7NmzPzLfhzbeeONceOGF+cc//pFnn302L730UmbNmpWePXtmt912y0EHHZSjjz46nTp1KsvvAAAAAAAAQOO0qSe6AAAAAAAAWHYs8+/oAgAAAAAAoJgEXQAAAAAAABSSoAsAAAAAAIBCEnQBAAAAAABQSIIuAAAAAAAACknQBQAAAAAAQCEJugAAAAAAACgkQRcAAAAAAACFJOgCAAAAAACgkARdAAAAAAAAFJKgCwAAAAAAgEISdAEAAAAAAFBIgi4AAAAAAAAKSdAFAAAAAABAIQm6AAAAAAAAKCRBFwAAAAAAAIUk6AIAAAAAAKCQBF0AAAAAAAAUkqALAAAAAACAQhJ0AQAAAAAAUEiCLgAAAAAAAApJ0AUAAAAAAEAhCboAAAAAAAAoJEEXAAAAAAAAhSToAgAAAAAAoJAEXQAAAAAAABSSoAsAAAAAAIBCEnQBAAAAAABQSIIuAAAAAAAACknQBQAAAAAAQCEJugAAAAAAACgkQRcAAAAAAACFJOgCAAAAAACgkARdAAAAAAAAFJKgCwAAAAAAgEISdAEAAAAAAFBIgi4AAAAAAAAKSdAFAAAAAABAIQm6AAAAAAAAKCRBFwAAAAAAAIUk6AIAAAAAAKCQBF0AAAAAAAAUkqALAAAAAACAQhJ0AQAAAAAAUEiCLgAAAAAAAApJ0AUAAAAAAEAhCboAAAAAAAAoJEEXAAAAAAAAhSToAgAAAAAAoJAEXQAAAAAAABSSoAsAAAAAAIBCEnQBAAAAAABQSIIuAAAAAAAACknQBQAAAAAAQCEJugAAAAAAACgkQRcAAAAAAACFJOgCAAAAAACgkARdAAAAAAAAFJKgCwAAAAAAgEISdAEAAAAAAFBIgi4AAAAAAAAKSdAFAAAAAABAIQm6AAAAAAAAKCRBFwAAAAAAAIUk6AIAAAAAAKCQBF0AAAAAAAAUkqALAAAAAACAQhJ0AQAAAAAAUEiCLgAAAAAAAApJ0AUAAAAAAEAhCboAAAAAAAAoJEEXAAAAAAAAhSToAgAAAAAAoJAEXQAAAAAAABSSoAsAAAAAAIBCEnQBAAAAAABQSIIuAAAAAAAACknQBQAAAAAAQCEJugAAAAAAACgkQRcAAAAAAACFJOgCAAAAAACgkARdAAAAAAAAFJKgCwAAAAAAgEISdAEAAAAAAFBIgi4AAAAAAAAKSdAFAAAAAABAIQm6AAAAAAAAKCRBFwAAAAAAAIUk6AIAAAAAAKCQBF0AAAAAAAAUkqALAAAAAACAQhJ0AQAAAAAAUEiCLgAAAAAAAApJ0AUAAAAAAEAhCboAAAAAAAAoJEEXAAAAAAAAhSToAgAAAAAAoJBqKt0BWNbV1dVl3szZle5Gi6jp3DFVVVWV7karpwZY1vkMUJ8i1oXtXVpqgKLVgO1fWkXb/okaWBpF3N6NpS6ap8g1YZuXTtHqwLYvraJt/0QNVJKgCyps3szZ+dNa/1PpbrSIz4/+Y9p36VTpbrR6aoBlnc8A9SliXdjepaUGKFoN2P6lVbTtn6iBpVHE7d1Y6qJ5ilwTtnnpFK0ObPvSKtr2T9RAJRm6EAAAAAAAgEISdAEAAAAAAFBIgi4AAAAAAAAKSdAFAAAAAABAIQm6AAAAAAAAKKSaSneAljNn7vw89eLkjHhuYp54fmLGTZyROXNr06F9u6zcu0s2X693hqzfOxuv2zMd2ldXurst4rW3pmbE8wt+/1GvvZcZs+alXVVVluvWIRsNXCGbD+6dLTZYMb1X6FTprtIC5s+vzXOj38sTz0/MiOcmZsy4aZk9Z37a17RL7x6dstngXtl8vd7ZfL3e6dLZ7rAtmjlrXkaOmpQRz03Mky9MyjuTZ2buvNp07FCd1fp0Xbgf3HCdFVJd3fbu/airq8vLYz5Y8D3wwsS8POaDzJw9L9XtqrLCch2zyaCeC/4G6/VOj+U6Vrq7tIC5c2vz9MuTF+4Hx74zPbPnLDgW6Nu784J94ODe2XRwr3Ts0DaPBZZ102bMXbj9R46alEnvzc68+bXp1KE6a/Trns0HL9gPDl6zR9q1q6p0d2kBEybNzOPPvpsnnp+YZ16ekqkz5qauri5dO7fP4DV6ZMj6vbPFBr2zWt9ule4qLaCuri6j35yaEc+9myeen5SXxryfGbMWHAss371DNlm3VzZfr1eGrL9iei7vWKAtmjevNs+8PDlPPD8pTzw/MW9OmL7wnGilnp2z+XoLzok2HdQrnTs5J2qLps+YmydfWLD9n3xhUia+N2vhOdGAVbotPCfeYO0VHAu0UROnzMrjz76bEf9/LPD+tDmpq6tLl041GbRGj2y+Xu9ssX7vDFi1e6W7Sgt57a2pefy5BceDL77+vuujy5j582vz7CtTFh4LfPz66IfHApsNLvb10eL2nAaNeXtqLr3+xVzxtxfz7pRZDc535d9fSpKsuEKnfPngdXPsIeum/yrF/1KbNXterrv7tVz01xfy72febXC+64e9liSprq7K/jutnhMOG5xdtlzFgV0b8O7kmfndTS/lkutG5fW3pzU43x9ueyVJ0q1L+xzxqbVz/KGDssE6PcvVTVrQqNfeyyXXjcrvb3k570+ds8T5V+vbNV/5zLr58sHrpm/vLmXoYcuaOn1O/nT76Fz01xfyzMtTGpzvL3e9miTp0L5dDtljjZxw2OBss/FKqaqyHyy6t8ZPz2U3jsrlN76Y8RNnNjjfVTe9nCTpuXzHHH3gwBx36KCstdpy5eomLWjkCxNz0V9fyJ/veDUzZs1b4vzr9F8uxx86OEcdsE5WEHwX3vz5tbn7kbG56K8v5I6H3kxdXf3z3ZQxC/97+8365ITDBufg3Qa02ZvgliXTZ8zNtXe+mouveyFPvjCpwfmuu3vBOVFNTVUO3nVATjhscHbYvK9jgTZg3LszcsXfXsxlN7yYtyZMb3C+q29ZcCzQo3uHHHXAOjnukEFZd40eZeolLemZlybn4uteyB9uG51pM+Yucf41Vu2e4w4ZlKMPGuhidxtQW1uXex9dcCxw6wNvpra2/oOBm//xxsL/3nqjFXPCYYNzyB5rpFNHl4yLbuas/14ffezZxl0fPWCn/jn+sEHZdatVHAu0Ae9M+v/ro9ePyphGXB/t3vXD66ODs/7aK5SrmyVTVVfX0GkPRTNtxtycfP5jueT6UQ2ezC5OVVVy7GcG5dxvb5HuXTuUvoNlcP2w13Li2Y/knckNB3yLs/G6PfO707bPZuv1LnHPGjZ3xqz8aa3/KVt75fT50X9M+y7lO0CeO7c2P7vyqZx1+X8yZ25ts9Zx8K4DctEp26ZPr84l7l3D1EDpTJwyK18/51+59s5Xm7V8TU1VTjpyo5x6/KaFfLqlrq4ul9/4Yk46/7F8MG3JJ7P1Gbppn1x52vYZOGD5EveuYT4DpTNj5rz86Ncj8utrn8/8+c07xDv6oIE57ztbVvwpvyLWRbm3d33eGj89x54xPHc89Fazlu/cqTqnHb9Zvn3EBhV/0lUNNM+jT72To099KC+8+l6zll91pS65+JTt8qmdVi9tx5qhaDXQGrZ/XV1drrnllXzrF49mygdLvtmnPltusGJ+d/r2Fb/AUbTtn7SOGpg1e15Ou2Rkfnn1M5k3r3nHAp/fd61c+L2t06tHGc/lCri9G6vcdTF+4oyccNYj+ft9Y5Y8cz06dqjOj47ZON8/euO0b1+5Y4Ei10Sl9wVPPD8xR//koTz90uRmLd+nV+f85gfb5DN7rFHinjVd0eqg0ts+WXAscN3dr+VrP/vXYh+AWJxNBvXMVafvkE0G9Spx75qmaNs/aR01MGfu/Pzsiqdy9hVPNfv66Kd3G5Df/qi810eXlni+jfjHY2/n6J88tNinV5akri655PpRuevht/K707fPzluuUsIetqyJU2bl+DMfzg33vL5U63nqxcnZ6n9uyQ+/tElO+comFT2oa46+26yfvf522kd+Nnf6zHzw6riMvuHBvHDlHamb37wdXGv3zEuTc+QpD2bkqIbvWG2Mv933ev45Ylx++8Ntcvjea5Wod+WzLNfATfe/nmNPf7jZQXeSzJtXl59d+VRu+eeYXH3Wjtm8jKH30npz/LR86dSHcs+/3l6q9QwfOSEbH/L3nP31IfnG59cv3FOuy/Jn4JH/TMhRP34wL4/5YKnW87u/v5S7H34rV562ffbcrl+Jelc+y2oN1NXV5fc3v5xvnvtos4PuJJk5a35O/tXj+dt9r+f3Z+xQuLv6l9XtnySz58zPKb9+Iuf/4dkG79pujLHvzMj+X78nR3xq7Vz4va0rHno31bJcA+PenZGvnDY8tz345lKt57Fn381mh92U007YLCcdtWHFQ++mWpZrYMRz7+bIUx7M86PfW6r1/On20bn30bdz2U+2y/479y9N58poWa6Ba+8Yna+e/Uizg+5kwffJT377ZG66f0yuPnOHQo56sqzWwNy5tTn90pH52ZVPNfumt2TBsMeHfPf+HLrnGrnoR9uWNfQuhWV1+ycLRjg6/sxHcuO9ry/Vev4zanK2+NzN+dGXN8mPjnF9tEiefmlyjvjRA3nqxeYF3R+68d4F10cv+tG2OXTPNUvUu5Yl6GoDrrnl5Rx96kNL9SW2qNffnpbdj70rvztt+xyx/zolWWdLemPctOz2lTuX+sLeh+bNq8vpl47MyFGT8tdf7FzIccpf/dtDeev+J5OqqnResUfWPmTHbHnaUVl+nVXzr5MurXT3Su7+f7+d/b9+T6bPXPLQTI0x+f3Z+ez3/pmXxnyQHx+7SSEf117WauCXv38mJ53/WMnW99zo9zL0yNty4/m7Zp/tVyvZelvKc69Mye7H3pVx784oyfpmzZ6fb//i33n6pcm5/NShqakp1kFtsux9Bm4Y9lo+9/1/Zu680hysj31nRvY+4e5cfMp2OfaQQSVZZ7ktSzVQV1eXk89/PL+8+pmSrfPRp9/N1v9za+64aI9ss3Gfkq23XJal7Z8sGNnhgK/fk/sfG1eydV5z6yt58oVJGXbpXll5xeIN67us1cDLY97Pbl+5M2+Ma3iIuqaYM7c2P7hwRP7z4qRcc9aOhRzOclmrgdseeCOf+c79mT1nfknWN2HSzBzwjXtz/klb5Vtf2KAk6yy3ZakG6urqctrFI3PaJSNLts4nX5iUbb5wW275390KdSP0opalGpg5a14O+e79uX0pb3ZY1HV3v5b/jJqcey/fq5Dv8lyWtn+y4FU2u33lrrzyRumuj552yX+vjxZxOMtlrQbufXRsDvzGvSW7Pjrpvdk57KR/5KUx7+dHx7T+66PFu3LFR/zxtldy5CkPlizk+tD8+XU56scP5k+3v1LS9Zba2+9Mz05H31GykGtRtz7wRj7znfsyZ25pThTKadIzr+XVGx/Kqzc8mOcuviW37/vDTB87MQM/t2s69mpb7155YMS47HvisJLtxBd16kVP5qzL/1Py9ZbDslQD511d2pDrQ7Nmz8+B37g3dz/cvOG/yuXF197Lzl+6o2Qh16J+f/PL+fJPhy/VkwGVsix9Bv527+s57OR/lCzk+lBdXXLcGQ/n8htGlXS95bKs1EBdXV1OOu+xkoZcH3pv6pzscezdeXwxY/q3VsvK9k8WXNja78RhJQ25PvTsK1Oy6zF3ZmIzh72ppGWpBl57a2p2+tIdJQu5FvXXu17L//zggcwv4F3Py1IN3PnQmzn4W/eVLORa1Ld/8e9c8IdnS77ecliWauD0S0obcn1o2oy52ffEYXnoifElX3c5LCs1MGfu/Bz8rftKGnJ96KUx77fY+WZLW1a2f7Jg+PKdjr6jZCHXom755xs55Dv3Z24zh8CrpGWpBv75+Ljsd2LpHgJY1I9/82R+dsVTJV9vqQm6CmzEc+/mqB8/2GLrr6tLjjzlwYx4rnVe3Jg3rzYHfvPevDZ2aou1ccdDb+Wk80p/Ab3c5s2cnXeffDlV7dpluf7Fuyu7IW+Nn54DvnFvZs1uuTDyx795Mjfe81qLrb9c2moN3PnQm/luC35G586rzae/fV9efav0B4ulMP3/TzybO+52Y1x9y8s596qnW2z95dJWPwPPvTIln/3eP1o0jDz2jIcLe3FjUW21Bn5/88s575qWuwA5bcbc7HfisEIGHYtqq9s/Sb569iN5YETLfUZfePW9HPLd+wt508Oi2moNzJo9L5/62rC8/U7LXYC8fthr+enFpb+AXm5ttQZeeeODfOY795f8hpdFfesX/271N381RlutgZb+jM6cNT/7f/2ejJ1Q+jC93NpqDXz3vMdyVwt+Rke/OTUHfuPezGvB/Uw5tNXtP3fuguujS/M6myW57cE3870LXB9trd4cPy0HfOOeFrnh5UM/+vUT+ft9r7fY+ktB0LWIYcOGZa+99kqvXr3SpUuXbLjhhvnZz36WOXOaP7ZxS5k9Z36OasaTXI9fu3/evOfwPH7t/o2af/78unzxxw+16AeluX7x+2fy+LMTm7RMU3//JPnfPz+fB0eU/g7Zcus+YMEOfPZ7LffFV051dXX5yunD8/7Upn0+m1MDx5/5SN6dPLOpXWx12loNvPfB7Bxz2vAmLdOc7T995rwc/ZOHWuUFvh/874iMfrNpYX9z/ganXvRknh89panda3Xa2mdg3rzaHPXjB5v8ctmm1kBdXXL0qQ9lRgvcGVZuba0G3ho/Pd8899EmLdOcfcA7k2flxJ890tTutTptbfsnyR0PvZmrbnq5Scs0pwb++fi4XHLdC03tXqvTFmvg9Ev+k+ea+D6m5tTAz658Kk8+37Rzr9aordVAbW1djv7Jg5kxq2nf0c2pgS//tOnnXq1RW6uBdybNzAlnNe07ujnb/72pc3LsGQ+nrq71nRM1VVurgX8+Pi6//vPzTVqmOTXw2LPv5vwWvLmqXNra9k+Sc696Ok808Tu6OTVwwR+fy/Ani38DZFurgbq6uhzz0+FNfk9zc2rguDMebtU3QAq6/t95552XPffcM3fffXe6d++eddddN6NGjcoPf/jD7Lzzzpk5s3Vd5D7r8qaf0CRJ395d0q9P1/Tt3fhx9p99ZUqrG77thVffy08vfrLJyzXn908WXOCb2cSTh0qq6dwhHXt2T8dey6XHoNWz1dlfTq8N18y7T76cD14tfmiXJH+49ZXcObzpdyw1pwbenTIrXz+naRcSK21ZqIGTzn8sY5t493Jz9wEPjBjf6i7wDX9yfJNPaJLm/Q3mzF0QqLTGsK8hy8Jn4LxrnsmI55p+0bE5NfDKGx/klN+MaHJblbQs1MBxZz7c5BOa5u4H/3rXa63+Dr5FLQvb/4Npc/KVJt7wkTS/Bk7+1eMZ83bLjaRQastCDTzx/MT8vBlPXTenBj4c2r5Id/MvCzVw8XUv5KEnJzR5uebUwFsTpufkXxXrbv5loQa+ds6/mnzRsbnfA7c/+Gb+dPvoJi1TaW29BmbOWnBTZlM1twZ+ctGTefG195rcXqW09e2fJM+PntKsYUubUwN1dckXf/JQZs12fbQ1ufqWl3P3I2ObvFxzauCdybPyjZ+33uujxXuLXAt47LHHctJJJ6WqqipXXXVVjjzyyCTJ6NGjs9dee+WRRx7JD37wg1xwwQWV7ej/mzp9Ti7443NlbfOCPz6Xk7+4Ubp1aV/Wdhvyy6ufafId7Etj9JtTc93dr+XIA9YpW5tLY9OTD8+mJx/+kZ+9fvuj+fcPrqhQj0qrtrYuZ5Y5fP3LXa/mjBM3z9qrF2MM37ZeA2+Nn56rbm7aHexL65zfPZ1jDxmU6urWcY/I2WUeH/nxZyfm3kfHZo9t+5W13eZq65+BWbPn5Re/L/07mRbn4utG5ZSvbJqey3csa7vN1dZrYOQLE1vkPQyLc9blT+WgXQeUtc3mauvbP1lwUtvUGz6WxvSZ83Lhn57L+SdtXbY2l8ayUAM//93TZb0J5ZmXp+TWB96wH2gl5s2rLfv7Mn5300s59bhNs8pKXcvabnO19Rp46fX3c93d5R1m/6zL/5PP77tWqqqqytpuc7X1Grj2zldb9HUeHzd7zvycd82zuezUoWVrc2m09e2fLBjtqiWHrv24V974INcPey1f+JTro61BbW1dzrq8vMcC1945OmecuFnW7Nf6ro+2jqt1FXbGGWekrq4uX/ziFxeGXEmy1lpr5corr0ySXHzxxXnnnXcq1cWP+NPtozN1etPu3l1aU6fPbTV37kz5YHauvbP8fbm4lT3NsTgv/mFY7j70tNzz+bMy4ow/ZNbkqem6cq/Mn/3foSZ2vPhb2fHSb39kuQ49uuXQ/1yeNQ/evtxdbpL7H3s7L48p/zuTLr1+VNnbbK62XgOX3/hik4duXVpvjp9e9ovKDXn1rQ9adAz2hlz0V/vB1uKGe17PpPdml7XNWbPn5/c3v1TWNpdGW6+Bi68r/3fSE89PzOPPts53t35cW9/+dXV1FdknX3XTy4UZxrSt18Db70zP3+9/veztOhZoPW594I2yht1JMm9eXa74m2OB1uKS68v/eRz12vv55+PFeQqirddAJa5T/en20YUZxrStb/9J783KX+56teztVuI8pLnaeg3c++jYvPJGea+P1tW13uujy3zQNXXq1AwbNixJcswxx3xi+g477JCBAwdmzpw5ueWWW8rdvXpdekNliqm1FPEfb3slM2eV/51h/37m3Tz14qSyt9scH7w6PuMeeiZj7x+ZZy+6OfcdeU56b7JWtvn5sQvn+dcPLs9KW6ybNQ7cbuHPtj77y3nnsVF59W9Nf/S9nCpVi7+76aXMLeOThEujLddAbW1dLv/bixVpu1L734+74saXUonh8W994M3CvIS6LX8GksrtBy+9vjKfveZoyzUwbUblbkBqLceDS9KWt3+SPPTE+Ix67f2yt/ve1Dm5flh5nx5orrZeA1fd9HLmzSv/wcC9j76d0W+W/4az5mjrNVCp/fFlN4wqzHua2nINzJk7v8nvaCyV1nJO1BhtuQaefH5is4YxX1ozZs3Ln25/peztNkdb3v7Jgld6zJpd/uuj/3rqnTzz0uSyt9scbb0GKnV+fuXfX2qVw1kv80HXyJEjM2fOnHTs2DFDhgypd56hQxc8kvvoo5Ufg/L9qXPyn1GV2ZmMHDUpH0yr/F0bDz5RuRcfVrLtpfHuiBcz+oYHs8aB22XFIesmSea8Ny2PfOfibHXWl9O5zwrpv+/W6bvt+vnX9y6tcG8Xr66urmLbYfL7s/Pc6CkVaXtptaUaeOWNDzLu3fLevfqhh56c0CreU/VghV4AW1tbl0eeah1PNzdVW/oMzJ4zP/9+pjJP1bw05v1MmNS63lvaWG2pBp54fmJmVOjdoZXa/yyttrT9k8puBzXQOlRyOzykBipu/vzaDB/Z9HdzlcLYd2bk1beK876+RbWlGnjm5Sl5r0JP1Tz4RGVqrxTaUg1U9NqY74FWwfFg07WlGqirq6vYdpj03uw8/+p7FWl7cZb5oOullxY8dt+/f//U1NT/yrK11lrrI/NW0n8q/ETRyFGVf6Lpiecr14dKtr20nvrVDamdNz+bnnTYwp+N/cd/8vqtj2SH33w9W59zTB75zsWZPWVaBXu5ZG+/MyPvTG7ay3ZL6Ynny3/HVKm0lRp48oXKbYOp0+eW/bHwj5s/vzYjX6jcvqiSf/+l1VY+A8+8PLms47B/nP1g5T1ZwX3Ay2M+KMxwNR/XVrZ/UtkasA+ovLq6uopuB+dElffSmA8yvYLDiFZyH7S02koNVHIfMO7dGRW78bAU2kwNVPC8zPdA6+B4sHnaSg28NWF6Jk5xfXRRy3zQNWXKgqczVlhhhQbn+XDah/M2Vl1dXaZPn57p06eX7NH+Sl7cbA3tv/fB7LK+aPPjWkPQ11xTXx+f125+OKvssFFW2mrwwp+POO2adF+jb8bePzJv3fdkBXvYOJXeBpVuf2mogbbR/stvfFCxJzmSyn8PLI028xlYxo8FloYaKI2iDOX8cW1l+yeVrYHnRk/JnLnlHyanFNpKDbw1YXrZ39O4qEofCy2NtlIDlf4eqHT7S0MNlMZ/7AcqrpI18MobH7SKEZ+ao61s/ykfzM6YtysXxDgWqLxKfw+UsgZKlaHU/wjTMmTWrAXJZ4cOHRqcp2PHjkmSmTObNlTPjBkz0q1btyTJyiuvnHbtlj5X/KDzLknnHeud9vi1+6dv7y6LXb5v784L///New5vcL7xE2dki89+8p1kPzn95/nlD/7RhB6X1rx2KyQ9vtng9CX9DZb293921Gvp169f4zvcCO3r2uXUbFnSdTbk6QtvzBoHbpdNTzosd3/mp0mSeTNnZ9qYdzLlhTdK3t7AdQZmblVpnzqY3mHjpNvB9U4rx2fgd1dfl5suOrQJPV4yNdA0U7rsn3TavN5ppdoHJA3XwLFf/U6+M/vxJvS4tGbXrJYs9+V6p5XjM3D/g4+lX7/6228un4GmmdppaNJl93qnlaMGfvbLX+fi0+9uQo+bp6XqoiVroCW2d30mdvt80mFgvdPKsR886JAvpPPcln8/R0vUQEvvA8pVA2+v8IOkqlO901r6eHjevLr0X3NQqutafhjTotVAubb/3Oo+yfIn1DutHN8D/x7xTPr1O64JPW4e3wMNm9Zxy6TrvvVOK0cNXPjbK3PNLw5sfIcbwfFg00zuekjScYN6p5XjWODzRx6bLnOebkKPm64la6ItHA+M6/HdpF33eqe19LFAkgxcb9PU1Lb8+0IdC9RvXrueSY9vNDi9pWvgmedeLfn10fo4FmjY9A6bJN0OqndaOY4FrrjqL/nbbw5pfIcXo7a2NuPGjUuSbLLJJhk5cmSz1rPMB12dOi04QZwzp+E7EWbPXnC3XOfOnZvdzocba6n1mZ400I2+vbukX5+ujVpNTXW7Rs+7qKlTZ2TqhLFNXq5kOsxLejQ8ubF/g+b+/rXzqzJ2bGl//w5V1Umf0qxr/L+ey+9X/kyD099/eWyu6XdYg9NL7e1xb2dOXYnv+F1hjaRb/ZPK8RmYOWu2GmiCFqmBfrOS+q/ttfg+IEnef39q3p9Uwf1g167JcvVPKsdnYO7c+T4DTdAin4EVpyUNHLOWowamT5uZ6eNa/jPQ3LqoZA20yPauz4A5SQP3aJVjPzh5yvvJ+62zBiq9DyhbDfSoSqrqn1SOGhg//p1kXssP5Vu0Gijb9u9Ukyxf/6RyfA/Mm1dX8mOB+vgeWIxeU5MGNl05amDGjFmZ4Xiw0VqkLlafk3Ssf1I5vgemvPdBpkxp2f3A0tREpWugLPuC5dLgOF3lqIEJEyYmc1r+/c2OBRrQcX5Fr4/Or41jgQaUrQZWWLOy10dnlv76aJJMmND890Au80FXY4YlbMzwhktSsie6OnVOQwP3jZ+45DGS+/bunJrqdpk3vzbjJzZ8F2ZD6+rerXOWq1m1MV1tEfPaLZ/FlfuS/gZL+/tXt5ufvquW9vdvX9cuqdyrVlrUKiuvUvK7GGZ06JaGPq3l+Ax07tQ+PdVAo7VEDUzp3CENbelS7QMWt64ey3dN106V2w/Oqe6RdxuYVo7PQPv2VVnJZ6DRWuIzMLVTlzR0ebkcNdCta8csX+IaqE8R66Iltnd9JnWsSUOjsZdjP9hzhe7p3E0N1KdcNfB25qehQT1a+ng4SVbuu2La1dV/F3kpFa0GyrX951b3TEOXFsvxPVBTnfTxPVCvctXAtI7d0tBzFOWoga5dOqSH48FGa4m6mNypJg1tuXIcC6zQo1u6dGnZ/UCRa6Ic+4LxVbVp6FJ6OY4F+q7UM9V17RvT1aVStDoo1/fAvHY9Knx9tLbk10frU7Ttn5SvBip+fbRz6a6PLvpEV58+zb/rZZkPugYOXDDsy5gxYzJv3rzU1HzyTzJ69OiPzNscL7/8crp2bd5dEou65paXc+QpD9Y7raHHiRf15j2Hp1+frhk/cWZW2/0vTW7/N+efmiP2/2OTlyuVuXNr032bazJ7Tv1f50v6Gyzt77/91uvlH1e+1eTlFmfujFn501r/U9J1thYvvfxS2ndp4NGbZnrkPxOy3RG31TutHJ+B7379yJz+1f9t8nKLowaa5ue/eyrfv2BEvdNaeh+QJNf98aLsvk3lgq53Js1Mn53/XO+0cnwGPvOpHfPnn/+0ycstjs9A09x4z2v5zHfur3daOWrg3DNPzvGHXdXk5ZqqiHXREtu7Pt/8+aO58E/P1TutHPvBB4bdkA3W6dmsZZtCDTRs88NuavAF5C1dAyss1yFjn3o5VVUNPFJWQkWrgXJt/6nT52T5bf+Q+l5hUI7vgb133SK3/Lq050T1Kdr2T8pXA3cNfyt7n1D/MMLlqIGf/vDEfPeoS5u83OIUcXs3VkvUxY/+d0TOvuKpeqeV41jgzpuuyVYbrdSsZRuryDVRjn3BDkfdloeerD/qaOka6NypOm++9lxqapb+hv4lKVodlOt7YM7c+em+9TWZM7f+QKWla2DHbdbPfVc4FqhPuWpg+JPjs/1Rt9c7rRzHAid/44v56Qm/bvJy9Zk+ffrC1z8NHz682etZ5oOuTTfdNB06dMjs2bMzYsSIbL311p+Y58M/8FZbbVXu7n3C5uv1rmj7Q9avbPvt27fLxgN75rFnG3qeoWUNqfDfv6Xc9elTK92FRttk3V5p164qtbXNfznh0lADlVfp/WCl21+pV+es1rdr3hw/vSLtV/r3bylF+gxU+ru40u23lCLVwObr9apY21061WTQGj0q1n5LKdL2TxbsixsKusrRdjlCrnIrUg1079oh6w5YPqNea/l3o9TH90DlVfJ7oDW031KKVAOV/BxWV1dlo4Etf8NLJRStBhoKulraJuv2KkvIVW5F2v4d2ldnw3V65onnJ1akfccClbfJoF6pqkq9Nz6VQ2usgba3V2qi7t27Z/fdF7zQ/fLLL//E9AcffDAvvfRSOnTokAMOOKDc3fuEQWssny6dKpNPdulUk3UHNDAYfBlV8qC6rR7QF0mXzjUZvEbl6rCtXuQvks0GV24brLFq9/RcvoHB8MuoknXoM1B5q6/cLb1XaPk7xOpTU1OVDddp/lDOlEYlP4ebDOrZJi9sFI3vASpbA86JKm3Fnp2z+spLP2JMc206SA1UWiX3AeuvtUI6V+i6FP/lWIDKXh9VA5XWrUv7it6A2BprwFlqklNOOSVVVVW56qqrcvXVVy/8+ejRo/OlL30pSXLsscdmpZVa9rHsxqiubpdP7bRaRdref6fVU11d+ZI5cJf+FWm3U8fq7LFtv4q0zUdVqgaGrN87qzbzRa2UTs/lO2aHzftWpO0Dd1m9Iu1+3IE7V+YzsOIKnbLNxpX/LlzWVVVV5YCdKlOLe2+3Wjp1dGGj0gat0SMD+1fmpo9K7X/4qP12WC3V1ZV5qkoNtA6V2g7Ld++QnYasXJG2+ahK1cDOW6ycHstV/savZd1qfbtWLHD0PdA67Lltv3TsUF2RttVA61Cp7dC5U3VFX+fAf1WqBrbcYMWsvGKXirS9OJVPLVqBrbfeOuecc07q6upy1FFHZcCAAdl0000zaNCgvPLKK9lqq61yzjnnVLqbC331sPUq0+7hgyvS7sfttvWqWXv15cre7mf3XrNVPMlBcuwhg9KuXfkv7pxwWOv4DFC5/dFxh7SOGjh0zzUqsj865tPrVuxkio+q1P7IfrB1aNeuKiccNqjs7XbsUJ0vHtj8d9ZSOqv26VqRE9vNBvfKVhutWPZ2+aQDdu6fVVYq/wWGo/ZfJ127tC97u3xSpb6TW8t1gWVdVVVVRWqguroqX/nMumVvl0/qvUKnHLbnGmVvd90By2eXrdzw0BrsuV2/rNmve9nb/dzea2UFNzy0Cscesq7ro4sQdP2/k08+OXfddVd23333vP/++xk1alQGDhyYs846Kw888EC6dGk9KeXQzfqUfdigDddZIdtt2qesbTakXbuqHH9o+S/utNYP8bJotb7dsn+Zn2ZYYbkOOWzPNcvaJg07cJf+Zb97ZPdtVsnAVjB8a5J07lSTo8t8sbldOye1rclm6/XOVhuW92LzWqt1zx7bunOvtThy/3XKPpz1YXuuUbFhM/mkShybnnDY4Db5fq4iat++Xb7y6fJ/Lx9XgfMw6rfuGj2y61arlLXNVVbqkv138iRHa/HZvddMj+4dytrmgTv3N8pJK1KJY4HjDx3kWKCVWHB9tAI14Ppoq9F/le7Zb4fyjvzWc/mOObQCIXtjCLoWseeee2bYsGGZMmVKZs6cmeeeey4//OEP07Fj60qpq6qqcsHJW5e1zQu/t3Wr+iI74bDBGVTG9zQd8am1M2R9d6+2Jj//5hbp1LF8T5ac+60t06Wz4bpaiw7tq3Ped7YsW3vta9rlvO9sVbb2GuMHX944fXt3Llt7Jx21YfqvUv67xWjYBSdvXda7ty78XnnbY/F6LNcxZ5y4WdnaW65b+5z5tc3L1h5LtvOWK5d1OOfN1+udI/dfp2ztsWTfPmKD9F+lW9naO/Gz61X0XRB80nnf3TI1NeX7bv7VSVulfXuXkVqLrl3a55xvblG29jp3qi5reyzZVhutlM/vu1bZ2ltvrR45rgLBCg376uGDyzqk+VEHrNMq3820LDv3W1uUdeSdX3x7y1b7nsbW2SuWaJetVsnxhw7KxdeNavG2TjhscHbesrx3ii1Jp441+f0ZO2TbI25LbW1di7a18opdcsH3yhsssmQDByyfs762eb7zy8davK09t101XzrYUE2tzeF7r5nrhr2Wm+4f0+Jt/eS4TbLhwJ4t3k5T9Fy+Yy77ydDs//V7WrytwWv2yE+P37TF26Fptt54pXzniA3yi98/0+JtHbn/Otl3h9bxjrrG6r/v1ll5+w3z6Pcvz5ZnHJ3V9xySbqutlFt2+24mP/f6wvkamlbdsX12vORbWX6dfpk/a05mTXw///r+5Zn6+vjK/EL1+Mbn18+N976eR/7zTou3df53t8pqfct3Qb0h3dfom+0v/Fo69uyeuVNnZPg3fpP3XnrrE/Ot89ldsuGJByXtqjL+4Wfzr+9fnrp585Oqqmxx6hFZdedNUjuvNrOnTM0j371k4Xbtt9vm2eLUI1LVrl2mjHojw7/xm8ydNjNJssFXD8zah+6Y2jnzMn/23Pz7lN9l4n9eKevvv6iqqqpcfMq2efCJ8Zn8/uwWbat9Tbtcdfr2qamp/AXupa2BFTcfmG3OOSZJUtW+Ju889kL+fcrvUjtn3mLro6ZLp+x85XfTa6M10666On8edGS5f/VP6N61Q6786fbZ7St3tnhba6zaPT/7xpAWb6elfPid8OawEdns+59NVVVVqmqq8+xFN2f09Q98Yv61D9s5Qy/4au7/4s/zxl2PV6DHjbPxur1yyjGb5KcXj2zxtj6924AcskfrvIN7WfaVz6ybG+55Lfc++naLt/Wzrw+pyGskWLz//f42ue/fb2f8xJkt2k67dlW56vQdWsVQ9i16LLCIPa8/Nb02XHPhd35rPBbo3KkmV52xfYYeeVvqWvbyaFZdqUt+dVLruAF4aWug7zbrZ7c//TAfjP7vvvP2T/0o82fNSd/tNsjmP/p82nftlLq65K17n8gTZ/0pqatrlTWw7ho9cuaJm+ek81v++ujeQ/vliwe23hvfKn+mQrOd++0ts95aPZq0zPiJM/LWhOkZP3FGo+Zfb60e+fm3WucdO1tttFJ+cuwmTVqmqb9/dXVVrjp9+1Y59mz3Nfpmn1vOykHD/zf73XlOegzst1TzrX3Yzjlq3A1Zfa//bu/PPHZRDnrowux/zy+y/z2/yID9t23UcuXyjc+vn922bloI29Qa6NOrcy7/6dBW9UTjh0pRA9Ud22eXq07OQcP/N/vf+8vs8Zcfp/uAvgun7/6XH2f/+87L/vf8InvfdEZ6bvDJk9tK1cCHF/j6NWHojKZu/yQZummffO+LGzeniy3uUzutnmMPadoQQk39G3TuVJ1rztohnTq2zntjyrEvXNy0Lc84Op957KIcNe6G9Fx/QEl+p6Y4/aubZbPBTXsReVNrYK3VuudXJ7eOE5qmWH2frfLGXQsO9sfc/q/cccApmfbmJwOhxU178Q/35O9Dv55bdvtu3rj78Wx33vEt3u+mqK5ul9+fsUNWWK7xwxY1Zz940K79c/RBreOGj23PPTYv/XHBdnnmNzdl6IUnfmKebqutlE1PPjx3Hvjj/G2bE9Op9/JZ9392T5KsvueQrLTFoNy863dzy67fybjhz2SzH3wuyYKLF9udf3zu/+LP87ftvpYZ4ydn4299JknSc/0BGXTUnrlt7x/klt1PygtX3Zmtzv5S+X7xBvTt3SWXnzo0TTlMaU4NnPPNIa3mho+lrYHJz7+eW/f+fm7Z/aTcvPO306n38hl01F5JFl8ftfPm5Znf3JRhh55evl+2EXbdepV8+4gNmrRMU2ugQ/t2ueasHdKtwO/m+vA7YYfffD3Dv/Hb3LL7SbnvCz/Ltucem5quHx2StVu/FTPw87vlnREvVqi3TfPDL2+SbTdZqUnLNLUGVuvbNRf9aNs2e07UcYVuC89597/nFzlo+P/miDf/mg49FtzgsbhzosacM7ekqqqqXHna9lmpZ+OHFm7O98Ae266ar31u/eZ0sewaWxOLO45f0nnyqrtsmk8NOzf73/OLHPCP87PWITu25K+0WD2X75irTt8h1dWN/3w2pwZ+evym2bLMQ6c3pCWPBT603rH7ZeqYCR/5WWs9Fth2kz455SubNGmZptZATU1Vrjpjh/RoJddHl7YGkuSD0W/nlt1PWvi/+bPmJEnmvD89Dxz3q9y047dy254nZ6Ut1s3a//8Zb6018K0vrJ9dtmzau/OaWgN9e3fOZT9pnddHP9Q6r1rRKN26tM+wS/bKDl+8Pa++NbVRy2zx2Vsavf61VuueYZfs1apPaH5y3KZ5d8qs/PYvLzRq/qb8/u3aVeXqM3fIntvVf1BUaR/u1F+57p/pv+/WGXrhiblt7+83a77Fncw9cNyvPnLne2OXK4fq6nb5+wW7ZY9j78q/nmrc3exNqYGey3fMsEv3ahV3sNenVDXw4h/uydj7F9wFOuiLe2W7847PXZ8+NUnywFfOy5wPFnzprb73lhl6wVdzy27fXbhspWugb+8uueeyvbLjF2/PO5NnLXH+pmz/JNl0UK/c+uvdW/UQLb/5wTaZ9N6s3HDP642avyl/g44dqvO383dr1UO3lmtf2NC0Mbf/K89edFP2ufnM0v5ijdSpY03uvGjP7PSlO/LCq+81apmm1MBqfbvm3sv2bpU3fHRYrksO+MevUt2pQ2a8PTHtOrZP99X7ZPQND+Rf3788fbZYN8O/8ZskyYRHGz5OaGja/NlzF+4bk+TdJ1/OBsfvX9pfogTW6b987vjtntnjuLsydfrcJc7f1P3gLluunD+fs1OrOKHp1Gu59Np4rQw7/IwkyZjbH83WZ38p3Qf0/ciTdv332zpvDhuRme++lyR58Zph2egbB2fU7+9KXV1S3aEm1R3bZ968+WnfrXNmjJuUZMFFq8nPvpb3X1lwZ+eoq+/OHtf+OCPO+EPq6urSrqY6NV06Zt6MWemwXNfMGDe5vH+ABhy824Bc9KNtc/yZjzRq/qbWwPeO3ijf+kLTgpSWUooamD9zzsL5qjvUpKZTh3x4C/Ti6qN2zryMf/jZdOvX+r4Tf/HtLTNxyqxcc2vjnjBsSg3U1FTlr7/YOUM367vkmSuosd8JdXVJh+UXvOe1ffcumTVl6kfv4K+qyrbnHZ9/n3Jltji18ndpN0b79u1y22/2yC5fviP/GdW4/VJTaqBPr86597K9s1Kv8g2Z3RSlOBacPWVabtn9pIXzrn/c/um7zXqZ8960JEs+J1rcOXM5rL5yt9x9yV7Z5ct3ZMoHc5Y4f1O/B7bdZKXceP6uhRnCurE1saTj+MWdJ+/wm6/nrk//NFNeGJNu/VbMQQ9dmDF3/Dvzpi/5nLQl7DW0X646ffscecqDjXqqp6k18LXPrdfkIKWltPSxQJL0GNgvq++1ZR7+5m8zYL9tFv68NR8LnHbCZnl38qxccn3jRv5q6vXRa87cMbtv0zre11yKGlicyc++tvC/58+em8nPvp5uqy24oaS11kB1dbvcdOFu2f0rd+Xfz7zbqGWaUgO9enTMsEv2Sr++rfsdja33yh2Nsmqfrhl+9X7ZZFBp77DceN2eeej3+7X6l4xWVVXl1z/YJt//0kYlXW/nTtX567k75/P7rl3S9ZbKhzv10Tc+mGTBTr3rKr0+codRo+db5GTu449pL1Zzlyuxbl3aZ9ile2XPbUv7hbta36558Kp9s1EruXv540pVA/VdyO222n+/sD88oUuSDt27fOTgr7XUwKA1emT41ftlzX6lfX/UjkP65v4r9m41dyw1pKamXa79+c75Uomftli+e4fcedEe2Wto6wz7kzLuCxczbcKjL1T8YvdKvTrngd/tky03KO3B9uA1F3y2BqzaOt/NNueDGXn17w/l+Stuzy27n5THfnJV3n3ypTzy3Uuy8nYb5J3HX1wwVF2JrPflffLG3a1z+KqtN14p/7hyn/Qp8UXIA3fpn9t/u0ereaKz66q9M3PClNTNr134s2ljJ6brqh99T0C3VXtn2lv/PcGb9ta7C+d5c9iIjP/Xczns6Sty2FOXZ+XtN8zIc/9a/3JvvpPOfXqkqrpdpjw/Js9ddls+89hFOeSJS7PeV/bLv390ZUv+uk1y3KGD8/szdkiHEt6YUVWVnHni5vnZN4a0iqAzKU0NJAtuXtj/3l/m8Od+lzkfzMio39+dZPH10Zq1a7fgLusTP7teSdfbrUv73Hzh7jlwlwElXW9LaOx3wgPHnZ+drzwpn3n84ux98xkZ/o3fpHbuf7/b1z/2U3nn8VGZ9PSrFfxtmm6F5TrmH1fsk+0361PS9a61WvcMv3q/DBxQvve/NEVJjwUXsc7ndsnL19638N+LPSdqJTYZ1CsPXrVvk0a7aIy9tuuXu1v5DdCLasq2Xtxx/JLOk5cYmlfAFz61Tv5y7s4lf5f5D7+8cS783tbLzLFAVU11tv3l8fnXyZd+pI3WrqqqKhedsm1O/uKGJV1v507Vuf6Xu+Sz+5TvXXBLUqoa6D6gbz417Nzsd+c5WffIPettq/OKPTJgv63z5r1PlPi3KL3uXTvknsv2yu7blPb1Q6uvvOD6aGsZ3WFxBF1twMordsmjf9w/Pzpm4yY9qlyf6uqq/OiYjfPvP+2flVfsUqIetqyqqqr87Btb5J7L9srqKy/9Qd3QTfvkqesPymda8fjjjd2pN2a+JZ3MDf3fr+WA+8/Ltucdn469lmv0cuXUrUv73HHRnvn1D7ZJlxK8EPFLBw3MMzcenPXXXqEEvWsZpayBRdV3IXfo/34th4y4JJuefHge/NqvF/68NdXAOv2Xz1M3HJQTDlv6F+N26lidX35ny9x3eesPuT5UU9MuV5y2fa7/5S5ZcYXGD1vSkH13WC3P/e3gVvd+xo8r176wNdV6Q1bs2TnDr94vp391s7RfynfoVFUl3z1ywzzxlwOy+sqt84nWD/XcYI1MfmbBHXe9Nlpr4d13q++1RcbcWboxyjf8+sHpPqBvnjj7TyVbZ6ltvl7vPPf3g/O5EpyELtetfa746dD87Ve7tpqQq1R6b7xWeqy7eq7f9Cv56yZfybiHnsk2535lict1W22l9N9nq9y4zYm5fvNj8/xlt2XHS79Vhh433pEHrJMn/3pghqy/9C8IX3v15fLA7/bNj76ySau5sFVK0956N7fs9t38daNjUt2xffrvs2B41ubWR2vQrt2CGwBv+d/d07f30ofeu229Sp7920HZZ/vVStC78ljSd0JVdbts/M3P5B9f+kVu2OL43H3Iadn+119Px54Lbujose5q6b/vVnnqghsr9jssjR7Ldcw/rtynZC+lP/Gz6+Wp6w9q1e9kaolzohWHrJuOy3fNm/d89KJmQ+dEH06r75y53DZYp2eeufGgkrw/pWvnmvz2h9vk9t/uUZiQK2n6+W9jffw8eUmheaUcuueaeer6g5o8nGl9+q/SLfdetnfO+nrrueGllBo6FtjkO4dkzB3/zvsvj61wD5uuqqoqP//Wlrn7kj2zWgmevNl+sz55+oaDc/BuA5a+c63MpGdezXWbHZtb9zg59x99btY9Yo8M+NQ2H5mnfbfO2fWa7+eZi27OpKdGV6inTdO9a4fcdfFe+d/vb12S66NfPnhgnr7h4Ky3Vuu9PrqotnXmugzr2KE6Z35tSA7adUBOvejJ3PHQm026yaiqasEL5U47YbNWPUTV4uy29ap55saDc+Zl/8kVf3uxUY/sL2qt1brn21/YIMcdOrjij+Tvc+tZWW7N+sdWXXRIhaX14cncnQf9pN7pdx70k0wfOzFVNdXZ7HufzfYXnph7/+fsJS5XCe3aVeXEz66Xfbbvl1N+/URuuOf1zJ3XtLtvhm7aJz8+dpPssW3ln2ApVw0s6sMLuY8cetpHfj786wtO5NY6ZMcMOeV/Wm0NdOvSPr/90bY5ZI81ctolI/PPx8c1afmamqocuHP/nHni5ll3jR4t08kW9pk91siOQ/rm1IuezDW3vpLpM5t2srXB2ivk+1/aKJ/bZ61WcTLTGvaFrbHWG9K+fbv8+NhNc8DO/fOT3z6RWx94M7W1TbvjeI9tV81Pj98022xc2jvCW0rP9QcsvJDZa6M18+b/X4BYZadNMuKMP5akjfWP2z/999kqww497SPDnLRGvXp0yp/O2SmH7blGzrr8qTz2bOOGrfhQxw7VOXyvNXPGiZu1ymF7p4+dmM59VkhVdbuFF7C6rdo708dO/Mh808ZOzHKL3Lndrd+KC+dZ65AdM+7hZxfenT/6un9m97/8eOFyq+z431ECuq22UmZOeC9182vTf9+tM2XUG5k5YUqS5JW//CNbn/3ltGtf0youbH1o/bVXyL/+8Kn8+trnc+GfnsuYt6c1afneK3TKcYcMyg++tHG6dG59p4qlqIFFzZsxK6/d9HDWPHj7vHbzw4utj6L41E6r57lNP53TLxmZq25+KR9MW/KQposatMbyOemojfLFA9dpFccCTbGk74SeG6yRzn1WWDhk7aSnRmfGuEnpucEaGffg0+mz1eB0W22lfPqRBce+nVfskW1+cVw6r7RCXrxmWGV+qSaqrm6Xk764UfbbcfX8+DdP5KZ/jMn8+U07Fth5i5Vz6vGbZschTXvXR0uoxDnROp/dJa9c/8AnnuSo75woaficuVJ6LNcxvzt9hxy6x5o547KReeQ/jRvi/0Md2rfLZ3ZfI2eeuHnWKPGIGaXQGs6TFw3NJzz6QnptvFZ2vfr7uXmXb2f25Ma9VqQlDRywfB68at9ccv2onH/Ns41+1cmHei7fMcd8et386JiN071r498DWy4tfSzQd5v103XV3hl89F6pqq5O++6d85nHLsqte38/syd90LK/XInssW2/PPu3g3PGpQuuj743tWnnMGuvvly+c8QG+cpnBlX8+mh9SlEDc6fNXPjzGeMm57WbhqfPVoPz+q3/SpLUdO2U3f98St64+/E8f+ltLf0rlVS7dlX52ufWzz7br5ZTfv1Ebry3eddHf3Lcpq1muMrGan1nLyyVzdfrndt+s0defeuDXHr9qNzzr7fzzCuTM2/eJw9ua2qqsuHaPbP7Nqvk2EMGZc1+rfdOrcZarluHnPvtLXPaCZvlL3e9mmvvHJ0Rz01sMPRarW/XbL3RSvnSQQOz+zartpod+B2f+tFip9fOntuonfqSdv5LOpn7cL66efPz/OW35eCHf92o5SppzX7L5c8/3zm/Onlmrrjxxdz24Bv5z4uTM2v2J4evateuKoPWWD47bt43xx4yKBuv26sCPa5fuWrgQ425kDv6+geyzc+/ko4rdGvVNbDTFitnpy1WzvOjp+SS60flH4+Ny/OvvlfvBf+OHaqz8cCe2Wf7fjnm0+tmlZVa93CtjbFiz8656JTtcs43t8gfbnsl1w97LU++MKnBd/es2a97ttukT4759LoZulmfVnVRqzXsC5O02lpvyEYDe+amC3fPG+Om5bIbRuWuh8fmmZcnZ87cTx7cVldXZYO1V8iuW62S4w4ZlHX6t86hierTpW/PpK4uM8YvGHKm5+D+efrCG9N703Xy/stjM2/G0r8jYb1j98saB22XYYee/pFhi1q7/Xfun/137p8Rz72by254MQ8+MT4vjXm/3pugunSqyaaDe+XAnfvniweuk149lv6p0JYya9IHmfzMa1nr0zssfO/G9HGTPzIWf7JgmKJ9bj4z//nldZn57ntZ94g98tpNDydJpr4xIf122SzPXXxLaufOS7/dh+S9F99Mkoz9x8hs/bMvZ/m1V8n7r7ydQUfumddu/u9yax++c2q6dMq8GbPSb/fN8/4rY1tVyPWhmpp2+dYXNsjXP7de7njorfz+5pfz72feydh36q/h3it0yhbr987n910rn9l9jZI8CdJSSlED3Qf0zbS33k3dvPlp174mq++9ZSa/MCbJ4uujSHou3zEXfG/rnPm1zfPnO0bnr3e9midemJT3G7jQNWCVbtl2kz758sEDs9MWK7eqY4HGasx3wvSxE9OlzwpZfp1V8/7LY9N9QN90798nH4xe8F6+F68Z9pHv9r1uPC3PX35b3rirdQ5buziD1+yRG87fNWMnTM/lN76YO4a/madfmpLZc+o/J1pvzR7ZZcuVc9yhgzN4zR7l7/D/sXfncVrW9f7H37PACAMIiuIIiUKomJa5lmJpmVua2aKmuRwrcylPZeqp48l+1WmxTD0tZqWmpzLNcgtNQksFNbXIfQEUF2RREGEGGGa5f3+oHBDBmXFm7rlmns/Hg8djmPu6rvnA3HPPfc9rvte1Ft39mqh64HrZ4kO75U/7n7HWj7nqa6LGF+vX+pq53PabMCr7TRiVfz26IBf+/tHc+o+5efTJRa/7XGDAei+/JjrovZvl0x/Zqsdejy3pvPtEW73e6+Q3iuY9QVVVZU4+fJuceOj4TLpjdi6+5vHcdf/8PDO34XW332D9muz0tuH5xP5jcti+YzKgE1aCdJWufi5w44f/7xdcXj294VW7nNR9/8BOMmRQ/3z/1Jd/PnrFTW/889HN6v7v56N7v6vn/Hz09XTGfWDAxkOz7PmXklIp1bXrZdTeO2b65bckefl7wQd+e2Zm/3Va7i/oKu8kGfuWIbn87L0y94Wl+eUfH8vE2555w5+P7rlTXT778a177GVc3kjPfeTiTRkzaki+98Vd8r0vJo0rWvLA9IWZ8/yyHHvmrVm4eEU2GlaTZ/7yiR79QvbNGLBedf7tw1vm3z68ZUqlUmbNrs+jTy7KJ7/ytyxcvCIbDq3JI9d8NBtt0HOfwK1LWx/U32i7db2Yqx5Qk8p+VSt/sLfFIROy4JXfkCzCi8ARGw7Ifx6/ff7z+O3T3NyaR55YlKfm1OeY/3z5a2D4sJrMuvGw1BboNAyr6qz7QLL2H+T2HzIwVQNqVv72+mb77ZzGF+vT+GJ9Ie4D24wdlv/5j5eXni9d1pz7H1+YD37upix8aUU2WL8mt/xy/2wzZlj6deL1THqSIYP65+TDt8nJh2+T1tZSZjy9ONOffilHf/WVr4GhNXn8Tx/PsIKcnvH1dMdj4au3r+22nmyzukH51ud3yrc+v1NWNLXkwekvZvb8pas9F3h60uGFPTXdBttusdqFglcsbsjWx+ybxoVL8vSfVz9t4bvPPj6j3r9jBmw8NB+4/Mw01S/LH3f7/DpvG1i3QXb5+rFZPGtu9rvq60mSlhXNmfjBr3Tbv/HN2ultG61cqb+kYUXue2xhDv73v6x8HLz9Vx/MVpuvn6qq4jwO3nH6hZlw3snZ7pSPpKl+WaZ84SdJkt1+cEKemXRvnpl0b+qfnp9pP7gy+1/38sXl597xUB77378kSR695M8ZOm5UPnTzD9La1JJlzy/KnadfmCRpblieO069IO+75IxUVFVm0WPP5PZTfpwkefqGv2f49mNz0E3fS0tjU5qXNua2k88vw/9A21VVVeagPTfLQXtuliSZt2BZHpi+MIeddksWvrQiG65fk39e+eG8ZZPaQoWNN3sfqJuwbcZ/6oCUWlpTUV2VObc/kPvPvSrJuu8fSfKhm8/JehsOSb/BA/Lxf1yYuXc8mNs/3zN+qP16Bg3sl+M/tnWO/9jWKZVKmfnMkjz+1Es56pXXRMOH1uTR6z7WowN3W7Xle8LyF17KHaf9LHte+KWUWkupqKzIXf95UYd/AF4EI0fU5usn7ZCvn7RDmppa89DMF/PsvIaVr4k2GlaTWX8+vEeu4GyLznxNlCRbHLxbFj48Ky/NeG7l+9b1mmhdr5l7iu233jAX/NfuSZL6pU2577GF+dApk1Y+F7j14gOy9RZDU/0mT33dU7T1c90Wa3ud/EbRvCeprKxYGT2TZP6CZXlg+os59LSbVz4XuPd3B2f0poM8F3jlucAbKdpzgYEDeufPR9/sfWD0B9+VrY7ZN6XmllRUV+Wp6+/MjN+9HLq2+cwB2eidb02/gTUrT2k560935v7z/5ikePeBTYYPzJnHvzNnHv/OXvnz0VVVlEo98CqavURDQ0MGDXr5tC/19fWprS3/SoFRe1+e2fOXZuTGA/Ps5E+Ue5xu1xP//U1Ll+c3Yz/Z7v2GjN00E847OTXDBq98UF/06NNJVn9gX9d2r7XqD3AHbbZx9vrlaamoqkxFRbLkqfm5+78uXu1Cjq+336qOnPnr9BvYs144uw+svt3Aug1y6D9/nsWz5qb5laXbr/4gt3bU8Oz581NTvV7/lFpLWb5gce79xmVZ+NCsNWYpyn2gJ37+u1tP/D/o6NdA0vWPhW9026qRpPHFJasFlKTnfQ0kPfM+8Ho6er84+G/n5qaPnpXlZTi1SE/8fL9WUT7/yZt7bCgX94HOVbT7QBE+/0lx7gOd8fnv7u8J7gMd1xNeFx9w3X/n8d9Mzowr/rryfet6TdTW18w97X7REz//r6er7xPreh6/rtfJSbLFh3fP20/5yMpofv+Prs6TV09ZOUNP+5y/VlHuA4nnAl2lKPeBon3+E/eBjuishlLMX9sBsnjmc2tdtn/Hl3/Wpu1e688fPWvl2/VPz8/1+7TtHNer7kf36Yz7wNI5C/Oruo+97m0Nz76QiQe0beWC+wDl0tWPhW90252n/7xNx6T7XLvnF8s9AgA9hO8JvV9nPhe84UNr3r6u10Ttec1M92nrfWJdz+PX9To5SZ68ZurKU6AB0DP0jrXJAAAAAAAA9DlCFwAAAAAAAIUkdAEAAAAAAFBIrtEFZVY9oCZHzvx1ucfoEtUDaso9QiG4D9DX+Rrg9RTxfuHz3bncByjafcDnv3MV7fOfuA+8GUX8fLeV+0XHFPk+4XPeeYp2P/C571xF+/wn7gPlJHRBmVVUVKTfwPXKPQZl5D5AX+drgNfjfoH7AO4DfZvPf9/i881ruU+QuB/0dT7/tIdTFwIAAAAAAFBIQhcAAAAAAACFJHQBAAAAAABQSEIXAAAAAAAAhSR0AQAAAAAAUEhCFwAAAAAAAIUkdAEAAAAAAFBIQhcAAAAAAACFJHQBAAAAAABQSEIXAAAAAAAAhSR0AQAAAAAAUEhCFwAAAAAAAIUkdAEAAAAAAFBIQhcAAAAAAACFJHQBAAAAAABQSEIXAAAAAAAAhSR0AQAAAAAAUEhCFwAAAAAAAIUkdAEAAAAAAFBIQhcAAAAAAACFJHQBAAAAAABQSEIXAAAAAAAAhSR0AQAAAAAAUEhCFwAAAAAAAIUkdAEAAAAAAFBIQhcAAAAAAACFJHQBAAAAAABQSEIXAAAAAAAAhSR0AQAAAAAAUEhCFwAAAAAAAIUkdAEAAAAAAFBIQtcrZs2alYsuuignnHBCdtxxx/Tv3z8VFRU59thjyz0aAAAAAAAAr6O63AP0FOedd17OP//8co8BAAAAAABAGwldrxg+fHgOOOCA7Lzzztlpp51y44035qc//Wm5x6KTPPD4wlx+4xN5cXFjkmRJQ1PmPL80dRsNLPNkAF2vVCrlngdfyO8nPbnycbB+aVMWvtSYDdavKfN0dIfm5tb86banc/Pf56y8Dyxd3pwVTS3p36+qzNMB3eHZuQ259LrpKx8DFtevyGNPLspWWwwt72BAt2hpac2fpz6bm+6YnYWvPhdY1pzljc1Zr8aPhqAvmPP80tWeC7xUvyIPTl+YbcdtUObJgO7Q2lrK5LtmZ+Jtz6x8HGhY1pyly5ozcEDxnwsU/1/QSc4888zV/n7XXXeVaRI60533zcsZ596T2/85b7X3L25oymb7/C4f/cDm+eGXd82mG9eWaUKArnXT1Gfznz/6R/7x8Aurvf+l+qaM3PvyHHHA2Pzg1F0ybIjg1RuVSqX86LcP5weXPpBn5jasdtuLi1fkLR/4XT5/xDb5yqfekaoqZ7SG3ujJZ5fk1HP+nuv+9nRaWkor379kaXO2PvgPef+um+b7X9o57xw/vIxTAl2lVCrlF394LN/55X2Z9Vz9are9uGRFRn3gdznpsPH5r+PfmX79PBeA3ujZuQ059Zy/54+TZ6V5lecC9Uubs91Hr857dtwk3/vCznnXOzYu45RAV7r02un51i/+lRlPL17t/YuWrMjIvS/P8R/bKt84ecfU9C/uL8J6FkOv9adbn85en7phjcj1quaWUq7485PZ9cjr1/giB+gNfnXt4zng5ElrRK5XLW9sycVXP57dj/5T5i1Y1s3T0dVKpVJO+ObU/Pv37lojcr1q/sLl+a8f/zOHnfbXNDe3dvOEQFd7cPrCvPuo63P1zU+tFrlWdfPfn8sex07MX+9+rpunA7paqVTKl8+5O5/9xtQ1IterFixqzDcv/Fc+/IW/ZEVTSzdPCHS16U+9lHd98rpcedOTq0WuVd32j7nZ69M35Ibbn+nm6YDu8LWf/CPH/tdta/3596IlK3L2JQ9k/xNvyrLlzd08XecRuuiV7n98YQ798i1pXPHGP7R7dl5D9j/pptQvbeqGyQC6x1/vfi6f/vqUtLa+/ouZVT3yxKIc9PlJaWkROnqT7150f35+1WNt2vYPk2fly+fc3cUTAd1p4UuNOeDkSW36RYaGZc358BcmZ/pTL3XDZEB3+fHlD+eHlz3Ypm1vuP3ZnPzfd3TxREB3WtKwIvufdFNmz1/6htsub2zJx0+9JQ9OX9gNkwHd5aI/PpZvXvivNm3713vm5Liv3d61A3UhoYte6exL7s+yxrb/NtqMpxfntzfM7MKJALrXt37+r7X+9v7ruefBF3LD7c924UR0p4alTfneJfe3a5+fXvGIlX3Qi1x89eNrXc35ehbXN+Xc/23bD8SBnm9FU0u+9fN/tWufi6+ZnqeeW9I1AwHd7td/mpmZz7T9a3rp8uZ8/1cPdOFEQHdqaWnNNy6c1q59fvfnJ/LIE4u6ZqAuJnTR6zy/cFl+P+nJdu/30yseSanU9h8KA/RUjz65KLfcPafd+/30ike6YBrK4fIbn8hLS1a0a5+m5tZc9Me2rQADerbW1lIuuLL9j+n/+6cZWdLQvscOoGf64+RZmb9webv2aW0ttXk1ONCzlUqlDr2+u+KmJ7NgUfseO4Ce6Ybbn83Tc9r+i2+v+lkHXkf0BEIXvc6kO2dnRVP7T79132ML2/VbrwA91Z9u7di51f889dk0rnBtht7g+luf7tB+1/2tY/sBPcvDM1/ME8+2f1VG/dLm/LUDvygB9Dwd/Z5+7V+f6uRJgHJ46rn6PDjjxXbv17iiJZPumN0FEwHd7bq/dex7elF/LlBd7gH6inHjxqWysvxdcc7QLyWV62fO3DkZNWpUucfpEvU1uya1B3Ro353f9d70a5nXyRPRk/SFrwHWrq98/l8a8P5kwHs6tO/mY7dJVUn0L7rnBx+X9Bvd7v3+8a9HMmrUSV0wET1FX3kc7OsaqzdLhnyqQ/se+6mTMnDFfZ08ET2Jx4G+4YVBn0z6j2v3fo9Mf8r9opfzGNA3rKiqS9Y/oUP7nvj5L+e04+/p5InoSTwO9A0LBh2a9H9bu/d76tnnu/V+0dr6fwtWJkyYkGnT2ne6xVcJXd1kzpwe8puRg1uSyqS1pSWzZ/fS39AYNj+p7diu8+c+m6yY37nz0LP0ha8B1q6vfP43WpAM6Niuc597Kmlt7Nx56H6bL0n6tX+35hVLe/fXBn3ncbCvG1CdDOnYri8umJcXF7tv9GoeB/qGzZYk/du/W2vTcveL3s5jQN9Q05Ks37FdX1o4Py8tct/o1TwO9A2jFnfouUCppbFs94t58zq+AEXo6iZ1dXU9Y0VXVVVak1RWVaVu5Mhyj9MlVlQtz/NJUiolFRVt3q+idWnqNhqQivTO/xde1he+Bli7vvL5X9ZvaRZ2YL+qlgUZUTc8bX/kpKd6qXpR6juw38DKBRnWi7826DuPg31da0VV5pZWpFTRjle2rzx33nj9pvQb7L7Rm3kc6BsW91uU9p/ANFmv4oVs6H7Rq3kM6BtKqc6c1mUpVbbjNyBfeS6w0ZDG9K913+jNPA70DUtqXsriDuxXU5qf4d14v2htbV25SGjEiBEdPo7Q1U2mT5+e2toOLjPqRKP2vjyz5y9N3SZ1efbBZ8s9TpfZ5Yhrc8+DL7Rrny8du0t+8OVZXTMQPUZf+Rrg9fWVz39LS2vGHHBluy86+r3T98+px5zeRVPRnWY+szjjDvx9SqX27ffXq87KLtv9uGuGokfoK4+DJMf/vyn5xR8ea/sOFRV5/66bZvIvnLawt/M40Dc8N78ho/e9Is0t7XsycMNlX85eu/ywi6aiJ/AY0Hd88ey7ct6vH2r7DhUVedfbN8qdv76364aiR/A40DcsWLQ8oz7wuyxvbN+12H//s5Nz0J7f66Kp1tTQ0JBBgwYlSaZMmdLh45R/iRF0gVOOaN/5R6urKnLCoeO7aBqA7lVVVZnPHb5Nu/apHVCdYw9u/3Uc6JnGvmVIDnzPZu3aZ5dtN8rO2w7voomA7nby4ePbc3KDJMnnj2jf9w6g59p049p8fJ8t2rXPtm8dlj13ruuiiYDuduKh41NV1b4nA5//RPuv5wP0TBsOXS+f/ODYdu0zZtTgHLBHMa/bJnTRKx35wbH59Ee2bPP2v/j6hLx1sw5eyACgB/riUdvmoPe2LXRUVVXkyh+8LxsOXa+Lp6I7/fLrEzL2LYPbtO2IDQfkd2fvlYr2/lQc6LHesdWG+Z//eHebt//iUW/LwXuN7sKJgO72k//cLduMHdqmbTdYvyZXnfM+zwWgF9ly8/Xz869NaPP2x39sq3zigDFdOBHQ3X542q5559YbtmnbIYP65Y/nvj9VVcVMRsWcugtMnTo1w4cPX/nnhz98ean+7373u9XeP3Xq1DJPSltUVFTkwq9NyKlHb7vO32QduF51fvvdPXPswW2PYgBFUF1dmat++L43XKU1bEj/TPzxPjlgj7d002R0l403HJDbf3Vgdtl2o3Vut83YoZl62YHZYlTbohhQHJ/7xDb5xVkTUtO/aq3bVFVV5GuffWfO+fKu3TgZ0B2GDanJrRd/MHvssO7rXbx1syGZcumB2WqLod0zGNBtjjtky/z6O+/NwPXWfvWaiorktGO3ywVn7i52Qy8zuLZ/bvnl/vnAuzdd53ajNx2U2y75YN6xVduiWE/kGl2vaGpqyoIFC9Z4f2NjYxobG1fbjmKorKzID768az73iW1y4VWP5jcTZ2buC8tSXV2RsaOG5DMf3SrHfGhc1h/cjot0AxRI/35VueSb78np//b2/OzKR/L7v6qGxEoAAQAASURBVMzK8y8uS02/qowfMzQnfHzrHL7fmNQO7FfuUekidRsNzF2/OSh/u2dOLrjy0Uy+a3YWNzRl0MB+2X37jXPy4dtk391GFvY3toA39umPbpVD3j86v7p2ei66+vHMem5JWlpK2XSjgTn6oHH5zEe3yqhNyn8tYaBrDB+2Xm695IOZOm1efnrFI/nz1GezuKEptQOqs+t2G+Xkw7fJB/d4S6qrPReA3urID741H9zjLbns+hn5xR8ey8xnF6e5uZRNhg/IJz/41hz/sa2y+Ui/9Aa91dAhNbnpZ/vl7geez0+veCQTb38mi5asSO2A6uy0zfCcdNj4fGjP0enXr9jPBYSuV+y5554ptfeK7RTC5iMH5zv/vnO+8+87l3sUgLIYP2Zozv+Pd+f8dpzCit6joqIie+2yafbaZd2/wQX0XhsOXS+nHrNdTj1mu3KPApRBRUVFJuywSSbssEm5RwHKZOiQmpxy5NtyypGuwQV9UUVFRXZ9+8bZ9e0bl3uULlPsTAcAAAAAAECfJXQBAAAAAABQSEIXAAAAAAAAhSR0AQAAAAAAUEhCFwAAAAAAAIUkdAEAAAAAAFBIQhcAAAAAAACFJHQBAAAAAABQSEIXAAAAAAAAhSR0AQAAAAAAUEhCFwAAAAAAAIUkdAEAAAAAAFBIQhcAAAAAAACFJHQBAAAAAABQSEIXAAAAAAAAhSR0AQAAAAAAUEhCFwAAAAAAAIUkdAEAAAAAAFBIQhcAAAAAAACFJHQBAAAAAABQSEIXAAAAAAAAhSR0AQAAAAAAUEhCFwAAAAAAAIUkdAEAAAAAAFBIQhcAAAAAAACFJHQBAAAAAABQSEIXAAAAAAAAhSR0AQAAAAAAUEhCFwAAAAAAAIUkdAEAAAAAAFBIQhcAAAAAAACFJHQBAAAAAABQSEIXAAAAAAAAhSR0AQAAAAAAUEhCFwAAAAAAAIUkdAEAAAAAAFBIQhcAAAAAAACFJHQBAAAAAABQSEIXAAAAAAAAhSR0AQAAAAAAUEhCFwAAAAAAAIUkdAEAAAAAAFBIQhcAAAAAAACFJHQBAAAAAABQSEIXAAAAAAAAhSR0AQAAAAAAUEhCV5JSqZSpU6fmjDPOyG677ZYNNtgg/fr1y4gRI3LggQfmuuuuK/eIAAAAAAAAvEZ1uQfoCW655ZbsvffeSZKKioqMHTs2Y8aMyYwZMzJx4sRMnDgxxx13XH75y1+moqKizNMCAAAAAACQWNGV5OUVXWPGjMmPfvSjzJ8/P9OnT8+9996bBQsW5Nxzz01FRUUuvvjiXHDBBeUetcOWNzbnnw+/kMYVLUle/jcD9CX1S5uyounlx8AVTa1pbm4t80QAAN2nVCrlsScXrXxN2NLqNSEA9DXTn3rp/54LtHguQO8hdCXZZZdd8uijj+Zzn/tchg8fvvL9VVVV+cIXvpDjjz8+SfLzn/+8XCN22KzZS3LGuXdn1Ad+lx0PvzYvLGpMksx9YVnOOPfuzJq9pMwTAnStR55YlM9/585s+v7L8/yLLz8GPv/i8my+3xX5fxf8M3OeX1rmCQEAus7SZc35+VWP5p2HXpOtD/7Daq8JP37qzfnr3c+VeUIAoCstb2zOJdc8np0/cW22POiq/3susGBZPvzvf8mkO561KILCE7qSDBkyJP369Vvr7fvuu2+S5LHHHuuukTrFDbc/k20/8secfckDWfDKA9irWkvJ2Zc8kG0/8sfccPszZZoQoGv97/XT846PXZ0fX/5wljQ0rXbb7PlL8/ULpmW7j/4xd943r0wTAgB0nefmN2S3o6/PZ78xNfc9tnCN26/6y6y879M35otn35VWK7wAoNeZv2BZ3vtvN+S4r92eex96YY3br/3r09n3hJvy2W9MdeYbCk3oaoPly5cnSQYOHFjmSdru1nvn5JAvTE7DsuZ1btewrDmHfGFybr13TjdNBtA9/vCXJ3PMmbel6Q2eqC1Y1Jh9T7gp9z++5g9/AACKatHixnzgs39+3cD1Wuf9+qGcce493TAVANBd6pc2Zf+TbsrdDz7/htv+4g+P5fPfudPKLgpL6GqDK664Ikmyxx57lHmStmltLeVTZ92eFU1tq/Armlrz6a9P8Rt8QK+xbHlzjv/G1LT1+dmShqac9N93dO1QAADd6DsX3ZeHZy5q8/Y/uPSBTHtkzd/0BgCK6YeXPZh/PrKgzdv/7PePZuo0Z7yhmISuN3DDDTfk2muvTZKcfvrpZZ6mbf5y5+zMfKZ9196a8fTiTL5rdhdNBNC9rrjpiSx8qfGNN1zF1GnzrOoCAHqF5Y3Nuejqx9u93wVXPtoF0wAA3a2pqTUXXtX+7+ueC1BUQtc6zJw5M0cddVSS5JRTTsluu+1W5ona5uJr2v+CJkmHXggB9EQXd/DxrKP7AQD0JNff+swa12lui99MnJnljes+/T0A0PP95a7ZeW7+0nbv9/tJT+alJSu6YCLoWhUlJ958XXPnzs0ee+yRGTNmZJ999smf/vSn9OvXr13HaGhoyKBBg5IkdXV1qazsnq44f8hn0lQ9qt379Wt+Jhsv/mUXTAQ9x5yhX0pr5fqpbH0pdYt+WO5x6CJz1/9iWqqGtnu/9VY8kg3rf9f5AwH0EL4PQt+wZL3ds3jgPh3ad5MXz0lVaXEnTwT0FJ4LQN9QX7NzXqo9sEP7brzoR+nX6nTGdI/W1tbMmTMnSbL99ttn2rRpHTpOdWcO1VssXLgw++yzT2bMmJHdd989V199dbsj12u9+snqFus1degz27SiObNnO30hvdzglqQyaW1pcX/vzQa3JlXt32358kb3C6B3830Q+obhi5OBHdt17rx5SZPTOUOv5bkA9A0bbpnUdmzX+fPnJ43d+LNseMW8eR2/RpzQ9RqLFy/OfvvtlwceeCA77LBDJk6cmIEDO/gKYRXduaJrQXVjlndgv/WqG7PhyJGdPg/0JHOqqtKapLKqKnXu773W/IqlacoG7d5vYP+mDHO/AHox3wehb1javyIvdmTHUkvqNh6Sygzo7JGAHsJzAegblvWrSod+baVUyiYb1aaq5PGB7rHqiq4RI0Z0+DhOXbiKpUuXZr/99svtt9+e8ePH57bbbsvw4cM7fLxVT11YX1+f2toOZvR2umrSk/n4l29p/37nvC8f/cAWXTAR9Byj9r48s+cvzciNB+bZyZ8o9zh0kR/99qGc8t272r3f1MsOzG7bd/ybKkBP5/sg9A2L61dk5N6Xp35p+663dfh+Y3L52Xt10VRAT+C5APQNy5Y3Z9QHfpeFL7Xvmp0HvXezXPejD3TRVLCmzmoo3bPEqABWrFiRQw45JLfffnvGjh2byZMnv6nIVU4H7zU6m27cvlVom248MAfvNbqLJgLoXkcfNC61A9q3aPkdW22Qd79j4y6aCACg+wwZ1D9HHzSu3fudfPj4LpgGAOhuA9arzqcO2bLd+510mOcCFJPQlaSlpSVHHHFEJk2alFGjRmXy5MnZdNNNyz1Wh/XrV5nzT39Xm7evqEj+54x3pbra3QHoHdYf3D/f++LObd6+X3Vlzjv9XamoqOjCqQAAus9XP/2OjGzHL0AeccDY7P5OK9sBoLf48jHbZYuRg9u8/cF7bZZ9dnPKQorJNbqSXHnllfnDH/6QJOnfv38++clPrnXbq666Kptsskl3jdZhH9tni/zy6xPy2W9OTUvL2s9OWVVVkQv/a3enLAR6nZMP3yaL65vy1f+5d53brVdTld+dvVf23LmumyYDAOh6I0fUZtKF+2W/E2/KM3Mb1rntR/fePBd/Yw+/9AMAvcjGGw7IpAv3y74n/DlPPLtkndsesMeo/Pa7e6Wy0nMBiknoStLY+H/nKn3iiSfyxBNPrHXb5cuXd8dIneJTH9kq243bIOf+74P5w+RZaWpuXXlbv+rKfHTvzfOFT74tu77dqbqA3ukrn35Hdt1uo5z/m4fyp9ueSWvr/4X/AetV5RP7j80XP/m2bDtugzJOCQDQNbYZOyz3XH5wfvTbh/KLPzyW+QtXfz27y7Yb5aTDxueog97qB1sA0Au9dbMhufu3H8qPL384F171WOY8v3S127ffeoOcdOj4/NuHt3S2LwqtolQqrX25D29KZ11IrTPMW7Asd/xrXpY0NGVwbb/stv2IjNhwQNnmgXJx4d2+66nnluQfDy9I/dKmDB3cP3vsuEmGDakp91gA3cr3Qei7VjS15G/3zMn8hcvTv19lthy9frbfesNyjwV0M88FoO9qamrNbf+Ym7kLlqa6qjJv3WxIdhi/oRXdlFVnNRQruvqIERsOyCHv37zcYwCUzehNB2f0pm0/NzUAQG/Sv19V9tltVLnHAADKpF+/yrz/XZuWewzoEtYjAgAAAAAAUEhCFwAAAAAAAIUkdAEAAAAAAFBIQhcAAAAAAACFJHQBAAAAAABQSEIXAAAAAAAAhSR0AQAAAAAAUEhCFwAAAAAAAIUkdAEAAAAAAFBIQhcAAAAAAACFJHQBAAAAAABQSEIXAAAAAAAAhSR0AQAAAAAAUEhCFwAAAAAAAIUkdAEAAAAAAFBIQhcAAAAAAACFJHQBAAAAAABQSEIXAAAAAAAAhSR0AQAAAAAAUEhCFwAAAAAAAIUkdAEAAAAAAFBIQhcAAAAAAACFJHQBAAAAAABQSEIXAAAAAAAAhSR0AQAAAAAAUEhCFwAAAAAAAIUkdAEAAAAAAFBIQhcAAAAAAACFJHQBAAAAAABQSEIXAAAAAAAAhSR0AQAAAAAAUEhCFwAAAAAAAIUkdAEAAAAAAFBIQhcAAAAAAACFJHQBAAAAAABQSEIXAAAAAAAAhSR0AQAAAAAAUEhCFwAAAAAAAIUkdAEAAAAAAFBIQhcAAAAAAACFJHQBAAAAAABQSEIXAAAAAAAAhSR0AQAAAAAAUEhCFwAAAAAAAIUkdAEAAAAAAFBIQhcAAAAAAACFJHQlue6663LiiSdml112yciRI1NTU5PBgwdn++23z1e/+tW88MIL5R4RAAAAAACA16gu9wA9wQ9/+MPceuut6d+/fzbddNO8/e1vz/z583P//ffnvvvuyy9/+ctMmjQp22+/fblHBQAAAAAA4BVWdCU57rjjcvPNN2fJkiV58sknc8899+Spp57Kfffdl2233TbPP/98jjjiiHKPCQAA7VYqlTLln3Nz5H/8LfMWLEuSzF+4PN+8cFrmvrC0zNMBAADAmyN0JTn66KPzvve9L/3791/t/dttt10uuuiiJMkjjzySRx55pBzjAQBAh0x/6qXseNi12ePYifntDTPT3FJKkjQ1t+ZrP/ln3vKB3+Xfv3tnmptbyzwpAAAAdIxTF76B8ePHr3x76VK/8QoAQDE89uSiTDh2Yl54cflat2luKeV/fvtwZs9fmiu+v1eqqvweHAAAAMXilewbmDp1apKktrY2W221VZmnAQCAN9bc3JqDTvnLOiPXqv4weVa+d/H9XTwVAAAAdD6h63W0trZmzpw5ueyyy3LssccmSb797W9n0KBB5R0MAADa4E+3PZ3pTy1u1z4/uvzhrGhq6aKJAAAAoGsIXav42c9+loqKilRVVWXTTTfNMccck1GjRuX666/PKaecUu7xAACgTX7yu/ZfW3buC8tyzS1PdcE0AAAA0HVco2sVdXV12X333dPc3Jxnnnkmc+bMyf3335/f/va32WOPPbL++ut3+Njjxo1LZaWuCOU2Z+iXksr1M2funIwaNarc4wBAl3hu2H8mFf3bvd9xn/92vrT0z10wEQDQE3hNDEBP0trauvLtCRMmZNq0aR06jtC1ioMPPjgHH3zwyr8/8MADOfnkk3P55Zfn6aefzpQpUzp87Dlz5nTGiMCbNbglqUxaW1oye/bsck8DAF1jg/ZHriRpWNqcBt8fAaD38poYgB5q3rx5Hd5X6FqH7bbbLhMnTsyYMWMyderUTJ48OXvvvXeHjlVXV2dFF/QAc6qq0pqksqoqdSNHlnscAOgSz5UaU6qoafd+tQOrM9T3RwDotbwmBqAnaW1tXblIaMSIER0+jtD1BgYPHpz3vve9+cMf/pD77ruvw6Fr+vTpqa2t7eTpgPYatfflmT1/aeo2qcuzDz5b7nEAoEt85IuTc/XN7b/e1u8vOiv77/HLLpgIAOgJvCYGoCdpaGjIoEGDkuRNnVHPEqM2aG5uTpK0tLSUeRIAAHhjJx02vt37bDFycPbd3bU6AAAAKBah6w0sXLgwt956a5Jk++23L+8wAADQBu/bZdPsvO3wdu1zxnFvT2VlRRdNBAAAAF2jz4eue++9N1/72tcyY8aMNW6bNm1a9t9//yxatCjbbbdd3v/+95dhQgAAaJ/Kyopce/4HMvYtg9u0/SlHbJPjP7ZVF08FAAAAna/Ph676+vp885vfzLhx4zJixIjstNNO2XXXXTNy5MjssMMOufvuu7PlllvmmmuuSVVVVbnHBQCANqnbaGDu/N+DcvBem6ViLQu1Nhxak3O+vEvOO+NdqVjbRgAAANCDVZd7gHJ7xzvekfPPPz9//etf8+CDD+bxxx/P8uXLs8EGG2TvvffOIYcckuOOOy7rrbdeuUcFAIB22WiDAbnm/A9k1uwl+flVj+W+xxdk2fKWDBtSk4P32iyH7rtF1qvp8y8JAAAAKLA+/6p22LBhOeWUU3LKKaeUexQAAOgSm48cnG//+07lHgMAAAA6XZ8/dSEAAAAAAADFJHQBAAAAAABQSEIXAAAAAAAAhSR0AQAAAAAAUEhCFwAAAAAAAIUkdAEAAAAAAFBIQhcAAAAAAACFJHQBAAAAAABQSEIXAAAAAAAAhSR0AQAAAAAAUEhCFwAAAAAAAIUkdAEAAAAAAFBIQhcAAAAAAACFJHQBAAAAAABQSEIXAAAAAAAAhSR0AQAAAAAAUEhCFwAAAAAAAIUkdAEAAAAAAFBIQhcAAAAAAACFJHQBAAAAAABQSEIXAAAAAAAAhSR0AQAAAAAAUEhCFwAAAAAAAIUkdAEAAAAAAFBIQhcAAAAAAACFJHQBAAAAAABQSEIXAAAAAAAAhSR0AQAAAAAAUEhCFwAAAAAAAIUkdAEAAAAAAFBIQhcAAAAAAACFJHQBAAAAAABQSEIXAAAAAAAAhSR0AQAAAAAAUEhCFwAAAAAAAIUkdAEAAAAAAFBIQhcAAAAAAACFJHQBAAAAAABQSEIXAAAAAAAAhSR0AQAAAAAAUEhCFwAAAAAAAIUkdAEAAAAAAFBIQhcAAAAAAACFJHQBAAAAAABQSEIXAAAAAAAAhSR0AQAAAAAAUEhC11r84he/SEVFRSoqKrLnnnuWexwAAAAAAABeQ+h6HXPnzs3pp59e7jEAAAAAAABYB6HrdXz+85/P4sWLc+CBB5Z7FAAAAAB4U0qlUv52z5wsWdqUJKlf2pSZzywu81QA0DmErte47rrrctVVV+Xkk0/OjjvuWO5xAAAAAKBDSqVSLvz9o3nbIX/MXp+6IYvrXw5dL9U3ZdyBv88BJ92UKf+cW+YpAeDNEbpWsWTJkpx88snZdNNN861vfavc4wAAAABAh7S0tObo/7w1J3xzah55YtEat5dKyY1Tns2en7ohl103vfsHBIBOUl3uAXqSr3zlK3n22Wdz5ZVXZsiQIeUeBwAAAAA65Evf/3t+/aeZb7hdS0sp//a127PxBgOy34RR3TAZAHQuK7peceedd+aCCy7I/vvvn49//OPlHgcAAAAAOmTW7CX50eUPt3n71tZSvvI/96RUKnXhVADQNYSuJE1NTfnMZz6Tmpqa/PjHPy73OAAAAADQYRde9Wja26z+9ejC3HX//K4ZCAC6kNCV5Lvf/W4eeuihnHnmmRkzZky5xwEAAACADrviz092aL/f3fhEJ08CAF2vz1+j67HHHst///d/Z/z48TnttNO67OOMGzculZW6IpTbnKFfSirXz5y5czJqlHOPAwAA0Ps8N+yrSUVNu/f7xSW/yx9+7JIeAHSP1tbWlW9PmDAh06ZN69Bx+nzoOvHEE9PY2Jif/exn6devX5d9nDlz5nTZsYF2GNySVCatLS2ZPXt2uacBAACAzjekKaluf+hatnSJ18oAlMW8efM6vG+fD13//Oc/U1lZmUMPPXSN2+rr65Mkd9xxRzbZZJMkyeOPP54hQ4a0++PU1dVZ0QU9wJyqqrQmqayqSt3IkeUeBwAAADrd/LyYpgxq935DapZlsNfKAHST1tbWlYuERowY0eHjVJRK7b00Ze8ydOjQvPTSS23e/sUXX8zQoUPbtG1DQ0MGDXr5SUV9fX1qa2s7MiLQiUbtfXlmz1+akRsPzLOTP1HucQAAAKDTXXLN4znua7e3a5/qqoo8Penw1G00sIumAoDVdVZD6fNLjBYtWpRSqfS6f84666wkyXvf+96V72tr5AIAAACAcjhs3zHZYP32nbrwI3tvLnIBUEh9PnQBAAAAQG8ycEB1fv3t96aqqqJN24/edFDOP+NdXTwVAHQNoQsAAAAAepn993hLrj537wxcr3qd240fMzR/u+iAbDLcai4AiknoAgAAAIBe6KA9N8sTNx6a//78jtmsbvXrnuz+zhH5zXf2zLQrP5zNRw4u04QA8OZVlEqlUrmH6K0660JqQOcZtfflmT1/aUZuPDDPTv5EuccBAACAbtHS0poFixqzdHlzhg7un6FD2ncNLwDobJ3VUNa9dhkAAAAAKLyqqspsvOGAco8BAJ3OqQsBAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISupIce+yxqaioWOefRx99tNxjAgAAAAAAsIrqcg/Qk4wbNy4bb7zx6942cODAbp4G6GwNS5vS0tKaJCmVSmWeBgAAAACAN0voWsVXv/rVHHvsseUeA+hEK5pacs0tT+WnVzySW++du/L98xYuzw9+9UD+7cPjsuHQ9co4IQAAAAAAHeXUhUCv9czc+ux42LU57LS/rha5kqSlpZTTfnh3ttj/ytw09dkyTQgAAAAAwJshdAG90rwFy/Lef7shD854cZ3bLWloykGf/0tuvuu5bpoMAAAAAIDO4tSFq7jqqqtyzTXXZPHixRk+fHje9a535aijjspGG21U7tGAdjrlu3fmydlL2rRtU3NrPnHGX/PMXw5PTf+qLp4MAAAAAIDOYkXXKiZOnJhrr702f/3rX/P73/8+p556arbYYov8+te/LvdoQDs8N78hf5w8q137PP/i8lz1lye7ZiAAAAAAALqE0JVkyy23zLnnnpt//etfWbRoURoaGnLbbbdln332SUNDQ44++uhMnDix3GMCbXTJNdPT3FJq934X/v7RLpgGAAAAAICuUlEqldr/0+A+olQq5ZBDDsm1116bt771rXn88cdTUVHR5v0bGhoyaNCgJEldXV0qK3VF6A4Laz+SZTXvaPd+la31qVv0/S6YCAAAAACAVbW2tmbOnDlJku233z7Tpk3r0HGErjfw2GOPZeutt06S3HfffXn729/e5n1XDV1AN3rLZ5OhO7d/v5ZlycOf7/x5AAAAAABYq7q6ujz33HMd2re6k2fpdbbaaqtssMEGWbhwYaZPn96u0LUqK7qg+yxarzUNHdivKkuzyciRnT4PAAAAAACrW3VF14gRIzp8HKGrDfr165ckaW5u7vAxpk+fntra2s4aCViHW++dkz2Pu6Hd+51+/Pvy7X8/vQsmAgAAAABgVaueFW/KlCkdPo4lRm/g+eefz/z585Mko0aNKvM0QFu8Z8dN8raxQ9u1T0VF8tmPb9U1AwEAAAAA0CWErjdwzjnnpFQqZf3118/OO3fgmj9At6uoqMh3/n3nVFS0fZ+TD98mozcd3HVDAQAAAADQ6fp86PrLX/6S//iP/8jMmTNXe//SpUvzjW98I2effXaS5Ctf+Ur69+9fjhGBDjhoz81y4X/tnsrKN65dh+83Jueetms3TAUAAAAAQGeqKJVKpXIPUU7XXHNNDjnkkCRJXV1dRo4cmdbW1jzyyCNZtmxZkuT444/Pz372s1S0Z3lIVj+/ZH19vWt0QRnc8vfn8u1f3peb//7cGreNGz0kpxzxtpx02Pg2BTEAAAAAADpHZzWUPh+6nnnmmfz85z/PnXfemRkzZuT5559PS0tLRowYkXe/+935zGc+k/e///0dOrbQBT3Ho08uyg23P5NFS1akdkB1dtxmeN63y6YCFwAAAABAGQhdBSB0AQAAAAAArKmzGkqfv0YXAAAAAAAAxSR0AQAAAAAAUEhCFwAAAAAAAIUkdAEAAAAAAFBIQhcAAAAAAACFJHQBAAAAAABQSEIXAAAAAAAAhSR0AQAAAAAAUEhCFwAAAAAAAIUkdAEAAAAAAFBIQhcAAAAAAACFJHQBAAAAAABQSEIXAAAAAAAAhSR0AQAAAAAAUEhCFwAAAAAAAIUkdAEAAAAAAFBIQhcAAAAAAACFJHQBAAAAAABQSEIXAAAAAAAAhSR0AQAAAAAAUEhCFwAAAAAAAIUkdAEAAAAAAFBIQhcAAAAAAACFJHQBAAAAAABQSEIXAAAAAAAAhSR0AQAAAAAAUEhCFwAAAAAAAIUkdAEAAAAAAFBIQhcAAAAAAACFJHQBAAAAAABQSEIXAAAAAAAAhSR0AQAAAAAAUEhCFwAAAAAAAIUkdAEAAAAAAFBIQhcAAAAAAACFJHQBAAAAAABQSEIXAAAAAAAAhSR0AQAAAAAAUEhCFwAAAAAAAIUkdAEAAAAAAFBIQhcAAAAAAACFJHQBAAAAAABQSEIXAAAAAAAAhSR0AQAAAAAAUEhCFwAAAAAAAIUkdAEAAAAAAFBIQtdrXHPNNTnooINSV1eXmpqa1NXVZa+99sr3v//9co8GAAAAAADAKipKpVKp3EP0BCtWrMiRRx6Zq666KkkyZsyYbLjhhpk3b15mz56doUOH5oUXXmjXMRsaGjJo0KAkSX19fWprazt9bgAAAAAAgKLprIZS3ZlDFdmnP/3pXHXVVdlvv/3y4x//OGPHjl1526JFi3LbbbeVcToAAAAAAABey4quJJMmTcq+++6bXXfdNVOmTEl1def0Pyu6AAAAAAAA1tRZDcU1upKce+65SZIzzzyz0yIXAAAAAAAAXavPr+hatmxZhgwZktbW1ixevDgPPvhgLrnkksyYMSODBg3Ku971rnz605/O8OHD231sK7oAAAAAAADW1FkNpc+Hrrvuuivvfve7s9FGG+XUU0/NV77ylbz2v2To0KH54x//mL322qtdxxa6AAAAAAAA1uTUhZ1kzpw5SZIXX3wx//Ef/5EDDjggDz30UBobG3P//ffnfe97XxYtWpSPfOQjefbZZ8s8LQAAAAAAAK/q86GroaEhSdLc3JyxY8fm6quvzjbbbJP+/ftnu+22y/XXX59NNtkkixYtynnnnVfeYQEAAAAAAFiputwDlNt666238u3Pfe5z6dev32q3Dxw4MCeeeGLOOuus/PnPf84PfvCDDn2ccePGpbKyz3dFAAAAAACAtLa2rnx7woQJmTZtWoeO0+dD17Bhw1a+PX78+Nfd5tX3P/nkkx3+OK+eIhEAAAAAAID/M2/evA7v2+dD19Zbb73y7f79+7/uNq+u+mppaenwx6mrq7OiCwAAAAAAIC+v6Hp1kdCIESM6fJw+H7pGjhyZzTbbLE8//XSeeOKJ7LXXXmtsM3PmzCTJqFGjOvxxpk+fntra2g7vDwAAAAAA0Fs0NDRk0KBBSZIpU6Z0+DiWGCU59NBDkySXXnrpGreVSqX86le/SpK8733v686xAAAAAAAAWAehK8lpp52WIUOG5Pbbb883v/nNlacobG5uzhlnnJH77rsvNTU1+eIXv1jmSQEAAAAAAHhVRalUKpV7iJ7gxhtvzCGHHJLGxsZstNFG2WKLLTJz5swsWLAg1dXVueSSS/LJT36yXcdcddldfX29UxcCAAAAAACk8xqKFV2v2H///TNt2rR88pOfTHV1daZNm5bq6uoceuih+fvf/97uyAUAAAAAAEDXsqKrC1nRBQAAAAAAsCYrugAAAAAAAOjThC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACqnPh65Zs2aloqKiTX/+3//7f+UeFwAAAAAAgFdUl3uAcltvvfWy++67r/X2JUuW5P7770+S7Lbbbt01FgAAAAAAAG+gz4euTTbZJFOmTFnr7WeffXbuv//+jBo1Ku9///u7cTIAAAAAAADWpc+fuvCNXHbZZUmSo446KpWV/rsAAAAAAAB6CuVmHf7xj3/koYceSpIcc8wxZZ4GAAAAAACAVQld63DppZcmSXbddddstdVWZZ4GAAAAAACAVQlda9HU1JTLL788SXLssceWdxgAAAAAAADWIHStxcSJE/PCCy+kpqYmhx12WLnHAQAAAAAA4DWErrW47LLLkiQf+tCHMmzYsDJPAwAAAAAAwGtVl3uAnmjBggWZOHFiks47beG4ceNSWakrAgAAAAAAtLa2rnx7woQJmTZtWoeOI3S9jssvvzwrVqzIJptskn333bdTjjlnzpxOOQ4AAAAAAEBvMm/evA7vK3S9jksvvTRJcuSRR6aqqqpTjllXV2dFFwAAAAAAQF5e0fXqIqERI0Z0+DgVpVKp1FlD9QYPP/xw3va2tyVJHnjggWy77bYdPlZDQ0MGDRqUJKmvr09tbW2nzAgAAAAAAFBkndVQLDF6jcsuuyxJssMOO7ypyAUAAAAAAEDXErpW0draml//+tdJkmOOOabM0wAAAAAAALAuQtcqJk+enNmzZ6dfv3454ogjyj0OAAAAAAAA6yB0reLSSy9Nknzwgx/M8OHDyzwNAAAAAAAA61JRKpVK5R6it+qsC6kBAAAAAAD0Jp3VUKzoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkISuV7zwwgs544wzst1226W2tjY1NTUZPXp0jjrqqPzzn/8s93gAAAAAAAC8RkWpVCqVe4hye+yxx7Lnnntm7ty5qayszBZbbJFBgwZl5syZqa+vT1VVVS699NIceeSR7TpuQ0NDBg0alCSpr69PbW1tV4wPAAAAAABQKJ3VUKzoSnLiiSdm7ty52WqrrfLQQw9lxowZ+de//pW5c+fm+OOPT0tLS0444YQsXLiw3KMCAAAAAADwij4fupYsWZK//e1vSZLvf//72XrrrVfeVltbm5/85CcZPnx46uvrc9ttt5VpSgAAAAAAAF6rz4euxsbGvHr2xjFjxqxxe3V1dUaPHp0kaWpq6tbZAAAAAAAAWLs+H7qGDx+ekSNHJknuuOOONW5fuHBhHn300VRWVmaHHXbo7vEAAAAAAABYiz4fupLk29/+dioqKnLaaaflkksuybx589LQ0JCpU6fmwAMPTENDQ770pS9l7Nix5R4VAAAAAACAV1SXe4Ce4Oijj87666+fb33rWznuuONWu2306NG57LLLctRRR5VpOgAAAAAAAF6P0JWkVCpl5syZef7551NZWZnNNtssQ4YMyYwZM/LUU0/lwgsvzE477ZTx48d3+GOMGzculZUW0AEAAAAAALS2tq58e8KECZk2bVqHjiN0JTnxxBNz4YUXZuedd86kSZOy5ZZbJkmWLVuWs846K9///vfz7ne/Ow888EDe8pa3dOhjzJkzpzNHBgAAAAAA6BXmzZvX4X0rSqVSqRNnKZz77rsv73znO1NdXZ3p06dn9OjRa2yz99575+abb84JJ5yQCy64oM3HbmhoyKBBg5IkdXV1VnQBAAAAAADk5RVdry4S2n777a3o6qipU6emVCpl3Lhxrxu5kmSfffbJzTffnHvuuafDH2f69Ompra3t8P4AAAAAAAC9xaqLhaZMmdLh4/T5JUZLlixp87bLly/vwkkAAAAAAABojz4ful69Htf06dPz1FNPve42kyZNSpJstdVW3TYXAAAAAAAA69bnQ9c+++yTjTfeOE1NTfn4xz+exx9/fOVty5Yty+mnn56bb745SXL00UeXa0wAAAAAAABeo89fo6u2tja/+c1v8uEPfzj33HNPxo8fn9GjR2fw4MGZMWNGli5dmiQ5+eSTc/DBB5d5WgAAAAAAAF5VUSqVSuUeoid44okncu6552by5Ml56qmn0tzcnOHDh2eXXXbJZz7zmXzwgx9s9zFXvZBafX19amtrO3tsAAAAAACAwumshiJ0dSGhCwAAAAAAYE2d1VD6/DW6AAAAAAAAKCahCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCErpe8fzzz+f000/P+PHjM2DAgAwbNizvec978tvf/rbcowEAAAAAAPA6qss9QE/wyCOPZO+9985zzz2Xfv36Zdttt83y5cszZcqU3H777bn55ptz0UUXlXtMAAAAAAAAVtHnV3S1tLTkox/9aJ577rlMmDAhTz/9dP75z3/m4Ycfzn333ZfNNtssF198cX7xi1+Ue1QAAAAAAABW0edD1w033JBHHnkkNTU1+d///d9ssskmK2/bbrvt8pOf/CRJ8vWvfz0tLS3lGhMAAAAAAIDX6POha8qUKUmSnXbaKZtvvvkatx944IGpra3Nc889l9tvv72bpwMAAAAAAGBt+nzoWrhwYZJk5MiRa93m1dvuuOOObpkJAAAAAACAN9bnQ9fQoUOTJLNnz17rNq/e9thjj3XHSAAAAAAAALRBnw9dO++8c5Lk3nvvzVNPPbXG7TfccEMaGhqSJC+++GK3zgYAAAAAAMDa9fnQdfDBB2fUqFFpbGzM4YcfnmeeeWblbffcc09OOOGElX9funRpOUYEAAAAAADgdVSXe4Byq6mpyZVXXpn9998/d911V7bYYouMGzcuy5cvz6xZs7LhhhvmIx/5SP74xz9m8ODBHf4448aNS2Vln++KAAAAAAAAaW1tXfn2hAkTMm3atA4dp8+HriR597vfnWnTpuW73/1ubrrppjzxxBMZNmxYjj322HzjG9/It7/97STJJpts0uGPMWfOnM4aFwAAAAAAoNeYN29eh/cVul6xxRZb5MILL3zd2x566KEkyU477dTh49fV1VnRBQAAAAAAkJdXdL26SGjEiBEdPk5FqVQqddZQvdELL7yQurq6JMnTTz+98u22aGhoyKBBg5Ik9fX1qa2t7ZIZAQAAAAAAiqSzGoolRm/gzDPPTHNzcw477LB2RS4AAAAAAAC6ltCV5IYbbsjUqVNXe9+iRYvyhS98IRdeeGE22mijnHPOOWWaDgAAAAAAgNfjGl1JJk2alPPPPz9DhgzJ5ptvniR59NFHs2LFiowcOTI33njjmzo/JAAAAAAAAJ1P6Ery4Q9/OPPmzcvdd9+d6dOnp7q6Ottss00+8pGP5Atf+EIGDx5c7hEBAAAAAAB4jYpSqVQq9xC9VWddSA0AAAAAAKA36ayG4hpdAAAAAAAAFJLQBQAAAAAAQCEJXQAAAAAAABSS0AUAAAAAAEAhCV0AAAAAAAAUktAFAAAAAABAIQldAAAAAAAAFJLQBQAAAAAAQCEJXQAAAAAAABSS0AUAAAAAAEAhCV0AAAAAAAAUktAFAAAAAABAIQldAAAAAAAAFJLQBQAAAAAAQCEJXQAAAAAAABSS0AUAAAAAAEAhCV0AAAAAAAAUktAFAAAAAABAIQldAAAAAAAAFJLQBQAAAAAAQCEJXQAAAAAAABSS0AUAAAAAAEAhCV0AAAAAAAAUktAFAAAAAABAIQldAAAAAAAAFJLQBQAAAAAAQCEJXQAAAAAAABSS0AUAAAAAAEAhCV0AAAAAAAAUktAFAAAAAABAIQldAAAAAAAAFJLQBQAAAAAAQCEJXQAAAAAAABSS0AUAAAAAAEAhCV0AAAAAAAAUktAFAAAAAABAIQldAAAAAAAAFJLQBQAAAAAAQCEJXQAAAAAAABSS0AUAAAAAAEAhCV0AAAAAAAAUktAFAAAAAABAIQldAAAAAAAAFJLQBQAAAAAAQCEJXQAAAAAAABSS0AUAAAAAAEAhCV0AAAAAAAAUUq8KXbNmzcpFF12UE044ITvuuGP69++fioqKHHvssW3af9KkSdlvv/2y4YYbZuDAgdluu+3yne98JytWrOjawQEAAAAAAGi36nIP0JnOO++8nH/++R3a95xzzsmXv/zlJMno0aOz2Wab5cEHH8xXv/rV/OlPf8rkyZMzYMCAzhwXAAAAAACAN6FXregaPnx4DjjggJx11lm5/vrrc9JJJ7Vpv7vvvjunnXZaKioq8qtf/SqzZs3KtGnT8uijj+atb31r7rjjjnzlK1/p4ukBAAAAAABoj161ouvMM89c7e933XVXm/b75je/mVKplOOOOy7HHHPMyvePHTs2F110Ud773vfmggsuyFe/+tVsvPHGnTozAAAAAAAAHdOrVnR1xJIlSzJp0qQkyWc+85k1bn/Pe96TLbfcMitWrMh1113X3eMBAAAAAACwFn0+dE2bNi0rVqxITU1Ndtppp9fdZsKECUnavkIMAAAAAACArtfnQ9fjjz+eJBk9enSqq1//TI5jx45dbVsAAAAAAADKr8+HrhdffDFJMmzYsLVu8+ptr24LAAAAAABA+b3+EqY+ZPny5UmS/v37r3WbmpqaJMmyZcs6/HHGjRuXyso+3xUBAAAAAADS2tq68u0JEyZk2rRpHTpOnw9d6623XpJkxYoVa92msbExSTJgwIAOf5w5c+Z0eF8AAAAAAIDeat68eR3et8+HrraclrAtpzd8I3V1dVZ0AQAAAAAA5OUVXa8uEhoxYkSHj9PnQ9eWW26ZJHnqqafS3Nyc6uo1/0tmzpy52rYdMX369NTW1nZ4fwAAAAAAgN6ioaEhgwYNSpJMmTKlw8fp80uM3vnOd6Z///5pbGzMvffe+7rbvPofvOuuu3bnaAAAAAAAAKxDnw9dgwcPzgc+8IEkyS9+8Ys1br/tttvy+OOPp3///jn44IO7ezwAAAAAAADWos+HriQ588wzU1FRkUsuuSSXXnrpyvfPnDkzn/rUp5Ikn/3sZ7PxxhuXa0QAAAAAAABeo6JUKpXKPURnmTp16mqrrpYuXZply5alpqZm5Xkek+Taa6/N7rvvvtq+Z599ds4444wkyejRozNs2LA8+OCDaW5uzq677ppbbrklAwcObNc8q55fsr6+3jW6AAAAAAAA0nkNpbozhyq3pqamLFiwYI33NzY2prGxcbXtXuv000/PO97xjpxzzjm55557Mm/evGy55ZY58sgjc+qpp6ampqZLZwcAAAAAAKB9etWKrp7Gii4AAAAAAIA1dVZDcY0uAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQelXomjVrVi666KKccMIJ2XHHHdO/f/9UVFTk2GOP7ZL9AAAAAAAAKJ/qcg/Qmc4777ycf/753bYfAAAAAAAA5dOrQtfw4cNzwAEHZOedd85OO+2UG2+8MT/96U+7bD8AAAAAAADKp1eFrjPPPHO1v991111duh8AAAAAAADl06uu0QUAAAAAAEDfIXQBAAAAAABQSEIXAAAAAAAAhSR0AQAAAAAAUEjV5R6grxg3blwqK3VFAAAAAACA1tbWlW9PmDAh06ZN69BxhK5uMmfOnHKPAAAAAAAA0OPMmzevw/sKXd2krq7Oii4AAAAAAIC8vKLr1UVCI0aM6PBxhK5uMn369NTW1pZ7DAAAAAAAgLJraGjIoEGDkiRTpkzp8HEsMQIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkCpKpVKp3EN0lqlTp+bggw9e+felS5dm2bJlqampWXmexyS59tprs/vuu7/p/d7IqueXrK+vd40uAAAAAACAdF5Dqe7MocqtqakpCxYsWOP9jY2NaWxsXG27ztgPAAAAAACA8ulVK7p6Giu6AAAAAAAA1tRZDcU1ugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQupVoWvWrFm56KKLcsIJJ2THHXdM//79U1FRkWOPPXat+5RKpUydOjVnnHFGdtttt2ywwQbp169fRowYkQMPPDDXXXdd9/0DAAAAAAAAaLPqcg/Qmc4777ycf/757drnlltuyd57750kqaioyNixYzNmzJjMmDEjEydOzMSJE3Pcccfll7/8ZSoqKrpibAAAAAAAADqgV63oGj58eA444ICcddZZuf7663PSSSe94T6lUiljxozJj370o8yfPz/Tp0/PvffemwULFuTcc89NRUVFLr744lxwwQXd8C8AAAAAAACgrXrViq4zzzxztb/fddddb7jPLrvskkcffTT9+vVb7f1VVVX5whe+kEcffTQXXnhhfv7zn7cpnAEAAAAAANA9etWKro4YMmTIGpFrVfvuu2+S5LHHHuuukQAAAAAAAGiDPh+63sjy5cuTJAMHDizzJAAAAAAAAKxK6HoDV1xxRZJkjz32KPMkAAAAAAAArEroWocbbrgh1157bZLk9NNPL/M0AAAAAAAArEroWouZM2fmqKOOSpKccsop2W233co8EQAAAAAAAKuqLvcAPdHcuXOz3377ZeHChdlnn33ygx/84E0fc9y4cams1BUBAAAAAABaW1tXvj1hwoRMmzatQ8cRul7j1bg1Y8aM7L777rn66qvTr1+/N33cOXPmdMJ0AAAAAAAAvcu8efM6vK/QtYrFixdnv/32ywMPPJAddtghEydOzMCBAzvl2HV1dVZ0AQAAAAAA5OUVXa8uEhoxYkSHjyN0vWLp0qU58MADc88992T8+PG56aabsv7663fa8adPn57a2tpOOx4AAAAAAEBRNTQ0ZNCgQUmSKVOmdPg4lhglWbFiRQ455JDcfvvtGTt2bCZPnpzhw4eXeywAAAAAAADWoc+HrpaWlhxxxBGZNGlSRo0alcmTJ2fTTTct91gAAAAAAAC8gYpSqVQq9xCdZerUqTn44INX/n3p0qVZtmxZampqVi5/S5Jrr702u+++e5Lk8ssvzxFHHJEkGTNmTOrq6tZ6/KuuuiqbbLJJm+dZddldfX29UxcCAAAAAACk8xpKr7pGV1NTUxYsWLDG+xsbG9PY2Ljadqve9qonnngiTzzxxFqPv3z58k6aFAAAAAAAgDerV63o6mms6AIAAAAAAFhTZzWUPn+NLgAAAAAAAIpJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAgP/P3n2HR1H1bRy/N71SQyAh9F4F6V16EUVsYEdsFHvvWHnsXREBu1IEC4LSBOlIEWmh95IAAUJ63X3+iERKArvL7s7O5vu5rvd6H7M7M79lz5ydmfvMGZgSQRcAAAAAAAAAAABMiaALAAAAAAAAAAAApkTQBQAAAAAAAAAAAFMi6AIAAAAAAAAAAIApEXQBAAAAAAAAAADAlAi6AAAAAAAAAAAAYEoEXQAAAAAAAAAAADAlgi4AAAAAAAAAAACYEkEXAAAAAAAAAAAATImgCwAAAAAAAAAAAKZE0AUAAAAAAAAAAABTIugCAAAAAAAAAACAKRF0AQAAAAAAAAAAwJQIugAAAAAAAAAAAGBKBF0AAAAAAAAAAAAwJYIuAAAAAAAAAAAAmBJBFwAAAAAAAAAAAEyJoAsAAAAAAAAAAACmRNAFAAAAAAAAAAAAUyLoAgAAAAAAAAAAgCkRdAEAAAAAAAAAAMCUCLoAAAAAAAAAAABgSgRdAAAAAAAAAAAAMCWCLgAAAAAAAAAAAJgSQRcAAAAAAAAAAABMiaALAAAAAAAAAAAApkTQBQAAAAAAAAAAAFMi6AIAAAAAAAAAAIApEXQBAAAAAAAAAADAlAi6AAAAAAAAAAAAYEoEXQAAAAAAAAAAADAlgi4AAAAAAAAAAACYEkEXAAAAAAAAAAAATImgCwAAAAAAAAAAAKbkU0HXnj17NGHCBA0bNkwtWrRQUFCQLBaLhgwZct7lpk+fruHDh6t169aqXLmygoODFRkZqWbNmunpp59WUlKSZz4AAAAAAAAAAAAA7BZgdAGu9N577+n99993eLl33nlHCxcuVFBQkGJjY9W0aVMdOXJE69ev17p16zR+/HjNmTNHzZo1c33RAAAAAAAAAAAAcIpP3dEVFRWlfv36adSoUfr11181YsQIu5YbOnSo/vjjD6Wmpmr37t1atWqV9u7dq3Xr1qlx48Y6evSobrzxRjdXDwAAAAAAAAAAAEf41B1dzz777Bn/vWLFCruWu/XWW4v8e5MmTTRhwgS1adNGmzdv1ubNm9WgQYOLrhMAAAAAAAAAAAAXz6fu6HKH04OtjIwMAysBAAAAAAAAAADA6Qi6LmDp0qWSpPDwcNWrV8/gagAAAAAAAAAAAHCKT01d6CpWq1WHDx/W3Llz9fjjj0uSRo8erYiICIMrAwAAAAAAAAAAwCkEXaf59NNPNXz48DP+1qJFC40fP179+/c3qCoAAAAAAAAAAAAUhaDrNDExMerQoYPy8vK0f/9+JSQkaP369fr+++/VqVMnlS5d2ul116lTR35+zBQJAAAAAAAAAABgtVoL/3fHjh21du1ap9ZD0HWaAQMGaMCAAYX/vWHDBo0cOVITJ07Uvn37tGTJEqfXnZCQ4IoSAQAAAAAAAAAAfMrhw4edXpag6zyaNGmimTNnqmbNmlq6dKnmzZunHj162L18WFiY0tLS1LFjRx05ckQWi8WN1QIAAAAAAAAAAJiDzWaTzWaTVDDjnrMIui4gMjJSXbp00bRp07Ru3TqHgi6LxaLw8HCnb7cDAAAAAAAAAABA8XholB3y8vIkSfn5+QZXAgAAAAAAAAAAgFMIui7g+PHjWrhwoSSpWbNmxhYDAAAAAAAAAACAQiU+6Fq9erWef/557dix45zX1q5dq759+yo5OVlNmjRR9+7dDagQAAAAAAAAAAAARbHYTj3pywcsXbpUAwYMKPzvjIwMZWZmKjg4WBEREYV//+WXX9ShQwdJ0p9//qmuXbtKkqKjo1WlShX5+/vrwIEDOnTokCSpbt26+v3331WzZk0PfhoAAAAAAAAAAACcT4DRBbhSbm6ujh07ds7fs7OzlZ2dfcb7Trnkkkv0/vvva8GCBdq4caO2bdumrKwslStXTj169NDAgQM1dOhQhYSEeOQzAAAAAAAAAAAAwD4+dUcXAAAAAAAAAAAASo4S/4wuAAAAAAAAAAAAmBNBFwAAAAAAAAAAAEyJoAsAAAAAAAAAAACmRNAFAAAAAAAAAAAAUyLoAgAAAAAAAAAAgCkRdAEAAAAAAAAAAMCUCLoAAAAAAAAAAABgSgRdAAAAAAAAAAAAMCWCLgAAAAAAAAAAAJgSQRcAAAAAAAAAAABMiaALAAAAAAAAAAAApkTQBQAAAAAAAAAAAFMi6AIAAAAAAAAAAIApEXQBAAAAAAAAAADAlAi6AAAAAAAAAAAAYEoEXQAAAAAAAAAAADAlgi4AAAAAAAAAAACYEkEXAAAAAAAAAAAATImgCwAAAAAAAAAAAKZE0AUAAAAAAAAAAABTIugCAAAAAAAAAACAKRF0AQAAAAAAAAAAwJQIugAAAAAAAAAAAGBKBF0AAAAAAAAAAAAwJYIuAAAAAAAAAAAAmBJBFwAAAAAAAAAAAEyJoAsAAAAAAAAAAACmRNAFAAAAAAAAAAAAUyLoAgAAAAAAAAAAgCkRdAEAAAAAAAAAAMCUCLoAAAAAAAAAAABgSgRdAAAAAAAAAAAAMCWCLgAAAAAAAAAAAJgSQRcAAAAAAAAAAABMiaALAAAAAAAAAAAApkTQBQAAAAAAAAAAAFMi6AIAAAAAAAAAAIApEXQBAAAAAAAAAADAlAi6AAAAAAAAAAAAYEoEXQAAAAAAAAAAADAlgi4AAAAAAAAAAACYEkEXAAAAAAAAAAAATImgCwAAAAAAAAAAAKZE0AUAAAAAAAAAAABTIugCAAAAAAAAAACAKRF0AQAAAAAAAAAAwJQIugAAAAAAAAAAAGBKBF0AAAAAAAAAAAAwJYIuAAAAAAAAAAAAmBJBFwAAAAAAAAAAAEyJoAsAAAAAAAAAAACmRNAFAAAAAAAAAAAAUyLoAgAAAAAAAAAAgCkRdAEAAAAAAAAAAMCUCLoAAAAAAAAAAABgSgRdAAAAAAAAAAAAMCWCLgAAAAAAAAAAAJgSQRcAAAAAAAAAAABMiaALAAAAAAAAAAAApkTQBQAAAAAAAAAAAFMi6AIAAAAAAAAAAIApEXQBAAAAAAAAAADAlAi6AAAAAAAAAAAAYEoEXQAAAAAAAAAAADAlgi4AAAAAAAAAAACYEkEXAAAAAAAAAAAATImgCwAAAAAAAAAAAKZE0AUAAAAAAAAAAABTIugCAAAAAAAAAACAKRF0AQAAAAAAAAAAwJQIugAAAAAAAAAAAGBKBF0AAAAAAAAAAAAwJYIuAAAAAAAAAAAAmBJBFwAAAAAAAAAAAEyJoAsAAAAAAAAAAACmRNAFAAAAAAAAAAAAUyLoAgAAAAAAAAAAgCkRdAEAAAAAAAAAAMCUCLoAAAAAAAAAAABgSgRdAAAAAAAAAAAAMCWCLgAAAAAAAAAAAJgSQRcAAAAAAAAAAABMiaALAAAAAAAAAAAApkTQBQAAAAAAAAAAAFMi6AIAAAAAAAAAAIApEXQBAAAAAAAAAADAlAi6AAAAAAAAAAAAYEoEXQAAAAAAAAAAADAlgi4AAAAAAAAAAACYEkEXAAAAAAAAAAAATImgCwAAAAAAAAAAAKZE0AUAAAAAAAAAAABTIugCAAAAAAAAAACAKRF0AQAAAAAAAAAAwJQIugAAAAAAAAAAAGBKBF0AAAAAAAAAAAAwJYIuAAAAAAAAAAAAmFKA0QWgaDabTXmZ2UaXYbeA0GBZLBajy4BJma29O4J9A3CcmfsE9nnXMWM74Pt3nhm/b3vRLpxntnbBd42LYbb2bi/2C+eZsU3wfbsWbQC0AcB+BF1eKi8zW9/VutnoMux2085vFRgWYnQZMCmztXdHsG8AjjNzn8A+7zpmbAd8/84z4/dtL9qF88zWLviucTHM1t7txX7hPDO2Cb5v16INgDYA2I+pCwEAAAAAAAAAAGBKBF0AAAAAAAAAAAAwJYIuAAAAAAAAAAAAmBJBFwAAAAAAAAAAAEyJoAslSl6eVfn5VqPLMIzValNurlU2m83oUmCQ/Hyr8vJK7j5gs9mUk5tfYvcBm62gD7BaS+bnB/sAOBYAxwIl3aljAc6J6AdLspJ+XaCk45wInBOhpB8LnNoHfK0fDDC6AMBdEo5maNq8PVq9KUlr4pO0ZU+y8vIKduCwkAA1rVtWLRpGqd0l0RrYrbrCQn1rd8jNtWrm4n1a/PdhrYlP0j9bj+tkao4kyc/PoppxkWrZMEotGkZpYPdqqlWllMEVw9VOpuZo2rw9+mvDEa2JP6aNO04oOydfkhQU6KdGtcqqRcPyat24gq7pWUPlSgcbXLFrWa02LViZoPkrD2l1fJL+3nxMSSeyCl+vUilcLRpGqWXDKF3euYqa1S9vYLXusedgqn6av7ewH9y+L6XwQCYyPFDN6pVTi4ZR6tCsoq7sWlVBgf4GVwxXstlsWrUxSbOWHtCa+CStjk/SoSMZha9HlwtRi39/B3q2jVWnFpVksVgMrBiulpdn1aylB7RoTaJWb0rS2i3HlPzvsYDFItWoHFnYDw7oWlX1apQxtmC4XGp6jn6ct1cr1h/Rms1J2rD9hLKyC44FAgP81KBmGbVsFKVWjaJ0TY/qqlAu1OCK4WoHEtM1bd5urY5P0pr4Y9q296Ty8wuOBcJDA9Ssfnm1aFBe7ZtV1ICuVRUS7FvnRNk5+fr1z31a+s9hrd6UpHXbjis1PVeS5O9vUe0qpQr6wUZRurp7NVWLjTS4YrjaseQsTZu3Rys3HNWazUmK35msnNyCkCs4yF+NaxecE7VpEq1relRX6cgggyuGq+3Yl6Kf5+/V6vijWhN/TLsOpBaeE5WODFLzf/vBTi0qqV/HKgoM5J4AX2Kz2bTsnyOas+yg1mwuOC9OTMosfD2mQphaNCivFg2j1LtDZbVtGs05kY85+/ro2i3HlJJWcCzg52dRrSqRatGg4Fjgqm6+eX10w7bj+nXhPq2JP6Y1m5O0LyFNpzK+8mWCdem/+8BlLWPUs11l+fmZcx+w2EpqdOnlcjOy9F2tm40uw2437fxWgWEhRpchSVq69rA++H6TfvxjT2GwdSFlIoM0ZEAd3XtDQ9N3aIePZWrM5M36bNpWJRzNuPAC/+rTIU4jBzfQ5Z2rePxH3Wzt3RFG7Bsbtx/XhxPj9e2MncrIyrNrmZBgf93Qt6buu6GhmjeIcnOF7pWSlqMJP23TmCmbtX1vit3LtbskWiMGNdDgPjUVEGDekxubzaY5yw7qo4nxmrl4v+z9lY8uF6I7r66nEYMaqHLFcPcWeQFm7hO84fcwOydf383cqU8mb9aa+CS7l2tYq4xGDGqgIVfWUXhYoBsrtI8Z24E3fP+SlHQiS2N/2KKxU7dof2K63ct1bxOrEYMa6Kpu1Tx+cmPG79teRrSLLbuT9eH38fr61x1Ky8i1a5mgQD9d37uG7ruhkVo3qeDmCu1jtnbhLX2AJM3/65A+mhSv6X/uKwy2LqR8mWDdMbCuRg5uqKoxEW6u0L0OHk7Xx5M2a/yPW3X0tIFO5+PnZ9Hlnaro3hsaqGe7ypwTuYhR+8Xf8Un6cGK8Js3aVRjwX0h4aIBu7l9b993QUI1ql3VzhRdmxjbhLf2gzWbTjIX79fGkeM1edtDu5WKjw3T3NfU07PoGqlje+MEftAHnZWbl6avp2/XJ5M3asP2E3ctdUq+cRgxqoFuvqO0Vgz9oA85LTMrQmMlbNO5H+6+PWiz/XR/t18nz10ddKT/fqh/m7NbHkzZrydrDdi9XMy5Sw66rr7uuqacypcw1IJ6gy0uZrSPzhk7sREq2HnrjL301fbvT6wgO8teLI5rrkVubmO5Ct81m09fTd+jBN1YUjtZ2Rp8OcRo3qqPiKnnuQrfZ2rsjPLlvZGXn6YUxa/Xmlxucvv3YYpEeuKmRXr2vpSnvcpy99IDufGGJDhy2/8Lu2Vo0jNKXL3dS4zrlXFiZZyQczdCwl5dq+p/7nF5HZHig3nqkte66pp5hB3Vm7hOM/j1cE5+kIc8u0sYd9p/Mna1mXKQ+f6mTurSMcWFljjNjOzD6+7fZbJoye7dGjl6mY8nZTq+na6sYTXixk2rEee7OBjN+3/byZLvIyc3X6HHr9Or4f+we8FWUYdfV1xsPt1JkuLF3NpitXRjdB0jS0eOZuvd/yzVl9m6n1xEWEqDXHmypkYMbmm5Er81m09gftuixd1bZHfIW5apu1TTm2faqFBXmwurOz2zt3V6e3i/SM3L19Aer9eHEeLsHfJ3N39+ix4c01ajhzRUcZNyMB2ZsE97QD+5LSNNdLy7RHAcCrrOViQzSB0+21c39axt6oZs24Jxl/xzW7c8t1ra9J51eR/0apfXly53Vpmm0CytzHG3AcTabTV/+sl0PvflX4cxWzujXKU6fPd/R8IHAztiyO1m3P7dIK9YfdXodMRXCNPa5DrrisqourMy9CLq8lDMdWaV2jdTnxxfPXE96plJ2JWjn1EXaPOE32dw0D7XRndifqxJ001N/njEl08Vo3biCprzV1TRTVySnZOuWpxdqxqL9LllfqYhAjX2ugwb3reWS9V2Iq364jdwHiuOpfWPj9uO6/rEF2rwr2SXrq121lKa82dU0d3dl5+Trvv8t17hpW12yvsAAP42+v6Ueua2xaUbw/PTHHt0xarFOpDh/IHe6nu1i9f1rXRVV1vN9+8X0CUb3A0b9HtpsNr306Vq9/Nk/do/cv5AHbmqktx5pbdjAD2fbQUk9HkpNz9Htzy3WtHl7XLK+8NAAffhUO91+VV2XrO9COBa4eNv2nNT1j83Xuq3HXbK+arERmvR6V7W9xLgLPJwTOeb3xft127OL7L6D6UI6t6ikSW90VUwFz4U9F+Po8Uzd8MSf+uOvQy5ZX7nSwfr8pU4a0LWaS9Z3Ib7aD3pyv1gTn6RBj83Xzv2pLllfw1pl9MNb3dSwljF3d3Es5LjvZ+7UsFeWFk5RerGu6FJVX7/a2bC7GmgDjsnPt+rpD1brzS83OB10n87Pz6Inbm+qV+5rYdjAD9qAY06kZOvmp/7Ub4sPuGR9pSODNPa5DhrUp6ZL1ucJH36/SY+9s6rw0SUX69YrauvT5zooNMT7B8N7f4Vw2K4fF+vA/L8li0WhFcqo9nVd1PrFISpdp7KWPzbW6PJcbvqCvbru0fmF82y7wsqNR9Xxtpn6Y1xf1a1e2mXrdYejxzPV855ZLruoIUkpabm64Yk/lZScrXtvaOiy9XpKSdsHVm08qt7DZrks4JAK5jHvMvQ3/fZxL3W8tJLL1usOmVl5GvjgPIempLiQ3DyrHntnpQ4dTdfbj7bx+rDr85+26c4XFrvkYP6UucsPqdOQGfpjXF/FRptvBFNJ6gesVpvueWmJxv+4zaXrff+7TdqfmK6Jb1xmyue3laQ2cCIlW32GzdbKjc6P2Dtbemaehj6/WEePZ+nxoU1dtl5PKUnfvySt33ZcPe/+XUeOuybgkKS9h9LU/a7f9csHPdSjbWWXrddTSlobmPjbTt3yzEKXDXaQpEVrEguPBbx9AODBw+nqftfv2rrH+dH7Zzt+MltXP/SHJrzYUUMGeCb0d6WStg8sWp2g/vfNdVnAIUnxO5PVachMzRnbRy0ammMA4OlKWhv44LtNeuD1FS5d568L96nrnb9p7ti+hgwAvFglqQ3k5Vl16zMLNfH3XS5bp9Vq0/8mrNOBw+n64uVO8vc318xPUslqA0eOZarH3b87NFXlhZxMzdHgxxfoWHKWRgz27uujNptNz3ywRv+bsM6l6/361x3al5iuGR/29IpHHJyP+fZQXNCxDbu1a9pi7Zq6SJvGTNfMy59W+sEk1b2xu4LLm/v5U2f7Y8Uhl4dcpxw4nK4ed/+ufQlpLl+3q6Sk5aj3sNkuDblOd9//luvzn1x74dQTStI+sGnHCZeHXKekpueq38g5+tuBZ/x4Wl6eVdc/Ot+lIdfp3v1mk577aI1b1u0qk37f6fKQ65Qtu0+q5z2zdPyk81OgGaUk9QMPvrHC5SHXKT/+sUe3PbPI6elQjVRS2kBGZp4uHznHpSHX6Z54b5U+mhjvlnW7U0n5/iVp+96TLg+5TsnIytOA++dp2T/2z+vvLUpSG5i+YK/LQ65Tdu5PVY+7Z+nwsUyXr9tVjiVnqec9s1wacp1itdo09PnF+mGO81NBGqUk7QOrNx3V5fe6NuQ65fjJbPW6Z5bid7ruwqmnlKQ2MH7aVpeHXKf8s+W4+gyfrdR0159zu1tJaQM2m013vbjEpSHX6b6ZsUPDXl4qM06KVlLawMnUHPUePsulIdfpRo5eri9/8e7ro6+O+8flIdcpf65K0MCH5ikn1zV3ibkLQddp5syZoz59+qh8+fIKCwtTkyZN9L///U85Oeb7MTtdXma2jv69XRY/P5WqVtHoclzmyLFMDX5igVtCrlP2J6brlqcXeu0FvgffWKG1W465dRvDX1mqTRfxrBdv4Kv7QHZOvq5/bL5bQq5TUtNzdf1j85V+Ec84cKc3vljvsik7i/PquHX6fbF7t+GsHftSNHSUe0KuU+J3Jmv4K0vdtwEP8dV+YMrsXfrwe/eGEJNm7dInkze7dRue4Ktt4In3Vmn5uiNu3caDb6zQ6k3uCdI8xVe//9xcqwY/vsAtIdcpGVl5GvTYgot6xoE38NU2sD8xzW0h1yk79qXojlGLvfICn81m090vLnXZ9N1Fb0Ma8uwi7TqQ4rZteIKv7gNpGbm6/tEFF/VMtgs5fjJbgx5b4LJpoIziq21gw7bjGvHqMrduY018kh5+8y+3bsMTfLUNfP7TNn35y3a3bmP8j9v0za873LoNT/DVNvDA6yv0zxb33ARwyj0vLfXaQQ8LVh7Scx/97dZtzF1+SC+P/cet27hYBF3/evvtt9W7d2/Nnj1bkZGRqlevnrZs2aKnn35aXbt2VWam945gs0dk9YLOKzvZe+9OctTI0cuU5OD886smXqn9cwdr1cQr7V5m0ZpEfTzJ+0Yy/7Z4v7742bEfcmc+f06uVUOeW6S8PM8+z8LVfHEfeHHMWsXvTHZoGWfawM79qXr6g9UOVud+G7cf1wtj1jq0jDOfX5LuenGJklO8666mghHGi5SZ5dgJtzP/BlNm79ZUE45kPpuv9QNHjmVq5OjlDi/nTBt44t1V2rnf3Bf4JN9rA3+uSnD4bitnvv/8fJuGPLvI9Bf4fO37lwoGfPy92bFBT860gQOH0/XIW+a/wOdrbcBms+muF5YoJc2xC/zOtIGZi/br6+ned4Fvyuzd+vGPPQ4t48znz8gqmM7VWwdA2svX9gFJevK9Vdp90LFncjnTBjbuOKGXxzp27uGNfK0N5P57vSLXwesVzrSB8T9u0+ylrnnuj5F8rQ3sT0zTww4eozh7XeCB11fo0JF0h5bxRr7WBmYu2qevpnvm+ujtzy32uuujaRm5Gvr8YoeXc+bf4H8T1mmNF8/6RNAlaeXKlXrsscdksVj05Zdfas+ePVq7dq22bNmi2rVra9myZXrqqaeMLtNuAaFBCi4XqeDypVSmflW1GX2nyjepqaN/b1fKrgSjy3OJGQv3aercPQ4vVykqTHEVw1UpyrEHKj/53molHM1weHvukp2Tr3tecvwOC2c//+pNSV4Z9hWnJOwDm3ac0OtfrHd4OWfbwAffx3vVaH6bzaa7X1rq8AmNs5//4JEMPetlUxhO+HGrFv/t+FRSzv4bjHh1mdfe2VeUktAPPPr2SocHfEjOtYGMrDyNdPNIWVfz9TaQl2fVnS84fkLjbB+waWey3vpyg8PbM4qvf/+StHN/il781PGLrs62gQk/bdOi1eb5tysJbWDS77ucmr7Z2TbwwBsrdMKLBv6kpudo5GjHf5uc/fwLVye6/Y4BVyoJ+8DKDUf18STH7zp3tg289vl6rx3NX5SS0AY+nLjJ4QEfkvNt4K4Xl3j91F2nKwlt4P7XVjg84MPZ7z85NUcPvmGugT++3gaysvN0twevj67ceFRjpnjXbCcvjlmrPYccDy2d+TfIz7f9++gM7xz4E2B0Ad7g5Zdfls1m09ChQ3XbbbcV/r1WrVqaMGGCunTpojFjxujpp59WdHS0gZXap/njg9X88cFn/G3PzBX666nxBlXkeu99u8mj28vIytO4aVv1/LDmHt1ucabN3aMDhz07iuT97+J1342N5Odn8eh2nVES9oGPJsZ7fETpB9/F6+vRXTy6zeKs2pjk9qm6zvbFz9v16n0tVToyyKPbLYrNZtN733m2Hzx6Ikvf/7ZTd11b36PbdZav9wOJSRmaOGunR7c5e9lBbd6VrAY1y3h0u87y9TYwc/F+7dzv2Aj2i/Xx5M16/PamCgz0/rFyvv79S9KYyZsdHvBxsd7/Ll6dW8Z4dJvOKgltwNPnRCdTc/TVL9v14C2NPbrd4nw3c6eOJXs2eHvv2426/ao6slg4J/IG73v4eDg/36aPJ23Wx8+09+h2neXrbSA/36oP3DyF99n2J6brpz/2alCfmh7drrN8vQ3sOpCiXxbs9eg2p83bo30JaaoaE+HR7TrL19vA1Ll7dOiIZ29MeP+7TRo5uKFXXB9Nz8jVZ9O2eHSb/2w5rkVrEtXFC88JvP8s1c1SU1M1Z84cSdJdd911zuudO3dW3bp1lZOTo+nTp3u6PKds/WaOZl//oube9KpWv/yNso6nKjymvPKz/5tXv8uYh9Rl7MNnLBdUJkLX/zNONa/u5OmSHbJ1d7L++OuQx7f72dQtXnN76icGjB7YfTDVNLfp+/o+kJKWo29meH7qmMmzdzl194g7GPG8oIysPH39q3eM4l28JtHhaStd4ZMpm7125M7ZfL0fmPDjNuXlef67+NTLRq+dj6+3ASP6wYSjGR6/mOAsX//+M7Py9PnPnn8g9i9/7tWBRHNM2ePrbWD1pqNaudHzd9t/MmWzV0zfZ7PZNGaKZy/sSNKG7Se07B/PDrZylq/vA0eOZeoHA6bW/mbGDqWmm+OZhb7eBn5fckB7nbiL4WKZ6dm1vt4Gxv6wxa3Pqy6K1WrTZ1M9//vjLF9vA0bsjzv3p2rucsfvqHeH73/b6fAdja7gbXe1nVLig661a9cqJydHwcHBatmyZZHv6dixoyRpxYoVnizNaSm7EpWweIMOzl+rjZ/8oj9ue01RzWqp3ev3FL5n+VPjFN2qnmpc1aHwb21H36kjK7do14+OT4PjSd/O9OwI9lMOHsnQ/JWeD9jOtutAipaudXy6Mlf4yksu8l+Ir+8DP/2xV+mZeR7fbk6uVVNm7/L4ds+WnZOvyQbV8ZWXPJvia4MegvvPluPauN0c07X4ej9gVBv4ZsYOr7jAaQ9fbgOJSRma48R0Za7g6Pz3RvHl718qeF7SiRTPX2jNz7fp+9+MORZ3lK+3gW8M+h3YvjdFf20wPuhZv+241m9z70Pni0M/6B0mz97l8btaJSk1PVc/zzfHoA9fbwNGHQ8vWpOoPQ4+F84ovtwGbDabYW3AW64L2MOX28COfSken+nnFKPa3tmMqmPavD1K88JHW5T4oGvbtoKRkNWqVVNAQNEzOdaqVeuM95rN0dVbtXPqItW4qoMqtKwnScpJTtOyR8aozat3KrRiWVW7vK0qtW+k5U+MNbjaCzPyxMqIUZNn+2u9cTWs3OC9Dxw8H/YB11m50fg2sGH7cWVlGzMv+rptx5SV7fmQ8Wx/bTCwH/CCftAZvtQPnEjJ1ra9Jw3ado527EsxZNsXy5fawCoD++KVG4+a5s7O0/nS9y8Z2xfzO+AdDD0WMHDbp3As5Dhf2weM7QeNPydyBm3AN7Z9MXypDexPTFdiUqYh2z5wOF0JRz07XZ6r+FIbKOnXh/PyrFqz2Zjfo7w8m9Y68XxEdyvxQdeJEwUj08uWLVvse069duq9ZrTu3amy5uWr+WODCv92cME/2vPrMnX+6H61fe0uLXtkjLJPeP62b0fYbDatiTduRzJy2//VYNxB9e6DqTp+0nseQO0IX9kHJGPboZHt778ajPv8eXk2bTD4jqaMzDzF70o2bPve0Aac5Sv9wN8G/xbRBoxn5Hdw5HiWDh4254m9r3z/krFtgD7AeHl5Vq0z6G4miXOiTTtPeMXAJ2f4yj4gcU7kLF9pA8eSswyZtvAU2oDxjP4OjN7+xaANXLwd+1J0MtXYaWy37E5WZpYxg8Al79wHSnzQlZVV8LyZoKCgYt8THBwsScrMdGykgM1mU3p6utLT0w0f+Zq6J1G7f1mq2M5NFd2mQeHfV7/4tSJrVNLB+Wt14I+/DazQPoePZRoatGzcYXzYucmA5/KcsX0v+Ddwhq/sA1LBybVR4nclKz/f2GfVGfn5JeP7ga17kg2dOs7oz38xfKUfKOn7wMWgDbiGWduAr3z/krHHg3sOpSndC6cqsYevtIFdB1INu7td8o4+wMh9IC/Ppq17jLmz+mL5yj6Ql2fVlt3Jhm3fG/YBZ/lKGzD6ugRtwHgcDzvPd9pAssHbN7YNGP35XbkPuCpDKXquvhIkJCREkpSTU3wKm51dEKyEhoY6tO6MjAxFRERIkmJiYuTnZ3+uGGjz0yi1dmh7F7L+/WmqcVUHNX9skGZf+4IkKS8zW2l7j+jE5n0Xte66deoq1+L+i995fuWkMg8U+/qqiVeqUlRYsa9Xigot/P/75w4u9n2JSRlqdcP0c/6+a88BxcXFOVCx6x2NvF0KrF7ka676/FLx/wYDrx2kkFzXPpvBHe29KO7cB4rj6n3DJim93IvFvu7ufcBqtalKtVryk3EXuE6ED5CCLy3yNU/sAw898qSeu3elAxW7VnZAVanUHUW+dqHPL118G1ixcq3i4oY5ULHj3NknuLsf8MTvYWpIJymsR5GveaINvP/Rp/rqjVkOVOwcd7UDXzgeSoq4WQqqU+RrnugHb7rldoXmuvYBxBwLOOZI2aclS3CRr7n7WECSatdrJH+b++/s45yoaDn+laTSw4t8zRO/Axs2bTH8nOhIqWFSQEyRr3miH+zRu7+C8/Y7UPGF+Wo/6I79wqog2co9U+zr7u4HU9OyVTkuThYHanYGx0LFywqsI0XeXORrnugH581frLi4os/JXIk2ULyToT2k0E5FvuaJ34HRr72lj0YtcKBi59AGinc0cqgUWK3I1zzRBq686jqF5Bn3HPv0oEuliAFFvuaJfvD7SdM0a8INDlRcPKvVqoSEBElSs2bNtHbtWqfWU+KDLnumJbRnesMLOfVl2SvI4i9VdGwbics36cuYa4t9/eT2g/o6blCxr1+MQwmHlGPzwKjCoFypTPEvV4oKU1zF8AuuJsDfz673nc2ab9XBg8Y8/L1QzRwpsOiX3P35JelY0nEpzbX/Bs6096IYuQ8Uxy37RrniX/JEG0g4dEiyGXiLduVMqehrex75/CdPntTJYwb2A2FhUqmiX7L380vO/xvk5ua6vR+8mD7B6H7AI7+HFVKlYo5ZPdEG0tPSlZ7g/n3A2XZQIo6HqmdLxUxG4Il+8PjxE1IKxwL2cku7KCMVd4XVE20gMfGwlOf+5/VxTlSMEH+pdNEveeJ3IC8v3/hzotC8Yq9meGIfSDqaJGXQD9rDLfuFX4jh50SHPLAPcCx0HpHlpMiiX/JEP5iTneORfpA2cB4V06Ri7kfwRB+Qmpqm1MO0gaJ4rA3UzDX2+uixYy6/PuqQsjWliKJf8kQ/mJmZ6ZZ+8PDhw04vW+KDrrp160qS9u7dq7y8PAUEnPtPsnPnzjPe6wxn7uiSsbODOSQ2JtYjaX2+JUKJ53k9Men8I0srRYUqwN9PefnW8z60srj1+Pvlq1LlyvaU6jZJgRYVN3mjqz7/+dYVVT5SwaVd+29gtvbuCHfsG4dsObJZir7C6e59QDarYmOjZZFxU+clhwUovZjXPLEPlCkVqvAQ4/qBHP/SKu6xpxf6/NLFt4GgAJsquLkfNHOf4Infw7TgEBU3YZIn2kBEeJBKe+C30IztwFPHQ8eCLcoq5jVP9IPly0UoJJJjAXu5o10kKFfWYkZ9uP1YQFJMxfLyK+4KowuZrV14qg/I9Suj4h6/7onfgUB/q6INPic6GmBTccOuPNEPRkeVUmA+/aA93LFf2OSnQzarZCn6Gou7+0GLchTLsVCRPNUPZgdEqrinw3iiHwwOsiiKNlAkT7WBlJBgpRbzmid+B0pFBCsygDZQFE+1gaQgGXx9tJTLr486IiMoTMXdtuOJfjAsxF9lXdQPnn5HV8WKzo/6KfFBV/PmzRUUFKTs7GytXr1abdu2Pec9S5YskSS1adPG6e1s375d4eH2p6O5GVn6rlbRt2F7o23btykwLMTt27HZbCrf6VudSCn6tKa46VVO2T93sOIqhisxKVNVek5yePv9ezTXz+8fcHg5V3rkrb/0ztcbi3zN3Z9fkrb8M1/ly7j2uzZbe3eEO/aN1jf+olUbiz6sd3cbaFS7nDb+5NppWhz16ZTNGv7KsiJf88Q+MPuXL9S6SQWnlnWFjMw8Rbb7usjndF3o80sX/28w9MY+GvPcyw4v5wgz9wme+D2ct+Kget5d9NSBnmgDY997Xjde/pXDyznKjO3AU8dDoz7+Wy+NLXo6B0/0g2uXz1CVSsUMH3SSGb9ve7mjXXS74zctWFX0jBHubgPVYiO0Z71npmkxW7vwVB+Qm2tVZLuvlZ1z7mhpT/wODLqqk74Z/ZzDy7nS3S8u0bhpW4t8zd37gL+/RXu2/qXQENdeTjFbe7eXu/aLBgOmasvuoof+uLsNtLmkipZ/6/7rAmZsE57qB5NOZKlCl++KfM0T/eD9d1+jNx5+3eHlHEUbKN6P8/bomof/KPI1TxwPfzv+DV1xWVWnlnUEbaB4D72xQu99u6nI1zzRBrav/1NlShUz3ZAHbNh2XE2v/anI1zzRD77y3Ag9dMsnDi9XlPT09MLHP53KYZxR4oOuyMhI9ezZUzNnztS4cePOCboWLVqkbdu2KSgoSAMGFD3vpdnNumaU0SXYzWKxqGWjKM1dfsiQ7bdsFGXIds+ooaFxNdSoHOnykMsbmGkfkAraQHFBl7u1MLD9eUMNAQEWNa3r/DS2rhAWGqCGNcsY9vBbb2gD7mCmfsDo78AbfgvdwVxtoLxh244uF+L09B7ezEzfv1TQDxQXdLmbkcei7mSmNhAY6Kdm9crprw3F3ePtXt7QBlo2iio26HK3xrXLujzk8gZm2gekgn6wuKDL3Vo2Mm7QmzuZqQ1ElQ1R1Zhw7Usobq4P9+J42HhGfwdGHo+7E23APrWqRBoacklSg5plFBrir8wsD0wTWQRvOB48m/1z6fmwZ599VhaLRV988YW++uq/Eco7d+7UHXcUPFzynnvuUXR0tFEl4jStGxt3UNnKCw5ojbyTpFVj7+vESiJj24Dx+0CTOmUVHORvyLab1imnkGDjL2zQD5RsZUsFq061Yh7U5mZlIoNUu6ox28Z/jOyLWzWuIIulmIdDwWP4HUBJPx409pyQfcAb0AZQ0q8NlXRVKoWrYvliHtLlZpWjwxQb7XsDv8ympPcBAQF+urSBMb9HAQEWNat/nodlGoSgS1Lbtm312muvyWazaciQIapevbqaN2+u+vXra8eOHWrTpo1ee+01o8vEv27uX9uQ7cZGh6lb61hDtn26WlVKqd0lxoSut15hzL89zjSwW3WFh3o+bAkK9NOg3jU8vt2zhQQH6PpextThLfvALQb1g03rllPTut53MFMSGdUGbu5fW35+hBxGi6kQph5tjTkm8ZZ+sKS7vFMVlS1V9PM63cnPz6Ib+9Xy+HZxLqN+B2pXLaW2TY0fAHpJvXJqXNuYu+xvvaKOIdvFmQb1qanAAM9f0ooIC9RV3ap5fLs4l1H9YMfmFVUjzv3PqcT5WSwWw9oAvwPeoU610mpj0MAfbzknMmofGNituiLDPX8uciEEXf96/PHHNWvWLPXs2VMnT57Uli1bVLduXb366qtauHChwsLCjC4R/6pfo4y6tY7x+HbvvqaeAgO9Y5cZObiBx7dZo3Kk+nSI8/h2ca7SkUGGBL7X966hCuWMGTF1NiP2gdAQf912pXcc0HZpWUkNapbx+HZHDm7AnRxe4s6r6ykgwPPfxfDr63t8myiaEf1gpahQLu55ibDQAN1+VV2Pb3dA16oufz4bnNOqcQVD7q4bMaiBVwx4sFgsGjHI8/1g49pl1fFS5x+SDtepWD5U1/as7vHt3tK/lkpFeN/FvZLo8s5VVDXG83fVGHEMhqINu76+PH166udn0T3X1fPsRlEsI/bHmnGR6u0l10dvuryWSkUEeny7RhyD2cM7rtp7id69e2vOnDk6ceKEMjMztWnTJj399NMKDjZ2zk2c64GbGnl0e6Eh/rrrGu/5Ibu2Zw3FRns2fL3vxoby96fL8Bb3Dvb8RYb7bvDsfnc+rZtU8PjInSFX1jF8DuZTLBaLx/vB8mWCGcXvRWIqhGlQ75oe3WbPdrFqWMvYZ9ThP/07V1VND48mHjGogYICjZk6Fucafn0Dj9/NcP+N3nMsAM+fE5WKCPSaQT+SdHP/WipX2rPHZg/c1IhBP17E032Sn59FIwc39Og2UTx/fz+Pn6PGVQzX1T2qe3SbKF6tKqV0RZeqHt3mwG7VVC2WO/q8xXW9aiimgmevj95/Y0OvGPQjFdxlfOfVnr1e3bRuOXVpWcmj27SX8Q8agUtE1qikTu/fp+BykcpNzdCSBz5S8rYD57yvzg3d1OTegZKfRYlLN2r5k+Nky8tXpQ6N1eKZmxQYHiKbTTowb43WvPqdZLMZ8Gku7IrLqurq7tX14x97PLK90fe19Kr5d4OD/DX2uQ664r65HtnepQ3K614O6L1K4zrl9OhtjfXGFxs8sr2RgxsY+iyIs1ksFn02qqNaDv5FuXlWt28vNjpMr97f0u3bccSdV9fVNzN2aOnawx7Z3sdPt1dEmOdHCqF4bz/aRrOWHtCx5Gy3bys0xF+fPNPB7duB/QIC/DRuVEd1v+t3j2yvYa0yemxIE49sC/apXbWUnr27mUZ98rdHtjdkQB1d1srzsyqcjz3nQBFxFdTx/XtVrnF1pe07ouk9HytyXb1/GKXyTWrq+/q3Ff6t8cirVPv6LrLm5Ck/O1d/Pfu5kv7Z4dbP5Igb+9XSV9O3a+7yQx7Z3ruPtfV4sHQ+keFB+vDJdrrpqT89sr1Ol1bU0IGev5MSxWt7SbSGXVdfn/6wxSPbe+L2pmpk0JSZp7vY6z+1B3VVwzv7Fb4vLLa8Dq/YrAV3vKmAsBB1nfCoyjetKT9//zP6xIi4Crp6xUdK3ryv8G8L7nxLqXs9cz5SlAduaqTvftuhf7Yc98j2Pnu+g+GDftz5/Z+u43sjVXtQV31f71blpGRIki4b94iiW9ZTWKVyZ/zdSB882VYLViUoNT3X7dsqHRmk9x5v6/btXMjFtoEKLeqq3Wt3SZIsgQE6snKz/nr2c1lz8s67nL1tx5NCggP06bPtNeCBeR7ZXstGUV434OGF4c01bd4e7T2U5vZt+ftbNP6Fjl476Iegy0e0f+Mebft2rnZM+VPVLm+rju/fqxl9nzzjPRFVotX88cH6tdfjyjyarG5fPqF6N/fUli9nKedkuhYOe1dp+47IPzhQvaY8r9rXddGOKX8a84EuwGKx6JNn22vhmgSHLvAlJmWc8f/t0bF5Rd3v4dGS9ujfpapuvaK2vv7V/pNtZz5/YICfvny5s9dM23g6e3/cz/c+/+BAdfn0IZWuE6f8rBxlJZ3U8ifHKXVPoiSp56TnFFqhjGS1Kjc9S389+7mOb9x9xvprD+qqju+N1PzbX9e+Wavc/rlPeXHEpfp14X5t3pVs9zLOtIEalSP12oOtHC3P7ZrWLafn7mmm5z+2/wKfM59fksaN6qiyXnI31yn+/n764qVOuuS6n5SZlW/3cs78G1zTo7qu94Lns12IvX1C65eHqmrvloqoEq3pPR7V8U177H792pWfKD87V/lZOZKk9R/+pD3Tl7nzYxWrYvlQffRUO93wxJ8OLedMG3jtgVaqXbWUQ9vxNtUub6uYTk20f/YqNX/iBvkFBig/M1vLHh+rE/F7JUmVuzXXpU/eIIvFIkuAvzZ+8ot2/rDQ4MqL161NrIZfX19jpth/gc+Z79/f36IvX+6skGDvO3VwxbGAJPkFBajVqNtU+bJmys/O0fH4vVp87wdnrKOo33uj28xTd1yin+fv1dotx+xexpk2UDk6TO8+1sbh+tzNnnOgnLRM/f36RAVFhunSJ28ocj0N7+mv1L2HVb7Jf3fKlmtUXfWH9NbPXR5SXkaWal7TSW1G36GZ/Z5y62dyhMVi0fgXOqnx1T86dIHPmTbQt2Ocbr/Ke+7mOuWGfjX1w9zd+nn+XruXcebzh4UE6IuXO3vNCO7TuaofPN8xjjefE73xcCv9vvSAQxf4nGkDjWqV0ajhzR2uzx0u9vrPjskLtGPygsL3Dljwjnb9uEiSZM3L04aPflZOcpr6THvxnG3npWUVO2DACIGBBdcrWt7wi/Ly7B+o7UwbuP2qOurbqYrDNbqaO7//U6r2ayNr3rnnmFu/nqMVT47T4I2fu+fDOaFabKTeeqS17nlpqd3LOHtd4N3H2iiukvGD4C+2DRyP36Nf+z4pW16+ZLGo64RHVX9IH8V/NuOi244RruxaTTf3r6VvZ+y0exln2kDQv/1NgAHPhzyfyPAgTXihk3rc7dgASGf+DZ64valaNfaeQfBn876zVTgspHwplb+kluYMflmStHfmCrUdfYciq1cqvFgvSdX6t9X+OauVeTRZUsEPVNMHri7o5E47SM3PztXxjXsUUcX4hwyfT8Xyofr+tcvU/965dt/R0eqG6Q5to3J0mL79XxevPKGRpA+ebKd1245r3Vb7Ri85+vkl6eOn26lJ3XIOL+cJ9vy42/O+rd/M1cH5ayVJ9W/vow5vD9esa0ZJkhbe/XbhKKWqfVur43sjNb3Ho4XLRsRVUN2beujI6q3u/KhFCgkO0OQ3uqrz7TOVnJpj1zKOtoGIsEBNeaur197J8+TQS7R83RH9vuTck/miOLMPPDG0qfp5wQlNUepUK63xozo5NJLZ0X+D+jVK69PnOnjtiJ3T2dsn7J25XBs/+Vn9fnmlyPVc6PWFw949JxwzyqA+NbVoTaJDQYejbeC6XjV07w3eNWrNGVX7tdH+2avU6aMHNGvgc0redkDRbRqo88cP6JeuD0uSOn90v2Zd84JObN6riLgKGrj4fe397S/lpWcZXH3x3ny4tf7efEx/bThq1/ud6QfffqS1157QuOpYoMUzN0s2m37scJ8kFVzQPU1xv/dGt5nAQD9NeqOrOtw2Q0kn7Numo20gJNhfk97o6jXT955i7zlQTnKajqzcokrtih64VqZunKr2aa2lD36s6v3bFf7dZrPJL8BfAWHBysvIUlCpcGUkeOaOAUdUjYnQV6901rWPzJfVat9FXkfbQM24SH3+UievPBawWCz67PkO2rwrWVv3nLRrGUc/v8UiTXixo2pV8c4BH67qB6Xij3G8+ZwoMjxIU97spm53/qb0zDy7lnG0DZQtFaTJb3ZTcJDx0/e64vrP6aKa11FIVGntm71akmTNyVPi0o2KiPPO3/2iXFKvvD56qr2GvWx/0OFoG2hev7xX3Mnj7u9fkkKiSqvp/Vdr1jWjVPemHme8P2GxZ2aUcdRd19TT4r8T7Q46nDkeHjKgjoYMMH7AhyvaQH7mf9eP/IMCFBASVDij18W0HSN9+GQ7rd92Quu3ue/66CfPtPeKu3qL0r1trEYNa64XP11r9zKO/ht0ax2j54d5x4CP4nhXBAmnhFeOUubhE7Ll/xf2pB1MUnjlMx9OHFE5SmkH/rsIknbg6DnvkQpO7Kv3b6v989a4r2gX6dU+TpPf7OqW5xPERodp3ri+Xj33bunIIM3+tI8au6mjfe/xNrrr2vpuWffFOvXjvnNaweiRvTNXKDy2vCKrV3LoffnZuYUhlyQd/Xu7Iqr8d1B/+q34QZFhZ07nabGo/dvD9dezEwpv8fa0JnXLadaY3ioT6foHIkeEBWrGRz3VspH3nuQEBvpp6tvd1aNtrFvWf9+NDfW/B7xrysKz3Xh5LX32fAe3PIS3brXSmju2r6LKhrh+5S5mb58gSYdXbD7vxcoLve5NLBaLPnq6vdtG2V95WVWvHvBxuqBSYbpuzVgN3vSFrpz7pq5a9J5u2TNR7d8aJkuAvyq2qqfUvYeVfSK1cAT7kb82K7xylMo1Kbhj0WaTgkoXzPEeGBmmrBOphvXv9goPC9Rvn/RWi4bnHtO5wqv3tdADNzd2y7ovlquOBQJCg1Xnhm76+7WJhcucOrmXdN7fe29oM3Wrl9bcsX3c0leHhvjr5/d6qOOl3jcPv73nQOdjCfBX+7eGa/njY89YjySdiN+rTZ/N0LUrP9F1a8aq4d399dczE1xWvysN7F5dX73SWf7+ru+rq8dGaN5nfVUpyrPPv3BEhXKhmvtZH9Wp5vogymIpuLN/cF/vfE6pq/rBC/H2c6LWTSro1w97KjzU9WO5y5YK0qwxfbzm4qarr//UubGbdk5dWHBnhx0CwoLV//fXdMWcN3TJQ9fK4ucdlxXvua6+3n60tVvW3fTfc+5SEa4/53aUJ77/9m8N0+qXv/HqgV5ns1gs+vzFzrqul3tmIbmhb02NG+Ud07W5qg1ExFXQlfPe0uBNnysnJUNbvpxt13KnONp3uFuZUsGa/WlvNapVxi3rf/+JtrrDw8/CctSo4c3dNtV85xaV9PP7PbxiwMf5eMcvErxGYESoun/9pDZ88ouOrbP/lk8jDexeXb9/0luVokJdts4WDaO05Mv+ql+jjMvW6S4Vy4dq4ReXq0+HOJetMzI8UN+M7uK1F7Yk+3/cHb0I0vDOfto3+8ypNjp+cJ+uW/2pmj8+WIvu+7Dw743uuUJHVm3RsfW7XPGRnNamabQWfnG56lYr7bJ11oyL1IIJfdWlpXc9i6MoYaEBmvFRL5c+MyEgwKL/PdBS7z/R1isOZi/krmvra8qb3VwaeHZtFaPFX17uFVMz2MMVFzzt1fGD+zRg/ttq//ZwBZc3fnS3n1/B1FXP3dPMpYHUyMENNPXt7oY/h8BeOSkZ2vXTYsWPn6npPR/Tyue/0NG/t2nZo58qpkNjHVm1VSm7EhRcNlIVWhacpFTp1VJBkWGFd7EvHPaOuk54TNeuGqO+v7ysJQ98JGuudwddklSudLDmj++rq7pVc9k6w0ICNG5URz19VzOXrdPVXHUsEFm9knKS09T0/qvVf9br6vvzy4rp+N9J4vl+772lzTSrX16Lv7zcpYOfqlQK19yxfdXbhceY3qbZI9dp729/6eT2g+e8FlElWtX6tdG0dvfqhxb3KP6zGeoy9iEDqrTPzf1r6+f3eqh8GdfdedeheUUt+aq/asR578C/U6pUitDiL/u79OHoZSKDNPXt7l59YcvV50TnO8bx9nOirq1jtWBCP9Wo7Lr2Wr9GaS38/HKvelaxKwWEBqvGgA7aPnG+Xe/POHJCU5rfrRl9n9Ts619SxTYN1GjYFW6u0n4P39pEX7/a2aWzkfTtGKc/P++n6PKuu97kLYr6/uvc2F3pB5OUuHSjgZU5JzDQTxNfv0yP3NrYZYNALRbp8dub6JvRXbxuurqLlXbgqKb3eFSTm94l/+BAVetn/xTVjvYdnlIpKkwLv7hcvdpXdtk6I8MD9d3/LvPKR9qczWKx6PWHWumdx9ooyIWPn7np8lqaNaa3IsOND/svhKkLfUD6wSSFViwri79f4YFrROUopR9MOuN9aQeTVOq0EVsRcRXOeE9AeIh6fv+s9s1epfixMzxTvIt0bxurTT9dowdeX+7QnKxnCwzw0wvDm+vx25ua6kesXOlg/fZJL33x83Y99OYKpaQ5/xDOnu1iNf6FTqoaE+HCCh3X79dXVapm0SGLu+YEb3L/1YqsXknLrj9zLvIl9xecyNW6rotaPnuz5t08WmXqVVG1y9vo94HPu6UWRzWtW07//HCVnv/4b7399YYzBlk66r4bG+p/97dUuJdOV1iU4CB/TXixk67uXk13v7RUh444/1DcZvXL6cuXO+uSeuVdWKH7XdurhtpdEq17Xl6qmYv2O72e8NAAvflwa91zXX2vuovHiD6hKL8PfF7pB5NkCfDXpU/coE7v36t5N4/22PaL4+dn0UsjW6h/56oa8twih57dd7ZqsRH6/MVO6tbGPXdKulO5xjW0efxvkqTyTWsVTs1ctU8r7f19pXJTM/TnXW+pxdM3KiA8REdXb9OJrftly8uXxd9Plzx4rRbc8aYOr9is8pfUUvevntQv3R5W9vFUIz+WXUpFBOnHd7vr+9926r7/LdeJFPumtC1K5xaV9PlLnQyfpstT+70lwE8RVaKVvP2A1oz+TuUa11Cvyc/p5y4PKaR8qWJ/772tzdSvUUarJw3QK5/9o/9NWKf8fOcPBu66pp7eeqS1V4xeL46950DnU6ldI4VXjlKDoX1k8fdXYGSorl35iX7t+6SqXd5WJ7bsU+bhE5KkHZMWqO3oO+UXGOC1AXj/LlUV/9M1GvHqMk2bt8fp9YQE+2v0/S11/40N5e9vnnOiiuVDNX98P42ZslmPv7NKGVnOf09XdKmqsc93UEwFY+9k8+Txz4WOccxwTtSqcQWtnzZQT763Sh9P2uz0evz8LHr0tsZ6ccSlXvd8Sldd/5Gk6le0U/LW/TpZxDPdimLNyVPWsRRJBdPCbp80XzUHdtLGT365mI/kUrdcUUedLq2kO19Yoj/+OuT0ekpHBundx9poyIA6XjXw0d3ff6UOjVWpTQNV6dmi8G9Xzn9b84e8cc5z+byRv7+f3nq0jQZ0rabbn1+knfudPx6rW620vni5k9o3q+jCCi+eK9uAJOVlZGn3z0tV8+pO2v3LUrf0HZ5UvkyIZo3prQk/btPDb/3l0DNMz9arfWWNG9XR8OujjrBYLHrolsbq1a6ybn9+kVZttP+4+GwVy4fq0+fa66pu1V1XoJt51y82nJJ1LEXHN+xWrWs6F863nZ5w/Iy5WaWC6Qn6/fKK/nlrijKPJqverb20++eCOYwDwgpCroML1mr9e9OM+BgXrVzpYH0z+jLdeXU9fTQxXj/N32v3CX6piEDddmUd3Tu4oepWd91dMZ5ksVg0dGBd9elQWWOmbNG4aVt1+Fim3cv3bBerEYMaaEDXal5xIPfbFc+c93Vrdq5dP+72HgQ0GnalqvVroznXv3jGfMWn2/nDQrV7/W4Fl41QxTYNFFElWtcsKzjhC61QRu3eHKbQ6LLa+vUcpz7zxQoNCdCbj7TWzf1r6cPv4/X97zuVmWXfbeTBQf4a1LuG7ruxoVdPVXghl3euqk0/VtT4H7dpzJTN2nXA/gPb1o0raPig+rqpX20FunD0iydVrhiuXz/sqd8W79fHkzZr1tIDdoeeUWVDdOfVdTViUANVqeR9B3Ku6hMu1qn12fLyFT9uhq5e+uEFlvCs1k0q6O/JA/TNrzv08eTNdj/DUZLqVS+tEYMaaOjAul77XL4LKdeoeuFJePmmNbX/3zt0Yy9rptUvfytJSly2SbOuLngOo19QgAatG6/kbQdUrnENhVYsq8MrCi6MHVu3UxkJx1SucQ0lLFpvwKdxnMVi0U2X11bPtpX16Q9bNHbqFoeC/8taxWjEoAa6pkd1rwi6PXUskH4wSdb8fO2atliSdHzjbqXtO6KyDaqqVI2YYn/vk9bt9Lo2Exzkr5fvbaHBfWrqo4nx+mbGDrufWRMY4Kdre1bXfTc2VLtLvOuiTlHsPQc6n9+veq7wf5+awmdq6xGSpNR9h1V7cFcFhIUoLyNLcT1b6OSOg14bcp0SXT5UP7zdTfNWHNJHE+M1Y9F+u5/dVbZUkIZeVVcjBzc0xV1cRfHzs2jk4Ia6oktVfTwpXhN+2qZjydl2LWuxFNy9MXJwQ/XtGFfizonsPcbx9nOiiLBAffR0e912ZR19+H28Js/epZxc+57pHRrir5v61dJ9NzZSUy99TrUrrv+cUufG7g7dkRFSvpSyT6bLlpcvv6AAVevXVse8MPyoXjlScz/ro5/n79Unkzdr3gr7A6+K5UN197X1NPz6BoYH3UVx9/e/eOT7Z/z3kISpmt7tkTOmLzWDTi0qaf3Uq/XFL9v0yeTNit+ZbPeyjWuX1YhBDTRkQB2FhnjfZXNXtIHI6pWUduBowb4cGKCqfVvr+Oa9F1zuFEf7Dk+zWCy685p66tcpTp9M3qxx07bqyHH7p+Ls1b6yRgxqoCsvq+oVxwLOaFS7rJZ9fYUmzdqlTyZv1vJ1R+xetlpshIZdV193X1tf5Up71zN6L8T79lg4ZdnjY9XxvZFqcv/Vyk3L1JIHP5ZUMLfu/jmrtX/OaqXtO6K1b01R3+mvSCq40LP1m7mSpIZ39VOF5rUVGBZceLvqnhnLtf79H435QBehS8sYdWkZo4OH0zV17m6tjk/Smvhj2rI7+YwLvq0aR6lFgyi1bRqta3pWN+1FvbPFRofr5Xtb6Ll7munXP/dp8d+HtSY+SWu3HDvjQkeNypFq2ShKLRqW18Bu1U0X8Nn7427P+xre0181BnbQnOtfOnP++VJh8g8NLhzJW7VPK2WfSFP2iTRt/XrOGSdvfaa9qPhxM7Rv1pnTHhrhknrlNf7FTnrzkdb6Yc5urdxwVGs2J2njjhPKy/tvJ2hat5xaNCyvVo0q6LpeNUzxHCZ7lCkVrEeHNNHDtzbW3OUHtWBVglZvStLfm5POuMMhNjpMLRpEqWWjKPXrFGfqgO90FotFl3euqss7V9XO/Sn6cd4erdlc0A/u2Jfy3/sktWsWrRYNo9ShWUUN6FrV60asOsIVFzwvJCA0WH6B/oX9RI2BHb3y5D4kOEB3XVtfd15TTyvWH9GsJQe1ZnOSVm9KOmMAhJ9F6tGuslo0iFKPtrHq2jrGtAfykhRWqZxksykjsSDcK9egmta/P01Rzevo5PaDyssoOLkJjS6jzCPJkqRLHrpWCUs3KnVPokKiSiusYlmVrlNZJ7cfVGT1SoqsVlEpO50fDWyU6PKhen5Ycz11xyX6bcl+LVqTqNWbCo4FTh/VWC02Qi0aFBwLXNWtmhrW8o7nj9jLVccC2cdTlbBko2Ivu0QH569VRJVoRVSN1sntB5WweEOxv/fe3GYa1S6rMc910GsPttLUubv114ajWhOfpA3bTyg3778Lvo1qlVHLRhXUqnGUru1ZQxVNNjWTPedA/qFBunrJh/IPDlBgZMGz/HZOW6i/R39/3nXv++0vRTWrpStmv6787FzlZWRr0VkXAL2VxWJRz3aV1bNdZe09lKpp8/Zo9aaCY4Fte0+e8d62TSuoRcMotb+kogZ2r+aVF/WcUTUmQq8/1FovjrhUP8/fq2Xrjmj1piT9s/XYGQPBalctpRYNy6tFgyhd07O6asYZPyWxI1zVD57vGMes50StGlfQ16O76O1HW2vq3D1aubGgH4zflXzGgNhm9cupRYMotWlSQdf2qqGypbz/ot7FXv+RpFK1YlWuUXXt/mXpOeu/8o+3FVK+lAIjQ3XdmrFKXLZRi+/7UNFtGqj5Y4Nky7fKEuCvxCUbtP597xwobbFYNLB7dQ3sXl1bdyfrp/l7tebfa0O7D6ae9j6pY/OKatEwSp0uraT+Xap4/bTd7v7+z6f7N0+pXMPqkqQBf76r1N2JmnXNKNd8MBcLCw3QyMENNWJQAy1ak6i5yw9qTfwxrYlP0tET/4UeFcqG/HttLEq92lVWx0srev050cW2gZiOjdXgjn6F+3LC4g1a/+5USXJb2zFCbHS4XrmvpZ4f1lzTF+zTkrVFXx+tGRepFg3Ne320OAEBfrq5f23d3L+21m5O0oxF+wv7wQOH0wvfZ7EUPLqiRcMoXdYqRr3bVzbVHf2ns9hsFzPBFc4nPT1dEREFo+LT0tIUHm7/c05yM7L0Xa2b3VWay92081sFhnn3RXKbzaa4HhN16GimYiuE6uAfNxpdksdV7v69V35+Z9t7qVqx6vjeSAWXjSz8cU/esk/SmT/w53tfWEw5Xf/3Z0rZk6i8tIILwPk5eZp5+VMKj4vSZZ89ooCQINmsNmUdS9Hql77W8U17zqmluJM6b9o32Ae8dx/wFKvVpio9vb8NuLtPaPfG3Yrr3kKh0WWUfSJVuWmZ+rH9fYXrKe71iKrR6jr+MVn8/WSxSKl7j2jlc5+f8bBeb9rni5Kfb1XVXpN06GimKkeH6cC8G4wuqViOtoO4Hi3UYGgfzb3xVUlS/99f0/FNe5R9PFUpexK1/fs/JBW0hYptGsji76eja7bpr2cm/Hdh76oOanr/1bJZbbL4WbT+w5+0+6cldtfg7d+/5L39oJHHApIUUTVaHd4ZoZBykbJZbVr37g/aO/Ovc7Z39u+9PW3Gm9qF2Y4FOCdyPbMcC7iLN+8DRvaD5zvGudhzIm/bL7y5DZzNbH2g5H3fd1FO7wd97XjYG5ihDXjr8XBRaAPuYaY24A7e1g9eTIZyOt8YrgXYwWKxFI7K8PbRGe7ia58/ZeehYqfzWPbop3a9LyPhuL6MubbI19IPJGlmv6fsqsVbRzGdjn3A9/YBR/n5+XYbsLdPWP74Z+ddT3Gvp+07ol97ee55YO7g7+/nk9+9JB2Yt0YH5q0p/O8ZfZ+UVDDadPZpffTpbeFsu39ees7UHL7G1/oAVxwLSAX79+xrX7jg9s7+vTdbm+FYAL5+LHAhvrgPuKIfPN8xDudE8DWn94MomegDUNLbgK/2gwRdAAAA8Fm/XPaQ0SUAAAAAAAA3MueEiwAAAAAAAAAAACjxCLoAAAAAAAAAAABgSgRdAAAAAAAAAAAAMCWe0eWlAkKDddPOb40uw24BocFGlwATM1t7dwT7BuA4M/cJ7POuY8Z2wPfvPDN+3/aiXTjPbO2C7xoXw2zt3V7sF84zY5vg+3Yt2gBoA4D9CLq8lMViUWBYiNFlAB5BewdwOvoESLSDkobvG0WhXaAkob3jbLQJ0AZAGwDsx9SFAAAAAAAAAAAAMCWCLgAAAAAAAAAAAJgSQRcAAAAAAAAAAABMiaALAAAAAAAAAAAApkTQBQAAAAAAAAAAAFMi6AIAAAAAAAAAAIApEXQBAAAAAAAAAADAlAi6AAAAAAAAAAAAYEoEXQAAAAAAAAAAADAlgi4AAAAAAAAAAACYEkEXAAAAAAAAAAAATImgCwAAAAAAAAAAAKZE0AUAAAAAAAAAAABTIugCAAAAAAAAAACAKRF0AQAAAAAAAAAAwJQIugAAAAAAAAAAAGBKBF0AAAAAAAAAAAAwJYIuAAAAAAAAAAAAmBJBFwAAAAAAAAAAAEyJoAsAAAAAAAAAAACmRNAFAAAAAAAAAAAAUyLoAgAAAAAAAAAAgCkRdAEAAAAAAAAAAMCUCLoAAAAAAAAAAABgSgRdAAAAAAAAAAAAMCWCLgAAAAAAAAAAAJgSQRcAAAAAAAAAAABMiaALAAAAAAAAAAAApkTQBQAAAAAAAAAAAFMi6AIAAAAAAAAAAIApEXQBAAAAAAAAAADAlAi6/rVnzx5NmDBBw4YNU4sWLRQUFCSLxaIhQ4YYXRoAAAAAAAAAAACKEGB0Ad7ivffe0/vvv290GQAAAAAAAAAAALATd3T9KyoqSv369dOoUaP066+/asSIEUaXBLhEfr5VvyzYq77DZysxKVOSdPhYpp5+f7X2Hko1uDoAnnAgMV2jPv5bDa+apoSjGZKkpBNZmjZ3t3JzrQZXB09YuzlJd7+4RDX7TilsA8dPZmvZP4dls9kMrg6Au2Vk5mnCj1vV/pZflfDv8eCR45l695uNOpGSbXB1gPvl5lo1dc5u9bz798J94PCxTL3wyd86eDjd4OoAeMKeg6l66v1Vqn/l1P/OiZKzNH3BXuXnc04EwPdt2Z2sB15brtqX/3dd4NjJbP2x4pBPXBfgjq5/Pfvss2f894oVKwyqBHCd1ZuO6rpH5mvPobQz/p6Xb9P/JqzT61+s1z3X1tP7T7RTYCC5N+Br8vOteuydlfrg+3jl55950JKda9W1j8xXXMVwTX6zq9o3q2hQlXCn4yezdcMTCzRn2cFzXsvMzleHW2eo3SXRmvp2N8VGhxtQIQB3+2HObt394hIlp+ac8ffcPJsefvMvPfPhao2+r6UevKWxQRUC7rXk70QNfnyBDh7JOOPvefk2vfjpWr0y7h89cFMjvfFQK/n7c04E+JrcXKvue225Ppu6RWdfx83OsWrAA/NUo3Kkpr7dTZc2jDKmSABwo/SMXN3+/GL9MGf3Oa9lZeerx92/q3Htsvrx3e6qU620ARW6BkdxgI9aueGoLhv62zkh1+msVpvGTNmiwY8vYAQT4GOsVptue3aR3v1m0zkh1+kOHE5Xtzt/06LVCR6sDp6QnJKtLrfPLDLkOt3ydUfU/tYZhSO6APiOr6dv1/WPzj8n5DpdZla+HnrzL7306VoPVgZ4xp+rEtTj7t/PCblOl59v0ztfb9Ttzy32idHMAP6Tn2/V9Y/N19gfzg25Trf7YKo63z5TqzYe9VxxAOABmVl56jN8dpEh1+k27jih9rfO0Pa9Jz1UmesRdAE+KCMzT1feP1fpmXl2vf/HP/bo7a82urkqAJ70yeTN+m7mTrvem51j1VUPztPJ81wIhfnc8/JSbdxxwq737j2Uphuf/NO9BQHwqM27knXHqMV2v3/UJ39rzrIDbqwI8KzklGwNfHCesnPsG9D3zYwd+nTKFjdXBcCT3vhig36ev9eu96b/ex0lM8u+6ygAYAZPvLdKS9Yetuu9SSeydNWD82S1mnPgD0EX4IMmz96lw8cyHVrmw4nxysvjri7AF1itNr3/3SaHljmRkqNvZuxwU0XwtP2JaZo6d49Dy/y5KkH/bDnmnoIAeNwnkzcr7zx39BbF0d8OwJt9NX37ee9mLMp7327iri7AR+TmWvXRpHiHlklMytSU2ee/6wEAzOJkao4+/2mbQ8vE70zWvBXnnxXGWxF0AT7ok8mbHV7mwOF0/bpwnxuqAeBp81Yc1I59KQ4v98nkzVzc8RGfTd3q1CisMVMc//0A4H3SMnL11fTtDi/3+5ID2n0g1Q0VAZ5lsxVM0e6obXtPav5fTOcM+ILpf+7VofNMW1ocZ66nAIA3+mbGDrtn+zqdWfvBAKMLKCnq1KkjPz9yRaMllHlY8iuthMQExcXFGV2OW9hk0aFyLzi17K3DRql05h8urQfepSTsA+dTUj5/akhnKay7w8tt3pWsylVqyU9MYWh2SRE3S0F1HF7ui0kLNPOzwW6oCN6ipPSDJV2Of4xSSw9zeDmbTWrZ6RqF5jo2Ah7mUhL6AauClVDuaaeWvfrmhxWZtcTFFcGblIR9ANLJ0J5SaEeHl1u54bAqx1WRRQwA9FX0ASgpbeB4+EApuJnDy/36x0bFxd3u+oKKYbX+N8NYx44dtXatc88OJujykIQERoV5hch8yU+y5ufr4EFz3oZ5QZYgqZxzi6al5ygtwUf/XVCgJOwD51NSPn/FLCnMuUUTDh+T8hy/GwxepqZNCnJ8sdx8P9/eN1By+sGSLixMKu3coseT06Vk2oZPKwn9QEBpp8+JUtKylXLYR/9dUKAk7AOQYrKlUCeWs/jp0KHDki3X5SXBS9AHoKS0gap5UrDji1ltAYb9uxw+bN/zxIpC0OUhMTEx3NHlBRL8/WWV5Ofvr5jKlY0uxy1skg7Z8iWLv8PLRoYHqJSP/rugQEnYB86npHz+1JAgORtVxVYsK4siXVoPPC8p0KZsJ5YL9M9TtA/vGyg5/WBJl+sfqSNOLluuTKhCw2kbvqwk9ANWBcrZoaalIgIVGeCb/y4oUBL2AUgpoQFyajJeW55iY6NlcXVB8Br0ASgpbeBEiJ8cn8BV8leOKnnw38VqtRbeJFSxYkWn10PQ5SHbt29XeHi40WWUeHE9JurgkQzFVIrRgY0HjC7Hba64d45mLNrv8HJzpr6ttpdEu6EieIuSsg8Up6R8/vXbjuuSa39yeLmurWI0f8Ie1xcEj/t4UrzuHb3c4eWeGnmFXhw5yg0VwVuUlH6wpMvLs6pmvynan5ju0HKhIf7asWSmypZyYugnTKOk9ANdbp+pRWsSHV5u2ayxalS7rBsqgrcoKftASbd07WF1vG2Gw8td2bWmfvmAduHL6ANQUtrA1Dm7dd2j8x1e7s7BbfXpc577d0lPT1dERIQkackS56eP5hYjwAeNGNTA4WWa1y+vNk0ruKEaAJ7WtG45dWju+CgYZ/oOeKdb+tdWeKhj45n8/S2665p6bqoIgCcFBPjpnmvrO7zcDX1rEXLBZzhzXNO5RSVCLsBHtG8WraZ1HZ/DlHMiAL5iQNdqiqng+HMthl/v+HmENyDoAnxQ7w5xatkoyqFlnr7zElks3JwP+Iqn77zEofc3qlVGA7pWc1M18LRSEUF64KZGDi0z5Mo6iqvE3eeAr7jrmnqqUDbE7veHBvvroZsd6zcAbzawezU1qFnG7vdbLNJTdzh2/ATAe1ksFj1zl2P7dKvGUerZznenMQNQsgQG+unJoU0dWqZ/5yq6pF55N1XkXgRdgA/y87No+gc9VbtqKbveP/r+lrq2Vw03VwXAk/p1qqL3Hm9j13urxUZo5se9FBjIYYEveWnkpbq+t319e4+2sfr4mfZurgiAJ0WXD9WMj3qpdETQBd8bFOinSW90VeM6jo98B7xVUKC/fvu4l6rYOYjj/Sfaqk/HODdXBcCTru9dU6/c28Ku99atVlrTP+gpPz8GAAPwHffd2FAjB9t3p2rLRlH67rXL3FuQG3FF619Lly5VVFRU4f+98847kqRJkyad8felS5caXClgn5gKYVr+zRUa1KeGAvyLPlCrFhuhr1/trKccvPMDgDk8cHNjTXqjq2pViSzydT8/iwZ2r6bl31yharFFvwfm5e/vp+9fu0wvDG+usqWKvtAdERagh29trJkf91JwkL+HKwTgbq2bVNDSr/urS8tKxb6nef3ymju2j67krl74oOqVI7Xi2yt0VbdqxV68rl21lKa81U333cgdjYAveubuZvry5c6qFhtR5OsB/hYN6lNDy77pr0pRjk/xBQDezGKx6MOn2undx9qoYvnQIt8TEuyvu66ppwUT+qmUHYPkvJVjD2/wYbm5uTp27Ng5f8/OzlZ2dvYZ7wPMIqpsiCa90U2HjqTr85+3aeOOE8rMylf5MsG6pkd19ekQJ39/8m7Alw3qU1PX9aqhucsP6oc5u3X0RJZCgv3VoEYZ3XF1XVWpVPQJH3yDv7+fRg2/VI/f3lSTZ+/SvBWHlJKWq8jwQHVoFq1brqityHDzHsgCuLBGtcvqz88vV/zOE/r8p23acyhNVptNsRXCdEv/2mrdpALTV8OnxUaH66f3emhfQpom/LhNW/YkKys7X9HlQnR975rq3iaWOzgAH3fbgDq6uX8t/b7kgH78Y4+OJWcrNMRfjWuX1R0D6zn1DBsAMAuLxaIHb2msEYMb6Kc/9uq3xfuVnJqj8NAAtWgYpSED6qh8GfunPPdWBF3/uuyyy2Sz2YwuA3CL2OhwPXt3c6PLAGAQPz+LeneIU+8OTMdTUoWGBGjIgLoaMqCu0aUAMEjDWmX11qP2TWkL+KKqMRF6ceSlRpcBwCD+/n7q36Wq+nepanQpAGCIoEB/DepTU4P61DS6FLfgVg4AAAAAAAAAAACYEkEXAAAAAAAAAAAATImgCwAAAAAAAAAAAKZE0AUAAAAAAAAAAABTIugCAAAAAAAAAACAKRF0AQAAAAAAAAAAwJQIugAAAAAAAAAAAGBKBF0AAAAAAAAAAAAwJYIuAAAAAAAAAAAAmBJBFwAAAAAAAAAAAEyJoAsAAAAAAAAAAACmRNAFAAAAAAAAAAAAUyLoAgAAAAAAAAAAgCkRdAEAAAAAAAAAAMCUCLoAAAAAAAAAAABgSgRdAAAAAAAAAAAAMCWCLgAAAAAAAAAAAJgSQRcAAAAAAAAAAABMiaALAAAAAAAAAAAApkTQBQAAAAAAAAAAAFMi6AIAAAAAAAAAAIApEXQBAAAAAAAAAADAlAi6AAAAAAAAAAAAYEoEXQAAAAAAAAAAADAlgi4AAAAAAAAAAACYEkEXAAAAAAAAAAAATImgCwAAAAAAAAAAAKZE0AUAAAAAAAAAAABTIugCAAAAAAAAAACAKRF0AQAAAAAAAAAAwJQIugAAAAAAAAAAAGBKBF0AAAAAAAAAAAAwJYIuAAAAAAAAAAAAmBJBFwAAAAAAAAAAAEyJoAsAAAAAAAAAAACmRNAFAAAAAAAAAAAAUyLoAgAAAAAAAAAAgCkRdAEAAAAAAAAAAMCUCLoAAAAAAAAAAABgSgRdAAAAAAAAAAAAMCWCLgAAAAAAAAAAAJgSQRcAAAAAAAAAAABMiaALAAAAAAAAAAAApkTQBQAAAAAAAAAAAFMi6AIAAAAAAAAAAIApEXQBAAAAAAAAAADAlAi6JNlsNi1dulRPPPGE2rdvr3LlyikwMFAVK1ZU//79NX36dKNLBAAAAAAAAAAAwFkCjC7AG8yfP189evSQJFksFtWqVUs1a9bUjh07NHPmTM2cOVNDhw7V+PHjZbFYDK4WAAAAAAAAAAAAEnd0SSq4o6tmzZr68MMPdeTIEW3fvl2rV6/WsWPH9O6778pisejzzz/XmDFjjC4VAOAEq9WmWUsOKCU9V5KUmp6rNfFJBlcFAJ6Tl2fVT3/sUUpajqSCfjB+5wmDqwIAwHOSTmTpk0nxOvnvb2F6Zp6SU7INrgoA4Ck5ufmaMnvXGedE2/eeNLgquAp3dElq3bq1tmzZosDAwDP+7u/vrwcffFBbtmzR2LFj9dlnn2nEiBEGVQkAcJTVatPHk+L13rebtOtAauHfU9Jz1XLwL2rVOEpP33mJrupW3bgiAcCNcnOteuOL9fpkymYdOpJR+PeU9Fw1GvijLmsVo+fubqZubWINrBIAAPfZczBVz3/8t6bM2a3snPzCvyen5ii2x0Td2LeWXr63hWIqhBlYJQDAXbKy8zR6/DqN/WGLjhzPKvx7Snqu6l4xVT3bxeqF4ZeqfbOKBlaJi8UdXZJKlSp1Tsh1ut69e0uStm7d6qmSAAAXKT/fqtueXaj7X1txRsh1ulUbkzTwwT/05hfrPVwdALhfVnaerrx/rp79aM0ZIdfp/lyVoF7DZunLX7Z5uDoAANxv/bbjanvzr/pmxo4zQq5TMrPyNeGnbWp783RG9QOAD0rLyFXvYbP18th/zgi5Tjd3+SFdNvQ3/TBnt4ergysRdNkhK6tgJwgLY3QPAJjF4++u0rczdjrw3h1urggAPGvo84s1a+mBC74vP9+mO0Yt0Ww73gsAgFkkJmWo74jZOnws84Lv3ZeQrj7DZ+sEUxkCgM+w2Wwa/PgCLVqTeMH35uZZddOTf2rJ3xd+L7wTQZcdJk+eLEnq1KmTwZUAAOxx6Ei63v9uk0PLPPvRGuXnW91UEQB41rqtxzTx9112v99qten5j/92Y0UAAHjWRxPji72juSi7DqTq85+4wxkAfMWyf45o5qL9dr8/N8+qF8asdWNFcCeCrgv47bff9Msvv0iSHn/8cYOrAQDYY9y0rcrPtzm0zN5Dafp9CXczAPANY6ZscXiZlRuPavWmo26oBgAAz8rJzde4aY4/fmLMlM2yWh07jwAAeKdPJm92eJk//jqkLbuTXV8M3I6g6zx27typW265RZJ0//33q3379gZXBACwx9S5ezy6HAB4m6lznZtfftq8Pa4tBAAAAyz5+3Cxz2I5n537U7Vu6zE3VAQA8CSbzeb0uc2PnBOZksVmszFUpQiJiYnq1KmTduzYoV69emnGjBkKDAx0aB3p6emKiIiQJMXExMjPj1zRaAllHpbVr7T8rCcVk/yO0eUAHldS9oGEMo/K6hfp8HLBOVsVlfa9GyoCAM+xyaJDZZ+XLI4fe4ZlrVHZjOluqAqAtygpx4Mo2TKCGulExPVOLVs+5SuF5Nk//S8Ac+F3sGSwKkgJ5Z5xatnwrGUqkzHbxRWhOFarVQkJCZKkZs2aae1a56aPDHBlUb7i+PHj6tWrl3bs2KEOHTrop59+cjjkOtupLwsGi8yX/CRrfr4OHjxodDWA55WUfSAiWwpyPOjKzkzz7X8XACVHmXyngq6M9JPKOEQ/CPi0knI8iJItsoIU4dyix44mShnsG4DP4newZLD4S+WcWzQ9JVnph2kbRjh8+LDTyxJ0nSUlJUV9+vTRhg0bdOmll2rmzJkKCwu76PVyR5d3SPD3l1WSn7+/YipXNrocwONKyj6QpOPKVpTDy0UGpamUD/+7ACg5jliPKtcv1uHlSodkKIJ+EPBpJeV4ECVbnl++DkuSzSZZLPYvaLOqUjk/+Zdl3wB8Fb+DJUdi/jHl+5d3eLmyYZkKo214zOl3dFWsWNHp9RB0nSYjI0P9+/fXqlWr1KBBA82ePVulS5d2ybq3b9+u8PBwl6wLzovrMVEHj2QoplKMDmw8YHQ5gMeVlH1g+oK9GvDAPIeW8fOzaMPCj1Ut1vE7wQDA24z9YYuGvbzUoWXCQwO0d+lklY4MclNVALxBSTkeBLrf+Zvmr3Rsdp1retbU1He2uKkiAN6A38GS460vN+ixd1Y6tEy50sE6sHK6QkOITTzl9Mc/LVmyxOn1cIvRv3JycjRw4EAtXrxYtWrV0rx58xQV5fjdAAAA413euYqqxzo2V8kVXaoQcgHwGTddXktlHAysbulfm5ALAOAz7r2hocPLjBzcwA2VAACMcPtVdRQa4u/QMncMrEvIZVIEXZLy8/N14403as6cOYqLi9O8efMUG+v4VC8AAO/g7++nKW91U5idByfVYiP06XMd3FwVAHhORFigJr7eVf7+9k3X1KROWb3+UCs3VwUAgOdc1a2a7r62nt3vf2xIE3VtzbUgAPAV5cuE6JtXu9g9g22bJhX0wvBL3VsU3IagS9KUKVM0bdo0SVJQUJBuvvlmdezYscj/S0xMNLhaAIA9WjWuoHnj+iiqbMh539eoVhkt+uJyVYq6+OcxAoA36dMxTr9+0FMRYecP/ds3i9b88f1UKoK7uQAAvsNiseiTZ9rrgZsaXfC9z97djAEfAOCDrulZQ1Pe7KaQ4PPf2dW9Taxmf9pHYaHczWVWfHOSsrOzC//3rl27tGvXrmLfm5WV5YmSAAAu0O6Sitr9+/X6buZOfTJ5s9ZvO174Wvc2sRoxqIGuvKyqAgIY9wHAN/XtVEX75gzWl79s15gpm7V9b4qkgucSXt6pikYObqCe7SrLz8/OYY4AAJiIv7+f3nuire66pp4+mbxZX/+6Q2kZuZKkMpFBuv2qOhp2XQPVre6a57MDALzPtb1qqEvLSvri54Jzoj2H0iRJ/v4WXdW1mkYMaqCurWNksffWL3gli81msxldhK86/UFqaWlpCg8PN7ginHrgZOXoMB2Yd4PR5QAeV9L3gazsPKVn5qlUeJACAwm3AJQ8mVl5yszOV6nwQEJ+oIQq6ceDKNmsVptS03NlsUiR4YFc1ARKIH4HSzabzabMrHxl5XBO5C1claFwRxcAoMQICQ5QSDA/fQBKrtCQAB6uDAAosfz8LCodyVS9AFBSWSwWhYUGMEWhDyKyBAAAAAAAAAAAgCkRdAEAAAAAAAAAAMCUCLoAAAAAAAAAAABgSgRdAAAAAAAAAAAAMCWCLgAAAAAAAAAAAJgSQRcAAAAAAAAAAABMiaALAAAAAAAAAAAApkTQBQAAAAAAAAAAAFMi6AIAAAAAAAAAAIApEXQBAAAAAAAAAADAlAi6AAAAAAAAAAAAYEoEXQAAAAAAAAAAADAlgi4AAAAAAAAAAACYEkEXAAAAAAAAAAAATImgCwAAAAAAAAAAAKZE0AUAAAAAAAAAAABTIugCAAAAAAAAAACAKRF0AQAAAAAAAAAAwJQIugAAAAAAAAAAAGBKBF0AAAAAAAAAAAAwJYIuAAAAAAAAAAAAmBJBFwAAAAAAAAAAAEyJoAsAAAAAAAAAAACmRNAFAAAAAAAAAAAAUyLoAgAAAAAAAAAAgCkRdAEAAAAAAAAAAMCUCLoAAAAAAAAAAABgSgRdAAAAAAAAAAAAMCWCLgAAAAAAAAAAAJgSQRcAAAAAAAAAAABMiaALAAAAAAAAAAAApkTQBQAAAAAAAAAAAFMi6AIAAAAAAAAAAIApEXQBAAAAAAAAAADAlAi6AAAAAAAAAAAAYEoEXQAAAAAAAAAAADAlgi4AAAAAAAAAAACYEkEXAAAAAAAAAAAATImgCwAAAAAAAAAAAKZE0AUAAAAAAAAAAABTIugCAAAAAAAAAACAKRF0AQAAAAAAAAAAwJQIugAAAAAAAAAAAGBKBF0AAAAAAAAAAAAwJYIuAAAAAAAAAAAAmBJBFwAAAAAAAAAAAEyJoEvS9OnTNXz4cLVu3VqVK1dWcHCwIiMj1axZMz399NNKSkoyukQAAAAAAAAAAACcJcDoArzBO++8o4ULFyooKEixsbFq2rSpjhw5ovXr12vdunUaP3685syZo2bNmhldKi7CiZRs5eZZJUlWm83gagAAAADAs44lZxWeE9k4JwIAAICP4I4uSUOHDtUff/yh1NRU7d69W6tWrdLevXu1bt06NW7cWEePHtWNN95odJlwgtVq02+L96v/vXNUvtO3OnI8S5KUeDRTd72wWGs3c7ceAAAAAN+Vl2fVLwv2qtc9vyuq83eF50QJSZka+eoybdx+3OAKAQAAgItjsTGM67xWrlypNm3aSJLi4+PVoEEDu5dNT09XRESEJCktLU3h4eFuqRFFS03P0fWPLtCspQfO+76n77xEr9zXQhaLxUOVAcaJ6zFRB49kqHJ0mA7Mu8HocgAAAOBGJ1KyNfDBeVq4OvG87/vfAy31xNCmnBMBAHwe10UA7+KqDIWpCy/g9GArIyPDwErgiJzcfA24f54WrEq44HtHj18nSXr1/pbuLgsAAAAAPCIzK0/9RszWivVHL/jep95fLYtFemLoJR6oDAAAAHAtpi68gKVLl0qSwsPDVa9ePYOrgb0+mhhvV8h1yujx67Rq44VPAAEAAADADN74Yr1dIdcpT763Wlt2J7uvIAAAAMBNCLqKYLValZCQoK+//lpDhgyRJI0ePbrwFjp4N6vVpjFTtji83Jgpm91QDQAAAAB4Vm6uVWOnbnV4uTGTOScCAACA+RB0nebTTz+VxWKRv7+/YmNjddtttykuLk6//vqr7r//fqPLg50Wrk7Qjn0pDi838fddSk3PcUNFAAAAAOA5vy3Zr4Sjjk+9/+X07crJzXdDRQAAAID78Iyu08TExKhDhw7Ky8vT/v37lZCQoPXr1+v7779Xp06dVLp0aafXXadOHfn5kSt6QnpwCyn8SoeXy8rOV+0GrRVoTXJDVYB3SCjzsORXWgmJCYqLizO6HAAAALhBakh7Kay3w8ulpOWqWs3G8reluqEqAACMx3URwLtYrdbC/92xY0etXbvWqfUQdJ1mwIABGjBgQOF/b9iwQSNHjtTEiRO1b98+LVmyxOl1JyTY/7woXKRydaVw5xY9cvSYlHXQtfUA3iQyX/KTrPn5OniQtg4AAOCTKqRJYc4tmnj4qJR7zLX1AADgLbguAnitw4cPO70sQdd5NGnSRDNnzlTNmjW1dOlSzZs3Tz169HBqXTExMdzR5SGZgQE67uhCNptksahSVJj8bZXdURbgFRL8/WWV5Ofvr5jKtHUAAABflB7kr2RnFrRZFRNdSn4KcXFFAAB4B66LAN7FarUW3iRUsWJFp9dD0HUBkZGR6tKli6ZNm6Z169Y5HXRt375d4eFO3mYEh6Rn5Cq2x0SlpOXav5DFoq6tYjR/guMPbAbMJK7HRB08kqGYSjE6sPGA0eUAAADADY4lZymu5yRlZTv2vK0B3arr5/d3uakqAACMx3URwLukp6crIiJCki5qRj1uMbJDXl6eJCk/n4fymkF4WKBuu7KOw8uNGNTADdUAAAAAgGeVLxOiwX1qOrwc50QAAAAwI4KuCzh+/LgWLlwoSWrWrJmxxcBujw1pokpRoXa/v3OLShrQtZobKwIAAAAAz3nmrmYqVzrY7vf36RCnHm2ZwgkAAADmU+KDrtWrV+v555/Xjh07znlt7dq16tu3r5KTk9WkSRN1797dgArhjCqVIjRrTG9VLH/hsKtNkwr66b0eCgws8bsDAAAAAB9Ru2op/fZxL7vCrstaxWjKW13l52fxQGUAAACAa5X4K/tpaWl6+eWXVadOHVWsWFEtW7ZUmzZtVLlyZV166aVauXKl6tatq59//ln+/v5GlwsHXFKvvFZ+f6WGX19fEWHnPo4urmK4Xhp5qeaP7+fQSEcAAAAAMIM2TaO18vsrdefVdRUacu75bPXYCL3+YCvNGtNbkeFBBlQIAAAAXDyLzWazGV2EkU6cOKFvvvlGCxYs0MaNG3X48GFlZWWpXLlyatKkiQYOHKihQ4cqJCTE4XWf/iC1tLQ0hYeHu7p82Ck1PUe//rlficcyFODvp1pVItW7fZwCAkp81osS5tRDVytHh+nAvBuMLgcAAAAekpySrV8X7tPRE1kKDPBT3Wql1aNtrPz9OScCAJQcXBcBvIurMpRzb3MpYcqWLav7779f999/v9GlwI0iw4N04+W1jC4DAAAAAAxRplSwbrmijtFlAAAAAC7H0C0AAAAAAAAAAACYEkEXAAAAAAAAAAAATImgCwAAAAAAAAAAAKZE0AUAAAAAAAAAAABTIugCAAAAAAAAAACAKRF0AQAAAAAAAAAAwJQIugAAAAAAAAAAAGBKBF0AAAAAAAAAAAAwJYIuAAAAAAAAAAAAmBJBFwAAAAAAAAAAAEyJoAsAAAAAAAAAAACmRNAFAAAAAAAAAAAAUyLoAgAAAAAAAAAAgCkRdAEAAAAAAAAAAMCUCLoAAAAAAAAAAABgSgRdAAAAAAAAAAAAMCWCLgAAAAAAAAAAAJgSQRcAAAAAAAAAAABMiaALAAAAAAAAAAAApkTQBQAAAAAAAAAAAFMi6AIAAAAAAAAAAIApEXQBAAAAAAAAAADAlAi6AAAAAAAAAAAAYEoEXQAAAAAAAAAAADAlgi4AAAAAAAAAAACYEkEXAAAAAAAAAAAATImgCwAAAAAAAAAAAKZE0AUAAAAAAAAAAABTIugCAAAAAAAAAACAKRF0AQAAAAAAAAAAwJQIugAAAAAAAAAAAGBKBF0AAAAAAAAAAAAwJYIuAAAAAAAAAAAAmBJBFwAAAAAAAAAAAEyJoAsAAAAAAAAAAACmRNAFAAAAAAAAAAAAUyLoAgAAAAAAAAAAgCkRdAEAAAAAAAAAAMCUCLoAAAAAAAAAAABgSgRdAAAAAAAAAAAAMCWCLgAAAAAAAAAAAJgSQRcAAAAAAAAAAABMiaALAAAAAAAAAAAApkTQBQAAAAAAAAAAAFMi6AIAAAAAAAAAAIApEXQBAAAAAAAAAADAlAi6ijFu3DhZLBZZLBZddtllRpcDAAAAAAAAAACAsxB0FSExMVGPP/640WUAAAAAAAAAAADgPAi6inDfffcpJSVF/fv3N7oUAAAAAAAAAMBFSEzK0Kuf/aOkE1mSpKQTWRo97h8dOZZpcGUAXIGg6yzTp0/X1KlTNXLkSLVo0cLocgAAAAAAAAAATsjIzNMdoxaraq/JevajNcrOtUqSsnOteubDNYrrOUl3v7hEWdl5BlcK4GIQdJ0mNTVVI0eOVGxsrF555RWjywEAAAAAAAAAOCEjM0+9hs3S5z9tU26etcj35OZZNW7aVvUZPluZWYRdgFkRdJ3mqaee0oEDB/Tee++pVKlSRpcDAAAAAAAAAHDCiFeXaenaw3a9d+HqRN33v+VurgiAuxB0/Wv58uUaM2aM+vbtq+uuu87ocgAAAAAAAAAATjiQmK5vZ+5waJmvpm9XYlKGmyoC4E4EXZJyc3N11113KTg4WB999JHR5QAAAAAAAAAAnDRu2lbl59scWiYv36bxP251U0UA3ImgS9Jrr72mTZs26dlnn1XNmjWNLgcAAAAAAAAA4KT5Kw85tdwffyW4uBIAnhBgdAFG27p1q1599VU1aNBAjz32mNu2U6dOHfn5kSsCMFZCmYclv9JKSExQXFyc0eUAAAAAAAC43OFSw6WASg4vt3T5asXF3e2GigAUxWq1Fv7vjh07au3atU6tp8QHXcOHD1d2drY+/fRTBQYGum07CQmMBgDgBSLzJT/Jmp+vgwcPGl0NAAAAAACA6wWnOXXlOzcrjeslgEEOHz7s9LIlPuj6+++/5efnp+uvv/6c19LS0iRJy5YtU6VKBSMAtm3bplKlSjm8nZiYGO7oAmC4BH9/WSX5+fsrpnJlo8sBAAAAAABwuZN+CUpTbYeXi/RPVCmulwAeY7VaC28SqlixotPrsdhsNseeyudjypQpo5MnT9r9/hMnTqhMmTJ2vTc9PV0RERGSCkKz8PBwZ0oEAJeJ6zFRB49kqHJ0mA7Mu8HocgAAAAAAAFxuz8FU1ew3RY5c+fb3t2jP74MUV4lruICnuCpDKfG3GCUnJ8tmsxX5f6NGjZIkdenSpfBv9oZcAAAAAAAAAADPq145Utf1quHQMoN61yTkAkyqxAddAAAAAAAAAADfMm5URzWvX96u97ZsFKWxz3dwc0UA3IWgCwAAAAAAAADgU0pFBOnPz/vp2p7VZbEU/R6LRbq+dw3NH99XEWGBni0QgMsEGF0AAAAAAAAAAACuVioiSD+83V0796do7A9btHB1olIzchUZFqjLWlXSsOsaqEZcpNFlArhIFpvNkUfywRGuepAaALhKXI+JOngkQ5Wjw3Rg3g1GlwMAAAAAAACghHJVhsLUhQAAAAAAAAAAADAlgi4AAAAAAAAAAACYEkEXAAAAAAAAAAAATImgCwAAAAAAAAAAAKZE0AUAAAAAAAAAAABTIugCAAAAAAAAAACAKRF0AQAAAAAAAAAAwJQIugAAAAAAAAAAAGBKBF0AAAAAAAAAAAAwJYIuAAAAAAAAAAAAmBJBFwAAAAAAAAAAAEyJoAsAAAAAAAAAAACmRNAFAAAAAAAAAAAAUyLoAgAAAAAAAAAAgCkRdAEAAAAAAAAAAMCUCLoAAAAAAAAAAABgSgRdAAAAAAAAAAAAMCWCLgAAAAAAAAAAAJgSQRcAAAAAAAAAAABMiaALAAAAAAAAAAAApkTQBQAAAAAAAAAAAFMi6AIAAAAAAAAAAIApEXQBAAAAAAAAAADAlAi6AAAAAAAAAAAAYEoEXQAAAAAAAAAAADAlgi4AAAAAAAAAAACYEkEXAAAAAAAAAAAATImgCwAAAAAAAAAAAKZE0AUAAAAAAAAAAABTIugCAAAAAAAAAACAKRF0AQAAAAAAAAAAwJQIugAAAAAAAAAAAGBKBF0AAAAAAAAAAAAwJYIuAAAAAAAAAAAAmBJBFwAAAAAAAAAAAEyJoAsAAAAAAAAAAACmRNAFAAAAAAAAAAAAUyLoAgAAAAAAAAAAgCkRdAEAAAAAAAAAAMCUCLoAAAAAAAAAAABgSgRdAAAAAAAAAAAAMCWCLgAAAAAAAAAAAJgSQRcAAAAAAAAAAABMiaALAAAAAAAAAAAApkTQBQAAAAAAAAAAAFMi6AIAAAAAAAAAAIApEXRJGjJkiCwWy3n/b8uWLUaXCQAAAAAAAAAAgNMEGF2AN6lTp46io6OLfC0sLMzD1QAAAAAAAAAAAOB8CLpO8/TTT2vIkCFGlwEAAPB/9u48TK/p8AP4dybLZCeEJIQgktj3XVC1q1K6Vy3VUnSvovyUotWqKrqhitJFF6po7NSSoLbUTiIktkhkI5nsmff3h0qDRGYm77zv3JnP53n6NOa9y3nnnnPn3vO951wAAAAAGsHUhQAAAAAAABSSoAsAAAAAAIBCMnXhYq6++ur84x//yFtvvZU+ffpku+22yyGHHJJVVlml2kUDAAAAAADgPQRdixk+fPi7/vtvf/tbTj311Fx00UX5/Oc/X6VSAQAAAAAAsCSmLkwyZMiQnHfeefnPf/6T6dOnp76+Pvfcc0/23HPP1NfX59BDD31fCAYAAAAAAEB11ZRKpVK1C9FalUqlHHjggbnuuuuy7rrrZvTo0ampqWn0+vX19enRo0eSZObMmenevXtLFRWgUQbsflVenTQrq6/aLa/c/tlqFwcAAAAAaKfKlaEIupbhueeey3rrrZckeeyxx7LJJps0et3FD1L//v1TW2sAHVBdE1b8dhpqV0htw5vpP/1n1S4OAAAAANBONTQ0ZMKECUmSzTbbLKNGjWrWdryjaxmGDh2alVZaKVOnTs2YMWOaFHQt7p2DBVBVPRcmtUnDwoV59dVXq10aAAAAAIBMnDix2esKuhqhU6dOSZIFCxY0extGdAGtwYQOHdKQpLZDh/RfffVqFwcAAAAAaKcWH9HVt2/fZm9H0LUMb7zxRiZNmpQkGTBgQLO3M2bMGO/oAqrunXd09e/XP688+Uq1iwMAAAAAtFOLv/5pxIgRzd6OIUbLcO6556ZUKmWFFVbI1ltvXe3iAAAAAAAA8F/tPui67bbb8t3vfjdjx459189nzZqVM844Iz/5yU+SJCeddFI6d+5cjSICAAAAAACwBO1+6sL6+vqcffbZOfvss9O/f/+svvrqaWhoyDPPPJPZs2cnSY466qiccMIJVS4pAAAAAAAAi2v3QdeWW26ZU045Jffff3+ef/75PP3001m4cGH69u2b7bffPkceeWR22223ahcTAAAAAACA92j3Qdcaa6yRM888s9rFAAAAAAAAoIna/Tu6AAAAAAAAKCZBFwAAAAAAAIUk6AIAAAAAAKCQBF0AAAAAAAAUkqALAAAAAACAQhJ0AQAAAAAAUEiCLgAAAAAAAApJ0AUAAAAAAEAhCboAAAAAAAAoJEEXAAAAAAAAhSToAgAAAAAAoJAEXQAAAAAAABSSoAsAAAAAAIBCEnQBAAAAAABQSIIuAAAAAAAACknQBQAAAAAAQCEJugAAAAAAACgkQRcAAAAAAACFJOgCAAAAAACgkARdAAAAAAAAFJKgCwAAAAAAgEISdAEAAAAAAFBIgi4AAAAAAAAKSdAFAAAAAABAIQm6AAAAAAAAKCRBFwAAAAAAAIUk6AIAAAAAAKCQBF0AAAAAAAAUkqALAAAAAACAQhJ0AQAAAAAAUEiCLgAAAAAAAApJ0AUAAAAAAEAhCboAAAAAAAAoJEEXAAAAAAAAhSToAgAAAAAAoJAEXQAAAAAAABSSoAsAAAAAAIBCEnQBAAAAAABQSIIuAAAAAAAACknQBQAAAAAAQCEJugAAAAAAACgkQRcAAAAAAACFJOgCAAAAAACgkARdAAAAAAAAFJKgCwAAAAAAgEISdAEAAAAAAFBIgi4AAAAAAAAKSdD1Hv/4xz/y0Y9+NP37909dXV369++fXXfdNeecc061iwYAAAAAAMBiOla7AK3FvHnzcvDBB+fqq69OkqyzzjpZY401MnHixNx777154okncvzxx1e5lADLp1QqVbsIAAAAAABlY0TXf33pS1/K1Vdfnb333jvPP/98xo4dmwcffDDjx4/P5MmTc9lll1W7iADN8srr9TntV49m4F5/zmtvzE6STJg8O//384fz0oSZVS4dAAAAAEDz1ZQ83p9bb701e+21V7bddtuMGDEiHTuWZ6BbfX19evTokSSZOXNmunfvXpbtAjRGqVTKOZc/kZN/8XAWLlzyqb62tianfnmznHr05qmpqalwCQEAAACA9qpcGYoRXUnOO++8JMkpp5xStpALoNrOvPg/OfH8h5YaciVJQ0Mp379wVL57/kMVLBkAAAAAQHm0+xFds2fPTq9evdLQ0JC33norTz75ZC6//PI8//zz6dGjR7bbbrt86UtfSp8+fZq8bSO6gGq595HXs/MXhjdpnZsv3Ct77TighUoEAAAAAPA/5cpQ2v3wpcceeywLFizIKquskl/+8pc56aSTsnj2d9111+Xss8/O3//+9+y6665VLClA4/3yz083fZ2rnhZ0AQAAAACF0u6nLpwwYUKSZNq0afnud7+bfffdN0899VTmzp2bxx9/PB/+8Iczffr0HHTQQXnllVeqXFqAZZs4ZXb+fvu4Jq83/N6XM/61GeUvEAAAAABAC2n3I7rq6+uTJAsWLMigQYNy7bXXplOnTkmSjTfeODfccEMGDRqU119/Peeff35++tOfNms/gwcPTm1tu88VgQqY23GtLOj1hSavVyolW+64f7rMH9MCpQIAAAAA+J+GhoZF/x42bFhGjRrVrO20+6CrS5cui/791a9+dVHI9Y5u3brlmGOOyWmnnZabb7652UHXOyPHAFpcjxWTXs1bdcrUGclbr5a1OAAAAAAAH2TixInNXrfdB129e/de9O/1119/icu88/MXX3yx2fvp37+/EV1ARczr0D1vNHPdPr27pq7n6mUtDwAAAADAezU0NCwaJNS3b99mb6fdB13rrbfeon937tx5icu8M+pr4cKFzd7PmDFj0r1792avD9BYCxY0ZO19/ppXJtY3ab0+vbvklYfvSl3nDi1UMgAAAACAt9XX16dHjx5JkhEjRjR7O+1+iNHqq6+eNddcM0nywgsvLHGZsWPHJkkGDBhQsXIBNFfHjrU56hNDm7zelw4aIuQCAAAAAAql3QddSfKpT30qSXLFFVe877NSqZTf/e53SZIPf/jDlSwWQLN9+RPrZbVVuzV6+VV6d8lXP7NBC5YIAAAAAKD8BF1Jjj/++PTq1Sv33ntvzjzzzEVTFC5YsCAnnnhiHnvssdTV1eVb3/pWlUsK0Dirrtw1N/16r6y6UpdlLtu7V+cM/9WeWb2v6VUBAAAAgGKpKZVKpWoXojW46aabcuCBB2bu3LlZZZVVsvbaa2fs2LGZMmVKOnbsmMsvvzyf//znm7TNxeeXnDlzpnd0ARX3witv5cTzHsq1d47PwoXvPt3X1tZk/w+tmR9/Y6sMXXvF6hQQAAAAAGiXypWhCLoW88wzz+Sss87KHXfckcmTJ2ellVbKLrvskhNPPDFbbLFFk7cn6AJai9cm1ecP/xybl16fmVIpWaNf9xz8kUFZo1+PahcNAAAAAGiHBF0FIOgCAAAAAAB4v3JlKN7RBQAAAAAAQCEJugAAAAAAACgkQRcAAAAAAACFJOgCAAAAAACgkARdAAAAAAAAFJKgCwAAAAAAgEISdAEAAAAAAFBIgi4AAAAAAAAKSdAFAAAAAABAIQm6AAAAAAAAKCRBFwAAAAAAAIUk6AIAAAAAAKCQBF0AAAAAAAAUkqALAAAAAACAQhJ0AQAAAAAAUEiCLgAAAAAAAApJ0AUAAAAAAEAhCboAAAAAAAAoJEEXAAAAAAAAhSToAgAAAAAAoJAEXQAAAAAAABSSoAsAAAAAAIBCEnQBAAAAAABQSIIuAAAAAAAACknQBQAAAAAAQCEJugAAAAAAACgkQRcAAAAAAACFJOgCAAAAAACgkARdAAAAAAAAFJKgCwAAAAAAgEISdAEAAAAAAFBIgi4AAAAAAAAKSdAFAAAAAABAIQm6AAAAAAAAKCRBFwAAAAAAAIUk6AIAAAAAAKCQBF0AAAAAAAAUkqALAAAAAACAQhJ0AQAAAAAAUEiCLgAAAAAAAApJ0AUAAAAAAEAhCboAAAAAAAAoJEEXAAAAAAAAhSToAgAAAAAAoJAEXQAAAAAAABSSoAsAAAAAAIBCavdB17hx41JTU9Oo/51++unVLi4AAAAAAAD/1bHaBai2Ll26ZMcdd1zq5zNmzMjjjz+eJNlhhx0qVSwAAAAAAACWod0HXf369cuIESOW+vlPfvKTPP744xkwYEB22223CpYMAAAAAACAD9Lupy5cliuvvDJJcsghh6S21q8LAAAAAACgtZDcfIBHHnkkTz31VJLksMMOq3JpAAAAAAAAWJyg6wNcccUVSZJtt902Q4cOrXJpAAAAAAAAWJygaynmz5+fq666Kkly+OGHV7cwAAAAAAAAvI+gaymGDx+eyZMnp66uLp/+9KerXRwAAAAAAADeQ9C1FFdeeWWSZP/990/v3r2rXBoAAAAAAADeq2O1C9AaTZkyJcOHD09SvmkLBw8enNpauSIAAAAAAEBDQ8Oifw8bNiyjRo1q1nYEXUtw1VVXZd68eenXr1/22muvsmxzwoQJZdkOAAAAAABAWzJx4sRmryvoWoIrrrgiSXLwwQenQ4cOZdlm//79jegCAAAAAADI2yO63hkk1Ldv32Zvp6ZUKpXKVai24Omnn86GG26YJHniiSey0UYbNXtb9fX16dGjR5Jk5syZ6d69e1nKCAAAAAAAUGTlylAMMXqPK6+8MkmyxRZbLFfIBQAAAAAAQMsSdC2moaEhf/jDH5Ikhx12WJVLAwAAAAAAwAcRdC3m9ttvz6uvvppOnTrlc5/7XLWLAwAAAAAAwAcQdC3miiuuSJJ85CMfSZ8+fapcGgAAAAAAAD5ITalUKlW7EG1VuV6kBgAAAAAA0JaUK0MxogsAAAAAAIBCEnQBAAAAAABQSIIuAAAAAAAACknQBQAAAAAAQCEJugAAAAAAACgkQRcAAAAAAACFJOgCAAAAAACgkARdAAAAAAAAFJKgCwAAAAAAgEISdAEAAAAAAFBIgi4AAAAAAAAKSdAFAAAAAABAIQm6AAAAAAAAKCRBFwAAAAAAAIUk6AIAAAAAAKCQBF0AAAAAAAAUkqALAAAAAACAQhJ0AQAAAAAAUEiCLgAAAAAAAApJ0AUAAAAAAEAhCboAAAAAAAAoJEEXAAAAAAAAhSToAgAAAAAAoJAEXQAAAAAAABSSoAsAAAAAAIBCEnQBAAAAAABQSIIuAAAAAAAACknQBQAAAAAAQCEJugAAAAAAACgkQRcAAAAAAACFJOgCAAAAAACgkARdAAAAAAAAFJKgCwAAAAAAgEISdAEAAAAAAFBIgi4AAAAAAAAKSdAFAAAAAABAIQm6AAAAAAAAKCRBFwAAAAAAAIUk6AIAAAAAAKCQBF0AAAAAAAAUkqALAAAAAACAQhJ0AQAAAAAAUEiCLgAAAAAAAApJ0AUAAAAAAEAhCboAAAAAAAAoJEEXAAAAAAAAhSTo+q/JkyfnxBNPzMYbb5zu3bunrq4uAwcOzCGHHJJHH3202sUDAAAAAADgPWpKpVKp2oWotueeey4f+tCH8vrrr6e2tjZrr712evTokbFjx2bmzJnp0KFDrrjiihx88MFN2m59fX169OiRJJk5c2a6d+/eEsUHAAAAAAAolHJlKEZ0JTnmmGPy+uuvZ+jQoXnqqafy/PPP5z//+U9ef/31HHXUUVm4cGGOPvroTJ06tdpFBQAAAAAA4L/afdA1Y8aM3HXXXUmSc845J+utt96iz7p3755f/epX6dOnT2bOnJl77rmnSqUEAAAAAADgvdp90DV37ty8M3vjOuus877PO3bsmIEDByZJ5s+fX9GyAQAAAAAAsHTtPujq06dPVl999STJfffd977Pp06dmmeffTa1tbXZYostKl08AAAAAAAAlqLdB11JctZZZ6WmpibHH398Lr/88kycODH19fUZOXJk9ttvv9TX1+fb3/52Bg0aVO2iAgAAAAAA8F8dq12A1uDQQw/NCiuskB/84Ac54ogj3vXZwIEDc+WVV+aQQw6pUukAAAAAAABYEiO6kpRKpYwdOzZvvPFGamtrs9Zaa2WTTTZJt27dMn78+Fx88cV55plnql1MAAAAAAAAFmNEV5JjjjkmF198cbbeeuvceuutGTJkSJJk9uzZOe2003LOOedk++23zxNPPJE11lijWfsYPHhwamvligAAAAAAAA0NDYv+PWzYsIwaNapZ26kplUqlchWqiB577LFsvvnm6dixY8aMGZOBAwe+b5ndd989d9xxR44++uhceOGFjd52fX19evToUc7iAgAAAAAAtCn9+/fPa6+91qx12/2IrpEjR6ZUKmXw4MFLDLmSZM8998wdd9yRhx56qNn76d+/vxFdAAAAAAAAeXtE14QJE5Ikffv2bfZ22n3QNWPGjEYvO2fOnGbvZ8yYMenevXuz1wcAAAAAAGgrFp8Vb8SIEc3eTrsfYvTO+7jGjBmT8ePHL3GZW2+9NUkydOjQipULAAAAAACAD9bug64999wzq666aubPn59PfvKTGT169KLPZs+enRNOOCF33HFHkuTQQw+tVjEBAAAAAAB4j3Y/dWH37t3zxz/+MR/72Mfy0EMPZf3118/AgQPTs2fPPP/885k1a1aS5Ctf+UoOOOCAKpcWAAAAAACAd9SUSqVStQvRGrzwwgs577zzcvvtt2f8+PFZsGBB+vTpk2222SZHHnlkPvKRjzR5m4vPLzlz5kzv6AIAAAAAAEj5MhRBVwsSdAEAAAAAALxfuTKUdv+OLgAAAAAAAIpJ0AUAAAAAAEAhCboAAAAAAAAoJEEXAAAAAAAAhSToAgAAAAAAoJAEXQAAAAAAABSSoAsAAAAAAIBCEnQBAAAAAABQSIIuAAAAAAAACknQBQAAAAAAQCEJugAAAAAAACgkQRcAAAAAAACFJOgCAAAAAACgkARdAAAAAAAAFJKgCwAAAAAAgEISdAEAAAAAAFBIgi4AAAAAAAAKSdAFAAAAAABAIQm6AAAAAAAAKCRBFwAAAAAAAIUk6AIAAAAAAKCQBF0AAAAAAAAUkqALAAAAAACAQhJ0AQAAAAAAUEiCLgAAAAAAAApJ0AUAAAAAAEAhCboAAAAAAAAoJEEXAAAAAAAAhSToAgAAAAAAoJAEXQAAAAAAABSSoAsAAAAAAIBCEnQBAAAAAABQSIIuAAAAAAAACknQBQAAAAAAQCEJugAAAAAAACgkQRcAAAAAAACFJOgCAAAAAACgkARdAAAAAAAAFJKgCwAAAAAAgEISdAEAAAAAAFBIgi4AAAAAAAAKSdAFAAAAAABAIQm6AAAAAAAAKCRBFwAAAAAAAIUk6AIAAAAAAKCQBF0AAAAAAAAUkqALAAAAAACAQhJ0/dcbb7yRE044Ieuvv366du2a3r17Z+edd86f/vSnahcNAAAAAACAJehY7QK0Bs8880x23333vPbaa+nUqVM22mijzJkzJyNGjMi9996bO+64I5deemm1iwkAAAAAAMBi2v2IroULF+bjH/94XnvttQwbNiwvvfRSHn300Tz99NN57LHHsuaaa+ayyy7LJZdcUu2iAgAAAAAAsJh2H3TdeOONeeaZZ1JXV5ff//736dev36LPNt544/zqV79Kknz/+9/PwoULq1VMAAAAAAAA3qPdB10jRoxIkmy11VZZa6213vf5fvvtl+7du+e1117LvffeW+HSAQAAAAAAsDTtPuiaOnVqkmT11Vdf6jLvfHbfffdVpEwAAAAAAAAsW7sPulZcccUkyauvvrrUZd757LnnnqtEkQAAAAAAAGiEdh90bb311kmShx9+OOPHj3/f5zfeeGPq6+uTJNOmTato2QAAAAAAAFi6jtUuQLUdcMABGTBgQF555ZV85jOfyV//+tesscYaSZKHHnooRx999KJlZ82a1ez9DB48OLW17T5XBAAAAAAASENDw6J/Dxs2LKNGjWrWdtp90FVXV5e//vWv2WefffLAAw9k7bXXzuDBgzNnzpyMGzcuK6+8cg466KD8/e9/T8+ePZu9nwkTJpSx1AAAAAAAAG3DxIkTm71uuw+6kmT77bfPqFGj8uMf/zi33HJLXnjhhfTu3TuHH354zjjjjJx11llJkn79+jV7H/379zeiCwAAAAAAIG+P6HpnkFDfvn2bvR1B13+tvfbaufjii5f42VNPPZUk2WqrrZq9/TFjxqR79+7NXh8AAAAAAKCtqK+vT48ePZIkI0aMaPZ2DDFahsmTJ+f+++9Px44ds++++1a7OAAAAAAAAPyXoGsZTjnllCxYsCCf/vSn079//2oXBwAAAAAAgP8SdCW58cYbM3LkyHf9bPr06fnmN7+Ziy++OKusskrOPffcKpUOAAAAAACAJfGOriS33nprLrjggvTq1StrrbVWkuTZZ5/NvHnzsvrqq+emm25arhehAQAAAAAAUH6CriQf+9jHMnHixDz44IMZM2ZMOnbsmA022CAHHXRQvvnNb6Znz57VLiIAAAAAAADvUVMqlUrVLkRbVV9fnx49eiRJZs6cme7du1e5RAAAAAAAANVXrgzFO7oAAAAAAAAoJEEXAAAAAAAAhSToAgAAAAAAoJAEXQAAAAAAABSSoAsAAAAAAIBCEnQBAAAAAABQSIIuAAAAAAAACknQBQAAAAAAQCEJugAAAAAAACgkQRcAAAAAAACFJOgCAAAAAACgkARdAAAAAAAAFJKgCwAAAAAAgEISdAEAAAAAAFBIgi4AAAAAAAAKSdAFAAAAAABAIQm6AAAAAAAAKCRBFwAAAAAAAIUk6AIAAAAAAKCQBF0AAAAAAAAUkqALAAAAAACAQhJ0AQAAAAAAUEiCLgAAAAAAAApJ0AUAAAAAAEAhCboAAAAAAAAoJEEXAAAAAAAAhSToAgAAAAAAoJAEXQAAAAAAABSSoAsAAAAAAIBCEnQBAAAAAABQSIIuAAAAAAAACknQBQAAAAAAQCEJugAAAAAAACgkQRcAAAAAAACFJOgCAAAAAACgkARdAAAAAAAAFJKgCwAAAAAAgEISdAEAAAAAAFBIgi4AAAAAAAAKSdAFAAAAAABAIQm6AAAAAAAAKCRBFwAAAAAAAIUk6AIAAAAAAKCQBF0AAAAAAAAUkqALAAAAAACAQhJ0AQAAAAAAUEhtKugaN25cLr300hx99NHZcsst07lz59TU1OTwww9v1Pq33npr9t5776y88srp1q1bNt544/zoRz/KvHnzWrbgAAAAAAAANFnHahegnM4///xccMEFzVr33HPPzXe+850kycCBA7PmmmvmySefzMknn5x//vOfuf3229O1a9dyFhcAAAAAAIDl0KZGdPXp0yf77rtvTjvttNxwww059thjG7Xegw8+mOOPPz41NTX53e9+l3HjxmXUqFF59tlns+666+a+++7LSSed1MKlBwAAAAAAoCna1IiuU0455V3//cADDzRqvTPPPDOlUilHHHFEDjvssEU/HzRoUC699NLssssuufDCC3PyySdn1VVXLWuZAQAAAAAAaJ42NaKrOWbMmJFbb701SXLkkUe+7/Odd945Q4YMybx583L99ddXungAAAAAAAAsRbsPukaNGpV58+alrq4uW2211RKXGTZsWJLGjxADAAAAAACg5bX7oGv06NFJkoEDB6ZjxyXP5Dho0KB3LQsAAAAAAED1tfuga9q0aUmS3r17L3WZdz57Z1kAAAAAAACqr90HXXPmzEmSdO7ceanL1NXVJUlmz55dkTIBAAAAAACwbEueq68d6dKlS5Jk3rx5S11m7ty5SZKuXbs2ez+DBw9ObW27zxUBAAAAAADS0NCw6N/Dhg3LqFGjmrWddh90NWZawsZMb7gsEyZMaPa6AAAAAAAAbdXEiRObvW67D7qGDBmSJBk/fnwWLFiQjh3f/ysZO3bsu5Ztjv79+xvRBQAAAAAAkLdHdL0zSKhv377N3k67D7o233zzdO7cOXPnzs3DDz+c7bbb7n3LjBgxIkmy7bbbNns/Y8aMSffu3Zu9PgAAAAAAQFtRX1+fHj16JPlfDtMc7X6IUc+ePbPHHnskSS655JL3fX7PPfdk9OjR6dy5cw444IBKFw8AAAAAAIClaPdBV5KccsopqampyeWXX54rrrhi0c/Hjh2bL37xi0mSL3/5y1l11VWrVUQAAAAAAADeo6ZUKpWqXYhyGTly5LtGXc2aNSuzZ89OXV3douFvSXLddddlxx13fNe6P/nJT3LiiScmSQYOHJjevXvnySefzIIFC7LtttvmzjvvTLdu3ZpUnsWH3c2cOdPUhQAAAAAAAClfhtKm3tE1f/78TJky5X0/nzt3bubOnfuu5d7rhBNOyKabbppzzz03Dz30UCZOnJghQ4bk4IMPznHHHZe6uroWLTsAAAAAAABN06ZGdLU2RnQBAAAAAAC8X7kyFO/oAgAAAAAAoJAEXQAAAAAAABSSoAsAAAAAAIBCEnQBAAAAAABQSIIuAAAAAAAACknQBQAAAAAAQCEJugAAAAAAACgkQRcAAAAAAACFJOgCAAAAAACgkARdAAAAAAAAFJKgCwAAAAAAgEISdAEAAAAAAFBIgi4AAAAAAAAKSdAFAAAAAABAIQm6AAAAAAAAKCRBFwAAAAAAAIUk6AIAAAAAAKCQBF0AAAAAAAAUkqALAAAAAACAQhJ0AQAAAAAAUEiCLgAAAAAAAApJ0AUAAAAAAEAhCboAAAAAAAAoJEEXAAAAAAAAhSToAgAAAAAAoJAEXQAAAAAAABSSoAsAAAAAAIBCEnQBAAAAAABQSIIuAAAAAAAACknQBQAAAAAAQCEJugAAAAAAACgkQRcAAAAAAACFJOgCAAAAAACgkARdAAAAAAAAFJKgCwAAAAAAgEISdAEAAAAAAFBIgi4AAAAAAAAKSdAFAAAAAABAIQm6AAAAAAAAKCRBFwAAAAAAAIUk6AIAAAAAAKCQBF0AAAAAAAAUkqALAAAAAACAQhJ0AQAAAAAAUEiCLgAAAAAAAApJ0AUAAAAAAEAhCboAAAAAAAAopDYVdI0bNy6XXnppjj766Gy55Zbp3Llzampqcvjhh7fIegAAAAAAAFRPx2oXoJzOP//8XHDBBRVbDwAAAAAAgOppU0FXnz59su+++2brrbfOVlttlZtuuim//vWvW2w9AAAAAAAAqqdNBV2nnHLKu/77gQceaNH1AAAAAAAAqJ429Y4uAAAAAAAA2g9BFwAAAAAAAIUk6AIAAAAAAKCQBF0AAAAAAAAUUsdqF6C9GDx4cGpr5YoAAAAAAAANDQ2L/j1s2LCMGjWqWdsRdFXIhAkTql0EAAAAAACAVmfixInNXlfQVSH9+/c3ogsAAAAAACBvj+h6Z5BQ3759m70dQVeFjBkzJt27d692MQAAAAAAAKquvr4+PXr0SJKMGDGi2dsxxAgAAAAAAIBCEnQBAAAAAABQSIIuAAAAAAAACqmmVCqVql2Ichk5cmQOOOCARf89a9aszJ49O3V1dYvmeUyS6667LjvuuONyr7csi88vOXPmTO/oAgAAAAAASPkylI7lLFS1zZ8/P1OmTHnfz+fOnZu5c+e+a7lyrAcAAAAAAED1tKkRXa2NEV0AAAAAAADvV64MxTu6AAAAAAAAKCRBFwAAAAAAAIUk6AIAAAAAAKCQBF0AAAAAAAAUkqALAAAAAACAQhJ0AQAAAAAAUEiCLgAAAAAAAApJ0AUAAAAAAEAhCboAAAAAAAAoJEEXAAAAAAAAhSToAgAAAAAAoJAEXQAAAAAAABSSoAsAAAAAAIBCEnQBAAAAAABQSIIuAAAAAAAACknQBQAAAAAAQCEJugAAAAAAACgkQRcAAAAAAACFJOgCAAAAAACgkARdAAAAAAAAFJKgCwAAAAAAgEISdAEAAAAAAFBIgi4AAAAAAAAKSdAFAAAAAABAIQm6AAAAAAAAKCRBFwAAAAAAAIUk6AIAAAAAAKCQBF0AAAAAAAAUkqALAAAAAACAQhJ0AQAAAAAAUEiCLgAAAAAAAApJ0AUAAAAAAEAhCboAAAAAAAAoJEEXAAAAAAAAhSToAgAAAAAAoJAEXQAAAAAAABSSoAsAAAAAAIBCEnQBAAAAAABQSIIuAAAAAAAACknQBQAAAAAAQCEJugAAAAAAACgkQRcAAAAAAACFJOgCAAAAAACgkARdAAAAAAAAFJKgCwAAAAAAgEISdAEAAAAAAFBIbSroGjduXC699NIcffTR2XLLLdO5c+fU1NTk8MMPX+o6pVIpI0eOzIknnpgddtghK620Ujp16pS+fftmv/32y/XXX1+5LwAAAAAAAECjdax2Acrp/PPPzwUXXNCkde68887svvvuSZKampoMGjQo66yzTp5//vkMHz48w4cPzxFHHJHf/va3qampaYliAwAAAAAA0AxtakRXnz59su++++a0007LDTfckGOPPXaZ65RKpayzzjr5xS9+kUmTJmXMmDF5+OGHM2XKlJx33nmpqanJZZddlgsvvLAC3wAAAAAAAIDGalMjuk455ZR3/fcDDzywzHW22WabPPvss+nUqdO7ft6hQ4d885vfzLPPPpuLL744v/nNbxoVnAEAAAAAAFAZbWpEV3P06tXrfSHX4vbaa68kyXPPPVepIgEAAAAAANAI7T7oWpY5c+YkSbp161blkgAAAAAAALA4Qdcy/OUvf0mS7LTTTlUuCQAAAAAAAIsTdH2AG2+8Mdddd12S5IQTTqhyaQAAAAAAAFicoGspxo4dm0MOOSRJ8vWvfz077LBDlUsEAAAAAADA4jpWuwCt0euvv5699947U6dOzZ577pmf/vSny73NwYMHp7ZWrggAAAAAANDQ0LDo38OGDcuoUaOatR1B13u8E249//zz2XHHHXPttdemU6dOy73dCRMmlKF0AAAAAAAAbcvEiRObva6gazFvvfVW9t577zzxxBPZYostMnz48HTr1q0s2+7fv78RXQAAAAAAAHl7RNc7g4T69u3b7O0Iuv5r1qxZ2W+//fLQQw9l/fXXzy233JIVVlihbNsfM2ZMunfvXrbtAQAAAAAAFFV9fX169OiRJBkxYkSzt2OIUZJ58+blwAMPzL333ptBgwbl9ttvT58+fapdLAAAAAAAAD5Auw+6Fi5cmM997nO59dZbM2DAgNx+++1ZbbXVql0sAAAAAAAAlqGmVCqVql2Ichk5cmQOOOCARf89a9aszJ49O3V1dYuGvyXJddddlx133DFJctVVV+Vzn/tckmSdddZJ//79l7r9q6++Ov369Wt0eRYfdjdz5kxTFwIAAAAAAKR8GUqbekfX/PnzM2XKlPf9fO7cuZk7d+67llv8s3e88MILeeGFF5a6/Tlz5pSppAAAAAAAACyvNjWiq7UxogsAAAAAAOD9ypWhtPt3dAEAAAAAAFBMgi4AAAAAAAAKSdAFAAAAAABAIQm6AAAAAAAAKCRBFwAAAAAAAIUk6AIAAAAAAKCQBF0AAAAAAAAUkqALAAAAAACAQhJ0AQAAAAAAUEiCLgAAAAAAAApJ0AUAAAAAAEAhCboAAAAAAAAoJEEXAAAAAAAAhSToAgAAAAAAoJAEXQAAAAAAABSSoAsAAAAAAIBCEnQBAAAAAABQSIIuAAAAAAAACknQBQAAAAAAQCEJugAAAAAAACgkQRcAAAAAAACFJOgCAAAAAACgkARdAAAAAAAAFJKgCwAAAAAAgEISdAEAAAAAAFBIgi4AAAAAAAAKSdAFAAAAAABAIQm6AAAAAAAAKCRBFwAAAAAAAIUk6AIAAAAAAKCQBF0AAAAAAAAUkqALAAAAAACAQhJ0AQAAAAAAUEiCLgAAAAAAAApJ0AUAAAAAAEAhCboAAAAAAAAoJEEXAAAAAAAAhSToAgAAAAAAoJAEXQAAAAAAABSSoAsAAAAAAIBCEnQBAAAAAABQSIIuAAAAAAAACknQBQAAAAAAQCEJugAAAAAAACgkQRcAAAAAAACFJOgCAAAAAACgkNpU0DVu3LhceumlOfroo7Plllumc+fOqampyeGHH/6B611//fU55phjss0222T11VdPXV1devbsmc022ywnn3xyJk+eXJkvAAAAAAAAQKN1rHYByun888/PBRdc0OT1fvazn+Xuu+9O586ds9pqq2WTTTbJpEmT8vjjj+exxx7Lb3/729x6663ZbLPNyl9oAAAAAAAAmqVNjejq06dP9t1335x22mm54YYbcuyxxzZqvSOOOCJ33HFHZsyYkRdffDEPPfRQxo8fn8ceeywbbbRR3njjjXzuc59r4dIDAAAAAADQFG1qRNcpp5zyrv9+4IEHGrXeoYceusSfb7zxxrn00kuz7bbb5plnnskzzzyT9ddff7nLCQAAAAAAwPJrUyO6WsLiwdasWbOqWBIAAAAAAAAWJ+hahpEjRyZJunfvnqFDh1a5NAAAAAAAALyjTU1dWC4NDQ2ZOHFibrvttpxwwglJkrPOOis9evSocskAAAAAAAB4h6BrMRdddFGOOeaYd/1syy23zG9/+9vst99+VSoVAAAAAAAAS2LqwsX0798/O+64Y7bddtusttpqqampyeOPP54//elPefPNN6tdPAAAAAAAABZjRNdiDjjggBxwwAGL/vuJJ57IV77ylVx11VV56aWXMmLEiGZve/DgwamtlSsCAAAAAAA0NDQs+vewYcMyatSoZm1H0PUBNt544wwfPjzrrLNORo4cmdtvvz277757s7Y1YcKEMpcOAAAAAACg+CZOnNjsdQVdy9CzZ8/ssssuueaaa/LYY481Kejq1q1bZs6cmWHDhmXSpEmpqalpwZICAAAAAAAUQ6lUSqlUSvL2q6WaS9DVCAsWLEiSLFy4sEnr1dTUpHv37s0ebgcAAAAAAMDSeWnUMkydOjV33313kmSzzTarbmEAAAAAAABYpN0HXQ8//HBOPfXUPP/88+/7bNSoUdlnn30yffr0bLzxxtltt92qUEIAAAAAAACWpKb0zgSIbcDIkSNzwAEHLPrvWbNmZfbs2amrq0uPHj0W/fy6667LjjvumCS56667suuuuyZJVl111ayxxhrp0KFDXnnllbz22mtJkiFDhuSmm27KOuusU8FvAwAAAAAAwAdpU+/omj9/fqZMmfK+n8+dOzdz585913Lv2HTTTXPBBRfkX//6V5588smMHj06c+bMyUorrZTdd989Bx54YI444oh06dKlIt8BAAAAAACAxmlTI7oAAAAAAABoP9r9O7oAAAAAAAAoJkEXAAAAAAAAhSToAgAAAAAAoJAEXQAAAAAAABSSoAsAAAAAAIBCEnQBAAAAAABQSIIuAAAAAAAACknQBQAAAAAAQCEJugAAAAAAACgkQRcAAAAAAACFJOgCAAAAAACgkARdAAAAAAAAFJKgCwAAAAAAgEISdAEAAAAAAFBIgi4AAAAAAAAKSdAFAAAAAABAIQm6AAAAAAAAKCRBFwAAAAAAAIUk6AIAAAAAAKCQBF0AAAAAAAAUkqALAAAAAACAQhJ0AQAAAAAAUEiCLgAAAAAAAApJ0AUAAAAAAEAhCboAAAAAAAAoJEEXAAAAAAAAhSToAgAAAAAAoJAEXQAAAAAAABSSoAsAAAAAAIBCEnQBAAAAAABQSIIuAAAAAAAACknQBQAAAAAAQCEJugAAAAAAACgkQRcAAAAAAACFJOgCAAAAAACgkARdAAAAAAAAFJKgCwAAAAAAgEISdAEAAAAAAFBIgi4AAAAAAAAKSdAFAAAAAABAIQm6AAAAAAAAKCRBFwAAAAAAAIUk6AIAAAAAAKCQBF0AAAAAAAAUkqALAAAAAACAQhJ0AQAAAAAAUEiCLgAAAAAAAApJ0AUAAAAAAEAhCboAAAAAAAAoJEEXAAAAAAAAhSToAgAAAAAAoJAEXQAAAAAAABSSoAsAAAAAAIBCEnQBAAAAAABQSIIuAAAAAAAACknQBQAAAAAAQCEJugAAAAAAACgkQRcAAAAAAACFJOgCAAAAAACgkARdAAAAAAAAFJKgCwAAAAAAgEISdAEAAAAAAFBIgi4AAAAAAAAKSdAFAAAAAABAIQm6AAAAAAAAKCRBFwAAAAAAAIUk6AIAAAAAAKCQBF0AAAAAAAAUkqALAAAAAACAQhJ0AQAAAAAAUEiCLgAAAAAAAApJ0AUAAAAAAEAhCboAAAAAAAAoJEEXAAAAAAAAhSToAgAAAAAAoJAEXQAAAAAAABSSoAsAAAAAAIBCEnQBAAAAAABQSIIuAAAAAAAACknQBQAAAAAAQCEJugAAAAAAACgkQRcAAAAAAACFJOgCAAAAAACgkARdAAAAAAAAFJKgCwAAAAAAgEISdAEAAAAAAFBIgi4AAAAAAAAKSdAFAAAAAABAIQm6AAAAAAAAKCRBFwAAAAAAAIUk6AIAAAAAAKCQBF0AAAAAAAAUkqALAAAAAACAQhJ0AQAAAAAAUEiCLgAAAAAAAApJ0AUAAAAAAEAhCboAAAAAAAAoJEEXAAAAAAAAhdSx2gUgKZVKWTB7brWLUXYdu9alpqam2sWgoIrYLtT55ivi8W4MdaJx2urxT9QBmq+I7UJ9Ly91gPZOG2hfini8G0u9aBx1gLZaBxx/lkcR20W16rygqxVYMHtu/jjo89UuRtkdPPYP6dStS7WLQUEVsV2o881XxOPdGOpE47TV45+oAzRfEduF+l5e6gDtnTbQvhTxeDeWetE46gBttQ44/iyPIraLatV5UxcCAAAAAABQSIIuAAAAAAAACknQBQAAAAAAQCEJugAAAAAAACikjtUuALS0UqmUl1+vz3Pj3sysOQtSW1OTXj06ZePBK2WlFeqqXbyKmFE/L4+PnpZpb83NgoUN6dK5Ywat0TOD1uiV2tqaahePCpg4ZXaeen5aZs6an1KSHl07ZYNBK6b/Kt2qXTQqoFQq5YVXZuT5l97K7LkL0qG2Nr17dc4mQ1ZKrx6dq108KmD+/IY8/cK0vDppVubOW5jOnWrTr0+3bLRu79R17lDt4rW4UqmUVyfOyrPjpqd+9oLUJOnZ/e1rgT69vRi6PWhoKGX0+Dfz4iszMnf+wnTsUJuVV6zLJoNXSvdunapdPCpg7ryFefL5aXl98qzMm9+Qus4dMqBv92ywzorp2LHtP/9ZKpUy7tWZGfPS2/dEHWprs0KPTtlkyEpZsVf7uCdq7xYsaMgzL0zPKxPrM3f+wnTqWJtVV+qajQf3Tpc6XUPtwazZC/LEmKmZPH1O5i9oSF2nDllr9Z4ZMrBXOnRo++dBkqlvzs0TY6bmzRnzUkrSrUvHrLf2ChnQt3tqavQNtXX6R5fcP7rumr0yaI2e2kAb4GqGNmnO3AX56y0v5qqbXsjDT0/O5GlzlrjcWqv1yPabrpojDhyS3bZdrU2d1B568o385upnM2LUxDw37s2USu9fplePTtli/T75+O5r5ZD91s0KPXV4txULFzZk+D0v54rrn8+/n5iUVyfNWuJy/Vfplm026pND9ls3+39oYDp1coPTVsyon5c/Dh+bq28bl0eenpzpM+YtcbnBA3tlx8365siPD832m67aps6D7d0rr9fnkmuey80jX8ljo6dm7ryF71umU8fabDy4d3bfbrV8+ZPrZZ0BvapQ0pYxb/7CXHPbuPzxxrF56Mk3Mmnqkq8F1uzfPdttsmoO339w9tpxgAdA2pCpb87N764bnX/cOT6jnp2ambPmv2+Z2tqarLf2Ctlly3758ifXy6ZDV65CSWkpY19+Kxf/7dnc/sBrefL5aZm/oOF9y3Sp65BNBq+UfYYNyJEfH5rV+3avQklbxqzZC3LVTWPzl1teyCNPT8nUN+cucblBa/TMDpv2zZcOGpKdtuznWqANeX3yrPz2789l+D0v57HRUzN7zvuvBTp2rMmGg3rnw9v0z9GfXD9D1lqhCiWlpTw5Zmouvvq53PXQhDzz4vQsXPj+joHuXTtms/VWzv67rJkjDhziIaA2pKGhlDv+/Vouu3Z0Hnh8Usa9NnOJy63Su0u22rBPPrvPOvnknmsLv9uQxvaPrr16z7f7Rz82JB/etn+buRYolUp56MnJueSaZ3PvoxMzevyS+0dX6Nk5W6y3cg7afa0c+tF1PRBcUDWl0pIOL5U0f9ac/HHQ56tdjLI7eOwf0qlbZS+QZs6an7MueSy/uebZTJm+5Bu5pRkycIUcd9hG+dJBQwvdyXXtHeNy1m8fy8NPTW7Set27dswh+62b7x+7Rfqu3LWFStd4RWwX1ajz7zV/fkMu+ONT+cVVT+WlCfVNWne1Vbvlq5/ZIN8+dKOKj/Ao4vFujGrUiSnT5+T0i0bld9eNyYz693fqfpDN1lspJ35hk3x673UqemHbVo9/Up068NTz03Lqrx7NdXeNX2JnxtLU1CR77zgg3z9mi2yz8SotWMKWNWv2gpx92eO56G/PLDXcWpp1BvTMtw7ZKMd8ar2qP9lcxHbRGv4OJm+HvKf++pFcddMLmTP3/Z26H2SHzVbNKUduln12WqOFStd46kDz/fvxSfn+haNy88hXmrRehw41+diuA3PGV7bIBoN6t1DpWt70t+bmzN/8J5ddO3qpD7oszYaDVszxh2+SQ/dft+qdXNpA840e92ZO/fUjueb2cVmwoGldPrtvt1pOO3rzDNuiXwuVbsmKeLwbqxr14vYHXs0ZF43KvY9ObNJ6dZ075NN7rZ0zvrJFBq7Ws4VKt2TqQPk0NJRyyTXP5dwrn8iY8W81ad0+vbvkqI8PzUlf2jQ9Kjzqva3WgWqcA2bUz8tZv30sl1zzXJP7R4eutUKOO3SjfLHg/aPX3PZifnTp43nk6ab3jx760XXz/WO2yKr6R5ulWtdDgq5WoFwVtt/2G2bvv5/+7m3Xz85bL0zI2KvvyTOX3pjSwvc/xdhSKl2p//Xgazni1HuX+oRKY+2yVb9cdsZOhXuq/Y2ps/OVs+7P3259cbm2s/KKdfnlSdtXvKP7vZrTLqrdBqp9Y/v46Kk5/JR7MurZKcu1nY3W7Z3f/WDnbLlBnzKVbNmcB8vj2jvG5egzRza5c/+99v/QmrnoeztWbGrLcl64tec6sGBBQ8753RP5/oWPZt785n/H2tqaHH/4xvn+MZsX7mnOkaMm5gun3tPkG/r32n7TVXP5GTtl6NorlqdgzdDcdlHNNlDtv4OlUim/u25MvnXOv/NmEzv33+uw/QfnvBO2Te8qTummDjTdnLkLcuqvHs25Vz6Zhobm3+Z27lSbM76yRY47dOPCTWt4470v56jTRyx1NH9j7bXD6rnk+8OyRr8eZSpZ02kDTbdw4dsPvf3fLx5pctC/uJqa5BsHb5gffm2rdOtamWsB14Pl8dbMeTnup//Ob/8+erm206Nbp/z0uG1y1CeGVqxfQB0oj+dfeitHnHpPk0PO91p79Z657Iyd8qGt+5epZMumX6A87vz3aznitHszfjn7Rz+0df9cdvpOWXtAZUPv5TVpyux85az7cvVt45ZrO316d8mvTt4+n9prnfIUrJn0jzZesXovaJQX/n5vXrnz0aSmJl1XWTHrfnKXbHP64Vlh8Oq5//iLq128siuVSvneLx/JDy95rCzbu/vh17PxQdfmDz/aJQfutlZZttnSHnhsUvb/+m15YylDkJtiyvS5+eyJd+XGe1/JpafvVMip7NpbG0iSS65+Nl856/4lTsnTVE8+Py3bHnx9fvadbfP1gzcsQ+kqr73VgYULG3LsD+/Lb65+rizbu/6ul3Lvo6/n2vN3zy5bVe7GppzaWx2YMn1OPvq123L/Y5OWe1sNDaWcfdnjGX7Py7np13tlQL/WP41XqVTKj377WE755SNLnIqiqe5/bFI2+9Q/ctnpO+Wz+w5a/g1WQXtrA3PmLsjB3707f79jXFm2d8X1Y3LbA6/mxl/tWdjpDNtbHXhpwszse+wteWrs9OXe1rz5Dfnu+Q/nhrtfzvU/36MQ761oaCjluJ/+O+f/4amybO+W+17NRgf9PX8958PZa8cBZdlmpbW3NvDmjHn52Ddvz10PTVjubZVKyfl/eCo33vtKbrpwz8I9BPqO9lYHnh47Lfsce0uTZ/ZYkpmz5ufoM0fmhrtfyl9+smth32fZ3urA328fl8+ffNcSpyltqhdfnZFdv3hjvvflzXL6sVtUfZRvc7S3418qlXLKLx7JWb8tT//oXQ9NyMYf/3v++OMP5YBdB5Zlmy3t/scmZv+v377UKRqbYvK0Ofn08f/Kjfe+kktOG6Z/tACKd4RYpilPvJgXrrk3L1x9T5668PoM/8jJqX91coZ8brfUrVzMC9SlKZVK+ebZD5Qt5HrHrDkL8onj7syfbxpb1u22hHsfeT27H3VTWUKuxf3+n8/nE8fdkfnLMSqgWtpTG0iSn//xqRx1xsiyhFzvWLiwlG+c/UB+VKYLpEprT3Vg4cKGHHzSXWULud4x7a152fuYW3Lb/a+WdbuV0p7qwORpc7LLF4aXJeRa3JPPT8uww/+ZlyYs35OAlfB/P38k//eL8oRc75gzd2EOPumuXHbt8j0RXS3tqQ3Mmbsg+331trKFXO94bdKs7HLEjXn4qTfKut1KaU91YNyrM7LT4f8sS8i1uJGjJuZDRwzPlOnlvc4ut4aGUr70/XvLFnK9462Z8/PRr92WG+56qazbrZT21AamvzU3H/7SjWUJuRY3evybGXbY8IwZ/2ZZt1sp7akOPD56anb+wvCyhFyLG37Py9n7mFtSv4T3XBZBe6oDfxo+Np/8zp1lCbkWd+bF/8m3z/l3ijghWHs6/qVSKV//8QNlC7neUT97QT7+7Tvy11teKOt2W8I9D0/I7kfeXJaQa3FXXD8mn/yO/tEiEHS1Awtmz80bj45JTW1teg3sW+3ilNUPL/lPfv6np1tk2w0NpRzyf3fn9gdabyfv02OnZb+v3Zr62QtaZPvX3/VSjjx9RItsu5Lachu46sax+cbZD7TY9k/++cP57TXlDVCqoS3Xga//+IH85eblm7J0aebMXZiPfeP2PNrEOa1bo7ZaB+bMXZB9yjSCYUnGvzYzexx1c6a/1bR53SvpvN8/mR9d2jKhfKmUHHn6iFz/r/Etsv1KaqttoFQq5eDv3p07/v1ai2z/zRlvh/4vvLJ802G2Bm21Dkx7a272+PLNZe/cfccTY94eITF3Xnk7Dsvpu+c/lMv/MaZFtj1/QUM++Z07c99/lm8KrNagrbaB+fMb8tGv3ZZHn1m+6cuXZsIbs7LHl2/OG1Nnt8j2K6mt1oGXX5+ZPb98c5Pfw9NYI0ZNzCe/c+dyTQnbWrTVOnDrfa/k0FPubrFjdP4fnirsQ7CLa6vHP0nOuGhUfnlVy/SPLlxYysEn3ZU7W+h6uxyeHDM1+33ttsya0zL9o9f966V8+Uz9o62doGsxt956a/bee++svPLK6datWzbeeOP86Ec/yrx5yzfHf2vQc623K+/c6a3/qezGevCJN3Lar0c1aZ2Hrto/L9/2mTx01f6NWn7BglIOO+WeVtnBN39+Qw79v3vy1szGP1nV1O+fvP3kwvK+96s1aItt4OXXZ+boH4xs0jrNqQPfOPuBjH25+B18bbEODL/npfz6L880aZ2m1oFZcxbk0P+7u1V38DVWW6wD379wVB5+qmlBZFPrwOjxb+bbP/13c4rX4p4YPTUnnvdQk9Zp6vd/e6TEiDbRwdcW28Bl145u8kiuptaBKdPn5gvfu7dNdPC1xTrwzbMfyPMvNf46pTnXQg89OTlnXNS0+45K+deDr+Wc3z3RpHWa+juYO29hDv2/uws7omNxbbENnH35YxkxqmlBZFPrwPjXZuarP7q/OcVrddpaHSiVSvniafdm4pTGX6c05zx404hXmnzf0Vq1tTow7a25Ofx792bhwsZfpzSnDpz660cLO8p9cW3t+Cdvv87kjIv/06R1mts/urzvwW0J7/SPzqhv2f7Ry/8xJtfcpn+0NRN0/de5556bvfbaK7fcckt69uyZoUOH5tlnn83JJ5+cXXfdNbNnF6dzo2PXzqlbqWfqVu6VFddbM9ue9aWsvPE6eePRMXnrhfJOZVAtc+YuyBdOvafJHQ79+nTLgL7d069Pt0av89qkWfnWOa2vg+8nlz+eR5o4yqI53z9Jjv3hfZnUhAvnamsPbaBUKuXI749oUtCZNK8OzJqzIEecWqwOvvZQB6a9NTdHndG0oDNpXh14auz0nH5h6+zgW5r2UAcefOKNJnduJs2rA5f/Y0xuuvflJu+rJc2f35DDv3dPk6dtbc73f2PanHzlrGJ18LWHNvDy6zObFcI2pw7c88jr+dWfW+Yp2ZbSHurAP+9+KVfe8HyT1mnu9fDZlz/e6jr4Zs6anyNOvbfJ6zXndzD25Rk5+ecPN3lf1dQe2sDjo6fmjIv+0+T1mlMH/nrLi7m6YA9Atoc6cOnfR+e2+5s2yqK558ETz3uocA9Atoc68M2zH8iEN2Y1aZ3m1IGFC0s5/JR7CvUAZHs4/pXsH31lYn2Oa4UPQP74sscy6tmmjWpu7nnwmB/cV6gHINtDG1hcx2oXoDV48MEHc/zxx6empiaXX355DjvssCTJ2LFjs/fee+e+++7LSSedlPPPP7+6BW2kzU/4TDY/4TPv+tm44Q/k3yf9tkolKr+L/vpsnm6haZqW5HfXjclXP7tBttygT8X2+UEmTZmdMy6uXKfz5GlzcsbFo/LLk3eo2D6XR3toAzfe+3Juua9y02re88jr+dutL+bTe69TsX0uj/ZQB3586WN5bVLTbmiWx09+93iO/tR6WbN/j4rtc3m0hzrwzZ88UNEA+utnP5DndhyQ2trW8SLqK64f02LTNC3J3259Mfc8PCE7b9W/YvtcHu2hDZzyi0ea/MDH8jj554/ksP0Hp1ePzhXb5/Jo63WgoaHUotM3v9fChaV88yf/zogr9qvYPpflvN8/mXGvVe5p3J//6ekc++n1M3TtFSu2z+XR1ttAknzn3H+X9T29y/LNnzyQj314YDp2LMYz0229DsyavSAnnPdg5fY3Z0G+e/5D+du5u1Vsn8urrdeBh558o8kPfCyPp8ZOz2+ufjZf+9yGFdvn8mjrxz9Jfv2XZ/Lsi5V7j+Kl147OVz6zfjZfv3X0j06cMjs/+M1/Kra/N6bNyZm/+U9+/t3tK7bP5dEe2sDiinF10sLOPPPMlEqlfOELX1gUciXJoEGDcumllyZJLrzwwkyaVN6XvLeU535/a2751Om57eAf5uEzf585U2eke/+Vs3Du/4aX7nLht7LLxd9+13qdV+yRT/3nkqxz0E6VLnKTNDSU8uu/Vn7I/IWtaJj+pdeOzrwoqEJPAADbZUlEQVQKvwTxyhuez4z61jdEeUnaehtIkl/9ufL1sUhTVbT1OjBn7oJceu3oiu5z4cJSfnP1sxXd5/Jo63Vg1DOTc/9jlb0uef6lt1rNeytLpVJ+9ZfKj66pxvVHc7X1NjB52pz8+ebKvhR75qz5+f0/K9eZtLzaeh24ZeQreeGVGRXd58hRE/PYc5UL2D/I/PkNuehvlf+7XI19NldbbwPPvTi9ySN5lterk2bl+rtequg+l0dbrwN/vvmFTHursvfo1945Pq9Napl3IraEtl4HqnGP/uu/PJNSqRizvbT149/QUKpKHbjwr63nWuC31zxX8f7RK64fk5kFmc65rbeB92r3QdeMGTNy6623JkmOPPLI932+8847Z8iQIZk3b16uv/76ShevWd564fVMuPeJvHrnqDz56+tyx2E/Tp/NBmX7s7+8aJn7T7okq249NGt/bMdFP9vurC9l0oPP5oW/N336i0q688HXMmZ85YfL/+mmsZnWCt7VtXBhQy76W+X/kM2on58/Dh9b8f02R1tvA2Nffis3j3yl4vu955HX8+SYqRXfb3O09Trwt1tfbLGXTX+QS655LvPmF2OqirZeB6p1c9FaAu8HHp+U/zxb+fPRNbePy+uTKzeScnm09TZwWRUe+kmK1bnT1utAtc5HraVz54a7X6royO53XH7dmMK8q6utt4FqhY6t5VqgMdpyHSiVSlWZUnfhwlIuuea5iu+3udpyHZgyvfIP/STJsy++mbseKsaUZ235+CfJbfe/mrEvV/ahnyT54/Cxmd4K+kcXLGjIxVV4GPetmfPzpxv1j7ZG7T7oGjVqVObNm5e6urpstdVWS1xm2LBhSZIHHqjc1Bjl9MbDz2Xs1fdk7Y/tmFW2GpokmTd9Zu477sJs+8MvpWvf3hn4ke3Sb4cNc/+JF1e5tMt27R3jq7Lf2XMW5pYqhAvvNerZKXlpQnWeoGrqy95bi7bWBq6/66VUq4/tH/+qTvtbXm2tDlx7Z3WOw6Spcyo+iqhc2lIdKJVKVasDw+99OXPmLqjKvhdXrWuBBQtKGX5P63pXWWO1pTaQJNfeOa4q+3167PSqPHBVDm2pDsyesyA3Vem6/No7xrWKsLNabeDNGfNy18PF6OB8r7bUBpLqXQ/e8e/X8uaMYsz08V5tqQ68MrG+olM4L65ada8c2lIduGXkq5kztzoPIf69Stfiy6stHf+kem1x1pwFufX+6s/08egzU/Ly69XpH63W/ejyamtt4L3afdA1evTbUz8NHDgwHTsu+ZVlgwYNeteyRfTYeVenYcHCbH78pxf97NV//SfjbrgvO//y69nux0fmvuMuzNxplZvjvbkefmpy1fb9yNPVn6qk2t+/NdzYN4c2UB6toQ00lzpQHo88Xb19L6+2UgdemjAzk6fNqcq+Fywo5Ykx06qy78VpA83TVtrAggUN+c9z1RthrA5U32PPTc3ChdW5Jp00dU5enVj9kZ2uB5unrbSBydPmZHwF38/2XqOeVQeqrZrngKfGTmsVDz41V5upA0+/UbV9uxZqHap5HFpDHXj4qeq2Af2jrU+7D7qmTXu7s6Z3795LXeadz95ZtohmjHs9L143MqvtvElW3Xb9RT9/+PQr03Ptfnn1zlF55Y5Hq1jCxpk/vyGPjW7fHRvVLMPUN+dW9YZqebSVNpC4mGmutlIH3pg6u2pPLSXF7txqK3Wg2seg2ueBUqmUR6vYwVbt3//yaCtt4OkXplftCeak+m1gebSVOvDIM9U9BtXe/4z6eXluXOVePP9e2kD1VfsYVHv/y0MdWH4LFpTy+Gj9Y9VWzWvS/zw3JQsWVH4K6XJoK8d/3vyFebyq/aPVvyd6pEqjWpPkjWlz8srE4ryvcHFtpQ0sSbsPuubMefuJ6M6dOy91mbq6uiTJ7Nmzm7TtUqmU+vr61NfXt4qU9/ELrknDwncntgtmz83M8ZMy7ZlivFB2wuRZmTuveh0bL7xa+blv31eGCr90u7Xtf3m0hTaQVPcYvPx6feZX4Z0o5dIW6kC12+ALrxRzyq53qAPF3//UN+dWdcqk1nAtsDzaRhuo7nlIHai+ap+Hqr3/8a/NrNo01kn1v//y0gaKv//lpQ6UY//uCaqtmnVg9pyFmTilaX2krUlbOP6vTZpVlffVvqPa56DWUIZq7395tLY2UK4MpabUGhKYKjrnnHNywgknZNttt13qO7guvPDCHHvssdloo43yxBNPNHrb9fX16dGjR5Kkf//+qa1dcq7YqVSb0xq2aXrhy2Tva07Py7c9kqcuur6s2z299sHMrynvSXd+7cqZtOLXl/r5Q1ftn359ui318359uqZjh9osWNiQ1ycv/Y/y65NnZevPvv/3UdswM/2nn9O0QpfZGz2PyLxOA5f4Wbm+f7L038HKM/6QLvPHNK3QzVDJdlGuNtASdf69SqnJayt9f6mft3QbSJL+U3+Y2pS3k9l5sPHmdhyYyb2OWOJnyzr+yfLXgU4LJmTVty5qWqGXodrHPylWHXiry86Z0W23JX5WiTrQfc6/s+KsG5tW6DJaWNMzr/f+zlI/b+nzYE1pblabdlbTCt0MlW4X5WgDlfg7mCSzOm+UaT0+ucTPKtEG6uaNSZ+Zf2haoZtBHVi66d0+kvouS/7dVOJ6uNes29NzTvVezj2vQ/+8scLRS/ysEm2gw8Ip6ffmz5tW6GbQBpZuZt12ebP7Pkv8rBJ1oNvcR9O7/rqmFXoZXA82zZQen86czhss8bNKnAdXnHltus/7T5PKvCzqQNNMWPGENNR2X+JnlegX6Dv9gnRsKO+IomrXgSId//m1fTJpxa8t9fOW7x+dkf7Tf9q0QpfZGz2/mHmd1lziZ5XpH/19usx/vmmFbob20D/a0NCQCRPefgfsZpttllGjRjVrv0t+KVU70phpCRszveGyvHOwlqRzTYekb7M33Wq9NuG1zCuVefRVp7nJikv/uF+fbhnQd8l/6BfXsUNto5Z7r4aF8/Lqq1V+4eLac5JOS/6opb9/kkyZPCmZ2fK/gyK2ixap80vSuyGpWXJwXok6MOG1l5NSeedkL+LxbowWqRPduia9lvxRY49/0vw6MH/enLKfB9vq8U9aqA6sMj1ZyjV7JepA/cw3Uz+hin8LO/RMPuCSrKXPg6WGBRW5Fihiu6jY38Fe/ZIeS/6oEm1g7px6dWApKlYH+r+VdFnyR5W4FnrrzWl5a3IVz4NdapIVlvxRJdrAwvlztYGlqFgbWHlqspRDV4k6MGvmjMx6zfVgY7VIvVijPlnKxESVOA9OnzYl06erA43VInWg5/ylztNViTow8fVXk/nlDbraah1okePfeX51+0cXtIL+0XWq3D/6xsSk3vXQkixPnZ84cWKz99vug64hQ4YkScaPH58FCxakY8f3/0rGjh37rmWbY1kjulLcmcCWarX+q5X9iYWGmi5ZemT4dsr+QZryxMKSdKyZl76rr96YoraYKZ0bMmcpn5Xr+3/QtlZZqXs6r9Dyv4MitouWqPNLMqE0Ow01S/5D3NJtoKY0L/1X65uaxhe3UYp4vBujJerE/NrumbSUz5Z1/JPlrwN1nRamT5nPg231+CctUwfq6zpl+lI+q0Qd6NmtQ3pV8W9hKR3zWmnpgX9Lnwc7ZG76VeD7F7FdVOrv4NyOXbO0N5NUog10qyultzqwRJWqA2916ZClTRZTievhFXt2Tve66p0HF9T2ytK6ACrRBjp3WJBVtIElqlQbmNW5Lkt7VLcSdaBHt9qs4Hqw0VqiXkzrkiztSFfiPLjyil3Spbs60FgtUQcm1szL0h4/benr4STpv+qKqU3XxhS10dpqHWiZ/tGuVe0f7VQ7L6tWu3+0U5X7R1funs4ruh5akqbW+cVHdPXt2/xUr91PXThjxoz06dMn8+bNy/3335/tttvufcsMHTo0o0ePzm9+85sceeSRjd724lMXzpw5M927L7ljev6sOfnjoM837wu0YgeP/UM6dVvKo5bLYe29/5Jxr81s1rov3/aZDOjbPa9MrM8ae/y5yesf+tF1c8UPd2nWvsvljItG5bRfN++lgMv7/Tt2rMmM+w9Nl7qWz8iL2C5aqs6/1x5H3ZTbH3itWesubx3YYbNVM/LKjzZr3x+kiMe7MVqiTixc2JBe2/8+s+Y0b1Td8taBE4/YJD/+5tbN2vfStNXjn7RMHXjoyTeyzeeaP5XA8taBf/5yj3xk5yVPEVEpGx14TZ4aO71Z6y7v9//47mvl6p8teerIcipiu6jU38Gpb87Nyjs1f+rA5a0D55+wbb7x+Y2avf/GUgeW7vp/jc8B37i9Wesu7/FPkkf+fEC22KBPs9Yth1KplD47/zFT35zbrPWX93fwlc+sn1+evEOz9t0U2sDSPT12WjY88O/NXn9568Bfztk1n9prnWbvf0mKeLwbqyXqxcV/ezZHnzmyWeuW4zz42h2fTf9VPniKzKZSB5rm8yfdlT8OH9usdZe3Dgxao2eeH/6pZu37g7TVOtBSfxsG7vXnvDShvlnrLm8dOPyAwbn8zJ2bte9y+f6vH83pFzVvirvl/f6dOtZmxgOHpq5zh2btvymK2C6aWucbm6Esy1IGubYfPXv2zB577JEkueSSS973+T333JPRo0enc+fOOeCAAypdPJZgyyreVFZz3/8rw8pV2/eGg3pXJOTig7X3NtDedehQm83WW6lq+1cHqm/jwb3TsWO5x1U2XmuoA86D7dtKK9Rl7dV7Vm3/6kD1VfMYdO5Um40GN39K+3Koqamp6j2BNlB9Q9daId27Vu++TB2ovmqeA/qv0q3sIRdN53qY9l4HqlmGjQf3rkjIRdO0+6ArSU455ZTU1NTk8ssvzxVXXLHo52PHjs0Xv/jFJMmXv/zlrLrqqtUqIovZect+Vdv3TltUf1LU7TZZNZ06Vqfp7rRF9X73/E9124A60BpUqw7U1CQ7bOpvYbV1qeuYbTeuznFYd81ey3zBfSW092sBqlcHunXpmM3Xq17nIm9bbdVuWWdAdcLObTdeJZ07Vb9jw/Vg+9ahQ2123Lw6f4/6r1K99sf/bDx4pazQcykv6WphroVaB38HqOZxaA3nge02WaVqD4BqA62ToCvJdtttlx//+McplUo5/PDDs9Zaa2XzzTfPeuutl+effz7bbrttfvzjH1e7mPzX5/dbN13qKn9zufVGfbL5+tV/YmHlFbvk47uvVZV9H/XxoVXZL++21w6rZ83+zRvGuzxWXalL9v9Qdacr421fOqg6bXG/ndfM6s18USvlVa3z8Zc/sV5V9vten957nfTsvpQ3D7eg9ddZsWodi7zbUZ+oThv4/H6D0r1b5ese71ZTU1O1OnBUKzkPfuGAIenQofKdOx/epn/WXbNXxffL+1XrWuCojw9NTU31RpbztrrOHXL4/oOrsu+jPt46zoPt3Rbrr5wt1q/8wzddu3TI5z8yqOL75f0O2W/dqowq2nbjVbLp0Oo/+LXKSl1z0G5rVWXfR+ofbZUEXf91wgkn5Oabb84ee+yRN998M88++2yGDBmSH/7wh7n77rvTrVv1n17mbSutUJfP7lPe+cAb49hPr1/xfS5NNcqy0xZ9s/GQ6k2Xxv906FBblc7mLx001NDsVmLQGr2y944DKr7f1nQebO8+tdfaWWmFuorus65zh3zhY9XpUHmvHt065bAqdO4c++n1de61Ettvumo2HVr56xLnwdbjiI8NSedOlb2d7dO7Sz6xx1oV3efSrN63ez6268CK71cbaD32/9DArLZqZfspOnSo0bnXihzzqcrfEw5da4V8eNv+Fd8v71dTU1OVc/LB+w7Kir0qex/CkvXp3SWf3mvtiu+3NV0LVKMsu2zVLxuuW91prFkyQddi9tprr9x6662ZNm1aZs+enaeeeionn3xy6uqcwFub7xy2cUWn71t79Z75dJlftrs8hm3Rt+LDhE/+0mYV3R8f7KhPrJeVV6zcualXj075ymdaz8UMyUlf3KSi+9tygz7Zc4fVK7pPlq5LXcccd+hGFd3n0Z9cLyuvWP6XKDfXtw7ZMF27VC58X33Vbjls/3Urtj8+WE1NTf7vyM0qus+P7LxGq3h6lbetslLXio+u+s5hG7Wq99V+94ubpLa2cuH7hoNWzP4fqny4xpJ16lSbE79Q2evBLxww2Oj+VmTo2itWfLaXk7+0qYd+WpHP7jMoa63Wo2L769ypNt8+dOOK7Y9lO/7wjSs6fd+gNXrmU1UI15Zm5y37ZViFZ9w4+UubVnR/NJ6gi0LaYFDvnHr0ZhXb32Vn7JSuXVrPTW1NTU0uO2PninXwHX7A4Ow9rPKjR1i6Pr275Fcn71Cx/Z13/HZZbVU3ta3Jzlv1r9jTS5071eZ3Z+5U0c40lu34wzep2HQl6wzomR9+bcuK7Kux1hnQK2d9bauK7e+S04alZ/fqvAtjcT3X7pd9r/9hDhzx8+x304+z4pAl/30e/NkP56CRv8hB9/8yO/z06NR0fP81w15/Oy2fe/Z/76ddcb01s/e1Z+TAey/IAf/6WXb82bHp0OV/3/lDlxyXT436TQ6fcHU696r+bAef2GOtik1XskLPzrnolB0rsq8P0pLHP0kG7L5lDrz3ghw08hfZ9dLj06lH1yTJah/aNPvfds6i/31q1G/y0Vt/Uv4v2EQ/+sZWFevg22rDPjmulXXubbXhKvnOYZV56KFDh5r87gc7p1OFR9EtyfK2g1W2HLKoLh9w13nZ/idHpbbz2/d6PQaskr2vOT2fe+6K7H/bOUstw5LaTzV85TPrV2xK3dVX7ZZzvr1NRfZF4/3y5O0rNsp/350G5JCPeuinNenWtWMuPX2niu3v+8dskfXXWbFi+2PZNhq8Ur531OYV299lp+/Uqh76qampyaWn71SxV9wcceCQ7LlD9ftHl/daqN+OG+UjN/4oH7v7vBxw13nZ8pTPv/1S9iQ91lg1+91y9tvXSf/6WT70m+PSeYX39wcOO/8rrea+8B2tp2bSZD3X7pedLvha6lbqmfkzZmXEN36Z6aNfafJye/z5e+m6yopJQ0Pm18/Jv0+5LFOffPFd21j307tm2PlfyZ1fODsv3fxQkmSbM4/ImnttlR5rrJrrd/9Opj41riW/7vuc+IVN8487X8ojT09u9DqvT571rv9vjK9+doN8aOvWNzR/3TV75Udf3yrf/Mm/G71Oc77/6qt2y3nHb9vk8rUmAz+yXfrvtHFevuWhbH7iZ1PbqWMWzp6b+064ONOeHp8kWf3Dm2eL7342NTU1qenYIU/++rqM/dvdVS75B/vUXmvnb7e+mGtuH9fodZpTB/becUCrma7svcp1Hqzt3DFbn3ZYVv/QZlk4d16mPj0+937150maf46shLO/tXVuHvlKXnhlRqPXaU4dOO3ozbPR4NY5dWm56sAnHvx1Fs6dn4Vz5iVJHv/FtRl3/X3pUNcpu1z0rawweEAWzpmXOZPfzP3fvSQzxr2epLp/Czt1qs3vztw5W332usyb39Do9ZpaB2pq3n7gozW+l+jrB2+Ya24flxGjJjZ6nea0gS98bHD22WmNJpevJezwky9n9B9uy/N/vSsDP7Jdhl3w1fxzn+++a5kea6yazU/4TG7Y84TMfmN6Pvy7EzP083vk2d/dvGiZDb68X2aMn5iVN/7fiPWFc+fl3ydfmmnPjE9NbW12/vU3svFXPpb/nPvXJMlzV96aB757ST7z5GWV+bLLUFNTk1+fskPuefT1TJ42p9HrNacOnHf8thnQr/oPfLTk8e/YrUt2/NkxufmgU/Pm869l2x9+MZt+6xN5+Mzf57W7Hsv1dz22aNndrjwpr498suW/8DL06NYpl52xU3Y78qaUSo1bpznHv3On2lx+xk7pWMEZJRrr9GO3yA13v5xnXpje6HWa8zs48QubZKsNV2lq8VrE8raDqU+Pyw37fDelBQuTmprseul3st7he+fp3/wz82bOzqNnX5XOPbtli+9+don7X1L7qZYOHd6um5t+8trMnrOw0es1pw5cctqwVjldWTmuBet698hefz1t0bIdutal58C++fPGX8y86TM/8F6x2veR/fp0y69O3j6fPfGuRq/TnOO/Qs/O+c2pw1rlaK5y3Q+84733dsuqH0tbr1I+vO1qOfbT6+fXf3mm0es0pw5svVGfHH9463rg4x0tfU+YtO5+gZO+uGn+cef4jHp2SqPXaU4d+PrnNsjOW7W+/tEha62Qs76+Vb59Tsv2jw7o2z0/+07r6B9d3muheW/W5+6jz8vMlyalQ12n7PnXU7PuJ3fJ83+9K7MmTs1NB3xvUTvY5swvZLPvfCoPfu/yRdtec99t07Cg8dcdlSLoKrDGVOrGLHf3Uedm3ltvN+w199kmw87/Sq7f/TuLPu8xYJUMOXj3THr4uXdtd/zw+/Pkr/+Rfa/7QQt9ww/WqVNt/nH+7hl2+D8z/rWZy14hydafvb5J+9h7xwE59zut96m1rx+8YZ5+YXp+c/Vzy144Tf/+K/TsnOG/2rNV3tA0xZr7bpuXb3koO/3yG7n5wO9l+uhXsuq262fnX30j1+367STJzr/8em7++Pcz7Znx6TFglRx47wUZf+O/s6C+8R1nlVZTU5PLz9wpL70+Mw892bjAt6l1YJMhK+VPZ3+oVd7QJOU7D275f59PSqX8fcevJcnbF7D/1dxzZCX06NYp//zlntn5C8Mb3cnb1Drw+f0G5btfbL1D88tVB5Lk7qPPW2JQ9dzvb8urd45Kkqz3hb2z47nH5OaPv32zW+2/hRsPWSl//NGH8ukT/pWGhsb18ja1Dlx4yo7ZpRXe0CRJbW1Nrv7Zbtnp8H9mzPi3GrVOU7//Llv1q+gI2g/SZeVeWXnTQbn1M2cmScYPfyDbnfXF9Fyr36LwNUkG7rddXr714cx+Y3qStwOqTb5x0KKgY8UhA7Lm3ttk5Dd/lbX2237RejNe/N82Sg0Nmfyfsem93v8Cvgn3PtGSX69Z+q7cNdf/fPfsfuTNmTVnQaPWaWodOO7QjXL4AdV/4KOlj//qH948U598MW8+/1qS5NkrbsmeV30vD5/5+3eVo2vf3uk/bKOM/NavWvLrNtqu26yWX560fb5y1v2NWr6px7+2tiZXnb1rq33go0tdx9zwiz0y7LB/5vXJsxu1TlN/BwfttlZOP3aL5hSv7MrRDhbOnrdouQ6dO6Zjl855JymdN31mJj34bPptv+ES97+09lNNgweukL/99MP52Ddvz4IFLXMt8NPjtmk1D3y8VzmuBedOm5nr9zh+0bIbHr1/+m2/waIQ44PuFVvDfeRn9hmUp8ZOzw9+859GLd/U49+lrkOuu2D3VjttZTnvB5Z0b7es+rG09SrpZ8dvm+dffiu33vdqo5Zvah1Ye/Weufa83VvlAx9JZe4JW3O/QKdOtbnu57tn2GH/zEsT6hu1TlPrwD7DBuSc41pv/+g3P79hnh47Lb/9++hGLd/U77/if/tHV+hZ/Rk+ynEttHhIu3Du/Ex9clx6rLFqkqRh3v/uqWpqa9Oxa10WzPrf37QufVbIJl8/KDd//LQMOXj3lvyqTdY6z1As0zuVeuw19yR5u1J3X23l9FyrX5OXe+dEnSSde3bLux6HrKnJDucek3+fcum7KnqSTHzgmcyaMLXcX61JBvTrnrsu3TeD1uhZ9m3vu9OAXPOz3dK5U+Xe/9FUNTU1+fX/7ZAvf7L87ydYecW63P6bvQvxLorOvbrlk49cnM88dXn2v+2cfOye83PIuKsWDcvtu/XQzBg/MXOnzVj0tM6kfz+T7qv3yUobvz23cKmUdF7h7eG2nXp2y5xpM95X51ujnt0755aL9s52m5T/CdvN11s5t128d3q30qCzXOfBjl3rMvizH86jP75q0TrvXAgkzT9HVsr666yYOy7ZJ31X7lr2bR+y37q5/IydW+2UheX8W7g0C+fOXxRyJckbj45JjzX+195aw9/CT+y5dv704w+1yNzsvzp5+xb5G1NOfVfumn/9dt8WmUblw9v0zw2/2KPVTF/cffU+mT1xWkoL/zeCb+ark9N99T7vWq7H6n0y85U3/rfMK28sWqamY4fs8NNjcv8JF79rO+/VsWtdhhy8W166pXJPozbX9pv2zc0X7pVePco/6vC4QzfKOcdt0yoe+Gjp4/++9V6elK59V0xNh3ffMq776V3zyp2jMmdK48LlSjj2MxvkFyeVP3To1LE2f/7Jrjmowu/AaapBa/TKXZfumzVaYNThJ/ZYK386+0OtpnOzHO0gebtDcv/bf5rPPHVZ5r01K8/+7pZl7rux589q+MjOa+bqc3dL5xaYWvIn39o6xx3WOkdxtNS14ODPfThjrrpj0X9/0L1ia7mPPOMrW+T/jiz/w2ndu3bMP3+xZ6t96KmsdaCR93bvrR+t4Z6wrnOHXHve7tl7x/JPqbbumr3yr0v3abVBZyXuCZPW3y+wRr8euevSj2SdAeXvH/3IzmsUon/0ou/tmCM/PrTs2+7Tu0tuv2SfbDKkdTz0VK5roXd0XWXFrLXfdnn59kcW/ay2U8fsf9s5+cxTl6XXOv0z6py/Lvpsh58enYfP/H2rHBjQOq5WabLGVurGLjfs51/LJx++KJuf8Jnc87VfLPr5hl/+aCY99GymPP5CC32T5bfW6j1z35UfzYG7lefFyB061OTkL22aa8/fPd26to6OrQ/SoUNtLjxlh/zipO3TrUwdcTtu3jcP/GH/VjM9ybLMe2tWXrj23jz92+G5fo/j8+Cpl+eNR0fnvu9clP47bpRJDz2Xt16YkLrePbPKVm//0Vtjz63SuWe3RU8s3H30z7LrpcfnEw9dmH2uOzMjvvHLNMxv/UFXkvTuVZfbf7NPjvlU+TqjjzhwSO66bN+s2gLhSbmU6zzYc61+mTd9Zjb5+kHZ7+azs88/zkz/Ye++mW/t58hNhqyUf//xo/nwNuW5Aa3r3CHnfHub/O4HO7eajq0laYm/hQfceW52OPeY1K3ca4n73OBL+7bKjv9P771O7rxk37Ld2PRfpVuG/2rPHPuZDcqyvZa2et/uGXHFfvnsPuWZRqqm5u2AY/iv9mwV7+Uqp82O+2TG3/jvvDlm6U/81nbqmF0u/nZeveuxvHTTgxUsXfPttGW/3P/7j2bLDd5/89YcvXp0ym+/P6zVhFzl0pjjvyyDP7NrxvzpjmUvWGFf/ewGueEXe6Rfn/Jcuwxao2fu/O0++eSereeF6x9k6Nor5oE/fDT7lOm9up061uYHX90yf/7Jrqnr3Ho7tppr5itv5Prdv5O/bHJkOtR1ysB9lz0VUTnaT0s6YNeBuefyj2ToWiuUZXur9O6Sa362W47/wiZl2V5LKPe1YJKsstXQ1K3QPS/f9r8Ovw+6V2wt95E1NTX5wde2ypU/3DkrlmnEwaZDV8rIK/fLbtutVpbttYRy1oHG3NstqX60lnvCbl075rqf756Tvrhp2R5U/Pjua+W+K/fLwNXKH56USyXvCVt7v8DaA3rmvt9/NB/7cPn6R085arNce97urebBvw/SoUNtLj51x1xw4nbp2qU81y47bdE3D/yhfPcYrU2nHl2z25XfzRO/vi5THhu76OcN8xfk+j2Oz182+VLefP7VDD1kjyTJ4M/tlvpXJ7eKKcyXpPXX0nZq3xt+mF7rLLnDcvEh0+Uy4utvn6AHfXKXbHXK53P758/KikPXyMCPbJubDjy17Psrt1VX7pprfrZb/nzTC/n62Q806T0Ni9to3d65/MydChPwvKOmpiZf/ewG2WfYgHzxtHtz98OvL3ulJejWpWN++LUt87XPbZAOHVpv5/aSrLTR2nnmtzcmSVbeZNCiYbhr7r11xt/0YObPmJW7jvxptjz5c+nY/f/Zu+/4ugr6/+Pvm6QtbdLSQumghQKlQJElexSRIRtZCl8ZgijIUBwICF/8+lMU/YoKfGUIiggOhuypCC5aQIaVWaAUyijdpbRJd5PfH4VaaKFJSHJzkufz8eDxKLnn3HzanHtz73ndc84qmfrYC3nz+dfSsGhxSpUV2fyrn8pfP39+Jj88JqtvPjS7X/3N3Lbb1zN/RuOvfVRO1T265NJzdsqnPrFuvvD/RublCc2be60B1bn8Wzu1i1OTtNXzYKmqIjVr9cvMsa/n8fN+l9U2WTd7Xv+t3LrL1zJv2ltJivEcOWTNnvnzFfvk8j88lzMueDS1cxY263522LxffvXdnbPRur1bdsBmaMvfhfcc/D+pmzAtparKbHnmZ7LzRV/KfUed965lNj31kPRcZ0AePOw7Lfq9W8rOWw3IkzcenLP+77Fcct2YRp/K8L0+e8D6ufDM7dvt0ZzvZ7VVu+X3/7trPr3nujnpew9m8vTGncLrvTZcZ9X86rs7Z8ct+rfwhB9e3YRp6d6/T0qVFUvfpNcM6pu6Ce8+fW3thGnptcynU2sGr7F0mQE7fCTVg/pm+HF7p1RZmS49u+dTj1yaO/b5ZuZPn5VSVWV2ufxrmTvlzTzyrfZxLa7G2nhonzz82wPyo6uezHcv/3fmL2jeeeP33mlwrvj2TllrQE0LT/jhtPbPv3bCtKy5y392aNes1S9zJ8981w6hATt8JJXduuaNZa7X1Z7sv8vaeeaWQ/OV/30ov71z3MpXWIGKilK+9F/D84OvbFOID70ta81+1bnrkj1z1a1j8/Uf/zNvzV6w8pVWYKuN++aq7+6cTdvJJ5eX1RKPg2UtmjMvL986KusdsnNevm3UB37vlT1/tgfbbdYvo284KP9zyb9ywW+fzuLFzXstcPje6+bis3ZM3z6rtPCETdPW+0WSZNhndsuLf/j70u3rg94rLnirrt29jzz6gGHZfbs1c+K5D+aOv7/arPvoUlWRs7+wec4+fvOyH8HRVttAY9/bvXf7aG/vCbt2qcx5X9k6B+8+JJ/71j/yzLiZzbqfvn1WycVn7ZDD9lq37B/4aU/vCYuwX6D/6t1z8wW759q7X8qp//tQps+c36z72XRYn1x17scKF3hKpVJOPfIj2XfntfL5bz+Qfzze/P2j5526Vb58xEfa3RluWuq1UFX1KvnE78/Jq396NM9efucKv1f9wkV58bq/Zscfn5inL70tA3baJAO2G561PrHV0mU++Zef5C/H/mi5a9aVQ7FeuXcidx/w3x94e/38hY3aqBu78b9j3B/+nh3+94R061OT/tsNT81a/XLog0ueyLuv0Ts7nH9iuvfrk+evuffD/hVbXKlUymf2HZoDdx2S6//0Ui65bkwef3bl1y2qqChl/4+tlZMOG549dxzU7p7AmmLoWr3y1yv3zcNPTsml14/JDX96OQsWrvy0GhsMWTUnHbZRjjlwWOF2bL5jtY+ss/RJdfXN1strbx9xsebHt8hj5/42STLpwWfyx0OWXFenomtVDn/il5n5wutZbZN1071/n0x+eMnFW6c/MS5zJk7Papusm4n/eLIMf5vm2227NfP87Z/KHX9/NZdePyb3//ONRq23y9YDcvLhw3PQbkPK/mbmHW31PFg3YVrqFy/OSzc9kCSZ8fTLqX11SvoMX3u569G09+fIiopSTjp8eI7Yd2h+c+eLueyGMXm2EW9uulRV5NA91snJhw/PiC37l/3NzDva8nfhO39uWLQ4z/7izhwy6mfvuo+PnPjJDNl3u9x72HfedW2P9qa6R5f83zd3yGmf3SRX3Ph8fnnz85kyY+Uf/ujds2s+d9CwnPjp4dmghT4JXi4H775O9hkxOH+49+VcdsNzeeiJKStdp1RaEjdOPnx49hkxuN1+2GPe9FmZ8dTLGXrox5ZeW6Bu4ox3nYs9WXIqln1v+17+/eMbMnfqzGz42T3z8q1LduDec9C3li73zqm7btz25CRLdubt8vOvZf6btXnwGz9vu79YC6qqqsjZx2+R4w/dMFfdOjY//8NzjfrwxyrdKnPEvkNz0mEbtdsPPLX2z3/CX0dn+x98Iauuv2beevGNbHTMXsvt+B92xG558Ya/pqG+fZ22bVmrrdotvznv4znn+C3y8z88l6tuG9uo4NN/9e45/tANc/yhG2btge0rcjZFqVTKcQdvkMP2Wje/u2tcLr1+TJ58YeWn2K2sLOWgXYfk5MOHZ9dtB7ab1wLv1RKPg57rDEjt61PTsGhxKrpUZe19ts2MMa+s9Ht/0OOnPem+SlXOP23bfPWoj+QXNz2fK256PhOnzlnper1quuSYTw7LiZ/eKBsP7dMGk65cW+8XqeqxStb95I65c58zl37tg94rLnirrl2+j1yzX3Vu/9kn8u/npueyG8bkt3eOa9R1LNceWJ0TPz08xx28QaucFr052mobaMx7uxVtH+3xPWGSbLPJGnnypkPyp1Gv59Lrx+SuB15715n23n+9vjn58OE5fK/12s0RPO3pPeE72vt+gVKplCP2G5qDdhuS6/74Ui657tn8a8z0la73zv7Rkw8fnk/sUOz9o+uv3St/+9W+eeiJJftH/3Bv4/ePnnz4Rjnmk8PSu53uH22J10JVPZZErgl/HZ0nL7zpXetVD+6bedNnLdnvUSplyAE7ZMaYJR+ceOCUi9617LETb8ztu532rlN7llP7eNaiyRq7Ua9sua69eqSye7fMnfxmkiVHv8x/szbz36zN89fc+64n5b1v+k6e/cWdefWP7e+UTcvq0b0qnztog3zuoA3y4quz8tgzU/P4s9Mz5uWZ+fNDE7JgYX1W6VaZbx63WbbauG+22WSNdvMiriWUSqXssHn/7LB5//zsmzvk0Wem5fFnp2X0c9Nz219eyfyF9enWtSLHH7pRtt64b7baePV8ZP0+7fbNbGP0GLBa0tCQOZOWvIlfbfiQPHnRTen70WF5a+yEpRdN7N6vd+ZOmZkk2fxrn8rEUU9n9vhJWaXvqunRv09WHTYob42dkJ7rDEjPIf0za1zjIlF706VLRQ7ZY50cssc6eX1SXR59Zmoef3Zann7xzfxx5OuZv7A+q3StzNeO3iRbbbx6ttlkjULu0Gmp58H5M2Zn4sins+bHN8+Ev4xOzVr9UrN2v7w1dkJhnyNX7dk1X/rMxjnlv4ZnzEsz8/iz0/L4s9Pzwitv5f5/vpEFC+vTvVtlzjlhi6XPg6ut2j5fxH2QltoGqrp3S0WXyqUvztY9eESmL/NppI2/uH/WPXin3HvYd9vNC7iVGbJmz3z/1K3z7ZM+mn8/NyOPPzstjz07LRMm1+Wvj05csg2sUpkffmWbbLVx32w5fPV282a2JazSrSpHHzAsRx8wLC+/Pnvp8+Cz45a8FnjnefD0z22ard9+DAxco0e5x26UB8+4PCMuPCWbnnpIFtbOzcivXpJkybnSX7v3sbx272OpfXVKRv/4huxz+/eSLPmgx/O/+fNK73vdA3fKOvttnxnPjM8n/3x+kmTyo8/nn2f/Mkmy+2/Oymobr5MkOfBvF2T2y5Pyx0O/3Qp/yw9vjdW654zjNss3jt00T42dkcefnZ7Hn52Wl16fnb888p/nwe+cvGW22rhvtv5I3/Sqaf+nqWzNn/+iunl58LTLsttVZ6ZUWZGZz7+WB069eOntXXr2yNr7bpfbdv166/zlWtiG6/bOBWdsn/NO3Tr/GrPk5//YM9Nyw70vZf6CJa+Hj9pv/Wy1cd9stXHfbLHRau3mwz4toaZHl3zx0xvlhE9tmBfGv5XHnl3ynuD58W/lvoffWPqe6L+P3zxbDV/yPFjuo3ca68M+DgaO2CTDP79vGhbXp1RVmYkPPJUnL7gxSVLZvWsOGfmzVHarSpeeS64DPO6mv+df5/2+PH/ZD2FQ/+r8v5O3zH8fv0WeeGF6Hn92eh57ZmpenzznXc+D55269dLHQdGOYmyp14LvWPfAHTPj2fF568X/vA+smzDtfd8rLp6/sF2/j9xio9Vz+f+MyE++sV0ee3u/wOPPTsvN949f+jz4uQM3ePvnv3o222C1dvthn/fTUttAY97brWj7aM/vCSsqStln57Wyz85rZfL0uXn06al57JlpeXLsjNz9j9eW7hv68mc+kq02Xj1bf2SNrL/2ik/f3p61xXvCou4X6NG9KscdvEE+d9Cwt/ePLnkOeG78WyvcP7rtJmu068tXNFWpVMqOW/TPjlv0z8Vnvf/+0RM+tVG2Gl6s/aMf9rXQxsfvmzU+un669Oi29PTN4+98KE9edHP6DB+SLb95RJKkVFHK9KdeziPnXFmGv2XTlRoaGtP0aY66urrU1CzZeVxbW5vq6hVfuHHhnHn53dCjmnz/vYaumREXnpJufXou3ahnPreksC67YX/QctWD++bjV5yWqlW6pqG+IfOmz8pj370mM54Zv9z3e++T9Q4/OiGDd98q3fv1zvw3Z2dh7dzcvOOXly5/5LjfpkuP9vVmafAe12bClDkZ1K9HXr/vM+Uep80V6e/flMfF4D22yvDj9s6fj/h+kmT/e36YGc+Mz/wZszNr/KSl15HY8ccnpv92w1OqrMjUx1/IP//7yv+8iDlop2x26iFpqG9IqaKUJ392S16+ZWSTZm6P2/x7tddtoJzPg0lSs3a/7PTTk7PKaj3TUN+QJy74Q165658f6jkyaZ/bRHvcBpr7809aZhuoWbtfdv3l6SlVVqRUSma/MiWPfOtXqX19anoMXC2H/euKzBo/KYtql5wKb/GCRblrv7OS+F1YREX5+3+Yx0W5tMftfUVsA62nCNtAUX7+rako/wYeA62nPW4D5X4/kCT73v79vPC7+/Li9X9919c/6L1iY95Htrftoj3+/JP2sQ28Y0Xv7d5v+1jZeoltoLHKuQ180HtC+wU6niL9/TvD66HGNpSVEbpaUWuHrvbOE3n7U6S/f0s8Lg782wX506Hfzrw2Omd+e9zm36u9bgOeB9tOe9wGOurPP7ENtEdF+fsX8XHRHrf3FbENtJ4ibANF+fm3pqL8G3gMtJ72uA0U8efdWO1tu2iPP//ENtCWbANtq739/JP2uw20lSL9/Yv4uChX6CrWcekATXDbx79W7hEAAAAAAGhFxTr5LgAAAAAAALxN6AIAAAAAAKCQhC4AAAAAAAAKyTW62oGq7t1y5LjflnuMFlfVvVu5R6DAivi4sM03XxF/3o1hm2icjvrzT2wDNF8RHxe295ZlG6Cz8xjoXIr4824s20Xj2AboqNuAnz8fRhEfF+Xa5oWudqBUKqVLj1XKPQa0Kx4XnYufd+fm5w/L87jANkBn5zHQufh5YxvANgDL87hoPKcuBAAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCErreNHz8+V155ZU488cRstdVW6dq1a0qlUo499thyjwYAAAAAAMAKVJV7gPbiwgsvzEUXXVTuMaDVzK5bkIWL6pMkixbXp6GhIaVSqcxTAUDbeWNKXRYsXPK7cHF9Q5mnoa01NDRk3Guzs2Dh4iRJfYNtAAAAOhP7RzsuR3S9rW/fvtl3333z7W9/O3fccUdOPvnkco8ELeKJ56fni98dmQG7XpspM+YlSSZPn5ePHnZrrrjxudTNWVjmCQGg9SxaVJ+b/vxydv/C3Rm0x3WZ+uaS34WTps3NoV+7P/c//EYaBI8ObVbtglx87bP5yME3Z9j+f8jUN+cnWbINfPkHD+XZcW+WeUIAAKA1/fu56TnhO8vvH93ycPtHOwpHdL3tnHPOedf/P/zww2WaBFrOT65+Kt/4ySMrvO2J52fki98dlQt/+0zuvmTPrDOoZxtPBwCta1btgnzqtPvz54feWOHtN98/PjffPz6fP3iDXHbOTunSxWfAOprnX56ZfU6+Ny9PmL3cbQ0NycXXPptLrx+TS/97x3zx0xuVYUIAAKA1nX/VkznjgkdXeNu/n/vP/tF7Lt0zQ9a0f7SovJuHDur/fvfM+0auZY15aWZ2P/6eTJk+tw2mAoC2sWDh4hz0lfveN3It68pbXshJ3xvlyK4O5rVJtdnt+HtWGLmWVV/fkBPPHZVf3/ZCG00GAAC0hQt/8/T7Rq5lvbN/dOoM+0eLSuiCDmjC5Lp8/cf/bPTyL70+O2f/32OtOBEAtK0rbnw+f310YqOXv/KWF/Lnhya04kS0tdN+/EjemDKn0cuf9L0HM+Ot+a04EQAA0FZem1Sb0xpxEMA7xr02O//9s8dbcSJak9AFHdAvbno+ixc37VPpv79nXGbOsnMHgOJraGjIpdePafJ6l93wXCtMQzlMnDont9w/vknrzJu/2FFdAADQQVxx4/Opr2/a/tHf3TUub81e0EoT0ZqELuiAfnnz801eZ+68xbn2npdaYRoAaFsPPTElY16a2eT1bv/bq5nsVL4dwjV3jM2iJn7oJ0l+ebPQBQAAHcGVtzT9tf2ceYty3R/tHy2iqnIP0FkMGzYsFRW6YrlN7P31pGLVTJw0MYMHDy73OK2iIZV5Y7X/ada6Z5xzfr5/2r0tPBHtSWd4DPDBbAN0hm1gTtfNkppDm7xefX1DNt1yl3RdvPLretG+vdnjgGSVrZu83phxUzvs44IlOsNz4Mr4N8A20Ln5+WMboDNsAw2pysTVvtWsdb9x9v/m3K/9uYUn4v3U19cv/fOIESMyevToZt2P0NVGJk5s/DUiaEU9FycVSf3ixZkwoYNeh6PUJVmteavW1tWldmIH/Xdhic7wGOCD2QboDNtA7yFJTfNWnTp1ejK3g/67dCaD5iarNGfFUsd9XLBEZ3gOXBn/BtgGOjc/f2wDdIZtoNS1+ftHa+tSO6mD/ru0c5MnT272ukJXGxk4cKAjutqBiZWVqU9SUVmZgYMGlXucVvNG/dw0VHRv8nq9eiQ9O/C/C53nMcD7sw3QGbaBeVVVmd7UlRoaklIp/ft2T1V9x/x36Uxmda/P7GasV1lflwEd9HHBEp3hOXBl/BtgG+jc/PyxDdAZtoGGJBMb5qWh1PRPv/Wqtn+0LdXX1y89SKh///7Nvh+hq42MHTs21dXV5R6j0xu8x7WZMGVOBg4YmNeffr3c47SaU77/YC69fkyT1qmoKOWpB67M2gOb+RF4CqGzPAZ4f7YBOsM2sHBhfYbsfX0mTp3T+JVKpez00f4ZefXTrTcYbWbMSzOz8UE3NXm900/YOT/4ytdbYSLai87wHLgy/g2wDXRufv7YBugs28BJ547Kz//wXJPWqaws5ZmRV2XwAPvx20pdXV1qapbsjx45cmSz78chRtABnXz48Cav88mPry1yAdAhdOlSkRMO3bDJ653SjN+ftE/D1+udXbcZ2KR1SqXkxE9v1EoTAQAAbemkZry/O/DjQ0SughK6oAP6yPp9mrSjpldNl3zvS1u14kQA0LZOPfIjGTakV6OX32XrATn0E+u03kC0uf/92jbp3q2y0cuffuymGbJmz1acCAAAaCubbbBaTvhU4z8AuWpN15z7pS1bcSJak9AFHdTPztohR++//kqX692za+782Z75yPp92mAqAGgbq63aLX+6bO+sv/bKY9eOW/TLLRfuka5dGh9FaP+22WSN3HrRHqnpsfKztZ/46Y3yg69s0wZTAQAAbeWSs3fMkfsNXelyfXp1zZ0XfyIbD7V/tKiErreNGjUqffv2XfrfT3/60yTJdddd966vjxo1qsyTQuNUVVXk6u9/LNd8/2PZZpO+y91e3b0qJ356ozx67YHZeasBZZgQAFrXuoN75uHfHpBzTtgi/VfvvtztQ9fqmfO/vm3uu2Kf9OnVrQwT0tr23HFwHvn9gfn8wRuk+yrLh8ydPto/1/1o11x6zo6pqCiVYUIAAKC1VFVV5Dfn7ZJfn/uxbP2R5feP1vSoykmHLdk/OmJL+0eLbOUfb+wkFi5cmOnTpy/39fnz52f+/PnvWg6KolQq5egDhuXoA4blX89Oy9Mvvpl5CxZn9VW75RM7DEqvmq7lHhEAWtXqvVfJuV/aKt/64ha57+E38saUOamsLGWdNWuyy9YDxY1OYPh6vfPL7+yc80/bNvc9/EbenDU/3btVZvMNV89mG6xW7vEAAIBWVCqVcsyBw3LMgcPy+LPT8oz9ox2S0PW2j3/842loaCj3GNBqtty4b7bcePlPLgBAZ9C1S2X23Xmtco9BGfXp1S2f3nPdco8BAACUyVYb981W9o92SE5dCAAAAAAAQCEJXQAAAAAAABSS0AUAAAAAAEAhCV0AAAAAAAAUktAFAAAAAABAIQldAAAAAAAAFJLQBQAAAAAAQCEJXQAAAAAAABSS0AUAAAAAAEAhCV0AAAAAAAAUktAFAAAAAABAIQldAAAAAAAAFJLQBQAAAAAAQCEJXQAAAAAAABSS0AUAAAAAAEAhCV0AAAAAAAAUktAFAAAAAABAIQldAAAAAAAAFJLQBQAAAAAAQCEJXQAAAAAAABSS0AUAAAAAAEAhCV0AAAAAAAAUktAFAAAAAABAIQldAAAAAAAAFJLQBQAAAAAAQCEJXQAAAAAAABSS0AUAAAAAAEAhCV0AAAAAAAAUktAFAAAAAABAIQldAAAAAAAAFJLQBQAAAAAAQCEJXQAAAAAAABSS0AUAAAAAAEAhCV0AAAAAAAAUktAFAAAAAABAIQldAAAAAAAAFJLQBQAAAAAAQCEJXQAAAAAAABSS0AUAAAAAAEAhCV0AAAAAAAAUktAFAAAAAABAIQldAAAAAAAAFJLQBQAAAAAAQCEJXQAAAAAAABSS0AUAAAAAAEAhCV0AAAAAAAAUktCVpKGhIaNGjcqZZ56ZHXfcMauttlq6dOmS/v37Z//998/tt99e7hEBAAAAAAB4j6pyD9Ae/OUvf8kee+yRJCmVShk6dGjWW2+9vPjii7nrrrty11135bjjjssvf/nLlEqlMk8LAAAAAABA4oiuJEuO6FpvvfXys5/9LFOmTMnYsWPz2GOPZfr06bngggtSKpXyq1/9Kpdddlm5RwVoskWL6nPL/ePzyS//OVNmzE2STJs5Lzf86aUsXFhf5umAtvDapNp86+LHs8NRt2fy9CXPA2/NXpCxr7xV5skAaAu1cxbmihufy+5fuHvp74EZb83PXx95Iw0NDWWeDmgLTzw/PSeeOypTZsxLkkx9c15+8MsnMuXt5wSgY5szd1GuuvWFfOKEe5a+Fpj+1vzc++Drqa/3WoDic0RXkm233TbPPfdcunTp8q6vV1ZW5qtf/Wqee+65XH755bniiity8sknl2lKgKa7+4HXcsJ3RmbClDnv+vr8BfU5/PS/ZkDf7rnk7B1zyB7rlGdAoFXNmbsoJ547Kr+7e9xyb15q5y7KBgfcmAN3XTu/Pvdj6d2rW5mmBKC1NDQ05Ge/fzbfuuTxzKpd+K7b5s5fnN2+cE82Hto7vz1vl3x0eN8yTQm0pgmT63LU2X/P3x6d+K6vL1hYn7P/77H8v8v+lZMOG54fn7Ztqqp8Hh46oitufC7fvPDRvDlrwbu+Pm/+4ux14p8ybEivXPO9XbL95v3KNCF8eH6DJenVq9dykWtZe+21V5Lk+eefb6uRAD60G/70Ug748p+Xi1zLmjRtbj512v25+raxbTgZ0BbmzluUvU78Y35z54sf+Am92/76anY+9q68OWt+G04HQFv4n0v+la/878PLRa5lPTtuZj72ubvy8BNT2nAyoC28Nqk2Oxx9x3KRa1kLFtbnot89k8NO/0sWL3bGD+hofnjlE/nid0ctF7mWNfaVWdn1C3d/4HMFtHdCVyPMm7fksO4ePXqUeRKAxhnz0swcffbfG3X4eUND8oX/90BGj5nWBpMBbeXUHz6UkaMnN2rZp198M8f89z9aeSIA2tLN943P9674d6OWrZ2zKAec+ue8Nfv9d4IBxdLQ0JCDv3p/XptU16jlb7n/lZx7+b9bdyigTf1x5Os566LHGrXsvPmLc9BX7nM6UwpL6GqE66+/Pkmy8847l3kSgMa5+Npns6AJ199atLghF/3u2VacCGhLU6bPzdW3v9ikde74+6t5/uWZrTMQAG3u/F8/2aTlp705L1ff7ih/6Cj+9ujEPP5s0z7MePF1z2be/EWtNBHQ1n589VNNWv6t2gW58pYXWmkaaF1C10rcfffdue2225IkZ5xxRpmnAVi52XULcs0dTd9Jcd0fX8r0mfNaYSKgrV15ywtZuKjpp5657IbnWmEaANra6DHT8vCTU5u83qXXj0lDgwvSQ0dw6fVjmrzO9Jnzc/0fX26FaYC29vzLM3P/P99o8no//8MYpzGlkEoNXsW+r3HjxmXbbbfNjBkzcuqpp+aiiy5q0vp1dXWpqalJkgwcODAVFbpiuU3s/fXUV6yaivq3MnDmT8s9DrSK+VVrZ1qvzzdr3dVnX5NVFo5r4YloTzwPdg7Tao7K/K7Dmrxel0VvpN+sy1thIoD2obP8Hqzttl3eqt63WesOePN/U9nw/td4pfg6y+Ogs5vY+xupr+jZ5PV6zHs8febc3goT0V54Dugc6rpumZk1BzZr3f4zL0hV/cyWHQjeR319fSZOXHJ9uC222CKjR49u1v1UteRQHcmkSZOy9957Z8aMGdlzzz3z4x//+EPd3zs/LMqs5+KkIqlfvDgTJkwo9zTQOmp6J72at+r0GXXJLI+NDs3zYOewXkPStemrLVxcYbsAOrbO8ntwjXlJdfNWnTT5zWSha7d2aJ3lcdDZrdqlWavNmbc4c2wXHZvngM5h9Y2SmuatOnnqW8k82wZtb/Lkxl1nfEWErhV4J269+OKL2WmnnXLLLbekS5fmvUB4hyO62oeJlZWpT1JRWZmBgwaVexxoFfOreqW5uyZWX606q/T02OjIPA92DtO6JPObsV6XysXpZ7sAOrDO8nuwttsqeauZ6w7o3yeVDd1adB7al87yOOjsJpYWpj6rNHm9HqtUpo/tokPzHNA51HXtkZnNXLf/Gqumqt5J4Ggbyx7R1b9//2bfj9D1HrNmzcree++dp556KltuuWXuuuuu9OjR40Pf79ixY1Nd3cyP1NFiBu9xbSZMmZOBAwbm9adfL/c40Crq5izMoE9cl7dmL2jSet1XqcyLI+9N7152bHRkngc7hx//+qmc/tNHmrzeV7+wd3709f9phYkA2ofO8nvwqRdmZLNP3dLk9TZZv0+evOn5lEqlVpiK9qKzPA46uyPO/GuuveelJq/3ywtPy2f2vbQVJqK98BzQOYx7bVbW3+8PTV5vvcE9M/bfT6WiwmsB2sayl38aOXJks+/HIUbLmDNnTvbff/88+uijGT58eP70pz9l1VVXLfdYAE1S3aNLjv1k06/Nc+S+Q0Uu6CA+d9CwdOta2aR1SqXki5/eqJUmAqAtbbrBatl5y6Z/Ivbkw4eLXNBBnHz48Cav02+1VXLIHuu0/DBAmxu6Vq/svdPgJq930mHDRS4KSeh624IFC3LwwQfngQceyNChQ3Pfffelb9++5R4LoFlO+a/h6d6t8Tu5u3apyKlHfKQVJwLa0uq9V8kXDtmgSescusc6GbpWMy/wB0C7c8bnNmvS8gPX6JGj9h/aStMAbW2nj/bPDpv3a9I6Xz1qkyZ/WApov04/dtM05fMrffusks8d1PQPTkN7IHQlWbx4cY444ojce++9GTx4cO67776sueaa5R4LoNmGDVk115+/W7pUrfxpvrKylN+ct0s23WC1NpgMaCs/+cZ22WP7xr2e2fojffOr7+7cyhMB0Jb232Xt/OArWzdq2d49u+auiz+RntVdW3kqoK2USqXcfMHuWX/txn2Q6cj9hubM45oWyIH2bbft1syFZ2zfqGVrelTl9v/bI6v3bvq1/aA9ELqS3HDDDbnpppuSJF27ds1RRx2VESNGrPC/SZMmlXlagMY54ONr508/3yvDhrz/G5t1B/XMnT/bM4fttV4bTga0hW5dK3PnxXvmpMM2StcuK37JV1lZypH7Dc1fr9zXzk2ADuibn988v/x/I7JGn/ffabXNJn0z6pr989HhzmgCHc2Avj0y6ur9s9/H1nrfZaq7V+W/j98813x/F6crgw7o1CM/kt/+YJcMXKPH+y6z+Yar5YFf758dNm/6aY+hvagq9wDtwfz585f++aWXXspLL73/xTrnzZvXFiMBtIhdt10zz932qdz/zzfy69vG5tWJtWlIMrh/jxxzwLDstdNgb2agA+vWtTKXnrNTvnPylvnVrS/k/n++kVm1C1PTo0t22qJ/TvjUhhnUv7rcYwLQij5/yIY5av/1c/N943PdH1/K1DfnpUtVRTYY0isnfGqjbLPJGuUeEWhF/Vbvnjsv3jMvvjorP79hTP41ZnrmzFuU3j27Zv9d1s7R+6+fVXv6wBN0ZEfut34O23O93PbXV/L7e8Zl0rS56VJVkaFr9czxh26Y7Tfr5xqdFJ7QleTYY4/NscceW+4xAFpFRUUpn9hhUD6xw6ByjwKUyRqrdc+Zx22eM4/bvNyjAFAG3bpW5jP7Ds1n9nUNLuis1l+7V378je3KPQZQJl26VORTe66bT+25brlHgVbh1IUAAAAAAAAUktAFAAAAAABAIQldAAAAAAAAFJLQBQAAAAAAQCEJXQAAAAAAABSS0AUAAAAAAEAhCV0AAAAAAAAUktAFAAAAAABAIQldAAAAAAAAFJLQBQAAAAAAQCEJXQAAAAAAABSS0AUAAAAAAEAhCV0AAAAAAAAUktAFAAAAAABAIQldAAAAAAAAFJLQBQAAAAAAQCEJXQAAAAAAABSS0AUAAAAAAEAhCV0AAAAAAAAUktAFAAAAAABAIQldAAAAAAAAFJLQBQAAAAAAQCEJXQAAAAAAABSS0AUAAAAAAEAhCV0AAAAAAAAUktAFAAAAAABAIQldAAAAAAAAFJLQBQAAAAAAQCEJXQAAAAAAABSS0AUAAAAAAEAhCV0AAAAAAAAUktAFAAAAAABAIQldAAAAAAAAFJLQBQAAAAAAQCEJXQAAAAAAABSS0AUAAAAAAEAhCV0AAAAAAAAUktAFAAAAAABAIQldAAAAAAAAFJLQBQAAAAAAQCEJXQAAAAAAABSS0AUAAAAAAEAhCV0AAAAAAAAUktAFAAAAAABAIQldAAAAAAAAFJLQBQAAAAAAQCEJXUluv/32nHTSSdl2220zaNCgdOvWLT179swWW2yRs88+O9OmTSv3iAAAAAAAALxHVbkHaA9++tOf5u9//3u6du2aNddcM5tttlmmTJmSJ598Mk888UR++ctf5t57780WW2xR7lEBAAAAAAB4myO6khx33HG5//77M3v27Lz88st59NFH88orr+SJJ57IJptskqlTp+aII44o95h8CLPrFuS6e8alds7CJMm8+YuzaFF9macCAADaytNjZ6Ru7pL3A3VzF2Xca7PKPBEAtJ1Fi+pz9wOvLd03NmfeoqV/Big6oSvJZz/72ey2227p2rXru76+6aab5sorr0ySjBkzJmPGjCnHeHwIr02qzSnffzCD9rgunznzb3mrdskv8Olvzc96+96Q71/x78ydt6jMUwIAAK3l1r+Mz8eOvTObHnpLZs5e8n5g5uwFWX+/P2Sfk/6Uv/zzjTJPCACtZ87cRfneFaOz7j43ZL9T7l26b+zNWQuy5u7X5kvnPZjXJ9WVeUqAD0foWonhw4cv/fOcOXPKOAlN9eQLM7LtEbfn0uvHZHbd8p9QeW1SXc65+PHs9oW78+as+WWYEAAAaC0NDQ0552eP5eCv3p8H/jV5hcv8cdTr2eOEe3LJdc+28XQA0PpmvDU/u33h7nzr4n/l9cnLx6zZdQtzyXVjsu2Rt+epF2aUYUKAliF0rcSoUaOSJNXV1dlwww3LPA2N9fqkuux14h8zadrclS778JNTc/BX78vChU5lCAAAHcWFv30m3//FEytdrqEh+dJ5D+X6P77UBlMBQNtYuLA+B33lz/nnU1NXuuzEqXOy98l/yoQVxDCAIhC6VqC+vj4TJ07MNddck2OPPTZJct5556Wmpqa8g9Fo5//6yUZFrnf8/bFJuf1vr7TiRAAAQFuZVbsg/3PJ401a5/SfPpLFi334DYCO4Za/jH/fI5pX5I0pc/KTa55qxYkAWo/QtYyf//znKZVKqayszJprrpljjjkmgwcPzh133JFTTz213OPRSHVzFubXt49t8nqXXu8abAAA0BH89s4XUzunadfifW1SXe76x2utNBEAtK3m7Oe66taxmTPXteyB4hG6ljFw4MDstNNO2W677bLmmmumVCrlySefzO9///u89dZb5R6PRvrjqNczq3b5a3KtzF8emZjJ0xt/FBgAANA+XdfM0xD+/p5xLTwJALS9iVPn5O+PTWryejNnL8ifHny9FSYCaF2lhoaGhnIP0V499dRTOeWUU/LAAw9kp512ysiRI5u0fl1d3dLTHQ4cODAVFbpiW6jttm3eqt6vWev2e+uSdFk8pYUnAmg/Jvb+euorVk1F/VsZOPOn5R4HAFrFpFW/nMWVfZu8XteFL2eN2b9u+YGgHfF6EDq+BZUDMnXVk5q1bu+6O1I9/7EWnghgxd65jFSSbLHFFhk9enSz7qeqJYfqaDbddNPcddddWW+99TJq1Kjcd9992WOPPZp1X+/8sGgDfaYn1c1bdcrkicn8pn/iBaAwei5OKpL6xYszYcKEck8DAK2jx/yksumrLZg3x+9HOj6vB6Hj69aQrNq8VWe+OT0z3/TcALS9yZMbf13B9xK6VqJnz57ZZZddctNNN+WJJ55oduhyRFfbmV9Vn2lJ0tCQlEqNX7FhYQb27Z6KDGqt0QDKbmJlZeqTVFRWZuAgz3cAdEzTK2ZnXjPWq+5Sl95+P9LBeT0IHV99qVsmNixKSk3Y9fv2frS+verTrYfnBqBtLHtEV//+/Zt9P0JXIyxatOQijIsXL272fYwdOzbV1c08zIgmqa9vyAYH/CHjXpvdpPWOPWjjXHVu887lD1AUg/e4NhOmzMnAAQPz+tPOvQ5Ax3Tn31/NAV/+c5PXG3n7edlio8tbYSJoP7wehM7hs2f/Pb+588XGr1AqZYMhq2bMbSNTUdGED44DfAjLXv6pqZeOWpZDjFZixowZ+fvf/55kyTkiaf8qKko56bDhTV7v5MObvg4AAND+7DNicNZZs6ZJ6+yweb9ssdHqrTQRALSt5uznOumwjUQuoJA6feh67LHH8j//8z958cXlP+EwevTo7LPPPpk5c2Y23XTT7L777mWYkOb48hEbZ9dtBjZ6+bM+v3m22WSNVpwIAABoK5WVFfnNebukW9fGveXt3bNrrvzOzq08FQC0ne0375czPrdpo5fffbs1c/J/+RA4UEydPnTV1tbm3HPPzbBhw9K/f/9svfXW2W677TJo0KBsueWWeeSRR7LBBhvk1ltvTWVlM65mTFl07VKZ2/5vj+y148rPKXzW5zfP9768VRtMBQAAtJURWw7IXRfvlV41XT5wuQF9u+f+X+yT4ev1bpvBAKCN/OAr2+TM4zZb6XL7jBicWy/aI1272PcJFFOnD12bb755Lrroohx00EHp1atXXnjhhYwePTqLFy/OHnvskUsuuSRPPPFE1ltvvXKPShP1rO6auy7ZM3de/Insu/PglJY58rr7KpX5/MEb5PHrDsx5X9naYdkAANAB7b79mhl7x6dz3qlbZ+2B775m8obrrJqLztw+z932qWy5cd8yTQgAraeiopQffnWbPHbdgfn8wRuk+yr/CVmlUrLfx9bKXZfsmTt+9onU9PjgD4YAtGelhoaGhnIP0VEteyG12traVFdXr2QNWtOMt+Znyoy5qaqsyMC+3VPtFzjQCb1z8fFB/Xrk9fs+U+5xAKDNLF5cnwlT5qR2zsL0qu6aQf17pFTygTc6H68HofOqm7MwE6fNzaLF9em3Wvestmq3co8EdHIt1VCqWnIoaM9WW7WbX+AAANBJVVZWZO2BNeUeAwDKprpHl6y/tg9+Ax1Ppz91IQAAAAAAAMUkdAEAAAAAAFBIQhcAAAAAAACFJHQBAAAAAABQSEIXAAAAAAAAhSR0AQAAAAAAUEhCFwAAAAAAAIUkdAEAAAAAAFBIQhcAAAAAAACFJHQBAAAAAABQSEIXAAAAAAAAhSR0AQAAAAAAUEhCFwAAAAAAAIUkdAEAAAAAAFBIQhcAAAAAAACFJHQBAAAAAABQSEIXAAAAAAAAhSR0AQAAAAAAUEhCFwAAAAAAAIUkdAEAAAAAAFBIQhcAAAAAAACFJHQBAAAAAABQSEIXAAAAAAAAhSR0AQAAAAAAUEhCFwAAAAAAAIUkdAEAAAAAAFBIQhcAAAAAAACFJHQBAAAAAABQSEIXAAAAAAAAhSR0AQAAAAAAUEhCFwAAAAAAAIUkdAEAAAAAAFBIQhcAAAAAAACFJHQBAAAAAABQSEIXAAAAAAAAhSR0AQAAAAAAUEhCFwAAAAAAAIUkdAEAAAAAAFBIQhcAAAAAAACFJHQBAAAAAABQSEIXAAAAAAAAhSR0AQAAAAAAUEhCFwAAAAAAAIUkdAEAAAAAAFBIQhcAAAAAAACFJHQBAAAAAABQSELX+/jFL36RUqmUUqmUj3/84+UeBwAAAAAAgPcQulZg0qRJOeOMM8o9BgAAAECLWbSoPvX1DeUeAwCgRQldK/DlL385s2bNyv7771/uUQAAAACabdGi+tx83/jscfw96bLlVZk4bW6SZMqMufnFjc+lbs7CMk8IAPDhCF3vcfvtt+fGG2/MKaeckq222qrc4wAAAAA0y6sTa7PFp2/JoV+/P/f/84133bZwUUNO+O6orLfvDXnkqallmhAA4MMTupYxe/bsnHLKKVlzzTXzve99r9zjAAAAADTLxKlz8rHP3ZVnxs38wOWmzJiX3b5wdx5/dlrbDAYA0MKErmWcddZZef3113PhhRemV69e5R4HAAAAoFlOPHdUXnmjtlHL1s1dlMNP/0sWL65v5akAAFqe0PW2hx56KJdddln22WeffPrTny73OAAAAADNMn7C7Nzx91ebtM6412bnTw9OaKWJAABaj9CVZOHChTn++OPTrVu3XHzxxeUeBwAAAKDZfnHT82loaPp6P7/huZYfBgCglVWVe4D24Ic//GGeeeaZfP/73896663XKt9j2LBhqajQFQEor4m9v55UrJqJkyZm8ODB5R4HAIBWML3mv5Kuw5u83t1/GZ3Bgz/XChMBACyvvv4/p00eMWJERo8e3az76fSh6/nnn8/3v//9DB8+PKeffnqrfZ+JEye22n0DQKP1XJxUJPWLF2fCBKemAQDokNZZlHRt+mqL60teIwIAZTF58uRmr9vpQ9dJJ52U+fPn5+c//3m6dOnSat9n4MCBjugCoOwmVlamPklFZWUGDhpU7nEAAGgFM7rWZ24z1qsqLUh/rxEBgDZSX1+/9CCh/v37N/t+Sg0NzTlrc8fRu3fvzJ49O2usscZyt9XW1qauri5dunTJaqutliR54YUX0qtXr0bdd11dXWpqapbeV3V1dcsNDgDNMHiPazNhypwM6tcjr9/3mXKPAwBAK7j1L+Nz8Ffvb/J63z1ly3zrix9thYkAAJbXUg2l0x/RlSyphh90WNzChQuX3r7sOSMBAAAA2pv9P7Z21hpQndcm1TV6narKUo4/dMNWnAoAoHV0+nPpzZw5Mw0NDSv879vf/naSZJdddln6td69e5d3YAAAAIAPUFVVke99aasmrfOVIz+SAX17tNJEAACtp9OHLgAAAICO5rOfHJYffGXrRi171P5D879f26aVJwIAaB1CFwAAAEAH9M3Pb56bfrp7ttq47wpvH7pWz/zfN7fPNd/fJZWVdhEBAMXkGl0AAAAAHdQhe6yTQ/ZYJ48+PTV/HPV6ZtUuTHX3qmy36RrZa6fBqagolXtEAIAPpdTQ0NBQ7iE6qrq6utTU1CRJamtrU11dXeaJAOjsBu9xbSZMmZNB/Xrk9fs+U+5xAAAAAOikWqqhOC4dAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoSvJsccem1Kp9IH/Pffcc+UeEwAAAAAAgGVUlXuA9mTYsGHp16/fCm/r0aNHG08DAAAAAADABxG6lnH22Wfn2GOPLfcYANCi6usbct/DE3Ljn8dn+sz5SZJZdQvz+qS6DB5QXebpAAAAAKD5hC4A6MD+cO/LOfv/HsuLr85619dn1y3MOvtcnwM/PiSX/PcOGdDXkcsAAAAAFI9rdAFAB/Wz3z+Tw77xl+Ui1zsWL27IzfePzw5H3ZFXJ9a28XQAAAAA8OE5omsZN954Y2699dbMmjUrffv2zfbbb5+jjz46a6yxRrlHA4AmueeB13LqDx9u1LLj36jNfqfcm39df1C6dPEZGAAAAACKw96sZdx111257bbb8te//jV/+MMfctppp2XdddfNb3/723KPBgBNct4vn2jS8k+/+GZu++srrTQNAAAAALQOoSvJBhtskAsuuCD//ve/M3PmzNTV1eUf//hH9txzz9TV1eWzn/1s7rrrrnKPCQCN8uQLMzJy9OQmr3fp9WNaYRoAAAAAaD2lhoaGhnIP0V41NDTk4IMPzm233Zb1118/L7zwQkqlUqPXr6urS01NTZKktrY21dXVrTUqACz1o189mTMvfLRZ68599Jis0s2ZjQEAAABoXS3VUISulXj++eez0UYbJUmeeOKJbLbZZo1ed9kf0sCBA1NR4QA6AFrfW913T233jzVr3QFv/iiVDXUtPBEAAAAAvFt9fX0mTpyYJNliiy0yevToZt2Pj2yvxIYbbpjVVlstM2bMyNixY5sUupb1zg8LAFrdGtOT7s1bddIbryT181t2HgAAAAD4AJMnN/0yHO8QuhqhS5cuSZJFixY1+z4c0QVAW5lXNTvTk6ShIWnCKXerFk9Nv4F90/g1AAAAAKB5lj2iq3///s2+H6FrJaZOnZopU6YkSQYPHtzs+xk7dqxrdAHQJurrG7LhJ2/Mi6/OatJ6P/3vA/LlI77ZSlMBAAAAwH8se/mnkSNHNvt+HGK0Ej/5yU/S0NCQVVddNdtss025xwGAlaqoKOXUIzZu0jq9e3bNZw8Y1koTAQAAAEDr6PSh689//nO++c1vZty4ce/6+pw5c/Ld7343P/rRj5IkZ511Vrp27VqOEQGgyU75r41zxL5DG7Vst64VufWiPbJqT7/nAAAAACiWUkNDQ0O5hyinW2+9NQcffHCSJdfRGjRoUOrr6zNmzJjMnTs3SXLCCSfk5z//eUpNuM5J8u7D7mpra526EIA2tXhxfU778SP52bXPpr5+xb/u1+zXIzecv1t2+mjzz4MMAAAAAE3VUg2l04eu1157LVdccUUeeuihvPjii5k6dWoWL16c/v37Z4cddsjxxx+f3XffvVn3LXQB0B68Nqk2v7jp+fzh3pcz9c15WaVrZYav1ztf/NRGOXDXIenSpdMf4A0AAABAGxO6CkDoAgAAAAAAWF5LNRQf4QYAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoeo9bb701BxxwQAYOHJhu3bpl4MCB2XXXXXP++eeXezQAAAAAAACWUWpoaGgo9xDtwYIFC3LkkUfmxhtvTJKst956WX311TN58uRMmDAhvXv3zrRp05p0n3V1dampqUmS1NbWprq6usXnBgAAAAAAKJqWaihVLTlUkX3hC1/IjTfemL333jsXX3xxhg4duvS2mTNn5h//+EcZpwMAAAAAAOC9HNGV5N57781ee+2V7bbbLiNHjkxVVcv0P0d0AQAAAAAALK+lGoprdCW54IILkiTnnHNOi0UuAAAAAAAAWlenP6Jr7ty56dWrV+rr6zNr1qw8/fTTueqqq/Liiy+mpqYm22+/fb7whS+kb9++Tb5vR3QBAAAAAAAsr6UaSqcPXQ8//HB22GGHrLHGGjnttNNy1lln5b3/JL17987NN9+cXXfdtUn3LXQBAAAAAAAsz6kLW8jEiROTJG+++Wa++c1vZt99980zzzyT+fPn58knn8xuu+2WmTNn5pBDDsnrr79e5mkBAAAAAAB4R6cPXXV1dUmSRYsWZejQobnllluy8cYbp2vXrtl0001zxx13ZMCAAZk5c2YuvPDC8g4LAAAAAADAUlXlHqDcVllllaV//tKXvpQuXbq86/YePXrkpJNOyre//e388Y9/zI9//ONmfZ9hw4aloqLTd0UAAAAAAIDU19cv/fOIESMyevToZt1Ppw9dffr0Wfrn4cOHr3CZd77+8ssvN/v7vHOKRAAAAAAAAP5j8uTJzV6304eujTbaaOmfu3btusJl3jnqa/Hixc3+PgMHDnREFwAAAAAAQJYc0fXOQUL9+/dv9v10+tA1aNCgrL322nn11Vfz0ksvZdddd11umXHjxiVJBg8e3OzvM3bs2FRXVzd7fQAAAAAAgI6irq4uNTU1SZKRI0c2+34cYpTksMMOS5JcffXVy93W0NCQX//610mS3XbbrS3HAgAAAAAA4AMIXUlOP/309OrVKw888EDOPffcpacoXLRoUc4888w88cQT6datW772ta+VeVIAAAAAAADeUWpoaGgo9xDtwT333JODDz448+fPzxprrJF1110348aNy/Tp01NVVZWrrroqRx11VJPuc9nD7mpra526EAAAAAAAIC3XUBzR9bZ99tkno0ePzlFHHZWqqqqMHj06VVVVOeyww/LPf/6zyZELAAAAAACA1uWIrlbkiC4AAAAAAIDlOaILAAAAAACATk3oAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKqdOHrvHjx6dUKjXqv+985zvlHhcAAAAAAIC3VZV7gHJbZZVVstNOO73v7bNnz86TTz6ZJNlxxx3baiwAAAAAAABWotOHrgEDBmTkyJHve/uPfvSjPPnkkxk8eHB23333NpwMAAAAAACAD9LpT124Mtdcc02S5Oijj05FhX8uAAAAAACA9kK5+QCPP/54nnnmmSTJMcccU+ZpAAAAAAAAWJbQ9QGuvvrqJMl2222XDTfcsMzTAAAAAAAAsCyh630sXLgw1157bZLk2GOPLe8wAAAAAAAALEfoeh933XVXpk2blm7duuXwww8v9zgAAAAAAAC8R1W5B2ivrrnmmiTJJz/5yfTp0+dD39+wYcNSUaErAgAAAAAA1NfXL/3ziBEjMnr06Gbdj9C1AtOnT89dd92VpOVOWzhx4sQWuR8AAAAAAICOZPLkyc1eV+hagWuvvTYLFizIgAEDstdee7XIfQ4cONARXQAAAAAAAFlyRNc7Bwn179+/2fcjdK3A1VdfnSQ58sgjU1lZ2SL3OXbs2FRXV7fIfQEAAAAAABRZXV1dampqkiQjR45s9v04xOg9nn322Tz22GNJWu60hQAAAAAAALQ8oes9rrnmmiTJlltumU022aTM0wAAAAAAAPB+hK5l1NfX57e//W2S5JhjjinzNAAAAAAAAHwQoWsZ9913XyZMmJAuXbrkiCOOKPc4AAAAAAAAfAChaxlXX311kmS//fZL3759yzwNAAAAAAAAH6TU0NDQUO4hOqq6urrU1NQkSWpra1NdXV3miQAAAAAAAMqvpRqKI7oAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISut42bdq0nHnmmdl0001TXV2dbt26ZciQITn66KPzr3/9q9zjAQAAAAAA8B6lhoaGhnIPUW7PP/98Pv7xj2fSpEmpqKjIuuuum5qamowbNy61tbWprKzM1VdfnSOPPLJJ91tXV5eampokSW1tbaqrq1tjfAAAAAAAgEJpqYbiiK4kJ510UiZNmpQNN9wwzzzzTF588cX8+9//zqRJk3LCCSdk8eLFOfHEEzNjxoxyjwoAAAAAAMDbOn3omj17dv72t78lSc4///xstNFGS2+rrq7OJZdckr59+6a2tjb/+Mc/yjQlAAAAAAAA79XpQ9f8+fPzztkb11tvveVur6qqypAhQ5IkCxcubNPZAAAAAAAAeH+dPnT17ds3gwYNSpI8+OCDy90+Y8aMPPfcc6moqMiWW27Z1uMBAAAAAADwPjp96EqS8847L6VSKaeffnquuuqqTJ48OXV1dRk1alT233//1NXV5etf/3qGDh1a7lEBAAAAAAB4W1W5B2gPPvvZz2bVVVfN9773vRx33HHvum3IkCG55pprcvTRR5dpOgAAAAAAAFbEEV1JGhoaMm7cuEydOjUVFRVZZ511stlmm6VHjx555ZVXcvnll2fMmDHlHhMAAAAAAIBlOKIryUknnZTLL78822yzTe69995ssMEGSZK5c+fm29/+ds4///zssMMOeeqpp7LWWms163sMGzYsFRW6IgAAAAAAQH19/dI/jxgxIqNHj27W/ZQaGhoaWmqoInriiSfy0Y9+NFVVVRk7dmyGDBmy3DJ77LFH7r///px44om57LLLGn3fdXV1qampaclxAQAAAAAAOpSBAwfmjTfeaNa6nf6IrlGjRqWhoSHDhg1bYeRKkj333DP3339/Hn300WZ/n4EDBzqiCwAAAAAAIEuO6Jo4cWKSpH///s2+n04fumbPnt3oZefNm9fs7zN27NhUV1c3e30AAAAAAICOYtmz4o0cObLZ99PpDzF653pcY8eOzSuvvLLCZe69994kyYYbbthmcwEAAAAAAPDBOn3o2nPPPdOvX78sXLgwn/70p/PCCy8svW3u3Lk544wzcv/99ydJPvvZz5ZrTAAAAAAAAN6j05+6sLq6Or/73e9y0EEH5dFHH83w4cMzZMiQ9OzZMy+++GLmzJmTJDnllFNy4IEHlnlaAAAAAAAA3lFqaGhoKPcQ7cFLL72UCy64IPfdd19eeeWVLFq0KH379s22226b448/Pvvtt1+T73PZ80vW1ta6RhcAAAAAAEBarqEIXa1I6AIAAAAAAFheSzWUTn+NLgAAAAAAAIpJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoetvUqVNzxhlnZPjw4enevXv69OmTj33sY/n9739f7tEAAAAAAABYgapyD9AejBkzJnvssUfeeOONdOnSJZtssknmzZuXkSNH5oEHHsj999+fK6+8stxjAgAAAAAAsIxOf0TX4sWLc+ihh+aNN97IiBEj8uqrr+Zf//pXnn322TzxxBNZe+2186tf/Sq/+MUvyj0qAAAAAAAAy+j0oevuu+/OmDFj0q1bt/zmN7/JgAEDlt626aab5pJLLkmS/L//9/+yePHico0JAAAAAADAe3T60DVy5MgkydZbb5111llnudv333//VFdX54033sgDDzzQxtMBAAAAAADwfjp96JoxY0aSZNCgQe+7zDu3Pfjgg20yEwAAAAAAACvX6UNX7969kyQTJkx432Xeue35559vi5EAAAAAAABohE4furbZZpskyWOPPZZXXnlludvvvvvu1NXVJUnefPPNNp0NAAAAAACA91dV7gHK7cADD8zgwYPz+uuv57/+679yww03ZK211kqSPProoznxxBOXLjtnzpxmf59hw4aloqLTd0UAAAAAAIDU19cv/fOIESMyevToZt1Ppw9d3bp1yw033JB99tknDz/8cNZdd90MGzYs8+bNy/jx47P66qvnkEMOyc0335yePXs2+/tMnDixBacGAAAAAADoGCZPntzsdTt96EqSHXbYIaNHj84Pf/jD/OlPf8pLL72UPn365Nhjj813v/vdnHfeeUmSAQMGNPt7DBw40BFdAAAAAAAAWXJE1zsHCfXv37/Z9yN0vW3dddfN5ZdfvsLbnnnmmSTJ1ltv3ez7Hzt2bKqrq5u9PgAAAAAAQEdRV1eXmpqaJMnIkSObfT8OMVqJadOm5aGHHkpVVVX23Xffco8DAAAAAADA24SulTjnnHOyaNGiHH744Rk4cGC5xwEAAAAAAOBtQleSu+++O6NGjXrX12bOnJmvfvWrufzyy7PGGmvkJz/5SZmmAwAAAAAAYEVcoyvJvffem4suuii9evXKOuuskyR57rnnsmDBggwaNCj33HPPh7oQGgAAAAAAAC1P6Epy0EEHZfLkyXnkkUcyduzYVFVVZeONN84hhxySr371q+nZs2e5RwQAAAAAAOA9Sg0NDQ3lHqKjqqurS01NTZKktrY21dXVZZ4IAAAAAACg/FqqobhGFwAAAAAAAIUkdAEAAAAAAFBIQhcAAAAAAACFJHQBAAAAAABQSEIXAAAAAAAAhSR0AQAAAAAAUEhCFwAAAAAAAIUkdAEAAAAAAFBIQhcAAAAAAACFJHQBAAAAAABQSEIXAAAAAAAAhSR0AQAAAAAAUEhCFwAAAAAAAIUkdAEAAAAAAFBIQhcAAAAAAACFJHQBAAAAAABQSEIXAAAAAAAAhSR0AQAAAAAAUEhCFwAAAAAAAIUkdAEAAAAAAFBIQhcAAAAAAACFJHQBAAAAAABQSEIXAAAAAAAAhSR0AQAAAAAAUEhCFwAAAAAAAIUkdAEAAAAAAFBIQhcAAAAAAACFJHQBAAAAAABQSEIXAAAAAAAAhSR0AQAAAAAAUEhCFwAAAAAAAIUkdAEAAAAAAFBIQhcAAAAAAACFJHQBAAAAAABQSEIXAAAAAAAAhSR0AQAAAAAAUEhCFwAAAAAAAIUkdAEAAAAAAFBIQhcAAAAAAACFJHQBAAAAAABQSEIXAAAAAAAAhSR0AQAAAAAAUEhCFwAAAAAAAIUkdAEAAAAAAFBIQhcAAAAAAACFJHQBAAAAAABQSB0qdI0fPz5XXnllTjzxxGy11Vbp2rVrSqVSjj322Eatf++992bvvffO6quvnh49emTTTTfND37wgyxYsKB1BwcAAAAAAKDJqso9QEu68MILc9FFFzVr3Z/85Cf5xje+kSQZMmRI1l577Tz99NM5++yzc+edd+a+++5L9+7dW3JcAAAAAAAAPoQOdURX3759s+++++bb3/527rjjjpx88smNWu+RRx7J6aefnlKplF//+tcZP358Ro8eneeeey7rr79+HnzwwZx11lmtPD0AAAAAAABN0aGO6DrnnHPe9f8PP/xwo9Y799xz09DQkOOOOy7HHHPM0q8PHTo0V155ZXbZZZdcdtllOfvss9OvX78WnRkAAAAAAIDm6VBHdDXH7Nmzc++99yZJjj/++OVu/9jHPpYNNtggCxYsyO23397W4wEAAAAAAPA+On3oGj16dBYsWJBu3bpl6623XuEyI0aMSNL4I8QAAAAAAABofZ0+dL3wwgtJkiFDhqSqasVnchw6dOi7lgUAAAAAAKD8On3oevPNN5Mkffr0ed9l3rntnWUBAAAAAAAov04fuubNm5ck6dq16/su061btyTJ3Llz22QmAAAAAAAAVm7F5+rrRFZZZZUkyYIFC953mfnz5ydJunfv3uzvM2zYsFRUdPquCAAAAAAAkPr6+qV/HjFiREaPHt2s++n0oasxpyVszOkNV2bixInNXhcAAAAAAKCjmjx5crPX7fSha4MNNkiSvPLKK1m0aFGqqpb/Jxk3bty7lm2OgQMHOqILAAAAAAAgS47oeucgof79+zf7fjp96ProRz+arl27Zv78+Xnsscey/fbbL7fMyJEjkyTbbbdds7/P2LFjU11d3ez1AQAAAAAAOoq6urrU1NQk+U+HaY5Of4hRz54984lPfCJJ8otf/GK52//xj3/khRdeSNeuXXPggQe29XgAAAAAAAC8j04fupLknHPOSalUylVXXZWrr7566dfHjRuXz3/+80mSL37xi+nXr1+5RgQAAAAAAOA9Sg0NDQ3lHqKljBo16l1HXc2ZMydz585Nt27dlh7+liS33XZbdtppp3et+6Mf/ShnnnlmkmTIkCHp06dPnn766SxatCjbbbdd/vKXv6RHjx5NmmfZw+5qa2uduhAAAAAAACAt11A61DW6Fi5cmOnTpy/39fnz52f+/PnvWu69zjjjjGy++eb5yU9+kkcffTSTJ0/OBhtskCOPPDKnnXZaunXr1qqzAwAAAAAA0DQd6oiu9sYRXQAAAAAAAMtrqYbiGl0AAAAAAAAUktAFAAAAAABAIQldAAAAAAAAFJLQBQAAAAAAQCEJXQAAAAAAABSS0AUAAAAAAEAhCV0AAAAAAAAUktAFAAAAAABAIQldAAAAAAAAFJLQBQAAAAAAQCEJXQAAAAAAABSS0AUAAAAAAEAhCV0AAAAAAAAUktAFAAAAAABAIQldAAAAAAAAFJLQBQAAAAAAQCEJXQAAAAAAABSS0AUAAAAAAEAhCV0AAAAAAAAUktAFAAAAAABAIQldAAAAAAAAFJLQBQAAAAAAQCEJXQAAAAAAABSS0AUAAAAAAEAhCV0AAAAAAAAUktAFAAAAAABAIQldAAAAAAAAFJLQBQAAAAAAQCEJXQAAAAAAABSS0AUAAAAAAEAhCV0AAAAAAAAUktAFAAAAAABAIQldAAAAAAAAFJLQBQAAAAAAQCEJXQAAAAAAABSS0AUAAAAAAEAhCV0AAAAAAAAUktAFAAAAAABAIQldAAAAAAAAFJLQBQAAAAAAQCEJXQAAAAAAABSS0AUAAAAAAEAhCV0AAAAAAAAUktAFAAAAAABAIQldAAAAAAAAFJLQBQAAAAAAQCF1qNA1fvz4XHnllTnxxBOz1VZbpWvXrimVSjn22GNbZT0AAAAAAADKp6rcA7SkCy+8MBdddFGbrQcAAAAAAED5dKjQ1bdv3+y7777ZZpttsvXWW+eee+7JpZde2mrrAQAAAAAAUD4dKnSdc8457/r/hx9+uFXXAwAAAAAAoHw61DW6AAAAAAAA6DyELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkKrKPUBnMWzYsFRU6IoAAAAAAAD19fVL/zxixIiMHj26WfcjdLWRiRMnlnsEAAAAAACAdmfy5MnNXlfoaiMDBw50RBcAAAAAAECWHNH1zkFC/fv3b/b9CF1tZOzYsamuri73GAAAAAAAAGVXV1eXmpqaJMnIkSObfT8OMQIAAAAAAKCQhC4AAAAAAAAKqdTQ0NBQ7iFayqhRo3LggQcu/f85c+Zk7ty56dat29LD35Lktttuy0477fSh11uZZQ+7q62tdepCAAAAAACAtFxD6VDX6Fq4cGGmT5++3Nfnz5+f+fPnv2u5llgPAAAAAACA8ulQR3S1N47oAgAAAAAAWF5LNRTX6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAP4/e/ce52Vd5///OcMAygx4QpwBTAVRsSzP5zwUqRnlYbeTprFutpr7bdt21dWfm1um2VH95qaWZrZtlquVGlaIlQfUr5KIR5SDh0DOSDDDGT6/P1IWBGQYhvnwZu73241bzOe63tf1Gmbsn8ftfV0ARRK6AAAAAAAAKJLQBQAAAAAAQJGELgAAAAAAAIq0RYWul19+OTfddFPOOeecHHDAAenWrVtqamoybNiwda6pVCoZNWpULrzwwhx++OHZfvvt07Vr1+y0004ZOnRo7rrrro77BgAAAAAAAGi1umoP0J6uvvrqXHPNNRu05ve//32GDBmSJKmpqcnAgQMzYMCATJgwIcOHD8/w4cNz1lln5cYbb0xNTc2mGBsAAAAAAIA22KJ2dPXu3TsnnnhiLr300tx999353Oc+t941lUolAwYMyHe/+93MmDEj48ePz+jRozN79uxcddVVqampyQ9/+MNcd911HfAdAAAAAAAA0Fpb1I6uSy65ZLWvH3300fWuOfjggzNu3Lh07dp1tc+7dOmSL3zhCxk3blxuuOGGfP/7329VOAMAAAAAAKBjbFE7utqiV69ea0SuVR1//PFJkhdeeKGjRgIAAAAAAKAVOn3oWp9FixYlSXr06FHlSQAAAAAAAFiV0LUeP//5z5Mk733ve6s8CQAAAAAAAKsSut7GPffckzvvvDNJcsEFF1R5GgAAAAAAAFZVV+0BNlcTJ07MGWeckST5/Oc/n8MPP3yjrjdo0KDU1uqKAAAAAAAAK1asWPn3I488MmPGjGnTdYSutZg2bVpOOOGEzJkzJ8cdd1y+9a1vbfQ1p06d2g6TAQAAAAAAbFmmT5/e5rVC11u8GbcmTJiQI444Ir/85S/TtWvXjb5uU1OTHV0AAAAAAAD5646uNzcJ7bTTTm2+jtC1innz5uWEE07I008/nf333z/Dhw9Pjx492uXa48ePT319fbtcCwAAAAAAoGQtLS1paGhIkjz00ENtvo4tRm9YsGBBhg4dmscffzyDBw/O7373u2yzzTbVHgsAAAAAAIB1ELqSLFmyJKecckoefPDBDBw4MCNHjkzv3r2rPRYAAAAAAABvo9OHruXLl+e0007LiBEj0r9//4wcOTJ9+/at9lgAAAAAAACsR02lUqlUe4j2MmrUqJx00kkrv16wYEEWLlyY7t27r3zOY5LceeedOeKII5Ikt956a0477bQkyYABA9LU1LTO699+++1pbGxs9TyrPl+yubnZO7oAAAAAAADSfg2lrj2HqralS5dm9uzZa3y+ePHiLF68eLXzVj32pkmTJmXSpEnrvP6iRYvaaVIAAAAAAAA21ha1o2tzY0cXAAAAAADAmtqroXT6d3QBAAAAAABQJqELAAAAAACAIgldAAAAAAAAFEnoAgAAAAAAoEhCFwAAAAAAAEUSugAAAAAAACiS0AUAAAAAAECRhC4AAAAAAACKJHQBAAAAAABQJKELAAAAAACAIgldAAAAAAAAFEnoAgAAAAAAoEhCFwAAAAAAAEUSugAAAAAAACiS0AUAAAAAAECRhC4AAAAAAACKJHQBAAAAAABQJKELAAAAAACAIgldAAAAAAAAFEnoAgAAAAAAoEhCFwAAAAAAAEUSugAAAAAAACiS0AUAAAAAAECRhC4AAAAAAACKJHQBAAAAAABQJKELAAAAAACAIgldAAAAAAAAFEnoAgAAAAAAoEhCFwAAAAAAAEUSugAAAAAAACiS0AUAAAAAAECRhC4AAAAAAACKJHQBAAAAAABQJKELAAAAAACAIgldAAAAAAAAFEnoAgAAAAAAoEhCFwAAAAAAAEUSugAAAAAAACiS0AUAAAAAAECRhC4AAAAAAACKJHQBAAAAAABQJKELAAAAAACAIgldAAAAAAAAFEnoAgAAAAAAoEhCFwAAAAAAAEUSugAAAAAAACjSFhW6Xn755dx0000555xzcsABB6Rbt26pqanJsGHD3nbdXXfdlXPPPTcHH3xw+vXrl+7du6dnz57Zd999c/HFF2fWrFkd8w0AAAAAAADQanXVHqA9XX311bnmmms2eN13vvOd3H///enWrVv69u2bd7/73ZkxY0aeeuqpjB07NjfeeGNGjBiRfffdt/2HBgAAAAAAoE22qB1dvXv3zoknnphLL700d999dz73uc+1at1ZZ52V++67L/Pnz89LL72Uxx9/PK+88krGjh2bd73rXZk5c2ZOO+20TTw9AAAAAAAAG2KL2tF1ySWXrPb1o48+2qp1Z5555lo/32effXLTTTflkEMOyfPPP5/nn38+gwcP3ug5AQAAAAAA2Hhb1I6uTWHVsLVgwYIqTgIAAAAAAMCqhK71GDVqVJKkvr4+e+65Z5WnAQAAAAAA4E1b1KML28uKFSsyffr03HvvvbnggguSJFdccUUaGhqqPBkAAAAAAABvErpWcf311+fcc89d7bMDDjggN954Y4YOHVqlqQAAAAAAAFgbjy5cRVNTU4444ogccsgh6du3b2pqavLUU0/lpz/9af7yl79UezwAAAAAAABWYUfXKk466aScdNJJK79++umnc9555+XWW2/Nq6++moceeqjN1x40aFBqa3VFAAAAAACAFStWrPz7kUcemTFjxrTpOkLX29hnn30yfPjwDBgwIKNGjcrIkSMzZMiQNl1r6tSp7TwdAAAAAABA+aZPn97mtULXevTs2TNHH3107rjjjowdO3aDQlePHj3S3NycI488MjNmzEhNTc0mnBQAAAAAAKAMlUollUolyV9fLdVWQlcrLFu2LEmyfPnyDVpXU1OT+vr6Nm+3AwAAAAAAYN28NGo95syZk/vvvz9Jsu+++1Z3GAAAAAAAAFbq9KFr9OjR+dKXvpQJEyascWzMmDH54Ac/mLlz52afffbJ+9///ipMCAAAAAAAwNrUVN58AOIWYNSoUTnppJNWfr1gwYIsXLgw3bt3T0NDw8rP77zzzhxxxBFJkj/+8Y859thjkyR9+vTJzjvvnC5dumTy5Ml57bXXkiR77LFHfvOb32TAgAEd+N0AAAAAAADwdraod3QtXbo0s2fPXuPzxYsXZ/Hixaud96b3vOc9ueaaa/KHP/whzzzzTF588cUsWrQo22+/fYYMGZJTTjklZ511VrbaaqsO+R4AAAAAAABonS1qRxcAAAAAAACdR6d/RxcAAAAAAABlEroAAAAAAAAoktAFAAAAAABAkYQuAAAAAAAAiiR0AQAAAAAAUCShCwAAAAAAgCIJXQAAAAAAABRJ6AIAAAAAAKBIQhcAAAAAAABFEroAAAAAAAAoktAFAAAAAABAkYQuAAAAAAAAiiR0AQAAAAAAUCShCwAAAAAAgCIJXQAAAAAAABRJ6AIAAAAAAKBIQhcAAAAAAABFEroAAAAAAAAoktAFAAAAAABAkYQuAAAAAAAAiiR0AQAAAAAAUCShCwAAAAAAgCIJXQAAAAAAABRJ6AIAAAAAAKBIQhcAAAAAAABFEroAAAAAAAAoktAFAAAAAABAkYQuAAAAAAAAiiR0AQAAAAAAUCShCwAAAAAAgCIJXQAAAAAAABRJ6AIAAAAAAKBIQhcAAAAAAABFEroAAAAAAAAoktAFAAAAAABAkYQuAAAAAAAAiiR0AQAAAAAAUCShCwAAAAAAgCIJXQAAAAAAABRJ6AIAAAAAAKBIQhcAAAAAAABFEroAAAAAAAAoktAFAAAAAABAkYQuAAAAAAAAiiR0AQAAAAAAUCShCwAAAAAAgCIJXQAAAAAAABRJ6AIAAAAAAKBIQhcAAAAAAABFEroAAAAAAAAoktAFAAAAAABAkYQuAAAAAAAAiiR0AQAAAAAAUCShCwAAAAAAgCIJXQAAAAAAABRJ6AIAAAAAAKBIQhcAAAAAAABFEroAAAAAAAAoktAFAAAAAABAkYQuAAAAAAAAiiR0AQAAAAAAUCShCwAAAAAAgCIJXQAAAAAAABRJ6AIAAAAAAKBIQhcAAAAAAABFEroAAAAAAAAoktAFAAAAAABAkYQuAAAAAAAAiiR0AQAAAAAAUCShCwAAAAAAgCIJXQAAAAAAABRJ6AIAAAAAAKBIQhcAAAAAAABFEroAAAAAAAAoktAFAAAAAABAkYQuAAAAAAAAiiR0AQAAAAAAUCShCwAAAAAAgCIJXQAAAAAAABRJ6AIAAAAAAKBIQhcAAAAAAABFEroAAAAAAAAoktAFAAAAAABAkYQuAAAAAAAAiiR0AQAAAAAAUCShCwAAAAAAgCIJXQAAAAAAABRJ6AIAAAAAAKBIQhcAAAAAAABFEroAAAAAAAAoktAFAAAAAABAkYQuAAAAAAAAiiR0AQAAAAAAUCShCwAAAAAAgCIJXQAAAAAAABRJ6AIAAAAAAKBIQhcAAAAAAABFEroAAAAAAAAoUl21B4C1qVQqWbZwcbXH2CB1W3dPTU1NtccAAAAAAIBOQ+his7Rs4eL898BPVXuMDXL6xJ+ka4+tqj0GAAAAAAB0Gh5dCAAAAAAAQJGELgAAAAAAAIokdAEAAAAAAFAkoQsAAAAAAIAi1VV7ADatGbMX5k/Pzcqfnp+VqTMXZsnS5enWtUuadtw6BwzunQP27p0+O2xd7THZRCqVSl6aMj9/em52xjw/O6/PW5xly1dkq+51Gdi/Zw58Z+/su9cOaejRtdqjAgAAAADABhO6tkDNC5bmp/dMzHW3PZ8nx81Z7/n77rV9zv3Y4Jx24kDBYwsxZXpLfnDHC7nxFy9kyowFb3tubW1NjjusXz738cE58b3906WLjZ4AAAAAAJShplKpVKo9BO1j+fIV+fYtz+TyG5/MvOalG7y+V0PXXPyZ9+RfztwndXXVjR1LFyzKfw/8VFVn2FCnT/xJuvbYqqozzJ23OP/y7cdyy13js3z5hv+nvUvfhvzfCw/NR47dZRNMBwAAAAAA7Uvo2kKMe2luhl3yQP7f0zM3+lqH7LNjbr7sqAwesO3GD9ZGbQ1djYe9Myf84surX6tlYeZNmpqJtz+Q52+6J5XlK9przNVUO3Td8+Cfc/aXH8pr69nB1RqfGjow11x4WLbfpns7TAYAAAAAAJuGRxduAUY+OiUn/9PItCxc1i7X+39Pz8xBn7wzv7pmSIYc2q9drtnRJv3iwUz+/RNJTU223nHb7P7Ro3Pwl4dlm0H98sj5N1R7vHb3jR8+lQuvfrzdrveTX0/Mo0/NzMjvn5Bd+vZst+sCAAAAAEB78jKewt336Gv50Hkj2i1yvall4bJ86LwRue/R19r1uh1l9tMvZdIdD2bS7Q/k2evuyvAPXZyWKbOyx2nvT/cdelV7vHZ15U1j2zVyvWnCq/Ny1N8Nz5+nNbf7tQEAAAAAoD0IXQUb/8pfctI/3ZslSzfNo/iWLF2Rk/7p3kx4dd4muX5HWrZwcWY+MT41tbXptctO1R6n3fzPiJdy0TWjN9n1X53akhM/NyKLFrdvSAUAAAAAgPYgdK1ixIgROeGEE7LDDjukR48e2WefffK1r30tS5YsqfZoa1ixopKzvvTgBu/kevzWj+TP934ij9/6kVad37JwWc760gNZsaL8V7n13PWvgWvx3C1jh9L02Qtz7ldHbdCaDf35J8kzE17Pl68fs6HjAQAAAADAJid0veHb3/52jj/++Pzud79Lz549s+eee2bcuHG5+OKLc+yxx2bhwoXVHnE13/3ps3lozPQNXtfYu0f671Sfxt49Wr3mwSem59pbn9vge1VT3dbd0n37num+Q69su9c7csgVn8kO+wzIzCfGZ96kqdUer12cd/nDmT138QatacvPP0m+cfPTefyZmRu0BgAAAAAANjWhK8ljjz2W888/PzU1NfnRj36Ul19+OWPGjMm4ceOy++675+GHH85FF11U7TFXWrxkeS7/wdgOvedXv/9kFi9Z3qH33Bj7XfCJfPLZm/PJZ36Yk//wnQz+uxPy8vBH8/thX6/2aO3iqRfn5I6RL3fY/VasqOQrdnUBAAAAALCZEbqSXHbZZalUKvm7v/u7fPrTn175+cCBA3PTTTclSa677rrMmDGjWiOu5vZ7X8rM1xd16D1nvr4od9z7cofec2O88F8j8ruPfTn3nn55Rl/2X1k0Z37qm3bI8sX/+xjKo6/75xx9wxdXW9dt24Z87MkfZMCp7+3okTfI937+fIffc/iDf87LU+Z3+H0BAAAAAGBdOn3omj9/fkaMGJEkOfvss9c4ftRRR2WPPfbIkiVLctddd3X0eGt1/W3jqnLf627r+LjSVvMmTcvUB5/OlN+PyTPfuzP3ffrK9N53YA77+j+sPOeRi36QPgftmd1OPmLlZ4de8ZnMeGxcJv3iwWqM3SrzW5bkJ7+e0OH3rVSS79/+QoffFwAAAAAA1qXTh64xY8ZkyZIl6d69ew488MC1nnPkkUcmSR599NGOHG2tFixclofHVmdn2SNPzciChcuqcu+NNXP0C5l4+wPZ7eQjsuOBeyZJlsxtzsP/cl0Oufwz2Xqn7bLLhw5N4+HvzCMX3lDlad/eY0/PSkuVfg6/f+y1qtwXAAAAAADWptOHrhdffDFJsssuu6Surm6t5wwcOHC1c6tp7Iuzs2JFpSr3Xr68krEvzq7KvdvD2Ktuz4ply7Pf+R9f+dmUPzyZl+9+OEdd+/kceuXZefhfrsvi15urOOX6jX5uZtXu/eQLc7J06Yqq3R8AAAAAAFbV6UPX66+/niTZbrvt1nnOm8fePLe1KpVKWlpa0tLSkkqlfeLUE89XNzT96blyQ9f8l6flpTtHpe9R706fQwav/Hz0l3+cnrs1Zsrvx2TyfU9UccLWqebvwOIly/PcpA377wAAAAAAADaVtW9h6kQWLVqUJOnWrds6z+nevXuSZOHChRt07QULFqShoSFJ0tTUlNraje+K87Y+Ntn6mLUee/zWj6Sxd4+3Xd/Ye+uV//vnez+xzvOmzVqQgz655jvJLv7S13Ll+X9o/cBt1LVSm0tzcLtf96lr7shuJx+R/c7/eH73t/+RJFm2cHGaX5mR159/daOuvcegPbK0ZtPvdprZc1jSdbe1Hlvf70Brf/7Jun8H3n/8Kdlq2aTWDwwAAAAAAG+jsbExo0ePbtPaTh+6ttpqqyTJkiVL1nnO4sWLkyRbb711m+8zderUNq9dzU4Lk3WM0di7R/rvVN+qy9R1qW31uauaP39B5k+fssHrNlS3mi7JThu+btojz+ZHTX+7zuN/GT8lP+7/8XUe3xivTX0tSyrLN8m1VzNgedJ17Yda+zvQ1p9/ksyeMzeZv+l/BwAAAAAAYH06fehqzWMJW/N4w/Vpvx1dW2f+Oo5Nm7Vgvesbe2+dui61WbZ8RabNWvcOtXVdq2fPrdOrrl9rRt0oXSu1SWGvgurb1LdjdnR1q826suz6fgda+/N/u2vtsP022arXpv8dAAAAAACgc2hsbGzz2k4fuvbYY48kySuvvJJly5alrm7Nf5KJEyeudm5bjB8/PvX1bdtBs6ob73ghZ3/5obUeW9tj5t7qz/d+Iv13qs+0WQuz8wd+tsH3/86V/57P/M1PNnjdhlq6YFH+e+CnNvl92tOL419M1x5bbfL7nHnx/fmvX09Y67H1/Q5s7M8/SUb94e7sudu2bVoLAAAAAADtaeO3GBVuv/32S7du3bJ48eJ1Pv/xoYf+GpYOOeSQjhxtrQ7Ye4dOff9N5bd/c2mevX79oXBzUM2fQc/6rhm0yzZVuz8AAAAAAKyq04eunj175gMf+ECS5Ac/+MEaxx944IG8+OKL6datW0466aSOHm8N79x9u3TrWp0fW7eutXnn7m1/fCPt44C9e1ft3vvttUNqa2uqdn8AAAAAAFhVpw9dSXLJJZekpqYmN998c2655ZaVn0+cODF///d/nyT5h3/4h/Tp06daI67UrWuXDDm0b1Xu/YHD+qVb1y5VuTf/66B37Zje2236RySuzYnv7V+V+wIAAAAAwNoIXUkOPfTQXHnllalUKhk2bFh23XXX7Lffftlrr70yYcKEHHLIIbnyyiurPeZKn/v44E51X1bXvVuX/P0pbX9fXFt161qbs07u+PsCAAAAAMC6CF1vuOCCC/Lb3/42H/jAB/KXv/wl48aNyx577JHLL788999/f3r06FHtEVc64Yj+2a1fzw695279euaEI+zm2Vyc89G9UtPBTxD82PG7Zcftt+7YmwIAAAAAwNuoq/YAm5Pjjz8+xx9/fLXHWK8uXWpz5RcOzMfP/0OH3fPr/3yQdzNtRnbt1zPnfWLvXHvrcx1yvx5b1eU/zt2/Q+4FAAAAAACtZUdXoT52/ID87Qd27ZB7ffS43fLR43brkHttiJ67NebEuy7PKQ/93wz9zZXZdo81d5w19N8xJ9zx5Zz2wi35yL3fXOP4oE++L6eO+m5OfeTaHP6tc1JTt+Y7yI7/n0tz2rhb1vi82q78pwMzoH/H7Oy78gsHZuDOvTrkXgAAAAAA0FpCV8H+8+LD07fPhj1ScdqsBZk8vSXTZi1o1fl9+/TIf158WFvG2+QO/8Y/5MWf3JtfHvn5PH3tr3LkNf+4xjlLmhfmia/fmgc+d80axxp27pP9LvhEfnPyv+cXh/1jtuq9Tfb81AdWO2fvfxia+a9M32Tfw8ao79E1P7rsqNTVtX6n3Yb+/JNkyKF9c94n9m7LiAAAAAAAsEkJXQXrs8PWGXH9Cdlh2+6tXnPQJ+/Kzh/4WQ765F3rPXeHbbtnxPUnbJbvZdpqh17Z4T0DM/GOB5Ikrwx/NPV9d0jPXRtXO2/J3ObMeGxcli1YvMY1dhl6aP48YnQWzpybJHnhxyOy2ylHrDy+7R79844TDs7T3/3lpvtGNtJ7D2jMT644ptWPldyQn3+SHPjO3rnjO+/32EoAAAAAADZLQlfh3rn7dnng5g+l3wbu7Fqffn165IGbP5R37r5du163vdT3652F019PZfmKlZ81T5mV+n69W32Nhn690zx55v+unzxz5fqaui45/Fvn5pELbljtHpujj58wIP/zrfele7c1H7u4MY46oDEjv//B9Gro1q7XBQAAAACA9iJ0bQH2Hrhdnrrj1Jz+oYHtcr3TPzQwT91xavYeuHlGro6w7798NK/c8//yl/FTqj1Kq5w6ZNf86Wcn5aB3tT70rUvXutp89R8PyMjvfzDb9BS5AAAAAADYfAldW4jtt+men3ztmPzqmiHZe+C2bbrG3gO3za+uGZKffO2YbL9N6x+HWA0tU2Zl6522S02X//0VbujXOy1TZrX6Gs1TZqWh/47/u77/jivXNx72zgz++w/mbx/7Xj5451fTtefW+dvHvpfuO/Rqv2+inb1z9+3y8I8/nG/880Hps/1WbbrGkEP75k8/Oyn/32f3Tdeu/u8BAAAAAIDNW121B6B9nXTsLvnIMe/IA3+alu/9/Pnc+8iUvD5vyTrP365Xt3zgsH753McH56gDGlNTU8a7mBbNnpc5T7+UgX9zVCbc9sfs8qFD0zJ1Tua/PK3V13hl+KM58c6v5slv3ZaFM+dmzzOPy0u/GpUk+c3J/77yvIb+O+YjI7+V2w/+XLt/H+2trq425//du/NPn3pnfjHy5Xz/9hfyyFMzsmjx8nWu2bmxPn8zZNec89G9sudu23bcsAAAAAAAsJFqKpVKpdpDbKlaWlrS0NCQJGlubk59fX2Hz1CpVPLylOb86blZmTprQS659k+Z17w02/fqltE/Ozm79mvYLOPW0gWL8t8DP/W25/Qa2DdHXn1eum/XM0ubF+ahL/xn5o57NYd/65z8ecTo/HnE6HTZultOfei76dK9Ll179siiWfMy8Y7788QVP02SDDp9SPb5x5OTJNMefjaPXPj9VJatHoXeDF0/3evTbzvP6RN/kq492raTalNatmxFnp80N2PGzc7nr3wkf2lemm0auuZn33hf9h+8Q/rssHW1RwQAAAAAgDYRujahzSF0vVX/IbdmyowF6denRyaP/GS1x1mn1oSuzc3mGrpWVcrPHwAAAAAAWsNLeAAAAAAAACiS0AUAAAAAAECRhC4AAAAAAACKJHQBAAAAAABQpLpqDwBrU7d195w+8SfVHmOD1G3dvdojAAAAAABApyJ0sVmqqalJ1x5bVXsMAAAAAABgM+bRhQAAAAAAABRJ6AIAAAAAAKBIQhcAAAAAAABFEroAAAAAAAAoktAFAAAAAABAkYQuAAAAAAAAiiR0AQAAAAAAUCShCwAAAAAAgCIJXQAAAAAAABRJ6AIAAAAAAKBIQhcAAAAAAABFEroAAAAAAAAoktAFAAAAAABAkYQuAAAAAAAAiiR0AQAAAAAAUCShCwAAAAAAgCIJXQAAAAAAABRJ6AIAAAAAAKBIQhcAAAAAAABFEroAAAAAAAAoktAFAAAAAABAkYQuAAAAAAAAiiR0AQAAAAAAUCShCwAAAAAAgCIJXQAAAAAAABRJ6AIAAAAAAKBIQhcAAAAAAABFEroAAAAAAAAoktAFAAAAAABAkYQuAAAAAAAAiiR0AQAAAAAAUCSh6w0vv/xybrrpppxzzjk54IAD0q1bt9TU1GTYsGHVHg0AAAAAAIC1qKv2AJuLq6++Otdcc021xwAAAAAAAKCVhK439O7dOyeeeGIOOuigHHjggfnNb36T733ve9Ueq92MfnZm/vj4tMxrXpIkWbJ0eZUnAgAAAAAA2DhC1xsuueSS1b5+9NFHqzRJ+/qfES/lmz96Ko8/M2u1z2e+vjgHn3Znzh/27nz0uN2qNB0AAAAAAEDbeUfXFqpSqeSS747Ox/7192tErjc9/sysfOxff59/v/ZPHTwdAAAAAADAxhO6tlDX3vpcLv/B2Fad+9XvP5nv/vTZTTwRAAAAAABA+xK6tkALFi7Ll/7ziQ1ac+n3nsiChcs20UQAAAAAAADtT+jaAv3st5Myd/6SDVrz+rwl+fnvJm2iiQAAAAAAANqf0LUFuq2NwernvxW6AAAAAACActRVe4DOYtCgQamt7ZiuOKPXPyR1fTd43e8feCz9+39mE0zE5mLqtl9MarfJ1GlT079//2qPAwAAAAAAaWxszOjRo9u0VujqIFOnTu24m221sE0/2aWLF2bKlCntPw+bj57Lk9pkxfLlftYAAAAAABRP6OogTU1NHbaj6/Uu87KgDet61M3Pdv36tfs8bD6mdumSFUlqu3RJk581AAAAAACbgcbGxjavFbo6yPjx41NfX98h93pk7PQcfsavN3jdfbd9KYe+59pNMBGbi/5Dbs2UGQvS1NiUyc9MrvY4AAAAAACwUTpmixEd6tB398l+e+2wQWv2H7xDDnn3jptoIgAAAAAAgPYndG2Bampq8l9XHJ1te3Zr1fnb9uyW/7ri6NTU1GziyQAAAAAAANqP0PWGUaNGpXfv3iv/fOc730mS/OxnP1vt81GjRlV50tZ55+7b5Q83nZi+fXq87Xl9+/TIH246MXsP3K6DJgMAAAAAAGgf3tH1hqVLl2b27NlrfL548eIsXrx4tfNKse9eO+TFu/42P71nYv7z589n7AtzVh57z57b57yPD85pJw5MfY+uVZwSAAAAAACgbWoqlUql2kNsqVpaWtLQ0JAkaW5uTn19fdVmqVQqmde8NPNblqZnfdf0aujqUYWdUP8ht2bKjAXp16dHJo/8ZLXHAQAAAACAjWJHVydRU1OTbXp2yzatfG8XAAAAAADA5s47ugAAAAAAACiS0AUAAAAAAECRhC4AAAAAAACKJHQBAAAAAABQJKELAAAAAACAIgldAAAAAAAAFEnoAgAAAAAAoEhCFwAAAAAAAEUSugAAAAAAACiS0AUAAAAAAECRhC4AAAAAAACKJHQBAAAAAABQJKELAAAAAACAIgldAAAAAAAAFEnoAgAAAAAAoEhCFwAAAAAAAEUSugAAAAAAACiS0AUAAAAAAECRhC4AAAAAAACKJHQBAAAAAABQJKELAAAAAACAIgldAAAAAAAAFEnoAgAAAAAAoEhCFwAAAAAAAEUSugAAAAAAACiS0AUAAAAAAECRhC4AAAAAAACKJHQBAAAAAABQJKELAAAAAACAIgldAAAAAAAAFEnoAgAAAAAAoEhCFwAAAAAAAEUSugAAAAAAACiS0AUAAAAAAECRhC4AAAAAAACKJHQBAAAAAABQJKELAAAAAACAIgldAAAAAAAAFEnoAgAAAAAAoEhCFwAAAAAAAEUSugAAAAAAACiS0AUAAAAAAECRhC4AAAAAAACKJHQBAAAAAABQJKELAAAAAACAIgldAAAAAAAAFEnoSlKpVDJq1KhceOGFOfzww7P99tuna9eu2WmnnTJ06NDcdddd1R4RAAAAAACAt6ir9gCbg9///vcZMmRIkqSmpiYDBw7MgAEDMmHChAwfPjzDhw/PWWedlRtvvDE1NTVVnhYAAAAAAIDEjq4kf93RNWDAgHz3u9/NjBkzMn78+IwePTqzZ8/OVVddlZqamvzwhz/MddddV+1RAQAAAAAAeENNpVKpVHuIaps3b1623nrrdO3ada3HzznnnNxwww15z3vekyeffLLV121paUlDQ0OSpLm5OfX19e0xLrRZ/yG3ZsqMBenXp0cmj/xktccBAAAAAICNYkdXkl69eq0zciXJ8ccfnyR54YUXOmokAAAAAAAA1kPoaoVFixYlSXr06FHlSQAAAAAAAHiT0NUKP//5z5Mk733ve6s8CQAAAAAAAG8SutbjnnvuyZ133pkkueCCC6o8DQAAAAAAAG+qq/YAm7OJEyfmjDPOSJJ8/vOfz+GHH97maw0aNCi1tboi1TV12y8mtdtk6rSp6d+/f7XHAQAAAACANDY2ZvTo0W1aK3Stw7Rp03LCCSdkzpw5Oe644/Ktb31ro643derUdpoMNkLP5UltsmL58kyZMqXa0wAAAAAAwEYRutbizbg1YcKEHHHEEfnlL3+Zrl27btQ1m5qa7Oii6qZ26ZIVSWq7dElTv37VHgcAAAAAANLY2NjmtULXW8ybNy8nnHBCnn766ey///4ZPnx4evTosdHXHT9+fOrr69thQmi7/kNuzZQZC9LU2JTJz0yu9jgAAAAAALBRbDFaxYIFCzJ06NA8/vjjGTx4cH73u99lm222qfZYAAAAAAAArIXQ9YYlS5bklFNOyYMPPpiBAwdm5MiR6d27d7XHAgAAAAAAYB2EriTLly/PaaedlhEjRqR///4ZOXJk+vbtW+2xAAAAAAAAeBve0ZXktttuyx133JEk6datWz71qU+t89zbb799o16KBgAAAAAAQPsQupIsXrx45d8nTZqUSZMmrfPcRYsWdcRIAAAAAAAArIdHFyYZNmxYKpVKq/7suuuu1R4XAAAAAACACF0AAAAAAAAUSugCAAAAAACgSEIXAAAAAAAARRK6AAAAAAAAKJLQBQAAAAAAQJGELgAAAAAAAIokdAEAAAAAAFAkoQsAAAAAAIAiCV0AAAAAAAAUSegCAAAAAACgSEIXAAAAAAAARRK6AAAAAAAAKJLQBQAAAAAAQJGELgAAAAAAAIokdAEAAAAAAFAkoQsAAAAAAIAiCV0AAAAAAAAUSegCAAAAAACgSEIXAAAAAAAARRK6AAAAAAAAKJLQBQAAAAAAQJGELgAAAAAAAIokdAEAAAAAAFAkoQsAAAAAAIAiCV0AAAAAAAAUSegCAAAAAACgSEIXAAAAAAAARRK6AAAAAAAAKJLQBQAAAAAAQJGELgAAAAAAAIokdAEAAAAAAFAkoQsAAAAAAIAiCV0AAAAAAAAUSegCAAAAAACgSEIXAAAAAAAARRK6AAAAAAAAKJLQBQAAAAAAQJGELgAAAAAAAIokdAEAAAAAAFAkoQsAAAAAAIAiCV0AAAAAAAAUSegCAAAAAACgSEIXAAAAAAAARRK6AAAAAAAAKJLQBQAAAAAAQJGELgAAAAAAAIokdCW56667cu655+bggw9Ov3790r179/Ts2TP77rtvLr744syaNavaIwIAAAAAAPAWNZVKpVLtIartmGOOyf33359u3bqlb9++6d27d2bMmJE///nPqVQq2XHHHTNixIjsu+++G3TdlpaWNDQ0JEmam5tTX1+/CaaH1us/5NZMmbEg/fr0yOSRn6z2OAAAAAAAsFHs6Epy1lln5b777sv8+fPz0ksv5fHHH88rr7ySsWPH5l3veldmzpyZ0047rdpjAgAAAAAAsAqhK8mZZ56Z973vfenWrdtqn++zzz656aabkiTPP/98nn/++WqMBwAAAAAAwFoIXesxePDglX9fsGBBFScBAAAAAABgVULXeowaNSpJUl9fnz333LPK0wAAAAAAAPCmumoPsDlasWJFpk+fnnvvvTcXXHBBkuSKK65IQ0NDlScDAAAAAADgTULXKq6//vqce+65q312wAEH5MYbb8zQoUOrNBUAAAAAAABr49GFq2hqasoRRxyRQw45JH379k1NTU2eeuqp/PSnP81f/vKXao8HAAAAAADAKmoqlUql2kNsrp5++umcd955efDBB3PEEUfkoYce2qD1LS0tKx932NTUlNpaXZHqmrrtF7OidpvUrvhLmuZ+p9rjAAAAAABAGhsbM3r06DatFbrWY/78+RkwYEBmzZqVe++9N0OGDGn12lVDF2wW9vpG0nX7ZOmcZNwF1Z4GAAAAAADSr1+/TJ48uU1rvaNrPXr27Jmjjz46d9xxR8aOHbtBoWtVdnSxOZjapUtWJKnt0iVN/fpVexwAAAAAAEhjY2Ob1wpdrbBs2bIkyfLly9t8jfHjx6e+vr69RoI26T/k1kyZsSBNjU2Z/Ezb6jgAAAAAAGwubDFajzlz5uT+++9Pkuy7777VHQYAAAAAAICVOn3oGj16dL70pS9lwoQJaxwbM2ZMPvjBD2bu3LnZZ5998v73v78KEwIAAAAAALA2nf7Rhc3Nzbnsssty2WWXpU+fPtl5553TpUuXTJ48Oa+99lqSZI899sivfvWrdOnSpcrTAgAAAAAA8KZOH7re85735Jprrskf/vCHPPPMM3nxxRezaNGibL/99hkyZEhOOeWUnHXWWdlqq62qPSoAAAAAAACrqKlUKpVqD7GlamlpSUNDQ5K/7hyrr6+v8kR0dv2H3JopMxakX58emTzyk9UeBwAAAAAANkqnf0cXAAAAAAAAZRK6AAAAAAAAKJLQBQAAAAAAQJGELgAAAAAAAIokdAEAAAAAAFAkoQsAAAAAAIAiCV0AAAAAAAAUSegCAAAAAACgSEIXAAAAAAAARRK6AAAAAAAAKJLQBQAAAAAAQJGELgAAAAAAAIokdAEAAAAAAFAkoQsAAAAAAIAiCV0AAAAAAAAUSegCAAAAAACgSEIXAAAAAAAARRK6AAAAAAAAKJLQBQAAAAAAQJGELgAAAAAAAIokdAEAAAAAAFAkoQsAAAAAAIAiCV0AAAAAAAAUSegCAAAAAACgSEIXAAAAAAAARRK6AAAAAAAAKJLQBQAAAAAAQJGELgAAAAAAAIokdAEAAAAAAFAkoQsAAAAAAIAiCV0AAAAAAAAUSegCAAAAAACgSEIXAAAAAAAARRK6AAAAAAAAKJLQBQAAAAAAQJGELgAAAAAAAIokdAEAAAAAAFAkoQsAAAAAAIAiCV0AAAAAAAAUSegCAAAAAACgSEIXAAAAAAAARRK6AAAAAAAAKJLQBQAAAAAAQJGELgAAAAAAAIokdAEAAAAAAFAkoQsAAAAAAIAiCV3r8IMf/CA1NTWpqanJMcccU+1xAAAAAAAAeAuhay2mTZuWCy64oNpjAAAAAAAA8DaErrX4P//n/2TevHkZOnRotUcBAAAAAABgHYSut7jrrrty++2357zzzssBBxxQ7XEAAAAAAABYB6FrFfPnz895552Xvn375qtf/Wq1xwEAAAAAAOBt1FV7gM3JRRddlMmTJ+e2225Lr169qj0OAAAAAAAAb8OOrjc88sgjue666/LBD34wH/3oR6s9DgAAAAAAAOshdCVZunRpzj777HTv3j3XXntttccBAAAAAACgFTy6MMmVV16ZZ599NpdffnkGDBhQ7XEAAAAAAABohU4ful544YVcfvnlGTx4cM4///xNdp9BgwalttYGOqpr6rZfTGq3ydRpU9O/f/9qjwMAAAAAAGlsbMzo0aPbtLbTh65zzz03ixcvzvXXX5+uXbtusvtMnTp1k10bWq3n8qQ2WbF8eaZMmVLtaQAAAAAAYKN0+tD1xBNPpLa2Nh/72MfWONbc3Jwkefjhh9PY2JgkefHFF9OrV68Nvk9TU5MdXVTd1C5dsiJJbZcuaerXr9rjAAAAAADAygbTFp0+dCXJihUrMn369HUeX7p06crjK1asaNM9xo8fn/r6+jathfbSf8itmTJjQZoamzL5mcnVHgcAAAAAADZKp99iNHfu3FQqlbX+ufTSS5MkRx999MrPtt122+oODAAAAAAAQBKhCwAAAAAAgEIJXQAAAAAAABRJ6AIAAAAAAKBIQtfb+I//+I9UKpX88Y9/rPYoAAAAAAAAvIXQBQAAAAAAQJGELgAAAAAAAIokdAEAAAAAAFAkoQsAAAAAAIAiCV0AAAAAAAAUSegCAAAAAACgSEIXAAAAAAAARRK6AAAAAAAAKJLQBQAAAAAAQJGELgAAAAAAAIokdAEAAAAAAFAkoQsAAAAAAIAiCV0AAAAAAAAUSegCAAAAAACgSEIXAAAAAAAARRK6AAAAAAAAKJLQBQAAAAAAQJGELgAAAAAAAIokdAEAAAAAAFAkoQsAAAAAAIAiCV0AAAAAAAAUSegCAAAAAACgSEIXAAAAAAAARRK6AAAAAAAAKJLQBQAAAAAAQJGELgAAAAAAAIokdAEAAAAAAFAkoQsAAAAAAIAiCV0AAAAAAAAUSegCAAAAAACgSEIXAAAAAAAARRK6AAAAAAAAKJLQBQAAAAAAQJGELgAAAAAAAIokdAEAAAAAAFAkoQsAAAAAAIAiCV0AAAAAAAAUSegCAAAAAACgSEIXAAAAAAAARRK6AAAAAAAAKJLQBQAAAAAAQJGELgAAAAAAAIokdAEAAAAAAFAkoQsAAAAAAIAiCV0AAAAAAAAUSegCAAAAAACgSEIXAAAAAAAARRK6kgwbNiw1NTVv+2fcuHHVHhMAAAAAAIBV1FV7gM3JoEGD0qdPn7Ue69GjRwdPAwAAAAAAwNsRulZx8cUXZ9iwYdUeAwAAAAAAgFbw6EIAAAAAAACKJHQBAAAAAABQJI8uXMXtt9+eX/3qV5k3b1569+6dQw89NGeccUZ23HHHao8GAAAAAADAWwhdqxg+fPhqX//P//xPvvSlL+X666/Ppz71qSpNBQAAAAAAwNp4dGGSPfbYI1dddVWefPLJzJ07Ny0tLXnggQdy3HHHpaWlJWeeeeYaEQwAAAAAAIDqqqlUKpVqD7G5qlQqOeWUU3LnnXdm9913z4svvpiamppWr29paUlDQ0OSpKmpKbW1uiLVNXXbL2ZF7TapXfGXNM39TrXHAQAAAACANDY2ZvTo0W1aK3StxwsvvJC99torSTJ27Ni8+93vbvXaVUMXbBb2+kbSdftk6Zxk3AXVngYAAAAAANKvX79Mnjy5TWu9o2s99txzz2y//faZM2dOxo8fv0Gha1V2dLE5mNqlS1Ykqe3SJU39+lV7HAAAAAAASGNjY5vXCl2t0LVr1yTJsmXL2nyN8ePHp76+vr1GgjbpP+TWTJmxIE2NTZn8TNvqOAAAAAAAbC5sMVqPmTNnZsaMGUmS/v37V3kaAAAAAAAA3iR0rce3v/3tVCqVbLPNNjnooIOqPQ4AAAAAAABv6PSh6957782//du/ZeLEiat9vmDBgnzlK1/JN77xjSTJRRddlG7dulVjRAAAAAAAANai07+jq6WlJV//+tfz9a9/PU1NTenXr19WrFiR559/PgsXLkySfPazn80FF1xQ5UkBAAAAAABYVacPXQcccEAuueSSPPLII5kwYUKee+65LF++PDvttFMOO+ywnH322Xn/+99f7TEBAAAAAAB4i04funbeeedcdtll1R4DAAAAAACADdTp39EFAAAAAABAmYQuAAAAAAAAiiR0AQAAAAAAUCShCwAAAAAAgCIJXQAAAAAAABRJ6AIAAAAAAKBIQhcAAAAAAABFEroAAAAAAAAoktAFAAAAAABAkYQuAAAAAAAAiiR0AQAAAAAAUCShCwAAAAAAgCIJXQAAAAAAABRJ6AIAAAAAAKBIQhcAAAAAAABFEroAAAAAAAAoktAFAAAAAABAkYQuAAAAAAAAiiR0AQAAAAAAUCShCwAAAAAAgCIJXQAAAAAAABRJ6AIAAAAAAKBIQhcAAAAAAABFEroAAAAAAAAoktAFAAAAAABAkYQuAAAAAAAAiiR0AQAAAAAAUCShCwAAAAAAgCIJXQAAAAAAABRJ6AIAAAAAAKBIQhcAAAAAAABFEroAAAAAAAAoktAFAAAAAABAkYQuAAAAAAAAiiR0AQAAAAAAUCShCwAAAAAAgCIJXQAAAAAAABRJ6AIAAAAAAKBIQhcAAAAAAABFEroAAAAAAAAoktAFAAAAAABAkYQuAAAAAAAAiiR0AQAAAAAAUCShCwAAAAAAgCIJXQAAAAAAABRJ6AIAAAAAAKBIQtdb/OpXv8qHP/zhNDU1pXv37mlqasqxxx6bb37zm9UeDQAAAAAAgFXUVXuAzcWSJUty+umn5/bbb0+SDBgwIDvvvHOmT5+eBx98ME8//XTOP//8Kk8JAAAAAADAm4SuN3zmM5/J7bffnhNOOCHXXnttBg4cuPLY3Llz88ADD1RxOtg4zQuW5tZ7Jmbu/CVJkr80L8noZ2fmwHfuWOXJAAAAAACg7WoqlUql2kNU24gRI3L88cfnkEMOyUMPPZS6uvbpfy0tLWloaEiSNDc3p76+vl2uC63VsmBp/r/v/ik33/li5jUvXeP4we/aMV85b/8cf0T/KkwHAAAAAAAbxzu6klx11VVJkksuuaTdIhdU29x5i3PM39+Ta/772bVGriR57JmZOfG8EbnpFy908HQAAAAAALDxOv2OroULF6ZXr15ZsWJF5s2bl2eeeSY333xzJkyYkIaGhhx66KH5zGc+k969e2/wte3ooloqlUo+8Nnf5r7/91qrzq+trclvrzs+Hzis3yaeDAAAAAAA2k+nD12PPvpoDjvssOy44475l3/5l1x00UV56z/Jtttum1/84hc59thjN+jaQhfVcv/oqTnmrHs2aM0R++2Uh24ZuokmAgAAAACA9tfpH104derUJMnrr7+ef/u3f8uJJ56YZ599NosXL85TTz2V973vfZk7d25OPfXUTJ48ucrTQut87+fPb/CaUWOmZ+wLszfBNAAAAAAAsGl0+tDV0tKSJFm2bFkGDhyYX/7yl9l7773TrVu37LPPPrn77rvT2NiYuXPn5uqrr67usNAKlUolv/r9K21a29Z1AAAAAABQDXXVHqDattpqq5V//8d//Md07dp1teM9evTIueeem0svvTS//e1v861vfatN9xk0aFBqazt9V6QDrEjXLNn+kjat/eZV1+UHl/+mnScCAAAAAIB1a2xszOjRo9u0ttOHru22227l3wcPHrzWc978/KWXXmrzfd58RCJserXJ9m1b2TLv9bRMn9K+4wAAAAAAwCbS6UPXXnvttfLv3bp1W+s5b+76Wr58eZvv09TUZEcXHWb6sulZVrfTBq/brkdzevTrtwkmAgAAAACAtWtsbGzz2k4fuvr165d3vOMdefXVVzNp0qQce+yxa5wzceLEJEn//v3bfJ/x48envr6+zethQ/znz57LP17xyAat2XG7rfLn0cPTvVuXTTQVAAAAAAC0L1uMknzsYx9Lktxyyy1rHKtUKvnRj36UJHnf+97XkWNBm50xdPds07D2HYrr8tm/3VPkAgAAAACgKEJXkvPPPz+9evXKgw8+mMsuu2zlIwqXLVuWCy+8MGPHjk337t3zz//8z1WeFFqnV0O33PatY1PXpaZV5x9zUFP+/R/228RTAQAAAABA+6qpVCqVag+xOfjNb36TU045JYsXL86OO+6Y3XbbLRMnTszs2bNTV1eXm2++OZ/61Kc26JotLS1paGhIkjQ3N3t0IR3u3kem5GP/+vvMnb9kneec8v5d8l+XH536Hl07cDIAAAAAANh4Qtcqnn/++VxxxRW57777MmvWrGy//fY5+uijc+GFF2b//fff4OsJXWwOmhcszU/vmZjrbxuXZya8nqXLVmTbnt1y6pBdc+7H9sqB79yx2iMCAAAAAECbCF2bkNDF5qZSqWTFikq6dPHUUgAAAAAAyldX7QGAjlNTU5MurXxvFwAAAAAAbO5s6wAAAAAAAKBIQhcAAAAAAABFEroAAAAAAAAoktAFAAAAAABAkYQuAAAAAAAAiiR0AQAAAAAAUCShCwAAAAAAgCIJXQAAAAAAABRJ6AIAAAAAAKBIQhcAAAAAAABFEroAAAAAAAAoktAFAAAAAABAkYQuAAAAAAAAiiR0AQAAAAAAUCShCwAAAAAAgCIJXQAAAAAAABRJ6AIAAAAAAKBIQhcAAAAAAABFEroAAAAAAAAoktAFAAAAAABAkYQuAAAAAAAAiiR0AQAAAAAAUCShCwAAAAAAgCIJXQAAAAAAABRJ6AIAAAAAAKBIQhcAAAAAAABFEroAAAAAAAAoktAFAAAAAABAkYQuAAAAAAAAiiR0AQAAAAAAUCShCwAAAAAAgCIJXQAAAAAAABRJ6AIAAAAAAKBIQhcAAAAAAABFEroAAAAAAAAoktAFAAAAAABAkYQuAAAAAAAAiiR0AQAAAAAAUCShCwAAAAAAgCIJXQAAAAAAABRJ6AIAAAAAAKBIQhcAAAAAAABFEroAAAAAAAAoktAFAAAAAABAkYQuAAAAAAAAiiR0AQAAAAAAUKROH7pefvnl1NTUtOrPl7/85WqPCwAAAAAAwBvqqj1AtW211VY54ogj1nl8/vz5eeqpp5Ikhx9+eEeNBQAAAAAAwHp0+tDV2NiYhx56aJ3Hv/GNb+Spp55K//798/73v78DJwMAAAAAAODtdPpHF67Pj3/84yTJGWeckdpa/1wAAAAAAACbC+XmbfzpT3/Ks88+myT59Kc/XeVpAAAAAAAAWJXQ9TZuueWWJMkhhxySPffcs8rTAAAAAAAAsCqhax2WLl2aW2+9NUkybNiw6g4DAAAAAADAGoSudRg+fHhmzZqV7t275+Mf/3i1xwEAAAAAAOAt6qo9wObqxz/+cZLkIx/5SLbbbruNvt6gQYNSW6srAgAAAAAArKqxsTGjR49u01qhay1mz56d4cOHJ2m/xxZOnTq1Xa4DAAAAAADAXwlda3HrrbdmyZIlaWxszPHHH98u12xqarKjCwAAAAAA4C0aGxvbvFboWotbbrklSXL66aenS5cu7XLN8ePHp76+vl2uBQAAAAAAQGKL0Vs899xzK58D2V6PLQQAAAAAAKD9CV1v8eMf/zhJsv/+++dd73pXlacBAAAAAABgXYSuVaxYsSI/+clPkiSf/vSnqzwNAAAAAAAAb0foWsXIkSMzZcqUdO3aNaeddlq1xwEAAAAAAOBtCF2ruOWWW5IkH/rQh9K7d+8qTwMAAAAAAMDbqalUKpVqD7GlamlpSUNDQ5Kkubk59fX1VZ4IAAAAAABgy2FHFwAAAAAAAEUSugAAAAAAACiS0AUAAAAAAECRhC4AAAAAAACKJHQBAAAAAABQJKELAAAAAACAIgldAAAAAAAAFEnoAgAAAAAAoEhCFwAAAAAAAEUSugAAAAAAACiS0AUAAAAAAECRhC4AAAAAAACKJHQBAAAAAABQJKELAAAAAACAIgldAAAAAAAAFEnoAgAAAAAAoEhCFwAAAAAAAEUSugAAAAAAACiS0AUAAAAAAECRhC4AAAAAAACKJHQBAAAAAABQJKELAAAAAACAIgldAAAAAAAAFEnoAgAAAAAAoEhCFwAAAAAAAEUSugAAAAAAACiS0AUAAAAAAECRhC4AAAAAAACKJHQBAAAAAABQJKELAAAAAACAIgldAAAAAAAAFEnoAgAAAAAAoEhCFwAAAAAAAEUSugAAAAAAACiS0AUAAAAAAECRhC4AAAAAAACKJHQBAAAAAABQJKELAAAAAACAIgldAAAAAAAAFEnoAgAAAAAAoEhCFwAAAAAAAEUSugAAAAAAACiS0AUAAAAAAECRhC4AAAAAAACKJHQBAAAAAABQJKELAAAAAACAIgldb5g1a1YuvPDC7LPPPqmvr0/37t2zyy675IwzzsgTTzxR7fEAAAAAAAB4i5pKpVKp9hDV9sILL+SYY47JtGnTUltbm9122y0NDQ2ZOHFimpub06VLl9xyyy05/fTTN+i6LS0taWhoSJI0Nzenvr5+U4wPAAAAAADQKdnRleTcc8/NtGnTsueee+bZZ5/NhAkT8uSTT2batGn57Gc/m+XLl+ecc87JnDlzqj0qAAAAAAAAb+j0O7rmz5+fbbbZJpVKJXfddVc+/OEPr3Z82bJlaWpqyqxZs/LLX/4yJ598cquvbUcXAAAAAADAptPpd3QtXrw4b7a+AQMGrHG8rq4uu+yyS5Jk6dKlHTobAAAAAAAA69bpQ1fv3r3Tr1+/JMnDDz+8xvE5c+Zk3Lhxqa2tzf7779/R4wEAAAAAALAOnT50JckVV1yRmpqanH/++bn55pszffr0tLS0ZNSoURk6dGhaWlryxS9+MQMHDqz2qAAAAAAAALyhrtoDbA7OPPPMbLPNNvnqV7+as846a7Vju+yyS3784x/njDPOqNJ0AAAAAAAArI3QlaRSqWTixImZOXNmamtr8453vCO9evXKhAkT8sorr+SGG27IgQcemMGDB7f5HoMGDUptrQ10AAAAAAAAq2psbMzo0aPbtFboSnLuuefmhhtuyEEHHZQRI0Zkjz32SJIsXLgwl156ab75zW/msMMOy9NPP52dd965TfeYOnVqe44MAAAAAADQ6dVUKpVKtYeoprFjx2a//fZLXV1dxo8fn1122WWNc4YMGZL77rsv55xzTq677rpWX7ulpSUNDQ1JkqamJju6AAAAAAAA3sKOro0watSoVCqVDBo0aK2RK0mOO+643HfffXn88cfbfJ/x48envr6+zesBAAAAAABYXaffYjR//vxWn7to0aJNOAkAAAAAAAAbotOHrjffxzV+/Pi88soraz1nxIgRSZI999yzw+YCAAAAAADg7XX60HXcccelT58+Wbp0aT760Y/mxRdfXHls4cKFueCCC3LfffclSc4888xqjQkAAAAAAMBb1FQqlUq1h6i2kSNH5uSTT05LS0tqa2uzyy67pGfPnpkwYUIWLFiQJDnvvPNy7bXXbtB1W1pa0tDQkCRpbm72ji4AAAAAAIB2JHS9YdKkSbnqqqsycuTIvPLKK1m2bFl69+6dgw8+OGeffXY+9KEPbfA1hS4AAAAAAIBNR+jahIQuAAAAAACATafTv6MLAAAAAACAMgldAAAAAAAAFEnoAgAAAAAAoEhCFwAAAAAAAEUSugAAAAAAACiS0AUAAAAAAECRhC4AAAAAAACKJHQBAAAAAABQJKELAAAAAACAIgldAAAAAAAAFEnoAgAAAAAAoEhCFwAAAAAAAEUSugAAAAAAACiS0AUAAAAAAECRhC4AAAAAAACKJHQBAAAAAABQJKELAAAAAACAIgldAAAAAAAAFEnoAgAAAAAAoEhCFwAAAAAAAEUSugAAAAAAACiS0AUAAAAAAECRhC4AAAAAAACKJHQBAAAAAABQJKELAAAAAACAIgldAAAAAAAAFEnoAgAAAAAAoEhCFwAAAAAAAEUSugAAAAAAACiS0AUAAAAAAECRhC4AAAAAAACKJHQBAAAAAABQJKELAAAAAACAIgldAAAAAAAAFEnoAgAAAAAAoEhCFwAAAAAAAEUSugAAAAAAACiS0AUAAAAAAECRhC4AAAAAAACKJHQBAAAAAABQJKELAAAAAACAIgldAAAAAAAAFEnoAgAAAAAAoEhCFwAAAAAAAEUSugAAAAAAACiS0AUAAAAAAECRhK43zJw5MxdccEEGDx6crbfeOtttt12OOuqo/PSnP632aAAAAAAAAKxFTaVSqVR7iGp7/vnnM2TIkLz22mvp2rVr3vWud2XRokUZN25cKpVKzjrrrNx0000bfN2WlpY0NDQkSZqbm1NfX9/eowMAAAAAAHRanX5H1/Lly/M3f/M3ee2113LkkUfm1VdfzRNPPJHnnnsuY8eOzTve8Y788Ic/zA9+8INqjwoAAAAAAMAqOv2Orrvvvjsf+chH0r1794wbNy677rrrasd//etf58Mf/nD69u2bV199NV26dGn1te3oAgAAAAAA2HQ6/Y6uhx56KEly4IEHrhG5kmTo0KGpr6/Pa6+9lgcffLCDpwMAAAAAAGBdOn3omjNnTpKkX79+6zznzWMPP/xwh8wEAAAAAADA+nX60LXtttsmSaZMmbLOc9489sILL3TESAAAAAAAALRCpw9dBx10UJJk9OjReeWVV9Y4fs8996SlpSVJ8vrrr3fobAAAAAAAAKxbpw9dJ510Uvr375/FixfnE5/4RP785z+vPPb444/nnHPOWfn1ggULqjEiAAAAAAAAa1FX7QGqrXv37rntttvywQ9+MI8++mh22223DBo0KIsWLcrLL7+cHXbYIaeeemp+8YtfpGfPnm2+z6BBg1Jb2+m7IgAAAAAAwGoaGxszevToNq3t9KErSQ477LCMGTMmV155ZX73u99l0qRJ2W677TJs2LB85StfyRVXXJHkr//QbTV16tT2GhcAAAAAAIAIXSvttttuueGGG9Z67Nlnn02SHHjggW2+flNTkx1dAAAAAAAAb7ExG41qKpVKpR1n2eLMmjUrTU1NSZJXX3115d9bo6WlJQ0NDUmS5ubm1NfXb5IZAQAAAAAAOiNbjNbjkksuybJly/Lxj398gyIXAAAAAAAAm5bQleSee+7JqFGjVvts7ty5+cIXvpAbbrghO+64Y7797W9XaToAAAAAAADWxju6kowYMSLXXHNNevXqlV133TVJMm7cuCxZsiT9+vXLb37zm+y0007VHRIAAAAAAIDVCF1JTj755EyfPj2PPfZYxo8fn7q6uuy999459dRT84UvfCE9e/as9ogAAAAAAAC8RU2lUqlUe4gtVUtLSxoaGpIkzc3Nqa+vr/JEAAAAAAAAWw7v6AIAAAAAAKBIQhcAAAAAAABFEroAAAAAAAAoktAFAAAAAABAkYQuAAAAAAAAiiR0AQAAAAAAUCShCwAAAAAAgCIJXQAAAAAAABRJ6AIAAAAAAKBIQhcAAAAAAABFEroAAAAAAAAoktAFAAAAAABAkYQuAAAAAAAAiiR0AQAAAAAAUCShCwAAAAAAgCIJXQAAAAAAABRJ6AIAAAAAAKBIQhcAAAAAAABFEroAAAAAAAAoktAFAAAAAABAkYQuAAAAAAAAiiR0AQAAAAAAUCShCwAAAAAAgCIJXQAAAAAAABRJ6AIAAAAAAKBIQhcAAAAAAABFEroAAAAAAAAoktAFAAAAAABAkYQuAAAAAAAAiiR0AQAAAAAAUCShCwAAAAAAgCIJXQAAAAAAABRJ6AIAAAAAAKBIQhcAAAAAAABFEroAAAAAAAAoktAFAAAAAABAkYQuAAAAAAAAiiR0AQAAAAAAUCShCwAAAAAAgCIJXQAAAAAAABRJ6AIAAAAAAKBIQhcAAAAAAABFEroAAAAAAAAoktAFAAAAAABAkYQuAAAAAAAAiiR0AQAAAAAAUCShCwAAAAAAgCJtUaHr5Zdfzk033ZRzzjknBxxwQLp165aampoMGzasVetHjBiRE044ITvssEN69OiRffbZJ1/72teyZMmSTTs4AAAAAAAAG6yu2gO0p6uvvjrXXHNNm9Z++9vfzr/+678mSXbZZZe84x3vyDPPPJOLL744v/71rzNy5MhsvfXW7TkuAAAAAAAAG2GL2tHVu3fvnHjiibn00ktz991353Of+1yr1j322GM5//zzU1NTkx/96Ed5+eWXM2bMmIwbNy677757Hn744Vx00UWbeHoAAAAAAAA2xBa1o+uSSy5Z7etHH320Vesuu+yyVCqVnHXWWfn0pz+98vOBAwfmpptuytFHH53rrrsuF198cfr06dOuMwMAAAAAANA2W9SOrraYP39+RowYkSQ5++yz1zh+1FFHZY899siSJUty1113dfR4AAAAAAAArEOnD11jxozJkiVL0r179xx44IFrPefII///9u4vtOr6j+P465hu5maRiG39IZhoBJmWldCKiOyfCKNboxC7yAoiCBRC6q6L6I8S9FeLboqgiBUWlf1vIDgIK6j8U/aHltYqSjdPWvvd/BxbZs617fTZHo+77/d8P9/zPuf2yef7vTjJ0HeIAQAAAAAAMPomfOjatm1bkuSMM87I5Ml//yTH2bNnD7oWAAAAAACA2pvwoevnn39Okpx00klHvObQZ4euBQAAAAAAoPb+fgvTBLJ///4kSV1d3RGvqa+vT5L09vYO+3vmzJmTSZMmfFcEAAAAAAAYpKmpKZ2dncNaO+FD19SpU5Mkv//++xGvqVarSZLjjz9+2N/T1dU17LUAAAAAAAAcbsKHrqE8lnAojzc8mubmZju6AAAAAAAA/qKpqWnYayd86Jo7d26S5KuvvsrBgwczefLhf8nOnTsHXTsc27dvT0NDw7DXAwAAAAAAMNiE32J07rnnpq6uLtVq9YjPf/zggw+SJIsWLRrL0QAAAAAAAPgHEz50TZ8+PVdccUWS5Iknnjjs8/feey/btm1LXV1d2traxno8AAAAAAAAjmDCh64kWbNmTSqVSp566qk8/fTT/ed37tyZG2+8MUly0003ZdasWbUaEQAAAAAAgL+o9PX19dV6iJHS0dExaNdVT09Pent7U19fn8bGxv7z7e3taW1tHbT23nvvzerVq5MkZ5xxRk466aR88sknOXjwYBYtWpS33nor06ZNO6Z59u3b1/+9e/fu9Y4uAAAAAACAETS51gOMpAMHDqS7u/uw89VqNdVqddB1f7Vq1arMnz8/999/f7Zs2ZLdu3dn7ty5ue6663LHHXekvr5+VGcHAAAAAADg2IyrHV3/NXZ0AQAAAAAAjB7v6AIAAAAAAKBIQhcAAAAAAABFEroAAAAAAAAoktAFAAAAAABAkYQuAAAAAAAAiiR0AQAAAAAAUCShCwAAAAAAgCIJXQAAAAAAABRJ6AIAAAAAAKBIQhcAAAAAAABFEroAAAAAAAAoktAFAAAAAABAkYQuAAAAAAAAiiR0AQAAAAAAUCShCwAAAAAAgCIJXQAAAAAAABRJ6AIAAAAAAKBIQhcAAAAAAABFEroAAAAAAAAoktAFAAAAAABAkYQuAAAAAAAAiiR0AQAAAAAAUCShCwAAAAAAgCIJXQAAAAAAABRJ6AIAAAAAAKBIQhcAAAAAAABFEroAAAAAAAAoktAFAAAAAABAkYQuAAAAAAAAiiR0AQAAAAAAUCShCwAAAAAAgCIJXQAAAAAAABRJ6AIAAAAAAKBIQhcAAAAAAABFEroAAAAAAAAoktAFAAAAAABAkYQuAAAAAAAAiiR0AQAAAAAAUCShCwAAAAAAgCIJXQAAAAAAABRJ6AIAAAAAAKBIQhcAAAAAAABFEroAAAAAAAAoktAFAAAAAABAkYQuAAAAAAAAiiR0AQAAAAAAUKRxFbp27dqVDRs2ZOXKlVm4cGHq6upSqVSyfPnyUVkHAAAAAABA7Uyu9QAjae3atVm3bt2YrQMAAAAAAKB2xlXomjlzZpYsWZILLrgg559/fl599dU8/PDDo7YOAAAAAACA2hlXoWvNmjWDjjdv3jyq6wAAAAAAAKidcfWOLgAAAAAAACYOoQsAAAAAAIAiCV0AAAAAAAAUSegCAAAAAACgSEIXAAAAAAAARZpc6wEmijlz5mTSJF0RAAAAAABgoKampnR2dg5rrdA1Rrq6umo9AgAAAAAAwLgidI2R5uZmO7oAAAAAAAD+oqmpadhrha4xsn379jQ0NNR6DAAAAAAAgHHDFiMAAAAAAACKJHQBAAAAAABQpEpfX19frYcYKR0dHWlra+s/7unpSW9vb+rr69PY2Nh/vr29Pa2trf963dHs27evf/3evXs9uhAAAAAAAGAEjat3dB04cCDd3d2Hna9Wq6lWq4OuG4l1AAAAAAAA1M642tH1X2NHFwAAAAAAwOjxji4AAAAAAACKJHQBAAAAAABQJKELAAAAAACAIgldAAAAAAAAFEnoAgAAAAAAoEhCFwAAAAAAAEUSugAAAAAAACiS0AUAAAAAAECRhC4AAAAAAACKJHQBAAAAAABQJKELAAAAAACAIgldAAAAAAAAFEnoAgAAAAAAoEhCFwAAAAAAAEUSugAAAAAAACiS0AUAAAAAAECRhC4AAAAAAACKJHQBAAAAAABQJKELAAAAAACAIgldAAAAAAAAFEnoAgAAAAAAoEhCFwAAAAAAAEUSugAAAAAAACiS0AUAAAAAAECRhC4AAAAAAACKJHQBAAAAAABQJKELAAAAAACAIgldAAAAAAAAFEnoAgAAAAAAoEhCFwAAAAAAAEUSugAAAAAAACiS0AUAAAAAAECRhC4AAAAAAACKJHQBAAAAAABQJKELAAAAAACAIgldAAAAAAAAFEnoAgAAAAAAoEhCFwAAAAAAAEUSugAAAAAAACiS0AUAAAAAAECRhC4AAAAAAACKJHQBAAAAAABQJKELAAAAAACAIgldAAAAAAAAFEnoAgAAAAAAoEhCFwAAAAAAAEUaV6Fr165d2bBhQ1auXJmFCxemrq4ulUoly5cvP+Kavr6+dHR0ZPXq1bnooosyY8aMTJkyJSeffHKWLl2al156aex+AAAAAAAAAEM2udYDjKS1a9dm3bp1x7TmrbfeyuLFi5MklUols2fPTktLS3bs2JGNGzdm48aNWbFiRdavX59KpTIaYwMAAAAAADAM42pH18yZM7NkyZLcfffdefnll3PLLbccdU1fX19aWlry0EMPZc+ePdm+fXs6OzvT3d2dBx98MJVKJU8++WQeeeSRMfgFAAAAAAAADNW42tG1Zs2aQcebN28+6poLL7wwn332WaZMmTLo/HHHHZfbb789n332WR577LE8/vjjQwpnAAAAAAAAjI1xtaNrOE444YTDItdAV111VZLk888/H6uRAAAAAAAAGIIJH7qOZv/+/UmSadOm1XgSAAAAAAAABhK6juK5555LklxyySU1ngQAAAAAAICBhK5/8Morr6S9vT1JsmrVqhpPAwAAAAAAwEBC1xHs3Lkz119/fZLktttuy0UXXVTjiQAAAAAAABhocq0H+C/6/vvvc/XVV+enn37KlVdemfvuu+9f33POnDmZNElXBAAAAAAAGKipqSmdnZ3DWit0/cWhuLVjx460trbmxRdfzJQpU/71fbu6ukZgOgAAAAAAAA4Rugb49ddfc/XVV+fjjz/Oeeedl40bN2batGkjcu/m5mY7ugAAAAAAAP6iqalp2GuFrv/r6enJ0qVLs2XLlpx11ll57bXXcuKJJ47Y/bdv356GhoYRux8AAAAAAMBEZ4tRkt9//z3XXntt3n///cyePTubNm3KzJkzaz0WAAAAAAAA/2DCh64//vgjy5Yty+uvv57TTjstmzZtyimnnFLrsQAAAAAAADiKSl9fX1+thxgpHR0daWtr6z/u6elJb29v6uvr09jY2H++vb09ra2tSZJnn302y5YtS5K0tLSkubn5iPd//vnnj+k5kfv27ev/3r1793p0IQAAAAAAwAgaV+/oOnDgQLq7uw87X61WU61WB1038LNDvvjii3zxxRdHvP/+/ftHaFIAAAAAAAD+rXG1o+u/xo4uAAAAAACA0TPh39EFAAAAAABAmYQuAAAAAAAAiiR0AQAAAAAAUCShCwAAAAAAgCIJXQAAAAAAABRJ6AIAAAAAAKBIQhcAAAAAAABFEroAAAAAAAAoktAFAAAAAABAkYQuAAAAAAAAiiR0AQAAAAAAUCShCwAAAAAAgCIJXQAAAAAAABRJ6AIAAAAAAKBIQhcAAAAAAABFEroAAAAAAAAoktAFAAAAAABAkYQuAAAAAAAAiiR0AQAAAAAAUCShCwAAAAAAgCIJXQAAAAAAABRJ6AIAAAAAAKBIQhcAAAAAAABFEroAAAAAAAAoktAFAAAAAABAkYQuAAAAAAAAiiR0AQAAAAAAUCShCwAAAAAAgCIJXQAAAAAAABRJ6AIAAAAAAKBIQhcAAAAAAABFEroAAAAAAAAoktAFAAAAAABAkYQuAAAAAAAAiiR0AQAAAAAAUCShCwAAAAAAgCIJXQAAAAAAABRJ6AIAAAAAAKBIQhcAAAAAAABFEroAAAAAAAAoktAFAAAAAABAkYQuAAAAAAAAiiR0AQAAAAAAUCShCwAAAAAAgCIJXQAAAAAAABRJ6AIAAAAAAKBIQhcAAAAAAABFGleha9euXdmwYUNWrlyZhQsXpq6uLpVKJcuXL//HdS+99FJuvvnmXHjhhTn11FNTX1+f6dOnZ8GCBbnzzjvz448/js0PAAAAAAAAYMgm13qAkbR27dqsW7fumNc98MADeffdd1NXV5dTTjkl55xzTvbs2ZOPPvooW7duzfr16/P6669nwYIFIz80AAAAAAAAwzKudnTNnDkzS5Ysyd13352XX345t9xyy5DWrVixIm+++WZ+++23fPnll9myZUu++uqrbN26NWeffXZ++OGHLFu2bJSnBwAAAAAA4FiMqx1da9asGXS8efPmIa274YYb/vb8vHnzsmHDhixatCiffvppPv3005x11ln/ek4AAAAAAAD+vXG1o2s0DAxbPT09NZwEAAAAAACAgYSuo+jo6EiSNDQ05Mwzz6zxNAAAAAAAABwyrh5dOFL+/PPP7N69O2+88UZWrVqVJLnnnnvS2NhY48kAAAAAAAA4ROga4NFHH83NN9886NzChQuzfv36LF26tEZTAQAAAAAA8HeErgGam5vT2tqagwcP5ptvvklXV1c++uijPPPMM7nkkkty4oknDvvec+bMyaRJnhQJAAAAAAAwUFNTUzo7O4e1VugaoK2tLW1tbf3HH3/8cW699dY8++yz+frrr/PBBx8M+95dXV0jMSIAAAAAAAD/J3T9g3nz5mXjxo1paWlJR0dHNm3alMWLFw95/bRp07J3795cfPHF2bNnTyqVyihOCwAAAAAAUJ6mpqZhrxW6jmL69Om59NJL88ILL2Tr1q3HFLoqlUoaGhry4YcfjuKEAAAAAAAAE5OXRg3BwYMHkyR//PFHjScBAAAAAADgEKHrKH766ae8++67SZIFCxbUdhgAAAAAAAD6TfjQ1dnZmbvuuis7duw47LMPP/ww11xzTX755ZfMmzcvl19+eQ0mBAAAAAAA4O9U+vr6+mo9xEjp6OhIW1tb/3FPT096e3tTX1+fxsbG/vPt7e1pbW1Nkrzzzju57LLLkiSzZs3K6aefnuOOOy7ffvttvvvuuyTJ3Llz8+qrr6alpWUMfw0AAAAAAAD/ZHKtBxhJBw4cSHd392Hnq9VqqtXqoOsOmT9/ftatW5e33347n3zySbZt25b9+/dnxowZWbx4ca699tqsWLEiU6dOHZPfAAAAAAAAwNCMqx1dAAAAAAAATBwT/h1dAAAAAAAAlEnoAgAAAAAAoEhCFwAAAAAAAEUSugAAAAAAACiS0AUAAAAAAECRhC4AAAAAAACKJHQBAAAAAABQJKELAAAAAACAIgldAAAAAAAAFEnoAgAAAAAAoEhCFwAAAAAAAEUSugAAAAAAACiS0AUAAAAAAECRhC4AAAAAAACKJHQBAAAAAABQJKELAAAAAACAIgldAAAAAAAAFEnoAgAAAAAAoEhCFwAAAAAAAEUSugAAAAAAACiS0AUAAAAAAECRhC4AAAAAAACKJHQBAAAAAABQJKELAAAAAACAIgldAAAAAAAAFEnoAgAAAAAAoEhCFwAAAAAAAEUSugAAAAAAACiS0AUAAAAAAECRhC4AAAAAAACKJHQBAAAAAABQJKELAAAAAACAIgldAAAAAAAAFEnoAgAAAAAAoEhCFwAAAAAAAEUSugAAAAAAACiS0AUAAAAAAECRhC4AAAAAAACKJHQBAAAAAABQJKELAAAAAACAIv0PRT5jhJvmGSsAAAAASUVORK5CYII=\n"
+          },
+          "metadata": {},
+          "execution_count": 23
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "qpixl_lo = QPIXLModule(angles, compression=0)\n",
+        "qpixl_hi = QPIXLModule(angles, compression=80)\n",
+        "\n",
+        "print(\"Uncompressed depth:\", qpixl_lo.get_circuit().depth())\n",
+        "print(\"Compressed depth:\", qpixl_hi.get_circuit().depth())\n"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "K25neBa_Pr2c",
+        "outputId": "5bb6f427-bd23-497b-f124-7faf6522ee4a"
+      },
+      "execution_count": 22,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Uncompressed depth: 32\n",
+            "Compressed depth: 8\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "# Test 4: RGB QPIXL Encoding and Merge\n",
+        "In this test, a color image is processed by separating its Red, Green, and Blue channels, encoding each independently using QPIXL.\n",
+        "\n",
+        "*   The image is resized to 4×4 and split into R, G, B components.\n",
+        "Each channel is scaled to rotation angles and flattened\n",
+        "\n",
+        "*   Separate QPIXL modules are created for each color with compression\n",
+        "*   The modules are combined side-by-side using the merge rule\n",
+        "\n",
+        "\n",
+        "*  This demonstrates how QPIXL and QuantumComposer can support multi-channel data\n",
+        "\n"
+      ],
+      "metadata": {
+        "id": "hmGoWhoS5NWq"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "from PIL import Image\n",
+        "import numpy as np\n",
+        "from qiskit import QuantumCircuit\n",
+        "from QPIXL.qiskit.qpixl_module import QPIXLModule\n",
+        "from QPIXL.qiskit.quantum_composer import QiskitCircuitModule, QuantumComposer\n",
+        "\n",
+        "# Load RGB image and resize\n",
+        "img = Image.open(\"/content/QuantumArtHack/figures/cat.webp\").resize((4, 4)).convert(\"RGB\")\n",
+        "r, g, b = img.split()\n",
+        "\n",
+        "# Convert each channel to angles in [0, π]\n",
+        "r_angles = (np.array(r) / 255.0 * np.pi).flatten()\n",
+        "g_angles = (np.array(g) / 255.0 * np.pi).flatten()\n",
+        "b_angles = (np.array(b) / 255.0 * np.pi).flatten()\n",
+        "\n",
+        "# Create QPIXL modules for each color\n",
+        "r_mod = QPIXLModule(r_angles, compression=10, name=\"RedChannel\")\n",
+        "g_mod = QPIXLModule(g_angles, compression=10, name=\"GreenChannel\")\n",
+        "b_mod = QPIXLModule(b_angles, compression=10, name=\"BlueChannel\")\n",
+        "\n",
+        "# Combine using merge (side-by-side)\n",
+        "composer = QuantumComposer([r_mod, g_mod, b_mod])\n",
+        "rgb_combined = composer.combine(rule=\"merge\")\n",
+        "\n",
+        "# Visualize\n",
+        "rgb_combined.draw(\"mpl\")\n"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 760
+        },
+        "id": "k7Ej0JRm5DV2",
+        "outputId": "1c81e29c-7400-4d47-dfb6-df20b350aa0e"
+      },
+      "execution_count": 21,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "▶ Combining using rule: merge\n",
+            "  ↪ RedChannel\n",
+            "  ↪ GreenChannel\n",
+            "  ↪ BlueChannel\n",
+            "✓ Done in 0.01s\n"
+          ]
+        },
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "<Figure size 2192.32x2290.94 with 1 Axes>"
+            ],
+            "image/png": "iVBORw0KGgoAAAANSUhEUgAABqwAAAb4CAYAAAD6S/JAAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjEsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvc2/+5QAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzs3Xd4FOXax/HfpldqIBA6SBekdwQpAnY8il2wiyh6VLDrsXvsFRHF3sBGEZUiHDpSpUPoNSGE9F523z/ygkGTsLvZ3Wd38/1cV65zzLQ7zD0zzzz3zDMWm81mEwAAAAAAAAAAAGBIgOkAAAAAAAAAAAAAULVRsAIAAAAAAAAAAIBRFKwAAAAAAAAAAABgFAUrAAAAAAAAAAAAGEXBCgAAAAAAAAAAAEZRsAIAAAAAAAAAAIBRFKwAAAAAAAAAAABgFAUrAAAAAAAAAAAAGEXBCgAAAAAAAAAAAEZRsAIAAAAAAAAAAIBRFKwAAAAAAAAAAABgFAUrAAAAAAAAAAAAGEXBCgAAAAAAAAAAAEZRsAIAAAAAAAAAAIBRFKwAAAAAAAAAAABgFAUrAAAAAAAAAAAAGEXBCgAAAAAAAAAAAEZRsAIAAAAAAAAAAIBRFKwAAAAAAAAAAABgFAUrAAAAAAAAAAAAGEXBCgAAAAAAAAAAAEZRsAIAAAAAAAAAAIBRFKwAAAAAAAAAAABgFAUrAAAAAAAAAAAAGEXBCgAAAAAAAAAAAEZRsAIAAAAAAAAAAIBRFKwAAAAAAAAAAABgFAUrAAAAAAAAAAAAGEXBCgAAAAAAAAAAAEZRsAIAAAAAAAAAAIBRFKwAAAAAAAAAAABgFAUrAAAAAAAAAAAAGEXBCgAAAAAAAAAAAEZRsAIAAAAAAAAAAIBRFKwAAAAAAAAAAABgFAUrAAAAAAAAAAAAGEXBCgAAAAAAAAAAAEZRsAIAAAAAAAAAAIBRQaYD8Hc2m01Fufmmw7BbUHioLBaL6TD8gq/t+9LIA9cgByD5Zh6w/13DF/d9aeSBa/hiHrDvURm+mPP24Liwj7/uf4kcqAxfzAv2t/N8cX/bi7xwnq/lBfvadXxt35dGHphBwcrNinLz9VWL602HYbfr9nyp4Igw02H4BV/b96WRB65BDkDyzTxg/7uGL+770sgD1/DFPGDfozJ8MeftwXFhH3/d/xI5UBm+mBfsb+f54v62F3nhPF/LC/a16/javi+NPDCDIQEBAAAAAAAAAABgFAUrAAAAAAAAAAAAGEXBCgAAAAAAAAAAAEZRsAIAAAAAAAAAAIBRQaYDAOxRXGzVzv3pWrctWfEHMpSbV6SAAIuqR4WoY6ta6tqutuLqRpoOE26Ul1+kTfGpWrctWYcSs5VfWKzgoADVrRWmLm1j1LlNbVWPDjEdJtwoLSNf67ef0PrtJ5SclqfCIqtCgwPVJC5KXdvVVoeWtRQaEmg6TLiJzWbT0aQcrduWrE27UpSRVSir1aaI8CC1blpdXdvFqFWT6goIsJgOFW5itdoUfyBd67ed0I79acrJLZLFYlH16GB1aFlLXdvGqEFshCwWcsBf5RcUa/OuFK3bdkIHjmadagvE1AhT5za11aVdbdWsFmo6TLex2Ww6cDRL67Yla8vuVGXlFMlmsykqIljtWtRQ13Yxat4wmmPAjxUVWbVjX5rWbTuhXQfTlZtfrMAAi2pWC9U5rWupa7sYxdYONx0m3Cgnt0gb40vaw4ePZSu/oFghwYGqVztcXdrWVue2tRUdyT2RP0tJz9e6bcnasP2ETqTnqajYptDgQDVrEKWu7WJ0dsuaCgnmnshf2Ww2HUrM1rptydq8K1WZ2YWy2WyKDA9Wm2bV1a19jFo0qsY9kR+rqH/0ZFugfp0I02HCjapC/ygFK3i1tVuPa9K07fpu3n5l5RRWOG+TuCjdMrKVbr28NSdnP1FcbNWcJYc0adp2/b76qIqKbBXO37VdjO68so2uvaCFIsI5vfmDrJxCfTVnjyZ/t11/7kipcN7goAAN7R2ncVe307A+DRQYyEvE/uDIsWx9+MNOfTwjXocSsyucNzoyWFcNa6a7rmqrzm1jPBQh3O3PHSc0adp2TZu7VxlZFbcFGsZG6qbLWur2f7VRw3o8yOIPrFab5i4/rEnTtmvuiiMqLLJWOP85rWvpzivb6LoLW/hNp+2eQxmaPH2HPp+9S0kpeRXOW6t6qK6/sIXGXtVWbZrV8EyAcCubzaaVG5M0adp2/fj7fuXmFVc4f4tG0br18ta6ZWQr1alF8cofFBZaNet/BzRp2nYtXpeo4uLy74ksFqlnhzoaO6qtRg1rprBQ7on8QXpmgb74ebc++G6HtuxOrXDekOAAXdC/ke66qq0G94yjcOEnDhzN1Aff7dSns3Yp4XhOhfPWiA7RNSOa666r2urslrU8FCHcbc2Wk/2j+5SdW1ThvE3jonTL5SX9o/Vi6B/1B8XFVv38//2jC+3oH+3WvqR/9JoRvtk/arHZbBX/haiUwpw8fdXieoeWqde7vYb/+PTp68nOVcbeBO35fom2T/1FtuKKb9addd2eLxUcEeaWdTti3bZkjXt+hf7YfNzhZYOCLLrhorP06gM9Vau6uadsndn3J5nMAcl8HthsNk2fu08T31itgwkVd1CXpUZ0iCbe1FETxnRQUJC5ogU54LyCwmK9NHWTXv1sszKzK+6gLkuzBtF67cEeGjm4qeuDc5CzeVDVrwXHU3L1wKur9fWveyrsmClP386xeu/R3jqndW03RGcfXz4HSObzYHN8isa9sEJL1x9zeNnAQIuuHt5crz/YU3UNv23AOcB5Mxcd0P2v/KG9hzMdXjY6Mlj333C2Hr3tHJ990vxQYpbGv7RKMxcdkDN3bMP7NtS7j/ZWi0bVXB9cBSpz7ivNG86DpZk4Llb8eUx3v7BSG3accHjZkOAA3TKylV66r7uqRXmueOuq/S+RAzabTZ/P2q1H31mro0kVd1CXpXaNUD12WyeNv7ad8Qe5uBY6Jy+/SM9M/lNvf731jB3UZWnVpLrenNhTI/o3ckN05eM84DoJx3N0739X6YcF+2W1Ot4YGNSjvt57rI9XPMRC/6hz1m49rnHPr9TqLc71j46+uKVeeaCH0VEIfPm+2HQe2Gw2Tfttrx56c43T/aMP3dxRD4422z/qKN8rsVUhe39cqsML10sWi8Lr1NBZVw5Qj6fHqHrLBlo54QPT4blFfkGxnpvyp16cutGpDkpJKiqy6ZMZu/TrssOa8mQ/XTywsYuj9JyqmAPHTuTqrudW6Mff9zu9jrTMAj369lr9sGC/Pn22v08/VVQVc+DPHSc05okl2riz4jeqKrLvSKYu//fvunp4c73zSG/F1DTf0HRWVcyBH+bv09jnVuh4asVvElRk+YZj6nbNTD1xe2c9css5Cg72ncZZaVVx/xcWWvXfTzbqmcl/nvFtmvIUF9v01Zw9mrviiCY91kdXnt/MxVF6TlXMgRNpeRr/0ip9/csep9eRmV2opydv0I+/79enz56rLu18561Lm82mqT/G6/5X/3DqoY2Tflt+WB3/9ZNeuq+bxl3dzmefsq+Kx0BuXpEef3ed3vhii1PFSkkqKLTq/ek79POSQ/roP/10fp+Grg3Sg6piDhw5lq3bn1mmX5YednodJ9Lydf8rf+iHBfv18dP91appdRdG6FlVMQf+2JSkm55cqu1705xeR/yBdF0wbp5uHtlKrz3QQzV8eNjcqpYDNltJW3b8SyuVmlHg9HoWrk5Qpytn6NlxXXT/jWcbL147q6rtf6mkf/SZyRv03082Vap/dOpP8fpl2WFNebKvLhpA/6gvOXYiV2OfW66ffj/g9DrSMgv0yFtr9ePv+/XJM+eq/Vk1XRih+/jmmaqKOLF5n/b+sFR7v1+ire/P0pwLH1X2kWS1unawQmt79klJT0jPLNDQ23/Vc1P+dPpkXFpicq4uGT9fT723Xr76ImFVy4Fte1LV5aoZlSpWlbZuW7K6XTNLs/930CXrM6Gq5cAP8/epx7WzKlWsKu3b3/aq69UzFL8/3SXrM6Eq5YDNZtPDb67RFQ8srFSx6qSiIpuemrRew8f+psxs52/0TKpK+18qGQb0gnFz9cS7650uVpWWnJqnUQ8u1IOv/kFbwEfsPpihrlfPrFSxqrTNu1LV6/rZ+m7ePpesz92Kiqy6+cmluu3pZZUqVp2Uk1ek8S+t0lUTFqqgsOKh5LxVVTsGklPzdO5Nc/T6584Xq0o7lJitYXfO1aufbq78ygypajmwfluyOo2aUaliVWnLNxxTl6tm6PdVR12yPhOqWg58PmuX+o7+uVLFqtI+/ilePa6bpQNHHX9j2VtUpRywWm2658WVuuHRxZUqVp2UX1CsiW+s0WX3LlBunuNv6nmDqrT/pZLvdw++7Ve98JHzD/OXlnA8RxffM19Pv0//qK/YsitFnUfNqFSxqrQ1W5LV7ZqZmrPEN/pHKVj5kKLcfB1fv0uWgABVaxJrOhyXyswu0NA7fnVq2J8zeeaDDXrs7XUuX68J/pwD2/emacDNvzg13EVF8guKNfLfCzRrkWtO8qb5cw58P2+fRk1Y5JJO6tIOJmRrwM1ztPtghkvXa4q/5oDNZtMDr/6h/368yeXrXrg6QSPumqfsM3wL0Rf46/6XSj4kf8Fdc7XADR1qr32+Rff9d5XP3qCV5s85sOdQhs69aY4OHM1y6XoLi6y6euIiTfttr0vX62pWq02jH1+iT2fucvm6v5+/X1c+sFCFhZ4bNsld/PkYSEnP16Bbf9HarckuX/eE11frpakbXb5eE/w5B9ZvS9Z5t/6iZBc8uFNadm6RLrx7nk8XrUrz5xz4dGa8Rj++xCWd1KXtOlByjT2U6NprrCn+mgM2m013PLNM73273eXr/nnJIV0yfr7yC3zzAZbS/HX/S1JGVoGG3vGblm9wff/of97foCfepX/U223bk6qBt/xyxu/VOSovv1iX3bdAPy/2/qKVXxas5s2bp+HDh6t27dqKiIhQhw4d9OKLL6qgwDefri4tumnJQZif5h+NDKnkgnz1xEVas8X1N2YnvTh1oz78fofb1u9J/pgDqRn5Gnbnby6/MTupuNimURMWacN29+WYJ/ljDqzefFzXPvw/p8bltkdicq7Ov+M3ZWT5/nVA8s8cePebbXrji61uW//yDcd042NL/KJg4Y/732azafTji93y4MpJb3+9TW996b4c8yR/zIGsnEINu/M3l9+YnWS12nT9o//Tyo3uy7HKevyddS57s6wss/53UPe9vMpt6/ckfzwGioutGnnfAm3eleq2bTzy1lp9+6v7csyT/DEHEpNzNHzsXGVkuecBm/yCYl1673zt3JfmlvV7mj/mwKLVR3XLU8vctv6DCdkaPnauz75l83f+mAMvfLhRH/0Y77b1L1h1VHc8s9xt6/ckf9z/NptNV01Y5JYHV056/sONmvrjTret35P8MQdS0vM17M65OpGW75b1FxXZdOWDC7Vxp+PfR/Ukv/uG1WuvvaYHH3xQktSkSRM1btxYW7Zs0aOPPqqff/5ZCxYsUHi42Y9v2ysoPEShtaJPjc/Z+sbzVbtDcx1fv0sZexNMh+cyU3+Md3i4gzXfXKJ6MRFKTM5R92tm2bXM/a+u1tDeDdS0QbQzYRpRVXLgvv+u0qFExz4e6GgO5BcUa8wTS7Xmm0t86uPrVSEH8vKLNPrxxQ69WeXMOWDfkUxNeH21Pniyn7OhGlEVcmDXgXQ99OYah5ZxJgd+/H2/vv5lj6678CxnwjSiKux/Sfr21736fv5+h5ZxJgceeXutRvRrqNZe8OFpe1WVHJj4+mrtOeTYUEWO5kBRkU1jHl+qP7+7TOFh3nUbtGpjkv77iWNvmDpzDEyatl0jBzfRkF4NnAnTiKpyDLz11VYtWZfo0DLO5MC4F1ZqYPf6qhcT4UyYRlSFHLDZbE59v9PRHMjOLdJNTy7V0k8v9Klv2VSFHMjMLtBNTy516AE+Z84B2/ak6cn31uuVB3o4G6oRVSEHNu48of9MXu/QMs7kwGezdunywU10yXlNnAnTiKqw/yXpwx926rfl7u8fve/lPzSkV5yaxNE/6m3u/e9KHT7m3v7RvPxijXliiVZ/danXfuvbu+7UKmn16tWaMGGCLBaLPvnkE40ePVqStGfPHg0fPlwrVqzQI488ojfffNNsoHbqPPFqdZ549Wm/2z9nlf545CNDEbneocQs3f/qHw4vVy8mQg1jIx1aJiunULc8tVQLPhwhi8U3PjpdFXJgzpKD+nz2boeXcyYHNsWn6PkpG/X0uC4Ob8+UqpADT01arx37HPvGlDP7X5KmfL9TVwxtpqG9faejzt9zwGq16aYnlyo3z7GhKZzNgXteXKlBPeJUv45vdNT5+/6XSj4me/eLKx1ezpkcONk4X/bZRT7TUVcVcmDhH0f1/nTH34R3JgfiD6TriXfX6dUHezq8PXfJyy/STU8ucfgtY2fPg7c8tVRbfrxc0ZEhDi9rQlU4BuL3p+uxdxwfoseZHEhJz9edzy7XjLeGOrw9U6pCDnz7617NWOj4EObO5MDKjUl688utemB0B4e3Z0pVyIGH3ljj8JC4zl4HXv9iiy4f0kS9z/GdYbT8PQcKC60a88QSFRV5pi1wx7PL1a9LPdWqHurwsib4+/6XpIMJWXrwtdUOL+ds/+it/1mmeR8Mp3/Ui8xadEBf/uz4m/DO5MCfO1L0wkd/6qmx3tk/6ht36nZ69tlnZbPZdNNNN50qVklSixYtNHXqVEnS+++/r6SkJFMhOmTnF/M0d9TTmn/d81r77BfKS8lUZP3aKs7/a0irAe//WwM+uP+05UJqRGnUnx+q+eX9PR2yw17+ZLNLPihtr4WrE7Rote9U3v09B2w2mx718PfFXvlsk9Iy3PNqrTv4ew4cT8nVmx4eosvXxmz29xz4ddkht4zPXZ7UjAK9/vkWj22vsvx9/0vSG19sUUq6587LqzYd15wlhzy2vcqqCjnwxHuePS+//fU2HTuR69FtVuTLn/c4/OBGZRxMyNaHP/jOUDBV4Rh4/sM/lZfvuW+KzFx0UGu2HPfY9irL33PAarXpcQ+3T5+b8qdycn1nWDh/z4EDRzP1wfeeOy9brTY9NcmxN3lM8/cc+GHBPv25I8Vj20tMztV7327z2PYqy9/3vyT99+NNHu0fXbDqqBavdezNbpP8PQdsNptTDy9VxsufbFZ6pnd+NsNvClaZmZmaN2+eJOm22277x/Rzzz1XrVq1UkFBgWbNsu8VSdMy9iYqYelmHVm4QVsmzdTvo19STKcW6v3fO07Ns/KRD1W3e2s1u6zvqd/1euFWJa3eob0/LjURtt2ycgr12SzXf1T6TCZNc/3HK93F33Ng5cYkbYr3XKNMknLzio3knbP8PQc+nhGvAg9/AP6Pzce1bpvvfM/M33PAmbcqKuvjGfE+M3a/v+//vPwiTf3JfeP0l8dE3jnL33Pgzx0ntOJPzz5MVlhk9Zqx+202m5G26fvTd7jtu5Gu5u/HQHJqnqbN3efx7b4/nXsibzFvxRHtPezYkKiVlZZZoGlz93p0m5Xh7zkw5fudHj8nz195VPH7PfewRGX5ew6YaAt88N0OFTkwLL9J/r7/M7MLnBp5qLLoH/Ueyzcc05bd7vuOaVly8or0+Wzv7B/1m4LVhg0bVFBQoNDQUHXr1q3Mefr1K/luyapVvvmx4eNrd2rP90vU7LK+qtOttSSpIC1LKx54Xz2fv1XhsTXV5MJeqtenvVY+9IHhaM/s61/2ePTpgZNmLDqgo0mOjQfqLfwtB0zdKE+atkM2m2900vydP+WA1WrTZEOdxu/7UMPs7/wpB/YfydQvSz3/pktKer6+m+f5zkFX8Kf9L0k/LNivZAe/1+EKvy0/rD2HMjy+XVfwtxyY/J2Z68Dk73aouNh8J82aLcnasMPzHz3efTBDC1Yd8fh2XcHfjoFPZ+5SfoHn3q466Ztf9yrVh0YdKM3fcsDcPRHtYW9QWGjVR4Yeopj8HTngDbbsStHS9Z4bceKkI0k5mr34oMe36wr+tP8l6as5e5SV4/n+0Z8W7lfC8RyPb9cV/C0HTD1QOWnadq/sH/WbglV8fMnTuU2aNFFQUNmf5mrRosVp8/qijW98L2tRsTpPuOrU744s+lP7Z6/Que+OV6+XbtOKB95XfqpjYx+bMG+FmZvk4mKbFq3xnWEB/85fcsBmsxnLgfgD6Q5/xNCb+EsO7D6Yof0OjtPuKgv+OGpku67iLznw+x9HZaptNN9HO2ol/9n/UsnTvab87sPnAf/KATPH4qHEbMUfMF+0nLfSsQ9ru9KCVRwD3sDU9Sgvv1jLDHSQuoq/5EBxsdXY9Wjt1mSfLVpK/pMDm3alKCnF8w/vSGbbYa7gLzkw3+D12FQ7zBX8Zf9L0jxD+6GoyKbFa+kfNc1msxnLgR370nU0yfuKln5TsEpNLXltrmbNmuXOc3LayXl9Ueb+RO2buVxx53ZU3Z5tT/1+7dOfK7pZPR1ZuEGHf/eNsYhNDsnlS8OB/Z2/5MCRYznGGuYSOeANTO6DA0ezdCLNXP5VFjngim17/o0GV/GX/S+ZzgGuA6alZuR7fBis0rwhB0yei7zh73eWvxwDNpuN86CT/CUH4g9kKNvgt6TW0x4yzuRxuG1vmk99y+zvyAFXbJtzgDcgB5zjLzlwKDHbyKgjJ3lje9BvClZ5eSU7NiQkpNx5QkNDJUm5ud7zkWVnbHrrB1mLT68gF+XmK+tAklK3+8brvCnp+cberJB8+4Qs+UcOrNtu9oRIDphn+qJoevuV5R85YO443LEvzciwC67iD/s/J7dI2/amGds+1wHzTHeUesN1wGgHxfYTXjkEiL384Rg4mJClE2nm3nDxhmOgMvwhB0zvA9PbryxyoHKsVps2xtMeMs1kDmyMT1Ghh78p7Ur+sP+TU/N0MMHcCEBcB8wzvQ9ceV9ss9mUnZ2t7OzsSt1nWGy+fJdSyiuvvKKJEyeqZ8+e5X6j6v3339ddd92ls88+W5s3b3Z4G926dVNiYqJDywTbAvSUtYfD23LG8B+e1qH567R18iyn1/F0wGoVWtx/sSoMqKOkGneXOW3NN5eoXkxEhcvXiwlXUGCAioqtSkwuvwCZmJyj7tf8898jqDhZsenvOBa0gzy5709yRQ5InsmD7NBuSou8uMxpnsiBiLx1qplTuX+nMyEHKpYSeblyQ88pc9qZcsDe/S+VnwM1s35URMFGx4J2gqfzwJeuBYnV/63iwBplTnNVDpS3/yUpNu0NBVnTHAnZIb58DpDcnwdFAdV1rMb95U53dw4EWNNVP+11x4J2AueA8uWEdFBq1BVlTvNEWyA8f7NqZX/vWNAudqTmE5Kl7OHMPXEejEt5Vha59ul6E+e+0lx5HizNHcdFQWADHa9+e5nTPHEMBBcdUd2MKY4FfQam97/kWzmQGdZHGRHDypzmiRyIzFuhGjlzHQvaCVwLy3ci6hrlhbQpc5on7olqZX6j8ELXfjuF84BjjtZ4WLaA8DKneaItUC/1vwq0uX9IMPpHy1YYWFdJ1ceVOc0z/aNJik1/z7GgHeTL98WeyIOs0O5Kj7yozGme6R9dq5o5sx0LuhxWq1UJCSXDTHbq1EkbNmxwaj1l3x35IHuG+7Nn2MCKJCYm6sgRx8aUDLEESrFObc6IowlHVWDzwEd/wwKkGmVPqhcToYaxkXatJigwwO55Sysqtjm8Lx3la/u+NI/kQe3WUjm7zhM5kJObrxxyoFweyYFGBVJo2ZPszQFn978kpaZlKjXV/eME+2IeeOxaEC0psOxJnsiBY0knpHzHHkRxhC/u+9LcngchheW2BST354DVGuD2toDkm3ngsXNAzaZSVNmTPNEWyM0r8EgOVKhW+bdjnjgPHk1IkqyuHX3CF3PeHm45LiIipOplT/LEMVBY6Pp7In/d/5KbcqBOtlROP5QnciA7O0/ZR7kWlsVj18KmhVI5AwV54jqQkpohpXMesJdb8qJG+YNfeSIHEhOTpKJ0p5Z1hK/lhef6RwONtgWKikT/aAU80z/axi/7R48dc/5bqX5TsGrVqpUk6cCBAyoqKlJQ0D//tD179pw2r6Pq1avn8DLBtgDJh96ujasf56E3rGopqZxpiclnfrLDkepxWYICpdgGDewJ1Wm+tu9L80QeZIdGKa2caZ7IgYjwUNUkB8rliRxICQ9ReXvuTDng6NOEZalZI1oREe7NAck388BT14LEAKm8pp+rcqCi9cTWra0gazkVMxfwxX1fmrvzoCiguipqwro7BwICrKrv5uuA5Jt54KlzQE5ItMp71MwTbYHwsGDV8kAOVOSIrajcN6w8cR6Mq1/XLW9Y+VrO28Mdx0VBYE0dL2eaJ46B4GCL6rr4GPDX/S+5JwcywyKVUc40T+RAZGSYanAtLJOnroUnQoNV3pdLPHFPVKtmNYVHcR6wlzvy4qiKVd7QV55oC9SrV0eBtnKeIHIhX8sLj/WPBhruHw2if7QinsiDrNBolVcy9rX+0dJvWMXGOl+l9JshATMzMxUTE6OCggKtXLlSvXr1+sc8rVu3Vnx8vKZMmaLbbrvNI3EV5uTpqxbXe2RbrnDdni8VHBHm9u2kZuSrVr8vnV7+0Pyr1TA2UoePZavR0G8dXn5g9/paNPUCp7dvD1/b96V5Ig9m/++gLhk/3+nlK5sDT97RWU+P6+L09u1BDlRs4uur9cqnjg/PKlV+/0vS/CnDNaSX+2/QfTEPPHUt6H39LK3aVF5XXcUqmwMBARZlrLhBkRHBTm3fHr6470tzdx7k5RcpqtfnKi52rila2RzofnaMVn99qVPbdoQv5oGnzgGLVh/VoFt/dXr5yubA/Teerdce7On09l2h6fBpOuDkd10r+/fXrBaiE0uvl8VicWr75fHFnLeHO46LQ4lZanz+NOeXr2QOXDKwsWa+PdTp7ZfFX/e/5J4c+HrOHl33yP+cXr6yOfDK/T304JgOTm/fXr6YF566Fo59drkmf+fckHyuuCda9eXF6tmxrlPLlscX97e93JEX7Uf+oG170pxatrI5EBYaqMyVNyooqPy3vFzF1/LCU+eAlPR81e5vrn90cM84LfhwhNPbt4ev7fvSPJEHMxcd0GX3LnB6+crmwH/GdtZTY13TP5qdna2oqJICeFZWliIjnXvz0/1nJA+Jjo7W0KElje0PP/zwH9OXLFmi+Ph4hYSE6NJL3d85gYrVrBaqFo2ijW2/W7sYY9tGia7talfp7UPq1t7scdilLecB07q1r2Ns2+2a13BrsQpnFhYapPYtnBum2RVoC5hn+jzsDTlgMoau7WJcXqyCYxrGRqpOTfd3hpXHdFsM5u9JyAHzuhq8DgQFWdSxVS1j20cJk22Bzm1qe6RYhfLVqh6qZg3M9Y+avg7B/D2JyetQefzqrPT444/LYrHok08+0WeffXbq93v27NEtt9wiSbrjjjtUt65rnx6Bc0weEJyQzYurG6n6dSr+cKA7eeMJuaoxuQ+aNYhWrerlfEALHmPyXMw5wDuQA1Vb9egQndW4mrHte0MOmG0Pm//7qzqLxUIOVHEtm1RXdKS5B2g6t+G+2DSTbaH2LWoqPMxvvhTis7gOgHuiqi2uboRia4cb27435oBfFax69eqll156STabTWPGjFHTpk3VuXNntWnTRrt371bPnj310ksvmQ4T/29Yn4ZGthscFKDzesQZ2TZON6yPme9GtG9RQ3F1zRXLUKJ5w2hjHZWmcg+nG9KzgQICzDzdTw54B1NtAYtFGtKLtoA3MHUsNmtg7hpUmslzEedB72BqP0SEBalvJx/9ArofCQiwaKgHhqguS+9z6qp6dIiRbeMvHVrWMvYgJ9cB73A+bYEqz2T/6MBu9Y1sG3+xWCzGjsUOLWsafZmgPH5VsJKkiRMn6rffftPQoUOVnp6uHTt2qFWrVnr++ee1ePFiRUR4306oqq4e3lw1DDSQ/zWkqdHKNf5y11VtjW2XIXDMs1gsuvPKNka2PdZQ7uF0DetF6uIBjTy+3To1w3T5kKYe3y7+aeTgJkauyRf2b6QmceaG3sBfxo4ycz4eO6qNsYJ5aV3axajH2Z4fHrVNs+oa2J0OCm8w+tKWCg8L9Ph2r7uwBcUKL2HqnmjsKDPtcJwuKChAt/+rtce3a7FIdxi6F8Pp2jSroUE9PH9NbhIXpRH9zBRKcLprRjQ3ck2+8vxmqkv/qFcwdU9kqg1yJn5XsJKkYcOGad68eUpNTVVubq62bt2qRx99VKGhDP/kTSLCg3TTZS09vl1vPRirou5n1/H4uOlREcG6/qKzPLpNlG/MpS0VFurZTpp+nWMZq92LmDgn33p5a4WGeL5zEP8UEhyo2wx00tAW8B7tz6qpAd3qeXSboSGBuumyVh7dZkVM5CMP73iPmtVCde2IFh7fLudB7zGoZ321blrdo9usXSNUV57fzKPbRPlu+1drBQZ69pw8ol9DNW9o/k1jlDBxTr7zyjYKDPTLbmGfExkRrDGX0D9alfXsWMfjw/RGRwbrugs93wa1B4PVepHA0GANmPxvVW/ZUMV5BcpLTtfKhz9U5v7E0+YLigjTeVMfVO2OzRUQGKiv24y2a5o3mjCmoz6duUupGQUe2d4F/RuqXxeGvvAmL97bTUNv/81j23v01nNULYqnSb1F7RphmjCmg5794E+PbfP5e7p6bFv2im5WT/3fukehtaJVmJmjZfe+q7T4w6fNE9Wwjvq9dbdqnd1UWQeTNGvohNOmt7xmkDrcPVIKsChx+RatfPhD2YqKJUk12jRWr+dvUVidks6Q9S99o4O//OGZP+4MhvRqoPO619eiNQke2V6dmmH69w3tPbIt2Oe+69tryvc7lJSS55HtDehWT8P6mn+a1J7jXir/2K7Xu72GfPWoMvYcPTXvnIsfU3FeQYXTznQuMeH5e7qp/5ifZbN5ZnsPjj5bMTXDPLMxO1xzQXO99vlmbd6V6pHttWgUrZu9qGAH6bHbOunb3/YqO7fII9sbNayZOvHtIq9hsVj04r3ddPm/f/fYNv8ztovCQr2rO8gV7eGThn33lGp3aF5mf0i/N8fprKvO09etb1RBRo5b/hZHNYiN1D3XtNObX271yPYCAy16Zpz33RNVZZcNaqKeHeroj83HPbK9hrGRxt7oKE9lzwFnXXWe2t16wan/joirrWOrtmvRLa8oqlFdDfzoAQUEBMgSFKj0XUe0YsJkFaRne+zvO5OJN3XQZ7N2KS3TM/2jF57bSH061fXItnBmJ9sCw8fO9dg2H7vtHEVHemf/qHe1UKCdX8zXkYUbJEltbhquvq+N1W//euq0eaxFRdr87gwVpGVp+A9P2z3NG9WvE6G3H+6tGx5d7PZtVY8O0ZQn+3n906T2dmAN/fYJhdepIVmtKszO0x+Pf6yULfvsWs8VqyepOL9QxXklF8JN7/yk/bNWeOTv+7shvRro9itaa8r3O92+rW7tYzRhTAe3b6ey7MmBigrcoTWjNGz6X+eNwPBQRTeJ1bcdblFBWpYCQoLU/anRajCwk4rzC5Sy7YCW3v22p//MUx6/vZNmLjqoTfEpbt/W+Gvb6VwvHKO5z8t3KP7L+do9/X9qcmEv9Xvrbv084uHT5inIytX6/36jkOgIdXn4mtOmRTWqq84Tr9bs8ycq93iaBn36kFpfP1Q7Pv1NgeEhGvzpQ1o6/h0lrd4hS0CAQmpGefLPq1BAgEVTn+6vDv/60SMddZMe66M6tbx72AN7rwM9nr1ZjYd1U1Sjupo15EGlbN1/2vQGgzqry8PXyGKxyBIUqC2TZmrPd4vPeI7wtNo1wjT5ib4e6aiLCAvSx8/094qh4Ow57is6tiUpY8/RcjvryptW0bnElL6dY3Xf9e31xhfu76g7+6yaeuKOzm7fjiNCggP16bPnqsd1s1Rc7N6qncUiffLMuYqMCHbrdpxh77nvTPNV1M7x1vZxs4bRevnf3TXuhZVu31admmF695Hebt+OM6pyDowc3FRXD2+ub3/b6/ZtDexe3yufqq9se/ikdndcpMwDx1S7Q/N/TGt8QU9Z//+BLm/z/D3d9POSQ9p9MMPt23rklnPUtZ1nRzqxhyvOAWd6ELy8Ze19gNxdAgMD9Mmz56rzqBnKL3B/jn70n35eNyxsZc8Bu6ct0u5pi07996WLXtfeH5dIknKOpejXS584dX7v8exN6vTgKK1+4hM3/1X2i6sbqbce6qXRjy9x+7ZqRIdoypN9/aZ/tKL74jPd+zY4r5M6P3SNAoKDVJybrxUTP1DqtgOe+PP+YVjfhrplZCtN/Sne7dvqcXYdPXCj9/aP8u6nFynOLzxVrJKk4+t3KarRP8e0txYUKXH5ljKfBKhomre67sIWunxwU4eWSUzO0eFj2UpMtv+JqHce7qUGsZEORud5Jy/SP/Ubr83vzlC/t+4uc77Ft7+mWYMf0KyhE7T1g9nq9+Y4h9az+M43NGvoBM0aOsFYseqkV+7voeYNHfuWiKM5EBEWpE+fPVdBQd5/2rM3B3Z+UTLPrCEP6uDcNer72lhJUn5q1ql9O2voBMV/uUBHFm441RHd9bHrJZtNP/a9RzMHPaC1T3/usb+tLCUddf0dGhrQmXNA66bV9cL4bs6E6FZhtaup9jkttOeHkobpgTmrFBlXW9FNTx8iqyAtS0mrd6goJ/8f62hyUS8dmrdWucfTJEk7P5+nZiP7SpKaj+yv4+vilbR6hyTJZrUq/4T7b4Qd0axhtN6c2MuhZZzJgWsvaKErfGD4G3vPAQfmrNQvlz6urENJZU4/993xWnbve5o1dIJ+v+FF9Xn5DgVFhp3xHGHCyMFNdYODw7U6kwOvPdjDK4a/sfe4r+jYdlZF5xKTnru7m9o2r+HQMo7mQGhIoD597lyvHBK0S7sYPXWnY4U0Z46Bf99wtvp39ewQjPay99x3pvkqaud4c/v4zlFtNbR3nEPLOJMDU57q67UPblT1HHjnkd6Kq+vYN7cdzYHq0SGa+nQ/r3hwozRXtIclqUarhmo8vIc2v/PTP7cRU10dx1+u1U996vL4XSEi/OT9qv37xplzQKc2tfT47Z2ciND9XHUOKO8++UzLVrScJ7RtXkMvjHfszTdncuCOK9t4xWgDpbnqHHBSTOeWCouproNz10oq6Ss9WayyBAQoKDxUHnu13wE3XHyWLhvUxKFlnMmBdx/trbi6/tM/WtF9cUX3viHVI9X/3Xu1bPw7mjX4Aa159gud+9697v6zKvTagz3VrIF7+0cjw4P0ybP9vbp/1Hsjg9rdeoEOzl1jOgy3s1gs+uKFATrXgZvn7tfMUqOh36r7NbPsmv/5e7rqhos9Px6so+y9SEs6bfiCkOiI0y62jqzHG1SLCtH8KcNVv479N2iO5EBIcIBmvDVE7c+qWZkwPcLefWdvgVuSWl47SLu+KXlzISg8VC2vGaT1L31zavrJjlCTOreN0fevDbL7Bs3Rc0CjepGa98Fwr3yiPLJBjHKPpcpWbD31u6wjyYpsYP9Tj1ENYpR1+K/hI7IOHz+1fI1WDVVcUKjBnz+iS+a/on5v36PQ2uY77P/u1n+11hN3dLJ7fkdzYEivOE19up+T0XmOI+fvY6u2Kyeh/DcTbTYppHrJeTU4OkJ5qZmyFvzzLbbS5wiTPvxPP53fp4Hd8zuaA4/eeo7u9JKhT+w97is6tiUpumk9XTzvZV3060tqPXrYactWNM0bRYQHae7kYWoSZ/8boI7kQFCQRd+9Osgrnyg/6fHbOzn0TTdHj4GrhzfXy//u7mx4bmXvue9M81XUzvH29nFAgEXfvzbYoe+7OpoDbz/cS5cNaupkhO5FDkgxNcM0/4Phql3D/m9vO5IDEWFBmvPu+V7x4MbfuaI9bAkKVJ9Xx2rlxA9OW89JfV69U2uf/UJF2Z4ZgtgZfTvH6qsXB9pdUHT0HHBW42r6ddIwr3xww1XngIrukyta1pH7a3f69w1n697r7B++3NEcuGRgY73zsPe9ZeuKc0BpLa8dpD3fLz41RL4kBQQH6ZL5r+jqrR+rWvP62vDK9ErH7WoWi0VfvThQ/Trb/ykTR3PgxXu76boLvf+77q68Ly6t9L1vdNN6yk/NPPXWVtIf2xXZIEa1Oph7yLV6dIjmfTBc9WLsf7jIkRwIDQnUzLeGql0L7+4fpWDlpTqMv1zRTetp3QtfmQ7FIyLCg/TLe+c71FFlr5f/3V2P3tbJ5et1B0cv0v3evkdXrp2szhOv1pJ73nFoPf3evkeXLnxNfV4b6xWd180bVtPSTy9UUwc6quwRGR6kX94bpqG9XZ9b7uBsQ628Anedbq0VWj1Sh+avk1RyQS5Iy1LH8Zfrot/+qxEznlX9ft7xGvCF5zbWrLeGKjzMtTdQLZuU5Fbj+t4zDJ4nWQIDFde/o1ZO/ECzhk5QTuIJ9X7pNtNhlenpu7ro2bu7uHy9F53bSLPeHup132ooiytv1hbf+brOmzpBV6x5XyNmPqtl974ra+HpBau/nyNMKmk8D9ElAxu7fN3/GdtZz3nh9+sq48TmvZre5Q7NPn+iFt78slrfeL6aXtz7jNO8WaN6UVryyYVq3bS6S9cbFhqoGW8O0cVuyC1XslgsmvxEX919TTuXr3vMpS31xQsDvPbj6vae+840X0XtHF9oH1eLCtGCKSMc6qiyh8Uivf94H91zrfd+w5EcKNGuRU0t+eRCh9+0OpMa0SUPCPZ1cW55k04PXKkDv/yh9F1H/jGt5bWDlX0kWYnLtxiIzDGjhjXX9FfOU0iwa8/XZ59Vklv1YlybW67iqnPA35W+T3ZkWVMPkFssFr0xsaceurmjy9c9algzfffaIAW7OLe8TVB4qJpd2le7vll42u+thUWaNXSCpnW8Vem7j6j1DUMNRVixiPAg/fr+MA3p5dhb1/Z49YEeeviWc1y+XndwdRFT+ue9b8beBIXWjFadbiUPjDU6v5tCoiMU1cjst73OalxNSz+9yKEH+ewRFRGsXyedr8FuyC1X8/6emyqo/Z2XqMkFPTVv1NMqzvXMx/a8QWREsOa8e75e+3yznnxvvQoK//lUlCOaxEXp46f7a1BP7zkQL5j9vKo1L/v7Oc589HzZ+JIiVYsrB6jb49drwfUv2LXcryOfVPaRZFmCAtXloWvU/6277V7WnVo0qqb10y/Tv1/+Q5/N2lXp9Z3btZ4+fqa/WjQyX5A7ydU5IP1V4F4x6p/frWt5zSDt/m7xqYu8JShAUY3qKm3XYa174SvVOruZzp/2hGYM+LfyktOd2r4rjejfSBumXaabnlyqlRvLHubMEbf9q7VefaCHqkV51/jcpWUfSVZ4bE1ZAgNO7aeoBjHKPpJs9zqyjiSrWqknjaIa1jm1fPaRZCWs2KqcxJInjvZ+v0RDv3nChX+B61gsFj1+e2d1a1dHtz29TIePVW5427DQQL0wvpvGX9vOazpp3XEOKIslMEDn3HeFFt3yio6t2q7a57TQ4M8e1sxB9ys/JfPUfH8/R5gWFhqkn94cone+3qpH3l6r3LzKjeHfoG6EpjzVTxf0b+SiCF3D3uO+omO7MCv31O9zElK0b8YyxfZsq/2zV1Y4zds1rh+lNd9cogmvr9EH3+2o9Pp6dqijT5491+HhBk0JCLDo7Yd7qV/nWI17YYVOpFVu6Mbq0SF6Y0JPjbm0pdHvFHjs3FdBO+dMvKV9XD06RL9/NEIvfLhRz3/0p4qKKjdkUcsm1fTJM+caL1SQA/Zr16Km/px+me5+caWmz9135gXOYGjvOH30n/5e/fCWK9rD9Xq3V2SDGLW9ebgsgYEKjg7XFasnafaIh1Wv79mq17OtGg396+GVSxa+poVjXj7tO9De4l9Dm2lNk+q66YklWr/9RKXXN/7adnphfDejo0146hxQWkX3ye5YzlUsFoteuq+7enWsozufXaFjJ3LPvFAFoiKC9cr93XXHlW289ptFrjgHnNT04t5K23lI6WV860gqKVzt/naR+rx6p7ZMmlmpuN2lpLAwTK98uln/eb/y/aNN46L08TP9dV4P/+0ftcff730LM3P0v9teVddHr1VQZJiOr41X6s5Dp72ZZ8pZjatpw/TLdN9/V+nz2bsrvb4B3epp6tPe1T9aEQpWXqbdHRep2ci+mjfqmdOGfKsqgoIC9NDN5+jiAY11739XacGqow6vIzwsULdd3lrP3dNV0ZHe1Un9y8WPVTjdml/o1EV6z3eL1fu/tyu0ZpTyU7POeLE/+b+2omJt+/BnXb78nXLX7Wk1q4Xq0+fO1ZXnN9WDr63Wjn2OF1Fia4frsdvO0bir23nd+OyuzoGKCtxBEWFqdkkf/TzioVO/yz6SLGtxsfb+sFSSlLJln7IOJqlm28ZKWLq5Mn+ay7RuVkNLP71Qb321VS9N3aTjqY4P29G+RQ29PqGnzu/jXWNzlyXvRIZSNu9Ti3+de+oDs9kJKQ594PfAnFW6YOZz+vPV6co9nqbWN56vfTOWS5L2z16hltcOUnBUuAqzctVgcBelbNvvpr/GNYb3a6gtP16uR95ao49n7HLqw8PD+jTQ2w/3VisXv6lRWe66DvxdrbObKTy2po6t2i5JOrFxj3ISTqjW2c2UsGSTpLLPEd4gIMCie68/Wxee21jjX1qpX5eVfbNZkdCQQI25tKVeurebalSzf2glT7H3uK/o2A6vW0O5x9Mlm01BkWFqOKTrqSdJK5rmC6IjQzT5ib66YmhT3f/KH9q8K9XhdcTUDNNDN3XUv29o7zUFa3tZLBZdNby5Bnavrwdf+0Pf/rbX4aJFQIBFlw9uojcm9FLDeua/UeCqc589bdzy2jmp2w74TPs4JDhQ/7mriy4b1ETjX1qppeuPObyOqIhgjR3VRv8Z20UR4eZv+8kBx9SpFa5prwzSlUP36ZG312r3Qce/P9qgboSeurOzbv1Xa6/tpD7JFe3hXy/764GsqIZ1dMmCV/V9j7skSUvHvXXavGMSvtesQQ94dZ9Lx1a1tOrLS/TKp5v02udblJLu+AMMndvU1psTe+rcbmV3CnuSp84BJ5V1n2zPst70APllg5qqf5d6mvjGGn0xe7cKixwrWlgs0sUDGuuth3qpqYPfxPE0V5wDTmp57eB/tHsjG8Yo70RGyT61WNTk4t5K2X7QVeG7RVBQgB659RxdMrCkf/T3P5zrH739X2303D1dFeVln0fw1H3xSeXd+yau2KrfLn9KkhQQEqSrNn50aohA02pWC9Vnzw/Qlec304OvrdbO/Y73j9aLCdfjt3fS2FFtva5/tCLmW644JaJ+LfX4zxhl7E/U8O//I0kqLijSnAsfUacJVyn3WKp2fj5PknTJ768prHY1BUeH68p1HyhxxRYt/f8h4Sqa5ivataip+VNGaPveNE2evl3f/rZXSSkVd1q3b1FDt17eWqMvbamaXtg5ZQ97L9Ih1SIUGB6q3GMlHTiNh3dXfmqW8lOzzrieoPBQBQQHnmqcNxvZTye88KmyC89trAv6N9L/1iRo0rTt+nXZYWXn/vPbKycFBwWoT6e6GjuqrUYObqKQYO8bl9sejjTUzlTgbnZpH6Vs26/03X81bPJTMpWwbIviBp6jIws3KKpRXUU1rlvm0BkmBQYG6P4bO2jc1e30w/z9mvzddq3clFRhh11URLAuPLehxl3VTv26xHr9jXlpKyZ+oH5vjlOH8ZerMCtXy+57T1LJWPuH5q3VoXlrFRgeosuXvaPA0CAFR0foynUfaM8Pi7X+ha+VdTBJG16drhGznpNU0uja+cV8SSU3Zpve/lEXzH5eNqtNOYkpWjFhsrG/1V7Vo0M06fG+evburvp05i5N/Sle2/emVbhMbO1wXXtBc915ZVuvK1TZy1U3a9lHkhURW1PVWzZQ+q4jim5aT9FNYpWx56/zQVnnCG9yVuNq+mXSMO06kK7J3+3Q17/sUWJyxU+YtmlWXTdf1ko3XdZKMTXDPBSpc+w57is6tptc2EutRw+TrahYlqBAHZi9Uru/XXjGaRWdS7zNkF4NtPH7kVq+4Zje+3a7fl5ySFk5heXOHxRkUa8OdXXnqDa6Ymgzr/xGhyNia4frixcG6r/3dddHP8brs1m7tPdwZoXLNK4fqRsuOku3X9HGq9+m+Dt7z31nmq+ido4vto87tamtJZ9epE3xKXp/2nZ9N39fhW/dWSwlndy3/au1brjoLK9+w/zvyIGyXXF+M10+pKkWrDqi977drvmrjlT49nFIcIAGdKunsaPa6uIBjb36g+p/V9n2sD8KDg7Qo7d10r9vOFvT5u7VB9/t0JqtySouLv+eqFpUsC4d2ER3XdVWPTvW8Zl7IledA6Ty75PPtKw3PkBeu0aYpj7dXy+O76apP8Xrk5nx2nWg4gJ2g7oRuu7CFrrzyrZq1tC7C1WlueIcUK1FnGq1b6p9M5eftu6abZuoy8PXSpIsARad2LxPqx+f6tk/0Entz6qpBR+O0LY9qZr83Q59++veMz7Ue/ZZNXXr5a00+pKWXvnwnj1cWcSUyr/3Da9bQ7lJaZKkc/59hRKWb3F6G+5y0YDGuvDcRlq0+q/+0Zy8ivtH+3aO1dhRbXTZIN/sH7XYbLbKjTGAChXm5OmrFtebDsNu1+35UsER3tfBY7PZdPhYttZtS9bO/el6fsqfyswpUvWoYM14a6g6t6mt6tHedUPm7L6v1iJO/d4cp9Ca0acu0mk7Sp78OHmhTtm2XwOnPKCgsBDZrDblncjQ2mc+V8rW/WdcT1TjujrvowmyBAbIYpEyDyRp9RMfn/ZRd2/Mg+Jiq+IPZGjt1uM6lJitl6ZuVGZOkWpEB2v+lBHq0LKW13VMuTMHTmzeq1Hrpyhjf6KK/n/op5MF7pMumPW84r9aoN3TFp22/qjGddX39bsUVitaNqtNG9/4Tgfm/HHaPN6YA3n5RdoUn6r125M18Y01yswuVLXIYE16vI+6totRqybVvfKJEV+7Dkjeuf8lKS0jX+u3n9Cm+BQ9OWn9qRz4/IUB6to2Rg1iI7zqptyd54BD89aq98u3q+HgrgqvW0P5qZkqzMrVj33uObWeZpf1Vcfxl8tmtckSYNGmd37Svp+WnZpe3jniJG/LA5vNpqNJOVq3LVk79qXruSkbTrUFfnh9iLq0q+2VD6xwDnAdq9WmXQfStW7bCe0/mnmqLVA9KljzPhihjq1q+sS36iojOTVP67Yla8vuVD09ecOp8+A3L5+nru1iFFvb/g80u4u7z30VzSdV3M7x9faxzWbTgaNZWrctWbsOZuiFD/+6J5r19lB1blvb+AgTlTnnkQNnVlRk1Y59aVq37YSOJJW+JwrRwo9GqP1ZNb2yY4proevk5BZpU3yK1m9P1sNvrT11Hfjgyb7q2i5GLRpVM35PZPI6EFG/VoX3yeUte6blTvKGvDiRlqf1209o864U/ef9v9oCX700UF3bxah+He/8TpmvnQe8YV+XxWaz6VBiSf9o/AH6R+25L5bKv/ft8+qdiu3ZVpbAAB1fF68/Hpt6WsHaG/OguNiqnfvTtW5b8t/6R0u+V2myfzQ7O1tRUSUPzWVlZSky0rmRHihYuRknZPdoOOQbHUnKUYO6ETq84BrT4ZTJ1/Z9ab6QB+SAe3l7DvjC/j/JF/PA2/e/5Bs54Iv7vjRvzwNfyAHJN/PA2/f9Sb6SA+7irX+/L+a8PbzxuPDGHPDX/S+RA5Xhi3nhjfv777x1//vi/raXt+WFt+ZAWXwtL7xtX5fHF3LA1/Z9ab6QB96UA64qWPnO++EAAAAAAAAAAADwSxSsAAAAAAAAAAAAYBQFKwAAAAAAAAAAABhFwQoAAAAAAAAAAABGBZkOwN8FhYfquj1fmg7DbkHhoaZD8Bu+tu9LIw9cgxyA5Jt5wP53DV/c96WRB67hi3nAvkdl+GLO24Pjwj7+uv8lcqAyfDEv2N/O88X9bS/ywnm+lhfsa9fxtX1fGnlgBgUrN7NYLAqOCDMdBgxg34McgEQeVGXse0jkAaoecr5qY/+jLORF1cL+RlnIi6qLfQ9HMSQgAAAAAAAAAAAAjKJgBQAAAAAAAAAAAKMoWAEAAAAAAAAAAMAoClYAAAAAAAAAAAAwioIVAAAAAAAAAAAAjKJgBQAAAAAAAAAAAKMoWAEAAAAAAAAAAMAoClYAAAAAAAAAAAAwioIVAAAAAAAAAAAAjKJgBQAAAAAAAAAAAKMoWAEAAAAAAAAAAMAoClYAAAAAAAAAAAAwioIVAAAAAAAAAAAAjKJgBQAAAAAAAAAAAKMoWAEAAAAAAAAAAMAoClYAAAAAAAAAAAAwioIVAAAAAAAAAAAAjKJgBQAAAAAAAAAAAKOCTAfg72w2m5SfbzoM+4WGymKxmI4CAAAAAAAAAABUIRSs3C0/X0WjRpuOwm5B0z+TwsJMhwEAAAAAAAAAAKoQhgQEAAAAAAAAAACAURSsAAAAAAAAAAAAYBQFKwAAAAAAAAAAABhFwQoAAAAAAAAAAABGUbACAAAAAAAAAACAURSsAAAAAAAAAAAAYBQFKwAAAAAAAAAAABhFwQoAAAAAAAAAAABGUbACAAAAAAAAAACAURSsAAAAAAAAAAAAYJTfFaz279+vqVOn6s4771TXrl0VEhIii8WiMWPGmA4NAAAAAAAAAAAAZQgyHYCrvfnmm3rrrbdMhwEAAAAAAAAAAAA7+V3BKiYmRhdccIG6d++ubt266ddff9WkSZNMhwUAAAAAAAAAAIBy+F3B6vHHHz/tv1etWmUoEtdZnJykoSv/p5faddT9LdqUOU/I7Om6oG59zejZ38PReVZ6ZoHmLDmkrJxCSVJefrGKi60KDPS70S0BlGPt1uPKzi05B2TnFulwYrYa1os0HBUAT8nM/mdboKjIqqAg2gKoGgoKi/XrssOnjoHcvCLl5hUpPMzvbu0AlGPPoQwt/OOoMv//PFBYZDUcEQBPKiy06rflf7UFcvKKlJNbpIhw2gJAVbH/SKYWrPqrLVBQ6D9tAc5k8An7j2TqpY836cufdys7t+jU70+k5+usC7/TnaPa6L7rz1ZoSKDBKAG4i81m01dz9uitr7Zq7dbkU79PyyxQ0xHTdMnAxnropo7q2bGuwSgBuNPhxGy99PFGfT57tzKzC0/9/kR6vpqNmK47rmyt+2/owI06/FZaRr5e+XSzPvpxp5JS8k79PiWjQA2HfqubL2uliTd1UJ1a4QajBOBOC/84qlc+3azflh8+7fdJKXk6d8zPuv/Gs3XZoKZmggPgdlk5hXr1082a8sNOJRzPOfX71IwCNRjyjUZf0lIP39JR9WIiDEYJwJ2WrU/Ufz/epDlLD8lm++v3x1Pz1Pv6Wfr3DWdr1LDm5gJ0AR5Fhddbu/W4elw7Sx98t+O0YtVJ+49m6eE312rYnb8pI6vAQIQA3Mlqtemu51bohkcXn1asOqm42Kaffj+g/mPm6Jtf9hiIEIC7bY5PUY/rZum9b7efVqw66fCxbD3x7noNuvUXpaTnG4gQcK8jx7LVb/TPeuGjjacVq05KSc/Xq59tVu8bZmvv4QwDEQJwt/e+3aYht//6j2LVSUvXH9PI+37XE++uk610DxYAv5B0IlcDbpqjpydvOK1YdVJaZoHe+mqrel43Szv3pXk+QABu9/FP8Rp4yy/6ecnpxaqTVm06rqsmLNL9r6zy6bYABSt4tX2HMzXirnk6nvrPG/O/W7w2UaMeXCir1XcPSAD/9Pg76zT5ux1nnK+wyKobHlus+SuPeCAqAJ5y5Fi2ht81t8wb87/7Y/NxXXbvfBX60XAIQFZOoS4YN09b96Sdcd49hzI1fOxcpWZQuAX8ybTf9uruF1aW2Tn1d89N+VNvfbnV/UEB8Ji8/CJdfM98rd9+4ozzHkzI1rCxc5V0ItcDkQHwlFmLDujW/yxVcfGZGwNvfLFVL3y40QNRuQcFKx+SU1ys5Pz8Mn/81YtTNyrZjmLVSXNXHNHccp44A+B7jiZl6+VPN9k9f3GxTRPfWO3TT5IAON2rn23W0aQzF6tOWrr+mGYsOuDGiADP+mzWLm2KT7F7/l0HMjR5+pkf9ADgG4qKrJrw+mqHlnnivXXKzGb0EcBfTPttn1ZvOW73/AeOZuntrylcA/7CarXpwddX2/XgyknPTvlTJ9Ls71P3JhSsfMgzO7cqbt7MMn/8UVpGvr6a4/jwXpOmbXdDNABM+PCHnXY9PVLanztStGpTkpsiAuBJ2TmF+mTmLoeXoy0Af2Gz2ZzK58nfbVdxMW8aAv5gztJDOpSY7dAyWTlF+vJnhsoG/IUzbYEPf9ipgsJiN0QDwNMWrj6qXQccG/Y7v6BYn8xw/F7aG1Cw8iG3Nm6uX3sNKPPHH81efFA5ef/8ZtWZzFl6SGkMgwL4hW9/2+vUcl//4txyALzL3BVHlJ7p+BPi/1uTYNcQgoC327IrVdvsGArw7w4mZGvFnzy8AfiDb351rvDk7HIAvMvewxkOvV11UlJKnhb+keCGiAB42re/Ots35pttgSDTAfiSbt26KTEx0aFlwgMCtK1Tb5ds/6yoKA2uE+uSdZWnVatWyrV6x9OYmWF9pIhhDi9ns0ltzu6uIKv9Q6fA9yTUuF8KqK6ExAQ1bNjQdDhwk6M1HpYCwh1ebuqn0/XTe1e6ISJ4C84BVUNWaHcp8iKnlu3Urb+Ci4+5OCJ4k6pwHsgLai5VG+3UspddcaPCC7e5OCJ4k6pwDEA6Hj1GCm7m8HIr12xVw4Z3uj4geA3OAVVDflBDqdptTi17zY13KLLAd79jgzPjPFA1JEddK4W0dni5jdv2eTQvrKVqCv369dOGDRucWg8FKwckJibqyJEjDi0TERgodXJPPO5w9OhR5RR7ySvDtVOlCOcWPZZ4RCqkYOXXooulAMlaXOzwcQkfUq3QqYJVbm4WeeHvOAdUDTWbS5HOLZp0LEHK56lSv1YVzgORUVI15xZNOXFcyvTTfxeUqArHAKSmuVKw44sVFeaTF/6Oc0DVEB7sdFsgLSVZaenkhl/jPFA1NM6WQhxfzFpUYCwvjh1z/uFRClYOqFevnsPLhAf41qiLcXFxXvOGVV5wkU44sZzFlq/6daNlkeOd3PAdCYGBskoKCAxU/QYNTIcDNzluS1OBE63z6NA8VSMv/BrngKohP8iqZKnk9WmLxf4FbUWqXydcATZyw59VhfNAUUCgjkmOHQP/P2/dmlJwNf/8d0GJqnAMQEoLzpJjX7AqERaQodrkhV/jHFA1FFuClWizShYH+hf/vy1Qp7oUEkVu+DPOA1VDekiuspxYLtSSrhgP5oXValVCQslDo7Gxzo8SR8HKAWvXrnV4GVtenopGOTeMhwnx8fGyhIWZDkOSVFRkVbMR03X4mGPN87FXd9J7j+13T1DwGg2HfKMjSTmqX6++Dm85bDocuMknM+J185NLHVomIMCizYsnqUlctJuigjfgHFA1WK02tbn0e4c/MHvjJW302fO+OV437FdVzgMjxs7Vb8sd+PssFvXpVFfLP3duCA74jqpyDFR167clq+vVMx1e7vsp43Xhua+6ISJ4C84BVceVD/yu7+fvt38Bi0XntK6lDdNXyeLIQ1/wOZwHqoad+9LU5tIfHF7u8zdv1ahhL7ghorJlZ2crKipKkrRs2TKn1+Nbr/+gSgkKCtAdVzo+PufYUW3cEA0AE64a1lw1qzn23vNF5zaiWAX4iYAAi8aOauvwcndd5fgygLdyJp85BgD/0aVdjHp1rOPQMk3jojS8L98yAfyFs20BilWAf2jdrIYG94xzaJl6MeG6bFATN0XkXn5XsFq+fLliYmJO/bz++uuSpG+//fa03y9fvtxwpLDHAzd2UJ9Ode2e/9m7u+jslrXcGBEAT4oID9Lnzw9QQIB9De24uhF699Hebo4KgCeNu7qtBvWob/f8D93cUT072t92ALzdRQMa6abLWto9/xVDm+qaES3cGBEAT5v6dH/ViLbvIa7QkAB9+eJABQb6XXcPUGUN7F5f91zbzu75Lzy3kW6+rJUbIwLgaR882Vd1ato3KlpQoEVfvjBQIcGBbo7KPfyuBVNYWKgTJ06c+snNzZUk5efnn/b7wsJCw5Hab0BMXRVcPEr3tyj/zaGCi0dpRs/+HozKM8LDgjTn3fN1Xvczd1Q9M66LHrutk/uDAuBRFw1orO9eHaSw0IovtM0bRmvRRxeoUb0oD0UGwBNCggM18+2hGtHvzE+KP3xLR70wvpsHogI8x2KxaMqT/XTr5WfueLpmRHN9+eJAux/0AOAb2rWoqd8/HKF6MRV/p7laVLDmvDtMfTs7/90IAN7HYrHojQk9de917c8478jBTTT9lUEKCvK7Ll+gSmvRqJoWfjRCjepFVjhfZHiQZr49VIN7OfZGljfxu29YDRw4UDabzXQYcKEa1UI174PhmrP0kCZN2655K46cmhYZHqQbLjpLY69qq46teLMK8FeXD2mqXWdfqSk/7NCHP+xUYnLuqWnntK6lcVe11bUXtFBkRLDBKAG4S1REsGa/M1RzVxzRpGnb9cvSQzrZ3AsPC9S1I1po7FVt1bVdjNlAATcJCgrQlKf6acylrTRp2nZ9N2+fCouskqTAQItGDmqiu65qq4Hd6zP8D+CnurSL0fYZ/9Lns3dr0rTt2rk//dS0xvUjdeeVbXXLyFaqW7viohYA3xQYGKA3H+qla0Y016Rp2zVt7j7lFxRLKhlG++IBjXTXVW01pFcDHlwB/NTZLWtp60+X68uf9+i9b7dp6560U9Ma1I3QHVe20a2Xt1b9OhHmgnQBvytYwT8FBQXo0vOa6NLzmuhEWp6Op+YpOChA9WMiFBFOGgNVQcN6kXpmXFc9cXtnHT2erezcItWIDlH9OhF0zgFVQGBggC7o30gX9G+klPR8JaXkKigwQPVjwilWo0qwWCzq2zlWfTvH6v3H++jYiVzZbFJs7XBVt3OoMAC+rUa1UI2/rr3uubadjhzLUUZ2gaIigtWgbgRDAAJVRM+OddWzY12991gfJSbnqrjYqrq1w1WzWqjp0AB4QHRkiMZe1VZ3jmqjo0k5Ss8qUGR4kBrUjfSbNyvp6YfPqV0jTLVr2DdmJwD/ExwcoCZx0abDAGBQreqhqlWdm3JUXdWiQlQtiiIVUFVZLBY1rBcpqeJhgQD4r6iIYJ3VmIe2gKrKYrGoQWykGsT6X1vAP8puAAAAAAAAAAAA8FkUrAAAAAAAAAAAAGAUBSsAAAAAAAAAAAAYRcEKAAAAAAAAAAAARlGwAgAAAAAAAAAAgFEUrAAAAAAAAAAAAGAUBSsAAAAAAAAAAAAYRcEKAAAAAAAAAAAARlGwAgAAAAAAAAAAgFEUrAAAAAAAAAAAAGAUBSsAAAAAAAAAAAAYRcEKAAAAAAAAAAAARlGwAgAAAAAAAAAAgFFBpgPwe6GhCpr+meko7BcaajoCAAAAAAAAAABQxVCwcjOLxSKFhZkOAwAAAAAAAAAAwGsxJCAAAAAAAAAAAACMomAFAAAAAAAAAAAAoyhYAQAAAAAAAAAAwCgKVgAAAAAAAAAAADCKghUAAAAAAAAAAACMomAFAAAAAAAAAAAAoyhYAQAAAAAAAAAAwCgKVgAAAAAAAAAAADCKghUAAAAAAAAAAACMomAFAAAAAAAAAAAAoyhYAQAAAAAAAAAAwCgKVgAAAAAAAAAAADCKghUAAAAAAAAAAACMomAFAAAAAAAAAAAAoyhYAQAAAAAAAAAAwCgKVgAAAAAAAAAAADCKghUAAAAAAAAAAACMCjIdgL+z2WxSfr7pMOwXGiqLxWI6CgAAAAAAAAAAUIVQsHK3/HwVjRptOgq7BU3/TAoLMx0GAAAAAAAAAACoQhgSEAAAAAAAAAAAAEZRsAIAAAAAAAAAAIBRFKwAAAAAAAAAAABgFAUrAAAAAAAAAAAAGEXBCgAAAAAAAAAAAEZRsAIAAAAAAAAAAIBRFKwAAAAAAAAAAABgFAUrAAAAAAAAAAAAGEXBCgAAAAAAAAAAAEZRsAIAAAAAAAAAAIBRFKwAAAAAAAAAAABglF8VrGw2m5YvX66HHnpIffr0Ua1atRQcHKzY2FhddNFFmjVrlukQAQAAAAAAAAAA8DdBpgNwpYULF2rIkCGSJIvFohYtWqh58+bavXu35syZozlz5ujmm2/WRx99JIvFYjhaAAAAAAAAAAAASH74hlXz5s31zjvvKCkpSbt27dLatWt14sQJvfHGG7JYLPr444/1/vvvmw7VIYuTkxQye7pe37Oj3HlCZk/XZX8s9WBUgDlFRVZZrTbTYQAAAENoCwAAqjqbzXba/wIA4A/8qmDVo0cP7dixQ3fffbdiYmJO/T4wMFD33Xefbr/9dknSlClTTIUIwElFRVbNWLhf59/xq4K7fKKE5FxJUlJKrqZ8v0NZOYWGIwQAAO5UXGzVz4sP6oK75iqk619tgWMncvXet9uUkVVgOEIAANwrLSNfb325RW0u+V5Hj5dcB48ez9Wl4+dr7vLDPMwBAPB5flWwqlatmoKDg8udPmzYMEnSzp07PRUSABc4lJilrlfP1Mj7ftf8lUdPm1ZYZNMdzyxX8xHTtXLjMUMRAgAAd0pMzlGv62fr4nvm69dlh1X6YfKiYpvufmGlmg6fpv+tSTAXJAAAbjR3+WE1HjZN9738h3buTz9t2qz/HdTwsXPVf8zPSk7NMxQhAACV51cFqzPJyyu5aEdERBiOBIC9jp3I1YCbftGm+JQK5zuemqcht/2mNVuOeygyAADgCSnp+Rp48y9auzW5wvlSMwo07M7ftHRdoociAwDAM+avPKKL7p6nzOyKRxZZ8WeSBt/2K28dAwB8VpUqWE2bNk2S1L9/f8OROCenuFjJ+fll/gD+auxzy7XvSKZd8+bkFenKBxequNjq5qgAAICn3PffVf94krw8BYVWXfngQuUXFLs5KgAAPCM7p1BXTVioomL7hvvbFJ+ih95Y4+aoAABwjyDTAXjKL7/8opkzZ0qSJk6caDga5zyzc6ue2bnVdBiAxxxKzNLMRQcdWubA0SzNWXJIl5zXxE1RAQAAT0k6katpc/c6tMyxE7n6ccF+XXNBCzdFBQCA53zz616lZjj2xtTns3frpfu6q3p0iJuiAgDAPapEwWrPnj264YYbJEnjx49Xnz59DEfknFsbN9e/4hqVOW3EqsUejgZwv49+iHfqo7GTv9tBwQoAAD/w6cxdKih0/M3pyd/toGAFAPALk7/b4fAyOXlF+nLObo27up0bIgIAwH38vmCVmJio4cOHKyUlReeff75effVVp9fVrVs3JSY6NiZ+eECAtnXq7fQ2SzsrKkqD68S6ZF3ladWqlXKtDKcG73AiapQU0t7h5eYt3qyGDW9xQ0QAvEVCjfulgOpKSExQw4YNTYcDwE1SIy+TQjs7vNyyNXs4N8DvcS0EqoajNR+TLI6/KfXQk2/pxQfnuCEiAN6CtgC8ibVUTaFfv37asGGDU+vx64LVySLV7t271bdvX/30008KDg52en2JiYk6cuSIQ8tEBAZKnZzepMcdPXpUOcWM+Q8v0aRQcmIEg2JrgMPHKgAfE10sBUjW4mKOd8CfNSqQQh1fzGoL5NwA/8e1EKgaajrXdZedk69szg2Af6MtAC917Ngxp5f124JVRkaGhg8frs2bN6tLly6aM2eOIiIiKrXOevXqObxMeEBApbbpaXFxcbxhBa+RGmpTjhPLBVnyFduggcvjAeA9EgIDZZUUEBio+hzvgN9KC5OynVguULmqx7kBfo5rIVA1JNhyZLVEObxcVLhF1Tk3AH6NtgC8idVqVUJCgiQpNtb5UeL8smCVk5Ojiy66SGvWrFHbtm01d+5cVa9evdLrXbt2rcPL2PLyVDRqdKW37Snx8fGyhIWZDgOQJP28+KAuvme+w8s9Om6Ynh73iBsiAuAtGg75RkeSclS/Xn0d3nLYdDgA3GTR6qMadOuvDi9330399eqDD7ohIsB7cC0Eqoaxzy536jtWv//4snp0qOOGiAB4C9oC8CbZ2dmKiip5wGLZsmVOr8e3Xv+xQ0FBgUaOHKmlS5eqRYsWWrBggWJiYkyHBcAJI/o1VJM4x54kCwy06PYrWrspIgAA4EkDu9dX2+Y1HF7uzlFtXR8MAAAG3HWV49e0bu1jKFYBAHySXxWsiouLde2112revHlq2LChFixYoLi4ONNhAXBSYGCAnr+nq0PL3H11OzWIjXRTRAAAwJMsFovDbYFbRrbSWY2ruSkiAAA8q0OrWrr2ghZ2zx8QYNGz4xy7dgIA4C38akjA6dOn64cffpAkhYSE6Prrry933u+//96pb1KZMCCmrgouHlXhPGeaDviq6y48S0eTcjTxjTVnnPeaEc312oM9PBAVAADwlJGDm+rdR3vrnhdXymareN7LBjXRpMf7eCYwAAA8ZOrT/ZSSnq/fllc85FdAgEUfPtVPw/s19FBkAAC4ll8VrPLz80/9/71792rv3r3lzpuXl+eJkAC4wISbOqpV0+p64cONWr3l+D+mN2sQrXuva6d7rm2vgACLgQgBAIA7jbu6nZo3iNZzH/6pFX8m/WN6o3qRuvvqdnpg9NkKDPSrQSQAAFBYaJBmvT1UL3+ySZOmb9fRpJx/zDOgWz09fnsnDenVwECEAAC4hl8VrMaMGaMxY8aYDgOAG1x6XhNdel4Trd16XL8tP6z0zEJFhgepR4c6Gt63IYUqAAD83Ij+jTSifyP9ueOE5iw5pLTMAkWEBalru9q68NxGFKoAAH4tODhAj93eSRNv6qjZiw9q484U5eYXqWa1UF0ysLHan1XTdIgAAFSaXxWsAPi/bu3rqFt7Ph4LAEBV1alNbXVqU9t0GAAAGBEcHKDLhzTV5UOamg4FAACX4zFEAAAAAAAAAAAAGEXBCgAAAAAAAAAAAEZRsAIAAAAAAAAAAIBRFKwAAAAAAAAAAABgFAUrAAAAAAAAAAAAGEXBCgAAAAAAAAAAAEZRsAIAAAAAAAAAAIBRFKwAAAAAAAAAAABgFAUrAAAAAAAAAAAAGEXBCgAAAAAAAAAAAEZRsAIAAAAAAAAAAIBRFKwAAAAAAAAAAABgFAUrAAAAAAAAAAAAGBVkOgC/FxqqoOmfmY7CfqGhpiMAAAAAAAAAAABVDAUrN7NYLFJYmOkwAAAAAAAAAAAAvBZDAgIAAAAAAAAAAMAoClYAAAAAAAAAAAAwioIVAAAAAAAAAAAAjKJgBQAAAAAAAAAAAKMoWAEAAAAAAAAAAMAoClYAAAAAAAAAAAAwioIVAAAAAAAAAAAAjKJgBQAAAAAAAAAAAKMoWAEAAAAAAAAAAMAoClYAAAAAAAAAAAAwioIVAAAAAAAAAAAAjKJgBQAAAAAAAAAAAKMoWAEAAAAAAAAAAMAoClYAAAAAAAAAAAAwioIVAAAAAAAAAAAAjKJgBQAAAAAAAAAAAKMoWAEAAAAAAAAAAMAoClYAAAAAAAAAAAAwKsh0AP7OZrNJ+fmmw7BfaKgsFovpKAAAAAAAAAAAPs7n+scl+sgNomDlbvn5Kho12nQUdgua/pkUFmY6DAAAAAAAAACAr/Ox/nGJPnKTGBIQAAAAAAAAAAAARlGwAgAAAAAAAAAAgFEUrAAAAAAAAAAAAGAUBSsAAAAAAAAAAAAYRcEKAAAAAAAAAAAARlGwAgAAAAAAAAAAgFEUrAAAAAAAAAAAAGAUBSsAAAAAAAAAAAAYRcEKAAAAAAAAAAAARlGwAgAAAAAAAAAAgFF+VbCaNWuWxo4dqx49eqhBgwYKDQ1VdHS0OnXqpEcffVTJycmmQwQAAAAAAAAAAMDfBJkOwJVef/11LV68WCEhIYqLi1PHjh2VlJSkTZs2aePGjfroo480b948derUyXSoAAAAAAAAAAAA+H9+9YbVzTffrN9//12ZmZnat2+f1qxZowMHDmjjxo06++yzdfz4cV177bWmwwQAAAAAAAAAAEApflWwuvHGGzVo0CCFhISc9vsOHTpo6tSpkqTt27dr+/btJsJz2uLkJIXMnq7X9+wod56Q2dN12R9LPRgVAACet+dQhh59a61S0vMlSWmZBVq2PlE2m81wZAAAAAAAuJfNZtP/1iTozmeX68T/3xdnZBVo/5FMw5G5H33kVYNfDQlYkbZt2576/zk5OQYjAQAAjtp7OEPjnl+p35YfPu332blF6j9mjjq0rKlXH+ih8/s0NBQhAAAAAADu8/Pig5r4xhpt35t22u8zc4rU/ILpurB/I016vI8a1YsyEyDgAn71hlVFli9fLkmKjIxU69atDUcDAADstXV3qnpdN/sfxarSNu9K1QXj5umbX/Z4MDIAAAAAANzvkxnxumT8/H8Uq06y2aSflxxSr+tna9eBdM8GB7iQXxesrFarEhIS9Pnnn2vMmDGSpBdeeEFRUVSZAQDwBRlZBRpx11wdT80747zFxTaNfnyJVm8+7oHIAAAAAABwvyVrE3Tb08tkz0j4R5NyNOKuucrNK3J/YIAb+GXBavLkybJYLAoMDFRcXJxGjx6thg0bavbs2Ro/frzp8JyWU1ys5Pz8Mn8AAPBHX/y8W4cSs+2ev7DIqlc+3eTGiAAAAAAA8JyXPt6k4mL7v9u851Cmvv1trxsjMos+cv/ml9+wql+/vvr27auioiIdOnRICQkJ2rRpk77++mv1799f1atXNx2iU57ZuVXP7NxqOgwAADzCZrNp0rTtDi/308IDOpqUrbi6kW6ICgAAAAAAz9hzKKPC4fHLM2nadt10WSs3RGQefeT+zS8LVpdeeqkuvfTSU/+9efNmjRs3Tt98840OHjyoZcuWGYzOebc2bq5/xTUqc9qIVYs9HA0AAO51KDFb2/akObxccbFN81ce1ehLW7o+KAAAAAAAPGTeiiN2DQX4d2u3Jut4Sq7q1Ap3fVCG0Ufu3/yyYPV3HTp00Jw5c9S8eXMtX75cCxYs0JAhQxxeT7du3ZSYmOjQMuEBAdrWqbfD2yrLWVFRGlwn1iXrKk+rVq2Ua7W6dRsAANijMDBWqn6XU8vee/8jemzcKhdHBACA90iocb8UUF0JiQlq2LCh6XAAAIAbZIb1kyKGOrVsh049FWRNcXFEjnNl/7hEH7m3spb69+rXr582bNjg1HqqRMFKkqKjozVgwAD98MMP2rhxo1MFq8TERB05csShZSICA6VODm/KmKNHjyqnuNh0GAAASCEFkpOj+KanHlN6qmPXbAAAfEp0sRQgWYuLHb5PBQAAPqJ2shTh3KLHEg5KRemujccJvtY/LtFHXlnHjh1zetkqU7CSpKKiIklSsZPJVq9ePYeXCQ8IcGpbpsTFxVE9BgB4BZsClWjNkjUgyoGFbJLForrROQqOaOC+4AAAMCwhMFBWSQGBgarfgGseAAD+KD8oS8nSqXtdewUWpyk2NloWOXA/7Sa+1j8u0UfuDKvVqoSEBElSbKzzb8BVmYJVSkqKFi8uGcOyU6dOTq1j7dq1Di9jy8tT0ajRTm3PhPj4eFnCwkyHAQCAJOnxd9bq+Q832r+AxaK+nWO17LN17gsKAAAv0HDINzqSlKP69err8BbHP8YOAAC8n81mU5erZujPHY4N7ffMfYP16G0PuCkqx/ha/7hEH7kzsrOzFRVVUiBdtmyZ0+vxvfJmOdauXasnn3xSu3fv/se0DRs2aMSIEUpLS1OHDh00ePBgAxECAABH3X5FG4WFBjq0zL3XtXdTNAAAAAAAeI7FYnH4HjcyPEi3XN7aTREB7uU3BausrCw9++yzatmypWJjY9WtWzf17NlTDRo0UJcuXbR69Wq1atVKM2bMUGCgYx1fAADAjMb1o/TViwMVEGDf0Af3Xd9eV57fzM1RAQAAAADgGaMvaanbr7CvABUUaNH0Vwcptna4m6MC3MNis9lspoNwhdTUVH3xxRdatGiRtmzZomPHjikvL0+1atVShw4dNHLkSN18880K8/CrfL72ymPQ9M943REA4HV+XnxQY55YohNp+WVODwkO0GO3ddITd3SSxYFxvQEA8FUnhwRsUDdChxdcYzocAADgRlarTY+/s06vfLpJRcVld+fXrRWmr14aqCG9vOvblr7WPy7RR+6M0kMCZmVlKTIy0qn1+E3Bylv52gHJwQgA8FZ5+UX6bt4+ffjDTu0+lKmiIqvqxYTr2gta6ObLWqkuT5ABAKoQClYAAFQ9CcdzNPWnnfr21706lpKnkOAAtWpSXbf/q7UuH9JUoSHeN7KYr/WPS/SRO8NVBasgVwYFAADgLmGhQbrh4pa64eKWpkMBAAAAAMDj6teJ0OO3d9bjt3c2HQrgFn7zDSsAAAAAAAAAAAD4JgpWAAAAAAAAAAAAMIqCFQAAAAAAAAAAAIyiYAUAAAAAAAAAAACjKFgBAAAAAAAAAADAKApWAAAAAAAAAAAAMIqCFQAAAAAAAAAAAIyiYAUAAAAAAAAAAACjKFgBAAAAAAAAAADAKApWAAAAAAAAAAAAMIqCFQAAAAAAAAAAAIyiYAUAAAAAAAAAAACjKFgBAAAAAAAAAADAKApWAAAAAAAAAAAAMCrIdAB+LzRUQdM/Mx2F/UJDTUcAAAAAAAAAAPAHvtY/LtFHbhAFKzezWCxSWJjpMAAAAAAAAAAA8Cj6x+EIhgQEAAAAAAAAAACAURSsAAAAAAAAAAAAYBQFKwAAAAAAAAAAABhFwQoAAAAAAAAAAABGUbACAAAAAAAAAACAURSsAAAAAAAAAAAAYBQFKwAAAAAAAAAAABhFwQoAAAAAAAAAAABGUbACAAAAAAAAAACAURSsAAAAAAAAAAAAYBQFKwAAAAAAAAAAABhFwQoAAAAAAAAAAABGUbACAAAAAAAAAACAURSsAAAAAAAAAAAAYBQFKwAAAAAAAAAAABhFwQoAAAAAAAAAAABGUbACAAAAAAAAAACAUUGmA/B3NptNys83HYb9QkNlsVhMRwEAAAAAAAAAAKoQClbulp+volGjTUdht6Dpn0lhYabDAAAAAAAAAAAAVQhDAgIAAAAAAAAAAMAoClYAAAAAAAAAAAAwioIVAAAAAAAAAAAAjKJgBQAAAAAAAAAAAKMoWAEAAAAAAAAAAMAoClYAAAAAAAAAAAAwioIVAAAAAAAAAAAAjKJgBQAAAAAAAAAAAKMoWAEAAAAAAAAAAMAoClYAAAAAAAAAAAAwioIVAAAAAAAAAAAAjPL7gtWHH34oi8Uii8WigQMHmg4HAAAAAAAAAAAAf+PXBavExERNnDjRdBgAAAAAAAAAAACogF8XrO655x5lZGTooosuMh1KpSxOTlLI7Ol6fc+OcucJmT1dl/2x1INRAQAAAAA8rbjYqpUbjyk3v0iSVFRsNRwRAAAA4Bp+W7CaNWuWvv/+e40bN05du3Y1HQ4AAAAAAE5LSc/XCx/+qeYXTFefG35WSnqBJOnYiTyNGDtXPy8+KJvNZjhKAAAAwHl+WbDKzMzUuHHjFBcXp+eee850OAAAAAAAOC1+f7q6XT1Tj72zTgcTsv8x/bflh3XxPfM17vkVKuaNKwAAAPioINMBuMMjjzyiw4cPa/r06apWrZrpcAAAAAAAcMrRpGwNuf1XHUr8Z6Hq796fvkMhwYF686FeHogMAAAAcC2/e8Nq5cqVev/99zVixAhdeeWVpsNxqZziYiXn55f5AwAAAADwP09P3mBXseqkt77aqk3xKW6MCAAAAHAPv3rDqrCwULfddptCQ0P17rvvmg7H5Z7ZuVXP7NxqOgwAAAAAgAekZxboy5/3OLzc+9O26/0n+rohIgAAAMB9/Kpg9dJLL2nr1q16/vnn1bx5c9PhuNytjZvrX3GNypw2YtViD0cDAAAAAHCn7+fvU05ekcPLffHzbr3zSG8FBfndoCoAAADwY35TsNq5c6eef/55tW3bVhMmTHDLNrp166bExESHlgkPCNC2Tr1dsv2zoqI0uE6sS9ZVnlatWinXykd6AQAAAMC0jPCBUvh5Di+XnVukRs3aKNCW4/qgAAAAgL+xlqop9OvXTxs2bHBqPX5TsBo7dqzy8/M1efJkBQcHu2UbiYmJOnLkiEPLRAQGSp3cEo5bHD16VDnFxabDAAAAAADUzZTCnVs0MSFBKs5ybTwAAADAGRw7dszpZf2mYLV+/XoFBARo1KhR/5iWlVXSSF+xYoXq1asnSYqPj1e1atUc2sbJZR0RHuBbQzDExcXxhhUAAAAAeIHsEJvSnFjOYstX/Xo1ZVF1V4cEAAAA/IPValVCQoIkKTbW+VHi/KZgJZX8o1RUvSssLDw13epEUWbt2rUOL2PLy1PRqNEOL2dKfHy8LGFhpsMAAAAAgCovPbNAcYO/cfg7VneMOkfvP3HQTVEBAAAAp8vOzlZUVJQkadmyZU6vx7de/6lAWlqabDZbmT9PPfWUJGnAgAGnflejRg2zAQMAAAAAUIHq0SG6/qIWDi839qq2bogGAAAAcC+/KVgBAAAAAOBv/jO2ixrVi7R7/vuub6+OrWq5MSIAAADAPfxqSEB/NSCmrgou/ue3uUo703QAAAAAgO+pXydCC6aM0PCxc7XvSGaF844d1UavPtDDQ5EBAAAArsUbVgAAAAAAeLFWTatr7beX6oXx3dS4/ulvW1ks0oh+DfXzu0P13mN9FBjIbT4AAAB8k8Vms9lMB+HPbHl5Kho12nQYdgua/pksYWGmwwAAAAAAlKG42Ko1W5J1PDVPoSEBatWkupo2iDYdFgAAAKqw7OxsRUVFSZKysrIUGWn/kNalMSQgAAAAAAA+IjAwQL3OqWs6DAAAAMDlGCsAAAAAAAAAAAAARlGwAgAAAAAAAAAAgFEUrAAAAAAAAAAAAGAUBSsAAAAAAAAAAAAYRcEKAAAAAAAAAAAARlGwAgAAAAAAAAAAgFEUrAAAAAAAAAAAAGAUBSsAAAAAAAAAAAAYRcEKAAAAAAAAAAAARlGwAgAAAAAAAAAAgFEUrAAAAAAAAAAAAGAUBSsAAAAAAAAAAAAYRcEKAAAAAAAAAAAARllsNpvNdBD+zGazSfn5psOwX2ioLBaL6SgAAAAAAAAAAIAPyM7OVlRUlCQpKytLkZGRTq0nyJVB4Z8sFosUFmY6DAAAAAAAAAAAAK/FkIAAAAAAAAAAAAAwioIVAAAAAAAAAAAAjKJgBQAAAAAAAAAAAKMoWAEAAAAAAAAAAMAoClYAAAAAAAAAAAAwioIVAAAAAAAAAAAAjKJgBQAAAAAAAAAAAKMoWAEAAAAAAAAAAMAoClYAAAAAAAAAAAAwioIVAAAAAAAAAAAAjKJgBQAAAAAAAAAAAKMoWAEAAAAAAAAAAMAoClYAAAAAAAAAAAAwioIVAAAAAAAAAAAAjKJgBQAAAAAAAAAAAKMoWAEAAAAAAAAAAMAoClYAAAAAAAAAAAAwioIVAAAAAAAAAAAAjKJgBQAAAAAAAAAAAKMoWAEAAAAAAAAAAMAoClYAAAAAAAAAAAAwioIVAAAAAAAAAAAAjKJgBQAAAAAAAAAAAKMoWAEAAAAAAAAAAMAoClYAAAAAAAAAAAAwioIVAAAAAAAAAAAAjKJgBQAAAAAAAAAAAKMoWAEAAAAAAAAAAMAoClYAAAAAAAAAAAAwioIVAAAAAAAAAAAAjPKrgtWYMWNksVgq/NmxY4fpMAEAAAAAAAAAAFBKkOkA3KFly5aqW7dumdMiIiI8HA0AAAAAAAAAAAAq4pcFq0cffVRjxowxHQYAAAAAAAAAAADs4FdDAgIAAAAAAAAAAMD3ULACAAAAAAAAAACAUX45JOD333+vGTNmKCMjQzExMerVq5duuOEG1alTx3RoAAAAAAAAAAAA+BuLzWazmQ7CVcaMGaPPPvuszGmRkZGaPHmyrr/+eg9HBQAAAAAAAAAA4J+ys7MVFRUlScrKylJkZKRT6/GrIQFbtWqlN954Q3/++afS0tKUnZ2tJUuW6Pzzz1d2drZuvPFGzZkzx3SYAAAAAAAAAAAAKMWv3rAqj81m08iRIzVz5kydddZZio+Pl8ViMR0WAAAAAAAAAACAT3PVG1ZVomAlSTt37lSbNm0kSRs3blTHjh0dXke3bt2UmJjo6tAAAAAAAAAAAAB8ktVqVUJCgiSpU6dO2rBhg1PrCXJlUN6sdevWqlWrllJSUrRr1y6nClaJiYk6cuSIG6IDAAAAAAAAAADwbceOHXN62SpTsJKk4OBgSVJRUZFTy9erV8+V4QAAAAAAAAAAAPg0m82mk4P51a9f3+n1VJmC1fHjx5WUlCRJatiwoVPrWLt2rStDAgAAAAAAAAAAgKQA0wF4ymuvvSabzabq1aure/fupsMBAAAAAAAAAADA//ObgtX8+fP18MMPa8+ePaf9PicnR88884xefvllSdIjjzyikJAQEyECAAAAAAAAAACgDBbbyYEFfdyMGTM0cuRISSVjJDZo0EBWq1Xbt29Xbm6uJOn222/X5MmTZbFYTIYKAAAAAAAAAACAUvymYHXo0CFNmTJFK1eu1O7du3X8+HEVFxcrNjZWvXv31m233abBgwebDhMAAAAAAAAAAAB/4zcFKwAAAAAAAAAAAPgmv/mGFQAAAAAAAAAAAHwTBSsAAAAAAAAAAAAYRcEKAAAAAAAAAAAARlGwAgAAAAAAAAAAgFEUrAAAAAAAAAAAAGAUBSsAAAAAAAAAAAAYRcEKAAAAAAAAAAAARlGwAgAAAAAAAAAAgFEUrAAAAAAAAAAAAGAUBSsAAAAAAAAAAAAYRcEKAAAAAAAAAAAARlGwAgAAAAAAAAAAgFEUrAAAAAAAAAAAAGAUBSsAAAAAAAAAAAAYRcEKAAAAAAAAAAAARlGwAgAAAAAAAAAAgFEUrAAAAAAAAAAAAGAUBSsAAAAAAAAAAAAYRcEKAAAAAAAAAAAARlGwAgAAAAAAAAAAgFEUrAAAAAAAAAAAAGAUBSsAAAAAAAAAAAAYRcEKAAAAAAAAAAAARlGwAgAAAAAAAAAAgFEUrAAAAAAAAAAAAGAUBSsAAAAAAAAAAAAYRcEKAAAAAAAAAAAARlGwAgAAAAAAAAAAgFEUrAAAAAAAAAAAAGAUBSsAAAAAAAAAAAAYRcEKAAAAAAAAAAAARlGwAgAAAAAAAAAAgFEUrAAAAAAAAAAAAGAUBSsAAAAAAAAAAAAYRcEKAAAAAAAAAAAARlGwAgAAAAAAAAAAgFEUrAAAAAAAAAAAAGAUBSsAAAAAAAAAAAAYRcEKAAAAAAAAAAAARlGwAgAAAAAAAAAAgFEUrAAAAAAAAAAAAGAUBSsAAAAAAAAAAAAYRcEKAAAAAAAAAAAARlGwAgAAAAAAAAAAgFEUrAAAAAAAAAAAAGAUBSsAAAAAAAAAAAAYRcEKAAAAAAAAAAAARlGwAgAAAAAAAAAAgFEUrAAAAAAAAAAAAGAUBSsAAAAAAAAAAAAYRcEKAAAAAAAAAAAARlGwAgAAAAAAAAAAgFEUrAAAAAAAAAAAAGAUBSsAAAAAAAAAAAAYRcEKAAAAAAAAAAAARlGwAgAAAAAAAAAAgFEUrAAAAAAAAAAAAGAUBSsAAAAAAAAAAAAYRcEKAAAAAAAAAAAARlGwAgAAAAAAAAAAgFEUrAAAAAAAAAAAAGAUBSsAAAAAAAAAAAAYRcEKAAAAAAAAAAAARlGwAgAAAAAAAAAAgFEUrAAAAAAAAAAAAGAUBSsAAAAAAAAAAAAYRcEKAAAAAAAAAAAARlGwAgAAAAAAAAAAgFEUrAAAAAAAAAAAAGAUBSsAAAAAAAAAAAAYRcEKAAAAAAAAAAAARlGwAgAAAAAAAAAAgFEUrAAAAAAAAAAAAGAUBSsAAAAAAAAAAAAYRcEKAAAAAAAAAAAARlGwAgAAAAAAAAAAgFEUrAAAAAAAAAAAAGAUBSsAAAAAAAAAAAAYRcEKAAAAAAAAAAAARlGwAgAAAAAAAAAAgFEUrAAAAAAAAAAAAGAUBSsAAAAAAAAAAAAYRcEKAAAAAAAAAAAARlGwAgAAAAAAAAAAgFEUrAAAAAAAAAAAAGAUBSsAAAAAAAAAAAAYRcEKAAAAAAAAAAAARlGwAgAAAAAAAAAAgFEUrAAAAAAAAAAAAGAUBSsAAAAAAAAAAAAYRcEKAAAAAAAAAAAARlGwAgAAAAAAAAAAgFEUrAAAAAAAAAAAAGAUBSsAAAAAAAAAAAAYRcEKAAAAAAAAAAAARlGwAgAAAAAAAAAAgFEUrAAAAAAAAAAAAGAUBSsAAAAAAAAAAAAYFWQ6AH9is9lUlJtvOgyXCwoPlcViMR2Gz/HlfGCfu44v5gH737XIgarLF/d9aeRB5flyDrD/XccX84D97zq+uP9PIg9cx9fygH0PV/O1Y0DiOHAVX9z3J5EDruOLecD+N4eClQsV5ebrqxbXmw7D5a7b86WCI8JMh+FzfDkf2Oeu44t5wP53LXKg6vLFfV8aeVB5vpwD7H/X8cU8YP+7ji/u/5PIA9fxtTxg38PVfO0YkDgOXMUX9/1J5IDr+GIesP/NYUhAAAAAAAAAAAAAGEXBCgAAAAAAAAAAAEZRsAIAAAAAAAAAAIBRFKwAAAAAAAAAAABgFAUrAAAAAAAAAAAAGBVkOgDgTPLyi7Rg1VGt3ZqsdduSFX8gQ7n5RQoIsKh6VIg6tqqprm1j1KdTrLqfHSOLxWI6ZLjY8ZRcLVh1VOu2JWvd9hM6lJil/AKrgoMCVLdWmDq3qa2u7WJ0Xo/6atGomulw4Qbx+9O1eG2C1m0/ofXbk5Wcmq/CIqtCQwLUpH6UuraLUdd2MRrSK061a4SZDhcuZrPZtGpTklZtOq5125K1KT5FGdmFslptiggLUuum1dW1XYy6tY/R4J5xCg0JNB0yXCy/oFgL/ziqtdtK2gI79qUrJ69IFotUPSpEHVrWUtd2tdWrY131PqcubQE/lJKer/krj5S0BbYl60DCX22BmJqhp9oCA7vVV6um1U2HCzfYezhDi1YnaN22ZK3ffkJJKXmn2gINYyNL2gJtS9oCdWuHmw4XLmaz2bR2a7JW/HlM67ad0Mb4FKVnFai4uKQt0LJJNXVtW9IWGNIrTuFhdHX4m8JCqxatOao1W5K1bnuytu9NU3ZuSVsgOiL4/9sCMerZoY76do5VQID/tQW27UnVknWJWrctWRt2pOhEWp6Kim0KDQlQswbRp+6JhvaKU41qoabDhYtZrTat+PPYqXuizbtSlJlTKJtNigwPUptmNdS1XW11b19Hg3rEKTiYdxT8TW5ekX7/o/z+0XNaldwT9ekUq27t6R/1R0kncvX7H+X3j3Zp+//3RN19u3+UVhy81t7DGZo8fYem/hSvlPT8cufbFJ+iL3/eI0k6+6yauuuqtrr+ohaKjgzxVKhwA5vNppUbkzRp2nZ9N2+fCgqtZc6370im/th8/NR/D+0dp3FXt9OF/RspKIgGmi8rKrJq5qIDmjRtuxauTih3vj2HMk9NDw0J1NXDm+uuq9qqR4c6ngoVbpKRVaDPZ+/WpGnbtX1vWrnz7dyfrln/OyhJiqkZplsvb6U7rmijpg2iPRQp3OVgQpYmT9+hj37cqeOpeeXMla3Nu1L19S8lbYE2zapr7Ki2Gn1JS1WPpi3g69ZsOa5J07br29/2Ki+/uMx59h3J1JotydL/sXff4VFUbR/Hf5teqaGE3jsIAoKAgCIdUexiw4YdewGxYu8dO/aCilSlifQivdfQISGEENLb7r5/8MIDkoTdze6e3c33c11c1/Mwc2ZunHtnzpx75oy2SpIu7Bive65prksvrMtgjZ+zWm2aNn+fPv5ls2YsPlDsegn7MjRvRZIkKTQkSFf1qa97rmmuLm0pYPu7zOwCfT/1eF9g/fajxa63bc8xTZu/T5JUsVyYbr2sie6+prlfD9bguAOHsvTZb1v12e9blJSSU+x6GxPS9PP0nZKkRnXK6e6rm2nYpU1Uqbx/F27yC6yaMHu3Pvp5sxauPlTsegn7MjR76UFJUlREiIYOOH5P1K55nLdChYekHsvT15O2aez4LdqxN73Y9bbsOqaJc/ZIkqrHRWr4Fc10xxVNVat6tLdChYck7Ds+PvrVxLOPj343dYckqXXjE+OjjRQTFeqtUOEBdrtdi9f8b3y0oNCx8dE+XWrqnmuaa1D32goO9q97IovdbrebDiJQFGTn6oeGN5R6O9XPb6l+E54/fdtZOUrfmaiE3+Zr85d/ym4tOjk94fqE7xUa5b03FvLyrRrz6Wq9+tU6Wa2upWf1uEh9+nRXDb6wrpujc1xp8sF0Dnj7mP/XoSM5uufFxZrw926Xt9G+RZy+HnOBWjWu5L7AXOBqHpjMAdPHX5LWbDmiYU/P19qtqS5v49p+DfTByPMVV9Hsv4UccM1vM3fpnpcWl1CkKFlIiEWj72irUbe3NTZg7c/XAclsHhQU2PTqV2s15tM1xXbIzyauYoQ+GnW+ru7bwM3ROc6fc8D0eeBIWq5GvLr0ZCHSFa0bV9TXY7rr3BZmB+u4Drhm446juuWZ+f9fjHTNZRfV1djRXVQ9LsqNkTmH84DrpszdqzvHLFLi4WyX2gcHW/T4sDZ69u52xt++diUPyvo5wGq16e1vN+jpj1YpL7/oBxbOpkJsmN5/srNuGNTIL4vXy9Yla9jT87Vl1zGXt3HLZY319qOdjL9xxbXQeXa7Xd9P3aERry5VWka+S9sIDwvWmHvP1cM3tTI2YM110HV5+VY9P3a1Xv/a9fHR+CpR+vTprrqkZx03R+cczgGuSUrJ1t0vLj5ZjHZFh5Zx+npMd7VsVNGNkXkWb1j5sJ0TFmj/nFWSxaLIKhXU6KoeOu/5YSrfuKaWPPap6fA8Yt22VF3/5Fxt2FH803OOSErJ0aUPzNb1Axtq7Ogufvu2VVnMgd9n7dKdYxbpSFrxT404YuWmFJ17zSQ9f8+5evK2Nn55gyKVvRyw2ewa8+lqvfj5GhUWlu55ip+n79Scfw/qi+cuMN45K42ylgNp6Xm6c8wijZ+xq1TbKSy067mxqzXxnz364ZWeatHQfzpnpyprx1+StuxK0/VPztWqzUdKtZ2Uo7m65rF/9OvMXfrs2W6q6KdT45TFHJg2f69ue3ahDh0p/kl6R6zfflTnXT9Zo24/R8/e1c7vniw8oazlgN1u1xvj1uvpj1YW+4a9oybO2aP5K5P0ydNddVWf+m6K0PvKWg5kZOXr3peWnHxK3FVWq12vfLlWk+Ye7wu0bVbZTRF6V1k7/tLxtwmuf3LuaU+KuyItI183PTVf42fs0lcvXKAqlfxjutDCQptGf7hSb3y9XjZb6e6Jxk3crpmLD+jrF7vr4s413RSh95W130HK0Vzd+swCTZm3t1Tbycu36vF3luv32bv1/Ss91aiOf751WtaOv3T8Id7rR87VpoS0Um0n8XC2Bo+YpRsHNdJHT53P+Kgf+W3m8fHRkt6qc8SKjSk695qJev6ec/XErf4xPuqfd21lxJH1u7Tz9wXa+dt8bRw7WdMGjlLWgRQ1GdpL4ZX98yJTkoWrknTBsKmlLlad6odpCep1x186kubaE/qmlbUc+PCnTbrykTmlLladUFBo06j3V+j25xbK6sW3Et2pLOVAYaFNNz01T8+NXV3qYtUJyam5uvSBWfri961u2Z4JZSkHDqfm6MLb/yx1sepUa7akqtvNU7VsXbLbtulNZen4S8enf+t609RSF6tO9dus3ep565+lLn6YUtZy4Ks/tmnwiNluO15Wq11jPl2jG0fNU0Epix+mlKUcsNnsuvOFRXri3eWlLladkHosT1c/Okfvfb/BLdszoSzlwNH0PPUePr3UxapTbUpIU/dbpmneiuKnmPZlZen4S8cfYu1y45RSF6tONXX+Pl0wbJr2J2W5bZuekpdv1VWPztFrX60rdbHqhAPJ2ep/zwz9VIq3lk0rS7+DA4eydMGwqaUuVp1q2frD6nrTFK3d6r4+tjeVpeMvSfNXJKr7LdNKXaw61XdTd+jiO6aXuvhhSlnLgfd/2KirHp3jtuOVX2DTyPdWaPjz/jE+SsHKjxTm5Onwqu2yBAWpXN1qpsNxq+UbDqv/PTOVnlnggW2nqP89M5SR5dor1L4kkHPg89+26P5Xlnhk21/9sU33vLRYgTADaqDmgM1m1+3PLdQP09x/E2W3S3c8v1DfTt7u9m2bEKg5kJaepz53TdeaLa5PA1mco+n56nv3DL+9QTtVoB5/6fgAVZ87PXMTdWLbR9P98wbtVIGcAz9M26Hbnl3gtgG6U/30107d+ux8j2zb2wI1B+x2u+57ebE+99BDJg++vkyfjN/skW17W6DmQGZ2gfrfPcOthYoTMrIKNPDemX77AMupAvX4S9LWXWm6+I6/lJzq/gdOt+4+pouH/6VkH36ApbDQpuufnFuqqZ+K37ZdN4yapwmzd7t92yYE6u/gcGqOLh7+V6mmgSxOcmqueg+frq270ty+bW8L1OMvSf+uP6wB985URpb7x0f/3XBYA+6Zocxs92/b2wI5Bz79dYseeG2pR7b9xYRtuu/lJT4/PhqQBauZM2eqX79+qly5sqKiotS6dWu98sorys/3/4JFbL3jP8K8tEzDkbjPsYx8DXlwtkdPmMs3pOi+lz1TDPG2QMyBFRsP6+6XFnt0H5/9tlVfTtjm0X14SyDmwEc/b9I3Hi4o3f7cQq3b5v5iiAmBmAPDX1jkkWLVCccy8nXZA5691nhLIB7/rOwCDXlwtsvz8zti3bZU3f7sQp/vnDsiEHNgw/ZU3fL0Ao/u4/upCfrgx40e3Ye3BGIOfD1pu8aO3+LRfdz78hL964FiiAmBmAMjXl3ikWLVCVk5hbr84b8D4uGFQDz+uXnHj4+r3y91xNbdx3TTU/N8ti/w+rh1+t2DBSWbza4bRs3Vjr3pHtuHNwXa78But+ump0r3zbKzOXw0V5c//Ldy8wo9tg9vCbTjLx1/iHPIQ7OVleO547Ns/WGPPSzubYGYA/+uP6x7PDw++smvWzRuom8/0B1wBau33npLffv21YwZMxQbG6umTZtqy5YtGjVqlC688ELl5Pju0zT/FRIZpvBKsQqvXE4VmtVRp5dvV+XWDXR41Xal7/TP6QyK8vCby3Qg2bkP6S7/abD2zbpWy38a7HCbb6fs0JS57nul2hvKQg7k5Vs1bPR8pz8g6UoOPPzmMu1N9K8LWVnIgYR96Xry3RVOtXHl+BcU2jRs9Hy/mxKqLOTArzN36deZzk0D6EoO7D6YqSfeWe5seEaVheMvSSPfX6Gd+zOcauNKDkz4e7d+mb7T2fCMKgs5UFho0y3PLFBBoXPnZ1dyYOT7K7R9j+cGgjyhLOTA/qQsPfi6c0+SunL8bTa7hj093+8G6spCDvy5YJ/Tgyeu5MDB5Gw99PoyZ8Mzqiwcf0l6/pPVTk9/5UoOzFh8QF/94XsPMm7Ynqrnxq52qo0r//6cXKtufcb/3jguC7+DcRO3a/qi/U61cSUHNiWk6flPnMs108rC8Zekh95YpoNeGB/9etJ2TZvP+Kivyc0r1LCnnT8/u5IDD72xVPuSfHd8NMR0AO7077//6rHHHpPFYtG4ceN08803S5ISEhLUr18/LV68WCNHjtS7775rNlAHtXv8WrV7/NrT/m73tKVaNvILQxG535xlB13qLFaPi1KtatFOt7tzzCJdeF68YqJCnW5rQlnIgVe/XKuNLszL60oOZGQV6J6XFmvqh32c3p8pZSEHhj+/UNm5zg0cuXoOWL3liN7+br2euPUcp9uaEug5cCwj36UniFzNgY9/2azr+jdQt3OrO93WhEA//pK0ZO0hffDjJqfbuZoD972yRH271lLFcuFOtzWhLOTAu99v1IqNKU63cyUHcnKtGv7CIv3z5QCn92dKWciBe19e7PTU4K6eAzbvTNPLX6zVC/e2d7qtKYGeA9k5hRr+/EKn27maA99M3q6hAxqoT5daTrc1IdCPvySt2XJEr49b73Q7V3Pg4TeXaVCPOqpWOdLptp5gt9t127MLnX5ww9V//4JVh/Tpr1t09zXNnW5rSqD/DpKP5OihN5yfAszVHHh93Hpd07eB2jar7HRbEwL9+EvS7KUH9PUk5996cTUHhr+wSNsmxyua8VGf8fIXa7V5Z5rT7VzJgfTMAt370hJN/qC30/vzhoB6w2rMmDGy2+265ZZbTharJKlhw4b68ssvJUljx45VcrJ/zFu99buZmnH185p1/UtaMeY75aZmKDq+sqx5/5sup8fYh9Tj04dPaxdWIUZXr/lcDS6/wNshO+2Nr53vlJZG4uFs/ehHHxoN9BzIzSvUBz85P0hZGtPm79OmhKNe3WdpBHoOrNqUojn/evdpmHe/36j8AqtX91kagZ4D30zerhQPTv1SlLe/2+DV/ZVGoB9/SXrrG+8ejyNpeS7dDJoS6DlQUGDTO997NwfmLk/Uio3+My1coOfA1l1pmuzlWRA+/GmTsj043Y67BXoO/PRXgtMzbpTWm9949z60NAL9+EvH++fefOMnPbNAn/3m2SlInTF/ZZL+3eDd69Jb3673q7esAv138NnvWzzyTffi2Gx2vcM9kU/x9vjoweRs/fSX/8w8Eeg5kJNbqA+9PD46Zd5ebfHRb9oFTMEqIyNDM2fOlCTdcccdZyzv3r27mjRpovz8fE2ePNnb4bkkfWeSEhes14E5q7Xh40n6++ZXFde2oc5/7c6T6ywZ+bmqdmyq+pd1Pfl3nV++Xcn/btHOCZ79DkBpJexLd/p1Z3f46OfNPjtn9X8Feg6Mn7FLR9K8P4e8p7+P4E6BngNjDXz8PCklxyMfMvaUQM4Bu92uj3/xfg5M+mev9idleX2/rgjk4y9JBw5laeI/3v89jh2/2W8GaQI9BybP3eP01CfuYOLc46pAzwET/bKj6fn6ZYb/DNIEcg7Y7XZ99LP3f4+zlhzUtt3+MT1oIB9/STqSlqufDUzX++mvW1To5BtNnmLimpSwL0MzFx/w+n5dFci/g8JCmz79davX9/vLjF1ef3DQVYF8/CVp+55jRn6PH/2yifFRH/HLjJ06mu657zkXZ6yP3hMFTMFq9erVys/PV3h4uDp06FDkOt26dZMkLV3q/Gu2vuDwiq1K+G2+6l/WVVU6NJUk5adlavEjY9XppdsVWa2i6g7srOpdWmrJE58ajvbsTD3dvG5bqlZtPmJk36UVaDnw1UQzc4d/M3m7333H6IRAyoHcvEL9YOiNxy99cN56RwVSDixZm6ytBgaLbDa7vpnsP2/YnCqQjr8kfTd1h9PfMHSH7XvStXBVktf36w6BlgOm+gI//bXTr96wOVUg5UBhoc3Y+Zi+gG9Yty1Vq7eYuTcbN8k/cyCQjr90/Hycl+/92Q8OJGdr5hLzBZuj6Xma8PduI/v+8g/vF0ncJZB+B7OXHtT+Q95/mC4v3+pXMxCdKpCOv2RufHTNllStMXQNLq1AywFT31b8ZsoOn3l441QBU7Datu34ga1bt65CQor+NFfDhg1PW9cfrX3nN9kKrWr32DUn/+7AP2u0e8pidf9whDq/eocWPzJWeUd998NpJyxec8jYvpes9Y9pIYsSKDlQWGjz+rQHJ2RkFWjTTv+ZFvC/AiUH1m5NVU6uman5lq5L9pu3K4oSKDmweI25c/GSdVwHfAE54JpAyQG73W6sT5abZ9Warf55gy4FTg5s2ZWmtAzvP00qSSs2pvjtA0xS4OSA0esA94Q+oayPC6zYmKLCQjP3Jb7w7y+NQPkdLF5btn8DrgqU4y9Jiw0eB3LAvIICm/7d4Pz3fN3hWEa+S9/N8rSAKVgdPXp88LlixYrFrnNi2Yl1/VHG7iTtmrRINbq3UdVO//tA5ornv1Vs/eo6MGe19v+9ymCEjrHb7Ubfclq5ycyJwB0CJQc270wzVqyQpJWb/HeQKlBywOTvMD2zQAn70o3tv7TIAf/ed2kFyvGXpJWbTeYA1wHTdh3IMDL1xQmcB8wz+TvMy7dqox991/S/AicHzP0OV20+4rcPMAXK8ZfMngd84TpgMoYDydk6dCTH2P5LK1B+B0bviQz2xUsrUI6/zWbXKpP3RH46A5UUODmwaedRI28an+CL54GAKVjl5h6fdzUsLKzYdcLDwyVJOTnOXZDtdruysrKUlZXlE3N7rnvvd9msp1eQC3PylLknWUc3e/eDxa7al5Rl7GlK6fibHf4sEHJg3Xazx2DdNnLAtLWGjwE5YJ7JHEhKyVGyH9+gB8LxP5KWa+TbRSfQFzDP9HmYHDDPdH+QHDDPZA5kZBVoz0Hffuq6JIFw/HNyC7Vtj7lviZm+DvlCDGv9+G1jKTB+B+u2mXt4YvuedL+dIlkKjOO/NzFT6ZkFxvZv+hxUWoGQA6b7o+7MAXfVUCx2X6jAuMEbb7yhxx9/XJ06dSr2G1Vjx47VPffco1atWmn9+vUObzsrK0sxMTGSpPj4eAUFFV3nC7UH6Vnbec4H7yb9fn9e+2at1MZPJrt1u88H/asCi3unyygIrqrk8vcWuWz5T4NVPS6qxPbV4yIVEhykQqtNSSnFDzgmpWSr43Vn/vcIth5R9WPvOxe0k0zkg7tywBPH/L8ywzvqWPSgIpd5Iwei8lapYtYk54J2gbfzwB054I3jL0mp0VcqJ7x1kcvOlgOOHn+p+ByokPmHovPXOBWzK8iB4iVWeFi2oPJFLnNXDhR3/CWpWtp7CrF5rnPoz9cByfN5UBhUQYcqPFTsck/nQJAtQ/FpbzoXtJP8OQe8cR7IDjtHR2MuL3KZN/oCkXkbVCnrV+eCdgHXgeIdjRqs7Ij2RS7zRl+gfNY0xeT961zQTuI8ULJD5e9TYXCVIpd5IweqHvtYoVbPT8flzTzwp3OA1RKtpIqPF7vc030Biz1XNY6+4lzQbpYSM1R5YU2LXOaN30CljJ8VWbDZuaBdwLWweAcrjJQ9KKLIZd64J6p+9HUF2z33DS2ugyUrCK6m5PL3FLnMG/3hEGuKqh37wLmgXcA5oHiZ4efpWPTAIpd5ZXw0d6UqZrunlmCz2ZSYmChJatu2rVavXu3Sdor+2JMfcmS6P0emDTybE//RixJmCZaqubxpn3Uw8aDy7W5+NTHCIhU9RqnqcVGqVS3aoc2EBAc5vO6prFabDhzw7AdW/TkfPHLM/6tyE6mYQ+eNHMjOzlW2h3NA8s888Mrxl6TauVJ40YsczQFXj78kpaWlK+0oOVAUr+VArL3Yd729kQOHDiVL+Z4bpPLHY38qj+dBWL5UofjFns4Bm81OX6AEXjkPVKgrxRS9yBt9gZzcXI/ngOSfeeC160DNHKnoMTqvXAeOHUvXsSOcB4rjlTyItknBRS/yRg4kJ6dIuZwH/str54CQclIJwzOezgG73eKV60CJ6uVLxUwU5I3fQOrRNOkYv4GieO13UMzYmOSdHEhKOiQVeu5NR3889id4JQcigoyOjxYWen58VPLPPPDaOaByekCOjx465PpYS8AUrJo0aSJJ2rNnjwoLCxUScuY/LSEh4bR1XXG2N6zkv9/tLVaN+Bruf8MqqJKK+6xfUsrZpwdypnpclJAgu6rVrOlIqC7z53zwxDH/r6ywGKUVs8wbORAdGaoKHs4ByT/zwBvHX5KORoaouCN9thxw9mnColSsEK2oKHKgKN7KgaQgm4rr/rkrB0raTrVqlRRi81xXyB+P/ak8nQdWS6ySSlju6RwItlhVnb5AsbxxHsgOi1Fxj5p5oy8QGRGqSvQFiuSt60BaVJiKe6bbG32BCuWjFR3BeaA43siDQ8F2FTcZlTdyoGqVigq1eX4wyt/ywFvnAJslXMU/Euz5vkCQChXvhetASY6EByu3mGXe+A1UqhiryBiuhUXx1u8g0WIt9j+NN+6J4qvHKchezBNEbuCPx/4Eb+SA8fHRYJvHx0cl/8wDb50DssKjzY6PRrlvfPTUN6yqVXO9QhkwUwJmZGQoLi5O+fn5WrJkiTp37nzGOk2bNtW2bdv02Wef6Y477nB426dOCZiZmano6KKrlQXZufqh4Q2u/QN82PUJ3ys0qphHH12UX2BVbOdvlV/g2g9/36xrVatatPYfylLt3j873X5Ir7qa8M7FLu3bUf6cD5445v+1cFWSLhg2zeX2pc2Bdx7rpAdvbOXy/h3lj3ngjeMvSa98sVaj3l/hUtvSHn9JWvHzpWrfIs6lts4gB4o34J4Z+mvhfpfaljYHoiNDdGzxjQoO9tznPP3x2J/K03lgs9lVoet3yshybc720uZAny41NeOTfi7t21H+nAPeOA+s2XJE7a6e6HL70ubAmPvO1ejh7Vzev6P8MQ+8dR14/4eNeuC1oqdzPxt39AXmfjVAPTrEu9TWUf54/E/wRh5c9cjf+m3WbpfaljYHQkOClLH0JoWHFfOKlxv5Wx546xxgt9sVf9FPOuTid0VLmwNd21XTwm+KnqbeW0a9t0KvfLnWpbbuOA9unXylmtQr4RUfN/G334Dkvd9Bt5unatFq195EKG0OVK0UoaR/hspisbi0f0f447E/wRs5kJd/fHy0oNDM+OiVvevp17d6ubRvZ/hjHnjrHDB/RaJ63Pqny+1LmwPvPdFZI65v6fL+T+VoDeVsPDdK42WxsbHq3bu3JOnzzz8/Y/n8+fO1bds2hYWF6dJLL/V2ePiPsNBgtWlSydj+O3hhkBola9ussoKCPNcpOhtvFCpQsg4tzR2D0JAgtWrk+vSwcA+TOXBu88oeLVbh7IKCLDq3eWVj+6cvYF7LhhW9MlBcnA4tiv5uDrzH5HXAYpHaNTN3DsJxJnOgVSOz5yBIFovFaA60N9gPORlDC3MxlIsJVaM65YztH8eZ7JN2aBnn0WIVzi48LFitG5sbm2BszLx2zSvL5M/QF3MgoEZqRo8eLYvFonHjxumbb745+fcJCQm67bbbJEl33nmnqlataipEnML0RRlmxUSFqnl9zz/JVZSgIIvaNjNXMMVxJi+KbZpUYoDCB3AdADlQtoWGBukcgw8wmRwkxHFtm1ZWcLCZO/Sm9cqrXEwxH46B15gsHHMd8A1lvS9gtmAXZ/QhUhxnMgd4eMc3GM0BHzgPlnWx0WFqVr+CkX0HB1vUtqnvjY8GVMGqc+fOevXVV2W32zVs2DDVq1dP7dq1U7NmzbRjxw516tRJr776qukw8f+u7d/AyH6rVopQz46enfoDjjGVA4O611ZsNAMUplUqH64+XczMGX9tPzO5h9P1Pr+mKpYz81u8tl9DI/vF6UxdB8rHhqlvl1pG9o3TmcqBXp1qqEqlSCP7xv9ERYZocM86RvZNX8A3dG9fXdXjzPwWyQHfcI2h4xAZEaxLepg5/5yqbo1YdW5jpmhg6hqM0w3qXltREZ77rm5JrulX38h+cTpT16PqcZHq3r66kX3jdKZy4JIedRQdFWpk3yUJqIKVJD3++OOaPn26evfurWPHjmnLli1q0qSJXnrpJc2bN09RUVGmQ8T/696+ulo2rOD1/d5xRVOFhfJmhS+4/fKmCg3x/mnonmuae32fKJqJYxERHqxbLmvs9f3iTJERIbr1siZe32/7FnHq2IonyXxBh5ZVjByLWy5trKhIMwMDON2wSxsrMsL7/TL6Ar7DxLEICbHojiuaen2/OFNoaJCGX9HM6/ttVr+8LjyPhxh9QfMGFXShgQdKrx/QUBXKhXt9v0UxcR4sFxOqoQN4gMsXVCgXrusHev9Y9OwYrxYNmSbfF/TsGK/mDSp4fb+Mj/qO2y9vopAQ77/x6qv3RAFXsJKkvn37aubMmTp69KhycnK0ceNGjRo1SuHhvtEZwXEWi0X3XdfCq/sMDQnS8Cu9f0OEolWPi9JVfbz7RE+TuuXV+3wzb/XgTAMvqK16NWK8us+hAxqqcgXPfzgTjrnr6uZenw7qvuuaM1e7D7nfy32BoCCL7rqKvoCvqFguXDcMbOTVfdauHm3srR6cqVenGl4fpLni4nqqUdW1j0DD/YZf2VRhod4dmrjvuhb0BXyIt8cFJOnea72/z+Jc1ae+qlby7v3JrZc1UYwPPlVfVt17rfcHjb3dB0fxLBaL7vNyDoSGmHlgBEWrUTVaV1xcz6v7bFa/vHp1quHVfTqKR0th1O2XN9VXE7dp+YYUr+zv6Tvbqk68dwfHUbLXH+qoaQv26VhGvlf298nTXXx6nu7Y+tV1wXv3K7xSrAoysrXwgQ+Vtm3/aevE1Kqibu/dp0qt6ilzb7Im937s5LLqXVup/VPXKzQ6Qna7tH/2Sq186QfJbvf2P8UhISFB+vipLhpw70yv7K9yhXC9PKKDV/bliuDwUPX45CGVb1xL1tx85aYc05InP1fG7qTT1guJitCFXz6qym0aKCg4WD82u/nksgrN6qjzK7crMq68bIVWpazeoaWjvpA11zu/MWc1qlNOT9zSRi9/sdYr++vWrppuuoQ37HzJ9QMb6YsJ2zR/ZdLZV3aDx4a1VlNDc4SjaC/e115/zNmjlKO5Xtnf2NFdFGLgDW9X1R3YWfEXtNbSJz/XeWNuVZ2+HRRTu6omX/yoUjfulnT260dx7XyBxWLR2NFd1PPWP72yv3IxoXrj4fO8si84pma1aD17Vzs99cFKr+zv3OaVfWKQzpF+vyQ1vu4itb5viBRkUdKiDVry5OeyF1pLvCeQ/r9P+NJtiqhy/LvBq179SXv/XOaT9wtDetVVv661NH3Rmf9+T7j32uZq28x3vmMYER6iD0aer2se+8cr+6tRNUrP3tXOK/sqCb+B/zmnaWXdd10LffjTJq/sr1/XWhrSq65X9gXHDL+ymb6auF0rN3lnfPTZu9qpVnXfenintONhVdo30fmv3iFJsoSGKPnfzVo2+ivZ8gtLXOYr3nj4PP21cL/SMwu8sr+xo7v67PgoBSsf4OhFuqT1znaTWvOidjr3yetksVhkCQnWho8nKeHXeQ4PjnpKSEiQvh7TXe2unqj8AptH93Vu88p68tZzPLoPd3BHPoRXjFHf8c+eXDc4Mlyxdavp59a3KT8t8+TfN7rmQnV7917NueU17Z2+3PP/uCLUrBatdx/vpFueXuDxfd1zTXNdeJ5vPj1wQpfX79S272dpx/i5qjuws7q9d5+m9n/ytHXyM3O06rWfFBYbpXOfvO70ZceyNO+ud5S5N1nB4aHqM/4ZNbqqh3aMn+vFf4Vz+l9QW7dc1ljjJm73+L4+HHm+qlX27W+WbP1ulg7MWS1JanZLP3V9625Nv+LZ09axFRZq/YcTlZ+WqX6/P3/aMmtevpaN+lJHN++RJShI3T9+QK3vvUxr3hrvtX+Ds565q50m/bNHGxPSPLqfyIhgffXCBT7bKTuVI9eCkq7hZ7sO1Lywrdo9cZ2CQkNkzcnT4sc/1dFNe7z9z5R0/I2nr164QG2u+EPZuZ69YWjeoIKeu9v8AM3ZlPb4lyY3TKhaOVIfP9VFVz86x+P7unlwYw3s7l9vV9UZ0EkJv86VJO2ZtkQbPp6oAZNePGO9kq4fJbXzBT06xOv+oS30wY+eH6h7+9FOql3d9x9gc/Se4GzFSEeKlb5wT/D4LW30x5w9WrHRswN1of9//xnq5Te6iuJIvz+mdlW1e/xaTenzuHIOp+mir59Q0xt6a8vX00u8JwiODFOvr5/QghEfKPnfLbIEBSms4vG898X7BYvFos+f7aaWl//u8YG6+jVj9eqDHT26D1dc3beBfp25S7/N2u3xfX3+bDefmA6R38DpXn2gg/5csE8792d4dD/lYkL1+bPdfP4tU3ddB4PCQtTx2ZtVs2dbWfPylbppjxbc9/5Zl3nb8fHRC9T+2kkeHx9t3yJOT9zaxqP7cEVpx8NSN+3WlP5Pyl5olSwWXfjlo2o2rJ82fTa1xGW+onb1GL39aCfd/txCj+/rvutaqKeB6XgdZb6XhpM/yD+6jdD6Dyeq23v3ubTe1u+OL5t88aPaO2O5ur5198ll3T8coYUPfKTJvR/T3ze+oi6v36mQ6IiztvOGFg0r6r0nOjvVJiklW/sPZSkpJduh9SuWC9P3r/T0iRuTs3FHPuQdzdTk3o+d/LPt+9k6MGf1aQNRMbWqqMn1Fyt5xVaP/5vO5ubBjZ2es9nZHGjXrLJee8j3bkxOFVG5nCqf01AJv8+XJO2ZtlTRNSortt7pH8HMT8tU8r9bVJidd8Y2UjfsUubeZEmSNa9AqRt2K6Z2Vc8HX0rvPNZZrRo5Pn+2s8dfkm4d0sTYR50dZc0rODnYKEmHV21XTO0zP8Jsyy9U0qINyj+WdcayjF1JOrr5eOHBbrMpZU1CkdvwJeFhwfrxtQtVLsbxaUlcyYGPn+qixnXLuxKi1zl6LSjuGl7SdSCsfLQu+PABLRzxgSb3ekTLx3yn7h894M1/3hka1i6nsaO7ONXG2RyIjQ7VD6/0UES47z+vVdrjX9IyR/oIJlzVp77T3xRyNgdaNKygdx/v5Ep4HhVWLkpXrfxU124cp8Gz3tBl89/Vjbt/Upc375IlJFjVOjZV4sINkqRDSzcrOzH1jG2c7fpRXDtf8sqIDmrfwvFv2rlyHbimX33dOsT73050haPngT3TlujPS0crc1+yS8t95Z4gJCRI37/cQ5XKOz6I7koOvPN4J7VuUsmVEN3K0X5/3UGdtW/mCuUcTpMkbf12puoP6Sqp5HuCBkMu0OGV25T87xZJx/uEeUfSJfnu/UKt6tH66vkL5MwYurM5EBkRrB9e7eGzU+F9/FQXNapTzuH1XfkNPHhDSw24oLYr4bkVv4EzRUeF6sdXezr1bU9nc8Bikb547gKfe7OmKO66DrZ/6gbJbteErvdr0kWPaMXz3zq0zIRWjSvpncec66s6mwOVyofr+1d6+NxsA+4YD7Pm5B8vSEkKDgtRSETYyTcnS1rmS24d0kTX9Xdu3MrZHDi3eWW98oDvzjwkUbAyztEf5NnWO9tNqt0uhZWPkiSFxkYp92iGbPmFDg+OetpdVzfXqw86/mPpeN1k1e79szpeN/ms65aPDdNfH/c18gFDZ7krH/6r8dCLtP2nv//3FxaLurx1t5aN/tInXn+1WCwa90J3XXaR46+kO5MDLRtW0PSxfX32xuSE6Jpxyjl0VHbr/56myTyQouiajg/enCqySgXVG9RZ+2Z7Z3qV0igfG6aZn/ZT03qOFROcOf7S8QGqT5/u6vNPkf1Xi9sHaO8M1590DokMV5Pre5VqG97SpkklTfuwj2KjHfudOpsD7z7eScMu9Y9BSkfP8c5cw0+9DsTWq668oxknn1BMXrZZ0TXjVKm1d78p+F83DW6s9590/AEWZ3IgOjJEUz/orXbNXTufepM7jr+ruWHa2NFdnLpBcyYHGtctp5mf9POJJ8r/Kz89Wzv/WKBNX0zT5N6P6d9nxunwqm1a/Ogniu/aSsnLt568wXZUaa8fJkRHhWr62L5q3dixB1icvQ4M7llH377Uwy/6As709c9WjCxxuY/dEzStX0EzPumrCrFhDq3vbA68dH97n/lukaP9/piaccrcf/h/6+w/7NC9QYUmtWTNL1Cvb0dq8Kw31O39+xVe+cxCiK/dL1zRu76+eM7xopUzORARHqw/3rlY559TrZRRek6VSpGa9Wk/h7/x6+xv4LYhTfTWo77x4Aa/gaJ1alNVk97r7XDRypkcsFiOv13n7e+Iu8Jd18GQyHA1vu4irXr1p5N/d6L4WdIyk+65toVTnzFwJgcqxIZp+ti+auaD06O7azwsplYVDZ79pq7d+JXy07O15esZDi3zFRaLRV+/2N2p7+06kwOtG1f0i/FRClaGOfqDdPaH+9+b1Hl3va0Lv3xMVy4fq/6TxmjhAx/KVnDmTYnJm9snbj1HnzzdVeFhjj9Ncjb1asRo3lcD1KmN+adlHOGJfKjSoanCy0dr36z/dcBa3nmJkpdv0ZF1Oz3wr3BNaGiQfn3zIg2/0rmnq8+mZ8d4zf96kKr6+DRw7hYaE6le3z6p9R9P0pG1CabDcUh8lSjNHzdQXdu59yby/qEt9MMrPX3uCaKzaT3icsXWq66VL//gUvug0BD1+PRhHZi7Vnv/+tfN0XlGt3Ora84X/VWrmvue+IsIPz4N4AM3tHLbNj3N1c56cdfw/14H0ncmKrxirKp0OH6+rd2ng8Jio3ziydL7h7bUNy92d+rJ0rOpWTVKf3/eX907+O6UB6dy9/EvaVlRfQSTgoOD9N3LPfTgDS3dut3ObapowdeDVNON5xZ3q9SqvlLX75IkVW7TUKkbjv/vOv06ao+T5/DSXj9MiqsYoXnjBuqi89z7e7398ib67a1eCgt137nFk9z9EFNxfPGeoEPLKpo3bqDq14x12zbDQoP00ajzNeqOtm7bpq+zBAerxgVttOTxTzW592PKTjpy8tsdJ/jq/cKtQ5ro59cvdOtgWrXKkZr5ST/17VrLbdv0lHo1Y7Xwm0FOvXF6NhaL9ORtbfTZs938Ympsd/Dn30Dv82tq5if9VD3OfWMYMVGh+vn1C3Xb5e4db/EUd10HY+tVV35aptqMuFyDpr+m/hPHKL5b67MuM23k7efo46e6KMyNs0TVrxmreeMGqmMr3559pbQy9x/W5Isf1S9t7lBweKjqDujk0DJfEhYarN/e6uX07BNnc2HHeM39aqCqVPL98VHfnxPFzw2Y8pLKNSj6huu/H4R0lxM3qYuvPv5dE0twkM558Er9c9sbOrR0syqf01C9vnlSky56WHmpGcW2M+HOq5qpe/vqGjZ6vv7dcPjsDUpwzzXN9dpDHX2qamwiHxpfd5F2/Drv5IW+QtPaqjuwk/4a8oxH9lcaISFB+vSZbhrcs46Gv7BIB5Mdn9rgv6IiQvTqgx1077Ut/KZTnnUgRZHVKsoSHHTyeMXUjFPWAefm8g+JjlDvH0dr74zl2vSp78zH64iqlSM176sBevf7jRr94Url5jn3RPmpaleP1pfPX6De59d0Y4Te0fKuwao7oJNmXv28rDn5Tre3hASrx6cPKSf5qP59+isPROg5HVpW0YYJl+vRt5bpiwnbSrWtru2qadwLF/jcNICeuBaUdA3/73WgICNbc+94U+1HDVVIdIQOr9imo1v3Of0Gh6fcNLixurStplufma8Fqw6Valu3Dmmitx45z6feqvH28XcmN3xBcHCQ3nm8swZ1r6PbnlugPQddn6owPCxYY+49Vw/f1ErBwb790EKllvVOFqkqt2mgff9fYKzRs61WjPne4e2U9vrhCyqWC9esz/pr7PjNeuKd5crKcf3Nn/gqUfrsma4a1MO3vltm4p7gv3z5nqBNk0pa9/sQPfnucn308+ZSbatjqziNe6G7Wjox9bQ3ONrvzzyQonKnvFEQU6uKQ/cGWQdSlLh4o7KTjr91sPO3+er909Mnl/v6/cLVfRvovFZVdPtzC/X3soOl2tbQAQ31/pOdVblChJui87ya1aK15LtL9Pq4dXr+k9UqKHT9Ot2wdqzGvdBdF7QvejYWU/gNlKzbudW18Y8rNOLVJfphWumKab061dAXz3VTPTc+CFBa3roOWkKCFFO7qtK279fKl39QpVb11eeXpzWxx0MlLstNOea2GFx19zXN1b19dd3yzHwt31C67zvee21zvfqgb42P/pe7xsNOKMzO1a6Ji9Tg8gu0a9Iih5f5itDQIH327P/GRxMPl2589PWHO+ruq5v7zfgoBSsP+/OSp0pcbssrcOgH6egPt6ib1Eqt6iuyWkUdWnq8s39kbYKyE4+oUqv6Spy/rth2pjRvUEGLvh2kcRO36YOfNmn99qMOtw0KsuiSHrX1yE2tfa5DJnk/H0KiIlR/cBdN7f/Eyb+r1qm5YmpX1RWLP5B0/BX489+4S5FVK2rrtzNL/W90h4Hd62jjhGp657uN+uz3LUpKyXG4bUxUqG4c1FCPDmutBrUcn//bF+QeSVfq+l1qeEX3kx+ZzEpMVcbuJIe3ERJ1vON94J/VWvfu7x6M1nOCg4P0yM2tNbhnHb3x9Xr9MC1B2bmOD1bVrBql4Vc204M3tFS5GMemlPElLe4cpPpDumrm1S8oP935ToklOEg9PnlIeUcztfjRTzwQoeeVjw3T589doOsHNtJb36zXtAX7nJpeum2zSrr/upa6eXAjnxykdte14ISSruFFXQckKWnxRk2//FlJxz82fM3aL4r8iLEpjeqU09yvBurbKdv1wY+btGrzEYfbWixS/2619MhNrXVRpxoejNI13jz+ruSGr+jVuYbW/z5E7/2wUZ/+ulX7D535zb7iREYE6/oBDfXoza3V1AenPPmvqOqVJLv95KBapeZ1te693xXXrrGObT+gwuxch7ZT2uuHLwkKsujea1toQLfaevOb9fp2yg5lZhc43L5a5UjdcUVTPXxTK1X0oYL1Ce4+D7jC1+8JYqJC9eGoLrquf0O9+c16TZ67Vzab452BVo0q6r7rWui2IU188i17R/v9e6Yt1YBJL2rNm+OVczhNTW/qo10Tzz64tnvKYjUeepFCYyJVkJmjmr3OVeqm3ZL8536hXs1Yzfqsn376c6fe/3Gjlq137oHWPl1q6qEbWqlfN99/q6oooaFBemp4W112UV29+c16/fTXTuXlO/5wUd0aMbrrqma6/7oWivbBQWp+A2d3/FtDPXXjoEZ6+7sNmrn4gFPtO7WuovuHttDQAQ19bjpcb10Hsw6kyGa1aufvCyT97/tlFZvXUerG3cUuS1yw3oV/lfu1bFRRi7+9RF9N3KYPftykDTucGx8d3LOOHr25tdtnsfEEd4yHxdarrsz9h2UvtCooNER1+p+n1P//vndJy3zZoB51tPGPanrnuw36/PetTo+P3nRJIz16c2vVr+U7BWtHULAyzNEfpCPrFXeTmnUgRVHVKqp845o6tv2AYutVV2zdakpPOFhiO5NCQoJ0x5XNdPsVTbVo9SH9MmOXVmw8rDVbU89446JKxQi1bxGn88+pqmGXNladeMfme/ZF7swHSap/aRelbtqtYzv+91Ta1m9nnnYT2u/357Xp86naO923vnNQoVy4nr/3XI0e3lYT/9mjafP3aeWmFG3amXbGzWr9mrFq36KyLuwYrxsGNfLLIsUJix//VN3evVetR1yugswcLXzwI0lSlzfv0r6ZK7Rv5goFR4bp8oUfKDg8RKGxxz/UnvD7PK16+Ue1uGOAqrRrpNCo8JOvN++eukTr3ptg8p/lksZ1y+uzZ7vp9Yc66vtpCZq7PFErNqWc8bR9cLBFLRpUUPsWcbqkRx0N7lnHJwcmHBEVX0nnPTdM6buT1O+35yRJ1vxCTRs4Um0fu0Y5h46e/P0O/vstRVQup9DYSF218lMlLd6gBfd/oPqXdlW9gZ2VunG3Bs96Q5J0aPlWLRv1hal/lst6doxXz47x2rU/Q99M3q4l65K1clOKjqSd/oHVyIhgtW1aWR1axmlo/4bq1KaKz92UOcOZzvrZruFFXQckKbJqBeUkp0mSznnoSiUu2uDUzYA3BAVZNOzSJrp5cGP9u/6wfvwzQSs2pWjNltQzitiVyoerQ8s4dW5dVTdf2sjvHlg4lbuOv6u54Utio8M0eng7PXnrOZoyb6+mzNurlZuOaGPCUVmtp/cF6taIUfvmcerZsbpuGNTIJ4sUxanUqv7Jt6skKT89S81u7qu81AztnX76dIDnvz5ctXq1V2TVCur902gVZOZoQpf7S7x+lNTO19WvFauPnuqiVx/soB+mJWjOv4lauSlFO/dnnLZeUJBFzeuXV/sWcRpwQW0N6VXXb6b/K4o7Bm3Oxl/uCbq2q6au7appX1Kmvpm8XYvXJGvFxhQdPnp6ITciPFjnNKmkDi3jdE3fBup2bjWf7ws40u/P3Jus1W+OV//JL0o6/sDJ1u9mSVKJ9wRZB1K07v0JGjDlJdltxwviix87/iCTP90vWCwWDR3YUEMHNtTKTSn6YdoOLd+QotVbjpzx9mWF2DC1bxGnzm2q6ObBjX3uDXtXtWxUUePGdNebj5ynb6fs0PyVSVq5KUX7kk5/kCMkxKJWjSqqffM4XXZRXfXvVssnH9w6Fb8Bx/TtWkt9u9bS9j3H9M3k7Vq2/rBWbExRWsbpDyNFR4aoXbPK6tgqTtcPbOTWaSW9zV3XwbzUDCUu3KAaPc/RgTmrFVO7qmLqVNWx7QdKXOZLQkKCNPzKZrrj/8dHf56+Uys3pZQ4Ptql7fHx0drV/Wt8tLTjYfHdWqn5bQNkt9pkCQlW4oL1WvfOb5JU4jJfV7FcuF64t/3x8dE5/xsf3bzrWJHjox1axunCjvG6fmBDvx0ftdjtzjyzXDZlZWUpJub4jzwzM1PR0UXPf1+QnasfGt7g9PbLNayhbu/eq/CKsSd/kGlb9ko6/UdZ0npR8ZV09arPlL47SYWZx6utp96k1r+sq9qMuFx2m12WIIvWffCHdv2x8KztJOn6hO8VGuUbr88XFtq0LylLnW+YrOTUXFWvHKGDc4b65M2IyXw4YcDkl7Tth9na8cs/xe6vqJtTXzrm/5WVXaDElBx1vWmKklNzFR8XqYNzhpoOq1iu5oFJvnz8JSn1WJ6aX/qbklNzVa1ShHZNv0aREb77/AU54F52u12Jh7PV7uqJx3OgcoT2z7rOJ4uUpTn2jlwLjqzfedZreHHXgS5v3qVqnZrLEhykwyu3adlTX55R1PDVPLBaj/cFOl1ftvsCJR1/R/p3Z+sj+Orxl6Sc3EIdSM4+2ReoHhepxADsC1w69x3NuOJZ5R5J90BUJfPl4y9JR9Pz1Hzwbzr0/32BhD+v9sk3CCTP3xOcWozMO5pxRjHybMtP8Kd7ArvdrqSUHLW96o+TfYF9M69TqBu/9eFu/tYf9NVjf4LVatP+Q1k6b6jv9wU8JeVorloO+f3kPdHuGdcoIpx7Infy5d+B3W7XgUPZan/t/+6JDsy+zieLlKavgzF1qqrr2/coolKs7Da71r7zq/ZMW3bWZZJv50BBwfHz4P/GRyN1cM51Pnse5Bzgfr44PupoDeVsfPdqVoakJxws9nXYU6dzKmm97MRUfR1/ZbH72DVxUZGvTZ+tna8JCQlS/VqxCv3/gcng4CCfPRm7yh35cMKfg0teLknTr3jWuQANi44KVaM6oSdzwF/mX4X7VCoffvL4h4QE+XSxCu5nsVhUo2r0/3IgOMgni1Wl5ei14GzX8OKuA/46XaR0/NpfryZ9Aan44+9I/86RPoKviowIUaM65f6XAwHaF5jU8yHTIfisiuXCT577Q0KCfLZYVRqOngeWPP5Zids52/IT/OmewGKxKL5K1Gl9AV8uVsH9goODVLdGYPcFziauYsRp90S+XKyC+1ksFtWqfvo9kS8Wq0rDXdfBzL3JmnHlc04v83Whof8dH7WUufNgWRfI46OBdTYDAAAAAAAAAACA36FgBQAAAAAAAAAAAKMoWAEAAAAAAAAAAMAoClYAAAAAAAAAAAAwiq8yulFIZLiuT/jedBhuFxIZbjoEv+TP+cAxdx9/zAOOv3uRA2WXPx77U5EHpefPOcDxdx9/zAOOv/v44/E/gTxwH3/LA4493M3ffgMSvwN38cdjfwI54D7+mAccf3MoWLmRxWJRaFSE6TDgI8gHSOQByIGyjGMPcgASeVDWcfwhkQcAv4Gyi2MPiTyAc5gSEAAAAAAAAAAAAEZRsAIAAAAAAAAAAIBRFKwAAAAAAAAAAABgFAUrAAAAAAAAAAAAGEXBCgAAAAAAAAAAAEZRsAIAAAAAAAAAAIBRFKwAAAAAAAAAAABgFAUrAAAAAAAAAAAAGEXBCgAAAAAAAAAAAEZRsAIAAAAAAAAAAIBRFKwAAAAAAAAAAABgFAUrAAAAAAAAAAAAGEXBCgAAAAAAAAAAAEZRsAIAAAAAAAAAAIBRFKwAAAAAAAAAAABgFAUrAAAAAAAAAAAAGEXBCgAAAAAAAAAAAEZRsAIAAAAAAAAAAIBRIaYDAIBAZrfbpbw802E4JzxcFovFdBQAAAAAAAAAyhAKVgDgSXl5Krz6ZtNROCVk/DdSRITpMAAAAAAAAACUIUwJCAAAAAAAAAAAAKMoWAEAAAAAAAAAAMAoClYAAAAAAAAAAAAwioIVAAAAAAAAAAAAjKJgBQAAAAAAAAAAAKMoWAEAAAAAAAAAAMAoClYAAAAAAAAAAAAwioIVAAAAAAAAAAAAjKJgBQAAAAAAAAAAAKMoWAEAAAAAAAAAAMCogCtY7d69W19++aXuuusutW/fXmFhYbJYLBo2bJjp0AAAAAAAAAAAAFCEENMBuNu7776r9957z3QYAAAAAAAAAAAAcFDAFazi4uI0YMAAdezYUR06dNBff/2ljz/+2HRYAAAAAAAAAAAAKEbAFaxGjx592v9funSpoUgAuFvqsTx9PWmbpi/ar+TUXEnSscx87dqfofq1Yg1H51nzUpLVe8lcvdqijR5u2KzIdcKmjNeAqvGa2OkCL0cHeIfdbteStcn6/PetOnz0+DngSFqefp25S5ddWFehoQE30zGA/ziWka9vp2zXtPn7/tcXyMjXjr3palSnnOHoAHia3W7X8g0p+vz3Laf1BX6clqAretdTeFiw4QgBz9uyK02f/vq/30BKWq7G/rJZNwxqqNjoMMPRAfC0vHyrJszerZ+n7zzZHz6anqd/1x9Wx1ZxslgshiMESifgClYAAk9hoU1PvLtcH/+yWbl51tOWZWYXquHA8RpyUT198Xw3VSwXbihKAJ60enOKbnlmgdZuTT3t73Pzrbr60TmKrxKlNx7uqOsHNjIUIQBPslpteuajVXr3+43Kzi08bVlmTqEaD/pVA7vX1rgXLlCVSpGGogTgSRt3HNWwp+drxcaU0/4+N9+q60fO1YOvR+iVBzrotsubGooQ8KyDyVm65ZkFmrn4wGl/n5dv0z0vLdbj7/yrx4a10ejhbRUUxIA1EIi+nLBVI99bcbJgfUJ2rlWdrp+s9i3i9M2L3dWyUUVDEQKlx6PIAHxaYaFNVz06R29/u+GMYtUJdrs04e/d6nbzVB1Jyy1yHQD+a/GaQ7pg2LQzilWnSjycrRtGztP7P2z0YmQAvMFms+ump+br5S/WnlGsOtW0+fvU5aapSkrJ9mJ0ALxh1aYUdb1p6hnFqlMdPpqr259bqFe/XOvFyADv2J+UpfNvnHJGsepUmdmFevbjVRr+/ELZ7XYvRgfAG177aq1uf27hGcWqU638/+vlqk3FXy8BX0fBCoBPe/bjVZo4Z49D625KSNN1T/zj4YgAeFPK0VwNHjFLWTnFD1Kf6sHXl2rOsoMejgqAN7321Tr9+GeCQ+vu2JuuKx7+m4E6IICkZ+Zr4H0zdSwz36H1R763QlPn7fVwVID32Gx2DR4xS3sTsxxa/8s/tvEQFxBgps3fqyffXeHQusf+/7qZ7uB1E/A1FKwA+Kys7AJ9+PMmp9rMWnJQqzcH7pMk2VarUvLyivwDBKJxE7fpSJrj+W23S299u96DEQHwprx8q975boNTbRavSdbiNckeigiAt30/dYeSUnKcavPG1/QFEDhmLz2g1VuOONXmrW83qLDQ5qGIAHibs9e1pJQcfTd1h4eiATyLghUAn/XjnwlKzyxwut3Y8Vs8EI1veGHrRtWYOanIP0CgsdnsLv2e/1q4Xzv3p3sgIgDe9vus3SVOe1Kcj3/Z7IFoAHib3W536fc8f2WSNmwvfiphwJ+48hvYl5SlaQv2eSAaAN62ccdRzVuR5HS7j3/ZzKwD8EshpgMAgOLM+TfRxXaBOx3Y7XUa6IoatYtc1n/pPC9HA3jWnoOZ2nUgw+l2drs0b0WSGtQq54GoAHiTq9f0QO4LAGXJ4dRcbUxIc6ntP8sT1apxJfcGBBjg8n3xsoO69MK6bo4GgLf9s9y1c8CmhDQlp+aqWuVIN0cEeBYFKyc1btxYQUG8mGZaYoWHpaDySkxKVK1atUyHAw85EjNUCmvqdLtde3wnLyKDgrSp7flu216jmBj1qlLNbdsrSpMmTZRj8+3pIzgHlA0FwdWk8ve41PahR0bp6fuWujki+BLOA2VDavSVUnhrp9sdOpxGXgQ4zgFlQ2FQRanCgy61Hf3Mi3rt8QXuDQg+pSycB+ySMio+K1mcH4f6Ytz3+v3Dq9wfFHxGWfgNQMqI6CZF9Xap7TntOinExhvHgcyXzgO2U8YSu3XrptWrV7u0HQpWTkpMdK2qDTeLtUpBks1q1YEDB0xHA0+pnSaFOd/MVpDtM3kRFRwstTUdhXMOHjyobKvVdBgl4xxQNoTmSeVda3rsaJKOHSU3AhrngbKhZpoU7nwze2EOeRHoOAeUDcHpUgXXmqanJSv9CLkR0MrKeaB8nhTs/BsS2Rmpyk4M4P8uKDu/gbKucrIU5WQbu12yWHQocY9UyHT5Ac1HzwOHDh1yuS0FKyfFx8fzhpUPSAwOlk1SUHCw4mvWNB0OPCQz9LCOudAuSgdU0UfyItIPzxc1atTw/TesOAeUCXZZdMiaJmtwBScaHe+YV43JUGgUuRHIOA+UDVlhh5XmQrsI+wFVJi8CGueAssEuKdl6WIXBVZxodLwvUCX6mMIiyI1AVlbOAynWfcoLbuJ0u0rhRxQZwP9dUHZ+A2VdQfAxJUsnr28OsVgUbE1RtWrlZFGsJ8ODYb50HrDZbCdf9qlWzfXZoShYOWn79u2Kjo42HUaZV+vin3QgOVvx1eO1f8N+0+HAQ9Iz81Xz4p+UmV3oVLu5vz+rjq0+9FBUzrHn5qrw6ptNh+GUbdu2yRIRYTqMEnEOKDte/nyNnvpgpeMNLBb1Pr+GZn661nNBwSdwHigbcnILVav3z0o9ludUu7++e0w9O77toajgCzgHlB3vfb9BD76+zPEGFovOP6eqFn+3wnNBwSeUlfPAtPl7Nei+WU61qVE1SrtXTldoqP89QAnHlZXfAKSuN03R4jXJTrV588mBevDGJzwUEXyFL50HsrKyFBMTI0lauHChy9vhygXAZ5WLCdOdVzZzqk339tXVsZUTT2AC8Gm3Xd5U5WOcmxv04Rud/94NAN8UGRGi+69r4VSb9i3i1KNDdQ9FBMDbbh7cWHEVnXuY6tGb6QsgcPTrWkstG1Zwqs0DQ1tSrAICiLPXtcoVwjXs0sYeigbwrIC7ei1atEhxcXEn/7z99vEnK3/++efT/n7RokWGIwXgiJcf6KB+XR37aGCjOuU0/s2LPBwRAG+qVjlSf7zbSxHhwQ6t/8oDHdSvGx8cBgLJ03e21ZBedR1at058tCa+e7Esjk6XAsDnVSgXrinv91Z0pGMTxIwe3laXX1zPs0EBXhQcHKTJH/RWfBXHPmIzdEBDPTqMoi0QSIb0qqen72zr0LrRkSGa8kFvVSjnwodgAR8QcAWrgoICHTly5OSfnJwcSVJeXt5pf19QUGA4UgCOCAsN1qT3L9ZdVzVTSHDxg099u9TUom8GqVpl5z9G6w96xFVV/iVX6+GGxb9xln/J1ZrY6QIvRgV4x4Xn1dA/XwxQ47rlil2nUvlwffZMVz152zlejAyANwQHB2n8GxfpwRtaKqyEp8V7dozXku8uUa3qTN8NBJrO51TV/HED1bxBhWLXKR8bpvee6Kwx97X3XmCAlzSoVU5Lvhukru2K/yZIRHiwHr+ltb59qbuCgnhwAwg0L9zbXu8/2VnlY4ufgaR5gwqaP26gzj/H9e8HAaYF3DesevbsKbvdbjoMAG4UFhqssU931bN3t9MXE7Zq+qIDSkvPU0xUqM5rXUV3X928xJtXAP6v8zlVtWXSlfp72UF9MWGrduxNV6HVrupxkRrav6Gu7ltfkREB160B8P9CQoL0zuOdNer2c/TVxG2aOm+f0jLyFRURovYtKuvuq5urdZNKpsME4EHntojTxj8u17wVSfrsty3atidd+QVWVa0UqWv7NdB1/RsoOirUdJiAx9StEauF3wzSqk0p+uTXLVq7NVXZuYWqVD5cg3vW0bBLG6tyBd/+FjGA0rl/aEvdelkT/Tx9p36evlOHjuQoLDRYTeqW0/Arm6lHh+rMNAC/x8gOAL9RPS5Ko4e30+jh7UyHAsCAoCCLep9fU73Pr2k6FACGVKkUqSduPUdP3MrblEBZZLFY1LNjvHp2jDcdCmDMuS3i9Nmz3UyHAcCQ6KhQ3XZ5U912eVPToQAeEXBTAgIAAAAAAAAAAMC/ULACAAAAAAAAAACAURSsAAAAAAAAAAAAYBQFKwAAAAAAAAAAABhFwQoAAAAAAAAAAABGUbACAAAAAAAAAACAURSsAAAAAAAAAAAAYBQFKwAAAAAAAAAAABhFwQoAAAAAAAAAAABGUbACAAAAAAAAAACAURSsAAAAAAAAAAAAYBQFKwAAAAAAAAAAABhFwQoAAAAAAAAAAABGhZgOAAACWni4QsZ/YzoK54SHm44AAAAAAAAAQBlDwQoAPMhisUgREabDAAAAAAAAAACfxpSAAAAAAAAAAAAAMIqCFQAAAAAAAAAAAIyiYAUAAAAAAAAAAACjKFgBAAAAAAAAAADAKApWAAAAAAAAAAAAMIqCFQAAAAAAAAAAAIyiYAUAAAAAAAAAAACjKFgBAAAAAAAAAADAKApWAAAAAAAAAAAAMIqCFQAAAAAAAAAAAIyiYAUAAAAAAAAAAACjKFgBAAAAAAAAAADAKApWAAAAAAAAAAAAMIqCFQAAAAAAAAAAAIyiYAUAAAAAAAAAAACjKFgBAAAAAAAAAADAKApWAAAAAAAAAAAAMIqCFQAAAAAAAAAAAIwKMR0AEMjsdruUl2c6DOeEh8tisZiOAgAAAAAAAABQhlCwAjwpL0+FV99sOgqnhIz/RoqIMB0GAAAAAAAAAKAMYUpAAAAAAAAAAAAAGEXBCgAAAAAAAAAAAEZRsAIAAAAAAAAAAIBRFKwAAAAAAAAAAABgFAUrAAAAAAAAAAAAGEXBCgAAAAAAAAAAAEZRsAIAAAAAAAAAAIBRFKwAAAAAAAAAAABgFAUrAAAAAAAAAAAAGEXBCgAAAAAAAAAAAEYFVMHKbrdr0aJFeuKJJ9SlSxdVqlRJoaGhqlatmgYNGqTJkyebDhEAAAAAAAAAAAD/EWI6AHeaM2eOLr74YkmSxWJRw4YN1aBBA+3YsUPTpk3TtGnTdOutt+qLL76QxWIxHC0AAAAAAAAAAACkAHzDqkGDBvrggw+UnJys7du3a8WKFTpy5IjeeecdWSwWffXVVxo7dqzpUAEAAAAAAAAAAPD/Aqpgdd5552nLli267777FBcXd/Lvg4OD9eCDD2r48OGSpM8++8xUiCil7JxCTfpnj7JyCiVJeflW2e12w1F53ryUZIVNGa+3E7YUu07YlPG6bNkCL0YFAID35eYVasrcvaf1BWy2wO8LAACA4/ILrPpzwT76AgCAMuvQkRz9/FeCsnIKJEkFhTbDEblPQBWsypUrp9DQ0GKX9+3bV5K0detWb4UENzmYnKVH3lymWr1/0mUPzFZaRr4kKSUtT60un6CPft6kgoLA+WECAIDTJR/J0ZPvLlftPr9o8IhZp/UFml/6u979boPy8q2GowQAAJ5yJC1XT3+4UnX6/KKB9848rS/QeNCvemPcOuXkFhqOEgAAz1m5KUXXPf6Pavf+Wdc9MVdpGccLVsmpueo9/C9Nm7/XcISlF1DfsDqb3NxcSVJUVJThSOCM9dtS1e+eGTqYnF3k8k0Jabrv5SWaOm+ffn+7l6Iiy1RaAwAQ8LbuSlPfu2doz8HMIpdv23NMD72xTJPm7tWk9y5WuZgwL0cIAAA8adf+DPW5a7p27E0vcvnO/Rl6/J3l+mPOHk39sI8qlQ/3coQAAHjWz38l6Kan5hf7NtXspQc1e+lBPX1nWz1/z7myWCxejtA9AuoNq7P55ZdfJEkXXHCB4UjgqP1JWep7d/HFqlNNX7RfQ5/8h6kAAAAIIIeO5JRYrDrV3OWJuvKRv1UYQNMhAABQ1qUey1Pfu4svVp1qydpkXTpilvILeOsaABA4Zi7erxtGzXNo6r8xn67RO99t8EJUnlFmClZ//vmnJk2aJEl6/PHHDUcDR73y5VolHj57seqESf/s1Zx/D3owIrOyrVal5OUV+QcAgED01jfrHSpWnTBryUFNDYBpEAAAwHEf/LhR2/ecvVh1wsLVh/TrzF0ejAgAAO+x2+166I1lslodf0lj9IcrlZbun+PFZWLutISEBN14442SpBEjRqhLly6GI4Ij0jPz9e2U7U63++jnzbq4c00PRGTeC1s36oWtG02HAQCAV+TkFurLP7Y53e7jXzbrsovquT8gAADgVQUFNn32u/PfIf/o5826fmAjD0QEAIB3zV+ZpE0JaU61ycm16utJ2/Xgja08E5QHBXzBKikpSf369VNqaqr69OmjN99803RIcNCUeXuVme38B1Mnz92r9Mz8gPx+xe11GuiKGrWLXNZ/6TwvRwMAgGfNWLxfqcecfyps1pKDOnQkR9UqR3ogKgAA4C3zViY69ImA/1qyNlk796erQa1yHogKAADv+WFagkvtvp+WQMHK15woUu3YsUNdu3bVH3/8odDQ0FJts3HjxgoKKjMzKRqVEdFFiurrdDubza4mLdorxHbUA1E5JzIoSJvanu+27TWKiVGvKtXctr2iNGnSRDk2vv0B35ZY4WEpqLwSkxJVq1Yt0+EA8JDM8I5S9CCX2rY5t5tCrYfcHBEAX0FfACgbssPOkWIud6ltp259FV64z80RAb6DayFQNqTEDJXCmjrdbvWGBK+eG2ynjCd369ZNq1evdmk7AVuwSk9PV79+/bR+/Xqde+65mjZtmqKiokq93cTERDdEB4dUTpNcPGSHkhKlgiNuDccVUcHBUlvTUTjn4MGDyrbygVr4uFirFCTZrFYdOHDAdDQAPKViQynatabJh5KkvMD9riVQ5tEXAMqG8jWlGNeapiQfknI4PyCAcS0EyoY62ZILE4nZCguNnRsOHXL94dGALFhlZ2dr0KBBWr58uZo3b64ZM2aofPnybtl2fHw8b1h5SU6oVakutLPY8xVfNUYWRbg9JmdF+mGu1KhRgzes4PMSg4NlkxQUHKz4moH5zToAUm6IXS49fmK3Kr5KpILsnB+AQEVfACgb8oMtOixJdrtksTje0G5T9cphCqYvgADGtRAoG9LCc5TlQrswS7qqePHcYLPZTr7sU62a6zOEBVzBKj8/X0OGDNGCBQvUsGFDzZ49W3FxcW7b/vbt2xUd7eKjvnBKQYFNdfr+rKSUHKfa3X5la3327G7PBOUke26uCq++2XQYTtm2bZssEeaLfUBJal38kw4kZyu+erz2b9hvOhwAHmK12tR40G/adSDDqXZDBzbRD6/u8FBUAHwBfQGgbLDb7Wp9+QRtdPJj84MvrKdJ72/xTFCAj+BaCJQNG3ccVavLJzjd7qs3h+n6gS96IKKiZWVlKSbm+GvRCxcudHk7/vf6RwmsVquGDh2qmTNnqlatWpo9e7Zq1KhhOiy4KDQ0SMOvaOZ0u3uuae6BaAAAgLcFBwfprquc7wvcfbXzbQAAgO+xWCwu3eMzLgAACBQtG1VUjw7VnWpTpWKEruxd30MReVZAvWE1fvx4/f7775KksLAw3XDDDcWu+9tvv6l6decONLzvsVtaa9qCfVq5KcWh9Ufedo7aNqvs4agAAIC3jLi+hSbP26tFqx2bA/v+oS3UtZ3r0w8AAADfcvsVTTXh7z36e5lj36a8dUgT9enC9GgAgMAxdnRXdblxitIy8s+6blCQRePGXKDwsGAvROZ+AVWwysvLO/m/d+7cqZ07dxa7bm5urjdCQinFRIVq+ti+GjxilpasTS5x3SdubaMX72/vpci8q0dcVeVfcnWJ65xtOQAA/igiPERTP+itIQ/9rbnLE0tc977rWuidxzrJ4sw3LgAAgE8LCw3WH+/20lWPzNGMxSV/PP62IU00dnRX+gIAgIDSvEEFzf68vwbeO1OHjhT/+ZzwsCB9/3JPDexex4vRuVdATQk4bNgw2e12h/7Uq1fPdLhwUFzFCM39aoB+eKXnGU9Mh4UG6YZBDbXku0v06oMdFRREpxQAgEBToVy4Zn7ST+PfvOiMqRBCgi26tl8DzftqgN5/srOCgwOqewsAACTFRodp6od99Me7vXRx59M//RAcbNEVF9fT7M/66/Pnuik0lL4AACDwtG8Rp41/XK43Hj5PDWrFnrascoVwPX5La22eeKWu7OOfUwGeEFBvWCFwhYUGa+jAhho6sKH2JWUqOTVXoSFBqlM9WhXKhZsODwAAeFhoaJCu6lNfV/WprwOHspR0JEchwRbVrh6jSuXpCwAAEOhCQoJ02UX1dNlF9ZR4OFuJh7MVHGxRzarRiqsYYTo8AAA8rnKFCD06rLUevqmVduxN17HMfEVHhqhBrVhFhAdGqScw/hUoU2pXj1Ht6jGmwwAAAIbUrBatmtWiTYcBAAAMia8SpfgqUabDAADAiKAgi5rUK286DI/gPWkAAAAAAAAAAAAYRcEKAAAAAAAAAAAARlGwAgAAAAAAAAAAgFEUrAAAAAAAAAAAAGAUBSsAAAAAAAAAAAAYRcEKAAAAAAAAAAAARlGwAgAAAAAAAAAAgFEUrAAAAAAAAAAAAGAUBSsAAAAAAAAAAAAYRcEKAAAAAAAAAAAARlGwAgAAAAAAAAAAgFEUrAAAAAAAAAAAAGAUBSsAAAAAAAAAAAAYFWI6ACCghYcrZPw3pqNwTni46QgAAAAAAAAAAGUMBSvAgywWixQRYToMAAAAAAAAAAB8GlMCAgAAAAAAAAAAwCgKVgAAAAAAAAAAADCKghUAAAAAAAAAAACMomAFAAAAAAAAAAAAoyhYAQAAAAAAAAAAwCgKVgAAAAAAAAAAADCKghUAAAAAAAAAAACMomAFAAAAAAAAAAAAoyhYAQAAAAAAAAAAwCgKVgAAAAAAAAAAADCKghUAAAAAAAAAAACMomAFAAAAAAAAAAAAoyhYAQAAAAAAAAAAwCgKVgAAAAAAAAAAADCKghUAAAAAAAAAAACMomAFAAAAAAAAAAAAoyhYAQAAAAAAAAAAwCgKVgAAAAAAAAAAADCKghUAAAAAAAAAAACMomAFAAAAAAAAAAAAoyhYAQAAAAAAAAAAwCgKVgAAAAAAAAAAADCKghUAAAAAAAAAAACMomAFAAAAAAAAAAAAoyhYAQAAAAAAAAAAwCgKVgAAAAAAAAAAADCKghUAAAAAAAAAAACMomAFAAAAAAAAAAAAoyhYAQAAAAAAAAAAwCgKVgAAAAAAAAAAADAqoApWkydP1t13363zzjtPNWvWVHh4uGJjY9W2bVuNGjVKKSkppkMEAAAAAAAAAADAf4SYDsCd3n77bc2bN09hYWGqUaOG2rRpo+TkZK1bt05r167VF198oZkzZ6pt27amQwUAAAAAAAAAAMD/C6g3rG699Vb9/fffysjI0K5du7R8+XLt2bNHa9euVatWrXT48GENHTrUdJgAAAAAgFKw2+2mQwAAAADgZgFVsLrpppt00UUXKSws7LS/b926tb788ktJ0ubNm7V582YT4QEAAAAAXJSXb9WP0xLU7eapOng4R5J0IDlbl46YpZmL98tmo4gFAAAA+LOAmhKwJM2bNz/5v7Ozsw1GAgAAAABwxpotRzR4xCztS8o6Y9nkuXs1ee5edWwVp0nv9VZ8lSgDEQIAAAAorYB6w6okixYtkiRFR0eradOmhqMBAAAAADhi/bZU9bh1WpHFqlMt35Ci7rdMU8rRXC9FBgAAAMCdArpgZbPZlJiYqG+//VbDhg2TJL388suKiYkxGxgAAAAA4KxsNruuenSO0jMLHFp/x9503f3iIg9HBQAAAMATArJg9cknn8hisSg4OFg1atTQzTffrFq1amnKlCkaMWKE6fAAAAAAAA6YvfSAtu4+5lSbP+bs0f6zvI0FAAAAwPcEZMEqPj5eXbt2VadOnVSjRg1ZLBatW7dOP/74o44dc+5mBwAAAABgxtjxW5xuY7Xa9cWErR6IBgAAAIAnWex2u910EJ62fv163XvvvVqwYIG6du2qhQsXOtU+Kyvr5DSC8fHxCgoKyDofAPiNxAoPyxZUXkG2Y4pPe9t0OAAAwEOSyj8ga3Alp9tF5G9S5cxfPBARAAC+gftiAL7kxOeZJKlt27ZavXq1S9sJcWdQvqp169aaNm2aGjRooEWLFmn27Nm6+OKLXdrWif/oAACDYq1SkGSzWnXgwAHT0QAAAE+JtUjBzjfLzaOPAAAIcNwXA/BRhw4dcrltmShYSVJsbKx69Oih33//XWvXrnW5YMUbVgBgXmJwsGySgoKDFV+zpulwAACAhxyy5KnQhXaRYTZVoo8AAAhg3BcD8CWnvmFVrVo1l7dTZgpWklRYePxWx2q1uryN7du3Kzo62l0hAQBcUOvin3QgOVvx1eO1f8N+0+EAAAAPeeajlRrz6Rqn23334UO6ovf77g8IAAAfwX0xAF9y6meVnP0k06nKzKtCqampmjdvnqTjcygCAAAAAHzb8CuaKTjY4lSbGlWjNLhnXQ9FBAAAAMBTAqZgtWLFCj3zzDPasWPHGctWr16t/v37Ky0tTa1bt1avXr0MRAgAAAAAcEat6tG688pmTrV59q52Cg0NmFtdAAAAoMwImCkBMzMzNWbMGI0ZM0ZVq1ZV7dq1FRwcrP379+vgwYOSpCZNmmjixIkKDnbhq70AAAAAAK979/HOSkzJ1h9/7znruk/dcY6GO1ngAgAAAOAbAuaxs3POOUfvvfeeLrvsMpUrV07btm3T6tWrZbVadfHFF+ujjz7S2rVr1aBBA9OhAgAAAAAcFBoapF/fvEgvj+igGlWjilyneYMK+u7lHnrx/g5ejg4AAACAuwTMG1YVK1bUiBEjNGLECNOhAAAAAADcKDg4SCNvP0eP3txak/7Zo2XrDyszu0DlY8PUr2st9ehQXRaLc9+6AgAAAOBbAqZgBQAAAAAIbKGhQbqyT31d2ae+6VAAAAAAuFnATAkIAAAAAAAAAAAA/0TBCgAAAAAAAAAAAEZRsAIAAAAAAAAAAIBRFKwAAAAAAAAAAABgFAUrAAAAAAAAAAAAGEXBCgAAAAAAAAAAAEZRsAIAAAAAAAAAAIBRFKwAAAAAAAAAAABgFAUrAAAAAAAAAAAAGEXBCgAAAAAAAAAAAEZRsAIAAAAAAAAAAIBRFKwAAAAAAAAAAABgFAUrAAAAAAAAAAAAGEXBCgAAAAAAAAAAAEZRsAIAAAAAAAAAAIBRFKwAAAAAAAAAAABgFAUrAAAAAAAAAAAAGEXBCgAAAAAAAAAAAEZRsAIAAAAAAAAAAIBRFKwAAAAAAAAAAABgFAUrAAAAAAAAAAAAGEXBCgAAAAAAAAAAAEZRsAIAAAAAAAAAAIBRFKwAAAAAAAAAAABgFAUrAAAAAAAAAAAAGEXBCgAAAAAAAAAAAEZRsAIAAAAAAAAAAIBRFKwAAAAAAAAAAABgFAUrAAAAAAAAAAAAGEXBCgAAAAAAAAAAAEZRsAIAAAAAAAAAAIBRFKwAAAAAAAAAAABgFAUrAAAAAAAAAAAAGBViOgAAAAKZ3W6X8vJMh+Gc8HBZLBbTUQAAAAAAAKAMoWAFAIAn5eWp8OqbTUfhlJDx30gREabDAAAAAAAAQBnClIAAAAAAAAAAAAAwioIVAAAAAAAAAAAAjKJgBQAAAAAAAAAAAKMoWAEAAAAAAAAAAMAoClYAAAAAAAAAAAAwioIVAAAAAAAAAAAAjKJgBQAAAAAAAAAAAKMoWAEAAAAAAAAAAMAoClYAAAAAAAAAAAAwioIVAAAAAAAAAAAAjAr4gtXnn38ui8Uii8Winj17mg4HAAAAAAAAAAAA/xHQBaukpCQ9/vjjpsMAAAAAAAAAAABACQK6YHX//fcrPT1dgwYNMh0KAAAAAAAAAAAAihGwBavJkyfrt99+07333qv27dubDgcA4AaZ2QX67LctOpqeJ0lKy8jXnwv2yWq1GY7M8+alJCtsyni9nbCl2HXCpozXZcsWeDEqAAAAAIA37TmYoefHrjp5X3wsM18btqcajgoA3CMgC1YZGRm69957VaNGDb344oumwwEAlFJuXqEefmOpavT6SXe+sEjZuVZJUlZOoQbeO1ONB/2mLydsNRwlAAAAAACesXN/ugbfP0sNBvyq58auPnlfnJldqNZX/KHuw6Zq+YbDhqMEgNIJyILVyJEjtX//fr377rsqV66c6XAAAKWQlV2gvnfN0DvfbVRGVkGR6+w6kKHbn1uoUe+t8HJ0AAAAAAB41obtqTr/himaMm+vbDZ7kessWHVIPW6ZpllLDng5OgBwn4ArWC1ZskRjx45V//79ddVVV5kOBwBQSrc8s0DzVyY5tO4rX67V578VP2UeAAAAAAD+JPVYnvrfM1PJqblnXTcnz6rLH5qtrbvSPB8YAHhAQBWsCgoKdMcddyg8PFwffvih6XAAAKW0ccdR/Tpzl1Ntxny2JqC/aZVttSolL6/IPwAAAACAwPLVH9u0/1CWw+tnZhfq7e82eDAiAPCcENMBuNOrr76qjRs36qWXXlKDBg1MhwMAKKVPfnX+bal9SVmaNn+fBl9Y1wMRmffC1o16YetG02EAAAAAADzMZrNr7PjNTrf7fmqCXn/oPJWPDfNAVADgOQFTsNq6dateeuklNW/eXI899pjpcAAAbjBl3l6X2wVqwer2Og10RY3aRS7rv3Sel6MBAAAAAHjKll1p2rk/w+l22bmF+mf5QV12UT33BwUAHhQwBau7775beXl5+uSTTxQaGuqx/TRu3FhBQQE1kyIA+KyDFUZKQRFOt/v+5z/01xfXeSAi50UGBWlT2/Pdtr1GMTHqVaWa27ZXlCZNmijHFrjTKgIAAACAP8gLqS2Vu92ltrfcfp/uy1/j3oAAoBi2U8aRunXrptWrV7u0nYApWK1atUpBQUG6+uqrz1iWmZkpSVq8eLGqV68uSdq2bZvKlSvn9H4SExNLFygAwHGxuS4VrHKzjunAgQMeCMh5UcHBUlvTUTjn4MGDyrZaTYcBAAAAAGVbRLDk/PClJCktNVlpx3zjvhhA2XLo0CGX2wZMwUo6XsUr6T9GQUHByeU2F58cj4+P5w0rAPCSFHuy8lTB6Xblw9IVU7Om+wNyQaQfXjNq1KjBG1YAAAAAYJhNwUqy58tuceJbVHa7ZLGoark8hcb4xn0xgMBns9lOvuxTrZrrMwMFTMEqLS2t2GXPPfecnn/+efXo0UNz584t1X62b9+u6OjoUm0DAOCYqfP26pL7ZznVJjIiWLsWfq+K5cI9FJVz7Lm5Krz6ZtNhOGXbtm2yRDj/ZhsAAAAAwL3uHrNIn/y6xfEGFot6daqh2Z+v9VxQAPAfWVlZiomJkSQtXLjQ5e3432PfAIAyo3+3WmpUx7n5D266pLHPFKsAAAAAACiNe69truBgi1NtHri+pYeiAQDPomAFAPBZwcFB+uOdXiof49j0Bx1axumtR87zcFQAAAAAAHhHq8aV9PFTXRxe/9GbW+uSnnU8GBEAeE7ATAkIAAhMrRpX0oKvB+qyB2dr5/6MYtfr362WfnrtQkVHhXoxOu/pEVdV+ZdcXeI6Z1sOAAAAAPA/w69spvDQYN3z0mJl5xYWuU5IsEVP39lOT9/Z1rvBAYAbWex2u910EL7u1PkXMzMz+YYVABhQWGjTtAX79PEvm7ViY4qycgpVITZMA7vX1j3XNFf7FnGmQyySP37DKmT8N3zDCgAAAAB8TFp6nr6dskNfTNiq3QczZbXaVaNqlG4c1Ei3X95ENaoyZgnADHfVUChYOYCCFQDAVRSsAAAAAAAAEMjcVUPhG1YAAAAAAAAAAAAwioIVAAAAAAAAAAAAjKJgBQAAAAAAAAAAAKMoWAEAAAAAAAAAAMAoClYAAAAAAAAAAAAwioIVAAAAAAAAAAAAjKJgBQAAAAAAAAAAAKMoWAEAAAAAAAAAAMAoClYAAAAAAAAAAAAwioIVAAAAAAAAAAAAjKJgBQAAAAAAAAAAAKMoWAEAAAAAAAAAAMAoClYAAAAAAAAAAAAwioIVAAAAAAAAAAAAjAoxHQAAAAEtPFwh478xHYVzwsNNRwAAAAAAAIAyhoIVAAAeZLFYpIgI02EAAAAAAAAAPo0pAQEAAAAAAAAAAGAUBSsAAAAAAAAAAAAYRcEKAAAAAAAAAAAARlGwAgAAAAAAAAAAgFEUrAAAAAAAAAAAAGAUBSsAAAAAAAAAAAAYRcEKAAAAAAAAAAAARlGwAgAAAAAAAAAAgFEUrAAAAAAAAAAAAGAUBSsAAAAAAAAAAAAYRcEKAAAAAAAAAAAARlGwAgAAAAAAAAAAgFEUrAAAAAAAAAAAAGAUBSsAAAAAAAAAAAAYRcEKAAAAAAAAAAAARlGwAgAAAAAAAAAAgFEUrAAAAAAAAAAAAGAUBSsAAAAAAAAAAAAYRcEKAAAAAAAAAAAARlGwAgAAAAAAAAAAgFEUrAAAAAAAAAAAAGAUBSsAAAAAAAAAAAAYRcEKAAAAAAAAAAAARlGwAgAAAAAAAAAAgFEUrAAAAAAAAAAAAGAUBSsAAAAAAAAAAAAYRcEKAAAAAAAAAAAARlGwAgAAAAAAAAAAgFEUrAAAAAAAAAAAAGAUBSsAAAAAAAAAAAAYFVAFq2HDhslisZT4Z8uWLabDBAAAAAAAAAAAwClCTAfgCY0bN1bVqlWLXBYVFeXlaAAAAAAAAAAAAFCSgCxYjRo1SsOGDTMdBgAAAAAAAAAAABwQUFMCAgAAAAAAAAAAwP9QsAIAAAAAAAAAAIBRATkl4G+//aaJEycqPT1dcXFx6ty5s2688UZVqVLFdGgAAAAAAAAAAAD4j4AsWE2bNu20///rr7/qmWee0SeffKIbbrjBUFQAAAAAAAAAAAAoSkBNCdikSRO98847WrNmjdLS0pSVlaX58+erT58+ysrK0k033XRGMQsAAAAAAAAAAABmWex2u910EJ5mt9s1ZMgQTZo0SY0aNdK2bdtksVgcbp+VlaWYmBhJUmZmpqKjoz0VKgAAAAAAAAAAgN9wVw2lTBSsJGnr1q1q1qyZJGnt2rVq06aNw21P/Y8dHx+voKCAejENAAAAAAAAAADAJTabTYmJiZKktm3bavXq1S5tJyC/YVWUpk2bqlKlSkpNTdX27dudKlid6sR/dAAAAAAAAAAAAPzPoUOHXG5bZgpWkhQaGipJKiwsdKpdVFSUMjMz1a1bNyUnJzs1nSAAAAAAAAAAAECgstvtOjGZX3x8vMvbKTMFq8OHDys5OVmSVKtWLafaWiwWRUdHu/waGwAAAAAAAAAAAIpXZj7G9NZbb8lut6t8+fLq2LGj6XAAAAAAAAAAAADw/wKmYDVr1iw9+eSTSkhIOO3vs7Oz9cILL+j111+XJI0cOVJhYWEmQgQAAAAAAAAAAEARLPYTEwv6uYkTJ2rIkCGSjs+RWLNmTdlsNm3evFk5OTmSpOHDh+uTTz7hG1QAAAAAAAAAAAA+JGAKVvv27dNnn32mJUuWaMeOHTp8+LCsVquqVaum888/X3fccYd69eplOkwAAAAAAAAAAAD8R8AUrAAAAAAAAAAAAOCfAuYbVgAAAAAAAAAAAPBPFKwAAAAAAAAAAABgFAUrAAAAAAAAAAAAGEXBCgAAAAAAAAAAAEZRsAIAAAAAAAAAAIBRFKwAAAAAAAAAAABgFAUrAAAAAAAAAAAAGEXBCgAAAAAAAAAAAEZRsAIAAAAAAAAAAIBRFKwAAAAAAAAAAABgFAUrAAAAAAAAAAAAGEXBCgAAAAAAAAAAAEZRsAIAAAAAAAAAAIBRFKwAAAAAAAAAAABgFAUrAAAAAAAAAAAAGEXBCgAAAAAAAAAAAEZRsAIAAAAAAAAAAIBRFKwAAAAAAAAAAABgFAUrAAAAAAAAAAAAGEXBCgAAAAAAAAAAAEZRsAIAAAAAAAAAAIBRFKwAAAAAAAAAAABgFAUrAAAAAAAAAAAAGEXBCgAAAAAAAAAAAEZRsAIAAAAAAAAAAIBRFKwAAAAAAAAAAABgFAUrAAAAAAAAAAAAGEXBCgAAAAAAAAAAAEZRsAIAAAAAAAAAAIBRFKwAAAAAAAAAAABgFAUrAAAAAAAAAAAAGEXBCgAAAAAAAAAAAEZRsAIAAAAAAAAAAIBRFKwAAAAAAAAAAABgFAUrAAAAAAAAAAAAGEXBCgAAAAAAAAAAAEZRsAIAAAAAAAAAAIBRFKwAAAAAAAAAAABgFAUrAAAAAAAAAAAAGEXBCgAAAAAAAAAAAEZRsAIAAAAAAAAAAIBRFKwAAAAAAAAAAABgFAUrAAAAAAAAAAAAGEXBCgAAAAAAAAAAAEZRsAIAAAAAAAAAAIBRFKwAAAAAAAAAAABgFAUrAAAAAAAAAAAAGEXBCgAAAAAAAAAAAEZRsAIAAAAAAAAAAIBRFKwAAAAAAAAAAABgFAUrAAAAAAAAAAAAGEXBCgAAAAAAAAAAAEZRsAIAAAAAAAAAAIBRFKwAAAAAAAAAAABgFAUrAAAAAAAAAAAAGEXBCgAAAAAAAAAAAEZRsAIAAAAAAAAAAIBRFKwAAAAAAAAAAABgFAUrAAAAAAAAAAAAGEXBCgAAAAAAAAAAAEZRsAIAAAAAAAAAAIBRFKwAAAAAAAAAAABgFAUrAAAAAAAAAAAAGEXBCgAAAAAAAAAAAEZRsAIAAAAAAAAAAIBRFKwAAAAAAAAAAABgFAUrAAAAAAAAAAAAGEXBCgAAAAAAAAAAAEZRsAIAAAAAAAAAAIBRFKwAAAAAAAAAAABgFAUrAAAAAAAAAAAAGEXBCgAAAAAAAAAAAEZRsAIAAAAAAAAAAIBRFKwAAAAAAAAAAABgFAUrAAAAAAAAAAAAGEXBCgAAAAAAAAAAAEZRsAIAAAAAAAAAAIBRFKwAAAAAAAAAAABgFAUrAAAAAAAAAAAAGEXBCgAAAAAAAAAAAEZRsAIAAAAAAAAAAIBRFKwAAAAAAAAAAABgFAUrAAAAAAAAAAAAGEXBCgAAAAAAAAAAAEZRsAIAAAAAAAAAAIBRFKwAAAAAAAAAAABgFAUrAAAAAAAAAAAAGEXBCgAAAAAAAAAAAEZRsAIAAAAAAAAAAIBRFKwAAAAAAAAAAABgFAUrAAAAAAAAAAAAGEXBCgAAAAAAAAAAAEZRsAIAAAAAAAAAAIBRFKwAAAAAAAAAAABgFAUrAAAAAAAAAAAAGEXBCgAAAAAAAAAAAEZRsAIAAAAAAAAAAIBRFKwAAAAAAAAAAABgVIjpAAKd3W5XYU6e6TAcFhIZLovFYjqMgOFvx18iB0rDH4+3o8gLx5ADCNQc4Pi7zh9zguPtXuRA2eKPx9tR5IVr/DknOObu4a85wPF3jb8eb0eQE67x55zgmLsHOeDkPr26tzKoMCdPPzS8wXQYDrs+4XuFRkWYDiNg+Nvxl8iB0vDH4+0o8sIx5AACNQc4/q7zx5zgeLsXOVC2+OPxdhR54Rp/zgmOuXv4aw5w/F3jr8fbEeSEa/w5Jzjm7kEOOIcpAQEAAAAAAAAAAGAUBSsAAAAAAAAAAAAYRcEKAAAAAAAAAAAARlGwAgAAAAAAAAAAgFEhpgMAnJGZXaCEfenKybUqKMii8jGhali7nEJCqL2WFYdTc7QvKUt5BVaFhgSpaqVI1a4eLYvFYjo0eIHdbteeg5lKSctVQaFN4aHBqlsjRpUr8BHQsqKw0KYd+9KVnlkgm82uqMgQNapdTlGRdGnKiuycQu3Yl67snEJZLFL52DA1oi9QphxJy9Weg5kn+wJxFSJUt0YMfYEywm63a19SlpJTc072BWpXj1aVSpGmQ4OXWK027dibrmOZBbLabIqKCFHD2uUUExVqOjR4SU5uoXbsTVfW//cFYqND1bhOeYWG0hcoK46m52n3gQzl5lsVEhykyhXCVb9mLH2BMsJut+vAoWwlHclWfoFN4WHBqlUtWtUq0xcoK6xWm3buz9DR9HxZbTZFhoeoQa1YlYsJMx0a3IDRHfg0q9WmGYsP6Oe/dmrFphRt2ZUmu/30dSIjgtW2aWV1Oaeqbh3SRC0aVjQTLDwiO6dQP/2VoKnz92nlphTtS8o6Y53KFcJ1bvPKuui8GrrlsiZ0UgJM4uFsffXHNs1dkahVm48o9VjeGevUrRGj9s3jNKhHbV3br4EiI7i8BZL121I1btI2LVmbrLXbUpWTaz1teVCQRc3rl1eHllV0Xf8G6n1+TQUFcbMaKGw2u2YvPaCf/tqp5RsOa/OuY7LZTu8MRIQH65wmldS5zfG+QJsmlQxFC0/IyS3U+Bm7NHnuXq3cnKI9BzPPWKdiuTCd2zxOPTtW121Dmiq+SpSBSOEpyUdyNG7SNs3593hfIOVo7hnr1KoWrfYtKmvgBbU1dEBDRVO8CChbdqXpywnbtHjtIa3Zkqrs3MLTllssUrP6FdShRZyu7ltf/bvVUnAwxYtAYbfbNXd5on6YlqDlG1O0MeGorNbT+wLhYcFq06SiOrWuqmGXNlb7FnGGooUn5OVb9fus3Zr4zx6t2JiiXQcyzlinfGyYzm1WWd3bV9dtlzdR7eoxBiKFpxxJy9XXk7Zr9tKDWrkpRYeL6AvUqBql9s3j1K9rTd0wqBHFiwCzfc8xffnHNi1afUirtxxRVs6ZfYHGdcqrQ8s4XdWnngZ1r8NDjX6KET34pLx8qz74cZM+/mVzkR2RU+XkWrVkbbKWrE3WW99uUM+O8XpsWGsNuKC2l6KFJxw6kqNXv1yrcZO261hGfonrHknL06wlBzVryUE989EqXdWnvkbe1katGjNg6c/Wbj2il79Yqwl/71Zhob3EdfcczNSeg5ma8PduPfLmMt16WRM9eds5iqvIm1f+bPI/e/TmN+u1YNWhEtez2ezamJCmjQlp+mbydjWsHav7rm2he65trrDQYC9FC3crKLBp7PjN+vDnTdq+J73EdXPzrFq2/rCWrT+s937YqK7tqunRm1vp0gvr8qStHzuSlqtXv1ynryZuK/JhhVMdTc/X38sO6u9lB/X8J6s15KJ6GnlbG7VrzoClP9uUcFQvf7FWv87cpfwCW4nr7j+Upf2HsjTpn7167J3luvmSRhp5+zmqHkfx0p9NX7hfb3y9TnP+TSxxPbtd2rwzTZt3pum7qTtUr0aM7rmmuUZc31LhYfQF/JXVatNnv23V+z9u1JZdx0pcNy/fquUbUrR8Q4o+/GmTOrWuoodvaqWr+tSnL+DH0tLz9Pq49fpiwtYiCxSnOpaRr3+WJ+qf5Yka89kaDe5ZRyNvO0fnta7ipWjhCdt2H9MrX67Vz9N3KjfPWuK6B5OzdTB5r6bM26sn3l2hGwc11Kjb26pW9WgvRQtPmLPsoF4bt04zFx8ocT27Xdq255i27TmmH/9MUK1q0brrqmZ66MZWzMjiZzhaPqj6+S3Vb8Lzp/1dQVaO0ncmKuG3+dr85Z+yW0u+YfNnKzYe1i1PL9CGHUddaj93eaLmLk/U9QMb6v0nz1el8uFujtDzynIO2O12/fzXTt33ypKzDk4VpaDQph//TNCvM3fp2bva6fFb2vjl1BBlOQfyC6x66bO1evnLNWctVBXlaHq+3vp2g76dskNjR3fRFb3reyBKzyvLOXA4NUf3vrxEv87c5VL7hH0ZeuiNZfp68nZ9Paa72jar7OYIPa8sH39JWrctVcNGz9fqLUdcar9o9SEtWn1IV1xcTx8/1UVV/fDN27KeA3/8vVt3jVmk5NSSB6eKUlho168zd2nC37s18rZzNHp4W78csC7LOVBYaNMbX6/Xc2NXnbVQVZRjGfl6/8dN+n5agj548nxdN6CBXw5Yl+UcSD2WpwdeW6Lvpya41H73wUw9/s7yk32Bjq38b8C6LB9/6XgB8pan52vZ+sMutV+2/rCueewffTdlhz59pqtqVPW/AeuyngN/Ltin4c8v1IHkbKfb2mx2TZyzR5Pn7tXDN7bSC/ee65ezcJTlHLBabXrvh4166oOVZy1UFSUzu0Bjx2/RD38m6J3HOuuWyxrTF/Az6Zn5euTNZfpiwjaX2u8/lKXRH67UN1O266vnL1C3c6u7OULPK6vH3//O1mXIzgkLtH/OKsliUWSVCmp0VQ+d9/wwlW9cU0se+9R0eB7x5tfr9eR7y894vd8VP0xL0OylB/XHu710/jnV3BCd95W1HMjLt2rY6Pn6efrOUm+roNCm0R+u1MR/9mjKB7399unaspYD+5OydMmImVqzJbXU2zp8NFdXPjJHNw9urM+f7eaXhUup7OXA/BWJuuKROUVO9+SstVtT1XHoJL31SCeNuL6lG6LzvrJ2/CXpo5836aHXl6mgsPQd799n79bcFYn67a1e6tkx3g3ReV9Zy4GCApvuHLNQ4yZuL/W2rFa7XvxsjSbP3aupH/b226mByloOHDqSo8H3z9K/G1wbpD5V6rE8XT9yribN3aNvXuyuiHD/vP0tazmwbF2yLntwtpJSckq9rU0Jaep8wxS9dH97PXFrG78crCxrx1+Svvpjm+55abHy8p0fpP6vqfP3qeWQCfrptQvVr1stN0TnfWUtB6xWm0a8ulQf/7K51Nuy2ex685v1mjp/r6Z+2EcNa5dzQ4TeV9ZyIPVYni57YNZZZ9pwRHpmgW57doEmztmjn17r6bdTBpe1HFiz5YgGj5hV5GdBnLV9T7q63zJNo4e31fP3nEtfwA/45+hdGXFk/S7t/H2Bdv42XxvHTta0gaOUdSBFTYb2Unhl/7zIlmT0Byv02Nv/uqVYdcKhIzm6+I7pmru85CkkfFVZyoHcvEJdcv9MtxSrTrViY4q63TxVBw6V/iJnQlnKgT0HM9Rt2FS3FKtO9c3k7br8odnKLyj9Da8JZSkHZi05oL53z3BLseqEwkK7HnhtqV78bLXbtulNZen4S9LLn6/RfS8vcUux6oQjaXnqd/cMTV+4323b9KaylAP5BVZd+cjfbilWnWrdtlR1u3mqdu0veZppX1WWcuBgcpYuGDbVLcWqU42fsUuD7pulnP9898hflKUcWLAySb3u+MstxaoTbDa7Rr63QiPfWyH7fz+I7AfK0vGXpPd/2Kjbnl3glmLVCWkZ+Ro8Ypb++Hu327bpTWUpB6xWm24YOc8txapTbdl1TBcMm6atu9Lcul1vKUs5cDg1Rz1umeaWYtWppszbq753z1BmdoFbt+stZSkH/l1/WD1v+9MtxaoT7HZpzKdrNOLVpfQF/EBAFqxmzpypfv36qXLlyoqKilLr1q31yiuvKD+/5O/g+LrCnDwdXrVdlqAglavrn28MFeetb9brpc/XemTb2bmFuuT+WVrj4rRCviRQc8Bms+u6J+Zq1pKDHtl+wr4M9b5zutLSnZ9i0NcEag4cScvVxcOna8/BTI9sf+r8fbrpqXl+2TH5r0DNgeUbDuuyB2a7NN2DI57+cJU++nmTR7btTYF6/CXpk/Gb9dQHKz2y7bx8qy5/eLaWrk32yPa9KVBzwG6365anF2jy3L0e2f7exCz1vvMvtxbETQnUHEjPzFefO6ef9Zt1rvp72UFd89g/stnoC/iqddtSNej+mWd8RN1dXvtqnd4Yt94j2/amQD3+kvTdlO164LWlHtl2QaFN1z7+j/751zP3nN4UyDlwz0uL3f4Q6wmJh7PV+87pOpjsnw+znipQcyA7p1D97p7h8idCzmbR6kMa8uBsFbrx4ThTAjUHtu5KU/97Zpz1W/au+vCnTXruY/98mPVUgXr8Twi4gtVbb72lvn37asaMGYqNjVXTpk21ZcsWjRo1ShdeeKFyctz3pJYJsfWOJ2FemmcGdU1YvTlFT7633Kk2y38arH2zrtXynwY7tH5mdoFuGDnXrU9pmRKIOfDpr1s0cc4ep9o4mwObd6bp4TeXuRKezwnEHLj/lSXasdfxASpnj78k/TJ9l76e5N6n9k0JtBzIzinU9SPnKtuJJ99dyYGH31imjR66+fGmQDv+0vFz9IOvO3eOdjYHcnKtumHUXGX56VOVpwrEHPhuyg79+Kdz36pxNgcS9mXo3pcXuxKezwnEHHjkzWXamJDm8PquXAemzNvr9qf2TQm0HMgvsOqGkXOVnun4OdqVHBj1wQqt2OjeN/hMCLTjL0m79mfo7hedO0c7mwP5BTbd9NR8jw2EelMg5sCE2bv12W9bnWrjbA7sS8rS8BcWBcSDjIGYA6PeX6FVmx1/2NyV68DspQf11rf+//CCFHg5UFho041PzXPqe/au5MCYz1ZrwcokV0L0KYF2/E8VUAWrf//9V4899pgsFou+/vpr7d69W6tXr9aWLVvUqFEjLV68WCNHjjQdpsNCIsMUXilW4ZXLqcL/sXff4VFV+R/HP5NeqYEQiFQJRUAQBKRaQFBRsYBdEcW6ulZU1rLWxbU3ioq9olhALBSV3ovSS+iQEAIJ6W1mfn/wg6UkYWYyc8/M5P16Hp9nN/feOV8937n3zP3ee07rxur2wq2q27659i3fpJwtgTnF3fFKSu0a9sQclZW5N1hokBCj5MRYt9YlWpOarWfGBVYVvTrkwLbduXr41cVuH+dJDnz4wyb9Mmen222ZVB1y4PuZ2/TlL+49RedJ/0vS/S8t0i4vvlZuheqQA4+/vdTtJ+o9yYGSUoeGPTE7oJ6oqw79X1bm0LDHZ7v9UIknOZC6M1ej3lzqbohGVYcc2JOR79ET9Z7kwMTfturbaVvdbsuk6pAD0+bvcntBbU/HAo+8tkRbdvnmLS5fqQ458Ny7K7Vqk3sPlXiSA3b7obc5A+lBxurQ/w6HU8OfmuP223We5MCuvfl6MMAeZKwOOZCZVaQ7n5vn9nGe5MDU2Tv1yeTNbrdlUnXIgTnL0vXmF2vcOsbTscCT7yzX2tTAepCxOuTAK5+s0pLVmW4d40kOOJ3S8KfmqMBHb3T7QnXo/6MF5qqzFXj22WfldDo1fPhw3XTTTUf+3qJFC02YMEF9+/bV2LFjNWrUKNWvX99gpK7pNPJqdRp59TF/2zZ1oRY99r6hiLxv3MT1+nujd9erqcyLH/6tWy5PUfPkwJjfszrkwMOvLvbZtB/lufuFBdr0UyOFhgZGvT7Yc6C01KF7/rPAsvYO5pbo0TeW6LP/nG1Zm1UV7Dmwbku2Xv/MvR8mVbF0TaYmfL9Rtw9pbVmbVRHs/S8dWmfO2+vVVObNL9ZqxBWt1K5lHcvarIrqkAOj3lymbAufdr/3xYW65JzGiggPtazNqgj2HHA4nLr7BevGAgVFZXrw5cX6/vV+lrVZVcGeA9v35OqF930zPXx5Vm/O0jtfrdUDN7a3rM2qCPb+l6SJv22xdN3pw2PBM9vVs6zNqqgOOfDUmOXKOGDdtL33v7RQV/ZvqtiYcMvarIpgzwGn06m7X5gvq158Kyl16J8vLtT0dy+wpkEvCPYc2Lu/UE9ZOFXf5h05euWTVXri9k6WtVkVwd7/xwuMO7YuyM3N1bRp0yRJI0aMOGF7nz59lJKSopKSEk2ePNnq8Dyy4dNp+m3o05p+3fNa+uynKjqQq9ikurIX/+8Hfd+x96vv+AeOOS6iVpyGrnxPzS/vbXXIbnE4nHrb4vVE7Hanxn+z3tI2qyLYc2BXer6+d3MqwKraujtXv8zdZWmbVRHsOfDDH9u1O6PA0jYn/rZVGfsDZ3rYYM+BsRPXWfbD5LB3vlobMNOABHv/O53WjwUkaexExgL+IjOrSF/+4t5UgFWVtq9A38+0dvxRFcGeA7/N2+XWtMDeMPnPHdqRFjjTpwR7Doz/ZoPsdmuvy2O+Xhcw65kFe/9L0ttfWT9V5zsG2vRUsOdATl6JPp5s7dTtWTklPlsryxeCPQfmLEt3+y3bqpqxcI/Wb822tM2qCPYceH/SBsvffh73zXqVlgbG7CvB3v/HC5qC1YoVK1RSUqLIyEh16dKl3H169eolSVq40DeLeHpbzpZ0pc1Zpd2/r9DqMT9q5k2jldCxhc568fYj+yx47D3VP7OVmg3ueeRv3V+4VRmL12vLd3NMhO2y3xfv8dmiypWZ8P1GFRUHxmufwZ4D702y/seppIBauyDYc8BEX5SWOTThe/emHTIpmHMgr6DU8h+nkrRqU5bmrdhrebueCOb+l6SFf2do5Xrr3rQ+7JMpm5WbHxjrVwR7Dnzw/UaVGPihyFjAf5joC4fDqXe/DZzCdTDnQHGJXe9/596aNd6QujNX0xfstrxdTwRz/0vS3xsPGBmXffXrFu3Ptu6NnqoI9hz49KfNls66ctiYr9cFzENswZ4DYyaaGZeNC6CH2II5B8rKHBpvYFy2J6NAU2btsLxdTwRz/5cnaApWGzceuvnYpEkThYWVP9NhixYtjtk30OxbukGp385Ws8E9Va9LK0lSSXae5j84Vt2ev1XRibXV5KLuatDjNC14ZLzhaE9u4m9m1g/Yn12s3xcH5vyeQZcD08w80fTrvF0Bu9BuMOXAvgOFlk79cbSvfwucp+mOF0w5MH3BbrcWV/emiQG2hs1hwdT/krmxQF5BqX6dFxg3Ko8XdDlg6Ls4e1m60jOtfcPXW4IpB/IKSvWzoTffvzZ0/vGGYMqBWUvTtC/LTNEgUMeDwdT/kvSNoetAcYldk/8MjBuVxyMHvGP5uv3asivXSNtVFUw5UFJqN/bme6D+JpSCKwcWrdqnnYbWGmcs4J+CpmCVlXXo1dHatWtXuM/hbYf3DUR/vfatHGV2dXr4qiN/2/3HSm2bMl993r5X3UeP0PwHx6o4y/+nuFi6xr2F9Lxp2VpzbVdVsORAbn6JNmw7aKRtp1NasX6/kba9IVhyYNlac32wJjUrYN60LE+w5ADXAc8ES/9L5ICngiUHikvslq5lejxywLwV6/Ybm5Zt846cgH2ASQqeHDB7HeD3gD9gLOCZYMkBh8Op5evMfRfJAfNWb8oy8ra9dGia6LR9gfkAkxQ8ObB0jXXrGR+Pc4B/CpqCVVHRoaeyIiIiKtwnMjJSklRYGDhrlxwvd1u6tv44Tw37dFD9bm2O/H3p058ovlkD7f59hXbNXG4wQtcUFZdp9WZzhcNAPiEFSw6sWLff8nVrjkYOmGeyD8rKnPp7Y+A+vEAOVN3K9QdUVhYY81UfL1j63253GH14gOuAeas3Z6nU4PcwkG9WB0sOmP4eLl/HecA00w8wFRYF5gNMwdL/TqfT6HnA9DmoKoIlBzZtP6jcfDMzLkjkgD8w3Qem26+K4MkBc2OB1J25ysopNtZ+VQRL/5cnaApWUVFRkqSSkoqfkisuPpSA0dHRbn220+lUfn6+8vPz/WJ+27/fmCSH/dgKallhsfK2ZyhrXWC80r4jLd/oDYqNBtbO8qZgyIFNFi+u7W/tV1Uw5MDG7WbesDts0w6z7VdVcOSAue9hQVGZ9gTw03TB0P/pmYVG1is4zPQ5qKqCIQc2Ge4DcsA80+MxfhOYZ3I8Zrc7tW1P4D11fFgw9P/B3BJjU0JK5s9BVRUMOWD6PGy6/aoKhhww/T1kPGie6XszmwP4WuBv/e+tGorN6Q8VGC94//33NWLECKWkpGjDhvIXbX3hhRf0r3/9S71799bs2bNd/uz8/HzFxcVJkpKSkhQS4ud9eaUAALRVSURBVHqdL9wZoqccXV3evyoGTnpaO6cv05pxkz3+jKdDFqvU5vtCUmloojJq3lXutiVfXqIGCTGVHt8gIVphoSEqszuUnlnxG3PpmQU685oT/3uE2g+owcE33AvaA1b2vxRYOZAX2VUHYy8qd5sVORBdvFJ18r93L+iTsLq/y+ONHCiPL/LiQOwQFUa2K3fbyXLA1f6XKs6BWvk/KrbYu0+bkAPuSav1kBwh8eVu81YOVNT/klQ/+02FO7z7NJfpHAik/i8LqaO9tf5Z4XZf50CII09J2S+5F7QHGAtULD+io7LjLit3mxVjgaiSNaqbN9G9oD1ADlQsK/ZSFUSeUe42K8YCNfN/UVzxQveCPgnT1wEpsK4F6TXvlT20brnbrMiBegfHKcLu2zVVA/EccJivzwV2W5zSaz9c4XZfjwVszhI1zHrevaA9EKg5YMW1oCDiNGXFDS13mxVjgciSTUrI+8y9oE+C64B7smMuVH5Ut3K3WXEdqFEwU/FFrt8j9oSJnAik80BGjTtUGpZU7jYrciAhZ4Iiy3xb3AnU64DkXg44HA6lpR0aV3Xs2FErVqzwqM0wj47yQykpKZKk7du3q6ysTGFhJ/6rpaamHrOvJw7/R3dVhC1USvS4OcvtSdujEqfd9w1FOqWa5W9qkBCj5MRYlz4mLDTE5X2PZi8r1e7dvl9sPdD6X7IwB+pkSRV0nRU5UJif5/UcCMT+dpVP8uKUfCmy/E2u5oCn/S9J2VkHlJ1FDrjKJzkQX1rhu95W5EDG3nSpJMOjYysSrDngk/4PL5ZqVbzZ1zngsJcxFqiAZWOBWo2luPI3WTEWKCooIAcqYFkONMozOhY4ePCADu5nLOAqn+RFTIkUWv4mK3JgX0a6VOTb80Ag54TPzwWh8VLFy5D7PAecDjvXgUpYci2okWh0LFBcVMh9ATf4JCeScqSo8jdZcR3IyclWzj6uAxWx5DwQXVJhhcKKHMjclyEVkAMV8TQH9u7d63GbQVOw6tSpkyIiIlRcXKylS5eqe/fuJ+wzd+5cSVK3buVX7l3hyRtWCqAlMhomNbTkacqykBqqKG3TM08+RZM7T9GUJzy0TPUbNXIl1CoJtP6XrMuBgogoVbSCkBU5EBsTolpezoFA7G9X+SIvsqNClF/BtpPlgLtP0ZSnTs0oRceQA67yRQ7stZWqognhvJUDlX1Og/o1FeoMdyVUlwVrDvii/x22KFX2GJCvcyAspFSJjAXKZdVYoDA8Wgcq2GbFWCAmyqba5EC5rMqBg9GhqmhCNivGArVrRCkmirGAq3yRFxlhdlW0eo0VOZBYr4bCHL49DwRyTvj6XOBUmPY4HZKt/Hssvh4LhKpYDbgOVMiKa0FRWIwqmu/AirFAdKRUh/sCLvNFTuREhym3gm1WXAdqxUcoNoLrQEWsOA9khtlV0SpSVuRA/YR4hdvJgYq4kwNHv2GVmOh5hS5opgSUpEGDBmnq1KkaPny4JkyYcMy22bNnq2/fvoqIiNDOnTtVv359lz/36CkB8/LyFBvresW2tKBIn7e43uX9Tbsu9TOFx1TwaIMXOZ1OJfT5XAcOeraw3c7pVys5MVa79ubrlP5fuX38LZel6P2ne3vUtjsCrf8l63JgbWqWTrvsO4+Pr2oOfPRsH910aUuP2y9PIPa3q3yRF+O/Wa87np3n0bFV7X9JSv15iJon1/Do2IqQA+65/rE/9fnUVI+OrWoONKofo10zrvGo7coEaw746trQ+PyvtDO9otJ15aqaA1cPbK4v/3uOR227IxBzwqqxwPY9uWo60PMp+aqaA++MOkt3Xd3W4/ZdRQ5U7LOfNuuGUbM8OtYbY4G/v71M7VPqeHRsRQKxv13li7y4/Zm5evfb8qf0P5mq5kCt+AgdmHu9bDabR+27KpBzwopzQdvBk7RuS7ZHx1Y1Bwb1OUVT3j7fo7bdEag5YEX/Z2YVqV7fzz0+vqo58N/7z9TDN3fwuP3yBGp/u8IXOfH9zG26/P6ZHh3rjbHAgk8vVvfTXb9H7IlAzgkrzgMPvLRQr326xqNjq5oDUZGhypl/o8LDXX85xRPVJQeqUkM5mm97w2KPP/64bDabPvzwQ3388cdH/p6amqpbbrlFknT77be7VayCb9hsNnVuW/5c5Vbo3DbBWNs4pFXTmoqNNveSp8n8wyEm+6B2jQg1a1T+2kmwjslzMdcB/0AOVG+Nk+JUt1YF88FZgBwwz2QfREeFqk3zWsbaxyEmc+CMNnV9XqzCyXFfoHpLqB2lJg0rmBPQAuSAeSb7IDTUptNbeffBFbjPZA6cnlLH58UquC+oeqR79+4aPXq0nE6nhg0bpqZNm6pTp05q3bq1Nm/erG7dumn06NGmw8T/69nR3OSdPTpStDQtNDRE3TuY6YfaNSLUulktI23jf9q3rKO4GO9Ox+aqs06vzw0KP8B1AORA9Waz2YzlQGx0mDp4+c0auC+lSQ1jRcuu7eopLCyofg4HJLPXgQBdTCLIMBaAqRyICA+hYOUHTmkQ6/HaQ1XVqXVdRUcFzWo5AavH6VwHcKygG6GPHDlSv/76q/r376+DBw9q/fr1SklJ0fPPP69Zs2YpJibGdIj4f8MubamQEOtvGJ/ZLkGnt+LtGn9w6+UpRtq9eXAKNyj8QGREqG68+FQjbY+4opWRdnGsM9slqH3LSlba9pGwMJtuusS7U4LCMzdcfKrCDZyP27aopbN8PPUHXHPr5WbOx9cPOpUbFH4gNDREwwebGQ8yFvAPp51aW9071LO8XZtNxnIPx7p6YHPFGDgfN20Yp/O6NbS8XZzI1H2BoQOaqWZ8hJG28T82m81YDjAW8A/NkuONnY9N/RZB5YLyju2AAQM0bdo0ZWVlqbCwUGvWrNGoUaMUGWluyhGcqEnDeA3qc4rl7d51VRvL20T5Lu/XVPXr+H59hOPdMaS15W2ifHcOtb4vkhNjNahPY8vbxYlsNpvuHGr9Ofny85qqQQIPsPiDxLrRurJ/U8vbvXNoG96y9BMX9k5W4yTrn6o1cf1B+W4f0lpWfx0Takfpyv7NrG0UFTLx++zC3qeoWTLTQ/uDWjUide2FzS1v946hrRUaGpS3xALO2WcmqXWzmpa3a+J3CMo34opWCg21djAQHxuuay9sYWmbqJiJscDZZyapbQvrH6DFyfFYoQHxzRqo9xv3KLJOvEpzCzT3n28re+OuE/Zrec25av+Py6QQm9LnrdaCR9+Ts8yuBj3bqfO/rlN4bJScTmnXjGVa9vznktOpWq0bq/t/blV0Qk05yuzKXLFZC0e9L3tRiWq1bqw+b91z5PMjasYqPC5aX7a92cp//WM8PKy9Jv+5w7L2GifF6qoB1g+GK+NKPsQl11OvN/6hOu2aKm9Hhib3f/iY7RXlysmOMy0iPFQP3NhOj76+1LI2Lz+vqVo2sX4wjPK1a1lHF/ZO1s9zTjwH+sqDN7bjDTs/cv2gFnr23ZVK21dgSXs2m/TQTe0taQuuefCm9vr6t61yOJyWtJdYN9rY250V8cZY4LAB3zyluu2b64vWNx3522l3XqJTh54tW4hNB1P3aN5976gkx5rv3MmEhobo4WEddM9/FljW5oAejfz6bfvQyHD1HXe/arZMlr2oREWZB7Xg0feUuy39mP3ikuvp8oVvK3vd/8bSf9z6snK371VYTJTOmfCQ6nZorpDQ0GPywd+0OKWGhpzfTBN/22pZm/ddd5oiI0Itaw+VG3J+Mz35znJt25NnWZsPD2Ms4E/uv6GdPpq8SWVl1owF6tSM1C2X8VS9v7DZbBp5cwcNf3KOZW327JTI2/Z+pGH9WN148an68IdNlrV599VtjC1RgBNdcnZjtW5WU+u3HrSszZGMBfwWBSsDevz3dm38bLo2T/xTTS7qrl5v/EM/XfDoMfvEnVJfnUZerSnnj1Thvmyd+9EjanV9f63/6FeVHMzXrDteU96ODIVGhuv8iU/q1CF9tXnin7IXl2jRqAnKWrddtpAQ9RnzT7W/e7BWvjJR2et3HHNzo9vzt0hOawaEFel1RgPdfXUbvfPVOkvam/B0b7+b/sWVfCjJK9TyF79URHyMznj0mmO2VZorlRznLx64ob0m/rZVy9ft93lbtWtE6O1RZ/m8HXe5WsSubL/I2nEaMPGpI/uGRkcqvkmivu5wS7l//6r9LSrJzlOjczqq0yPXKCQ8TPbCYs0fOV5Za7f7/l/6KGMf76l2l3+n3PxSn7d11un1dc+1bX3ejru8kQNHO/Wqc9Tr9bv1+80vasevSyRJVy4eI3txqexFJZKkv9/6Xtsmzz/pcb4WHxuhd5/sqYvvmW5Jew/c0E5ntrN+6qGT8VYOVNbPXZ8drsYDuijulPqa3O8hHViz7chxJs8Fndsm6KGb2um/H66ypL3xT/ZUjTj/mv6lqmOBw9rePki52/eqbvv/PZyT1KeDWl59jn668DGV5Repw31XqNOj12rRqPd9+u/kjjuHttZXv27RvBV7fd5WfGy4xj/Z0+ftVNWGT6dr9+8rJEmtbx6onq/cqV+veOqE/cryisotXjrKyrTq7R9Ukp2ngZOe9nm8VfXmo2dp5qI92p9d7PO2Orauo5E3d/B5O+7y1nWg0bmddMaj18hms8kWFqrVY35U6jezKi2Eulok9ZWoyDB98ExvnXvrL5a0d8eQ1urbJcmStqrC1Zyo7PouVT42cGV8aIW2LWrrids66akxyy1p761Hz1JCbetn+vCmJhd1V1Lv9nKU2svt/4p+H37V/hbZC4uNfufLM+zSlvryl1RNX7DH521FRYbqg6d7+93b9t66DlR2Tuj/1ROKrldLcjhUml+kRY9/oAOrt1aaLyXZ1jxM8PKD3fTL3F1Kzyz0eVutmtbUk7d38nk7VeWtnKio301f/48WFhaiD5/po543/WTJg4w3DDpVF/S2ftYvd1WnHDgaj5hbLKpuDdU9vYVSJ82WJG2fulCxDesqvmmDY/ZrMqi7dk5bqsJ92ZKkDZ9MU7PLDv24PrB6q/J2ZEiS7MWlOrB6m+JOOfRkSO7WdGWtO3SDyelwKHNlquJOOfHGXGhkuJpf3lubvvzdJ/+e7hh935lq1si96RjSMwu0a2++0jNdfzr49iGt1a97I3fD8ylX86EkO08Zi9errODEH/GV5Uplx/mL8PAQffRsH7fXMPEkB9567Cwl1fO/acAO36j8vte9WvX2D+r1xj/c3q84K0+T+z985J+Nn83Q7t9XVPj3kuw8RdSMVe+3/6m5976lyec9qCXPfqo+7/zTqn/tIxonxem1h7u5dYwn/R8ZEaoPn+ntl1N/eCMHDotLrqeU6/opY+mGE7bNuuO1I7lw/M2Iyo7ztUF9G7u9ppQnOdCqaU09+4/O7oZnCW/mQEX9vH3qAv186ePK25lxzP7+cC54+q4z1KZ5LbeO8SQHrruohS49p4mb0fmWN8YCklQrJVmNB3bVqre+P+bvddo21d7F61WWXyRJ2jVzuVpc2ccH/yaeCw0N0YfP9FZ0lHtvvHiSAy8/2FVNGvr3NGD24tIjxSpJ2rd8U7nj+co4SsqUPm+1Sg7mezs8n0isG623H3PvoSJP+j8szHZo3BkevGOBPm/fq7n/fEeT+z+smTf8Rz3+e7vCYg/dmN/w6aHjJvd7SDt+W6Ker9x55LjKtlnhnK4N3Z4OyJMcaNIwTv994Ex3wzPC1Zyo6Pp+tMrGgJVts9Jjt5yuTq3de/vVkxwYfG4TXWNgCkJva3xhN+34dXGF/V/Z70DJ/Hf+eDabTe//u7fiY91748WTHHj+ns5Kaep/s6546zpQ2Tlh1m2vaPJ5D2py/4e1ZvwU9Xr9bkknzxcr1KkZqXef7OXWMZ70f0jIobGAvz3MXh5v5URF/S7517mg++n19eCN7dw6xpMcSKoXozce7e5ueEZUtxw4zP9G6kEutlGCCvdmyWl3HPlb3u5MxTZKOGa/uEYJytu173/77Np3wj6SFF2vlpoO6q6dM5adsC0sOlIp152nHb+d+JR84wu7KXfH3hOevjIhLiZck9/sp9o1XH/a+cxrJuuU/l/pzGsmu7R/3y4N3L4hbgVX86EyruaKP2ufUkcfP9fHrfUL3M2BB29s55fzE7t6o9LV/Q5ree252vTlzEr/Ht+0gYqzco88dZGxaJ1iGyWoTnvr13QYflmK/nGN628+udv/ISE2fTH6bLVqVsvDCH3Hqzlgs6nHK3dq0eMT5Cgpcz0IT4/zondGneXWtBzu5kC92lH68Y1+fvnDxFfngePtXbhOBWkHTvi7P5wLoiLD9MPr/dxa19DdHOjWvp7GPeF/b9Z4YyxgCwtVj5fv1IKR44/5HEna/3eqGvbucOiJOknNL++tiPgYRdSK80r83tKySU19Mfpst9YvcDcH7hzaOiAX125764XljuclKSwmUoN+Ga2Lp/1Xp99/pWwhgfvz7uoLWmjkza5PzeJu/0vSh8/08cvpIL15HXA6pYiahx7QCo+PUVFWrhwlZZUWQr1RJPWGVx7qqnPOdP3NJ3dzoFZ8hCa/2V/xsf71lm153LnmV3R9DzTh4SH6/vXz1Ki+6w8YupsDp7eqow+f8b83a44XUSNGQ5aN19VrPtQl01/S4Nmv64ZtX6rHy3dIOnTdTzyzldLmrna5/4/+Hegv3/njNU6K0zcvn+vWw6zu5sBNl7TUfde7d0PcCt68DlSWE0dPCR0RH1PhrEsV3U/wtYvPbqxn7j7D5f09GQuMe7yHugfAdJDezImK+t0fzwXP3dNZF/RKdnl/d3MgLiZcP77RT7VrRHoaomWqaw5IFKwCWnhctM775FGtGvOj9v+Vesy2kPAw9R3/gHb/+Zd2/LL4hGNbXnOeNn1h/u2qw9q1rKPp717gk9fy+3ZpoMlv9vfLm5T4n2subKEPn+mjkBDv/3j453Wn6aUHu/rlDxNXb1S6c0OzXpdWiqwZq53Tl1X695wtaYqsHa96XQ7dvDvl/C6KiI858samlWw2m954pLvuGNLa658dFmbT5//pq8v7NfX6Z3uDN3PgtNsvVsaS9dr/95Zy2+r15j269PdX1OOVOxVZt4bLx1khNiZcP79zvnp09H7+JdaN1oz3LvDLgqXk/fNARf1cEX85F6Q0ramZ712gBgnRXv/sbu3r6ZexA4J2nvqODw7R9p8X6eCm3SdsS5+/RqvHTtZ5nz6mi6b+R8X7cyRJzjK71WGe1OBzm+qL0We7/da1K0Zc0Upvj+rhl2OByrS/93LFN22gZS98fsK2gowsTex0m3664FH9NvQZJXZro9PuuNhAlN4z+r4z3X6y1hUhITZ98ExvXT/Iv9avO8yb14FZd7yqcyY8rCuXjNUFPz6ruf98W47SEx9GqawQWtk2X4qKDNOPb/Zzq2jlqjo1IzVt/EB1SKnj9c/2BW88zHC0ysYG7o4bfKlJw3j9/v6FOqVBrNc/u2PrOpo2bqBqBcBNypKcAm35fo7Wvj9Vk/s/rMVPfqh9yzdq/kPjJElJPdspY8kGl6/lFf0+PMzUd748A3oma9Kr5/lkncHrB7XQ+//u5ZN7DlXli/sCFen15j0asnScOo28WrPveeuE7SfLF197/LaOPpuu7+1RZ2nEld6/5+ALvviNWFm/S/5xLogID9WkV89zq2jlqhpx4fplzPl+uURAeaprDkisYWW5/N2Zik6sLVtoyJFEimuUoPzdmcfsl7c7UzWOqoTGJdc7Zp+w2Cj1/+Jx7fhtidaO/+mYY21hoeo7/n4VZmRp8RMfnBBD3Cn1Va9zS/1560ve/Ferss5tEzT/k0G6YdQsLVq17+QHuOCuq9ro5Qe7+m2xytV8qMzJciWQ3HRpSzVIiNbwp+ZoT0bVF4OPiQrTfx84U3dd1cbYDaoLpzyvGs3L/9Fd3poT3tDymnO1+ZtZJzxlf/zfS3ML9OeIl9V51LUKi43SvqUblbVhp7GbmCEhNo15vIdSmtbUqDeXqqi46nE0TorVR8/20TldG3ohQs9YlQO1Wp2iJhd10y+XPVnu9l8ue1L5uzNlCwvVGY9co95v/EMzrn/hpMdZqVaNSE0bN1D3v7RI703yztSEPTsl6pPn+6h5srkbMFaeByrq58r407mgXcs6WvDpxbrxX7M0Z7l31jMaflmK3niku98Wq7wxFmhw1mmKbZSgNsMHyhYaqvD4aF25eIymXPCoivfnaMPHv2nDx79Jkuqd0VL5uzNVmuf79QE8MXRAcyXWjdZNj8/W9j1Vn4YmMiJUz9/TWQ/c2C7gilWn3XGJmlzYTdOGPi17YckJ2x0lZSr6/wJkSXaeNn31u5pf1lurx/xodaheY7PZ9NKDXXVq4xp66JXFyi+s+lu/DevHaMK/e2ugD258uMqq64AtNESn33el/rjlJe1duE51T2+h8z5+VD+e+4CKD+Qe2e9wIXT+0BPXN6tsmxXiYyP085jz9fCrS/T2l2u98plntkvQp8/39asHV/xlbODJuMHXUprW1PxPLtbNT87WjIXeWc/ouota6J1RPVQz3j/erjtZ/xfs2a867Zpp3fs/S5LqdmihA6u3Htmn8cAztb2cB5MrUtHvQ8n8d748F5/dWH9MuEA3/mu2Nu/IqfLnhYeF6Kk7OumxW083VqwycV+gInPvPXSjusWQvury+PUnfOcryxcr2Gw2PX33GWqWHKd/vrhQOXlVX+u6Xu0ovftUTw0+t2nVA/QSq3PiZP3uT+eC6Kgw/fBGP/3rzWV65ZNVFb0I6JbTW9XRp8/3VXs/enCFHKiYf97FD2JF+3N0YNVWtbiiz5GFtfPTDpywmNn2qQt14Y/PaeXLE1W4L1utbjxfW3+YJ0kKizlUrNr9xwr9/fqkY46zhYao77j7VZyVd+Tpm+O1vOZc7fhl8TGvA/qLlk1qat4ng/TqJ6v1xDvLVVzi2c2ypg3j9MEzvY3epHaFq/lQmcpyJRAN6JmsNd9drgdeXqQPf9jk8ef07dJAE57urRanmH1K8OeL/1XpdkdxqUs3Kl29oRkWE6Vml/TQTxc84tLf0+ev0a+XH1pcNSQiTFf99X65CzhaxWaz6f4b2umi3qfo5idna/7KiufiP5nbrmyllx7oqhpxZn+YWpUDid3aKO6U+rpi/qFBSHS9WjrrpTsUXb+2Nnwy7ch+zjK71r73ky6f95ZLx1ktNiZc7z7VS1f2b6pb/z1XO9M9W38lOipUL9zTRfdc29b4umVWngcq6ueT8adzQdNG8frzg4v0zldr9ejrS1VQ5NkN6+TEWL33VC+jN6ld4Y2xwC+Dnzjyv+OS6+mSGS/r2653HflbdP1aKszIVmh0hDqOvFqr/Lyg0bdLklZNukyPvLZEYyeu9/hzuneopw+f7aPWfnST2lVtbx+kZpf11LShz1Q4Zo+qW0PFB/PlLLMrJCJMTS7srv1H3dAMVDabTXcMbaMBPZI1/Kk5+nNJmsefddMlLfXayG7Gp32x6jpQp10zRSfW1t6F6yRJ+/9KVUHaoRvfabP/llR5IfRkRVKrREWG6a3HztIV/ZrqlqfmaMuu3JMfVI6I8BA9c/cZevDG9grzwZubVeGtnHBFZWMDT8cNvpbcIFbTxg/Ue5M26MGXFyuvwLMb1ol1ozX+yZ5+t37lyfpfkuqc1vRIkapuh+baedQT7w3P7qilz37mUlsV/Q6U/Oc7X56zTk/UX99cpn+9tVRvfL7G4xvWZ7Spq4+e7WP8JrXV9wVckfrNLJ314m2KrB2n4qxDDwlVli9WG3Zpis7r1lC3PT1Pv87z/HfJVQOb6e3HevhkRqeqMJUT5fW7P54LIsJD9dKDXXV5vya6+Yk52rDtoEefExZm0+MjOuqxW09XRLj339ysCnKgYhSsDJg/crx6vX632t97uUrzCjX3vnckST1evkM7py3VzmlLlbcjQytenqgLJj8n6dCNpA2fTpcktR1xoep1OlXhMZFqcuGhdZm2/bRAf7/xnZpd2lNNL+quA2u26ZLph96g2rtkgxaNev9Q4zabTh16tubc6x8D0fKEhobo4Zs76IaLT9WE7zZq3DfrtWuvazcse3ZK1F1D2+iK/k198gq5L7iSD6HREbp87lsKjQxTePyh+axTJ83S8he+qDRXKjvOn9WqEakPnumjB25op7ET1+uTKZtd+pESGmrTZec20d1Xt1XfLg0C4klqV29Uurpfs0t76MDabTq4eY9Lfz98E1OSTr//SqXNW+3WTVJfSWlaU3M+GqTfF+/RmK/X6cc/dsjhOPmvlBpx4Rp2SUvdMbSN2jSv5ftAvcBbObDhk2nHFJgGTnpaa9/7STt+XaKw6EiFhIceuenZ7LJeR25qVnacSef3SNbGKVfqm2lb9c5X61x+87ZJwzjdMaS1hg9OUf263p9azhe8lQOV9fPJ+Nu5ICTEpnuuPU1XD2yuD37YqHET12ubi2/bdG1XT3dd1UZDBzTz2zesj1fVscDJnP/VE1JIiELDw5T67Syt/+AXX/8rVVl8bITGPN5T9153msZNXK+PJm/SwdyT/3gKCbHpkrMb666r2ui8bg39ctqfk4lJqqOu/x6mnG3pGvjtvyVJ9pIyTb3oMXV8+CoV7s3Shk+mqX63Nur08FVy2h2yhYUqfe4q/f3G/x5mu2TmK4qqW0Ph8dEasmy80uev1pwKpv/wR82S4/X7+xdo9rJ0jfl6nb6buU1lZScfC8TFhOuGQS1059A2xm9Quspb14H83ZmKSaytmi0b6eCm3Ypv2kDxTRKVk3po/FdZIdSVIqnVzj4zSWt/uELfzdimMV+v09wVrr15m5wYq9uHtNKtl7dSgwTX10PyJ954mEGqfGxQlXGDFWw2m267srWu7N9MH/24UWMnrnf5bZtOrevq7qvb6OqBzRXrp29YVyamQR3J6VRB+qF1iOq0aXLk/J7QqaUObtqtsoIilz6rot+B/vidP15MdJheG9ldd1/dVuO/Wa8PftioAweLT3qczSZd2PsU3XVVGw3o0cj4w2uu8PZ9gfJE1IhRaHSkCvdmSTr0pl5xVt6RG9ZSxfliyikN4vTzmPM1f2WGxny9Tt9M26rSspO/+RUdFarrLjw0FjijbWCt8X6Yt3LiZP3u7+eCs05P1KpJl+vHP7ZrzNfr9IeLDzI1SIjWbVccWr822QfTzFqhOueAzen0xot1wS0/P19xcYcWps7Ly1NsrOuJXlpQpM9bXO+r0LzuutTPFB7jX08dlJU5tOCvDC1dm6llazO1YdtBrVy/X2V2pyLCQzTiilbq3DZBZ51e3++eoA20/pf8Mwdy80s0Z/leLVubqaVrMrUzPV+rNh1Qmd2pyPAQ3XdDO3Vum6DeZyQa/VHqaX/XaNFQvV6/W5G144/cqMxev0PSsTcrK9vvsAsnP6+Nn8/Q5q//cOnvPV6+Q4nd2sgWGqJ9yzZq0b8mlHuBMp0XezLyNXfFXi1dk6nl6/Zr9rI0lZY5FR5m00V9Gqtz27rq3CZBvTs3MDrtlz/kwGFHF57iGtfXOe8/LFtoiGw2KXd7hhY/8YHydp1YBKqoYGU6B9amZmnBXxlatjZTf2/K0qJVGSorcyo8LERXDWymzm0S1OW0Q9cCkz9KTebAyfr5rP/epuTzOiu6fi0VZ+WqNK9Q3/W450gblZ0LTPe/3e7Qwr/3aemafVq2dr/Wb8vWinX/GwsMH5yiLqclqHuH+jrt1NrG4iwPYwHvyC8oPTIWWLYuU9t25x0zFrj3utPUuW2CenVKVKNE//pRSg54R3pmgeYu36tl6w79Jvhzyf/GAgN7nqIupyWoc9u66n1GA6NvV5seCzQb3FMd7r1cTodTthCb/n7re239fq5ikupo6PJ3lbMtXWX/PyXo4UJoZduOZjovNmzN1oK/M7Rs7X6tXL9fC48aCww5v5k6t62rLm0T1KNjol+9UeXrnKjs+l7Z2MCV8aHpPj+aw+HU4lX7tOT/xwLrtmRr+brMQ2OBsBANG9xSndseGgu0b1nbrx5edDcHkvt1VpvhAzX92uclSYN+Ga0Da7Zp/kPj1HnUdcrZlq5NX8yUVPn4Tir/d2CgfOePV1hUpjnL07Vs7X4tW5upLbtyj4wFIsJD9I9r2qpL2wT17JSoxklxxuI0fR2oKCdikxN09rsPKiwqQk6HU0X7c7T0mU90YM22I8dWdN/gMNM5se9A4f/Gg2sz9fviPUfGAuf3SFaXtglH7g3503p1JnOisn535Vxgus+Pt3lHjuavPJQDKzcc0Py/9h4ZC1zRr6k6tz00HuzVqYHCw6vPWMBfcqAqNZSjUbByAQUr/5Pc70vtzihQo/ox2jXjGtPhVCjQ+l8iB6oiEPvbVf6WF/7Y/xI5YCVywFr+1v+S/+bA8QIxJ/yxv8tDDvhOIOSAv/Z/IPa3q/wtL/w1B44XyDnhb31+vOqYA5f++Zp+u+KpI2sY+pK/97/knzkQyN/5k/G3nPDH/i9PIOeEv/X58cgB3zNRsAqMeVIAAAAAAACAauzHs+83HQIAAD7lP+/GAQAAAAAAAAAAoFqiYAUAAAAAAAAAAACjKFgBAAAAAAAAAADAKApWAAAAAAAAAAAAMCrMdADBLiw6UtelfmY6DJeFRUeaDiGoBFr/S+RAVQRif7uKvHANOYBgzQH633OBmBP0t3eRA9VLIPa3q8gLzwRyTtDn3hGoOUD/eyZQ+9sV5IRnAjkn6HPvIAfcbNPyFqsZm82m8Jgo02HAEPq/eqG/QQ6AHMDxyAmQA9UL/Y3jkRMgB6oX+hvHIydADriHKQEBAAAAAAAAAABgFAUrAAAAAAAAAAAAGEXBCgAAAAAAAAAAAEZRsAIAAAAAAAAAAIBRFKwAAAAAAAAAAABgFAUrAAAAAAAAAAAAGEXBCgAAAAAAAAAAAEZRsAIAAAAAAAAAAIBRFKwAAAAAAAAAAABgFAUrAAAAAAAAAAAAGEXBCgAAAAAAAAAAAEZRsAIAAAAAAAAAAIBRFKwAAAAAAAAAAABgFAUrAAAAAAAAAAAAGEXBCgAAAAAAAAAAAEZRsAIAAAAAAAAAAIBRFKwAAAAAAAAAAABgVJjpAAAAAIBg5XQ6peJi02G4JzJSNpvNdBQAAAAAgGqGghUAAADgK8XFKht6k+ko3BI28WMpKsp0GAAAAACAaoYpAQEAAAAAAAAAAGAUBSsAAAAAAAAAAAAYRcEKAAAAAAAAAAAARlGwAgAAAAAAAAAAgFEUrAAAAAAAAAAAAGAUBSsAAAAAAAAAAAAYRcEKAAAAAAAAAAAARlGwAgAAAAAAAAAAgFEUrAAAAAAAAAAAAGAUBSsAAAAAAAAAAAAYRcEKAAAAAAAAAAAARgVdwWrbtm2aMGGC7rjjDnXu3FkRERGy2WwaNmyY6dAAAAAAAAAAAABQjjDTAXjb66+/rjfeeMN0GAAAAAAAAAAAAHBR0L1hlZCQoAsvvFBPPfWUpkyZorvuust0SPCygsIyldkdkiSn02k4GgBWczicsjucR/43gOqnsKj6jQVmZWYoYspEvZq6vsJ9IqZM1OBFcyyMCjCDsQCAwqIy2avZWADA/zidx44FOA8AwSPoClaPP/64pk6dqn//+98aNGiQateubTokeIHD4dSMhbt1+f0zVKPHJ9q7v0iSlJZZqAdfXqRN2w8ajhCAr+07UKgXP/hLLS6cqPTMQkmHzgG9bvpJX0xNVXGJ3XCEAHzJ6XTqzyVpGvrQ7yeMBe4dvUDrtmSbDRCAzx04WKxXP1mlVpd8e8xYoNu1k/Xxj5tUWFRmOEIAvuR0OjVvxV5d9+ifqtnjU6UfNRa467l5WrXxgOEIAfhadk6x3vx8jdoOnnTMWKDL1T/q/UkblF9QajhCAFUVdAUrBJ+8glJdfM809b/tV30/c7vs9v89NeF0Sq9+slqtLvlWr3y8iicqgCD1y5ydan7hRD36+lJt25N3zLZ5K/bqusf+VMch32vb7lxDEQLwpcKiMl35wO8655af9c20rSorO3Ys8NYXa9V28CQ9O34FYwEgSP2xeI+aXzBRD768WJt35ByzbfHqfRr2xGy1v+I7bdzGg2xAMCousev6x2Ydeljt51SVljmObHM6pbET16vDld/rsTeW8OYlEKTmr9yrUwd9o3++uFDrtx57vV++br9GPD1XbQZP0upNFK+BQEbBCn6tuMSuS+6Zrp/n7Kp0P6dTeuiVxXrl49UWRQbAKtMX7NYl905XXkHlT02v33pQfYdPVdq+AosiA2CFsjKHrnxwpr6bue2k+z75znI9PXaF74MCYKm5y9N1wV2/6WBeSaX7pe7MVd/hU7V9Dw+wAMHEbnfoukf/1Bc/p55039ET/tYjry2xICoAVlq6Zp/63/ar9mcXV7rfzvR8nX3Lz8zEBAQwClbwa298tkZ/LElzef+HX12s9VuzfRcQAEsVFZfpukf/VJndtackd6Tl657/LPBxVACsNP7b9Sd9cOVoT49boWVrM30YkVkFdrsyi4vL/QcIRmVlDl376J8qLnGcfGdJ6ZmFuuPZ+T6OCoCVPv1psybN2Oby/i9/vEpzlqX7LiAAlnI4nLru0VkqcHHq3/3ZxRr+JOu6AoGKghX8lt3u0NiJ69w+btzEihcjBxBYvp2+Tfuyitw65oc/tmv33nwfRQTASk6nU+985f5YYOzX7h8TKJ7ZsEYNp/1Y7j9AMPpp9g7tTHfvuv7rvF1K3Zlz8h0BBARPxgJjgngsAFQ3Mxft0UY335iau2Kv/mZdOyAgUbCC35q+YM8Ja9W44qPJm1RcYvdBRACs9u637heg7XanPvhhow+iAWC1ucv3at2WbLeP++KXVOXmVz51WKC6tXFz/dK9b7n/AMFo/DcbPDruvUmeHQfAv6xYl6mla9x/c/rb6VuV6eaDbwD80/hvPHsw3ZP7CQDMCzMdQKBp2bKlQkKo81khL7K7FHuB28cdzC1Rk1M7KMzBfLXBLK3WA1JITaWlpyk5Odl0OPCRtFoPSyFxbh/3n1c/1PhnL/ZBRPAXnAOqh/zIM6TYS90+rrDIrlPbdFO4Y58PonJPdEiI1nY8y2ufd2pcnM6rl+i1zytPSkqKCh2uTb9mEueB6iG95j+l0DpuH/fGuK/12cuX+SAi+AvOAdVDQUQ7KW6I28eV2Z1q27GPIux7fBAV/AXngephb427pDD3x7/vf/qTfhgz1AcRwV9wDvAvjqN+Q/bq1UsrVni2vjQFKzelpbm+nhKqKCFPivXs0L17M6WSDO/GA/8Sb5dCJIfdrt27d5uOBr5S07MHBAoLS8iLYMc5oHqo09LjsUDGvv1SkfnciAkNlTqajsI9e/bsUYE9AN5W5zxQPcRLCnX/sKKiUvIi2HEOqB5qNZHcf35NkrQvM0sqIDeCGueB6iHW6dEd7OLiMvIi2HEO8Ft79+71+FgKVm5KSkriDSuL5EeEKdvDY5PqxyvEGe7NcOBn0kJD5ZAUEhqqpEaNTIcDH0lXgeyKcfu42CinapEXQY1zQPVQGB4ut2eedzolm00NEmIV6jSfG9EBOG5s2LBhYLxhxXmgWsiwFavUg+NiIu2qTV4ENc4B1UNReLj2u3vQ/48F6teNUXhtciOYcR6oHvaFFMuTyb6jIspUl7wIapwD/IvD4Tjysk9iouezglCwctOmTZsUG+vho75wy/7sIiX3/0pFxe494TugRyP9Om6zj6KCv0ju96V2ZxQoqUGSdq3eZToc+MgTby/Tc++udPu4n7/4t/p0Ge/9gOA3OAdUD7n5JWrU7yvl5rtxu9pmU69OiZrzsX8stu4sKlLZ0JtMh+GWjRs3yhYVZTqMk+I8UD2MnvCXHntjqdvHffv+I7qg99s+iAj+gnNA9VBUXKZTzv/avfWobDZ1bF1Hy79eKZvN5rvgYBzngerhrS/W6N7RC90+7tM379GV57/qg4jgLzgH+Jf8/HzFxR16LXru3Lkef07gPfKJaqNurShdPbC528fddVUbH0QDwITbrmylkBD3fmSe1qKWendu4KOIAFgpPjZCN158qtvH3TmUsQAQLIYPTlFEuHs/W5s1iteAnqxjAASDqMgwDR/c0u3j7hrahmIVECRuvLilYqLce+ciqV6MLj2niY8iAuBLFKzg10bderpqxUe4vH/fLg10UZ9TfBgRACud0iBO/7yurcv722zS6PvO5McpEEQeHtZe9Wq7/rZP13b1dEX/pr4LCICl6teN1iPDO7h1zIv3n+n2Ay8A/Nd917dTw/quTxN+eqs6uu4i9x94AeCfasZH6Mk7Orp1zAv3dla4mw+8APAPQffNnTdvnhISEo788+qrh179/Oqrr475+7x58wxHCle0bFJTP719vktFq27t6+n71/spNDTo0hqo1l56oKtuGHTyH5whITa991QvDerb2IKoAFilScN4/TzmfCW4ULTq2LqOprzVX5ERoRZEZq2+CfVVcvFQPdCidYX7lFw8VD90621hVIA1/n3nGbpjSMW5f5jNJr312Fkacn4zC6ICYJWkejH6dcwANUiIPum+bVvU0tS3z1dMNCtgAMFk5M0d9MCN7Vzad/R9XTTs0hQfRwTAV4Luzn5paan2799/5J/CwkJJUnFx8TF/Ly31ZOlemNCzU6IWfnaxbhh0arnTgTRIiNaTt3fS7+9fqNo1Ig1ECMCXQkND9PHzfTTuiZ5q26JWufuc36ORZr53gW65vJW1wQGwRJfT6mnR5xfr5sEtFRV5YjGqXu0oPXpLB83+8CLVr3vym1kAAktIiE1jHu+hD5/trQ4pdcrd59yuSfp17AD94xrX38wGEDjap9TRos8v0W1Xtip3arA6NSP10E3tNffjQWqUyLrjQLCx2Wx65aFu+vw/Z+uMNnXL3af3GYma8lZ/PTL8dIujA+BNQffIydlnny2n02k6DHhZq2a19MkLffXKQ131w+/btfdAoSLCQtWySQ0N6tOY13yBIGez2XT7kNa67cpWmr0sXcvWZiq/sEy14iM0sGeyWjapaTpEAD7WPLmGPnimj15+sJu+n7lN6ZmFCguzqUVyDV18duOgfKsKwP/YbDYNuzRFN13SUvNXZmjRqgzlFZSpZly4zu+RrDbNa5kOEYCPNU6K0/gne+m/93fV979v056MAoWE2NSsUbwuObuxot1c4wZA4Ln2oha65sLmWrI6U/NW7lVufqlqxIarX/eGatey/IdaAAQWruYIKPXqRGvElSefDgRAcLLZbOrbJUl9uySZDgWAIXVqRvI2JVCN2Ww29eyUqJ6dEk2HAsCQmvERTPcFVGM2m01d29dT1/b1TIcCwAd4LQUAAAAAAAAAAABGUbACAAAAAAAAAACAURSsAAAAAAAAAAAAYBQFKwAAAAAAAAAAABhFwQoAAAAAAAAAAABGUbACAAAAAAAAAACAURSsAAAAAAAAAAAAYBQFKwAAAAAAAAAAABhFwQoAAAAAAAAAAABGUbACAAAAAAAAAACAURSsAAAAAAAAAAAAYBQFKwAAAAAAAAAAABhFwQoAAAAAAAAAAABGhZkOAAAAAAhakZEKm/ix6SjcExlpOgIAAAAAQDVEwQoAAADwEZvNJkVFmQ4DAAAAAAC/x5SAAAAAAAAAAAAAMIqCFQAAAAAAAAAAAIyiYAUAAAAAAAAAAACjKFgBAAAAAAAAAADAKApWAAAAAAAAAAAAMIqCFQAAAAAAAAAAAIyiYAUAAAAAAAAAAACjKFgBAAAAAAAAAADAKApWAAAAAAAAAAAAMIqCFQAAAAAAAAAAAIyiYAUAAAAAAAAAAACjKFgBAAAAAAAAAADAKApWAAAAAAAAAAAAMIqCFQAAAAAAAAAAAIyiYAUAAAAAAAAAAACjKFgBAAAAAAAAAADAKApWAAAAAAAAAAAAMIqCFQAAAAAAAAAAAIwKMx0AAABAMHM6nVJxsekwXBcZKZvNZjoKAAAAAABQzVCwAgAA8KXiYpUNvcl0FC4Lm/ixFBVlOgwAAAAAAFDNMCUgAAAAAAAAAAAAjKJgBQAAAAAAAAAAAKMoWAEAAAAAAAAAAMAoClYAAAAAAAAAAAAwioIVAAAAAAAAAAAAjKJgBQAAAAAAAAAAAKMoWAEAAAAAAAAAAMAoClYAAAAAAAAAAAAwioIVAAAAAAAAAAAAjKJgBQAAAAAAAAAAAKOCqmDldDo1b948PfLII+rRo4fq1Kmj8PBwJSYmatCgQZo8ebLpEAEAAAAAAAAAAHCcMNMBeNPvv/+ufv36SZJsNptatGih5s2ba/PmzZo6daqmTp2q4cOH6/3335fNZjMcLQAAAAAAAAAAAKQgfMOqefPmeuutt5SRkaFNmzZp6dKl2r9/v1577TXZbDZ98MEHGjt2rOlQAQAAAAAAAAAA8P+CqmDVtWtXrV+/Xv/4xz+UkJBw5O+hoaG67777dNttt0mS3n33XVMhAgCAKvhrw37944X5yswukiQdOFisn+fslMPhNByZ783KzFDElIl6NXV9hftETJmowYvmWBgVAADWWrM5S/e9uPCYscDkP7bLbncYjgwAAFhhw9ZsPfjyomPGApOmb1VpKWOBYBBUUwLWqFGj0u0DBgzQ+PHjtWHDBosiAgAA3rA2NUsjnp6r+Sszjvl7YbFdF909Tc0axeuVh7rqsvOamgkQAAD41OYdORrx9Fz9uSTtmL8XFtt16T9nqHFSrF6870xdfUELQxECAABf2pGWp1v/PUfTF+w55u+FxXZd+eDvalg/Rs/f01nDLk0xFCG8IajesDqZoqJDVdeYmBjDkQAAAFctX5upnjf+dEKx6mhbd+fqigdm6v1JPJQCAECwWbM5S2fdMOWEYtXRdqTl65pH/tSbn6+xMDIAAGCFzTty1P36KScUq462J6NANz8xR6Mn/GVhZPC2alWw+vrrryVJvXv3NhwJAABwRVZOsS76xzRl55acdF+nU7r92XmauzzdgsgAAIAV8gpKdeHdvykzq8il/e/770JNm7/Lx1EBAACrFJfYdeHdvyltX4FL+z/2xlL98Ps23wYFn6k2Bauff/5ZP/74oyRp5MiRhqMBAACu+OjHTUrPLHR5f4fDqZc+WuXDiMwrsNuVWVxc7j8AAASbL35O1Y60fJf3dzql/34Y3GMBAACqk0nTt2nT9hy3jhk94W8fRQNfC6o1rCqSmpqqG264QZJ07733qkePHoYjAgAAJ+NwODV24jq3j/tp9k7tSMtT46Q4H0Rl3jMb1uiZDUx3BAAIfk6nU2O+dn8sMHPRHq3fmq3WzWp5PygAAGCpMR7cF1i0ap+Wr83UGW0TfBARfCnoC1bp6ekaOHCgDhw4oPPPP18vv/yy6ZAAAIALdqTluf0UlXSo0PX74j1Bu9DqrY2b64qGp5S77YKFsyyOBgAA39mfXay/Nhzw6NgZC/dQsAIAIMAVFJZp3oq9Hh07feFuClYByOZ0Op2mg/CVAwcO6Oyzz9aqVavUs2dPTZs2TTExMW5/Tn5+vuLiDj2lnZSUpJCQajOTIuC30mo9IEdITYU4Diop+1XT4QDwgdLQRGXUvMujY2vm/6K44oVejsgz0SEhWtvxrCp/zqzMDPVf8KdGt+2gB1q0LnefiCkTdWH9JP3QzfP1OtuuXKBCh8Pj4wGrMBYAgl9ZSG3trXWfR8fWKJih+KI53g0IgF9hLAAEP7stVum1PVveJ65wtmoWzvRyRKiIw+FQWlqaJKljx45asWKFR58TtG9Y5eTkaODAgVq1apXOOOMMTZ061aNi1fEO/0cHYFi8XQqRHHa7du/ebToaAL4QXizV9OzQg1npOpjlH+eGmNBQqaPpKFy3Z88eFdjtpsMATo6xABD8wnKlWp4dmpO9Tzn7OTcAQY2xABD8QiKl2p4dmndwn/L2cW4wYe9ez96Kk4K0YFVQUKBBgwZpyZIlatOmjX777TfVrOnhHa/j8IYV4B/SQkPlkBQSGqqkRo1MhwPAB5wKUbojR46QGm4c5JRsNtWPy1d4jH+cG6IDbNzQsGFD3rBCQGAsAAQ/p2zaa98ve2hdNw46NBaoF5ujiCjODUAwYywABD+npIyydJWFNXDjoENjgYSYHEVybrDM0W9YJSYmevw5QVewKikp0WWXXaY5c+aoRYsWmjFjhhISvDdX5aZNmxQbG+u1zwPgmeR+X2p3RoGSGiRp1+pdpsMB4CNPj12uf4914zVym01nn5mkPyZ49uq5LziLilQ29CbTYbhs48aNskVFmQ4DOCnGAkD18PJHq/Twq4tdP8Bm05ntErT4CzeOARCQGAsA1cO4iet053PzXT/AZlOb5rW05vs5stlsvgsMxzh6WaW5c+d6/DmB9cjvSdjtdl177bWaNm2akpOTNWPGDDVs2NB0WAAAwEMjrmiluBj3nq+5//rTfBQNAACw2s2DW6pWfIRbxzxwQzsfRQMAAKx23UUtVK+2ew9VPnBDO4pVASqo3rCaOHGiJk2aJEmKiIjQ9ddfX+G+3377rRo0cONVQgAAYLmG9WP1zcvn6ZJ7p6u07OTT1D1xe0ddck4TCyIDAABWqFsrSj+80U8D7/xNRcUnX2PxgRvb6eoLWlgQGQAAsEJ8bISmvNVf5434RfmFZSfd//YhrXXL5SkWRAZfCKqCVXFx8ZH/vWXLFm3ZsqXCfYuKiqwICQAAVNHAXsn6bdwA3fiv2dq1N7/cfeJiwvTs3Z31zyB+u6pvQn2VXDy00n1Oth0AgEDUt0uSfn//Al37yJ/atiev3H2io0L1xG2d9OgtHSyODgAA+Fq3DvU1+8OLdPUjf2jT9pxy94mMCNXIm9vr6bvO4O2qABZUBathw4Zp2LBhpsMAAABedk7Xhtr6y1D9NHuH3pu0Qak7c1Va5lCDhGhde2EL3TDoVNWIc2+6IAAAEDjOOj1Rm6cO0a/zdmn8Nxu0cftBlZY5VK92lK4e2FzDLm2pWjUiTYcJAAB85Iy2CVr/45WavmC3xn+7Xuu2ZKu45NBYYMj5zXTz4JaqW4v1mANdUBWsAABA8AoLC9Hgc5tq8LlNTYcCAAAMCA0N0UV9GuuiPo1NhwIAAAwICbFpQM9kDeiZbDoU+EiI6QAAAAAAAAAAAABQvVGwAgAAAAAAAAAAgFEUrAAAAAAAAAAAAGAUBSsAAAAAAAAAAAAYRcEKAAAAAAAAAAAARlGwAgAAAAAAAAAAgFEUrAAAAAAAAAAAAGAUBSsAAAAAAAAAAAAYRcEKAAAAAAAAAAAARlGwAgAAAAAAAAAAgFEUrAAAAAAAAAAAAGAUBSsAAAAAAAAAAAAYRcEKAAAAAAAAAAAARoWZDgAAACCoRUYqbOLHpqNwXWSk6QgAAAAAAEA1RMEKAADAh2w2mxQVZToMAAAAAAAAv8aUgAAAAAAAAAAAADCKghUAAAAAAAAAAACMomAFAAAAAAAAAAAAoyhYAQAAAAAAAAAAwCgKVgAAAAAAAAAAADCKghUAAAAAAAAAAACMomAFAAAAAAAAAAAAoyhYAQAAAAAAAAAAwCgKVgAAAAAAAAAAADCKghUAAAAAAAAAAACMomAFAAAAAAAAAAAAoyhYAQAAAAAAAAAAwCgKVgAAAAAAAAAAADCKghUAAAAAAAAAAACMomAFAAAAAAAAAAAAoyhYAQAAAAAAAAAAwCgKVgAAAAAAAAAAADCKghUAAAAAAAAAAACMCjMdAAAEM6fTKRUXmw7DPZGRstlspqMAAAAAAAAAUI1QsAIAXyouVtnQm0xH4ZawiR9LUVGmwwAAAAAAAABQjTAlIAAAAAAAAAAAAIyiYAUAAAAAAAAAAACjKFgBAAAAAAAAAADAKApWAAAAAAAAAAAAMIqCFQAAAAAAAAAAAIyiYAUAAAAAAAAAAACjKFgBAAAAAAAAAADAKApWAAAAAAAAAAAAMIqCFQAAAAAAAAAAAIyiYAUAAAAAAAAAAACjgqpgNXnyZN15553q2rWrGjVqpMjISMXHx6tjx44aNWqUMjMzTYcIAAAAAAAAAACA44SZDsCbXn31Vc2aNUsRERFq2LChOnTooIyMDP3999/666+/9P7772vatGnq2LGj6VABAAAAAAAAAADw/4LqDavhw4dr5syZys3N1datW7VkyRJt375df/31l9q1a6d9+/bp2muvNR0mAAAAAAAAAAAAjhJUBasbb7xR5557riIiIo75e/v27TVhwgRJ0rp167Ru3ToT4QHwguycYk35c4cKisokSWV2h+GIrDErM0MRUybq1dT1Fe4TMWWiBi+aY2FUAAAAAABYK6+gVFNnH3VfoKx63BcAgOogqKYErEybNm2O/O+CggKDkQDwxNrULL326Wp9/nOqCovsR/6+d3+RLr13uu67/jSd07WhwQgBAAAAAICvbNmVo9c/W6OPJ29STl7pkb/vPVCk/rf9onuvPU0Xn93YYIQAgKqqNgWrefPmSZJiY2PVqlUrw9EAcMeUP3foqod/V2Gxvdztk//cocl/7tAL93bRY7eebnF0AAAAAADAl+YsS9cl905Xdm5JudtnLNyjGQv36P4bTtMrD3WTzWazOEIAgDcE1ZSAx3M4HEpLS9Mnn3yiYcOGSZJeeOEFxcXFmQ0MgMvmLEvXlQ/OrLBYdbRRby7VO1+ttSAqAAAAAABghb83HtBF/5hWYbHqaK99ukZPjVluQVQAAF8IyoLVuHHjZLPZFBoaqoYNG+qmm25ScnKypkyZonvvvdd0eABc5HQ6de+LC1RS6vp81CNfXaKDLgxiA1WB3a7M4uJy/wEAAAAAINg88toS5eaXnnzH//f8e39pZ3qeDyMCAPhKUE4JmJSUpJ49e6qsrEw7d+5UWlqa/v77b33xxRfq3bu3atasaTpEAC5Y9Pc+rVx/wK1jCorK9MmUTbrn2tN8FJVZz2xYo2c2rDEdBgAAAAAAPpe6M0e/ztvl1jEOh1PvfrtBz/6js4+iAgD4SlAWrC699FJdeumlR/7/qlWrdPfdd+vLL7/Ujh07NHfuXIPRAXDVJ1M2eXjc5qAtWN3auLmuaHhKudsuWDjL4mgAAAAAAPCdz37a7NFxn0zZRMEKAAJQUBasjte+fXtNnTpVzZs317x58zRjxgz169fPo89q2bKlQkKCciZFwO/sj7taimjj9nHLV21RcnKyDyJyX3RIiNZ2PMtrn3dqXJzOq5fotc8rT0pKigodrk/DCACACWm1HpBCaiotPc1vrvsAAMC7smIulqK6uH3cjj05apScLJsPYgIAnMhx1L3EXr16acWKFR59TrUoWElSfHy8+vbtq0mTJumvv/7yuGCVlpbm5cgAVKhxoRTh/mEOe5l2797t/Xg8EBMaKnU0HYV79uzZowK73XQYAABULt4uhUgOu91vrvsAAMDLGuZJUR4c53RqD+MDADBi7969Hh9bbQpWklRWViZJslfhRmxSUhJvWAEWyY4sVr4Hx0UoV/UaNfJ6PJ6IDsDzRcOGDXnDCgDg99JCQ+WQFBIaqiQ/ue4DAADvyo0qVY4Hx4U6s9WA8QEAWMbhcBx52Scx0fPZoapNwerAgQOaNevQ+i4dO3b0+HM2bdqk2NhYL0UFoDJ/bzyg06/83u3jxr5wvYZf9owPInKfs6hIZUNvMh2GWzZu3ChblCePsAEAYJ3kfl9qd0aBkhokaddq9xZjBwAAgWH33nw1Gfi17HanW8c998BAPXrLIz6KCgBwvPz8fMXFxUmS5s6d6/HnBN6j/xVYunSpnnzySW3efOJijCtWrNAFF1yg7OxstW/fXuedd56BCAG4q0NKHfXq5F5FvnaNCF09sLmPIgIAAAAAAFZplBirwec0ceuYiPAQDR+c4qOIAAC+FDQFq7y8PD377LNq2bKlEhMT1aVLF3Xr1k2NGjXSGWecocWLFyslJUU//PCDQkNDTYcLwEXv/KuH4mPDXd5//JO9FBNdbV4eBQAAAAAgqL30QFcl1o12ef9XH+6m+m7sDwDwH0FTsDr99NP1xhtvaPDgwapRo4Y2btyoFStWyG63q1+/fnrnnXf0119/qXlz3rwAAkmHlDr6bdwA1a0VWel+YaE2ffRsHw05v5lFkVmrb0J9lVw8VA+0aF3hPiUXD9UP3XpbGBUAAAAAAL7VLDleM94dqOTEky/R8fKDXXX31W0tiAoA4As2p9Pp3iSw1dDR8y/m5eWxhhVgQNq+Ar377Xq9O2mD9mQUHPl7fGy4bhh0qu6+uo3atqhtMMLyBeIaVmETP2YNKwCA3zu8hlWj+jHaNeMa0+EAAAAf259dpA++36ixE9dr6+7cI3+PigzVNRc0191Xt1XntgkGIwSA6stbNRTmzQIQEJLqxeipO8/QqFs7avXmA8rOLVFcTLhaN6up+NgI0+EBAAAAAAAfqlsrSg/f3EEP3tReqzdn6cDBYkVHhiqlaU3VrlH5rCwAgMBAwQpAQAkPD1GnNjwxBQAAAABAdRQSYlOHlDqmwwAA+EDQrGEFAAAAAAAAAACAwETBCgAAAAAAAAAAAEZRsAIAAAAAAAAAAIBRFKwAAAAAAAAAAABgFAUrAAAAAAAAAAAAGEXBCgAAAAAAAAAAAEZRsAIAAAAAAAAAAIBRFKwAAAAAAAAAAABgFAUrAAAAAAAAAAAAGEXBCgAAAAAAAAAAAEZRsAIAAAAAAAAAAIBRFKwAAAAAAAAAAABgFAUrAAAAAAAAAAAAGBVmOgAACGqRkQqb+LHpKNwTGWk6AgAAAAAAAADVDAUrAPAhm80mRUWZDgMAAAAAAAAA/BpTAgIAAAAAAAAAAMAoClYAAAAAAAAAAAAwioIVAAAAAAAAAAAAjKJgBQAAAAAAAAAAAKMoWAEAAAAAAAAAAMAoClYAAAAAAAAAAAAwioIVAAAAAAAAAAAAjKJgBQAAAAAAAAAAAKMoWAEAAAAAAAAAAMAoClYAAAAAAAAAAAAwioIVAAAAAAAAAAAAjKJgBQAAAAAAAAAAAKMoWAEAAAAAAAAAAMAoClYAAAAAAAAAAAAwioIVAAAAAAAAAAAAjKJgBQAAAAAAAAAAAKMoWAEAAAAAAAAAAMCoMNMBAAAAAECwcjqdUnGx6TDcExkpm81mOgoAAAAA1QwFKwAAAADwleJilQ29yXQUbgmb+LEUFWU6DAAAAADVDFMCAgAAAAAAAAAAwCgKVgAAAAAAAAAAADCKghUAAAAAAAAAAACMomAFAAAAAAAAAAAAoyhYAQAAAAAAAAAAwCgKVgAAAAAAAAAAADCKghUAAAAAAAAAAACMomAFAAAAAAAAAAAAoyhYAQAAAAAAAAAAwCgKVgAAAAAAAAAAADCKghUAAAAAAAAAAACMCvqC1XvvvSebzSabzaazzz7bdDgAAAAAAAAAAAA4TlAXrNLT0zVy5EjTYQAAAAAAAAAAAKASQV2wuueee5STk6NBgwaZDgUAAAAAPDYrM0MRUybq1dT1Fe4TMWWiBi+aY2FUAAAAAOA9QVuwmjx5sr799lvdfffd6ty5s+lwAAAAAFTRktX7dPMTs1W/7+fanVEgSdqXVaRvpm1VaanDcHQAAAAAgKoIyoJVbm6u7r77bjVs2FDPPfec6XAAAAAAVMHB3BJdcOdv6nrtZH304ybtyyo6sq2k1KGhD/2uUwdN1Mr1+w1GCQAAAACoiqAsWD322GPatWuXXn/9ddWoUcN0OAAAAAA8lF9Qqv63/6Jf5+2qdL8dafnqc/NUilYAAAAAEKCCrmC1YMECjR07VhdccIGGDBliOhwAAAAAVfDwq4u1ZHWmS/vm5pfqsvtmqKwseKcHLLDblVlcXO4/AAAAABDIwkwH4E2lpaUaMWKEIiMj9fbbb5sOBwAAAEAVZOcU6+PJm906ZtuePP00e4cGn9vUN0EZ9syGNXpmwxrTYQAAAACA1wVVwWr06NFas2aNnn/+eTVv3tx0OAAAAACq4JMpm1VQVOb2cWO+Xhe0BatbGzfXFQ1PKXfbBQtnWRwNAAAAAHhP0BSsNmzYoOeff15t2rTRww8/7LN2WrZsqZCQoJtJEQAAAPA7WbGDpchObh83c95GJSeP8H5AHogOCdHajmd57fNOjYvTefUSvfZ55UlJSVGhI3inVQQAAADgXY6jfj/06tVLK1as8OhzgqZgdeedd6q4uFjjxo1TeHi4z9pJS0vz2WcDAAAAOMoppVKk+4c5nGHavXu39+PxQExoqNTRdBTu2bNnjwrsdtNhAAAAAAhAe/fu9fjYoClYLV++XCEhIRo6dOgJ2/Ly8iRJ8+fPV4MGDSRJGzduVI0aNdxuJykpiTesAAAAAAtkR9mU78FxoSpWg0aNvB6PJ6ID8LdDw4YNecMKAAAAgMscDseRl30SEz2fESJoClbSof8olVXvSktLj2x3ePgDbNOmTYqNjfXoWAAAAACu+3nOTl109zS3j7v92u5651+7fBCR+5xFRSobepPpMNyyceNG2aKiTIcBAAAAIEDk5+crLi5OkjR37lyPPyfwHverQHZ2tpxOZ7n/PPXUU5Kkvn37HvlbrVq1zAYMAAAAoFIDejRSs0bxbh9359DWPogGAAAAAOBLQVOwAgAAABBcQkND9OQdHd065op+TdWuZR3fBAQAAAAA8JmgmhIQAAAAQHAZdmmKtu3O09PjVpx0395nJOrj5/pYEJX1+ibUV8nFJ67Xe7STbQcAAAAAf8YbVgAAAAD82r/vOkMfP9dHpzauUe72GnHheuDGdpo2fqBiY8Itjg4AAAAA4A02p9PpNB2Evzt6wbC8vDzFxsYajggAAACofhwOp2Ys3K2fZu9Udk6JYqLD1LlNXV17YQu/LVQ5i4pUNvQm02G4JWzix7JFRZkOAwAAAECA8FYNhSkBAQAAAASEkBCbzu+RrPN7JJsOBQAAAADgZUwJCAAAAAAAAAAAAKMoWAEAAAAAAAAAAMAoClYAAAAAAAAAAAAwioIVAAAAAAAAAAAAjKJgBQAAAAAAAAAAAKMoWAEAAAAAAAAAAMAoClYAAAAAAAAAAAAwioIVAAAAAAAAAAAAjKJgBQAAAAAAAAAAAKMoWAEAAAAAAAAAAMAoClYAAAAAAAAAAAAwioIVAAAAAAAAAAAAjKJgBQAAAAAAAAAAAKPCTAcAAAAAAEErMlJhEz82HYV7IiNNRwAAAACgGqJgBQAAAAA+YrPZpKgo02EAAAAAgN9jSkAAAAAAAAAAAAAYRcEKAAAAAAAAAAAARlGwAgAAAAAAAAAAgFEUrAAAAAAAAAAAAGAUBSsAAAAAAAAAAAAYRcEKAAAAAAAAAAAARlGwAgAAAAAAAAAAgFEUrAAAAAAAAAAAAGAUBSsAAAAAAAAAAAAYRcEKAAAAAAAAAAAARlGwAgAAAAAAAAAAgFEUrAAAAAAAAAAAAGAUBSsAAAAAAAAAAAAYRcEKAAAAAAAAAAAARlGwAgAAAAAAAAAAgFEUrAAAAAAAAAAAAGAUBSsAAAAAAAAAAAAYRcEKAAAAAAAAAAAARlGwAgAAAAAAAAAAgFEUrAAAAAAAAAAAAGAUBSsAAAAAAAAAAAAYRcEKAAAAAAAAAAAARlGwAgAAAAAAAAAAgFEUrAAAAAAAAAAAAGAUBSsAAAAAAAAAAAAYRcEKAAAAAAAAAAAARlGwAgAAAAAAAAAAgFEUrAAAAAAAAAAAAGAUBSsAAAAAAAAAAAAYRcEKAAAAAAAAAAAARgVVwWrYsGGy2WyV/rN+/XrTYQIAAAAAAAAAAOAoYaYD8IWWLVuqfv365W6LiYmxOBoAAAAAAAAAAABUJigLVqNGjdKwYcNMhwEAAAAAAAAAAAAXBNWUgAAAAAAAAAAAAAg8FKwAAAAAAAAAAABgVFBOCfjtt9/qhx9+UE5OjhISEtS9e3fdcMMNqlevnunQAAAAAAAAAAAAcJygLFhNnTr1mP//zTff6Mknn9S4ceN0/fXXG4oKAAAAAAAAAAAA5QmqKQFTUlL02muvaeXKlcrOzlZ+fr5mz56t888/X/n5+brxxhtPKGYBAAAAAAAAAADALJvT6XSaDsLXnE6nLrvsMv3444869dRTtXHjRtlsNpePz8/PV1xcnCQpLy9PsbGxvgoVAAAAAAAAAAAgYHirhhJUb1hVxGaz6cUXX5Qkbd68WatWrTIcEQAAAAAAAAAAAA4LyjWsytOqVSvVqVNHBw4c0KZNm9ShQwePPqdly5YKCakWdT4AAAAAAAAAAIBKORyOI/+7V69eWrFihUefU20KVpIUHh4uSSorK/P4M9LS0rwVDgAAAAAAAAAAQNDYu3evx8dWm4LVvn37lJGRIUlKTk5269iYmBjl5eWpV69eysjIcGv9KwAAAAAAAAAAgGDldDrldDolSUlJSR5/TrUpWL3yyityOp2qWbOmzjzzTLeOtdlsio2N9fg1NgAAAAAAAAAAAFQsaBZjmj59uh599FGlpqYe8/eCggI988wz+u9//ytJeuyxxxQREWEiRAAAAAAAAAAAAJTD5jz8nlaA++GHH3TZZZdJOvTKWaNGjeRwOLRu3ToVFhZKkm677TaNGzeOKf0AAAAAAAAAAAD8SNAUrHbu3Kl3331XCxYs0ObNm7Vv3z7Z7XYlJibqrLPO0ogRI3TeeeeZDhMAAAAAAAAAAADHCZqCFQAAAAAAAAAAAAJT0KxhBQAAAAAAAAAAgMBEwQoAAAAAAAAAAABGUbACAAAAAAAAAACAURSsAAAAAAAAAAAAYBQFKwAAAAAAAAAAABhFwQoAAAAAAAAAAABGUbACAAAAAAAAAACAURSsAAAAAAAAAAAAYBQFKwAAAAAAAAAAABhFwQoAAAAAAAAAAABGUbACAAAAAAAAAACAURSsAAAAAAAAAAAAYBQFKwAAAAAAAAAAABhFwQoAAAAAAAAAAABGUbACAAAAAAAAAACAURSsAAAAAAAAAAAAYBQFKwAAAAAAAAAAABhFwQoAAAAAAAAAAABGUbACAAAAAAAAAACAURSsAAAAAAAAAAAAYBQFKwAAAAAAAAAAABhFwQoAAAAAAAAAAABGUbACAAAAAAAAAACAURSsAAAAAAAAAAAAYBQFKwAAAAAAAAAAABhFwQoAAAAAAAAAAABGUbACAAAAAAAAAACAURSsAAAAAAAAAAAAYBQFKwAAAAAAAAAAABhFwQoAAAAAAAAAAABGUbACAAAAAAAAAACAURSsAAAAAAAAAAAAYBQFKwAAAAAAAAAAABhFwQoAAAAAAAAAAABGUbACAAAAAAAAAACAURSsAAAAAAAAAAAAYBQFKwAAAAAAAAAAABhFwQoAAAAAAAAAAABGUbACAAAAAAAAAACAURSsAAAAAAAAAAAAYBQFKwAAAAAAAAAAABhFwQoAAAAAAAAAAABGUbACAAAAAAAAAACAURSsAAAAAAAAAAAAYBQFKwAAAAAAAAAAABhFwQoAAAAAAAAAAABGUbACAAAAAAAAAACAURSsAAAAAAAAAAAAYBQFKwAAAAAAAAAAABhFwQoAAAAAAAAAAABGUbACAAAAAAAAAACAURSsAAAAAAAAAAAAYBQFKwAAAAAAAAAAABhFwQoAAAAAAAAAAABGUbACAAAAAAAAAACAURSsAAAAAAAAAAAAYBQFKwAAAAAAAAAAABhFwQoAAAAAAAAAAABGUbACAAAAAAAAAACAURSsAAAAAAAAAAAAYBQFKwAAAAAAAAAAABhFwQoAAAAAAAAAAABGUbACAAAAAAAAAACAURSsAAAAAAAAAAAAYBQFKwAAAAAAAAAAABhFwQoAAAAAAAAAAABGUbACAAAAAAAAAACAURSsAAAAAAAAAAAAYBQFKwAAAAAAAAAAABhFwQoAAAAAAAAAAABGUbACAAAAAAAAAACAURSsAAAAAAAAAAAAYBQFKwAAAAAAAAAAABhFwQoAAAAAAAAAAABGUbACAAAAAAAAAACAURSsAAAAAAAAAAAAYBQFKwAAAAAAAAAAABhFwQoAAAAAAAAAAABGUbACAAAAAAAAAACAURSsAAAAAAAAAAAAYBQFKwAAAAAAAAAAABhFwQoAAAAAAAAAAABGUbACAAAAAAAAAACAURSsAAAAAAAAAAAAYBQFKwAAAAAAAAAAABhFwQoAAAAAAAAAAABGUbACAAAAAAAAAACAURSsAAAAAAAAAAAAYBQFKwAAAAAAAAAAABhFwQoAAAAAAAAAAABGUbACAAAAAAAAAACAURSsAAAAAAAAAAAAYBQFKwAAAAAAAAAAABhFwQoAAAAAAAAAAABGUbACAAAAAAAAAACAURSsAAAAAAAAAAAAYBQFKwAAAAAAAAAAABhFwQoAAAAAAAAAAABGUbACAAAAAAAAAACAUWGmA0BwczqdKissNh2GW8KiI2Wz2UyHERQCsf8PIw+8IxBzgL73LnKgegnE/nYVeQFPBPJ3gpz3nkDMA/rfuwItB+h/AABgCgUr+FRZYbE+b3G96TDccl3qZwqPiTIdRlAIxP4/jDzwjkDMAfreu8iB6iUQ+9tV5AU8EcjfCXLeewIxD+h/7wq0HKD/AQCAKUwJCAAAAAAAAAAAAKMoWAEAAAAAAAAAAMAoClYAAAAAAAAAAAAwioIVAAAAAAAAAAAAjAozHQBck5NXouXr9mv5ukylZxaqpNShyIgQNawXo85tE9SxdV3FxYSbDhM+lLavQMvWZmrlhv3KzimR3eFUVGSoTj2lhjq3TdBpLWorPJwadLByOJxK3ZmjZWsztSY1W/mFpbLZbIqNDlO7U2urc9sENU+Ol81mMx0qfKSk1K41m7O0bO1+pe7KUVGxXWGhIaoVH6FObeqqc9sEJdaNNh0mfCivoFQr1u3XsrWZSsssUHGJQxHhIUqqF6PObeqqU5u6io+NMB0mfGjv/sJDY4H1+5WVU6Iyu0OREaFqkRyvzm0T1K5lbUWEh5oO02eKisv098YsLVubqe1peSoqtis8LEQJtSN1RpsEdW6boDo1I02HCR/KzinW8v8/D+7LKjrym+iUBnHq3LauTk+pq5hofuIGK6fTqT0ZBVq6NlN/bTignLxDv4miI8OU0rSGOrdJUJvmtRQWxm+iYOVwOLVx+0EtW5updVuyVVBUJpvNprjocLVveeg3UdNGcfwmAgAggDGa92OFRWWa+NtWjZ24TotW7at035AQm3p1StRdV7XRZec1CeqbFdXJvgOFmvD9Rr03aYO27MqtdN+oyFBdek5j3X1VW/U6I5FBepBYvzVbY79ep8+mpurAweJK961bK1I3Xnyq7hjSRilNa1oUIXzJ6XTqzyVpGvP1Ok2ZtVPFJfZK92/ZpIZGXN5Kwy9LUd1aURZFCV8qLrFr0vRtGjtxneat3Cuns+J9bTbprNPr666r2ujK/s0UGcFYIBjszy7SRz9u0rvfbtDG7Qcr3TciPEQX922su65qo3O6JgXFWMBud+jXebs05ut1mrZgt8rKKvkSSGrfsrbuGNJa1w86VTXiKOAGg/yCUn35yxaNnbhOy9ftr3Tf0FCbzjkzSXdd1UYX921M4SJIpO0r0HuTNmjC9xu0Iy2/0n1josJ0Rb+muuuqNurWoV5QnAchrdp4QGO+XqcvfklVTl5ppfsm1o3WTZcc+k3ULDneoggBAIC32JzOym59wAS73aE3v1ir595dedIb1OVpkBCtZ+/urFsuTzE+QC8tKNLnLa53+7gGZ52mgd89fexn5RcqZ0uaUr+drXUTfpbT7vBWmMe4LvUzhceYvdGbk1eiR19fognfb1RJqfv/nh1S6ujtx85S784NfBCd6wKx/w8znQepO3P0jxcW6Nd5uzw6/qI+p+jtx85S00Zmf6QFYg6Y7vvDfl+0R/eMXqC1qdluHxsZEarbrmylF+7tYvztW3LAMw6HU+O/Wa+nxizXvqwit4+vVztKT93ZSXcObaOQEOvGAp72d3n84VpwNKvzIr+gVI+/vUzjvlmvouLKi9XladO8lt58tLv6dW/kg+is8f3MbXrw5cXaurvyh3bKExcTrvtvOE3/GtHRaPG2Kt8J098B0+fCsjKHXvpolV788G8dzC1x+/jkxFiNvq+Lrr2wBb+JPGC6/yXpwMFiPfTKIn360+aTFqvL0+W0BL0zqoe6tq/ng+jc40kOVPf+l6R1W7J11/Pz9eeSNLePtdmky89rqjcf7a6G9WN9EB0AAPAF3rDyMxu3HdTwp+Zo3oq9Hn9GemahRjw9V99M36r3nuqlxklxXozQWlu+m6Ndvy+XbDZF16ulU4f0Vdenh6lmy0Za8PB40+H5xLT5u3Trv+dqZ3rlTw9W5u+NB9R3+FTdc01bvXBvF8UG6HSR1bH/HQ6n3vlqrR59fakKiso8/pyps3dq1tJ0vfTAmbp9SGvjN2o8VR1zIK+gVCNfXayxE9d7/BnFJXa99cVa/TRrpz54prfOPjPJixFaqzrmwNZdubrlqTn6w4ObM4ftyyrSP15YoG+nb9OEp3upeXINL0ZoreqYA7OWpmn4k3NO+nZ1ZdZtyVb/237V7UNa66UHzgyo6SIzs4p0z38W6Ktft3j8GXkFpXp2/Ep9P3O7Pnqujzq3TfBihNaqjt+B1ZsOaNgTc7RsbabHn7Frb76uf2yWvpm2VeOe6KkGCTFejNBa1TEHJv+xXbc/O0/pmYUef8bSNZk664YpGnlzez11RydFRQbm7Y/q2P9lZQ698skqPTVmxUlnGKiI0ylNmrFNMxft0esju+vGS04N2N9EAABUJ8yR4Ed+X7RHna/+sUrFqqNNm79bnYb+oCWrK59O0J/tX7VVWybN0ZZvZ2vN2MmaetEo5e/OVMq15ymybuDefKvIyx+t0oA7fqtSseowp1N684u16jXsJ2Xs9/yHnknVrf9LSu26euQfunf0wioVqw7LKyjVnc/N1w2jZqnUgzf1/EF1y4E9Gfnqft3kKhWrjrZ1d67OueVnvf3lWq98ngnVLQfmr9yrTlf9UKVi1dH+XJKmTkN/0Jxl6V75PBOqWw6M/Xqdzrnl5yoVq442/pv16nbdFO3eW/WxhRU2bT+ozlf/UKVi1dFWb85S9+sn62svfZ4J1e078NOsHTrz2slVKlYd7cc/dqjT0B+0auMBr3yeCdUpB5xOp/49Zrku/eeMKhWrDnM4nBo94W+de+svyspxf/YSf1Cd+l86tDTC4Ptm6NHXl3pcrDpadm6Jhj0xW3c+N192C9/MBgAAnqFg5Sd+X7RHF949TXkFlc/H7K4DB4t13ohftHRN4BatjlZWWKx9yzfJFhKiGk0STYfjVS9+8JcefnWx1z935foDOufWn5XpwZRS/iaY+7+01KGhD/2ub6Zt9fpnfz41VdeP+jMofqAFcw6kZxbo7Ft+1hoPpgA8mXv+s0BvfLba659rQjDnwPyVe9X/tl89mvqqMjl5pRpw568BXbQ6WjDnwNtfrtVdz8+vdK0yT6zbkq2+w6cqbV+Bdz/YyzbvyFGfm6eedI0ad5WVOXXNI3/oy59Tvfq5pgTzd2DKnzt02f0zPJoGszLpmYU6+5aftXpT4BatjhbMOfDE28v09LgVXv/cBX9lqN+IX7x+jTUhmPu/uMSuS+6drqmzd3r9s8d/s14jnp4rh4NVMQAA8GdBWbCaNm2aBg4cqLp16yomJkbt27fXf/7zH5WU+OfgdOO2g7r0nzO88vRQeXLzSzXwzt+0JyMwnqw9mfimhwblxdl5hiPxnq9/3aJHX1/qs89fm5qtS/85PSgKFsHY/5L0wMuL9OMfO3z2+RN/2+rTHLNSMOZAaalDF98zXZu25/isjfv+u0g//rHdZ59vpWDMge17cnXR3dO88nZleQqL7Bp0zzRt9dJbO6YFYw78NGuH7vnPAp99furOQzlWUuqb8WZV5eaXaMAdv3rljYryOJ3SjY/P0vyV3pnJwLRg/A78tWG/hjz0u0drFbniwMFiDbjzN+3PDvyHuKTgzIEJ323Q8+/95bPPX75uv4Y8NDMoChbB2P+SdPsz8zRj4R6fff6HP2zSc++u9NnnAwCAqgu6gtUrr7yiAQMG6LffflN8fLxatWql9evXa9SoUTrnnHNUWOhfU6PZ7Q7d/ORst96sWvLlJdo5/Wot+fISl4/Zn12s25+ZJ6e3H9n1sbDoCEXWiVdk3Rqq1bqxur1wq+q2b659yzcpZ4t3pksyLT2zQHc9P9+tYzzJgfkrM/TKx4H1hkV16H9Jmrlwj9tTtnmSA698ssprU45apbrkwH8m/KWla9yb+siTHLjt6bkBd6OuOuSA0+nUrf+eq2w3n/p2Nwdy8kp1y1NzAu5GXXXIgQMHizXi6bluHePJOWDF+v16/l3f3QyuipGvLnF7GkR3/xuUlTk17InZKvRRYdhXqsN3oLTUoZsen+3WA3yefAf2ZBTo3tELPQnRqOqQA9v35Oq+/y5y6xhPcmD6gj1691vvTL1slerQ/5L04x/b9fHkTW4d40kOPPvuCq1Y550pRwEAgPcF5qqjFVi8eLEefvhh2Ww2ffjhh7rpppskSampqRo4cKDmz5+vxx57TK+//rrZQI/yxudrNH9lhlvHNEiIUXJirNtt/TR7pz6dslk3XtLS7WNN6TTyanUaefUxf9s2daEWPfa+oYi8787n5uvAQffmU/c0B54cs1wXn91YbZrXcvtYE6pD/+cVlOqWf89x+zhPcsDplG5+crZWTrxMMdGBcfqvDjnw14b9evZd96e+8SQHMg4U6Z7/LNAXL57jdnumVIcceG/SBo+eJvYkB/5Ykqbx36zXnVe1cbs9U6pDDtw7eoHbbxZ5OhZ4YcJKDT63sTq1SXD7WF+ZuXCPxn3j/g1kT/4bbNqeo8ffXqZXHurmdnumVIfvwAvvr9RfG9ybrs/T78AXP6dqyPlNNfjcpm4fa0qw58DhBzfcnR7f0xx46JXFGtgzWU0bxbt9rAnB3v/SoQc3bn9mntvHeZIDhx5emKMlX16iiPBQt9sEAAC+FVRvWD377LNyOp26+eabjxSrJKlFixaaMGGCJGns2LHKyHCvQOQrhUVllr+O/uSY5QE1LdyGT6fpt6FPa/p1z2vps5+q6ECuYpPqyl78v6fQ+469X33HP3DMcRG14jR05Xtqfnlvq0N2y9I1+/TD79ZN0VVcYg+oKRCCvf8l6f1JG7R9j3VTeWzanqNPf9psWXtVVR1y4JlxK302/VF5vvxli9ZszrKsvaoK9hwoLXXo32O9v1ZHZZ4et8Jvp4UrT7DnwLot2fp8qnVrK5WVOX2yPkxVPPHOMkvbe+uLtUrP9O/1vI4W7N+Bg7kl+u+Hqyxt8/G3lgXUzBPBngOzlqb7dBq44+UXlunFD/62rL2qCvb+lw6t4bh3v3Wz4fy98YC+nbbNsvYAAIDrgqZglZubq2nTpkmSRowYccL2Pn36KCUlRSUlJZo8ebLV4ZXr69+2KCvH2nW1tu/J0y9zd1naZlXkbElX2pxV2v37Cq0e86Nm3jRaCR1b6KwXbz+yz4LH3lP9M1up2eCeR/7W/YVblbF4vbZ85/6bK1YaO9H66Si+mbZVGRb+GKiKYO9/h8OpMRPXWd7umK/XBcxNmmDPgV3p+frxT+vXlRprIO88Few58OMf25W2z9ob53v3F+r7mYGznlmw54CJ7+OUWTu1I80/1j1ZsS5TC/6y9mGy0jKHJny30dI2qyLYvwOfTNnks/X7KrImNVtzlqVb2mZVBHsOjPna+vPgpz9tVk6ef65xfbxg7/+yMoeRaRpN/A4DAAAnFzQFqxUrVqikpESRkZHq0qVLufv06tVLkrRwoX/MWz7OQLFCCqwblcfbt3SDUr+drWaDe6pel1aSpJLsPM1/cKy6PX+rohNrq8lF3dWgx2la8Mh4w9FWLjunWF/8bN0T1YeVljn0wQ+Bc5PmaMHU/5L0x+I0bdqeY3m7f2884PZUpP4i2HLg/e82yG63vnj4yZTNbk+74y+CLQdMXZNN3Bz0lmDKgYLCMrfX6/AGh8PpN2u4eDIVoDeM/3Z9QM06cLRg+g44nU4jD3BJgX2zOphyID2zQN//vs3ydvMLywJq1oGjBVP/S9JPs3dod4b1b73OW7FXf290bypSAADge0FTsNq48dAN+CZNmigsrPy1WVq0aHHMviYdzC3RolX7jLT9x5I0lZUF5g90SfrrtW/lKLOr08NXHfnb7j9WatuU+erz9r3qPnqE5j84VsVZ/vHkcEXmrdyromIzUzJZOeWGtwVL/0vS9IW7jbU9w2DbVUUOVF1ufqkWG7oGeUOw5EBRcZlmLzfzhP+8lXtVaPEbDd4ULDmwZM0+5eSZKR77y1hg+gIzcexMz9dGAw+NeEuwfAf2ZBRo3ZZsI23PWLgnYN44L0+w5MCfS9IsnRr5aP5yHvREsPS/ZO46IAX2byIAAIJV0BSssrIOrcdRu3btCvc5vO3wviatWL/fWNuFRXat35ptrP2qyt2Wrq0/zlPDPh1Uv9v/Fo1f+vQnim/WQLt/X6FdM5cbjNA1y9aay4FlazMD9gd6sPS/dKgfzLVtLv+qKlhyoKzMoZXrzT3VaTL/qipYcmDVpixjN+nsdqf+2hC4TxUHSw6Y/B7+tfGA8QeYDhws1tbducba5zxonsk+2J9d7DdTY3oieHLA7G+iQBUs/S/xmwgAABwraApWRUVFkqSIiIgK94mMjJQkFRa6t36P0+lUfn6+8vPzvXaT3/TgeGkAD84l6e83JslhP/aJsrLCYuVtz1DWuh0GI3Pd8nXm+iA7t0Rbdpm7QVRVwdD/TqdTy9eZ+4HEOcC8DdsOWr5mx9HIAfNMjwWWGbwOeUNw5IC560BRsV1rDb3ZctgKg9dBSVq6hu+AaaZvFpMD5pm8Fu5Mz9e+A4Gxtm95gqH/y8ocWmnwARrTYzEAAHAimzNQX7M4zksvvaSRI0eqW7duFa5RNXbsWN11111q166dVq1a5fJn5+fnKy4uTpKUlJSkkJCq1/kORp+vvOie5W5b8uUlapAQU+GxDRKiFRYaojK7Q+mZlQ+w0zMLdOY1k0/4e42C6Yovmute0B4Id4boKUdXn7dz2MBJT2vn9GVaM+7Ef2dXPR2yWKU23z9xnFHjVpWGnVLuNityICHnfUWW7XQvaDcFYv8f5us8cCpEe+o8VeF2b+VARf0vp0MNs56Wza2o3ReIOWDVOaAorJn21xhW7raT9b9U9RyIKN2qerkfuROyR8iBiuVEn63c6HPK3WZFDsQX/qkahX+4F/RJWN3f5fHmteBovsiLzPibVBzevNxtVowF6uZ8rKiyLe4F7UUFEe2VFXdludus+A5EF69Snfxv3QvaTSa+E976DlhxLsyKuVgFUeWvP2zFd6Bm/k+KK17iXtAe4FpYsb0171ZZaP1yt1mRA/UPvqNwu+/XdrUyBwKp/+22aKXXfrTC7b7+TWRzFKph9mj3ggYAACfVoEEDLV261KNjy1/sKQC5Mt2fK9MGnkxaWprHxx4jqVCKLn9Tg4QYJSfGnvQjwkJDXNqvPDm5+crJ8P18zRG2UCnR58141Z60PSpxWrC2VLSjwm+gFTmQmZkl5fs2BwKx/w/zeR7YIqQ6FW/2eQ7YQrRn9x5Jvn1mIRBzwLJzQFxtqUb5m1ztf8nzHCgpsWv3bq4D5bEsBxILqjwWkDzPgdy8QuWmezcHArG/XeWTvGheJoWXv8mKscD+AwelXIPrd9RuKsWVv8mK70BhUYnPz4OB/J2w5FzYqFiKKn+TFd+BgwfzdHA/18LyWHYtjJUUWv4mK3IgI+OAVEQOHM+y/g+rKVVye8bXOeBUiCXjYQAA4LqgKVilpKRIkrZv366ysjKFhZ34r5aamnrMvp7w3htW0apoxvT0zIJKj3X3SbLy1IiPVXx4I1dCrZJwZ4hkdnkEtzVMamjNG1bhIapomXUrciAhobYia/k2BwKx/w/zdR44FaLKlhf2Vg5U+DlOuxo1auhCpFUTiDlg1TmgOKyWKpqE5GT9L1U9ByIiQlWvEdeB8liVAzlRMapoclYrciA+Llo1vJwDgdjfrvJFXmRGhKm4gm1WjAXq1qmpqBq+Pw9UpCAiXhU9ambFdyA6Klx1fHweDOTvhBXnwqyYCFXU01Z8B2rWjFNcFNfC8lh1LdwbKlU0QbIVOVC/fh2F230/RXOg5YBV/W+3RSu9ku2+/k1kk0MNLRgPAwBQ3TRo0MDjY4NmSsDc3FwlJCSopKRECxYsUPfu3U/Yp1WrVtq4caPeffddjRgxwuXPPnpKwLy8PMXGevb01tFe/3S17n9pkUfH7px+tZITY7Vrb75O6f+VR5/x6Qt9df2gUz061h2lBUX6vMX1Pm/Hm65L/UzhMRU86ulFV9w/U9/N3ObRsd7IgW2/DlWThvEeHeuqQOz/w6zIg/p9P9e+rCKPjq1qDpzSIFY7pl3tUdvuCMQcsOocsH5rttpcOsnj46uaA9de2EKfjz7b4/ZdRQ5U7L1v1+u2Z+Z5fHxVc2Ds4z10x9A2J9/RDYHY367yRV7cOGqWPv1ps0fHemMssPq7y3XaqZ7PPFBVfy5J0zm3/Ozx8VX9b/Dgje308kPdPG7fFYH8nbDiXPjMuBV6asxyj471xnfghzf66dJzmnh0rDsCMQ+suhb2v+0XzVhY2WNcFfNGDmTOvk51a/n+3zPQcsCq/rfbHapx1qcer+ta1Rxo26KW1nx/hUdtAwAA36j6q0J+Ij4+Xv3795ckvffeeydsnz17tjZu3KiIiAhdeumlVod3gs5tE6p1+5DOaFPXWNt1a0WqcVIFc/DAMiZzgHOAeSlNaioupoK5wCzQua25/MMhpr+HptuH2e9hTFSYWjeraax9SerU2ux5iO+AeaavRZ3bkAOmmfweNm0YZ0mxChULDQ1Rx9aVzJPuY5wDAADwP0FTsJKkxx9/XDabTR9++KE+/vjjI39PTU3VLbfcIkm6/fbbVb9++Yu6WqlTm7qy2cy0HRsdppQmFSycAsuY/HHWuW2CbKYSEEeYzQGKFaaFhNjUyeQPdG7UGteuZW1FhJsZioWF2dS+pbk3a3CIye9hx9Z1FBpq9qdAzfgIndrY3JiU86B5Jvugfp0oNUqMMdY+DjH9mwjm8ZsIAAAcLagKVt27d9fo0aPldDo1bNgwNW3aVJ06dVLr1q21efNmdevWTaNHjzYdpiQpLiZcvTqZWXW1/1mNjN+ggNSzU31jb1cM6ME83f5gYM/katk2/sdUP9SuEaGu7eoZaRv/ExEeqnO7+n4tufKcc2aSoiKDZinTgNXltATVqRlppG1/uQ6YiqN5crzRYhkOaZAQo9NbmXl4Y2DPZB7g8gPnnJlk7OENfzkPVncm+2EAOQAAgN8JuqrFyJEj9euvv6p///46ePCg1q9fr5SUFD3//POaNWuWYmL85ym6O728boSr7rrKTLs4VnxshG4Y1MLydqMiQzXs0hTL28WJep2RqHYG1g45s12CupxGscIf3HJ5K4WHWX8pvnlwiqKjKFb4A1PXZMYC/iEqMkzDB1t/TQ4Ls+nWy1tZ3m557hza2lC7bRQSQrHCH3AerN4Sakdp6IBmlrdbMz5C11zQ3PJ2caIBPRqpaUPrp6s/t2uSWjerZXm7AACgckFXsJKkAQMGaNq0acrKylJhYaHWrFmjUaNGKTLSzBOsFbm8X1PVr2PtnNktm9TQed3MPM2NE5koWl5zQXNjT3PjWDabzcjNEm7Q+I/EutG6sn9Ty9u9Y4iZG8Q40YW9k9U4KdbSNpMTYzWoT2NL20TF7jBQsLn8vKZKqucfD3G1bVFbZ5+ZZGmbkRGhunlwS0vbRMWuvbCFasRZO+vAGW3qqmt7Ht7xFybGpsMuaalYg2uJ4n9CQ0OMXAv5TQQAgH/i8WqDIiNC9czdnXXHs/Msa/M/93Yx/jRpfLMG6v3GPYqsE6/S3ALN/efbyt6464T9Wl5zrtr/4zIpxKb0ef/X3n2H2VHWbQB+zu6mbnpCOi0hQOgQegtC6E1QwAIYEZGiqJ+AoGABUT6UJgoBsRe6QADpVZoSjKEYIKETEtIgve7u90c+Ii3J7mZ3Z7O57+vKdcGZec/8zk4575xn5p1n8/jpv0rN4qr03mHjDPvzdzLzpbeWznv7gd9N1fyFy2+30yYZ8t3Pp1Vl29TUJG/e+1SeOvfPSU1Nk332D9t0/W75/P4D8+fbX2qS5VW2q8iZx23RJMuidoYfPCgX/+m5vPjajCZZ3ibrdc1n9236O/s+bGWPAymVss33j06/T2yR6sXVWfDOrDx2yojMenVSumy4Vrb/ybFp16NzqhdXZero8XniO1elav7CtOvVNTtffFI69F8jVQsXZ+YrE/P4t6/MgmkzC/grLPH947fMX+97LQsWVjXJ8r50yPoZtHbnJlnWslj//1VeXpYfn7x1jjzjoSZb5o++OiQVBdzZx8cbuGanHPfpDXLlDS80yfJatyrL94/fskmWVVvnfm1Idv7CbU3WJTt1+Kbp3qVpLxpj2Tq0b5Wzjtsyp174zyZb5o9P3tpwgM3I9pv1zEG7rZWRD77eJMvr0rF1Tvvipk2yrOVZ6f7Q++x9/ffTfdMB+cuGX0iSVLRvm0/8+pR032xAysrLl76+omlFOeHwwbns2rF5feKcJlnetpuskYM/sXaTLAsAqBu/VhTsuE9vkGHbN80dT0fss24+tWfTD7fwYTue/5W8+Kd7ctPOJ+eZX9ycnS/56kfm6bBmz2x52mdyxyfPyl93+Gra9uicDY7cc+n0mS+9lZF7nrr033th1fLaLZwxJw8df1FuHvrN3Lb3aem5zQZZ77ChTfOhl+OSb2+fXt3bNcmy/veb22RA/+b9vIaO6/bOfiPPzSGP/DwH3HFeuqz/8eOKb3vOMfn0Py/L8Ik3pNvG63xker/dt8yBd5+fg+75aQ5+4MIMfN+63vOas3LQfRfkoHt+mn1vPifdNiluv2jXtiK/PWeXNMVvJuXlpfzuR7umTevyxl/YCqzscWCtvbdOz202zC17nJKRe3wrEx95Jlud8bkkSdWChfnHd36dm3b5ekbucUoq2rfJpid9MklSU1WdMRfd8P/TvpXZr72dbc46qsk+98fZYN0u+dFXhzTJsvr3qswFp2zXJMtaHuv/gz6338ActFvT3PG0/65r5uiD1muSZdVFbY/9y5uvvE2r7P7b03LIIz/PQff+LHtdc1Y6rtM7SdKma4ccdM9Pl/475JGf5+g3rk3rLh8cgmi9Iz6R4RNvyFr7bNN4H/Zj/PR/tm2yO+3OPmmrbDSw6YejXZ4dt+iVbx61SZMsa9NBXXPWV7ZokmWtjIbYJ5Jl93mWt78U4ZtHbZztN2uaO56OPXT9Veq5NWvvv322P+/LSZKy1hXZ7twv5dBHL83B91+QXX5x8tL5ltf3Xd605qBUKmXEWTula6fWTbK8S769ffr2bNq7mz9OQ5wXJ8lGXzkgs157+wOvVS9enGd+cXPuPvzsj7zn8qYVpVOH1rnqB7s0ybLatC7P7360q4t3AKCZ8g1dsFKplKt+sHOdOueTps7Nm2/PyaSpc2vdpm/P9vnFGTvWp8QG1bZ7p3TffGBeuvHhJMlrtz+Ryr7dP3KCvPYB2+eNu0dl3pR3kyQv/OHurHvITit8/+W1m/7sK5n9+uQkSdWCRZn+7KvpsGbPBvpk9de9S9tc9YOd6xRY1Gcb2HOHvoU9N60uanPiliSv3f54/nbwmZn9xuSPnb7rL07OI1//ZUbueWruO+on2fH8r6SicsnV1A8dd0FG7vGtjNzz1Dx3xa3Z+eKTGu3z1MaOW/TKt4/ZrE5t6rMNnHXcFhmyUY+6ltfgGuI4UFOTlLeuSHmbJUO5tOrQLnMnTkuSzHplUt4Z+9qS+aqrM/XfL6XDmkt+BJs/dUYm//P5pcuY8q9xzeI48M2jNs6uQ+r2Q2Fdt4GyslJ+c/Yu6dyxaX4MWhbr/6NKpVKu+N5OdR4muK7bQI+ubXPl93ZqlncV1PbYv6L5Xvjjkmkjh52S1+96MjtdcEKSZME7sz9wocuLf7o3E+4fnYXvzl7atkP/NbL+54dl8qimudPp/Tp1aJ3fnr1rystrv27q8z2w05a98q2ji7+r4OP86KtDsvHALnVqU9e/Qds25fndObumdaviL9xYkYbaJ5bX51nW/lKE8vKy/PacXdOhDkO01WcfWLdfx2Zx4UZdrLXfdnn9ziV3nw357pFJTU3+utPXcsvu38qoH/5h6XzL6/sub1pz0WeN9rnsu3U7X63PNnDIHmvnqAOLv3Cjoc6Lu6zfP2vts22eufSmD7SrXrg4kx59NgtnfPSOpeVNK9KeO/TLSZ+p2/lqfbaBH588JIMHdKljdQBAUxFYNQNr9+2YOy7bu9YnaNt8dmTW3POabPPZkbWav3uXNrl7xD7p0bX4k5LKfj0y7+13UlNVvfS12ROmprLfB39E79CvR2a/OeW/87w55QPzdFyndw68+/wccMd52eALe9e63XvardEl6xywfd6496kG+Vwr64Cha+WX36n9CVpdt4EhG/XIDRfsUfhwkCtS2xO3JHn7ibGZO3H6Mt+rpiZp3XnJ8zladWyf+e/MSvXCxUmShTP/e0LTumP7QoeFfM+5X9s6Rx5Q+6H66roNHHvo+vleMxkCqiGOA2/cPSqTHn8uRzx9VY4Y86v02WXTjD7/2o8sq6Jdm6z/+T3y+l1PfmRaqawsg4/Z92OnNbXy8rLcfMmwbLZ+t1q3qes2cNUPds6eO/Srb4kNxvr/eL17tM9dI/ZJlzoEinXZBjp1aJW7Lt+7WVxR/mG1PfavaL6qBYsy4f7RS+dfEkh+/B0bgz63e8Zdfd9/XyiVsuMFJ+QfZ/566XdFU9t9u775zQ9rf8dtXY8Bm6zXNSN/vmezvaK8XduK3Hn5Plmnb4cVz/z/6vI3qKgo5fqf7Z6tmsGFGyvSUPtEsuw+T132l6ay4bpdMvLnw9K2Te0CxbruA717tMs9V+6TTh2KvXDjw1p3ap/Dnroin3nutznonp/mkw9fnKNevTo7/uz4lCrK02ubDTLxkWdT0a5NBn129/zrvKuXtn0vxEiW3/dd3rTm5DP7Dsz536z9Ha513QZ23rJX/vTj3ZrFhRsN0R8qVZRnx5+dkMdPu+ID77Mqu/i07XPIHrUfqq+u28A3jty4ye7oBQDqxzOsmontNuuZ+361b/Y98a5Mn7Ggwd63b8/2uXvEPtl4veY19MvKmPbMy7luq69k0ay5ad+nW4b96btZMH1mXr318Vq1b9WhXfb4w+l55rJbMm1M0zw7qjZOOGJwWlWU5SvnPJrq6oYLUHbeslduvXTPZndy/nGWd+I269VJdXqvh46/MJ/49alZPHdBWneuzANf+mmqF/33xHznn38tfXbcOElyz5E/bpgPsBLKykr53Tm7pm3r8lz11xcb9L1P+szg/Pz0HZrFyXlD6bH5wHTZYK1cv+VxWThrXoZ89/PZ4fzj8vev/nzpPGWtKjL0iv/JhAfH5PU7PvpcjO3POzYLZszOf351e1OWvkxdO7XJ/Vftm/1Pujv/eGbKihvUUnl5Kb89e5ccdeCgBnvPorXE9Z8kW2zYPQ/8er/sffydmTx9foO97xpd2+bOy/dutj/U1/bYX9fviI2O3e9jA8k1tt4gbTpX5o17/nvRysZfOTCTn3w+055+uaE+Vr0cfdCgVJSX5QtnPZTFixuuL7D1xj1yx2V7p1vnNg32no2hf+/KPPy7/bPXV+7M86803LMd27Utzw0X7JH9dlmzwd6zMTX0PlGbPs+y9pem9olt++bOy/fOgV+7J7PmLGqw912nb4fcc+W+Gbhm8xsae+HMuXn5pr9n0Zz5efqiG9J3t82z2cmH5rFTRqTv0M0z+ckXUrO4Kh0H9c/Cd2dns5MPTZ9dN0vV/IX598+uy8RHnkmy/L7vivrFzcmpX9wsrSrK8s2f/qNB33fPHfrmpouGpX27lvMTyBbfOiyv/e0fmTFuQjr0LzZwbigVFWW59vzd84UzH8rVdzTsd/LpX9rM8+sAYBXQcnprLcC2m66RMdcfkuPOfiR3PPLRh63W1eF7r5tfnLFD1ujWNM9Hqo05E6amXa+uKZWXLT257tCvR+ZMmPqB+WZPmJpO77s6tEP/NZbOs2j2vKWvz504Pa/c/Eh6bTc4r976+HLbJUlFZdvs+Zcz8/pdT+Y/V9zWKJ9xZRz7qQ2yyXpd88XvPbzSP9RUVJTy3WO3yHe+vHmzGfpmv1vPTacBfT522sg9T22w5ZTKy7L5Nz6dB77007z9xNh033xg9vj96bll9//JgumzkiSPnHxpkmTgYUOz9ZlH5t5mEFqVl5flyu/vnF2H9M7J5z2Rd2ctXKn3696lTX75nR1z+N7rNqsTs4Y4Dgw8bGgmPvrs0ivHX7ruwex5zVlL5y1VlGfoFd/MvMnv5J9n/eYjNWz3o2NS2bdH7v/i+c3iDrv3dO/SNg/9dv+cPWJ0/ve3T6eqauVq22S9rvndj3ZtFkNBvsf6X74tNuyep288NCf86NHcdN9rK/1+B39irYw4a6f07tG+Aaqrn6Y69r/fpicfmo7r9M5jh//wI9MGfXb3jL/+oaXbX5cN1sza+2+XOw75XqPUUlef239gNly3c4af9XCeGffOSr1XWVkpp31x03z/+C3Tts2q0e1fs3eH/PMvB+XbFz2Zy697fsUNVmCHzXvmt2fvkg3W7bLyxTWQpt4nVtTnWd7+UoShW/fJmOsPyZe+//c88OTElX6/4QcPyoWnbpeunZpvYNttk3Uz9qq/JUm6bzYw0599JUmy1j7b5LX/v+iiVFGWDmv2zLvj3sxTP/5zum2ybva69qzcPPSbWfDOrGX2fRfOmLPCfnFz842jNsmWg7vnmO/9PS+/uXI1tm5VlrNP2irfOnrTZnWHaUP0h3rvsHEq+/XI4GP2Sam8PK06tsun/3lZbt339CyYNrPpPkwDa9WqLH8+b7fstk2ffOtn/8zsuSsXXvfu0S5XnLVTDvpE7e/cAgCK03x6bCRZcmXp7b/cK789Z5d6P3x7vbU65fqf7Z5rf7p7swqrkmT+tJmZ/swrGfipXZMseYjwnInTP3Jl9Gu3P5E199o67dbokiTZ4Oi98srNjyZJ2vXskvfGy6mobJv+w4Zk2rOvrrBdRfslYdWEB0bn6YtvbNwPuhK237xnRl/3yXzn2M3TsbL24/i/365DeufJvxycH5y4VbMJq5Lkbwd+N9dsfMzH/pv71rQPnLi95+NO3Fak2ybrpl2vrnn7ibFJkmljXsrcidOWPmj8/V66/qH03nHjtOla+yGIGlOpVMpRBw7Kf27+VD6zz4A6Pc/kPRUVpRx5wMA8d9OncsQ+A5pVWJU0zHFg1utvp89Om6Ss1ZIfYPvvuXXefeGNJEsCy6EjvpkF78zOY6eM+Mjytz3nmHRct0/uP+b8Znl1cZvW5Tn35K3zxJ8OzI5b1O/5Sp07ts73vrJlRl1zcLMKqxLrvzZ6dW+XGy/cI385b7es269jvd5jnb4d8qefDM1NFw8rNKxKGu7YX9v5Nj7+oKy933a59/PnpmreB4P/ivZts+5BO2b8Nfcvfa3XdoPTYc2e+dRjl+bT/7wsa2w1KDv89PhscPReDflnqJOtNuqRUdccnB+csGWdhol8v+03WyOP//HA/OTr26wyYdV7Ola2zmVn7pT7frVvNt+g9kOlvt8aXdvmglO2zd9/t3+zCquSpt8n3vNxfZ7l7S9FWrd/x9z7q31z2Xd3TN+e9TuGDR7QJbf9Ys/89pxdm3VYlSTdNl5naUjVfbMBmfbMkv/uu9sWS4dunDNhaqqrqvLyjX9P8t/n83YdvNZy+7516Rc3J0O37pOnbzgk/3P0Jqms511Rw7bvm9HXfTLfPmbzZhVWJQ3TH7rjk2flhm1OyA3bnpg7Dj4zi2bNyw3bnrhKh1XvKZVKOe7TG+bZvx6SQ/ZYu07Pe35P61Zl+dIh6+e5mz4lrAKAVciqdfa6miiVShl+8Po56oD1cvvDb+Ty657Pg6MmZv6CqmW2ad+2Invu0DcnHjE4w7bv16yfVfTYaVdk54tPyqYnH5pFs+flkW/8Mkmy48+Ozxt3j8obd4/K7NcnZ/TPrsu+I3+UJJn02HN54Y/3JFnSmd/gC3unZnFVShXlee3Wx5f+8LS8dht9eb+sseV6adW+Tdbeb8nDll+97fE8fclfm/Tz10bbNhU59+Stc8axm+fPt7+UX934QkY/P225QwX26No2nx62Tk48YnA2rcNzcJqT95+4jb/uwWWeuK3InAlT075X13Qe1C8zxk1Ix3V6p+PavTLzpbfSulP7lLdrk3lvL7lqfa19tsmCd2ZnwTuzG+Mj1VufNdrn6vM/kZ+9vW1+deML+cOt4/PKhOVfYTpwzY75wkGDcuyhG6TPGsX+QL0iK3sceP63d6bLoP456L6fpXpRVeZNeTePn3ZFkmTdg3fKOvtvn+nPvZqD7vlpkuTtJ1/IP75zVXpus0E2Ona/vDvuzRxw+0+SJLPemJwHjvlpU/8JVmjrjdfIo384MKPHTs3l1z2fG+99dblDxpaVlTJko+457lMb5rP7DkhlHR5c39Ss/xUrlUr57H4Dc8Q+A3LXo2/msmvH5r5/vpV585fdF2jbpjx7bLekL7D3jv1SXt68fpxbltoe+2sz30ZfOSDrHrJT7j787A88u+c96x68Y6b/59XMGP/W0tde+MPdeeEPdy/9/31u/GH+86vb8vqdxQ6P1rpVeb5/wlY5dfhmuebOl3PlDc9n1H+mLvfOy26d2+TQPdbOCYcPbrZDQNbF7tst+bH58TGT88trxua2h1/PzNnLvtK+VUVZdti8Z44/bMMcOmydtGndfC7aqYuG2idW1OdZ0f5StLKyUk44YnCOPXSDjHzwtVx+3fP5+78mZeGiZT+rp0P7Vtlnp3456TMbZejWvZvdRTsfp33vbklNTeZOWvJs1m6D187Tl9yYHlsOyoxxE7J47pIhYhdMn5WJjzybvrttngn3j06HNXumw1o9M2PchFQvrlpm37dqwaJlTmvuKtu3ygWnbJfvfWXL/PG28bnqry/k6RenL/fm6F7d2+WIvdfNCUcMzobNLKz+sJXtD63IQfddkLbdO6VVx3Y57KkrMumxZ/P3r126wmnNydp9O+avFw3LqxNm5cobXsifbh+fNybNWW6b9dfunC9+clC+dMj6ze4CXgBgxUo1Nc1sLJxmaM6cOenQYcmViLNnz05lZdM/sHzRour85+V38tR/puWb5z+RmXMWpVNlq1x6xg4ZslGPbLhu52b5w9SiufPz54FHFl1GnXz+pT+lVfu2RZfxEXPmLsq/X5ief78wLd+5ZNTSbeC35+yaIRt1z1p9OjS7k/L6rP9OA/tm54tPSpuuHZeeuL37/OtJPnjytsP5x6X/HkPSrmeXLHhnVhbNnpe/7vi1pe+z7id3ymYnH5qa6pqUykp5+tKb8spNj6Syf4/sduW3UtG2dWqqazJ/2syMOvsPmf7cqx+oozluB1Omz8u/xk7Lcy+9kx9cPjqz5ixK5w6tcv0Fe2Srwd3TvUvzqjdxDGhINTU1ee2t2XnqP1Mz/o2ZOfdXY5ZuA3dcvnc2X797s3wug22g4SxeXJ3nX3k3o/4zNZOmzsuPr1qyDXTp2DoP/3b/DB7QpfAryOu7vmt77F/efO37dMvh/7oyM1+dlMX/P3xw1cLFuX3/M5YuZ7+R5+bFP9+b8dc+sMxalhVYNYftYu68xRnz4rSMHjstZ7yvL/DrH+6SIRv1yDr9ml9foCFVV9fkpTdm5qn/TM2rb81+3z7QKvdcuW82HdSt2YVURe4Ty+vz1GZ/aQ7b/IctXFSV58YvOSf61s/+sXQf+OV3d8zWG/fI+mt3bpYX7i1vO+g/bEgGH7NP7vncuUmSA+44L9OfezULps/KzFcnZdxf7ls6b4e1emanC09M224dU1NdkzEXXZ/Xbl/yrKdl9X1XNG1ZmuP6T5JZcxZm9NhpGfPi9Jx56VNLt4E//HhohgzukX692jfL4+Cq1h9qrus/Sd6eNi9P/Wdqxr78bn444r/nRDdeOCxbbdS92d9RCQAsn8CqFppDYPV+/YddnQmT56Zfz/Z5897PFlrLiqxqHfOkeXfO37OqbAOr4vp/T3PfDmwDjae5r/v32AYaj22g/lbF9V1bzW27aI7rv6mtCn+DVXmfaG7b/IetCuv/PfXZDg5+8KLc9anvZ35Bw7s19/WftPxtoEirwvpPVq1tAAConeZ3KTYAAACsxm7Z7ZtFlwAAAE2u+Y0hBwAAAAAAwGpFYAUAAAAAAEChBFYAAAAAAAAUyjOsaFQV7drk8y/9qegy6qSiXZuiS2gxVsX1/x7bQcNYFbcB675h2QZWL6vi+q4t2wX1sSrvE7b5hrMqbgfWf8Na1bYB6x8AKIrAikZVKpXSqn3bosugINY/tgFsA6sX6xs+yD5BYjvANgAAUFuGBAQAAAAAAKBQAisAAAAAAAAKJbACAAAAAACgUAIrAAAAAAAACiWwAgAAAAAAoFACKwAAAAAAAAolsAIAAAAAAKBQAisAAAAAAAAKJbACAAAAAACgUAIrAAAAAAAACiWwAgAAAAAAoFACKwAAAAAAAAolsAIAAAAAAKBQAisAAAAAAAAKJbACAAAAAACgUAIrAAAAAAAACiWwAgAAAAAAoFACKwAAAAAAAAolsAIAAAAAAKBQAisAAAAAAAAKJbACAAAAAACgUAIrAAAAAAAACiWwAgAAAAAAoFACKwAAAAAAAAolsAIAAAAAAKBQAisAAAAAAAAKJbACAAAAAACgUAIrAAAAAAAACiWwAgAAAAAAoFACKwAAAAAAAArV4gKrV199Nb/+9a9z/PHHZ8iQIWndunVKpVKGDx9edGkAAAAAAAB8jIqiC2hoF198cS655JKiywAAAAAAAKCWWlxg1aNHj+y3337ZZpttsvXWW+eOO+7IZZddVnRZAAAAAAAALEOLC6zOPPPMD/z/E088UVAljeOZF6dn9txFSZI58xblxVdnZP11OhdcFdBU5s1fnNsffmPpcWDe/MWZv2Bx2rZpcYdzYBnGvvxuHho1MbPmLDkOLFpcXXBF0LTemDQ7dz06Yek+sHBRVWpqalIqlQquDGgKVVXVuefxt5b2h+fOW5x3Zi5I105tCq4MAICV5RfOVcTN97+aC37/bB4Z/fbS196dtSgbHHRDhm3fN6cO3zR77di/wAqBxjT1nfn53988nd/c/GKmz1iw9PXpMxdmzb2uzZcOWT+nfXGzdOvsRB1aqr/9/Y387HfP5IEnJ37g9cnT5+cTX/pbTvnCJtl/17UKqg4a3z+enpzzfvN0Rj74eqqra5a+PuWdBdnqiJvz9c9vnC8cNEhwBS3UgoVVufhPz+by657Pa2/NXvr6O7MWpt+wq/O5fQfmjGM3z8A1OxVYJQAAK6Os6AJYvpqamnzvl0/lkG/c94Gw6v3ufeKt7H38Xbn4j882cXVAU3jlzVnZ4ahb87PfP/OBsOo974VZOx19a96YNPtj3gFY1f3vb8Zk/5Pu/khY9Z4Hn5yYA756T378q383bWHQRK6546XsMvz23Hz/ax8Iq97z7+en54tn/T1f/sEjHzsdWLXNmrMw+5xwV06/eNQHwqr3zJtflV/f9GK2/dzI/OPpyQVUCABAQxBYNXOX/uU/OeeKf9dq3m/+9B/5023jG7cgoEm9O3NB9jnhrox/feYK533+lRnZ94S7MmvOwiaoDGgqv/7rCzn94lG1mve7lz6VK294vpErgqZ17xMTcuR3HqrV8Je/vunFfPuiJ5ugKqCpVFfX5PBTHsiDy7ho4/2mz1iQ/U66u1Z9ZwAAmh+BVTM2e+6inPmLp+rU5tsXP5lFizzLAlqKK254Pi++NqPW8z/30rv5zU0vNmJFQFNasLAqp19Su7DqPWdcMirz5i9upIqgadXU1OS0C59MVVXt75q68I/PuuMYWpC7H5uQOx99s9bzT5+xID++6t+NVxAAAI1GYNWM/fn2l5Y+TLq23po8NyMffK2RKgKaUlVVdUZcV/c7JS679vnU1BgOCVqCG+55JVPfmV+nNtNnLMj1d7/SSBVB0/rnM1My+vlpdWpTXV2TK294oZEqApraZdeOrXObq+94+WOH0gYAoHkTWDVj19z5cr3aXX1H/doBzcs/npmSVz9mjP4VefG1GRk9tm4/7gHNU32/0/UFaCnqvw+81MCVAEWYNWdhbnv49Tq3m7+gKrc84EJOAIBVTUXRBaxqBg0alLKypsn53u58UlLes87tbr3jofS/7guNUBHNxcQu/5OUdc7ESRPTv3//osuhkcxrtWHS8bP1arvX/p9O20WeadeSOQ6sHiZ3+nJSUff1e99D/0z//l9qhIpoLlaXY8D0yk8lbTarc7uXX5/Sov8urD77wOpucVmX1HT5Zr3afuOU7+Wsrz7SwBXRnDgOAEDz1Lt374waVbfHG7xHYFVHEyeu+EGvDabdgqRd3ZstXDA3EyZMaPh6aD46ViVlSXVVlXXdknXsnnSsX9NpU95O5tg2WjTHgdVDm/n16q0tWjjfdtHSrS7HgP6zkzZ1b1ZTtbhl/11YffaB1V3F3KRL/ZrOnPFOZk61bbRojgMA0OIIrOqoT58+TXaH1bTymanbUyuWaF8xO1379Wvwemg+JpaXpzpJWXl5+ljXLdaismRyktTUJKVS7Rr9/7y9upWnoottoyVzHFg9TK+YnXn1aNeufFa62S5atNXlGDCzzfzMqke7VnknPVvw34XVZx9Y3dWkPBOr56emrG2d23brsDjt2tg2WjLHAQBonnr37l3vtgKrOho3blwqKyubZFl3Pfpm9jnhrjq3e/jmH2XIRiMaoSKai/7Drs6EyXPTp3efvPnsm0WXQyMa+sXb8/BTk2rfoFTKXjv2y10jnm28omgWHAdWD4+Ofjs7f+G2Ore7889nZNetf94IFdFcrC7HgDcnzck6+16bqqqaOrW7/EefzZcO/UGj1ETzsLrsAyQnn/d4Lv3Lf+rUpm/P9nntX/ekosJju1syxwEAaHn03pqxPXfol/XW6lSnNttuskaGbNSjkSoCmtqJRwxukjZA87TjFj2z2frd6tRm44FdssuQ+l/NBM1J/96VOXi3tevUpkvH1vnsvgMbqSKgqZ1weN37tl/59IbCKgCAVVCL68E9+uij6dGjx9J/F154YZLkmmuu+cDrjz76aMGVrlhZWSl/PHdo2rYpr9X8nTu0zm/O3qWRqwKa0mF7rZvP7DOg1vMPP3hQDtptrUasCGhKpVIpv//RrunQvnY3xVe2q8gffzw0pdoOIwqrgJ+fvn3696rdCAdlZaX84dyhad/OQBLQUgwe0CU/+frWtZ5/h8175tThmzZiRQAANJYWF1gtWrQo06ZNW/pv3rwlT35YsGDBB15ftGhRwZXWzvab98ydl++dLh1bL3e+3j3a5b6r9s3G63VtosqAplBWVsrvz901Rx+43grnPfbQ9XPl93b2QzW0MFts2D33XrlvenRd/vM7undpk3uu3CdbDnanNS1Lv16VefA3+2XQ2ssfeaBtm/Jc/7Pdc6ALN6DF+fYxm9UqtNptmz752y/3Sru2QmsAgFVRi+vF7bbbbqmpqdsY983d0K37ZNxth+W3N7+Yy697Pq9M+O+jpwcP6JITDt8wRx84KJ1XEGoBq6bWrcrzux/tmmMP3SCXXTs2N9z7ShYvrvn/aWU5bK91c+IRg7PD5j2FVdBCbbdZz7x466fz+1vG5bLrxmbcazOXTltvrU458YjB+cJBg9Ktc5sCq4TGM3DNTvn3dYfk2rtezi+vGZun/jN16bQ+a7TPlw/dIF/+1Abp37tpnjULNK1SqZTTv7R5Dhy6Vi6/bmz+cOv4zJrz34tQ996xX048YnD233XNlJe3uOtyAQBWG6WalpbuNII5c+akQ4cOSZLZs2ensrK4E+Hq6ppMnDI3s+YuSqfKVumzRns/UK+G3nu4bL+e7fPmvZ8tuhya2Kw5C/P2tPkplZJe3dulQ/tWRZdEARwHVl/v7wt0bL+kL1BWpi+wulndjwFvT5uXd2cuSPt2FenTo71n1ayGVvd9YHU3f8HiTJo6LwsXVWeNbm3TtZMLNlZHjgMA0PK0uDusWrqyslL61XIMf6Bl6ljZOh0r3VEJqyt9AVhywUav7u2KLgMoSNs2FVmnX8eiywAAoIG5FBEAAAAAAIBCCawAAAAAAAAolMAKAAAAAACAQgmsAAAAAAAAKJTACgAAAAAAgEIJrAAAAAAAACiUwAoAAAAAAIBCCawAAAAAAAAolMAKAAAAAACAQgmsAAAAAAAAKJTACgAAAAAAgEIJrAAAAAAAACiUwAoAAAAAAIBCCawAAAAAAAAolMAKAAAAAACAQgmsAAAAAAAAKJTACgAAAAAAgEIJrAAAAAAAACiUwAoAAAAAAIBCCawAAAAAAAAolMAKAAAAAACAQgmsAAAAAAAAKJTACgAAAAAAgEIJrAAAAAAAACiUwAoAAAAAAIBCCawAAAAAAAAolMAKAAAAAACAQgmsAAAAAAAAKJTACgAAAAAAgEIJrAAAAAAAACiUwAoAAAAAAIBCCawAAAAAAAAolMAKAAAAAACAQgmsAAAAAAAAKJTACgAAAAAAgEIJrAAAAAAAACiUwAoAAAAAAIBCCawAAAAAAAAolMAKAAAAAACAQgmsAAAAAAAAKJTACgAAAAAAgEIJrAAAAAAAACiUwAoAAAAAAIBCCawAAAAAAAAolMAKAAAAAACAQrWowKqmpiaPPvpovv3tb2fHHXdMt27d0qpVq/Tq1SsHHHBARo4cWXSJAAAAAAAAfEhF0QU0pPvvvz/Dhg1LkpRKpQwcODADBgzI+PHjc/vtt+f222/PMccck6uuuiqlUqngagEAAAAAAEha4B1WAwYMyKWXXprJkydn3LhxGTVqVKZNm5aLLroopVIpv/nNb3L55ZcXXSoA1NvixdWpqq5JsuS7DwBWN+99//keBACAlqNFBVbbbrttnn/++Xz1q19Njx49lr5eXl6eb3zjGznuuOOSJFdeeWVRJQJAvdTU1OS+J97Kp755X9pu87tMmjovSfL2tPn539+MyZTp8wquEAAa1+y5i3LF9c9n80/flLemLPnee2vKvOz+pb/lxnteyaJF1QVXCAAArIwWFVh16tQprVq1Wub0vffeO0nywgsvNFVJALDS3p25IHsed2eGHXdH/nrfq6mq+u/V5FXVNTn94lFZe+9rc+M9rxRYJQA0nifGTM6Afa/L8ec8mqdfnP6BaQ88OTGf/tb92fLwm/LaW7MKqhAAAFhZLSqwWpH58+cnSdq3b19wJQBQO3PmLsrex9+V+/7x1nLnm7egKoedcr/QCoAWZ9RzU7LHl+/IlHfmL3e+5156N7t+8fa8NXlOE1UGAAA0pNUqsLr22muTJLvsskvBlQBA7fxwxOj889kptZq3piY56rsPZdq7y/9BDwBWFVVV1Tn8lAcyd/7iWs3/+sQ5Of6cxxq5KgAAoDGsNoHV3/72t9xyyy1JktNOO63gagBgxebNX5yr/lq3YWznza/K724Z10gVAUDTuuORN/PKhLoN83fbw6/n1Tq2AQAAirdaBFYvvfRSjjrqqCTJySefnB133LHgigBgxW6455W8M3NhnduNuP75RqgGAJreFfX4TqupSX51o+cWAwDAqqZUU1NTs+LZVl2TJk3KLrvskvHjx2evvfbKbbfdllatWtXpPebMmZMOHTokSfr06ZOystUi56MZm9jlf1Jd1jll1TPS590Liy4HaCQz2g3L7Hb1G8a27/QfppTqBq4IaC70BVhdTOr89VSVd6tzu7YLx6b77GsaoSKgufBdCADNU+/evTNq1Kh6ta1o4FqalenTp2evvfbK+PHjs9NOO+Wmm26qc1j1YRMnTmyg6mAldKxKypLqqqpMmDCh6GqAxtJnftKufk3fmjg5qV7QsPUAzYe+AKuLjqWkvO7N5i9YbN+Als53IQC0OC02sJo5c2b22WefPPPMM9lqq61y++23p3379iv9vu6wojmYWF6e6iRl5eXp069f0eUAjWRW27LMrE/DmkXp26dHSg1dENBs6Auwuni7tCCL69GuXeuqdLNvQIvmuxAAmqfevXvXu22LDKzmzp2bAw44IE8++WQGDx6cu+66K507d26Q9x43blwqKysb5L2gvvoPuzoTJs9Nn9598uazbxZdDtBInn/l3Qw++MY6t/v8ARvmTz9xbICWTF+A1cU5V4zO9375rzq3u2bEKTnoE5c2QkVAc+G7EABanhZ3q9DChQtzyCGH5O9//3sGDhyYe++9Nz169Ci6LACosw3X7ZI9tutb53YnHjG4EaoBgKb35U9tkIryut0zvFafyuy/65qNVBEAANBYWlRgVVVVlc997nO5++67079//9x7773p27fuP/QBQHPxwxO3SquK2n9dHzh0reywec9GrAgAmk7vHu3zzaM2qVObc7+2dcrLW9SpLgAArBZa1JCA1113XW68ccnQSa1bt86RRx65zHlvuOGGlRpLEQCawk5b9spfztstnzv9wSxaXL3ceYdu3TtX/+9uKZU8vQqAluMnX986b0+blz/cOn6F8/7vN7bJkQes1wRVAQAADa1FBVYLFixY+t8vv/xyXn755WXOO3/+/KYoCQBW2qf3Wjd9e7bP2SNG567HJnxkeq/u7XL8YRvmjGM3T5vW5QVUCACNp7y8LL/70a7ZdtM1cvGfnsv412d+ZJ7tNl0jZxy7eQ7+xNoFVAgAADSEFhVYDR8+PMOHDy+6DABocDtu0St3jtgn416bkZvvfy3TZixI29bl2Xi9rjn4E2uldStBFQAtV6lUykmf2SgnHD449zw+If94ZkrmzFuUTpWts8/O/TNkI88tBgCAVV2LCqwAoKUbtHbnnPrFzYouAwAKUVZWyt479c/eO/UvuhQAAKCBeRItAAAAAAAAhRJYAQAAAAAAUCiBFQAAAAAAAIUSWAEAAAAAAFAogRUAAAAAAACFElgBAAAAAABQKIEVAAAAAAAAhRJYAQAAAAAAUCiBFQAAAAAAAIUSWAEAAAAAAFAogRUAAAAAAACFElgBAAAAAABQKIEVAAAAAAAAhRJYAQAAAAAAUCiBFQAAAAAAAIUSWAEAAAAAAFAogRUAAAAAAACFElgBAAAAAABQKIEVAAAAAAAAhRJYAQAAAAAAUCiBFQAAAAAAAIUSWAEAAAAAAFAogRUAAAAAAACFElgBAAAAAABQKIEVAAAAAAAAhRJYAQAAAAAAUCiBFQAAAAAAAIUSWAEAAAAAAFAogRUAAAAAAACFElgBAAAAAABQKIEVAAAAAAAAhRJYAQAAAAAAUCiBFQAAAAAAAIUSWAEAAAAAAFAogRUAAAAAAACFElgBAAAAAABQKIEVAAAAAAAAhRJYAQAAAAAAUCiBFQAAAAAAAIUSWAEAAAAAAFAogRUAAAAAAACFElgBAAAAAABQKIEVAAAAAAAAhRJYAQAAAAAAUCiBFQAAAAAAAIVqUYHVyJEjc8IJJ2TbbbdNv3790qZNm3Ts2DFbbLFFvvOd72Tq1KlFlwgAAAAAAMCHVBRdQEO68MIL89BDD6V169bp27dvNttss0yePDlPP/10xowZk6uuuip33313tthii6JLBQAAAAAA4P+1qDusjjnmmNx3332ZNWtWXnnllTz55JN57bXXMmbMmGyyySaZMmVKPve5zxVdJgAAAAAAAO/TogKro48+Orvvvntat279gdc33XTT/PrXv06SjB07NmPHji2iPAAAWClvTZ6Tc64YnekzFiRJ3pm5ICMfeC1VVdUFVwYAAAArp0UNCbg8gwcPXvrfc+fOLbASAACom6nvzM9Xf/JYbrjn1VRV1Sx9fe78qhz89XuzVp/KnH3ikHzh4EEFVgkAAAD1t9oEVo8++miSpLKyMhtssEHB1QAAQO1MnDI3Q4+5PeNem7nMeV6fOCfDz3o4b749J989boumKw4AAAAaSIsaEvDDqqurM3HixPzhD3/I8OHDkyQ//vGP06FDh2ILAwCAWqiurslBJ9+z3LDq/c78xVO57q6XG7kqAAAAaHgtMrAaMWJESqVSysvL07dv33zhC19I//79c+utt+bkk08uujwAAKiVux+bkFHPTa1Tm3N/NSY1NTUrnhEAAACakRYZWPXp0yc77bRTtttuu/Tt2zelUilPP/10/vKXv2TGjBlFlwcAALVy2bVj69zm6Ren57F/T26EagAAAKDxtMjA6uCDD84jjzySJ554IhMmTMiYMWOy/fbb5+qrr87+++9fdHkAALBCNTU1ufPRN+vV9o5H3mjgagAAAKBxlWpWk/FCZs2alQEDBmTq1Km55557MmzYsFq3nTNnztLnXvXp0ydlZS0y52MVMrHL/6S6rHPKqmekz7sXFl0OANAIalKRt7qdVa+2lfP/kS5z/9bAFQFA8+G8GACap969e2fUqFH1alvRwLU0Wx07dszQoUNz4403ZsyYMXUKrN5v4sSJDVwZ1EPHqqQsqa6qyoQJE4quBgBoFKWka3VSqvvFUnNmTs+ct/URAGjBnBcDQIuz2gRWSbJ48eIkSVVVVb3fwx1WNAcTy8tTnaSsvDx9+vUruhwAoJFMrnoriyr617ldt3Yz0k4fAYAWzHkxADRPvXv3rnfb1Sawmj59eh566KEkyRZbbFHv9xk3blwqKysbqCqon/7Drs6EyXPTp3efvPls/Z5tAQA0f7+75cV88ay/16lN357t89q/7kpFhYusAGi5nBcDQMvTYs5iR40ale9973sZP378R6aNHj06++67b959991suumm2WOPPQqoEAAA6uaIvQekd492dWrztc9uJKwCAABgldNizmRnz56dc845J4MGDUqvXr2y9dZbZ7vttku/fv2y1VZb5Z///GfWX3/93HzzzSkvLy+6XAAAWKF2bSsy8ud7prJd7QZG+OTua+fU4Zs2clUAAADQ8FpMYLX55pvnkksuySc/+cl06tQpL774YkaPHp2qqqoMGzYsv/zlLzNmzJgMGDCg6FIBAKDWttlkjTz02/2zbr+Oy5ynrKyU4w/bMNf9dPeUl7eYLj4AAACrkRbzDKuuXbvm5JNPzsknn1x0KQAA0KCGbNQj4277dO545M1cft3YPDv+ncybX5XuXdrk0D3WyXGf3iBr9112oAUAAADNXYsJrAAAoCUrLy/LAUPXygFD1yq6FAAAAGhwxgsBAAAAAACgUAIrAAAAAAAACiWwAgAAAAAAoFACKwAAAAAAAAolsAIAAAAAAKBQAisAAAAAAAAKJbACAAAAAACgUAIrAAAAAAAACiWwAgAAAAAAoFACKwAAAAAAAAolsAIAAAAAAKBQAisAAAAAAAAKJbACAAAAAACgUAIrAAAAAAAACiWwAgAAAAAAoFACKwAAAAAAAAolsAIAAAAAAKBQAisAAAAAAAAKJbACAAAAAACgUAIrAAAAAAAACiWwAgAAAAAAoFACKwAAAAAAAAolsAIAAAAAAKBQAisAAAAAAAAKJbACAAAAAACgUAIrAAAAAAAACiWwAgAAAAAAoFACKwAAAAAAAAolsAIAAAAAAKBQAisAAAAAAAAKJbACAAAAAACgUAIrAAAAAAAACiWwAgAAAAAAoFACKwAAAAAAAAolsAIAAAAAAKBQAisAAAAAAAAKJbACAAAAAACgUAIrAAAAAAAACiWwAgAAAAAAoFACKwAAAAAAAAolsAIAAAAAAKBQAisAAAAAAAAKJbACAAAAAACgUAIrAAAAAAAACiWwAgAAAAAAoFACKwAAAAAAAArV4gOrX/3qVymVSimVStltt92KLgcAAAAAAIAPadGB1aRJk3LaaacVXQYAAAAAAADL0aIDq6997WuZOXNmDjjggKJLgQbzypuzMn9BVZJkwcKqLF5cXXBFAAAA0DRqamoy6rkpmbdgcZJkkXNiAGgxWmxgNXLkyNxwww056aSTMmTIkKLLgZVSU1OTWx98Pfscf2cG7Hddps1YkCSZ+u6CrLPPtTl7xOhMmT6v4CoBAACgccyZuyiX/uW5bHzIX7PNZ0dm+oyFSZLJ0+dn+8+PzO9vGeeCTgBYxZVqampqii6ioc2aNSsbbbRRqqurM3bs2Fx44YX54Q9/mKFDh+bBBx+s8/vNmTMnHTp0SJLMnj07lZWVDVwxLFtVVXW+9pPHc/l1zy93vjV7V+bOy/fORgO7NlFlAAAA0PjenjYv+514V/41dtpy59tvl/657qe7p7J9qyaqDABoSC3yDqszzjgjb775Zi6++OJ06tSp6HJgpZx64T9XGFYlyRuT5mTPr9yZNybNboKqAAAAoPHNnrso+56w4rAqSf729zfzmdMeSFWVO60AYFXU4gKrxx9/PJdffnn23XffHHbYYUWXAyvl2XHTc9Efn6v1/G9NnpsfXD66ESsCAACApnPZNWMz+vkVh1Xvue3hN3LLA683YkUAQGNpUYHVokWL8uUvfzlt2rTJL37xi6LLgZVWmzurPuzqO17KOzMXNEI1AAAA0HSqq2sy4vq6nxdfdu3YRqgGAGhsLSqwOu+88/Lcc8/lzDPPzIABA4ouB1ZKVVV1/nDr+Dq3mze/Ktff/UojVAQAAABN5+//mpRXJsyqc7v7/vGW4fIBYBVUUXQBDeWFF17Iueeem8GDB+fUU09ttOUMGjQoZWUtKuejmaoutcvsrqfXq+0pZ/w4Z3/j/gauCAAAAJrO3NabJR0+Va+2W20/LG0Wv9nAFQEAK9K7d++MGjWqXm1bTGB1wgknZMGCBRkxYkRatWrVaMuZOHFio703fEBZ+6Rr/ZrOmjUzs96e0LD1AAAAQFPqsmbSoX5Np06eksxzXgwAq5IWE1j961//SllZWQ4//PCPTJs9e8lt4I899lh69+6dJHnxxRfTqVOnOi+nT58+7rCiSdSklIk181NTalvntl0qa1LZr18jVAUAAABNY0FFWabWtVFNTVIqpXf3NimvcV4MAE3tvQymPlpMYJUk1dXVefvtt5c5fdGiRUunV1dX12sZ48aNS2VlZb3aQl197SeP5xdX/6dObdq1Lc8rj1yXLp3aNFJVAAAA0Piqq2sy6IDr8/KbdXiOVamUPXfom7uvqNu5NABQvBZzq9C7776bmpqaj/33/e9/P0kydOjQpa916dKl2IKhFk44fMM6t/n8fgOFVQAAAKzyyspKOeHwwXVud+IRdW8DABSvxQRW0BJtNLBrTh2+aa3nX7N3ZX544laNWBEAAAA0nRMO3zBbb9yj1vN/cve1c+DQtRqxIgCgsQisoJk77xvb5OTPbbTC+dbt1zH3XLFP+vY0ZCUAAAAtQ2X7VvnbL/fKtpusscJ5D9ptrfz5J7ulvNzPXQCwKvINDs1cWVkpl5y+Q+68fO8csOuaKZU+OH3tvh3yk69vnVHXHJwN1u1SSI0AAADQWNbo1i4P/ma/jDhrp2w6qOtHpu+8Za/8+Se75a8X7ZH27VrU49oBYLVSqqmpqSm6iOZuzpw56dChQ5Jk9uzZqax0BwvFeWPS7Lzw6owsWFiVHl3aZuuNe7h6DAAAgNVCTU1Nnn5xet6aPDfl5aWs3aeDizcBoIUQWNWCwAoAAAAAAKDxuC0DAAAAAACAQgmsAAAAAAAAKJTACgAAAAAAgEIJrAAAAAAAACiUwAoAAAAAAIBCCawAAAAAAAAolMAKAAAAAACAQgmsAAAAAAAAKJTACgAAAAAAgEIJrAAAAAAAACiUwAoAAAAAAIBCCawAAAAAAAAolMAKAAAAAACAQgmsAAAAAAAAKJTACgAAAAAAgEIJrAAAAAAAACiUwAoAAAAAAIBCCawAAAAAAAAolMAKAAAAAACAQgmsAAAAAAAAKJTACgAAAAAAgEIJrAAAAAAAACiUwAoAAAAAAIBCCawAAAAAAAAolMAKAAAAAACAQgmsAAAAAAAAKJTACgAAAAAAgEIJrAAAAAAAACiUwAoAAAAAAIBCCawAAAAAAAAolMAKAAAAAACAQgmsAAAAAAAAKJTACgAAAAAAgEIJrAAAAAAAACiUwAoAAAAAAIBCCawAAAAAAAAolMAKAAAAAACAQgmsAAAAAAAAKJTACgAAAAAAgEIJrAAAAAAAACiUwAoAAAAAAIBCCawAAAAAAAAolMAKAAAAAACAQgmsAAAAAAAAKJTACgAAAAAAgEK1qMBq+PDhKZVKy/33/PPPF10mAAAAAAAA71NRdAGNYdCgQenZs+fHTmvfvn0TVwMAAAAAAMDytMjA6jvf+U6GDx9edBkAAAAAAADUQosaEhAAAAAAAIBVj8AKAAAAAACAQrXIIQFvuOGG3HzzzZk5c2Z69OiR7bffPkcddVTWWGONoksDAAAAAADgQ0o1NTU1RRfRUIYPH57f//73HzutsrIyI0aMyJFHHlnn950zZ046dOiQJJk9e3YqKytXqk4AAAAAAAD+q0UNCbj++uvnoosuyr///e+8++67mTNnTh5++OHstddemTNnTo4++ujcfvvtRZcJAAAAAADA+7SoO6yWpaamJoccckhuueWWrLfeennxxRdTKpVq3d4dVgAAAAAAAI1ntQiskuSFF17IhhtumCQZM2ZMNttss1q3fX9g1adPn5SVtagb0wAAAAAAAFZa7969M2rUqHq1rWjgWpqtDTbYIN26dcv06dMzbty4OgVW7zdx4sQGrgwAAAAAAGD1ttoEVknSqlWrJMnixYvr1K59+/aZPXt2dt5550yePLlOwwkCAAAAAACsDnr37l3vtqtNYDVlypRMnjw5SdK/f/86tS2VSqmsrMzo0aMbozQAAAAAAIDV2mrzMKYLLrggNTU16dy5c7bZZpuiywEAAAAAAOD/tZjA6p577snpp5+el1566QOvz507N2effXbOP//8JMkZZ5yR1q1bF1EiAAAAAAAAH6NUU1NTU3QRDeHmm2/OIYcckiTp06dP+vXrl+rq6owdOzbz5s1Lkhx33HEZMWKEZ1ABAAAAAAA0Iy0msHrjjTdy5ZVX5vHHH8/48eMzZcqUVFVVpVevXtlhhx3y5S9/OXvssUfRZQIAAAAAAPAhLSawAgAAAAAAYNXUYp5hBQAAAAAAwKpJYAUAAAAAAEChBFYAAAAAAAAUSmAFAAAAAABAoQRWAAAAAAAAFEpgBQAAAAAAQKEEVgAAAAAAABRKYAUAAAAAAEChBFYAAAAAAAAUSmAFAAAAAABAoQRWAAAAAAAAFEpgBQAAAAAAQKEEVgAAAAAAABRKYAUAAAAAAEChBFYAAAAAAAAUSmAFAAAAAABAoQRWAAAAAAAAFEpgBQAAAAAAQKEEVgAAAAAAABRKYAUAAAAAAEChBFYAAAAAAAAUSmAFAAAAAABAoQRWAAAAAAAAFEpgBQAAAAAAQKEEVgAAAAAAABRKYAUAAAAAAEChBFYAAAAAAAAUSmAFAAAAAABAoQRWAAAAAAAAFEpgBQAAAAAAQKEEVgAAAAAAABRKYAUAAAAAAEChBFYAAAAAAAAUSmAFAAAAAABAoQRWAAAAAAAAFEpgBQAAAAAAQKEEVgAAAAAAABRKYAUAAAAAAEChBFYAAAAAAAAUSmAFAAAAAABAoQRWAAAAAAAAFOr/AKo5zxKFrGD4AAAAAElFTkSuQmCC\n"
+          },
+          "metadata": {},
+          "execution_count": 21
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "# Test 5: Audio Signal Encoding with QPIXL\n",
+        "\n",
+        "This test demonstrates encoding a real audio file into a quantum circuit using QPIXL\n",
+        "\n",
+        "\n",
+        "*   An audio file is loaded and converted to mono if necessary. The signal is downsampled and truncated to a power-of-2 length\n",
+        "\n",
+        "\n",
+        "\n",
+        "*   Amplitude values are normalized and scaled to rotation angles.\n",
+        "A QPIXL circuit is generated from these angles using cFRQI\n",
+        "\n",
+        "\n",
+        "*   The resulting quantum circuit captures features of the input audio.\n",
+        "\n",
+        "The resulting process_audio() function provides both the angle array and the encoded quantum circuit, which can be directly wrapped in a QPIXLModule or combined with other circuits using QuantumComposer\n"
+      ],
+      "metadata": {
+        "id": "ta6dS_ME5_is"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# AUDIO HELPER (standalone, no patching needed)\n",
+        "import numpy as np\n",
+        "import soundfile as sf\n",
+        "from qiskit import QuantumCircuit\n",
+        "from QPIXL.qiskit.qpixl import cFRQI  # or encode_angles_to_qc\n",
+        "\n",
+        "def process_audio(path: str, normalize=True, compression=0):\n",
+        "    data, _ = sf.read(path)\n",
+        "    if len(data.shape) > 1:\n",
+        "        data = data.mean(axis=1)\n",
+        "\n",
+        "    samples = data[::200]\n",
+        "    L = 2 ** int(np.floor(np.log2(len(samples))))\n",
+        "    samples = samples[:L]\n",
+        "\n",
+        "    if normalize:\n",
+        "        samples = (samples - samples.min()) / (samples.max() - samples.min() + 1e-8)\n",
+        "    angles = samples * np.pi\n",
+        "\n",
+        "    circuit = cFRQI(angles, compression)\n",
+        "    return angles, circuit"
+      ],
+      "metadata": {
+        "id": "JrNdoJRkqbKe"
+      },
+      "execution_count": 20,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "angles, circuit = process_audio(\"/content/QuantumArtHack/figures/Ignacio_short.mp3\")\n"
+      ],
+      "metadata": {
+        "id": "WPODVhq4qgDA"
+      },
+      "execution_count": 19,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# === TEST: Audio as QPIXL Data + Algorithm Circuit (Merge) ===\n",
+        "\n",
+        "from QPIXL.qiskit.qpixl_module import QPIXLModule\n",
+        "from QPIXL.qiskit.quantum_composer import QiskitCircuitModule, QuantumComposer\n",
+        "from IPython.display import display\n",
+        "import numpy as np\n",
+        "import soundfile as sf\n",
+        "\n",
+        "def process_audio(path, compression=25):\n",
+        "    \"\"\"Preprocess audio to return QPIXL angles + algorithm circuit.\"\"\"\n",
+        "    audio_data, _ = sf.read(path)\n",
+        "    if len(audio_data.shape) > 1:\n",
+        "        audio_data = audio_data.mean(axis=1)\n",
+        "    audio_data = audio_data[:16]  # Limit for scroll-safe example\n",
+        "\n",
+        "    # Normalize and convert to angles\n",
+        "    audio_data = (audio_data - audio_data.min()) / (audio_data.max() - audio_data.min() + 1e-8)\n",
+        "    angles = audio_data * np.pi\n",
+        "\n",
+        "    # Simple audio algorithm (3-qubit example)\n",
+        "    from qiskit import QuantumCircuit\n",
+        "    algo = QuantumCircuit(3)\n",
+        "    algo.h(0)\n",
+        "    algo.cx(0, 1)\n",
+        "\n",
+        "    return angles, algo\n",
+        "\n",
+        "# Step 1: Load and process audio\n",
+        "angles, audio_algo = process_audio(\"/content/QuantumArtHack/figures/Ignacio_short.mp3\", compression=25)\n",
+        "print(f\"[INFO] {len(angles)} QPIXL angles from audio signal (trimmed)\")\n",
+        "\n",
+        "# Step 2: Wrap QPIXL + audio algorithm as modules\n",
+        "qpixl_audio = QPIXLModule(angles, compression=25, name=\"QPIXL_Audio\")\n",
+        "audio_mod = QiskitCircuitModule(audio_algo, name=\"AudioAlgo\")\n",
+        "\n",
+        "# Step 3: Safely preview qubit layout\n",
+        "composer_temp = QuantumComposer([qpixl_audio, audio_mod])\n",
+        "combined_temp = composer_temp.combine(rule=\"sequential\")\n",
+        "valid_indices = list(range(combined_temp.num_qubits))\n",
+        "\n",
+        "DEBUG = False\n",
+        "if DEBUG:\n",
+        "    print(f\"[DEBUG] Qubits: {combined_temp.num_qubits}\")\n",
+        "    for idx in valid_indices:\n",
+        "        print(f\"  Qubit {idx}\")\n",
+        "\n",
+        "# Step 4: Safe entanglement map (QPIXL q0 ↔ Algo q5)\n",
+        "requested_map = {\n",
+        "    0: 5\n",
+        "}\n",
+        "connection_map = {\n",
+        "    k: v for k, v in requested_map.items()\n",
+        "    if k in valid_indices and v in valid_indices\n",
+        "}\n",
+        "print(f\"[INFO] Using connection map: {connection_map}\")\n",
+        "\n",
+        "# Step 5: Final composition\n",
+        "composer = QuantumComposer([qpixl_audio, audio_mod])\n",
+        "combined = composer.combine(rule=\"merge\", connection_map=connection_map, entangle_type=\"cx\")\n",
+        "\n",
+        "# Step 6: Visualize and summarize\n",
+        "print(f\"[RESULT] Qubits: {combined.num_qubits}\")\n",
+        "print(f\"[RESULT] Depth: {combined.depth()}\")\n",
+        "print(f\"[RESULT] Gate counts: {combined.count_ops()}\")\n",
+        "display(combined.draw(\"mpl\"))\n"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 709
+        },
+        "id": "eIaGpCV4rABK",
+        "outputId": "eb23a100-f289-4ffe-f88a-a06cd570ac1e"
+      },
+      "execution_count": 18,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "[INFO] 16 QPIXL angles from audio signal (trimmed)\n",
+            "▶ Combining using rule: sequential\n",
+            "  ↪ QPIXL_Audio\n",
+            "  ↪ AudioAlgo\n",
+            "✓ Done in 0.00s\n",
+            "[INFO] Using connection map: {0: 5}\n",
+            "▶ Combining using rule: merge\n",
+            "  ↪ QPIXL_Audio\n",
+            "  ↪ AudioAlgo\n",
+            "✓ Done in 0.00s\n",
+            "[RESULT] Qubits: 9\n",
+            "[RESULT] Depth: 27\n",
+            "[RESULT] Gate counts: OrderedDict([('cx', 16), ('ry', 12), ('h', 5)])\n"
+          ]
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 2192.32x1622.06 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "# Test 6: Gate Injection into QPIXL Circuit\n",
+        "This test verifies support for custom gate injection during QPIXL encoding\n",
+        "\n",
+        "\n",
+        "*   A small grayscale image (8 pixels) is converted into angle data\n",
+        "\n",
+        "\n",
+        "*   The QPIXLModule is configured with injected_ops, which include:\n",
+        "A RY(π/4) rotation on the first qubit and\n",
+        "a CZ gate between the first and second qubits\n",
+        "\n",
+        "\n",
+        "*  These operations are injected after the QPIXL encoding but within the same module\n",
+        "\n",
+        "\n",
+        "This test demonstrates how the QPIXLModule can be extended to include additional computation, manipulation, or entanglement — all while staying modular and composable.\n",
+        "\n",
+        "\n"
+      ],
+      "metadata": {
+        "id": "nJMFukN89ciH"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "from QPIXL.qiskit.qpixl_module import QPIXLModule\n",
+        "from QPIXL.qiskit.quantum_composer import QuantumComposer\n",
+        "import numpy as np\n",
+        "\n",
+        "# Image data\n",
+        "angles = np.linspace(0, np.pi / 2, 8)\n",
+        "\n",
+        "# Create QPIXL module\n",
+        "qpixl_mod = QPIXLModule(angles, compression=0, name=\"QPIXL_with_Gates\")\n",
+        "\n",
+        "# Inject gates using supported method\n",
+        "qpixl_mod.add_injection(\"before\", \"ry\", [0], {\"angle\": np.pi / 4})\n",
+        "qpixl_mod.add_injection(\"before\", \"cz\", [0, 1])\n",
+        "\n",
+        "# Combine using QuantumComposer\n",
+        "composer = QuantumComposer([qpixl_mod])\n",
+        "circuit = composer.combine(rule=\"sequential\")\n",
+        "\n",
+        "# Draw\n",
+        "circuit.draw(\"mpl\")\n",
+        "\n"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 334
+        },
+        "id": "0p-cL9bj9QzC",
+        "outputId": "3b361a7d-ea2e-45b0-a968-2ce619b5cc81"
+      },
+      "execution_count": 17,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "▶ Combining using rule: sequential\n",
+            "  ↪ QPIXL_with_Gates\n",
+            "✓ Done in 0.00s\n"
+          ]
+        },
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "<Figure size 1105.38x451.5 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {},
+          "execution_count": 17
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "# TEST 6.1:Custom Injection test\n",
+        "\n",
+        "This test demonstrates the add_custom_injection() capability of QPIXLModule, allowing advanced logic to be injected during circuit generation.\n",
+        "We define a custom function that applies a gate based on the index and angle of each pixel, and the module calls it during encoding\n",
+        "\n",
+        "The module supports all three injection stages:\n",
+        "\n",
+        "Before encoding → e.g., initialize extra qubits\n",
+        "\n",
+        "During encoding → e.g., apply gates conditionally per pixel angle\n",
+        "\n",
+        "After encoding → e.g., apply final entangling or measurement logic"
+      ],
+      "metadata": {
+        "id": "pF_qCLaXGcKo"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "from QPIXL.qiskit.qpixl_module import QPIXLModule, InjectionPoint\n",
+        "from qiskit import QuantumCircuit\n",
+        "import numpy as np\n",
+        "\n",
+        "# Sample image array\n",
+        "angles = np.linspace(0, np.pi, 8)\n",
+        "\n",
+        "# Define a custom gate injection function\n",
+        "def my_custom_gate(circuit, idx, angle):\n",
+        "    if angle > np.pi / 2:\n",
+        "        q_enc = circuit.qubits[-2]     # encoding qubit\n",
+        "        q_algo = circuit.qubits[-1]    # algorithm qubit\n",
+        "        circuit.cry(angle / 2, q_algo, q_enc)\n",
+        "\n",
+        "# Create QPIXLModule with algorithm qubit and custom injection\n",
+        "mod = QPIXLModule(angles, compression=0, algorithm_qubits=1)\n",
+        "mod.add_custom_injection(my_custom_gate, when=\"during\")\n",
+        "\n",
+        "# Generate circuit\n",
+        "circuit = mod.get_circuit(verbose=True)\n",
+        "circuit.draw(\"mpl\")\n"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 393
+        },
+        "id": "u0SktZNZGaRr",
+        "outputId": "45b034f6-c6dc-452a-8b1a-66c2e9e1c6a5"
+      },
+      "execution_count": 16,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "[QPIXL] qubits=6, depth=10, compression=0\n"
+          ]
+        },
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "<Figure size 956.385x535.111 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {},
+          "execution_count": 16
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "# Test 7: Combined Image, Audio, and Algorithm with Entanglement\n",
+        "\n",
+        "This test demonstrates the full capabilities of the QuantumComposer by integrating three distinct components:\n",
+        "\n",
+        "A QPIXL circuit from a grayscale image , a QPIXL circuit from an audio file , a standard 3 qubit quantum algorithm\n",
+        "\n",
+        "All three modules are merged using the merge rule. Controlled-X entanglement gates are added between\n",
+        " a qubit from the image circuit and a qubit from the audio circuit another qubit  from the audio circuit and one from the algorithm"
+      ],
+      "metadata": {
+        "id": "Z3WcnSCC-xj9"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# === Test 7: Combined Image, Audio, Algorithm + Entanglement ===\n",
+        "\n",
+        "from QPIXL.qiskit.qpixl_module import QPIXLModule\n",
+        "from QPIXL.qiskit.quantum_composer import QiskitCircuitModule, QuantumComposer\n",
+        "from qiskit import QuantumCircuit\n",
+        "import numpy as np\n",
+        "from PIL import Image\n",
+        "import soundfile as sf\n",
+        "from IPython.display import display\n",
+        "\n",
+        "print(\"\\n== Test 7: Combined Image, Audio, Algorithm + Entanglement ==\")\n",
+        "\n",
+        "# -- 1. Image Module (4x4 grayscale → 16 pixels → 5 qubits)\n",
+        "img = Image.open(\"/content/QuantumArtHack/figures/cat.webp\").convert(\"L\").resize((4, 4))\n",
+        "image_angles = (np.array(img) / 255.0 * np.pi).flatten()\n",
+        "image_mod = QPIXLModule(image_angles, compression=20, name=\"ImageQPIXL\")\n",
+        "\n",
+        "# -- 2. Audio Module (first 16 samples → 5 qubits)\n",
+        "audio_data, _ = sf.read(\"/content/QuantumArtHack/figures/Ignacio_short.mp3\")\n",
+        "if len(audio_data.shape) > 1:\n",
+        "    audio_data = audio_data.mean(axis=1)\n",
+        "audio_data = audio_data[:16]\n",
+        "audio_data = (audio_data - audio_data.min()) / (audio_data.max() - audio_data.min() + 1e-8)\n",
+        "audio_angles = audio_data * np.pi\n",
+        "audio_mod = QPIXLModule(audio_angles, compression=25, name=\"AudioQPIXL\")\n",
+        "\n",
+        "# -- 3. Simple Algorithm Module (3 qubits)\n",
+        "algo = QuantumCircuit(3)\n",
+        "algo.h(0)\n",
+        "algo.cx(0, 1)\n",
+        "algo_mod = QiskitCircuitModule(algo, name=\"SimpleAlgo\")\n",
+        "\n",
+        "# -- 4. Dry-run composition to get actual qubit layout\n",
+        "composer_temp = QuantumComposer([image_mod, audio_mod, algo_mod])\n",
+        "combined_temp = composer_temp.combine(rule=\"sequential\")\n",
+        "total_qubits = combined_temp.num_qubits\n",
+        "valid_indices = list(range(total_qubits))\n",
+        "\n",
+        "# -- Optional: Debug output (turn on for layout inspection)\n",
+        "DEBUG = False\n",
+        "if DEBUG:\n",
+        "    print(f\"[DEBUG] Total Qubits: {total_qubits}\")\n",
+        "    for idx in valid_indices:\n",
+        "        print(f\"  Qubit {idx}\")\n",
+        "\n",
+        "# -- 5. Safe entanglement map (filtered to stay within bounds)\n",
+        "requested_map = {\n",
+        "    0: 5,   # image q0 ↔ audio q0\n",
+        "    7: 8    # audio q2 ↔ algo q0\n",
+        "}\n",
+        "connection_map = {\n",
+        "    k: v for k, v in requested_map.items()\n",
+        "    if k in valid_indices and v in valid_indices\n",
+        "}\n",
+        "print(f\"[INFO] Using safe entanglement map: {connection_map}\")\n",
+        "\n",
+        "# -- 6. Final composition with merge and entanglement\n",
+        "composer = QuantumComposer([image_mod, audio_mod, algo_mod])\n",
+        "combined = composer.combine(\n",
+        "    rule=\"merge\",\n",
+        "    connection_map=connection_map,\n",
+        "    entangle_type=\"cx\"\n",
+        ")\n",
+        "\n",
+        "# -- 7. Show results\n",
+        "print(f\"[RESULT] Total qubits: {combined.num_qubits}\")\n",
+        "print(f\"[RESULT] Circuit depth: {combined.depth()}\")\n",
+        "print(f\"[RESULT] Gate counts: {combined.count_ops()}\")\n",
+        "display(combined.draw(\"mpl\"))\n",
+        "\n"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 998
+        },
+        "id": "Arig2ezxmkSk",
+        "outputId": "8d24356c-78c3-44d8-9881-56a1a01901bb"
+      },
+      "execution_count": 15,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "\n",
+            "== Test 7: Combined Image, Audio, Algorithm + Entanglement ==\n",
+            "▶ Combining using rule: sequential\n",
+            "  ↪ ImageQPIXL\n",
+            "  ↪ AudioQPIXL\n",
+            "  ↪ SimpleAlgo\n",
+            "✓ Done in 0.00s\n",
+            "[INFO] Using safe entanglement map: {0: 5, 7: 8}\n",
+            "▶ Combining using rule: merge\n",
+            "  ↪ ImageQPIXL\n",
+            "  ↪ AudioQPIXL\n",
+            "  ↪ SimpleAlgo\n",
+            "✓ Done in 0.00s\n",
+            "[RESULT] Total qubits: 9\n",
+            "[RESULT] Circuit depth: 56\n",
+            "[RESULT] Gate counts: OrderedDict([('cx', 33), ('ry', 25), ('h', 9)])\n"
+          ]
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 2192.32x2458.17 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "# Test 8: Hardware-Aware Transpilation with a Custom Coupling Map\n",
+        "\n",
+        "This test shows how the QuantumComposer supports hardware-aware transpilation using Qiskit’s transpiler.\n",
+        "\n",
+        "*   A QPIXL circuit (8 qubits) is combined with a simple 3-qubit algorithm using the sequential rule\n",
+        "\n",
+        "*   A linear 8-qubit coupling map is defined to simulate a hardware layout\n",
+        "*   The composed circuit is passed to Qiskit's transpiler with custom constraints:\n",
+        "Basis gates: [\"cx\", \"u3\"]\n",
+        ", Optimization level: 1\n",
+        ", Coupling map: linear 8-qubit chain\n",
+        "\n",
+        "\n",
+        "The output circuit shows any rewrites, swap insertions, or gate adjustments based on connectivity\n",
+        "\n",
+        "This confirms that circuits created through QuantumComposer are compatible with hardware-aware execution paths.\n",
+        "\n"
+      ],
+      "metadata": {
+        "id": "G6sp02HLBvp7"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "from qiskit.transpiler import CouplingMap\n",
+        "from QPIXL.qiskit.qpixl_module import QPIXLModule\n",
+        "from QPIXL.qiskit.quantum_composer import QiskitCircuitModule, QuantumComposer\n",
+        "import numpy as np\n",
+        "from qiskit import QuantumCircuit\n",
+        "\n",
+        "# Prepare QPIXL and algorithm circuits\n",
+        "angles = np.linspace(0, np.pi / 2, 8)\n",
+        "qpixl = QPIXLModule(angles, compression=0, name=\"QPIXLImg\")\n",
+        "algo = QuantumCircuit(3); algo.h(0); algo.cx(0, 1)\n",
+        "algo_mod = QiskitCircuitModule(algo, name=\"MiniAlgo\")\n",
+        "\n",
+        "# Combine them with the composer\n",
+        "composer = QuantumComposer([qpixl, algo_mod])\n",
+        "\n",
+        "# Define a larger fake coupling map with 8 qubits (linear topology)\n",
+        "larger_map = CouplingMap([[i, i + 1] for i in range(8)])\n",
+        "\n",
+        "# Combine with transpilation for hardware-awareness\n",
+        "combined_hw = composer.combine(\n",
+        "    rule=\"hardware_aware_sequential\",\n",
+        "    coupling_map=larger_map,\n",
+        "    basis_gates=[\"cx\", \"u3\"],\n",
+        "    optimization_level=1\n",
+        ")\n",
+        "\n",
+        "# Visualize and show circuit metadata\n",
+        "print(\"Transpiled depth:\", combined_hw.depth())\n",
+        "print(\"Transpiled qubits:\", combined_hw.num_qubits)\n",
+        "combined_hw.draw(\"mpl\")"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 275
+        },
+        "id": "Fmzecy-FAvyO",
+        "outputId": "a71f446d-f3e1-4714-972f-a980847222c5"
+      },
+      "execution_count": 14,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "▶ Combining using rule: hardware_aware_sequential\n",
+            "  ↪ QPIXLImg\n",
+            "  ↪ MiniAlgo\n",
+            "✓ Done in 0.07s\n",
+            "Transpiled depth: 19\n",
+            "Transpiled qubits: 9\n"
+          ]
+        },
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "<Figure size 2263.23x535.111 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {},
+          "execution_count": 14
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "# Test: Algorithm–QPIXL Interaction During Encoding\n",
+        "This test shows direct entanglement between an algorithm qubit and the QPIXL encoding qubit. We inject a CRY gate during the encoding loop, so the algorithm qubit actually influences the QPIXL-encoded data."
+      ],
+      "metadata": {
+        "id": "ygdzB5oQ8awn"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "#Algorithm qubit controls encoding qubit via CRY\n",
+        "import numpy as np, math\n",
+        "from qiskit import QuantumCircuit\n",
+        "from QPIXL.qiskit.qpixl_module import QPIXLModule, InjectionPoint\n",
+        "from QPIXL.qiskit.quantum_composer import QiskitCircuitModule, QuantumComposer\n",
+        "\n",
+        "data = np.linspace(0, np.pi/2, 8)\n",
+        "\n",
+        "mod = QPIXLModule(data, compression=0, name=\"InteractiveQPIXL\", algorithm_qubits=1)\n",
+        "mod.add_injection(\n",
+        "    when=InjectionPoint.DURING_ENCODING,\n",
+        "    gate_type=\"cry\",\n",
+        "    qubits=[-1, 0],                 # algo_qubit → encoding_qubit\n",
+        "    params={\"angle\": math.pi/4},\n",
+        "    condition=lambda i, angle: i % 2 == 0\n",
+        ")\n",
+        "\n",
+        "algo = QuantumCircuit(1, name=\"AlgoInit\")\n",
+        "algo.h(0)\n",
+        "algo_mod = QiskitCircuitModule(algo, \"AlgoInit\")\n",
+        "\n",
+        "composer = QuantumComposer([algo_mod, mod])\n",
+        "combined = composer.combine(rule=\"sequential\")\n",
+        "combined.draw(\"mpl\")\n"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 379
+        },
+        "id": "4Z4xryWb5m7W",
+        "outputId": "94630d18-a3aa-49d5-87e7-18128b92b6df"
+      },
+      "execution_count": 13,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "▶ Combining using rule: sequential\n",
+            "  ↪ AlgoInit\n",
+            "  ↪ InteractiveQPIXL\n",
+            "✓ Done in 0.00s\n"
+          ]
+        },
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "<Figure size 1356.21x618.722 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {},
+          "execution_count": 13
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "# Test: Cross-Sliced Circuit Composition with Entanglement\n",
+        "\n",
+        "This test demonstrates our final slice rule, where:\n",
+        "\n",
+        "Both the QPIXL data circuit and the algorithm circuit are sliced into segments.\n",
+        "\n",
+        "These slices are interleaved together, forming an intertwined execution pipeline.\n",
+        "\n",
+        "At each insertion point, we connect the modules using a configurable entanglement rule (e.g., cx, cz, swap).\n",
+        "\n",
+        "In this example, QPIXL qubit 2 is connected to algorithm qubit 0 using a controlled-X (cx) gate."
+      ],
+      "metadata": {
+        "id": "7vArh4hoE3xC"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "from QPIXL.qiskit.qpixl_module import QPIXLModule\n",
+        "from QPIXL.qiskit.quantum_composer import QiskitCircuitModule, QuantumComposer\n",
+        "from qiskit import QuantumCircuit\n",
+        "import numpy as np\n",
+        "\n",
+        "# 1) Create modules\n",
+        "data_mod = QPIXLModule(np.linspace(0, np.pi/2, 8), name=\"QPIXLDATA\")\n",
+        "algo    = QuantumCircuit(2)\n",
+        "algo.h(0); algo.cx(0,1)\n",
+        "algo_mod = QiskitCircuitModule(algo, name=\"ALGO\")\n",
+        "\n",
+        "# 2) Compose with slicing\n",
+        "composer = QuantumComposer([data_mod, algo_mod])\n",
+        "combined = composer.combine(\n",
+        "    rule=\"slice\",\n",
+        "    slice_size=4,\n",
+        "    connection_rule=\"cx\",\n",
+        "    connection_map=[(2, 0)]  # Connects qubit 2 of data to qubit 0 of algo\n",
+        ")\n",
+        "\n",
+        "# 3) Draw\n",
+        "combined.draw(\"mpl\")\n"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 464
+        },
+        "id": "GyN2lkXdrz1u",
+        "outputId": "de5def6e-40e2-4b54-a2bd-170d1da248d0"
+      },
+      "execution_count": 12,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "▶ Combining using rule: slice\n",
+            "✓ Done in 0.00s\n"
+          ]
+        },
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "<Figure size 956.385x618.722 with 1 Axes>"
+            ],
+            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAvQAAAHwCAYAAADJpfudAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjEsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvc2/+5QAAAAlwSFlzAAAPYQAAD2EBqD+naQAAVvlJREFUeJzt3Xl8FPX9x/H3bu6QBEgCJBCuQIIkEFAORVQEQUUEPAFFPH4IVqWgRVK19cCqiNLaIrXiVWutMXhWwQM1HoiKgYhCCCBHkIQssJwh5N79/UFBIknILrs7O5vX8/Hw0bIz35nPZue7+97Z73zH4nQ6nQIAAABgSlajCwAAAADgPgI9AAAAYGIEegAAAMDECPQAAACAiRHoAQAAABMj0AMAAAAmRqAHAAAATIxADwAAAJgYgR4AAAAwMQI9AAAAYGIEegAAAMDECPQAAACAiRHoAQAAABMj0AMAAAAmRqAHAAAATIxADwAAAJgYgR4AAAAwMQI9AAAAYGIEegAAAMDECPQAAACAiRHoAQAAABMj0AMAAAAmRqAHAAAATIxADwAAAJgYgR4AAAAwMQI9AAAAYGIEegAAAMDECPQAAACAiRHoAQAAABMj0AMAAAAmRqAHAAAATIxADwAAAJgYgR4AAAAwMQI9AAAAYGIEegAAAMDECPQAAACAiRHoAQAAABMLNroA1M/pdKqmvNLoMposOCJMFovF6DIChtlef4ljAJ5FHwDM1w/oA8Yh0PupmvJK/afbdUaX0WQTN7+ikMhwo8sIGGZ7/SWOAXgWfQAwXz+gDxiHITcAAACAiRHoAQAAABMj0AMAAAAmRqAHAAAATIxADwAAAJgYs9wgYJWWVen9ZUVamW/XqnV2rS88oMMVNbJapJioUGWkxKpfWpwG9WmrC85sr6Agvt8GmuKdZfrgqyKtWmfXynV2bdtxSJXVtQoJtiq+VbjO6BmnfmnxGjogUWekxRtdrsdVVdfqo+XFWrFml1at26O1m/bp0OFqOSVFRQQrvXtr9esZr4G943Xx4CSFh/GREGj2HqjU+8u2H3sf/OnngyqvrFGQ1aLWMWHq2yNO/dLiNPj0djr3jARZrYE15WBtrUOf59r09Q87tWqdXT9s2KsDh6rkcEoRYUFK7dxS/dPj1T8tXpec21Eto0ONLhkedri8Ru8v267c/N1atW6PCrbuV1l5jSySoluEqHdKa/VPa6OzMtpo+FkdFBJizizAuzcCzrrN+/R0doFefm+TSsuq611n38EqbdtxSO998bMkqVNiC0298jRNubKH2sZF+LJceJjT6VTOihI9nV2g/36+TbW1znrX27O/UhsKDyjrgy2SpP7p8bptfE9NuDhZEeHmfmv8ueSQFr6+Xs+/tUG79lbUu86B0ioV7zqspV8XS5LiWoXp/y5L1a3jeqprUrQvy4UXrMzfraezC5T1wRZVVNbWu86+g1XaUlSqtz4tlCSldm6pW8edphvHpqhVTJgPq/W8Pfsr9MJbG/XM6+u1tbi03nUOlEo2e7m+XGWTJLWICNbEUd10+4Q0ZaTG+rJceMHGwgP6x6ICvfTfn7S/tKredfaXVmm7rUzvLyuSJLVvG6mpV/bQ1KtOU2KbSF+We8osTqez/k87GKr6cIXLc88mDErXxW/NrrudsnId3FKizW98qYIX3pez1uHJMo/xh7lnyytqdP/f8/SXf6+Vw+HeYR0TFaInZ52lmy5LMfTmGO68/hLHwI5dZZr60HIt+XK729tI6RyjF2efq3POSPBgZb5RW+vQX1/J1x8XrGowxJ1MaIhVD/zmdGXelKHgYOPOVNEH3HOgtEoz563QC29vdHsbbWPD9cx9g3X5BV08V5iPOJ1Ovfr+Zv12zjfad7D+ENcU065J02Mz+qtFZIgHq3MdWcB1lVW1+tPC7/XYiz82eELnZFpEBOuJ3w3ULVefZppfrcx9Ggr12vLWMhXl5EkWiyLatFL3q4do4Owb1TKlg76ZtdDo8rwib51d1979uTYUHjil7Rw8VK3JDyzT60u36uVHzlObWHOerW+Ox8BrH2zWrQ9/3eCZmKb6adtBnXfTEt1xXboev3OgoaHWFYXFpbr27s/1zQ+7Tmk7VdUO/eGpVXrr023Kmnu+Ujq39FCFvtUc+8DnuSWadO8XKtpZdkrb2bW3Qlfc+akmXJysZx8YrOgW5hiGsu9gpf7v/mV6J2fbKW9rQdY6vb9su/4z53yd1aetB6rzvebYB/I37dOEzM+0dtO+U9pOWXmNbnvka72+dKtemTNE7du28FCF3mOOTyq4ZM+ardry5jJteeNL5f/jXS0Zda/Kiu1KvfYChcXFGF2ex32xskRD/u/9Uw7zx/tweZHOvXGJimyn9sFolOZ2DPztlbW65vefn3KYP8rplJ78d76umvmpKqvcO9PtS+u37tfgGxafcpg/3qp1dp1zw2L9sGGPx7bpS82tD7z9aaEu+s2Hpxzmj/fah1s0fMqH2nug0mPb9Jade8o15KYlHgnzR20pKtWwKe/ro+VFHtumLzW3PrDix10654bFpxzmj/dZbonOuWGJthbVP2zLnxDom4Ga8krtzvtJFqtVMZ3bGV2OR323ZrdG3b5Uhw7XP1b+VGwoPKDhUz/Qrj3lHt+2rwXyMfDMogLd8fgKr2z7v5/9rIl3f65aL/087Qlbi0p1wZQPtGPXYY9ve9feCo2Y+qE2bN3v8W37WiD3gQ+Wbdf4WZ+pqtrzx+l3a3frkts+8sp7rKfsO1ipC2/5UGt+8lyQO6q8olaX3fGJvlxZ4vFt+1og94EfNuzRRbd+5LGTOsfbWnz0Pda/T/AR6JuJ6C5HOm/l/kMGV+I5B0qrdOXvPlVZeY3X9rGh8IBuuv9LBcKlJoF4DKzM361pc77x6j7e/KRQ8/61xqv7cFdNjUPjZuV4JcwftXtfha6amWOKXypOJhD7QPHOMl1z9+eqrvHel84Va3brjrnfem37p+qWh5brx417vbb9ispaXX1Xjuz76r/A3EwCsQ+UHa7WFXd+qgNeCPNHbS0u1cR7vnD7+jxfINAHoOCIUIXFRissLkatTuukMx+9WXG9k7U77ycd3GL+swxH/W7eCpd/Xs7NGqPtH09QbtaYJrd5f1mRXn53k6vlGao5HAOVVbW68Y9funzRkzvHwP1/z9O6zZ4/+3eq5v1rjVbm211q487zX7tpnx5+drWL1RmrOfQBp9OpKbO/cjnIuHMMvPD2Rr8cevL60q16felWl9q48/x37a3Qb7188sDTmkMfkKR756/UFheHxLhzDHyeW6JnFhW4Wp7PNIuLYu12ux5//HG99dZbKioqUps2bXTFFVfo0Ucf1fTp0/Xiiy/qqaee0rRp04wu1SNOz5yg0zMn1HmscMm3WnHP8wZV5HmffbdDL7oxi0NCfKSS2rl+ccuMx7/VqPM6Kr61sVfvN1VzOAYe/+ePyt+83+V27hwDVdUO3fzgV1r+8qWGzn50vM3bD+qBp/NcbuduH5jzwg8af1FX9Uoxx3R+zaEPvPbBFn3wlesh291j4OYHv9JPi6/ym/sVHDxUpdsf+drldu4+/9c+3KLrLu2mUed1crmtEZpDH/huzW7Nf3Wdy+3cPQYyn8zVZcM6++VFsgF/hn716tXq3bu3nnjiCdlsNqWlpam6ulrz58/X+PHjVVBw5NtW3759jS3Ugzb8e6k+GjdbH098RCv/9G9V7C1Vi8Q41Vb+chZnyD/u1JCFv6vTLrRVlMatfk7JV5zr65Jd9peX1/p0fwdKq/TPd9yfBs7XAv0YqKyq1VNuvImfim9+2KUVP+726T4b8/fX1nllzHRDamudeirLt3/zUxHofcDpdPp8KFjRzjK98XGhT/fZmFcWb9JuHw+D8fVnz6kI9D4gSU/+27evR1l5jZ59Y4NP99lUAR3o7Xa7Ro8eLZvNppkzZ6qkpER5eXmy2WyaO3eulixZotzcXFksFmVkZBhdrscc3GJTybI1Ks75Xmuf/q8+veExxfftpkFzbzm2zjf3PKe2A3qo62WDjz121qM3a9d367XlrWVGlN1khcWlWrLM/XnG3fWPRev9evzc8QL9GHjj460+/yCXpKez/ePn1sPlNfrnOz/5fL+vLN6s/Qf9f8YTKfD7QO5au/IKfD8D0d9f848vdU6nU383oD/mfFeigi37fb5fdwR6H7DZD+vNTwp9vt9n39ygah+eTGmqgA7006dPV1FRkaZNm6Z58+YpOvqXux9mZmaqT58+qqmpUZcuXRQTE3hTOB21e+UGbX7jS3W9bLDa9O8hSaraf0hfz/yHznzkZkW0a63Oo85Swtnp+ub3/j837cvvbZIR16huLS49dkdBswm0Y+Cl//o+zEpS9kdbVOYHs328k7PNK7M5nMzhihqXxyv7i0DrA0b9Yvjtj7u13g9mPVqZb9c6N4bcecJL/zXPr7XHC7Q+8J8lm716MXhDSnYf1kdf+9/1JAEb6AsKCpSdna34+HjNmTOn3nX69esnSerTp0+dx7du3aoxY8YoOjparVu31vXXX689e8w5F/NRPzz5hhw1tTp91vhjjxV/tlqF732t8xZM11mPTdHXM/+hyn3+f+X7tz96bq5tM+37VAXKMeBwOLVijTFDX6qqHVq9wXuzaTTVt2uMOw6N+tt7QqD0AcngY8APhp4Z+zlg/PN3V0D1AQOPAX98HwzYQJ+VlSWHw6GJEycqKiqq3nUiIo7cBfT4QF9aWqqhQ4eqqKhIWVlZevbZZ7Vs2TJdeumlcjj87yeWpiottGnrf5er/XkZantmz2OPr5z9sqK7Jqg453sVfer6BXa+5nQ6tWqda7N6eJKR+z5VgXIMbPr5oErLjDtL7g/HgKF9oMD45++uQOkDFZU1Hr15jqv84RhYtc64k2zfr99jmuGXvxYofUAy9hjwh8+BXwvYQJ+TkyNJGjp0aIPrFBUd+cnk+ED/7LPPqri4WO+8844uvfRSXX311Xr11Vf17bff6t133/Vu0V7249/elKO27jfzmvJKHdq2S/sKfjawsqbbvbdCu/YaNxfwjxv9b+pCVwTCMbDmJ2PPkHtzvuum8sYNdJpq7aZ9pg0zUmD0gQ2FB1RTY9xr4B99wLgaSsuqVbjD/+8c2pBA6AOHDldra7Fxr4E/9IFfszgD4Y459ejYsaOKior0/fff1zuDTU1NjRITE2W327V582YlJydL+uULwGeffVZn/W7duun888/XCy+84HIt/fv3l83m2tjrEKdVDzgGurwvd1z85mxt/3iV8p9x/wvLbOt3qrZ4/xeMGmusdraa0eDy3KwxSoiPbHB5QnyEgoOsqql1yGZv+A6wNvthDbjmxL+H1XFQifv/7FrRbvDl6y+Z6xgoC+2r/VGX17vsZK+/dOrHQETlWsWWve5a0R7klLQjdnaDy73dByQpce/Dssq7v5LQBxpWGdxJ9pjJ9S7zRR8IqdmhtgeNHWNtazldtUFx9S7zVB+QGv4btD3wtEJqd7pWtBvIAvWrtUTJ1npWg8u9/T5ocVSo/f76h3OfioSEBK1cudKttv4xmawXlJUdueFQeXn9L1R2drbsdruio6PVtWvXY4+vW7dOV1999Qnrp6ena906967ut9lsKi4udqlNqCVIMtGdmXeU7FCV0wd3kgytllo1vLipc8sGB1ndmoPWUet0+bV0h9lef8mHx0DrLlL9o+hcmlvY3WOgvKLCJ8dAoxqZCt7bfUCSSkpKJId3Z7uhDzQiMlJqYB4HX/SB6uoa4/tAi1opqP5FvugDu3btlir4LPg1n/WB4JZS64YXe/sYcDplfB/4lYAN9AkJCdq3b5/y8vI0aNCgOstKSko0a9aRb3YZGRl1bhSzb98+tWrV6oTtxcbGasMG9+YeTUhIcLlNiNMqmWjIfvvE9j76Vh6txn7rsNkPN9relW/l9Qmy1iqhQ4emlHpKzPb6S747Bg6HRqmhAScne/2lUz8GIsOD1NoHx0Bjdjir5LSE1rvM231ATofaJ7aRRd79cZc+0LCqoFZq6JI8X/SB0GCn2hjcB3YGOVTTwDJP9YHGttW2TWuF+OC6OrP1A1/1AYclTI3d69bb74NWS7USvdAH3MmLRwXskJvp06frqaeeUseOHfXJJ58oNTVVkpSbm6tJkyZpy5Ytqq6u1u23364FCxYcaxcaGqrMzEw9/PDDdbZ344036ptvvnE71Luq+nCF/tPtOp/syxMmbn5FIZHev4uqw+FU63P+rYOH3Pu5f/vHE5TUroWKdpap44jXXG4/6ryOWrzgQrf27Qqzvf6S746BHzbsUd+r33G7/akeA4/d0V+//78+J1/Ri84Y946+X+/eBWGn+vx7dGmp9e9e5da+XUEfaFhpWZVanv1vt6fvPdVj4OYrUvXcg8bedGj8rBwt+si9KVRP9fmHhQap9JvrFRLi/csQzdYPfNUHJClx2Ksn/ULWkFM9Bs4fkKjPXrjErX17S8BeFJuZmam4uDht375d6enp6t27t1JSUjRw4EAlJydr2LBhkk6csrJ169bav3//Cdvbu3evYmPNccvzQGa1WnRGz3jD9t/PwH3jiLTk1goLbeC3dh/ol2b8MdAvrf6xw77Zt/HPv7mLbhGq1M4tDdu/PxwDRr4XZ6S29kmYR+OMPA779TTuPbghAXtEJiUladmyZRo1apTCw8NVWFio2NhYLVy4UEuWLNHGjUduDPHrQN+zZ896x8qvW7dOPXv2POFx+N6AdOM68YBexn+QNXchIVadfpoxX64tFhn6hfKoAb3aGLbv/gb2P/zCyPcifzgGjHz+A9KN63/4hZFZwB/6wK8FbKCXjoTzxYsXq7S0VKWlpVqxYoWmTp2qsrIyFRYWymq1qlevXnXaXHrppfrqq6+OTWkpSStWrNDmzZs1evRoXz8F1OPaS7oZst/41uEaMcjYcaM4wqhj4JJzOyq2ZZgh+z7eFRd0MeRXiqAgi8Zd2PXkK8LrJl7S3ZD99ujS0i/O0J97RoI6tG18Nh9vmTjKmPcf1HXNSGNeh+gWIbp0SCdD9t2YgA70DcnPz5fT6VRKSooiI+u+IUydOlWJiYkaO3asFi9erDfeeEPXXHONBg4cqLFjxxpUMY7X97Q4DerT1uf7nXx5qqFDPfCL60enKDLc99f03zruNJ/vsz7xrcM1/iLfB+vLhnZWBzdnBYFnXXh2ByUnRft8v7eOO63ORBJGCQ626parfd8f+/SINeTzBydK7dJSIwa19/l+bxiToqjIEJ/v92SaZaBfs2aNpBOH20hSTEyMcnJylJiYqAkTJujmm2/W2WefrcWLF8tqbZZ/Lr80/do0n+4vJNiqW67yjzAHqWV0qG4cm+LTfXbvFKOLByf5dJ+N+a2P+4BR+0T9rFaLpl3j29cjukWIbhjj237XmJuv6KHwMN+eZPntNWl+8YUGR0y/Nt2n+7NaLbptvH8Ov26WCbWxQC8duYnU4sWLdejQIe3fv1+vvPKK2rRhzJw/GX9xsk+/md93S191NeBsGBr2p2n9lBAf4bP9PXv/YAUF+c9bZv/0Nj79xeD60d01pH+iz/aHk5s2IU19fXg9yV/uOlOtYowfcnZUYptIPfLbfj7b3zmnt9NNl6X6bH84uVHnddRlwzr7bH+zbuytnsmtfLY/VwTsPPSNOVmgD2SdR52lxHN7K/eBlzTkmTvVMiVJtRVVqrAf0Dd3P6fSQtfuaGsUi8Wi5x88V72ueEulZU2fwvLonLJNmav5qNNPi9PdBk9T6A1HjwVHda06XdRfUR3b6t3hd2lvfuEJ63YfP1Tn/PV25dw0Vz9/mOv7YusR2zJMC+8brLEzPnGpnTvHwG3je2roQN//tHsyc+8coPe/KtK2HYea3Mad55/YJlJ//f1ZLtdnNl3GnK2+d42To/LIe0pQRJiiO7fTa70nq2p/0//GvhISYtVLfzpP/a/5r2pqmj6HpTvHwIVnd9DkK/wvzM6YmK43PynU16t3NbmNO88/IjxILz50rqxWc52dDwoLOaXPen/vExaLRf/449n6cpVNew80/WZ37hwDPZNb6cFbT3e5Rl9ploE+JyfH6BIM0+mSM7X59c8lSRv+/bGKc76XJJ1208Ua/Odb9eGVDxhYnWs6JUbpxdnnatysnCbPx9zQrewbEtsyTP957PyAnKLs6LFQW1GltU+/o0v++3C960UltVHqxOHatdI392BwxZihnXXHden66yv5TW7j6jHQLy1ec+8c4GppPhHdIlSvzR2qYVPeV3lF0+7O6OrzDw2x6j9zhqi1H52Z9ZaOFw3Qd/f/Uzs+/0GSlP6bMUoYlOYXwaUhfXrE6a+ZZ2nao980uY2rx0CnxBZ6cfa5fjnUJCjIqn8/OkRnT1qsnXuaNie5q89fkp7542ClGDhV6Kk4lc96M/SJhPhIvfzIeRo74xPV1jYtDLh6DMREhejVx85XeJj/xmb/rQxuCY2J1NjPnlRQeKgO77DLGhai6E7ttPmNL/TN3c+p3YAe+mrGAjlrao91cEnanfeTet06xsDK3XPVhV31wuFzNfmBZW7fZKUhrWNC9dEzF/ntz2uNaew4+PquZ2QJDqpzLDTIYtHZf75VK/74ggY8cIPvnoAL/nzXmSorr9Fzb3r+C0efHrH68B8X+eUFUEed1aet/vu3ERo74+Mmh/qmCg2x6vV5w/zy1wlXudInjkq5dpjyHv2PgVU3ze0T0lRaVq17/rbS49vu0DZSHy8c6dcXQycnxejjhRfrgikfaPe+Co9vf8G9g3S9H1074IrayuoGP+sDqU+MOq+TXnl0iK6794smh/qmim4RoiULLlTf0/xv7vnjEegDTNXBw9ry9jJVl1XoxyffUPvz+yhj+hX6+q5n1H5IH+3K3VBvgEu7+RL9/JF/DKVw1U2XpSo6MkSTH1zm9h1kf617pxi99ZcL1DvVnDcTa+w4kKTEwb0aPBaOl37LaO3KXa89P27xRdlusVotWnj/YLWLi9Ajz6322Be7EYPaK/uJYaY4Mz1iUActfeZijc/8TDt2Nf0n5Ma0jQ3Xq48N1QVnmT/MS673iTb9eyisZQtt/3iVkWU32d2T+6h1TJjuePxbVVR65otd39Ni9faTw9Wlg/9fP9Q7NVbLXhqly+/8VAVb9ntkmy0igvXMfYN13aXGTBHqDcd/1gdan5gwspuiIkN0/R++0L6DVR7ZZuf2UXrzLxf4xVStJ0OgD0Cxvbqq4Pn3JUlxGd20d+2R22N3uniAtn3w3Qnr955+haK7JOjrcbN9WqcnXXVhV52Z0UZTHvxKH31d7PZ2LJYjYzIf+W1/RUb4b/e45L1HFJNc/wWK746YpcM79jR4HEgNHwvHa9WjozqPOlMfXH6/5wr3EovFoj9N66dLzk3SjX9cpo3bDri9rajIEP35roGacmUPvxxi0JBzzkjQ2reu0J2Pr9C/3v3plLY14eJkPXXPIMW39s0t3D3B030i5Zph2vT6F3LWOrxbuAfdcvVpOr9/gm66f5m++aHpY8p/LTjYovumnq57Jvcx1XDDHl1bKS97rGY/870e/+caORzuf7s/f0CiXpx9rt9PhtCU4/6o+j7rA61PXDqkk/LfvlK/+dNyvfv5z6e0rVvHnaa5dw5QdItQD1XnXf6bWOC22PQuxzplXEaytv/v23j78/tq5Z9eqbNu+m/GqPMlZ2rpuNmqLffMN1qjdEyI0gf/uEhvflyop7LW6ctVTb/ANyTYqiuHd9Gdk3ppYG//n9Ho/dF/OOk6DR0HUv3Hwq+1O7Onojq21ZVfPyVJimjTSoOe+I0i2rbWhpeXnkL13jOoTzutfv0yLXx9vZ5eVKCfth1scttW0aG66bIU3XFdL3VKjPJild7TOiZMLz18nq4f3V1/+0++Fn+5vcmhxmKRLh6cpBkT03WRH03P2VSe7BPBkeHqOuZsLR75e+8U60U9urbSspdG6d+LN2lBVoFWrbM3uW1EeJCuHdlNd07qpfTurb1YpfeEhwVrzowBGndhVz3573xlf7RFVdVND6Bn922raRPSNP7iZFNcANuU415q+LM+EPtEYptIvfO34Xrv8581/9V1+nTFjia3DQqy6PJhnXXHdb00+PR2XqzS8wj0ASYyIVZyOnXYtleSFNuzs37825uKPz1FB34qVs3hX8YXpt1yqbpePlhLxz2kqoOe+ZneaBaLRVdd2FVXXdhVa3/aq9c+3KKV+XatKtgj+6/GVnZpH6V+afE6K6Otrru0mxLijbnroDc0dBxIqvdYqM+Gl5fWCe4Xvzlb655b7Dez3DQkIjxYd0zqpekT0/Xpih1a/MXPWlWwR98X7NHhipo66/ZOaa0zesbr/AEJGndhsl//KuOKYWe217Az22vbjlK9snizvlu7W6vW2VX8q+E4iW0i1a9nnAb0aqOJo7qpW8cYgyr2Plf6RNexZ2vvukId2NT0IOBPgoKsunFsqm4cm6rctbv1+tKtWrXOrryCPdpfWvfETUrnGPXrGa/Bp7fTxFHdTDHErClO7xmvlx8doj/fNVD/WbJZ3/y4S6vW2bV5e2md9WJbhqlfWpz6pcVr/EXJfj9O2h0NfdYHcp+wWCwaM7SzxgztrPVb9yvr/S3KzT/yPrhrb93Pvk6JLdQvLV5n9m6j60Z19+vrRRoTGJ9eOCa2V9c6P5lVHSzTaTdcpMq9pfr5w19+OotMjNXAB2/UwUKbLn7jQUlSbVWNloy6x9cle02vlFg9nHJkDLzT6dTeA5VKv/xN7dxTocT4CG39cLzBFXpPQ8fB13c9o84jB9Y5FgY9PlVJF/RTRNtWGpH1R1UfKtdbZ//WiLI9ymq1aMSgDhoxqIMkqbbWoT37K5Vx1VvauadC7dtE6Mc3rzC4Su/q3D5af5ja99i/9x+sVM+xb8j2vz6w49NrjCvOx1zpEynXXKCN/3FtOlR/NaBXGw3odeRXR6fTKfu+CvW+8kgfSGwToY3vXW1whd7VJjZCd0zqpTv+9+9Dh6uVMmqRbHsqlPC/PmCmoXWuauyzvrn0idO6ttLs28+QdKQP7DtYpfTLfnkf3PbRBIMr9AwCfYAp+mSVij755YKVxSPvliSN/fxJfXTcNFWHS/bqpcSrfF6fUSwWi+JahSv4fzcGMsNPqaeioeNAkpIu7F/nWPgm89kmbdNMU5rWJyjIqrZxEceOgUD+EG9Iq5iwYzfHCvQ+8Guu9In3xzRtGIPZWCwWtYn9pQ9Ym2EfiIoMOdYHgqyWgH8faOyzvjn2CYvFotiWgfk+SKBvJv57/p1GlwA/wbEA1EWfAOqiT5iPeS5fBwAAAHACAj0AAABgYgR6AAAAwMQYQ++ngiPCNHFz4/OE+5PgiMCY6sxfmO31lzgG4Fn0AcB8/YA+YBwCvZ+yWCwKiTTPXRrhWbz+aO7oAwD9AE3HkBsAAADAxAj0AAAAgIkR6AEAAAATI9ADAAAAJkagBwAAAEyMQA8AAACYGIEeAAAAMDECPQAAAGBiBHoAAADAxAj0AAAAgIkR6AEAAAATI9ADAAAAJkagBwAAAEyMQA8AAACYGIEeAAAAMDECPQAAAGBiBHoAAADAxAj0AAAAgIkFG10A6ud0OqXKSqPLaLqwMFksFqOrAAAAaHYI9P6qslI1424wuoomC170Lyk83OgyAAAAmh2G3AAAAAAmRqAHAAAATIxADwAAAJgYgR4AAAAwMQI9AAAAYGIEegAAAMDECPQAAACAiRHoAQAAABMj0AMAAAAmRqAHAAAATIxADwAAAJgYgR4AAAAwsWYR6O12uzIzM9W9e3eFh4erY8eOmjFjhsrKyjR58mRZLBYtWLDA6DIBAAAAlwV8oF+9erV69+6tJ554QjabTWlpaaqurtb8+fM1fvx4FRQUSJL69u1rbKFe8oV9l0LfW6S/bF7f4Dqh7y3SZSuW+bAq3zpcXqMX396o4VM+0M495ZKkPQcq9cGy7XI4nAZXB3hfdbVDb368VZdOW3qsD9j3V+i1DzarqrrW4OoAAKcq2OgCvMlut2v06NGy2WyaOXOmHnjgAUVHR0uSHn/8cf3+979XcHCwLBaLMjIyDK4W3vDsG+v1+ydztb+0qs7jFZW1uuT2perWMVr/eniIBp/ezqAKAe9a/MXPuuVPy7Vj1+E6j1dWOXTN7z9Xu7gILbhnkK66sKtBFQIATlVAn6GfPn26ioqKNG3aNM2bN+9YmJekzMxM9enTRzU1NerSpYtiYmIMrBTeMOf5H3TLQ8tPCPPH27y9VBdMeV+ffrvDh5UBvpH94RaNnfHJCWH+eDv3lGvcrBz9852NPqwMAOBJARvoCwoKlJ2drfj4eM2ZM6fedfr16ydJ6tOnz7HHjn4BGDhwoMLCwmSxWHxSLzzro+VFunf+yiatW1nl0BW/+0Q2e8OhBzCbdZv36fo/fNGkYWVOpzRl9lfKW2f3QWUAAE8L2ECflZUlh8OhiRMnKioqqt51IiIiJNUN9Js2bdKbb76phIQEDRgwwCe1+sLh2lrZKyvr/S8Q/fnlNS6tf/BQtZ5/a4OXqgF8b0HWOlVVO5q8fm2tU/NfXefFigAA3hKwY+hzcnIkSUOHDm1wnaKiIkl1A/15552nkpISSdKDDz6o5cuXe7FK33loQ74e2pBvdBk+sbHwgD7+xvUhNAtf36C7/6+PgoMD9nsumomDh6r078WbXG732odbNG/mQMW3DvdCVQAAbwnYQL9t2zZJUufOnetdXlNTcyysHx/orVbPh7n+/fvLZrO51CbCatW6voM8VsPNnZJ1ZfuO9S4b+e0Xp7z91NRUlTuafjbQm8pC+0pRl7vcrmhnmZKS+yjYsc/zRcFvlLT6nWRtqRJbiZKSkowuxysqgzvpUMxk19tV1eq0My5WeLXrXwZgHs2hDzSmuT9/+O8xkJCQoJUrmzZc+NcCNtCXlZVJksrLy+tdnp2dLbvdrujoaHXt6t3ZHWw2m4qLi11qExkUJPX1XA3do6J0QRvvzeSyY8cOHa71k+nv4npI9Y+yOqmduw9IFa69VjCZ6FrJKjlqa13ul6YR1Vpy8zr/PXsPSQcD9O+CI5pDH2hMc3/+CMhjIGADfUJCgvbt26e8vDwNGlT3THdJSYlmzZolScrIyPD6ha8JCQkut4nwwi8F3tS+fXs/OkMfrv1utm3XpqWC/eR5wDtKgoLkkGQNClJihw5Gl+MVlcFRcvfy1rjYFgqPDsy/C45oDn2gMc39+cN/jwF38uJRARvohw8froKCAs2dO1cjRoxQamqqJCk3N1eTJk2S3X7k484XN5Ry5+cTZ0WFasbd4IVqvGPjxo2yhPvHuNvC4lIlX7JIThfvGdW1Q7Q2rf5RViszGwWypOFZKt51WIkJiSpaW2R0OV5xuLxG7Ydn6UAjU7bWJzI8WJu+WqpWMWFeqgz+oDn0gcY09+ePwDwGzHUa2AWZmZmKi4vT9u3blZ6ert69eyslJUUDBw5UcnKyhg0bJqnu+HkEhi4dojXq3PqvF2jMreNOI8wjIERGBOumsSkut5s4qhthHgBMKGADfVJSkpYtW6ZRo0YpPDxchYWFio2N1cKFC7VkyRJt3HjkJioE+sB014295cpIqvjW4brpslTvFQT42O0T0hQZ3vQfYcNCrZoxMd2LFQEAvCVgA70k9ezZU4sXL1ZpaalKS0u1YsUKTZ06VWVlZSosLJTValWvXr2MLhNeMKR/ohbc07RZgqIig/Xu/OFM1YeA0r1TjBbNG6rQkJO/zQcFWfTKo+crvXtrH1QGAPC0gB1D35j8/Hw5nU6lpqYqMjLyhOVvvPGGJGndunV1/t2lSxf179/fd4V6wJD4tqoaPa7RdU623Kxum5CmuFbhmjlvhYp31X8X2NNPi9OLD52rvqfF+bg6wPtGnddJSxderFseWq4NhQfqXad7pxj9/d5BuvBs/5m6DQDgmmYZ6NesOXIX0YaG21x99dX1/vuGG27QSy+95NXa4FnjL07WlcO76L0vftZ/lmyWbU+5goMs6tYxRlOu6KEzM9p4fZYjwEhD+ieq4L9X6rPvSvTP/27UzyVlcjqdSmrXQjeMSdGIQR24dgQATI5AXw+nq9OjwK8FB1t1+QVddPkFXYwuBTCExWLRsDPba9iZ7Y0uBQDgBQE9hr4hJwv0AAAAgFk0yzP0OTk5RpcAAAAAeESzPEMPAAAABAoCPQAAAGBiBHoAAADAxAj0AAAAgIkR6AEAAAATI9ADAAAAJkagBwAAAEyMQA8AAACYGIEeAAAAMDECPQAAAGBiBHoAAADAxIKNLgANCAtT8KJ/GV1F04WFGV0BAABAs0Sg91MWi0UKDze6DAAAAPg5htwAAAAAJkagBwAAAEyMQA8AAACYGIEeAAAAMDECPQAAAGBiBHoAAADAxAj0AAAAgIkR6AEAAAATI9ADAAAAJkagBwAAAEyMQA8AAACYGIEeAAAAMDECPQAAAGBiBHoAAADAxAj0AAAAgIkR6AEAAAATI9ADAAAAJkagBwAAAEws2OgCUD+n0ylVVhpdRtOFhclisRhdBQAAQLNDoPdXlZWqGXeD0VU0WfCif0nh4UaXAQAA0Oww5AYAAAAwMQI9AAAAYGIEegAAAMDECPQAAACAiRHoAQAAABMj0AMAAAAmRqAHAAAATIxADwAAAJgYgR4AAAAwMQI9AAAAYGIEegAAAMDECPQAAACAiRHoAQAAABNrFoHebrcrMzNT3bt3V3h4uDp27KgZM2aorKxMkydPlsVi0YIFC4wu0yu+sO9S6HuL9JfN6xtcJ/S9RbpsxTIfVgVfczqd+jy3RAuy1umJf/6of76zUbv2lBtdlk/9XHJIz72xXqVl1ZKkqupaOZ1Og6sC4Cu1tQ59+FWRDh0+8h5wuLxG+w9WGlwV4BnBRhfgbatXr9bIkSNls9nUokULpaWlaceOHZo/f742b96svXv3SpL69u1rbKGAF9TWOvSPRev199fWaf3WA3WWhQRbdfWFXXXP5Az1Sok1qELv+/aHXXrsxR/03hfb5XD8EuB376tUv/H/1YyJ6bp+THdZLBYDqwTgLZVVtXry32v1zOvrtW3HoWOP7yutUvvhWZp4STfdc3MfJSfFGFglcGoC+gy93W7X6NGjZbPZNHPmTJWUlCgvL082m01z587VkiVLlJubK4vFooyMDKPLBTyqsqpWV83M0W/nfHNCmJek6hqHXn1/s8667j19tLzIgAq979Ulm3XujYv1389+rhPmj/p+/R7deN+Xmjr7q3qXAzC3g4eqdOEtH+qev62sE+aPKq+o1fNvbdTAa9/Vd2t2G1Ah4BkBHeinT5+uoqIiTZs2TfPmzVN0dPSxZZmZmerTp49qamrUpUsXxcTwzRyBZersr/ROzraTrldWXqMr7vxUeevsPqjKdz7+pljX//EL1dSePKg//9ZG3fO3XB9UBcBXHA6nrr4rR1+usp103T37K3XJ7R9p8/aDPqgM8LyADfQFBQXKzs5WfHy85syZU+86/fr1kyT16dPn2GNvvPGGrrzySnXu3FmRkZE67bTT9Ic//EGHDp34zd5MDtfWyl5ZWe9/CDzfF9j18nubmrz+4Yoa3ff3VV6syLecTqcyn/xOtU0I80f9+eW1KrKVebEqAL700fIiLf26uMnr79lfqTnP/+DFigDvCdgx9FlZWXI4HJo4caKioqLqXSciIkJS3UA/b948derUSY8++qiSkpK0evVqzZ49W1988YW+/PJLWa3m/A700IZ8PbQh3+gy4CP/WNTwRdAN+eCrIm0pOhgQ40i//XGXVq/f61Kb2lqnnntzg2bffoaXqgLgS09nF7jc5tUPNuuJmQPVOibMCxUB3hOwgT4nJ0eSNHTo0AbXKSo6Mm74+ED/3nvvqU2bNsf+PWTIELVp00YTJ07UV199pfPOO89LFXvXzZ2SdWX7jvUuG/ntFz6uBt7kdDqV9cEWN9pJiz7aqrsn9zn5yn7OnecvSVkfbibQAwHgQGmVlizb7nK78opavfvZz7phbIoXqgK8J2AD/bZtR8YOd+7cud7lNTU1Wr58uaS6gf74MH9U//79JUnFxU3/6e7X7W22k4/hO16E1ap1fQe5tb/6dI+K0gVt2nlse7+WmpqqcofDa9tH0zkVrEOx97nV9uG5T2nBAx96uCLf29viKimst8vtNm3dpaSkJC9UBPiPkla/k6wtVWIrCdjjvcbaWs5Wd7jVdvrMP+oPty/3bEHwK/7aBxISErRy5Uq32gZsoC8rOzIWtry8/rm2s7OzZbfbFR0dra5duza6rc8++0yS1LNnT7dqsdlsLn8ZiAwKkvq6tTtD7NixQ4dra40uA5KkIMnNWSjLSg+ozObeF1e/klQmufGLudNR7fYXd8A0omslq+SorQ3c4z2kXGrlXtOD+/fp4J4A/bvgiADsAwEb6BMSErRv3z7l5eVp0KC6Z7pLSko0a9YsSVJGRkaj808XFxfrvvvu08UXX+z2XPUJCQkut4kw2Vj99u3bc4bej9hq96k2qLXL7VpFVqlFhw5eqMi3DoaVq9SNdqHOfWoTAM8faExJUJAckqxBQUoM0OPdqSCVOCvktIS73DY2ukYR4YH5d8ER/toH3MmLRwVsoB8+fLgKCgo0d+5cjRgxQqmpqZKk3NxcTZo0SXb7kSn6Ggvphw4d0tixYxUaGqoXX3zR7Vrc+fnEWVGhmnE3uL1PX9u4caMs4a6/ccI7Hn1utf7wlGuz1kRFBuvnb15XdItQL1XlO9tth9Tl4kUuzy3/zJyJuumy2V6qCvAPScOzVLzrsBITElW0NjDvQSFJv53zjRZkrXOpTVK7Ftqa94mCg811Ug2uCcQ+ELBHbGZmpuLi4rR9+3alp6erd+/eSklJ0cCBA5WcnKxhw4ZJqjt+/njl5eUaPXq0tm7dqqVLlyoxMdGX5QOnZPIVPRQa4lr3vn50SkCEeUnqmBClMed3cqlN65hQjb8o2UsVAfC1W8ed5nKbW67uQZiHKQXsUZuUlKRly5Zp1KhRCg8PV2FhoWJjY7Vw4UItWbJEGzdulFR/oK+urtZVV12llStX6oMPPlBaWpqvywdOSbu4CD1z3+Amr98zuZUe/m0/L1bke0/dPUgd2kY2aV2r1aKXHxmiyIiA/dESaHbSurXWIy68r53dt63uusH1i+kBfxDQn149e/bU4sWLT3j80KFDKiwslNVqVa9eveosOzp3/aeffqr3339fAwcO9FW5XjEkvq2qRo9rdJ2TLYc53XRZqmpqHLr1ka8bvcHSGT3jtHjBhQE373JSQgt9/uIojbztI236ueG7P4aHBenVx87XpUNcO6MPwP/dc/ORk3YnG4I4dECi3nryAoWHBXQsQgBrlkdufn6+nE6nUlNTFRlZ9wze7bffrtdff1133323IiMj9e233x5b1q1bt3qntQT81ZSrTtOwM9tr4evr9cLbG7X3wC93Bj6vX4JuG99Tl1/QWaEhQQZW6T3dO8Xoh9cv12sfbtHfX1unvII9x5a1bxupKVf00JQre6hDuxYGVgnAWywWi+6d0ldjh3bWPxYV6OX3Nqm0rPrY8osHJ+m28T11yblJCgoK2EELaAYsTqfTtavGAsDzzz+vKVOmaNy4ccrOzq6zrEuXLsfmsP+1f/7zn7rxxht9UKH5LooNXvQvLor1c1XVtep04WvauadCCfERKsm51uiSfMrpdGrX3grtP1ipyIhgJcZHMlYWzdLRCwI7tI1U0SfXGF2OT5VX1GjnnnJVVTvUJjY84H6ZRNMEYh9olmfo16xZI6n+8fOFhYU+rgbwjdCQIAX/7wxUkLXhqVoDlcViUbu4CLWLizC6FAAGiQgPVpcO0UaXAXhcszw91VigBwAAAMykWZ6hz8nJMboEAAAAwCOa5Rl6AAAAIFAQ6AEAAAATI9ADAAAAJkagBwAAAEyMQA8AAACYGIEeAAAAMDECPQAAAGBiBHoAAADAxAj0AAAAgIkR6AEAAAATI9ADAAAAJhZsdAFoQFiYghf9y+gqmi4szOgKAAAAmiUCvZ+yWCxSeLjRZQAAAMDPMeQGAAAAMDECPQAAAGBiBHoAAADAxAj0AAAAgIkR6AEAAAATI9ADAAAAJkagBwAAAEyMQA8AAACYGIEeAAAAMDECPQAAAGBiBHoAAADAxAj0AAAAgIkR6AEAAAATI9ADAAAAJkagBwAAAEyMQA8AAACYGIEeAAAAMLFgowtA/ZxOp1RZaXQZTRcWJovFYnQVAAAAzQ6B3l9VVqpm3A1GV9FkwYv+JYWHG10GAABAs8OQGwAAAMDECPQAAACAiRHoAQAAABMj0AMAAAAmRqAHAAAATIxADwAAAJgYgR4AAAAwMQI9AAAAYGIEegAAAMDECPQAAACAiRHoAQAAABMj0AMAAAAmRqAHAAAATKxZBHq73a7MzEx1795d4eHh6tixo2bMmKGysjJNnjxZFotFCxYsMLpMAAC8qrbWIYfDKUlyOp0GVwP4nsPhDMg+EPCBfvXq1erdu7eeeOIJ2Ww2paWlqbq6WvPnz9f48eNVUFAgSerbt6+xhXrJF/ZdCn1vkf6yeX2D64S+t0iXrVjmw6oAAL7idDr1xcoSjZ+Vo/ABL6nEXi5J2rmnQo88u1o795QbXCHgfavX79HU2V8p+qyXj/UBm71cmX/5TluKDhpc3akL6EBvt9s1evRo2Ww2zZw5UyUlJcrLy5PNZtPcuXO1ZMkS5ebmymKxKCMjw+hyAQDwqNKyKo26fanO/7/3teijraqp+eWMZK3DqT8uWKVOF76mV5dsNrBKwHtqahy65aGvdPq4d/Tcmxt0uKLm2DKHU3ripTXqPup1zXn+B1OfsQ/oQD99+nQVFRVp2rRpmjdvnqKjo48ty8zMVJ8+fVRTU6MuXbooJibGwEoBAPCsisoajbp9qT74qqjR9aqqHZp4z+d6ZfEmH1UG+IbT6dSN932pZ9/YcJL1pHvnr9SfFq72TWFeELCBvqCgQNnZ2YqPj9ecOXPqXadfv36SpD59+hx7bNmyZRo+fLgSExMVFhampKSkOkNzAAAwgznP/6hleTubvP7kB5apZPdhL1YE+NZ/lmzWf1z49emBp/O04sddXqzIewI20GdlZcnhcGjixImKioqqd52IiAhJdQP9vn371Lt3b82fP19Lly7V3LlzlZ+fr0GDBqmoqPGzHP7scG2t7JWV9f4HAAgsVdW1evbNhq+dqr+NQ8+/1fiZTMBMFmStc7nN09nmPIEbbHQB3pKTkyNJGjp0aIPrHA3oxwf6MWPGaMyYMXXWGzBggHr06KE333xTM2bM8EK13vfQhnw9tCHf6DIAAD7w3uc/y2Z3/WLXha+v1x+m9JXVavFCVYDvrF6/RyvW7Ha5XfZHW/XX35+l1jFhXqjKewI20G/btk2S1Llz53qX19TUaPny5ZLqBvr6xMXFSZKCg937c/Xv3182m82lNhFWq9b1HeTW/upzc6dkXdm+Y73LRn77xSlvPzU1VeUOxylvB95V0up3krWlSmwlSkpKMrocAF5yMHyIFDnM5XbFuw4rqXN3WZ38egtzOxzaW4q6yuV2lVW16tH7HIXWlnihqsYlJCRo5cqVbrUN2EBfVlYmSSovr/8MRXZ2tux2u6Kjo9W1a9cTltfW1srhcGjbtm265557lJCQoHHjxrlVi81mU3FxsUttIoOCpL5u7a5e3aOidEGbdp7b4K/s2LFDh2trvbZ9eEh0rWSVHLW1Lh+TAEykXbkU6V7TkpLdUm2pZ+sBfK11F6n+Edcntdu+Tzpsrs/IgA30CQkJ2rdvn/Ly8jRoUN0z3SUlJZo1a5YkKSMjQxbLiT8tDhky5NgZ/O7duysnJ0dt2rRxuxZXRVjNdXlD+/btOUNvAiVBQXJIsgYFKbFDB6PLAeAlh8KCdMCdhk6H2ie0lkXM/AZzKw8J1V5XGzmdksWitnEtFNLa95+R7uTFowI20A8fPlwFBQWaO3euRowYodTUVElSbm6uJk2aJLvdLqnhG0q98MIL2r9/v7Zu3aonnnhCF154oZYvX65OnTq5XIs7P584KypUM+4Gl9sZZePGjbKEhxtdBk4iaXiWincdVmJCoorWmvcibwCNKywuVfIli+TqtNqXD++qt57c5p2iAB86XF6jDsOztL+0qumNLBb1TmmtH95YXe/JXn9mrtPALsjMzFRcXJy2b9+u9PR09e7dWykpKRo4cKCSk5M1bNiRsYUNjZ/v0aOHzjzzTE2YMEGffvqpSktL9fjjj/vyKQAA4JYuHaI16tz6r5tqzG3je3qhGsD3IiOCddNlKS63u218T9OFeSmAA31SUpKWLVumUaNGKTw8XIWFhYqNjdXChQu1ZMkSbdy4UdLJL4iVpFatWql79+7atImbbgAAzOGBW09XeFhQk9cfflZ7XXBmey9WBPjWnZN6qU3rpo8eSOvWSpMu7e7FirwnYAO9JPXs2VOLFy9WaWmpSktLtWLFCk2dOlVlZWUqLCyU1WpVr169TrqdXbt2acOGDerWrZsPqgYA4NT1T2+jRU8Ma1KoPyujjd748wWmPDMJNKRjQpTef/pCxbU6+RSU3TvF6IOnL1KLyBAfVOZ5ATuGvjH5+flyOp1KTU1VZGTdaQCuu+46de/eXX379lWrVq30008/6cknn1RwcLDuvPNOgyp235D4tqoa3fjsPCdbDgAwp9Hnd9KX/xyl2c98r/eXbT9hTH2b1uGacmUP/XFqX0WEN8tIgADXP72Nvn1ljB54Ok+vL92q6pq6E3hERQZr0qXd9dDt/RTvwtl8f9Mse++aNWsk1T/c5qyzztLLL7+sv/3tb6qoqFDHjh01dOhQ3XvvvQ3OaQ8AgL8a0KuNFi+4UFuLSvXWp4Xava9CYSFB6pncUpdf0EVhoU0flgOYUfdOMfrPY+frL7PO1OtLt2rHrsMKCrKoS/sojbuoq6JbhBpd4ikj0P/KtGnTNG3aNF+XBACAV3VNitbMG3obXQZgmHZxEZp2TZrRZXhFQI+hb0hjgR4AAAAwk2Z5hj4nJ8foEgAAAACPaJZn6AEAAIBAQaAHAAAATIxADwAAAJgYgR4AAAAwMQI9AAAAYGIEegAAAMDECPQAAACAiRHoAQAAABMj0AMAAAAmRqAHAAAATIxADwAAAJhYsNEFoAFhYQpe9C+jq2i6sDCjKwAAAGiWCPR+ymKxSOHhRpcBAAAAP8eQGwAAAMDECPQAAACAiRHoAQAAABMj0AMAAAAmRqAHAAAATIxADwAAAJgYgR4AAAAwMQI9AAAAYGIEegAAAMDECPQAAACAiRHoAQAAABMj0AMAAAAmRqAHAAAATIxADwAAAJgYgR4AAAAwMQI9AAAAYGIEegAAAMDECPQAAACAiRHoAQAAABMj0AMAAAAmRqAHAAAATIxADwAAAJgYgR4AAAAwMQI9AAAAYGIEegAAAMDECPQAAACAiRHoAQAAABMj0AMAAAAmRqAHAAAATIxADwAAAJgYgR4AAAAwMQI9AAAAYGIEegAAAMDEAj7Q2+12ZWZmqnv37goPD1fHjh01Y8YMlZWVafLkybJYLFqwYIHRZQIAAABuCTa6AG9avXq1Ro4cKZvNphYtWigtLU07duzQ/PnztXnzZu3du1eS1LdvX2MLBQAAANwUsGfo7Xa7Ro8eLZvNppkzZ6qkpER5eXmy2WyaO3eulixZotzcXFksFmVkZBhdLgAAAOCWgA3006dPV1FRkaZNm6Z58+YpOjr62LLMzEz16dNHNTU16tKli2JiYgysFAAAAHBfQAb6goICZWdnKz4+XnPmzKl3nX79+kmS+vTp0+B2Ro4cKYvFogcffNAbZQIAAACnLCADfVZWlhwOhyZOnKioqKh614mIiJDUcKBftGiRVq9e7a0SAQAAAI8IyECfk5MjSRo6dGiD6xQVFUmqP9AfPHhQd9xxh+bNm+edAgEAAAAPCchZbrZt2yZJ6ty5c73La2pqtHz5ckn1B/o//OEPSk1N1cSJE3Xdddedcj39+/eXzWY75e0Ap6qk1e8ka0uV2EqUlJRkdDkAAOB/EhIStHLlSrfaBmSgLysrkySVl5fXuzw7O1t2u13R0dHq2rVrnWUrV67Uc889p1WrVnmsHpvNpuLiYo9tD3BbdK1klRy1tRyTAAAEiIAM9AkJCdq3b5/y8vI0aNCgOstKSko0a9YsSVJGRoYsFsuxZbW1tbrllls0bdo0paene7QewB+UBAXJIckaFKTEDh2MLgcAAPzPqeTFgAz0w4cPV0FBgebOnasRI0YoNTVVkpSbm6tJkybJbrdLOvGGUgsWLNDOnTs9PquNuz+fAJ6WNDxLxbsOKzEhUUVri4wuBwAAeEBAXhSbmZmpuLg4bd++Xenp6erdu7dSUlI0cOBAJScna9iwYZLqjp+32+267777dP/996umpkb79+/X/v37JUkVFRXav3+/HA6HEU8HAAAAaFBABvqkpCQtW7ZMo0aNUnh4uAoLCxUbG6uFCxdqyZIl2rhxo6S6gb6oqEilpaW65ZZb1Lp162P/SdLcuXPVunVr/fzzz4Y8HwAAAKAhATnkRpJ69uypxYsXn/D4oUOHVFhYKKvVql69eh17vHv37vrss89OWH/o0KG64YYbdOONNzIWHgAAAH4nYAN9Q/Lz8+V0OpWamqrIyMhjj0dFRen888+vt02XLl0aXAYAAAAYKSCH3DRmzZo1khq+QywAAABgJs3uDL2rgd7pdHqzHAAAAOCUcIYeAAAAMLFmd4Y+JyfH6BIAAAAAj2l2Z+gBAACAQEKgBwAAAEyMQA8AAACYGIEeAAAAMDECPQAAAGBiBHoAAADAxAj0AAAAgIkR6AEAAAATI9ADAAAAJkagBwAAAEyMQA8AAACYGIEeAAAAMDECPQAAAGBiBHoAAADAxAj0AAAAgIkR6AEAAAATI9ADAAAAJkagBwAAAEyMQA8AAACYGIEeAAAAMDECPQAAAGBiBHoAAADAxAj0AAAAgIkR6AEAAAATI9ADAAAAJkagBwAAAEyMQA8AAACYGIEeAAAAMDECPQAAAGBiBHoAAADAxIKNLgD1czqdUmWl0WU0XViYLBaL0VUAAAA0OwR6f1VZqZpxNxhdRZMFL/qXFB5udBkAAADNDkNuAAAAABMj0AMAAAAmRqAHAAAATIxADwAAAJgYgR5oJpxO55HZk/73/wEAQGBglhsgQFVV1+rdz37WsjybVhXs0er1e1RWXiNJ2rG7XF0vzlb/9Hj1S4vX5cM6q0fXVsYWDAAA3GJxcqrOLzkrKkw3baWFaSv9wo5dZfr7awV6/q0N2rW3osntLjizvW6f0FOXDevMPQUAADARztADAcLpdOqFtzbqd/NWqLSs2uX2n67YoU9X7NAFZ7bXC7PPUef20V6oEgAAeBpj6IEAsPdApS65bammzP7KrTB/vE9X7FCvK97WK4s3eag6AADgTZyhB0xu555yDZ/ygdZu2uexbR46XK1J934h+74K3TGpl8e2CwAAPI8z9ICJHSit0kW/+dCjYf54dz6xQs+9sd4r2wYAAJ5BoAdMbPpj3+iHDXu9uo/bH/1GazZ6dx8AAMB9BHrApN77/Ge9/J5r49xzs8Zo+8cTlJs1psltqmscuvG+L1Vd7XC1RAAA4APNItDb7XZlZmaqe/fuCg8PV8eOHTVjxgyVlZVp8uTJslgsWrBggdFlesUX9l0KfW+R/rK54WEToe8t0mUrlvmwKt9zOJz6bs1uvfvZNi358met37rf6JJOSWVVrX7z8HKX2yXERyqpXQslxEe61C6vYI8WvLbO5f0BAADvC/iLYlevXq2RI0fKZrOpRYsWSktL044dOzR//nxt3rxZe/ceGUrQt29fYwuFVxw8VKXn3tygZ15fr00/H6yz7JzT2+m28T01/uJkWa3mmnf9jY+3aseuwz7d51OvrtP0a9MUFNQszgMAAGAaAf3JbLfbNXr0aNlsNs2cOVMlJSXKy8uTzWbT3LlztWTJEuXm5spisSgjI8PocuFh222HdPak93TXn787IcxL0lff79S1d3+ucXflqKKyxoAK3ff31wp8vs+txaX6cHmRz/cLAAAaF9CBfvr06SoqKtK0adM0b948RUf/cqOczMxM9enTRzU1NerSpYtiYmIMrBSetu9gpS76zUfK37z/pOu++UmhbrzvSzkc5rhp8ubtB/XND7sM2berY/YBAID3BWygLygoUHZ2tuLj4zVnzpx61+nXr58kqU+fPsce+/zzz2WxWE74z+xDcg7X1speWVnvf4HoLy+vVcGW/U1eP/vDrfp0xQ7vFeRB363Zbdi+c9faDds3AACoX8COoc/KypLD4dDEiRMVFRVV7zoRERGS6gb6o/7+97/rjDPOOPbvFi1aeKdQH3loQ74e2pBvdBk+UVVdq+fe3OByu6ezCzRiUAcvVORZK9cZF6q3Fpdqz/4KxbUKN6wGAABQV8AG+pycHEnS0KFDG1ynqOjIeOD6An1aWprOOuss7xRngJs7JevK9h3rXTby2y98XI13Lf26WDv3lLvc7t3Pf9beA5WKbRnmhao8J99LN5FqqnWb9+vcfgmG1gAAAH4RsIF+27ZtkqTOnTvXu7ympkbLlx+Z9q++QO9J/fv3l81mc6lNhNWqdX0HeayG7lFRuqBNO49t79dSU1NV7vCPecoPhQ2QWlzqcjuHw6meGYMUUmvM+PSm2h39f1JI/cd1btaYRqekTIiPOPa/2z+e0Oh+bPbDGnDNuyc8fvlVExRezVh6AAA8KSEhQStXrnSrbcAG+rKyMklSeXn9Z2qzs7Nlt9sVHR2trl27nrB8/PjxstvtiouL05gxY/TYY48pPj7erVpsNpuKi4tdahMZFCT1dWt3htixY4cO19YaXcYRsSmSmyOkdu3cKVX6+Vj65EoppP5FR+eZP5ngIGuT1qvPHrtdOuTa8QwAALwnYAN9QkKC9u3bp7y8PA0aVPdMd0lJiWbNmiVJysjIkMXyyxzkLVu21KxZs3TeeecpKipK33zzjebMmaNvv/1WK1euVHi462OHExJcH54QYTXX9crt27f3mzP0FSHSHncaOh1KbBMpq9O/x9HbQyxq6FJmm73xuekT4iMUHGRVTa1DNnvjw5Ia2lZ8XIzCWvr33wgAALNxJy8eFbCBfvjw4SooKNDcuXM1YsQIpaamSpJyc3M1adIk2e1HLiz89ew1p59+uk4//fRj/z7//PPVq1cvjRkzRllZWbrppptcrsWdn0+cFRWqGXeDy+2MsnHjRlnc+LLjDdXVDnW66LWTBtZfu2J4st588icvVeU5d81boT+/vLbeZfUNkTne9o8nKKldC9ns5eo44jW39r/hh8/8/joDAACaE3OdBnZBZmam4uLitH37dqWnp6t3795KSUnRwIEDlZycrGHDhklq2vj5Sy+9VC1atHB7XBN8KyTEqqlXnuZyu9vG9/RCNZ7XL829oV+e0LVDNGEeAAA/E7CBPikpScuWLdOoUaMUHh6uwsJCxcbGauHChVqyZIk2btwoybULYo8fmgP/9rvre6lX99ZNXn/iqG4admaiFyvynDMz2hi274G9jfsyAQAA6hewQ24kqWfPnlq8ePEJjx86dEiFhYWyWq3q1avXSbfz7rvvqqysTAMHDvRGmV41JL6tqkaPa3Sdky03o5bRofromYs08ral+nHj3kbXnXBxsl6Yfa5pvrAlJ8Vo8OnttPz7nT7f9w2jU3y+TwAA0LiADvQNyc/Pl9PpVGpqqiIj607xd9111yk5OVlnnHHGsYtiH3/8cfXt21cTJjQ+zR/8S/u2LbT85Uv1z3c26unsAq3feqDO8qEDEnXb+J66YngXWa3mCPNH3Taup88DfXJStC4anOTTfQIAgJML2CE3jVmzZo2k+ofbpKen6+2339b111+vkSNH6sUXX9SUKVP0+eefKzQ01Nel4hRFRYbot9ema907V2rVa2MV97/x3+1iw5XzwiW66sKupgvzknTliC5uTzvprunXppnybwUAQKBrlmfoGwv099xzj+655x5flwQvs1gsOiMtXuFhQZKk4GBzf5cNCw3Ss/cP1iW3L/XJ/gb0itftE9J8si8AAOAac6caNzUW6AGzGHluR910mWtj2m32wyraWXbS+eqPFxpi1Ut/Os/0X4IAAAhUzfIMfU5OjtElAB7x18yz9MOGvcoraNqttE42T319nrlvsNK6NX3GIAAA4FuccgNMLCYqVB/+4yL16RHrle0/dc8g3XRZqle2DQAAPINAD5hcm9gIff7CJbr0vI4e22ZMVIiy5p6vadcwbh4AAH9HoAcCQKuYML371Aj96+Hz1Cr61GZjunhwkvLfulITRnbzUHUAAMCbmuUYeiAQWSwWXT8mRRcNTtIziwr07JsbtGNX0y5+tViOBPnbxvfUqPM6muYmWwAAgEAPBJx2cRF64NYzdO/NffX+V9v1Vd5OrVpn1/fr92h/aZUkKSjIom5JMeqXFqd+afG6bFhndesYY3DlAADAHQR6IECFhFg1dmhnjR3a+dhjDodTtbVOhYQw2g4AgEBBoAeaEavVwt1eAQAIMJymAwAAAEyMQA8AAACYGIEeAAAAMDECPQAAAGBiXBTrr8LCFLzoX0ZX0XRhYUZXAAAA0CwR6P2UxWKRwsONLgMAAAB+jiE3AAAAgIkR6AEAAAATI9ADAAAAJkagBwAAAEyMQA8AAACYGIEeAAAAMDECPQAAAGBiBHoAAADAxAj0AAAAgIkR6AEAAAATI9ADAAAAJkagBwAAAEyMQA8AAACYGIEeAAAAMDECPQAAAGBiBHoAAADAxAj0AAAAgIkR6AEAAAATI9ADAAAAJkagBwAAAEyMQA8AAACYGIEeAAAAMDECPQAAAGBiBHoAAADAxIKNLgDwpn0HK5W3bo9WrbNrw7YD2nugUpK0v7RKT7+2Tv3S4pWRGquIcLoCAAAwJ4vT6XQaXQTgSbW1Dn24vEh/f61AHy4v0smO8IjwIF07sptuG99TZ6TF+6ZIAAAADyHQI6B88m2xfvOn5dq8vdSt9kMHJOrZB85R904xHq4MAADAOwj0CAilZVWa9ZdcLXx9/SlvKyI8SHOm99dvr02X1WrxQHUAAADeQ6CH6e3aU66Lbv1Qq9fv9eh2r7u0m16cfZ5CQrh2HAAA+C8CPUxtz/4KDblpifI37/fK9idcnKxX5gxRUBChHgAA+CdSCkzL4XDq6pk5XgvzkvTah1v04D++99r2AQAAThWBHqb1dHaBPsstcalNbtYYbf94gnKzxjS5zZwXftDK/N2ulgcAAOATAR/o7Xa7MjMz1b17d4WHh6tjx46aMWOGysrKNHnyZFksFi1YsMDoMuGirUWl+v2TuS63S4iPVFK7FkqIj2xym9pap266b5mqqmtd3h8AAIC3BfTddFavXq2RI0fKZrOpRYsWSktL044dOzR//nxt3rxZe/ceuYiyb9++xhYKl8371xodrqjx2f7Wbtqntz/dpvEXJ/tsnwAAAE0RsGfo7Xa7Ro8eLZvNppkzZ6qkpER5eXmy2WyaO3eulixZotzcXFksFmVkZBhdLlxQWlall9/b5PP9Pp1d4PN9AgAAnEzABvrp06erqKhI06ZN07x58xQdHX1sWWZmpvr06aOamhp16dJFMTHcRMhMsj7YokOHq32+3y9X2VSwZb/P9wsAANCYgAz0BQUFys7OVnx8vObMmVPvOv369ZMk9enT54Rlb7/9ts4++2y1aNFCLVu21ODBg5Wfn+/VmtF0n33n2oWwnvS5ixfhAgAAeFtABvqsrCw5HA5NnDhRUVFR9a4TEREh6cRAP3/+fI0bN07nnHOO3n33XWVlZWn48OEqLy/3et1omlUFduP2vc64fQMAANQnIC+KzcnJkSQNHTq0wXWKiook1Q30mzdv1qxZs/Tkk09q2rRpxx6/5JJLvFQpXHXwUJV+2nbQsP0b+WUCAACgPgEZ6Ldt2yZJ6ty5c73La2pqtHz5ckl1A/2LL76okJAQTZkyxaP19O/fXzabzaPbbK5qrK2kVnc2uDw3a0yjU1ImxEcc+9/tH09ocD2b/bAGXPPuCY+vyd+qpKSkphcMAADQBAkJCVq5cqVbbQMy0JeVlUlSg8NksrOzZbfbFR0dra5dux57/Ouvv1aPHj30yiuv6OGHH9b27duVkpKi+++/X9dcc43b9dhsNhUXF7vdHscJrZFaNbz46DzzJxMcZG3Ser9W67DwWgIAAL8SkIE+ISFB+/btU15engYNGlRnWUlJiWbNmiVJysjIkMViqbOsuLhY99xzj+bOnauOHTvqhRde0LXXXqs2bdpo+PDhbtcDz6ixttTORpbb7IcbbZ8QH6HgIKtqah2y2Ru+LqKh7QRZHUro0KEppQIAADTZqeRFi9PpdHqwFr8wffp0PfXUU+rYsaM++eQTpaamSpJyc3M1adIkbdmyRdXV1br99tvr3CU2NTVVP/30k95++21ddtllkiSn06m+ffuqVatW+uKLL4x4OjhOZVWtos96WdU1Drfab/94gpLatVDRzjJ1HPGay+3PPaOdvnzpUrf2DQAA4A0BOctNZmam4uLitH37dqWnp6t3795KSUnRwIEDlZycrGHDhkk6cYab2NhYSapzJt5isWj48OFau3at754AGhQWGqTeKa0N23+/tHjD9g0AAFCfgAz0SUlJWrZsmUaNGqXw8HAVFhYqNjZWCxcu1JIlS7Rx40ZJJwb69PT0BrdZUVHh1ZrRdEaGagI9AADwNwEZ6CWpZ8+eWrx4sUpLS1VaWqoVK1Zo6tSpKisrU2FhoaxWq3r16lWnzdixYyVJS5cuPfaYw+HQxx9/rAEDBvi0fjRs9JBOhuw3JNiqCwcxfh4AAPiXgLwotjH5+flyOp1KTU1VZGTd6Q1Hjx6tc889V1OnTtWePXvUqVMnPf/888rPz9fHH39sUMX4tUvOTVKnxBb6uaTMp/u9akQXtY2L8Ok+AQAATiZgz9A3ZM2aNZJOHG4jHRkv/+677+rKK6/UvffeqzFjxmjbtm16//33j427h/GCgqy65arTfL7fW8f19Pk+AQAAToZA/yutWrXSwoULtXv3blVWVuq7777TRRdd5MsS0QS/vTZNndtH+Wx/l1/QWeec0c5n+wMAAGgqAj1MKbpFqF6cfa5P9hXbMkz/+OPgOvcsAAAA8BfNbgx9Tk6O0SXAQ4ad2V53TkrXk//Ob3KbozeMOtkNqI638L7BasfYeQAA4KcC8sZSaD5qax26/g9f6tX3N3tl+wvuHaTbJ6R5ZdsAAACeQKCH6dXWOnTbI1/r2Tc2eGybQUEWPfPHwbr5yh4e2yYAAIA3EOgRMF5fulW3PfK17PtO7SZgGamxeulP5+r0ntxECgAA+D8CPQLKrj3lunf+Sv3n/c2qqKx1qW3b2HD99to0Zd6UodCQIC9VCAAA4FkEegSkvQcq9c93Nirrgy36ceNeVdc46l0vKjJEZ/Zuo8mXp+qK4V0UFkqQBwAA5kKgR8CrrKrVmp/2akPhAR0ur5HValFMVKgyUlorpXNLWa1MRwkAAMyLQA8AAACYWLO7sRQAAAAQSAj0AAAAgIkR6AEAAAATI9ADAAAAJkagBwAAAEyMQA8AAACYGIEeAAAAMDECPQAAAGBiBHoAAADAxAj0AAAAgIkR6AEAAAATI9ADAAAAJkagBwAAAEyMQA8AAACYGIEeAAAAMDECPQAAAGBiBHoAAADAxAj0AAAAgIkR6AEAAAATI9ADAAAAJkagBwAAAEyMQA8AAACYGIEeAAAAMDECPQAAAGBiBHoAAADAxAj0AAAAgIkR6AEAAAATI9ADAAAAJkagBwAAAEyMQA8AAACYGIEeAAAAMLH/BzB25BQ2xKATAAAAAElFTkSuQmCC\n"
+          },
+          "metadata": {},
+          "execution_count": 12
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "# Test: Slicing with Multiple Entanglement Connections\n",
+        "\n",
+        "This test showcases\n",
+        "\n",
+        "The QPIXL image module and algorithm circuit are both sliced into smaller segments (every 2 gates).\n",
+        "\n",
+        "Slices are interleaved, preserving logical order from both modules.\n",
+        "\n",
+        "At each step, we apply multiple entangling gates:\n",
+        "\n",
+        "cx(0,0) connects qubit 0 from the QPIXL module to qubit 0 of the algorithm slice.\n",
+        "\n",
+        "cx(1,1) similarly connects qubit 1 from QPIXL to algo qubit 1.\n",
+        "\n",
+        "This proves our support for multi-qubit connectivity between slices, completing the \"bidirectional sliced entanglement\""
+      ],
+      "metadata": {
+        "id": "n7Bgnj9XFUzC"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "from QPIXL.qiskit.qpixl_module import QPIXLModule\n",
+        "from QPIXL.qiskit.quantum_composer import QiskitCircuitModule, QuantumComposer\n",
+        "import numpy as np\n",
+        "from qiskit import QuantumCircuit\n",
+        "\n",
+        "data = np.linspace(0, np.pi/2, 8)\n",
+        "qpixl = QPIXLModule(data, name=\"DataMod\")\n",
+        "algo = QuantumCircuit(2); algo.h(0); algo.cx(0,1)\n",
+        "algo_mod = QiskitCircuitModule(algo, name=\"AlgoMod\")\n",
+        "\n",
+        "comp = QuantumComposer([qpixl, algo_mod])\n",
+        "circ = comp.combine(\n",
+        "  rule=\"slice\",\n",
+        "  slice_size=2,\n",
+        "  connection_rule=\"cx\",\n",
+        "  connection_map=[(0,0), (1,1)]\n",
+        ")\n",
+        "circ.draw(\"mpl\")\n"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 359
+        },
+        "id": "nSW8zG6539H1",
+        "outputId": "1ab19d71-aebc-4724-dd80-f400d19a6d8d"
+      },
+      "execution_count": 11,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "▶ Combining using rule: slice\n",
+            "✓ Done in 0.00s\n"
+          ]
+        },
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "<Figure size 1290.83x618.722 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {},
+          "execution_count": 11
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "# Test: Sliced Algorithm Interleaved into QPIXL with Entanglement\n",
+        "\n",
+        "This test demonstrates the advanced integration of an algorithm circuit into the QPIXL encoding pipeline using create_sliced_circuit.\n",
+        "\n",
+        "The QPIXL circuit encodes 16-pixel image data with 20% compression.\n",
+        "\n",
+        "The algorithm circuit (with 2 qubits) is sliced every 2 gates.\n",
+        "\n",
+        "Each slice is inserted during the QPIXL encoding loop.\n",
+        "\n",
+        "At each insertion point, a CZ entanglement is applied from QPIXL qubit 2 to algorithm qubit 0, as specified by the connection_map.\n",
+        "\n",
+        "This test showcases:\n",
+        "\n",
+        "- Smart gate slicing of the algorithm.\n",
+        "\n",
+        "- Interleaved placement into a nontrivial QPIXL circuit.\n",
+        "\n",
+        "- Controlled entanglement pattern across module boundaries."
+      ],
+      "metadata": {
+        "id": "SKsGS2FiHAXW"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "from QPIXL.qiskit.quantum_composer import create_sliced_circuit\n",
+        "from qiskit import QuantumCircuit\n",
+        "import numpy as np\n",
+        "\n",
+        "# --- 1. Create image input ---\n",
+        "image = np.linspace(0, np.pi / 2, 16)  # 1D image data\n",
+        "algo = QuantumCircuit(2)\n",
+        "algo.h(0)\n",
+        "algo.cx(0, 1)\n",
+        "algo.ry(np.pi/3, 1)\n",
+        "algo.cx(1, 0)\n",
+        "\n",
+        "# --- 2. Define connection pattern ---\n",
+        "conn_map = {2: 0}  # QPIXL data qubit 2 ↔ algo qubit 0\n",
+        "\n",
+        "# --- 3. Compose circuit with slicing and connection ---\n",
+        "combined = create_sliced_circuit(\n",
+        "    image_array=image,\n",
+        "    compression=20,\n",
+        "    algorithm_circuit=algo,\n",
+        "    slice_size=2,\n",
+        "    connection_rule=\"cz\",           # Entangling gate between data + algo\n",
+        "    connection_map=conn_map,\n",
+        "    name=\"QPIXL_Interleaved\"\n",
+        ")\n",
+        "\n",
+        "# --- 4. Visualize ---\n",
+        "combined.draw(\"mpl\")\n"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 438
+        },
+        "id": "eiE_NSpFAkz2",
+        "outputId": "ee9d2bba-e471-43f0-d7d5-c9d61499672c"
+      },
+      "execution_count": 10,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "[QPIXL] Interleaved 2 slices:\n",
+            "  ↪ At index 0: inserted slice 0\n",
+            "  ↪ At index 8: inserted slice 1\n"
+          ]
+        },
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "<Figure size 2210.55x1287.61 with 1 Axes>"
+            ],
+            "image/png": "iVBORw0KGgoAAAANSUhEUgAABroAAAPzCAYAAADoBNyLAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjEsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvc2/+5QAAAAlwSFlzAAAPYQAAD2EBqD+naQAA0elJREFUeJzs3Xd4FFXbx/HfpldaAgQIHUKHIEVQRFBQkWKlKCoqNhSxY+8VxUdFRLHrq2KwU1UUREBBqg9CKAIBQhJgIUB6233/yAOCJJBddnd2Zr+f68rlZWbOzB3mnGn3nHNsTqfTKQAAAAAAAAAAAMBkgowOAAAAAAAAAAAAAHAHiS4AAAAAAAAAAACYEokuAAAAAAAAAAAAmBKJLgAAAAAAAAAAAJgSiS4AAAAAAAAAAACYEokuAAAAAAAAAAAAmBKJLgAAAAAAAAAAAJgSiS4AAAAAAAAAAACYEokuAAAAAAAAAAAAmBKJLgAAAAAAAAAAAJgSiS4AAAAAAAAAAACYEokuAAAAAAAAAAAAmBKJLgAAAAAAAAAAAJgSiS4AAAAAAAAAAACYEokuAAAAAAAAAAAAmBKJLgAAAAAAAAAAAJgSiS4AAAAAAAAAAACYEokuAAAAAAAAAAAAmBKJLgAAAAAAAAAAAJgSiS4AAAAAAAAAAACYEokuAAAAAAAAAAAAmBKJLgAAAAAAAAAAAJgSiS4AAAAAAAAAAACYEokuAAAAAAAAAAAAmBKJLgAAAAAAAAAAAJgSiS4AAAAAAAAAAACYEokuAAAAAAAAAAAAmBKJLgAAAAAAAAAAAJgSiS4AAAAAAAAAAACYEokuAAAAAAAAAAAAmBKJLgAAAAAAAAAAAJgSiS4AAAAAAAAAAACYEokuAAAAAAAAAAAAmBKJLgAAAAAAAAAAAJgSiS4AAAAAAAAAAACYEokuAAAAAAAAAAAAmBKJLgAAAAAAAAAAAJhSiNEBoGJOp1MqKjI6jKoLD5fNZjM6CgAAAAAAAAAAEEBIdPmroiKVDhtldBRVFjL9IykiwugwAAAAAAAAAABAAGHoQgAAAAAAAAAAAJgSiS4AAAAAAAAAAACYEokuAAAAAAAAAAAAmBKJLgAAAAAAAAAAAJgSiS4AAAAAAAAAAACYEokuAAAAAAAAAAAAmBKJLgAAAAAAAAAAAJgSiS4AAAAAAAAAAACYEokuAAAAAAAAAAAAmBKJLgAAAAAAAAAAAJgSiS4AAAAAAAAAAACYEokuAAAAAAAAAAAAmBKJLgAAAAAAAAAAAJhSQCS67Ha7xo8frxYtWigiIkINGzbUHXfcoby8PI0ePVo2m02TJ082OkwAAAAAAOAlWfZ8LV6VpfnLMrR20345nU6jQwIAAIAHhBgdgLetWbNGAwYMUFZWlqKjo9W2bVtlZGRo0qRJ2rJli/bv3y9JSk5ONjZQL1lo36P+v/+iF9p21N3NW1e4TtjM6bqwTj19e/pZPo4OAAAAAADvWvBHht74PFXfLtiusrJ/klutm1bXmGFtdO1FLVUtJszACAEAAHAqLN2jy263a/DgwcrKytI999yjzMxMrVq1SllZWZowYYJmz56t5cuXy2azqWPHjkaHCwAAAAAAPMThcOreict0zg1z9dVPacckuSRpw7aDumPCUnW/cobSduUYFCUAAABOlaUTXePGjVN6errGjh2riRMnKjY29siy8ePHq1OnTiotLVWTJk1UrVo1AyMFAAAAAACe9MjrK/Xyx3+ddL2NaQfV76a52ru/wAdRAQAAwNMsm+hKTU1VSkqK4uPj9fzzz1e4TpcuXSRJnTp1Oub327Zt05AhQxQbG6uaNWvqmmuu0b59+7weMwAAAAAAOHXrt2Tr+ff+rPL6W3bm6Kmpa7wXEAAAALzGsomuadOmyeFwaOTIkYqJialwncjISEnHJrpycnLUt29fpaena9q0aXr77be1aNEiDRo0SA6Hwyexe0N+WZnsRUUV/gAAAAAAYCVvTt/gcpmPZmxWbn6JF6IBAACAN4UYHYC3zJ8/X5LUt2/fStdJT0+XdGyi6+2339auXbv066+/qlGjRpKkxMREnXHGGZoxY4Yuvvhi7wXtRU9tXKenNq4zOgwAAAAAALyqtNShj2ZsdrlcTl6JvpqXplEXtfRCVAAAAPg3p9Op/Px8SVJUVJRsNptb27Fsomv79u2SpMaNG1e4vLS0VEuWLJF0bKJr1qxZ6tWr15EklyT17NlTzZo108yZM91KdHXt2lVZWVkulYkMCtL65J4u76syNzRqpsvqN6xw2YClC095+0lJSSowcY83AAAAAIA1lNmilFPzfrfK3n7PE3r4tlN/RgYAAMDJORwOZWZmSpKSk5O1evVqt7Zj2URXXl6eJKmgoOLJZFNSUmS32xUbG6umTZse+f369es1dOjQ49Zv166d1q9f71YsWVlZ2rVrl0tlooKDpWS3dlehFjExOrd2Xc9t8F8yMjKUX1bmte0DAAAAAFAlwbFSTfeK5uTkKmePa8/vAAAAOHW7d+92u6xlE10JCQnKzs7WqlWr1LPnsT2jMjMzdd9990mSOnbseEx3uOzsbNWoUeO47dWqVUsbN250OxZXRQaZa/q0+vXr06MLAAAAAGA4p4KU6SyW0xbmctkaMVJ0aAMvRAUAAIB/O7pHV9267nfUsWyiq1+/fkpNTdWECRPUv39/JSUlSZKWL1+uq6++Wna7XVJ5dzhvW7FihctlnIWFKh02ygvReMemTZtki4gwOgwAAAAAAHTD44v03jebXCoTGRGsrYunq2a1cC9FBQAAgKPl5eUpJiZGkrR48WK3t2OubkMuGD9+vOLi4rRz5061a9dOHTp0UMuWLdW9e3c1a9ZM55xzjqRj5+eSpJo1a+rAgQPHbW///v2qVauWL0IHAAAAAACnYMzwNi6XuWJAc5JcAAAAJmTZRFdiYqIWLVqkgQMHKiIiQmlpaapVq5amTp2q2bNna9Om8i+7/p3oatOmTYVzca1fv15t2rh+owwAAAAAAHyrS9t43XhZqyqvX692lB6/pbMXIwIAAIC3WHboQqk8aTVr1qzjfp+bm6u0tDQFBQWpffv2xywbNGiQHnroIaWnpysxMVGStGzZMm3ZskUvvfSST+IGAAAAAACnZsrDZ6iouEwfz/z7hOs1qBOl7988X43qxfgoMgAAAHiSzel0Oo0OwteWLVumHj16qFWrVtqwYcMxyw4dOqQOHTooPj5eTz75pAoLCzV+/HjVrl1bv//+u4KCfNMJzmxzdIVM/4g5ugAAAAAAfsXpdGr6D9v0xufrtWjV7mOW1akVoRsva6WxV7RVQnyUQRECAAAErqPn6MrNzVV0dLRb27F0j67KrF27VtLxwxZKUrVq1TR//nzdcccdGjFihEJCQjRo0CC98sorPktyAQAAAACAU2ez2TT8gmYafkEzrd+SrbOunaX9B4sVVyNcO+eNUFhosNEhAgAA4BSR6KpA8+bNKxzyEAAAAAAAmFPb5jUVGR4iqVgRYcEkuQAAACwiILsonSzRBQAAAAAAAAAAAP8XkD265s+fb3QIAAAAAAAAAAAAOEUB2aMLAAAAAAAAAAAA5keiCwAAAAAAAAAAAKZEogsAAAAAAAAAAACmRKILAAAAAAAAAAAApkSiCwAAAAAAAAAAAKZEogsAAAAAAAAAAACmRKILAAAAAAAAAAAApkSiCwAAAAAAAAAAAKZEogsAAAAAAAAAAACmRKILAAAAAAAAAAAApkSiCwAAAAAAAAAAAKYUYnQAqER4uEKmf2R0FFUXHm50BAAAAAAAAAAAIMCQ6PJTNptNiogwOgwAAAAAAAAAAAC/xdCFAAAAAAAAAAAAMCUSXQAAAAAAAAAAADAlEl0AAAAAAAAAAAAwJRJdAAAAAAAAAAAAMCUSXQAAAAAAAAAAADAlEl0AAAAAAAAAAAAwJRJdAAAAAAAAAAAAMCUSXQAAAAAAAAAAADAlEl0AAAAAAAAAAAAwJRJdAAAAAAAAAAAAMCUSXQAAAAAAAAAAADAlEl0AAAAAAAAAAAAwJRJdAAAAAAAAAAAAMCUSXQAAAAAAAAAAADAlEl0AAAAAAAAAAAAwJRJdAAAAAAAAAAAAMCUSXQAAAAAAAAAAADAlEl0AAAAAAAAAAAAwpRCjA0DFnE6nVFRkdBhVFx4um81mdBQAAAAAAAAAACCAkOjyV0VFKh02yugoqixk+kdSRITRYQAAAAAAAAAAgADC0IUAAAAAAAAAAAAwJRJdAAAAAAAAAAAAMCUSXQAAAAAAAAAAADAlEl0AAAAAAAAAAAAwJRJdAAAAAAAAAAAAMCUSXQAAAAAAAAAAADAlEl0AAAAAAAAAAAAwJRJdAAAAAAAAAAAAMCUSXQAAAAAAAAAAADAlEl0AAAAAAAAAAAAwJRJdAAAAAAAAAAAAMCUSXQAAAAAAAAAAADClgEh02e12jR8/Xi1atFBERIQaNmyoO+64Q3l5eRo9erRsNpsmT55sdJgAAAAAAAAAAABwQYjRAXjbmjVrNGDAAGVlZSk6Olpt27ZVRkaGJk2apC1btmj//v2SpOTkZGMD9ZKF9j3q//sveqFtR93dvHWF64TNnK4L69TTt6ef5ePoAACAL2zYdkBvpqTq52UZOpRXopioUPXqXFe3Dm+j5NZxRocHAAAAAF61dtN+TUlJ1a+rspSTV6LY6FD16VpPY4a1VvuWtYwOD8ApsnSiy263a/DgwcrKytI999yjxx9/XLGxsZKkF198Uffff79CQkJks9nUsWNHg6MFAADwrEO5xbrm4YX6bsGO45albj2gd77aqL7d6unzF/uqTlykARECAAAAgPfsO1CokQ/8oh9+23XcsvVbDmhKSqouPCtRnzzfRzWrhRsQIQBPsPTQhePGjVN6errGjh2riRMnHklySdL48ePVqVMnlZaWqkmTJqpWrZqBkQIAAHhWTl6x+o6eU2GS62gLlmfqzFGztGdfgY8iAwAAAADv23+wSL2vm11hkutocxal6+zrZuvAoSIfRQbA0yyb6EpNTVVKSori4+P1/PPPV7hOly5dJEmdOnU68rvDibHu3bsrPDxcNpvNJ/ECAAB40q3P/qZVqfuqtO7fOw7pqod+8W5AAAAAAOBD1z/2q9ZvOVClddduztYNTyz2bkAAvMayia5p06bJ4XBo5MiRiomJqXCdyMjyIXqOTnT9/fff+uqrr5SQkKBu3br5JFZfyC8rk72oqMIfAABgLRl78jRt7laXysz7PUN/bd7vpYgAAAAAwHf+3nHopKNb/NvXP6cpbVeOlyIC4E2WnaNr/vz5kqS+fftWuk56erqkYxNdvXv3VmZmpiTpiSee0JIlS7wYpe88tXGdntq4zugwAACAD7zz1UaVlTldLvfm9A164+EzvBARAAAAAPjOW9NTXS7jdEpvfbFBL9xpnc4PQKCwbKJr+/btkqTGjRtXuLy0tPRIEuvoRFdQkOc7uXXt2lVZWVkulYkMCtL65J4ei+GGRs10Wf2GFS4bsHThKW8/KSlJBQ7HKW8HAACcOnvMVVJYS5fLvfPpz/ruzWFeiAgAAP+QWeNuKai6MrMylZiYaHQ4AAAv2Rs7Wgpt5HK5V6Z+p08mXuKFiABUxHFUTqFXr15avXq1W9uxbKIrLy9PklRQUPHE6ikpKbLb7YqNjVXTpk29GktWVpZ27TrxpIf/FhUcLCV7LoYWMTE6t3Zdz23wXzIyMpRfVua17QMAABc0c0phrhcrKQty+Z4FAABTiS2TgiRHWRnXPACwshaSQl0vVlxi4/oAGGT37t1ul7VsoishIUHZ2dlatWqVevY8tmdUZmam7rvvPklSx44dZbPZvB6LqyK90LPMm+rXr0+PLgAA/IQ91Cl3ZuEMDS5TnQYNPB4PAAD+IjM4WA5JQcHBqsc1DwAsa2+IQ8VulAsLdag21wfAZxwOx5GppOrWdb+jjmUTXf369VNqaqomTJig/v37KykpSZK0fPlyXX311bLb7ZKk5ORkr8eyYsUKl8s4CwtVOmyUF6Lxjk2bNskWEWF0GAAAQNJrn/ylO19c5nK5+265UM+Oe8wLEQEA4B8S+03Trj35qpdQT+l/pRsdDgDAS56eulqPvbHK5XJP3jtMD4x+1gsRAahIXl6eYmJiJEmLFy92ezvm6jbkgvHjxysuLk47d+5Uu3bt1KFDB7Vs2VLdu3dXs2bNdM4550g6dn4uAAAAKxg1pKUiI4JdKhMUZNNNl7fyUkQAAAAA4Ds3XtZKIcGujeIVFhqk0ZckeSkiAN5k2URXYmKiFi1apIEDByoiIkJpaWmqVauWpk6dqtmzZ2vTpk2SSHQBAADrqVEtXLcNb+tSmZEXNlfj+rFeiggAAAAAfCchPkqjL3XtQ74bL2ul2rUivRQRAG+y7NCFktSmTRvNmjXruN/n5uYqLS1NQUFBat++vQGRAQAAeNfzd3TV5h0H9d2CHSdd96zT6mrqY2f6ICoAAAAA8I3X7u+hremHNO/3jJOue8GZifrPfaf7ICoA3mDpRFdl1q1bJ6fTqaSkJEVFRR23/Msvv5QkrV+//pj/b9Kkibp27eq7QD3g7Pg6Kh487ITrnGw5AAAwn5CQIH358rl6ZPJKvfH5euXmlx63TkR4sK67qKX+c9/piggPyNtCAAAAABYVHhasWZPP0/j/LNfbX21QQWHZcetERYTo5qGtNOHO7goNtezgZ4DlBeQbjbVr10qqfNjCoUOHVvj/o0aN0ocffujV2AAAADwlJCRIL9zZTQ/f2EmfzNqin5ZmaPavO1RU4lC1mFBtnTNMcTUijA4TAAAAALwiLDRYr97fQ0+M6ayPZmzWA6+tUGFRmSLCgzXhzm4aNaSlqseGGR0mgFMUkGnqkyW6nE5nhT8kuQAAgBnFRodpzPA2+uqVcxVfszyxFRsVSpILAAAAQECoUS1cd1zVXnHVwyVJcdXDNW5kO5JcgEWQ6AIAAAAAAAAAAIApBeTQhfPnzzc6BAAAAAAAAAAAAJyigOzRBQAAAAAAAAAAAPMj0QUAAAAAAAAAAABTItEFAAAAAAAAAAAAUyLRBQAAAAAAAAAAAFMi0QUAAAAAAAAAAABTItEFAAAAAAAAAAAAUyLRBQAAAAAAAAAAAFMi0QUAAAAAAAAAAABTItEFAAAAAAAAAAAAUyLRBQAAAAAAAAAAAFMi0QUAAAAAAAAAAABTCjE6AFQiPFwh0z8yOoqqCw83OgIAAAAAAAAAABBgSHT5KZvNJkVEGB0GAAAAAAAAAACA32LoQgAAAAAAAAAAAJgSiS4AAAAAAAAAAACYEokuAAAAAAAAAAAAmBKJLgAAAAAAAAAAAJgSiS4AAAAAAAAAAACYEokuAAAAAAAAAAAAmBKJLgAAAAAAAAAAAJgSiS4AAAAAAAAAAACYEokuAAAAAAAAAAAAmBKJLgAAAAAAAAAAAJgSiS4AAAAAAAAAAACYEokuAAAAAAAAAAAAmBKJLgAAAAAAAAAAAJgSiS4AAAAAAAAAAACYEokuAAAAAAAAAAAAmBKJLgAAAAAAAAAAAJgSiS4AAAAAAAAAAACYEokuAAAAAAAAAAAAmFKI0QGgYk6nUyoqMjqMqgsPl81mMzoKAAAAAAAAAAAQQEh0+auiIpUOG2V0FFUWMv0jKSLC6DAAAAAAAAAAAEAAYehCAAAAAAAAAAAAmBKJLgAAAAAAAAAAAJgSiS4AAAAAAAAAAACYEokuAAAAAAAAAAAAmBKJLgAAAAAAAAAAAJgSiS4AAAAAAAAAAACYEokuAAAAAAAAAAAAmBKJLgAAAAAAAAAAAJgSiS4AAAAAAAAAAACYEokuAAAAAAAAAAAAmBKJLgAAAAAAAAAAAJgSiS4AAAAAAAAAAACYEokuAAAAAAAAAAAAmFKI0QH4gt1u14svvqivv/5a6enpql27ti699FI999xzGjdunN5//329/vrrGjt2rNGhetxC+x71//0XvdC2o+5u3rrCdcJmTteFderp29PP8nF08JUyp/TbbmlLjlRUJlUPk/okSAlRRkcGX8nNL9HXP6VpR1aunE4psW60LuvXRNViwowODQAAn9iy85BmLdyh7EPFiowIVnKrOPXv2UBBQTajQ4MPOJ3Sf7OlP/dLBaVSdIjUvbaUVN3oyAAAvrI9I0czftmhfQeKFBEerA4ta+qCMxMVHEw/AAAwO8snutasWaMBAwYoKytL0dHRatu2rTIyMjRp0iRt2bJF+/fvlyQlJycbGyjgBaUO6ZMt0pdpUlbBscv+85fUK0G6IUlqW8OI6OALe/YV6Om31+ijGZuVk1dyzLLbn/9dVw9qoUdvTlb9OtEGRQgAgHctWb1bz7y9Rt8vST9uWfOGsRo7oq1uv7ItL7ksyumU5qRLn26RNh06fnmnWtKoFlLvBN/HBgDwjeV/7dXTU9do9qKdcjicxyxrXD9Gtw5ro7uubq/QUO4FAMCsLH0Gt9vtGjx4sLKysnTPPfcoMzNTq1atUlZWliZMmKDZs2dr+fLlstls6tixo9HhAh5VWCbdtUyanHp8kkuSHJJ+zZJuWCz9kunz8OAD29Jz1PPqmZo8bf1xSS5Jyiso1VtfbFCPq2Zq47YDvg8QAAAvmzZni/pcP7vCJJckbdmZo7teWqah985XcUmZj6ODtzmd0st/SY+vrjjJJZX38Lr7D+nDzb6NDQDgG9/8nKazrp2lmQt3HJfkkqTtGbm6/9XluuiOeSosKjUgQgCAJ1g60TVu3Dilp6dr7NixmjhxomJjY48sGz9+vDp16qTS0lI1adJE1apVMzBSwPOeWC39vvfk6xU7pIdWSmv3ez8m+M7BnGJdMOYHbU3POem6O7PydMGYH2TPLvRBZAAA+MbPSzN09cMLVVp2/Eutf/vm5+0a88xvPogKvvT+ZunzbVVbd3KqNHOHd+MBAPjWb2t2a8T4BSoqdpx03bmL03Xto7/6ICoAgDdYNtGVmpqqlJQUxcfH6/nnn69wnS5dukiSOnXqdOR3X375pS677DI1btxYUVFRat26tR5++GHl5ub6JG5vyS8rk72oqMIfWM+6bOmnjKqvX+yQ3trovXjge+99s1Gbth+s8vppGbl6c3qqFyMCAMC3Hn59hcqqkOQ67P1vNmkDPZwtI6dEen+Ta2XeSC0f+hsAYA2PTl6p4pKqn9hTvt+mlevtXowIAOAtlk10TZs2TQ6HQyNHjlRMTEyF60RGRko6NtE1ceJEBQcH67nnntPcuXM1ZswYvfnmm7rgggvkcJj3qeepjetU/8fvKvyB9XyZ5nqZZXul7ebO5+J/HA6n3py+weVyU7/YoFLe7gAALGDleruWra1C1/Z/eTOFjz6sYtZOqcjF2xp7kfRLlnfiAQD4VurWA5r/h+vzNHAvAADmFGJ0AN4yf/58SVLfvn0rXSc9vXys/qMTXTNnzlTt2rWP/P/ZZ5+t2rVra+TIkVq8eLF69+7tpYi964ZGzXRZ/YYVLhuwdKGPo4E3OZ3SPBd6cx3tpwxpdJJn44HvrdmwT3/vqGQiihPYtSdfv63Zrd5d63khKgAAfOeLH6s4Xt2/pPywTa890NPD0cAI83a5X65ffc/GAgDwvS/nuX8v8O6TZ3k4GgCAt1k20bV9+3ZJUuPGjStcXlpaqiVLlkg6NtF1dJLrsK5du0qSdu1y72mpa9euyspy7dPAyKAgrU/23EN2i5gYnVu7rse2929JSUkqMHGPN0sJjVDCa3+7VXTiG+/o8a+e9HBA8LXC0OZS7DVulb1k6DWKLOELNsDKMmvcLQVVV2ZWphITE40OB/CK7OiLpPDTXC63256rBomJsnkhJvhW/BOLFFKnqcvl5iz8TZ9eMswLEcFfcB0EAsOBqAFSRA+Xy+Xml6hBYhPZVOqFqOAPuA4A/uXoUfR69eql1atXu7Udyya68vLyJEkFBQUVLk9JSZHdbldsbKyaNj3xA9CCBQskSW3atHErlqysLJeTZFHBwVKyW7szREZGhvLLyowOA5IUHKIEN4vmHNjvdkIXfiQ6Rop1r+j+fXukHOoAYGmxZVKQ5Cgr45wP66p/SAp3o5yzVBm0C0uoXpjv1sNuYV4O50ar4zoIBIaEg1KEe0Uzdu2QVPV5PmEyXAcAv7V79263y1o20ZWQkKDs7GytWrVKPXse2zMqMzNT9913nySpY8eOstkq/2Zz165devTRR3XBBRcoOTnZ7VhcFRlkrunT6tevT48uP1K6J00hdZq4XC4yf48aNGjg+YDgU2W2IGU5ndIJzm3H+d/6dWpIodWoA4CVZQYHyyEpKDhY9Tjnw6Jywwt00I1yoY79qkO7sATbvu1So3Yulws5sIv7YYvjOggEhrzwQh1wo1xwmV0JDRjD1sq4DgD+xeFwKDOzfE7FunXdH5HOsomufv36KTU1VRMmTFD//v2VlFQ+8dDy5ct19dVXy263S9IJk1e5ubm66KKLFBYWpvfff9/tWFasWOFyGWdhoUqHjXJ7n762adMm2SLc/FQGHvfRZul1F0efiw6RFk17WZEhL3snKPjU4LE/atavO6tewGZT3271NP+9P70XFAC/kNhvmnbtyVe9hHpK/yvd6HAAr9h3oFCJ/T9XYZFrIw5MeuIy3TLsES9FBV9aukcau9T1cjOfvF4tXrne8wHBb3AdBAJDTl6xGvT7XDl5JS6VmzD+Qt0z6n4vRQV/wHUA8C95eXmKiYmRJC1evNjt7Zir25ALxo8fr7i4OO3cuVPt2rVThw4d1LJlS3Xv3l3NmjXTOeecI+nY+bmOVlBQoMGDB2vbtm368ccfVa9ePV+GD5ySixpJ4S627iGNpEjLpr4Dz20j2rpRxr3hWQEA8DdxNSJ0xYBmLpWpFhOqkQObeyki+Fr32lKjaNfKnBYntajmnXgAAL4VGx2mUUNaulQmIjxY117kWhkAgH+wbKIrMTFRixYt0sCBAxUREaG0tDTVqlVLU6dO1ezZs7Vp0yZJFSe6SkpKdPnll2vFihWaO3eu2rZ1/YUxYKQa4dJjnau+flI16ZbW3osHvnf+mQ1cSlxde1FLXdqvifcCAgDAx166u7taNalepXWDgmz65Lk+io0O83JU8JUgm/RMFykyuGrr1wyTHkv2akgAAB979vYu6phUq8rrf/RMb8XVYLQiADAjS/ffaNOmjWbNmnXc73Nzc5WWlqagoCC1b9/+mGUOh0MjR47Uzz//rDlz5qh79+6+Ctcrzo6vo+LBw064zsmWw5zOb1A+7dKTa6SSE0yf1qmW9HK38qELYR02m02THuipsNAgvfJ/60647i1DW+v1B3uecL5CAADMJq5GhBa8d6EGjf1Rq1L3VbpeZHiwpr3YV4P7NPJhdPCFtjWkN3pKd/8hHSiufL36UdJrp0uJLvYAAwD4t2oxYfrp7Qt00R0/6fc/91S6XlhokD56preGne9ab3AAgP8IyFfb69atk9PpVFJSkqKioo5Zdtttt+mLL77QAw88oKioKC1d+s/A7s2bN1ft2rV9HS7gtgsSpS7x0jfby3/2Fv6z7Iw60tAm0hl1pWDyG5YUFGTTf+7roVFDWurN6Rv0yay/lVdQKkmySbr+kiSNGd5GXdrGGxsoAABeUq92lJZ9OkQzftmhKSmp+nlZxpFlwUE2PT22i0ZfkqQ6cZEGRglv6lhL+vZcaU669GWatDXnn2Vta0jDmkj9GkgRVez5BQAwl9q1IrXow4GasyhdU1JS9f2Sf+ZkCgqy6YkxnXXDpa1Ur3bUCbYCAPB3NqfT6TQ6CF979913deONN2rYsGFKSUk5ZlmTJk20ffv2Cst98MEHuvbaa30QoeQsLFTpsFE+2ZcnhEz/SLYIunf7szKn1GOm5FR5kmP5EKMjgq8Vl5Sp8fkpyrIXqH7tSO36+UqjQwJggMOTLzeoE6X0n64wOhzAp/LyS9Ri4HRl7SvkWhiAnE6pO/fDAY/rIBDY8gtK1fzCFO4FAhjXAcC/5OXlKSYmRlL5SHzR0e4NsxCQPbrWrl0rqeL5udLS0nwcDeAbwbbyB/rDD/YIPGGhwQoOKj/6DFMIAAhE0VGhCg4un6aYa2HgsXE/DAABLyoyhHsBALCgIKMDMMKJEl0AAAAAAAAAAAAwh4Ds0TV//nyjQwAAAAAAAAAAAMApCsgeXQAAAAAAAAAAADA/El0AAAAAAAAAAAAwJRJdAAAAAAAAAAAAMCUSXQAAAAAAAAAAADAlEl0AAAAAAAAAAAAwJRJdAAAAAAAAAAAAMCUSXQAAAAAAAAAAADAlEl0AAAAAAAAAAAAwJRJdAAAAAAAAAAAAMCUSXQAAAAAAAAAAADAlEl0AAAAAAAAAAAAwpRCjA0AlwsMVMv0jo6OouvBwoyMAAAAAAAAAAAABhkSXn7LZbFJEhNFhAAAAAAAAAAAA+C2GLgQAAAAAAAAAAIApkegCAAAAAAAAAACAKZHoAgAAAAAAAAAAgCmR6AIAAAAAAAAAAIApkegCAAAAAAAAAACAKZHoAgAAAAAAAAAAgCmR6AIAAAAAAAAAAIApkegCAAAAAAAAAACAKZHoAgAAAAAAAAAAgCmR6AIAAAAAAAAAAIApkegCAAAAAAAAAACAKZHoAgAAAAAAAAAAgCmR6AIAAAAAAAAAAIApkegCAAAAAAAAAACAKZHoAgAAAAAAAAAAgCmR6AIAAAAAAAAAAIApkegCAAAAAAAAAACAKYUYHQAq5nQ6paIio8OouvBw2Ww2o6MAAAAAAAAAAAABhESXvyoqUumwUUZHUWUh0z+SIiKMDgMAAAAAAAAAAAQQhi4EAAAAAAAAAACAKZHoAgAAAAAAAAAAgCmR6AIAAAAAAAAAAIApkegCAAAAAAAAAACAKZHoAgAAAAAAAAAAgCmR6AIAAAAAAAAAAIApkegCAAAAAAAAAACAKZHoAgAAAAAAAAAAgCmR6AIAAAAAAAAAAIApkegCAAAAAAAAAACAKZHoAgAAAAAAAAAAgCmR6AIAAAAAAAAAAIApkegCAAAAAAAAAACAKQVEostut2v8+PFq0aKFIiIi1LBhQ91xxx3Ky8vT6NGjZbPZNHnyZKPDhJflF5RqZ1auMvfmq6TEYXQ4AOBzufkl2pGZq937ClRaynkQgaegsFTpWXnK2JOn4pIyo8MBfK64pEwZe/KUnpWngsJSo8MBAJ8rLCrVrt3l9wJFxdwLAAg8vB/FwZxibc/IkT27UA6H0+hwPCbE6AC8bc2aNRowYICysrIUHR2ttm3bKiMjQ5MmTdKWLVu0f/9+SVJycrKxgXrJQvse9f/9F73QtqPubt66wnXCZk7XhXXq6dvTz/JxdN7ndDr1y/JMvTl9g76Zn6bS0vLGWz02TKMGt9CY4W3UumkNY4MEAC8qK3Po+yXpmpKSqrmL0+X83z1M7ZoRGn1pkm6+vLWaNIg1NkjAi5xOp5as3q0pKan6cl6aSv6X5I2JCtU1g1tozLDWat+ylsFRAt61dtN+TUlJ1Seztyg3v0SSFBYapMv7N9Wtw9vojOQ6stlsBkcJAN7hdDr1x9q9mpKSqpQfth1JcEVFhGjkwOYaM6y1OreJNzhKAPCew+9Hp6Sk6pv521VW9s/70WuHtNSYYa3VivejllZUXKYv523TlJRU/bZmz5HfN20Qq5uHttL1Fyepdq1IAyM8dZbu0WW32zV48GBlZWXpnnvuUWZmplatWqWsrCxNmDBBs2fP1vLly2Wz2dSxY0ejw4WH5ReU6tK7ftY5N8zVFz9uO5Lkksoz15M+W682F32lZ99eI6fTOtlrADgs+1CRzr1xrgaNnac5i/5JcknS3uxCvfDef9Vi0Bd6+8sNxgUJeFFRcZlGPvCLzrp2tqbN3XokySWV93CckpKqDpd9o4cnreBeAJbkcDj14GvL1fHyb/TWFxuOJLkkqbjEoc/mbFGvUbN09UML6eUIwJJKShy64YnF6nHVTH088+9jenHlF5bqna826rTh3+muF5eqrIyeDQCsJ7+gVJfc+ZPOuWGuvpyXdiTJJZW/H33t03VqfdFXeu4d3o9a1bb0HCUP/UZXPbjwmCSXJG3blaMHXl2hZhdO19xFOw2K0DMsnegaN26c0tPTNXbsWE2cOFGxsf98sT5+/Hh16tRJpaWlatKkiapVq2ZgpPC0khKHLrv7Z307f/tJ131k8ko9PXWN94MCAB/Kyy/R+bd8r4Ursk64XlmZUzc/tUTvkOyCxZSVOXTl/b9o2tytJ133uXf/1AOvLvdBVIBv3f/Kcr3w3n9Put6ns7do5AO/WGroEgBwOp26/vFf9f43m0667qufrNO4F5bykheApZSUOHTJXT/puwU7Trruw6+v1LPvrPF+UPCpjD156jN6tjZsO3jC9XLzSzVk3Dz9tHSXjyLzPMsmulJTU5WSkqL4+Hg9//zzFa7TpUsXSVKnTp2O/G7RokXq16+f6tWrp/DwcCUmJmr48OFKTU31SdzwjLe+SNX3S9KrvP7jU1ZpdardixEBgG89+86fWv5X1c9rY579TelZeV6MCPCtj2f+ra9/Tqvy+i9+sFZLVu/2XkCAj/26IlMTP1pb5fW/nJemj2du9mJEAOBbX/y4TZ/M2lLl9aekpOrH38z7gg8A/m1KynqXzmuPTl6lPzfu82JE8LVxLyzVjsyqvespLXPqyvt/Me0clpZNdE2bNk0Oh0MjR45UTExMhetERpaPO3l0ois7O1sdOnTQpEmT9OOPP2rChAlat26devbsqfT0qidO/E1+WZnsRUUV/liN0+nUG5+7nph8czq9GQBYQ1Fxmd75eqNLZcrKnHrnK9fKAP7K6XRq8rT1LpebksKHTbCOKdNdr8+0AQBW4s57Ac6DAKzC4XDqDTfOabwftY70rDx9u+Dko50dbW92ob6ct81LEXmXZRNd8+fPlyT17du30nUOJ66OTnQNGTJEr7zyioYOHaqzzz5bI0eO1Ndff62DBw/qq6++8m7QXvTUxnWq/+N3Ff5YzaKVWdqYduLumBX59KjJuQHAzL6dv1327EKXy7391QaGrYIlrErdp1Wprn+J+MWP27TvgOttB/A3e/cX6Kt5aS6XW/6XnVEOAFjChm0H9OvKEw/hXZFZv+7Urt2McgDA/BauyNTm7YdcLvfJrL+Vx/tRS3j/203HzMlWVVO/MGeyM8ToALxl+/bybGXjxo0rXF5aWqolS5ZIOjbRVZG4uDhJUkiIe/9cXbt2VVaWazdYkUFBWp/c0639VeSGRs10Wf2GFS4bsHThKW8/KSlJBQ7/mLg1L7yLFD3E5XL5haVq3rqbQh3WfbivO3m7bEHBKnOUKTGx4rYBa8uscbcUVF2ZWZlKTEw0Ohx4yaGIPlJU5R96VCbLXqDExi0U5LReb1/8IxDOA/lhHaSYy10uV1LqUJtOZymsLNMLUcFfBEIbKA5uoNLqN7lV9tyBIxVVvM7DEfkP7ocRCOcASAWhraTYK10u53A4lXz6eQovde0LeJgL54HAFijHPy+8qxQ92PVyBaVq1rqrQh0MYWh2+6Mvk8I7ulxuyYq/fdo2HEflFHr16qXVq1e7tR3LJrry8sq/wCkoKKhweUpKiux2u2JjY9W0adPjlpeVlcnhcGj79u168MEHlZCQoGHDhrkVS1ZWlnbtcm2c56jgYCnZrd1VqEVMjM6tXddzG/yXjIwM5Zf5yfidcUlStHtF9+zdJxVad0zuuocn1nU6Xa6TsIjYMilIcpSVUQesrG6+FOVe0czMPVJZrmfjgX8JhPNAjcZSxSNXn9Re+34p36L/LigXCG0gKlKq7l7R7OxDyj5g0X8XcT8MBcY5AFK1BCnWvaJ2e7aUR92wNM4DgS1Qjn9ca/ffj+6xS0UZno0HvteoWAp3vZjDEWRY29i92/15sy2b6EpISFB2drZWrVqlnj2P7RmVmZmp++67T5LUsWNH2Wy248qfffbZR3p8tWjRQvPnz1ft2rXdjsVVkUHmGlWyfv36ftOjKz8sVNmuFnI6JZtNCfHRCnY28EZY/uFwXbfZ1KCBhf9OVCozOFgOSUHBwapHHbCs3PAguT6AqyRnmeon1JTN3bejMIVAOA8UhobJ5e8P/3cvUDcuWiE1rfnvgnKB0AZKgqK0RzpSr10RVyNcEdHW/HeRxP0wAuIcAKkoJEIuj9Xyv3NmnbhIhdagblgZ54HAFijHPz8sxP33o7VjrP1+NEAcCHfIncF4Q2wFquvDtuFwOJSZWT6qSt267nfUsWyiq1+/fkpNTdWECRPUv39/JSUlSZKWL1+uq6++WnZ7+S1PcnJyheXfe+89HThwQNu2bdNLL72k8847T0uWLFGjRo1cjmXFihUul3EWFqp02CiXyxll06ZNskVEGB2GJCknr1j1z52m3PzSqhey2dS7S4IWfmDOMUirqvsMySEpOCj4yBx1CCyJ/aZp15581Uuop/S/qANWlZ6VpyYDUlwei3nYBS2U8tIOL0UFfxEI54HColI16Pe59h90YRhOm02ntYnTis//rPAjKFhHILQBp9OpzsO+1Z8b97tULr5mhNJX/KzwsGAvRWY87ocRCOcASCUlDjUZkKKMPflVL2SzqVWT6kr9bgX3AhbHeSCwBcrxP5hTrAb9pimvwLX3o3261dOC9zZ6LzD4zMIVmepz/RyXyz14az89ddv9XoioYnl5eYqJKR+SZfHixW5vx1zdhlwwfvx4xcXFaefOnWrXrp06dOigli1bqnv37mrWrJnOOeccSZXPz9WqVSudfvrpGjFihH7++Wfl5OToxRdf9OWfADfFRofp6kEtXC43ZlhrL0QDAL6XmBCtwWe7/mHGrcPbeCEawPciwkM0+pIkl8vdOrwNL7ZgCTabza1z+uhLkiyd5AIQOEJDg3TTZa1cLjdmWGvuBQBYQvXYMF3F+9GA1rtLgto2r+FSmaAgm2504/rpDyyb6EpMTNSiRYs0cOBARUREKC0tTbVq1dLUqVM1e/Zsbdq0SVLlia6j1ahRQy1atNDff//t7bDhIeOv66j4mlXvYdajY21d2q+J9wICAB97YkxnRUVUveP2wN4N1buL60PtAv7qzqvaqX6dqk9Wl9y6lq68sLkXIwJ866qBLdQxqVaV129QJ0p3jGznxYgAwLduG9FWTepXfdLONs1q6LqLXf9QBgD81f3XdVRcjapP0tSzUx1dfE5jL0YEX7LZbJpwZzeXRjK/Y2RbNUxwc8Jrg1k20SVJbdq00axZs5STk6OcnBwtW7ZMN910k/Ly8pSWlqagoCC1b9/+pNvZs2ePNm7cqObNeflhFk0axGrOG+dV6WTeuXWcZkzqr7BQvl4FYB2dWsXp29f6KTry5Mmuvt3q6fMX+/L1Kiylfp1ozZ1yvhLiI0+6brvmNTR78nmKdCE5DPi7qMgQzXnjPLVpVuOk69arHaXv3zxf9WpXPTkMAP4uvmaEvn/zfDVMiD7pui0aVdPcKeepWkyYDyIDAN9omhirOW+cX6X3o6e14f2oFQ06u5HeebyXgoJO/r7nmsEt9NLd3X0QlXdYOtFVmXXr1snpdKply5aKijr2Ye6qq67SE088oW+//Va//PKL3nnnHfXp00chISG66667DIrYfWfH11Hx4GG6u3nl3U6LBw/Tt6ef5cOofKNb+9pa9ukQXXtRS0WEH3+Srl0zQg+O7qRfPxyo2rVO/hIMAMymf88G+u3/BmvY+U0VEnz8TU3DhGg9e3sXff/W+YqJCjUgQsC7OibV0rJPh+jGy1pV2MOxVvVw3TuqgxZ/NEj165z8JRhgNg3qRmvJx4N0zzXtVav68S84oiJCdNPlrbTs08Fq37Lqvb8AwCxaNa2hpZ8M1q3D2ygm6vh7gRqxYbrzqnb6/f8Gq3H9WAMiBADv6t6htpZ+Uv5+tKIhquvUitBDN3TSwg8GujQ6Fsxj9KWt9PM7A3TeGQ0qXN62eQ1NfexMffhMbwUHmzddFJCfra5du1ZSxcMW9ujRQx9//LFee+01FRYWqmHDhurbt68eeughNW5M102zad6wmj54urdevvd0ffNzmu5+aZkO5ZWoVrUw7Zw3gjkIAFhex6RaSnnpHGXuzdd3C7Zr/CvLlZNXolrVw7V1zjCFhJj3Jgaoikb1YvT247304l3d9O2C7brjhaU6lFeimtXCtOunEYoID8jbYQSQmtXCNfHe0/X02C76bsF23fzUEh3KK1GN2DClfT9c1WPpvQDA2urXidYbD5+hF+7sqm9+3q7bn//9yL1A+rwrFFWFERAAwMxaNCp/Pzrxnu76dv72496P0ovL+vp0q6c+3epp8/aD+n5Juh5+faVy8koUXyNcf319qSVG+AnIt1snSnSNHTtWf/zxh7Kzs1VQUKBNmzZp6tSpJLlMrlb1cI2+tJVio8t7LERGhJDkAhBQ6tWO0i3D2qja4fNgeDBJLgSUGtXCde1FSUfuBaIiQkhyIaBERoRoxIDmR9pAdGQISS4AASU2OkzXDGl5zL0ASS4AgSSuRsRx70dJcgWWlo2r6/Yr2x15NxQeFmyJJJdEosvgSAAAAAAAAAAAAOCugPx0Zf78+UaHAAAAAAAAAAAAgFMUkD26AAAAAAAAAAAAYH4kugAAAAAAAAAAAGBKJLoAAAAAAAAAAABgSiS6AAAAAAAAAAAAYEokugAAAAAAAAAAAGBKJLoAAAAAAAAAAABgSiS6AAAAAAAAAAAAYEokugAAAAAAAAAAAGBKJLoAAAAAAAAAAABgSiS6AAAAAAAAAAAAYEokugAAAAAAAAAAAGBKIUYHgEqEhytk+kdGR1F14eFGRwAAAAAAAAAAAAIMiS4/ZbPZpIgIo8MAAAAAAAAAAADwWwxdCAAAAAAAAAAAAFMi0QUAAAAAAAAAAABTItEFAAAAAAAAAAAAUyLRBQAAAAAAAAAAAFMi0QUAAAAAAAAAAABTItEFAAAAAAAAAAAAUyLRBQAAAAAAAAAAAFMi0QUAAAAAAAAAAABTItEFAAAAAAAAAAAAUyLRBQAAAAAAAAAAAFMi0QUAAAAAAAAAAABTItEFAAAAAAAAAAAAUyLRBQAAAAAAAAAAAFMi0QUAAAAAAAAAAABTItEFAAAAAAAAAAAAUyLRBQAAAAAAAAAAAFMi0QUAAAAAAAAAAABTItEFAAAAAAAAAAAAUwoxOgBUzOl0qrSgyOgwqiwkMlw2m83oMGAhZmsDEu3Akzj+oA4g0NEGgMBmxnOAxHnA08xYD6gDnsPxB3UAgY42AFeQ6PJTpQVF+rT5VUaHUWUjt3yi0KgIo8OAhZitDUi0A0/i+IM6gEBHGwACmxnPARLnAU8zYz2gDngOxx/UAQQ62gBcwdCFAAAAAAAAAAAAMCUSXQAAAAAAAAAAADAlEl0AAAAAAAAAAAAwJRJdAAAAAAAAAAAAMKUQowMAvG3/wSKtSrVrw7aDyskrkSTlFZRq6Z971KlVLUVG0Axgbbn5JVqduk9//Z2tnPySI79buCJTnVvHqVpMmMERwtv27CvQyvV2bd5x6Jjz4Mr1drVvUVPhYcEGRwhvcjqd2rYrRyvW2ZWxJ/9IHcgvLNXGbQfUsnF1BQXZDI7Suw4cKtKq1H1K3XbgqDZQot/W7FZyqzhFRXIvYGVOp1MZe/K1cr1d23blHHMe/O+m/WrbrIZCQqz9/V9efonWbNyvtZv3H3MvMH9Zhk5rE6ca1cINjhDwrqLiMq3dvF9/bjy2DcxdtFNd2sarTlykwRHC2w7lFmtV6j6t35J95DqQm1+iRSuz1LlNnGKiQg2OEN6Wubf8XmDLzmOfidZs2Kd2zWsqNNTa9wKBzuFwasvOQ1q53q7co64DKd9vVZe28WreMFY2m7WfifYfLNLK9XZtTOP9aCByOp3amZWnlevt2pGZ+897gYJSrfs7W62bVldwsLnPg9RgWNLOrFxN/WKDps3dqq3pOcctP5BTrJ5Xz1RwsE3JreJ0/cUtddWgFrzwh2XsO1CoD77drI9mbNa6LdlyOo9dfjC3RH2unyNJatOshq4e1EKjL0niId9CNqUd1FtfpOrLeWnamZV33PIDOcXqOuI7hYYEqVv7eN14WSsNP78ZN7cW4XQ6tXjVbk1JSdUPv6Ur+1DxcetkHypW64u+Umx0qM49vb7GDGutfj0aWCbplbEnT+98tVGfztmizdsPHbf8QE6JzrxmloKCbOqYVFPXDmmpUUNa8sLfQv7cuE9vTt+g7xZsV5a94LjlB3KK1enybxQRHqwzk+vq5qGtdXHfxpZ50ZV9qEgffbdZH87YrLWbs+VwHHszcDC3ROfeOFeSlNS4ukYObK4bL2ulerWjjAgX8LiCwlJ9/v1Wvfv1Ri3/y66SUscxyw/mlujC236UJDVMiNbQ85rqlqGt1bJxdSPChRfs3leg977eqP+b9bc2bDt43PKDuSXqfd1s2WxSu+Y1NWpIS113cUvF1YgwIFp4w/ot2Xpz+gZ9/XOaMvbkH7f8QE6xOg/7VuFhwerRsbZuuqy1LuvfhA8BLcLpdGr+sky9OT1V85bu0qHckmOWH8wt0YjxCyRJ1WPDdF7PBhozrLX6dKtnmaTXjsxcvf1l1d6Pdm4dp+svTtJVg5orNpr3o1axYt1eTUlJ1cyFO2XPLjxueXZOsdpf+rWiIkJ01ml1dcuw1hrUu5EpPwS0OZ3/fv0Jf1CSX6hPm19ldBhVNnLLJwqNMv5mcHtGju6Z+Ie+mb/9uIf5k4mJCtXNl7fSk7eepmiLfs3VfYbkUPmYpX8MMTqaEzNbG5D8ox3sP1ikB15dro9n/q2i4jKXyoaGBGnkwOZ68a5uql3L2IQXx999qVsP6K4Xl+qH33a5XLZW9XDdMbKdHhjdUWGhxj7cUQfcN2fRTt3/ynL99Xe2y2VbNKqmp287TcMvaGbah7uMPXm6Z+If+mLeNpWVuXYvEBURotGXJumZsV0M//iFNuC+P9bu1d0Tl2nJ6t0ul61XO0r3X9dBY69oa9ovGg/mFOuRySv13jcbVVDo2r1ASIhNQ/s31cR7uqt+nWgvRWgss9wPm/EcIPnHeaCouEwvvPenXvt0XYUfepzMBWcm6pXxp6t10xqeD85FZqwH/lAH9uwr0PhXluuzOVuOS3CeTER4sEYNaann7+iqmgZ//MLxd9+aDft090vLtGB5pstla9eM0L2jOujua9ob/qKXOuC+r+Zt08Ovr9TGtOOT3CfTplkNPTeuiy4+p4nnA/OR7Rk5uvulP/TtAvfej94ytLWeGNPZ8PejtAH3LVqZpXtf/kN//LXX5bKJdaP1yE3JuvGyVj75EDYvL08xMTGSpNzcXEVHu/ccwmfbFpLQs50u+PrJY35XklegQ1szteXLX5X63hw5y1y7yTMLp9Opd77aqHtf/uNI10tX5eaX6OWP/9I387fr/afO0tld63k4SnhbILcBSZqxYLtufnpJhV+tV0VJqUMffrdZs37dqSkPn6Gh5zX1cITeF8h1oLTUoZc/XqvHp6x2Ocl52P6DRXp8yip99VOaPnz6LHVuE+/hKL0vkOvAgUNFuuulZfrwu81ub+PvHYd0xf2/aPqP2/TmI2eqrol6eTqdTn0842/d+eJSHchx/cWmVD6c4+ufrdd3C7br3SfOUv+eDTwcpfcFchsoLCrVk2+t1osfrHX5gf6wzL35uvPFZfpiXpo+eOos0/Xs+GFJum54YrHSdx/fk7cqSkudmjZ3q+YuTtekB3roqkEtTJv0DmSBfB5Yud6uax/51a2PPQ77fkm6FgzN1NO3naa7r2lvuqR3IB9/p9Op6T9s023P/aZ9B4rc2kZhUZmmfrFBM37ZobcfO1ODzm7k4Si9L5DrQHFJmZ5/9089884alZa6dy+wN7tQ97+6XF/+tE0fPNVb7VrU9HCU3hfIdWDv/gKNff53Tf9hm9vbSN16QJfc+bOuvLC5Jj3Qw1S9PJ1Op97+svz96OEhGl2Vm1+iiR+t1Tfz0/TBU711VpcED0fpfYHcBvILSvXQpBWa9Nm640Z3qqr03Xm65eklmv7DVr335Flq0iDWs0F6CYkuC9r69SKlz18l2WyKrF1DLYaere5PXqvqLRvo9/umGh2exxWXlOnqhxae0kXsaFvTc9Tn+jmaeE933TOqg0e2Cd8KtDbgdDp1/yvL9dKHaz2yPXt2oYbdO1+3jWijSQ/0NOUwZoFWB3LyinXJnT/r52UZHtnefzftV/eRM/T+k2fp6sEtPbJNXwu0OrB5+0H1v/l7bc/I9cj2vvl5uxav2q3v3zxfp7X1/4RnaalDNz65+JSSfEfbkZmn827+Xk/ddpoeuSnZlC/6A60N7N1foAG3/qiV6+0e2d6S1bvVaeg3+vLlc3XhWQ09sk1vcjqdeuqt1XrizdUe2d6BnGJd8/CvWrA8U28/1svwL9rhnkA7D3z03WaNfmKRy715K1JUXKbxryzXvKW79PUr/Uw5f1OgHX+Hw6mxz/2mN6dv8Mj2Mvfma/Dt83T/9R31/B1duRcwgexDRRp8+zy3enRXZPlfdp02/Ft99kIfXdbffB+BSoFXB/7avF/n3fKDMvceP0ylOz6bs0ULV2Tqx6kXqG1z/094FhWX6aoHf9GX89I8sr0tO3N09vWz9fK9p+uuq9t7ZJu+FmhtYNfuPJ1/y/dat+WAR7Y3/49Mdbz8G333Wj/17V7fI9v0Jp5YLGjf2m3a+tUibf3yV617c4ZmD3xIebvsSrryXIXHVTM6PI8qKXHo8rvneyzJdbR7X/5Dz7/7p8e3C+8LpDbgdDp1x4SlHktyHe2Nz1N145OLZcYRbgOpDuTll+iCMT94LMl1WGmpU9c8/Kve/2aTR7frK4FUBzZvP6izrp3tsSTXYXuzC9X3hjla5aHEgbeUlTk08sFfPJbkOtpjb6zSI6+v9Ph2fSGQ2oA9u1B9Rs/xWJLrsILCMl10xzzN/GWHR7frDQ9NWuGxJNfRPvh2s65+aKHKLPrFq9UF0nng3a826tpHf/VIkuto837P0IAxPyi/oNSj2/WFQDr+DodTox9f5LEk19EmvP9f3fXiMp6J/NyBQ0U694a5HktyHVZc4tCw+xZo+g9bPbpdXwmkOrB20371vm62x5Jch+3ak6/e183W+i3u9xT2heKSMl12988eS3Id5nRKd7+0TBPeN+f70UBqAxl78tT7utkeS3IdlpNXogG3/qifl3r2nZM3kOgKAKUFRdq7arNsQUGq1riu0eF41G3P/aaZC7338uGhSSv08QzPvziDb1m5Dbz0wVq9/tl6r23//W826fEpq7y2fV+xah1wOp0aMX6Bfluzx2v7uPHJxfp+cbrXtu8rVq0D2YeK1P/m77V7n3tDlp7ModwSnT/mB6VnuTcMmi/c+/IfXvng5bDn3v1Tb6akem37vmLVNlBS4tCgsT9qvYcf6A4rLXVq6L3ztWKd62Pb+8obn6/XC+/912vb//z7rRr/ynKvbR++Y9XzwJxFO3XTU4u9tv3Fq3frygcWmDLRcTSrHn9JeuyNlV754OWw1z5dp5c/+str2/cVq9aBsjKHLrnrZ63esM8r23c4nLrqwYVatDLLK9v3JavWgSx7vs675Xu35mWsin0Hyp+59u73zjOXJ4x55jfN/nWn17b/wKsr9Onsv722fV+xahsoKCzVBWN+0Nb0HK9sv6i4/APAdacwNLQvkOgKELFNyhtv0QHPfu1tpNm/7tA7X210qczyaUO0c94ILZ9W9Zmnb3/hd+3Mss6/W6CyYhv476b9emSyaz0N3GkDz77zp/5Y678v+KrKinXgva83aZaLN7Ou1gGHw6nRTyxS9iH35jnwJ1asA3dOWOpyTy5X64A9u9Bve3fOX5ahVz9Z51IZd86D97y8TH/vOORqeH7Him3ghff/1DIXr1Gu1oGi4jKNeuRXFRb5X4+OTWkHde/Lf7hUxp028J+P/9LCFZmuhgc/ZLXzwP6DRRr9+CKX5qBwpw18t2CHVxMpvmK14y9JS//co+ddTPa7Uwcefn2F/tq839Xw/I4V68Brn67TL8tdu0a5WgdKSh269tFflefmnEf+xGp1wOl0aswzv7k0V7k754CMPfm67bnf3QnR62Ys2O7ySCzu/Bvc9tzv2uXmPLD+xGptQCofiWTtZteSUK7WgbyCUl376K8qLfXfkR5IdFlQSGSYwmvFKjyummq0bqTTn7tBcR2aae+qzTq01RoPqNmHinTjk0tcLpcQH6XEutFKiI+qcplDuSW68Qn/fMGHigVCGygpcei6R39ViYsXGHfagMPh1LWP+ucLvsoEQh3YkZmruycuc7mcO3UgY0++7nrR9X0ZKRDqwMxfdujjma5/VedOHfh+Sbo++Na/XvDl5pdo9OOLXC7nzt9fUFim6x/7VQ6Hee4FAqEN/HfTfj09dY3L5dypA+u3HNCTb3l+aMBTUVbm0PWPL1JhUZlL5dz5+yXp+scWWeIFXyAJhPPAnROWuvRyU3K/Ddz54lK/7uH8b4Fw/AsKy1+6uXp9dqcOFJc4dO2ji1RS4r8v+P4tEOrAprSDetiNYabdqQNb03P04KQVLu/LSIFQBz6fu1Xfzt/uUhl3rwNf/LhNX/zovZEk3LH/YJFufto370cP5hT77QeQlQmENvD7n7v1n/9zvdexO3VgxTq7V6ZO8ZQQowPwNrvdrhdffFFff/210tPTVbt2bV166aV67rnnNG7cOL3//vt6/fXXNXbsWKND9ZjO40eo8/gRx/wubfZSLXvwXYMi8rzXPlnn8XF3T+SH33Zp/rJMndvD/yfeQ2C0gZQftmpVqneGZqhI6tYD+mjG37p5aGuf7fNUBEIdePadNcrJ890Lx49mbNZ913ZQuxb+PwmvZP064HQ6df+rvh1K7KFJK3TVoOYKCw326X4r82ZKqtI8PC/ZiSxatVuzFu7QkL6NfbbPU2H1NiBJj7y+0uUPPk7Fyx/9pTtGtnP5pYi3zPhlh8fnIjmRrek5mvrlBt19TQef7ROnxurngbWb9uv/ZvluGKVDuSV69p01evPRM322z1Nh9eMvSR98u0kb0w76bH8r19v1xY/bdOXA5j7b56kIhDrw+JRVLn/wcSomT1uvu69uryYNYn22z1Nh9TpQVubQA6/59pno/leW67J+TRQUZPPpfivzyv/95fIHH6di7uJ0/bI8U327m+P9qNXbgCQ9+NoKn36Q+czba3Tr8DaqHhvms31WlaV7dK1Zs0YdOnTQSy+9pKysLLVt21YlJSWaNGmShg8frtTU8vkWkpOTjQ3Uwzb+34/6YdiTmjfyWa14+v9UuD9H0fXiVFb0z1i1Z795l86eevcx5cJqxGjYmnfU7NKzfB2yS0pKHHrbxSELPeHN6eafnyNQWL0NSNIUA+aLmZKSapovd6xeBw7mFOuTWVt8vl8znQetXgcWrshS6tYDPt3n7n0FLn8t6S0Oh9MrE86fjBHnXndZvQ2k7crRrF+9N09rRUpKHXrva9eGhfEmI+rjm9M3mKpnY6Cz+nnAiPuST2Zv0aFc78wB42lWP/5Op9Og8yD3Av4iy56vr35K8+k+nU7p7S99/z7KXVavA7N/3akdmb7tabttV45+WOIfc1gXl5S5PKWLJxjxHOYuq7eBdX9na+EK384fmF9Yqo9n+tdoL4dZNtFlt9s1ePBgZWVl6Z577lFmZqZWrVqlrKwsTZgwQbNnz9by5ctls9nUsWNHo8P1qENbs5S5aK12zV+tv6Z8p59HvaD45ObqOeHmI+v8/uA7qtOtlZpe/M/XaD2eu0F7/tigrV+7PgyQL323YLtPe3Md9u2C7ZYYizYQWL0NrNmwT7//ucfn+/3vpv36bY3v9+sOq9eBj2duVn6h74eS/Hjm38rJM8fLHavXAaMSLv6S6PlhSbq27fLORLsn3O9vu0wzV5fV28DbX250aU4eT5n65QaVlRk/bNWmtIP6aWmGz/f7945D+mnpLp/vF+6x8nkgJ69Y/2fARz+5+SX6xIe9yE6FlY+/JC1amaV1Ww74fL+LV+/WfzeZY64uq9eB977e5NOe3Ye9+/VGFRX7rhfZqbB6HQj0Z6Jvft6u3ft815vryH7npxnyXtYdVm8DRn184a8fwls20TVu3Dilp6dr7NixmjhxomJj/+lWPH78eHXq1EmlpaVq0qSJqlWrZmCk3rd3xUZt+fJXNb34TNXu2kqSVHwgV7/d86ZOf/YGRdatqcYDeyjhjHb6/f6pBkd7cnMN+nKirMxpyAsFnDrLtYHFxn09NHfxTsP2fSqoA56Rk1dimmTnv1mpDjgcTn1v0LXw15VZyvWDOXqMuheQpB9+848vOF1lpTYgSXOXGHM92pmVZ8iL1X8z6hwgGXsfglNjpfPA4lW7DbsembUNWOn4S8beC3xPHfALRtWBvdmFWpVqN2Tfp8pKdaCouEzz/zBmjqV5SzP8Yr4+o65HpaVO0374ZKU2IBlXBzZsO6jtPpxGoKosmehKTU1VSkqK4uPj9fzzz1e4TpcuXSRJnTp1qnQ7AwYMkM1m0xNPPOGNMH3qz1e+lKO0TJ3vG37kd7sWrFHazN/Ue/I49XjhRv12z5sqyva/SvpvK9cbd0Ox0qQ3M6ANeG7fvpsXzNOsUgecTqfBdcC850Gr1IG/dxzy6fxsR3M6y3uVGo024B6rtIHColL99Xe2Yfv3hzpAG4C7rHIeMPK5bKUP58n1NKscf4n3Au6ySh0oK3NotYFtkedi463dvN+QHn1SeZJt/Vbj7kUP492Qe6zSBrIPFWlruu9HOTnMH58JLJnomjZtmhwOh0aOHKmYmJgK14mMjJRUeaJr+vTpWrNmjbdC9LmctCxt+26J6vfuqDqntzny+xVPfqzYpgnaNX+10n9eZWCEVWP0i40V6/yvEaNqrNIGJGmFwS+3/LF7clVYpQ6k787Tnv2Fhu3fzDe0VqkDRl+LjN5/WZlDqw1MttEGjPffTdkqLTXuWuQPD3VGxrAqdZ9fDN8I91jlPGDktShzb74y9phzSHurHH+n06lVBiY5jL4XOhVWqQMb0w4aMpT7YdQB4xl9DIzef35Bqdb7eM7moxn5XupUWaUNrDL4udQf64AlE13z58+XJPXt27fSddLTy7v2VZToOnTokO68805NnDjROwEa5L+vfSVH2bEZ69KCIuVu36PsVN9O5u2uLHuBysqMe7GRzhxdpmaFNiBJuwx8sN6bXWjYV1OeYIU6YPR5yOj9nyrqgPn3n32oWAWFxs2LYPTff6poA+bfvySl7zFuXoS8glIdMqhXKTzDGucBY+cGMXr/p8IKx7+wqEz7DhQZtn9/uA6cCivUAaOPgZHP5J5ghTqwy8B7IX/Yf9a+fDkcvB91lxXagNHHwOj9V8TmNOun+SfQsGFDpaena/Xq1UpOTj5ueWlpqerVqye73a4tW7aoWbNmxyy//fbbtXbtWv3yyy+y2Wx6/PHHT2n4wq5duyorK8ulMqHOID3u6O72Pl1xwVdPaue8lVr31gy3t/Fk0B8qsXn/5XdJUJz21BhX6fLl04YoIT6q0uUJ8ZEKCQ5SaZlDWfbKJ2zMsuer2xXH/3sEOXJV78BLrgXtR+pO3i5bULCcjjLtHtvY6HBOyGxtQPJNO3DKpoxaT1S63NttQJLq7X9WQSquashu8eXxl8x1HiwKaSJ7tesqXHay4y+deh0ILc1UnUNvuRa0G6gDlTsUcbZyos6pcJkv6kB04TLVyJ/jWtAeVGaLVVbNeytd7u3zoM1ZpPrZz7kWtBtoA5XLD2uv7JihFS7zRRsIL96s+NxPXAvaw3bVfESyhVa4zBf3AgnZLynY6d/DuVTGLPfDvj4HSOY6D+yudqtKQ+pWuMxTbUCqvB3EH3pP4aXefxHGM1HFHLYIZdZ8sNLlvjgP1t//uGxVD9kt3AtUriA0SftjR1a4zBf3AmElaaqd84FrQbuBOlC5g5H9lRvZq8JlvrgOxBT8quoFP7sWtAeVBMVrT43bK13u/fejOap3wPsdRGgDlcsL76ID0UMqXOaL82Bk0V+qlfeFa0FXwuFwKDOzfM695ORkrV692q3thHgkGj+Tl1eeUSwoqPggpaSkyG63KzY2Vk2bNj1m2YoVK/TOO+9o5cqVHosnKytLu3a5NklfmC1Yqvi+3S9lZGao2OmDr6tDi6QalS9OiI9SYt3ok24mJDioSuv9m6O02OVj6U/qHs5rO51+/3eYrQ1IPmwHNcskW3CFi7zdBiQpM2On5PTuMBEc/xOIipCqVbyoqsdfcr8OlBQX+uT8QR04gfj9UiX3rL6oA3k5B5WXZeA1JDhGqln5Ym+fB51lpbSBSvisDVSrK1U8OrlP2kBRYa7x91HVS6TgihNdvrgXyMpMl8r87yvOqjDL/bAZzwGSD88DkYWVvs3wRRuw78mSCrgWVMQndcAWZui9gBylyuBeoEI+OwfE1JBiK17ki3uB4qJ87gcr4bM6UPeAFFnxIl9cB3IPZSt3j4H3EWHFAfF+lDZwAjUaS5UcOl+cBwvyvfNMtHv3brfLWjLRlZCQoOzsbK1atUo9e/Y8ZllmZqbuu+8+SVLHjh1ls/3zDU5ZWZluvvlmjR07Vu3atfNoPK4KdQZJJhodrH69+j7JVjsUpkynQ7JVPOpmlv3EXYddyVZXJDSoQHUaNKh6wP7mcH232dTAz/8Os7UByXftINOZJ4et4kyHt9uAzVGgevXr+uTrRY5/xUqDIlXZZf9kx1869ToQEVKsOB+cP6gDlcsLC9KBSpb5og5Ui5ZiDbyGOBWsDGepZKv4Ntbb58EQW77q0gYq5Ks2UBQSpspGhPdFG4gKK1NNg++jspSvskoy3t5uA3KWqH5CLdlO9HbFn5nkftiM5wDJd+cBe3CRKhu4zlNt4ETbqhsfpRAH14KK+KIOOCVlOgvltEVUuNzb58FgZ54SuBeokK/OAcXBEdpbyTJf3AtEhpaqFnWgQr6qA7nhQTpYyTJfXAeqxwQrJtS4+wiHwpV5guVWeT9KG6hcYWioKpulyxfnwZgIh6p7qA4c3aOrbl33M5uWHLpw3Lhxev3119WwYUP99NNPSkpKkiQtX75cV199tbZu3aqSkhLddtttmjx58pFyr732ml566SVt2LBBMTHln4l6YuhCd5TkF+rT5lf5dJ+nYuSWTxQaVfFNpqe1uehLbdhW2eXsxHbOG6HEutFK352nhv0/d7n8TZe30tTHKu4abQbdZ5RfH4Ik/VFx71a/YbY2IPmuHQwe+6Nm/brTrbKn2gb6dqun+e9d6Na+XcHxr5zT6VStXp/oQI57w0eeah147ObOevK209zatyuoA5Vbu2m/Ol7+jdvlT7UO/PT2AJ3bo77b+/eEriO+00o3J7891b//ygub69MX+ri1b1fQBiqXm1+iaj0/lrtPMadaB9585AzdMqzNyVf0ohHj5yvl+21ulT3Vv797+9pa9pmf30iegFnuh814DpB8dx54dPJKPfP2GrfKnmobqFU9XPZfRx7z0ay3mLEe+KoOnH3dbP260rUpIg471TpwUd9G+va1/m7t2xUc/8oVl5QptsfHKi5x72XyqdaBifd01z2jOri1b1dQByq3ZPVu9Ro1y62yp3r8JWnZp0PUvUNtt8p6StLgL7R5+yG3yp7qv8EtQ1vrzUfPdGvfrqANVG73vgIl9P3M7fKnWgc+fb6PrhzY3O39Hy0vL+9ILiY3N1fR0e71tKy4W4zJjR8/XnFxcdq5c6fatWunDh06qGXLlurevbuaNWumc84pn9eiU6dOR8rY7XY9+uijeuyxx1RaWqoDBw7owIEDkqTCwkIdOHBADofJUsgW1aVtfEDuGziMNhDYbDabTmsTZ9j+u7Q1bt8o16ZZDUVGVDx8qS+c5gd1wMh6SBswXkxUqFo3rWHY/v3hWtiljZH3ArQBGM/o64Avklw4MWPrgPHXgUAXFhqsjkm1DNs/dcB4ya1qKSjImHNxSIhNHZNOMH6qjxh7P0gbMFrduEg1qHPiebi8yR+fCSyZ6EpMTNSiRYs0cOBARUREKC0tTbVq1dLUqVM1e/Zsbdq0SdKxia709HTl5OTo5ptvVs2aNY/8SNKECRNUs2ZN7djh/clmcXLnnm7cV+TndDf2C3ZAMrYNGLlv/MOo4xAWGqQzO5tsgGwLCgkJ0tld6hmy79PaxKlmtXBD9n00zoMw6jjE1Qg39MXaYbQBBLpenRMUFmrM6wzagH/gPAijjkNsdKi6teMlv9Gio0LVo6MxParOTK6riHDjZwMy8lzUt7sxz6M4llF1oGFCtFo2rm7Ivk/EkokuSWrTpo1mzZqlnJwc5eTkaNmyZbrpppuUl5entLQ0BQUFqX379kfWb9GihRYsWHDcjySNGjVKCxYscGuuLXje8PObqUZsmM/3279nfbVoVPG8SIAv9Tqtrto1r+Hz/TZLjNV5Z/jvXBaB5PpLkhQa4vtL+PDzmymuhm+GqcWJjRnW2qD9Gjtc22EXn9NYdeMqmX3ai3p2qqNOrfzvy7VAdMtQY9rA6EuSFB5mXI/Kw05rG6/u7X3/cqd+nSgN6dPY5/sF/i2+ZoSGntfU5/sNCw3SdRcl+Xy/ON4FZyaqcf0Yn++3Y1It9exUx+f7xfFuvry1jOhcec3gFoqOCvX9jnEco55N/OWZ6IoBzVTdgPej55/RQM0b8n7UHxhVF2++vLVhPSpPxLKJrsqsW7dOTqdTLVu2VFTUP937YmJi1KdPn+N+JKlJkybq06ePIiJ4uecPoiJDdN3FLX2+31uH+8eFDLDZbLptRFuf73fMsDZ+eSELRAnxUbqsXxOf7/e2EZwH/cXA3g3VqJ5741a7q3psmK4Y0Myn+6xMWGiwbrq8lc/3SxvwH+1a1FSfbr79ktRmk24Z6j91wIj6eNNlrRRqUC8a4N+MeD4bel5T1THgQwscLzg4yJAPf24d3oahK/1E08RYXXhWQ5/vl3dD/mPoeU0VX9O372oT4iN1ybn+8dFPdFSorh3C+9FAdnrH2j6f2iI0JEijL/XPj34C7ill7dq1ko4dthDmc/fVHVQtxndf0HRtF69BvRv5bH/AyVwzuIWaJcb6bH8N6kTpxst8/1IZlXv4xk4+7dV14VmJhk+2i38EBwfp8VtO8+k+H7i+o199vXr7FW19+mDbvkVNQ3oPoHJPjuns0/1df3GSmvrw2nsywy9oprY+7OFdu2aEIR/aAJXp2amOzvfhaANhoUF66AbeI/iTmy9vrfo+nJ+kecNYXT2ohc/2h5N7/JbOPv0Yc8QFzdS2ufFzM6FceFiwHrnRt+flR29KVlio8b37D7tnVHvFRvvuGa17+9oa2Nv3CWZUzGaz6anbfPte4LYRbZQQb9zcYCdi/ICiPuZqosvpdHozHJ9rPLCH6p3VQcsf/1Bnv3WXqrdMVFlhsQrtB/X7A+8oJy3L6BCrJDEhWq/c10OjH1/k9X2FhQbpw6d7K8SAYcLgPYfbQmyTBEXWriE5HCrJK9SyR97X/r+2SZJimyborNduV3itWJXk5GvxHZN1YFO6sYH/T3RUqN5/6iz1uX6OT/b3zuO9DOkS72n+fExd1b5lLT1+S2c9Mnml1/dVPTZMbz/Wy3Jfrx4+DzhKytTo/K6KaVhHM/rdq/3r0o6sc/kfU1RWVKKywmJJ0n9f/0ZpM34zKOJjXXdxS33x4zZ9v8T7dbhb+3jdO6qD1/fjitq1IvXGQz01/L4FXt9XcLBNHz7T268eat1lpfNg7671NPaKtpo8bb3X95VYN1ov33u61/fjivCwYH3wVG/1vHqmHA7vP7O8+cgZPv9qGq4JDg89pWc8s10XbTab3nmil9pf+rUO5ZZ4fX9P3nqaJV5wW+k6UKNauN5+7EwNGjvP6/uy2aQPnuqtqEjzv0azUh3o1r627ru2gya8/1+v76tOrQi9/mBPr+/H26x0/CXp9ivb6ct5aVq8erfX99WnWz3d4ifDFh7WMCFG/7n3dN345GKv7yssNEgfPH2WgoPN/37USu1gYO9GumZwC30882+v76tFo2p69vauXt+Pu8xfM10U6D26Gl14unZ8/4ckaeP/zdM3vcZpRr97teOH5Trz5TEGR+ea6y5uqUEufkWQZc9X+u48Zdnzq1zmqdtOU7sW5n+gwbEOt4WFN72sGefeoxn979O6qTPV69Xbjqxzxos3a9Mn5e1k7eRv1eu1sQZGfLyzu9bTHSPbuVTGnTZww6VJGmDAkBDe4O/H1FX3X9/R5Tla3KkDk+7voQZ1fTtMni8cPg9sn/275lz0iHJ37qlwvYW3vKIZ/e/TjP73+U2SS/rfC77He6lmNdeS0K7WgciI8pfp/vjBx7Dzm2nY+a71snKnDTx0Qyd1aWuNScetdh584Y6uLs+h6modsNmkd5/wzw8+uneorQeu7+hSGXfawBUDmumy/vRoNINTecYz43WxYUKMXh3fw6Uy7rSBHh1r+90HH+6y2nVgYO9GLk9t4E4duPOqdjqrizXmbbdaHXhiTGe1d/GdjTt14K1Hz7TEBx9WO/5BQTZ98HRvRbuQhHbn+MdGh+q9J3v55XQOoy9N0oBeiS6Vceff4JmxXSzxwYdkvXbw6v09lOjiOxtX60BwsE0fPHWWX3/w4b+Recn8+fONDsGrwqpF6aIFryg4Ikz5GXYFhYcqtlFdbflyoX5/4B3V7dZKi++YLGdpmXbNX32k3N5Vm9V+zBADI3edzWbTZxP66Nwb52r5X/Yqlel2xQyX9nHT5a00/jrXXh7AeCdqB7/d+5ZsIcHHtIUj5WKjpP/14oyIq6a4Ts3144inJUnbZy9Vj+dGK7ZJgl/1fJx4T3dtz8zVt/O3V2l9V9vA+Wc00BsPn+FOaH7HLMfUFSEhQZrxen/1vna2Nm0/WKUyrtaBx27urGsMGPf7VLl7HjCbxIRozX7jPPW/6XvlFZRWqYwrdSAkxKavXj7Xrz/4+OCp3srcm69Fq6r2FaerbeCqQc31xBjfDgfhLVY8D0ZHheqHt85Xr1Gzlbm3ag9prtaBNx46Q+ef6drLA196emwXbduVo2lzt1ZpfVf//rO7Jui9J89yJzT4WFlRSaXPeFa+Ll53cZK2pufombfXVGl9V9tAqybVNWNSf7/84MNVVrwOSNKbj5yp9N15mvd7RpXWd7UOXHpuE714V3d3QvM7VqwDEeEhmjPlPPUaNUs7MvOqVMbVOjDxnu665NwmbkTnX6x4/KXyXibfvdZfA8f+qKLik1/DXD3+EeHBmvl6fzVLdO3jKl+x2Wz6/MW+OvfGuVqxzjvvR28Z2lr3XmuNDz6s2A5qVgvXD2+dr97Xzda+A0VVKuNqHfjw6d7qdZp/f/Bh/js1HKP4UL62frNI69+drRn979Mfj32gvas26bd731K9M9trz/KNFT64tL3hQu34YbkBEZ+a2Ogw/fjWBTqzc12Pb/u2EW305iNnWm6orkBwonYg6bi20GvS7Rq64i11Hj9Cv97+uiQpukG8CnZny1nmOLLd3F12RTfwry/6Q0KClPJSX6/MGzP47Eb65tV+lhiqSzLPMXVV3bhI/fL+hWrnhXlanrrtND1xq2/nwPEUV88DJ9Jr0u26aP7LOuPlMQqP87+Hm56d6urHqRd4vLdJRHiwvnutv9/36IyKDNGcKefr3NPre3zb113cUh881dsvv9x0h1XPg80Sq2nh+xeqUT3P9jy12cq/3h7j5xNuBwXZ9PGzZ+uawZ6fN6Zfj/qaNfk8RUYE3PeRlnD0M57Vr4tP3XaanvDCvH0dWtbUL+9fqNq1Ij2+bSNY9ToQHlZ+z+KNeWOGX9BU017sY4lEp2TdOtAwIUYL3x/oci/vqvjPfafrHov06LTq8Zekc3vU16zJ/V3q2VUVMVGhmjvlfJ3dtZ5Ht+tp1WLC9OPUC9SzUx2Pb/v2K9vqjYfPsMz7Uau2g7bNa2rBuxcqId6z9yzBwTb933Nn6yoTzFFpjSs1jlGrfVPtX1s+x1Bcx+ZH5htqdEE3bZ/7x3Hrdxh3qWKbJGjlc5/6NE5PqVEtXD+9fYEeGN3RIy+iasSG6aNneuv1B3ta5sWW1Vw481mNWPd+hT9R9eMkVd4OpOPbwuJxr+uLrrdo1YRp6vrIVb79YzwgLDRYn7/YV6+OP12REaeelAoPC9aEO7vp61fO5cWWSdSrHaXfPxmsm4e29sj2EuIj9d1r/fTozZ399mbW0+eBysy95LHy4U3PG6+i/Tk6y0+HNDgjua5WpVyks7t65gurLm3jtfyzIbrQz5Nch8VEhWrOlPP0+C2dFRJy6nU2NjpUbz92pt578izLvNiyupaNq2vFtItcHsqyMs0SY7XgvQs9dl71tpCQIH34TG+99eiZiok69QnJQ0JsevLW0zTnjfM9sj14RlWufYdV9Ixn5euizWbT42NO0zevnqu6cZ55wTNmWGst+XiQ3064jmNFRoTo21f76fk7uios9NSv3VERIZr0QA999kJfy3z4Z3VNGsTqj8+GeOzDj4YJ0frhrfN119XtPbI9eF+/Hg204vOL1KOja8P7V+aM5Dpa+flF6tPNv5Nch9WsFq757w7Q+Os6eOz96MfP9tZr9/fg/ahJdEiqpVUpF2vw2Y08sr3WTatr8YeDTJHkkgJw6MJAUKtdkyMPLXEdm2nn/77iq98nWSue/uSYddvdMkSNLzxdPw57UmUFxT6P1VMiwkP0/B3ddMk5TXTL00u0esM+t7ZzybmNNfnBnqpfx3pz0VjJnMEPn3SdytqBVHFbkKQtXyxUzwk3KbxmjPJ22RVZt6ZswUFHvvKIaRCvvF1V6wbua0FBNt1xVXtdeFZD3frsb/ppadWG7fi33l0S9NajZ6pNsxqeDdAPmO2Yuio2OkxvPXqmLu/fRLc9+3uVhzI8WnCwTVcPaqGX7z1dtaqHeyFKz/HWeeDfDtcPZ2mZ1r8zS5cued3NiL2vWWI1zX/3Qr05PVWPvbFK+w9WbciCo8VGh+qB6ztq/HUdTZfgCQsN1hO3nqaLz2msW55eomVr97q1nUG9G+qNh89Qo3oxHo7QeFY/D9auFamUl87R0P7bdPfEZdqZVbXhi44WFhqkMcPa6NnbuyjaZAkem82mm4e21vlnNNBtz/2mOYvcm1C7R8faeuvRM9WpVdzJV4ZPVeXaJ1X+jBcI18WLz2mis05L0N0vLdOnc7aorMzp8jZaNamuKQ+foXO80FPYaFa/DoSEBOmB0Z00pE8j3fL0kioPa/xv/XvW15uPnKnmDf2jx6InWb0O1KwWro+ePVtDz2uqcS8s1bZdOS5vIzQkSNdfkqQX7+qmajH+Nz/nqbD68Zek1k1raPFHg/Sfj//Ss+/+qYM5rr/rrBEbpkdvTtYdI9spONhcz0QR4SGacFd3XXpuE93yzBKt2bDf5W3YbOVDtr7+YE/Vq229jz2s3g7q1Y7Sd5P66dPZWzT+leVVHt79aBHhwRp3ZVs9eetpigg3T/rIXK0VJxWVUEtyOpWfVX4iq9WmsbI37FB855Y6uHmXSvMLj6zb9uZBanrJmfpx+FMqPuR6pfdH3TvU1sqUi7Tk40G68sLmCg87+ZdXcTXCde+oDvp79lB9/Uo/klwWUFk7kHRMWwirFqXIuv/MO9Pogm4qys5VUXauCvcd0v6129T8st6SpMYDeygvc7/fj9fbsnF1zXt7gNZ+dYluHd5GsdEnf0kXHRmiGy9rpVUpF2nhBwMtmeSSZNpj6qp+PRoo9bvL9OPUC3TxOY0VHHzyL6/q1Y7SYzd31vbvh+uDp3v7fZKrKqp6HjiRkMhwhVX758a+6SW9tO+or9/9UVCQTbeNaKv0eSP00TO9dXqHqn3N2DGplt569Exl/HyFHrox2XRJrqMlt47T758M1rJPh2jUkJaKCD/5vUCN2DDdMbKdNnx3mWZOPs+SSS4pcM6Dl5/XVFvnDNO3r/XTeWc0UFU6pjZtEKsJd3ZT+rwRevX+HqZLch2tSYNYzX7jfKV+d5nGXdlWNaowrGlkRLCuvail/vhsiH7/ZAhJLhOr7BkvkK6LcTUi9NGzZytt7nA9enNylV7ShYTYdMm5jTXv7QuU+t1llkxySYFzHWjbvKZ+/XCQVn5+kW64NKlKQ5nFRofq1uFt9NfXl+rHqQMsmeSSAqcODDq7kTbPulyz3zhPA3s3rFJvlEb1ovXM2C7a8eNwvfXomZZLckmBc/yDg4N033UdtWveCL3zeC91bl21+5oubeP13pNnaddPV+juazqYLsl1tNM71tGqlIu1+KPy96NV6ekaVyNc913bQZtnDdWX/znXkkkuKTDagc1m01WDWmj798M1feI5VR75Jalxdf3nvtOV8fMVmnBXd1MluSTJ5nQ6Xf/ECV5Xkl+oT5u7PoRaYr8uanP9BZp35bOSpEFzX9D+dWkq2p+jQ2lZ2vzZz5KkqHq1NGzV2zqUlqXS3AJJUllxqWYPfNCteEdu+UShURFulfWm4pIy/bU5WyvX27Uh7aDyC0oVHGxTbHSoOraspS5t49WiUbWA6YLbfYbkUHmG+48hRkdzYu62AanydvDbvW+py0Mjj7SF6MR49Xn7HoVEhMnpcKpw3yGteOpj7V+XJkmq1ry+er16m8Jrxqokt0CL73xDB/73QqAi/tgOysoc2rDtoFaut+uvv7OVV1Aqp9Op6MhQtWtRQ13axKtNsxp+91L7VI7/ibh6TF3hj8dfkgoKS/XfTfu1cr1dm3ccUkFRmUKCbaoRG6bkVnHq0jZeTRrE+N0QhadaB6p6HpCkni/epMRzuyiyTg0VZeeoJLdAX59xu2Ia1VHfd++TLThINpuUs32P/nj0feWmV9xTyF/rQPahIq1av08r19u1a0+eikocCgsNUkJcpLq0jddpbeIsM/dIRUpKHFq3pfxeIHXrAeUXlspmK78X6NCyprq0jVdS4+p+dy/AedBzcvNLtGZDeRvYtitXhcVlCg0JUlz1cHVuE6cubeLVoG6U350HPaWszKHNOw5p5Xq71m7OVk5eyZF7gTbNaqhL2zi1bVZToR4Y6ssMzHI/7M454ETPeL66LvrjecDpdCptV65WrrdrzcZ9OpBTrNIyp6IigtWyUXV1aRuvjkk1/fJljjeuBd68Dkj+WQdKSx1K3XpAK1PtWvf3AeUVlMhmsykmKkTtW5TfC7RqUt3vXmpzL+A5efkl+vN/z0Rb03NUUFR+L1CzWpg6ty5/JmqYEO139wKcAzzHnl2oVal2rVy/T1n2fBWVOBQeGqR6taOOPBPF1fC/uD3lRO9HOyWVvx9t3tD/3o9yHvScQ7nF5c9Eqfu0PaP8mSgsNEjxNSJ0Wpvy86BRyc28vDzFxJR/bJqbm6voaPc6oZDo8lOebsgX/fKKfrjscRXuO+SxbR7NXxsxjmWWB3vJexczb7YF2oHneOv4exPH37O8WQe8dR6gDsCTOA8C3mGW+2FfngM8eV3kPOBZXAsCG8cf1AEEOtpAYPBUosv/PlmCV3zX5y6jQwD8Am0BAOcBAAD+wXURAAAAZudf/bIBAAAAAAAAAACAKiLRBQAAAAAAAAAAAFMi0QUAAAAAAAAAAABTsjmdTqfRQeB4TqdTpQVFRodRZSGR4bLZbEaHgZMwy+TbkvnagEQ78CSOP6gDCHS0AcA7zHI/bMZzgMR5wNPMWA+oA57D8Qd1AIGONhAY8vLyFBMTI0nKzc1VdHS0W9sJ8WRQ8BybzabQqAijwwAMQxsIbBx/UAcQ6GgDQGDjHACJehDoOP6gDiDQ0QbgCoYuBAAAAAAAAAAAgCmR6AIAAAAAAAAAAIApkegCAAAAAAAAAACAKZHoAgAAAAAAAAAAgCmR6AIAAAAAAAAAAIApkegCAAAAAAAAAACAKZHoAgAAAAAAAAAAgCmR6AIAAAAAAAAAAIApkegCAAAAAAAAAACAKZHoAgAAAAAAAAAAgCmR6AIAAAAAAAAAAIApkegCAAAAAAAAAACAKZHoAgAAAAAAAAAAgCmR6AIAAAAAAAAAAIApkegCAAAAAAAAAACAKZHoAgAAAAAAAAAAgCmR6AIAAAAAAAAAAIApkegCAAAAAAAAAACAKYUYHQAq5nQ6paIio8OouvBw2Ww2o6MAAAAAAAAAAAABhESXvyoqUumwUUZHUWUh0z+SIiKMDgMAAAAAAAAAAAQQhi4EAAAAAAAAAACAKZHoAgAAAAAAAAAAgCmR6AIAAAAAAAAAAIApkegCAAAAAAAAAACAKYUYHQAA+ILT6VROXomKissUGhKkmKhQhYSQ6wcAAAAAAAAAMyPRBcCSnE6nlqzerZkLd2jl+n1alWpX9qHiI8vDw4LVMammTmsTrz5dE3TJuU0UHhZsYMQAAAAAAAAAAFeR6AJgKcUlZfrg282akpKq/27aX+l6RcVlWv6XXcv/smvqFxtUp1aEbri0lcZe0Vb1akf5MGIAAAAAAAAAgLsYtwuAZaxcb1eX4d/plqeXnDDJVZE9+wv13Lt/qu3FX+njGZvldDq9FCUAAAAAAAAAwFNIdAEwPafTqWffXqPTR87QX39nn9K2DuQUa9Qjv+qicT/pUG7xyQsAAAAAAAAAAAxDoguAqTmdTo17YakembxSZWWe64U1c+EOnXvjXGUfKvLYNgEAAAAAAAAAnkWiC4CpPfjaCk2ett4r216xzq6Bt/2o/IJSr2wfAAAAAAAAAHBqSHQBMK25i3Zqwvv/9eo+fv9zjx5+fYVX9wEAAAAAAAAAcA+JLgCmdDCnWDc+udjlcsunDdHOeSO0fNqQKpd57dN1WrQyy+V9AQAAAAAAAAC8KyASXXa7XePHj1eLFi0UERGhhg0b6o477lBeXp5Gjx4tm82myZMnGx2mVyy071HYzOn6z5YNla4TNnO6Ll62yIdR+V5pqUPzl2Xos9lblPL9Vq1cb5fT6bn5nMwgLUc6/Bc7JRWafDS+x6es0q49+S6XS4iPUmLdaCXER1W5jNMp3fTUYjkcgVVnAAAArGRPwbH3wweYihUAAACwhBCjA/C2NWvWaMCAAcrKylJ0dLTatm2rjIwMTZo0SVu2bNH+/fslScnJycYGCq/Yf7BIk6et19tfbjguKZLcupZuHdZG112cpJAQa+Z8nU5pfqaUsk1ate+o30u6cJ40uKF0RXMpIdKwEN2Sk1es977Z5NN9bth2UPN+36Xzz0z06X4BAABwatbskz7bKi3MOjbRdeE8qX99aWRzKam6kRECAAAAOBXWfLv/P3a7XYMHD1ZWVpbuueceZWZmatWqVcrKytKECRM0e/ZsLV++XDabTR07djQ6XHjY1vRDOn3kjEp7/qzZsF83PbVEF90xT/kFJu/eVIEyp/T8f6X7Vxyb5DrsUIn06Vbp6oXSX9m+j+9UfDJri3LzS3y+3ykpqT7fJwAAANz3+VbpxiXlH3+V/atzfrFDmp0ujVok/bjLmPgAAAAAnDpLJ7rGjRun9PR0jR07VhMnTlRsbOyRZePHj1enTp1UWlqqJk2aqFq1agZGCk+zZxfqvJu/1987Dp103TmL0nXlAwssNyzdpHXS19tPvl52sTRuqbQ91/sxecons/82ZL+zft2pA4cY4wYAAMAMZu2QJv71Ty+uypQ4pEdWSb/t8UlYAAAAADzMsomu1NRUpaSkKD4+Xs8//3yF63Tp0kWS1KlTpyO/++WXX2Sz2Y77MfvQhvllZbIXFVX4Y0Uvf7xWW3bmVHn97xbs0A9L0r0YkW+l5ZT31qqqQyXSFJN0ViotdWhVagVd1HzA4XAatm8AAABUXWGZ9J91VV/f4ZQmri3/LwAAAABzsewcXdOmTZPD4dDIkSMVExNT4TqRkeUTEx2d6DrsjTfe0GmnnXbk/6Ojo70TqI88tXGdntrowpOeiRUVl+ndr12fv2lKSqoGnNXQCxH53ldV6Mn1b79kSXsLpdoRno/Hk1K3HlBhUZlh+1+53q5zTq9v2P4BAABwcvN2lX/M5YodedIfe6UedbwTEwAAAADvsGyia/78+ZKkvn37VrpOenp5D56KEl1t27ZVjx49vBOcAW5o1EyX1a84iTNg6UIfR+Nd3y9Jlz270OVysxftlD27UPE1/TzTUwWzd7pepswp/ZAuXdXC8/F40vqtBwJ6/wAAADi52W4O1jA7nUQXAAAAYDaWTXRt317epaVx48YVLi8tLdWSJUskVZzo8qSuXbsqKyvLpTKRQUFan9zTYzG0iInRubXremx7/5aUlKQCh8Nr23dFbng3KXqQy+WcTqld8hkKLTP54Pwh4UqYtMWtos++/rYe+OopDwfkWXlhnaWYiytctnzaECXER52wfEJ85JH/7pw3otL1suz56nbFjON+nzL9G8374MqqBwwAAACfi398oULqNne53Lc/L9EHQ4Z7ISIAAAAA/+Y4KqfQq1cvrV692q3tWDbRlZeXJ0kqKCiocHlKSorsdrtiY2PVtGnT45YPHz5cdrtdcXFxGjJkiF544QXFx8e7FUtWVpZ27drlUpmo4GAp2a3dGSIjI0P5ZcYNJ3eMWi0kN0ea3LM7SyrK9Gw8PmYLCVOCm2VzDh1yua76XM0mUsWjkSohPkqJdat28EOCg6q87tEKCgr8/98IAAAgwFUvLnbrYbeokHs9AAAAwAi7d+92u6xlE10JCQnKzs7WqlWr1LPnsT2jMjMzdd9990mSOnbsKJvNdmRZ9erVdd9996l3796KiYnR77//rueff15Lly7VihUrFBHh+rB2CQmupx0ig4JcLmOk+vXr+02PrsJQaZ87BZ1lqlc7SkHOBp4OyefKDu5WcHXXe/BFFR9Qgwb+/fcXhEZpfyXLsuz5Jy2fEB+pkOAglZY5lGWvOBF+om1FRQarpp//GwEAAAS6oENZktq4XC4kd6/f3w8DAAAAVuFwOJSZWd7xpG5d90eks2yiq1+/fkpNTdWECRPUv39/JSUlSZKWL1+uq6++Wna7XZKUnJx8TLnOnTurc+fOR/6/T58+at++vYYMGaJp06bpuuuuczmWFStWuFzGWVio0mGjXC5nlE2bNsnmRhLQG0pLHWo6YLrSd+e5VG74gBb6/MW/vRSVb72RKn2w2bUy4UHSHx88oxphz3gnKA/ZsO2A2lz0VYXLKhpq8N92zhuhxLrRyrIXqGH/z13e/7OPjNGdV7/hcjkAAAD4zk8Z0gOuP4Zp2v1XqNOEKzwfEAAAAIDj5OXlKSamfPiuxYsXu70dc3UbcsH48eMVFxennTt3ql27durQoYNatmyp7t27q1mzZjrnnHMkVW1+rkGDBik6OtqthBV8LyQkSDcPbeVyuVuHuf7Fp7+6rLHrjfu8BlKNMK+E41FJjasrJirUsP13befeEKYAAADwnT4JUly4a2WSqkkda3onHgAAAADeY9lEV2JiohYtWqSBAwcqIiJCaWlpqlWrlqZOnarZs2dr06ZNkqqW6Drs6CEO4d/uvKq9TmsTV+X1b7g0SWd1cXdmK/+TECXd5kLerm6kdKtJ8nxBQTZ1MyjZFBoSpOTWVa9XAAAAMEZIkPRoctUfeMODpIc6STzyAQAAAOZj2aELJalNmzaaNWvWcb/Pzc1VWlqagoKC1L59+5NuZ8aMGcrLy1P37t29EaZXnR1fR8WDh51wnZMtN6OYqFDNnXK+Bt8+T3/8tfeE615/SZLefORMyyUyr2khlTiktzaeeL0GUdLrPaTa/jHyZJVce1FLLVie6fP9Xt6/iaG9yQAAAFB1vepKz3WVHlslFZ9gOuGYEOmlblJ7enMBAAAApmTpRFdl1q1bJ6fTqaSkJEVFRR2z7KqrrlKzZs102mmnKSYmRr///rtefPFFJScna8SIEQZFDHfUiYvUwg8u1GdztmpKSqpWrrcfs3zw2Y00ZlhrXdAr0XJJLqn8a9QbWkmn15amp5XPU1By1AN+o2jp8ibS4EZSrMlyN8POb6q7Xlqm/QeLfLrfW4ebpNsbAAAAJEn96kstq0lfpkkzd0i5pf8sqxUmXdxYurSJlBBpVIQAAAAATlVAJrrWrl0rqeJhC9u1a6fPPvtMr776qgoKCpSYmKgbb7xRjz/+uMLCTDCBEY4RER6i6y9J0vWXJGlT2kGdec1M2Q8UKSEuQjNe7290eD7RoVb5zz3tpfQ8qbCsfC6uZrFSkEnzexHhIbptRBs9PXWNz/bZrX28zuxc12f7AwAAgGc0jim/F761tbQtV8ovlaJDpBbVpFDLDuYPAAAABA4SXf/y4IMP6sEHH/R1SPCBpCbVFR4WLEkKDg68J9oaYeU/VvHg6E6a/sM2bUw76PV9hYYE6d0nzrJkzz8AAIBAERkita1hdBQAAAAAPC3w3vbrxIkuAOYQGRGiD54+S0EudkvLsucrfXeesuz5VS7z6M3J6phUy9UQAQAAAAAAAABeFpA9uubPn290CAA8oGenuvrPvd1154vLqlym2xUzXNrHoN4N9cD1JMUBAAAAAAAAwB8FZI8uANZxx1Xt9cKdXb2y7QvOTNT0iecolMkbAAAAAAAAAMAv8fYWgOndf30nffh0b8VEhXpsm2OGtdZ3k/opMiIgO74CAAAAAAAAgCmQ6AJgCaMuaqm/vr5E555e/5S207h+jH56e4CmPHKmwkKDPRQdAAAAAAAAAMAb6KoAwDIa14/VvLcv0Oxfd+rN6amauzhdTmfVyrZvUVO3Dm+jqwe38GjPMAAAAAAAAACA95DoAmApNptNg85upEFnN9LW9EOasyhdK9fbtWKdXdszc5WTVyJJCg6yaUjfRurSJl59utXTGcl1ZLPZDI4eAAAAAAAAAOAKEl0ALKtZYjWNvaLtMb9L7DdNu/bkKyE+Ul+/0s+gyAAAAAAAAAAAnsAcXQAAAAAAAAAAADAlEl0AAAAAAAAAAAAwJRJdAAAAAAAAAAAAMCUSXQAAAAAAAAAAADAlEl0AAAAAAAAAAAAwpRCjA0AlwsMVMv0jo6OouvBwoyMAAAAAAAAAAAABhkSXn7LZbFJEhNFhAAAAAAAAAAAA+C2GLgQAAAAAAAAAAIApkegCAAAAAAAAAACAKZHoAgAAAAAAAAAAgCmR6AIAAAAAAAAAAIApkegCAAAAAAAAAACAKZHoAgAAAAAAAAAAgCmR6AIAAAAAAAAAAIApkegCAAAAAAAAAAD/397dx3lV1/n/f36GC4FhUAF1SJALAQUUMBLF1MSw1bzsyiyzdtcuN9JtXSjb0u1iM8pdy+yCrdzdapcoq28klrpRSWoFooWAQijI4Iw2AgLD5TDz+8NfbCQoM8zMxzPc77dbt25+znmf85o+h+l24+E5BwpJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkLqWewDg+Zqbm9O4dXu5x2iRrj0PSalUKvcYAAAAAAAcRIQueAlq3Lo9/33s28o9RotcvvLb6darR7nHAAAAAADgIOLRhQAAAAAAABSS0AUAAAAAAEAhCV0AAAAAAAAUktAFAAAAAABAIQldAAAAAAAAFFLXcg8A7enJpxuycEl9Hlj6TB5ZtSHPbNiWJFn37PZ87j9+nwmj+2fC6P45tKp7mScFAAAAAABaSuii09mxc1f+37zV+dJ3luWeB+r2us/W7bsy/aYFSZJuXSvyhilD8ndvHpXTX35USqVSR44LAAAAAAC0ktBFpzLn56vzd/9yX9Y+vWW/1+xsbMp3fvpYvvPTxzLxhCPyjY+fnhNG9G3HKQEAAAAAgLYgdNEprN+4PVd95v58+/aVB3Sc3z78x0y47Ee5/r0nZfrfjE3XrsV6jV31pDE59wcf3+OznQ1bs/Gx2qy87Z4s+8Ydad7VVKbpAAAAAACgbQldFN7apxpyznt+mmWPbWiT4+3Y2ZR/+uIDeWDpM/mfGWflkO5d2uS4HemxH8xPzbxFSamUnkccluFvelUmfvyvc+iIo3P/tJnlHg8AAAAAANpEsW5Xgb/w1DNbM/mdd7RZ5PpzP/jZqlw2/edpbCzeHVDPLH48j31/fh677Z4s+cqczD3/I2lYW5+Rb311DunXp9zjAQAAAABAmxC6KKxdu5ry+g/+b1as3thu5/h/81bnw59f0G7H7yiNW7fnj4tWpFRRkT6Djyr3OAAAAAAA0CaELgrrpm8tyX0PPd2iNQtmXZQ1d1+WBbMu2u81//ath3PfQ0+1dLyXnKohzwWu7Rs2l3kSAAAAAABoG50+dNXX12f69OkZPnx4evTokUGDBuXqq69OQ0NDrrzyypRKpdxyyy3lHpMWWr7q2Xz0lgdavK66f68MPKoy1f177fea5ubkbz42P9t37Grx+cqla8/uOaRvVQ7p1yeHHX9MTvn0O9PvxGH546IV2fhYbbnHAwAAAACANtG13AO0p4ceeijnnXde6urqUllZmdGjR+fJJ5/MzTffnJUrV2bdunVJkvHjx5d3UFrsxv9a3KHhafnqZ/O9ux7P2y4Y3mHnPBAnTb8sJ02/bI/PVs39dX5z7dfLNFH5NDc3Z8HD9fny7GWZO39N6tdvS5LUr9+W2+56PBdPHpxu3Tp98wcAAAAA6JQ67d/u1tfX58ILL0xdXV2uueaa1NbWZtGiRamrq8uMGTMyd+7cLFiwIKVSKWPHji33uLTAs5t25L/nruzw837lu8s6/Jyt9ei37sqdl348d1/+L1n4yW9l27pNqRzQL7u279i9z6u+8sG8auY/7LGu+2G9c+lDX8uw15/R0SO3i2c37ch577szp1w+J/81Z8XuyJUk23c25U3/OC8jLvxeHnrkmTJOCQAAAABAa3Xa0HXVVVelpqYmU6dOzY033piqqqrd26ZPn55x48alsbExQ4YMSZ8+fco4KS3133P/kC3bGjv8vPc99HQWL1/X4edtjY2P1aV2/uKsnfdgHv7yj/Kzd3wm/ccfm0kz3rN7n/uv/VqOPPm4DL3klbs/O/XT78zTv30kj/1gfjnGblObt+zMq9/1k9x539oX3G/1k5vzqr+dm989KnYBAAAAABRNpwxdy5Yty+zZs9O/f//ccMMNe91nwoQJSZJx48Y9b9sPf/jDnHbaaamsrMyhhx6aV77ylVmyZEm7zsz+++UDdWU79z2LynfuA/HHhY9m5W33ZOglr8wRrzguSbJjw+bcd81Xcsq/vDM9jzo8g88/NdWnjcn9H5pZ5mnbxj/+62/zwNL6/dp34+aded3f/yyNjU3tPBUAAAAAAG2pU4auWbNmpampKZdffnl69+6913169uyZ5Pmh6+abb86ll16a008/PXPmzMmsWbMyZcqUbN26td3nZv/sb7zobOc+UL+76bY0Ne7KSdPevPuztT9/KKt+fF/OvOWqnPqZd+W+a76S7es3l3HKtrF+4/Z888crWrTm8bWbcsf8Ne00EQAAAAAA7aFruQdoD/PmzUuSTJ48eZ/71NTUJNkzdK1cuTLTpk3LTTfdlKlTp+7+/LWvfW07TUpLPbtpR1au2VS28z+wtLiPt9u0qi6P/+jeHPuGM3PkKaPy9G+ee+fYwo9/M5fM/3zWznswNT9bVOYp28Z//WhFtm7b1eJ1X569LBdNHtwOEwEAAAAA0B46ZehavXp1kmTw4L3/hXVjY2PuvffeJHuGrltvvTXdunXLu971rjad5xWveEXq6or5yLuXmsaKw5PD/n6f2xfMuijV/Xvtc3t1/567/3vN3Zftc7+6+i05+S1znvf5w488noEDB+7/wK3Urbki12dimx/391/4foZe8sqcNO3NufON/5wkady6PZtXP531y544oGOPHDEyO0svjUf/rat8XXLI+Bavu/tXj2TgwHe2/UAAAAAAAOyhqen//j759NNPz4MPPtiq43TK0NXQ0JAk+3zc4OzZs1NfX5+qqqoMHTp09+f33XdfjjvuuHz729/Opz71qaxZsyYjRozIddddl7e85S2tnqeuri5r165t9Xr+TPfG5LB9b67u3ysDj6p80cN07VKxX/v9paZdpQ75LruXuiRHtXxd3f1L8p8D3rjP7c+uWJtvDnzzPrcfiCdrn8yO5pbfRdUuBu1MDmn5sqbmrv6sAgAAAAB0sKeeeqrVaztl6Kqurs769euzaNGiTJo0aY9ttbW1mTZtWpJk7NixKZVKe2xbu3Ztrr322syYMSODBg3KN77xjbz1rW/NEUcckSlTprR6HtpGY8WheaHLva5+ywuur+7fM127VKRxV1Pq6vf93rV9HadLRVOqjz56f0Y9IN2aK5KXxs1R++1lA172krmja32PUl74Sti7LtneId8vAAAAAMDBrrm5Oc3NzUmSAQMGtPo4nTJ0TZkyJcuWLcuMGTNyzjnnZOTIkUmSBQsW5Iorrkh9fX2SZPz48Xusa2pqyubNm/Otb30rl1xySZLk1a9+dZYuXZpPfvKTrQ5dCxcubPXPwp527NyVqlO/mR079x5U9va4wT+35u7LMvCoytTVb82gc77T4vOffsrx+cWtNS1e11I7t2zLfx/7tnY/T1tavmJ5uvXqUe4xkiS3//KJXPiBu1u87n1vOy1fvPaadpgIAAAAAID2UFHuAdrD9OnT069fv6xZsyZjxozJiSeemBEjRmTixIkZNmxYzj777CR7vp8rSfr27ZskewStUqmUKVOm5OGHH+64H4B96t6tS8aO7Fu2808Y3b9s525PP33D9Vny1ReOhEVy3ukDM/hlvVu87n2XHt8O0wAAAAAA0F46ZegaOHBg5s+fn/PPPz89evTIqlWr0rdv38ycOTNz587N8uXLkzw/dI0ZM2afx9y2bVu7zsz+e0UZY9OEUZ0zdHU2XbpU5Lr3nNSiNW96zdCMPvbwdpoIAAAAAID20ClDV5KMGjUqt99+ezZt2pRNmzblN7/5Td797nenoaEhq1atSkVFRU444YQ91lx88cVJkrvuumv3Z01NTbn77rtz8sknd+j87NtFZx1TlvMe0r1LXnOa9zcVxd++bmQ+9p7x+7XvmROq85+fPLN9BwIAAAAAoM11ynd0vZAlS5akubk5I0eOTK9evfbYduGFF+aMM87Iu9/97jzzzDM55phj8vWvfz1LlizJ3Xe3/H0/tI+/euXADD26Ko+v3dSh533zXw1N/8NfGu+gYv984v0TcuzAPvnU1x7KH57Y+Lzth1Z1zztfNzL/ctUrckj3LmWYEAAAAACAA3HQha7Fixcnef5jC5Pn3sc1Z86cfOhDH8pHPvKRbNy4MePGjcsdd9yx+71elF9FRSnvu/T4TL9pQYee9+/ePKpDz0fbeMfFI3LFhcPzv79em9vvWZMNG3eksmfXTBjdP285b1gqe3Ur94gAAAAAALSS0PUXDjvssMycOTMzZ87syLFoofdfNjpf+8GjWbH6+XfptIe3nDcsp4w9skPORdurqCjlNacNzGtOG1juUQAAAAAAaENCF4XUq2fX/McnzswZf317mpvb91xH9u2RL147qX1P0oEGn39qBpxxYn794a/lnO98LD2POCxpasrOhm35zUdvzbqHHy/3iAAAAAAAsF8OutA1b968co9AG3nlSUfl2ivH5dNf/91+r6mr37LHf7+YiopSvvHxM9LvsM7zbq5jXntKVn7vF0mSX777X7Nj43P/Wxxz3sSc/vn3Z86UfyzjdAAAAAAAsP8OutBF5/KpD0zI0+u25us/WL5f+5/8ljn7fexSKfn6P5+eC151TGvHK4vufXrl4p/flC49umfLk/WpOKRbqo45Kitv+2Xu//DXctTJx+VXV9+SJLsjV5J0r+qVdr89DgAAAAAA2pDQRaGVSqXMvO70VFV2y03fWtJmx+3erSL/8Ykz89bzj22zY3aUHRu35LEfzs/Ohm35/U235WVnjcvYq16f+/7xq3nZq8bl6QWPprlx1+79T7/5Axlw2pgkyd1v+3S5xgYAAAAAgBarKPcAcKAqKkr5t2mn5vZbzsnLjux1wMebeMIRefC7lxQycv1J3xOGZt3i59611W/ssbvfu3XMuSdn9U9+u8e+v7rqi/neK96bRTNm5RUffVuHzwoAAAAAAK0ldNFpnH/mMXn4B6/PVW8dnarKbi1eP6i6Mv827ZTc+80LMvrYw9thwo7Td8yQ3XGr39hheeb/j14vO2t81s57cK9rVn7vl6k+bUwOObx3h80JAAAAAAAHwqML6VQO73NIvvDhSfnUBybkv+euzKyfPJZFy57J5i0797r/kX175NSxR+bK143M+WcOSpcuxW+/var7Js3N2VK3LknSd9Tg/P4L30//k0bk2RVr07hlW5Ln3uXVpech2frU+iTP3e21ff3mbF+/uWyzAwAAAABASwhddEpVld3z3ktH5b2XjkpTU3OWr342jzy+IVu27kqXLqVUVXbL2BF9c/RRvVIqlco9bpvqe8LQ3XdzJcmOjQ05/h1/le3rNuWJn/7fYwu79emVs/79mnTt0T3NTc3Z9szG/OztN5RjZAAAAAAAaJVSc3Nzc7mHAPa0c8u2/Pexbfu+rIt/cVPufMP12fbMxjY97p9cvvLb6darR7scGwAAAAAA9sYdXXCQ+NFZHyz3CAAAAAAA0KaK/0IiAAAAAAAADkpCFwAAAAAAAIUkdAEAAAAAAFBIpebm5uZyDwHsqbm5OY1bt5d7jBbp2vOQlEqlco8BAAAAAMBBROgCAAAAAACgkDy6EAAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEI6KEJXfX19pk+fnuHDh6dHjx4ZNGhQrr766jQ0NOTKK69MqVTKLbfcUu4xAWhHW7c1ZvHydfn1757Ossc2ZNeupnKPBAAAAAAcoK7lHqC9PfTQQznvvPNSV1eXysrKjB49Ok8++WRuvvnmrFy5MuvWrUuSjB8/vryDAtAuVq7ZmK/MXpZb/9/yrN+4Y/fnQ17WO+950/G58nUjc0TfnmWcEAAAAABorVJzc3NzuYdoL/X19TnppJNSU1OTa665Jtdff32qqqqSJJ/97GfzoQ99KF27ds2uXbuyYcOG9OnTp8wTA9CWZv/0sbz9n36ZHTv3fffWkX17ZO6XXpNXjDmiAycDAAAAANpCpw5db33rWzNr1qxMnTo1X/ziF5+3ffz48fnd736XoUOH5rHHHivDhAC0lzk/X53XffBnaWp68f+bO6yqe+795gUZfezhHTAZAAAAANBWOu07upYtW5bZs2enf//+ueGGG/a6z4QJE5Ik48aN2+Pzxx9/PBdddFGqqqpy+OGH5+1vf3ueeeaZdp8ZgLaxbXtj/vb6+fsVuZJkw6Yded+n7mvnqQAAAACAttZpQ9esWbPS1NSUyy+/PL17997rPj17PvdOlj8PXZs2bcrkyZNTU1OTWbNm5d///d8zf/78XHDBBWlq2vejrwB46fjeXY/nmQ3bW7TmngfqsuQP69tpIgAAAACgPXQt9wDtZd68eUmSyZMn73OfmpqaJHuGrn//93/P2rVrc8899+SYY45JkgwcODCnnXZa5syZk0suuWS/Z2hubs6WLVuSJL169UqpVGrpjwFAK3zjh8tbue7R/Nu0U9t4GgAAAACgvXTad3QNGjQoNTU1efDBBzN+/PjnbW9sbMyAAQNSX1+flStXZtiwYUn+L4z9/Oc/32P/Y489NmeddVa+8Y1v7PcMDQ0Nu+8mGzBgQCoqOu0NdAAvKXWHfjC7uhzW4nU9dixLv83fafuBAAAAAIB9qq6uzsKFC1u1ttPe0dXQ0JAk2bp16163z549O/X19amqqsrQoUN3f7506dK86U1vet7+Y8aMydKlS1s9T21tbavXAtBCVc1Jl5Yv27Zte9auXdv28wAAAAAA7aLThq7q6uqsX78+ixYtyqRJk/bYVltbm2nTpiVJxo4du8cjBdevX5/DDjvsecfr27dvHn300VbP444ugI7zdGlLdubwFq/r1b0xhx99dDtMBAAAAADsS3V1davXdtrQNWXKlCxbtiwzZszIOeeck5EjRyZJFixYkCuuuCL19fVJstfHGraHFStWpLKyskPOBXCw+/y3Hs4HP/ebFq/76azrc8aEr7TDRAAAAABAe+i0txhNnz49/fr1y5o1azJmzJiceOKJGTFiRCZOnJhhw4bl7LPPTpKMGzduj3WHH354NmzY8LzjrVu3Ln379u2I0QE4QO+4eER69mjZswtPGH54Tn/5Ue00EQAAAADQHjpt6Bo4cGDmz5+f888/Pz169MiqVavSt2/fzJw5M3Pnzs3y5cuTPD90jRo1aq/v4lq6dGlGjRrVIbMDcGAO73NI/uUDr9jv/bt2KeWm6afs8ShbAAAAAOClr9M+ujB5Llrdfvvtz/t88+bNWbVqVSoqKnLCCSfsse2CCy7IRz7ykdTU1GTgwIFJkt/85jdZuXJlPve5z3XI3AAcuL9/25g8u2lHPv7VB19wv+7dKvLtG87KlFO9mwsAAAAAiqbU3NzcXO4hOtpvfvObnHrqqTnuuOPyyCOP7LFt48aNOfHEE9O/f/98/OMfz7Zt2zJ9+vQcccQRuf/++1NRsf83wTU0NKR3795Jnotr3tEF0PF++qua3PTth3PXfWv3+Lx7t4q86TVDc83bT8hJo/qXaToAAAAA4EB06ju69mXx4sVJnv/YwiTp06dP5s2bl6uvvjqXXXZZunbtmgsuuCA33XRTiyIXAC8N554+MOeePjArVj+bUy6fk/Ubd+TwPt3zyI/emCP79Sz3eAAAAADAARC69uLYY4/d6yMPASiuEYMPTa8eXbN+44706tFV5AIAAACATuCgvEXpxUIXAAAAAAAAL30H5R1d8+bNK/cIAAAAAAAAHKCD8o4uAAAAAAAAik/oAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAArpoAhd9fX1mT59eoYPH54ePXpk0KBBufrqq9PQ0JArr7wypVIpt9xyS7nHBAAAAAAAoAW6lnuA9vbQQw/lvPPOS11dXSorKzN69Og8+eSTufnmm7Ny5cqsW7cuSTJ+/PjyDgoAAAAAAECLdOo7uurr63PhhRemrq4u11xzTWpra7No0aLU1dVlxowZmTt3bhYsWJBSqZSxY8eWe1wAAAAAAABaoFOHrquuuio1NTWZOnVqbrzxxlRVVe3eNn369IwbNy6NjY0ZMmRI+vTpU8ZJAQAAAAAAaKlOG7qWLVuW2bNnp3///rnhhhv2us+ECROSJOPGjdv92Z/C2MSJE3PIIYekVCp1yLwAAAAAAAC0TKcNXbNmzUpTU1Muv/zy9O7de6/79OzZM8meoesPf/hDvv/976e6ujonn3xyh8wKAAAAAABAy3Xa0DVv3rwkyeTJk/e5T01NTZI9Q9eZZ56Z2trazJkzJ1OmTGnfIQEAAAAAAGi1ruUeoL2sXr06STJ48OC9bm9sbMy9996bZM/QVVHRPu1vxIgR7XZsAPZP7WH/kFQcmtq62gwcOLDc4wAAAAAASaqrq7Nw4cJWre20oauhoSFJsnXr1r1unz17durr61NVVZWhQ4e2+zy1tbXtfg4AXkTVrqQiadq1K2vXri33NAAAAADAAeq0oau6ujrr16/PokWLMmnSpD221dbWZtq0aUmSsWPHplQqtfs8AwYMcEcXQJnVdumSpiQVXbpkwNFHl3scAAAAACDPNZ3W6rSha8qUKVm2bFlmzJiRc845JyNHjkySLFiwIFdccUXq6+uTJOPHj++QeVasWJHKysoOORcAezdwyqysfXpLBlQPSM3DNeUeBwAAAAA4QJ32FqPp06enX79+WbNmTcaMGZMTTzwxI0aMyMSJEzNs2LCcffbZSfZ8PxcAAAAAAADF0WlD18CBAzN//vycf/756dGjR1atWpW+fftm5syZmTt3bpYvX55E6AIAAAAAACiqTvvowiQZNWpUbr/99ud9vnnz5qxatSoVFRU54YQTyjAZAAAAAAAAB6pTh659WbJkSZqbmzNy5Mj06tXredtvu+22JMnSpUv3+OchQ4bkFa94RccNCgAAAAAAwD4dlKFr8eLFSfb92MI3velNe/3nd7zjHfnP//zPdp0NAAAAAACA/SN07UVzc3NHjgMAAAAAAEArVJR7gHJ4sdAFAAAAAADAS99BeUfXvHnzyj0CAAAAAAAAB+igvKMLAAAAAACA4hO6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACikgyJ01dfXZ/r06Rk+fHh69OiRQYMG5eqrr05DQ0OuvPLKlEql3HLLLeUek3a0cfOO/M/clfnX/1qcL3z74cy954k0NjaVeywAAAAAAOAAdC33AO3toYceynnnnZe6urpUVlZm9OjRefLJJ3PzzTdn5cqVWbduXZJk/Pjx5R2UdvFE7ebc8PXf5dtz/5DNWxr32Hb0kb3ynjcdn2vefmJ69ez0fxQAAAAAAKDT6dR3dNXX1+fCCy9MXV1drrnmmtTW1mbRokWpq6vLjBkzMnfu3CxYsCClUiljx44t97i0sYceeSYT3zonX/3eI8+LXEmy9uktue5Li3L2O+/Iume3l2FCAAAAAADgQHTq0HXVVVelpqYmU6dOzY033piqqqrd26ZPn55x48alsbExQ4YMSZ8+fco4KW1tTd3mnPd3d+apZ7a+6L6/WfzHXHL13dm506MMAQAAAACgSDpt6Fq2bFlmz56d/v3754YbbtjrPhMmTEiSjBs3bvdnt912W97whjdk8ODB6dWrV44//vj80z/9UzZv3twhc9M2Pvefi1NX/+KR60/mL3oqP/r56nacCAAAAAAAaGudNnTNmjUrTU1Nufzyy9O7d++97tOzZ88ke4auG2+8MV26dMmnP/3p/OQnP8n73ve+fOUrX8m5556bpiZ3/BTB5i07819zVrR43ZdnL2uHaQAAAAAAgPbStdwDtJd58+YlSSZPnrzPfWpqapLsGbp+/OMf54gjjtj9z6961atyxBFH5PLLL8+vfvWrnHnmme00MW3lp7+qycbNO1u87ucLalNXvyXV/Xu1w1QAAAAAAEBb67Sha/Xq5x5DN3jw4L1ub2xszL333ptkz9D155HrT17xilckSdauXdvqeUaMGJGKik57A91LyuZDJiaV57dq7bgJZ6TbrqfaeCLgpaL2sH9IKg5NbV1tBg4cWO5xAAAAAIAk1dXVWbhwYavWdtrQ1dDQkCTZunXv72maPXt26uvrU1VVlaFDh77gsX7+858nSUaNGtXqeWpra1u9lhY6/JmksnVLn37qyWR7XdvOA7x0VO1KKpKmXbsO6F9eAAAAAABeGjpt6Kqurs769euzaNGiTJo0aY9ttbW1mTZtWpJk7NixKZVK+zzO2rVr87GPfSznnntuxo8f3+p5BgwY4I6uDrK9667UJ0lzc/IC3+3zNO/MgP49U5Gj22s0oMxqu3RJU5KKLl0y4Gh/1gEAAADgpaC6urrVaztt6JoyZUqWLVuWGTNm5JxzzsnIkSOTJAsWLMgVV1yR+vr6JHnBeLV58+ZcfPHF6d69e2699dYDmmfFihWprGzlbUa0SFNTc4676Lb84YmNLVr3N68bnVs/8Vg7TQW8FAycMitrn96SAdUDUvNwTbnHAQAAAAAOUKe9xWj69Onp169f1qxZkzFjxuTEE0/MiBEjMnHixAwbNixnn312kj3fz/Xntm7dmgsvvDCPP/547rrrrgwYMKAjx+cAVFSU8r5Lj2/xuvdd2vpHUwIAAAAAAB2v04augQMHZv78+Tn//PPTo0ePrFq1Kn379s3MmTMzd+7cLF++PMneQ9fOnTvzxje+MQsXLsxPfvKTjB49uqPH5wBNfcvonD1x/+PkR945LiefcEQ7TgQAAAAAALS1UnNzc3O5h+homzdvTp8+fVIqlbJp06b06tVr97ampqZcdtllmTNnTu64447dd361RkNDQ3r37r37nB5d2LE2b9mZS/9xXn7yqxd+PNk/vWtcPjl1wgu+qw3oHP706MKjj+yVmv99S7nHAQAAAAAOUKd9R9cLWbJkSZqbmzNy5Mg9IleSvP/978/3vve9fPjDH06vXr3y61//eve2Y489Nkcc4a6foujdq1tuv+U1ufPemnzlu4/k9nueyJ+ybinJu954XN536aiMP75fWecEAAAAAABa56AMXYsXL06y98cW/uQnP0mSfOYzn8lnPvOZPbb9x3/8R/76r/+63eej7VRUlHLeGYNy3hmDsmHj9hx/0W15at22VB/RMzOvO73c4wEAAAAAAAdA6PoLq1at6uBp6CiH9TkkXbs+91q6Co8pBAAAAACAwqso9wDl8EKhCwAAAAAAgGI4KO/omjdvXrlHAAAAAAAA4AAdlHd0AQAAAAAAUHxCFwAAAAAAAIUkdAEAAAAAAFBIQhcAAAAAAACFJHQBAAAAAABQSEIXAAAAAAAAhSR0AQAAAAAAUEhCFwAAAAAAAIUkdAEAAAAAAFBIQhcAAAAAAACFJHQBAAAAAABQSEIXAAAAAAAAhSR0AQAAAAAAUEhCFwAAAAAAAIUkdAEAAAAAAFBIQhcAAAAAAACFJHQBAAAAAABQSEIXAAAAAAAAhSR0AQAAAAAAUEhCFwAAAAAAAIUkdAEAAAAAAFBIQhcAAAAAAACFJHQBAAAAAABQSEIXAAAAAAAAhSR0AQAAAAAAUEhCFwAAAAAAAIUkdAEAAAAAAFBIQhcAAAAAAACFJHQBAAAAAABQSEIXAAAAAAAAhSR0AQAAAAAAUEhCFwAAAAAAAIUkdAEAAAAAAFBIQhcAAAAAAACFJHQBAAAAAABQSEIXAAAAAAAAhSR0AQAAAAAAUEhCFwAAAAAAAIUkdAEAAAAAAFBIQhcAAAAAAACFJHQBAAAAAABQSEIXAAAAAAAAhSR0AQAAAAAAUEhCFwAAAAAAAIUkdAEAAAAAAFBIB0Xoqq+vz/Tp0zN8+PD06NEjgwYNytVXX52GhoZceeWVKZVKueWWW8o9JtDOdu5syjMbtmXrtsZyjwIAAAAAQBvoWu4B2ttDDz2U8847L3V1damsrMzo0aPz5JNP5uabb87KlSuzbt26JMn48ePLOyjQLnbtasrce9bky7OX5c771u7+fNSww/J3bx6VKy4YnkOrupdxQgAAAAAAWqtT39FVX1+fCy+8MHV1dbnmmmtSW1ubRYsWpa6uLjNmzMjcuXOzYMGClEqljB07ttzjAm3syacbMvGtc3Lx1f+7R+RKkmWPbcgHbrg/Q86dnZ//9skyTQgAAAAAwIHo1KHrqquuSk1NTaZOnZobb7wxVVVVu7dNnz4948aNS2NjY4YMGZI+ffqUcVKgrdWv35azrrwji5Y984L7bdi0I+e+787cs7C2gyYDAAAAAKCtdNrQtWzZssyePTv9+/fPDTfcsNd9JkyYkCQZN27c7s/mz5+fKVOmZMCAATnkkEMycODAvPnNb86yZcs6ZG6gbVw949dZsXrjfu27Y2dTLp328+zYuaudpwIAAAAAoC112tA1a9asNDU15fLLL0/v3r33uk/Pnj2T7Bm61q9fnxNPPDE333xz7rrrrsyYMSNLlizJpEmTUlNT0yGzAwemrn5LvnfX4y1a89QzW/OD/13VPgMBAAAAANAuupZ7gPYyb968JMnkyZP3uc+fwtWfh66LLrooF1100R77nXzyyTnuuOPy/e9/P1dffXU7TAu0pf/80YrsbGxq8bqvfu+RXHbese0wEQAAAAAA7aHThq7Vq1cnSQYPHrzX7Y2Njbn33nuT7Bm69qZfv35Jkq5dW/8/14gRI1JR0WlvoCuM2sP+Iak4NLV1tRk4cGC5x6GdrKt8fXLIC/+53pv5v/2D66KT8zsAAAAAAF56qqurs3Dhwlat7bShq6GhIUmydevWvW6fPXt26uvrU1VVlaFDhz5v+65du9LU1JTVq1fn2muvTXV1dS699NJWz1NbW9vqtbShql1JRdK0a1fWrl1b7mloL4N2JIe0fFlTcxfXRWfndwAAAAAAdCqdNnRVV1dn/fr1WbRoUSZNmrTHttra2kybNi1JMnbs2JRKpeetf9WrXrX7jq/hw4dn3rx5OeKII1o9z4ABA9zR9RJQ26VLmpJUdOmSAUcfXe5xaCcbejSnoRXrumRrql0XnZrfAQAAAADw0lNdXd3qtZ02dE2ZMiXLli3LjBkzcs4552TkyJFJkgULFuSKK65IfX19kmT8+PF7Xf+Nb3wjGzZsyOOPP57Pfe5zec1rXpN77703xxxzTKvmWbFiRSorK1u1lrYzcMqsrH16SwZUD0jNwzXlHod2Mu83T+bV7/pJi9dd885XZcYHp7XDRLxU+B0AAAAAAJ1Lp73FaPr06enXr1/WrFmTMWPG5MQTT8yIESMyceLEDBs2LGeffXaSfb+f67jjjsspp5ySyy67LD/72c+yadOmfPazn+3IHwFopckTB+T4oYe2aE2plLznTce300QAAAAAALSHThu6Bg4cmPnz5+f8889Pjx49smrVqvTt2zczZ87M3Llzs3z58iT7Dl1/7rDDDsvw4cPzhz/8ob3HBtpAqVTKp696RYvWvPuNx2fYwD7tNBEAAAAAAO2h0z66MElGjRqV22+//Xmfb968OatWrUpFRUVOOOGEFz3O008/nUcffTSnnHJKe4wJtIPXvXpIbvnIpHzghvvT3PzC+77+1UPyxQ9PeuGdAAAAAAB4yenUoWtflixZkubm5owcOTK9evXaY9vb3va2DB8+POPHj89hhx2WFStW5KabbkrXrl3zwQ9+sEwTA63x/stG59iBffIvX3sov3rwqedtH/Ky3pn6ltH5+7eNSZcunfYGVwAAAACATuugDF2LFy9OsvfHFp566qn55je/mS984QvZtm1bBg0alMmTJ+cjH/lIBg8e3NGjAgfo3NMH5tzTB+Z3jz6TO+bX5NNffyibtzSm36GH5A9z3yRwAQAAAAAUmND1F6ZOnZqpU6d29EhAOxt3XL+MO65fvvSdpdm8pTE9DukicgEAAAAAFNxB+be8LxS6AAAAAAAAKIaD8o6uefPmlXsEAAAAAAAADtBBeUcXAAAAAAAAxSd0AQAAAAAAUEhCFwAAAAAAAIUkdAEAAAAAAFBIQhcAAAAAAACFJHQBAAAAAABQSEIXAAAAAAAAhSR0AQAAAAAAUEhCFwAAAAAAAIUkdAEAAAAAAFBIQhcAAAAAAACFJHQBAAAAAABQSEIXAAAAAAAAhSR0AQAAAAAAUEhCFwAAAAAAAIUkdAEAAAAAAFBIQhcAAAAAAACFJHQBAAAAAABQSEIXAAAAAAAAhSR0AQAAAAAAUEhCFwAAAAAAAIUkdAEAAAAAAFBIQhcAAAAAAACFJHQBAAAAAABQSEIXAAAAAAAAhSR0AQAAAAAAUEhCFwAAAAAAAIUkdAEAAAAAAFBIQhcAAAAAAACFJHQBAAAAAABQSEIXAAAAAAAAhdS13AOwd83NzWncur3cY+y3rj0PSalUKvcYnUbRvv/ENdCWivj9/4nrAAAAAADoSELXS1Tj1u3572PfVu4x9tvlK7+dbr16lHuMTqNo33/iGmhLRfz+/8R1AAAAAAB0JI8uBAAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKqWu5B4D2tmVrY363/Jk8uurZbN6y87nPtjVm8fJ1GTXssHTtqvd2duue3Z4HltZn9ZObd18DW7c1ZtXaTRn8st4plUplnpD21NzcnDV1DVm0rD4NWxuTJA1bG3PnvTWZMLp/+h/eo8wTAgAAAACtJXTRKT39zNZ844fLM+snK7P0sQ3Ztat5j+3rN+7I2Df+MD17dMnJY47I314yMpf+1dD07OGPRGex7LEN+cp3l+XHv3giq57c/Lzt6zbuyNDzvpu+hx6SV72iOu990/GZcurRqagQvTqD5ubm/GJBbb76vUcy77e1qV+/bY/tGzbtyLnvuzNJcsyAypx/xqC879JROXFk33KMCwAAAAC0kr/Vp1Op/eOWfPjzC/Kdnz6WHTubXnT/rdt25Z4H6nLPA3X5hxt/k6mXjc617xybHof4o1FUDyytz7R//W1+vqB2v/Zf9+z2/PBnq/PDn63OiMF98rF3j8/bLhjuLq+Cam5uzvfuejzXf3lRHnn82f1a80RtQ77y3Ufyle8+kjNeflRmfPDkTBp3VDtPCgAAAAC0BX+b34lUTxqTc3/w8T0+29mwNRsfq83K2+7Jsm/ckeZdLx5/iqi5uTn/c8fKfOCG+7N+445WHWPds9vziZkP5rb/fTz/8YkzM/HEI9p4yvZ3MF8D23fsyidnPpjP3Pr7593Bt79WrN6Yt//TPZl95+P59+temZcdWdnGU7a/g/kaeOqZrfm7T92XH/xsVauPMX/RUzn9HXPzD1eckE+8/+Xu8gQAAACAlzh/g9cJPfaD+amZtygpldLziMMy/E2vysSP/3UOHXF07p82s9zjtbnGxqa86+O/yn/+aEWbHG/pyg2ZdMWP86WPTMp7Lx3VJsfsaAfbNfDHdVvz2vfflYVL6tvkeHPvWZMTXv+D3H7La3La+GLe2XOwXQMPLK3Pee+7M3/8i0cUtkZTU3Nu/K/FufO+mtz51XMz4IhebTAhAAAAANAeKso9AG3vmcWP57Hvz89jt92TJV+Zk7nnfyQNa+sz8q2vziH9+pR7vDa1a1dTLr/2F20Wuf6kqak57/vUffnCtx9u0+N2lIPpGvjjuq0568o72ixy/cn6jTtyzrt/mvkP1LXpcTvKwXQNLHj4j5l85R1tErn+3OIV63PGX9+e2j9uadPjAgAAAABtR+g6CDRu3Z4/LlqRUkVF+gwu5t0p+/LBz/0m373z8XY7/t9/9jf57p2PtdvxO0pnvQZ27NyV86felaUrN7TL8bdsa8wFH7grjz7ePsfvSJ31Gli1dlPOfd+d2dSws12Ov3LNpvzVe3+ardsa2+X4AAAAAMCBEboOElVDnvuL7e0bNpd5krZz9/1r88X/WdqiNQtmXZQ1d1+WBbMu2u817/3kvZ3ijo7OeA38y7//LgsebtmdXC29BjZu3pm/uW5+dnWC91p1tmugqak5V14/P+ue3b7fa1rzO2DxivX52C0PtGZEAAAAAKCdCV2dUNee3XNI36oc0q9PDjv+mJzy6Xem34nD8sdFK7Lxsdpyj9cmNm7ekXf+8/wWr6vu3ysDj6pMdf/9f+fO+o078t5P3pvm5uYWn69cDoZr4MFl9fn0Nx5q8brWXAP3/+7pfP7bS1p8rnI6GK6Bmd97JPN+27KfpTXff5L827cezn0PPdWiNQAAAABA++ta7gHaW319fT772c/mBz/4QWpqanLEEUfk9a9/fT796U/nqquuyq233povfvGLmTp1arlHbTMnTb8sJ02/bI/PVs39dX5z7dfLNFHb++L/LM0TtQ0ddr45v3gi8x+oy5mvGNBh5zwQB8M18OEvLExjY8fFx+u/vCjvesNx6dO7e4ed80B09mtg67bGfLQD77Jqbk6m37Qgv/qvCzrsnAAAAADAi+vUoeuhhx7Keeedl7q6ulRWVmb06NF58sknc/PNN2flypVZt25dkmT8+PHlHbSNPfqtu7Lqx/enolvXHH78MTnh/ZekckC/7Nq+Y/c+r/rKB5OKUn75nn/b/Vn3w3rnkl/clIWf+GYe+0HL75bqKI2NTZl52yMdft6vfPeRwoSuzn4NrFj9bO66b22HnrNha2O+ffsf8neXje7Q87ZWZ78GZt/5WIseWdgW7n3wqfx++bqMHdm3Q88LAAAAAOxbp310YX19fS688MLU1dXlmmuuSW1tbRYtWpS6urrMmDEjc+fOzYIFC1IqlTJ27Nhyj9umNj5Wl9r5i7N23oN5+Ms/ys/e8Zn0H39sJs14z+597r/2azny5OMy9JJX7v7s1E+/M0//9pGX9F9uJ8nc+Wuypq7j7ub6k+//76rU1RfjXV2d/Rr46vc6PnQmyZdmLyvMIyw7+zXw5dnLDqrzAgAAAAB712lD11VXXZWamppMnTo1N954Y6qqqnZvmz59esaNG5fGxsYMGTIkffr0KeOk7e+PCx/NytvuydBLXpkjXnFckmTHhs2575qv5JR/eWd6HnV4Bp9/aqpPG5P7PzSzzNO+uNt/+URZzruzsSl339+xdxG1lc53Dawpy3mXrtyQ1U9uLsu5D1RnugaefmZrFjxcX5Zzz72nPNceAAAAALB3nTJ0LVu2LLNnz07//v1zww037HWfCRMmJEnGjRu3z+Ocd955KZVK+ed//uf2GLND/e6m29LUuCsnTXvz7s/W/vyhrPrxfTnzlqty6mfelfuu+Uq2r3/p/yX+A0ufOSjPfaA6yzWwcfOOLF/9bNnO/8DS8gSWttBZroFyfgc1TzXk6We2lu38AAAAAMCeOmXomjVrVpqamnL55Zend+/ee92nZ8+eSfYdur773e/moYceaq8RO9ymVXV5/Ef35mVnjs2Rp4za/fnCj38zVUOrs3beg6n52aIyTrh/tu/YlYf/sL5s5y9y5Ogs18BDj5Q3NhY5dnaWa2DRsnJfA8X9PQAAAAAAnU2nDF3z5s1LkkyePHmf+9TU1CTZe+jauHFj/v7v/z433nhj+wxYJr//wvfTtGvPuzkat27P5tVPZ/2y8jwOsKXq6rdkZ2NT2c7/RN1L+06XF9MZroEnyvB+tj3P7xoot3J/B+W+BgEAAACA/1Nqbm5uLvcQbW3QoEGpqanJgw8+mPHjxz9ve2NjYwYMGJD6+vqsXLkyw4YN22P7Bz7wgSxevDi/+MUvUiqVcv3117fq8YUNDQ277ygbMGBAKir2vyt2a67I9U0TW3zO1jj3+x/PmrsfyJKvzmn1MT5e8dvsLLV/gNpZ0S9PH3bVPrcvmHVRqvv32uf26v4907VLRRp3NaWuft+PH6ur35KT3/L8/z0qmjZnwIbPtWzoVujI7z8p1jXQ0P3l2dD74r1ue7HvPznwa6DHjiXpt/m7LRu6hTr6+0/a5hpIOuY6WF95SbYcctJet7XV74Bk39fAoQ0/Se/tv27Z0AAAAADAPlVXV2fhwoWtWtu1jWd5SWhoeO7ftt+6de9/iTl79uzU19enqqoqQ4cO3WPbwoUL87WvfS0PPPBAm85UW1vbov27l7okR7XpCO3qydons6N5V/ufqNv25LB9b67u3ysDj6p80cN07VKxX/v9pabGHVm7dm2L17VU0b7/pAOvgcOOSfb+RNL9/v6T1l8D27ZsbvdroIjf/590yHVw9KbkkL1vau/fAUny7IZn8uy69v89AAAAAAC8uE4Zuqqrq7N+/fosWrQokyZN2mNbbW1tpk2bliQZO3ZsSqXS7m27du3Ke97znkydOjVjxoxp05lac0dXyveEvhZ72YCXdcjdPE3pnhdKhnX1W15wfUvu5tmbbhXbcuTRR+/PqAekaN9/0nHXwLZu3bOvNzS92PefHPg1UNmjOYe18zVQxO//TzriOni2Z7Kvhxe21e+AFzpW3z7d0rNn+/8eAAAAAICDRXV1davXdsrQNWXKlCxbtiwzZszIOeeck5EjRyZJFixYkCuuuCL19fVJ8rzHGt5yyy156qmnWvWYwhezYsWKVFbu/90DO7dsy38f+7Y2n2NvfvqG6w/4GMtXLE+3Xj3aYJoXd9yFt2X56mf3um1vjxn7c2vuviwDj6pMXf3WDDrnOy0+9zsuPStf++ePtXhdS3Xk958U6xp46pmtqZ78P3vd9mLff3Lg18CXb5yet1/0tRava4mO/v6TtrkGko65Dm676/G86R/n7XVbe/8OSJKF87+foQOrWrUWAAAAAGhb+3+LUYFMnz49/fr1y5o1azJmzJiceOKJGTFiRCZOnJhhw4bl7LPPTpKMGzdu95r6+vp87GMfy3XXXZfGxsZs2LAhGzZsSJJs27YtGzZsSFNTQW+x6GQmjO5XxnP3L9u5ec5R/Xrm6CNf+D1c7ck1UH7l/A4O79M9Q47ex7MzAQAAAIAO1ylD18CBAzN//vycf/756dGjR1atWpW+fftm5syZmTt3bpYvX55kz9BVU1OTTZs25T3veU8OP/zw3f9JkhkzZuTwww/PE088UZafhz1NPnlA2c59VhnPzf+ZPLE830N1/545fuihZTk3/2fI0b0z5GXliU2TT37ZHo+8BQAAAADKq1M+ujBJRo0aldtvv/15n2/evDmrVq1KRUVFTjjhhN2fDx8+PD//+c+ft//kyZPzjne8I3/91399QM+IpO285bXH5pp//W02Nezs0POedfKAHD/0sA49J3v33jeNyrdvX9nh533XG45Lly6d8t8PKJRSqZT3vOn4XPuFhR1+7vdeenyHnxMAAAAA2LdOG7r2ZcmSJWlubs7IkSPTq9f/Pf6sd+/eOeuss/a6ZsiQIfvcRsfr3atb3nHRiNwya2mHnvfv3jyqQ8/Hvp02/siMO65vfvfoug47Z5cupbz7DSLHS8WVrxuZ67+8KDt2dtwjZUcM7pNXn/KyDjsfAAAAAPDiDrpbExYvXpxkz8cWUjzXvP2EVPbsuE47dmTfXDJ5cIedjxdWKpXyz+87qUPPeeXrRmZgdWWHnpN9O6Jvz0x9y+gOPed17zkpFRUeWwgAAAAALyUH3R1dLQ1dzc3N7TlOh6oaWp0zvvCBHNK3Kjs3bcmvrr4lG5bXlHusVhlydFU++8GT8/5P39/u5+ratZT//OQZ6dat+F24M10Dl5w9JJedOyzf+elj7X6uYwZU5nP/MLHdz9NWhr95ck7//Psz729m5ImfLtivNYPPPzUDzjgxTTt35Zi/ekV6Dzoyc6b8Y9YtWbV7nzf+9svZtX1ndm3bkST5/Rd/mFVz7muPH2G/fPL9E/LjXz6RFas3tvu5LnzVMbn8/GPb/TwAAAAAQMsU/2/uW+hgvqPrtM++J8u/fXd+ePpVWXzL/8vpX5ha7pEOyHsvHZUpp7bsMWJ19VtS81RD6uq37Peaf3rn+Jw0qn9Lx3tJ6mzXwBevnZTq/j1btKal10CplHz9n89In97dWzNih+s98IiMvHxKnl74aIvWHfPaU/LET3+b1XPvzx0XfzSb1zy91/1++d6bMuecaZlzzrSyRq4k6dWza/7jE2emS5f9v8uqNb8D+h56SGZe98qUSu7mAgAAAICXmoPujq558+aVe4Sy6NGvT/qNOzZ3XfbJJMnqub/OqZ++MlVDqrNpVV2Zp2udiopSvnvj2Tnrb+/I75fv37uaTn7LnBad44oLhue693bsI/LaS2e8Bvof3iM/+fJf5awr78izm3bs15qWXgNf+egrc86ko1szXscrlXLav74vv/noN3Ly9e/Y/XH3Pr1y8c9vSpce3bPlyfpUHNItVccclZW3/TL3/eNXU+raJUedfFx+dfUtaW7cVcYfoOVeedJRufXjZ+QdH71nv/Zv6fdf2bNr7vjSazLgiF4vvjMAAAAA0OEOuju6DlaVR/fP1qfWp3lX0+7PNq+tT+XRxb5T6fA+h+RnXzsvE0a3/c/xN5eMyK2fOKPTvJOns14D44/vl3lfOy/9D+/RpsctlZKvfuyVec+bjm/T47anMe+5ME8veCTP/H7Pxznu2Lglj/1wfpZ+fW7mnDMtv73uP/LHRctz3z9+NUky4JUn5OkFj+5X5Dr95g/k4nn/mtP+9X05pF+fdvk5WurtF43If32qZXd27Y/Dqrrn7n8/N6eMPbJNjwsAAAAAtJ2D7o4uOp/+h/fIL299bT78hYW5ZdbSAz5eZc+u+ewHT857Lx3VaSJXZ/fy0f2zcNZFeec//yr/++snD/h4g1/WO7d+/IycfUrLHo3Znl77439Jn2ED9rptzjnT0r2qVwaff0p+8rrr9rpP3xOGZtnX70iS9Bt7bNY9/Pjubcece3JW/+S3LzrDT153XRrW1qfUtUte/qG35IwvTM3/vu3Trfhp2t7bLxqRYQOr8jfXzc8fnjjwd3ad8fKj8h+fPDPHDnppxDwAAAAAYO+EroNEw9r69Dzq8JS6VOy+o6f30f3TsLa+zJO1jcpe3fLFayflDVOG5L2fvDePrnq2Vcd5zWlH56sffWWGDqxq4wnLr7NfA4NfVpW7Zp6br33/0Vz7hYVZ9+z2Fh+ja9dS3vX64zLjgyenqvKl9U6uOy78pxfcPujtE9J70JF5w31fTJL0POKwTPrce9PzyMPz6DfvSt8xQ3bHrX5jh2XNnQt2r33ZWeOz8JPfftEZ/nStNDfuytKv3Z7X3/vF1v447eL0l1fnd997XT56y8J86TvLsmNn04sv+guHVnXPJ/7u5Zn6ltFCNwAAAAAUgNB1kNj2zMasW/x4jn3DmfnDd3+RweefmobadYV9N9O+nHXygCz9f2/I//56bb48e1l+/Ms1aWpqfsE1vXt1yxUXHJv3XToqJ47s20GTdryD4RoolUp59xuPzxUXDM9373w8X5q9NAsefvGQd/SRvfKeNx2fd77+uMK+i+nRb96VR7951+5/Pvf7H8/Sr92eJ366IL2q+ybNzdlS99y77PqOGpzff+H7SZL+J43IsyvWpnHLthc8fteeh6SiW5fs2LglSTL0dafnmT+7K+ylolfPrvm3aafmw387Lrf+v+X56vceyeonN7/oupOO75e/e/OovOW8Yans1a0DJgUAAAAA2oLQdRC5b/rMnP759+fEq16fnZu35ld//6Vyj9QuKipKec1pA/Oa0wZmU8OOPPTIuixcWp9HHt+QLdsa06WiIlWV3TJuZN9MGN0vY4Yfnu7dupR77A5xsFwDPXt0zTsuHpF3XDwiTz2zNQ8src8DS+uz+snN2bZjV7p3q0j/w3rk5aP6ZcLo/jl2UJ9OffdO3xOG7vGowh0bG3L8O/4q9/3jVzP4vIl54qf/99jCSZ99dwa+ekJ6HnlYzpn10ezcvDU/OO0D6XHEoZn89WkpdalIqZRsWv10fvWBl9YdXX/uyH498+Erx+VDfzs2j9VsygNL67No2TN5et3W7NjZlB7du2RQdWUmjO6fCaP7FzZwAgAAAMDBrtTc3PzCt7vQag0NDendu3eSZPPmzamsrNzvtTu3bMt/H/u29hqtzV2+8tvp1qtHucfoNIr2/SeugbbUkd//xb+4KXe+4fpse+bA32uVuA4AAAAAgI7lji6Ag9iPzvpguUcAAAAAAGi1inIPAAAAAAAAAK0hdAEAAAAAAFBIQhcAAAAAAACFJHQBAAAAAABQSKXm5ubmcg/RWTU0NKR3795Jks2bN6eysnK/1zY3N6dx6/b2Gq3Nde15SEqlUrnH6DSK9v0nroG2VMTv/09cBwAAAABAR+pa7gHYu1KplG69epR7DMrE939w8/0DAAAAAOwfjy4EAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACumgCF319fWZPn16hg8fnh49emTQoEG5+uqr09DQkCuvvDKlUim33HJLuccEAAAAAACgBbqWe4D29tBDD+W8885LXV1dKisrM3r06Dz55JO5+eabs3Llyqxbty5JMn78+PIOCgAAAAAAQIt06ju66uvrc+GFF6auri7XXHNNamtrs2jRotTV1WXGjBmZO3duFixYkFKplLFjx5Z7XAAAAAAAAFqgU4euq666KjU1NZk6dWpuvPHGVFVV7d42ffr0jBs3Lo2NjRkyZEj69OlTxkkBAAAAAABoqU4bupYtW5bZs2enf//+ueGGG/a6z4QJE5Ik48aN2/3ZL37xi5RKpef9x6MNAQAAAAAAXlo67Tu6Zs2alaamplx++eXp3bv3Xvfp2bNnkj1D15986Utfystf/vLd/1xZWdk+gwIAAAAAANAqnTZ0zZs3L0kyefLkfe5TU1OTZO+ha/To0Tn11FPbZzgAAAAAAAAOWKcNXatXr06SDB48eK/bGxsbc++99ybZe+hqayNGjEhFRad9UiQAAAAAAECrVFdXZ+HCha1a22lDV0NDQ5Jk69ate90+e/bs1NfXp6qqKkOHDn3e9je/+c2pr69Pv379ctFFF+Uzn/lM+vfv3+p5amtrW70WAAAAAACA5+u0oau6ujrr16/PokWLMmnSpD221dbWZtq0aUmSsWPHplQq7d526KGHZtq0aTnzzDPTu3fv3H///bnhhhvy61//OgsXLkyPHj1aNc+AAQPc0QUAAAAAAPAXqqurW72204auKVOmZNmyZZkxY0bOOeecjBw5MkmyYMGCXHHFFamvr0+SjB8/fo91J510Uk466aTd/3zWWWflhBNOyEUXXZRZs2blb/7mb1o1z4oVK1JZWdm6HwYAAAAAAIDn6bS3GE2fPj39+vXLmjVrMmbMmJx44okZMWJEJk6cmGHDhuXss89Osn/v57rgggtSWVnZ6udDAgAAAAAA0PY6begaOHBg5s+fn/PPPz89evTIqlWr0rdv38ycOTNz587N8uXLk+xf6PqTP3/EIQAAAAAAAOXVaR9dmCSjRo3K7bff/rzPN2/enFWrVqWioiInnHDCix5nzpw5aWhoyMSJE9tjTAAAAAAAAFqhU4eufVmyZEmam5szcuTI9OrVa49tb3vb2zJs2LC8/OUvT+/evXP//ffns5/9bMaPH5/LLrusTBMDAAAAAADwlw7K0LV48eIke39s4ZgxY/I///M/+fznP5+tW7dm4MCBede73pXrr78+3bt37+hRAQAAAAAA2Aeh6y9ce+21ufbaazt6JAAAAAAAAFqootwDlMMLhS4AAAAAAACKodTc3Nxc7iE6q4aGhvTu3TtJsnnz5lRWVpZ5IgAAAAAAgM7joLyjCwAAAAAAgOITugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBC6vShq76+PtOnT8/w4cPTo0ePDBo0KFdffXUaGhpy5ZVXplQq5ZZbbin3mAAAAAAAALRQ13IP0J4eeuihnHfeeamrq0tlZWVGjx6dJ598MjfffHNWrlyZdevWJUnGjx9f3kEBAAAAAABosU57R1d9fX0uvPDC1NXV5ZprrkltbW0WLVqUurq6zJgxI3Pnzs2CBQtSKpUyduzYco8LAAAAAABAC3Xa0HXVVVelpqYmU6dOzY033piqqqrd26ZPn55x48alsbExQ4YMSZ8+fco4KQAAAAAAAK3RKUPXsmXLMnv27PTv3z833HDDXveZMGFCkmTcuHHP2/bDH/4wp512WiorK3PooYfmla98ZZYsWdKuMwMAAAAAANAynTJ0zZo1K01NTbn88svTu3fvve7Ts2fPJM8PXTfffHMuvfTSnH766ZkzZ05mzZqVKVOmZOvWre0+NwAAAAAAAPuva7kHaA/z5s1LkkyePHmf+9TU1CTZM3StXLky06ZNy0033ZSpU6fu/vy1r31tO00KAAAAAABAa3XK0LV69eokyeDBg/e6vbGxMffee2+SPUPXrbfemm7duuVd73pXm880YsSIVFR0yhvoAAAAAAAAWq26ujoLFy5s1dpOGboaGhqSZJ+PG5w9e3bq6+tTVVWVoUOH7v78vvvuy3HHHZdvf/vb+dSnPpU1a9ZkxIgRue666/KWt7zlgGaqra09oPUAAAAAAADsqVOGrurq6qxfvz6LFi3KpEmT9thWW1ubadOmJUnGjh2bUqm0x7a1a9fm2muvzYwZMzJo0KB84xvfyFvf+tYcccQRmTJlSovm6NWrVzZv3pzTTz89Tz/99B7nAgAAAAAA4Lmu01qdMnRNmTIly5Yty4wZM3LOOedk5MiRSZIFCxbkiiuuSH19fZJk/Pjxe6xramrK5s2b861vfSuXXHJJkuTVr351li5dmk9+8pMtDl2lUimVlZV58MEHD/hnAgAAAAAAYE+d8qVR06dPT79+/bJmzZqMGTMmJ554YkaMGJGJEydm2LBhOfvss5Ps+X6uJOnbt2+S7BG0SqVSpkyZkocffrjjfgAAAAAAAABeVKcMXQMHDsz8+fNz/vnnp0ePHlm1alX69u2bmTNnZu7cuVm+fHmS54euMWPG7POY27Zta9eZAQAAAAAAaJlSc3Nzc7mH6EibN29Onz59UiqVsmnTpvTq1Wv3tjlz5uTiiy/O97///bz+9a9P8tzjDMePH5++ffvmF7/4RZmmBgAAAAAA4C91ynd0vZAlS5akubk5I0eO3CNyJcmFF16YM844I+9+97vzzDPP5JhjjsnXv/71LFmyJHfffXeZJgYAAAAAAGBvDrrQtXjx4iTPf2xh8tz7uObMmZMPfehD+chHPpKNGzdm3LhxueOOO3a/1wsAAAAAAICXBqHrLxx22GGZOXNmZs6c2ZFjAQAAAAAA0EIV5R6go71Y6AIAAAAAAKAYSs3Nzc3lHgIAAAAAAABa6qC7owsAAAAAAIDOQegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkP4/60ym1ZgaJKQAAAAASUVORK5CYII=\n"
+          },
+          "metadata": {},
+          "execution_count": 10
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "# Test: Dual-Sliced Module Composition with CZ Connections\n",
+        "\n",
+        "This test demonstrates the full slicing-based integration of two distinct modules — a QPIXL-encoded image circuit and a 2-qubit quantum algorithm.\n",
+        "\n",
+        "The QPIXLModule encodes 16 values using a compressed cFRQI encoding.\n",
+        "\n",
+        "The Algorithm Module consists of 4 gates: H, CX, RY, CZ — and is sliced every 2 gates.\n",
+        "\n",
+        "The QuantumComposer is used to interleave these alternating slices, mimicking layered hybrid circuits.\n",
+        "\n",
+        "A CZ entanglement is inserted at every boundary, connecting:\n",
+        "\n",
+        "QPIXL data qubit 1\n",
+        "with Algorithm qubit 0\n",
+        "\n",
+        "Ihope this setup fulfills the requirements as it :\n",
+        "- Slices both QPIXL and the algorithm circuit.\n",
+        "-Interleaves them alternately.\n",
+        "Adds connection gates between qubits at each boundary.\n",
+        "\n"
+      ],
+      "metadata": {
+        "id": "xB3FLu4fHtZN"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# === TEST: Dual QPIXL Slicing with CZ Entanglement ===\n",
+        "\n",
+        "from QPIXL.qiskit.qpixl_module import QPIXLModule\n",
+        "from QPIXL.qiskit.quantum_composer import QiskitCircuitModule, QuantumComposer\n",
+        "import numpy as np\n",
+        "from IPython.display import display\n",
+        "\n",
+        "# Step 1: Generate simple QPIXL data (4×4 grayscale)\n",
+        "image_data = np.linspace(0, np.pi / 2, 16)\n",
+        "\n",
+        "# Step 2: Create two QPIXL modules\n",
+        "qpixl_mod_1 = QPIXLModule(image_data, name=\"QPIXLDATA_1\")\n",
+        "qpixl_mod_2 = QPIXLModule(image_data, name=\"QPIXLDATA_2\")\n",
+        "algo_mod = QiskitCircuitModule(qpixl_mod_2.get_circuit(), name=\"QPIXLDATA_2_ALGO\")\n",
+        "\n",
+        "# Step 3: Compose with slicing + CZ entanglement between slices\n",
+        "composer = QuantumComposer([qpixl_mod_1, algo_mod])\n",
+        "combined = composer.combine(\n",
+        "    rule=\"slice\",\n",
+        "    slice_size=2,\n",
+        "    connection_rule=\"cz\",\n",
+        "    connection_map=[(1, 0)]  # QPIXL_1 qubit 1 ↔ QPIXL_2 qubit 0\n",
+        ")\n",
+        "\n",
+        "# Step 4: Display result and confirm clean register usage\n",
+        "print(f\"[RESULT] Qubits: {combined.num_qubits}\")\n",
+        "print(f\"[RESULT] Gate counts: {combined.count_ops()}\")\n",
+        "print(f\"[RESULT] Registers: {[reg.name for reg in combined.qregs]}\")\n",
+        "display(combined.draw(\"mpl\"))\n"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 1000
+        },
+        "id": "aA8IyyERAxai",
+        "outputId": "af006780-8ad2-403f-db62-f619a55346cf"
+      },
+      "execution_count": 8,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "▶ Combining using rule: slice\n",
+            "✓ Done in 0.01s\n",
+            "[RESULT] Qubits: 12\n",
+            "[RESULT] Gate counts: OrderedDict([('cx', 32), ('ry', 30), ('cz', 18), ('h', 8)])\n",
+            "[RESULT] Registers: ['q']\n"
+          ]
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 2228.58x3210.67 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "# Dual QPIXL Slice Composition — Removing Ghost Qubits\n",
+        "\n",
+        "This test ensures that slicing two QPIXLModule circuits together using the \"slice\" rule with entanglement produces a clean circuit:\n",
+        "\n",
+        "No ghost qubits\n",
+        "\n",
+        "No extra unused registers\n",
+        "\n",
+        "No visual imbalance\n",
+        "\n",
+        "Proper entanglement between corresponding slices"
+      ],
+      "metadata": {
+        "id": "OXDCHQ_b4EJC"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# === TEST: Dual QPIXL Slice Composition — No Ghost Qubits ===\n",
+        "\n",
+        "from QPIXL.qiskit.qpixl_module import QPIXLModule\n",
+        "from QPIXL.qiskit.quantum_composer import QiskitCircuitModule, QuantumComposer\n",
+        "from IPython.display import display\n",
+        "import numpy as np\n",
+        "\n",
+        "# Step 1: Prepare 16-angle QPIXL data\n",
+        "image_data = np.linspace(0, np.pi / 2, 16)\n",
+        "\n",
+        "# Step 2: Create two QPIXL modules (data + algo)\n",
+        "qpixl_mod_data = QPIXLModule(image_data, name=\"QPIXLDATA_1\")\n",
+        "qpixl_mod_algo = QPIXLModule(image_data, name=\"QPIXLDATA_2\")\n",
+        "algo_mod = QiskitCircuitModule(qpixl_mod_algo.get_circuit(), name=\"QPIXLDATA_2_ALGO\")\n",
+        "\n",
+        "# Step 3: Compose with slice rule + CZ, ensure even slicing\n",
+        "composer = QuantumComposer([qpixl_mod_data, algo_mod])\n",
+        "combined = composer.combine(\n",
+        "    rule=\"slice\",\n",
+        "    slice_size=2,\n",
+        "    connection_rule=\"cz\",\n",
+        "    connection_map=[(0, 0), (1, 1)]  # connect first 2 qubits from each\n",
+        ")\n",
+        "\n",
+        "# Step 4: Validate output\n",
+        "print(f\"[TEST] Qubits: {combined.num_qubits}\")\n",
+        "print(f\"[TEST] Gate Count: {combined.count_ops()}\")\n",
+        "print(f\"[TEST] Registers: {[reg.name for reg in combined.qregs]}\")\n",
+        "\n",
+        "# Assert: Single register used, no ghost registers like q_5, q_11 etc.\n",
+        "assert len(combined.qregs) == 1, \"❌ Ghost register detected!\"\n",
+        "assert all(isinstance(q, qiskit.circuit.Qubit) for q in combined.qubits), \"❌ Invalid qubits found\"\n",
+        "\n",
+        "# Display final circuit\n",
+        "display(combined.draw(\"mpl\"))\n"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 1000
+        },
+        "id": "7tHu6osLucBd",
+        "outputId": "e9c4657e-930c-434f-95cb-57573575133e"
+      },
+      "execution_count": 9,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "▶ Combining using rule: slice\n",
+            "✓ Done in 0.01s\n",
+            "[TEST] Qubits: 12\n",
+            "[TEST] Gate Count: OrderedDict([('cz', 36), ('cx', 32), ('ry', 30), ('h', 8)])\n",
+            "[TEST] Registers: ['q']\n"
+          ]
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 2228.58x3210.67 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
+      ]
+    }
+  ]
+}
\ No newline at end of file
diff --git a/figures/Ignacio_short.mp3 b/figures/Ignacio_short.mp3
new file mode 100644
index 0000000..29bf628
Binary files /dev/null and b/figures/Ignacio_short.mp3 differ